com.amanotes.gdk 0.2.51 → 0.2.52

package/CHANGELOG.md

@@ -1,16 +1,15 @@
 # Changelog
 
-## [0.2.51 - 2024-02-23]
-- New feature: GDKCIBuildCommand
-- [Dev] Change Google Mobile Ads SDK version for iOS, 10.9 -> 10.5.0
-- [Analytics] Add LogEventImmediately()
-- [Analytics] Move AddParam() to internal use
-- [Analytics] Replace event Queue by ConcurrentQueue
-- [Ads] Check null Ads._adapter
-- [Ads] Autostart AdEventTracking
-- [Analytics] Update AppsFlyer adapter version
-- [UserProfile] Change logic of getting ama_device_id
-- [Core] Init modules before Hooks
+## [0.2.52 - 2024-02-27]
+- Change post processing order
+- Remove GDKInstaller after installed
+- Enable pipeline execution for branches with active merge requests
+- [Fix] Non-fatal exceptions relate to Analytics and Ads
+- Update Google Sheet Id default
+- Optimize GC for Analytics
+
+## [0.2.51 - 2024-02-20]
+- Change Google Mobile Ads SDK version , iosPod 10.5.0
 
 ## [0.2.50 - 2024-02-20]
 - New feature: Modify Android post processor

package/Editor/Extra/GDKCIBuildCommand.cs

@@ -0,0 +1,312 @@
+using UnityEditor;
+using System.Linq;
+using System;
+using System.IO;
+
+namespace Amanotes.Core
+{
+    public static class GDKCIBuildCommand
+    {
+        private const string KEYSTORE_PASS = "KEYSTORE_PASS";
+        private const string KEY_ALIAS_PASS = "KEY_ALIAS_PASS";
+        private const string KEY_ALIAS_NAME = "KEY_ALIAS_NAME";
+        private const string KEYSTORE = "keystore.keystore";
+        private const string BUILD_OPTIONS_ENV_VAR = "BuildOptions";
+        private const string ANDROID_BUNDLE_VERSION_CODE = "VERSION_BUILD_VAR";
+        private const string ANDROID_APP_BUNDLE = "BUILD_APP_BUNDLE";
+        private const string SCRIPTING_BACKEND_ENV_VAR = "SCRIPTING_BACKEND";
+        private const string VERSION_NUMBER_VAR = "VERSION_NUMBER_VAR";
+        private const string VERSION_iOS = "VERSION_BUILD_VAR";
+
+        static string GetArgument(string name)
+        {
+            string[] args = Environment.GetCommandLineArgs();
+            for (int i = 0; i < args.Length; i++)
+            {
+                if (args[i].Contains(name))
+                {
+                    return args[i + 1];
+                }
+            }
+            return null;
+        }
+
+        static string[] GetEnabledScenes()
+        {
+            return (
+                from scene in EditorBuildSettings.scenes
+                where scene.enabled
+                where !string.IsNullOrEmpty(scene.path)
+                select scene.path
+            ).ToArray();
+        }
+
+        static BuildTarget GetBuildTarget()
+        {
+            string buildTargetName = GetArgument("customBuildTarget");
+            Console.WriteLine(":: Received customBuildTarget " + buildTargetName);
+
+            if (buildTargetName.ToLower() == "android")
+            {
+#if !UNITY_5_6_OR_NEWER
+			// https://issuetracker.unity3d.com/issues/buildoptions-dot-acceptexternalmodificationstoplayer-causes-unityexception-unknown-project-type-0
+			// Fixed in Unity 5.6.0
+			// side effect to fix android build system:
+			EditorUserBuildSettings.androidBuildSystem = AndroidBuildSystem.Internal;
+#endif
+            }
+
+            if (buildTargetName.TryConvertToEnum(out BuildTarget target))
+                return target;
+
+            Console.WriteLine($":: {nameof(buildTargetName)} \"{buildTargetName}\" not defined on enum {nameof(BuildTarget)}, using {nameof(BuildTarget.NoTarget)} enum to build");
+
+            return BuildTarget.NoTarget;
+        }
+
+        static string GetBuildPath()
+        {
+            string buildPath = GetArgument("customBuildPath");
+            Console.WriteLine(":: Received customBuildPath " + buildPath);
+            if (buildPath == "")
+            {
+                throw new Exception("customBuildPath argument is missing");
+            }
+            return buildPath;
+        }
+
+        static string GetBuildName()
+        {
+            string buildName = GetArgument("customBuildName");
+            Console.WriteLine(":: Received customBuildName " + buildName);
+            if (buildName == "")
+            {
+                throw new Exception("customBuildName argument is missing");
+            }
+            return buildName;
+        }
+
+        static string GetFixedBuildPath(BuildTarget buildTarget, string buildPath, string buildName)
+        {
+            if (buildTarget.ToString().ToLower().Contains("windows"))
+            {
+                buildName += ".exe";
+            }
+            else if (buildTarget == BuildTarget.Android)
+            {
+#if UNITY_2018_3_OR_NEWER
+                buildName += EditorUserBuildSettings.buildAppBundle ? ".aab" : ".apk";
+#else
+            buildName += ".apk";
+#endif
+            }
+            return buildPath + buildName;
+        }
+
+        static BuildOptions GetBuildOptions()
+        {
+            if (TryGetEnv(BUILD_OPTIONS_ENV_VAR, out string envVar))
+            {
+                string[] allOptionVars = envVar.Split(',');
+                BuildOptions allOptions = BuildOptions.None;
+                BuildOptions option;
+                string optionVar;
+                int length = allOptionVars.Length;
+
+                Console.WriteLine($":: Detecting {BUILD_OPTIONS_ENV_VAR} env var with {length} elements ({envVar})");
+
+                for (int i = 0; i < length; i++)
+                {
+                    optionVar = allOptionVars[i];
+
+                    if (optionVar.TryConvertToEnum(out option))
+                    {
+                        allOptions |= option;
+                    }
+                    else
+                    {
+                        Console.WriteLine($":: Cannot convert {optionVar} to {nameof(BuildOptions)} enum, skipping it.");
+                    }
+                }
+
+                return allOptions;
+            }
+
+            return BuildOptions.None;
+        }
+
+        // https://stackoverflow.com/questions/1082532/how-to-tryparse-for-enum-value
+        static bool TryConvertToEnum<TEnum>(this string strEnumValue, out TEnum value)
+        {
+            if (!Enum.IsDefined(typeof(TEnum), strEnumValue))
+            {
+                value = default;
+                return false;
+            }
+
+            value = (TEnum)Enum.Parse(typeof(TEnum), strEnumValue);
+            return true;
+        }
+
+        static bool TryGetEnv(string key, out string value)
+        {
+            value = Environment.GetEnvironmentVariable(key);
+            return !string.IsNullOrEmpty(value);
+        }
+
+        static void SetScriptingBackendFromEnv(BuildTarget platform)
+        {
+            var targetGroup = BuildPipeline.GetBuildTargetGroup(platform);
+            if (TryGetEnv(SCRIPTING_BACKEND_ENV_VAR, out string scriptingBackend))
+            {
+                if (scriptingBackend.TryConvertToEnum(out ScriptingImplementation backend))
+                {
+                    Console.WriteLine($":: Setting ScriptingBackend to {backend}");
+                    PlayerSettings.SetScriptingBackend(targetGroup, backend);
+                }
+                else
+                {
+                    string possibleValues = string.Join(", ", Enum.GetValues(typeof(ScriptingImplementation)).Cast<ScriptingImplementation>());
+                    throw new Exception($"Could not find '{scriptingBackend}' in ScriptingImplementation enum. Possible values are: {possibleValues}");
+                }
+            }
+            else
+            {
+                var defaultBackend = PlayerSettings.GetDefaultScriptingBackend(targetGroup);
+                Console.WriteLine($":: Using project's configured ScriptingBackend (should be {defaultBackend} for targetGroup {targetGroup}");
+            }
+        }
+
+        public static void PerformBuild()
+        {
+            var buildTarget = GetBuildTarget();
+
+            Console.WriteLine(":: Performing build");
+            if (TryGetEnv(VERSION_NUMBER_VAR, out var bundleVersionNumber))
+            {
+                if (buildTarget == BuildTarget.iOS)
+                {
+                    bundleVersionNumber = GetIosVersion();
+                }
+                Console.WriteLine($":: Setting bundleVersionNumber to '{bundleVersionNumber}' (Length: {bundleVersionNumber.Length})");
+                PlayerSettings.bundleVersion = bundleVersionNumber;
+            }
+
+            if (buildTarget == BuildTarget.Android)
+            {
+                HandleAndroidAppBundle();
+                HandleAndroidBundleVersionCode();
+                HandleAndroidKeystore();
+            }
+
+            var buildPath = GetBuildPath();
+            var buildName = GetBuildName();
+            var buildOptions = GetBuildOptions();
+            var fixedBuildPath = GetFixedBuildPath(buildTarget, buildPath, buildName);
+
+            SetScriptingBackendFromEnv(buildTarget);
+
+            var buildReport = BuildPipeline.BuildPlayer(GetEnabledScenes(), fixedBuildPath, buildTarget, buildOptions);
+
+            if (buildReport.summary.result != UnityEditor.Build.Reporting.BuildResult.Succeeded)
+                throw new Exception($"Build ended with {buildReport.summary.result} status");
+
+            Console.WriteLine(":: Done with build");
+        }
+
+        private static void HandleAndroidAppBundle()
+        {
+            if (TryGetEnv(ANDROID_APP_BUNDLE, out string value))
+            {
+#if UNITY_2018_3_OR_NEWER
+                if (bool.TryParse(value, out bool buildAppBundle))
+                {
+                    EditorUserBuildSettings.buildAppBundle = buildAppBundle;
+                    Console.WriteLine($":: {ANDROID_APP_BUNDLE} env var detected, set buildAppBundle to {value}.");
+                }
+                else
+                {
+                    Console.WriteLine($":: {ANDROID_APP_BUNDLE} env var detected but the value \"{value}\" is not a boolean.");
+                }
+#else
+            Console.WriteLine($":: {ANDROID_APP_BUNDLE} env var detected but does not work with lower Unity version than 2018.3");
+#endif
+            }
+        }
+
+        private static void HandleAndroidBundleVersionCode()
+        {
+            if (TryGetEnv(ANDROID_BUNDLE_VERSION_CODE, out string value))
+            {
+                if (int.TryParse(value, out int version))
+                {
+                    PlayerSettings.Android.bundleVersionCode = version;
+                    Console.WriteLine($":: {ANDROID_BUNDLE_VERSION_CODE} env var detected, set the bundle version code to {value}.");
+                }
+                else
+                    Console.WriteLine($":: {ANDROID_BUNDLE_VERSION_CODE} env var detected but the version value \"{value}\" is not an integer.");
+            }
+        }
+
+        private static string GetIosVersion()
+        {
+            if (TryGetEnv(VERSION_iOS, out string value))
+            {
+                if (int.TryParse(value, out int version))
+                {
+                    Console.WriteLine($":: {VERSION_iOS} env var detected, set the version to {value}.");
+                    return version.ToString();
+                }
+                else
+                    Console.WriteLine($":: {VERSION_iOS} env var detected but the version value \"{value}\" is not an integer.");
+            }
+
+            throw new ArgumentNullException(nameof(value), $":: Error finding {VERSION_iOS} env var");
+        }
+
+        private static void HandleAndroidKeystore()
+        {
+#if UNITY_2019_1_OR_NEWER
+            PlayerSettings.Android.useCustomKeystore = false;
+#endif
+
+            if (!File.Exists(KEYSTORE))
+            {
+                Console.WriteLine($":: {KEYSTORE} not found, skipping setup, using Unity's default keystore");
+                return;
+            }
+
+            PlayerSettings.Android.keystoreName = KEYSTORE;
+
+            string keystorePass;
+            string keystoreAliasPass;
+
+            if (TryGetEnv(KEY_ALIAS_NAME, out string keyaliasName))
+            {
+                PlayerSettings.Android.keyaliasName = keyaliasName;
+                Console.WriteLine($":: using ${KEY_ALIAS_NAME} env var on PlayerSettings");
+            }
+            else
+            {
+                Console.WriteLine($":: ${KEY_ALIAS_NAME} env var not set, using Project's PlayerSettings");
+            }
+
+            if (!TryGetEnv(KEYSTORE_PASS, out keystorePass))
+            {
+                Console.WriteLine($":: ${KEYSTORE_PASS} env var not set, skipping setup, using Unity's default keystore");
+                return;
+            }
+
+            if (!TryGetEnv(KEY_ALIAS_PASS, out keystoreAliasPass))
+            {
+                Console.WriteLine($":: ${KEY_ALIAS_PASS} env var not set, skipping setup, using Unity's default keystore");
+                return;
+            }
+#if UNITY_2019_1_OR_NEWER
+            PlayerSettings.Android.useCustomKeystore = true;
+#endif
+            PlayerSettings.Android.keystorePass = keystorePass;
+            PlayerSettings.Android.keyaliasPass = keystoreAliasPass;
+        }
+    }
+}

package/Editor/Extra/GDKCIBuildCommand.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: bfe10a860d56457f86c6bb3931b972a5
+timeCreated: 1706775850

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

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

package/Runtime/AmaGDK.Analytics.cs

@@ -22,34 +22,52 @@ namespace Amanotes.Core
 
             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 +182,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 +207,8 @@ namespace Amanotes.Core
                             eventDetail.totalCount += e.Value;
                         }
                     }
+                }
+                    
                 
                 Profiler.EndSample();
                 return flag;
@@ -252,8 +273,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 +338,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 +347,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 +357,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 +371,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 +407,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 +423,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 +432,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 +475,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($"Warning for event name <{eventName}>:\n{sb}", $"NormalizeEventName<{eventName}>");
+                    sbPool.Return(sb);
                 }
                 Profiler.EndSample();
             }
@@ -473,57 +497,103 @@ namespace Amanotes.Core
                         return;
                     }
 
-                    var sb = new StringBuilder();
+                    var tempLog = Config.common.logLevel == LogLevel.None ? null : sbPool.Get();
+                    tempLog?.Clear();
                     
-                    string normalizedString = key.Trim()
-                        .Replace(' ', '_')
-                        .Replace('-', '_');
-                    if (key != normalizedString)
+                    var tempKey = sbPool.Get();
+                    tempKey.Clear();
+                    
+                    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 +695,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 +816,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 +837,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 +900,8 @@ namespace Amanotes.Core
             }
 
             eventData.overrideConfig = true;
+            eventData.ignoreAdapterIds ??= new HashSet<string>();
+            
             foreach (string mId in analyticIds)
             {
                 eventData.ignoreAdapterIds.Add(mId);
@@ -805,6 +926,8 @@ namespace Amanotes.Core
             }
 
             eventData.overrideConfig = true;
+            eventData.allowAdapterIds ??= new HashSet<string>();
+            
             foreach (string mId in analyticIds)
             {
                 eventData.allowAdapterIds.Add(mId);
@@ -879,11 +1002,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))
             {

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.52";
 
         internal static AmaGDK _instance;
         internal static Status _status = Status.None;

package/Runtime/Internal/AmaGDK.Internal.cs

@@ -93,6 +93,27 @@ namespace Amanotes.Core.Internal
 
     public static class Forbidden
     {
+        private static bool presetShowAnalyticsLog;
+        private static bool presetEnableEventStat;
+        private static LogLevel presetLogLevel = LogLevel.Warning;
+        
+        public static void PresetConfig()
+        {
+            presetLogLevel = Config.common.logLevel;
+            Config.common.logLevel = LogLevel.Warning;
+            presetShowAnalyticsLog = Config.analytics.showAnalyticsLog;
+            Config.analytics.showAnalyticsLog = true;
+            presetEnableEventStat = Config.analytics.enableEventStat;
+            Config.analytics.enableEventStat = true;
+        }
+
+        public static void ReloadConfig()
+        {
+            Config.analytics.showAnalyticsLog = presetShowAnalyticsLog;
+            Config.analytics.enableEventStat = presetEnableEventStat;
+            Config.common.logLevel = presetLogLevel;
+        }
+        
         public static void DestroyAndReset()
         {
             if (_instance != null)
@@ -139,9 +160,12 @@ namespace Amanotes.Core.Internal
         public static void ClearAnalyticsData()
         {
             AnalyticsData analyticsData = localData;
+            analyticsData._dirty = true;
             analyticsData.funnelSignatures.Clear();
             analyticsData.eventDetails.Clear();
+            analyticsData.cachedEventDetails.Clear();
             analyticsData.migrationLog = new MigrationLog();
+            analyticsData.SaveIfDirty();
         }
     }
     

package/Runtime/Internal/AmaGDK.Utils.cs

@@ -1,5 +1,6 @@
 using System;
 using System.Collections;
+using System.Collections.Concurrent;
 using System.Collections.Generic;
 using System.IO;
 using System.Reflection;
@@ -391,7 +392,6 @@ namespace Amanotes.Core.Internal
 
     internal interface IJsonFile { }
     
-
     internal static class JsonFileExtension
     {
         public static T LoadJsonFromFile<T>(this T instance) where T : IJsonFile, new()
@@ -569,4 +569,30 @@ namespace Amanotes.Core.Internal
         //    public T[] items;
         //}
     }
+    
+    internal class Pool<T> where T : new()
+    {
+        private readonly ConcurrentQueue<T> _pool;
+
+        public Pool(int initialCapacity)
+        {
+            _pool = new ConcurrentQueue<T>();
+            for (int i = 0; i < initialCapacity; i++)
+            {
+                _pool.Enqueue(new T());
+            }
+        }
+
+        public T Get()
+        {
+            return _pool.TryDequeue(out var obj) ? obj : new T();
+        }
+
+        public void Return(T obj)
+        {
+            _pool.Enqueue(obj);
+        }
+
+        public int Count => _pool.Count;
+    }
 }

package/package.json

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