com.amanotes.gdk 0.2.67 → 0.2.69

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.cs

@@ -17,7 +17,7 @@ namespace Amanotes.Core
 {
     public partial class AmaGDK : MonoBehaviour
     {
-        public const string VERSION = "0.2.67";
+        public const string VERSION = "0.2.69";
         
         internal static Status _status = Status.None;
         private static ConfigAsset _config = null;
@@ -100,11 +100,12 @@ namespace Amanotes.Core
             Profiler.BeginSample("AmaGDK.InitModules()");
             {
                 User.InitModule();
+                Consent.InitModule();
                 Analytics.InitModule();
                 Ads.InitModule();
                 IAP.InitModule();
                 RemoteConfig.InitModule();
-                Audio.InitModule();
+                if (Config.enableAudioModule) Audio.InitModule();
             }
             Profiler.EndSample();
         }
@@ -124,8 +125,6 @@ namespace Amanotes.Core
 
         IEnumerator InitAdapters(StringBuilder sb)
         {
-            float TIMEOUT = 1;
-            
             // sort on priority
             List<Adapter2> listAdapters = Adapter2.adapterMap
                 .Values.ToList();
@@ -133,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)");
                 
@@ -342,6 +352,7 @@ 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";
         }
     }

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,9 +1,17 @@
 using UnityEngine;
 using System;
-using System.Collections;
-using System.Text;
 using Amanotes.Core.Internal;
 
+namespace Amanotes.Core.Internal
+{
+    public partial class ConfigAsset
+    {
+        [SerializeField]
+        [Tooltip("Enable to get accurate audio latency & be informed when audio device changed\n\nApi: AmaGDK.Audio.DeviceInfo")]
+        public bool enableAudioModule = true;
+    }
+}
+
 namespace Amanotes.Core
 {
     public partial class AmaGDK
@@ -14,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>
@@ -40,6 +65,8 @@ namespace Amanotes.Core
             /// </remarks>
             public static void SetOnAudioDeviceChangeCallback(Action<AudioDeviceInfo> onAudioDeviceChange)
             {
+                GDKUtils.ThrowIf(!Config.enableAudioModule, "Audio Module is disabled, Please enable it in the AmaGDKConfig");
+
                 if (onAudioDeviceChange == null)
                 {
                     Logging.LogWarning("Cannot add a null callback!");
@@ -51,6 +78,8 @@ namespace Amanotes.Core
 
             public static void SetOnAudioInterruptedCallback(Action beginCallback, Action endCallback)
             {
+                GDKUtils.ThrowIf(!Config.enableAudioModule, "Audio Module is disabled, Please enable it in the AmaGDKConfig");
+
                 if (beginCallback != null)
                 {
                     dispatcher.AddListener(Event.GDK_AUDIO_INTERRUPT_BEGIN, beginCallback);
@@ -74,8 +103,8 @@ namespace Amanotes.Core
                 _audioDeviceDetector.RegisterEvents();
                 RegisterCallbacks();
 
-                DeviceInfo = DetectAudioInfo();
-                DeviceInfo.LatencyMs = GetAudioDeviceLatency();
+                currentDevice = DetectAudioInfo();
+                currentDevice.latencyMs = GetAudioDeviceLatency();
             }
 
             private static AudioDeviceInfo DetectAudioInfo()
@@ -89,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
                 };
             }
         }
@@ -112,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);
                 });
             }
 
@@ -129,10 +158,12 @@ namespace Amanotes.Core
         {
             public static bool IsConnectingBluetoothHeadset()
             {
-                return DeviceInfo != null
-                       && (DeviceInfo.RawType == "AVAudioSessionPortBluetoothA2DP"
-                           || DeviceInfo.RawType == "TYPE_BLUETOOTH_A2DP"
-                           || DeviceInfo.RawType == "AVAudioSessionPortBluetoothHFP");
+                GDKUtils.ThrowIf(!Config.enableAudioModule, "Audio Module is disabled, Please enable it in the AmaGDKConfig");
+
+                return currentDevice != null
+                       && (currentDevice.rawType == "AVAudioSessionPortBluetoothA2DP"
+                           || currentDevice.rawType == "TYPE_BLUETOOTH_A2DP"
+                           || currentDevice.rawType == "AVAudioSessionPortBluetoothHFP");
             }
 
             private static string GetCurrentRouteInputs()
@@ -146,6 +177,7 @@ namespace Amanotes.Core
 
             public static bool IsRecordingWithMicrophone()
             {
+                GDKUtils.ThrowIf(!Config.enableAudioModule, "Audio Module is disabled, Please enable it in the AmaGDKConfig");
 #if UNITY_IOS
                 string currentAudioInputs = GetCurrentRouteInputs();
                 return string.IsNullOrWhiteSpace(currentAudioInputs) == false;

package/Runtime/AudioToolkit/Plugins/Android/GDKAudioDeviceDetector.java

@@ -243,7 +243,7 @@ public class GDKAudioDeviceDetector
 
     private static String toTypeString(int AudioDeviceType)
     {
-        return DEVICE_TYPE_MAP.getOrDefault(AudioDeviceType, "TYPE_UNKNOWN");
+        return DEVICE_TYPE_MAP.containsKey(AudioDeviceType) ? DEVICE_TYPE_MAP.get(AudioDeviceType) : "TYPE_UNKNOWN";
     }
 
     // API For Version before M

package/Runtime/Fps/AmaFPS.cs

@@ -60,7 +60,6 @@ namespace Amanotes.Core
         public Action<string, Dictionary<string, object>> LogEventHook;
 
         private bool _isAppReady = false;
-        private int _playCount = 0;
 
         public void TrackLaunchTime()
         {

package/Runtime/Fps/AmaFPSVisualizer.cs

@@ -87,8 +87,8 @@ namespace Amanotes.Core
             public bool enabled = true;
             public Graphic graphic = null;
 
-            public int minFPS = 15;
-            public int maxFPS = 60;
+            public int lowerFPSBoundary = 15;
+            public int upperFPSBoundary = 60;
             public int goodFPS = 55;
             public int acceptableFPS = 45;
             public int badFPS = 30;
@@ -128,8 +128,8 @@ namespace Amanotes.Core
                 {
                     var idx = (i + stIndex) % RESOLUTION;
                     var fps = fpsHistory[idx];
-                    var h = fps <= minFPS ? 0 :
-                                fps >= maxFPS ? 1 : (fps - minFPS) / (maxFPS - minFPS);
+                    var h = fps <= lowerFPSBoundary ? 0 :
+                                fps >= upperFPSBoundary ? 1 : (fps - lowerFPSBoundary) / (upperFPSBoundary - lowerFPSBoundary);
 
                     var v0 = new Vector3(barX, 0, 0);
                     var v1 = new Vector3(barX, h * barH, 0);
@@ -155,9 +155,9 @@ namespace Amanotes.Core
                     barX += barW;
                 }
 
-                AddHorzLine(vh, rect.width, barH * ((goodFPS-minFPS) / (float)(maxFPS-minFPS)), colors[2], 2f);
-                AddHorzLine(vh, rect.width, barH * ((acceptableFPS-minFPS) / (float)(maxFPS-minFPS)), colors[1], 2f);
-                AddHorzLine(vh, rect.width, barH * ((badFPS-minFPS) / (float)(maxFPS-minFPS)), colors[0], 2f);
+                AddHorzLine(vh, rect.width, barH * ((goodFPS-lowerFPSBoundary) / (float)(upperFPSBoundary-lowerFPSBoundary)), colors[2], 2f);
+                AddHorzLine(vh, rect.width, barH * ((acceptableFPS-lowerFPSBoundary) / (float)(upperFPSBoundary-lowerFPSBoundary)), colors[1], 2f);
+                AddHorzLine(vh, rect.width, barH * ((badFPS-lowerFPSBoundary) / (float)(upperFPSBoundary-lowerFPSBoundary)), colors[0], 2f);
             }
 
             void AddHorzLine(VertexHelper vh, float w, float h, Color color, float thickness = 1f)

package/Runtime/Internal/AmaGDK.Internal.AmaGUI.cs

@@ -100,7 +100,7 @@ namespace Amanotes.Core.Internal
             GUI.DrawTextureWithTexCoords(new Rect(x + l, y + t, centerX, centerY), texture, new Rect(lu, bv, ru - lu, tv - bv));
         }
 
-        public static void SectionLabel(string text)
+        public static void SectionLabel(GUIContent text)
         {
             if (BIG_LABEL == null)
             {

package/Runtime/Internal/GDKGeoLocationcs.cs

@@ -7,7 +7,9 @@ namespace Amanotes.Core.Internal
 {
     public partial class ConfigAsset
     {
-        [SerializeField] public bool enableGeoLocation = true;
+        [SerializeField]
+        [Tooltip("Enable to get countryCode automatically, provided by '"+ CountryIS_GeoLocationProvider.URL + "'\n\ndefault: OFF")]
+        public bool enableGeoLocation = false;
     }
 
     internal class GDKGeoLocation

package/Runtime/Internal/GDKServerTime.cs

@@ -58,7 +58,7 @@ namespace Amanotes.Core
 
     internal class WorldTimeServer_TimeProvider : BaseServerTimeProvider
     {
-        private const string URL = "https://www.worldtimeserver.com/current_time_in_LA.aspx";
+        internal const string URL = "https://www.worldtimeserver.com/current_time_in_LA.aspx";
 
         public override ServerTimeData ParseResponse(string response)
         {
@@ -90,7 +90,7 @@ namespace Amanotes.Core
 
     internal class WorldTimeAPI_TimeProvider : BaseServerTimeProvider
     {
-        private const string URL = "https://worldtimeapi.org/api/ip";
+        internal const string URL = "https://worldtimeapi.org/api/ip";
 
         [Serializable]
         private class TimeData
@@ -123,18 +123,21 @@ namespace Amanotes.Core.Internal
 {
     public partial class ConfigAsset
     {
-        [SerializeField] public bool enableServerTime = true;
+        [SerializeField]
+        [Tooltip("Enable to get serverTime automatically, provided by\n\n'"+ WorldTimeAPI_TimeProvider.URL + "'\n'" + WorldTimeServer_TimeProvider.URL+ "'\n\ndefault: OFF" )]
+        public bool enableServerTime = false;
     }
 
     internal class GDKServerTime
     {
         private const float MAX_WAIT_TIME = 60;
-        private List<IServerTimeProvider> providers = new List<IServerTimeProvider>() { new WorldTimeAPI_TimeProvider(), new WorldTimeServer_TimeProvider() };
-        private int currentIndex = 0;
-        private IServerTimeProvider provider
+        private List<IServerTimeProvider> providers = new List<IServerTimeProvider>()
         {
-            get { return providers[currentIndex]; }
-        }
+            new WorldTimeAPI_TimeProvider(),
+            new WorldTimeServer_TimeProvider()
+        };
+        private int currentIndex = 0;
+        private IServerTimeProvider provider => providers[currentIndex];
 
         private DateTime? serverTime;
         private float timeSinceFetchServerTime;
@@ -144,7 +147,7 @@ namespace Amanotes.Core.Internal
         {
         }
 
-        public void SetTimeProviders(List<IServerTimeProvider> providers)
+        internal void SetTimeProviders(List<IServerTimeProvider> providers)
         {
             GDKUtils.ThrowIf(providers == null || providers.Count == 0, "Server time providers list cannot be null or empty.");
             this.providers = providers;
@@ -173,7 +176,7 @@ namespace Amanotes.Core.Internal
             }
         }
 
-        public void UpdateTime(Action<DateTime?> result = null)
+        internal void UpdateTime(Action<DateTime?> result = null)
         {
             provider.FetchServerTime(data =>
             {

package/package.json

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