com.alicizax.unity.framework/Runtime/Localization/LocalizationComponent.cs

using System.Collections.Generic;
using Cysharp.Threading.Tasks;
using AlicizaX.Resource.Runtime;
using UnityEngine;

namespace AlicizaX.Localization.Runtime
{
    /// <summary>
    /// <20><><EFBFBD>ػ<EFBFBD><D8BB><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
    /// </summary>
    [DisallowMultipleComponent]
    [AddComponentMenu("Game Framework/Localization")]
    public sealed class LocalizationComponent : MonoBehaviour
    {
        private const string DefaultLanguage = "ChineseSimplified";
        private const string RuntimeLanguagePrefsKey = "AlicizaX.Localization.Language";

        private ILocalizationService _mLocalizationService = null;

        public static string PrefsKey = Application.dataPath.GetHashCode() + "Language";

        [SerializeField] private string _language;
        [SerializeField] private List<GameLocaizationTable> _startupTables = new();
        [SerializeField] private List<string> _startupTableLocations = new();
        [SerializeField] private string _resourcePackageName = string.Empty;

        internal void SetLanguage(string language)
        {
            _language = language;
        }

        internal static void SaveLanguagePreference(string language)
        {
            if (string.IsNullOrEmpty(language))
            {
                return;
            }

#if UNITY_EDITOR
            UnityEditor.EditorPrefs.SetString(PrefsKey, language);
#endif
            PlayerPrefs.SetString(RuntimeLanguagePrefsKey, language);
            PlayerPrefs.Save();
        }

        private static string LoadLanguagePreference(string fallbackLanguage)
        {
            string fallback = string.IsNullOrEmpty(fallbackLanguage) ? DefaultLanguage : fallbackLanguage;
            string language = PlayerPrefs.GetString(RuntimeLanguagePrefsKey, fallback);
#if UNITY_EDITOR
            language = UnityEditor.EditorPrefs.GetString(PrefsKey, language);
#endif
            return string.IsNullOrEmpty(language) ? fallback : language;
        }

        private void Awake()
        {
            if (!AppServices.App.TryGet<ILocalizationService>(out _mLocalizationService))
            {
                _mLocalizationService = AppServices.App.Register(new LocalizationService());
            }

            if (_mLocalizationService == null)
            {
                Log.Info("Localization manager is invalid.");
                return;
            }

            _language = LoadLanguagePreference(_language);
            _mLocalizationService.Initialize(_language);
            ApplyStartupTables(_startupTables);

            if (_startupTableLocations != null && _startupTableLocations.Count > 0)
            {
                LoadStartupTablesAsync().Forget();
            }
        }

        private void ApplyStartupTables(List<GameLocaizationTable> tables)
        {
            if (tables == null || tables.Count == 0)
            {
                return;
            }

            bool applied = false;
            for (int i = 0; i < tables.Count; i++)
            {
                GameLocaizationTable table = tables[i];
                if (table == null)
                {
                    continue;
                }

                if (!applied)
                {
                    _mLocalizationService.CoverAddLocalizationConfig(table);
                    applied = true;
                    continue;
                }

                _mLocalizationService.IncreAddLocalizationConfig(table);
            }
        }

        private async UniTaskVoid LoadStartupTablesAsync()
        {
            if (!AppServices.TryGet<IResourceService>(out var resourceService))
            {
                return;
            }

            List<GameLocaizationTable> loadedTables = new(_startupTableLocations.Count);
            for (int i = 0; i < _startupTableLocations.Count; i++)
            {
                string location = _startupTableLocations[i];
                if (string.IsNullOrEmpty(location))
                {
                    continue;
                }

                GameLocaizationTable table = await resourceService.LoadAssetAsync<GameLocaizationTable>(location, default, _resourcePackageName);
                if (table != null)
                {
                    loadedTables.Add(table);
                }
            }

            if (loadedTables.Count == 0)
            {
                return;
            }

            if (_startupTables == null)
            {
                _startupTables = new List<GameLocaizationTable>(loadedTables.Count);
            }

            for (int i = 0; i < loadedTables.Count; i++)
            {
                GameLocaizationTable table = loadedTables[i];
                if (_startupTables.Contains(table))
                {
                    continue;
                }

                _startupTables.Add(table);
                _mLocalizationService.IncreAddLocalizationConfig(table);
            }
        }
    }
}