com.beanbag.huaweiads 0.0.1

package/Runtime/Scripts/ML/LangDetector/HMSMLLanguageDetectionManager.cs

@@ -0,0 +1,180 @@
+using HmsPlugin;
+using HuaweiMobileServices.ML.Common;
+using HuaweiMobileServices.ML.LanguageDetection;
+using HuaweiMobileServices.ML.LanguageDetection.Cloud;
+using HuaweiMobileServices.ML.LanguageDetection.Local;
+using HuaweiMobileServices.Utils;
+using System;
+using System.Collections.Generic;
+using UnityEngine;
+
+
+namespace Assets.Huawei.Scripts.ML.LangDetector
+{
+    public enum DetectionMode
+    {
+        Online = 0,
+        Offline = 1
+    }
+    public class HMSMLLanguageDetectionManager : HMSManagerSingleton<HMSMLLanguageDetectionManager>
+    {
+
+        private const string TAG = "[HMS] HMSMLLanguageDetectionManager ";
+        private readonly string apiKey;
+        private readonly int DefaultUserRegion = MLApplication.REGION_DR_GERMAN;
+        private DetectionMode currentDetectionMode;
+
+        private MLRemoteLangDetectorSetting remoteSetting;
+        private MLRemoteLangDetector remoteDetector;
+        private MLLocalLangDetectorSetting localSetting;
+        private MLLocalLangDetector localDetector;
+
+        private bool IsLangDetectionModuleEnabled => HMSMLKitSettings.Instance.Settings.GetBool(HMSMLKitSettings.EnableLanguageDetectionModule);
+
+        public HMSMLLanguageDetectionManager()
+        {
+            if (!IsLangDetectionModuleEnabled)
+            {
+                Debug.Log($"{TAG} -> Lang Detection Module is not enabled");
+                return;
+            }
+            apiKey = HMSMLKitSettings.Instance.Settings.Get(HMSMLKitSettings.MLKeyAPI);
+            HMSManagerStart.Start(OnAwake, TAG);
+        }
+        private void OnAwake()
+        {
+            Initialize();
+        }
+        private void Initialize()
+        {
+            var instance = MLApplication.Initialize();
+            instance.SetApiKey(apiKey);
+            instance.SetUserRegion(DefaultUserRegion);
+            Debug.Log($"{TAG} -> Initialized");
+        }
+
+        public void Configure(DetectionMode detectionMode)
+        {
+            currentDetectionMode = detectionMode;
+            switch (detectionMode)
+            {
+                case DetectionMode.Online:
+                    SetOnlineDetection();
+                    break;
+                case DetectionMode.Offline:
+                    SetOfflineDetection();
+                    break;
+            }
+        }
+
+
+        private void SetOnlineDetection(float f = 0.01f)
+        {
+            
+            remoteSetting = new MLRemoteLangDetectorSetting.Factory().SetTrustedThreshold(f).Create();
+
+            remoteDetector = MLLangDetectorFactory.GetInstance().GetRemoteLangDetector(remoteSetting); 
+        }
+        private void SetOfflineDetection(float f = 0.01f)
+        {
+          
+            localSetting = new MLLocalLangDetectorSetting.Factory().SetTrustedThreshold(f).Create();
+
+            localDetector = MLLangDetectorFactory.GetInstance().GetLocalLangDetector(localSetting); 
+        }
+
+
+        public void ProbilityDetectLocal(string text, Action<IList<MLDetectedLang>> success, Action<HMSException> failure)
+        {
+            localDetector.ProbabilityDetect(text).AddOnSuccessListener((result) =>
+            {
+                Debug.Log($"{TAG} PROBILITY DETECT LOCAL -> {result}");
+                success?.Invoke(result);
+
+            }).AddOnFailureListener((error) =>
+            {
+                Debug.LogError($"{TAG} PROBILITY DETECT LOCAL -> Error: {error.WrappedCauseMessage}");
+                failure?.Invoke(error);
+            });
+        }
+        public void FirstBestDetectLocal(string text, Action<string> success, Action<HMSException> failure)
+        {
+           
+            localDetector.FirstBestDetect(text).AddOnSuccessListener((result) =>
+            {
+                Debug.Log($"{TAG} FIRST BEST DETECT LOCAL -> {result}");
+                success?.Invoke(result);
+            }).AddOnFailureListener((error) =>
+            {
+                Debug.LogError($"{TAG} FIRST BEST DETECT LOCAL -> Error: {error.WrappedCauseMessage}");
+                failure?.Invoke(error);
+            });
+        }
+
+        public void ProbilityDetectRemote(string text, Action<IList<MLDetectedLang>> success, Action<HMSException> failure)
+        {
+            remoteDetector.ProbabilityDetect(text).AddOnSuccessListener((result) =>
+            {
+                Debug.Log($"{TAG} PROBILITY DETECT REMOTE -> {result}");
+                success?.Invoke(result);
+
+            }).AddOnFailureListener((error) =>
+            {
+                Debug.LogError($"{TAG}  PROBILITY DETECT REMOTE -> Error: {error.WrappedCauseMessage}");
+                failure?.Invoke(error);
+            });
+        }
+        public void FirstBestDetectRemote(string text, Action<string> success, Action<HMSException> failure)
+
+        {
+            
+            remoteDetector.FirstBestDetect(text).AddOnSuccessListener((result) =>
+            {
+                Debug.Log($"{TAG} FIRST BEST DETECT REMOTE -> {result}");
+                success?.Invoke(result);
+            }).AddOnFailureListener((error) =>
+            {
+                Debug.LogError($"{TAG}  FIRST BEST DETECT REMOTE -> Error: {error.WrappedCauseMessage}");
+                failure?.Invoke(error);
+
+            });
+        }
+        public IList<MLDetectedLang> SyncProbilityDetectLocal(string text)
+        {
+            return localDetector.SyncProbabilityDetect(text); 
+        }
+
+        public string SyncFirstBestDetectLocal(string text)
+        {
+            return localDetector.SyncFirstBestDetect(text); 
+        }
+
+        public void StopLocalLangDetector()
+        {
+            if (localDetector != null)
+            {
+                localDetector.Stop();
+            }
+        }
+
+
+        public IList<MLDetectedLang> SyncProbilityDetectRemote(string text)
+        {
+            return remoteDetector.SyncProbabilityDetect(text); 
+        }
+
+        public string SyncFirstBestDetectRemote(string text)
+        {
+            return remoteDetector.SyncFirstBestDetect(text); 
+        }
+
+        public void StopRemoteLangDetector()
+        {
+            if (remoteDetector != null)
+            {
+                remoteDetector.Stop();
+            }
+        }
+
+    }
+}

package/Runtime/Scripts/ML/LangDetector/HMSMLLanguageDetectionManager.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 2fc8bdac1ecb8b24bb0dae717aa30312
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Runtime/Scripts/ML/LangDetector.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 3daf579439611964387b9f42ec0e1ce8
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Runtime/Scripts/ML/MLDownloadListenerManager.cs

@@ -0,0 +1,17 @@
+using System;
+using UnityEngine;
+using static HuaweiMobileServices.ML.DownloadModel.MLModelDownloadListener;
+
+public class MLDownloadListenerManager : IMLModelDownloadListener
+{
+    public Action<long, long> OnProcessAction;
+    public MLDownloadListenerManager()
+    {
+        Debug.Log($"{this.GetType().Name} was created");
+    }
+    public void OnProcess(long total, long current)
+    {
+        OnProcessAction?.Invoke(total, current);
+    }
+
+}

package/Runtime/Scripts/ML/MLDownloadListenerManager.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 65ac1316ce8f18542b2a4a40e8cc01d1
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Runtime/Scripts/ML/TextRecognition/HMSMLTextRecognitionKitManager.cs

@@ -0,0 +1,163 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using HmsPlugin;
+using HuaweiMobileServices.Base;
+using HuaweiMobileServices.ML.Common;
+using HuaweiMobileServices.ML.TextRecognition;
+using HuaweiMobileServices.Utils;
+using UnityEngine;
+
+public class HMSMLTextRecognitionKitManager : HMSManagerSingleton<HMSMLTextRecognitionKitManager>
+{
+    private const string TAG = "[HMS] MLTextRecognitionKitManager ";
+    private readonly string apiKey;
+    private readonly int defaultUserRegion = MLApplication.REGION_DR_GERMAN;
+    private readonly int offlineDefaultDetectMode;
+    private readonly LanguageCodes offlineDefaultLanguageCode;
+    private readonly int onlineDefaultDetectMode;
+    private readonly LanguageCodes onlineDefaultLanguageCode;
+    private MLTextAnalyzer mlTextAnalyzer;
+    private bool IsTREnabled => HMSMLKitSettings.Instance.Settings.GetBool(HMSMLKitSettings.EnableTextRecognitionModule);
+    public Dictionary<LanguageCodes, string> LanguageDict { get; } = new Dictionary<LanguageCodes, string>
+    {
+        { LanguageCodes.English, "en" },
+        { LanguageCodes.Chinese, "zh" },
+        { LanguageCodes.French, "fr" },
+        { LanguageCodes.German, "de" },
+        { LanguageCodes.Italian, "it" },
+        { LanguageCodes.Japanese, "ja" },
+        { LanguageCodes.Korean, "ko" },
+        { LanguageCodes.Portuguese, "pt" },
+        { LanguageCodes.Russian, "ru" },
+        { LanguageCodes.Spanish, "es" },
+        { LanguageCodes.Polish, "pl" },
+        { LanguageCodes.Norwegian, "no" },
+        { LanguageCodes.Swedish, "sv" },
+        { LanguageCodes.Danish, "da" },
+        { LanguageCodes.Turkish, "tr" },
+        { LanguageCodes.Finnish, "fi" },
+        { LanguageCodes.Thai, "th" },
+        { LanguageCodes.Arabic, "ar" },
+        { LanguageCodes.Hindi, "hi" }
+    };
+
+    public Action<AndroidIntent, AndroidBitmap> OnImageSelectSuccess;
+    public Action<MLText> OnAnalyseFrameSuccess;
+    public Action<HMSException> OnAnalyseFrameFailure;
+
+    public HMSMLTextRecognitionKitManager()
+    {
+        if (!IsTREnabled)
+        {
+            Debug.LogError($"{TAG}Text Recognition is not enabled");
+            return;
+        }
+
+        offlineDefaultDetectMode = MLLocalTextSetting.OCR_DETECT_MODE;
+        offlineDefaultLanguageCode = LanguageCodes.English;
+        onlineDefaultDetectMode = MLRemoteTextSetting.OCR_LOOSE_SCENE;
+        onlineDefaultLanguageCode = LanguageCodes.English;
+        apiKey = HMSMLKitSettings.Instance.Settings.Get(HMSMLKitSettings.MLKeyAPI);
+
+        HMSManagerStart.Start(OnAwake, TAG);
+    }
+
+    private void OnAwake()
+    {
+        Init();
+    }
+
+    public void Init()
+    {
+        MLApplication instance = MLApplication.Initialize();
+        instance.SetApiKey(apiKey);
+        instance.SetUserRegion(defaultUserRegion);
+        Debug.Log($"{TAG}-> Init");
+    }
+
+    public void OnDeviceConfiguration(LanguageCodes? language = null, int? detectMode = null)
+    {
+        var setting = new MLLocalTextSetting.Factory()
+            .SetOCRMode(detectMode ?? offlineDefaultDetectMode)
+            .SetLanguage(LanguageDict[language ?? offlineDefaultLanguageCode])
+            .Create();
+
+        mlTextAnalyzer = MLAnalyzerFactory.Instance.GetLocalTextAnalyzer(setting);
+    }
+
+    public void OnCloudConfiguration(List<LanguageCodes> languages = null, string borderType = null)
+    {
+        languages ??= new List<LanguageCodes> { onlineDefaultLanguageCode };
+        var setting = new MLRemoteTextSetting.Factory()
+            .SetBorderType(borderType ?? MLRemoteTextSetting.ARC)
+            .SetLanguageList(languages.Select(lang => LanguageDict.TryGetValue(lang, out var value) ? value : LanguageDict[onlineDefaultLanguageCode]).ToList())
+            .SetTextDensityScene(onlineDefaultDetectMode)
+            .Create();
+
+        mlTextAnalyzer = MLAnalyzerFactory.Instance.GetRemoteTextAnalyzer(setting);
+    }
+
+    public void AnalyzeFrameAsync(MLFrame frame)
+    {
+        Debug.Log($"{TAG}Analyzing Frame {(frame == null ? "Frame is null" : "Frame is not null")}");
+        var task = mlTextAnalyzer.AnalyseFrameAsync(frame);
+
+        task.AddOnSuccessListener(result =>
+        {
+            Debug.Log($"{TAG}Text Recognition Success & Result: {result}");
+            OnAnalyseFrameSuccess?.Invoke(result);
+        }).AddOnFailureListener(exception =>
+        {
+            Debug.Log($"{TAG}Text Recognition Failed: {exception.WrappedExceptionMessage}");
+            OnAnalyseFrameFailure?.Invoke(exception);
+        });
+    }
+
+    public IList<MLText.Block> AnalyzeFrame(MLFrame frame)
+    {
+        Debug.Log($"{TAG}Analyzing Frame {(frame == null ? "Frame is null" : "Frame is not null")}");
+        var result = mlTextAnalyzer.AnalyseFrame(frame);
+        Debug.Log($"{TAG}Text Recognition Success & Result: {result}");
+        return result;
+    }
+
+    public void SelectImage()
+    {
+        AndroidToast.MakeText("Please select an image file").Show();
+        AndroidFilePicker.mOnSuccessListener = OnSuccessFilePicker;
+        AndroidFilePicker.OpenFilePicker("image/*");
+    }
+
+    private void OnSuccessFilePicker(AndroidIntent androidIntent, AndroidBitmap bitmap)
+    {
+        Debug.Log($"{TAG}FilePicker: Success: {androidIntent.GetData()?.GetPath}");
+        Debug.Log($"{TAG}FilePickerBitmap: Success: {(bitmap == null ? "null" : "not null")}");
+        OnImageSelectSuccess?.Invoke(androidIntent, bitmap);
+    }
+
+    public enum LanguageCodes
+    {
+        English,
+        Chinese,
+        French,
+        German,
+        Italian,
+        Japanese,
+        Korean,
+        Portuguese,
+        Russian,
+        Spanish,
+        Polish,
+        Norwegian,
+        Swedish,
+        Danish,
+        Turkish,
+        Finnish,
+        Thai,
+        Arabic,
+        Hindi
+    }
+
+}
+

package/Runtime/Scripts/ML/TextRecognition/HMSMLTextRecognitionKitManager.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 6e1ac60ef5ff8ad48b75b09a321e8086
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Runtime/Scripts/ML/TextRecognition.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: d6c80c8b7f29eaa49b13185e79b70fe4
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Runtime/Scripts/ML/TextToSpeech/HMSMLTextToSpeechKitManager.cs

@@ -0,0 +1,276 @@
+using HmsPlugin;
+using HuaweiMobileServices.ML.Common;
+using HuaweiMobileServices.ML.DownloadModel;
+using HuaweiMobileServices.ML.TextToSpeech;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using UnityEngine;
+public class HMSMLTextToSpeechKitManager : HMSManagerSingleton<HMSMLTextToSpeechKitManager>
+{
+    private const string TAG = "[HMS] MLTextToSpeechKitManager ";
+    public Action<long, long> OnProcessAction;
+    private readonly string API_KEY;
+    private readonly string OnlineDefaultLanguageCode;
+    private readonly string OnlineDefaultSpeakerCode;
+    private readonly string OfflineDefaultLanguageCode;
+    private readonly string OfflineDefaultSpeakerCode;
+
+    private string SelectedOfflineLanguageCode;
+    private string SelectedOfflineSpeakerCode;
+
+    private Dictionary<string, string> LanguageCodes;
+    private MLTtsConfig mlConfigs;
+    private MLTtsEngine mlTtsEngine;
+    private MLLocalModelManager mLLocalModelManager;
+    private int DefaultUserRegion = MLApplication.REGION_DR_GERMAN;
+    private string m_ttsMode;
+
+    private bool IsTTSEnable => HMSMLKitSettings.Instance.Settings.GetBool(HMSMLKitSettings.EnableTextToSpeechModule);
+    public HMSMLTextToSpeechKitManager()
+    {
+
+        if (!IsTTSEnable)
+        {
+            Debug.LogError(TAG + "TextToSpeech module is not enabled");
+            return;
+        }
+        OnlineDefaultLanguageCode = MLTtsConstants.TTS_EN_US;
+        OnlineDefaultSpeakerCode = MLTtsConstants.TTS_SPEAKER_FEMALE_EN;
+
+        OfflineDefaultLanguageCode = MLTtsConstants.TTS_EN_US;
+        OfflineDefaultSpeakerCode = MLTtsConstants.TTS_SPEAKER_OFFLINE_EN_US_FEMALE_BEE;
+
+        API_KEY = HMSMLKitSettings.Instance.Settings.Get(HMSMLKitSettings.MLKeyAPI);
+        InitLanguageCodes();
+        HMSManagerStart.Start(OnAwake, TAG);
+    }
+    private void OnAwake()
+    {
+        Init();
+    }
+
+    public void Init()
+    {
+        MLApplication instance = MLApplication.Initialize();
+        instance.SetApiKey(API_KEY);
+        instance.SetUserRegion(DefaultUserRegion);
+        Debug.Log(TAG + "-> Init");
+    }
+
+    private void InitLanguageCodes()
+    {
+        LanguageCodes = new Dictionary<string, string>
+        {
+            { MLTtsConstants.TTS_SPEAKER_FEMALE_EN, MLTtsConstants.TTS_EN_US },     // English
+            { MLTtsConstants.TTS_SPEAKER_FEMALE_EN_2, MLTtsConstants.TTS_EN_US },   // English
+            { MLTtsConstants.TTS_SPEAKER_MALE_EN, MLTtsConstants.TTS_EN_US },       // English
+            { MLTtsConstants.TTS_SPEAKER_MALE_EN_2, MLTtsConstants.TTS_EN_US },     // English
+            { MLTtsConstants.TTS_SPEAKER_FEMALE_TR, MLTtsConstants.TTS_LAN_TR_TR }, // Turkish
+            { MLTtsConstants.TTS_SPEAKER_FEMALE_AR, MLTtsConstants.TTS_LAN_AR_AR }, // Arabic
+            { MLTtsConstants.TTS_SPEAKER_MALE_ZH, MLTtsConstants.TTS_ZH_HANS },     // Chinese
+            { MLTtsConstants.TTS_SPEAKER_MALE_ZH_2, MLTtsConstants.TTS_ZH_HANS },   // Chinese
+            { MLTtsConstants.TTS_SPEAKER_FEMALE_ZH, MLTtsConstants.TTS_ZH_HANS },   // Chinese
+            { MLTtsConstants.TTS_SPEAKER_FEMALE_ZH_2, MLTtsConstants.TTS_ZH_HANS }, // Chinese
+            { MLTtsConstants.TTS_SPEAKER_FEMALE_DE, MLTtsConstants.TTS_LAN_DE_DE }, // German
+            { MLTtsConstants.TTS_SPEAKER_FEMALE_ES, MLTtsConstants.TTS_LAN_ES_ES }, // Spanish
+            { MLTtsConstants.TTS_SPEAKER_FEMALE_FR, MLTtsConstants.TTS_LAN_FR_FR }, // French
+            { MLTtsConstants.TTS_SPEAKER_FEMALE_IT, MLTtsConstants.TTS_LAN_IT_IT }, // Italian
+            { MLTtsConstants.TTS_SPEAKER_FEMALE_MS, MLTtsConstants.TTS_LAN_MS_MS }, // Malay
+            { MLTtsConstants.TTS_SPEAKER_FEMALE_PL, MLTtsConstants.TTS_LAN_PL_PL }, // Polish
+            { MLTtsConstants.TTS_SPEAKER_FEMALE_RU, MLTtsConstants.TTS_LAN_RU_RU }, // Russian
+            { MLTtsConstants.TTS_SPEAKER_FEMALE_TH, MLTtsConstants.TTS_LAN_TH_TH }, // Thai
+            { MLTtsConstants.TTS_SPEAKER_OFFLINE_EN_US_MALE_EAGLE, MLTtsConstants.TTS_EN_US },      // English
+            { MLTtsConstants.TTS_SPEAKER_OFFLINE_EN_US_FEMALE_BEE, MLTtsConstants.TTS_EN_US },  // English
+            { MLTtsConstants.TTS_SPEAKER_OFFLINE_EN_US_FEMALE_EAGLE, MLTtsConstants.TTS_EN_US },    // English
+            { MLTtsConstants.TTS_SPEAKER_OFFLINE_EN_US_FEMALE_BOLT, MLTtsConstants.TTS_EN_US },     // English
+            { MLTtsConstants.TTS_SPEAKER_OFFLINE_EN_US_FEMALE_FLY, MLTtsConstants.TTS_EN_US },      // English
+            { MLTtsConstants.TTS_SPEAKER_OFFLINE_EN_US_MALE_BOLT, MLTtsConstants.TTS_EN_US },       // English
+            { MLTtsConstants.TTS_SPEAKER_OFFLINE_DE_DE_FEMALE_FLY, MLTtsConstants.TTS_LAN_DE_DE },  // German
+            { MLTtsConstants.TTS_SPEAKER_OFFLINE_DE_DE_FEMALE_BEE, MLTtsConstants.TTS_LAN_DE_DE },  // German
+            { MLTtsConstants.TTS_SPEAKER_OFFLINE_ES_ES_FEMALE_BEE, MLTtsConstants.TTS_LAN_ES_ES },  // Spanish
+            { MLTtsConstants.TTS_SPEAKER_OFFLINE_ES_ES_FEMALE_FLY, MLTtsConstants.TTS_LAN_ES_ES },  // Spanish
+            { MLTtsConstants.TTS_SPEAKER_OFFLINE_IT_IT_FEMALE_FLY, MLTtsConstants.TTS_LAN_IT_IT },  // Italian
+            { MLTtsConstants.TTS_SPEAKER_OFFLINE_IT_IT_FEMALE_BEE, MLTtsConstants.TTS_LAN_IT_IT },  // Italian
+            { MLTtsConstants.TTS_SPEAKER_OFFLINE_FR_FR_FEMALE_BEE, MLTtsConstants.TTS_LAN_FR_FR },  // French
+            { MLTtsConstants.TTS_SPEAKER_OFFLINE_FR_FR_FEMALE_FLY, MLTtsConstants.TTS_LAN_FR_FR },  // French
+            { MLTtsConstants.TTS_SPEAKER_OFFLINE_RU_RU_FEMALE_FLY, MLTtsConstants.TTS_LAN_RU_RU },  // Russian
+            { MLTtsConstants.TTS_SPEAKER_OFFLINE_AR_AR_FEMALE_FLY, MLTtsConstants.TTS_LAN_AR_AR },  // Arabic
+            { MLTtsConstants.TTS_SPEAKER_OFFLINE_TH_TH_FEMALE_FLY, MLTtsConstants.TTS_LAN_TH_TH },  // Thai
+            { MLTtsConstants.TTS_SPEAKER_OFFLINE_ZH_HANS_FEMALE_BOLT, MLTtsConstants.TTS_ZH_HANS }, // Chinese
+            { MLTtsConstants.TTS_SPEAKER_OFFLINE_ZH_HANS_MALE_BOLT, MLTtsConstants.TTS_ZH_HANS },   // Chinese
+            { MLTtsConstants.TTS_SPEAKER_OFFLINE_ZH_HANS_FEMALE_EAGLE, MLTtsConstants.TTS_ZH_HANS }, // Chinese
+            { MLTtsConstants.TTS_SPEAKER_OFFLINE_ZH_HANS_MALE_EAGLE, MLTtsConstants.TTS_ZH_HANS }, // Chinese
+        };
+    }
+
+    public void Configurations(string ttsMode)
+    {
+        Debug.Log(TAG + $"-> Configurations {ttsMode}");
+        m_ttsMode = ttsMode;
+        mlConfigs = new MLTtsConfig()
+            .SetLanguage(ttsMode == MLTtsConstants.TTS_ONLINE_MODE ? OnlineDefaultLanguageCode : OfflineDefaultLanguageCode)
+            .SetPerson(ttsMode == MLTtsConstants.TTS_ONLINE_MODE ? OnlineDefaultSpeakerCode : OfflineDefaultSpeakerCode)
+            .SetSynthesizeMode(ttsMode);
+
+        if (ttsMode == MLTtsConstants.TTS_ONLINE_MODE)
+        {
+            mlConfigs.SetSpeed(1.0f).SetVolume(1.0f);
+        }
+
+        mlTtsEngine = new MLTtsEngine(mlConfigs);
+
+        var listener = new MLTtsCallback(new MLTextToSpeechListenerManager());
+
+        mlTtsEngine.SetTtsCallback(listener);
+
+        if (m_ttsMode == MLTtsConstants.TTS_ONLINE_MODE)
+        {
+            mlTtsEngine.SetPlayerVolume(20);
+        }
+
+        mlTtsEngine.UpdateConfig(mlConfigs);
+
+        if (m_ttsMode == MLTtsConstants.TTS_OFFLINE_MODE)
+        {
+            OnDeviceModelManager();
+        }
+    }
+
+    public void SetLanguage(string languageCode)
+    {
+        Debug.Log(TAG + "-> SetLanguage: " + languageCode);
+        mlConfigs.SetLanguage(languageCode);
+        mlTtsEngine.UpdateConfig(mlConfigs);
+    }
+
+    public void SetSpeaker(string speakerCode)
+    {
+        mlConfigs.SetPerson(speakerCode);
+        Debug.Log(TAG + "-> SetSpeaker: " + speakerCode);
+        var languageCode = LanguageCodes.FirstOrDefault(x => x.Key.ToLowerInvariant() == speakerCode).Value;
+        SetLanguage(languageCode);
+        mlTtsEngine.UpdateConfig(mlConfigs);
+
+        if (m_ttsMode == MLTtsConstants.TTS_OFFLINE_MODE)
+        {
+            SelectedOfflineSpeakerCode = speakerCode;
+            OnDeviceModelManager();
+        }
+    }
+
+    public void SetSpeed(float speed)
+    {
+        mlConfigs.SetSpeed(speed);
+        mlTtsEngine.UpdateConfig(mlConfigs);
+    }
+
+    public void SetVolume(float volume)
+    {
+        mlConfigs.SetVolume(volume);
+        mlTtsEngine.UpdateConfig(mlConfigs);
+    }
+
+    public void Stop()
+    {
+        mlTtsEngine.Stop();
+    }
+
+    public void Shutdown()
+    {
+        mlTtsEngine.Shutdown();
+    }
+
+    public string Speak(string text, int playMode)
+    {
+        // Check if ttsMode is online and internet is not available
+        if (m_ttsMode == MLTtsConstants.TTS_ONLINE_MODE && !IsInternetAvailable())
+        {
+            var error = "Speak Error: Internet connection is not available for online TTS mode.";
+            Debug.LogError(TAG + "->" + error);
+            return null;
+        }
+
+        try
+        {
+            Debug.Log(TAG + "-> Speak Mode " + mlConfigs.GetSynthesizeMode());
+            var result = mlTtsEngine.Speak(text.Trim(), playMode);
+            return result;
+        }
+        catch (Exception e)
+        {
+            Debug.LogError(TAG + "-> Speak Error: " + e.Message);
+            return null;
+        }
+    }
+
+    public void Pause()
+    {
+        mlTtsEngine.Pause();
+    }
+
+    public void Resume()
+    {
+        mlTtsEngine.Resume();
+    }
+
+    public List<MLTtsSpeaker> GetSpeakers()
+    {
+        return mlTtsEngine.GetSpeakers().ToList();
+    }
+
+    public void OnDeviceModelManager()
+    {
+        var offlineSpeaker = SelectedOfflineSpeakerCode ?? OfflineDefaultSpeakerCode;
+        // Create an on-device TTS model manager.
+        mLLocalModelManager = MLLocalModelManager.Instance;
+        // Create an MLTtsLocalModel instance to set the speaker so that the language model corresponding to the speaker can be downloaded through the model manager.
+        MLTtsLocalModel model = new MLTtsLocalModel.Factory(offlineSpeaker).Create();
+
+        // Check whether the model corresponding to the speaker has been downloaded. If not, download the model.
+        mLLocalModelManager.IsModelExist(model).AddOnSuccessListener((result) =>
+        {
+            bool isExist = result;
+            if (!isExist)
+            {
+                Debug.Log($"{TAG} -> Model does not exist, downloading {offlineSpeaker}");
+                DownloadModel(model);
+            }
+            else
+            {
+                Debug.Log($"{TAG} -> Model exists, {offlineSpeaker}");
+            }
+        }).AddOnFailureListener((exception) =>
+        {
+            Debug.Log($"{TAG} -> IsModelExist Failed: {exception.Message}");
+        });
+    }
+
+    private void DownloadModel(MLTtsLocalModel model)
+    {
+        // Create a download policy configurator. You can set that when any of the following conditions is met, the model can be downloaded: 1. The device is charging; 2. Wi-Fi is connected; 3. The device is idle.
+        MLModelDownloadStrategy request = new MLModelDownloadStrategy.Factory().NeedWifi().Create();
+
+        var listenerInstance = new MLDownloadListenerManager
+        {
+            OnProcessAction = OnProcessAction
+        };
+        var listener = new MLModelDownloadListener(listenerInstance);
+
+        // Register the download listener.
+        mLLocalModelManager.DownloadModel(model, request, listener).AddOnSuccessListener((result) =>
+        {
+            mlTtsEngine.UpdateConfig(mlConfigs);
+            Debug.Log($"{TAG} -> Model downloaded successfully - > {model.ModelName}");
+        }).AddOnFailureListener((exception) =>
+        {
+            Debug.Log($"{TAG} -> DownloadModel Failed: {exception.WrappedExceptionMessage}");
+        });
+    }
+    private bool IsInternetAvailable()
+    {
+        return Application.internetReachability != NetworkReachability.NotReachable;
+    }
+
+
+}