com.taptap.sdk.license 4.7.0 → 4.7.1

package/Mobile/Runtime/TapLicenseMobile.cs

@@ -17,6 +17,11 @@ namespace TapSDK.License.Mobile
             EngineBridge.GetInstance().Register(TDS_LICENSE_SERVICE_CLZ, TDS_LICENSE_SERVICE_IMPL);
         }
 
+        public void Init()
+        {
+            // Android 原生内部处理
+        }
+
         public void RegisterLicencesCallback(ITapLicenseCallback callback)
         {
             var command = new Command.Builder()

package/Mobile/Runtime/TapSDK.License.Mobile.Runtime.asmdef

@@ -6,8 +6,7 @@
         "GUID:10560023d8780423cb943c7a324b69f2"
     ],
     "includePlatforms": [
-        "Android",
-        "iOS"
+        "Android"
     ],
     "excludePlatforms": [],
     "allowUnsafeCode": false,

package/Runtime/Internal/ITapLicenseBridge.cs

@@ -1,6 +1,8 @@
 
 namespace TapSDK.License.Internal {
     public interface ITapLicenseBridge {
+
+        void Init();
         void RegisterLicencesCallback(ITapLicenseCallback callback);
 
         void RegisterDLCCallback(ITapDlcCallback callback);

package/Runtime/Internal/TapLicenseInitTask.cs

@@ -0,0 +1,22 @@
+using TapSDK.Core;
+using TapSDK.Core.Internal.Init;
+
+#if PLATFORM_STANDALONE_WIN 
+namespace TapSDK.License.Internal
+{
+    internal class TapLicenseInitTask : IInitTask
+    {
+        public int Order => 13;
+
+        public void Init(TapTapSdkOptions coreOption, TapTapSdkBaseOptions[] otherOptions)
+        {
+            TapTapLicense.Init();
+        }
+
+        public void Init(TapTapSdkOptions coreOption)
+        {
+           TapTapLicense.Init();
+        }
+    }
+}
+#endif

package/Runtime/Internal/TapLicenseInitTask.cs.meta

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

package/Runtime/Public/ITapLicenseCallback.cs

@@ -1,5 +1,8 @@
 namespace TapSDK.License {
-    public interface ITapLicenseCallback {
+    public interface ITapLicenseCallback
+    {
         void OnLicenseSuccess();
+
+        void OnLicenseFailed();
     }
 }

package/Runtime/Public/TapTapLicense.cs

@@ -1,10 +1,13 @@
 using TapSDK.License.Internal;
 using TapSDK.Core.Internal.Utils;
+using System;
+using UnityEngine.PlayerLoop;
+using TapSDK.Core;
 
 namespace TapSDK.License {
     public class TapTapLicense {
 
-        public static readonly string Version = "4.7.0";
+        public static readonly string Version = "4.7.1";
         
         static readonly ITapLicenseBridge license;
 
@@ -13,7 +16,13 @@ namespace TapSDK.License {
                 as ITapLicenseBridge;
         }
 
-        public static void RegisterLicenseCallBack(ITapLicenseCallback callback) {
+        internal static void Init()
+        {
+            license.Init();
+        }
+
+        public static void RegisterLicenseCallBack(ITapLicenseCallback callback)
+        {
             license.RegisterLicencesCallback(callback);
         }
 
@@ -40,7 +49,9 @@ namespace TapSDK.License {
             license.PurchaseDLC(dlc);
         }
 
-        public static void SetTestEnvironment(bool isTest){
+        [Obsolete("No longer needed with new TapTap client and will be removed in the future")]
+        public static void SetTestEnvironment(bool isTest)
+        {
             license.SetTestEnvironment(isTest);
         }
 

package/Runtime/TapSDK.License.Runtime.asmdef

@@ -3,7 +3,11 @@
     "references": [
         "GUID:7d5ef2062f3704e1ab74aac0e4d5a1a7"
     ],
-    "includePlatforms": [],
+    "includePlatforms": [
+        "Android",
+        "Editor",
+        "WindowsStandalone64"
+    ],
     "excludePlatforms": [],
     "allowUnsafeCode": false,
     "overrideReferences": false,

package/Standalone/Runtime/TapLicenseStandalone.cs

@@ -1,42 +1,229 @@
 using TapSDK.License;
 using TapSDK.License.Internal;
 using TapSDK.Core;
+using TapSDK.Core.Standalone;
+using System.Collections.Generic;
+using System;
+using UnityEngine.Animations;
+using System.Linq;
 
+#if PLATFORM_STANDALONE_WIN 
 namespace TapSDK.License.Standalone {
-    public class TapLicenseStandalone : ITapLicenseBridge {
+
+    public class TapLicenseStandalone : ITapLicenseBridge
+    {
+
+        private List<ITapDlcCallback> currentDLCCallbacks;
+
+        private List<ITapLicenseCallback> currentLicenseCallbacks;
+
+        // 是否已在 dll 层注册回调
+        private bool HasRegisterNativeDLCCallback = false;
+
+        private bool HasRegisterNativeLicenseCallback = false;
+
+        private string currentSessionId = null;
+
+        public void Init()
+        {
+            TaplicenseTracker.Instance.TrackInit();
+        }
         public void CheckLicense()
         {
-            TapLogger.Warn($"{nameof(CheckLicense)} NOT implemented.");
+            if (!CheckInit())
+            {
+                return;
+            }
+            currentSessionId = Guid.NewGuid().ToString();
+            string method = "checkLicense";
+            Dictionary<string, string> props = new Dictionary<string, string> { { "license_type", "tap_license" } };
+            TaplicenseTracker.Instance.TrackStart(method, currentSessionId, props);
+            bool isOwned = false;
+            try
+            {
+                isOwned = TapClientStandalone.HasLicense();
+            }
+            catch (Exception e)
+            {
+                TaplicenseTracker.Instance.TrackFailure(method, currentSessionId, props, -1, e.Message ?? "");
+                throw ;
+            }
+
+            if (isOwned)
+            {
+                TaplicenseTracker.Instance.TrackSuccess(method, currentSessionId, props);
+            }
+            else
+            {
+                TaplicenseTracker.Instance.TrackFailure(method, currentSessionId, props, 0, "NOT_PURCHASED");
+            }
+
+            if (currentLicenseCallbacks != null)
+            {
+                foreach (ITapLicenseCallback callback in currentLicenseCallbacks)
+                {
+                    if (isOwned)
+                    {
+                        callback?.OnLicenseSuccess();
+                    }
+                    else
+                    {
+                        callback?.OnLicenseFailed();
+                    }
+                }
+
+            }
         }
 
         public void CheckLicenseForcibly()
         {
-            TapLogger.Warn($"{nameof(CheckLicenseForcibly)} NOT implemented.");
+            CheckLicense();
         }
 
-        public void PurchaseDLC(string sku) {
-            TapLogger.Warn($"{nameof(PurchaseDLC)} NOT implemented.");
-        }
 
-        public void QueryDLC(string[] skus) {
-            TapLogger.Warn($"{nameof(QueryDLC)} NOT implemented.");
+        public void QueryDLC(string[] skus)
+        {
+            if (!CheckInit())
+            {
+                return;
+            }
+            if (skus.Length == 0)
+            {
+                return;
+            }
+            currentSessionId = Guid.NewGuid().ToString();
+            string method = "queryDLC";
+            Dictionary<string, string> props = new Dictionary<string, string> { { "sku_ids", string.Join(",", skus) } };
+            TaplicenseTracker.Instance.TrackStart(method, currentSessionId, props);
+            Dictionary<string, object> dlcResult = new Dictionary<string, object>();
+            try
+            {
+                foreach (string skuId in skus)
+                {
+                    bool isOwned = TapClientStandalone.QueryDLC(skuId);
+                    dlcResult.Add(skuId, isOwned ? 1 : 0);
+                }
+            }
+            catch (Exception e)
+            {
+                TaplicenseTracker.Instance.TrackFailure(method, currentSessionId, props, -1, e.Message ?? "");
+                throw ;
+            }
+            TaplicenseTracker.Instance.TrackSuccess(method, currentSessionId, props);
+            if (currentDLCCallbacks != null)
+            {
+                foreach (ITapDlcCallback callback in currentDLCCallbacks)
+                {
+                    callback?.OnQueryCallBack(TapLicenseQueryCode.QUERY_RESULT_OK, dlcResult);
+                }
+            }
         }
 
         public void RegisterDLCCallback(ITapDlcCallback callback)
         {
-            TapLogger.Warn($"{nameof(RegisterDLCCallback)} NOT implemented.");
+            if (currentDLCCallbacks == null)
+            {
+                currentDLCCallbacks = new List<ITapDlcCallback>();
+            }
+            currentDLCCallbacks.Add(callback);
+            if (!HasRegisterNativeDLCCallback)
+            {
+                HasRegisterNativeDLCCallback = true;
+                TapClientStandalone.RegisterDLCOwnedCallback(DLCCallbackDelegate);
+            }
         }
 
+
         public void RegisterLicencesCallback(ITapLicenseCallback callback)
         {
-            TapLogger.Warn($"{nameof(RegisterLicencesCallback)} NOT implemented.");
+            if (currentLicenseCallbacks == null)
+            {
+                currentLicenseCallbacks = new List<ITapLicenseCallback>();
+            }
+            currentLicenseCallbacks.Add(callback);
+            if (!HasRegisterNativeLicenseCallback)
+            {
+                HasRegisterNativeLicenseCallback = true;
+                TapClientStandalone.RegisterLicenseCallback(LicenseCallbackDelegate);
+            }
+        }
+
+
+        public void SetTestEnvironment(bool isTest)
+        {
+            TapLogger.Warn($"{nameof(SetTestEnvironment)} NOT implemented.");
+        }
 
+        public void PurchaseDLC(string skuId)
+        {
+            if (!CheckInit())
+            {
+                return;
+            }
+            currentSessionId = Guid.NewGuid().ToString();
+            string method = "purchaseDLC";
+            Dictionary<string, string> props = new Dictionary<string, string> { { "sku_id", skuId } };
+            TaplicenseTracker.Instance.TrackStart(method, currentSessionId, props);
+            bool isSuccess = false;
+            try
+            {
+                isSuccess = TapClientStandalone.ShowStore(skuId);
+            }
+            catch (Exception e)
+            {
+                TaplicenseTracker.Instance.TrackFailure(method, currentSessionId, props, -1, e.Message ?? "");
+                throw;
+            }
+            if (isSuccess)
+            {
+                TaplicenseTracker.Instance.TrackSuccess(method, currentSessionId, props);
+            }
+            else
+            {
+                TaplicenseTracker.Instance.TrackFailure(method, currentSessionId, props, -1, "ShowStoreFailed");
+            }
         }
 
-        public void SetTestEnvironment(bool isTest){
-             TapLogger.Warn($"{nameof(SetTestEnvironment)} NOT implemented.");
+        private void DLCCallbackDelegate(string skuId, bool isOwned)
+        {
+            if (currentDLCCallbacks != null)
+            {
+                foreach (ITapDlcCallback callback in currentDLCCallbacks)
+                {
+                    callback?.OnOrderCallBack(skuId, isOwned ? TapLicensePurchasedCode.DLC_PURCHASED : TapLicensePurchasedCode.DLC_NOT_PURCHASED);
+                }
+            }
+        }
+
+
+        private void LicenseCallbackDelegate(bool isOwned)
+        {
+            if (currentLicenseCallbacks != null)
+            {
+                foreach (ITapLicenseCallback callback in currentLicenseCallbacks)
+                {
+                    if (isOwned)
+                    {
+                        callback?.OnLicenseSuccess();
+                    }
+                    else
+                    {
+                        callback?.OnLicenseFailed();
+                    }
+                }
+
+            }
+        }
+
+        private bool CheckInit()
+        {
+            if (!TapCoreStandalone.CheckInitState())
+            {
+                return false;
+            }
+            return true;
         }
 
-       
     }
 }
+#endif

package/Standalone/Runtime/TapLicenseTracker.cs

@@ -0,0 +1,106 @@
+using System.Collections.Generic;
+using System.Linq;
+using Newtonsoft.Json;
+using TapSDK.Core.Standalone.Internal.Openlog;
+
+namespace TapSDK.License.Standalone
+{
+    internal class TaplicenseTracker
+    {
+        private const string ACTION_INIT = "init";
+        private const string ACTION_START = "start";
+        private const string ACTION_SUCCESS = "success";
+        private const string ACTION_FAIL = "fail";
+
+
+
+        private static TaplicenseTracker instance;
+
+        private TapOpenlogStandalone openlog;
+
+        private TaplicenseTracker()
+        {
+            openlog = new TapOpenlogStandalone("TapLicense", TapTapLicense.Version);
+        }
+
+        public static TaplicenseTracker Instance
+        {
+            get
+            {
+                if (instance == null)
+                {
+                    instance = new TaplicenseTracker();
+                }
+                return instance;
+            }
+        }
+
+        internal void TrackInit()
+        {
+            ReportLog(ACTION_INIT);
+        }
+        
+         internal void TrackStart(string funcName, string seesionId, Dictionary<string, string> props = null)
+        {
+            Dictionary<string, string> parameters = new Dictionary<string, string>
+            {
+                { "func_name", funcName },
+                { "session_id", seesionId },
+            };
+            if (props != null) {
+               foreach (var item in props)
+               {
+                    parameters.Add(item.Key, item.Value);
+               }
+            }
+            ReportLog(ACTION_START, new Dictionary<string, string>()
+            {
+                { "args", JsonConvert.SerializeObject(parameters) }
+            });
+        }
+
+        internal void TrackSuccess(string funcName, string seesionId, Dictionary<string, string> props = null)
+        {
+            Dictionary<string, string> parameters = new Dictionary<string, string>
+            {
+                { "func_name", funcName },
+                { "session_id", seesionId },
+            };
+            if (props != null) {
+               foreach (var item in props)
+               {
+                    parameters.Add(item.Key, item.Value);
+               }
+            }
+            ReportLog(ACTION_SUCCESS, new Dictionary<string, string>()
+            {
+                { "args", JsonConvert.SerializeObject(parameters) }
+            });
+        }
+
+        internal void TrackFailure(string funcName, string seesionId, Dictionary<string, string> props = null, int errorCode = -1, string errorMessage = null)
+        {
+            Dictionary<string, string> parameters = new Dictionary<string, string>
+            {
+                { "func_name", funcName },
+                { "session_id", seesionId },
+                { "error_code", errorCode.ToString() },
+                { "error_msg", errorMessage }
+            };
+            if (props != null) {
+               foreach (var item in props)
+               {
+                    parameters.Add(item.Key, item.Value);
+               }
+            }
+            ReportLog(ACTION_FAIL, new Dictionary<string, string>()
+            {
+                { "args", JsonConvert.SerializeObject(parameters) }
+            });
+        }
+         private void ReportLog(string action, Dictionary<string, string> parameters = null)
+        {
+            openlog.LogBusiness(action, parameters);
+        }
+    }
+}

package/Standalone/Runtime/TapLicenseTracker.cs.meta

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

package/Standalone/Runtime/TapSDK.License.Standalone.Runtime.asmdef

@@ -2,13 +2,11 @@
     "name": "TapSDK.License.Standalone.Runtime",
     "references": [
         "GUID:6f31234cd7bae42d2ae6f8b300cad891",
-        "GUID:7d5ef2062f3704e1ab74aac0e4d5a1a7"
+        "GUID:7d5ef2062f3704e1ab74aac0e4d5a1a7",
+        "GUID:cdf1346592073467a860c3effd9679d4"
     ],
     "includePlatforms": [
         "Editor",
-        "LinuxStandalone64",
-        "macOSStandalone",
-        "WindowsStandalone32",
         "WindowsStandalone64"
     ],
     "excludePlatforms": [],

package/package.json

@@ -2,10 +2,10 @@
   "name": "com.taptap.sdk.license",
   "displayName": "TapTapSDK License",
   "description": "TapTapSDK License",
-  "version": "4.7.0",
+  "version": "4.7.1",
   "unity": "2019.4",
   "license": "MIT",
   "dependencies": {
-    "com.taptap.sdk.core": "4.7.0"
+    "com.taptap.sdk.core": "4.7.1"
   }
 }