com.amanotes.gdk 0.1.8 → 0.1.10

package/CHANGELOG.md

@@ -1,5 +1,14 @@
 # Changelog
 
+## [0.1.10 - 2023-02-17]
+### Release AmaGDK v0.1.10
+### Support accumulated event within session
+
+## [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/Editor/AmaGDKEditor.cs

@@ -108,7 +108,10 @@ namespace Amanotes.Core
         void DrawGUI_ConfigDetail()
         {
             CreateCachedEditor(configAsset, null, ref editor);
+            var lbWidth = EditorGUIUtility.labelWidth;
+            EditorGUIUtility.labelWidth = 200f;
             editor.OnInspectorGUI();
+            EditorGUIUtility.labelWidth = lbWidth;
         }
 
         void DrawGUI_ConfigAsset(){

package/Packages/IronsourceAdapter_v7.2.6.unitypackage

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:313276bb7dcfb6c5dc1a760945f89b413282c7329d1b4856e777c6aee75cc22e
+size 1635

package/{Runtime/Interfaces.meta → Packages/IronsourceAdapter_v7.2.6.unitypackage.meta}

@@ -1,6 +1,5 @@
 fileFormatVersion: 2
-guid: cfbb48f0167d74afa8a2099a218d698e
-folderAsset: yes
+guid: 1a3999539db3049c998b0c84b7f92f07
 DefaultImporter:
   externalObjects: {}
   userData: 

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.Ads.cs

@@ -0,0 +1,235 @@
+using System;
+using System.Collections;
+
+using UnityEngine;
+
+using Amanotes.Core.Internal;
+using static Amanotes.Core.Internal.Logging;
+
+namespace Amanotes.Core
+{
+    public interface IAds
+    {
+        bool IsAdReady(AdType Type);
+
+        #region Interstitial   
+        event Action InterstitialShowSucceededCallback;
+        event Action InterstitialShowFailedCallback;
+        event Action InterstitialClickedCallback;
+        void RequestInterstitial();
+        void ShowInterstitial();
+        void ShowInterstitial(string placementName);
+        #endregion FullAds
+
+        #region VideoAds     
+        event Action RewardedVideoShowFailedCallback;
+        event Action RewardedVideoClosedCallback;
+        event Action RewardedCallback;
+        event Action RewardedVideoClickCallback;
+        void RequestRewardedVideo();
+        void ShowRewardedVideo();
+        void ShowRewardedVideo(string placementName);
+        #endregion VideoAds
+
+        #region Banner
+        event Action BannerAdsClickCallback;
+        event Action BannerShowCallback;        
+        void RequestBanner(BannerPosition position = BannerPosition.TOP);
+        void RequestBanner(BannerPosition position, string placementName);
+        void ShowBanner();
+        void HideBanner();
+        #endregion Banner
+    }
+
+    public enum BannerPosition
+    {
+        TOP = 1,
+        BOTTOM = 2
+    };
+
+    public enum AdType : byte
+    {
+        Interstitial,
+        Reward,
+        Banner
+    };
+
+    public partial class AmaGDK // IAds module
+    {
+        public static class Ads
+        {
+            internal static IAds adsModule;
+            public static Action<string> OnInterstitalFailCallback;
+            public static Action<string> OnRewardedVideoFailCallback;
+
+            public static void Init()
+            {
+                var adsModules = Adapter.FindAll<IAds>();
+
+                if (adsModules == null || adsModules.Count < 1)
+                {
+                    LogError("Ads module not found!");
+                    return;
+                }
+                
+                if (adsModules.Count > 1)
+                {
+                    LogError("Multiple Ads modules is not supported!");
+                    return;
+                }
+                
+                adsModule = adsModules[0].GetAdapterApi<IAds>();
+            }
+
+            public static void RequestBanner(BannerPosition position)
+            {
+                if (adsModule == null)
+                {
+                    LogWarning("Ads module is not initialized");
+                    return;
+                }
+                adsModule.RequestBanner(position);
+            }
+
+            public static void ShowBanner()
+            {
+                adsModule.ShowBanner();
+            }
+
+            public static void HideBanner()
+            {
+                if (!adsModule.IsAdReady(AdType.Banner))
+                {
+                    LogWarning("Banner is not ready");
+                    return;
+                }
+
+                adsModule.HideBanner();
+            }
+
+            public static void RequestInterstitial()
+            {
+                if (adsModule == null)
+                {
+                    LogWarning("Ads module is not initialized");
+                    return;
+                }
+                adsModule.RequestInterstitial();
+            }
+
+            public static void ShowInterstitial()
+            {
+                if (!adsModule.IsAdReady(AdType.Interstitial))
+                {
+                    LogWarning("Interstitial is not ready");
+                    BeginCoroutine(IWaitShowInterstitial());
+                    return;
+                }
+                adsModule.ShowInterstitial();
+            }
+
+            public static void RequestRewardedVideo()
+            {
+                if (adsModule == null)
+                {
+                    LogWarning("Ads module is not initialized");
+                    return;
+                }
+                adsModule.RequestRewardedVideo();
+            }
+
+            public static void ShowRewardedVideo()
+            {
+                if (!adsModule.IsAdReady(AdType.Reward))
+                {
+                    LogWarning("Reward is not ready");
+                    BeginCoroutine(IWaitShowRewardedVideo());
+                    return;
+                }
+                adsModule.ShowRewardedVideo();
+            }
+
+            private static IEnumerator IWaitShowRewardedVideo()
+            {
+                LogWarning("Wait Show Rewarded Video");
+                if (adsModule == null)
+                {
+                    OnRewardedVideoFailCallback?.Invoke("Not found ads module");
+                    OnRewardedVideoFailCallback = null;
+                    yield break;
+                }
+
+                var startTime = Time.time;
+                float timeout = 5;
+                string error = null;
+                while (!adsModule.IsAdReady(AdType.Reward))
+                {
+                    if (Application.internetReachability == NetworkReachability.NotReachable)
+                    {
+                        error = Application.internetReachability.ToString();
+                        break;
+                    }
+
+                    if ((Time.time - startTime) > timeout)
+                    {
+                        error = "Timeout";
+                        break;
+                    }
+
+                    yield return null;
+                }
+
+                if (adsModule.IsAdReady(AdType.Reward))
+                {
+                    adsModule.ShowRewardedVideo();
+                }
+                else
+                {
+                    OnRewardedVideoFailCallback?.Invoke(error);
+                    OnRewardedVideoFailCallback = null;
+                }
+            }
+
+            private static IEnumerator IWaitShowInterstitial()
+            {
+                LogWarning("Wait Show Interstitial");
+                if (adsModule == null)
+                {
+                    OnInterstitalFailCallback?.Invoke("Not found ads module");
+                    OnInterstitalFailCallback = null;
+                    yield break;
+                }
+
+                var startTime = Time.time;
+                float timeout = 5;
+                string error = null;
+                while (!adsModule.IsAdReady(AdType.Interstitial))
+                {
+                    if (Application.internetReachability == NetworkReachability.NotReachable)
+                    {
+                        error = Application.internetReachability.ToString();
+                        break;
+                    }
+
+                    if ((Time.time - startTime) > timeout)
+                    {
+                        error = "Timeout";
+                        break;
+                    }
+
+                    yield return null;
+                }
+
+                if (adsModule.IsAdReady(AdType.Interstitial))
+                {
+                    adsModule.ShowInterstitial();
+                }
+                else
+                {
+                    OnInterstitalFailCallback?.Invoke(error);
+                    OnInterstitalFailCallback = null;
+                }
+            }
+        }
+    }
+}

package/Runtime/{Interfaces/Analytics/IAnalytics.cs.meta → AmaGDK.Ads.cs.meta}

@@ -1,5 +1,5 @@
 fileFormatVersion: 2
-guid: 653a76219edea423ca7f51c1c4c9b02b
+guid: 46425c80eac894185a5609143ace732f
 MonoImporter:
   externalObjects: {}
   serializedVersion: 2

package/Runtime/AmaGDK.Analytics.cs

@@ -22,6 +22,7 @@ namespace Amanotes.Core
                 public Dictionary<string, object> parameters = new Dictionary<string, object>();
                 public string funnelSignature;
                 public bool accumulated;
+                public bool withinSession;
                 public HashSet<string> ignoreAnalyticIds = new HashSet<string>();
                 public HashSet<string> allowAnalyticIds = new HashSet<string>();
 
@@ -43,15 +44,44 @@ 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 LogEvent(string eventName, params (string, object)[] parameters)
+            {
+                var result = new EventParams(eventName);
+                for (var i = 0;i < parameters.Length; i++)
+                {
+                    result.AddParam(parameters[i].Item1, parameters[i].Item2);
+                }
+                eventQueue.Enqueue(result);
+                return result;
+            }
+
             public static IEventParamsBuilder LogFunnelEvent(string eventName, string signature = "")
             {
                 return LogEvent(eventName).SetAsFunnel(signature);
             }
 
-            public static int GetAccumulatedCount(string eventName)
+            public static IEventParamsBuilder LogFunnelEvent(string eventName, Dictionary<string, object> parameters, string signature = "")
+            {
+                return LogEvent(eventName, parameters).SetAsFunnel(signature);
+            }
+
+            public static IEventParamsBuilder LogFunnelEvent(string eventName, string signature = "", params (string, object)[] parameters)
+            {
+                return LogEvent(eventName, parameters).SetAsFunnel(signature);
+            }
+
+            public static int GetAccumulatedCount(string eventName, bool withinSession = false)
             {
                 var eventDetail = localData.GetEventDetail(eventName);
-                return eventDetail != null ? eventDetail.count : 0;
+                return eventDetail != null ? (withinSession ? eventDetail.countInSession : eventDetail.totalCount) : 0;
             }
 
             public static void SetLogEventCondition(Predicate<EventDetail> condition)
@@ -70,7 +100,7 @@ namespace Amanotes.Core
 
                 foreach (var s in listAdapters)
                 {
-                    s.SetUserId(userId);
+                    s.GetAdapterApi<IAnalyticAdapter>().SetUserId(userId);
                 }
             }
 
@@ -84,10 +114,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;
@@ -108,20 +138,20 @@ namespace Amanotes.Core
                         localData.eventDetails.Add(new EventDetail
                         {
                             eventName = e.Key,
-                            count = e.Value
+                            totalCount = e.Value
                         });
                         flag |= IntegrityFlag.NewEvent;
                         continue;
                     }
 
-                    if (eventDetail.count != e.Value)
+                    if (eventDetail.totalCount != e.Value)
                     {
                         flag |= IntegrityFlag.DifferentCount;
                     }
 
                     if (sumEventCount)
                     {
-                        eventDetail.count += e.Value;
+                        eventDetail.totalCount += e.Value;
                     }
                 }
 
@@ -158,13 +188,16 @@ 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()
+            internal static void Init()
             {
                 listAdapters.Clear();
                 listAdapters.AddRange(Adapter.FindAll<IAnalyticAdapter>());
+
+                _frameUpdate -= ProcessEventQueue;
+                _frameUpdate += ProcessEventQueue;
             }
 
             internal static void ProcessEventQueue()
@@ -179,24 +212,22 @@ namespace Amanotes.Core
                     if (!NormalizeEventName(ref eventData.eventName))
                         continue;
 
-                    var counter = localData.IncreaseCounter(eventData.eventName);
+                    var (countInSession, totalCount) = localData.IncreaseCounter(eventData.eventName);
 
                     if (!ShouldSendEvent(eventData))
                         continue;
 
                     if (eventData.accumulated)
                     {
-                        eventData.AddParam("accumulated_count", counter);
+                        eventData.AddParam("accumulated_count", eventData.withinSession ? countInSession : totalCount);
                     }
 
                     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}> (in session: {countInSession}, total: {totalCount})");
                     }
                 }
 
@@ -258,7 +289,9 @@ namespace Amanotes.Core
             public class EventDetail
             {
                 public string eventName;
-                public int count;
+                public int totalCount;
+                [NonSerialized]
+                public int countInSession;
             }
 
             [Flags]
@@ -324,12 +357,13 @@ namespace Amanotes.Core
                     return true;
                 }
 
-                internal int IncreaseCounter(string eventName)
+                internal (int countInSession, int totalCount) IncreaseCounter(string eventName)
                 {
                     var result = GetEventDetail(eventName, true);
-                    result.count++;
+                    result.totalCount++;
+                    result.countInSession++;
                     _dirty = true;
-                    return result.count;
+                    return (result.countInSession, result.totalCount);
                 }
 
                 internal void SaveIfDirty()
@@ -377,11 +411,13 @@ namespace Amanotes.Core
             data.funnelSignature = string.IsNullOrEmpty(signature) ? data.eventName : signature;
             return ap;
         }
-        public static IEventParamsBuilder SetAsAccumulated(this IEventParamsBuilder ap)
+        public static IEventParamsBuilder SetAsAccumulated(this IEventParamsBuilder ap, bool withinSession = false)
         {
             if (ap == null) return null;
 
-            (ap as EventParams).accumulated = true;
+            EventParams data = ap as EventParams;
+            data.accumulated = true;
+            if (withinSession) data.withinSession = true;
             return ap;
         }
 

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,20 +25,21 @@ 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",
             //"AppsflyerAdapter_v6.5.4",
+            // "IronsourceAdapter_v7.2.6",
         };
     }
 
@@ -69,55 +70,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,9 +12,10 @@ namespace Amanotes.Core
 {
     public partial class AmaGDK : MonoBehaviour
     {
-        public const string VERSION = "0.1.8";
+        public const string VERSION = "0.1.10";
 
         internal static AmaGDK _instance;
+        internal static event Action _frameUpdate;
         private static ConfigAsset _config = null;
         internal static ConfigAsset Config {
             get {
@@ -24,7 +25,7 @@ namespace Amanotes.Core
                 return _config;
             }
         }
-
+        
         internal static Status _status = Status.None;
         internal static Action _onReadyCallback;
         internal static bool _allowInit = false;
@@ -51,9 +52,7 @@ namespace Amanotes.Core
             _allowInit = _allowInit || autoInit;
             StartCoroutine(InitRoutine());
         }
-
-
-
+        
         IEnumerator InitRoutine()
         {
             if (Config == null)
@@ -63,10 +62,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 +79,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,13 +92,16 @@ 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}");
                 }
-            }
 
-            // Init adapters
-            Analytics.GetAnalyticAdapters();
+                Log($"Adapter {adapter.id} inited!");
+            }
 
+            // Init modules (Adapter managers)
+            Analytics.Init();
+            Ads.Init();
+            
             _status = Status.Ready;
             _onReadyCallback?.Invoke();
             _onReadyCallback = null;
@@ -108,7 +111,7 @@ namespace Amanotes.Core
         private void Update()
         {
             if (!isReady) return;
-            Analytics.ProcessEventQueue();
+            _frameUpdate?.Invoke();
         }
     }
 
@@ -144,6 +147,16 @@ namespace Amanotes.Core
             _instance = sdk.AddComponent<AmaGDK>();
         }
 
+        public static void BeginCoroutine(IEnumerator enumerator)
+        {
+            _instance.StartCoroutine(enumerator);
+        }
+
+        public static void EndCoroutine(IEnumerator enumerator)
+        {
+            _instance.StopCoroutine(enumerator);
+        }
+
         public static void AddCallback(Action onReady)
         {
             if (onReady == null)

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/Tests/Runtime/MigrationTest.cs

@@ -123,7 +123,7 @@ public class MigrationTest
             analyticsData.eventDetails.Add(new EventDetail
             {
                 eventName = e.Key,
-                count = e.Value
+                totalCount = e.Value
             });
         }
 
@@ -132,7 +132,7 @@ public class MigrationTest
             analyticsData.eventDetails.Add(new EventDetail
             {
                 eventName = "migration_error",
-                count = migrationError
+                totalCount = migrationError
             });
         }
 
@@ -154,7 +154,7 @@ public class MigrationTest
         var eventDetail = analyticsData.GetEventDetail(errEventName);
         if (eventDetail != null)
         {
-            Assert.IsTrue(eventDetail.count == 1);
+            Assert.IsTrue(eventDetail.totalCount == 1);
         }
         else
         {

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "com.amanotes.gdk",
-    "version": "0.1.8",
+    "version": "0.1.10",
     "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"
 }

package/Runtime/Interfaces/Analytics/IAnalytics.cs

@@ -1,6 +0,0 @@
-using System.Collections.Generic;
-
-namespace Amanotes.Core
-{
-    
-}

package/Runtime/Interfaces/Analytics.meta

@@ -1,8 +0,0 @@
-fileFormatVersion: 2
-guid: d1a686515ec7946df9492f35e9638fea
-folderAsset: yes
-DefaultImporter:
-  externalObjects: {}
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: