com.amanotes.gdk 0.1.15 → 0.1.17

package/CHANGELOG.md

@@ -1,5 +1,14 @@
 # Changelog
 
+## [0.1.17 - 2023-03-13]
+### Release AmaGDK v0.1.17
+### Rename Analytics APIs
+
+## [0.1.16 - 2023-03-10]
+### Release AmaGDK v0.1.16
+### SemVer supports 4 parts
+### Analytics supports EventConfig
+
 ## [0.1.15 - 2023-03-06]
 ### Release AmaGDK v0.1.15
 ### Fix null exception in VersionExtractor

package/Runtime/AmaGDK.Analytics.cs

@@ -54,7 +54,7 @@ namespace Amanotes.Core
                     get { return !string.IsNullOrEmpty(funnelSignature); }
                 }
 
-                public bool IsForbidden(string adapterId)
+                public bool IsAdapterForbidden(string adapterId)
                 {
                     if (ignoreAdapterIds.Count > 0)
                     {
@@ -69,10 +69,24 @@ namespace Amanotes.Core
                     Debug.LogWarning("[AmaGDK] Should never be here: overrideConfig == true but no id in listAdapterIds!");
                     return false;
                 }
+
+                public bool IsSkippedBySendAtCountConfig()
+                {
+                    if (!sendAtCount.TryGetValue(eventName, out var sendAtCountConfig)) return false;
+
+                    int accumulatedCount = GetAccumulatedCount(eventName, sendAtCountConfig.withinSession);
+                    return sendAtCountConfig.listCount == null ? false : !sendAtCountConfig.listCount.Contains(accumulatedCount);
+                }
             }
 
             public static IEventParamsBuilder LogEvent(string eventName)
             {
+                if (string.IsNullOrWhiteSpace(eventName))
+                {
+                    LogWarningOnce($"Invalid EventName: <{eventName}> ");
+                    return null;
+                }
+
                 var result = new EventParams(eventName);
                 eventQueue.Enqueue(result);
                 return result;
@@ -80,20 +94,16 @@ namespace Amanotes.Core
 
             public static IEventParamsBuilder LogEvent(string eventName, Dictionary<string, object> parameters)
             {
-                var result = new EventParams(eventName);
-                result.AddParam(parameters);
-                eventQueue.Enqueue(result);
-                return result;
+                return LogEvent(eventName).AddParam(parameters);                
             }
 
             public static IEventParamsBuilder LogEvent(string eventName, params (string, object)[] parameters)
             {
-                var result = new EventParams(eventName);
+                var result = LogEvent(eventName);
                 for (var i = 0;i < parameters.Length; i++)
                 {
                     result.AddParam(parameters[i].Item1, parameters[i].Item2);
-                }
-                eventQueue.Enqueue(result);
+                }                
                 return result;
             }
 
@@ -216,28 +226,58 @@ namespace Amanotes.Core
                 localData.UpdateMigrationLog();
             }
 
-            public static void SetPermittedEvents(List<string> eventNames, params string[] adapterIDs)
+            public static void OnlyAllowEvents(List<string> eventNames, params string[] adapterIDs)
             {
                 foreach (var adapterID in adapterIDs)
                 {
                     var adapter = listAdapters.Find(a => a.id == adapterID)?.GetAdapterApi<IAnalyticAdapter>();
-                    adapter?.SetPermittedEvents(eventNames);
+                    adapter?.OnlyAllowEvents(eventNames);
                 }
             }
 
-            public static void SetForbiddenEvents(List<string> eventNames, params string[] adapterIDs)
+            public static void OnlyBanEvents(List<string> eventNames, params string[] adapterIDs)
             {
                 foreach (var adapterID in adapterIDs)
                 {                    
                     var adapter = listAdapters.Find(a => a.id == adapterID)?.GetAdapterApi<IAnalyticAdapter>();
-                    adapter?.SetForbiddenEvents(eventNames);
+                    adapter?.OnlyBanEvents(eventNames);
+                }
+            }
+
+            public static void OnlySendAtCount(string eventName, List<int> listCount, bool withinSession = false, bool appendCountToEventName = false, string numberFormat = "00")
+            {
+                var config = new EventConfig
+                {
+                    listCount = listCount,
+                    withinSession = withinSession,
+                    appendCountToEventName = appendCountToEventName,
+                    numberFormat = numberFormat
+                };
+
+                if (sendAtCount.ContainsKey(eventName))
+                {
+                    LogWarning($"{eventName} has already been set list of count number to log.");
+                    sendAtCount[eventName] = config;                    
                 }
+                else
+                {
+                    sendAtCount.Add(eventName, config);
+                }                
             }
         }
 
         //INTERNAL
         public static partial class Analytics
         {
+            internal class EventConfig
+            {
+                public List<int> listCount;
+                public bool withinSession;
+                public bool appendCountToEventName;
+                public string numberFormat;                
+            }
+
+            internal static readonly Dictionary<string, EventConfig> sendAtCount = new Dictionary<string, EventConfig>();
             internal static Predicate<EventDetail> logEventHook = null;
             internal static readonly Queue<EventParams> eventQueue = new Queue<EventParams>();
             internal static readonly List<AdapterInfo> listAdapters = new List<AdapterInfo>();
@@ -260,10 +300,6 @@ namespace Amanotes.Core
                 while (eventQueue.Count > 0)
                 {
                     var eventData = eventQueue.Dequeue();
-
-                    if (!NormalizeEventName(ref eventData.eventName))
-                        continue;
-
                     var (countInSession, totalCount) = localData.IncreaseCounter(eventData.eventName);
 
                     if (!ShouldSendEvent(eventData))
@@ -274,24 +310,29 @@ namespace Amanotes.Core
                         eventData.AddParam("accumulated_count", eventData.withinSession ? countInSession : totalCount);
                     }
 
-                    if (showAnalyticsLog) Debug.Log($"[AmaGDK] Event <{eventData.eventName}> (in session: {countInSession}, total: {totalCount})");
+                    var eventNameToSend = GetEventNameToSend(eventData.eventName, countInSession, totalCount);
+                    NormalizeEventName(ref eventNameToSend);
+
+                    if (showAnalyticsLog) Debug.Log($"[AmaGDK] Event <{eventNameToSend}> (in session: {countInSession}, total: {totalCount})");
                     foreach (var m in listAdapters)
                     {                        
-                        m.GetAdapterApi<IAnalyticAdapter>().LogEvent(eventData);                        
+                        m.GetAdapterApi<IAnalyticAdapter>().LogEvent(eventNameToSend, eventData);
                     }
                 }
 
                 localData.SaveIfDirty();
             }
 
-            internal static bool NormalizeEventName(ref string eventName)
+            internal static string GetEventNameToSend(string eventName, int countInSession, int totalCount)
             {
-                if (string.IsNullOrWhiteSpace(eventName))
-                {
-                    LogWarningOnce($"Invalid EventName: <{eventName}> ");
-                    return false;
-                }
+                if (!sendAtCount.TryGetValue(eventName, out var config)) return eventName;
+                if (!config.appendCountToEventName) return eventName;
 
+                return $"{eventName}_{(config.withinSession ? countInSession : totalCount).ToString(config.numberFormat)}";
+            }
+
+            internal static bool NormalizeEventName(ref string eventName)
+            {
                 var sb = tmpWarningSB;
                 sb.Clear();
 
@@ -325,10 +366,20 @@ namespace Amanotes.Core
                     return localData.AddFunnelSignature(eventData.funnelSignature);
                 }
 
+                //Check predefined event count config
+                if (eventData.IsSkippedBySendAtCountConfig())
+                {
+                    return false;
+                }
+
                 //Check the rule to log event
-                if (logEventHook == null) return true;
-                var eventDetail = localData.GetEventDetail(eventData.eventName, true);
-                return logEventHook(eventDetail);
+                if (logEventHook != null)
+                {
+                    var eventDetail = localData.GetEventDetail(eventData.eventName, true);
+                    return logEventHook(eventDetail);
+                }
+
+                return true;
             }
         }
 
@@ -584,7 +635,7 @@ namespace Amanotes.Core
             }
 
             return true;
-        }
+        }        
 
     }
 }
@@ -600,14 +651,14 @@ namespace Amanotes.Core.Internal
 
     public interface IAnalyticAdapter
     {
-        void LogEvent(EventParams eventData);
+        void LogEvent(string eventNameToSend, EventParams eventData);
 
         void SetUserId(string userId);
 
         void SetUserProperty(string key, string value);
 
-        void SetPermittedEvents(List<string> eventNames);
+        void OnlyAllowEvents(List<string> eventNames);
 
-        void SetForbiddenEvents(List<string> eventNames);
+        void OnlyBanEvents(List<string> eventNames);
     }
 }

package/Runtime/AmaGDK.Internal.SemVer.cs

@@ -12,12 +12,14 @@ namespace Amanotes.Core.Internal
         public int major;
         public int minor;
         public int patch;
+        public int extra;
 
-        public SemVer(int major, int minor, int patch)
+        public SemVer(int major, int minor, int patch, int extra = -1)
         {
             this.major = major;
             this.minor = minor;
             this.patch = patch;
+            this.extra = extra;
         }
 
         public SemVer(string version)
@@ -25,6 +27,7 @@ namespace Amanotes.Core.Internal
             major = 0;
             minor = 0;
             patch = 0;
+            extra = -1;
 
             if (string.IsNullOrEmpty(version))
             {
@@ -33,7 +36,7 @@ namespace Amanotes.Core.Internal
 
             version = version.Trim();
 
-            Regex regex = new Regex(@"^(\d+)\.(\d+)\.(\d+)$");
+            Regex regex = new Regex(@"^(\d+)\.(\d+)\.(\d+)(?:\.(\d+))?$");
             Match match = regex.Match(version);
             if (!match.Success)
             {
@@ -43,6 +46,12 @@ namespace Amanotes.Core.Internal
             major = int.Parse(match.Groups[1].Value);
             minor = int.Parse(match.Groups[2].Value);
             patch = int.Parse(match.Groups[3].Value);
+            if (match.Groups.Count > 3)
+            {
+                if (!int.TryParse(match.Groups[4].Value, out extra))
+                    extra = -1;
+            }
+                
         }
 
         public bool isValid { get { return this != ZERO; } }
@@ -50,6 +59,7 @@ namespace Amanotes.Core.Internal
         public override string ToString()
         {
             if (this == ZERO) return "-";
+            if (extra != -1) return $"{major}.{minor}.{patch}.{extra}";
             return $"{major}.{minor}.{patch}";
         }
 
@@ -67,6 +77,10 @@ namespace Amanotes.Core.Internal
             {
                 return patch.CompareTo(other.patch);
             }
+            if (extra != other.extra)
+            {
+                return extra.CompareTo(other.extra);
+            }
             return 0;
         }
 
@@ -82,7 +96,7 @@ namespace Amanotes.Core.Internal
                 return false;
             }
             SemVer other = (SemVer)obj;
-            return major == other.major && minor == other.minor && patch == other.patch;
+            return major == other.major && minor == other.minor && patch == other.patch && extra == other.extra;
         }
 
         public static bool operator >(SemVer x, SemVer y)
@@ -117,7 +131,7 @@ namespace Amanotes.Core.Internal
 
         public override int GetHashCode()
         {
-            return (major << 16) | (minor << 8) | patch;
+            return (major << 24) | (minor << 16) | (patch << 8) | extra;
         }
     }
 }

package/Runtime/AmaGDK.Utils.cs

@@ -1,4 +1,5 @@
 using System;
+using System.Collections.Generic;
 using System.IO;
 using UnityEngine;
 
@@ -75,7 +76,7 @@ namespace Amanotes.Core.Internal
             catch (Exception ex)
             {
                 LogWarningOnce(path + "\n" + ex);
-            }            
+            }
         }
 
         private static string _basePath;
@@ -92,7 +93,73 @@ namespace Amanotes.Core.Internal
                 return _basePath;
             }
         }
-    }        
+    }
+
+    public class ActionQueue
+    {
+        private Queue<Action<Action>> queue;
+        private bool isProcessing = false;
+        private Action onComplete;
+
+        public ActionQueue(Action onComplete)
+        {
+            queue = new Queue<Action<Action>>();
+            this.onComplete = onComplete;
+        }
+
+        public void EnqueueAction(params Action<Action>[] actions)
+        {
+            if (isProcessing)
+            {
+                LogWarning("queue is processing!");
+                return;
+            }
+
+            foreach (var action in actions)
+            {
+                if (action == null)
+                {
+                    LogWarning("action is null!");
+                    continue;
+                }
+                queue.Enqueue(action);
+            }
+
+            ProcessQueue();
+        }
+
+        private void ProcessQueue()
+        {
+            if (isProcessing)
+                return;
+            if (queue.Count == 0)
+            {
+                onComplete?.Invoke();
+                return;
+            }
+
+            Action<Action> nextAction = null;
+            while (queue.Count > 0)
+            {
+                nextAction = queue.Dequeue();
+                if (nextAction != null)
+                {
+                    isProcessing = true;
+                    nextAction.Invoke(ActionCompleted);
+                    return;
+                }
+            }
+
+            if(nextAction == null)
+                onComplete?.Invoke();
+        }
+
+        private void ActionCompleted()
+        {
+            isProcessing = false;
+            ProcessQueue();
+        }
+    }
 
     internal interface IJsonFile { }
 

package/Runtime/AmaGDK.cs

@@ -12,7 +12,7 @@ namespace Amanotes.Core
 {
     public partial class AmaGDK : MonoBehaviour
     {
-        public const string VERSION = "0.1.15";
+        public const string VERSION = "0.1.17";
 
         internal static AmaGDK _instance;
         internal static event Action _frameUpdate;
@@ -100,7 +100,7 @@ namespace Amanotes.Core
 
             // Init modules (Adapter managers)
             Analytics.Init();
-            Ads.Init();
+            //Ads.Init();
             
             _status = Status.Ready;
             _onReadyCallback?.Invoke();

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "com.amanotes.gdk",
-    "version": "0.1.15",
+    "version": "0.1.17",
     "displayName": "AmaGDK",
     "description": "Amanotes Game Development Kit",
     "unity": "2020.3",