com.xd.sdk.tap 0.0.6-xd.1

package/Runtime/Internal/TapComplianceHelper.cs

@@ -0,0 +1,174 @@
+using System;
+using System.Collections.Generic;
+using System.Threading.Tasks;
+using TapSDK.Compliance;
+using TapSDK.Compliance.Model;
+using TapSDK.Core.Internal.Log;
+
+#if UNITY_EDITOR || UNITY_STANDALONE
+using AliyunTrack = XD.SDK.Account.Internal.Standalone.AliyunTrack;
+using XD.SDK.Account.Internal.Standalone;
+using XD.SDK.Common.Internal.Standalone;
+#endif
+
+namespace XD.SDK.Tap.Internal
+{
+    public class TapComplianceHelper
+    {
+        private static TapComplianceHelper _instance;
+        private static readonly object LockObj = new object();
+
+        public static TapComplianceHelper Instance
+        {
+            get
+            {
+                if (_instance == null)
+                {
+                    lock (LockObj)
+                    {
+                        if (_instance == null)
+                        {
+                            _instance = new TapComplianceHelper();
+                        }
+                    }
+                }
+
+                return _instance;
+            }
+        }
+
+        private bool callbackRegistered;
+        private Action<Dictionary<string, object>> loginProcessComplianceResult;
+
+        private void StartUp(bool bGlobal, string unionId, Action<Dictionary<string, object>> callback)
+        {
+            EnsureCallbackRegistered();
+            loginProcessComplianceResult = callback;
+            if (bGlobal)
+            {
+                var quick = new Dictionary<string, object>
+                {
+                    { "success", true },
+                    { "code", StartUpResult.LOGIN_SUCCESS },
+                    { "reason", "success" },
+                    { "extras", string.Empty }
+                };
+                loginProcessComplianceResult?.Invoke(quick);
+                loginProcessComplianceResult = null;
+                return;
+            }
+
+            TapTapCompliance.Startup(unionId);
+        }
+
+        public async Task<Dictionary<string, object>> StartUp(bool bGlobal, string unionId)
+        {
+            var tcs = new TaskCompletionSource<Dictionary<string, object>>();
+            StartUp(bGlobal, unionId, result => { tcs.TrySetResult(result); });
+            return await tcs.Task;
+        }
+
+        public void RegisterComplianceCallback(bool bGlobal)
+        {
+            if (bGlobal)
+            {
+                return;
+            }
+
+            EnsureCallbackRegistered();
+        }
+
+        public void Exit(bool bGlobal)
+        {
+            if (bGlobal)
+            {
+                return;
+            }
+
+            TapTapCompliance.Exit();
+            loginProcessComplianceResult = null;
+        }
+
+        private void EnsureCallbackRegistered()
+        {
+            if (callbackRegistered) return;
+
+            try
+            {
+                TapTapCompliance.RegisterComplianceCallback(OnComplianceResult);
+                callbackRegistered = true;
+                TapLog.Log("[TapCompliance] Callback registered");
+            }
+            catch (Exception ex)
+            {
+                TapLog.Error($"[TapCompliance] Register callback failed: {ex.Message}");
+            }
+        }
+
+        private void OnComplianceResult(int code, string message)
+        {
+#if UNITY_EDITOR || UNITY_STANDALONE
+            TapLog.Log($"[TapCompliance] Result: code={code}, message={message}");
+            switch (code)
+            {
+                case StartUpResult.LOGIN_SUCCESS:
+                    SendLoginProcessComplianceResult(code, "success", message);
+                    break;
+                case StartUpResult.EXITED:
+                    if (loginProcessComplianceResult == null)
+                    {
+                        AccountFeaturesImpl.Instance.InternalLogout("COMPLIANCE_EXIT", true);
+                    }
+                    else
+                    {
+                        SendLoginProcessComplianceResult(code, "exited", message);
+                    }
+                    break;
+                case StartUpResult.SWITCH_ACCOUNT:
+                    if (loginProcessComplianceResult == null)
+                    {
+                        AccountFeaturesImpl.Instance.InternalLogout("SWITCH_ACCOUNT", true);
+                    }
+                    else
+                    {
+                        SendLoginProcessComplianceResult(code, "switch_account", message);
+                    }
+                    break;
+                case StartUpResult.REAL_NAME_STOP:
+                    SendLoginProcessComplianceResult(code, "real_name_stop", message);
+                    break;
+                case StartUpResult.INVALID_CLIENT_OR_NETWORK_ERROR:
+                    SendLoginProcessComplianceResult(code, "invalid_client_or_network_error", message);
+                    break;
+                case StartUpResult.AGE_LIMIT:
+                    var conf = new Dictionary<string, object>
+                    {
+                        { ConfirmDialog.TITLE_KEY, ConfigModule.Anti.AgeLimitTitle },
+                        { ConfirmDialog.CONTENT_KEY, ConfigModule.Anti.AgeLimitContent },
+                        { ConfirmDialog.CONFIRM_TEXT_KEY, ConfigModule.Anti.AgeLimitConfirm }
+                    };
+                    UIManager.ShowUI<ConfirmDialog>(conf, (c, data) =>
+                    {
+                        UIManager.Dismiss();
+                        SendLoginProcessComplianceResult(code, "age_limit", message);
+                    });
+                    break;
+            }
+#endif
+        }
+
+        private void SendLoginProcessComplianceResult(int code, string reason, string message)
+        {
+#if UNITY_EDITOR || UNITY_STANDALONE
+            loginProcessComplianceResult?.Invoke(new Dictionary<string, object>()
+            {
+                { "success", code == StartUpResult.LOGIN_SUCCESS },
+                { "code", code },
+                { "extras", message }
+            });
+            loginProcessComplianceResult = null;
+            AliyunTrack.LoginAntiAddictionResult(code, reason, message);
+#endif
+        }
+    }
+}

package/Runtime/Internal/TapComplianceHelper.cs.meta

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

package/Runtime/Internal/TapConvertExtension.cs

@@ -0,0 +1,44 @@
+using TapSDK.Core;
+
+namespace XD.SDK.Tap.Internal
+{
+    public static class LanguageTypeExtension
+    {
+        public static TapTapLanguageType ConvertToTapLanguage(this string languageType)
+        {
+            switch (languageType)
+            {
+                case @"zh_CN":
+                    return TapTapLanguageType.zh_Hans;
+                case @"zh_TW":
+                    return TapTapLanguageType.zh_Hant;
+                case @"en_US":
+                    return TapTapLanguageType.en;
+                case @"th_TH":
+                    return TapTapLanguageType.th;
+                case @"in_ID":
+                    return TapTapLanguageType.id;
+                case @"ko_KR":
+                    return TapTapLanguageType.ko;
+                case @"ja_JP":
+                    return TapTapLanguageType.ja;
+                case @"de_DE":
+                    return TapTapLanguageType.de;
+                case @"fr_FR":
+                    return TapTapLanguageType.fr;
+                case @"pt_PT":
+                    return TapTapLanguageType.pt;
+                case @"es_ES":
+                    return TapTapLanguageType.es;
+                case @"tr_TR":
+                    return TapTapLanguageType.tr;
+                case @"ru_RU":
+                    return TapTapLanguageType.ru;
+                case @"vi_VN":
+                    return TapTapLanguageType.vi;
+                default:
+                    return TapTapLanguageType.Auto;
+            }
+        }
+    }
+}

package/Runtime/Internal/TapConvertExtension.cs.meta

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

package/Runtime/Internal/TapLicenseFuncProxy.cs

@@ -0,0 +1,54 @@
+#if !UNITY_IOS && !UNITY_STANDALONE_OSX
+using System;
+using System.Collections.Generic;
+using TapSDK.License;
+
+namespace XD.SDK.Tap.Internal
+{
+    public class TapLicenseFuncProxy
+    {
+        public class TapLicenseProxy : ITapLicenseCallback
+        {
+            private readonly Action<bool> action;
+
+            public TapLicenseProxy(Action<bool> callback)
+            {
+                action = callback;
+            }
+
+            public void OnLicenseSuccess()
+            {
+                action.Invoke(true);
+            }
+
+            public void OnLicenseFailed()
+            {
+                action.Invoke(false);
+            }
+        }
+
+        public class TapDLCProxy : ITapDlcCallback
+        {
+            private readonly Action<int, Dictionary<string, object>> queryAction;
+
+            private readonly Action<string, TapLicensePurchasedCode> orderAction;
+
+            public TapDLCProxy(Action<int, Dictionary<string, object>> queryAction, Action<string, TapLicensePurchasedCode> orderAction)
+            {
+                this.queryAction = queryAction;
+                this.orderAction = orderAction;
+            }
+
+            public void OnQueryCallBack(TapLicenseQueryCode code, Dictionary<string, object> queryList)
+            {
+                queryAction?.Invoke((int)code, queryList);
+            }
+
+            public void OnOrderCallBack(string sku, TapLicensePurchasedCode status)
+            {
+                orderAction?.Invoke(sku, status);
+            }
+        }
+    }
+}
+#endif

package/Runtime/Internal/TapLicenseFuncProxy.cs.meta

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

package/Runtime/Internal.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 84e5df8b7427494ea4381e55b5e0f973
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Runtime/Public/TapSDKEventHandler.cs

@@ -0,0 +1,235 @@
+using System;
+using System.Collections.Generic;
+using Newtonsoft.Json;
+using TapSDK.Compliance;
+using TapSDK.Core;
+#if !UNITY_IOS && ! UNITY_STANDALONE_OSX
+using TapSDK.License;
+using TapSDK.Review;
+using TapSDK.Update;
+#endif
+using TapSDK.Login;
+using TapSDK.Moment;
+using UnityEngine;
+using UnityEngine.Scripting;
+using XD.SDK.Common.Internal.Events;
+
+#if UNITY_EDITOR || UNITY_STANDALONE
+using XD.SDK.Common.Internal.Standalone;
+#endif
+
+[assembly: Preserve]
+[assembly: AlwaysLinkAssembly]
+
+namespace XD.SDK.Tap.Internal
+{
+    public static class TapSDKEventHandler
+    {
+        [RuntimeInitializeOnLoadMethod(RuntimeInitializeLoadType.BeforeSceneLoad)]
+        static void RegisterEventHandlers()
+        {
+            RegisterTapCore();
+            RegisterTapLogin();
+            RegisterTapDB();
+            RegisterTapCompliance();
+        }
+
+        static void RegisterTapCore()
+        {
+#if UNITY_EDITOR || UNITY_STANDALONE
+            // 同步事件处理
+            XDGEventBus.Subscribe(XDGEvents.TapSDKInit, args =>
+            {
+                var clientId = (string)args[0];
+                var clientToken = (string)args[1];
+                var language = (string)args[2];
+                var bGlobal = (bool)args[3];
+                var enableLog = (bool)args[4];
+                var bDB = (bool)args[5];
+                var channel = (string)args[6];
+
+                var antiConfig = (AntiConfig)args[7];
+
+                var options = new TapTapSdkOptions
+                {
+                    clientId = clientId,
+                    clientToken = clientToken,
+                    preferredLanguage = language.ConvertToTapLanguage(),
+                    region = bGlobal ? TapTapRegionType.Overseas : TapTapRegionType.CN,
+                    //TODO  Debug 来判断
+                    enableLog = enableLog
+                };
+
+                var baseOptions = new TapTapSdkBaseOptions[3];
+
+                if (!bGlobal && antiConfig.Enabled)
+                {
+                    var complianceOption = new TapTapComplianceOption()
+                    {
+                        useAgeRange = antiConfig.UseAgeRange,
+                        showSwitchAccount = antiConfig.ShowSwitchAccount
+                    };
+                    baseOptions[0] = complianceOption;
+                }
+
+                if (bDB)
+                {
+                    var tapDBOption = new TapTapEventOptions()
+                    {
+                        channel = channel
+                    };
+                    baseOptions[1] = tapDBOption;
+                }
+
+                //TODO 埋点，4.x 内部判断了是否需要从 Tap 启动器启动
+                TapTapSDK.Init(options, baseOptions);
+
+                if (enableLog)
+                {
+                    TapLogger.LogDelegate = (level, s) =>
+                    {
+                        switch (level)
+                        {
+                            case TapLogLevel.Debug:
+                                Debug.Log(s);
+                                break;
+                            case TapLogLevel.Warn:
+                                Debug.LogWarning(s);
+                                break;
+                            case TapLogLevel.Error:
+                                Debug.LogError(s);
+                                break;
+                        }
+                    };
+                }
+            });
+#endif
+        }
+
+        static void RegisterTapLogin()
+        {
+            XDGEventBus.SubscribeAsync(XDGEvents.TapSDKLogin, async args =>
+            {
+                var scopes = (List<string>)args[0];
+                var task = await TapTapLogin.Instance.LoginWithScopes(scopes.ToArray());
+                if (task?.accessToken == null)
+                    return null;
+
+                var accessTokenDic = new Dictionary<string, object>()
+                {
+                    { "token", task.accessToken.kid },
+                    { "secret", task.accessToken.macKey }
+                };
+                return accessTokenDic;
+            });
+
+            // 异步事件处理
+            XDGEventBus.SubscribeAsync(XDGEvents.TapSDKGetAccessToken, async _ =>
+            {
+                var task = await TapTapLogin.Instance.GetCurrentTapAccount();
+                if (task?.accessToken == null)
+                    return null;
+
+                var accessTokenDic = new Dictionary<string, object>()
+                {
+                    { "token", task.accessToken.ToDict() },
+                    { "secret", task.accessToken.macKey }
+                };
+                return accessTokenDic;
+            });
+
+            XDGEventBus.Subscribe(XDGEvents.TapSDKLogout, _ =>
+            {
+                TapTapLogin.Instance.Logout();
+                TapTapEvent.ClearUser();
+            });
+        }
+
+        static void RegisterTapDB()
+        {
+            XDGEventBus.Subscribe(XDGEvents.TapSDKSetUserID, args =>
+            {
+                var userId = (string)args[0];
+                TapTapEvent.SetUserID(userId);
+            });
+
+            XDGEventBus.Subscribe(XDGEvents.TapSDKGetDeviceID, args => TapTapEvent.GetDeviceId());
+
+            XDGEventBus.Subscribe(XDGEvents.TapSDKTrackRole, args =>
+            {
+                var bTrack = (bool)args[0];
+                var roleInfo = (string)args[1];
+                var roleDictionary = JsonConvert.DeserializeObject<Dictionary<string, object>>(roleInfo);
+                if (bTrack)
+                {
+                    var roleId = SafeDictionary.GetValue<string>(roleDictionary, "roleId");
+                    if (!string.IsNullOrEmpty(roleId))
+                    {
+                        TapTapEvent.SetUserID(roleId);
+                    }
+                }
+
+                var serverId = SafeDictionary.GetValue(roleDictionary, "serverId", "");
+                var roleName = SafeDictionary.GetValue(roleDictionary, "roleName", "");
+                var roleLevel = SafeDictionary.GetValue<int>(roleDictionary, "roleLevel");
+                var userInitEvent = new Dictionary<string, object>()
+                {
+                    { "first_server", serverId }
+                };
+                TapTapEvent.UserInitialize(JsonConvert.SerializeObject(userInitEvent));
+
+                var userUpdateEvent = new Dictionary<string, object>
+                {
+                    { "current_server", serverId },
+                    { "user_name", roleName },
+                    { "level", roleLevel }
+                };
+                TapTapEvent.UserUpdate(JsonConvert.SerializeObject(userUpdateEvent));
+            });
+
+            XDGEventBus.Subscribe(XDGEvents.TapSDKTrackEvent, args =>
+            {
+                var eventName = (string)args[0];
+                var eventMaps = (string)args[1];
+                TapTapEvent.LogEvent(eventName, eventMaps);
+            });
+        }
+
+        static void RegisterTapCompliance()
+        {
+            XDGEventBus.SubscribeAsync(XDGEvents.TapSDKComplianceStartup, async args =>
+            {
+                var bGlobal = (bool)args[0];
+                var unionId = (string)args[1];
+
+                return await TapComplianceHelper.Instance.StartUp(bGlobal, unionId);
+            });
+
+            XDGEventBus.Subscribe(XDGEvents.TapSDKRegisterComplianceCallback, args =>
+            {
+                var bGlobal = (bool)args[0];
+                TapComplianceHelper.Instance.RegisterComplianceCallback(bGlobal);
+            });
+
+            XDGEventBus.Subscribe(XDGEvents.TapSDKComplianceExit, args =>
+            {
+                try
+                {
+                    bool bGlobal = false;
+                    if (args != null && args.Length > 0 && args[0] is bool)
+                    {
+                        bGlobal = (bool)args[0];
+                    }
+
+                    TapComplianceHelper.Instance.Exit(bGlobal);
+                }
+                catch (Exception e)
+                {
+                    Debug.LogError($"TapSDKComplianceExit handler error: {e.Message}");
+                }
+
+                return null;
+            });
+        }
+    }
+}

package/Runtime/Public/TapSDKEventHandler.cs.meta

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

package/Runtime/Public/XDGTapSDK.cs

@@ -0,0 +1,102 @@
+using System;
+using TapSDK.License;
+using TapSDK.Moment;
+using TapSDK.Review;
+using TapSDK.Update;
+
+namespace XD.SDK.Tap
+{
+    public static class XDGTapSDK
+    {
+        #region TapMoment
+
+        public static void SetMomentCallback(Action<int, string> callback)
+        {
+            TapTapMoment.SetCallback(callback);
+        }
+
+        public static void MomentOpen()
+        {
+            TapTapMoment.open();
+        }
+
+        public static void MomentOpenScene(string sceneId)
+        {
+            TapTapMoment.OpenScene(sceneId);
+        }
+
+        public static void MomentFetchNotification()
+        {
+            TapTapMoment.FetchNotification();
+        }
+
+        public static void MomentClose(string title, string content)
+        {
+            TapTapMoment.CloseWithTitle(title, content);
+        }
+
+        public static void MomentClose()
+        {
+            TapTapMoment.Close();
+        }
+
+        public static void MomentPublish(PublishMetaData metaData)
+        {
+            TapTapMoment.Publish(metaData);
+        }
+
+        #endregion
+
+        #region TapTapLicense
+
+        public static void RegisterLicenseCallback(ITapLicenseCallback callback)
+        {
+            TapTapLicense.RegisterLicenseCallBack(callback);
+        }
+
+        public static void RegisterDLCCallback(ITapDlcCallback callback)
+        {
+            TapTapLicense.RegisterDLCCallback(callback);
+        }
+
+        public static void CheckLicense(bool force = false)
+        {
+            TapTapLicense.CheckLicense(force);
+        }
+
+        public static void QueryDLC(string[] dlcList)
+        {
+            TapTapLicense.QueryDLC(dlcList);
+        }
+
+        public static void PurchaseDLC(string dlc)
+        {
+            TapTapLicense.PurchaseDLC(dlc);
+        }
+
+        #endregion
+
+        #region TapReview
+
+        public static void OpenReview()
+        {
+            TapTapReview.OpenReview();
+        }
+
+        #endregion
+
+        #region TapUpdate
+
+        public static void UpdateGame(Action action)
+        {
+            TapTapUpdate.UpdateGame(action);
+        }
+
+        public static void CheckForceUpdate()
+        {
+            TapTapUpdate.CheckForceUpdate();
+        }
+
+        #endregion
+    }
+}

package/Runtime/Public/XDGTapSDK.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 19a09f46128c4e26980495d6ed29a28a
+timeCreated: 1752119429

package/Runtime/Public.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 17b9a40d51a640f88580a441972b7e48
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: