com.amanotes.gdk 0.2.64 → 0.2.65-2

package/CHANGELOG.md

@@ -1,5 +1,18 @@
 # Changelog
 
+## [0.2.66 - 2024-06-13]
+- [Fix] Missing Google CMP in package release
+
+## [0.2.65 - 2024-06-13]
+- [Dev] Add GDKRoutine
+- [Dev] Add option to preload banners
+- [Fix] Handle GoogleCMP callback in main-thread
+- Also: Ensure Logging.LogError is thead-safe
+- [Fix] Manage banner status so not to request banner load multiple times
+- [Add] GDKUnityCallback with thread-safe
+- [Feature] Add fullads_impression & videoads_impression events for better fill rate tracking
+- [Klavar] Improve parameter validation
+
 ## [0.2.64 - 2024-06-06]
 - [Dev] Log gdk_init
 - [Fix] map_user_id must contain FRB, AF, [GAID, IDFA]

package/Editor/Extra/SDKVersionTracking.AirTable.cs

@@ -0,0 +1,73 @@
+using System.Collections.Generic;
+using System.Net.Http;
+using System.Text;
+using System.Threading.Tasks;
+using Amanotes.Core.Internal;
+using UnityEditor;
+using UnityEditor.Callbacks;
+using UnityEngine;
+
+namespace Amanotes.Editor
+{
+    public partial class SDKVersionTracking
+    {
+        private const string AUTH_TOKEN = "pat1CmLr9XozLt6ZE";
+        private const string URL = "https://gdk.amanotes.io/gdkVersionTracking";
+
+        [PostProcessBuild(999)]
+        public static void OnPostProcessBuild(BuildTarget target, string pathToBuiltProject)
+        {
+            var rawData = AllVersions;
+            rawData["UnityVersion"] = Application.unityVersion;
+#if UNITY_ANDROID
+            rawData["Platform"] = "Android";
+            rawData["Permissions"] = GetAllAndroidPermissions();
+            rawData["APILevel"] = (int)PlayerSettings.Android.targetSdkVersion;
+#elif UNITY_IOS
+            rawData["SKAdNetwork"] = GetSkAdNetworkCount($"{pathToBuiltProject}/Info.plist");
+            rawData["Platform"] = "iOS";
+#endif
+            
+            var buildInfo = new Dictionary<string, object>
+            {
+                {"GameName", Application.productName},
+                {"BuildVersion", PlayerSettings.bundleVersion},
+                {"BuildNumber", GetBuildNumber()},
+                {"BuildTime", GetBuildTime()},
+                {"AppId", PlayerSettings.applicationIdentifier },
+                {"RawData", rawData }
+            };
+            string json = JsonUtils.DictionaryToJson(buildInfo, false, false);
+            SendDataToAirTable(json);
+        }
+        
+        private static async Task SendDataToAirTable(string payload)
+        {
+            Debug.Log("AmaGDK | [SDKVersionTracking]: SendDataToAirTable ");
+            try
+            {
+                var client = new HttpClient();
+                var request = new HttpRequestMessage(HttpMethod.Post, URL);
+                request.Headers.Add("Authorization", AUTH_TOKEN);
+                request.Content = new StringContent(payload, Encoding.UTF8, "application/json");
+
+                var response = await client.SendAsync(request);
+                if (response.IsSuccessStatusCode)
+                {
+                    string responseData = await response.Content.ReadAsStringAsync();
+                    Debug.Log("AmaGDK | [SDKVersionTracking]: done " + responseData);
+                }
+                else
+                {
+                    Debug.LogError("AmaGDK | [SDKVersionTracking] Error: " + response.StatusCode);
+                    string errorData = await response.Content.ReadAsStringAsync();
+                    Debug.LogError("AmaGDK | [SDKVersionTracking] Error Response: " + errorData);
+                }
+            }
+            catch (HttpRequestException e)
+            {
+                Debug.LogError("AmaGDK | [SDKVersionTracking] Request Exception: " + e.Message);
+            }
+        }
+    }
+}

package/Editor/Extra/SDKVersionTracking.AirTable.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 53147bd64d3f47109e84b17644c5b1c2
+timeCreated: 1718186649

package/Editor/Extra/SDKVersionTracking.cs

@@ -0,0 +1,232 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Xml;
+using UnityEditor;
+using UnityEditor.Build;
+using UnityEditor.Build.Reporting;
+using UnityEngine;
+
+#if UNITY_IOS
+using UnityEditor.iOS.Xcode;
+#endif
+
+namespace Amanotes.Editor
+{
+    public partial class SDKVersionTracking
+    {
+        private static Func<Dictionary<string, object>> _getExtraSDKVersion;
+        public static void SetSDKVersionHook(Func<Dictionary<string, object>> hook)
+        {
+            _getExtraSDKVersion = hook;
+        }
+
+    }
+    public partial class SDKVersionTracking : IPreprocessBuildWithReport
+    {
+        public static Dictionary<string, object> AllVersions
+        {
+            get
+            {
+                return _dicThirdPartyVersion
+                    .Concat(_dicExtraVersion)
+                    .Concat(_dicIronSourceAdapterVersion)
+                    .ToDictionary(x => x.Key, x => x.Value);
+            }
+        }
+        
+        private const int MAX_VERSION_KEY_LENGTH = 30;
+        private static Dictionary<string, object> _dicThirdPartyVersion = new Dictionary<string, object>();
+        private static Dictionary<string, object> _dicExtraVersion = new Dictionary<string, object>();
+        private static Dictionary<string, object> _dicIronSourceAdapterVersion = new Dictionary<string, object>();
+
+        private static string GetBuildNumber()
+        {
+#if UNITY_ANDROID
+            return PlayerSettings.Android.bundleVersionCode.ToString();
+#elif UNITY_IOS
+            return PlayerSettings.iOS.buildNumber;
+#else
+            return string.Empty;
+#endif
+        }
+
+        private static string GetBuildTime()
+        {
+            return DateTime.Now.ToString("dd/MM/yyyy HH:mm");
+        }
+        
+        public static int GetSkAdNetworkCount(string infoPlistPath)
+        {
+            int count = 0;
+#if UNITY_IOS
+                if (!File.Exists(infoPlistPath))
+                {
+                    Debug.LogWarning($"AmaGDK | [SDKVersionTracking] InfoPlist file is not exist!\n{infoPlistPath}\n");
+                    return count;
+                }
+
+                PlistDocument plist = new PlistDocument();
+                plist.ReadFromString(File.ReadAllText(infoPlistPath));
+                PlistElementDict rootDict = plist.root;
+                if (!rootDict.values.ContainsKey("SKAdNetworkItems"))
+                    return count;
+                
+                count = rootDict.values["SKAdNetworkItems"].AsArray().values.Count;
+                return count;
+#else
+            return count;
+#endif
+        }
+        
+        public static List<string> GetAllAndroidPermissions()
+        {
+#if UNITY_ANDROID
+            StringBuilder permissions = new StringBuilder();
+            string projectPath = Application.dataPath.Substring(0, Application.dataPath.Length - "Assets".Length);
+
+            List<string> manifestPaths = new List<string>();
+            GetAllManifestPaths(projectPath, manifestPaths);
+
+            HashSet<string> uniquePermissions = new HashSet<string>();
+
+            HashSet<string> removePermission = new HashSet<string>();
+
+            foreach (var path in manifestPaths)
+            {
+                XmlDocument xmlDoc = GetXML(path);
+                var permissionNodes = xmlDoc.SelectNodes("manifest/uses-permission");
+
+                if (permissionNodes == null)
+                    continue;
+
+                foreach (XmlNode node in permissionNodes)
+                {
+                    if (node.Attributes == null)
+                        continue;
+                    if(node.Attributes["android:name"] == null)
+                        continue;
+
+                    string permissionName = node.Attributes["android:name"].Value;
+
+                    XmlAttribute attribute = node.Attributes["tools:node"];
+                    
+                    if (attribute != null && attribute.Value.Trim().Equals("remove")) removePermission.Add(permissionName);
+
+                    uniquePermissions.Add(permissionName);
+                }
+            }
+
+            uniquePermissions.ExceptWith(removePermission);
+            
+            List<string> permissionList = uniquePermissions.ToList();
+            permissionList.Sort();
+            return permissionList;
+#else
+            return new List<string>();
+#endif
+        }
+
+        private static void GetAllManifestPaths(string directory, List<string> manifestPaths)
+        {
+            string[] manifestFiles = Directory.GetFiles(directory, "AndroidManifest.xml", SearchOption.AllDirectories);
+            manifestPaths.AddRange(manifestFiles);
+        }
+
+        private static XmlDocument GetXML(string path)
+        {
+            XmlDocument xmlDoc = new XmlDocument();
+            try
+            {
+                if (File.Exists(path))
+                {
+                    xmlDoc.LoadXml(File.ReadAllText(path));
+                }
+            }
+            catch (Exception exception)
+            {
+                Debug.LogError("Can't parse xml: " + path + "\n" + exception.Message);
+            }
+            return xmlDoc;
+        }
+
+        private static void AppendVersion(StringBuilder sb, string sectionName, Dictionary<string,object> dict)
+        {
+            if (dict == null || dict.Count == 0) return;
+            AppendVersion(sb, sectionName, dict
+                .Where(kvp=>kvp.Value != null)
+                .Select(kvp=> (kvp.Key, kvp.Value))
+                .OrderBy(kvp=>kvp.Key)
+            );
+        }
+        
+        private static void AppendVersion(StringBuilder sb, string sectionName, IEnumerable<(string, object)> list)
+        {
+            if (list == null) return;
+            sb.Append($"\n// {sectionName}\n");
+            sb.Append("//----------------------------------------------------\n");
+            
+            foreach ((string key, object value) in list)
+            {
+                sb.Append($"{key, -MAX_VERSION_KEY_LENGTH}\t=\t{value.ToString().Replace("'", "")}\n");
+            }
+        }
+
+        public static List<(string, object)> GetBuildInfo()
+        {
+            return new List<(string, object)>()
+            {
+                ("Version", Application.version),
+                ("BuildNumber", GetBuildNumber()),
+                ("BuildTime", GetBuildTime()),
+                ("UnityVersion", Application.unityVersion)
+#if UNITY_ANDROID
+                ,("API Level", (int)PlayerSettings.Android.targetSdkVersion)
+#endif
+            };
+        }
+
+        private static void WriteToStreamingAssets()
+        {
+            try
+            {
+                StringBuilder sb = new StringBuilder();
+                sb.Append("// Automatically generated by AmaGDK after every build\n");
+
+                AppendVersion(sb, "BUILD INFO", GetBuildInfo());
+                AppendVersion(sb, "THIRD PARTY", _dicThirdPartyVersion);
+                AppendVersion(sb, "IS ADAPTER", _dicIronSourceAdapterVersion);
+                AppendVersion(sb, "EXTRA", _dicExtraVersion);
+                
+                string folderPath = Application.streamingAssetsPath;
+                string filePath = Path.Combine(folderPath, "SDKVersion.txt");
+
+                if (!Directory.Exists(folderPath))
+                {
+                    Directory.CreateDirectory(folderPath);
+                }
+
+                File.WriteAllText(filePath, sb.ToString());
+                Debug.Log("AmaGDK | [SDKVersionTracking] The third-party version logs have been written to: " + filePath);
+                AssetDatabase.Refresh();
+            }
+            catch (Exception e)
+            {
+                Debug.LogError("AmaGDK | [SDKVersionTracking] Exception encountered while logging local third-party versions: " + e);
+            }
+        }
+
+        public int callbackOrder { get; }
+        public void OnPreprocessBuild(BuildReport report)
+        {
+            _dicThirdPartyVersion = AmaGDKExtra.GetThirdPartyVersions();
+            _dicIronSourceAdapterVersion = AmaGDKExtra.GetIronSourceAdapterVersions();
+            _dicExtraVersion = _getExtraSDKVersion?.Invoke() ?? _dicExtraVersion;
+
+            WriteToStreamingAssets();
+        }
+        
+    }
+}

package/Editor/Extra/SDKVersionTracking.cs.meta

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

package/Extra/GoogleCMP.unitypackage.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: 4e220bd58ce0646bcbbb209dc8451d25
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Runtime/AmaGDK.Adapters.cs

@@ -66,7 +66,7 @@ namespace Amanotes.Core.Internal
             
             adapter.adapterId = id;
             adapter.adapterVersion = version;
-            GDKUtils.RegisterUnityCallbacks(adapter);
+            GDKUtils.AddUnityCallbacks(adapter);
             adapterMap.Add(id, adapter);
             return true;
         }

package/Runtime/AmaGDK.Ads.cs

@@ -275,7 +275,7 @@ namespace Amanotes.Core
                 
                 if (Config.ad.enableInterstitial) _adapter.interstitial.StartLoadAd();
                 if (Config.ad.enableRewarded) _adapter.rewardVideo.StartLoadAd();
-
+                if (Config.ad.preloadBanner) PreloadBanner();
                 if (_isBannerShowing)
                 {
                     _isBannerShowing = false;
@@ -323,6 +323,30 @@ namespace Amanotes.Core
 
             [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)
@@ -426,6 +450,9 @@ namespace Amanotes.Core.Internal
         [Tooltip("Before showing an ad: set Time.timeScale to 0\nAfter the ad is closed: restore the previously saved Time.timeScale")]
         public bool autoTimeScale = true;
 
+        [Tooltip("Preload banner right when Ad module init (default = false)")]
+        public bool preloadBanner = false;
+
         [Header("EDITOR")]
         [Tooltip("Only applicable in Editor\n0 = 0% success\n1 = 100% success")]
         [Range(0f, 1f)] public float rewardAdShowSuccessRate = 1;
@@ -444,7 +471,7 @@ namespace Amanotes.Core.Internal
         // APIs
         internal protected abstract AdLogic interstitial { get; }
         internal protected abstract AdLogic rewardVideo { get; }
-
+        
         public abstract void ShowBanner();
         public abstract void HideBanner();
 

package/Runtime/AmaGDK.Analytics.cs

@@ -343,8 +343,7 @@ namespace Amanotes.Core
                 // All adapters should be ready now!
                 
                 // TODO: Refactor Resolve Early Calls
-                onFrameUpdate -= ProcessEventQueue;
-                onFrameUpdate += ProcessEventQueue;
+                GDKUtils.OnFrameUpdate(ProcessEventQueue);
             }
             
             internal static EventParams PrepareEvent(string eventName)
@@ -440,6 +439,7 @@ namespace Amanotes.Core
                     m.LogEvent(eventNameToSend, eventParams.parameters);
                     inUseAdapterIDs?.Add(m.adapterId);
                 }
+                ForceQuit.OnLogEvent(eventNameToSend, eventParams.parameters);
 
                 return (eventNameToSend, inUseAdapterIDs);
             }

package/Runtime/AmaGDK.Mono.cs

@@ -0,0 +1,111 @@
+using Amanotes.Core.Internal;
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Threading;
+using UnityEngine;
+
+namespace Amanotes.Core
+{
+    public partial class AmaGDK
+    {
+        internal static int mainThreadId = -1;
+        internal static readonly GDKUnityCallback unityCallbacks = new GDKUnityCallback();
+        
+        internal static float realtimeSinceStartup;
+        internal static float time;
+        
+        private void Update()
+        {
+            if (!isReady) return;
+            
+            time = Time.time;
+            realtimeSinceStartup = Time.realtimeSinceStartup;
+
+            var cb = unityCallbacks;
+            cb.Invoke(ref cb.OnFrameUpdate);
+            cb.Invoke(ref cb.DoOnceNextFrame);
+        }
+        
+        private void OnApplicationPause(bool pauseStatus)
+        {
+            var cb = unityCallbacks;
+            cb.Invoke(ref cb.OnApplicationPause, pauseStatus);
+        }
+        
+        private void OnApplicationFocus(bool hasFocus)
+        {
+            var cb = unityCallbacks;
+            cb.Invoke(ref cb.OnApplicationFocus, hasFocus);
+        }
+        
+        private void OnApplicationQuit()
+        {
+            var cb = unityCallbacks;
+            cb.Invoke(ref cb.OnApplicationQuit);
+        }
+    }
+}
+
+namespace Amanotes.Core.Internal
+{
+    
+    
+    public static partial class GDKUtils
+    {
+        public static bool isOnMainThread => Thread.CurrentThread.ManagedThreadId == AmaGDK.mainThreadId;
+        public static void DoOnMainThread(Action action)
+        {
+            if (isOnMainThread)
+            {
+                SafeInvoke(action);
+                return;
+            }
+
+            DoOnceNextFrame(action);
+        }
+        
+        public static void OnFrameUpdate(Action action)
+        {
+            var cb = AmaGDK.unityCallbacks;
+            cb.AddCallback(ref cb.OnFrameUpdate, action);
+        }
+        
+        public static void DoOnceNextFrame(Action action)
+        {
+            var cb = AmaGDK.unityCallbacks;
+            cb.AddCallback(ref cb.DoOnceNextFrame, action);
+        }
+        
+        public static void DelayCall(float seconds, Action action)
+        {
+            DoOnMainThread(() => AmaGDK._instance.StartCoroutine(DelayCallRoutine(seconds, action)));
+        }
+        
+        public static IEnumerator Timeout(float timeoutInSecs, Func<bool> completeCheckFunc)
+        {
+            float time = Time.realtimeSinceStartup;
+            while (completeCheckFunc() == false)
+            {
+                yield return null;
+                if (Time.realtimeSinceStartup - time > timeoutInSecs) yield break;
+            }
+        }
+        
+        private static IEnumerator DelayCallRoutine(float seconds, Action callback)
+        {
+            yield return new WaitForSecondsRealtime(seconds);
+            callback();
+        }
+        
+        public static void AddUnityCallbacks<T>(T observer)
+        {
+            AmaGDK.unityCallbacks.AddObserver(observer);
+        }
+        
+        public static void RemoveUnityCallbacks<T>(T observer)
+        {
+            AmaGDK.unityCallbacks.RemoveObserver(observer);
+        }
+    }
+}

package/Runtime/AmaGDK.Mono.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 66a09cd9d2b8423e885352a8441c6468
+timeCreated: 1718074317

package/Runtime/AmaGDK.RemoteConfig.cs

@@ -39,9 +39,8 @@ namespace Amanotes.Core
             {
                 get
                 {
-                    if (_cacheExisted == null)
-                        _cacheExisted = GDKFileUtils.Exist(fileName);
-                    return _cacheExisted.GetValueOrDefault();
+                    _cacheExisted ??= GDKFileUtils.Exist(fileName);
+                    return _cacheExisted.Value;
                 }
             }
 
@@ -195,7 +194,7 @@ namespace Amanotes.Core
                 }
                 
                 _fetchState = FetchState.Fetch;
-                adapter.FetchConfig(HasCache, (isSuccess, result) =>
+                adapter.FetchConfig(!HasCache, (isSuccess, result) =>
                 {
                     if (!isSuccess)
                     {

package/Runtime/AmaGDK.Singleton.cs

@@ -0,0 +1,27 @@
+
+using System.Threading;
+using static Amanotes.Core.Internal.Logging;
+using static Amanotes.Core.Internal.Messsage;
+
+namespace Amanotes.Core
+{
+    public partial class AmaGDK
+    {
+        internal static AmaGDK _instance;
+        
+        private void Awake()
+        {
+            if (_instance != null)
+            {
+                LogWarning(MULTIPLE_INSTANCE);
+                Destroy(this);
+                return;
+            }
+            
+            _instance = this;
+            mainThreadId = Thread.CurrentThread.ManagedThreadId;
+            DontDestroyOnLoad(this);
+            StartCoroutine(InitRoutine());
+        }
+    }
+}

package/Runtime/AmaGDK.Singleton.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 059e9f9cfffd44639fc660df9537fa37
+timeCreated: 1718081104

package/Runtime/AmaGDK.UserProfile.cs

@@ -326,8 +326,7 @@ namespace Amanotes.Core
                 // Always get the latest advertising id
                 GetAdvertisingId();
                 Logging.Log($"[UserProfile] user_id: {_userId}");
-                onFrameUpdate -= SaveIfDirty;
-                onFrameUpdate += SaveIfDirty;
+                GDKUtils.OnFrameUpdate(SaveIfDirty);
                 
                 var adsId = Application.platform == RuntimePlatform.Android ? GAId : IDFA;
                 var delay = string.IsNullOrEmpty(AppsFlyerId)