com.amanotes.gdk 0.2.60 → 0.2.62

package/CHANGELOG.md

@@ -1,5 +1,27 @@
 # Changelog
 
+## [0.2.62 - 2024-05-27]
+- [Dev] Remove pipeline for unity 2020
+- [Dev] Dispatch changes / support callback for when UserId updated
+- Also: Improve log to show UserId in GDK Ready message
+- [Dev] Add GDK Init callback
+- [Feature] Generate Klavar using template
+- [Dev] Add Scriptable object release config
+- [Dev] Add UserContext
+- [Dev] Add Project Auditor
+- [Dev] Various API improvements & update Unity 2021.3.36f1
+- [Dev] Update Klavar generated files
+- [Feature] Download Klavar config from Airtable
+- [Feature] Add checkpoint event
+- [Dev] Get google target sheet every build time
+- [Dev] Update GDK Example project with Unity2021.3.36f1
+- Also: Update AppsFlyer + GMA SDK
+- [Dev] Fix change log post JSON error
+
+## [0.2.61 - 2024-04-25]
+- Add immediate event logging logic
+- [Feature] Improve handling of locked parameters in Klavar
+
 ## [0.2.60 - 2024-04-23]
 - [Feature] Ensured container's context values remain unchanged
 - [Feature] Check sent funnel event

package/Runtime/AmaGDK.Ads.cs

@@ -126,7 +126,7 @@ namespace Amanotes.Core
     }
     public partial class AmaGDK // Ads module
     {
-        public static partial class Event
+        partial class Event
         {
             public const string INTER_REQUEST = nameof(INTER_REQUEST);
             public const string INTER_SHOW_CALLED = nameof(INTER_SHOW_CALLED);
@@ -364,7 +364,7 @@ namespace Amanotes.Core
             /// <param name="interstitialCappingTime"></param>
             /// <param name="rewardedVideoCappingTime"></param>
             /// <returns></returns>
-            public static bool IsCapped(float interstitialCappingTime = 0, float rewardedVideoCappingTime = 0)
+            internal static bool IsCapped(float interstitialCappingTime = 0, float rewardedVideoCappingTime = 0)
             {
                 bool interCapped = (interstitialCappingTime > 0) && TimeSinceLastInterstitialSucceed < interstitialCappingTime;
                 bool rewardCapped = (rewardedVideoCappingTime > 0) && TimeSinceLastVideoRewardSucceed < rewardedVideoCappingTime;

package/Runtime/AmaGDK.Analytics.cs

@@ -38,8 +38,11 @@ namespace Amanotes.Core
                 public HashSet<string> ignoreAdapterIds = null;
                 public HashSet<string> allowAdapterIds = null;
 
+                public int totalCount => detail.totalCount;
+                public int totalCountWithinSession => detail.countInSession;
+
                 private EventDetail _detail;
-                public EventDetail EventDetail
+                internal EventDetail detail
                 {
                     get
                     {
@@ -47,6 +50,7 @@ namespace Amanotes.Core
                         return _detail = localData.GetEventDetail(eventName, true);
                     }
                 }
+                internal bool isLoggedImmediately = false;
 
                 internal EventParams Init(string eventName)
                 {
@@ -126,22 +130,22 @@ namespace Amanotes.Core
                 return LogEvent(eventName, parameters).SetAsFunnel(signature);
             }
             
+            [Obsolete("Please use AmaGDK.Analytics.LogEvent(eventName).LogImmediately() instead")]
             public static void LogEventImmediately(string eventName)
             {
-                var eventParams = PrepareEvent(eventName);
-                LogEventImmediately(eventParams);
+                LogEvent(eventName).LogImmediately();
             }
 
+            [Obsolete("Please use AmaGDK.Analytics.LogEvent(eventName, parameters).LogImmediately() instead")]
             public static void LogEventImmediately(string eventName, Dictionary<string, object> parameters)
             {
-                var eventParams = PrepareEvent(eventName, parameters);
-                LogEventImmediately(eventParams);
+                LogEvent(eventName, parameters).LogImmediately();
             }
 
+            [Obsolete("Please use AmaGDK.Analytics.LogEvent(eventName, parameters).LogImmediately() instead")]
             public static void LogEventImmediately(string eventName, params (string, object)[] parameters)
             {
-                var eventParams = PrepareEvent(eventName, parameters);
-                LogEventImmediately(eventParams);
+                LogEvent(eventName, parameters).LogImmediately();
             }
 
             public static int GetAccumulatedCount(string eventName, bool withinSession = false)
@@ -392,6 +396,9 @@ namespace Amanotes.Core
                 
                 while (eventQueue.TryDequeue(out var eventData))
                 {
+                    if (eventData.isLoggedImmediately) continue;
+                    if (Config.analytics.immediatelyLoggedEvents.Contains(eventData.eventName))
+                        Utils.ThrowExceptionIfEditor($"This event '{eventData.eventName}' must be sent immediately by AmaGDK.Analytics.LogEvent(eventName).LogImmediately()");
                     var (eventNameToSend, inUseAdapterIDs) = LogEventActually(eventData);
                     sessionStat?.Add(eventNameToSend, eventData, inUseAdapterIDs);
                     epPool.Return(eventData);
@@ -472,7 +479,7 @@ namespace Amanotes.Core
                     if (Config.analytics.migrateAccumulatedCount && !eventData.withinSession)
                     {
                         Log($"[Analytics] Update event count of event <{eventData.eventName}> from {countByGDK} to {oriAccCount}");
-                        eventData.EventDetail.totalCount = oriAccCount;
+                        eventData.detail.totalCount = oriAccCount;
                         totalCount = oriAccCount;
                         localData._dirty = true;
                     }
@@ -658,7 +665,7 @@ namespace Amanotes.Core
         public static partial class Analytics
         {
             [Serializable]
-            public class EventDetail
+            internal class EventDetail
             {
                 public string eventName;
                 public int totalCount;
@@ -696,7 +703,7 @@ namespace Amanotes.Core
             }
 
             [Serializable]
-            public class MigrationLog
+            internal class MigrationLog
             {
                 public string deviceId;
                 public string appVersion;
@@ -866,11 +873,15 @@ namespace Amanotes.Core
                 {
                     //Clear() is supported from .Net Standard 2.1
 #if UNITY_2021_3_OR_NEWER
-                    sessionStat?.savedEventStatsInLastFrame.Clear();
+                    savedEventStatsInLastFrame.Clear();
+                    lastFrameEventStats.Clear();
 #else
                     while (savedEventStatsInLastFrame.TryDequeue(out var stat))
                     {
                     }
+                    while (lastFrameEventStats.TryDequeue(out var stat))
+                    {
+                    }
 #endif
                 }
             }
@@ -879,6 +890,27 @@ namespace Amanotes.Core
 
     public static class EventParamsExtension
     {
+        public static void LogImmediately(this IEventParamsBuilder ap)
+        {
+            if (ap == null) return;
+            
+            var data = ap as EventParams;
+            data!.isLoggedImmediately = true;
+            LogEventImmediately(data);
+        }
+        
+        public static IEventParamsBuilder AttachParam_TimeDiffLastFire(this IEventParamsBuilder ap)
+        {
+            var data = ap as EventParams;
+            return data?.AddParam("time_diff_last_fire", Utils.GetTimeDiffLastFire(data.eventName));
+        }
+        
+        public static IEventParamsBuilder AttachParam_InternetConnectionStatus(this IEventParamsBuilder ap)
+        {
+            var data = ap as EventParams;
+            return data?.AddParam("connection", Application.internetReachability == NetworkReachability.ReachableViaLocalAreaNetwork ? "online" : "offline");
+        }
+        
         public static IEventParamsBuilder SetAsFunnel(this IEventParamsBuilder ap, string signature = null)
         {
             if (ap == null) return null;
@@ -1051,13 +1083,12 @@ namespace Amanotes.Core
                 return false;
             }
 
-            if (value.GetType() == typeof(string))
+            if (value is string stringValue)
             {
-                var v = value.ToString();
                 var strLimit = 100;
-                if (v.Length > strLimit)
+                if (stringValue.Length > strLimit)
                 {
-                    value = v.Substring(0, strLimit);
+                    value = stringValue.Substring(0, strLimit);
                     LogWarning($"Param value exceeds the length limit ({strLimit}). Event name: {eventName}, key: {key}!");    
                 }
             }
@@ -1077,6 +1108,7 @@ namespace Amanotes.Core.Internal
         [HideInInspector] public bool checkMigrationIntegrity = true;
         [HideInInspector] public bool migrateAccumulatedCount = true;
         [HideInInspector] public bool enableEventStat;
+        [HideInInspector] public List<string> immediatelyLoggedEvents = new List<string>(){"ad_impression", "ad_impression_ama"};
         public AnalyticQualityConfig quality;
     }
     

package/Runtime/AmaGDK.Context.cs

@@ -0,0 +1,63 @@
+using static Amanotes.Core.Internal.Logging;
+
+namespace Amanotes.Core
+{
+    public partial class AmaGDK 
+    {
+        public static Context Context = new Context();
+    }
+    
+    public partial class Context
+    {
+        public string Location
+        {
+            get => _location;
+            set => SetStringField(ref _location, value, nameof(Location));
+        }
+
+        public string SongACMid
+        {
+            get => _songACMid;
+            set => SetStringField(ref _songACMid, value, nameof(SongACMid));
+        }
+
+        public string SongName
+        {
+            get => _songName;
+            set => SetStringField(ref _songName, value, nameof(SongName));
+        }
+
+        public string SongUnlockType
+        {
+            get => _songUnlockType;
+            set => SetStringField(ref _songUnlockType, value, nameof(SongUnlockType));
+        }
+
+        public string Reward
+        {
+            get => _reward;
+            set => SetStringField(ref _reward, value, nameof(Reward));
+        }
+    }
+
+    public partial class Context // PRIVATE
+    {
+        private string _location;
+        private string _songACMid;
+        private string _songName;
+        private string _songUnlockType;
+        private string _reward;
+
+        private void SetStringField(ref string field, string value, string name)
+        {
+            if (string.IsNullOrWhiteSpace(value))
+            {
+                LogWarning($"[Context] {name} is empty");
+            }
+            else
+            {
+                field = value;
+            }
+        }
+    }
+}

package/Runtime/AmaGDK.Context.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: d8fc30da5e864878af47d27c0caaf2a4
+timeCreated: 1715746839

package/Runtime/AmaGDK.UserProfile.cs

@@ -3,14 +3,28 @@ using System.Text.RegularExpressions;
 using Amanotes.Core.Internal;
 using System.Collections.Generic;
 using UnityEngine;
-using UnityEngine.Serialization;
 
 namespace Amanotes.Core
 {
     public partial class AmaGDK //User profile
     {
+        partial class Event
+        {
+            public const string GDK_USER_ID_UPDATED = nameof(GDK_USER_ID_UPDATED);
+        }
+        
         public static readonly UserProfile User = new UserProfile();
-
+        
+        /// <summary>
+        /// We use multiple IDs to do the user mapping between AppsFlyer, IronSource & Firebase
+        /// The callback triggers when a better UserID (gaid, idfv, pseudoId,...)  was found and replace the current UserId
+        /// </summary>
+        /// <param name="onUserIdChange"></param>
+        public static void SetCallback_OnUserIdUpdated(Action<string> onUserIdChange)
+        {
+            dispatcher.AddListener(Event.GDK_USER_ID_UPDATED, onUserIdChange, false);
+        }
+        
         [Serializable]
         public partial class UserProfile : IJsonFile
         {
@@ -56,6 +70,8 @@ namespace Amanotes.Core
                 {
                     if (_userId == value) return;
                     _userId = value;
+                    Logging.Log($"GDK UserID Updated: {_userId}");
+                    dispatcher.Dispatch(Event.GDK_USER_ID_UPDATED, _userId);
                     Save();
                 }
             }

package/Runtime/AmaGDK.cs

@@ -17,24 +17,23 @@ namespace Amanotes.Core
 {
     public partial class AmaGDK : MonoBehaviour
     {
-        public const string VERSION = "0.2.60";
+        public const string VERSION = "0.2.62";
 
         internal static AmaGDK _instance;
-        internal static Status _status = Status.None;
         internal static bool _allowInit = false;
-        public bool autoInit = true;
+        internal static Status _status = Status.None;
+        private static ConfigAsset _config = null;
         internal static readonly GDKGeoLocation GeoLocation = new GDKGeoLocation();
         internal static readonly GDKServerTime ServerTime = new GDKServerTime();
-        private static ConfigAsset _config = null;
         
-        public static partial class Event
+        
+        public bool autoInit = true;
+        internal static partial class Event
         {
             public const string GDK_HOOK_START = nameof(GDK_HOOK_START);
             public const string GDK_HOOK_END = nameof(GDK_HOOK_END);
             
-            public const string GDK_INIT_START = nameof(GDK_INIT_START);
-            public const string GDK_INIT_END = nameof(GDK_INIT_END);
-            
+            public const string GDK_INIT = nameof(GDK_INIT);
             public const string GDK_READY = nameof(GDK_READY);
             public const string ADAPTER_READY = nameof(ADAPTER_READY);
         }
@@ -141,7 +140,6 @@ namespace Amanotes.Core
 
         IEnumerator InitAdapters(StringBuilder sb)
         {
-            _status = Status.Initialize;
             float TIMEOUT = 1;
             
             // sort on priority
@@ -182,12 +180,19 @@ namespace Amanotes.Core
             }
             
             float startTime = Time.realtimeSinceStartup;
-            
-            dispatcher.Dispatch(Event.GDK_INIT_START);
             var sb = new StringBuilder();
+
             InitModules();
             
+            float moduleTime = Time.realtimeSinceStartup - startTime;
+            sb.Append($"- InitModules() took (~ {moduleTime:#0.00}s)\n");
+            
             yield return InitHook(); //Google CMP takes long at first time (~ 1.7s)
+            float hookTime = Time.realtimeSinceStartup - moduleTime - startTime;
+            sb.Append($"- InitHook() took (~ {hookTime:#0.00}s)\n\n");
+            
+            _status = Status.Initialize;
+            dispatcher.Dispatch(Event.GDK_INIT);
             yield return WaitForManualInit();
             yield return InitAdapters(sb);
             
@@ -199,10 +204,10 @@ namespace Amanotes.Core
                 ServerTime.UpdateTime();
             }
             
-            dispatcher.Dispatch(Event.GDK_INIT_END);
-            
             _status = Status.Ready;
             dispatcher.Dispatch(Event.GDK_READY);
+            
+            sb.Append($"\nMapping UserId: {User.UserId}\n");
             Debug.Log($"AmaGDK v{VERSION} | {READY} in {Time.realtimeSinceStartup - startTime:#0.00}s\n\n{sb}");
         }
 
@@ -230,7 +235,14 @@ namespace Amanotes.Core
     public partial class AmaGDK // PUBLIC APIS
     {
         public static bool isReady => _status == Status.Ready;
-
+        public static bool isInitted => _status >= Status.Initialize;
+        
+        public static LogLevel logLevel
+        {
+            get => Config.common.logLevel;
+            set => Config.common.logLevel = value;
+        }
+        
         public static void Init(Action onReady = null)
         {
             if (isReady)
@@ -257,8 +269,28 @@ namespace Amanotes.Core
             var sdk = new GameObject("AmaGDK");
             _instance = sdk.AddComponent<AmaGDK>();
         }
-
-        public static void SetOnReadyCallback(Action onReady)
+        
+        /// <summary>
+        /// Will be triggered right after all the cached data being loaded
+        /// And before any Adapter has been called to Init
+        /// </summary>
+        /// <param name="onInit"></param>
+        public static void SetCallback_OnGDKInit(Action onInit)
+        {
+            if (isInitted)
+            {
+                onInit.Invoke();
+                return;
+            }
+            
+            dispatcher.AddListener(Event.GDK_INIT, onInit, true);
+        }
+        
+        /// <summary>
+        /// Will be trigger after all adapters have been ready
+        /// </summary>
+        /// <param name="onReady"></param>
+        public static void SetCallback_OnGDKReady(Action onReady)
         {
             if (isReady)
             {

package/Runtime/Internal/AmaGDK.Internal.cs

@@ -22,7 +22,7 @@ namespace Amanotes.Core.Internal
 
     public static class Messsage
     {
-        public const string READY = "Init success";
+        public const string READY = "Ready";
         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!";
@@ -132,7 +132,7 @@ namespace Amanotes.Core.Internal
             }
 
             AmaGDK[] result = Resources.FindObjectsOfTypeAll<AmaGDK>();
-            for (var i = 0; i < result.Length; i++)
+            for (int i = 0; i < result.Length; i++)
             {
                 if (result[i] == null) continue;
 
@@ -175,6 +175,12 @@ namespace Amanotes.Core.Internal
             analyticsData.cachedEventDetails.Clear();
             analyticsData.migrationLog = new MigrationLog();
             analyticsData.SaveIfDirty();
+            sessionStat.Clear();
+#if UNITY_2021_3_OR_NEWER
+            eventQueue.Clear();
+#else
+            while (eventQueue.TryDequeue(out var stat)){}
+#endif
         }
     }
     
@@ -183,8 +189,33 @@ namespace Amanotes.Core.Internal
     public interface IOnApplicationFocus { void OnApplicationFocus(bool hasFocus); }
     public interface IOnFrameUpdate { void OnFrameUpdate(); }
 
-    public static class Utils
+    public static class Utils // Hidden Utils
     {
+        private static readonly Dictionary<string, float> LastFireInSessions = new Dictionary<string, float>();
+
+        public static int GetTimeDiffLastFire(string eventName)
+        {
+            if (!LastFireInSessions.TryGetValue(eventName, out float lastFire))
+            {
+                LastFireInSessions[eventName] = Time.realtimeSinceStartup;
+                return 0;
+            }
+
+            float current = Time.realtimeSinceStartup;
+            int diff = Mathf.RoundToInt(current - lastFire);
+            LastFireInSessions[eventName] = current;
+            return diff;
+        }
+
+        public static void ThrowExceptionIfEditor(string message)
+        {
+            #if UNITY_EDITOR
+            throw new GDKException(message);
+            #else
+            Logging.LogError(message);
+            #endif
+        }
+        
         /// <summary>
         /// Registers the list of server time providers.
         /// </summary>

package/Runtime/Klavar/Attributes/TimeDiffLastFireAttribute.cs

@@ -6,22 +6,10 @@ namespace Amanotes.Core
 {
     public class TimeDiffLastFireAttribute : ConverterLogEventAttribute
     {
-        static readonly Dictionary<string, float> lastFireInSessions = new Dictionary<string, float>();
-
         public override object Convert(object parent, FieldInfo fieldInfo, object param)
         {
-            // return AmaGDK.Ads.InterstitialShowCalledInSession;
             string name = parent.GetType().FullName;
-            if (!lastFireInSessions.TryGetValue(name, out var lastFire))
-            {
-                lastFireInSessions[name] = Time.realtimeSinceStartup;
-                return 0;
-            }
-
-            var current = Time.realtimeSinceStartup;
-            var diff = Mathf.RoundToInt(current - lastFire);
-            lastFireInSessions[name] = current;
-            return diff;
+            return Internal.Utils.GetTimeDiffLastFire(name);
         }
     }
 

package/Runtime/Klavar/KlavarEvent.cs

@@ -33,7 +33,15 @@ namespace Amanotes.Core
                 @params[kvp.Key] = kvp.Value;
             }
             
-            AmaGDK.Analytics.LogEvent(eventName, @params);
+            if (AmaGDK.Config.analytics.immediatelyLoggedEvents.Contains(eventName))
+            {
+                AmaGDK.Analytics.LogEvent(eventName, @params).LogImmediately();
+            }
+            else
+            {
+                AmaGDK.Analytics.LogEvent(eventName, @params);    
+            }
+            
         }
 
 
@@ -107,5 +115,17 @@ namespace Amanotes.Core
                 additionalParameters[kvp.Key] = kvp.Value;
             }
         }
+
+        /// <summary>
+        /// AttachContainerParameters method attaches container parameters to the event.
+        /// </summary>
+        /// <param name="parameters">The container parameters to attach.</param>
+        public void AttachContainerParameters(params (string, object)[] parameters)
+        {
+            foreach ((string key, object value) in parameters)
+            {
+                additionalParameters[key] = value;
+            }
+        }
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "com.amanotes.gdk",
-    "version": "0.2.60",
+    "version": "0.2.62",
     "displayName": "AmaGDK",
     "description": "Amanotes Game Development Kit",
     "unity": "2019.4",