com.taptap.sdk.core 4.6.2 → 4.6.3

package/Standalone/Runtime/Internal/TapClientBridge.cs

@@ -14,29 +14,29 @@ namespace TapSDK.Core.Standalone.Internal
     internal enum TapSDKInitResult
     {
         // 初始化成功
-        kTapSDKInitResult_OK = 0,
+        OK = 0,
         // 其他错误
-        kTapSDKInitResult_FailedGeneric = 1,
+        FailedGeneric = 1,
         // 未找到 TapTap，用户可能未安装，请引导用户下载安装 TapTap
-        kTapSDKInitResult_NoPlatform = 2,
+        NoPlatform = 2,
         // 已安装 TapTap，游戏未通过 TapTap 启动
-        kTapSDKInitResult_NotLaunchedByPlatform = 3,
+        NotLaunchedByPlatform = 3,
 
         // SDK 本地执行时未知错误
-        kTapSDKInitResult_Unknown = -1,
+        Unknown = -1,
         // SDK 本地执行时超时
-        kTapSDKInitResult_Timeout = -2,
+        Timeout = -2,
     };
 
-    internal enum TapCallbackID
+    internal enum TapEventID
     {
-        kTapCallbackIDUnknown = 0,
+        Unknown = 0,
 
         // [1, 2000), reserved for TapTap platform events
-        kTapCallbackIDSystemStateChanged = 1,
+        SystemStateChanged = 1,
 
         // [2001, 4000), reserved for TapTap user events
-        kTapCallbackIDAuthorizeFinished = 2001,
+        AuthorizeFinished = 2001,
     };
 
     // 系统事件类型
@@ -49,9 +49,9 @@ namespace TapSDK.Core.Standalone.Internal
     // 是否触发授权的返回结果
     internal enum AuthorizeResult
     {
-        kAuthorizeResult_UNKNOWN = 0, // 未知
-        kAuthorizeResult_OK = 1, // 成功触发授权
-        kAuthorizeResult_FAILED = 2, // 授权失败
+        UNKNOWN = 0, // 未知
+        OK = 1, // 成功触发授权
+        FAILED = 2, // 授权失败
     };
 
     // 完成授权后的返回结果
@@ -152,39 +152,47 @@ namespace TapSDK.Core.Standalone.Internal
         SystemStateResponse response = Marshal.PtrToStructure<SystemStateResponse>(userData);
      }
     */
-    internal static void RegisterCallback(int callbackId, CallbackDelegate callback)
+    internal static void RegisterCallback(TapEventID eventID, CallbackDelegate callback)
     {
        
-        TapLogger.Debug("start set delegate");
         IntPtr funcPtr = Marshal.GetFunctionPointerForDelegate(callback);
-         if (callbackId == (int)TapCallbackID.kTapCallbackIDSystemStateChanged){
-            if(_callbackInstance!= null){
-                UnRegisterCallback(_callbackInstance, false);
-            }
-            _callbackInstance = callback; // 防止被 GC 回收
-        }else {
-            if(_userCallbackInstance!= null){
-                UnRegisterCallback(_userCallbackInstance, true);
-            }
-            _userCallbackInstance = callback;
+        switch (eventID)
+        {
+            case TapEventID.AuthorizeFinished:
+                if (_userCallbackInstance != null)
+                {
+                    UnRegisterCallback(eventID, _userCallbackInstance);
+                }
+                _userCallbackInstance = callback;
+                break;
+            case TapEventID.SystemStateChanged:
+                if (_callbackInstance != null)
+                {
+                    UnRegisterCallback(eventID, _callbackInstance);
+                }
+                _callbackInstance = callback; // 防止被 GC 回收 
+                break;
         }
-        TapLogger.Debug("start set delegate ptr " + funcPtr);
-        TapSDK_RegisterCallback(callbackId, funcPtr);
-        TapLogger.Debug("start set delegate ptr finish");
+        
+        TapSDK_RegisterCallback((int)eventID, funcPtr);
     }
 
     // 移除回调
-    internal static void UnRegisterCallback(CallbackDelegate callback, bool isUser)
+    internal static void UnRegisterCallback(TapEventID eventID,CallbackDelegate callback)
     {
         
         IntPtr funcPtr = Marshal.GetFunctionPointerForDelegate(callback);
-        if (isUser){
-            _userCallbackInstance = null;
-        }else {
-            _callbackInstance = null;
+        switch (eventID)
+        {
+            case TapEventID.AuthorizeFinished:
+                _userCallbackInstance = null;
+                break;
+            case TapEventID.SystemStateChanged:
+                _callbackInstance = null;
+                break; 
         }
-         TapLogger.Debug("start remove delegate ptr " + funcPtr);
-        TapSDK_UnregisterCallback(isUser? (int)TapCallbackID.kTapCallbackIDAuthorizeFinished :(int)TapCallbackID.kTapCallbackIDSystemStateChanged,funcPtr);
+        TapLogger.Debug("start remove delegate ptr " + funcPtr);
+        TapSDK_UnregisterCallback((int) eventID, funcPtr);
     }
    
     internal static AuthorizeResult LoginWithScopes(string[] scopeStrings, string responseType, string redirectUri, 
@@ -198,7 +206,7 @@ namespace TapSDK.Core.Standalone.Internal
             return (AuthorizeResult)result;
         }catch(Exception ex){
             TapLogger.Debug("login crash = " + ex.StackTrace);
-            return AuthorizeResult.kAuthorizeResult_UNKNOWN;
+            return AuthorizeResult.UNKNOWN;
         }
     }
 

package/Standalone/Runtime/Internal/TapClientBridgePoll.cs

@@ -3,9 +3,7 @@ using UnityEngine;
 
 namespace TapSDK.Core.Standalone.Internal
 {
-    /// <summary>
-    /// 防沉迷轮询器
-    /// </summary>
+    
     internal class TapClientBridgePoll : MonoBehaviour 
     {
         static readonly string TAP_CLIENT_POLL_NAME = "TapClientBridgePoll";

package/Standalone/Runtime/Internal/UI/TapClientConnectTipController.cs

@@ -31,13 +31,13 @@ namespace TapSDK.Core.Standalone.Internal {
 
         internal void Show(TapSDKInitResult errorType)
         {
-            if (errorType == TapSDKInitResult.kTapSDKInitResult_NoPlatform){
+            if (errorType == TapSDKInitResult.NoPlatform){
                 tipText.text = "获取游戏信息失败，请下载 TapTap 客户端后重新启动游戏";
-            }else if (errorType == TapSDKInitResult.kTapSDKInitResult_NotLaunchedByPlatform){
+            }else if (errorType == TapSDKInitResult.NotLaunchedByPlatform){
                 tipText.text = "获取游戏信息失败，请从 TapTap 客户端重新启动游戏";
-            }else if (errorType == TapSDKInitResult.kTapSDKInitResult_Unknown){
+            }else if (errorType == TapSDKInitResult.Unknown){
                 tipText.text = "本地发生未知错误，请从 TapTap 客户端重新启动游戏";
-            }else if (errorType == TapSDKInitResult.kTapSDKInitResult_Timeout){
+            }else if (errorType == TapSDKInitResult.Timeout){
                 tipText.text = "获取游戏信息超时，请从 TapTap 客户端重新启动游戏";                  
             }else {
                 tipText.text = "发生未知错误，请从 TapTap 客户端重新启动游戏";

package/Standalone/Runtime/Internal/User.cs

@@ -16,11 +16,11 @@ namespace TapSDK.Core.Standalone.Internal {
 
         private readonly PlayRecorder playRecorder;
 
-        public User() {
+        internal User() {
             playRecorder = new PlayRecorder();
         }
 
-        public void Login(string userId, Dictionary<string, object> props = null) {
+        internal void Login(string userId, Dictionary<string, object> props = null) {
             // 先执行旧用户登出逻辑
             Id = TapCoreStandalone.Prefs.Get<string>(USER_ID_KEY);
             if (!string.IsNullOrWhiteSpace(Id)) {
@@ -31,18 +31,18 @@ namespace TapSDK.Core.Standalone.Internal {
             Id = userId;
 
             if (TapCoreStandalone.enableAutoEvent) {
-                TapCoreStandalone.Tracker.TrackEvent(Constants.USER_LOGIN, props, true);
+                TapEventStandalone.Tracker?.TrackEvent(Constants.USER_LOGIN, props, true);
             }
 
             Dictionary<string, object> updateProps = new Dictionary<string, object> {
                 { "has_user", true },
             };
-            TapCoreStandalone.Tracker.TrackDeviceProperties(Constants.PROPERTY_UPDATE_TYPE, updateProps);
+            TapEventStandalone.Tracker?.TrackDeviceProperties(Constants.PROPERTY_UPDATE_TYPE, updateProps);
 
             playRecorder.Start();
         }
 
-        public void Logout() {
+        internal void Logout() {
             playRecorder.Stop();
 
             Id = null;

package/Standalone/Runtime/Public/TapClientStandalone.cs

@@ -0,0 +1,314 @@
+using UnityEngine;
+using System.Threading.Tasks;
+using TapSDK.Core.Internal.Utils;
+using TapSDK.Core.Standalone.Internal;
+using TapSDK.UI;
+using System;
+using System.Runtime.InteropServices;
+using TapSDK.Core.Standalone.Internal.Openlog;
+using System.Threading;
+
+
+
+namespace TapSDK.Core.Standalone
+{
+#if UNITY_STANDALONE_WIN
+    public class TapClientStandalone
+    {
+
+        // 是否是渠道服游戏包
+        private static bool isChannelPackage = false;
+
+        // -1 未执行 0 失败  1 成功
+        private static int lastIsLaunchedFromTapTapPCResult = -1;
+        private static bool isRuningIsLaunchedFromTapTapPC = false;
+
+
+        // 当为渠道游戏包时，与启动器的初始化校验结果
+        private static TapInitResult tapInitResult;
+
+        // <summary>
+        // 校验游戏是否通过启动器唤起，建立与启动器通讯
+        //</summary>
+        public static async Task<bool> IsLaunchedFromTapTapPC()
+        {
+            // 正在执行中
+            if (isRuningIsLaunchedFromTapTapPC)
+            {
+                UIManager.Instance.OpenToast("IsLaunchedFromTapTapPC 正在执行，请勿重复调用", UIManager.GeneralToastLevel.Error);
+                TapLogger.Error("IsLaunchedFromTapTapPC 正在执行，请勿重复调用");
+                return false;
+            }
+            // 多次执行时返回上一次结果
+            if (lastIsLaunchedFromTapTapPCResult != -1)
+            {
+                TapLogger.Debug("IsLaunchedFromTapTapPC duplicate invoke return " + lastIsLaunchedFromTapTapPCResult);
+                return lastIsLaunchedFromTapTapPCResult > 0;
+            }
+
+            isChannelPackage = true;
+            TapTapSdkOptions coreOptions = TapCoreStandalone.coreOptions;
+            if (coreOptions == null)
+            {
+                UIManager.Instance.OpenToast("IsLaunchedFromTapTapPC 调用必须在初始化之后", UIManager.GeneralToastLevel.Error);
+                TapLogger.Error("IsLaunchedFromTapTapPC 调用必须在初始化之后");
+                return false;
+            }
+            string clientId = coreOptions.clientId;
+            string pubKey = coreOptions.clientPublicKey;
+            if (string.IsNullOrEmpty(clientId) || string.IsNullOrEmpty(pubKey))
+            {
+                UIManager.Instance.OpenToast("clientId 及 TapPubKey 参数都不能为空, clientId =" + clientId + ", TapPubKey = " + pubKey, UIManager.GeneralToastLevel.Error);
+                TapLogger.Error("clientId 或 TapPubKey 无效, clientId = " + clientId + ", TapPubKey = " + pubKey);
+                return false;
+            }
+            isRuningIsLaunchedFromTapTapPC = true;
+
+            string sessionId = Guid.NewGuid().ToString();
+            TapCoreTracker.Instance.TrackStart(TapCoreTracker.METHOD_LAUNCHER, sessionId);
+            try
+            {
+                TapInitResult result = await RunClientBridgeMethodWithTimeout(clientId, pubKey);
+                isRuningIsLaunchedFromTapTapPC = false;
+                if (result.needQuitGame)
+                {
+                    lastIsLaunchedFromTapTapPCResult = 0;
+                    TapCoreTracker.Instance.TrackSuccess(TapCoreTracker.METHOD_LAUNCHER, sessionId, TapCoreTracker.SUCCESS_TYPE_RESTART);
+                    TapLogger.Debug("IsLaunchedFromTapTapPC Quit game");
+                    Application.Quit();
+                    return false;
+                }
+                else
+                {
+                    if (result.result == TapSDKInitResult.OK)
+                    {
+                        string currentClientId;
+                        bool isFetchClientIdSuccess = TapClientBridge.GetClientId(out currentClientId);
+                        TapLogger.Debug("IsLaunchedFromTapTapPC get  clientId = " + currentClientId);
+                        if (isFetchClientIdSuccess && !string.IsNullOrEmpty(currentClientId) && currentClientId != clientId)
+                        {
+                            UIManager.Instance.OpenToast("SDK 中配置的 clientId = " + clientId + "与 Tap 启动器中" + currentClientId + "不一致", UIManager.GeneralToastLevel.Error);
+                            TapLogger.Error("SDK 中配置的 clientId = " + clientId + "与 Tap 启动器中" + currentClientId + "不一致");
+                            TapCoreTracker.Instance.TrackFailure(TapCoreTracker.METHOD_LAUNCHER, sessionId, -1, "SDK 中配置的 clientId = " + clientId + "与 Tap 启动器中" + currentClientId + "不一致");
+                            lastIsLaunchedFromTapTapPCResult = 0;
+                            return false;
+                        }
+                        string openId;
+                        bool fetchOpenIdSuccess = TapClientBridge.GetTapUserOpenId(out openId);
+                        if (fetchOpenIdSuccess)
+                        {
+                            TapLogger.Debug("IsLaunchedFromTapTapPC get  openId = " + openId);
+                            EventManager.TriggerEvent(EventManager.IsLaunchedFromTapTapPCFinished, openId);
+                        }
+                        else
+                        {
+                            TapLogger.Debug("IsLaunchedFromTapTapPC get  openId failed");
+                        }
+                        lastIsLaunchedFromTapTapPCResult = 1;
+                        TapClientBridgePoll.StartUp();
+                        TapCoreTracker.Instance.TrackSuccess(TapCoreTracker.METHOD_LAUNCHER, sessionId, TapCoreTracker.SUCCESS_TYPE_INIT);
+                        TapLogger.Debug("IsLaunchedFromTapTapPC check success");
+                        return true;
+                    }
+                    else
+                    {
+
+                        TapCoreTracker.Instance.TrackFailure(TapCoreTracker.METHOD_LAUNCHER, sessionId, (int)result.result, result.errorMsg ?? "");
+                        lastIsLaunchedFromTapTapPCResult = 0;
+                        TapLogger.Debug("IsLaunchedFromTapTapPC show TapClient tip Pannel " + result.result + " , error = " + result.errorMsg);
+                        string tipPannelPath = "Prefabs/TapClient/TapClientConnectTipPanel";
+                        if (Resources.Load<GameObject>(tipPannelPath) != null)
+                        {
+                            var pannel = UIManager.Instance.OpenUI<TapClientConnectTipController>(tipPannelPath);
+                            pannel.Show(result.result);
+                        }
+                        return false;
+                    }
+                }
+            }
+            catch (TimeoutException e)
+            {
+                lastIsLaunchedFromTapTapPCResult = 0;
+                TapCoreTracker.Instance.TrackFailure(TapCoreTracker.METHOD_LAUNCHER, sessionId, (int)TapSDKInitResult.Timeout, e.Message ?? "");
+
+                TapLogger.Debug("IsLaunchedFromTapTapPC check timeout");
+                string tipPannelPath = "Prefabs/TapClient/TapClientConnectTipPanel";
+                if (Resources.Load<GameObject>(tipPannelPath) != null)
+                {
+                    var pannel = UIManager.Instance.OpenUI<TapClientConnectTipController>(tipPannelPath);
+                    pannel.Show(TapSDKInitResult.Timeout);
+                }
+                return false;
+            }
+            catch (Exception e)
+            {
+                lastIsLaunchedFromTapTapPCResult = 0;
+                TapCoreTracker.Instance.TrackFailure(TapCoreTracker.METHOD_LAUNCHER, sessionId, (int)TapSDKInitResult.Unknown, e.Message ?? "");
+
+                TapLogger.Debug("IsLaunchedFromTapTapPC check exception = " + e.Message + " \n" + e.StackTrace);
+                string tipPannelPath = "Prefabs/TapClient/TapClientConnectTipPanel";
+                if (Resources.Load<GameObject>(tipPannelPath) != null)
+                {
+                    var pannel = UIManager.Instance.OpenUI<TapClientConnectTipController>(tipPannelPath);
+                    pannel.Show(TapSDKInitResult.Unknown);
+                }
+                return false;
+            }
+        }
+
+        private static async Task<TapInitResult> RunClientBridgeMethodWithTimeout(string clientId, string pubKey)
+        {
+            TaskCompletionSource<TapInitResult> task = new TaskCompletionSource<TapInitResult>();
+            try
+            {
+                TapInitResult result = await ExecuteWithTimeoutAsync(() =>
+                {
+                    bool needQuitGame = TapClientBridge.TapSDK_RestartAppIfNecessary(clientId);
+                    TapLogger.Debug("RunClientBridgeMethodWithTimeout invoke  TapSDK_RestartAppIfNecessary result = " + needQuitGame);
+                    TapLogger.Debug("RunClientBridgeMethodWithTimeout invoke  TapSDK_RestartAppIfNecessary finished " );
+                    if (needQuitGame)
+                    {
+                        tapInitResult = new TapInitResult(needQuitGame);
+                    }
+                    else
+                    {
+                        string outputError;
+                        TapSDKInitResult tapSDKInitResult = TapClientBridge.CheckInitState(out outputError, pubKey);
+                        TapLogger.Debug("RunClientBridgeMethodWithTimeout invoke  CheckInitState result = " + tapSDKInitResult + ", error = " + outputError);
+                        tapInitResult = new TapInitResult(tapSDKInitResult, outputError);
+                    }
+                    return tapInitResult;
+                }, TimeSpan.FromSeconds(5));
+                task.TrySetResult(tapInitResult);
+
+            }
+            catch (TimeoutException ex)
+            {
+                TapLogger.Debug("RunClientBridgeMethodWithTimeout invoke  CheckInitState 方法执行超时！");
+                task.TrySetException(ex);
+            }
+            catch (Exception ex)
+            {
+                TapLogger.Debug("RunClientBridgeMethodWithTimeout invoke C 方法出错！" + ex.Message);
+                task.TrySetException(ex);
+            }
+            return await task.Task;
+        }
+
+        /// <summary>
+        /// 在 IO 线程执行 C 方法，超时 5 秒后切回主线程
+        /// </summary>
+        private static async Task<T> ExecuteWithTimeoutAsync<T>(Func<T> cMethod, TimeSpan timeout)
+        {
+            using (var cts = new CancellationTokenSource())
+            {
+                Task<T> ioTask = Task.Run(cMethod); // 在后台线程执行 C 方法
+                Task delayTask = Task.Delay(timeout); // 超时任务
+
+                Task completedTask = await Task.WhenAny(ioTask, delayTask);
+
+                if (completedTask == delayTask)
+                {
+                    cts.Cancel(); // 取消 C 方法任务
+                    throw new TimeoutException("C 方法执行超时！");
+                }
+                else
+                {
+                    cts.Cancel();
+                    return await ioTask;
+                }
+            }
+        }
+
+        /// <summary>
+        /// 是否需要从启动器登录
+        /// </summary>
+        public static bool IsNeedLoginByTapClient()
+        {
+            return isChannelPackage;
+        }
+
+
+        private static Action<bool, string> currentLoginCallback;
+
+        /// <summary>
+        /// 发起登录授权
+        /// </summary>
+        public static bool StartLoginWithScopes(string[] scopes, string responseType, string redirectUri,
+    string codeChallenge, string state, string codeChallengeMethod, string versonCode, string sdkUa, string info, Action<bool, string> callback)
+        {
+            if (lastIsLaunchedFromTapTapPCResult == -1)
+            {
+                // UIManager.Instance.OpenToast("IsLaunchedFromTapTapPC 正在执行，请在完成后调用授权接口", UIManager.GeneralToastLevel.Error);
+                TapLogger.Error(" login must be invoked after IsLaunchedFromTapTapPC success");
+                throw new Exception("login must be invoked after IsLaunchedFromTapTapPC success");
+            }
+            TapLogger.Debug("LoginWithScopes start login by tapclient thread = " + Thread.CurrentThread.ManagedThreadId);
+            try
+            {
+                TapClientBridge.RegisterCallback(TapEventID.AuthorizeFinished, loginCallbackDelegate);
+                AuthorizeResult authorizeResult = TapClientBridge.LoginWithScopes(scopes, responseType, redirectUri,
+     codeChallenge, state, codeChallengeMethod, versonCode, sdkUa, info);
+                TapLogger.Debug("LoginWithScopes start result = " + authorizeResult);
+                if (authorizeResult != AuthorizeResult.OK)
+                {
+                    TapClientBridge.UnRegisterCallback(TapEventID.AuthorizeFinished,loginCallbackDelegate);
+                    return false;
+                }
+                else
+                {
+                    currentLoginCallback = callback;
+                    return true;
+                }
+
+            }
+            catch (Exception ex)
+            {
+                TapLogger.Debug("LoginWithScopes start login by tapclient error = " + ex.Message);
+                TapClientBridge.UnRegisterCallback(TapEventID.AuthorizeFinished,loginCallbackDelegate);
+                return false;
+            }
+
+        }
+
+
+        [AOT.MonoPInvokeCallback(typeof(TapClientBridge.CallbackDelegate))]
+        static void loginCallbackDelegate(int id, IntPtr userData)
+        {
+            TapLogger.Debug("LoginWithScopes recevie callback " + id);
+            if (id == (int)TapEventID.AuthorizeFinished)
+            {
+                TapLogger.Debug("LoginWithScopes callback thread = " + Thread.CurrentThread.ManagedThreadId);
+                TapClientBridge.AuthorizeFinishedResponse response = Marshal.PtrToStructure<TapClientBridge.AuthorizeFinishedResponse>(userData);
+                TapLogger.Debug("LoginWithScopes callback = " + response.is_cancel + " uri = " + response.callback_uri);
+                if (currentLoginCallback != null)
+                {
+                    currentLoginCallback(response.is_cancel != 0, response.callback_uri);
+                    TapClientBridge.UnRegisterCallback(TapEventID.AuthorizeFinished,loginCallbackDelegate);
+                    currentLoginCallback = null;
+                }
+            }
+        }
+
+        // 初始化校验结果
+        private class TapInitResult
+        {
+            internal TapSDKInitResult result;
+            internal string errorMsg;
+
+            internal bool needQuitGame = false;
+
+            public TapInitResult(TapSDKInitResult result, string errorMsg)
+            {
+                this.result = result;
+                this.errorMsg = errorMsg;
+            }
+
+            public TapInitResult(bool needQuitGame)
+            {
+                this.needQuitGame = needQuitGame;
+            }
+        }
+    }
+#endif
+}

package/Standalone/Runtime/Public/TapClientStandalone.cs.meta

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