com.amanotes.gdk 0.2.13 → 0.2.16

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,9 +1,9 @@
 {
     "name": "com.amanotes.gdk",
-    "version": "0.2.13",
+    "version": "0.2.16",
     "displayName": "AmaGDK",
     "description": "Amanotes Game Development Kit",
-    "unity": "2020.3",
+    "unity": "2019.4",
     "keywords": [
         "Amanotes",
         "Amanotes GDK",