com.amanotes.gdk 0.2.65-1 → 0.2.65-2

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/Runtime/AmaGDK.Analytics.cs

@@ -439,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.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.cs

@@ -17,14 +17,16 @@ namespace Amanotes.Core
 {
     public partial class AmaGDK : MonoBehaviour
     {
-        public const string VERSION = "0.2.66";
+        public const string VERSION = "0.2.65-2";
         
         internal static Status _status = Status.None;
         private static ConfigAsset _config = null;
         internal static readonly GDKGeoLocation GeoLocation = new GDKGeoLocation();
         internal static readonly GDKServerTime ServerTime = new GDKServerTime();
+        private static readonly ForceQuitMonitor ForceQuit = new ForceQuitMonitor();
         
         internal static bool _allowInit = false;
+        
         public bool autoInit = true;
         
         internal static partial class Event
@@ -186,6 +188,8 @@ namespace Amanotes.Core
                 ServerTime.UpdateTime();
             }
             
+            ForceQuit.Init();
+            
             _status = Status.Ready;
             dispatcher.Dispatch(Event.GDK_READY);
 

package/Runtime/Internal/AmaGDK.Internal.cs

@@ -107,7 +107,7 @@ namespace Amanotes.Core.Internal
         private static bool presetEnableEventStat;
         private static LogLevel presetLogLevel = LogLevel.Warning;
         
-        public static void PresetConfig()
+        public static void LoadPresetConfig()
         {
             presetLogLevel = Config.common.logLevel;
             Config.common.logLevel = LogLevel.Warning;

package/Runtime/Internal/AmaGDK.Utils.cs

@@ -3,6 +3,7 @@ using System.Collections;
 using System.Collections.Concurrent;
 using System.Collections.Generic;
 using System.IO;
+using System.Linq;
 using System.Reflection;
 using System.Text;
 using System.Text.RegularExpressions;
@@ -398,11 +399,7 @@ namespace Amanotes.Core.Internal
     {
         public static string TupleToJson(params (string key, object value)[] parameters)
         {
-            var tupleToDict = new Dictionary<string, object>();
-            foreach (var item in parameters)
-            {
-                tupleToDict.Add(item.key, item.value);
-            }
+            var tupleToDict = parameters.ToDictionary(item => item.key, item => item.value);
             return DictionaryToJson(tupleToDict);
         }
 
@@ -419,13 +416,13 @@ namespace Amanotes.Core.Internal
             Profiler.BeginSample("AmaGDK.JsonUtils.DictionaryToJson()");
             var jsonSb = new StringBuilder();
             jsonSb.Append("{");
-            var isFirstElement = true;
+            bool isFirstElement = true;
 
             foreach (DictionaryEntry entry in inputDict)
             {
                 if (entry.Key == null || string.IsNullOrEmpty(entry.Key.ToString())) continue;
-                var key = entry.Key.ToString();
-                var value = entry.Value;
+                string key = entry.Key.ToString();
+                object value = entry.Value;
 
                 if (isFirstElement)
                     isFirstElement = false;
@@ -437,7 +434,7 @@ namespace Amanotes.Core.Internal
             }
 
             jsonSb.AppendFormat("{0}{1}", format ? "\n" : "", "}");
-            var result = jsonSb.ToString();
+            string result = jsonSb.ToString();
             Profiler.EndSample();
             
             return result;
@@ -446,7 +443,7 @@ namespace Amanotes.Core.Internal
         private static void GetJsonIListValue(ref StringBuilder jsonSb, string key, IList list, bool format)
         {
             jsonSb.Append("[");
-            var isFirstElement = true;
+            bool isFirstElement = true;
 
             foreach (object item in list)
             {
@@ -473,7 +470,7 @@ namespace Amanotes.Core.Internal
 
             if (value is string)
             {
-                var s = value.ToString();
+                string s = value.ToString();
                 if (checkJsonInString)
                 {
                     if (s.StartsWith("{") && s.EndsWith("}"))
@@ -497,34 +494,77 @@ namespace Amanotes.Core.Internal
                 return;
             }
 
-            if (value is bool)
+            if (value is bool b)
             {
-                jsonSb.Append((bool)value ? "true" : "false");
+                jsonSb.Append(b ? "true" : "false");
                 return;
             }
 
-            if (value is IDictionary)
+            if (value is IDictionary dictionary)
             {
-                jsonSb.Append($"{DictionaryToJson((IDictionary)value, format)}");
+                jsonSb.Append($"{DictionaryToJson(dictionary, format)}");
                 return;
             }
 
-            if (value is IList || value is Array)
+            if (value is IList list)
             {
-                GetJsonIListValue(ref jsonSb, key, (IList)value, format);
+                GetJsonIListValue(ref jsonSb, key, list, format);
                 return;
             }
 
             jsonSb.Append($"{JsonUtility.ToJson(value, format)}");
         }
 
-        private static string EscapeJsonString(string input)
+        /// <summary>
+        /// Escapes a string for inclusion in a JSON document according to RFC 8259.
+        /// For more details, see <a href="https://www.rfc-editor.org/rfc/rfc8259.txt">RFC 8259</a>.
+        /// </summary>
+        /// <param name="input">The input string to be escaped.</param>
+        /// <returns>The escaped string.</returns>
+        public static string EscapeJsonString(string input)
         {
-            //Match any occurrence of a backslash(\) and double quotation (")
-            string pattern = "[\\\"]";
-            return Regex.Replace(input, pattern, match => $"\\{match.Value}");
+            var sb = new StringBuilder();
+            foreach (char c in input)
+            {
+                switch (c)
+                {
+                    case '\"': sb.Append("\\\""); break;
+                    case '\\': sb.Append("\\\\"); break;
+                    case '\b': sb.Append("\\b"); break;
+                    case '\f': sb.Append("\\f"); break;
+                    case '\n': sb.Append("\\n"); break;
+                    case '\r': sb.Append("\\r"); break;
+                    case '\t': sb.Append("\\t"); break;
+                    default:
+                        if (c < 0x20)
+                        {
+                            // Encode as \uXXXX for control characters
+                            sb.Append("\\u" + ((int)c).ToString("X4"));
+                        }
+                        else if (char.IsSurrogate(c))
+                        {
+                            // Handle surrogate pairs
+                            if (char.IsHighSurrogate(c))
+                            {
+                                sb.Append("\\u" + ((int)c).ToString("X4"));
+                            }
+                            else if (char.IsLowSurrogate(c))
+                            {
+                                sb.Append("\\u" + ((int)c).ToString("X4"));
+                            }
+                        }
+                        else
+                        {
+                            // Keep characters as is if they are in the UTF-8 range
+                            sb.Append(c);
+                        }
+                        break;
+                }
+            }
+            return sb.ToString();
         }
 
+
         //public static T[] FromJsonToArray<T>(string json)
         //{
         //    if (!json.StartsWith("{\"items\":"))

package/Runtime/Internal/ForceQuitMonitor.cs

@@ -0,0 +1,111 @@
+using System;
+using System.Collections.Generic;
+using UnityEngine;
+
+namespace Amanotes.Core.Internal
+{
+    public class ForceQuitMonitor : IOnApplicationFocus, IOnApplicationPause
+    {
+        [Serializable]
+        internal class AdsEvent
+        {
+            [NonSerialized]
+            internal const string EVENT_NAME = "force_quit";
+            [SerializeField]
+            internal string reason;
+            [SerializeField]
+            internal string detail;
+            
+            internal Dictionary<string, object> Parameters => new Dictionary<string, object>
+            {
+                {"reason", reason},
+                {"detail", detail}
+            };
+        }
+    
+        [Serializable]
+        private class ForceQuitData : IJsonFile
+        {
+            [SerializeField]
+            internal AdsEvent adsEvent;
+            [NonSerialized]
+            internal bool isDirty;
+            
+            internal void SaveIfDirty(bool forceSave = false)
+            {
+                if (!isDirty && !forceSave) return;
+                this.SaveJsonToFile();
+                isDirty = false;
+            }
+        }
+                
+        private readonly ForceQuitData localData = new ForceQuitData();
+
+        private string GetStringValueOrDefault(Dictionary<string, object> dict, string key, string defaultValue = "")
+        {
+            return dict.TryGetValue(key, out object result) 
+                ? result.ToString().Trim().ToLower()
+                : defaultValue;
+        }
+        
+        public void OnLogEvent(string eventNameToSend, Dictionary<string, object> parameters)
+        {
+            switch (eventNameToSend)
+            {
+                case "videoads_show_called":
+                    localData.adsEvent = new AdsEvent { reason = "watch_videoads" };
+                    localData.isDirty = true;
+                    break;
+                case "fullads_show_called":
+                    localData.adsEvent = new AdsEvent { reason = "watch_fullads" };
+                    localData.isDirty = true;
+                    break;
+                case "ad_impression":
+                    string adFormat = GetStringValueOrDefault(parameters, "ad_format");
+                    if (adFormat == "rewarded_video" || adFormat == "interstitial") break;
+                    
+                    if (localData.adsEvent != null)
+                    {
+                        var detailParams = new Dictionary<string, object>
+                        {
+                            ["ad_source"] = GetStringValueOrDefault(parameters, "ad_source"),
+                            ["ad_unit_name"] = GetStringValueOrDefault(parameters, "ad_unit_name") 
+                        };
+                        localData.adsEvent.detail = JsonUtils.DictionaryToJson(detailParams);
+                        localData.SaveIfDirty(true);
+                    }
+                    break;
+                case "videoads_show_notready":
+                case "videoads_finish":
+                case "fullads_show_notready": 
+                case "fullads_finish":
+                    localData.adsEvent = null;
+                    localData.isDirty = true;
+                    break;
+            }
+        }
+
+        public void Init()
+        {
+            GDKUtils.AddUnityCallbacks(this);
+            OnAppOpen();
+        }
+
+        public void OnAppOpen()
+        {
+            localData.LoadJsonFromFile();
+            if (localData.adsEvent == null || string.IsNullOrWhiteSpace(localData.adsEvent.reason)) return;
+            AmaGDK.Analytics.LogEvent(AdsEvent.EVENT_NAME, localData.adsEvent.Parameters);
+            localData.adsEvent = null;
+        }
+        
+        public void OnApplicationFocus(bool hasFocus)
+        {
+            if (!hasFocus) localData.SaveIfDirty();
+        }
+        public void OnApplicationPause(bool pauseStatus)
+        {
+            if (pauseStatus) localData.SaveIfDirty();
+        }
+    }
+}

package/Runtime/Internal/ForceQuitMonitor.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 9c9f11bdd3e34b8ea54c88e412132dc6
+timeCreated: 1717642885

package/package.json

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