com.amanotes.gdk 0.1.8 → 0.1.9

package/CHANGELOG.md

@@ -1,5 +1,10 @@
 # Changelog
 
+## [0.1.9 - 2023-02-15]
+### Release AmaGDK v0.1.9
+### Change Documentation URL
+### Support API LogEvent(eventName, parameters)
+
 ## [0.1.8 - 2023-02-15]
 ### Release AmaGDK v0.1.8
 ### Add AdapterID

package/Runtime/AmaGDK.Adapters.cs

@@ -5,41 +5,109 @@ using ConfigAsset = Amanotes.Core.Internal.ConfigAsset;
 using Status = Amanotes.Core.Internal.Status;
 using static Amanotes.Core.Internal.Logging;
 using static Amanotes.Core.Internal.Messsage;
+using System.Linq;
 
 namespace Amanotes.Core.Internal
 {
-    public interface IAdapter
+
+    [Serializable] public class AdapterInfo
     {
-        string Id { get; }
-        bool IsReady { get; }
-        void Init();        
+        public string id;
+        public string version;
+        public int initOrder;
+        public Status status = Status.None;
+        public IAdapter adapter;
+        
+        public bool IsReady { get { return status == Status.Ready; }}
+        
+        public void Init(){
+            if (status != Status.None)
+            {
+                LogWarning($"Invalid status: {status}");
+                return;
+            }
+
+            status = Status.Initialize;
+            adapter.Init((success) =>
+            {
+                status = success ? Status.Ready : Status.Failed;
+            });
+        }
+
+        public T GetAdapterApi<T>(){ return (T)adapter; }
     }
     
-    public class AdapterT<T> : IAdapter where T : IAdapter, new()
+    public interface IAdapter 
     {
-        protected static T _instance;
-        protected static Status _status = Status.None;
-        public bool IsReady => _status == Status.Ready;
-        public string Id => typeof(T).Name.Replace("Adapter", string.Empty);
+        void Init(Action<bool> onCompleted);
+    }
+
+    // public static class AdapterExtension
+    // {
+    //     public static string GetId<T>(this T adapter) where T: IAdapter {
+    //         return Adapter.GetId(typeof(T));
+    //     }
+    // } 
+
+    public static class Adapter
+    {
+        internal static readonly List<AdapterInfo> listAdapters = new List<AdapterInfo>();
+        
+        public static string GetId(Type adapterType) {
+            return adapterType.Name.Replace("Adapter", string.Empty);
+        }
 
-        public void Init()
+        public static void Register<T>(string version) where T : IAdapter, new()
         {
-            if (_status != Status.None)
+            var typeT = typeof(T);
+            var id = GetId(typeT);
+            
+            if (AmaGDK._status != Status.None)
             {
-                LogWarning($"Invalid status: {_status}");
+                LogWarningOnce($"RegisterAdapter - Invalid status: {AmaGDK._status}");
                 return;
             }
 
-            _status = Status.Initialize;
-            InternalInit((success) =>
+            var orderConfig = AmaGDK.Config.initOrder.FirstOrDefault(item => item.id == id);
+            listAdapters.Add(new AdapterInfo()
             {
-                _status = success ? Status.Ready : Status.Failed;
+                id = id,
+                version = version,
+                initOrder = (orderConfig != null) ? orderConfig.order : 0,
+                adapter = new T()
             });
         }
 
-        protected virtual void InternalInit(Action<bool> onCompleted)
+        public static AdapterInfo Find<T>()
         {
-            
+            for (var i = 0; i < listAdapters.Count; i++)
+            {
+                var item = listAdapters[i];
+                var itemType = item.adapter.GetType();
+                if (!typeof(T).IsAssignableFrom(itemType)) continue;
+                return item;
+            }
+
+            return default;
+        }
+
+        public static List<AdapterInfo> FindAll<T>()
+        {
+            var result = new List<AdapterInfo>();
+            for (var i = 0; i < listAdapters.Count; i++)
+            {
+                var item = listAdapters[i];
+                var itemType = item.adapter.GetType();
+                if (!typeof(T).IsAssignableFrom(itemType)) continue;
+                result.Add(item);
+            }
+
+            return result;
+        }
+
+        public static T GetConfig<T>() where T : ConfigAsset
+        {
+            return (T)AmaGDK.Config;
         }
     }
 }

package/Runtime/AmaGDK.Analytics.cs

@@ -43,6 +43,14 @@ namespace Amanotes.Core
                 return result;
             }
 
+            public static IEventParamsBuilder LogEvent(string eventName, Dictionary<string, object> parameters)
+            {
+                var result = new EventParams(eventName);
+                result.AddParam(parameters);
+                eventQueue.Enqueue(result);
+                return result;
+            }
+
             public static IEventParamsBuilder LogFunnelEvent(string eventName, string signature = "")
             {
                 return LogEvent(eventName).SetAsFunnel(signature);
@@ -70,7 +78,7 @@ namespace Amanotes.Core
 
                 foreach (var s in listAdapters)
                 {
-                    s.SetUserId(userId);
+                    s.GetAdapterApi<IAnalyticAdapter>().SetUserId(userId);
                 }
             }
 
@@ -84,10 +92,10 @@ namespace Amanotes.Core
 
                 foreach (var s in listAdapters)
                 {
-                    s.SetUserProperty(key, value);
+                    s.GetAdapterApi<IAnalyticAdapter>().SetUserProperty(key, value);
                 }
             }
-
+            
             private static IntegrityFlag MergeData(List<string> funnelEvents, Dictionary<string, int> eventCountMap, bool sumEventCount)
             {
                 var flag = IntegrityFlag.Ok;
@@ -158,7 +166,7 @@ namespace Amanotes.Core
         {
             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 List<AdapterInfo> listAdapters = new List<AdapterInfo>();
             internal static readonly AnalyticsData localData = new AnalyticsData().LoadJsonFromFile();
 
             internal static void GetAnalyticAdapters()
@@ -191,12 +199,10 @@ namespace Amanotes.Core
 
                     foreach (var m in listAdapters)
                     {
-                        var id = ((IAdapter)m).Id;
-                        if (eventData.ignoreAnalyticIds.Contains(id))
+                        if (eventData.ignoreAnalyticIds.Contains(m.id))
                             continue;
-
-                        m.LogEvent(eventData);
-                        if (showAnalyticsLog) Debug.Log($"[{id}] Sent event <{eventData.eventName}> ({counter})");
+                        m.GetAdapterApi<IAnalyticAdapter>().LogEvent(eventData);
+                        if (showAnalyticsLog) Debug.Log($"[{m.id}] Sent event <{eventData.eventName}> ({counter})");
                     }
                 }
 

package/Runtime/AmaGDK.Config.cs

@@ -1,13 +1,94 @@
 using System;
+using System.Collections.Generic;
+using System.Reflection;
 using UnityEngine;
 
+#if UNITY_EDITOR
+using UnityEditor;
+#endif
+
 namespace Amanotes.Core.Internal {
     public partial class ConfigAsset : ScriptableObject
     {
+        [SerializeField] internal bool simpleOrder = true;
+        [SerializeField] internal List<InitOrder> initOrder = new List<InitOrder>();
         [SerializeField] internal SDKConfig common;
+
+#if UNITY_EDITOR
+        void OnValidate()
+        {
+            if (Application.isPlaying) return;
+            if (simpleOrder) {
+                EditorApplication.update -= DelayCheckOrder;
+                EditorApplication.update += DelayCheckOrder;
+            }
+        }
+
+        void DelayCheckOrder()
+        {
+            EditorApplication.update -= DelayCheckOrder;
+            var dirty = false;
+            for (var i =0 ;i < initOrder.Count;i++){
+                if (initOrder[i].order == i) continue;
+                dirty = true;
+                break;
+            }
+
+            if (!dirty) return;
+            initOrder.Sort((a1, a2)=> a1.order.CompareTo(a2.order));
+            for (var i =0 ;i < initOrder.Count;i++){
+                initOrder[i].order = i;
+            }
+            EditorUtility.SetDirty(this);
+        }
+
+        [ContextMenu("Scan Adapters")]
+        void ScanAdapters()
+        {
+            initOrder.Clear();
+
+            var counter = 0;
+            foreach (var adapter in GetAllAdapters<IAdapter>())
+            {
+                var id = adapter.Name.Replace("Adapter", string.Empty);
+                initOrder.Add(new InitOrder(){ id = id, order = counter++ });
+            }
+        }
+
+        [ContextMenu("Refresh Order")]
+        void UpdateOrderToPosition()
+        {
+            for (var i =0 ;i < initOrder.Count; i++)
+            {
+                initOrder[i].order = i;
+            }
+        }
+        
+        public static IEnumerable<Type> GetAllAdapters<T>()
+        {
+            var typeT = typeof(T);
+            foreach (Assembly a in AppDomain.CurrentDomain.GetAssemblies())
+            {
+                if (!a.FullName.Contains("Assembly-CSharp")) continue;
+                
+                foreach (var type in a.GetTypes()){
+                    if (typeT.IsAssignableFrom(type)) yield return type;
+                }
+            }
+        }
+#endif
     }
 
-    [Serializable] internal partial class SDKConfig {
+    [Serializable]
+    internal partial class SDKConfig
+    {
         public bool verboseLog = false;
     }
+
+    [Serializable]
+    internal class InitOrder
+    {
+        public string id;
+        public int order;
+    }
 }

package/Runtime/AmaGDK.Internal.cs

@@ -25,16 +25,16 @@ namespace Amanotes.Core.Internal
 
     public static class Res
     {
-        #if AMAGDK_DEV
+#if AMAGDK_DEV
         public const string BASE_PATH = "Assets/AmaGDKCore/";
-        #else
+#else
         public const string BASE_PATH = "Packages/com.amanotes.gdk/";
-        #endif
+#endif
 
         public const string PACKAGE_PATH = BASE_PATH + "Packages/";
         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 = new string[]
         {
             "FirebaseAnalyticsAdapter_v9.1.0",
@@ -69,55 +69,27 @@ namespace Amanotes.Core.Internal
         }
     }
 
-    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 class Forbidden
+    {
         public static void DestroyAndReset()
         {
-            if (AmaGDK._instance != null) {
+            if (AmaGDK._instance != null)
+            {
                 UnityObject.Destroy(AmaGDK._instance);
                 AmaGDK._instance = null;
             }
 
             var result = Resources.FindObjectsOfTypeAll<AmaGDK>();
-            for (var i = 0;i < result.Length; i++)
-            {   
+            for (var i = 0; i < result.Length; i++)
+            {
                 if (result[i] == null) continue;
-                
-                #if UNITY_EDITOR // Ignore loaded prefabs assets
+
+#if UNITY_EDITOR // Ignore loaded prefabs assets
                 {
                     var path = UnityEditor.AssetDatabase.GetAssetPath(result[i]);
                     if (!string.IsNullOrEmpty(path)) continue;
                 }
-                #endif
+#endif
 
                 // Logging.LogWarning("Something wrong: another AmaGDK instance found!");
                 UnityObject.Destroy(result[i].gameObject);

package/Runtime/AmaGDK.cs

@@ -12,7 +12,7 @@ namespace Amanotes.Core
 {
     public partial class AmaGDK : MonoBehaviour
     {
-        public const string VERSION = "0.1.8";
+        public const string VERSION = "0.1.9";
 
         internal static AmaGDK _instance;
         private static ConfigAsset _config = null;
@@ -51,9 +51,7 @@ namespace Amanotes.Core
             _allowInit = _allowInit || autoInit;
             StartCoroutine(InitRoutine());
         }
-
-
-
+        
         IEnumerator InitRoutine()
         {
             if (Config == null)
@@ -63,10 +61,7 @@ namespace Amanotes.Core
 
             float time = 0;
             float timeout = 3;
-
-            // Wait 1 frame to make sure all adapters have finished registering
-            yield return null;
-
+            
             var counter = 0;
             const int INIT_TOLERANCE = 10 * 60;
             const int INIT_WARN_CYCLE = 5 * 60;
@@ -83,8 +78,12 @@ namespace Amanotes.Core
             }
 
             _status = Status.Initialize;
+
+            // sort on priority
+            Adapter.listAdapters.Sort((a1, a2)=> a1.initOrder.CompareTo(a2.initOrder));
             foreach (var adapter in Adapter.listAdapters)
             {
+                Log($"Initing {adapter.id} --> initOrder: {adapter.initOrder}");
                 adapter.Init();
 
                 while (!adapter.IsReady)
@@ -92,8 +91,10 @@ namespace Amanotes.Core
                     time += Time.deltaTime;
                     yield return null;
                     if (time <= timeout) continue;
-                    LogWarningOnce($"{adapter.Id} is time out");
+                    LogWarningOnce($"{adapter.id} init time out: {timeout}");
                 }
+
+                Log($"Adapter {adapter.id} inited!");
             }
 
             // Init adapters

package/Tests/Runtime/AmaGDKCoreTest.cs

@@ -70,8 +70,7 @@ public class AmaGDKCoreTest
         
         AmaGDK.Init();
         SceneManager.LoadScene(SCENE_WITH_AUTOINIT_OFF, LoadSceneMode.Single);
-        LogAssert.NoUnexpectedReceived();
-
+        
         yield return new WaitForSeconds(AMAGDK_INIT_DURATION);
         Assert.IsTrue(AmaGDK.isReady);
     }
@@ -85,8 +84,8 @@ public class AmaGDKCoreTest
         SceneManager.LoadScene(SCENE_WITH_AUTOINIT_OFF, LoadSceneMode.Single);
         yield return null; // Took 1 frame for scene ready (call Awake)
         AmaGDK.Init();
-        LogAssert.NoUnexpectedReceived();
 
+        
         yield return new WaitForSeconds(AMAGDK_INIT_DURATION);
         Assert.IsTrue(AmaGDK.isReady);
     }

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "com.amanotes.gdk",
-    "version": "0.1.8",
+    "version": "0.1.9",
     "displayName": "AmaGDK",
     "description": "Amanotes Game Development Kit",
     "unity": "2020.3",
@@ -14,5 +14,6 @@
         "email": "tech.support@amanotes.com",
         "url": "https://amanotes.com"
     },
+    "documentationUrl": "https://amagdk.notion.site/amagdk/Ama-GDK-a73596617ab247b6a43c8f12a1581415",
     "license": "MIT"
 }