com.amanotes.gdk 0.2.66 → 0.2.68

package/Runtime/Ad/AmaGDK.Ads.cs

@@ -0,0 +1,383 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+using Amanotes.Core.Internal;
+
+using static Amanotes.Core.Internal.Logging;
+using static Amanotes.Core.AmaGDK;
+
+namespace Amanotes.Core
+{
+    public partial class AmaGDK // Ads module
+    {
+        partial class Event
+        {
+            public const string INTER_REQUEST = nameof(INTER_REQUEST);
+            public const string INTER_SHOW_CALLED = nameof(INTER_SHOW_CALLED);
+            public const string INTER_SHOW_READY = nameof(INTER_SHOW_READY);
+            public const string INTER_SHOW_NOT_READY = nameof(INTER_SHOW_NOT_READY); // reason: string
+            public const string INTER_SHOW_BEGIN = nameof(INTER_SHOW_BEGIN); // always call result: true / false
+            public const string INTER_SHOW_END = nameof(INTER_SHOW_END); // always call result: true / false
+        
+            public const string REWARD_REQUEST = nameof(REWARD_REQUEST);
+            public const string REWARD_VIDEO_SHOW_CALLED = nameof(REWARD_VIDEO_SHOW_CALLED);
+            public const string REWARD_VIDEO_SHOW_READY = nameof(REWARD_VIDEO_SHOW_READY);
+            public const string REWARD_VIDEO_SHOW_NOT_READY = nameof(REWARD_VIDEO_SHOW_NOT_READY); // reason: string
+            // public const string REWARD_VIDEO_REWARD_GRANTED = nameof(REWARD_VIDEO_REWARD_GRANTED);
+            public const string REWARD_VIDEO_SHOW_BEGIN = nameof(REWARD_VIDEO_SHOW_BEGIN); // always call result: true / false
+            public const string REWARD_VIDEO_SHOW_END = nameof(REWARD_VIDEO_SHOW_END); // always call result: true / false
+
+            public const string BANNER_SHOW = nameof(BANNER_SHOW);
+        }
+        
+        
+        [Serializable]
+        internal class AdStat
+        {
+            // per session
+            internal float prevCallTime;
+            internal float currentCallTime;
+            internal int callCount;
+            
+            internal float lastSuccessTime;
+            internal int success;
+            internal int failed;
+            
+            // persistent
+            public int successTotal;
+            public int failedTotal;
+        }
+
+        [Serializable]
+        internal class AdsData : IJsonFile
+        {
+            public AdStat interstitial = new AdStat();
+            public AdStat reward = new AdStat();
+
+            internal AdStat GetStat(AdType adType)
+            {
+                return adType == AdType.Interstitial ? interstitial : reward;
+            }
+            
+            internal int ShowCallCount(AdType adType)
+            {
+                return GetStat(adType).callCount;
+            }
+            
+            internal int TimeSinceLastShowCalled(AdType adType)
+            {
+                AdStat stat = GetStat(adType);
+                AdShowContext context = Ads.context;
+                
+                // Right inside XXX_ShowCalled() callbacks
+                if (context != null && context.adType == adType)
+                {
+                    if (stat.callCount == 1) return 0; // first call
+                    return (int)(stat.currentCallTime - stat.prevCallTime);
+                }
+                
+                if (stat.callCount == 0) return 0; // not yet called
+                return (int)(Time.realtimeSinceStartup - stat.prevCallTime);
+            }
+
+            internal int TimeSinceLastShowSuccess(AdType adType)
+            {
+                return (int)(Time.realtimeSinceStartup - GetStat(adType).lastSuccessTime);
+            }
+            
+            internal void Save()
+            {
+                this.SaveJsonToFile();
+            }
+        }
+
+        [Serializable]
+        public class AdAdapterConfig
+        {
+            
+        }
+
+        public partial class Ads
+        {
+            public static bool allowAdRequest = true;
+
+            // internal use
+            internal static readonly AdsData localData = new AdsData().LoadJsonFromFile();
+
+            internal protected static AdShowContext context;
+            internal protected static AdAdapter _adapter;
+            internal protected static float _savedVolume = -1;
+            internal protected static float _savedTimeScale = -1;
+
+            public static void OnInter_Request(Action callback)
+            {
+                dispatcher.AddListener(Event.INTER_REQUEST, callback);
+            }
+
+            public static void OnInter_ShowCalled(Action callback)
+            {
+                dispatcher.AddListener(Event.INTER_SHOW_CALLED, callback);
+            }
+        
+            public static void OnReward_ShowCalled(Action callback)
+            {
+                dispatcher.AddListener(Event.REWARD_VIDEO_SHOW_CALLED, callback);
+            }
+            
+            public static void OnInter_ShowReady(Action callback)
+            {
+                dispatcher.AddListener(Event.INTER_SHOW_READY, callback);
+            }
+        
+            public static void OnReward_ShowReady(Action callback)
+            {
+                dispatcher.AddListener(Event.REWARD_VIDEO_SHOW_READY, callback);
+            }
+        
+            public static void OnInter_ShowNotReady(Action<AdShowReadyStatus> callback)
+            {
+                dispatcher.AddListener(Event.INTER_SHOW_NOT_READY, callback);
+            }
+        
+            public static void OnReward_ShowNotReady(Action<AdShowReadyStatus> callback)
+            {
+                dispatcher.AddListener(Event.REWARD_VIDEO_SHOW_NOT_READY, callback);
+            }
+        }
+
+        public partial class Ads // Public
+        {
+            internal static bool InitModule()
+            {
+                _adapter = Adapter2.GetAdapter<AdAdapter>();
+                return _adapter == null;
+            }
+            
+            internal static void StartModule()
+            {
+                if (_adapter == null) return;
+                
+                if (Config.ad.enableInterstitial) _adapter.interstitial.StartLoadAd();
+                if (Config.ad.enableRewarded) _adapter.rewardVideo.StartLoadAd();
+                if (Config.ad.preloadBanner) PreloadBanner();
+                if (_isBannerShowing)
+                {
+                    _isBannerShowing = false;
+                    ShowBanner();
+                }
+            }
+
+            public static bool HasInterstitial => _adapter?.interstitial.hasAd ?? false;
+            public static bool HasRewardedVideo => _adapter?.rewardVideo.hasAd ?? false;
+            public static bool IsBannerShowing => _isBannerShowing;
+            public static bool IsAdShowing => context != null;
+
+            private static bool ClearPrevContext()
+            {
+                if (context == null) return true;
+                float duration = Time.realtimeSinceStartup - context.showCallAt;
+                LogWarning($"[AD] ShowRequest IGNORED as another ad is showing (elapsedTime: {duration:n2}s):\n" + JsonUtility.ToJson(context, true));
+                return false;
+            }
+
+            public static IAdCallback ShowInterstitial(string placementName = null, Dictionary<string, object> userData = null)
+            {
+                if (_adapter == null) return null;
+                if (!ClearPrevContext()) return null;
+
+                context = new AdShowContext(AdType.Interstitial, placementName, userData);
+                _adapter.interstitial.StartShowAd();
+                return context;
+            }
+
+            public static bool IsInterstitialShowing => (context != null) && (context.adType == AdType.Interstitial);
+
+            public static IAdCallback ShowRewardedVideo(string placementName = null, Dictionary<string, object> userData = null)
+            {
+                if (_adapter == null) return null;
+                if (!ClearPrevContext()) return null;
+
+                context = new AdShowContext(AdType.VideoReward, placementName, userData);
+                _adapter.rewardVideo.StartShowAd();
+                return context;
+            }
+
+            public static bool IsRewardedVideoShowing => (context != null) && (context.adType == AdType.VideoReward);
+
+
+            [NonSerialized] private static bool _isBannerShowing = false;
+            
+            public static void PreloadBanner()
+            {
+                if (!_config.ad.enableBanner)
+                {
+                    LogWarning($"Banner not enabled! {_config.ad.enableBanner}");
+                    return;
+                }
+                
+                if (_adapter == null)
+                {
+                    LogWarning($"Adapter is null!");
+                    return;
+                }
+                
+                if (_isBannerShowing)
+                {
+                    LogWarning($"Banner is showing!");
+                    return;
+                }
+                
+                _adapter.ShowBanner();
+                _adapter.HideBanner();
+            }
+            
+            public static void ShowBanner()
+            {
+                if (!_config.ad.enableBanner)
+                {
+                    LogWarning($"Banner not enabled! {_config.ad.enableBanner}");
+                    return;
+                }
+
+                if (_isBannerShowing)
+                {
+                    LogWarning($"Banner is showing!");
+                    return;
+                }
+                
+                _isBannerShowing = true;
+
+                if (_adapter == null)
+                {
+                    LogWarning($"Adapter is null!");
+                    return;
+                }
+
+                dispatcher.Dispatch(Event.BANNER_SHOW);
+                _adapter.ShowBanner(); 
+            }
+
+            public static void HideBanner()
+            {
+                if (!_config.ad.enableBanner) return;
+                if (!_isBannerShowing) return;
+                _isBannerShowing = false;
+                if (_adapter == null) return;
+                _adapter.HideBanner();
+            }
+
+            public static void StopWaitForAd()
+            {
+                if (_adapter == null) return;
+                if (context == null)
+                    return;
+                
+                if (context.adType == AdType.Interstitial)
+                    _adapter.interstitial.StopShowAd();
+                else
+                    _adapter.rewardVideo.StopShowAd();
+            }
+
+            /// <summary>
+            /// Capping for interstitial ad
+            /// - Time since last interstitial show success > interstitialCappingTime
+            /// - Time since last rewardedVideo show success > rewardVideoCappingTime (for interstitial)
+            /// </summary>
+            /// <param name="interstitialCappingTime"></param>
+            /// <param name="rewardedVideoCappingTime"></param>
+            /// <returns></returns>
+            public static bool IsCapped(float interstitialCappingTime = 0, float rewardedVideoCappingTime = 0)
+            {
+                bool interCapped = (interstitialCappingTime > 0) && TimeSinceLastInterstitialSucceed < interstitialCappingTime;
+                bool rewardCapped = (rewardedVideoCappingTime > 0) && TimeSinceLastVideoRewardSucceed < rewardedVideoCappingTime;
+                return interCapped || rewardCapped;
+            }
+
+            public static int TimeSinceLastInterstitialSucceed => localData.TimeSinceLastShowSuccess(AdType.Interstitial);
+            public static int TimeSinceLastVideoRewardSucceed => localData.TimeSinceLastShowSuccess(AdType.VideoReward);
+            public static int TimeSinceLastAdSucceed => Math.Min(TimeSinceLastInterstitialSucceed, TimeSinceLastVideoRewardSucceed);
+            public static int TimeSinceLastInterstitialShowCalled => localData.TimeSinceLastShowCalled(AdType.Interstitial);
+            public static int TimeSinceLastVideoRewardShowCalled => localData.TimeSinceLastShowCalled(AdType.VideoReward);
+
+            public static int InterstitialShowCalledInSession => localData.ShowCallCount(AdType.Interstitial);
+            public static int RewardVideoShowCalledInSession => localData.ShowCallCount(AdType.VideoReward);
+
+            public static void SetUserId(string userId)
+            {
+                if (_adapter == null) return;
+                _adapter.SetUserId(userId);
+            }
+        }
+    }
+}
+
+namespace Amanotes.Core.Internal
+{
+    [Serializable] public abstract class AdAdapter : Adapter2
+    {
+        protected AdShowContext context => Ads.context;
+        protected AdModuleConfig moduleConfig => Config.ad;
+
+        // APIs
+        internal protected abstract AdLogic interstitial { get; }
+        internal protected abstract AdLogic rewardVideo { get; }
+        
+        public abstract void ShowBanner();
+        public abstract void HideBanner();
+
+        // Internally used
+        internal protected abstract void SetUserId(string userId);
+    }
+    
+    public interface IAdCallback { }
+    
+    public enum LoadAdsState
+    {
+        None,
+        Requesting,
+        Ready
+    }
+
+    public enum ShowAdsState
+    {
+        None,
+        ShowCalled,
+        WaitForAd,
+        Showing,
+        ShowFail,
+        ShowSuccess
+    }
+
+    [Flags]
+    public enum AdCallback
+    {
+        None = 0,
+        ShowCalled = 1,
+        ShowReadyStatus = 2,
+        Open = 4,
+        Reward = 8,
+        Click = 16,
+        Cancel = 32,
+        Close = 64,
+        Success = 128,
+        Fail = 256
+    }
+    
+    public enum AdType
+    {
+        Interstitial,
+        VideoReward,
+        Banner
+    }
+    
+    public enum AdShowReadyStatus
+    {
+        None,
+        Wifi3GDisabled,
+        NoInternet,
+        WaitForAd,
+        TimeOut,
+        Ready,
+    }
+}

package/Runtime/Ad.meta

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

package/Runtime/AmaGDK.Analytics.cs

@@ -122,6 +122,19 @@ namespace Amanotes.Core
                 return result;
             }
 
+            public static void FlushEventDetails()
+            {
+                if (Config.analytics.autoFlushEventDetail)
+                {
+                    LogWarning("[Analytics] This function FlushEventDetails() is not supposed to be called manually!");
+                    return;
+                }
+                
+                if (!localData._dirty) return;
+                localData._dirty = false;
+                localData.SaveJsonToFile();
+            }
+
             public static IEventParamsBuilder LogFunnelEvent(string eventName, string signature = "")
             {
                 return LogEvent(eventName).SetAsFunnel(signature);
@@ -293,7 +306,7 @@ namespace Amanotes.Core
             internal static readonly ConcurrentQueue<EventParams> eventQueue = new ConcurrentQueue<EventParams>();
             internal static readonly List<AnalyticsAdapter> listAdapters = new List<AnalyticsAdapter>();
             internal static readonly AnalyticsData localData = new AnalyticsData().LoadJsonFromFile().BuildCache();
-            internal static readonly SessionStat sessionStat = _config.analytics.enableEventStat ? new SessionStat() : null;
+            internal static SessionStat sessionStat;
             internal static readonly GDKPool<StringBuilder> sbPool = new GDKPool<StringBuilder>(3);
             internal static readonly GDKPool<EventParams> epPool = new GDKPool<EventParams>(1);
 
@@ -341,6 +354,10 @@ namespace Amanotes.Core
 
             internal static void InitModule()
             {
+                if (Config.analytics.enableEventStat)
+                {
+                    sessionStat = new SessionStat();
+                }
                 listAdapters.Clear();
                 listAdapters.AddRange(Adapter2.GetAllAdapter<AnalyticsAdapter>());
             }
@@ -806,6 +823,7 @@ namespace Amanotes.Core
 
                 internal void SaveIfDirty()
                 {
+                    if (!Config.analytics.autoFlushEventDetail) return;
                     if (!_dirty) return;
                     _dirty = false;
                     this.SaveJsonToFile();
@@ -1106,6 +1124,7 @@ namespace Amanotes.Core.Internal
         [HideInNormalInspector] public bool checkMigrationIntegrity = true;
         [HideInNormalInspector] public bool migrateAccumulatedCount = true;
         [HideInNormalInspector] public bool enableEventStat;
+        [HideInNormalInspector] public bool autoFlushEventDetail = true;
         [HideInInspector] public List<string> immediatelyLoggedEvents = new List<string>()
         {
             "ad_impression",

package/Runtime/AmaGDK.Device.cs

@@ -0,0 +1,105 @@
+using System;
+using System.Text;
+using Amanotes.Core.Internal;
+using UnityEngine;
+
+namespace Amanotes.Core
+{
+    public partial class AmaGDK
+    {
+        public static GDKDevice Device = new GDKDevice();
+        
+        public partial class UserProfile
+        {
+            public GDKDevice.QualitySetting QualitySetting
+            {
+                get => _qualitySetting;
+                set
+                {
+                    _qualitySetting = value;
+                    _dirty = true;
+                }
+            }
+            
+            [SerializeField]
+            private GDKDevice.QualitySetting _qualitySetting;
+        }
+    }
+}
+
+namespace Amanotes.Core.Internal
+{
+    public class GDKDevice
+    {
+        public enum DeviceSpec
+        {
+            Low,
+            Mid,
+            High
+        }
+
+        public enum QualitySetting
+        {
+            Auto,
+            Low,
+            Mid,
+            High
+        }
+
+        public DeviceSpec GetDeviceSpec()
+        {
+            DeviceSpec result;
+            switch (AmaGDK.User.QualitySetting)
+            {
+                case QualitySetting.Low: 
+                    result = DeviceSpec.Low;
+                    break;
+                case QualitySetting.Mid: 
+                    result = DeviceSpec.Mid;
+                    break;
+                case QualitySetting.High: 
+                    result = DeviceSpec.High; break;
+                case QualitySetting.Auto: 
+                default:
+                    result = GetDevicePerformanceSpec();
+                    break;
+            }
+            
+            if (AmaGDK.Config.common.logLevel == LogLevel.Verbose)
+            {
+                var stringBuilder = new StringBuilder();
+                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());   
+            }
+            return result;
+        }
+        
+        // Sentry device classify: https://github.com/getsentry/sentry/discussions/44422#discussioncomment-5149936
+        // Telegram android device classify: https://github.com/DrKLO/Telegram/blob/bab9943ee0d90f537adace746ab4ed76f422dd03/TMessagesProj/src/main/java/org/telegram/messenger/SharedConfig.java#L1372-L1453
+        // Telegram iOS device performance: https://github.com/TelegramMessenger/Telegram-iOS/blob/a568e2d878977417d1f40a9454d084e133bbc8ca/submodules/Display/Source/DeviceMetrics.swift#L9
+        private DeviceSpec GetDevicePerformanceSpec()
+        {
+            int memorySize = SystemInfo.systemMemorySize;
+            int cpuCount = SystemInfo.processorCount;
+            int cpuFrequency = SystemInfo.processorFrequency;
+            if (Application.platform == RuntimePlatform.IPhonePlayer)
+            {
+                if (cpuFrequency < 2000) return DeviceSpec.Low;
+                return cpuFrequency < 3000 ? DeviceSpec.Mid : DeviceSpec.High;
+            }
+            if (Application.platform == RuntimePlatform.Android)
+            {
+                if (cpuCount < 8 || memorySize < 4 * 1024 || cpuFrequency < 2000) return DeviceSpec.Low;
+                if (cpuFrequency < 2500 || memorySize < 6 * 1024) return DeviceSpec.Mid;
+                return DeviceSpec.High;
+            }
+            return DeviceSpec.Mid;
+        }
+    }
+}

package/Runtime/AmaGDK.Device.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: bdf9f8e2af1d4796b769c4edbf8c1d00
+timeCreated: 1719388266

package/Runtime/AmaGDK.Mono.cs

@@ -19,7 +19,6 @@ namespace Amanotes.Core
         {
             time = Time.time;
             realtimeSinceStartup = Time.realtimeSinceStartup;
-
             var cb = unityCallbacks;
             cb.Invoke(ref cb.OnFrameUpdate);
             cb.Invoke(ref cb.DoOnceNextFrame);

package/Runtime/AmaGDK.cs

@@ -17,7 +17,7 @@ namespace Amanotes.Core
 {
     public partial class AmaGDK : MonoBehaviour
     {
-        public const string VERSION = "0.2.66";
+        public const string VERSION = "0.2.68";
         
         internal static Status _status = Status.None;
         private static ConfigAsset _config = null;
@@ -104,7 +104,11 @@ namespace Amanotes.Core
                 Ads.InitModule();
                 IAP.InitModule();
                 RemoteConfig.InitModule();
-                Audio.InitModule();
+
+                if (Config.enableAudioModule)
+                {
+                    Audio.InitModule();
+                }
             }
             Profiler.EndSample();
         }

package/Runtime/AudioToolkit/AmaGDK.Audio.cs

@@ -4,6 +4,15 @@ using System.Collections;
 using System.Text;
 using Amanotes.Core.Internal;
 
+namespace Amanotes.Core.Internal
+{
+    public partial class ConfigAsset
+    {
+        [SerializeField]
+        public bool enableAudioModule;
+    }
+}
+
 namespace Amanotes.Core
 {
     public partial class AmaGDK
@@ -40,6 +49,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 +62,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);
@@ -129,6 +142,8 @@ namespace Amanotes.Core
         {
             public static bool IsConnectingBluetoothHeadset()
             {
+                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"
@@ -146,6 +161,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.Utils.cs

@@ -0,0 +1,44 @@
+using System.Collections.Generic;
+using static Amanotes.Core.Internal.Logging;
+using UnityEngine;
+namespace Amanotes.Core
+{
+    public partial class AmaFPS
+    {
+        internal class Utils
+        {
+            internal static void InjectUserData(Dictionary<string, object> dictionary, Dictionary<string, object> userData)
+            {
+                if (userData == null || userData.Count == 0) return;
+
+                foreach (var kvp in userData)
+                {
+                    if (dictionary.ContainsKey(kvp.Key))
+                    {
+                        Log("Duplicated key: " + kvp.Key);
+                        continue;
+                    }
+
+                    dictionary.Add(kvp.Key, kvp.Value);
+                }
+            }
+            internal static void InjectDeviceInfo(Dictionary<string, object> dictionary)
+            {
+                var resolution = Screen.currentResolution;
+                dictionary.Add("system_memory_size", SystemInfo.systemMemorySize);
+                dictionary.Add("graphics_memory_size", SystemInfo.graphicsMemorySize);
+                dictionary.Add("graphics_device_type", SystemInfo.graphicsDeviceType);
+                dictionary.Add("graphics_shader_level", SystemInfo.graphicsShaderLevel);
+                dictionary.Add("processor_count", SystemInfo.processorCount);
+                dictionary.Add("processor_frequency", SystemInfo.processorFrequency);
+                dictionary.Add("screen_width", resolution.width);
+                dictionary.Add("screen_height", resolution.height);
+                dictionary.Add("screen_refresh_rate", resolution.refreshRate);
+            }
+            internal static void InjectDeviceStatus(Dictionary<string, object> dictionary)
+            {
+                dictionary.Add("battery_level", Mathf.RoundToInt(SystemInfo.batteryLevel * 100));
+            }
+        }
+    }
+}