com.amanotes.gdk 0.2.14 → 0.2.16

package/Editor/EmbedRemoteConfigAssetInspector.cs

@@ -142,7 +142,7 @@ namespace Amanotes.Editor
         {
             try
             {
-                string[] lines = rawText.Split("\n");
+                string[] lines = rawText.Split('\n');
                 KeyValue[] arrKeyValue = new KeyValue[lines.Length];
                 for (int i = 0; i < lines.Length; i++)
                 {

package/Editor/MatchSDKVersion.cs

@@ -0,0 +1,151 @@
+using System.Collections.Generic;
+using UnityEditor;
+using UnityEngine;
+using System.IO;
+using System.Linq;
+using System;
+using System.Text.RegularExpressions;
+using Amanotes.Core.Internal;
+using Amanotes.Editor;
+
+namespace Amanotes.Core
+{
+    internal class MatchSDKVersion
+    {
+        private static string defineVer = "#define VER_";
+        private static string comment = "//";
+
+        private static Dictionary<string, string> sdkToClassMap = new Dictionary<string, string>
+        {
+            { "FirebaseAnalytics", "FirebaseAnalyticsAdapter" },
+            { "FirebaseRemoteConfig", "FirebaseRemoteConfigAdapter" },
+            { "appsflyer-unity-plugin", "AppsFlyerAdapter" },
+            { "IronSource_IntegrationManager", "IronSourceAdapter" },
+            { "Adjust", "AdjustAdapter" },
+            { "Purchases", "RevenueCatAdapter" }
+        };
+        
+        private static FileInfo[] files = null;
+
+        [InitializeOnLoadMethod]
+        private static void Initialize()
+        {
+            AssetDatabase.importPackageCompleted += UpdateAdapter;
+        }
+        private static void UncommentDefineAtLine(string filePath, int lineIndex)
+        {
+            string[] lines = File.ReadAllLines(filePath);
+
+            for (int i = 0; i < lines.Length; i++)
+            {
+                if (i == lineIndex)
+                {
+                    lines[i] = lines[i].TrimStart(new[] { '/', ' ' });
+                }
+                else if (Regex.IsMatch(lines[i], @"^#define\s+"))
+                {
+                    lines[i] = "//" + lines[i];
+                }
+            }
+
+            File.WriteAllLines(filePath, lines);
+        }
+
+        private static KeyValuePair<int, SemVer> FindNearestLowerVersion(SemVer inputVersion, Dictionary<int, SemVer> defineLines)
+        {
+            KeyValuePair<int, SemVer> versionLessAndNearest = default;
+            SemVer bestMatch = SemVer.ZERO;
+            
+            foreach (var kvp in defineLines)
+            {
+                if(inputVersion.CompareTo(kvp.Value) < 0)
+                    continue;
+                if(kvp.Value.CompareTo(bestMatch) <= 0)
+                    continue;
+                    
+                bestMatch = kvp.Value;
+                versionLessAndNearest = kvp;
+            }
+
+            return versionLessAndNearest;
+        }
+        
+        private static Dictionary<int, SemVer> GetSemVersDefine(string code)
+        {
+            Dictionary<int, SemVer> defineLines = new Dictionary<int, SemVer>();
+
+            string[] lines = code.Split(new[] { "\r\n", "\r", "\n" }, StringSplitOptions.None);
+            for (int i = 0; i < lines.Length; i++)
+            {
+                string line = lines[i].Trim();
+
+                if (Regex.IsMatch(line, @"^(\/\/\s*)?#define\s+"))
+                {
+                    defineLines.Add(i, new SemVer(GetVersionNumber(line)));
+                }
+            }
+
+            return defineLines;
+        }
+
+        private static string GetVersionNumber(string defineString)
+        {
+            string pattern = @"VER_(\d+)_(\d+)_(\d+)";
+
+            Match match = Regex.Match(defineString, pattern);
+
+            if (match.Success)
+            {
+                string major = match.Groups[1].Value;
+                string minor = match.Groups[2].Value;
+                string patch = match.Groups[3].Value;
+                string versionNumber = $"{major}.{minor}.{patch}";
+
+                return versionNumber;
+            }
+
+            return string.Empty;
+        }
+
+        private static void UpdateAdapter(string packageName)
+        {
+            if (files == null)
+            {
+                string dataPath = Path.Combine(Application.dataPath, "AmaGDK/Adapters");
+                if (!Directory.Exists(dataPath))
+                {
+                    Logging.Log($"{dataPath} is not found");
+                    return;
+                }
+                DirectoryInfo directory = new DirectoryInfo(dataPath);
+                files = directory.GetFiles("*Adapter.cs", SearchOption.AllDirectories);
+            }
+
+            if (sdkToClassMap.TryGetValue(GetSDKName(packageName), out string adapterClass))
+            {
+                var version = SDKStatus.Get(adapterClass.Replace("Adapter", "")).sdkVersion;
+                FileInfo file = files.FirstOrDefault(x => x.FullName.Contains($"{adapterClass}.cs"));
+
+                if (file != null)
+                {
+                    Dictionary<int, SemVer> defineLines = GetSemVersDefine(File.ReadAllText(file.FullName));
+
+                    KeyValuePair<int, SemVer> r = FindNearestLowerVersion(version, defineLines);
+                    
+                    if (r.Value.isValid)
+                    {
+                        return;
+                    }
+                    UncommentDefineAtLine(file.FullName, r.Key);
+                }
+            }
+
+            AssetDatabase.Refresh();
+        }
+
+        private static string GetSDKName(string packageName)
+        {
+            return sdkToClassMap.Keys.FirstOrDefault(sdk => packageName.Contains(sdk));
+        }
+    }
+}

package/Editor/MatchSDKVersion.cs.meta

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

package/Editor/Utils/AmaGDKEditor.ExtractVersion.cs

@@ -24,7 +24,7 @@ namespace Amanotes.Editor
         }
     }
 
-    [Serializable] internal class SDKStatus
+    [Serializable] public class SDKStatus
     {
 
         // 

package/Editor/Utils/AmaGDKEditor.Utils.cs

@@ -44,40 +44,43 @@ namespace Amanotes.Editor
 
         private static IEnumerator GetCoroutine(string url, Dictionary<string, string> headers = null, Action<float> onProgress = null, Action<string> onSuccess = null, Action<string> onError = null)
         {
-            using var request = UnityWebRequest.Get(url);
-            // Add headers to the request
-            if (headers != null)
+            using (var request = UnityWebRequest.Get(url))
             {
-                foreach (var header in headers)
+                // Add headers to the request
+                if (headers != null)
                 {
-                    request.SetRequestHeader(header.Key, header.Value);
+                    foreach (var header in headers)
+                    {
+                        request.SetRequestHeader(header.Key, header.Value);
+                    }
+                }
+    
+                // Send the request
+                request.timeout = 60;
+                yield return request.SendWebRequest();
+    
+                while (request.isDone == false)
+                {
+                    onProgress?.Invoke(request.downloadProgress);
+                    yield return null;
+                }
+    
+                // Check for errors
+    #pragma warning disable CS0618
+                if (request.isNetworkError || request.isHttpError)
+    #pragma warning restore CS0618
+                {
+                    Debug.LogError("Error: " + request.error);
+                    onError?.Invoke(request.error);
+                }
+                else
+                {
+                    // Process the response
+                    string responseText = request.downloadHandler.text;
+                    onSuccess?.Invoke(responseText);
                 }
             }
-
-            // Send the request
-            request.timeout = 60;
-            yield return request.SendWebRequest();
-
-            while (request.isDone == false)
-            {
-                onProgress?.Invoke(request.downloadProgress);
-                yield return null;
-            }
-
-            // Check for errors
-#pragma warning disable CS0618
-            if (request.isNetworkError || request.isHttpError)
-#pragma warning restore CS0618
-            {
-                Debug.LogError("Error: " + request.error);
-                onError?.Invoke(request.error);
-            }
-            else
-            {
-                // Process the response
-                string responseText = request.downloadHandler.text;
-                onSuccess?.Invoke(responseText);
-            }
+            
         }
     }
 }

package/Runtime/AmaGDK.AmaPassport.cs

@@ -336,6 +336,7 @@ namespace Amanotes.Core
             public static string IpAddress => User.amaPassport.device.ipAddress;
             public static string Country => User.amaPassport.device.country;
             public static string DeviceUniqueId => User.amaPassport.device.deviceUniqueId;
+            public static string AppsflyerId => User.amaPassport.device.appsflyerId;
 
             internal static void Init()
             {

package/Runtime/AmaGDK.IAP.cs

@@ -0,0 +1,423 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+using Amanotes.Core.Internal;
+
+using static Amanotes.Core.AmaGDK.IAP;
+using static Amanotes.Core.Internal.Logging;
+
+namespace Amanotes.Core
+{
+    public partial class AmaGDK //In-app purchase
+    {
+        public partial class IAP //Public
+        {
+            public static bool IsVIP => !string.IsNullOrEmpty(localData.activeSubscriptionId);
+
+            public static string ActiveSubscriptionId => localData.activeSubscriptionId;
+
+            public static Dictionary<string, ProductInfo> AllProducts => dicProducts;
+
+            public static ISetupBuilder GetProducts()
+            {
+                var result = new SetupContext();
+                ExecuteInNextFrame(result.GetProducts);
+                return result;
+            }
+
+            public static IPurchaseBuilder Purchase(string productId)
+            {
+                var result = new PurchaseContext();
+                ExecuteInNextFrame(() => result.Purchase(productId));
+                return result;
+            }
+
+            public static IPurchaseBuilder RestorePurchase()
+            {
+                var result = new PurchaseContext();
+                ExecuteInNextFrame(result.RestorePurchase);
+                return result;
+            }
+
+            public static ProductInfo GetProduct(string productId)
+            {
+                if (!dicProducts.ContainsKey(productId))
+                {
+                    LogWarning($"[IAP] Not found product with id <{productId}>. Make sure you have called Setup() first.");
+                    return null;
+                }
+
+                return dicProducts[productId];
+            }
+
+            public static List<string> GetActiveSubscriptions()
+            {
+                return IAPAdapter?.GetActiveSubscriptions();
+            }
+
+            public static List<string> GetPurchasedProductIds()
+            {
+                return localData.purchasedProducts;
+            }
+
+            public static bool IsPurchased(string productId)
+            {
+                var purchasedProductIds = GetPurchasedProductIds();
+                return purchasedProductIds != null && purchasedProductIds.Contains(productId);
+            }
+        }
+
+        public partial class IAP //Internal
+        {
+            internal static IIAPAdapter adapter;
+            internal static readonly IAPData localData = new IAPData().LoadJsonFromFile();
+            internal static IIAPAdapter IAPAdapter
+            {
+                get
+                {
+                    if (adapter != null) return adapter;
+                    LogWarning("[IAP] Adapter is not available.");
+                    return null;
+                }
+            }
+            
+            private static IAPAdapterConfig _adapterConfig;
+            internal static IAPAdapterConfig AdapterConfig
+            {
+                get
+                {
+                    if (_adapterConfig != null) return _adapterConfig;
+                    LogWarning("[IAP] Adapter config is not available.");
+                    return null;
+                }
+            }
+
+            internal static Dictionary<string, ProductInfo> dicProducts = new Dictionary<string, ProductInfo>();
+
+            internal static void Init()
+            {
+                adapter = Adapter.GetSingleAdapter<IIAPAdapter>();
+                var adapterContext = adapter as AdapterContext;
+                
+                if (adapterContext == null) return;
+                _adapterConfig = adapterContext?.GetAdapterConfig<IAPAdapterConfig>();
+
+                if (!adapterContext.IsReady) return;
+                localData.Sync();
+                if (_adapterConfig.autoGetProducts)
+                    GetProducts();
+            }
+            
+            internal static void ExecuteInNextFrame(Action method)
+            {
+                _instance.StartCoroutine(ExecuteRoutine(method));
+            }
+
+            static IEnumerator ExecuteRoutine(Action method)
+            {
+                yield return null;
+                method?.Invoke();
+            }
+        }
+        
+        public partial class IAP //Persistent
+        {
+            [Serializable]
+            internal class IAPData : IJsonFile
+            {
+                public string activeSubscriptionId;
+                public List<string> purchasedProducts;
+
+                public void Sync()
+                {
+                    activeSubscriptionId = adapter.GetActiveSubscriptionId();
+                    purchasedProducts = adapter.GetPurchasedProducts();
+                    this.SaveJsonToFile();
+                }
+            }
+        }
+    }
+    
+    public enum ProductType
+    {
+        Subscription,
+        Consumable,
+        NonConsumable
+    }
+    
+    [Serializable]
+    public class ProductInfo
+    {
+        public string id;
+        public ProductType type;
+        [HideInInspector] public string title;
+        [HideInInspector] public string description;
+        [HideInInspector] public float price;
+        [HideInInspector] public string currencyCode;
+        [HideInInspector] public string[] discountIds;
+    }
+
+    public class PurchaseSuccess
+    {
+        public string productId;
+        public string transactionId;
+        public string receipt;
+        public string purchaseToken;
+    }
+
+    public class PurchaseError
+    {
+        public string productId;
+        public bool isCancelled;
+        public string error;
+
+        public PurchaseError()
+        {
+        }
+        
+        public PurchaseError(string errorMessage)
+        {
+            error = errorMessage;
+        }
+    }
+
+    public static class IAPExtension
+    {
+        //GetProducts extensions
+        public static ISetupBuilder SetSubscriptions(this ISetupBuilder sc, params string[] subs)
+        {
+            if (sc == null) return null;
+
+            foreach (var pId in subs)
+            {
+                AdapterConfig?.products.Add(new ProductInfo() { id = pId, type = ProductType.Subscription });
+            }
+            return sc;
+        }
+        
+        public static ISetupBuilder SetConsumables(this ISetupBuilder sc, params string[] cons)
+        {
+            if (sc == null) return null;
+
+            foreach (var pId in cons)
+            {
+                AdapterConfig?.products.Add(new ProductInfo() { id = pId, type = ProductType.Consumable });
+            }
+            return sc;
+        }
+        
+        public static ISetupBuilder SetNonComsumables(this ISetupBuilder sc, params string[] nons)
+        {
+            if (sc == null) return null;
+
+            foreach (var pId in nons)
+            {
+                AdapterConfig?.products.Add(new ProductInfo() { id = pId, type = ProductType.NonConsumable });
+            }
+            return sc;
+        }
+
+        public static ISetupBuilder OnSuccess(this ISetupBuilder sc, Action<Dictionary<string, ProductInfo>> callback)
+        {
+            if (sc == null) return null;
+
+            var setupContext = sc as SetupContext;
+            setupContext.onSuccess = callback; 
+            return sc;
+        }
+        
+        public static ISetupBuilder OnFail(this ISetupBuilder sc, Action<string> callback)
+        {
+            if (sc == null) return null;
+
+            var setupContext = sc as SetupContext;
+            setupContext.onFail = callback; 
+            return sc;
+        }
+
+        //Purchase extensions
+        public static IPurchaseBuilder OnSuccess(this IPurchaseBuilder pb, Action<PurchaseSuccess> callback)
+        {
+            if (pb == null) return null;
+
+            var purchaseContext = pb as PurchaseContext;
+            purchaseContext.onSuccess = callback; 
+            return pb;
+        }
+        
+        public static IPurchaseBuilder OnFail(this IPurchaseBuilder pb, Action<PurchaseError> callback)
+        {
+            if (pb == null) return null;
+
+            var purchaseContext = pb as PurchaseContext;
+            purchaseContext.onFail = callback; 
+            return pb;
+        }
+
+        public static IPurchaseBuilder SetDiscount(this IPurchaseBuilder pb, string discountId)
+        {
+            if (pb == null) return null;
+
+            var purchaseContext = pb as PurchaseContext;
+            purchaseContext.discountId = discountId; 
+            return pb;
+        }
+    }
+}
+
+namespace Amanotes.Core.Internal
+{
+    [Serializable]
+    public class IAPAdapterConfig
+    {
+        [SerializeField] internal bool allPurchaseSuccessInEditor;
+        [SerializeField] internal List<ProductInfo> products;
+        [SerializeField] internal bool autoGetProducts;
+    }
+    
+    public interface ISetupBuilder { }
+            
+    public class SetupContext: ISetupBuilder
+    {
+        public Action<Dictionary<string, ProductInfo>> onSuccess;
+        public Action<string> onFail;
+
+        private readonly Queue<(List<string> pIds, ProductType pType)> getProdQueue = new Queue<(List<string> pIds, ProductType pType)>();
+
+        public void GetProducts()
+        {
+            if (AdapterConfig?.products.Count == 0)
+            {
+                LogWarning("There is no IAP product");
+                return;
+            }                
+            
+            getProdQueue.Clear();
+            var subs = new List<string>();
+            var cons = new List<string>();
+            var nons = new List<string>();
+            
+            foreach (var p in AdapterConfig.products)
+            {
+                switch (p.type)
+                {
+                    case ProductType.Subscription:
+                        subs.Add(p.id);
+                        break;
+                    case ProductType.Consumable:
+                        cons.Add(p.id);
+                        break;
+                    case ProductType.NonConsumable:
+                        nons.Add(p.id);
+                        break;
+                    default:
+                        LogWarning($"[IAP] Product <{p.id}> has not specified ProductType.");
+                        break;
+                }
+            }
+            
+            getProdQueue.Enqueue((subs, ProductType.Subscription));
+            getProdQueue.Enqueue((cons, ProductType.Consumable));
+            getProdQueue.Enqueue((nons, ProductType.NonConsumable));
+            GetNextProductsInQueue();
+        }
+
+        void GetNextProductsInQueue()
+        {
+            if (getProdQueue.Count <= 0)
+            {
+                onSuccess?.Invoke(dicProducts);
+                return;
+            }
+            
+            var item = getProdQueue.Dequeue();
+            GetProductsByType(item.pIds, item.pType);
+        }
+        
+        void GetProductsByType(List<string> lsProduct, ProductType type)
+        {
+            try
+            {
+                IAPAdapter?.GetProducts(lsProduct.ToArray(), type, (pList) =>
+                {
+                    foreach (var pI in pList)
+                    {
+                        dicProducts.Add(pI.id, pI);    
+                    }
+                    ExecuteInNextFrame(GetNextProductsInQueue);
+                });
+            }
+            catch (Exception e)
+            {
+                LogWarning($"[IAP] Error on getting products of type <{type}>. Error detail:\n{e.Message}");
+                onFail?.Invoke(e.Message);
+                throw;
+            }
+        }
+    }
+    
+    public interface IPurchaseBuilder { }
+
+    public class PurchaseContext : IPurchaseBuilder
+    {
+        public Action<PurchaseSuccess> onSuccess;
+        public Action<PurchaseError> onFail;
+        public string discountId;
+
+        public void Purchase(string productId)
+        {
+            if (!dicProducts.ContainsKey(productId))
+            {
+                LogWarning($"[IAP] Product {productId} is not found");
+                return;
+            }
+            
+#if UNITY_EDITOR
+            if (AdapterConfig.allPurchaseSuccessInEditor)
+            {
+                DoOnSuccess(new PurchaseSuccess
+                {
+                    productId = productId
+                });
+                return;
+            }
+#endif
+
+            if (!string.IsNullOrWhiteSpace(discountId))
+            {
+                IAPAdapter?.PurchaseDiscount(productId, dicProducts[productId].type, discountId, DoOnSuccess, DoOnFail);
+                return;
+            }
+
+            IAPAdapter?.Purchase(productId, dicProducts[productId].type, DoOnSuccess, DoOnFail);
+        }
+
+        public void RestorePurchase()
+        {
+            IAPAdapter?.RestorePurchase(DoOnSuccess, DoOnFail);
+        }
+
+        void DoOnSuccess(PurchaseSuccess success)
+        {
+            localData.Sync();
+            onSuccess?.Invoke(success);
+        }
+
+        void DoOnFail(PurchaseError error)
+        {
+            onFail?.Invoke(error);
+        }
+    }
+
+    public interface IIAPAdapter
+    {
+        void GetProducts(string[] productIds, ProductType productType, Action<ProductInfo[]> onComplete);
+        void Purchase(string productId, ProductType productType, Action<PurchaseSuccess> onSuccess, Action<PurchaseError> onFail);
+        void PurchaseDiscount(string productId, ProductType productType, string discountId, Action<PurchaseSuccess> onSuccess, Action<PurchaseError> onFail);
+        void RestorePurchase(Action<PurchaseSuccess> onSuccess, Action<PurchaseError> onFail);
+        List<string> GetActiveSubscriptions();
+        List<string> GetPurchasedProducts();
+        string GetActiveSubscriptionId();
+    }
+}

package/Runtime/AmaGDK.IAP.cs.meta

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

package/Runtime/AmaGDK.cs

@@ -109,6 +109,7 @@ namespace Amanotes.Core
             AmaPassport.Init();
             Analytics.Init();
             Ads.Init();
+            IAP.Init();
 
             _status = Status.Ready;
             _onReadyCallback?.Invoke();
@@ -242,7 +243,7 @@ namespace Amanotes.Core
         public void ChangeDevMode()
         {
             string variableName = "GDK_HOME";
-            string output = RunShellCommand($"source ~/.zshrc && echo ${variableName}");
+            string output = RunShellCommand($"source ~/.zshrc && echo file:${variableName}");
             output = output.Trim();
 
             if (string.IsNullOrEmpty(output))

package/package.json

@@ -1,9 +1,9 @@
 {
     "name": "com.amanotes.gdk",
-    "version": "0.2.14",
+    "version": "0.2.16",
     "displayName": "AmaGDK",
     "description": "Amanotes Game Development Kit",
-    "unity": "2020.3",
+    "unity": "2019.4",
     "keywords": [
         "Amanotes",
         "Amanotes GDK",