com.amanotes.gdk 0.2.68 → 0.2.70-1

package/Runtime/AmaGDK.Consent.cs

@@ -0,0 +1,259 @@
+using System;
+using Amanotes.Core.Internal;
+using UnityEngine;
+
+namespace Amanotes.Core
+{
+    public partial class AmaGDK //Consent
+    {
+        public static partial class Consent //Public
+        {
+            private static bool _onGoingRequestAllConsents;
+            public static void RequestAllConsents(Action onComplete)
+            {
+                OnAllConsentComplete(onComplete);
+                
+                if (_onGoingRequestAllConsents)
+                {
+                    Logging.LogWarning($"[Consent] RequestAllConsents is called multiple times.");
+                    return;
+                }
+                
+                _onGoingRequestAllConsents = true;
+#if UNITY_IOS
+                ATT.Request(ConsiderCMP);
+#else
+                CMP.Request(EndConsent);
+#endif
+            }
+
+            public static void OnAllConsentComplete(Action onComplete)
+            {
+                if (allConsentChecked)
+                {
+                    onComplete?.Invoke();
+                    return;
+                }
+
+                _onConsentComplete -= onComplete;
+                _onConsentComplete += onComplete;
+            }
+        }
+        
+        public static partial class Consent //ATT
+        {
+            public static class ATT
+            {
+                public static bool IsAllowed
+                {
+                    get
+                    {
+                        if (checkedATT) return allowedATT;
+                        Logging.LogWarning("[Consent] ATT has not completed yet");
+                        return false;
+                    }
+                }
+            
+                public static void Request(Action<bool> onComplete)
+                {
+                    if (checkedATT)
+                    {
+                        onComplete?.Invoke(allowedATT);
+                        return;
+                    }
+
+                    ConsentHook.ATTRequest(isAllowed =>
+                    {
+                        data.att = isAllowed ? Status.Allowed : Status.NotAllowed;
+                        data.SaveJsonToFile();
+                        onComplete?.Invoke(allowedATT);
+                    });
+                }
+            }
+            
+        }
+        
+        public static partial class Consent //CMP
+        {
+            public static class CMP
+            {
+                public static bool IsRequired
+                {
+                    get
+                    {
+                        if (checkedCMP) return data.cmp >= Status.Allowed;
+                        
+                        if (!ConsentHook.IsRequiredCMP.HasValue)
+                        {
+                            Logging.LogWarningOnce("[Consent] CMP is not available or not ready");
+                            return false;
+                        }
+    
+                        return ConsentHook.IsRequiredCMP.Value;
+                    }
+                }
+                
+                public static void Request(Action<bool> onComplete)
+                {
+                    if (checkedCMP)
+                    {
+                        onComplete?.Invoke(checkedCMP);
+                        return;
+                    }
+                    
+                    ConsentHook.TryToShowCMP(successful =>
+                    {
+                        if (successful)
+                        {
+                            data.cmp = !IsRequired ? Status.NotRequired : Status.Allowed;
+                            data.SaveJsonToFile();
+                        }
+                        onComplete?.Invoke(checkedCMP);
+                    });
+                }
+                
+                public static void ForceShowPopUp(Action onComplete)
+                {
+                    OnAllConsentComplete(onComplete);
+                    ConsentHook.ForceShowCMP(EndConsent);
+                }
+            }
+        }
+
+        public static partial class Consent //Internal
+        {
+            private static readonly ConsentData data = new ConsentData().LoadJsonFromFile();
+            private static Action _onConsentComplete;
+            
+            internal static bool checkedATT => data.att >= Status.Allowed;
+            internal static bool allowedATT => data.att == Status.Allowed;
+            internal static bool checkedCMP => data.cmp >= Status.NotRequired;
+            internal static bool allConsentChecked => checkedATT && checkedCMP;
+            
+            internal enum Status
+            {
+                None,
+                NotRequired,
+                Allowed,
+                NotAllowed
+            }
+
+            internal static bool InitModule()
+            {
+                if (allConsentChecked) return true;
+                if (!_config.consent.autoGetConsent) return true;
+                RequestAllConsents(null);
+                return true;
+            }
+
+            private static void ConsiderCMP(bool needToShowCMP)
+            {
+                if (checkedCMP)
+                {
+                    EndConsent(true);
+                    return;
+                }
+                
+                if (needToShowCMP)
+                {
+                    ConsentHook.TryToShowCMP(EndConsent);
+                }
+                else
+                {
+                    ConsentHook.SetNotRequiredCMP(EndConsent);
+                }
+            }
+
+            private static void EndConsent(bool isConsentSuccess)
+            {
+                var tmpAction = _onConsentComplete;
+                _onConsentComplete = null;
+                tmpAction?.Invoke();
+                Logging.Log("[Consent] End consent checking");
+            }
+        }
+    }
+    
+    [Serializable]
+    public class ConsentData : IJsonFile
+    {
+        [SerializeField] internal AmaGDK.Consent.Status att;
+        [SerializeField] internal AmaGDK.Consent.Status cmp;
+    }
+
+    public static class ConsentHook
+    {
+        public static bool? IsRequiredCMP;
+        
+        private static Action<Action<bool>> _tryToShowCMP;
+        public static Action<Action<bool>> TryToShowCMP
+        {
+            get
+            {
+                if (_tryToShowCMP != null) return _tryToShowCMP;
+                
+                Logging.LogWarning("[Consent] ConsentHook.TryToShowCMP is null");
+                _tryToShowCMP = callback => callback(false);
+                return _tryToShowCMP;
+            }
+            set => _tryToShowCMP = value;
+        }
+        
+        private static Action<Action<bool>> _forceShowCMP;
+        public static Action<Action<bool>> ForceShowCMP
+        {
+            get
+            {
+                if (_forceShowCMP != null) return _forceShowCMP;
+                
+                Logging.LogWarning("[Consent] ConsentHook.ForceShowCMP is null");
+                _forceShowCMP = callback => callback(false);
+                return _forceShowCMP;
+            }
+            set => _forceShowCMP = value;
+        }
+
+        private static Action<Action<bool>> _setNotRequiredCMP;
+        public static Action<Action<bool>> SetNotRequiredCMP
+        {
+            get
+            {
+                if (_setNotRequiredCMP != null) return _setNotRequiredCMP;
+                
+                Logging.LogWarning("[Consent] ConsentHook.SetNotRequiredCMP is null");
+                _setNotRequiredCMP = callback => callback(false);
+                return _setNotRequiredCMP;
+            }
+            set => _setNotRequiredCMP = value;
+        }
+
+        private static Action<Action<bool>> _attRequest;
+        public static Action<Action<bool>> ATTRequest
+        {
+            get
+            {
+                if (_attRequest != null) return _attRequest;
+                
+                Logging.LogWarning("[Consent] ConsentHook.ATTRequest is null");
+                _attRequest = callback => callback(false);
+                return _attRequest;
+            }
+            set => _attRequest = value;
+        }
+    }
+}
+
+namespace Amanotes.Core.Internal
+{
+    [Serializable]
+    public class ConsentConfig
+    {
+        [Tooltip("Auto pop-up ATT and CMP form")]
+        public bool autoGetConsent = true;
+    }
+    
+    public partial class ConfigAsset
+    {
+        [SerializeField] public ConsentConfig consent;
+    }
+}

package/Runtime/AmaGDK.Consent.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 9af6959e72d274cce9036cd73c4b6bbc
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Runtime/AmaGDK.Device.cs

@@ -67,16 +67,16 @@ namespace Amanotes.Core.Internal
             
             if (AmaGDK.Config.common.logLevel == LogLevel.Verbose)
             {
-                var stringBuilder = new StringBuilder();
+                var stringBuilder = GDKPool.GetStringBuilder();
                 stringBuilder.Append("Device info:");
                 stringBuilder.AppendLine("DeviceSpec: " + result);
                 stringBuilder.AppendLine("systemMemorySize: " + SystemInfo.systemMemorySize);
                 stringBuilder.AppendLine("processorCount: " + SystemInfo.processorCount);
                 stringBuilder.AppendLine("processorFrequency: " + SystemInfo.processorFrequency);
-                stringBuilder.AppendLine("graphicsMemorySize: " + SystemInfo.graphicsMemorySize);
-                    
-                Logging.Log(stringBuilder.ToString());   
+                stringBuilder.AppendLine("graphicsMemorySize: " + SystemInfo.graphicsMemorySize);    
+                Logging.Log(GDKPool.ReturnString(stringBuilder));
             }
+            
             return result;
         }
         

package/Runtime/AmaGDK.RemoteConfig.cs

@@ -214,7 +214,7 @@ namespace Amanotes.Core
                 Profiler.BeginSample("AmaGDK.RemoteConfig.SaveCache()");
                 
                 _fetchState = FetchState.SaveCache;
-                StringBuilder sb = new StringBuilder();
+                StringBuilder sb = GDKPool.GetStringBuilder(8);
                 
                 //Add embedded remote config version to force load from embedded config after app update
                 sb.AppendLine($"{VERSION_PREFIX}{EmbedVersion}");
@@ -226,6 +226,8 @@ namespace Amanotes.Core
                 
                 string filePath = GDKFileUtils.GetPath(fileName);
                 GDKFileUtils.Save(filePath, sb.ToString());
+                GDKPool.Return(sb);
+                
                 Log($"[RemoteConfig] Saved remote config to {filePath}");
                 Profiler.EndSample();
                 NextState();

package/Runtime/AmaGDK.cs

@@ -17,7 +17,7 @@ namespace Amanotes.Core
 {
     public partial class AmaGDK : MonoBehaviour
     {
-        public const string VERSION = "0.2.68";
+        public const string VERSION = "0.2.70-1";
         
         internal static Status _status = Status.None;
         private static ConfigAsset _config = null;
@@ -100,15 +100,12 @@ namespace Amanotes.Core
             Profiler.BeginSample("AmaGDK.InitModules()");
             {
                 User.InitModule();
+                Consent.InitModule();
                 Analytics.InitModule();
                 Ads.InitModule();
                 IAP.InitModule();
                 RemoteConfig.InitModule();
-
-                if (Config.enableAudioModule)
-                {
-                    Audio.InitModule();
-                }
+                if (Config.enableAudioModule) Audio.InitModule();
             }
             Profiler.EndSample();
         }
@@ -128,8 +125,6 @@ namespace Amanotes.Core
 
         IEnumerator InitAdapters(StringBuilder sb)
         {
-            float TIMEOUT = 1;
-            
             // sort on priority
             List<Adapter2> listAdapters = Adapter2.adapterMap
                 .Values.ToList();
@@ -137,21 +132,32 @@ namespace Amanotes.Core
             
             foreach (Adapter2 adapter in listAdapters)
             {
-                // Log($"Initiating {adapter.adapterId} --> initOrder: {adapter.initOrder} | {adapter.status}");
-                float startTime = Time.realtimeSinceStartup;
-                Profiler.BeginSample($"AmaGDK.adapter.InitSDK-{adapter.adapterId}");
+                if (!adapter.enabled)
                 {
-                    adapter.InitSDK();
+                    Log($"Adapter <{adapter.adapterId} is disabled!");
+                    continue;
                 }
-                Profiler.EndSample();
-                
-                yield return GDKUtils.Timeout(TIMEOUT,() => adapter.status != Status.Initialize);
                 
-                if (adapter.status == Status.Initialize)
+                // Log($"Initiating {adapter.adapterId} --> initOrder: {adapter.initOrder} | {adapter.status}");
+                var startTime = Time.realtimeSinceStartup;
+                Profiler.BeginSample($"AmaGDK.adapter.InitSDK-{adapter.adapterId}");
+                adapter.InitSDK();
+                Profiler.EndSample();
+
+                if (adapter.status != Status.Ready)
                 {
-                    LogWarning($"{adapter.adapterId} init time out: {TIMEOUT}");
+                    var beginTime = Time.realtimeSinceStartup;
+                    yield return GDKUtils.Timeout(adapter.Timeout,() => adapter.status != Status.Initialize);
+                    var endTime = Time.realtimeSinceStartup; 
+                        
+                    if (adapter.status == Status.Initialize)
+                    {
+                        LogWarning($"{adapter.adapterId} init time out: {adapter.Timeout:#0.00}");
+                    } else
+                    {
+                        Log($"{adapter.adapterId} init took: {(endTime-beginTime):#0.00} s");
+                    }
                 }
-
                 dispatcher.Dispatch(Event.ADAPTER_READY, adapter.adapterId);
                 sb.AppendLine($"[{(adapter.IsReady ? " OK " : "FAIL")}] {adapter.adapterId} (~ {Time.realtimeSinceStartup - startTime:#0.00}s)");
                 
@@ -170,7 +176,7 @@ namespace Amanotes.Core
             }
             
             var startTime = Time.realtimeSinceStartup;
-            var sb = new StringBuilder();
+            var sb = GDKPool.GetStringBuilder();
 
             InitModules();
             
@@ -205,6 +211,7 @@ namespace Amanotes.Core
             
             sb.Append($"\nMapping UserId: {User.UserId}\n");
             Debug.Log($"AmaGDK v{VERSION} | {READY} in {initDuration:#0.00}s\n\n{sb}");
+            GDKPool.Return(sb);
         }
 
         private void ConfigGeoLocation()
@@ -346,7 +353,9 @@ namespace Amanotes.Core
             public const string FIREBASE_REMOTE_CONFIG = "FirebaseRemoteConfig";
             public const string APPSFLYER = "AppsFlyer";
             public const string IRONSOURCE = "IronSource";
+            public const string MAX = "Max";
             public const string REVENUECAT = "RevenueCat";
+            public const string SQLITE_ANALYTICS = "SqliteAnalytics";
         }
     }
     

package/Runtime/AnalyticQualityAsset.cs

@@ -1,3 +1,4 @@
+using Amanotes.Core.Internal;
 using System;
 using System.Collections.Generic;
 using System.Linq;
@@ -82,14 +83,15 @@ namespace Amanotes.Core
 
         internal void ValidateParams(string eventName, Dictionary<string, object> eventParams)
         {
-            StringBuilder logBuilder = new StringBuilder();
+            var logBuilder = GDKPool.GetStringBuilder();
+            
             logBuilder.AppendLine($"Analytics quality violation found for event <{eventName}>");
-            bool isValid = true;
-            HashSet<string> checkedParameters = new HashSet<string>();
+            var isValid = true;
+            HashSet<string> checkedParameters = GDKPool.GetHashSet();
 
             foreach (var kvp in DicParam)
             {
-                if (!eventParams.ContainsKey(kvp.Key))
+                if (!eventParams.TryGetValue(kvp.Key, out object paramValue))
                 {
                     if (!kvp.Value.isOptional)
                     {
@@ -99,8 +101,6 @@ namespace Amanotes.Core
                     continue;
                 }
 
-                object paramValue = eventParams[kvp.Key];
-
                 if (!ValidateParamType(paramValue, kvp.Value.type))
                 {
                     isValid = false;
@@ -117,8 +117,11 @@ namespace Amanotes.Core
                 isValid = false;
                 logBuilder.AppendLine($"[+] {parameter.Key}");
             }
-
+            
             if (!isValid) LogWarningOnce(logBuilder.ToString());
+            
+            GDKPool.Return(logBuilder);
+            GDKPool.Return(checkedParameters);
         }
 
         private bool ValidateParamType(object paramValue, ParamType paramType)
@@ -179,7 +182,7 @@ namespace Amanotes.Core
         [ContextMenu("Validate Unique EventNames")]
         private void ValidateUniqueEventNames()
         {
-            HashSet<string> eventNames = new HashSet<string>();
+            HashSet<string> eventNames = GDKPool.GetHashSet();
             
             lstEvent = lstEvent.OrderBy(evt => evt.eventName).ToList();
             
@@ -189,7 +192,7 @@ namespace Amanotes.Core
 
                 if (!eventNames.Add(eventQuality.eventName)) Debug.LogWarning($"Duplicate event name found: {eventQuality.eventName}. Event names must be unique.");
 
-                HashSet<string> paramNames = new HashSet<string>();
+                HashSet<string> paramNames = GDKPool.GetHashSet();
                 
                 eventQuality.lstParam = eventQuality.lstParam.OrderBy(param => param.paramName).ToList();
                 
@@ -199,7 +202,11 @@ namespace Amanotes.Core
 
                     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);
             }
+            
+            GDKPool.Return(eventNames);
             EditorUtility.SetDirty(this);
         }
 #endif

package/Runtime/AudioToolkit/AmaGDK.Audio.Latency.cs

@@ -1,6 +1,4 @@
 using System;
-using System.Collections;
-using Amanotes.Core.Internal;
 using UnityEngine;
 
 namespace Amanotes.Core
@@ -75,7 +73,7 @@ namespace Amanotes.Core
                     return DEFAULT_FOR_SPEAKER;
                 }
 
-                string deviceName = DeviceInfo.Name;
+                string deviceName = currentDevice.name;
                 int savedLatency = PlayerPrefs.GetInt(PREF_AUDIO_LATENCY + deviceName, -1);
 
                 if (savedLatency >= 0)

package/Runtime/AudioToolkit/AmaGDK.Audio.cs

@@ -1,7 +1,5 @@
 using UnityEngine;
 using System;
-using System.Collections;
-using System.Text;
 using Amanotes.Core.Internal;
 
 namespace Amanotes.Core.Internal
@@ -9,7 +7,8 @@ namespace Amanotes.Core.Internal
     public partial class ConfigAsset
     {
         [SerializeField]
-        public bool enableAudioModule;
+        [Tooltip("Enable to get accurate audio latency & be informed when audio device changed\n\nApi: AmaGDK.Audio.DeviceInfo")]
+        public bool enableAudioModule = true;
     }
 }
 
@@ -23,21 +22,38 @@ namespace Amanotes.Core
             public const string GDK_AUDIO_INTERRUPT_BEGIN = nameof(GDK_AUDIO_INTERRUPT_BEGIN);
             public const string GDK_AUDIO_INTERRUPT_END = nameof(GDK_AUDIO_INTERRUPT_END);
         }
-        public class AudioDeviceInfo
-        {
-            internal AudioDeviceType Type;
-            internal string RawType;
-            public string Name;
-            public int LatencyMs;
-        }
+
         // Public Usage
-        public partial class Audio
+        public static partial class Audio
         {
-            public static AudioDeviceInfo DeviceInfo;
+            public class AudioDeviceInfo
+            {
+                internal AudioDeviceType type;
+                internal string rawType;
+                public string name;
+                public int latencyMs;
+
+                public override string ToString()
+                {
+                    if (string.IsNullOrEmpty(rawType) || string.IsNullOrEmpty(name)) return base.ToString();
+                    return $"type: {type.ToString().ToLower()} rawType:{rawType} name:{name}";
+                }
+            }
+
+            private static AudioDeviceInfo _currentDevice;
+
+            public static AudioDeviceInfo currentDevice
+            {
+                get => _currentDevice ?? NO_DEVICE;
+                private set => _currentDevice = value;
+            }
 
             private static readonly AudioDeviceInfo NO_DEVICE = new AudioDeviceInfo()
             {
-                LatencyMs = DEFAULT_FOR_SPEAKER
+                type = AudioDeviceType.Unknown,
+                rawType = string.Empty,
+                name = "NO_DEVICE",
+                latencyMs = DEFAULT_FOR_SPEAKER
             };
 
             /// <remarks>
@@ -87,8 +103,8 @@ namespace Amanotes.Core
                 _audioDeviceDetector.RegisterEvents();
                 RegisterCallbacks();
 
-                DeviceInfo = DetectAudioInfo();
-                DeviceInfo.LatencyMs = GetAudioDeviceLatency();
+                currentDevice = DetectAudioInfo();
+                currentDevice.latencyMs = GetAudioDeviceLatency();
             }
 
             private static AudioDeviceInfo DetectAudioInfo()
@@ -102,9 +118,9 @@ namespace Amanotes.Core
                 var info = _audioDeviceDetector.GetInfo();
                 return new AudioDeviceInfo
                 {
-                    Type = info.AudioDeviceType,
-                    RawType = info.RawType,
-                    Name = info.Name
+                    type = info.AudioDeviceType,
+                    rawType = info.RawType,
+                    name = info.Name
                 };
             }
         }
@@ -125,9 +141,9 @@ namespace Amanotes.Core
             {
                 GDKUtils.DelayCall(1f, () =>
                 {
-                    DeviceInfo = DetectAudioInfo();
-                    DeviceInfo.LatencyMs = GetAudioDeviceLatency();
-                    dispatcher.Dispatch(Event.GDK_AUDIO_INFO_CHANGE, DeviceInfo);
+                    currentDevice = DetectAudioInfo();
+                    currentDevice.latencyMs = GetAudioDeviceLatency();
+                    dispatcher.Dispatch(Event.GDK_AUDIO_INFO_CHANGE, currentDevice);
                 });
             }
 
@@ -144,10 +160,10 @@ namespace Amanotes.Core
             {
                 GDKUtils.ThrowIf(!Config.enableAudioModule, "Audio Module is disabled, Please enable it in the AmaGDKConfig");
 
-                return DeviceInfo != null
-                       && (DeviceInfo.RawType == "AVAudioSessionPortBluetoothA2DP"
-                           || DeviceInfo.RawType == "TYPE_BLUETOOTH_A2DP"
-                           || DeviceInfo.RawType == "AVAudioSessionPortBluetoothHFP");
+                return currentDevice != null
+                       && (currentDevice.rawType == "AVAudioSessionPortBluetoothA2DP"
+                           || currentDevice.rawType == "TYPE_BLUETOOTH_A2DP"
+                           || currentDevice.rawType == "AVAudioSessionPortBluetoothHFP");
             }
 
             private static string GetCurrentRouteInputs()

package/Runtime/AudioToolkit/Plugins/AudioDeviceDetector.cs

@@ -86,15 +86,13 @@ namespace Amanotes.Core
 
         private void OnAudioDeviceAdded(string param)
         {
-            if (string.IsNullOrEmpty(param))
-                return;
+            if (string.IsNullOrEmpty(param)) return;
             onChanged?.Invoke(param);
         }
 
         private void OnAudioDeviceRemoved(string param)
         {
-            if (string.IsNullOrEmpty(param))
-                return;
+            if (string.IsNullOrEmpty(param)) return;
             onChanged?.Invoke(param);
         }
 
@@ -170,15 +168,18 @@ namespace Amanotes.Core
             }
 
             StringBuilder sb = null;
-
-            for (int i = 0; i < str.Length; i++)
+            for (var i = 0; i < str.Length; i++)
             {
                 char ch = str[i];
 
                 if (char.IsSurrogate(ch))
                 {
-                    sb ??= new StringBuilder(str, 0, i, str.Length);
-
+                    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
@@ -187,13 +188,13 @@ namespace Amanotes.Core
                         i++;
                     }
                 }
-                else if (sb != null)
+                else
                 {
-                    sb.Append(ch);
+                    sb?.Append(ch);
                 }
             }
-
-            return sb == null ? str : sb.ToString();
+            
+            return sb == null ? str : GDKPool.ReturnString(sb);
         }
     }