com.amanotes.gdk 0.2.81-alpha.5 → 0.2.81-alpha.7

package/CHANGELOG.md

@@ -1,5 +1,3 @@
-# Changelog
-
 ## [0.2.80] - 2024-11-13
 - [Dev] Don't use obsolete functions
 - [Dev] Add CrashlyticHook
@@ -14,7 +12,6 @@
 - [Dev] Track Adapters and Third-party packages used in games
 
 ## [0.2.77] - 2024-11-07
-- [Release] 0.2.76
 - [Dev] Remove GDKAudio
 - [Dev] Handle format exception in RemoteConfig
 - [Dev] Handle exception of FetchConfig

package/Runtime/AmaGDK.cs

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

package/Runtime/Consent/AmaGDK.Consent.cs

@@ -0,0 +1,224 @@
+using System;
+using Amanotes.Core.Internal;
+using UnityEngine;
+using static Amanotes.Core.GDKDebug;
+
+namespace Amanotes.Core
+{
+    public partial class AmaGDK //Consent
+    {
+        public static partial class Consent //Public
+        {
+            private static readonly GDKTaskTracker _allConsentTaskTracker = new GDKTaskTracker();
+            public static void RequestAllConsents(Action onComplete)
+            {
+                _allConsentTaskTracker.RegisterOnCompleteCallback(onComplete);
+                if (_allConsentTaskTracker.HasStarted) return;
+                
+                _allConsentTaskTracker.MarkStarted();
+                
+                void CompleteRequestAllConsents()
+                {
+                    _allConsentTaskTracker.MarkCompleted();
+                }
+                void ShowConsentIfRequired()
+                {
+                    CMP.ShowConsentFormIfRequired(
+                        _ => CompleteRequestAllConsents(),
+                        _ => CompleteRequestAllConsents());    
+                }
+#if UNITY_IOS
+                ATT.Request(
+                    allow =>
+                    {
+                        if (allow)
+                        {
+                            ShowConsentIfRequired();
+                            return;
+                        }
+                        CompleteRequestAllConsents();
+                    });
+#else
+                ShowConsentIfRequired();
+#endif
+            }
+        }
+        
+        public static partial class Consent //ATT
+        {
+            public static class ATT
+            {
+                public static bool IsAllowed
+                {
+                    get
+                    {
+                        if (checkedATT) return allowedATT;
+                        LogWarning("[Consent] ATT has not completed yet");
+                        return false;
+                    }
+                }
+            
+                public static void Request(Action<bool> onComplete)
+                {
+                    if (checkedATT)
+                    {
+                        Log("[Consent] ATT has already completed");
+                        onComplete?.Invoke(allowedATT);
+                        return;
+                    }
+                    if (ConsentHook.ATTRequest == null)
+                    {
+                        LogWarning("[Consent] ConsentHook.ATTRequest is not implemented");
+                        onComplete?.Invoke(false);
+                        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
+            {
+                /// <summary>
+                /// Determines if a consent popup should be shown to the user and displays it if required.
+                /// The consent popup will be shown only once in the lifecycle of the app if this function is used.
+                /// </summary>
+                /// <remarks>
+                /// The consent popup is required in the European Economic Area (EEA) and
+                /// other countries that have implemented the General Data Protection Regulation (GDPR).
+                /// </remarks>
+                /// <param name="onComplete">Callback invoked with a boolean indicating the
+                /// ConsentInformation.CanRequestAds() result
+                /// </param>
+                /// <param name="onError">Callback invoked with an error message if the consent
+                /// form could not be loaded or shown.</param>
+                public static void ShowConsentFormIfRequired(Action<bool> onComplete, Action<string> onError)
+                {
+                    if (ConsentHook.ShowConsentFormIfRequired == null)
+                    {
+                        LogWarning("[Consent] ConsentHook.ShowConsentFormIfRequired is not implemented");
+                        onError?.Invoke("ShowPrivacyForm is not implemented");
+                        return;
+                    }
+                    if (data.consentAlreadyShown)
+                    {
+                        Log("[Consent] Consent form has already been shown");
+                        onComplete?.Invoke(data.canShowAds);
+                        return;
+                    }
+                    ConsentHook.ShowConsentFormIfRequired(canShowAd =>
+                    {
+                        data.canShowAds = canShowAd;
+                        data.consentAlreadyShown = true;
+                        data.SaveJsonToFile();
+                        onComplete?.Invoke(canShowAd);
+                    }, onError);
+                }
+                
+                /// <summary>
+                /// Forces the consent popup to be shown to the user, regardless of previous
+                /// consent status.
+                /// </summary>
+                /// <param name="onComplete">Callback invoked with a boolean indicating the
+                /// ConsentInformation.CanRequestAds() result
+                /// </param>
+                /// <param name="onError">Callback invoked with an error message if the consent
+                /// form could not be loaded or shown.</param>
+                public static void ShowPrivacyForm(Action<bool> onComplete, Action<string> onError)
+                {
+                    if (ConsentHook.CheckPrivacyOptionsRequired == null)
+                    {
+                        LogWarning("[Consent] ConsentHook.ShowPrivacyForm is not implemented");
+                        onError?.Invoke("ShowPrivacyForm is not implemented");
+                        return;
+                    }
+                    ConsentHook.ShowPrivacyForm(onComplete, onError);
+                }
+
+                /// <summary>
+                /// Determines whether privacy options are required for the current user.
+                /// Updates the consent information before returning the result.
+                /// </summary>
+                /// <param name="onComplete">Callback invoked with `true` if privacy options are required, otherwise `false`.</param>
+                public static void CheckPrivacyOptionsRequired(Action<bool> onComplete)
+                {
+                    if (ConsentHook.CheckPrivacyOptionsRequired == null)
+                    {
+                        LogWarning("[Consent] ConsentHook.CheckPrivacyOptionsRequired is not implemented");
+                        onComplete?.Invoke(false);
+                        return;
+                    }
+                    ConsentHook.CheckPrivacyOptionsRequired(onComplete);
+                }
+
+                [Obsolete("Use ShowPrivacyForm instead")]
+                public static void ForceShowPopup(Action<bool> onComplete)
+                {
+                    ShowPrivacyForm(onComplete, s => onComplete?.Invoke(false));
+                }
+            }
+        }
+
+        public static partial class Consent //Internal
+        {
+            private static readonly Lazy<ConsentData> _data = new Lazy<ConsentData>(() => new ConsentData().LoadJsonFromFile());
+            private static ConsentData data => _data.Value;
+            private static Action _onConsentComplete;
+            
+            internal static bool checkedATT => data.att >= Status.Allowed;
+            internal static bool allowedATT => data.att == Status.Allowed;
+            
+            internal enum Status
+            {
+                None,
+                NotRequired,
+                Allowed,
+                NotAllowed
+            }
+
+            internal static bool InitModule()
+            {
+                if (_config.autoGetConsent)
+                {
+                    RequestAllConsents(null);
+                }
+                return true;
+            }
+        }
+    }
+    
+    [Serializable]
+    public class ConsentData : IJsonFile
+    {
+        [SerializeField] internal AmaGDK.Consent.Status att;
+        [SerializeField] internal bool consentAlreadyShown;
+        [SerializeField] internal bool canShowAds;
+    }
+
+    public static class ConsentHook
+    {
+        public static Action<Action<bool>, Action<string>> ShowConsentFormIfRequired;
+        public static Action<Action<bool>, Action<string>> ShowPrivacyForm;
+        public static Action<Action<bool>> CheckPrivacyOptionsRequired;
+        public static Action<Action<bool>> ATTRequest;
+    }
+}
+
+namespace Amanotes.Core.Internal
+{
+    public partial class ConfigAsset
+    {
+        [SerializeField]
+        [Tooltip("Auto pop-up ATT and CMP form")]
+        public bool autoGetConsent = true;
+    }
+}

package/Runtime/Consent/GDKPrivacyButton.cs

@@ -0,0 +1,25 @@
+using System;
+using UnityEngine;
+using UnityEngine.UI;
+namespace Amanotes.Core
+{
+    public class GDKPrivacyButton: MonoBehaviour
+    {
+        public Button button;
+        private void Start()
+        {
+            gameObject.SetActive(false);
+            UpdateUI();
+        }
+        
+        public void OnButtonClick()
+        {
+            AmaGDK.Consent.CMP.ShowPrivacyForm(canShowAd => UpdateUI(), GDKDebug.LogWarning);
+        }
+
+        private void UpdateUI()
+        {
+            AmaGDK.Consent.CMP.CheckPrivacyOptionsRequired(required => button.interactable = required);   
+        }
+    }
+}

package/Runtime/Consent/GDKPrivacyButton.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 23184a9779a949419e702ce599a0dcc5
+timeCreated: 1733448516

package/Runtime/Consent/GDKPrivacyButton.prefab

@@ -0,0 +1,148 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!1 &4256389965931995120
+GameObject:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  serializedVersion: 6
+  m_Component:
+  - component: {fileID: 1151037748665809425}
+  - component: {fileID: 981792811258053838}
+  - component: {fileID: 6086753863169534924}
+  - component: {fileID: 3785844084317390329}
+  - component: {fileID: 2957037893780307854}
+  m_Layer: 0
+  m_Name: GDKPrivacyButton
+  m_TagString: Untagged
+  m_Icon: {fileID: 0}
+  m_NavMeshLayer: 0
+  m_StaticEditorFlags: 0
+  m_IsActive: 1
+--- !u!224 &1151037748665809425
+RectTransform:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 4256389965931995120}
+  m_LocalRotation: {x: 0, y: 0, z: 0, w: 1}
+  m_LocalPosition: {x: 0, y: 0, z: 0}
+  m_LocalScale: {x: 1, y: 1, z: 1}
+  m_Children: []
+  m_Father: {fileID: 0}
+  m_RootOrder: 0
+  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
+  m_AnchorMin: {x: 0.5, y: 0.5}
+  m_AnchorMax: {x: 0.5, y: 0.5}
+  m_AnchoredPosition: {x: 0, y: 0}
+  m_SizeDelta: {x: 100, y: 100}
+  m_Pivot: {x: 0.5, y: 0.5}
+--- !u!114 &981792811258053838
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 4256389965931995120}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: 4e29b1a8efbd4b44bb3f3716e73f07ff, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  m_Navigation:
+    m_Mode: 3
+    m_WrapAround: 0
+    m_SelectOnUp: {fileID: 0}
+    m_SelectOnDown: {fileID: 0}
+    m_SelectOnLeft: {fileID: 0}
+    m_SelectOnRight: {fileID: 0}
+  m_Transition: 1
+  m_Colors:
+    m_NormalColor: {r: 1, g: 1, b: 1, a: 1}
+    m_HighlightedColor: {r: 0.9607843, g: 0.9607843, b: 0.9607843, a: 1}
+    m_PressedColor: {r: 0.78431374, g: 0.78431374, b: 0.78431374, a: 1}
+    m_SelectedColor: {r: 0.9607843, g: 0.9607843, b: 0.9607843, a: 1}
+    m_DisabledColor: {r: 0.78431374, g: 0.78431374, b: 0.78431374, a: 0.5019608}
+    m_ColorMultiplier: 1
+    m_FadeDuration: 0.1
+  m_SpriteState:
+    m_HighlightedSprite: {fileID: 0}
+    m_PressedSprite: {fileID: 0}
+    m_SelectedSprite: {fileID: 0}
+    m_DisabledSprite: {fileID: 0}
+  m_AnimationTriggers:
+    m_NormalTrigger: Normal
+    m_HighlightedTrigger: Highlighted
+    m_PressedTrigger: Pressed
+    m_SelectedTrigger: Selected
+    m_DisabledTrigger: Disabled
+  m_Interactable: 1
+  m_TargetGraphic: {fileID: 2957037893780307854}
+  m_OnClick:
+    m_PersistentCalls:
+      m_Calls:
+      - m_Target: {fileID: 6086753863169534924}
+        m_TargetAssemblyTypeName: Amanotes.Core.GDKPrivacyButton, AmaGDK
+        m_MethodName: OnButtonClick
+        m_Mode: 1
+        m_Arguments:
+          m_ObjectArgument: {fileID: 0}
+          m_ObjectArgumentAssemblyTypeName: UnityEngine.Object, UnityEngine
+          m_IntArgument: 0
+          m_FloatArgument: 0
+          m_StringArgument: 
+          m_BoolArgument: 0
+        m_CallState: 2
+--- !u!114 &6086753863169534924
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 4256389965931995120}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: 23184a9779a949419e702ce599a0dcc5, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  button: {fileID: 981792811258053838}
+--- !u!222 &3785844084317390329
+CanvasRenderer:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 4256389965931995120}
+  m_CullTransparentMesh: 1
+--- !u!114 &2957037893780307854
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 4256389965931995120}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: fe87c0e1cc204ed48ad3b37840f39efc, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  m_Material: {fileID: 0}
+  m_Color: {r: 1, g: 1, b: 1, a: 1}
+  m_RaycastTarget: 1
+  m_RaycastPadding: {x: 0, y: 0, z: 0, w: 0}
+  m_Maskable: 1
+  m_OnCullStateChanged:
+    m_PersistentCalls:
+      m_Calls: []
+  m_Sprite: {fileID: 0}
+  m_Type: 0
+  m_PreserveAspect: 0
+  m_FillCenter: 1
+  m_FillMethod: 4
+  m_FillAmount: 1
+  m_FillClockwise: 1
+  m_FillOrigin: 0
+  m_UseSpriteMesh: 0
+  m_PixelsPerUnitMultiplier: 1

package/Runtime/Consent/GDKPrivacyButton.prefab.meta

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

package/Runtime/Consent.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: fd1abbc2a7bd48d9b0f429852b96daa9
+timeCreated: 1733448490

package/Runtime/Core/GDKTaskTracker.cs

@@ -0,0 +1,118 @@
+using Amanotes.Core.Internal;
+using System;
+
+namespace Amanotes.Core
+{
+    internal abstract class GDKTaskTrackerBase
+    {
+        protected enum GDKTaskState
+        {
+            None,
+            Running,
+            Completed,
+        }
+        
+        protected GDKTaskState state;
+        public bool HasCompleted => state == GDKTaskState.Completed;
+        public bool HasStarted => state >= GDKTaskState.Running;
+        
+        public void MarkStarted()
+        {
+            if (HasStarted)
+            {
+                GDKDebug.LogWarning("[GDKTaskTracker] Task already started");
+                return;
+            }
+            
+            state = GDKTaskState.Running;
+        }
+        
+        public virtual void Reset()
+        {
+            if (state == GDKTaskState.Running)
+            {
+                GDKDebug.LogWarning("[GDKTaskTracker] Task stop abruptly because of Reset()");
+            }
+            state = GDKTaskState.None;
+        }
+
+        protected bool ValidateMarkComplete()
+        {
+            if (HasCompleted)
+            {
+                GDKDebug.LogWarning("[GDKTaskTracker] Task already completed");
+                return false;
+            }
+            
+            if (!HasStarted)
+            {
+                GDKDebug.LogWarning("[GDKTaskTracker] Task not yet started or been reset?");
+            }
+            
+            state = GDKTaskState.Completed;
+            return true;
+        }
+    }
+
+
+    internal class GDKTaskTracker : GDKTaskTrackerBase
+    {
+        private Action callback;
+        public void RegisterOnCompleteCallback(Action onComplete)
+        {
+            if (HasCompleted)
+            {
+                onComplete?.Invoke();
+            }
+            else
+            {
+                callback -= onComplete;
+                callback += onComplete;
+            }
+        }
+        
+        public void MarkCompleted()
+        {
+            if (!ValidateMarkComplete()) return;
+            GDKUtils.SafeInvokeAndClear(ref callback);
+        }
+
+        public override void Reset()
+        {
+            base.Reset();
+            callback = null;
+        }
+    }
+    
+    internal class GDKTaskTracker<T> : GDKTaskTrackerBase
+    {
+        public T Result { get; private set; }
+        private Action<T> callback;
+        
+        public void RegisterOnCompleteCallback(Action<T> onComplete)
+        {
+            if (HasCompleted)
+            {
+                onComplete?.Invoke(Result);
+            }
+            else
+            {
+                callback -= onComplete;
+                callback += onComplete;
+            }
+        }
+        
+        public void MarkCompleted(T result)
+        {
+            if (!ValidateMarkComplete()) return;
+            Result = result;
+            GDKUtils.SafeInvokeAndClear(ref callback, Result);
+        }
+        
+        public override void Reset()
+        {
+            base.Reset();
+            callback = null;
+        }
+    }
+}

package/Runtime/Core/GDKTaskTracker.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 5c024a021cd0415bb5aace8887625c3d
+timeCreated: 1733366401

package/Runtime/GDKAudio/Plugins.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 556517e393f149748cf9890d5d436491
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Runtime/GDKAudio.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 19f1c4b4ece54d438bb89c63b87846bf
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Runtime/Utils/GDKUtils.cs

@@ -14,6 +14,14 @@ namespace Amanotes.Core.Internal
             SafeInvoke(temp);
         }
         
+        public static void SafeInvokeAndClear<T>(ref Action<T> action, T data)
+        {
+            if (action == null) return;
+            Action<T> temp = action;
+            action = null;
+            SafeInvoke(temp, data);
+        }
+        
         public static void SafeInvoke(Action action)
         {
             if (action == null) return;

package/package.json

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

package/Runtime/AmaGDK.Consent.cs

@@ -1,256 +0,0 @@
-using System;
-using Amanotes.Core.Internal;
-using UnityEngine;
-using static Amanotes.Core.GDKDebug;
-
-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)
-                {
-                    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;
-                        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)
-                        {
-                            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 Lazy<ConsentData> _data = new Lazy<ConsentData>(() => new ConsentData().LoadJsonFromFile());
-            private static ConsentData data => _data.Value;
-            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.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();
-                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;
-                
-                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;
-                
-                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;
-                
-                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;
-                
-                LogWarning("[Consent] ConsentHook.ATTRequest is null");
-                _attRequest = callback => callback(false);
-                return _attRequest;
-            }
-            set => _attRequest = value;
-        }
-    }
-}
-
-namespace Amanotes.Core.Internal
-{
-    public partial class ConfigAsset
-    {
-        [SerializeField]
-        [Tooltip("Auto pop-up ATT and CMP form")]
-        public bool autoGetConsent = true;
-    }
-}