com.amanotes.gdk 0.2.13 → 0.2.14

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # 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 (", ', \)
 

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.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)
@@ -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.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
@@ -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,27 +198,14 @@ 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 = GDKFileUtils.GetPath(fileName);
                 GDKFileUtils.Save(filePath, sb.ToString());
@@ -220,15 +228,32 @@ namespace Amanotes.Core
                     dictConfig.Clear();
                     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.cs

@@ -14,7 +14,7 @@ namespace Amanotes.Core
 {
     public partial class AmaGDK : MonoBehaviour
     {
-        public const string VERSION = "0.2.13";
+        public const string VERSION = "0.2.14";
 
         internal static AmaGDK _instance;
         internal static Status _status = Status.None;

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/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.13",
+    "version": "0.2.14",
     "displayName": "AmaGDK",
     "description": "Amanotes Game Development Kit",
     "unity": "2020.3",