com.amanotes.gdk 0.2.86 → 0.2.88

package/Runtime/AmaGDK.Analytics.cs

@@ -458,42 +458,51 @@ namespace Amanotes.Core
                 if (config.normalizeEventName) NormalizeEventName(ref eventNameToSend);
 	            config.quality.CheckEventQuality(eventParams.eventName, eventParams.parameters);
 	            
-                var inUseAdapterIDs = config.enableEventStat ? new List<string>(listAdapters.Count) : null;
+                List<string> inUseAdapterIDs = config.enableEventStat ? new List<string>(listAdapters.Count) : null;
+                bool effective = ProcessAdapters(eventParams, eventNameToSend, inUseAdapterIDs);
+                HandleEventResult(effective, config, eventNameToSend, countInSession, totalCount, eventParams, inUseAdapterIDs);
+            }
+
+            private static bool ProcessAdapters(EventParams eventParams, string eventNameToSend, List<string> inUseAdapterIDs)
+            {
                 var effective = false;
                 foreach (AnalyticsAdapter m in listAdapters)
                 {
-                    if (eventParams.overrideConfig)
-                    {
-                        // IMPORTANT NOTE:
-                        //
-                        // Once set overrideConfig, we should skip the adapter config completely!!!
-                        //
-                        if (eventParams.IsAdapterForbidden(m.adapterId)) continue;
-                    }
-                    else // Do not remove else
-                    {
-                        if (m.IsForbidden(eventParams.eventName)) continue;
-                    }
+                    if (ShouldSkipAdapter(eventParams, m)) continue;
                     
                     effective = true;
                     m.LogEvent(eventNameToSend, eventParams.parameters);
                     inUseAdapterIDs?.Add(m.adapterId);
                 }
+                return effective;
+            }
 
+            private static bool ShouldSkipAdapter(EventParams eventParams, AnalyticsAdapter adapter)
+            {
+                // IMPORTANT NOTE:
+                //
+                // Once set overrideConfig, we should skip the adapter config completely!!!
+                //
+                return eventParams.overrideConfig 
+                    ? eventParams.IsAdapterForbidden(adapter.adapterId)
+                    : adapter.IsForbidden(eventParams.eventName);
+            }
+
+            private static void HandleEventResult(bool effective, AnalyticsConfig config, string eventNameToSend, int countInSession, int totalCount, EventParams eventParams, List<string> inUseAdapterIDs)
+            {
                 if (effective)
                 {
                     if (config.showAnalyticsLog)
                     {
                         ForceLog($"[Analytics] Event <{eventNameToSend}> (in session: {countInSession}, total: {totalCount})\n{JsonUtils.DictionaryToJson(eventParams.parameters, true)}");
                     }
+                    GDKUtils.SafeInvoke(OnEventSent, eventNameToSend, eventParams.parameters);
+                    sessionStat?.OnEventSent(eventNameToSend, eventParams.parameters, inUseAdapterIDs);
                 }
                 else
                 {
                     LogError($"Event <{eventParams}> has been skipped (no matching Adapter)\n{JsonUtility.ToJson(eventParams)}");
                 }
-                
-	            GDKUtils.SafeInvoke(OnEventSent, eventNameToSend, eventParams.parameters);
-	            sessionStat?.OnEventSent(eventNameToSend, eventParams.parameters, inUseAdapterIDs);
             }
 			
             internal static void LogEventImmediately(EventParams eventParams)
@@ -568,63 +577,89 @@ namespace Amanotes.Core
                     var hasChanged = false;
                     var trimKey = key.Trim();
                     
-                    foreach (var c in trimKey)
-                    {
-                        var isLetter = IsAlphabet(c);
-                        var isNumber = char.IsDigit(c);
-
-                        if (c == '_' || isLetter || isNumber)
-                        {
-                            tempKey.Append(c);
-                            continue;
-                        }
-                        
-                        hasChanged = true;
-                        if (c == ' ' || c == '-')
-                        {
-                            tempKey.Append('_');
-                        }
-                    }
-
-                    if (hasChanged && willLog)
-                    {
-                        tempLog.Append(" - Name may only contain alphanumeric characters and underscores");
-                    }
+                    hasChanged = ProcessCharacters(trimKey, tempKey, tempLog, willLog, hasChanged);
+                    hasChanged = EnsureValidStart(tempKey, tempLog, willLog, hasChanged, key);
+                    hasChanged = HandleReservedPrefixes(tempKey, tempLog, willLog, hasChanged, key);
+                    hasChanged = ValidateLength(trimKey, tempKey, tempLog, willLog, hasChanged, key);
                     
-                    if (tempKey.Length > 0 && !IsAlphabet(tempKey[0]))
-                    {
-                        hasChanged = true;
-                        tempKey.Insert(0, 'E');
-                        if (willLog) tempLog.Append($" - Name must start with a letter: <{key}>");
-                    }
+                    ApplyChanges(dryRun, warningLog, tempLog, hasChanged, ref key, tempKey);
                     
-                    foreach (var prefix in reservedPrefixes)
-                    {
-                        if (tempKey.Length < prefix.Key.Length || !StringStartsWith(tempKey, prefix.Key)) continue;
-                        hasChanged = true;
-                        tempKey.Remove(0, prefix.Key.Length);
-                        tempKey.Insert(0, prefix.Value);
-                        if (willLog) tempLog.AppendLine($" - <{key}> starts with reserved prefix <{prefix}>");
-                    }
+                    GDKPool.Return(tempLog);
+                    GDKPool.Return(tempKey);
+                }
+                Profiler.EndSample();
+            }
 
-                    if (trimKey.Length > 40)
+            private static bool ProcessCharacters(string trimKey, StringBuilder tempKey, StringBuilder tempLog, bool willLog, bool hasChanged)
+            {
+                foreach (var c in trimKey)
+                {
+                    var isLetter = IsAlphabet(c);
+                    var isNumber = char.IsDigit(c);
+
+                    if (c == '_' || isLetter || isNumber)
                     {
-                        hasChanged = true;
-                        if (willLog) tempLog.AppendLine($" - Name is too long ({key.Length} > 40): <{key}> ");
-                        tempKey.Length = 40;
+                        tempKey.Append(c);
+                        continue;
                     }
                     
-                    if (dryRun)
+                    hasChanged = true;
+                    if (c == ' ' || c == '-')
                     {
-                        warningLog.Append(tempLog);
-                    } else {
-                        if (hasChanged) key = tempKey.ToString();
+                        tempKey.Append('_');
                     }
-                    
-                    GDKPool.Return(tempLog);
-                    GDKPool.Return(tempKey);
                 }
-                Profiler.EndSample();
+
+                if (hasChanged && willLog)
+                {
+                    tempLog.Append(" - Name may only contain alphanumeric characters and underscores");
+                }
+                return hasChanged;
+            }
+
+            private static bool EnsureValidStart(StringBuilder tempKey, StringBuilder tempLog, bool willLog, bool hasChanged, string key)
+            {
+                if (tempKey.Length > 0 && !IsAlphabet(tempKey[0]))
+                {
+                    hasChanged = true;
+                    tempKey.Insert(0, 'E');
+                    if (willLog) tempLog.Append($" - Name must start with a letter: <{key}>");
+                }
+                return hasChanged;
+            }
+
+            private static bool HandleReservedPrefixes(StringBuilder tempKey, StringBuilder tempLog, bool willLog, bool hasChanged, string key)
+            {
+                foreach (var prefix in reservedPrefixes)
+                {
+                    if (tempKey.Length < prefix.Key.Length || !StringStartsWith(tempKey, prefix.Key)) continue;
+                    hasChanged = true;
+                    tempKey.Remove(0, prefix.Key.Length);
+                    tempKey.Insert(0, prefix.Value);
+                    if (willLog) tempLog.AppendLine($" - <{key}> starts with reserved prefix <{prefix}>");
+                }
+                return hasChanged;
+            }
+
+            private static bool ValidateLength(string trimKey, StringBuilder tempKey, StringBuilder tempLog, bool willLog, bool hasChanged, string key)
+            {
+                if (trimKey.Length > 40)
+                {
+                    hasChanged = true;
+                    if (willLog) tempLog.AppendLine($" - Name is too long ({key.Length} > 40): <{key}> ");
+                    tempKey.Length = 40;
+                }
+                return hasChanged;
+            }
+
+            private static void ApplyChanges(bool dryRun, StringBuilder warningLog, StringBuilder tempLog, bool hasChanged, ref string key, StringBuilder tempKey)
+            {
+                if (dryRun)
+                {
+                    warningLog.Append(tempLog);
+                } else {
+                    if (hasChanged) key = tempKey.ToString();
+                }
             }
             
             private static bool StringStartsWith(StringBuilder stringBuilder, string prefix)
@@ -1069,11 +1104,16 @@ namespace Amanotes.Core
                 h.Add(mId);
             }
 
+            eventData.overrideConfig = true;
             if (h.Count > 0)
             {
-                eventData.overrideConfig = true;
                 eventData.allowAdapterIds ??= h;    
             }
+            else
+            {
+                // No valid adapters found, create empty set to ensure event is skipped
+                eventData.allowAdapterIds ??= GDKPool.GetHashSet();
+            }
             
             return ap;
         }

package/Runtime/AmaGDK.RemoteConfig.cs

@@ -259,43 +259,9 @@ namespace Amanotes.Core
                 try
                 {
                     DictConfig.Clear();
-                    using (StreamReader sr = new StreamReader(GDKFileUtils.GetPath(fileName)))
-                    {
-                        //Check new app update
-                        string firstLine = sr.ReadLine();
-                        if (firstLine == null)
-                        {
-                            NextState(false);
-                            return;
-                        }
-                        if (ShouldClearCache(firstLine))
-                        {
-                            GDKFileUtils.Delete(fileName);
-                            string oldVersion = firstLine.StartsWith(VERSION_PREFIX) ? firstLine : "<none>";
-                            Log($"[RemoteConfig] Cached remote config cleared due to embed version changed:\n{oldVersion} -> {EmbedVersion}");
-                            NextState(false);
-                            return;
-                        }
-                        
-                        //Read key-value
-                        string line;
-                        int lineNo = 1;
-                        while ((line = sr.ReadLine()) != null)
-                        {
-                            lineNo++;
-                            var idx = line.IndexOf('\t');
-                            if (idx == -1)
-                            {
-                                LogWarning($"[RemoteConfig] Cannot get (key, value) at line {lineNo} of cache. Content:\n<{line}>");
-                                continue;
-                            }
-                            string key = line.Substring(0, idx);
-                            string value = line.Substring(idx + 1);
-                            DictConfig.Add(key, Decode(value));
-                        }
-                    }
-                    Source = RemoteConfigSource.LocalCache;
-                    Log("[RemoteConfig] Load from cache");
+                    bool success = ReadCacheFile();
+                    Profiler.EndSample();
+                    NextState(success);
                 }
                 catch (Exception ex)
                 {
@@ -303,11 +269,55 @@ namespace Amanotes.Core
                     _cacheExisted = false;
                     Profiler.EndSample();
                     NextState(false);
-                    return;
                 }
+            }
 
-                Profiler.EndSample();
-                NextState(true);
+            static bool ReadCacheFile()
+            {
+                using (StreamReader sr = new StreamReader(GDKFileUtils.GetPath(fileName)))
+                {
+                    string firstLine = sr.ReadLine();
+                    if (firstLine == null) return false;
+                    
+                    if (!ValidateCacheVersion(firstLine)) return false;
+                    
+                    ReadConfigKeyValues(sr);
+                }
+                
+                Source = RemoteConfigSource.LocalCache;
+                Log("[RemoteConfig] Load from cache");
+                return true;
+            }
+
+            static bool ValidateCacheVersion(string firstLine)
+            {
+                if (ShouldClearCache(firstLine))
+                {
+                    GDKFileUtils.Delete(fileName);
+                    string oldVersion = firstLine.StartsWith(VERSION_PREFIX) ? firstLine : "<none>";
+                    Log($"[RemoteConfig] Cached remote config cleared due to embed version changed:\n{oldVersion} -> {EmbedVersion}");
+                    return false;
+                }
+                return true;
+            }
+
+            static void ReadConfigKeyValues(StreamReader sr)
+            {
+                string line;
+                int lineNo = 1;
+                while ((line = sr.ReadLine()) != null)
+                {
+                    lineNo++;
+                    var idx = line.IndexOf('\t');
+                    if (idx == -1)
+                    {
+                        LogWarning($"[RemoteConfig] Cannot get (key, value) at line {lineNo} of cache. Content:\n<{line}>");
+                        continue;
+                    }
+                    string key = line.Substring(0, idx);
+                    string value = line.Substring(idx + 1);
+                    DictConfig.Add(key, Decode(value));
+                }
             }
 
             static void LoadEmbedConfig()

package/Runtime/AmaGDK.cs

@@ -27,7 +27,7 @@ namespace Amanotes.Core
 {
     public partial class AmaGDK : MonoBehaviour
     {
-        public const string VERSION = "0.2.86";
+        public const string VERSION = "0.2.88";
         
         internal static Status _status = Status.None;
         internal static ConfigAsset _config = null;

package/Runtime/AnalyticQualityAsset.cs

@@ -54,31 +54,27 @@ namespace Amanotes.Core
             }
         }
 
+        private static readonly HashSet<Type> NumericTypes = new HashSet<Type>
+        {
+            typeof(int), typeof(long), typeof(short), typeof(byte),
+            typeof(double), typeof(float), typeof(decimal),
+            typeof(uint), typeof(ulong), typeof(ushort), typeof(sbyte)
+        };
+
         private bool IsNumericType(Type type)
         {
-            return type == typeof(int) ||
-                   type == typeof(long) ||
-                   type == typeof(short) ||
-                   type == typeof(byte) ||
-                   type == typeof(double) ||
-                   type == typeof(float) ||
-                   type == typeof(decimal) ||
-                   type == typeof(uint) ||
-                   type == typeof(ulong) ||
-                   type == typeof(ushort) ||
-                   type == typeof(sbyte);
+            return NumericTypes.Contains(type);
         }
 
+        private static readonly HashSet<Type> IntegerTypes = new HashSet<Type>
+        {
+            typeof(sbyte), typeof(byte), typeof(short), typeof(ushort),
+            typeof(int), typeof(uint), typeof(long), typeof(ulong)
+        };
+
         private bool IsIntegerType(Type type)
         {
-            return type == typeof(sbyte) ||
-                   type == typeof(byte) ||
-                   type == typeof(short) ||
-                   type == typeof(ushort) ||
-                   type == typeof(int) ||
-                   type == typeof(uint) ||
-                   type == typeof(long) ||
-                   type == typeof(ulong);
+            return IntegerTypes.Contains(type);
         }
 
         internal void ValidateParams(string eventName, Dictionary<string, object> eventParams)
@@ -89,6 +85,19 @@ namespace Amanotes.Core
             var isValid = true;
             HashSet<string> checkedParameters = GDKPool.GetHashSet();
 
+            isValid &= ValidateRequiredParams(eventParams, logBuilder, checkedParameters);
+            isValid &= ValidateExtraParams(eventParams, logBuilder, checkedParameters);
+            
+            if (!isValid) LogWarningOnce(logBuilder.ToString());
+            
+            GDKPool.Return(logBuilder);
+            GDKPool.Return(checkedParameters);
+        }
+
+        private bool ValidateRequiredParams(Dictionary<string, object> eventParams, StringBuilder logBuilder, HashSet<string> checkedParameters)
+        {
+            bool isValid = true;
+            
             foreach (var kvp in DicParam)
             {
                 if (!eventParams.TryGetValue(kvp.Key, out object paramValue))
@@ -109,7 +118,14 @@ namespace Amanotes.Core
 
                 checkedParameters.Add(kvp.Key);
             }
+            
+            return isValid;
+        }
 
+        private bool ValidateExtraParams(Dictionary<string, object> eventParams, StringBuilder logBuilder, HashSet<string> checkedParameters)
+        {
+            bool isValid = true;
+            
             foreach (var parameter in eventParams)
             {
                 if (checkedParameters.Contains(parameter.Key)) continue;
@@ -118,10 +134,7 @@ namespace Amanotes.Core
                 logBuilder.AppendLine($"[+] {parameter.Key}");
             }
             
-            if (!isValid) LogWarningOnce(logBuilder.ToString());
-            
-            GDKPool.Return(logBuilder);
-            GDKPool.Return(checkedParameters);
+            return isValid;
         }
 
         private bool ValidateParamType(object paramValue, ParamType paramType)
@@ -188,26 +201,44 @@ namespace Amanotes.Core
             
             foreach (EventQuality eventQuality in lstEvent)
             {
-                if (string.IsNullOrWhiteSpace(eventQuality.eventName)) Debug.LogWarning("Event name cannot be empty or whitespace.");
+                ValidateEventName(eventQuality.eventName, eventNames);
+                ValidateEventParameters(eventQuality);
+            }
+            
+            GDKPool.Return(eventNames);
+            EditorUtility.SetDirty(this);
+        }
 
-                if (!eventNames.Add(eventQuality.eventName)) Debug.LogWarning($"Duplicate event name found: {eventQuality.eventName}. Event names must be unique.");
+        private void ValidateEventName(string eventName, HashSet<string> eventNames)
+        {
+            if (string.IsNullOrWhiteSpace(eventName)) 
+                Debug.LogWarning("Event name cannot be empty or whitespace.");
 
-                HashSet<string> paramNames = GDKPool.GetHashSet();
-                
-                eventQuality.lstParam = eventQuality.lstParam.OrderBy(param => param.paramName).ToList();
-                
-                foreach (var param in eventQuality.lstParam)
-                {
-                    if (string.IsNullOrWhiteSpace(param.paramName)) Debug.LogWarning("Event parameter name cannot be empty or whitespace.");
+            if (!eventNames.Add(eventName)) 
+                Debug.LogWarning($"Duplicate event name found: {eventName}. Event names must be unique.");
+        }
 
-                    if (!paramNames.Add(param.paramName)) Debug.LogWarning($"Duplicate parameter name found in event {eventQuality.eventName}: {param.paramName}. Parameter names must be unique within an event.");
-                }
-                
-                GDKPool.Return(paramNames);
+        private void ValidateEventParameters(EventQuality eventQuality)
+        {
+            HashSet<string> paramNames = GDKPool.GetHashSet();
+            
+            eventQuality.lstParam = eventQuality.lstParam.OrderBy(param => param.paramName).ToList();
+            
+            foreach (var param in eventQuality.lstParam)
+            {
+                ValidateParameterName(param.paramName, eventQuality.eventName, paramNames);
             }
             
-            GDKPool.Return(eventNames);
-            EditorUtility.SetDirty(this);
+            GDKPool.Return(paramNames);
+        }
+
+        private void ValidateParameterName(string paramName, string eventName, HashSet<string> paramNames)
+        {
+            if (string.IsNullOrWhiteSpace(paramName)) 
+                Debug.LogWarning("Event parameter name cannot be empty or whitespace.");
+
+            if (!paramNames.Add(paramName)) 
+                Debug.LogWarning($"Duplicate parameter name found in event {eventName}: {paramName}. Parameter names must be unique within an event.");
         }
 #endif
 

package/Runtime/AudioToolkit/Plugins/AudioDeviceDetector.cs

@@ -162,10 +162,7 @@ namespace Amanotes.Core
 
         private static string RemoveSurrogatePairs(string str, string replacementCharacter = "?")
         {
-            if (str == null)
-            {
-                return null;
-            }
+            if (str == null) return null;
 
             StringBuilder sb = null;
             for (var i = 0; i < str.Length; i++)
@@ -174,19 +171,8 @@ namespace Amanotes.Core
 
                 if (char.IsSurrogate(ch))
                 {
-                    if (sb == null)
-                    {
-                        sb = GDKPool.GetStringBuilder();
-                        sb.Append(str, 0, i);
-                    }
-                    
-                    sb.Append(replacementCharacter);
-
-                    // If there is a high+low surrogate, skip the low surrogate
-                    if (i + 1 < str.Length && char.IsHighSurrogate(ch) && char.IsLowSurrogate(str[i + 1]))
-                    {
-                        i++;
-                    }
+                    sb = HandleSurrogateCharacter(str, i, sb, replacementCharacter, out int skipCount);
+                    i += skipCount;
                 }
                 else
                 {
@@ -196,6 +182,34 @@ namespace Amanotes.Core
             
             return sb == null ? str : GDKPool.ReturnString(sb);
         }
+
+        private static StringBuilder HandleSurrogateCharacter(string str, int index, StringBuilder sb, string replacementCharacter, out int skipCount)
+        {
+            skipCount = 0;
+            
+            if (sb == null)
+            {
+                sb = GDKPool.GetStringBuilder();
+                sb.Append(str, 0, index);
+            }
+            
+            sb.Append(replacementCharacter);
+
+            // If there is a high+low surrogate, skip the low surrogate
+            if (ShouldSkipLowSurrogate(str, index))
+            {
+                skipCount = 1;
+            }
+            
+            return sb;
+        }
+
+        private static bool ShouldSkipLowSurrogate(string str, int index)
+        {
+            return index + 1 < str.Length && 
+                   char.IsHighSurrogate(str[index]) && 
+                   char.IsLowSurrogate(str[index + 1]);
+        }
     }
 
     internal enum AudioDeviceType

package/Runtime/Core/GDKSemVer.cs

@@ -32,38 +32,35 @@ namespace Amanotes.Core.Internal
         // Constructor for string-based version initialization
         public GDKSemVer(string version)
         {
-            // Default values
-            major = 0;
-            minor = 0;
-            patch = 0;
-            extra = -1;
+            var parsed = ParseVersionString(version);
+            major = parsed.major;
+            minor = parsed.minor;
+            patch = parsed.patch;
+            extra = parsed.extra;
+        }
 
-            if (string.IsNullOrEmpty(version)) return;
+        private static (int major, int minor, int patch, int extra) ParseVersionString(string version)
+        {
+            if (string.IsNullOrEmpty(version)) return (0, 0, 0, -1);
 
             Profiler.BeginSample("GDKSemVer()");
+            version = version.Trim();
+            Match match = VERSION_PATTERN.Match(version);
+            
+            if (!match.Success)
             {
-                version = version.Trim();
-                Match match = VERSION_PATTERN.Match(version);
-                if (!match.Success)
-                {
-                    LogWarning($"[GDKSemVer] Invalid version string: [{version}]");
-                    Profiler.EndSample();
-                    return;
-                }
-
-                // Parse the version components using TryParse for safety
-                major = int.TryParse(match.Groups[1].Value, out int parsedMajor) ? parsedMajor : 0;
-                minor = int.TryParse(match.Groups[2].Value, out int parsedMinor) ? parsedMinor : 0;
-                if (match.Groups.Count > 3 && !int.TryParse(match.Groups[3].Value, out patch))
-                {
-                    patch = 0;
-                }
-                if (match.Groups.Count > 4 && !int.TryParse(match.Groups[4].Value, out extra))
-                {
-                    extra = -1;
-                }
+                LogWarning($"[GDKSemVer] Invalid version string: [{version}]");
+                Profiler.EndSample();
+                return (0, 0, 0, -1);
             }
+
+            var major = int.TryParse(match.Groups[1].Value, out int parsedMajor) ? parsedMajor : 0;
+            var minor = int.TryParse(match.Groups[2].Value, out int parsedMinor) ? parsedMinor : 0;
+            var patch = match.Groups.Count > 3 && int.TryParse(match.Groups[3].Value, out int parsedPatch) ? parsedPatch : 0;
+            var extra = match.Groups.Count > 4 && int.TryParse(match.Groups[4].Value, out int parsedExtra) ? parsedExtra : -1;
+            
             Profiler.EndSample();
+            return (major, minor, patch, extra);
         }
 
         // Property to check if the version is valid