RoApp/Assets/Src/Core/Config/LocalizedTextureCfgMgr.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
public class LocalizedSpriteCfg
{
    public string key;
    public string Language;
    public string AssetPath;
    public string OtherSetting;
    public string SetNativeSize;


    public LocalizedSpriteCfg()
    {
        key = "";
        Language = "";
        AssetPath = "";
        OtherSetting = "";
        SetNativeSize = "0";
    }


    public bool GetSetNativeSize()
    {
        return !string.IsNullOrEmpty(SetNativeSize) && SetNativeSize != "0";
    }
}


public class GameLanguageCfg
{
    public const string FileName = "LanguageCfg";
    public string key;
    public string language;

    public GameLanguageCfg()
    {
        key = "";
        language = "";
    }
}

public class LocalizedTextureCfgMgr : Singleton<LocalizedTextureCfgMgr>
{
    public static string  baseName = "LocalizeTextureCfg";
    private static bool isOpen = false;
    public static bool IsOpen { get => isOpen; }

    private string baseKey;

    private string curLanguageKey;
    public string CurLanguageKey { get => curLanguageKey; }
    private string oldLanguageKey;
    private Dictionary<string, Dictionary<string, LocalizedSpriteCfg>> cfgs = new Dictionary<string, Dictionary<string, LocalizedSpriteCfg>>();
    private Dictionary<string, LocalizedSpriteCfg> curCfg;
    private Dictionary<string, GameLanguageCfg> gameLanguageCfgs = new Dictionary<string, GameLanguageCfg>();
    public override void Init()
    {
        ReadlanguageCfg();

        if (!isOpen)
        {
            return ;
        }
        //SetLanguageLocalSetting("_tw");
        string defaultlg = GetLanguageLocalSetting();
        string systemlg = GetSystemDefaultLanguage();
        string curKey = "";
        if (!string.IsNullOrEmpty(defaultlg))
        {
            curKey = defaultlg;
        }
        else if (!string.IsNullOrEmpty(systemlg))
        {
            curKey = systemlg;
        }
        else
        {
            curKey = GetLanguageCfgByKey(LanguageFileEx.Unknown);
        }
        ConfigMgr.CurLangKey = curKey;
        curLanguageKey = curKey;
        oldLanguageKey = curKey;
        baseKey = GetLanguageCfgByKey(LanguageFileEx.Unknown);
        ReadConfig();
    }

    private void ReadConfig()
    {
        string cfgname = GetLanguageCfgName(curLanguageKey);

        if (!cfgs.ContainsKey(curLanguageKey))
        {
            Dictionary<string, Dictionary<string, string>> cfgdata = ConfigMgr.Instance.getTable(cfgname);
            if (cfgdata == null)
            {
                return;
            }
            Dictionary<string, LocalizedSpriteCfg> cfg = new Dictionary<string, LocalizedSpriteCfg>();
            foreach (var item in cfgdata)
            {
                LocalizedSpriteCfg localizedSpriteCfg = new LocalizedSpriteCfg();
                localizedSpriteCfg.key = item.Key;
                Dictionary<string, string> _value = item.Value;
                localizedSpriteCfg.Language = _value["Language"];
                localizedSpriteCfg.AssetPath = _value["AssetPath"];
                localizedSpriteCfg.OtherSetting = _value["OtherSetting"];
                localizedSpriteCfg.SetNativeSize = _value["SetNativeSize"];
                cfg.Add(item.Key, localizedSpriteCfg);
            }
            cfgs.Add(curLanguageKey, cfg);
            curCfg = cfg;
        }
        else
        {
            curCfg = cfgs[curLanguageKey];
        }

    }

    public void SetLanguage(string language)
    {
        if (!string.IsNullOrEmpty(language) && language != curLanguageKey)
        {
            curLanguageKey = language;
            ReadConfig();
            ConfigMgr.CurLangKey = language;
        }
    }

    private string GetLanguageCfgName(string lg)
    {
        return $"{baseName}{lg}";
    }

    /// <summary>
    /// 
    /// </summary>
    /// <param name="key"></param>
    /// <param name="notbase">要求不是base才返回</param>
    /// <returns></returns>
    public LocalizedSpriteCfg GetLocalizedSpriteCfg(string key, bool notbase = true)
    {
        if (!isOpen)
        {
            return null;
        }
        if (notbase && (curLanguageKey == oldLanguageKey || curLanguageKey == baseKey))
        {
            return null;
        }
        if (curCfg == null)
        {
            ReadConfig();
        }
        if (curCfg == null)
        {
            return null;
        }

        if (curCfg.ContainsKey(key))
        {
            return curCfg[key];
        }

        return null;
    }


    public string GetLocalize(string key, bool notbase = false)
    {
        if (!isOpen)
        {
            return "";
        }
        if (notbase && curLanguageKey == oldLanguageKey)
        {
            return "";
        }
        if (curCfg == null)
        {
            ReadConfig();
        }
        if (curCfg == null)
        {
            return "";
        }

        if (curCfg.ContainsKey(key))
        {
            return curCfg[key].Language;
        }

        return "";
    }

    private void ReadlanguageCfg()
    {
        Dictionary<string, Dictionary<string, string>> cfgdata = ConfigMgr.Instance.getTable(GameLanguageCfg.FileName);
        if (cfgdata == null)
        {
            return;
        }
        gameLanguageCfgs.Clear();
        foreach (var item in cfgdata)
        {
            GameLanguageCfg cfg = new GameLanguageCfg();
            cfg.key = item.Key;
            cfg.language = item.Value["Language"];
            gameLanguageCfgs.Add(cfg.key,cfg);
        }

        isOpen = FileHelper.CheckStringIsTrue(GetLanguageCfgByKey("openSetting"));
    }


    public void SetLanguageByKey(string key)
    {
        if (!isOpen)
        {
            return;
        }
        string lg = GetLanguageCfgByKey(key);
        if (!string.IsNullOrEmpty(lg))
        {
            SetLanguage(lg);
        }
    }

    public string GetLanguageCfgByKey(string key)
    {
        if (gameLanguageCfgs.ContainsKey(key))
        {
            return gameLanguageCfgs[key].language;
        }

        return "";
    }


    public string GetSystemDefaultLanguage()
    {
        string ret = LanguageFileEx.Unknown;
        switch (UnityEngine.Application.systemLanguage)
        {

            case UnityEngine.SystemLanguage.Vietnamese: //越南语
                {
                    ret = LanguageFileEx.Vietnamese;
                }
                break;
            case UnityEngine.SystemLanguage.Thai: //泰语
                {
                    ret = LanguageFileEx.Thai;
                }
                break;

            case UnityEngine.SystemLanguage.English:
                {
                    ret = LanguageFileEx.English;
                }
                break;
           
            case UnityEngine.SystemLanguage.Chinese:
            case UnityEngine.SystemLanguage.ChineseSimplified:
            case UnityEngine.SystemLanguage.ChineseTraditional:
                {
                    ret = LanguageFileEx.Chinese;
                }
                break;
            case UnityEngine.SystemLanguage.Unknown:
                {
                    ret = LanguageFileEx.Unknown;
                }
                break;
            default:
                break;
        }
        UnityEngine.Debug.Log(UnityEngine.Application.systemLanguage.ToString() + " 系统语言：" +ret);
        return GetLanguageCfgByKey(ret);
    }

    public string GetCurLanguageKey()
    {
        foreach (var item in gameLanguageCfgs)
        {
            if (item.Value.language == curLanguageKey && item.Key != LanguageFileEx.Unknown)
            {
                return item.Key;
            }
        }

        return "";
    }

    public static string GetLanguageLocalSetting()
    {
        return UnityEngine.PlayerPrefs.GetString("LanguageLocalSetting",string.Empty);
    }

    public static void SetLanguageLocalSetting(string key)
    {
        UnityEngine.PlayerPrefs.SetString("LanguageLocalSetting", key);
    }
}