com.amanotes.gdk 0.2.12 → 0.2.14

package/CHANGELOG.md

@@ -1,5 +1,14 @@
 # Changelog
 
+## [0.2.14 - 2023-08-08]
+### Support multiple embed remote config and load config by id
+### Clear cached remote config on new app update
+### Override remote config value in editor mode
+### New feature: Analytics Quality
+
+## [0.2.13 - 2023-07-20]
+### Fix error Remote Config JSON caused by special chars (", ', \)
+
 ## [0.2.12 - 2023-07-07]
 ### Restructure GDK - symlink GDK source to unity projects
 ### Unity 2019 compatible - no null coalescing

package/Editor/AmaGDKEditor.cs

@@ -3,6 +3,7 @@ using System.Text;
 using Amanotes.Core;
 using Amanotes.Core.Internal;
 using System.Collections.Generic;
+using System.IO;
 using UnityEditor;
 using UnityEngine;
 using static Amanotes.Core.Internal.Logging;
@@ -23,6 +24,8 @@ namespace Amanotes.Editor
         private static bool showConfigDetail;
         private static bool showAdapterInstaller;
         private static bool showExampleDetail;
+        private bool adapterScanned;
+        private readonly List<string> lstAdapter = new List<string>();
 
         public static Color btnColor;
         public static float btnLerp;
@@ -119,14 +122,28 @@ namespace Amanotes.Editor
             EditorGUILayout.ObjectField(configAsset, configAsset.GetType(), false);
         }
 
+        private void UpdateListAdapter()
+        {
+            if(adapterScanned)
+                return;
+            
+            adapterScanned = true;
+            
+            var adapterPath = Directory.GetFiles(Res.PACKAGE_PATH, "*Adapter*.unitypackage", SearchOption.AllDirectories);
+
+            for (int i = 0; i < adapterPath.Length; i++)
+            {
+                lstAdapter.Add(Path.GetFileName(adapterPath[i]));
+            }
+        }
         private void DrawGUI_AdapterList()
         {
-            for (var i = 0; i < Res.AMAGDK_ADAPTERS.Length; i++)
+            UpdateListAdapter();
+            foreach (var adapter in lstAdapter)
             {
-                string adapterName = Res.AMAGDK_ADAPTERS[i];
-                if (GUILayout.Button(ObjectNames.NicifyVariableName(adapterName)))
+                if (GUILayout.Button(ObjectNames.NicifyVariableName(adapter)))
                 {
-                    var package = $"{Res.PACKAGE_PATH}{adapterName}.unitypackage";
+                    var package = $"{Res.PACKAGE_PATH}{adapter}";
                     AssetDatabase.ImportPackage(package, false);
                 }
             }

package/Editor/AssemblyInfo.cs

@@ -0,0 +1,5 @@
+using System.Runtime.CompilerServices;
+
+#if UNITY_EDITOR
+[assembly: InternalsVisibleTo("AmaGDK.Dev.Editor")]
+#endif

package/Editor/AssemblyInfo.cs.meta

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

package/Editor/EmbedRemoteConfigAssetInspector.cs

@@ -0,0 +1,191 @@
+using System;
+using System.Text;
+using Amanotes.Core.Internal;
+using UnityEditor;
+using UnityEngine;
+
+using static Amanotes.Core.Internal.Logging;
+
+namespace Amanotes.Editor
+{
+    [CustomEditor(typeof(EmbedRemoteConfigAsset))]
+    internal class EmbedRemoteConfigAssetInspector : UnityEditor.Editor
+    {
+        private EmbedRemoteConfigAsset remoteConfigAsset;
+        private SerializedProperty overrideInEditorProperty;
+        private SerializedProperty overrideConfigProperty;
+        private SerializedProperty configsProperty;
+        private bool[] foldouts;
+        
+        private void OnEnable()
+        {
+            remoteConfigAsset = (EmbedRemoteConfigAsset)target;
+            overrideInEditorProperty = serializedObject.FindProperty("overrideInEditor");
+            overrideConfigProperty = serializedObject.FindProperty("overrideConfig");
+            configsProperty = serializedObject.FindProperty("configs");
+            foldouts = new bool[configsProperty.arraySize];
+        }
+
+        public override void OnInspectorGUI()
+        {
+            EditorGUILayout.BeginHorizontal();
+            EditorGUILayout.LabelField("Active Id:");
+            EditorGUILayout.LabelField(remoteConfigAsset.activeId);
+            EditorGUILayout.EndHorizontal();
+            
+            serializedObject.Update();
+            
+            DrawPropertiesExcluding(serializedObject, "m_Script", "activeId", "configs", "overrideConfig");
+            
+            if (overrideInEditorProperty.boolValue)
+            {
+                EditorGUILayout.PropertyField(overrideConfigProperty);
+            }
+            
+            if (GUILayout.Button("Add a config set"))
+            {
+                configsProperty.arraySize++;
+                int lastIndex = configsProperty.arraySize - 1;
+                var config= configsProperty.GetArrayElementAtIndex(lastIndex);
+                config.FindPropertyRelative("id").stringValue = $"config{lastIndex}";
+                foldouts = AddElementToArray(foldouts, false);
+            }
+            
+            for (int i = 0; i < configsProperty.arraySize; i++)
+            {
+                SerializedProperty configProperty = configsProperty.GetArrayElementAtIndex(i);
+                SerializedProperty idProperty = configProperty.FindPropertyRelative("id");
+                SerializedProperty fetchUrlProperty = configProperty.FindPropertyRelative("fetchUrl");
+                SerializedProperty itemsProperty = configProperty.FindPropertyRelative("items");
+
+                EditorGUILayout.BeginVertical(GUI.skin.box);
+                foldouts[i] = EditorGUILayout.Foldout(foldouts[i], idProperty.stringValue);
+                if (foldouts[i])
+                {
+                    EditorGUI.indentLevel++;
+                    EditorGUILayout.BeginHorizontal();
+                    if (GUILayout.Button("Set active", GUILayout.MinWidth(100)))
+                    {
+                        remoteConfigAsset.SetActiveConfig(idProperty.stringValue);
+                    }
+                    if (GUILayout.Button("Fetch", GUILayout.MinWidth(80)))
+                    {
+                        var url = fetchUrlProperty.stringValue;
+                        var currentConfigIndex = i;
+                        if (string.IsNullOrWhiteSpace(url))
+                        {
+                            ShowError("Please fill the fetch URL first");
+                        }
+                        else
+                        {
+                            WebRequest.Get(url, onProgress: FetchProgress, onSuccess: s => FillEmbedConfig(currentConfigIndex, s), onError:ShowError);
+                        }
+                    }
+                    if (GUILayout.Button("Remove", GUILayout.MinWidth(80)))
+                    {
+                        if (remoteConfigAsset.ActiveConfig?.id == idProperty.stringValue)
+                        {
+                            remoteConfigAsset.SetActiveConfig(string.Empty);
+                        }
+                        configsProperty.DeleteArrayElementAtIndex(i);
+                        foldouts = RemoveElementAtIndex(foldouts, i);
+                    }
+                    if (GUILayout.Button("Copy", GUILayout.MinWidth(80)))
+                    {
+                        GUIUtility.systemCopyBuffer = KeyValueToText(itemsProperty);
+                    }
+                    if (GUILayout.Button("Paste", GUILayout.MinWidth(80)))
+                    {
+                        FillEmbedConfig(i, GUIUtility.systemCopyBuffer);
+                    }
+                    EditorGUILayout.EndHorizontal();
+                    EditorGUILayout.PropertyField(idProperty);
+                    EditorGUILayout.PropertyField(fetchUrlProperty);
+                    EditorGUILayout.PropertyField(itemsProperty);
+
+                    EditorGUI.indentLevel--;
+                }
+                EditorGUILayout.EndVertical();
+            }
+            
+            serializedObject.ApplyModifiedProperties();
+        }
+        
+        private T[] AddElementToArray<T>(T[] array, T element)
+        {
+            T[] newArray = new T[array.Length + 1];
+            array.CopyTo(newArray, 0);
+            newArray[array.Length] = element;
+            return newArray;
+        }
+
+        private T[] RemoveElementAtIndex<T>(T[] array, int index)
+        {
+            T[] newArray = new T[array.Length - 1];
+            for (int i = 0, j = 0; i < array.Length; i++)
+            {
+                if (i != index)
+                {
+                    newArray[j] = array[i];
+                    j++;
+                }
+            }
+            return newArray;
+        }
+
+        private void FetchProgress(float progress)
+        {
+            EditorUtility.DisplayProgressBar("Fetching default remote config", "Please wait...", progress);
+        }
+        
+        private void FillEmbedConfig(int configIndex, string rawText)
+        {
+            try
+            {
+                string[] lines = rawText.Split("\n");
+                KeyValue[] arrKeyValue = new KeyValue[lines.Length];
+                for (int i = 0; i < lines.Length; i++)
+                {
+                    var line = lines[i];
+                    var idx = line.IndexOf('\t');
+                    if (idx == -1)
+                    {
+                        LogWarning($"[RemoteConfig] Cannot get (key, value) at line {i+1}. Content:\n<{line}>");
+                        continue;
+                    }
+                    arrKeyValue[i] = new KeyValue
+                    {
+                        key = line.Substring(0, idx),
+                        value = line.Substring(idx + 1)
+                    };
+                }
+                remoteConfigAsset.configs[configIndex].items = arrKeyValue;
+            }
+            catch (Exception e)
+            {
+                LogWarning(e.Message);
+            }
+            finally
+            {
+                EditorUtility.ClearProgressBar();
+            }
+        }
+
+        private string KeyValueToText(SerializedProperty items)
+        {
+            StringBuilder sb = new StringBuilder();
+            for (int i = 0; i < items.arraySize; i++)
+            {
+                SerializedProperty c = items.GetArrayElementAtIndex(i);
+                sb.AppendLine($"{c.FindPropertyRelative("key").stringValue}\t{c.FindPropertyRelative("value").stringValue}");
+            }
+            return sb.ToString();
+        }
+
+        private void ShowError(string error)
+        {
+            EditorUtility.ClearProgressBar();
+            EditorUtility.DisplayDialog("Error", error, "OK");
+        }
+    }
+}

package/Editor/EmbedRemoteConfigAssetInspector.cs.meta

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

package/Editor/Utils/AmaGDKEditor.Utils.cs

@@ -1,7 +1,10 @@
 using System;
 using System.Collections;
+using System.Collections.Generic;
 using UnityEditor;
 using UnityEngine;
+using UnityEngine.Networking;
+
 namespace Amanotes.Editor
 {
     internal static class Utils
@@ -31,4 +34,50 @@ namespace Amanotes.Editor
             EditorApplication.update += closureCallback;
         }
     }
+
+    internal static class WebRequest
+    {
+        internal static void Get(string url, Dictionary<string, string> headers = null, Action<float> onProgress = null, Action<string> onSuccess = null, Action<string> onError = null)
+        {
+            GetCoroutine(url, headers, onProgress, onSuccess, onError).StartEditorCoroutine();
+        }
+
+        private static IEnumerator GetCoroutine(string url, Dictionary<string, string> headers = null, Action<float> onProgress = null, Action<string> onSuccess = null, Action<string> onError = null)
+        {
+            using var request = UnityWebRequest.Get(url);
+            // Add headers to the request
+            if (headers != null)
+            {
+                foreach (var header in headers)
+                {
+                    request.SetRequestHeader(header.Key, header.Value);
+                }
+            }
+
+            // Send the request
+            request.timeout = 60;
+            yield return request.SendWebRequest();
+
+            while (request.isDone == false)
+            {
+                onProgress?.Invoke(request.downloadProgress);
+                yield return null;
+            }
+
+            // Check for errors
+#pragma warning disable CS0618
+            if (request.isNetworkError || request.isHttpError)
+#pragma warning restore CS0618
+            {
+                Debug.LogError("Error: " + request.error);
+                onError?.Invoke(request.error);
+            }
+            else
+            {
+                // Process the response
+                string responseText = request.downloadHandler.text;
+                onSuccess?.Invoke(responseText);
+            }
+        }
+    }
 }

package/Runtime/AmaGDK.Ads.cs

@@ -85,7 +85,7 @@ namespace Amanotes.Core
             public AdStat interstitial = new AdStat();
             public AdStat reward = new AdStat();
 
-            internal int GetLastShowInSeconds(AdType adType)
+            internal int TimeSinceLastShow(AdType adType)
             {
                 return (int)(Time.realtimeSinceStartup - (adType == AdType.Interstitial ? interstitial.lastSuccessTime : reward.lastSuccessTime));
             }
@@ -138,11 +138,11 @@ namespace Amanotes.Core
                 _adapter?.rewardVideo.StartLoadAd();
             }
 
-            public static bool hasInterstitial => _adapter.interstitial.hasAd;
-            public static bool hasRewardedVideo => _adapter.rewardVideo.hasAd;
-            public static bool showingBanner => _showingBanner;
-            public static bool showingAd => context != null;
-
+            public static bool HasInterstitial => _adapter.interstitial.hasAd;
+            public static bool HasRewardedVideo => _adapter.rewardVideo.hasAd;
+            public static bool IsBannerShowing => _isBannerShowing;
+            public static bool IsAdShowing => context != null;
+            
             private static bool ClearPrevContext()
             {
                 if (context == null) return true;
@@ -176,6 +176,15 @@ namespace Amanotes.Core
                 return context;
             }
 
+            public static bool IsInterstitialShowing
+            {
+                get
+                {
+                    if (context == null)  return false;
+                    return context.adType == AdType.Interstitial;
+                }
+            }
+
             public static IAdCallback ShowRewardedVideo(string placementName = null, Dictionary<string, object> userData = null)
             {
                 if (!ClearPrevContext()) return null;
@@ -184,19 +193,36 @@ namespace Amanotes.Core
                 _adapter.rewardVideo.StartShowAd();
                 return context;
             }
+            
+            public static bool IsRewardedVideoShowing
+            {
+                get
+                {
+                    if (context == null)  return false;
+                    return context.adType == AdType.VideoReward;
+                }
+            }
 
-            private static bool _showingBanner;
-            public static void ShowBanner()
+            private static bool _isBannerShowing;
+            public static void ShowBanner(BannerPosition? bannerPosition = null)
             {
-                if (_showingBanner) return;
-                _showingBanner = true;
-                _adapter.ShowBanner(_adConfig.bannerPosition);
+                if (_isBannerShowing) return;
+                _isBannerShowing = true;
+
+                if (bannerPosition.HasValue)
+                {
+                    _adapter.ShowBanner(bannerPosition.Value);
+                }
+                else
+                {
+                    _adapter.ShowBanner(_adConfig.bannerPosition);
+                }
             }
 
             public static void HideBanner()
             {
-                if (!_showingBanner) return;
-                _showingBanner = false;
+                if (!_isBannerShowing) return;
+                _isBannerShowing = false;
                 _adapter.HideBanner();
             }
 
@@ -210,6 +236,12 @@ namespace Amanotes.Core
                 else
                     _adapter.rewardVideo.StopShowAd();
             }
+
+            public static int TimeSinceLastInterstitial => localData.TimeSinceLastShow(AdType.Interstitial);
+            
+            public static int TimeSinceLastVideoReward => localData.TimeSinceLastShow(AdType.VideoReward);
+            
+            public static int TimeSinceLastAd => Math.Min(TimeSinceLastInterstitial, TimeSinceLastVideoReward) ;
         }
     }
 }
@@ -287,7 +319,7 @@ namespace Amanotes.Core.Internal
         // Stats
         public float showCallAt;
         public float showFinishAt;
-
+        
         public ShowAdContext(AdType adType, string placementName, Dictionary<string, object> userData)
         {
             this.adType = adType;

package/Runtime/AmaGDK.Analytics.cs

@@ -301,7 +301,8 @@ namespace Amanotes.Core
             internal static void ProcessEventQueue()
             {
                 if (eventQueue.Count <= 0) return;
-                bool showAnalyticsLog = Config.common.showAnalyticsLog;
+                SDKConfig common = Config.common;
+                bool showAnalyticsLog = common.showAnalyticsLog;
                 sessionStat.ClearLastFrameEventInfo();
 
                 while (eventQueue.Count > 0)
@@ -317,9 +318,11 @@ namespace Amanotes.Core
                     }
 
                     string eventNameToSend = GetEventNameToSend(eventData.eventName, countInSession, totalCount);
-                    if (Config.common.normalizeEventName) NormalizeEventName(ref eventNameToSend);
+                    if (common.normalizeEventName) NormalizeEventName(ref eventNameToSend);
 
-					if (showAnalyticsLog) Debug.Log($"AmaGDK | Event <{eventNameToSend}> (in session: {countInSession}, total: {totalCount})\n{JsonUtils.DictionaryToJson(eventData.parameters, true)}");
+                    if (showAnalyticsLog) Debug.Log($"AmaGDK | Event <{eventNameToSend}> (in session: {countInSession}, total: {totalCount})\n{JsonUtils.DictionaryToJson(eventData.parameters, true)}");
+                    
+                    common.quality.CheckEventQuality(eventData.eventName, eventData.parameters);
 
                     var inUseAdapterIDs = new List<string>();
                     foreach (AdapterContext m in listAdapters)
@@ -585,7 +588,7 @@ namespace Amanotes.Core
                         contents.AppendLine(stat.ToTsv());
                     }
 
-                    FileUtils.SaveAppend(fileName, contents.ToString());
+                    GDKFileUtils.SaveAppend(fileName, contents.ToString());
                 }
             }
         }
@@ -731,12 +734,28 @@ namespace Amanotes.Core
 
 namespace Amanotes.Core.Internal
 {
+    [Serializable]
+    public class AnalyticQualityConfig
+    {
+        public bool enable = false;
+        public AnalyticQualityAsset qualityAsset;
+        
+        public void CheckEventQuality(string eventName, Dictionary<string, object> parameters)
+        {
+            if (enable && qualityAsset != null)
+            {
+                qualityAsset.CheckEventQuality(eventName, parameters);
+            }
+        }
+    }
+
     public partial class SDKConfig
     {
         public bool showAnalyticsLog = true;
         public bool normalizeEventName = true;
         public bool checkMigrationIntegrity = true;
         public bool enableEventStat;
+        public AnalyticQualityConfig quality;
     }
 
     public interface IAnalyticAdapter

package/Runtime/AmaGDK.Internal.cs

@@ -40,15 +40,6 @@ namespace Amanotes.Core.Internal
         public const string AMAGDK_PREFAB = BASE_PATH + "Runtime/AmaGDK.prefab";
         public const string AMAGDK_CONFIG_PACKAGE = PACKAGE_PATH + "AmaGDKConfig.unitypackage";
 
-        public static readonly string[] AMAGDK_ADAPTERS =
-        {
-            "FirebaseAnalyticsAdapter_v9.1.0",
-            "AppsFlyerAdapter_v6.5.4",
-            "AdjustAdapter_v4.33.0",
-            "IronsourceAdapter_v7.2.6",
-            "FirebaseRemoteConfigAdapter_v9.1.0"            
-        };
-
 #if UNITY_EDITOR
 
         [MenuItem("GameObject/AmaGDK/Add AmaGDK Prefab", false, 10)]

package/Runtime/AmaGDK.RemoteConfig.cs

@@ -16,8 +16,7 @@ namespace Amanotes.Core
     {
         public enum RemoteConfigSource
         {
-            DefaultAsset,
-            DefaultFile,
+            EmbedConfig,
             Cache,
             Internet
         }
@@ -26,7 +25,7 @@ namespace Amanotes.Core
         public partial class RemoteConfig //Public
         {
             public static Action<bool> onFetchCompleted;
-            public static Dictionary<string, string> DictConfig { get { return dictConfig; } }
+            public static Dictionary<string, string> DictConfig => dictConfig;
             public static RemoteConfigSource Source { private set; get; }
             static bool? _cacheExisted = null;
             public static bool HasCache
@@ -34,7 +33,7 @@ namespace Amanotes.Core
                 get
                 {
                     if (_cacheExisted == null)
-                        _cacheExisted = FileUtils.Exist(fileName);
+                        _cacheExisted = GDKFileUtils.Exist(fileName);
                     return _cacheExisted.GetValueOrDefault();
                 }
             }
@@ -64,6 +63,15 @@ namespace Amanotes.Core
 
             public static T Get<T>(string key, T defaultValue = default(T))
             {
+#if UNITY_EDITOR
+                //Override value in editor environment
+                if (adapterConfig.embedRemoteConfig.overrideInEditor)
+                {
+                    foreach (var c in adapterConfig.embedRemoteConfig.overrideConfig)
+                        if (c.key == key)
+                            return (T)Convert.ChangeType(c.value, typeof(T));
+                }
+#endif
                 if (dictConfig.ContainsKey(key))
                     return (T)Convert.ChangeType(dictConfig[key], typeof(T));
                 return defaultValue;
@@ -78,6 +86,13 @@ namespace Amanotes.Core
             {
                 return JsonUtils.DictionaryToJson(dictConfig);
             }
+
+            public static void SetActiveEmbedConfig(string id)
+            {
+                if (adapterConfig == null || adapterConfig.embedRemoteConfig == null)
+                    LogWarning("[RemoteConfig] No embed remote config available");
+                adapterConfig.embedRemoteConfig.SetActiveConfig(id);
+            }
         }
 
         public partial class RemoteConfig //Internal
@@ -91,7 +106,7 @@ namespace Amanotes.Core
                 SaveCache,
 
                 LoadCache,
-                LoadDefaultAsset,
+                LoadEmbedConfig,
 
                 Success,
                 Fail
@@ -100,9 +115,15 @@ namespace Amanotes.Core
             static Dictionary<string, string> dictConfig = new Dictionary<string, string>();
             static string fileName = $"{nameof(RemoteConfig)}.kv";            
             static string base64Prefix = "base64:";
+            const string VERSION_PREFIX = "version:";
+            static int EmbedVersion =>
+                adapterConfig != null && adapterConfig.embedRemoteConfig != null
+                    ? adapterConfig.embedRemoteConfig.version
+                    : 1;
 
             static FetchState _state = FetchState.None;
-            internal static FetchState State { get { return _state; } }
+            internal static FetchState State => _state;
+
             static readonly Dictionary<FetchState, Action[]> fetchSM = new Dictionary<FetchState, Action[]>
             {
                 { FetchState.None,                new Action[]{ ResolveDependency }},
@@ -110,8 +131,8 @@ namespace Amanotes.Core
                 { FetchState.CheckInternet,       new Action[]{ LoadCache, Fetch}},
                 { FetchState.Fetch,               new Action[]{ LoadCache, SaveCache}},
                 { FetchState.SaveCache,           new Action[]{ SetDone }},
-                { FetchState.LoadCache,           new Action[]{ LoadDefaultAsset, SetDone}},
-                { FetchState.LoadDefaultAsset,    new Action[]{ SetFail, SetDone}}
+                { FetchState.LoadCache,           new Action[]{ LoadEmbedConfig, SetDone}},
+                { FetchState.LoadEmbedConfig,      new Action[]{ SetFail, SetDone}}
             };
 
             internal static IRemoteConfig adapter;
@@ -177,30 +198,17 @@ namespace Amanotes.Core
             {
                 _state = FetchState.SaveCache;
                 StringBuilder sb = new StringBuilder();
-
-                
-                bool needUpdateDefault = Application.isEditor && adapterConfig.autoUpdateDefaultValue;
-                List<KeyValue> list = needUpdateDefault ? new List<KeyValue>() : null;
                 
+                //Add embedded remote config version to force load from embedded config after app update
+                sb.AppendLine($"{VERSION_PREFIX}{EmbedVersion}");
+
                 foreach (var c in dictConfig)
                 {
                     sb.AppendLine($"{c.Key}\t{Encode(c.Value)}");
-                    if (!needUpdateDefault) continue;
-                    list.Add(new KeyValue() { key = c.Key, value = c.Value });
-                }
-                
-                #if UNITY_EDITOR
-                if (needUpdateDefault)
-                {
-                    list.Sort((item1, item2) => string.Compare(item1.key, item2.key, StringComparison.Ordinal));
-                    adapterConfig.defaultValue = list.ToArray();
-                    EditorUtility.SetDirty(_config);
-                    Log($"[RemoteConfig] Updated default remote config!");
                 }
-                #endif
                 
-                string filePath = FileUtils.GetPath(fileName);
-                FileUtils.Save(filePath, sb.ToString());
+                string filePath = GDKFileUtils.GetPath(fileName);
+                GDKFileUtils.Save(filePath, sb.ToString());
                 Log($"[RemoteConfig] Saved remote config to {filePath}");
                 NextState();
             }
@@ -218,17 +226,34 @@ namespace Amanotes.Core
                 try
                 {
                     dictConfig.Clear();
-                    using (StreamReader sr = new StreamReader(FileUtils.GetPath(fileName)))
+                    using (StreamReader sr = new StreamReader(GDKFileUtils.GetPath(fileName)))
                     {
+                        //Check new app update
+                        string firstLine = sr.ReadLine();
+                        if (firstLine == null)
+                        {
+                            NextState(false);
+                            return;
+                        }
+                        if (ShouldClearCache(firstLine))
+                        {
+                            GDKFileUtils.Delete(fileName);
+                            string oldVersion = firstLine.StartsWith(VERSION_PREFIX) ? firstLine : "<none>";
+                            Log($"[RemoteConfig] Cached remote config cleared due to embed version changed:\n{oldVersion} -> {EmbedVersion}");
+                            NextState(false);
+                            return;
+                        }
+                        
+                        //Read key-value
                         string line;
-                        int lineIdx = 0;
+                        int lineNo = 1;
                         while ((line = sr.ReadLine()) != null)
                         {
-                            lineIdx++;
+                            lineNo++;
                             var idx = line.IndexOf('\t');
                             if (idx == -1)
                             {
-                                LogWarning($"[RemoteConfig] Cannot get (key, value) at line {lineIdx} of cache");
+                                LogWarning($"[RemoteConfig] Cannot get (key, value) at line {lineNo} of cache. Content:\n<{line}>");
                                 continue;
                             }
                             string key = line.Substring(0, idx);
@@ -250,24 +275,30 @@ namespace Amanotes.Core
                 NextState(true);
             }
 
-            static void LoadDefaultAsset()
+            static void LoadEmbedConfig()
             {
-                _state = FetchState.LoadDefaultAsset;
+                _state = FetchState.LoadEmbedConfig;
+                
+                if (adapterConfig == null || adapterConfig.embedRemoteConfig == null)
+                {
+                    NextState(false);
+                    return;
+                }
 
-                var defaultValue = ((AdapterContext)adapter).GetAdapterConfig<RemoteConfigConfig>().defaultValue;
+                var config = adapterConfig.embedRemoteConfig.ActiveConfig;
 
-                if (defaultValue.Length == 0)
+                if (config == null || config.items.Length == 0)
                 {
                     NextState(false);
                     return;
                 }
 
-                foreach (var item in defaultValue)
+                foreach (var item in config.items)
                 {
                     dictConfig.Add(item.key, item.value);
                 }
-                Source = RemoteConfigSource.DefaultAsset;
-                Log("[RemoteConfig] Load from default asset");
+                Source = RemoteConfigSource.EmbedConfig;
+                Log("[RemoteConfig] Load from embed asset");
                 NextState(true);
             }
 
@@ -301,6 +332,12 @@ namespace Amanotes.Core
                 s = s.Remove(0, base64Prefix.Length);
                 return Encoding.UTF8.GetString(Convert.FromBase64String(s));
             }
+
+            static bool ShouldClearCache(string cacheVersion)
+            {
+                if (!cacheVersion.StartsWith(VERSION_PREFIX)) return true;
+                return cacheVersion != VERSION_PREFIX + EmbedVersion;
+            }
         }
     }
 
@@ -324,19 +361,12 @@ namespace Amanotes.Core.Internal
     [Serializable]
     public class RemoteConfigConfig
     {
-        public bool autoUpdateDefaultValue;
-        public KeyValue[] defaultValue;
+        [SerializeField]
+        internal EmbedRemoteConfigAsset embedRemoteConfig;
         public float firstFetchTimeOutInSeconds = 10;
         public float defaultTimeOutInSeconds = 3;
     }
-
-    [Serializable]
-    public class KeyValue
-    {
-        public string key;
-        public string value;
-    }
-
+    
     public interface IRemoteConfig
     {
         void ResolveDependencies(Action<bool> onComplete);

package/Runtime/AmaGDK.UserProfile.cs

@@ -15,12 +15,12 @@ namespace Amanotes.Core
 
             public void Save()
             {
-                FileUtils.Save(FILE_NAME, JsonUtility.ToJson(this));
+                GDKFileUtils.Save(FILE_NAME, JsonUtility.ToJson(this));
             }
 
             public UserProfile Load()
             {
-                string json = FileUtils.Load(FILE_NAME);
+                string json = GDKFileUtils.Load(FILE_NAME);
                 if (string.IsNullOrEmpty(json)) return this;
                 JsonUtility.FromJsonOverwrite(json, this);
                 return this;

package/Runtime/AmaGDK.Utils.cs

@@ -3,12 +3,13 @@ using System.Collections;
 using System.Collections.Generic;
 using System.IO;
 using System.Text;
+using System.Text.RegularExpressions;
 using UnityEngine;
 using static Amanotes.Core.Internal.Logging;
 
 namespace Amanotes.Core.Internal
 {
-    public class Utils
+    public class GDKUtils
     {
         public static void DelayCall(float seconds, Action action)
         {
@@ -22,7 +23,7 @@ namespace Amanotes.Core.Internal
         }
     }
     
-    internal class FileUtils
+    internal class GDKFileUtils
     {
 
         private static string _basePath;
@@ -39,6 +40,7 @@ namespace Amanotes.Core.Internal
                 return _basePath;
             }
         }
+        
         internal static string GetPath(string fileName)
         {
             return Path.Combine(basePath, fileName);
@@ -161,6 +163,26 @@ namespace Amanotes.Core.Internal
                 LogWarningOnce(path + "\n" + ex);
             }
         }
+        
+        internal static void ClearCacheData()
+        {
+            StringBuilder logBuilder = new StringBuilder();
+            logBuilder.AppendLine("[AmaGDK] All cached data & stats cleared");
+            
+            if (!Directory.Exists(_basePath))
+            {
+                logBuilder.AppendLine("Cache path not exists: " + _basePath);
+                return;
+            }
+            
+            string[] filePaths = Directory.GetFiles(_basePath);
+            foreach (string path in filePaths)
+            {
+                Delete(path);
+                logBuilder.AppendLine($"[deleted] - {path}");
+            }
+            Debug.Log(logBuilder);
+        }
     }
 
     public class ActionQueue
@@ -238,7 +260,7 @@ namespace Amanotes.Core.Internal
                 instance = result;
             }
             string fileName = instance.GetType().Name;
-            string json = FileUtils.Load(fileName);
+            string json = GDKFileUtils.Load(fileName);
             JsonUtility.FromJsonOverwrite(json, instance);
             return instance;
         }
@@ -247,7 +269,7 @@ namespace Amanotes.Core.Internal
         {
             string fileName = instance.GetType().Name;
             string json = JsonUtility.ToJson(instance);
-            FileUtils.Save(fileName, json);
+            GDKFileUtils.Save(fileName, json);
         }
     }
 
@@ -342,8 +364,7 @@ namespace Amanotes.Core.Internal
                         return;
                     }
                 }
-
-                jsonSb.Append($"\"{value}\"");
+                jsonSb.Append($"\"{EscapeJsonString(s)}\"");
                 return;
             }
 
@@ -374,6 +395,13 @@ namespace Amanotes.Core.Internal
             jsonSb.Append($"{JsonUtility.ToJson(value, format)}");
         }
 
+        private static string EscapeJsonString(string input)
+        {
+            //Match any occurrence of a backslash(\), single quotation('), or double quotation (")
+            string pattern = "[\\\'\"]";
+            return Regex.Replace(input, pattern, match => $"\\{match.Value}");
+        }
+
         //public static T[] FromJsonToArray<T>(string json)
         //{
         //    if (!json.StartsWith("{\"items\":"))

package/Runtime/AmaGDK.cs

@@ -1,16 +1,20 @@
 using System;
 using System.Collections;
+using System.Diagnostics;
+using System.IO;
 using System.Text;
+using System.Text.RegularExpressions;
 using Amanotes.Core.Internal;
 using UnityEngine;
 using static Amanotes.Core.Internal.Logging;
 using static Amanotes.Core.Internal.Messsage;
+using Debug = System.Diagnostics.Debug;
 
 namespace Amanotes.Core
 {
     public partial class AmaGDK : MonoBehaviour
     {
-        public const string VERSION = "0.2.12";
+        public const string VERSION = "0.2.14";
 
         internal static AmaGDK _instance;
         internal static Status _status = Status.None;
@@ -109,7 +113,7 @@ namespace Amanotes.Core
             _status = Status.Ready;
             _onReadyCallback?.Invoke();
             _onReadyCallback = null;
-            Debug.Log($"AmaGDK v{VERSION} | {READY} in {Time.realtimeSinceStartup - startTime}s\n\n{adapterInfo.ToString()}");
+            Log($"AmaGDK v{VERSION} | {READY} in {Time.realtimeSinceStartup - startTime}s\n\n{adapterInfo.ToString()}");
         }
 
         void RegisterUnityCallback(AdapterContext adapter)
@@ -231,4 +235,48 @@ namespace Amanotes.Core
             applicationQuit?.Invoke();
         }
     }
+    
+    public  partial class  AmaGDK // Switch dev mode
+    {
+        [ContextMenu("Change Dev Mode")]
+        public void ChangeDevMode()
+        {
+            string variableName = "GDK_HOME";
+            string output = RunShellCommand($"source ~/.zshrc && echo ${variableName}");
+            output = output.Trim();
+
+            if (string.IsNullOrEmpty(output))
+            {
+                LogWarning($"{variableName} environment variable is not set.");
+                return;
+            }
+            
+            UpdateManifest(output);
+        }
+            
+        private string RunShellCommand(string command)
+        {
+            Process process = new Process();
+            process.StartInfo.FileName = "/bin/zsh";
+            process.StartInfo.Arguments = $"-c \"{command}\"";
+            process.StartInfo.RedirectStandardOutput = true;
+            process.StartInfo.UseShellExecute = false;
+            process.StartInfo.CreateNoWindow = true;
+            process.Start();
+    
+            string output = process.StandardOutput.ReadToEnd();
+            process.WaitForExit();
+    
+            return output;
+        }
+            
+        private void UpdateManifest(string strDesired)
+        {
+            const string manifestPath = "Packages/manifest.json";
+            string manifestJson = File.ReadAllText(manifestPath);
+
+            manifestJson = Regex.Replace(manifestJson, "\"com\\.amanotes\\.gdk\"\\s*:\\s*\"\\d+\\.\\d+\\.\\d+\"", $"\"com.amanotes.gdk\": \"{strDesired}\"");
+            File.WriteAllText(manifestPath, manifestJson);
+        }
+    }
 }

package/Runtime/AnalyticQualityAsset.cs

@@ -0,0 +1,218 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using UnityEngine;
+using static Amanotes.Core.Internal.Logging;
+#if UNITY_EDITOR
+using UnityEditor;
+#endif
+
+namespace Amanotes.Core
+{
+    public enum ParamType
+    {
+        String,
+        Integer,
+        RealNumber
+    }
+
+    [Serializable]
+    public class EventParam
+    {
+        public string paramName;
+        public ParamType type;
+        public bool isOptional;
+    }
+
+    [Serializable]
+    public class EventQuality
+    {
+        public string eventName;
+        public List<EventParam> lstParam;
+
+        private Dictionary<string, EventParam> dicParam = null;
+
+        internal Dictionary<string, EventParam> DicParam
+        {
+            get
+            {
+                if (dicParam == null) BuildCache();
+                return dicParam;
+            }
+        }
+
+        private void BuildCache()
+        {
+            dicParam = new Dictionary<string, EventParam>();
+            foreach (var param in lstParam)
+            {
+                if (dicParam.ContainsKey(param.paramName)) continue;
+
+                dicParam.Add(param.paramName, param);
+            }
+        }
+
+        private bool IsNumericType(Type type)
+        {
+            return type == typeof(int) ||
+                   type == typeof(long) ||
+                   type == typeof(short) ||
+                   type == typeof(byte) ||
+                   type == typeof(double) ||
+                   type == typeof(float) ||
+                   type == typeof(decimal) ||
+                   type == typeof(uint) ||
+                   type == typeof(ulong) ||
+                   type == typeof(ushort) ||
+                   type == typeof(sbyte);
+        }
+
+        private bool IsIntegerType(Type type)
+        {
+            return type == typeof(sbyte) ||
+                   type == typeof(byte) ||
+                   type == typeof(short) ||
+                   type == typeof(ushort) ||
+                   type == typeof(int) ||
+                   type == typeof(uint) ||
+                   type == typeof(long) ||
+                   type == typeof(ulong);
+        }
+
+        internal void ValidateParams(string eventName, Dictionary<string, object> eventParams)
+        {
+            StringBuilder logBuilder = new StringBuilder();
+            logBuilder.AppendLine($"Analytics quality violation found for event <{eventName}>");
+            bool isValid = true;
+            HashSet<string> checkedParameters = new HashSet<string>();
+
+            foreach (var kvp in DicParam)
+            {
+                if (!eventParams.ContainsKey(kvp.Key))
+                {
+                    if (!kvp.Value.isOptional)
+                    {
+                        isValid = false;
+                        logBuilder.AppendLine($"[-] {kvp.Key}");
+                    }
+                    continue;
+                }
+
+                object paramValue = eventParams[kvp.Key];
+
+                if (!ValidateParamType(paramValue, kvp.Value.type))
+                {
+                    isValid = false;
+                    logBuilder.AppendLine($"[X] {kvp.Key}. Input type {paramValue.GetType()}, Expected type: {kvp.Value.type.ToString()}.");
+                }
+
+                checkedParameters.Add(kvp.Key);
+            }
+
+            foreach (var parameter in eventParams)
+            {
+                if (checkedParameters.Contains(parameter.Key)) continue;
+
+                isValid = false;
+                logBuilder.AppendLine($"[+] {parameter.Key}");
+            }
+
+            if (!isValid) LogWarningOnce(logBuilder.ToString());
+        }
+
+        private bool ValidateParamType(object paramValue, ParamType paramType)
+        {
+            bool isValidType = false;
+
+            switch (paramType)
+            {
+                case ParamType.String:
+                    isValidType = paramValue is string;
+                    break;
+                case ParamType.Integer:
+                    isValidType = IsIntegerType(paramValue.GetType());
+                    break;
+                case ParamType.RealNumber:
+                    isValidType = IsNumericType(paramValue.GetType());
+                    break;
+                default:
+                    LogWarningOnce($"Unsupported EventParam type: + {paramType}");
+                    break;
+            }
+
+            return isValidType;
+        }
+    }
+
+    [CreateAssetMenu(fileName = "AmaGDKAnalyticsQuality", menuName = "Ama GDK/Analytics Quality", order = 3)]
+    [Serializable]
+    public class AnalyticQualityAsset : ScriptableObject
+    {
+        [SerializeField] private List<EventQuality> lstEvent = new List<EventQuality>();
+
+        private Dictionary<string, EventQuality> dictEvent = null;
+        private void BuildCache()
+        {
+            dictEvent = new Dictionary<string, EventQuality>();
+            foreach (var evt in lstEvent)
+            {
+                if (dictEvent.ContainsKey(evt.eventName))
+                {
+                    LogWarningOnce($"Duplicate event: {evt.eventName}");
+                    continue;
+                }
+
+                dictEvent.Add(evt.eventName, evt);
+            }
+        }
+
+        private Dictionary<string, EventQuality> DictEvent
+        {
+            get
+            {
+                if (dictEvent == null) BuildCache();
+                return dictEvent;
+            }
+        }
+#if UNITY_EDITOR
+        [ContextMenu("Validate Unique EventNames")]
+        private void ValidateUniqueEventNames()
+        {
+            HashSet<string> eventNames = new HashSet<string>();
+            
+            lstEvent = lstEvent.OrderBy(evt => evt.eventName).ToList();
+            
+            foreach (EventQuality eventQuality in lstEvent)
+            {
+                if (string.IsNullOrWhiteSpace(eventQuality.eventName)) Debug.LogWarning("Event name cannot be empty or whitespace.");
+
+                if (!eventNames.Add(eventQuality.eventName)) Debug.LogWarning($"Duplicate event name found: {eventQuality.eventName}. Event names must be unique.");
+
+                HashSet<string> paramNames = new HashSet<string>();
+                
+                eventQuality.lstParam = eventQuality.lstParam.OrderBy(param => param.paramName).ToList();
+                
+                foreach (var param in eventQuality.lstParam)
+                {
+                    if (string.IsNullOrWhiteSpace(param.paramName)) Debug.LogWarning("Event parameter name cannot be empty or whitespace.");
+
+                    if (!paramNames.Add(param.paramName)) Debug.LogWarning($"Duplicate parameter name found in event {eventQuality.eventName}: {param.paramName}. Parameter names must be unique within an event.");
+                }
+            }
+            EditorUtility.SetDirty(this);
+        }
+#endif
+
+        public void CheckEventQuality(string eventName, Dictionary<string, object> parameters)
+        {
+            if (!DictEvent.ContainsKey(eventName))
+            {
+                LogWarningOnce($"Event not found in AnalyticQuality: {eventName}");
+                return;
+            }
+
+            DictEvent[eventName].ValidateParams(eventName, parameters);
+        }
+    }
+}

package/Runtime/AnalyticQualityAsset.cs.meta

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

package/Runtime/AssemblyInfo.cs

@@ -4,4 +4,5 @@
 #if UNITY_EDITOR
 [assembly: InternalsVisibleTo("AmaGDK.Editor")]
 [assembly: InternalsVisibleTo("AmaGDK.Test.Editor")]
-#endif
+[assembly: InternalsVisibleTo("AmaGDK.Dev.Editor")]
+#endif

package/Runtime/EmbedRemoteConfigAsset.cs

@@ -0,0 +1,59 @@
+using System;
+using System.Linq;
+using UnityEngine;
+
+namespace Amanotes.Core.Internal
+{
+    [CreateAssetMenu(fileName = "AmaGDKEmbedRemoteConfig", menuName = "Ama GDK/Embed Remote Config", order = 2)]
+    [Serializable]
+    internal class EmbedRemoteConfigAsset : ScriptableObject
+    {
+        public int version = 1;
+        [SerializeField] 
+        internal string activeId;
+        public bool overrideInEditor;
+        public KeyValue[] overrideConfig;
+        [SerializeField]
+        internal EmbedConfig[] configs;
+        private EmbedConfig activeConfig;
+        internal EmbedConfig ActiveConfig
+        {
+            get
+            {
+                if (activeConfig != null) return activeConfig;
+                activeConfig = GetConfigById(activeId);
+                return activeConfig;
+            }   
+        }
+
+        internal EmbedConfig GetConfigById(string id)
+        {
+            var config = configs?.FirstOrDefault(a => a.id == id);
+            if (config == null)
+                Logging.LogWarningOnce($"Not found embedded config <{id}>");
+            return config;
+        }
+
+        internal void SetActiveConfig(string id)
+        {
+            activeId = id;
+            activeConfig = null;
+        }
+    }
+
+    [Serializable]
+    internal class EmbedConfig
+    {
+        public string id;
+        public string fetchUrl;
+        public KeyValue[] items;
+    }
+    
+    [Serializable]
+    internal class KeyValue
+    {
+        public string key;
+        public string value;
+    }
+}
+

package/Runtime/EmbedRemoteConfigAsset.cs.meta

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

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "com.amanotes.gdk",
-    "version": "0.2.12",
+    "version": "0.2.14",
     "displayName": "AmaGDK",
     "description": "Amanotes Game Development Kit",
     "unity": "2020.3",