XMen/Assets/Plugins/XPlugins/Localization/Localization.cs

using System;
using UnityEngine;
using System.Collections;
using System.Collections.Generic;
using System.Globalization;
using System.IO;
using System.Threading;
using XPlugin.Update;

namespace XPlugin.Localization
{
    public delegate void LanguageChange();

    public static class Localization
    {
        public static Dictionary<LanguageEnum, string> LanguagePath;

        //https://blog.csdn.net/lhy2199/article/details/7410694
        public static Dictionary<LanguageEnum, CultureInfo> CultureInfos = new Dictionary<LanguageEnum, CultureInfo>() {
            {LanguageEnum.en, CultureInfo.GetCultureInfo("en-US")},
            {LanguageEnum.zh, CultureInfo.GetCultureInfo("zh-CN")},
            {LanguageEnum.zht, CultureInfo.GetCultureInfo("zh-TW")},
            {LanguageEnum.vi, CultureInfo.GetCultureInfo("vi-VN")},
            {LanguageEnum.jp, CultureInfo.GetCultureInfo("ja-JP")},
            {LanguageEnum.kr, CultureInfo.GetCultureInfo("ko-KR")},
            {LanguageEnum.de,CultureInfo.GetCultureInfo("de-DE")},
            {LanguageEnum.fr, CultureInfo.GetCultureInfo("fr-FR")},
            {LanguageEnum.ru,CultureInfo.GetCultureInfo("ru-RU")},
            {LanguageEnum.pt,CultureInfo.GetCultureInfo("pt-PT")},
            {LanguageEnum.es,CultureInfo.GetCultureInfo("es-ES")},
            {LanguageEnum.it,CultureInfo.GetCultureInfo("it-IT")},
            {LanguageEnum.th,CultureInfo.GetCultureInfo("th-TH")},
            {LanguageEnum.ar,CultureInfo.GetCultureInfo("ar-SA")},
            {LanguageEnum.tr,CultureInfo.GetCultureInfo("tr-TR")},
            {LanguageEnum.pl,CultureInfo.GetCultureInfo("pl-PL")},
            {LanguageEnum.ina,CultureInfo.GetCultureInfo("id-ID")}
        };

        static Localization()
        {
            //初始化语言路径
            LanguagePath = new Dictionary<LanguageEnum, string>();
            foreach (LanguageEnum name in Enum.GetValues(typeof(LanguageEnum)))
            {
                LanguagePath.Add(name, name + "/");
            }
            LanguagePath[LanguageEnum.unkonwn] = "";
        }

        public static LanguageChange OnLanguageChanged;

        private static LanguageEnum _language = LanguageEnum.unkonwn;

        /// <summary>
        /// 当前语言
        /// </summary>
        public static LanguageEnum Language
        {
            get { return _language; }
            set
            {
                Debug.Log("设置语言:" + value);
                var oldLanguage = _language;
                _language = value;
                CultureInfo info;
                if (CultureInfos.TryGetValue(_language, out info))
                {
                    Thread.CurrentThread.CurrentCulture = info;
                }
                else
                {
                    Thread.CurrentThread.CurrentCulture = CultureInfo.GetCultureInfo("en-US");
                }
            }
        }

        /// <summary>
        /// 当前语言资源路径
        /// </summary>
        public static string CurrentPath => LanguagePath[Language];

        public static LanguageEnum SystemLang
        {
            get
            {
                LanguageEnum lang = LanguageEnum.unkonwn;
                //预置语言
                var www = UResources.LoadStreamingAsset("language.txt");
                if (string.IsNullOrEmpty(www.error))
                {
                    var txt = www.text;
                    lang = (LanguageEnum)Enum.Parse(typeof(LanguageEnum), txt);
                    Debug.Log("使用StreamingAsset中的语言:" + www.text + " => " + lang);
                }
                else
                {
                    var systemLanguage = Application.systemLanguage;
                    switch (systemLanguage)
                    {
                        case SystemLanguage.Chinese:
                        case SystemLanguage.ChineseSimplified:
                            lang = LanguageEnum.zh;
                            break;
                        case SystemLanguage.ChineseTraditional:
                            lang = LanguageEnum.zht;
                            break;
                        case SystemLanguage.English:
                            lang = LanguageEnum.en;
                            break;
                        case SystemLanguage.Vietnamese:
                            lang = LanguageEnum.vi;
                            break;
                        case SystemLanguage.Japanese:
                            lang = LanguageEnum.jp;
                            break;
                        case SystemLanguage.Korean:
                            lang = LanguageEnum.kr;
                            break;
                        case SystemLanguage.German:
                            lang = LanguageEnum.de;
                            break;
                        case SystemLanguage.French:
                            lang = LanguageEnum.fr;
                            break;
                        case SystemLanguage.Russian:
                            lang = LanguageEnum.ru;
                            break;
                        case SystemLanguage.Portuguese:
                            lang = LanguageEnum.pt;
                            break;
                        case SystemLanguage.Spanish:
                            lang = LanguageEnum.es;
                            break;
                        case SystemLanguage.Italian:
                            lang = LanguageEnum.it;
                            break;
                        case SystemLanguage.Thai:
                            lang = LanguageEnum.th;
                            break;
                        case SystemLanguage.Arabic:
                            lang = LanguageEnum.ar;
                            break;
                        case SystemLanguage.Turkish:
                            lang = LanguageEnum.tr;
                            break;
                        case SystemLanguage.Polish:
                            lang = LanguageEnum.pl;
                            break;
                        case SystemLanguage.Indonesian:
                            lang = LanguageEnum.ina;
                            break;
                    }
                    Debug.Log("没有找到StreamingAsset中的语言,使用系统语言:" + systemLanguage + " => " + lang);
                }
                return lang;
            }
        }

        public static string GetStringWithLanguage(LanguageEnum languageEnum)
        {
            switch (languageEnum)
            {
                case LanguageEnum.zh:
                    return "简体中文";
                case LanguageEnum.en:
                    return "English";
                case LanguageEnum.ina:
                    return "Bahasa Indonesian";
                case LanguageEnum.ar:
                    return "";
            }

            return null;
        }

        public static void Init(LanguageEnum lang)
        {
            Language = lang;
        }

        /// <summary>
        /// 将资源路径转换为本地化资源路径
        /// 例如简体中文下asset变为zh-CN/asset
        /// </summary>
        /// <param name="path"></param>
        /// <returns></returns>
        public static string ConvertAssetPath(string path)
        {
            return CurrentPath + path;
        }
    }
}