com.amanotes.gdk 0.1.3

package/Runtime/AmaGDK.Analytics.cs

@@ -0,0 +1,454 @@
+using System;
+using System.Collections.Generic;
+using UnityEngine;
+
+using Amanotes.Core.Internal;
+using static Amanotes.Core.Internal.Logging;
+using IEventParamsBuilder = Amanotes.Core.AmaGDK.Analytics.IEventParamsBuilder;
+using EventParams = Amanotes.Core.AmaGDK.Analytics.EventParams;
+
+namespace Amanotes.Core
+{    
+    partial class AmaGDK
+    {
+        //PUBLIC APIS
+        public static partial class Analytics
+        {
+            public interface IEventParamsBuilder { }            
+
+            public class EventParams : IEventParamsBuilder
+            {
+                public string eventName;
+                public Dictionary<string, object> parameters = new Dictionary<string, object>();
+                public string funnelSignature;
+                public bool accumulated;
+                public HashSet<string> ignoreAnalyticIds = new HashSet<string>();
+                public HashSet<string> allowAnalyticIds = new HashSet<string>();
+
+                public EventParams(string eventName)
+                {
+                    this.eventName = eventName;
+                }
+
+                public bool IsFunnelEvent
+                {
+                    get { return !string.IsNullOrEmpty(funnelSignature); }
+                }
+            }
+
+            public static IEventParamsBuilder LogEvent(string eventName)
+            {
+                var result = new EventParams(eventName);
+                eventQueue.Enqueue(result);
+                return result;
+            }
+
+            public static IEventParamsBuilder LogFunnelEvent(string eventName, string signature = "")
+            {
+                return LogEvent(eventName).SetAsFunnel(signature);
+            }
+
+            public static int GetAccumulatedCount(string eventName)
+            {
+                var eventDetail = localData.GetEventDetail(eventName);
+                return eventDetail != null ? eventDetail.count : 0;
+            }
+
+            public static void SetLogEventCondition(Predicate<EventDetail> condition)
+            {
+                if (logEventHook != null) LogWarning("LogEventCondition has already set! Please make sure to call it once.");
+                logEventHook = condition;
+            }
+
+            public static void SetUserId(string userId)
+            {
+                if (listAdapters.Count == 0)
+                {
+                    LogWarningOnce("ListAnalyticsAdapter is empty! Maybe you need to wait for Analytics to init");
+                    return;
+                }
+
+                foreach (var s in listAdapters)
+                {
+                    s.SetUserId(userId);
+                }
+            }
+
+            public static void SetUserProperty(string key, string value)
+            {
+                if (listAdapters.Count == 0)
+                {
+                    LogWarningOnce("ListAnalyticsAdapter is empty! Maybe you need to wait for Analytics to init");
+                    return;
+                }
+
+                foreach (var s in listAdapters)
+                {
+                    s.SetUserProperty(key, value);
+                }
+            }
+
+            private static IntegrityFlag MergeData(List<string> funnelEvents, Dictionary<string, int> eventCountMap, bool sumEventCount)
+            {
+                var flag = IntegrityFlag.Ok;
+
+                foreach (var e in funnelEvents)
+                {
+                    if (localData.funnelSignatures.Contains(e)) continue;
+
+                    flag |= IntegrityFlag.NewFunnel;
+                    localData.AddFunnelSignature(e);
+                }
+
+                foreach (var e in eventCountMap)
+                {
+                    var eventDetail = localData.GetEventDetail(e.Key);
+                    if (eventDetail == null)
+                    {
+                        localData.eventDetails.Add(new EventDetail
+                        {
+                            eventName = e.Key,
+                            count = e.Value
+                        });
+                        flag |= IntegrityFlag.NewEvent;
+                        continue;
+                    }
+
+                    if (eventDetail.count != e.Value)
+                    {
+                        flag |= IntegrityFlag.DifferentCount;
+                    }
+
+                    if (sumEventCount)
+                    {
+                        eventDetail.count += e.Value;
+                    }
+                }
+
+                return flag;
+            }
+
+            public static void Migrate(List<string> lsFunnelEvents, Dictionary<string, int> dicEventCounts)
+            {
+                var migrationLog = localData.migrationLog;
+
+                //First time
+                if (migrationLog.count == 0)
+                {
+                    MergeData(lsFunnelEvents, dicEventCounts, true);
+                    localData.UpdateMigrationLog();
+                    return;
+                }
+
+                //Integrity check
+                if (!Config.common.checkMigrationIntegrity)
+                    return;
+
+                // False: DO NOT UPDATE EXISTED COUNT VALUE BECAUSE WE DON'T HAVE
+                // ENOUGH INFORMATION TO DECIDE WHICH ONE IS MORE ACCURATE
+                var flag = MergeData(lsFunnelEvents, dicEventCounts, false);
+                if (flag == IntegrityFlag.Ok) return;
+
+                localData.UpdateMigrationLog();
+            }
+        }
+
+        //INTERNAL
+        public static partial class Analytics
+        {
+            internal static Predicate<EventDetail> logEventHook = null;
+            internal static readonly Queue<EventParams> eventQueue = new Queue<EventParams>();
+            internal static readonly List<IAnalyticAdapter> listAdapters = new List<IAnalyticAdapter>();
+            internal static readonly AnalyticsData localData = new AnalyticsData().LoadJsonFromFile();
+
+            internal static void GetAnalyticAdapters()
+            {
+                listAdapters.Clear();
+                listAdapters.AddRange(Adapter.FindAll<IAnalyticAdapter>());
+            }
+
+            internal static void ProcessEventQueue()
+            {
+                if (eventQueue.Count <= 0) return;
+
+                while (eventQueue.Count > 0)
+                {
+                    var eventData = eventQueue.Dequeue();
+
+                    if (!NormalizeEventName(ref eventData.eventName))
+                        continue;
+
+                    var counter = localData.IncreaseCounter(eventData.eventName);
+
+                    if (!ShouldSendEvent(eventData))
+                        continue;
+
+                    if (eventData.accumulated)
+                    {
+                        eventData.AddParam("accumulated_count", counter);
+                    }
+
+                    Log($"Send {eventData.eventName}, count {counter}");
+                    foreach (var m in listAdapters)
+                    {
+                        if (eventData.ignoreAnalyticIds.Contains(((IAdapter)m).Id))
+                            continue;
+                        m.LogEvent(eventData);
+                    }
+                }
+
+                localData.SaveIfDirty();
+            }
+
+            internal static bool NormalizeEventName(ref string eventName)
+            {
+                if (string.IsNullOrWhiteSpace(eventName))
+                {
+                    LogWarningOnce($"Invalid EventName: <{eventName}> ");
+                    return false;
+                }
+
+                var sb = tmpWarningSB;
+                sb.Clear();
+
+                var normalizedEventName = eventName.Trim()
+                    .Replace(' ', '_')
+                    .Replace('-', '_');
+
+                if (eventName != normalizedEventName)
+                {
+                    if (Config.common.normalizeEventName)
+                    {
+                        eventName = normalizedEventName;
+                    }
+                    else
+                    {
+                        sb.AppendLine($" - Malformed eventName (should not contains <space> or <dash>: <{eventName}>");
+                    }
+                }
+
+                if (!char.IsLetter(eventName[0])) sb.AppendLine($" - EventName must start with a letter: <{eventName}> ");
+                if (eventName.Length > 40) sb.AppendLine($" - EventName is too long ({eventName.Length} > 40): <{eventName}> ");
+                if (sb.Length > 0) LogWarningOnce(sb.ToString(), $"NormalizeEventName<{eventName}>");
+                return true;
+            }
+
+            internal static bool ShouldSendEvent(EventParams eventData)
+            {
+                //Funnel event
+                if (eventData.IsFunnelEvent)
+                {
+                    return localData.AddFunnelSignature(eventData.funnelSignature);
+                }
+
+                //Check the rule to log event
+                if (logEventHook == null) return true;
+                var eventDetail = localData.GetEventDetail(eventData.eventName, true);
+                return logEventHook(eventDetail);
+            }
+        }
+
+        //PERSISTENT DATA
+        public static partial class Analytics
+        {
+            [Serializable]
+            public class EventDetail
+            {
+                public string eventName;
+                public int count;
+            }
+
+            [Flags]
+            internal enum IntegrityFlag
+            {
+                Ok = 0,
+                NewFunnel = 1,
+                NewEvent = 2,
+                DifferentCount = 4
+            }
+
+            [Serializable]
+            public class MigrationLog
+            {
+                public string deviceId;
+                public string appVersion;
+                public string amaGDKVersion;
+                public int count;
+
+                public Dictionary<string, object> ToDictionary()
+                {
+                    var result = new Dictionary<string, object>();
+                    result.Add("device_id", deviceId);
+                    result.Add("app_version", appVersion);
+                    result.Add("amagdk_version", amaGDKVersion);
+                    return result;
+                }
+            }
+
+            [Serializable]
+            internal class AnalyticsData : IJsonFile
+            {
+                [NonSerialized] internal bool _dirty = false;
+
+                public List<string> funnelSignatures = new List<string>();
+                public List<EventDetail> eventDetails = new List<EventDetail>();
+                public MigrationLog migrationLog = new MigrationLog();
+
+                internal EventDetail GetEventDetail(string eventName, bool autoNew = false)
+                {
+                    var result = eventDetails.Find(e => e.eventName == eventName);
+                    if (result != null) return result;
+                    if (autoNew == false) return null;
+
+                    result = new EventDetail
+                    {
+                        eventName = eventName
+                    };
+                    eventDetails.Add(result);
+                    _dirty = true;
+                    return result;
+                }
+
+                internal bool AddFunnelSignature(string signature)
+                {
+                    if (funnelSignatures.Contains(signature))
+                    {
+                        return false;
+                    }
+
+                    _dirty = true;
+                    funnelSignatures.Add(signature);
+                    return true;
+                }
+
+                internal int IncreaseCounter(string eventName)
+                {
+                    var result = GetEventDetail(eventName, true);
+                    result.count++;
+                    _dirty = true;
+                    return result.count;
+                }
+
+                internal void SaveIfDirty()
+                {
+                    if (!_dirty) return;
+                    _dirty = false;
+                    this.SaveJsonToFile();
+                }
+
+                internal void UpdateMigrationLog()
+                {
+                    if (migrationLog.count == 0) // reset migration log
+                    {
+                        migrationLog.deviceId = SystemInfo.deviceUniqueIdentifier;
+                        migrationLog.appVersion = Application.version;
+                        migrationLog.amaGDKVersion = AmaGDK.VERSION;
+                        migrationLog.count = 1;
+                        Log($"Analytics data was migrated successfully");
+                    }
+                    else
+                    {
+                        migrationLog.count++;
+                        Log($"Analytics data was migrated {migrationLog.count} times");
+
+                        if (migrationLog.count == 2)
+                        {
+                            LogEvent("migration_error").AddParam(migrationLog.ToDictionary());
+                        }
+                    }
+
+                    _dirty = true;
+                    SaveIfDirty();
+                }
+            }            
+        }
+    }
+
+    public static class EventParamsExtension
+    {
+        public static IEventParamsBuilder SetAsFunnel(this IEventParamsBuilder ap, string signature = null)
+        {
+            if (ap == null) return null;
+
+            EventParams data = ap as EventParams;
+            data.funnelSignature = string.IsNullOrEmpty(signature) ? data.eventName : signature;
+            return ap;
+        }
+        public static IEventParamsBuilder SetAsAccumulated(this IEventParamsBuilder ap)
+        {
+            if (ap == null) return null;
+
+            (ap as EventParams).accumulated = true;
+            return ap;
+        }
+
+        public static IEventParamsBuilder Except(this IEventParamsBuilder ap, params string[] analyticIds)
+        {
+            if (ap == null) return null;
+
+            EventParams eventData = ap as EventParams;
+            foreach (var mId in analyticIds)
+            {
+                eventData.ignoreAnalyticIds.Add(mId);
+            }
+            return ap;
+        }
+
+        public static IEventParamsBuilder OnlyTo(this IEventParamsBuilder ap, params string[] analyticIds)
+        {
+            if (ap == null) return null;
+
+            EventParams eventData = ap as EventParams;
+            foreach (var mId in analyticIds)
+            {
+                eventData.allowAnalyticIds.Add(mId);
+            }
+            return ap;
+        }
+
+        public static IEventParamsBuilder AddParam(this IEventParamsBuilder ap, string key, object value)
+        {
+            if (ap == null) return null;
+
+            var parameters = (ap as EventParams).parameters;
+            if (parameters.ContainsKey(key))
+            {
+                LogWarning($"Duplicated key: {key}!");
+                return ap;
+            };
+
+            parameters.Add(key, value);
+            return ap;
+        }
+
+        public static IEventParamsBuilder AddParam(this IEventParamsBuilder ap, Dictionary<string, object> dictParams)
+        {
+            if (ap == null) return null;
+
+            foreach (var kvp in dictParams)
+            {
+                ap.AddParam(kvp.Key, kvp.Value);
+            }
+            return ap;
+        }
+
+    }
+}
+
+namespace Amanotes.Core.Internal
+{
+    partial class SDKConfig
+    {
+        public bool normalizeEventName;
+        public bool checkMigrationIntegrity;
+    }
+
+    public interface IAnalyticAdapter
+    {
+        void LogEvent(EventParams eventData);
+
+        void SetUserId(string userId);
+
+        void SetUserProperty(string key, string value);
+    }
+}

package/Runtime/AmaGDK.Analytics.cs.meta

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

package/Runtime/AmaGDK.Config.cs

@@ -0,0 +1,13 @@
+using System;
+using UnityEngine;
+
+namespace Amanotes.Core.Internal {
+    public partial class ConfigAsset : ScriptableObject
+    {
+        [SerializeField] internal SDKConfig common;
+    }
+
+    [Serializable] internal partial class SDKConfig {
+        public bool verboseLog = false;
+    }
+}

package/Runtime/AmaGDK.Config.cs.meta

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

package/Runtime/AmaGDK.Internal.cs

@@ -0,0 +1,133 @@
+using System.Linq;
+using System.Text;
+using System.Collections.Generic;
+
+using UnityEngine;
+using UnityObject = UnityEngine.Object;
+
+namespace Amanotes.Core.Internal
+{
+    public enum Status
+    {
+        None,
+        Initialize,
+        Ready,
+        Failed
+    }
+
+    public static class Messsage
+    {
+        public const string READY = "init success!";
+        public const string SDK_INIT_CALLED = "init has been called!";
+        public const string MULTIPLE_INSTANCE = "multiple instance found!";
+        public const string CONFIG_NOT_FOUND = "AmaGDKConfig not found in Resources!";
+    }
+
+    public static class Res
+    {
+        #if AMAGDK_DEV
+        public const string BASE_PATH = "Assets/AmaGDKCore/";
+        #else
+        public const string BASE_PATH = "Packages/com.amanotes.gdk/";
+        #endif
+
+        public const string PACKAGE_PATH = BASE_PATH + "Packages/";
+        public const string AMAGDK_PREFAB = BASE_PATH + "AmaGDK.prefab";
+        public const string AMAGDK_CONFIG_PACKAGE = PACKAGE_PATH + "AmaGDKConfig.unitypackage";
+        
+        public static readonly string[] AMAGDK_ADAPTERS = new string[]
+        {
+            "FirebaseAnalyticsAdapter_v9.1.0",
+            "AppsflyerAdapter_v6.5.4",
+        };
+    }
+
+
+    public static class Logging
+    {
+        public static readonly StringBuilder tmpWarningSB = new StringBuilder();
+        public static readonly HashSet<string> logWarningDict = new HashSet<string>();
+
+        public static void LogWarningOnce(string message, string key = null)
+        {
+            if (string.IsNullOrEmpty(key)) key = message;
+            if (logWarningDict.Contains(key)) return;
+            logWarningDict.Add(key);
+            Debug.LogWarning("[AmaGDK] " + message);
+        }
+        public static void LogWarning(string message)
+        {
+            Debug.LogWarning("[AmaGDK] " + message);
+        }
+        public static void LogError(string message)
+        {
+            Debug.LogError("[AmaGDK] " + message);
+        }
+        public static void Log(string message)
+        {
+            Debug.Log("[AmaGDK] " + message);
+        }
+    }
+
+    public static class Adapter {
+        internal static readonly List<IAdapter> listAdapters = new List<IAdapter>();
+
+        public static void Register(IAdapter adapter)
+        {
+            if (AmaGDK._status != Status.None)
+            {
+                Logging.LogWarningOnce($"RegisterAdapter - Invalid status: {AmaGDK._status}");
+                return;
+            }
+
+            listAdapters.Add(adapter);
+        }
+
+        public static T Find<T>()
+        {
+            return listAdapters.OfType<T>().FirstOrDefault();
+        }
+
+        public static T[] FindAll<T>()
+        {
+            return listAdapters.OfType<T>().ToArray();
+        }
+
+
+        public static T GetConfig<T>() where T: ConfigAsset {
+            return (T) AmaGDK.Config;
+        }
+    }
+
+    public static class Forbidden {
+        public static void DestroyAndReset()
+        {
+            if (AmaGDK._instance != null) {
+                UnityObject.Destroy(AmaGDK._instance);
+                AmaGDK._instance = null;
+            }
+
+            var result = Resources.FindObjectsOfTypeAll<AmaGDK>();
+            for (var i = 0;i < result.Length; i++)
+            {   
+                if (result[i] == null) continue;
+                
+                #if UNITY_EDITOR // Ignore loaded prefabs assets
+                {
+                    var path = UnityEditor.AssetDatabase.GetAssetPath(result[i]);
+                    if (!string.IsNullOrEmpty(path)) continue;
+                }
+                #endif
+
+                // Logging.LogWarning("Something wrong: another AmaGDK instance found!");
+                UnityObject.Destroy(result[i].gameObject);
+            }
+
+            AmaGDK._status = Status.None;
+            AmaGDK._allowInit = false;
+
+            // TODO: Destroy adapters?
+            Adapter.listAdapters.Clear();
+        }
+    }
+}

package/Runtime/AmaGDK.Internal.cs.meta

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

package/Runtime/AmaGDK.UserProfile.cs

@@ -0,0 +1,41 @@
+using System;
+using UnityEngine;
+using static Amanotes.Core.Internal.Logging;
+using FileUtils = Amanotes.Core.Internal.FileUtils;
+
+namespace Amanotes.Core
+{
+    public partial class AmaGDK //User profile
+    {
+        public static readonly UserProfile User = new UserProfile().Load();
+
+        [Serializable]
+        public class UserProfile
+        {
+            const string FILE_NAME = nameof(UserProfile);
+
+            public string amaId;
+            public string amaDeviceId;
+            public string gaId;
+            public string androidId;
+            public string idfa;
+            public string idfv;
+            public string appsflyerId;
+            public string firebaseUserPseudoId;
+
+            public void Save()
+            {
+                FileUtils.Save(FILE_NAME, JsonUtility.ToJson(this));
+            }
+
+            public UserProfile Load()
+            {
+                var json = FileUtils.Load(FILE_NAME);
+                if (string.IsNullOrEmpty(json))
+                    return this;
+                JsonUtility.FromJsonOverwrite(json, this);
+                return this;
+            }
+        }
+    }
+}

package/Runtime/AmaGDK.UserProfile.cs.meta

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