com.amanotes.gdk 0.1.20 → 0.1.21

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # Changelog
 
+## [0.1.21 - 2023-05-22]
+### Add Remote Config module + Firebase Remote Config adapter
+### Rearrange adapters
+### Add "enableAnalyticsCollection" to Firebase Analytics config
+### Fix AmaGDK to compatible with Unity 2019
+
 ## [0.1.20 - 2023-04-20]
 ### Refactor Adapter architure to support reading adapter config from Core
 ### Add session stat for Analytics module

package/{Samples~/Example/AmaGDKExample.unity.meta → Packages/FirebaseRemoteConfigAdapter_v9.1.0.unitypackage.meta}

@@ -1,5 +1,5 @@
 fileFormatVersion: 2
-guid: 10026e46727964068991024d2146c0c7
+guid: c4acdfbf7c40646b6b8d379d00b3df5d
 DefaultImporter:
   externalObjects: {}
   userData: 

package/Runtime/AmaGDK.Adapters.cs

@@ -86,6 +86,25 @@ namespace Amanotes.Core.Internal
             return result;
         }
 
+        public static T GetSingleAdapter<T>() where T: class
+        {
+            var adapters = Adapter.FindAll<T>();
+
+            if (adapters == null || adapters.Count < 1)
+            {
+                LogError($"Not found adapter for <{nameof(T)}>!");
+                return null;
+            }
+
+            if (adapters.Count > 1)
+            {
+                LogError($"Multiple adapters detected. <{nameof(T)}> supports only one adapter!");
+                return null;
+            }
+
+            return adapters[0].GetAdapterApi<T>();
+        }
+
         public static T GetConfig<T>() where T : ConfigAsset
         {
             return (T)AmaGDK.Config;

package/Runtime/AmaGDK.Ads.cs

@@ -63,22 +63,8 @@ namespace Amanotes.Core
             public static Action<string> OnRewardedVideoFailCallback;
 
             public static void Init()
-            {
-                var adsModules = Adapter.FindAll<IAds>();
-
-                if (adsModules == null || adsModules.Count < 1)
-                {
-                    LogError("Ads module not found!");
-                    return;
-                }
-                
-                if (adsModules.Count > 1)
-                {
-                    LogError("Multiple Ads modules is not supported!");
-                    return;
-                }
-                
-                adsModule = adsModules[0].GetAdapterApi<IAds>();
+            {                                
+                adsModule =Adapter.GetSingleAdapter<IAds>();
             }
 
             public static void RequestBanner(BannerPosition position)

package/Runtime/AmaGDK.Internal.cs

@@ -44,6 +44,7 @@ namespace Amanotes.Core.Internal
             "FirebaseAnalyticsAdapter_v9.1.0",
             "AppsFlyerAdapter_v6.5.4",
             // "IronsourceAdapter_v7.2.6",
+            "FirebaseRemoteConfigAdapter_v9.1.0"
         };
 
 #if UNITY_EDITOR
@@ -67,7 +68,6 @@ namespace Amanotes.Core.Internal
 #endif
     }
 
-
     public static class Logging
     {
         public static readonly StringBuilder tmpWarningSB = new StringBuilder();

package/Runtime/AmaGDK.RemoteConfig.cs

@@ -0,0 +1,343 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Text;
+using UnityEngine;
+
+using Amanotes.Core.Internal;
+using static Amanotes.Core.Internal.Logging;
+
+namespace Amanotes.Core
+{    
+    public partial class AmaGDK //Remote Config
+    {
+        public enum RemoteConfigSource
+        {
+            DefaultAsset,
+            DefaultFile,
+            Cache,
+            Internet
+        }
+
+        [Serializable]
+        public partial class RemoteConfig //Public
+        {
+            public static Dictionary<string, string> DictConfig { get { return dictConfig; } }
+            public static RemoteConfigSource Source { private set; get; }
+            static bool? _cacheExisted = null;
+            public static bool HasCache {
+                get
+                {
+                    if (_cacheExisted == null)
+                        _cacheExisted = FileUtils.Exist(fileName);
+                    return _cacheExisted.GetValueOrDefault();
+                }
+            }            
+
+            public static T ParseConfig<T>(T config = null) where T : class, new()
+            {
+                if (config == null)
+                    config = new T();
+
+                var configInJson = GetConfigAsJson();
+                if (string.IsNullOrEmpty(configInJson))
+                {
+                    LogWarning("[RemoteConfig] The config is empty");
+                    return config;
+                }
+
+                try
+                {                    
+                    return config = JsonUtility.FromJson<T>(configInJson);
+                }
+                catch (Exception e)
+                {
+                    LogError("[RemoteConfig] Cannot parse remote config file. Error: " + e.Message);
+                    return config;
+                }
+            }
+
+            public static T Get<T>(string key, T defaultValue = default(T))
+            {
+                if (dictConfig.ContainsKey(key))
+                    return (T)Convert.ChangeType(dictConfig[key], typeof(T));
+                return defaultValue;
+            }
+
+            public static string GetConfigAsJson()
+            {
+                return JsonUtils.DictionaryToJson(dictConfig);
+            }                      
+        }        
+
+        public partial class RemoteConfig //Internal
+        {
+            internal enum FetchState
+            {
+                None,
+                ResolveDependencies,
+                CheckInternet,
+                Fetch,
+                SaveCache,
+
+                LoadCache,
+                LoadDefaultFile,
+                LoadDefaultAsset,
+
+                Success,
+                Fail
+            }
+
+            static Dictionary<string, string> dictConfig = new Dictionary<string, string>();
+            static string fileName = $"{nameof(RemoteConfig)}.kv";
+            static string defaultConfigFileName = "remote_config_defaults";
+
+            static FetchState _state = FetchState.None;
+            internal static FetchState State { get { return _state; } }
+            static readonly Dictionary<FetchState, Action[]> fetchSM = new Dictionary<FetchState, Action[]>
+            {
+                { FetchState.None,                new Action[]{ ResolveDependency }},
+                { FetchState.ResolveDependencies, new Action[]{ LoadCache, CheckInternet}},
+                { FetchState.CheckInternet,       new Action[]{ LoadCache, Fetch}},                
+                { FetchState.Fetch,               new Action[]{ LoadCache, SaveCache}},                
+                { FetchState.SaveCache,           new Action[]{ SetDone }},
+                { FetchState.LoadCache,           new Action[]{ LoadDefaultFile, SetDone}},
+                { FetchState.LoadDefaultFile,     new Action[]{ LoadDefaultAsset, SetDone}},
+                { FetchState.LoadDefaultAsset,    new Action[]{ SetFail, SetDone}}
+            };
+
+            internal static IRemoteConfig adapter;
+            internal static Action<bool> onAdapterInitCompleteCallback;
+
+            internal static void NextState(bool result = true)
+            {
+                if (!fetchSM.TryGetValue(_state, out var actions))
+                {
+                    LogWarning("[RemoteConfig] Invalid / Unsupported state: " + _state);
+                    return;
+                }
+
+                if (actions.Length == 1)
+                {
+                    actions[0]();
+                    return;
+                }
+
+                actions[result ? 1 : 0]();
+            }            
+
+            static void ResolveDependency()
+            {
+                _state = FetchState.ResolveDependencies;
+                adapter = Adapter.GetSingleAdapter<IRemoteConfig>();
+                if (adapter == null)
+                {
+                    NextState(false);
+                    return;
+                }
+                adapter.ResolveDependencies(NextState);
+            }
+
+            static void CheckInternet()
+            {
+                _state = FetchState.CheckInternet;
+                NextState(Application.internetReachability != NetworkReachability.NotReachable);
+            }            
+
+            static void Fetch()
+            {
+                _state = FetchState.Fetch;
+                adapter.FetchConfig(HasCache, (isSuccess, result) =>
+                {
+                    if (!isSuccess)
+                    {
+                        NextState(false);
+                        return;
+                    }                    
+
+                    dictConfig = result;
+                    Source = RemoteConfigSource.Internet;
+                    Log("[RemoteConfig] Load from the internet");
+                    NextState(true);
+                });
+            }            
+
+            static void SaveCache()
+            {
+                _state = FetchState.SaveCache;
+                StringBuilder sb = new StringBuilder();
+                foreach (var c in dictConfig)
+                {
+                    sb.AppendLine($"{c.Key}\t{c.Value}");
+                }
+
+                var filePath = FileUtils.GetPath(fileName);
+                FileUtils.Save(filePath, sb.ToString());
+                Log($"[RemoteConfig] Saved remote config to {filePath}");
+                NextState();
+            }            
+
+            static void LoadCache()
+            {
+                _state = FetchState.LoadCache;
+
+                if (!HasCache)
+                {
+                    NextState(false);
+                    return;
+                }
+
+                try
+                {
+                    dictConfig.Clear();
+                    using (StreamReader sr = new StreamReader(FileUtils.GetPath(fileName)))
+                    {
+                        string line;
+                        int lineIdx = 0;
+                        while ((line = sr.ReadLine()) != null)
+                        {
+                            lineIdx++;
+                            var idx = line.IndexOf('\t');
+                            if (idx == -1)
+                            {
+                                LogWarning($"[RemoteConfig] Cannot get (key, value) at line {lineIdx} of cache");
+                                continue;
+                            }
+                            string key = line.Substring(0, idx);
+                            string value = line.Substring(idx + 1);
+                            dictConfig.Add(key, value);
+                        }
+                    }
+                    Source = RemoteConfigSource.Cache;
+                    Log("[RemoteConfig] Load from cache");
+                }
+                catch (Exception ex)
+                {
+                    LogWarning($"[RemoteConfig] Error on LoadCache: {ex.Message}");
+                    _cacheExisted = false;
+                    NextState(false);
+                    return;
+                }
+
+                NextState(true);
+            }
+
+            static void LoadDefaultFile()
+            {
+                _state = FetchState.LoadDefaultFile;                
+
+                var defaultConfigFile = Resources.Load<TextAsset>(defaultConfigFileName);                
+                if (defaultConfigFile == null)
+                {
+                    NextState(false);
+                    return;
+                }
+                
+                dictConfig = JsonToDictionary(defaultConfigFile.text);
+
+                Source = RemoteConfigSource.DefaultFile;
+                Log("[RemoteConfig] Load from default file");
+                NextState(true);
+            }
+
+            static void LoadDefaultAsset()
+            {
+                _state = FetchState.LoadDefaultAsset;
+
+                var defaultValue = ((AdapterContext)adapter).GetAdapterConfig<RemoteConfigConfig>().defaultValue;
+
+                if (defaultValue.Length == 0)
+                {
+                    NextState(false);
+                    return;
+                }
+
+                foreach (var item in defaultValue)
+                {
+                    dictConfig.Add(item.key, item.value);
+                }
+                Source = RemoteConfigSource.DefaultAsset;
+                Log("[RemoteConfig] Load from default asset");
+                NextState(true);
+            }
+
+            static void SetDone()
+            {
+                _state = FetchState.Success;
+                onAdapterInitCompleteCallback(true);
+            }
+
+            static void SetFail()
+            {
+                _state = FetchState.Fail;
+                onAdapterInitCompleteCallback(false);
+            }
+
+            static Dictionary<string, string> JsonToDictionary(string json)
+            {
+                var dictResult = new Dictionary<string, string>();
+                string[] lines = json.Split(new[] { '\r', '\n' }, StringSplitOptions.RemoveEmptyEntries);
+                for (int i = 0; i < lines.Length; i++)
+                {
+                    int idx = lines[i].IndexOf(':');
+                    if (idx < 0)
+                    {
+                        continue;
+                    }
+                    string key = lines[i].Substring(0, idx - 1).Trim().Trim('"');
+                    string value = "";
+                    if (idx == lines.Length - 1)
+                    {
+                        value = lines[i].Substring(idx + 1).Trim().Trim('"');
+                    }
+                    else
+                    {
+                        value = lines[i].Substring(idx + 1).Trim();
+                        value = value.Substring(1, value.Length - 3);
+                    }                    
+                    dictResult[key] = value;
+                }
+                return dictResult;
+            }
+        }        
+    }
+
+    public static class RemoteConfigExtension
+    {
+        public static void InitRemoteConfigModule(this IRemoteConfig ap, Action<bool> onCompleteCallback)
+        {
+            if (AmaGDK.RemoteConfig.State != AmaGDK.RemoteConfig.FetchState.None)
+            {
+                LogWarning($"[RemoteConfig] Current state {AmaGDK.RemoteConfig.State.ToString()}\n" +
+                           $"Cannot start to initialize");
+                return;
+            }
+            AmaGDK.RemoteConfig.onAdapterInitCompleteCallback = onCompleteCallback;
+            AmaGDK.RemoteConfig.NextState();
+        }
+    }
+}
+
+namespace Amanotes.Core.Internal
+{
+    [Serializable]
+    public class RemoteConfigConfig
+    {
+        public KeyValue[] defaultValue;
+        public float firstFetchTimeOutInSeconds = 10;
+        public float defaultTimeOutInSeconds = 3;        
+    }
+
+    [Serializable]
+    public class KeyValue
+    {
+        public string key;
+        public string value;
+    }
+
+    public interface IRemoteConfig
+    {        
+        void ResolveDependencies(Action<bool> onComplete);
+        void FetchConfig(bool isFirstTime, Action<bool, Dictionary<string, string>> onComplete);
+    }
+}

package/Runtime/{AmaPassport/AmaGDK.AmaPassport.cs.meta → AmaGDK.RemoteConfig.cs.meta}

@@ -1,5 +1,5 @@
 fileFormatVersion: 2
-guid: ce8b955ef63a04f96b8402c5d9558928
+guid: d81aa5ad940bd43139879d9d53e0e00b
 MonoImporter:
   externalObjects: {}
   serializedVersion: 2

package/Runtime/AmaGDK.Utils.cs

@@ -16,6 +16,11 @@ namespace Amanotes.Core.Internal
             return Path.Combine(basePath, fileName);
         }
 
+        internal static bool Exist(string fileName)
+        {
+            return File.Exists(GetPath(fileName));
+        }
+
         internal static void Save(string fileName, string content)
         {
             if (string.IsNullOrWhiteSpace(fileName))
@@ -127,7 +132,7 @@ namespace Amanotes.Core.Internal
             {
                 LogWarningOnce(path + "\n" + ex);
             }
-        }
+        }        
 
         private static string _basePath;
         private static string basePath
@@ -252,7 +257,7 @@ namespace Amanotes.Core.Internal
             return DictionaryToJson(new Dictionary<string, object>() { { key, value } });
         }
 
-        public static string DictionaryToJson(IDictionary inputDict, bool format = false)
+        public static string DictionaryToJson(IDictionary inputDict, bool format = false, bool checkJsonInString = true)
         {
             if (inputDict == null)
                 return "{}";
@@ -276,7 +281,7 @@ namespace Amanotes.Core.Internal
                     jsonSb.Append(",");
 
                 jsonSb.AppendFormat("{0}\"{1}\":", format ? "\n" : "", key);
-                AppendJsonValue(ref jsonSb, key, value, format);
+                AppendJsonValue(ref jsonSb, key, value, format, checkJsonInString);
 
             }
 
@@ -299,7 +304,7 @@ namespace Amanotes.Core.Internal
 
                 if (format)
                     jsonSb.AppendLine();
-                AppendJsonValue(ref jsonSb, key, item, format);
+                AppendJsonValue(ref jsonSb, key, item, format, false);
             }
 
             if (format)
@@ -309,36 +314,60 @@ namespace Amanotes.Core.Internal
             jsonSb.Append("]");
         }
 
-        private static void AppendJsonValue(ref StringBuilder jsonSb, string key, object value, bool format)
+        private static void AppendJsonValue(ref StringBuilder jsonSb, string key, object value, bool format, bool checkJsonInString)
         {
             if (value == null)
             {
                 jsonSb.Append("null");
+                return;
             }
+
             if (value is string)
             {
+                string s = value.ToString();
+                if (checkJsonInString)
+                {
+                    if (s.StartsWith("{") && s.EndsWith("}"))
+                    {
+                        jsonSb.Append(s);
+                        return;
+                    }
+                    if (s.StartsWith("[") && s.EndsWith("]"))
+                    {
+                        jsonSb.Append(s);
+                        return;
+                    }                    
+                }
+
                 jsonSb.Append($"\"{value}\"");
+                return;
             }
-            else if (value is int || value is float || value is double || value is long)
+
+            if (value is int || value is float || value is double || value is long)
             {
                 jsonSb.Append($"{value}");
+                return;
             }
-            else if (value is bool)
+
+            if (value is bool)
             {
                 jsonSb.Append((bool)value ? "true" : "false");
+                return;
             }
-            else if (value is IDictionary)
+
+            if (value is IDictionary)
             {
                 jsonSb.Append($"{DictionaryToJson((IDictionary)value, format)}");
+                return;
             }
-            else if (value is IList || value is Array)
+
+            if (value is IList || value is Array)
             {
                 GetJsonIListValue(ref jsonSb, key, (IList)value, format);
+                return;
             }
-            else
-            {
-                jsonSb.Append($"{JsonUtility.ToJson(value, format)}");
-            }
+
+            jsonSb.Append($"{JsonUtility.ToJson(value, format)}");
         }
 
         //public static T[] FromJsonToArray<T>(string json)

package/Runtime/AmaGDK.WebUtils.cs

@@ -57,9 +57,8 @@ namespace Amanotes.Core.Internal
                 {"api-token", requestHeader}
             });
             yield return SendWebRequest();
-            
-            var httpError = result == Result.ConnectionError || result == Result.ProtocolError;
-            if (httpError)
+
+            if (!string.IsNullOrEmpty(error))
             {
                 LogWarning($"{url} returned {responseCode}: {error}");
                 yield break;
@@ -117,16 +116,14 @@ namespace Amanotes.Core.Internal
             webRequest.downloadHandler = new DownloadHandlerBuffer();
             yield return webRequest.SendWebRequest();
 
-            if (webRequest.result != UnityWebRequest.Result.Success)
+            if (!string.IsNullOrEmpty(webRequest.error))
             {
-                onComplete?.Invoke(false, webRequest.error);
-                
+                onComplete?.Invoke(false, webRequest.error);                
             }
             else
             {
-                onComplete?.Invoke(true, webRequest.downloadHandler.text);
-            }
-            yield return null;
+                onComplete?.Invoke(true, webRequest.downloadHandler.text);
+            }            
         }
     }
 }

package/Runtime/AmaGDK.cs

@@ -12,7 +12,7 @@ namespace Amanotes.Core
 {
     public partial class AmaGDK : MonoBehaviour
     {
-        public const string VERSION = "0.1.20";
+        public const string VERSION = "0.1.21";
 
         internal static AmaGDK _instance;
         internal static event Action _frameUpdate;
@@ -88,16 +88,18 @@ namespace Amanotes.Core
             {
                 Log($"Initing {adapter.adapterId} --> initOrder: {adapter.initOrder}");
                 adapter.Init();
+                time = 0;
 
                 while (!adapter.IsReady)
                 {
                     time += Time.deltaTime;
                     yield return null;
                     if (time <= timeout) continue;
-                    LogWarningOnce($"{adapter.adapterId} init time out: {timeout}");
+                    LogWarning($"{adapter.adapterId} init time out: {timeout}");
+                    break;
                 }
 
-                Log($"Adapter {adapter.adapterId} inited!");
+                Log(string.Format("Adapter {0} {1}", adapter.adapterId, adapter.IsReady ? "inited!" : "is not ready!"));
             }
 
             // Init modules (Adapter managers)

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "com.amanotes.gdk",
-    "version": "0.1.20",
+    "version": "0.1.21",
     "displayName": "AmaGDK",
     "description": "Amanotes Game Development Kit",
     "unity": "2020.3",