com.amanotes.gdk 0.1.18 → 0.1.20

package/Runtime/AmaGDK.Utils.cs

@@ -1,6 +1,8 @@
 using System;
+using System.Collections;
 using System.Collections.Generic;
 using System.IO;
+using System.Text;
 using UnityEngine;
 
 using static Amanotes.Core.Internal.Logging;
@@ -39,6 +41,54 @@ namespace Amanotes.Core.Internal
             }
         }
 
+        internal static void SaveAppend(string fileName, IEnumerable<string> contents)
+        {
+            if (string.IsNullOrWhiteSpace(fileName))
+            {
+                LogWarningOnce($"File name must be not null or empty");
+                return;
+            }
+
+            if (contents == null || !contents.GetEnumerator().MoveNext())
+            {
+                LogWarningOnce($"Content for {fileName} is empty");
+            }
+
+            string path = GetPath(fileName);
+            try
+            {
+                File.AppendAllLines(path, contents);
+            }
+            catch (Exception ex)
+            {
+                LogWarningOnce(path + "\n" + ex);
+            }            
+        }
+
+        internal static void SaveAppend(string fileName, string content)
+        {
+            if (string.IsNullOrWhiteSpace(fileName))
+            {
+                LogWarningOnce($"File name must be not null or empty");
+                return;
+            }
+
+            if (string.IsNullOrWhiteSpace(content))
+            {
+                LogWarningOnce($"Content for {fileName} is empty");
+            }
+
+            string path = GetPath(fileName);
+            try
+            {
+                File.AppendAllText(path, content);
+            }
+            catch (Exception ex)
+            {
+                LogWarningOnce(path + "\n" + ex);
+            }
+        }        
+
         internal static string Load(string fileName)
         {
             string content = "";
@@ -117,15 +167,9 @@ namespace Amanotes.Core.Internal
 
             foreach (var action in actions)
             {
-                if (action == null)
-                {
-                    LogWarning("action is null!");
-                    continue;
-                }
+                if (action == null) continue;
                 queue.Enqueue(action);
             }
-
-            ProcessQueue();
         }
 
         private void ProcessQueue()
@@ -154,6 +198,11 @@ namespace Amanotes.Core.Internal
                 onComplete?.Invoke();
         }
 
+        public void StartQueue()
+        {
+            ProcessQueue();
+        }
+
         private void ActionCompleted()
         {
             isProcessing = false;
@@ -185,4 +234,144 @@ namespace Amanotes.Core.Internal
             FileUtils.Save(fileName, json);
         }
     }
+
+    internal static class JsonUtils
+    {
+        public static string TupleToJson(params (string key, object value)[] parameters)
+        {
+            Dictionary<string, object> tupleToDict = new Dictionary<string, object>();
+            foreach (var item in parameters)
+            {
+                tupleToDict.Add(item.key, item.value);
+            }
+            return DictionaryToJson(tupleToDict);
+        }
+
+        public static string KeyValueToJson(string key, object value)
+        {
+            return DictionaryToJson(new Dictionary<string, object>() { { key, value } });
+        }
+
+        public static string DictionaryToJson(IDictionary inputDict, bool format = false)
+        {
+            if (inputDict == null)
+                return "{}";
+
+            StringBuilder jsonSb = new StringBuilder();
+            jsonSb.Append("{");
+            var 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;
+
+                if (isFirstElement)
+                    isFirstElement = false;
+                else
+                    jsonSb.Append(",");
+
+                jsonSb.AppendFormat("{0}\"{1}\":", format ? "\n" : "", key);
+                AppendJsonValue(ref jsonSb, key, value, format);
+
+            }
+
+            jsonSb.AppendFormat("{0}{1}", format ? "\n" : "", "}");
+
+            return jsonSb.ToString();
+        }
+
+        private static void GetJsonIListValue(ref StringBuilder jsonSb, string key, IList list, bool format)
+        {
+            jsonSb.Append("[");
+            var isFirstElement = true;
+
+            foreach (var item in list)
+            {
+                if (isFirstElement)
+                    isFirstElement = false;
+                else
+                    jsonSb.Append(",");
+
+                if (format)
+                    jsonSb.AppendLine();
+                AppendJsonValue(ref jsonSb, key, item, format);
+            }
+
+            if (format)
+            {
+                jsonSb.AppendLine();
+            }
+            jsonSb.Append("]");
+        }
+
+        private static void AppendJsonValue(ref StringBuilder jsonSb, string key, object value, bool format)
+        {
+            if (value == null)
+            {
+                jsonSb.Append("null");
+            }
+            if (value is string)
+            {
+                jsonSb.Append($"\"{value}\"");
+            }
+            else if (value is int || value is float || value is double || value is long)
+            {
+                jsonSb.Append($"{value}");
+            }
+            else if (value is bool)
+            {
+                jsonSb.Append((bool)value ? "true" : "false");
+            }
+            else if (value is IDictionary)
+            {
+                jsonSb.Append($"{DictionaryToJson((IDictionary)value, format)}");
+            }
+            else if (value is IList || value is Array)
+            {
+                GetJsonIListValue(ref jsonSb, key, (IList)value, format);
+            }
+            else
+            {
+                jsonSb.Append($"{JsonUtility.ToJson(value, format)}");
+            }
+        }
+
+        //public static T[] FromJsonToArray<T>(string json)
+        //{
+        //    if (!json.StartsWith("{\"items\":"))
+        //    {
+        //        json = $"{{\"items\":{json}}}";
+        //    }
+        //    Wrapper<T> wrapper = JsonUtility.FromJson<Wrapper<T>>(json);
+        //    return wrapper.items;
+        //}
+
+        //public static T FromJsonToObject<T>(string json)
+        //{
+        //    return JsonUtility.FromJson<T>(json);
+        //}
+
+        //public static string ToJson<T>(T[] array)
+        //{
+        //    Wrapper<T> wrapper = new Wrapper<T>();
+        //    wrapper.items = array;
+        //    return JsonUtility.ToJson(wrapper);
+        //}
+
+        //public static string ToJson<T>(T obj)
+        //{
+        //    return JsonUtility.ToJson(obj);
+        //}
+
+        //[Serializable]
+        //private class Wrapper<T>
+        //{
+        //    public T[] items;
+        //}
+    }
 }

package/Runtime/AmaGDK.WebUtils.cs

@@ -1,17 +1,105 @@
-using System.Collections;
-using UnityEngine.Networking;
-using System;
+using System.Collections;
+using UnityEngine.Networking;
+using System;
 using System.Collections.Generic;
+using UnityEngine;
 using static Amanotes.Core.Internal.Logging;
 
 namespace Amanotes.Core.Internal
-{
-    internal class WebUtils
+{
+    public class JsonWebRequest<T> : UnityWebRequest where T : class
     {
-        public static void PostJson(string url, string jsonData, Action<bool, string> onComplete = null, Dictionary<string, string> headers = null)
+
+        [Serializable]
+        internal class ResponseError
+        {
+            public string error;
+            public string message;
+            public string statusCode;
+        }
+
+        [Serializable]
+        internal class ResponseT
         {
-            AmaGDK._instance.StartCoroutine(PostJsonCoroutine(url, jsonData, onComplete, headers));
+            public T data;
+            public ResponseError error = null;
+        }
+
+        private string requestJson;
+        private string requestHeader;
+        public T data;
+        public bool isResponseError;
+
+        public JsonWebRequest(string url, string json, string header = "") : base(url, "POST")
+        {
+            requestJson = json;
+            requestHeader = header;
+        }
+
+        public JsonWebRequest<T> SetRequestHeader(Dictionary<string, string> headers)
+        {
+            foreach (KeyValuePair<string, string> kvp in headers)
+            {
+                SetRequestHeader(kvp.Key, kvp.Value);
+            }
+            return this;
+        }
+
+        public new IEnumerator Send()
+        {
+            byte[] bodyRaw = System.Text.Encoding.UTF8.GetBytes(requestJson);
+            uploadHandler = new UploadHandlerRaw(bodyRaw);
+            downloadHandler = new DownloadHandlerBuffer();
+            SetRequestHeader(new Dictionary<string, string>
+            {
+                {"Authorization", $"bearer {requestHeader}"},
+                {"Content-Type", "application/json"},
+                {"api-token", requestHeader}
+            });
+            yield return SendWebRequest();
+            
+            var httpError = result == Result.ConnectionError || result == Result.ProtocolError;
+            if (httpError)
+            {
+                LogWarning($"{url} returned {responseCode}: {error}");
+                yield break;
+            }
+            
+            try
+            {
+                string result = downloadHandler.text;
+                var response = JsonUtility.FromJson<ResponseT>(result);
+                if (response == null)
+                {
+                    LogWarning("Response parse fail???\n" + result);
+                    yield break;
+                }
+
+                if (!string.IsNullOrEmpty(response.error?.message))
+                {
+                    LogWarning($"server return error: errorMessage = {response.error?.message}");
+                    isResponseError = true;
+                    yield break;
+                }
+
+                data = response.data;
+            }
+            catch (Exception ex)
+            {
+                LogWarning($"Error parsing {typeof(T)}: {ex.Message}\n");
+                isResponseError = true;
+                yield break;
+            }
         }
+    }
+
+
+    internal class WebUtils
+    {
+        public static Coroutine PostJson(string url, string jsonData, Action<bool, string> onComplete = null, Dictionary<string, string> headers = null)
+        {
+            return AmaGDK._instance.StartCoroutine(PostJsonCoroutine(url, jsonData, onComplete, headers));
+        }
 
         static IEnumerator PostJsonCoroutine(string url, string jsonData, Action<bool, string> onComplete = null, Dictionary<string, string> headers = null)
         {
@@ -29,15 +117,16 @@ namespace Amanotes.Core.Internal
             webRequest.downloadHandler = new DownloadHandlerBuffer();
             yield return webRequest.SendWebRequest();
 
-            if (webRequest.result != UnityWebRequest.Result.Success)
-            {
-                LogWarning("POST request failed: " + webRequest.error);
-                onComplete?.Invoke(false, webRequest.error);
-            }
-            else
-            {
-                onComplete?.Invoke(true, webRequest.downloadHandler.text);
-            }
+            if (webRequest.result != UnityWebRequest.Result.Success)
+            {
+                onComplete?.Invoke(false, webRequest.error);
+                
+            }
+            else
+            {
+                onComplete?.Invoke(true, webRequest.downloadHandler.text);
+            }
+            yield return null;
         }
-    }
+    }
 }

package/Runtime/AmaGDK.cs

@@ -12,24 +12,26 @@ namespace Amanotes.Core
 {
     public partial class AmaGDK : MonoBehaviour
     {
-        public const string VERSION = "0.1.18";
+        public const string VERSION = "0.1.20";
 
         internal static AmaGDK _instance;
         internal static event Action _frameUpdate;
+        internal static Status _status = Status.None;
+        internal static Action _onReadyCallback;
+        internal static bool _allowInit = false;
+        public bool autoInit = true;
+
         private static ConfigAsset _config = null;
-        internal static ConfigAsset Config {
-            get {
+        internal static ConfigAsset Config
+        {
+            get
+            {
                 if (_config != null) return _config;
                 _config = Resources.Load<ConfigAsset>("AmaGDKConfig");
                 // if (_config == null) LogWarningOnce(CONFIG_NOT_FOUND);
                 return _config;
             }
         }
-        
-        internal static Status _status = Status.None;
-        internal static Action _onReadyCallback;
-        internal static bool _allowInit = false;
-        public bool autoInit = true;
 
         void Awake()
         {
@@ -52,7 +54,7 @@ namespace Amanotes.Core
             _allowInit = _allowInit || autoInit;
             StartCoroutine(InitRoutine());
         }
-        
+
         IEnumerator InitRoutine()
         {
             if (Config == null)
@@ -62,7 +64,7 @@ namespace Amanotes.Core
 
             float time = 0;
             float timeout = 3;
-            
+
             var counter = 0;
             const int INIT_TOLERANCE = 10 * 60;
             const int INIT_WARN_CYCLE = 5 * 60;
@@ -81,10 +83,10 @@ namespace Amanotes.Core
             _status = Status.Initialize;
 
             // sort on priority
-            Adapter.listAdapters.Sort((a1, a2)=> a1.initOrder.CompareTo(a2.initOrder));
+            Adapter.listAdapters.Sort((a1, a2) => a1.initOrder.CompareTo(a2.initOrder));
             foreach (var adapter in Adapter.listAdapters)
             {
-                Log($"Initing {adapter.id} --> initOrder: {adapter.initOrder}");
+                Log($"Initing {adapter.adapterId} --> initOrder: {adapter.initOrder}");
                 adapter.Init();
 
                 while (!adapter.IsReady)
@@ -92,16 +94,16 @@ namespace Amanotes.Core
                     time += Time.deltaTime;
                     yield return null;
                     if (time <= timeout) continue;
-                    LogWarningOnce($"{adapter.id} init time out: {timeout}");
+                    LogWarningOnce($"{adapter.adapterId} init time out: {timeout}");
                 }
 
-                Log($"Adapter {adapter.id} inited!");
+                Log($"Adapter {adapter.adapterId} inited!");
             }
 
             // Init modules (Adapter managers)
             Analytics.Init();
             //Ads.Init();
-            
+
             _status = Status.Ready;
             _onReadyCallback?.Invoke();
             _onReadyCallback = null;
@@ -143,11 +145,11 @@ namespace Amanotes.Core
             _allowInit = true;
 
             if (_instance != null) return;
-            var sdk = new GameObject("AmaGDK5");
+            var sdk = new GameObject("AmaGDK");
             _instance = sdk.AddComponent<AmaGDK>();
         }
 
-        
+
 
         public static void SetOnReadyCallback(Action onReady)
         {
@@ -170,7 +172,7 @@ namespace Amanotes.Core
             public const string FIREBASE_REMOTE_CONFIG = "FirebaseRemoteConfig";
             public const string APPSFLYER = "AppsFlyer";
             public const string IRONSOURCE = "IronSource";
-            public const string REVENUECAT = "RevenueCat";     
+            public const string REVENUECAT = "RevenueCat";
         }
     }
 }