com.amanotes.gdk 0.2.51 → 0.2.53

package/Extra/{AndroidPostProcessor.unitypackage.meta → ForceUpdate.unitypackage.meta}

@@ -1,5 +1,5 @@
 fileFormatVersion: 2
-guid: e331d1b8f5c1d49bc8ef6ea5239e4ca4
+guid: 2e197f38dc0b2460b9efe8fa5958a370
 DefaultImporter:
   externalObjects: {}
   userData: 

package/Extra/PostProcessor.unitypackage.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: ee4588fce1b7043429e48574edb72bde
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Runtime/AmaGDK.Analytics.cs

@@ -17,39 +17,63 @@ namespace Amanotes.Core
         public static partial class Analytics
         {
             public static bool HasMigrated => localData.migrationLog.count > 0;
+            
+            public static bool enableAnalyticsLog
+            {
+                set => Config.analytics.showAnalyticsLog = value;
+                get => Config.analytics.showAnalyticsLog;
+            }
 
             public interface IEventParamsBuilder { }            
 
             public class EventParams : IEventParamsBuilder
             {
-                public readonly string eventName;
-                public Dictionary<string, object> parameters = new Dictionary<string, object>();
+                public string eventName { get; private set; }
+                public readonly Dictionary<string, object> parameters = new Dictionary<string, object>();
                 public string funnelSignature;
                 public bool accumulated;
                 public bool withinSession;
                 public bool doNotIncreaseCounter;
 
                 public bool overrideConfig;
-                public HashSet<string> ignoreAdapterIds = new HashSet<string>();
-                public HashSet<string> allowAdapterIds = new HashSet<string>();
+                public HashSet<string> ignoreAdapterIds = null;
+                public HashSet<string> allowAdapterIds = null;
 
-                public EventDetail EventDetail => localData.GetEventDetail(eventName, true);
+                private EventDetail _detail;
+                public EventDetail EventDetail
+                {
+                    get
+                    {
+                        if (_detail != null) return _detail;
+                        return _detail = localData.GetEventDetail(eventName, true);
+                    }
+                }
 
-                public EventParams(string eventName)
+                internal EventParams Init(string eventName)
                 {
                     this.eventName = eventName;
+                    parameters.Clear();
+                    funnelSignature = "";
+                    accumulated = false;
+                    withinSession = false;
+                    doNotIncreaseCounter = false;
+                    overrideConfig = false;
+                    ignoreAdapterIds = null;
+                    allowAdapterIds = null;
+                    _detail = null;
+                    return this;
                 }
 
                 public bool IsFunnelEvent => !string.IsNullOrEmpty(funnelSignature);
 
                 public bool IsAdapterForbidden(string adapterId)
                 {
-                    if (ignoreAdapterIds.Count > 0)
+                    if (ignoreAdapterIds != null && ignoreAdapterIds.Count > 0)
                     {
                         return ignoreAdapterIds.Contains(adapterId);
                     }
 
-                    if (allowAdapterIds.Count > 0)
+                    if (allowAdapterIds != null && allowAdapterIds.Count > 0)
                     {
                         return !allowAdapterIds.Contains(adapterId);
                     }
@@ -164,12 +188,13 @@ namespace Amanotes.Core
                     }
 
                 if (eventCountMap != null)
+                {
                     foreach (KeyValuePair<string, int> e in eventCountMap)
                     {
                         EventDetail eventDetail = localData.GetEventDetail(e.Key);
                         if (eventDetail == null)
                         {
-                            localData.eventDetails.Add(new EventDetail
+                            localData.AddEventDetail(new EventDetail
                             {
                                 eventName = e.Key,
                                 totalCount = e.Value
@@ -188,6 +213,8 @@ namespace Amanotes.Core
                             eventDetail.totalCount += e.Value;
                         }
                     }
+                }
+                    
                 
                 Profiler.EndSample();
                 return flag;
@@ -252,8 +279,10 @@ namespace Amanotes.Core
             internal static Predicate<EventParams> logEventHook;
             internal static readonly ConcurrentQueue<EventParams> eventQueue = new ConcurrentQueue<EventParams>();
             internal static readonly List<AnalyticsAdapter> listAdapters = new List<AnalyticsAdapter>();
-            internal static readonly AnalyticsData localData = new AnalyticsData().LoadJsonFromFile();
-            internal static readonly SessionStat sessionStat = new SessionStat();
+            internal static readonly AnalyticsData localData = new AnalyticsData().LoadJsonFromFile().BuildCache();
+            internal static readonly SessionStat sessionStat = _config.analytics.enableEventStat ? new SessionStat() : null;
+            internal static readonly Pool<StringBuilder> sbPool = new Pool<StringBuilder>(3);
+            internal static readonly Pool<EventParams> epPool = new Pool<EventParams>(1);
 
             internal static readonly Dictionary<string, string> reservedPrefixes = new Dictionary<string, string>()
             {
@@ -315,7 +344,7 @@ namespace Amanotes.Core
             internal static EventParams PrepareEvent(string eventName)
             {
                 PrepareEventCheck(eventName);
-                var result = new EventParams(eventName);
+                var result = epPool.Get().Init(eventName);
                 PostPrepareEventProcess(result);
                 return result;
             }
@@ -324,7 +353,7 @@ namespace Amanotes.Core
             {
                 if (parameters == null) return PrepareEvent(eventName);
                 PrepareEventCheck(eventName);
-                var result = new EventParams(eventName);
+                var result = epPool.Get().Init(eventName);
                 result.AddParam(parameters);
                 PostPrepareEventProcess(result);
                 return result;
@@ -334,7 +363,7 @@ namespace Amanotes.Core
             {
                 if (parameters == null) return PrepareEvent(eventName);
                 PrepareEventCheck(eventName);
-                var result = new EventParams(eventName);
+                var result = epPool.Get().Init(eventName);
                 for (var i = 0; i < parameters.Length; i++)
                 {
                     result.AddParam(parameters[i].Item1, parameters[i].Item2);
@@ -348,18 +377,18 @@ namespace Amanotes.Core
                 if (eventQueue.Count <= 0) return;
 
                 Profiler.BeginSample("AmaGDK.Analytics.ProcessEventQueue()");
-                
-                sessionStat.savedEventStatsInLastFrame.Clear();
+
+                sessionStat?.Clear();
                 
                 while (eventQueue.TryDequeue(out var eventData))
                 {
                     var (eventNameToSend, inUseAdapterIDs) = LogEventActually(eventData);
-                    if (string.IsNullOrEmpty(eventNameToSend) || inUseAdapterIDs == null) continue;
-                    sessionStat.Add(eventNameToSend, eventData, inUseAdapterIDs);
+                    sessionStat?.Add(eventNameToSend, eventData, inUseAdapterIDs);
+                    epPool.Return(eventData);
                 }
 
                 localData.SaveIfDirty();
-                sessionStat.Save();
+                sessionStat?.Save();
 				Profiler.EndSample();
             }
 
@@ -384,7 +413,7 @@ namespace Amanotes.Core
                     
                 config.quality.CheckEventQuality(eventParams.eventName, eventParams.parameters);
 
-                var inUseAdapterIDs = new List<string>();
+                var inUseAdapterIDs = config.enableEventStat ? new List<string>(listAdapters.Count) : null;
                 foreach (AnalyticsAdapter m in listAdapters)
                 {
                     if (eventParams.overrideConfig)
@@ -400,7 +429,7 @@ namespace Amanotes.Core
                         if (m.IsForbidden(eventParams.eventName)) continue;
                     }
                     m.LogEvent(eventNameToSend, eventParams.parameters);
-                    inUseAdapterIDs.Add(m.adapterId);
+                    inUseAdapterIDs?.Add(m.adapterId);
                 }
 
                 return (eventNameToSend, inUseAdapterIDs);
@@ -409,9 +438,9 @@ namespace Amanotes.Core
             internal static void LogEventImmediately(EventParams eventParams)
             {
                 var (eventNameToSend, inUseAdapterIDs) = LogEventActually(eventParams);
-                if (string.IsNullOrEmpty(eventNameToSend) || inUseAdapterIDs == null) return;
-                sessionStat.Add(eventNameToSend, eventParams, inUseAdapterIDs);
-                sessionStat.Save();
+                sessionStat?.Add(eventNameToSend, eventParams, inUseAdapterIDs);
+                epPool.Return(eventParams);
+                sessionStat?.Save();
                 localData.SaveIfDirty();
             }
 
@@ -452,12 +481,13 @@ namespace Amanotes.Core
             {
                 Profiler.BeginSample("AmaGDK.Analytics.NormalizeEventName()");
                 {
-                    StringBuilder sb = tmpWarningSB;
+                    StringBuilder sb = sbPool.Get();
                     sb.Clear();
                     NormalizeKeyString(ref eventName, sb, dryRun);
                     if (reservedEvents.Contains(eventName))
                         sb.AppendLine($" - EventName <{eventName}> is reserved and should not be used");
-                    if (sb.Length > 0 && dryRun) LogWarningOnce($"Warning for event name <{eventName}>:\n{sb}", $"NormalizeEventName<{eventName}>");    
+                    if (sb.Length > 0 && dryRun) LogWarningOnce($"NormalizeEventName <{eventName}> warnings:\n{sb}\n", $"NormalizeEventName<{eventName}>");
+                    sbPool.Return(sb);
                 }
                 Profiler.EndSample();
             }
@@ -473,57 +503,103 @@ namespace Amanotes.Core
                         return;
                     }
 
-                    var sb = new StringBuilder();
+                    var tempLog = Config.common.logLevel == LogLevel.None ? null : sbPool.Get();
+                    tempLog?.Clear();
+                    
+                    var tempKey = sbPool.Get();
+                    tempKey.Clear();
                     
-                    string normalizedString = key.Trim()
-                        .Replace(' ', '_')
-                        .Replace('-', '_');
-                    if (key != normalizedString)
+                    var hasChanged = false;
+                    var trimKey = key.Trim();
+                    
+                    foreach (var c in trimKey)
                     {
-                        sb.Append($" - Malformed name (should not contains <space> or <dash>): <{key}>");    
+                        var isLetter = IsAlphabet(c);
+                        var isNumber = char.IsDigit(c);
+
+                        if (c == '_' || isLetter || isNumber)
+                        {
+                            tempKey.Append(c);
+                            continue;
+                        }
+                        
+                        hasChanged = true;
+                        if (c == ' ' || c == '-')
+                        {
+                            tempKey.Append('_');
+                        }
                     }
 
-                    var r = new Regex("^[a-zA-Z0-9_]*$");
-                    if (!r.IsMatch(normalizedString))
+                    if (hasChanged)
                     {
-                        normalizedString = Regex.Replace(normalizedString, "[^a-zA-Z0-9_]", "");
-                        sb.Append(" - Name may only contain alphanumeric characters and underscores");
+                        tempLog?.Append(" - Name may only contain alphanumeric characters and underscores");
                     }
-
-                    if (!char.IsLetter(normalizedString[0]))
+                    
+                    if (tempKey.Length > 0 && !IsAlphabet(tempKey[0]))
                     {
-                        normalizedString = "E" + normalizedString;
-                        sb.Append($" - Name must start with a letter: <{key}> ");
+                        hasChanged = true;
+                        tempKey.Insert(0, 'E');
+                        tempLog?.Append($" - Name must start with a letter: <{key}>");
                     }
-
+                    
                     foreach (var prefix in reservedPrefixes)
                     {
-                        if (!normalizedString.StartsWith(prefix.Key)) continue;
-                        normalizedString = prefix.Value + normalizedString.Remove(0, prefix.Key.Length);
-                        sb.AppendLine($" - <{key}> starts with reserved prefix <{prefix}>");
+                        if (tempKey.Length < prefix.Key.Length || !StringStartsWith(tempKey, prefix.Key)) continue;
+                        hasChanged = true;
+                        tempKey.Remove(0, prefix.Key.Length);
+                        tempKey.Insert(0, prefix.Value);
+                        tempLog?.AppendLine($" - <{key}> starts with reserved prefix <{prefix}>");
                     }
 
-                    if (normalizedString.Length > 40)
+                    if (trimKey.Length > 40)
                     {
-                        sb.AppendLine($" - Name is too long ({key.Length} > 40): <{key}> ");
-                        normalizedString = normalizedString.Substring(0, 40);
+                        hasChanged = true;
+                        tempLog?.AppendLine($" - Name is too long ({key.Length} > 40): <{key}> ");
+                        tempKey.Length = 40;
                     }
                     
                     if (dryRun)
                     {
-                        warningLog.Append(sb);
+                        warningLog.Append(tempLog);
                     } else {
-                        key = normalizedString;
+                        if (hasChanged) key = tempKey.ToString();
                     }
+                    
+                    if (tempLog != null) sbPool.Return(tempLog);
+                    sbPool.Return(tempKey);
                 }
                 Profiler.EndSample();
             }
+            
+            private static bool StringStartsWith(StringBuilder stringBuilder, string prefix)
+            {
+                if (stringBuilder == null || prefix == null)
+                    return false;
+
+                if (stringBuilder.Length < prefix.Length)
+                    return false;
+
+                for (int i = 0; i < prefix.Length; i++)
+                {
+                    if (stringBuilder[i] != prefix[i])
+                        return false;
+                }
+
+                return true;
+            }
+
+            private static bool IsAlphabet(char c)
+            {
+                if (c >= 'A' && c <= 'Z') return true;
+                if (c >= 'a' && c <= 'z') return true;
+                return false;
+            }
 
             internal static void PrepareEventCheck(string eventName)
             {
                 NormalizeEventName(ref eventName, true);
                 
-                if (localData.GetEventDetail(eventName) == null && localData.eventDetails.Count >= 500)
+                if (localData.GetEventDetail(eventName) == null && localData.totalEventDetailCount >= 500)
                 {
                     LogWarning($" - You have reported 500 types of events. New event <{eventName}> will be ignored.");
                 }
@@ -625,23 +701,63 @@ namespace Amanotes.Core
             internal class AnalyticsData : IJsonFile
             {
                 public List<string> funnelSignatures = new List<string>();
-                public List<EventDetail> eventDetails = new List<EventDetail>();
+                
                 public MigrationLog migrationLog = new MigrationLog();
                 [NonSerialized] internal bool _dirty;
-
+                
+                [SerializeField] internal List<EventDetail> eventDetails = new List<EventDetail>();
+                internal readonly Dictionary<string, EventDetail> cachedEventDetails = new Dictionary<string, EventDetail>();
+                
+                public int totalEventDetailCount => eventDetails.Count;
+                public bool AddEventDetail(EventDetail ed)
+                {
+                    if (cachedEventDetails.ContainsKey(ed.eventName))
+                    {
+                        Debug.LogWarning($"EventName <{ed.eventName}> existed!");
+                        return false;
+                    }
+                    
+                    eventDetails.Add(ed);
+                    cachedEventDetails.Add(ed.eventName, ed);
+                    return true;
+                }
+                
+                internal AnalyticsData BuildCache()
+                {
+                    if (cachedEventDetails.Count > 0)
+                    {
+                        LogWarning("BuildCache should be called once!");
+                        cachedEventDetails.Clear();
+                    }
+                    
+                    for (var i = 0; i < eventDetails.Count; i++)
+                    {
+                        var item = eventDetails[i];
+                        if (cachedEventDetails.ContainsKey(item.eventName))
+                        {
+                            LogWarning($"Duplicated eventName <{item.eventName}> entry found in AnalyticData!");
+                            continue;
+                        }
+                        cachedEventDetails.Add(item.eventName, item);
+                    }
+                    return this;
+                }
+                
                 internal EventDetail GetEventDetail(string eventName, bool autoNew = false)
                 {
                     if (string.IsNullOrEmpty(eventName)) return null;
 
-                    EventDetail result = eventDetails.Find(e => e.eventName == eventName);
-                    if (result != null) return result;
+                    if (cachedEventDetails.TryGetValue(eventName, out var result))
+                    {
+                        return result;
+                    }
                     if (autoNew == false) return null;
 
                     result = new EventDetail
                     {
                         eventName = eventName
                     };
-                    eventDetails.Add(result);
+                    AddEventDetail(result);
                     _dirty = true;
                     return result;
                 }
@@ -706,14 +822,13 @@ namespace Amanotes.Core
 
                 internal void Add(string eventNameToSend, EventParams eventParams, List<string> adapterIDs)
                 {
+                    if (string.IsNullOrEmpty(eventNameToSend) || adapterIDs == null) return;
                     var eventStat = new EventStat(eventNameToSend, eventParams, adapterIDs);
                     lastFrameEventStats.Enqueue(eventStat);
                 }
 
                 internal void Save()
                 {
-                    if (!Config.analytics.enableEventStat || lastFrameEventStats.Count == 0) return;
-
                     contents.Clear();
                     if (isFirstSave)
                     {
@@ -728,9 +843,19 @@ namespace Amanotes.Core
 
                     GDKFileUtils.SaveAppend(fileName, contents.ToString());
                 }
+
+                internal void Clear()
+                {
+                    //Clear() is supported from .Net Standard 2.1
+#if UNITY_2021_3_OR_NEWER
+                    sessionStat?.savedEventStatsInLastFrame.Clear();
+#else
+                    while (savedEventStatsInLastFrame.TryDequeue(out var stat))
+                    {
+                    }
+#endif
+                }
             }
-            
-            
         }
     }
 
@@ -781,6 +906,8 @@ namespace Amanotes.Core
             }
 
             eventData.overrideConfig = true;
+            eventData.ignoreAdapterIds ??= new HashSet<string>();
+            
             foreach (string mId in analyticIds)
             {
                 eventData.ignoreAdapterIds.Add(mId);
@@ -805,6 +932,8 @@ namespace Amanotes.Core
             }
 
             eventData.overrideConfig = true;
+            eventData.allowAdapterIds ??= new HashSet<string>();
+            
             foreach (string mId in analyticIds)
             {
                 eventData.allowAdapterIds.Add(mId);
@@ -879,11 +1008,12 @@ namespace Amanotes.Core
         {
             string eventName = (ap as EventParams)?.eventName;
             
-            StringBuilder sb = tmpWarningSB;
+            StringBuilder sb = sbPool.Get();
             sb.Clear();
             NormalizeKeyString(ref key, sb, AmaGDK.Config.analytics.normalizeEventName);
             
             if (sb.Length > 0) LogWarningOnce($"Warning for event <{eventName}>, param <{key}>:\n{sb}", $"NormalizeParamKey <{eventName}>");
+            sbPool.Return(sb);
             
             if (string.IsNullOrWhiteSpace(key))
             {
@@ -918,7 +1048,7 @@ namespace Amanotes.Core.Internal
     [Serializable] public class AnalyticsConfig
     {
         // [Header("-----     MODULE CONFIG      -----")]
-        public bool showAnalyticsLog = true;
+        public bool showAnalyticsLog;
         public bool normalizeEventName = true;
         public bool checkMigrationIntegrity = true;
         public bool migrateAccumulatedCount = true;

package/Runtime/AmaGDK.cs

@@ -17,7 +17,7 @@ namespace Amanotes.Core
 {
     public partial class AmaGDK : MonoBehaviour
     {
-        public const string VERSION = "0.2.51";
+        public const string VERSION = "0.2.53";
 
         internal static AmaGDK _instance;
         internal static Status _status = Status.None;
@@ -90,7 +90,7 @@ namespace Amanotes.Core
             });
             yield return new WaitUntil(() => hookCompleted);
             float elapsed = Time.realtimeSinceStartup - stTime;
-            Log($"[Hook] {nHooks} hooks complete after " + elapsed);
+            Log($"[Hook] {nHooks} hooks complete after {elapsed} secs");
             dispatcher.Dispatch(Event.GDK_HOOK_END);
         }
         
@@ -304,10 +304,10 @@ namespace Amanotes.Core
     public partial class  AmaGDK // Switch dev mode
     {
         #if UNITY_EDITOR
-        [ContextMenu("Change Dev Mode")]
+        [ContextMenu("Change To Dev Mode")]
         public void ChangeDevMode()
         {
-            string variableName = "GDK_HOME";
+            const string variableName = "GDK_HOME";
             string zshrcPath = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.UserProfile), ".zshrc");
             string zshrcContent;
         
@@ -341,13 +341,19 @@ namespace Amanotes.Core
                     Debug.LogWarning($"{variableName} environment variable is set but has an empty value in {zshrcPath}.");
                     return;
                 }
+
+                if (!Directory.Exists(gdkHomeValue))
+                {
+                    Debug.LogWarning($"{variableName} environment variable is set to <{gdkHomeValue}> but the path is not exist!");
+                    return;
+                }
             }
         
             string output = RunShellCommand($"source ~/.zshrc && echo file:${variableName}");
             output = output.Trim();
-            UpdateManifest(output); 
-            Debug.Log("AmaGDK changes to dev mode successfully");
-            UnityEditor.AssetDatabase.Refresh();
+            UpdateManifest(output);
+            
+            UnityEditor.AssetDatabase.Refresh(UnityEditor.ImportAssetOptions.ForceUpdate);
         }
             
         private string RunShellCommand(string command)
@@ -368,11 +374,28 @@ namespace Amanotes.Core
             
         private void UpdateManifest(string strDesired)
         {
-            const string manifestPath = "Packages/manifest.json";
-            string manifestJson = File.ReadAllText(manifestPath);
+            try
+            {
+                const string manifestPath = "Packages/manifest.json";
+                string manifestJson = File.ReadAllText(manifestPath);
 
-            manifestJson = Regex.Replace(manifestJson, "\"com\\.amanotes\\.gdk\"\\s*:\\s*\"\\d+\\.\\d+\\.\\d+\"", $"\"com.amanotes.gdk\": \"{strDesired}\"");
-            File.WriteAllText(manifestPath, manifestJson);
+                string pattern = "\"com\\.amanotes\\.gdk\": \"(.*)\"";
+                string devModeEntry = $"\"com.amanotes.gdk\": \"{strDesired}\"";
+                
+                manifestJson = Regex.Replace(manifestJson, pattern, devModeEntry);
+                File.WriteAllText(manifestPath, manifestJson);
+                
+                if (!File.ReadAllText(manifestPath).Contains(devModeEntry))
+                {
+                    Debug.LogWarning($"AmaGDK changes to dev mode failed. The expected value is: {devModeEntry}");
+                    return;
+                }
+                Debug.Log("AmaGDK changes to dev mode successfully");
+            }
+            catch (Exception e)
+            {
+                Debug.LogWarning($"AmaGDK changes to dev exception: {e.Message}");
+            }
         }
         #endif
     }