alianblank
/
com.alianblank.gameframex.unity.localization
mirror of https://github.com/AlianBlank/com.alianblank.gameframex.unity.localization
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

[修改] 修改本地化的实现

This commit is contained in:
Blank 2025-06-23 19:44:39 +08:00
parent fbc361a2db
commit 66712b8373
11 changed files with 97 additions and 833 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
Editor/Inspector/LocalizationComponentInspector.cs
View File

@ -36,14 +36,15 @@ namespace GameFrameX.Localization.Editor
EditorGUILayout.PropertyField(m_IsEnableEditorMode);
EditorGUILayout.PropertyField(m_EditorLanguage);
EditorGUILayout.HelpBox("Editor language option is only use for localization test in editor mode.", MessageType.Info);
EditorGUILayout.HelpBox("Language Code: https://datatracker.ietf.org/doc/html/rfc5646", MessageType.Info);
// EditorGUILayout.PropertyField(m_EnableLoadDictionaryUpdateEvent);
}
EditorGUI.EndDisabledGroup();
if (EditorApplication.isPlaying && IsPrefabInHierarchy(localizationComponent.gameObject))
{
EditorGUILayout.LabelField("Language", localizationComponent.Language.ToString());
EditorGUILayout.LabelField("System Language", localizationComponent.SystemLanguage.ToString());
EditorGUILayout.LabelField("Language", localizationComponent.Language);
EditorGUILayout.LabelField("System Language", localizationComponent.SystemLanguage);
}
serializedObject.ApplyModifiedProperties();

19
Runtime/EventArgs/LocalizationLanguageChangeEventArgs.cs
View File

@ -16,20 +16,23 @@ namespace GameFrameX.Localization.Runtime
/// <summary>
/// 当前语言。
/// </summary>
public Language Language { get; set; }
public string Language { get; set; }
/// <summary>
/// 未知本地化
/// </summary>
const string UnknownLocalization = "zxx";
/// <summary>
/// 旧的语言。
/// </summary>
public Language OldLanguage { get; set; }
public string OldLanguage { get; set; }
/// <summary>
/// 初始化本地化语言改变事件的新实例。
/// </summary>
public LocalizationLanguageChangeEventArgs()
{
OldLanguage = Language.Unspecified;
Language = Language.Unspecified;
OldLanguage = UnknownLocalization;
Language = UnknownLocalization;
}
/// <summary>
@ -38,7 +41,7 @@ namespace GameFrameX.Localization.Runtime
/// <param name="oldLanguage">旧的语言。</param>
/// <param name="language">当前语言。</param>
/// <returns>创建的本地化语言改变事件。</returns>
public static LocalizationLanguageChangeEventArgs Create(Language oldLanguage, Language language)
public static LocalizationLanguageChangeEventArgs Create(string oldLanguage, string language)
{
LocalizationLanguageChangeEventArgs localizationLanguageChangeEventArgs = ReferencePool.Acquire<LocalizationLanguageChangeEventArgs>();
localizationLanguageChangeEventArgs.OldLanguage = oldLanguage;
@ -51,8 +54,8 @@ namespace GameFrameX.Localization.Runtime
/// </summary>
public override void Clear()
{
OldLanguage = Language.Unspecified;
Language = Language.Unspecified;
OldLanguage = UnknownLocalization;
Language = UnknownLocalization;
}
/// <summary>

8
Runtime/GameFrameXLocalizationCroppingHelper.cs
View File

@ -1,3 +1,9 @@
// GameFrameX 组织下的以及组织衍生的项目的版权、商标、专利和其他相关权利均受相应法律法规的保护。使用本项目应遵守相关法律法规和许可证的要求。
//
// 本项目主要遵循 MIT 许可证和 Apache 许可证（版本 2.0）进行分发和使用。许可证位于源代码树根目录中的 LICENSE 文件。
//
// 不得利用本项目从事危害国家安全、扰乱社会秩序、侵犯他人合法权益等法律法规禁止的活动！任何基于本项目二次开发而产生的一切法律纠纷和责任，我们不承担任何责任！
using UnityEngine;
using UnityEngine.Scripting;
@ -11,12 +17,10 @@ namespace GameFrameX.Localization.Runtime
{
_ = typeof(ILocalizationHelper);
_ = typeof(ILocalizationManager);
_ = typeof(Language);
_ = typeof(LoadDictionaryFailureEventArgs);
_ = typeof(LoadDictionarySuccessEventArgs);
_ = typeof(LoadDictionaryUpdateEventArgs);
_ = typeof(LocalizationManager);
_ = typeof(DefaultLocalizationHelper);
_ = typeof(LocalizationComponent);
_ = typeof(LocalizationHelperBase);
}

232
Runtime/Localization/DefaultLocalizationHelper.cs
View File

@ -1,17 +1,10 @@
//------------------------------------------------------------
// Game Framework
// Copyright © 2013-2021 Jiang Yin. All rights reserved.
// Homepage: https://gameframework.cn/
// Feedback: mailto:ellan@gameframework.cn
//------------------------------------------------------------
// GameFrameX 组织下的以及组织衍生的项目的版权、商标、专利和其他相关权利均受相应法律法规的保护。使用本项目应遵守相关法律法规和许可证的要求。
//
// 本项目主要遵循 MIT 许可证和 Apache 许可证（版本 2.0）进行分发和使用。许可证位于源代码树根目录中的 LICENSE 文件。
//
// 不得利用本项目从事危害国家安全、扰乱社会秩序、侵犯他人合法权益等法律法规禁止的活动！任何基于本项目二次开发而产生的一切法律纠纷和责任，我们不承担任何责任！
using GameFrameX.Localization;
using System;
using System.IO;
using System.Text;
using GameFrameX.Asset.Runtime;
using GameFrameX.Runtime;
using UnityEngine;
using System.Globalization;
namespace GameFrameX.Localization.Runtime
{
@ -20,221 +13,14 @@ namespace GameFrameX.Localization.Runtime
/// </summary>
public class DefaultLocalizationHelper : LocalizationHelperBase
{
private static readonly string[] ColumnSplitSeparator = new string[] { "\t" };
private static readonly string BytesAssetExtension = ".bytes";
private const int ColumnCount = 4;
private AssetComponent m_ResourceComponent = null;
readonly string _regionName = RegionInfo.CurrentRegion.Name.Replace("-", "_");
/// <summary>
/// 获取系统语言。
/// </summary>
public override Language SystemLanguage
public override string SystemLanguage
{
get
{
switch (Application.systemLanguage)
{
case UnityEngine.SystemLanguage.Afrikaans: return Language.Afrikaans;
case UnityEngine.SystemLanguage.Arabic: return Language.Arabic;
case UnityEngine.SystemLanguage.Basque: return Language.Basque;
case UnityEngine.SystemLanguage.Belarusian: return Language.Belarusian;
case UnityEngine.SystemLanguage.Bulgarian: return Language.Bulgarian;
case UnityEngine.SystemLanguage.Catalan: return Language.Catalan;
case UnityEngine.SystemLanguage.Chinese: return Language.ChineseSimplified;
case UnityEngine.SystemLanguage.ChineseSimplified: return Language.ChineseSimplified;
case UnityEngine.SystemLanguage.ChineseTraditional: return Language.ChineseTraditional;
case UnityEngine.SystemLanguage.Czech: return Language.Czech;
case UnityEngine.SystemLanguage.Danish: return Language.Danish;
case UnityEngine.SystemLanguage.Dutch: return Language.Dutch;
case UnityEngine.SystemLanguage.English: return Language.English;
case UnityEngine.SystemLanguage.Estonian: return Language.Estonian;
case UnityEngine.SystemLanguage.Faroese: return Language.Faroese;
case UnityEngine.SystemLanguage.Finnish: return Language.Finnish;
case UnityEngine.SystemLanguage.French: return Language.French;
case UnityEngine.SystemLanguage.German: return Language.German;
case UnityEngine.SystemLanguage.Greek: return Language.Greek;
case UnityEngine.SystemLanguage.Hebrew: return Language.Hebrew;
case UnityEngine.SystemLanguage.Hungarian: return Language.Hungarian;
case UnityEngine.SystemLanguage.Icelandic: return Language.Icelandic;
case UnityEngine.SystemLanguage.Indonesian: return Language.Indonesian;
case UnityEngine.SystemLanguage.Italian: return Language.Italian;
case UnityEngine.SystemLanguage.Japanese: return Language.Japanese;
case UnityEngine.SystemLanguage.Korean: return Language.Korean;
case UnityEngine.SystemLanguage.Latvian: return Language.Latvian;
case UnityEngine.SystemLanguage.Lithuanian: return Language.Lithuanian;
case UnityEngine.SystemLanguage.Norwegian: return Language.Norwegian;
case UnityEngine.SystemLanguage.Polish: return Language.Polish;
case UnityEngine.SystemLanguage.Portuguese: return Language.PortuguesePortugal;
case UnityEngine.SystemLanguage.Romanian: return Language.Romanian;
case UnityEngine.SystemLanguage.Russian: return Language.Russian;
case UnityEngine.SystemLanguage.SerboCroatian: return Language.SerboCroatian;
case UnityEngine.SystemLanguage.Slovak: return Language.Slovak;
case UnityEngine.SystemLanguage.Slovenian: return Language.Slovenian;
case UnityEngine.SystemLanguage.Spanish: return Language.Spanish;
case UnityEngine.SystemLanguage.Swedish: return Language.Swedish;
case UnityEngine.SystemLanguage.Thai: return Language.Thai;
case UnityEngine.SystemLanguage.Turkish: return Language.Turkish;
case UnityEngine.SystemLanguage.Ukrainian: return Language.Ukrainian;
case UnityEngine.SystemLanguage.Unknown: return Language.Unspecified;
case UnityEngine.SystemLanguage.Vietnamese: return Language.Vietnamese;
default: return Language.Unspecified;
}
}
}
/// <summary>
/// 读取字典。
/// </summary>
/// <param name="localizationManager">本地化管理器。</param>
/// <param name="dictionaryAssetName">字典资源名称。</param>
/// <param name="dictionaryAsset">字典资源。</param>
/// <param name="userData">用户自定义数据。</param>
/// <returns>是否读取字典成功。</returns>
public override bool ReadData(ILocalizationManager localizationManager, string dictionaryAssetName, object dictionaryAsset, object userData)
{
// TextAsset dictionaryTextAsset = dictionaryAsset as TextAsset;
// if (dictionaryTextAsset != null)
// {
// if (dictionaryAssetName.EndsWith(BytesAssetExtension, StringComparison.Ordinal))
// {
// return localizationManager.ParseData(dictionaryTextAsset.bytes, userData);
// }
// else
// {
// return localizationManager.ParseData(dictionaryTextAsset.text, userData);
// }
// }
//
// Log.Warning("Dictionary asset '{0}' is invalid.", dictionaryAssetName);
return false;
}
/// <summary>
/// 读取字典。
/// </summary>
/// <param name="localizationManager">本地化管理器。</param>
/// <param name="dictionaryAssetName">字典资源名称。</param>
/// <param name="dictionaryBytes">字典二进制流。</param>
/// <param name="startIndex">字典二进制流的起始位置。</param>
/// <param name="length">字典二进制流的长度。</param>
/// <param name="userData">用户自定义数据。</param>
/// <returns>是否读取字典成功。</returns>
public override bool ReadData(ILocalizationManager localizationManager, string dictionaryAssetName, byte[] dictionaryBytes, int startIndex, int length, object userData)
{
return true;
// if (dictionaryAssetName.EndsWith(BytesAssetExtension, StringComparison.Ordinal))
// {
// return localizationManager.ParseData(dictionaryBytes, startIndex, length, userData);
// }
// else
// {
// return localizationManager.ParseData(Utility.Converter.GetString(dictionaryBytes, startIndex, length), userData);
// }
}
/// <summary>
/// 解析字典。
/// </summary>
/// <param name="localizationManager">本地化管理器。</param>
/// <param name="dictionaryString">要解析的字典字符串。</param>
/// <param name="userData">用户自定义数据。</param>
/// <returns>是否解析字典成功。</returns>
public override bool ParseData(ILocalizationManager localizationManager, string dictionaryString, object userData)
{
try
{
int position = 0;
string dictionaryLineString = null;
while ((dictionaryLineString = dictionaryString.ReadLine(ref position)) != null)
{
if (dictionaryLineString[0] == '#')
{
continue;
}
string[] splitedLine = dictionaryLineString.Split(ColumnSplitSeparator, StringSplitOptions.None);
if (splitedLine.Length != ColumnCount)
{
Log.Warning("Can not parse dictionary line string '{0}' which column count is invalid.", dictionaryLineString);
return false;
}
string dictionaryKey = splitedLine[1];
string dictionaryValue = splitedLine[3];
if (!localizationManager.AddRawString(dictionaryKey, dictionaryValue))
{
Log.Warning("Can not add raw string with dictionary key '{0}' which may be invalid or duplicate.", dictionaryKey);
return false;
}
}
return true;
}
catch (Exception exception)
{
Log.Warning("Can not parse dictionary string with exception '{0}'.", exception);
return false;
}
}
/// <summary>
/// 解析字典。
/// </summary>
/// <param name="localizationManager">本地化管理器。</param>
/// <param name="dictionaryBytes">要解析的字典二进制流。</param>
/// <param name="startIndex">字典二进制流的起始位置。</param>
/// <param name="length">字典二进制流的长度。</param>
/// <param name="userData">用户自定义数据。</param>
/// <returns>是否解析字典成功。</returns>
public override bool ParseData(ILocalizationManager localizationManager, byte[] dictionaryBytes, int startIndex, int length, object userData)
{
try
{
using (MemoryStream memoryStream = new MemoryStream(dictionaryBytes, startIndex, length, false))
{
using (BinaryReader binaryReader = new BinaryReader(memoryStream, Encoding.UTF8))
{
while (binaryReader.BaseStream.Position < binaryReader.BaseStream.Length)
{
string dictionaryKey = binaryReader.ReadString();
string dictionaryValue = binaryReader.ReadString();
if (!localizationManager.AddRawString(dictionaryKey, dictionaryValue))
{
Log.Warning("Can not add raw string with dictionary key '{0}' which may be invalid or duplicate.", dictionaryKey);
return false;
}
}
}
}
return true;
}
catch (Exception exception)
{
Log.Warning("Can not parse dictionary bytes with exception '{0}'.", exception);
return false;
}
}
/// <summary>
/// 释放字典资源。
/// </summary>
/// <param name="localizationManager">本地化管理器。</param>
/// <param name="dictionaryAsset">要释放的字典资源。</param>
public override void ReleaseDataAsset(ILocalizationManager localizationManager, object dictionaryAsset)
{
// m_ResourceComponent.UnloadAsset(dictionaryAsset);
}
private void Start()
{
m_ResourceComponent = GameEntry.GetComponent<AssetComponent>();
if (m_ResourceComponent == null)
{
Log.Fatal("Resource component is invalid.");
return;
}
get { return _regionName; }
}
}
}

13
Runtime/Localization/Localization/ILocalizationHelper.cs
View File

@ -1,9 +1,8 @@
//------------------------------------------------------------
// Game Framework
// Copyright © 2013-2021 Jiang Yin. All rights reserved.
// Homepage: https://gameframework.cn/
// Feedback: mailto:ellan@gameframework.cn
//------------------------------------------------------------
// GameFrameX 组织下的以及组织衍生的项目的版权、商标、专利和其他相关权利均受相应法律法规的保护。使用本项目应遵守相关法律法规和许可证的要求。
//
// 本项目主要遵循 MIT 许可证和 Apache 许可证（版本 2.0）进行分发和使用。许可证位于源代码树根目录中的 LICENSE 文件。
//
// 不得利用本项目从事危害国家安全、扰乱社会秩序、侵犯他人合法权益等法律法规禁止的活动！任何基于本项目二次开发而产生的一切法律纠纷和责任，我们不承担任何责任！
namespace GameFrameX.Localization.Runtime
{
@ -15,7 +14,7 @@ namespace GameFrameX.Localization.Runtime
/// <summary>
/// 获取系统语言。
/// </summary>
Language SystemLanguage
string SystemLanguage
{
get;
}

44
Runtime/Localization/Localization/ILocalizationManager.cs
View File

@ -1,12 +1,8 @@
//------------------------------------------------------------
// Game Framework
// Copyright © 2013-2021 Jiang Yin. All rights reserved.
// Homepage: https://gameframework.cn/
// Feedback: mailto:ellan@gameframework.cn
//------------------------------------------------------------
using GameFrameX.Asset;
using GameFrameX.Asset.Runtime;
// GameFrameX 组织下的以及组织衍生的项目的版权、商标、专利和其他相关权利均受相应法律法规的保护。使用本项目应遵守相关法律法规和许可证的要求。
//
// 本项目主要遵循 MIT 许可证和 Apache 许可证（版本 2.0）进行分发和使用。许可证位于源代码树根目录中的 LICENSE 文件。
//
// 不得利用本项目从事危害国家安全、扰乱社会秩序、侵犯他人合法权益等法律法规禁止的活动！任何基于本项目二次开发而产生的一切法律纠纷和责任，我们不承担任何责任！
namespace GameFrameX.Localization.Runtime
{
@ -18,47 +14,23 @@ namespace GameFrameX.Localization.Runtime
/// <summary>
/// 获取或设置 默认本地化语言。当加载本地化失败时使用。
/// </summary>
Language DefaultLanguage { get; set; }
string DefaultLanguage { get; set; }
/// <summary>
/// 获取或设置本地化语言。
/// </summary>
Language Language { get; set; }
string Language { get; set; }
/// <summary>
/// 获取系统语言。
/// </summary>
Language SystemLanguage { get; }
string SystemLanguage { get; }
/// <summary>
/// 获取字典数量。
/// </summary>
int DictionaryCount { get; }
/// <summary>
/// 设置资源管理器。
/// </summary>
/// <param name="assetManager">资源管理器。</param>
void SetAssetManager(IAssetManager assetManager);
/// <summary>
/// 设置本地化辅助器。
/// </summary>
/// <param name="localizationHelper">本地化辅助器。</param>
void SetLocalizationHelper(ILocalizationHelper localizationHelper);
/*
/// <summary>
/// 确保二进制流缓存分配足够大小的内存并缓存。
/// </summary>
/// <param name="ensureSize">要确保二进制流缓存分配内存的大小。</param>
void EnsureCachedBytesSize(int ensureSize);
/// <summary>
/// 释放缓存的二进制流。
/// </summary>
void FreeCachedBytes();*/
/// <summary>
/// 根据字典主键获取字典内容字符串。
/// </summary>

270
Runtime/Localization/Localization/Language.cs
View File

@ -1,270 +0,0 @@
//------------------------------------------------------------
// Game Framework
// Copyright © 2013-2021 Jiang Yin. All rights reserved.
// Homepage: https://gameframework.cn/
// Feedback: mailto:ellan@gameframework.cn
//------------------------------------------------------------
namespace GameFrameX.Localization.Runtime
{
/// <summary>
/// 本地化语言。
/// </summary>
public enum Language : byte
{
/// <summary>
/// 未指定。
/// </summary>
Unspecified = 0,
/// <summary>
/// 南非荷兰语。
/// </summary>
Afrikaans,
/// <summary>
/// 阿尔巴尼亚语。
/// </summary>
Albanian,
/// <summary>
/// 阿拉伯语。
/// </summary>
Arabic,
/// <summary>
/// 巴斯克语。
/// </summary>
Basque,
/// <summary>
/// 白俄罗斯语。
/// </summary>
Belarusian,
/// <summary>
/// 保加利亚语。
/// </summary>
Bulgarian,
/// <summary>
/// 加泰罗尼亚语。
/// </summary>
Catalan,
/// <summary>
/// 简体中文。
/// </summary>
ChineseSimplified,
/// <summary>
/// 繁体中文。
/// </summary>
ChineseTraditional,
/// <summary>
/// 克罗地亚语。
/// </summary>
Croatian,
/// <summary>
/// 捷克语。
/// </summary>
Czech,
/// <summary>
/// 丹麦语。
/// </summary>
Danish,
/// <summary>
/// 荷兰语。
/// </summary>
Dutch,
/// <summary>
/// 英语。
/// </summary>
English,
/// <summary>
/// 爱沙尼亚语。
/// </summary>
Estonian,
/// <summary>
/// 法罗语。
/// </summary>
Faroese,
/// <summary>
/// 芬兰语。
/// </summary>
Finnish,
/// <summary>
/// 法语。
/// </summary>
French,
/// <summary>
/// 格鲁吉亚语。
/// </summary>
Georgian,
/// <summary>
/// 德语。
/// </summary>
German,
/// <summary>
/// 希腊语。
/// </summary>
Greek,
/// <summary>
/// 希伯来语。
/// </summary>
Hebrew,
/// <summary>
/// 匈牙利语。
/// </summary>
Hungarian,
/// <summary>
/// 冰岛语。
/// </summary>
Icelandic,
/// <summary>
/// 印尼语。
/// </summary>
Indonesian,
/// <summary>
/// 意大利语。
/// </summary>
Italian,
/// <summary>
/// 日语。
/// </summary>
Japanese,
/// <summary>
/// 韩语。
/// </summary>
Korean,
/// <summary>
/// 拉脱维亚语。
/// </summary>
Latvian,
/// <summary>
/// 立陶宛语。
/// </summary>
Lithuanian,
/// <summary>
/// 马其顿语。
/// </summary>
Macedonian,
/// <summary>
/// 马拉雅拉姆语。
/// </summary>
Malayalam,
/// <summary>
/// 挪威语。
/// </summary>
Norwegian,
/// <summary>
/// 波斯语。
/// </summary>
Persian,
/// <summary>
/// 波兰语。
/// </summary>
Polish,
/// <summary>
/// 巴西葡萄牙语。
/// </summary>
PortugueseBrazil,
/// <summary>
/// 葡萄牙语。
/// </summary>
PortuguesePortugal,
/// <summary>
/// 罗马尼亚语。
/// </summary>
Romanian,
/// <summary>
/// 俄语。
/// </summary>
Russian,
/// <summary>
/// 塞尔维亚克罗地亚语。
/// </summary>
SerboCroatian,
/// <summary>
/// 塞尔维亚西里尔语。
/// </summary>
SerbianCyrillic,
/// <summary>
/// 塞尔维亚拉丁语。
/// </summary>
SerbianLatin,
/// <summary>
/// 斯洛伐克语。
/// </summary>
Slovak,
/// <summary>
/// 斯洛文尼亚语。
/// </summary>
Slovenian,
/// <summary>
/// 西班牙语。
/// </summary>
Spanish,
/// <summary>
/// 瑞典语。
/// </summary>
Swedish,
/// <summary>
/// 泰语。
/// </summary>
Thai,
/// <summary>
/// 土耳其语。
/// </summary>
Turkish,
/// <summary>
/// 乌克兰语。
/// </summary>
Ukrainian,
/// <summary>
/// 越南语。
/// </summary>
Vietnamese
}
}

3
Runtime/Localization/Localization/Language.cs.meta
View File

@ -1,3 +0,0 @@
fileFormatVersion: 2
guid: 2825df334b6f4897a96e2547d5a4b3c4
timeCreated: 1712727478

207
Runtime/Localization/Localization/LocalizationManager.cs
View File

@ -1,9 +1,8 @@
//------------------------------------------------------------
// Game Framework
// Copyright © 2013-2021 Jiang Yin. All rights reserved.
// Homepage: https://gameframework.cn/
// Feedback: mailto:ellan@gameframework.cn
//------------------------------------------------------------
// GameFrameX 组织下的以及组织衍生的项目的版权、商标、专利和其他相关权利均受相应法律法规的保护。使用本项目应遵守相关法律法规和许可证的要求。
//
// 本项目主要遵循 MIT 许可证和 Apache 许可证（版本 2.0）进行分发和使用。许可证位于源代码树根目录中的 LICENSE 文件。
//
// 不得利用本项目从事危害国家安全、扰乱社会秩序、侵犯他人合法权益等法律法规禁止的活动！任何基于本项目二次开发而产生的一切法律纠纷和责任，我们不承担任何责任！
using System;
using System.Collections.Generic;
@ -21,8 +20,13 @@ namespace GameFrameX.Localization.Runtime
{
private readonly Dictionary<string, string> _dictionary;
private ILocalizationHelper _localizationHelper;
private Language _defaultLanguage;
private Language _language;
private string _defaultLanguage;
private string _language;
/// <summary>
/// 未知本地化
/// </summary>
const string UnknownLocalization = "zxx";
/// <summary>
/// 初始化本地化管理器的新实例。
@ -31,19 +35,19 @@ namespace GameFrameX.Localization.Runtime
{
_dictionary = new Dictionary<string, string>(StringComparer.Ordinal);
_localizationHelper = null;
_defaultLanguage = Language.Unspecified;
_language = Language.Unspecified;
_defaultLanguage = UnknownLocalization;
_language = UnknownLocalization;
}
/// <summary>
/// 获取或设置 默认本地化语言。当加载本地化失败时使用。
/// </summary>
public Language DefaultLanguage
public string DefaultLanguage
{
get { return _defaultLanguage; }
set
{
if (value == Language.Unspecified)
if (value == UnknownLocalization)
{
throw new GameFrameworkException("default Language is invalid.");
}
@ -55,12 +59,12 @@ namespace GameFrameX.Localization.Runtime
/// <summary>
/// 获取或设置本地化语言。
/// </summary>
public Language Language
public string Language
{
get { return _language; }
set
{
if (value == Language.Unspecified)
if (value == UnknownLocalization)
{
throw new GameFrameworkException("Language is invalid.");
}
@ -72,7 +76,7 @@ namespace GameFrameX.Localization.Runtime
/// <summary>
/// 获取系统语言。
/// </summary>
public Language SystemLanguage
public string SystemLanguage
{
get
{
@ -89,52 +93,6 @@ namespace GameFrameX.Localization.Runtime
get { return _dictionary.Count; }
}
/*
/// <summary>
/// 获取缓冲二进制流的大小。
/// </summary>
public int CachedBytesSize
{
get { return DataProvider<ILocalizationManager>.CachedBytesSize; }
}
/// <summary>
/// 读取字典成功事件。
/// </summary>
public event EventHandler<ReadDataSuccessEventArgs> ReadDataSuccess
{
add { m_DataProvider.ReadDataSuccess += value; }
remove { m_DataProvider.ReadDataSuccess -= value; }
}
/// <summary>
/// 读取字典失败事件。
/// </summary>
public event EventHandler<ReadDataFailureEventArgs> ReadDataFailure
{
add { m_DataProvider.ReadDataFailure += value; }
remove { m_DataProvider.ReadDataFailure -= value; }
}
/// <summary>
/// 读取字典更新事件。
/// </summary>
public event EventHandler<ReadDataUpdateEventArgs> ReadDataUpdate
{
add { m_DataProvider.ReadDataUpdate += value; }
remove { m_DataProvider.ReadDataUpdate -= value; }
}
/// <summary>
/// 读取字典时加载依赖资源事件。
/// </summary>
public event EventHandler<ReadDataDependencyAssetEventArgs> ReadDataDependencyAsset
{
add { m_DataProvider.ReadDataDependencyAsset += value; }
remove { m_DataProvider.ReadDataDependencyAsset -= value; }
}
*/
/// <summary>
/// 本地化管理器轮询。
/// </summary>
@ -151,133 +109,6 @@ namespace GameFrameX.Localization.Runtime
{
}
/// <summary>
/// 设置资源管理器。
/// </summary>
/// <param name="resourceManager">资源管理器。</param>
public void SetAssetManager(IAssetManager resourceManager)
{
// m_DataProvider.SetResourceManager(resourceManager);
}
/// <summary>
/// 设置本地化辅助器。
/// </summary>
/// <param name="localizationHelper">本地化辅助器。</param>
public void SetLocalizationHelper(ILocalizationHelper localizationHelper)
{
GameFrameworkGuard.NotNull(localizationHelper, nameof(localizationHelper));
_localizationHelper = localizationHelper;
}
/*
/// <summary>
/// 读取字典。
/// </summary>
/// <param name="dictionaryAssetName">字典资源名称。</param>
public void ReadData(string dictionaryAssetName)
{
m_DataProvider.ReadData(dictionaryAssetName);
}
/// <summary>
/// 读取字典。
/// </summary>
/// <param name="dictionaryAssetName">字典资源名称。</param>
/// <param name="priority">加载字典资源的优先级。</param>
public void ReadData(string dictionaryAssetName, int priority)
{
m_DataProvider.ReadData(dictionaryAssetName, priority);
}
/// <summary>
/// 读取字典。
/// </summary>
/// <param name="dictionaryAssetName">字典资源名称。</param>
/// <param name="userData">用户自定义数据。</param>
public void ReadData(string dictionaryAssetName, object userData)
{
m_DataProvider.ReadData(dictionaryAssetName, userData);
}
/// <summary>
/// 读取字典。
/// </summary>
/// <param name="dictionaryAssetName">字典资源名称。</param>
/// <param name="priority">加载字典资源的优先级。</param>
/// <param name="userData">用户自定义数据。</param>
public void ReadData(string dictionaryAssetName, int priority, object userData)
{
m_DataProvider.ReadData(dictionaryAssetName, priority, userData);
}
/// <summary>
/// 解析字典。
/// </summary>
/// <param name="dictionaryString">要解析的字典字符串。</param>
/// <returns>是否解析字典成功。</returns>
public bool ParseData(string dictionaryString)
{
return m_DataProvider.ParseData(dictionaryString);
}
/// <summary>
/// 解析字典。
/// </summary>
/// <param name="dictionaryString">要解析的字典字符串。</param>
/// <param name="userData">用户自定义数据。</param>
/// <returns>是否解析字典成功。</returns>
public bool ParseData(string dictionaryString, object userData)
{
return m_DataProvider.ParseData(dictionaryString, userData);
}
/// <summary>
/// 解析字典。
/// </summary>
/// <param name="dictionaryBytes">要解析的字典二进制流。</param>
/// <returns>是否解析字典成功。</returns>
public bool ParseData(byte[] dictionaryBytes)
{
return m_DataProvider.ParseData(dictionaryBytes);
}
/// <summary>
/// 解析字典。
/// </summary>
/// <param name="dictionaryBytes">要解析的字典二进制流。</param>
/// <param name="userData">用户自定义数据。</param>
/// <returns>是否解析字典成功。</returns>
public bool ParseData(byte[] dictionaryBytes, object userData)
{
return m_DataProvider.ParseData(dictionaryBytes, userData);
}
/// <summary>
/// 解析字典。
/// </summary>
/// <param name="dictionaryBytes">要解析的字典二进制流。</param>
/// <param name="startIndex">字典二进制流的起始位置。</param>
/// <param name="length">字典二进制流的长度。</param>
/// <returns>是否解析字典成功。</returns>
public bool ParseData(byte[] dictionaryBytes, int startIndex, int length)
{
return m_DataProvider.ParseData(dictionaryBytes, startIndex, length);
}
/// <summary>
/// 解析字典。
/// </summary>
/// <param name="dictionaryBytes">要解析的字典二进制流。</param>
/// <param name="startIndex">字典二进制流的起始位置。</param>
/// <param name="length">字典二进制流的长度。</param>
/// <param name="userData">用户自定义数据。</param>
/// <returns>是否解析字典成功。</returns>
public bool ParseData(byte[] dictionaryBytes, int startIndex, int length, object userData)
{
return m_DataProvider.ParseData(dictionaryBytes, startIndex, length, userData);
}*/
/// <summary>
/// 根据字典主键获取字典内容字符串。
/// </summary>

66
Runtime/Localization/LocalizationComponent.cs
View File

@ -1,12 +1,9 @@
//------------------------------------------------------------
// Game Framework
// Copyright © 2013-2021 Jiang Yin. All rights reserved.
// Homepage: https://gameframework.cn/
// Feedback: mailto:ellan@gameframework.cn
//------------------------------------------------------------
// GameFrameX 组织下的以及组织衍生的项目的版权、商标、专利和其他相关权利均受相应法律法规的保护。使用本项目应遵守相关法律法规和许可证的要求。
//
// 本项目主要遵循 MIT 许可证和 Apache 许可证（版本 2.0）进行分发和使用。许可证位于源代码树根目录中的 LICENSE 文件。
//
// 不得利用本项目从事危害国家安全、扰乱社会秩序、侵犯他人合法权益等法律法规禁止的活动！任何基于本项目二次开发而产生的一切法律纠纷和责任，我们不承担任何责任！
using System;
using GameFrameX.Asset.Runtime;
using GameFrameX.Event.Runtime;
using GameFrameX.Runtime;
using GameFrameX.Setting.Runtime;
@ -19,16 +16,20 @@ namespace GameFrameX.Localization.Runtime
/// </summary>
[DisallowMultipleComponent]
[AddComponentMenu("Game Framework/Localization")]
[HelpURL("https://datatracker.ietf.org/doc/html/rfc5646")]
public sealed class LocalizationComponent : GameFrameworkComponent
{
private ILocalizationManager m_LocalizationManager = null;
private EventComponent m_EventComponent = null;
private SettingComponent m_SettingComponent = null;
/// <summary>
/// 未知本地化
/// </summary>
const string UnknownLocalization = "zxx";
[SerializeField] private string m_EditorLanguage = "zh_CN";
[SerializeField] private Language m_EditorLanguage = Language.Unspecified;
[SerializeField] private Language m_DefaultLanguage = Language.Unspecified;
[SerializeField] private string m_DefaultLanguage = "zh_CN";
[SerializeField] private bool m_EnableLoadDictionaryUpdateEvent = false;
[SerializeField] private bool m_IsEnableEditorMode = false;
@ -41,7 +42,7 @@ namespace GameFrameX.Localization.Runtime
/// <summary>
/// 获取或设置编辑器语言（仅编辑器内有效）。
/// </summary>
public Language EditorLanguage
public string EditorLanguage
{
get { return m_EditorLanguage; }
set { m_EditorLanguage = value; }
@ -50,16 +51,16 @@ namespace GameFrameX.Localization.Runtime
/// <summary>
/// 获取或设置 默认本地化语言。当加载本地化失败时使用。
/// </summary>
public Language DefaultLanguage
public string DefaultLanguage
{
get
{
if (m_LocalizationManager.DefaultLanguage == Language.Unspecified)
if (m_LocalizationManager.DefaultLanguage == UnknownLocalization)
{
var value = m_SettingComponent.GetString(nameof(LocalizationComponent) + "." + nameof(DefaultLanguage));
if (value.IsNotNullOrWhiteSpace() && Enum.TryParse(value, true, out Language result))
if (value.IsNotNullOrWhiteSpace() )
{
m_LocalizationManager.DefaultLanguage = result;
m_LocalizationManager.DefaultLanguage = value;
}
}
@ -70,7 +71,7 @@ namespace GameFrameX.Localization.Runtime
if (m_LocalizationManager.DefaultLanguage != value)
{
m_LocalizationManager.DefaultLanguage = value;
m_SettingComponent.SetString(nameof(LocalizationComponent) + "." + nameof(DefaultLanguage), value.ToString());
m_SettingComponent.SetString(nameof(LocalizationComponent) + "." + nameof(DefaultLanguage), value);
m_SettingComponent.Save();
}
}
@ -79,16 +80,16 @@ namespace GameFrameX.Localization.Runtime
/// <summary>
/// 获取或设置本地化语言。
/// </summary>
public Language Language
public string Language
{
get
{
if (m_LocalizationManager.Language == Language.Unspecified)
if (m_LocalizationManager.Language == UnknownLocalization)
{
var value = m_SettingComponent.GetString(nameof(LocalizationComponent) + "." + nameof(Language));
if (value.IsNotNullOrWhiteSpace() && Enum.TryParse(value, true, out Language result))
if (value.IsNotNullOrWhiteSpace() )
{
m_LocalizationManager.Language = result;
m_LocalizationManager.Language = value;
}
}
@ -100,7 +101,7 @@ namespace GameFrameX.Localization.Runtime
{
var oldLanguage = m_LocalizationManager.Language;
m_LocalizationManager.Language = value;
m_SettingComponent.SetString(nameof(LocalizationComponent) + "." + nameof(Language), value.ToString());
m_SettingComponent.SetString(nameof(LocalizationComponent) + "." + nameof(Language), value);
m_SettingComponent.Save();
var localizationLanguageChangeEventArgs = LocalizationLanguageChangeEventArgs.Create(oldLanguage, value);
m_EventComponent.Fire(this, localizationLanguageChangeEventArgs);
@ -111,7 +112,7 @@ namespace GameFrameX.Localization.Runtime
/// <summary>
/// 获取系统语言。
/// </summary>
public Language SystemLanguage
public string SystemLanguage
{
get { return m_LocalizationManager.SystemLanguage; }
}
@ -124,13 +125,6 @@ namespace GameFrameX.Localization.Runtime
get { return m_LocalizationManager.DictionaryCount; }
}
/// <summary>
/// 获取缓冲二进制流的大小。
/// </summary>
// public int CachedBytesSize
// {
// get { return m_LocalizationManager.CachedBytesSize; }
// }
/// <summary>
/// 游戏框架组件初始化。
@ -179,7 +173,6 @@ namespace GameFrameX.Localization.Runtime
return;
}
m_LocalizationManager.SetAssetManager(GameFrameworkEntry.GetModule<IAssetManager>());
LocalizationHelperBase localizationHelper = Helper.CreateHelper(m_LocalizationHelperTypeName, m_CustomLocalizationHelper);
if (localizationHelper == null)
@ -193,22 +186,21 @@ namespace GameFrameX.Localization.Runtime
localizationHelperTransform.SetParent(this.transform);
localizationHelperTransform.localScale = Vector3.one;
m_LocalizationManager.SetLocalizationHelper(localizationHelper);
#if UNITY_EDITOR
if (m_IsEnableEditorMode)
{
Language = EditorLanguage != Language.Unspecified ? EditorLanguage : m_LocalizationManager.SystemLanguage;
Language = EditorLanguage != UnknownLocalization ? EditorLanguage : m_LocalizationManager.SystemLanguage;
}
#else
if (m_LocalizationManager.Language == Language.Unspecified)
if (m_LocalizationManager.Language == UnknownLocalization)
{
Language = m_LocalizationManager.SystemLanguage;
}
#endif
DefaultLanguage = m_DefaultLanguage != Language.Unspecified ? m_DefaultLanguage : m_LocalizationManager.SystemLanguage;
DefaultLanguage = m_DefaultLanguage != UnknownLocalization ? m_DefaultLanguage : m_LocalizationManager.SystemLanguage;
}
/*/// <summary>
/// <summary>
/// 根据字典主键获取字典内容字符串。
/// </summary>
/// <param name="key">字典主键。</param>
@ -707,7 +699,7 @@ namespace GameFrameX.Localization.Runtime
public void RemoveAllRawStrings()
{
m_LocalizationManager.RemoveAllRawStrings();
}*/
}
/*
private void OnReadDataSuccess(object sender, ReadDataSuccessEventArgs e)

63
Runtime/Localization/LocalizationHelperBase.cs
View File

@ -1,11 +1,9 @@
//------------------------------------------------------------
// Game Framework
// Copyright © 2013-2021 Jiang Yin. All rights reserved.
// Homepage: https://gameframework.cn/
// Feedback: mailto:ellan@gameframework.cn
//------------------------------------------------------------
// GameFrameX 组织下的以及组织衍生的项目的版权、商标、专利和其他相关权利均受相应法律法规的保护。使用本项目应遵守相关法律法规和许可证的要求。
//
// 本项目主要遵循 MIT 许可证和 Apache 许可证（版本 2.0）进行分发和使用。许可证位于源代码树根目录中的 LICENSE 文件。
//
// 不得利用本项目从事危害国家安全、扰乱社会秩序、侵犯他人合法权益等法律法规禁止的活动！任何基于本项目二次开发而产生的一切法律纠纷和责任，我们不承担任何责任！
using GameFrameX.Localization;
using UnityEngine;
namespace GameFrameX.Localization.Runtime
@ -18,55 +16,6 @@ namespace GameFrameX.Localization.Runtime
/// <summary>
/// 获取系统语言。
/// </summary>
public abstract Language SystemLanguage { get; }
/// <summary>
/// 读取字典。
/// </summary>
/// <param name="localizationManager">本地化管理器。</param>
/// <param name="dictionaryAssetName">字典资源名称。</param>
/// <param name="dictionaryAsset">字典资源。</param>
/// <param name="userData">用户自定义数据。</param>
/// <returns>是否读取字典成功。</returns>
public abstract bool ReadData(ILocalizationManager localizationManager, string dictionaryAssetName, object dictionaryAsset, object userData);
/// <summary>
/// 读取字典。
/// </summary>
/// <param name="localizationManager">本地化管理器。</param>
/// <param name="dictionaryAssetName">字典资源名称。</param>
/// <param name="dictionaryBytes">字典二进制流。</param>
/// <param name="startIndex">字典二进制流的起始位置。</param>
/// <param name="length">字典二进制流的长度。</param>
/// <param name="userData">用户自定义数据。</param>
/// <returns>是否读取字典成功。</returns>
public abstract bool ReadData(ILocalizationManager localizationManager, string dictionaryAssetName, byte[] dictionaryBytes, int startIndex, int length, object userData);
/// <summary>
/// 解析字典。
/// </summary>
/// <param name="localizationManager">本地化管理器。</param>
/// <param name="dictionaryString">要解析的字典字符串。</param>
/// <param name="userData">用户自定义数据。</param>
/// <returns>是否解析字典成功。</returns>
public abstract bool ParseData(ILocalizationManager localizationManager, string dictionaryString, object userData);
/// <summary>
/// 解析字典。
/// </summary>
/// <param name="localizationManager">本地化管理器。</param>
/// <param name="dictionaryBytes">要解析的字典二进制流。</param>
/// <param name="startIndex">字典二进制流的起始位置。</param>
/// <param name="length">字典二进制流的长度。</param>
/// <param name="userData">用户自定义数据。</param>
/// <returns>是否解析字典成功。</returns>
public abstract bool ParseData(ILocalizationManager localizationManager, byte[] dictionaryBytes, int startIndex, int length, object userData);
/// <summary>
/// 释放字典资源。
/// </summary>
/// <param name="localizationManager">本地化管理器。</param>
/// <param name="dictionaryAsset">要释放的字典资源。</param>
public abstract void ReleaseDataAsset(ILocalizationManager localizationManager, object dictionaryAsset);
public abstract string SystemLanguage { get; }
}
}