com.xmobitea.changx.mini-localization 1.4.1 → 1.4.3

package/Editor/LocalizationManagerEditor.cs

@@ -6,11 +6,13 @@
     using System.Linq;
     using System.Xml;
     using System.Collections.Generic;
+    using System.Text.RegularExpressions;
+    using System.Text;
 
     [CustomEditor(typeof(LocalizationManager))]
     public class LocalizationManagerEditor : Editor
     {
-        private const string Version = "1.4.1";
+        private const string Version = "1.4.2";
         private const string Library = @".\Library\PackageCache\com.xmobitea.changx.mini-localization@" + Version;
         //private const string Library = @".\Assets\MiniLocalization";
         private const string ProcessPath = @"\Editor\Tools\GetLocalizationTools";
@@ -101,6 +103,16 @@
 
             for (var i = 0; i < localizationLanguageItems.Length; i++) arguments += " " + localizationLanguageItems[i].SystemLanguage;
 
+            if (platform == RuntimePlatform.WindowsEditor || platform == RuntimePlatform.WindowsPlayer || platform == RuntimePlatform.WindowsServer)
+            {
+
+            }
+            else
+            {
+                processPath = processPath.Replace("\\", "/");
+                arguments = arguments.Replace("\\", "/");
+            }
+
             Debug.Log("Run CommandLine " + processPath + " " + arguments);
 
             var process = new System.Diagnostics.Process
@@ -189,11 +201,13 @@
                 {
                     var key = node.Attributes.GetNamedItem("name").Value;
 
-                    if (!keyNameLst.Contains(key))
+                    var validKey = ToValidFieldName(key);
+
+                    if (!keyNameLst.Contains(validKey))
                     {
-                        keyNameLst.Add(key);
+                        keyNameLst.Add(validKey);
 
-                        contentBuilder.AppendLine("        public const string " + key + " = " + "\"" + key + "\";");
+                        contentBuilder.AppendLine("        public const string " + validKey + " = " + "\"" + key + "\";");
                     }
                 }
             }
@@ -202,5 +216,48 @@
             contentBuilder.AppendLine("}");
             MiniAutoGenerate.Editor.AutoGenerate.GenerateFile("LocalizationConstanceId.cs", contentBuilder, Application.dataPath + "/XmobiTea-constance/Scripts/");
         }
+
+        private static readonly HashSet<string> CSharpKeywords = new()
+        {
+            "class","struct","int","float","string","public","private","protected",
+            "internal","void","new","return","if","else","for","while","switch",
+            "case","default","break","continue","static","this","base","null",
+            "true","false","namespace","using"
+        };
+
+        private static string RemoveDiacritics(string text)
+        {
+            var normalized = text.Normalize(NormalizationForm.FormD);
+            var sb = new StringBuilder();
+
+            foreach (var c in normalized)
+            {
+                if (System.Globalization.CharUnicodeInfo.GetUnicodeCategory(c)
+                    != System.Globalization.UnicodeCategory.NonSpacingMark)
+                {
+                    sb.Append(c);
+                }
+            }
+
+            return sb.ToString().Normalize(NormalizationForm.FormC);
+        }
+
+        private static string ToValidFieldName(string input)
+        {
+            if (string.IsNullOrWhiteSpace(input))
+                return "_field";
+
+            input = RemoveDiacritics(input.Trim());
+
+            input = Regex.Replace(input, @"[^a-zA-Z0-9_]", "_");
+
+            if (char.IsDigit(input[0]))
+                input = "_" + input;
+
+            if (CSharpKeywords.Contains(input))
+                input = "_" + input;
+
+            return input;
+        }
     }
 }

package/Runtime/LocalizationLanguageItem.cs

@@ -3,6 +3,10 @@
     using System;
     using UnityEngine;
 
+#if ADDRESSABLE
+    using UnityEngine.AddressableAssets;
+#endif
+
     [Serializable]
     public class LocalizationLanguageItem
     {
@@ -18,16 +22,17 @@
         private TextAsset xml;
         public TextAsset XML { get { return xml; } set { xml = value; } }
 
-        public string OnlineXmlStr
-        {
-            get => PlayerPrefs.GetString("LocalizationLanguageItem_OnlineXmlStr_" + systemLanguage);
-            set => PlayerPrefs.SetString("LocalizationLanguageItem_OnlineXmlStr_" + systemLanguage, value);
-        }
-
-        public int VersionXml
-        {
-            get => PlayerPrefs.GetInt("LocalizationLanguageItem_VersionXml_" + systemLanguage);
-            set => PlayerPrefs.SetInt("LocalizationLanguageItem_VersionXml_" + systemLanguage, value);
-        }
+#if ADDRESSABLE
+
+        [SerializeField]
+        private AssetReferenceT<TextAsset> xmlRef;
+        public AssetReferenceT<TextAsset> XMLRef { get { return xmlRef; } set { xmlRef = value; } }
+
+#endif
+
+        [SerializeField]
+        private string onlineLocalizationUrl;
+        public string OnlineLocalizationUrl { get { return onlineLocalizationUrl; } set { onlineLocalizationUrl = value; } }
+
     }
 }

package/Runtime/LocalizationManager.cs

@@ -7,6 +7,7 @@
     using System.IO;
     using MiniSingleton;
     using Core;
+    using UnityEngine.Networking;
 
     public class LocalizationManager : Singleton<LocalizationManager>
     {
@@ -63,42 +64,22 @@
 
             var thisLanguage = Instance.localizationLanguageItemDic[systemLanguage];
 
-            var textLocalizationDic = Instance.textLocalizationDic;
-
-            {
-                var xml = LocalizationManager.GetTextWithoutBOM(thisLanguage.XML);
-
-                var xmlDoc = new XmlDocument();
-
-                xmlDoc.LoadXml(xml);
-
-                //var xml = thisLanguage.XML;
-
-                var xSectionNode = xmlDoc.ChildNodes.Item(1);
-
-                textLocalizationDic.Clear();
+            Instance.currentLanguage = thisLanguage;
 
-                foreach (XmlNode sectionNode in xSectionNode)
-                {
-                    foreach (XmlNode node in sectionNode)
-                    {
-                        var key = node.Attributes.GetNamedItem("name").Value;
-                        var text = node.InnerText.Replace("\\n", "\n").Replace("&lt;", "<").Replace("&gt;", ">").Replace("&#38;", "&").Replace("&#39;", "'").Replace("&#34;", "\"");
+            var textLocalizationDic = Instance.textLocalizationDic;
 
-                        if (Instance.textLocalizationDic.ContainsKey(key)) Debug.LogError("[Localization] " + key + " " + " duplicate");
-                        else Instance.textLocalizationDic[key] = text;
-                    }
-                }
-            }
+            textLocalizationDic.Clear();
 
             {
-                var onlineXmlStr = thisLanguage.OnlineXmlStr;
-
-                if (!string.IsNullOrEmpty(onlineXmlStr))
+                if (thisLanguage.XML != null)
                 {
+                    var xml = LocalizationManager.GetTextWithoutBOM(thisLanguage.XML);
+
                     var xmlDoc = new XmlDocument();
 
-                    xmlDoc.LoadXml(onlineXmlStr);
+                    xmlDoc.LoadXml(xml);
+
+                    //var xml = thisLanguage.XML;
 
                     var xSectionNode = xmlDoc.ChildNodes.Item(1);
 
@@ -109,78 +90,116 @@
                             var key = node.Attributes.GetNamedItem("name").Value;
                             var text = node.InnerText.Replace("\\n", "\n").Replace("&lt;", "<").Replace("&gt;", ">").Replace("&#38;", "&").Replace("&#39;", "'").Replace("&#34;", "\"");
 
-                            if (textLocalizationDic.ContainsKey(key))
-                            {
-                                Debug.LogError("[Localization] " + key + " " + " had replace by online xml");
-                            }
-
-                            textLocalizationDic[key] = text;
+                            if (textLocalizationDic.ContainsKey(key)) Debug.LogError("[Localization] " + key + " " + " duplicate");
+                            else textLocalizationDic[key] = text;
                         }
                     }
                 }
-            }
 
-            Instance.currentLanguage = thisLanguage;
+#if ADDRESSABLE
+                if (thisLanguage.XMLRef != null)
+                {
+                    thisLanguage.XMLRef.LoadAssetAsync().Completed += (handle) =>
+                    {
+                        if (handle.Status == UnityEngine.ResourceManagement.AsyncOperations.AsyncOperationStatus.Succeeded)
+                        {
+                            Debug.Log("Load xml from addressable success");
 
-            OnUpdateText?.Invoke();
+                            if (Instance.currentLanguage == thisLanguage)
+                            {
+                                var xml = LocalizationManager.GetTextWithoutBOM(handle.Result);
 
-            return true;
-        }
+                                var xmlDoc = new XmlDocument();
 
-        public static bool OnLanguageXmlOnlineChange()
-        {
-            if (!IsExists)
-            {
-                Debug.LogError("[Localization] LocalizationManager instance is null!");
-                return false;
-            }
+                                xmlDoc.LoadXml(xml);
 
-            if (Instance.currentLanguage == null)
-            {
-                Debug.LogError("[Localization] LocalizationManager currentLanguage is null!");
-                return false;
-            }
+                                var xSectionNode = xmlDoc.ChildNodes.Item(1);
 
-            var systemLanguage = Instance.currentLanguage.SystemLanguage;
+                                foreach (XmlNode sectionNode in xSectionNode)
+                                {
+                                    foreach (XmlNode node in sectionNode)
+                                    {
+                                        var key = node.Attributes.GetNamedItem("name").Value;
+                                        var text = node.InnerText.Replace("\\n", "\n").Replace("&lt;", "<").Replace("&gt;", ">").Replace("&#38;", "&").Replace("&#39;", "'").Replace("&#34;", "\"");
 
-            if (!Instance.localizationLanguageItemDic.ContainsKey(systemLanguage))
-            {
-                Debug.LogError("[Localization] " + systemLanguage + " does not esixts!");
-                return false;
-            }
+                                        if (textLocalizationDic.ContainsKey(key))
+                                        {
+                                            Debug.LogError("[Localization] " + key + " " + " had replace by addressable xml");
+                                        }
 
-            var thisLanguage = Instance.localizationLanguageItemDic[systemLanguage];
+                                        textLocalizationDic[key] = text;
+                                    }
+                                }
 
-            var textLocalizationDic = Instance.textLocalizationDic;
+                                OnUpdateText?.Invoke();
+                            }
+                            else
+                            {
+                                Debug.Log("Load xml from addressable success, but the current language does not match");
+                            }
+                        }
+                        else
+                        {
+                            Debug.LogError("Failed to load xml from addressable");
+                        }
+
+                        
+                    };
+                }
+#endif
+            }
 
             {
-                var onlineXmlStr = thisLanguage.OnlineXmlStr;
+                var onlineLocalizationUrl = thisLanguage.OnlineLocalizationUrl;
 
-                if (!string.IsNullOrEmpty(onlineXmlStr))
+                if (!string.IsNullOrEmpty(onlineLocalizationUrl))
                 {
-                    var xmlDoc = new XmlDocument();
+                    Instance.StartCoroutine(IELoadOnlineLocalization(onlineLocalizationUrl, (success, value) =>
+                    {
+                        if (success)
+                        {
+                            Debug.Log("Load xml from online url success");
 
-                    xmlDoc.LoadXml(onlineXmlStr);
+                            if (Instance.currentLanguage == thisLanguage)
+                            {
+                                var xml = value;
 
-                    //var xml = thisLanguage.XML;
+                                var xmlDoc = new XmlDocument();
 
-                    var xSectionNode = xmlDoc.ChildNodes.Item(1);
+                                xmlDoc.LoadXml(xml);
 
-                    foreach (XmlNode sectionNode in xSectionNode)
-                    {
-                        foreach (XmlNode node in sectionNode)
-                        {
-                            var key = node.Attributes.GetNamedItem("name").Value;
-                            var text = node.InnerText.Replace("\\n", "\n").Replace("&lt;", "<").Replace("&gt;", ">").Replace("&#38;", "&").Replace("&#39;", "'").Replace("&#34;", "\"");
+                                var xSectionNode = xmlDoc.ChildNodes.Item(1);
+
+                                textLocalizationDic.Clear();
+
+                                foreach (XmlNode sectionNode in xSectionNode)
+                                {
+                                    foreach (XmlNode node in sectionNode)
+                                    {
+                                        var key = node.Attributes.GetNamedItem("name").Value;
+                                        var text = node.InnerText.Replace("\\n", "\n").Replace("&lt;", "<").Replace("&gt;", ">").Replace("&#38;", "&").Replace("&#39;", "'").Replace("&#34;", "\"");
+
+                                        if (textLocalizationDic.ContainsKey(key))
+                                        {
+                                            Debug.LogError("[Localization] " + key + " " + " had replace by online url");
+                                        }
 
-                            if (textLocalizationDic.ContainsKey(key))
+                                        textLocalizationDic[key] = text;
+                                    }
+                                }
+
+                                OnUpdateText?.Invoke();
+                            }
+                            else
                             {
-                                Debug.LogError("[Localization] " + key + " " + " had replace by online xml");
+                                Debug.Log("Load xml from online url success, but the current language does not match");
                             }
-
-                            textLocalizationDic[key] = text;
                         }
-                    }
+                        else
+                        {
+                            Debug.LogError("Failed to load xml from online url");
+                        }
+                    }));
                 }
             }
 
@@ -189,6 +208,17 @@
             return true;
         }
 
+        private static System.Collections.IEnumerator IELoadOnlineLocalization(string localizationUrl, Action<bool, string> onLoaded)
+        {
+            using var unityWebRequest = UnityWebRequest.Get(localizationUrl);
+            yield return unityWebRequest.SendWebRequest();
+
+            if (unityWebRequest.result == UnityWebRequest.Result.Success)
+                onLoaded?.Invoke(true, unityWebRequest.downloadHandler.text);
+            else
+                onLoaded?.Invoke(false, unityWebRequest.error);
+        }
+
         public static string GetTextWithoutBOM(TextAsset textAsset)
         {
             var memoryStream = new MemoryStream(textAsset.bytes);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "com.xmobitea.changx.mini-localization",
-  "version": "1.4.1",
+  "version": "1.4.3",
   "displayName": "XmobiTea Localization",
   "description": "XmobiTea Unity package",
   "unity": "2020.3",