基于 Unity 现有文件管理系统实现的本地化框架，代码已上传 Git 项目 GRUnityTools，可直接下载源码或通过 UPM 使用
现已实现 Resources、AssetBundle 和 Addressable 资源管理方式，另外可根据需求自由扩展
提供逐行解析，csv 解析和 json 解析，三种本地化文本解析方式，也可根据需求自由扩展
本文原地址：Unity实践—本地化框架实现
实现目标
- 支持语言的可扩展性
- 加载方式的可扩展性
- 文本解析的可扩展性
- 动态加载本地化资源
- 快速的资源更新方式
实现方式
-
SystemLanguage
为确保不同的项目和开发对象的本地化内容的规范统一，直接使用
SystemLanguage枚举型作为各种语言的唯一ID -
ILocalizationLoader
通过自定义接口的形式，将加载方法开放给开发者实现，使不同项目实现最大自由地定制
-
ILocalizationParser
通过自定义接口的形式，将文本解析方法开放给开发者实现，使不同项目实现最大自由地定制
-
Resources，AssetBundle 和 Addressable
使用 Unity 提供的三种动态加载资源方法实现
ILocalizationLoader接口，提供三种预设本地化资源动态加载器 -
LocalizationComponent
为进一步简化开发过程，提供该脚本实现切换语言时本地化控件的自动批量更新，支持 Text、TextMesh、Image 和 SpriteRender
项目结构
- LocalizationManager
- ILocalizationLoader
- LocalizationResourcesLoader
- LocalizationAssetBundleLoader
- LocalizationAddressableLoader
- ...LocalizationCustomLoader
- IlocalizationParser
- LocalizationDefaultParser
- ...LocalizationCustomParser
- ILocalizationLoader
- LocalizationComponent
- LocalizationComponentItem
实现过程
为节省篇幅，部分示例代码有删改，具体代码可见项目 GRUnityTools，并包含使用示例
LocalizationManager
最初设计时，仅为实现本地化文本加载与切换的简单功能，因此所有的加载和解析功能均由 LocalizationManager 单例完成
首先思考的问题是如何使不同项目对拥有同一套语言表，由我个人补充难免会有缺漏，无法覆盖所有需求，最终决定使用系统提供的枚举型SystemLanguage，基本涵盖了所有应用度比较广的语言，同时确认以枚举名称作为本地化文本文件名称用于加载，可加入序号作为语言顺序
构建文件数据结构，用于匹配语言加载文件
public struct LocalizationFile
{
public int Index { get; }
public SystemLanguage Type { get; }
public string Name { get; }
public string FileName { get; }
public LocalizationFile(string fileName = null)
{
if (!string.IsNullOrEmpty(fileName))
{
Name = fileName;
string[] lan = fileName.Split('.');
Name = lan[1];
bool success;
int index;
SystemLanguage lanuageType;
success = Int32.TryParse(lan[0], out index);
Index = success ? index : -1;
success = Enum.TryParse(Name, true, out lanuageType);
Type = success ? lanuageType : SystemLanguage.Unknown;
}
}
}
LocalizatioManager 单例初始化时，使用 Resources 获取规定目录下所有文本文件以获取支持的语言列表
TextAsset[] res = Resources.LoadAll("Localization");
List fileList = new List();
for (int i = 0; i < res.Length; i++)
{
TextAsset asset = res[i];
LocalizationFile data = new LocalizationFile(asset.name);
fileList.Add(data);
Resources.UnloadAsset(asset);
}
使用 Resources 提供的接口加载规定子目录下的其他本地化资源
Resources.LoadAsync("Localization/Assets/" + assetPath);
最初使用的自定义的文本规则的 txt 文件，每行一个键值对，等号分隔键和值，使用Regex.Unescape方法将文本中的转义符转义，LocalizationManager 持有解析后的字典数据，供外部控件使用
public Dictionary ParseTxt(string txt)
{
if (string.IsNullOrEmpty(txt))
{
return null;
}
string[] lines = txt.Split('\n');
Dictionary localDict = new Dictionary();
foreach (string line in lines)
{
if (!string.IsNullOrEmpty(line))
{
string[] keyAndValue = line.Split(new[] {'='}, 2);
if (keyAndValue.Length == 2)
{
string value = Regex.Unescape(keyAndValue[1]);
localDict.Add(keyAndValue[0], value);
}
}
}
return localDict;
}
ILocalizationLoader
由于 Resources自身的弊端和限制，需要使用更加灵活的资源动态加载方法，因此又加入了对 AssetBundle 和 Addressable 的支持，有关这两种方式的信息可看文章Unity学习—资源管理概览
在设计这两种加载方式时意识到，提供现成的加载方法会有大量的约束限制，无法做到通用，因此决定抽离 LocalizationManager 所需的两个固定的方法作为接口，以实现外部自定义
public interface ILocalizationLoader
{
//用于加载支持语言列表
void LoadAllFileListAsync(Action complete);
//用于加载本地化资源
void LoadAssetAsync(string localizationFileName, string assetPath, bool defaultAsset, Action complete) where T : Object;
}
首先将之前的 Resources 加载方式改写为实现该接口的LocalizationResourcesLoader，并扩展了LocalizationAssetBundleLoader和LocalizationAddressableLoader两个加载器
LocalizationAssetBundleLoader
将不同语言的 AssetBundle 打包到 Assets/StreamingAssets/Localization 目录下，并使用类似于Resources的资源命名方式命名，加载 Localization 的 manifest 获取支持语言的 Bundle 清单
string bundlePath = Path.Combine(Application.streamingAssetsPath, FilesPath, FilesPath);
//加载自动生成的 Localization Bundle
var loadrequest = AssetBundle.LoadFromFileAsync("Assets/StreamingAssets/Localization/Localization");
loadrequest.completed += operation =>
{
//获取 Localization Bundle 的 Manifest 文件信息
AssetBundleManifest manifest =
loadrequest.assetBundle.LoadAsset("AssetBundleManifest");
var files = manifest.GetAllAssetBundles();
List fileList = new List();
for (int i = 0; i < files.Length; i++)
{
if (!files[i].Equals(CommonAssetsPath.ToLower()))
{
LocalizationFile data = new LocalizationFile(files[i]);
fileList.Add(data);
}
}
loadrequest.assetBundle.Unload(manifest);
}
加载资源
AssetBundleCreateRequest loadrequest = AssetBundle.LoadFromFileAsync(Path.Combine(Application.streamingAssetsPath, FilesPath,
localizationFileName));
loadrequest.completed += operation =>
{
var request = loadrequest.assetBundle.LoadAssetAsync(assetPath);
request.completed += asyncOperation =>
{
//get request.asset
};
};
同时为更便捷打包本地化 AssetBundle 包，增加快捷方法
string[] paths = Directory.GetDirectories(localizationFilePath);
AssetBundleBuild[] buildMap = new AssetBundleBuild[paths.Length];
for (int i = 0; i < paths.Length; i++)
{
string bundleName = Path.GetFileName(paths[i]);
buildMap[i].assetBundleName = bundleName;
var files = Directory.GetFiles(paths[i], "*", SearchOption.AllDirectories);
List assets = new List();
foreach (var file in files)
{
if (!file.EndsWith(".meta"))
{
var filePath = file.Replace(Application.dataPath, "Assets");
assets.Add(filePath);
}
}
buildMap[i].assetNames = assets.ToArray();
}
var parent = Path.GetFileName(localizationFilePath);
BuildPipeline.BuildAssetBundles("Assets/StreamingAssets/" + parent, buildMap,
BuildAssetBundleOptions.ChunkBasedCompression, target);
LocalizationAddressableLoader
由于Addressable的特性，无法通过固定的资源路径获取文件获取支持语言，因此使用 Addressable 的 Label功能，给每种语言的本地化文本文件打上Localization标签，实现统一获取，且需将文本文件 address 与对应SystemLanguage相同
Addressables.LoadResourceLocationsAsync(KLocalizeFolder).Completed += handle =>
{
List fileList = new List();
if (handle.Status == AsyncOperationStatus.Succeeded)
{
foreach (var file in handle.Result)
{
LocalizationFile data = new LocalizationFile(file.PrimaryKey);
fileList.Add(data);
}
}
};
使用 Addressables 加载资源
Addressables.LoadAssetAsync(assetAddress).Completed += handle =>
{
//get request.asset
};
ILocalizationParser
由于编写的文本解析格式过于个性化，并不通用，因此扩展支持了 csv 和 json 的解析，同时仿照ILocalizationLoader方式，抽出解析方法到ILocalizationParser，以增加扩展性
public interface ILocalizationParser
{
Dictionary Parse(string text);
}
LocalizationDefaultParser
项目将上述的 txt、csv 和 json 解析方法汇总到 LocalizationDefaultParser中，通过LocalizationFileType决定解析方式
LocalizationComponent
LocalizationComponent 是一套用于挂载在场景对象的脚本，用于自动更新本地化文本和资源，使用LocalizationComponentItem在 Inspector 中将 Component匹配本地化键
[Serializable]
public class LocalizationComponentItem
{
[SerializeField] internal Component component;
public string localizationKey;
public string defaultValue;
public bool setNativeSize;
internal Vector2 originalImageSize = Vector2.zero;
}
public class LocalizationComponent : MonoBehaviour
{
public LocalizationComponentItem[] items;
private void LocalizationChanged(LocalizationFile localizationFile)
{
foreach (var item in items)
{
if (!string.IsNullOrEmpty(item.localizationKey) && item.component != null)
{
string value = LocalizationManager.Singleton.GetLocalizedText(item.localizationKey);
if (value == null)
{
value = item.defaultValue;
}
if (item.component is Text text)
{
text.text = value;
}
else if (item.component is TextMesh mesh)
{
mesh.text = value;
}
else
{
Image image = null;
SpriteRenderer spriteRenderer = null;
if (item.component is Image imageComponent)
{
image = imageComponent;
if (item.originalImageSize == Vector2.zero)
{
item.originalImageSize = image.rectTransform.sizeDelta;
}
}
if (item.component is SpriteRenderer rendererComponent)
{
spriteRenderer = rendererComponent;
}
if (image != null || spriteRenderer != null)
{
//替换图片
LocalizationManager.Singleton.LoadLocalizationAssetAsync(value, item.defaultValue,
delegate(Sprite sprite)
{
if (sprite != null)
{
if (image != null)
{
Image img = (Image) item.component;
img.sprite = sprite;
if (item.setNativeSize)
{
img.SetNativeSize();
}
else
{
image.rectTransform.sizeDelta = item.originalImageSize;
}
}
if (spriteRenderer != null)
{
spriteRenderer.sprite = sprite;
}
}
});
}
}
}
}
}
}