com.amanotes.gdk 0.2.66-1 → 0.2.67

package/CHANGELOG.md

@@ -1,5 +1,19 @@
 # Changelog
 
+## [0.2.67 - 2024-07-04]
+- [Fix] Do retry immediately when OnAdLoadFailed trigger regardless of reason
+- Also: Update default ad request timeout to 30 secs
+- [Feature] Support FPS tracking
+- [Release] 0.2.66-1
+- [Dev] Add a flag to control flushEventDetail (save to file)
+- [Fix] Remove device spec call from constructor of AmaGDK
+- [Feature] classify device performance
+- [Dev] Update GoogleCMP events
+- + cmp_popup_show
+- + cmp_popup_finish
+- [Dev] Handle a special case when Ad close callback is not triggered
+- [Dev] Automatically reimport adapters & extra packages on update
+
 ## [0.2.66 - 2024-06-25]
 - [Dev] Verify all fields are reset in Init EventParams
 - [Dev] Add try catch to prevent coroutines to stop silently

package/Runtime/Ad/AdLogic.cs

@@ -128,8 +128,8 @@ namespace Amanotes.Core.Internal
         // Show Ad logic
         internal ShowAdsState _showState = ShowAdsState.None;
         private Coroutine _showAdRoutine;
-        private bool _isRequesting;
-        private bool _isInterstitial => adType == AdType.Interstitial;
+        protected bool _isRequesting;
+        protected bool _isInterstitial => adType == AdType.Interstitial;
         
         public void StartShowAd()
         {
@@ -521,11 +521,10 @@ namespace Amanotes.Core.Internal
             _isRequesting = false;
         }
         
-        
-        
         protected void OnAdLoadFailed(string error)
         {
             Log($"[Ad] {adType} OnAdLoadFailed: {error}");
+            _isRequesting = false;
         }
     }
 }

package/Runtime/Ad/AdModuleConfig.cs

@@ -6,7 +6,7 @@ namespace Amanotes.Core.Internal
     [Serializable] public class AdModuleConfig
     {
         [Tooltip("Automatically retry requesting ad if an ad failed to response in this amount of time (in secs)")]
-        public int adLoadTimeoutInSecs = 60;
+        public int adLoadTimeoutInSecs = 30;
         
         [Tooltip("When an ad is not ready to show, keep waiting for this amount of time (in secs)\n\nIf the ad is ready during that time, it would be shown normally.")]
         public int adShowTimeoutInSecs = 5;

package/Runtime/AmaGDK.Analytics.cs

@@ -306,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);
 
@@ -354,6 +354,10 @@ namespace Amanotes.Core
 
             internal static void InitModule()
             {
+                if (Config.analytics.enableEventStat)
+                {
+                    sessionStat = new SessionStat();
+                }
                 listAdapters.Clear();
                 listAdapters.AddRange(Adapter2.GetAllAdapter<AnalyticsAdapter>());
             }

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.67";
         
         internal static Status _status = Status.None;
         private static ConfigAsset _config = null;

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));
+            }
+        }
+    }
+}

package/Runtime/Fps/AmaFPS.Utils.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: f9be250eab01474da9eea488bef071e0
+timeCreated: 1716886847

package/Runtime/Fps/AmaFPS.cs

@@ -0,0 +1,197 @@
+using System;
+using System.Collections.Generic;
+using Amanotes.Core.Internal;
+using static Amanotes.Core.Internal.Logging;
+using UnityEngine;
+using UnityEngine.Events;
+
+namespace Amanotes.Core.Internal
+{
+    public partial class ConfigAsset
+    {
+        [SerializeField]
+        public FPSConfig fpsConfig;
+    }
+}
+
+namespace Amanotes.Core
+{
+    public partial class AmaGDK
+    {
+        public static readonly AmaFPS FPS = new AmaFPS();
+    }
+    
+    
+    [Serializable]
+    public class FPSConfig
+    {
+        [Tooltip("Enable this to always record FPS for the app session. This allows developers to get the current FPS and current average FPS at any time.")]
+        public bool enableRealtimeFPS = false;
+
+        [Tooltip("The number of frames over which FPS is calculated. The FPS will be averaged after every 'frameGroup' frames.")]
+        [Range(1, 60)] 
+        public int frameGroup = 20;
+        
+        [Header("Lagging Tolerance")]
+        [Tooltip("The size of the sliding window used to calculate the Simple Moving Average (SMA) of the FPS.")]
+        [Range(10, 100)] 
+        public int windowSize = 15;
+        
+        [Tooltip("The allowed deviation from the SMA to detect an FPS drop.")]
+        [Range(0f, 0.3f)] 
+        public float deviation = 0.1f;
+        
+        [Tooltip("Number of frames to skip after OnApplicationFocus to avoid false alarms.")]
+        [Range(0, 60)] 
+        public int skipFrameFocus = 10;
+
+        [Header("Callback")]
+        [Tooltip("This callback is invoked when an FPS drop is detected.")]
+        public UnityEvent onFrameDrop = new UnityEvent();
+    }
+
+    public partial class AmaFPS // public API
+    {
+        
+        public float CurrentFPS => _realtime?.lastFPS ?? 0;
+        public float AverageFPS => _realtime?.avgFPS ?? 0;
+        public float MinFPS => _realtime?.minFPS ?? 0;
+        public float MaxFPS => _realtime?.maxFPS ?? 0;
+        public Action<string, Dictionary<string, object>> LogEventHook;
+
+        private bool _isAppReady = false;
+        private int _playCount = 0;
+
+        public void TrackLaunchTime()
+        {
+            if (_isAppReady)
+            {
+                Log("TrackAppReady() being called multiple time!");
+                return;
+            }
+            _isAppReady = true;
+
+            var dict = new Dictionary<string, object>()
+            {
+                {"loading_time", Time.realtimeSinceStartup},
+                {"session", AmaGDK.User.Session},
+                {"device_name", SystemInfo.deviceModel},
+                {"device_os_version", SystemInfo.operatingSystem},
+
+                // Update
+                {"game_time", Time.time},
+            };
+
+            Utils.InjectDeviceInfo(dict);
+            Utils.InjectDeviceStatus(dict);
+
+            LogEvent("pm_launch_time", dict);
+        }
+        
+        public void StartRecordFPS(string context, Dictionary<string, object> userData = null)
+        {
+            _recorder ??= new FrameRecorder(_config ?? AmaGDK.Config.fpsConfig);
+            if (_recorder.isRecording)
+            {
+                LogWarning("Not yet support - Start multiple recorders at the same time! Please stop the previous session first!");
+                return;
+            }
+
+            _recorder.Start(context, userData);
+        }
+        
+        public Dictionary<string, object> StopRecordFPS(bool logEvent = true)
+        {
+            if (_recorder == null || !_recorder.isRecording)
+            {
+                LogWarning("No tracking session found!");
+                return null;
+            }
+
+            var data = _recorder.Stop();
+            if (logEvent) LogEvent("fps_measurement", data);
+            return data;
+        }
+
+        private void LogEvent(string eventName, Dictionary<string, object> parameters)
+        {
+            if (LogEventHook == null)
+            {
+                AmaGDK.Analytics.LogEvent(eventName, parameters);
+                return;
+            }
+            LogEventHook(eventName, parameters);
+        }
+    }
+
+    public partial class AmaFPS: IOnApplicationFocus, IOnApplicationPause, IOnFrameUpdate // Internal logic
+    {
+        private FrameRecorder _recorder;
+        private FrameRecorder _realtime;
+        private int _skipFrames = 0;
+        private FPSConfig _config;
+
+        internal AmaFPS()
+        {
+            AmaGDK.SetCallback_OnGDKInit(OnGDKInit);
+            AmaGDK.unityCallbacks.AddObserver(this);
+        }
+        
+        internal AmaFPS(FPSConfig config)
+        {
+            // Constructor for unit test
+            _config = config;
+            _realtime = new FrameRecorder(config);
+        }
+
+        private void OnGDKInit()
+        {
+            _config = AmaGDK.Config.fpsConfig;
+            _realtime ??= new FrameRecorder(_config);
+            
+            _realtime.bands.onFPSDrop -= OnFrameDrop;
+            _realtime.bands.onFPSDrop += OnFrameDrop;
+        }
+
+        private void OnFrameDrop()
+        {
+            if (_config.onFrameDrop.GetPersistentEventCount() > 0)
+            {
+                _config.onFrameDrop.Invoke();
+            }
+        }
+
+        public void OnFrameUpdate()
+        {
+            UpdateFrame(Time.unscaledDeltaTime);
+        }
+
+        internal void UpdateFrame(float unscaledDeltaTime)
+        {
+            if (unscaledDeltaTime <= 1 / 1200f) unscaledDeltaTime = 1 / 1200f; // prevent the case when unscaledDeltaTime == 0
+
+            if (_skipFrames > 0)
+            {
+                _skipFrames--;
+                return;
+            }
+            
+            if (_realtime != null && _config.enableRealtimeFPS) _realtime.UpdateFrame(unscaledDeltaTime);
+            
+            if (_recorder != null && _recorder.isRecording)
+            {
+                _recorder.UpdateFrame(unscaledDeltaTime);
+            }
+        }
+
+        public void OnApplicationFocus(bool hasFocus)
+        {
+            _skipFrames = _config?.skipFrameFocus ?? 0;
+        }
+
+        public void OnApplicationPause(bool pauseStatus)
+        {
+            _skipFrames = _config?.skipFrameFocus ?? 0;
+        }
+    }
+}

package/Runtime/Fps/AmaFPS.cs.meta

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

package/Runtime/Fps/AmaFPSVisualizer.cs

@@ -0,0 +1,246 @@
+using System;
+using System.Collections.Generic;
+using UnityEngine;
+using UnityEngine.Profiling;
+using UnityEngine.UI;
+using static Amanotes.Core.Internal.Logging;
+
+namespace Amanotes.Core
+{
+
+    [RequireComponent(typeof(RectTransform))]
+    [RequireComponent(typeof(CanvasRenderer))]
+    public class AmaFPSVisualizer : Graphic
+    {
+        [Serializable]
+        private class FlashOnDrop
+        {
+            public bool enabled = true;
+            public Color flashColor = new Color(1, 0, 0, 0.5f);
+            [Range(1f, 10f)] public float flashingSpeed = 10f;
+
+            public Image flashImage;
+            private float _alpha = 0;
+
+            public void OnFrameDrop()
+            {
+                _alpha = flashColor.a;
+                flashImage.color = flashColor;
+            }
+            
+            public void Update()
+            {
+                float dAlpha = flashingSpeed * Time.deltaTime;
+                _alpha = Mathf.Max(0, _alpha - dAlpha);
+
+                Color c = flashColor;
+                c.a = _alpha;
+                flashImage.color = c;
+            }
+        }
+
+        [Serializable]
+        private class FPSTextUpdate
+        {
+            private static readonly Dictionary<int, string> intMap = new Dictionary<int, string>();
+            private static string GetString(float value)
+            {
+                Profiler.BeginSample("FPSTextUpdate.GetString");
+                int intValue = Mathf.RoundToInt(value * 10);
+                if (intMap.TryGetValue(intValue, out string result))
+                {
+                    Profiler.EndSample();
+                    return result;
+                }
+                
+                result = $"{(intValue/10f):F1}";
+                intMap.Add(intValue, result);
+                Profiler.EndSample();
+                return result;
+            }
+            
+            public bool enabled = true;
+            public GameObject parent = null;
+
+            public Text currentFPS;
+            private int frame;
+            
+            public void Update(float fps)
+            {
+                if (frame-- > 0) return;
+                currentFPS.text = GetString(fps);
+                frame = 60;
+            }
+        }
+
+        struct FPSVertex
+        {
+            public float fps;
+            public int colorIndex;
+            public Vector3 position;
+        }
+
+        [Serializable]
+        private class FPSGraph : FrameRecorder
+        {
+            const int RESOLUTION = 64;
+            public bool enabled = true;
+            public Graphic graphic = null;
+
+            public int minFPS = 15;
+            public int maxFPS = 60;
+            public int goodFPS = 55;
+            public int acceptableFPS = 45;
+            public int badFPS = 30;
+
+            public Color[] colors = new Color[]{
+                Color.red, // min -> bad
+                new Color(1f, 0.65f, 0f), // bad -> ok
+                Color.yellow, // ok --> good
+                Color.green, // very good
+            };
+
+            private readonly float[] fpsHistory = new float[RESOLUTION];
+            private int vCount = 0;
+
+            public void Clear()
+            {
+                vCount = 0;
+            }
+
+            protected override void UpdateGroupFrame(){
+                var hIndex = vCount % RESOLUTION;
+                fpsHistory[hIndex] = lastFPS;
+                vCount++;
+            }
+
+            public void PopulateMesh(VertexHelper vh)
+            {
+                var rect = ((RectTransform)graphic.transform).rect;
+                var barW = rect.width / (RESOLUTION-1);
+                var barH = rect.height;
+
+                var barX = vCount < RESOLUTION ? (RESOLUTION - vCount) * barW : 0;
+                var stIndex = vCount <= RESOLUTION ? 0 : (vCount % RESOLUTION);
+                var nVertex = vCount <= RESOLUTION ? vCount : RESOLUTION;
+
+                for (var i = 0; i < nVertex; i++)
+                {
+                    var idx = (i + stIndex) % RESOLUTION;
+                    var fps = fpsHistory[idx];
+                    var h = fps <= minFPS ? 0 :
+                                fps >= maxFPS ? 1 : (fps - minFPS) / (maxFPS - minFPS);
+
+                    var v0 = new Vector3(barX, 0, 0);
+                    var v1 = new Vector3(barX, h * barH, 0);
+                    var c1 = colors[
+                                fps <= badFPS ? 0 :
+                                fps <= acceptableFPS ? 1 :
+                                fps <= goodFPS ? 2 : 3
+                            ];
+                    var c0 = c1;
+                    c0.a = 0;
+
+                    // Add 2 vertices
+                    vh.AddVert(v0, c0, Vector2.zero);
+                    vh.AddVert(v1, c1, Vector2.zero);
+
+                    if (i > 0)
+                    {
+                        var vIndex = vh.currentVertCount - 2;
+                        vh.AddTriangle(vIndex - 2, vIndex - 1, vIndex + 1);
+                        vh.AddTriangle(vIndex - 2, vIndex + 1, vIndex);
+                    }
+
+                    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);
+            }
+
+            void AddHorzLine(VertexHelper vh, float w, float h, Color color, float thickness = 1f)
+            {
+                var v0 = new Vector3(0, h, 0);
+                var v1 = new Vector3(w, h, 0);
+                var v2 = new Vector3(w, h+thickness, 0);
+                var v3 = new Vector3(0, h+thickness, 0);
+                
+                var vIndex = vh.currentVertCount;
+                
+                vh.AddVert(v0, color, new Vector2(0, 0));
+                vh.AddVert(v1, color, new Vector2(0, 0));
+                vh.AddVert(v2, color, new Vector2(0, 0));
+                vh.AddVert(v3, color, new Vector2(0, 0));
+
+                vh.AddTriangle(vIndex, vIndex+1, vIndex+2);
+                vh.AddTriangle(vIndex+2, vIndex+3, vIndex);
+            }
+
+            public FPSGraph(FPSConfig config) : base(config)
+            {
+            }
+        }
+
+        [SerializeField] private FlashOnDrop flashOnDropFrame = new FlashOnDrop();
+        [SerializeField] private FPSTextUpdate textUpdate = new FPSTextUpdate();
+        
+        private FPSGraph graph;
+        
+        protected override void Awake()
+        {
+            flashOnDropFrame.flashImage.enabled = flashOnDropFrame.enabled;
+            textUpdate.parent.SetActive(textUpdate.enabled);
+            
+            graph = new FPSGraph(AmaGDK.Config.fpsConfig)
+            {
+                graphic = GetComponent<Graphic>()
+            };
+            
+            Application.targetFrameRate = Screen.currentResolution.refreshRate;
+            Log($"Target FrameRate: {Application.targetFrameRate}");
+        }
+
+        protected override void Start()
+        {
+            var rect = Screen.safeArea;
+            var trans = transform as RectTransform;
+            var transRect = trans.rect;
+            trans.anchoredPosition = new Vector2(rect.x / rect.width * transRect.width, -rect.y / rect.height * transRect.height);
+        }
+
+        public void OnFrameDrop()
+        {
+            flashOnDropFrame.OnFrameDrop();
+        }
+
+        private void Update()
+        {
+            if (!Application.isPlaying) return;
+            Profiler.BeginSample("AmaFPSVisualiser.Update()");
+            {
+                if (flashOnDropFrame.enabled) flashOnDropFrame.Update();
+                if (textUpdate.enabled) textUpdate.Update(1f/Time.unscaledDeltaTime);
+                if (graph != null && graph.enabled)
+                {
+                    graph.UpdateFrame(Time.unscaledDeltaTime);
+                    Profiler.BeginSample("SetVerticesDirty()");
+                    {
+                        SetVerticesDirty();
+                    }
+                    Profiler.EndSample();
+                }    
+            }
+            Profiler.EndSample();
+        }
+
+        protected override void OnPopulateMesh(VertexHelper vh)
+        {
+            vh.Clear();
+
+            if (graph == null || !graph.enabled) return;
+            graph.PopulateMesh(vh);
+        }
+    }
+}

package/Runtime/Fps/AmaFPSVisualizer.cs.meta

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