com.amanotes.gdk 0.2.65-5 → 0.2.66-1

package/CHANGELOG.md

@@ -1,5 +1,16 @@
 # Changelog
 
+## [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
+- [Fix] Reset 'isLoggedImmediately' for every new EventParams
+- [Dev] Update Audio native plugin name
+
+## [0.2.65-6 - 2024-06-20]
+- [Dev] Improve SDK Version Tracking
+- [Klavar] improve enum converter
+- [Fix] Turn off Google CMP on Editor 
+
 ## [0.2.65-5 - 2024-06-17]
 - [Dev] Update for GDKTest Unity 2022.3 project
 - [Dev] Update for GDKTest Unity 2021.3 project
@@ -12,6 +23,22 @@
 - [Dev] Degrade GDKDev project to Unity 2020
 - [Dev] Audio module supports Unity 2020
 
+## [0.2.65-4 - 2024-06-14]
+- [Dev] Audio module supports Unity 2020
+- [Dev] Degrade GDKDev project to Unity 2020
+
+## [0.2.65-3 - 2024-06-14]
+- [Dev] Simplify LocalBuild + Minor editor fixes for GDK Analytics
+- [Dev] fix PostBuild unity 2020
+- [Dev] Audio Device Detector and Bluetooth Audio Latency
+- [Dev] Update SDK configs
+
+## [0.2.65-2 - 2024-06-13]
+- [Feature] Implement analytics event correction for force kill app
+- [Feature] Upload version tracking to Airtable
+- [Fix] Unity 2020 compatible
+- [Fix] Wrong condition check for first time remote config
+
 ## [0.2.65 - 2024-06-13]
 - [Dev] Add GDKRoutine
 - [Dev] Add option to preload banners

package/Editor/Extra/GDKAutoUpdateAdapter.cs

@@ -0,0 +1,67 @@
+using Amanotes.Core.Internal;
+using System;
+using System.Collections.Generic;
+using UnityEditor;
+using UnityEngine;
+
+namespace Amanotes.Editor
+{
+    internal class GDKAutoUpdateAdapter: AssetPostprocessor
+    {
+        private static readonly Dictionary<string, string> packageMap = new Dictionary<string, string>()
+        {
+            { "AmaGDKConfigAsset", $"{Res.AMAGDK_CONFIG_PACKAGE}" },
+            
+            // Adapters
+            { "AppsFlyerAdapter", $"{Res.PACKAGE_PATH}AppsFlyerAdapter.unitypackage" },
+            { "FirebaseAnalyticsAdapter", $"{Res.PACKAGE_PATH}FirebaseAnalyticsAdapter.unitypackage" },
+            { "FirebaseRemoteConfigAdapter", $"{Res.PACKAGE_PATH}FirebaseRemoteConfigAdapter.unitypackage" },
+            { "IronSourceAdapter", $"{Res.PACKAGE_PATH}IronSourceAdapter.unitypackage" },
+            { "RevenueCatAdapter", $"{Res.PACKAGE_PATH}RevenueCatAdapter.unitypackage" },
+            { "SqliteAnalyticsAdapter", $"{Res.PACKAGE_PATH}SqliteAnalyticsAdapter.unitypackage" },
+            
+            // Extra packages
+            { "DiskSpacePopup", $"{Res.EXTRA_PATH}CheckDiskSpace.unitypackage" },
+            { "ForceUpdatePopup", $"{Res.EXTRA_PATH}ForceUpdate.unitypackage" },
+            { "GoogleCMPSupport", $"{Res.EXTRA_PATH}GoogleCMP.unitypackage" },
+            { "AndroidPostProcessor", $"{Res.EXTRA_PATH}PostProcessor.unitypackage" }
+        };
+        
+        private static void OnPostprocessAllAssets(string[] importedAssets, string[] deletedAssets, string[] movedAssets, string[] movedFromAssetPaths)
+        {
+            if (importedAssets.Length == 0) return;
+            // Debug.LogWarning($"importedAssets: {string.Join("\n", importedAssets)}");
+            
+            foreach (string path in importedAssets)
+            {
+                if (!path.EndsWith("AmaGDK.cs", StringComparison.InvariantCulture)) continue;
+                ImportAdapters();
+                break;
+            }
+        }
+        
+        [MenuItem("Window/AmaGDK/Reimport Adapters")]
+        private static void ImportAdapters()
+        {
+            var packages = new List<string>();
+            foreach (KeyValuePair<string, string> kvp in packageMap)
+            {
+                string[] assets = AssetDatabase.FindAssets($"t:monoscript {kvp.Key}");
+                if (assets.Length == 0)
+                {
+                    // Debug.LogWarning($"Not found: {kvp.Key}");
+                    continue;
+                }
+                
+                packages.Add(kvp.Value);
+            }   
+            
+            // import packages
+            for (var i = 0; i < packages.Count; i++)
+            {
+                Debug.Log($"Reimport: {packages[i]}");
+                AssetDatabase.ImportPackage(packages[i], false);
+            }
+        }
+    }
+}

package/Editor/Extra/GDKAutoUpdateAdapter.cs.meta

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

package/Editor/Extra/SDKVersionTracking.cs

@@ -2,12 +2,16 @@ using System;
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
+using System.Net.Http;
 using System.Text;
 using System.Xml;
+using Amanotes.Core.Internal;
 using UnityEditor;
 using UnityEditor.Build;
 using UnityEditor.Build.Reporting;
 using UnityEngine;
+using System.Threading.Tasks;
+using UnityEditor.Callbacks;
 
 #if UNITY_IOS
 using UnityEditor.iOS.Xcode;
@@ -227,6 +231,70 @@ namespace Amanotes.Editor
 
             WriteToStreamingAssets();
         }
+    }
+    
+    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 = _dicThirdPartyVersion
+                .Concat(_dicExtraVersion)
+                .Concat(_dicIronSourceAdapterVersion.ToDictionary(kvp => kvp.Key, kvp => (object)("IS_" + kvp.Value)))
+                .ToDictionary(x => x.Key, x => x.Value);
+            rawData["UnityVersion"] = Application.unityVersion;
+            string platform = "";
+#if UNITY_ANDROID
+            platform = "Android";
+            rawData["Permissions"] = GetAllAndroidPermissions();
+            rawData["APILevel"] = (int)PlayerSettings.Android.targetSdkVersion;
+#elif UNITY_IOS
+            rawData["SKAdNetwork"] = GetSkAdNetworkCount($"{pathToBuiltProject}/Info.plist");
+            platform = "iOS";
+#endif
+            
+            var buildInfo = new Dictionary<string, object>
+            {
+                {"GameName", Application.productName},
+                {"BuildVersion", PlayerSettings.bundleVersion},
+                {"BuildNumber", GetBuildNumber()},
+                {"BuildTime", GetBuildTime()},
+                {"AppId", PlayerSettings.applicationIdentifier },
+                {"Platform", platform},
+                {"RawData", rawData }
+            };
+            string json = JsonUtils.DictionaryToJson(buildInfo, false, false);
+            Task.Run(()=>SendDataToAirTable(json));
+        }
         
+        private static async Task SendDataToAirTable(string payload)
+        {
+            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
+                {
+                    string errorData = await response.Content.ReadAsStringAsync();
+                    Debug.LogError($"AmaGDK | [SDKVersionTracking] Status code {response.StatusCode} Error Response: {errorData}");
+                }
+            }
+            catch (HttpRequestException e)
+            {
+                Debug.LogError("AmaGDK | [SDKVersionTracking] Request Exception: " + e.Message);
+            }
+        }
     }
 }

package/Extra/LegacyGDKUpdateHelper.unitypackage.meta

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

package/Runtime/Ad/AdExtension.cs

@@ -0,0 +1,111 @@
+using Amanotes.Core.Internal;
+using System;
+namespace Amanotes.Core
+{
+    public static class AdExtension
+    {
+        /// <summary>
+        /// Invoke when ad view has opened
+        /// </summary>
+        public static IAdCallback OnAdOpened(this IAdCallback ad, Action callback)
+        {
+            if (!MakeSureAdNotNull(ad)) return null;
+            AmaGDK.Ads.context.onOpened -= callback;
+            AmaGDK.Ads.context.onOpened += callback;
+            return ad;
+        }
+        /// <summary>
+        /// The user finished watching the video, and should be rewarded.
+        /// </summary>
+        public static IAdCallback OnRewardReceived(this IAdCallback ad, Action callback)
+        {
+            if (!MakeSureAdNotNull(ad)) return null;
+            AmaGDK.Ads.context.onRewardReceived -= callback;
+            AmaGDK.Ads.context.onRewardReceived += callback;
+            return ad;
+        }
+        /// <summary>
+        /// Invoked when the video ad was clicked.
+        /// </summary>
+        public static IAdCallback OnAdClicked(this IAdCallback ad, Action callback)
+        {
+            if (!MakeSureAdNotNull(ad)) return null;
+            AmaGDK.Ads.context.onClicked -= callback;
+            AmaGDK.Ads.context.onClicked += callback;
+            return ad;
+        }
+        /// <summary>
+        /// Callback when the rewarded video ad was failed to show
+        /// </summary>
+        public static IAdCallback OnAdShowFailed(this IAdCallback ad, Action callback)
+        {
+            if (!MakeSureAdNotNull(ad)) return null;
+            AmaGDK.Ads.context.onShowFailed -= callback;
+            AmaGDK.Ads.context.onShowFailed += callback;
+            return ad;
+        }
+        /// <summary>
+        /// Invoked before OnAdOpened but is not reliable (not supported by all adNetworks)
+        /// </summary>
+        public static IAdCallback OnAdShowSuccess(this IAdCallback ad, Action callback)
+        {
+            if (!MakeSureAdNotNull(ad)) return null;
+            AmaGDK.Ads.context.onShowSuccess -= callback;
+            AmaGDK.Ads.context.onShowSuccess += callback;
+            return ad;
+        }
+        /// <summary>
+        /// Invoke when ad view is about to be closed
+        /// </summary>
+        public static IAdCallback OnAdClosed(this IAdCallback ad, Action callback)
+        {
+            if (!MakeSureAdNotNull(ad)) return null;
+            AmaGDK.Ads.context.onClosed -= callback;
+            AmaGDK.Ads.context.onClosed += callback;
+            return ad;
+        }
+        /// <summary>
+        /// This callback may invokes several times according to the AdShowReadyStatus
+        /// - When there is no ad cached (wifi disabled / no internet / wait4Ad / timeout)
+        /// - When the ad is cached & ready to show
+        /// </summary>
+        public static IAdCallback OnAdShowReadyStatus(this IAdCallback ad, Action<AdShowReadyStatus> callback)
+        {
+            if (!MakeSureAdNotNull(ad)) return null;
+            AmaGDK.Ads.context.onAdShowReadyStatus -= callback;
+            AmaGDK.Ads.context.onAdShowReadyStatus += callback;
+            return ad;
+        }
+        /// <summary>
+        /// The finalize callback that will always trigger to mark an end for the AdShowRoutine
+        /// 
+        /// </summary>
+        public static IAdCallback OnAdResult(this IAdCallback ad, Action<bool> callback)
+        {
+            if (!MakeSureAdNotNull(ad)) return null;
+            AmaGDK.Ads.context.onAdResult -= callback;
+            AmaGDK.Ads.context.onAdResult += callback;
+            return ad;
+        }
+        /// <summary>
+        /// Call right before the ad actually open (that means Ad has already been cached & available to show).
+        /// This callback will not be triggered in case Ad is not available or no internet (in those case use OnAdShowReadyStatus callback)
+        /// </summary>
+        public static IAdCallback OnBeforeAdOpen(this IAdCallback ad, Action callback)
+        {
+            if (!MakeSureAdNotNull(ad)) return null;
+            AmaGDK.Ads.context.onBeforeAdOpen -= callback;
+            AmaGDK.Ads.context.onBeforeAdOpen += callback;
+            return ad;
+        }
+        private static bool MakeSureAdNotNull(IAdCallback ad)
+        {
+            bool isValid = (ad != null);
+            if (!isValid)
+            {
+                Logging.LogWarning("Something wrong:: no AdShowContext");
+            }
+            return isValid;
+        }
+    }
+}

package/Runtime/Ad/AdExtension.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: ea59d18629b44bd29b26316c9025f27e
+timeCreated: 1719302222