com.xd.sdk.account 0.0.1 → 0.0.11-alpha

package/Plugins/iOS/XDAccountSDK.framework/Headers.meta

@@ -1,5 +1,5 @@
 fileFormatVersion: 2
-guid: 3ac66aa6bd48f49b0b20e06dae06f827
+guid: faced476f9674d77b29f163ebfae261d
 folderAsset: yes
 DefaultImporter:
   externalObjects: {}

package/Plugins/iOS/XDAccountSDK.framework/Info.plist.meta

@@ -1,5 +1,5 @@
 fileFormatVersion: 2
-guid: 6a13a2439550e455ab66910eca8a2d09
+guid: 702a082eaf49473f85fa383b6986d915
 DefaultImporter:
   externalObjects: {}
   userData: 

package/Plugins/iOS/XDAccountSDK.framework/Modules/XDAccountSDK.swiftmodule/Project/arm64-apple-ios.swiftsourceinfo.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: e9d7db59294d4cc5b203f0bd29ebb026
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/{Mobile/Http.meta → Plugins/iOS/XDAccountSDK.framework/Modules/XDAccountSDK.swiftmodule/Project.meta}

@@ -1,5 +1,5 @@
 fileFormatVersion: 2
-guid: 5e058405fc5734ba4849a3614da3a161
+guid: d5481a5f1dbe4801aa2b6a6f46f80cad
 folderAsset: yes
 DefaultImporter:
   externalObjects: {}

package/Plugins/iOS/XDAccountSDK.framework/Modules/XDAccountSDK.swiftmodule/arm64-apple-ios.abi.json

@@ -0,0 +1,9 @@
+{
+  "ABIRoot": {
+    "kind": "Root",
+    "name": "NO_MODULE",
+    "printedName": "NO_MODULE",
+    "json_format_version": 8
+  },
+  "ConstValues": []
+}

package/Plugins/iOS/XDAccountSDK.framework/Modules/XDAccountSDK.swiftmodule/arm64-apple-ios.abi.json.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: 5dce830275654b078b58aafbd4107e92
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Plugins/iOS/XDAccountSDK.framework/Modules/XDAccountSDK.swiftmodule/arm64-apple-ios.swiftdoc.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: 4a3d4889ca6f4d3da31537380b0382a6
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Plugins/iOS/XDAccountSDK.framework/Modules/XDAccountSDK.swiftmodule/arm64-apple-ios.swiftmodule.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: 116a07f7d0814985a802d7735ca9aa26
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/{Mobile/Editor.meta → Plugins/iOS/XDAccountSDK.framework/Modules/XDAccountSDK.swiftmodule.meta}

@@ -1,5 +1,5 @@
 fileFormatVersion: 2
-guid: ae4b4cc27e35c4030a2c713e217de54e
+guid: d5254b7b95c64299bbc72599ce285d65
 folderAsset: yes
 DefaultImporter:
   externalObjects: {}

package/Plugins/iOS/XDAccountSDK.framework/Modules/module.modulemap.meta

@@ -1,5 +1,5 @@
 fileFormatVersion: 2
-guid: a120d2dcbb0d74178a545ca273bb0ba2
+guid: c1add893ff47489083a1546cc46c018f
 DefaultImporter:
   externalObjects: {}
   userData: 

package/Plugins/iOS/XDAccountSDK.framework/Modules.meta

@@ -1,5 +1,5 @@
 fileFormatVersion: 2
-guid: 3ccc53369a2174f6da6eeb79c7b27991
+guid: c50db11fe03b41df9c3dd4144151b3f2
 folderAsset: yes
 DefaultImporter:
   externalObjects: {}

package/Plugins/iOS/XDAccountSDK.framework/XDAccountSDK.meta

@@ -1,5 +1,5 @@
 fileFormatVersion: 2
-guid: cf552a32a65a84937bc2319a694ee867
+guid: e1b38850fcea4d168e30f9f6e52b8e82
 DefaultImporter:
   externalObjects: {}
   userData: 

package/Plugins/iOS/XDAccountSDK.framework.meta

@@ -1,6 +1,5 @@
 fileFormatVersion: 2
-guid: aa2c9c4a67fa44bc1862ebd1f8c700c4
-folderAsset: yes
+guid: 09e48b6e2e314ff5b645259afc9bedec
 PluginImporter:
   externalObjects: {}
   serializedVersion: 2
@@ -8,21 +7,75 @@ PluginImporter:
   executionOrder: {}
   defineConstraints: []
   isPreloaded: 0
-  isOverridable: 0
+  isOverridable: 1
   isExplicitlyReferenced: 0
   validateReferences: 1
   platformData:
+  - first:
+      : Any
+    second:
+      enabled: 0
+      settings:
+        Exclude Android: 1
+        Exclude Editor: 1
+        Exclude Linux64: 1
+        Exclude OSXUniversal: 1
+        Exclude WebGL: 1
+        Exclude Win: 1
+        Exclude Win64: 1
+        Exclude iOS: 0
+  - first:
+      Android: Android
+    second:
+      enabled: 0
+      settings:
+        CPU: ARMv7
   - first:
       Any: 
     second:
-      enabled: 1
+      enabled: 0
       settings: {}
   - first:
       Editor: Editor
     second:
       enabled: 0
       settings:
+        CPU: AnyCPU
         DefaultValueInitialized: true
+        OS: AnyOS
+  - first:
+      Standalone: Linux64
+    second:
+      enabled: 0
+      settings:
+        CPU: None
+  - first:
+      Standalone: OSXUniversal
+    second:
+      enabled: 0
+      settings:
+        CPU: None
+  - first:
+      Standalone: Win
+    second:
+      enabled: 0
+      settings:
+        CPU: None
+  - first:
+      Standalone: Win64
+    second:
+      enabled: 0
+      settings:
+        CPU: None
+  - first:
+      iPhone: iOS
+    second:
+      enabled: 1
+      settings:
+        AddToEmbeddedBinaries: true
+        CPU: AnyCPU
+        CompileFlags: 
+        FrameworkDependencies: 
   userData: 
   assetBundleName: 
   assetBundleVariant: 

package/Plugins/iOS.meta

@@ -1,5 +1,5 @@
 fileFormatVersion: 2
-guid: 726d804c3a8864751833ecaddfcca99d
+guid: 282408b166f4485f9b87cffde0ecd5da
 folderAsset: yes
 DefaultImporter:
   externalObjects: {}

package/Plugins.meta

@@ -1,5 +1,5 @@
 fileFormatVersion: 2
-guid: 9feaa06939a844b66b6abc373c121767
+guid: 88231a3562444bf29a33c3cc0ed69efb
 folderAsset: yes
 DefaultImporter:
   externalObjects: {}

package/Runtime/Internal/IXDGAccount.Extended.cs

@@ -0,0 +1,11 @@
+using System.Collections.Generic;
+using System.Net.Http;
+using System.Threading.Tasks;
+
+namespace XD.SDK.Account
+{
+    interface IXDGAccountExtended : IXDGAccount
+    {
+        Task<Dictionary<string, string>> GetRequestAuthorizationHeader(HttpRequestMessage request, long timestamp);
+    }
+}

package/{Mobile/Http/XDGAccountHttpConfigMobile.cs.meta → Runtime/Internal/IXDGAccount.Extended.cs.meta}

@@ -1,5 +1,5 @@
 fileFormatVersion: 2
-guid: ff0780c8218434a908fe4b7e3097cb2d
+guid: 0f24cc2d20a54204a089811a5abb3220
 MonoImporter:
   externalObjects: {}
   serializedVersion: 2

package/Runtime/Internal/Mobile/AccountFeaturesImpl.cs

@@ -0,0 +1,341 @@
+#if UNITY_ANDROID || UNITY_IOS
+using System;
+using System.Collections.Generic;
+using System.Net.Http;
+using System.Runtime.InteropServices;
+using System.Threading.Tasks;
+using Newtonsoft.Json;
+using UnityEngine;
+using XD.SDK.Account.Internal.Http;
+using XD.SDK.Common;
+using XD.SDK.Common.Internal;
+using XD.SDK.Common.Internal.Events;
+using XD.SDK.Common.Internal.Http;
+using XD.SDK.Common.Internal.Mobile;
+using XD.SDK.Common.Internal.Mobile.Bridge;
+
+namespace XD.SDK.Account.Internal.Mobile
+{
+    public class AccountFeaturesImpl : IXDGAccountExtended
+    {
+        private static AccountFeaturesImpl _instance;
+
+        private static readonly object LockObj = new object();
+
+        private const string LoginSynUrl = "/api/login/v1/syn";
+
+        private readonly Lazy<IHttpClient> defaultClient = new Lazy<IHttpClient>(() =>
+            XDHttpClientFactory.GetClient(nameof(AccountFeaturesImpl),
+                () =>
+                {
+                    return XDHttpClientFactory.CreateClient(XDGHost.CreateBaseHost(XDGCommonInternal.IsCn()), builder =>
+                    {
+                        builder
+                            .Timeout(TimeSpan.FromSeconds(10))
+                            .WithLogging()
+                            .AddInterceptor(new CommonParamsInterceptor())
+                            .AddInterceptor(new UrlBuildInterceptor())
+                            .AddInterceptor(new MacAuthenticationInterceptor())
+                            .Build();
+                    });
+                })
+        );
+
+        private IHttpClient HttpClient => defaultClient.Value;
+
+        public static AccountFeaturesImpl Instance
+        {
+            get
+            {
+                if (_instance == null)
+                {
+                    lock (LockObj)
+                    {
+                        if (_instance == null)
+                        {
+                            _instance = new AccountFeaturesImpl();
+                        }
+                    }
+                }
+
+                return _instance;
+            }
+        }
+
+
+        private AccountFeaturesImpl()
+        {
+            EngineBridge.GetInstance()
+                .Register(BridgeConstants.Account.SERVICE_NAME, BridgeConstants.Account.SERVICE_IMPL);
+        }
+
+        public void AddUserStatusChangeCallback(Action<XDGUserStatusCodeType, string> callback)
+        {
+            var command = new Command.Builder()
+                .Service(BridgeConstants.Account.BRIDGE_NAME)
+                .Method("addUserStatusChangeCallback")
+                .Callback(true)
+                .OnceTime(false)
+                .CommandBuilder();
+            EngineBridge.GetInstance().CallHandler(command, async (result) =>
+            {
+                if (!XDGTool.CheckResultSuccess(result))
+                {
+                    return;
+                }
+
+                var dic = XDGJson.Deserialize(result.content) as Dictionary<string, object>;
+                var code = XDDictionary.GetValue<int>(dic, "code");
+                var message = XDDictionary.GetValue<string>(dic, "message");
+                callback((XDGUserStatusCodeType)code, message);
+            });
+        }
+
+        public void LoginByType(LoginType loginType, Action<XDGUser> callback, Action<XDGError> errorCallback)
+        {
+            var command = new Command.Builder()
+                .Service(BridgeConstants.Account.BRIDGE_NAME)
+                .Method("loginByType")
+                .Args("loginType", loginType.FormatString()) //和app交互用的是字符串，如TapTap 
+                .Callback(true)
+                .OnceTime(true)
+                .CommandBuilder();
+
+            EngineBridge.GetInstance().CallHandler(command, async result =>
+            {
+                var xdgError = result.Parse2XDGError();
+                if (xdgError != null)
+                {
+                    errorCallback(xdgError);
+                    return;
+                }
+
+                var contentDic = XDGJson.Deserialize(result.content) as Dictionary<string, object>;
+                var userDic = XDDictionary.GetValue<Dictionary<string, object>>(contentDic, "user");
+                if (userDic != null)
+                {
+                    var user = new XDGUser(userDic);
+                    await SyncTdsUser(user);
+                    if (loginType == LoginType.Default)
+                    {
+                        RefreshFacebookToken();
+                    }
+                    else if (loginType == LoginType.Facebook)
+                    {
+                        XDGEventBus.Publish(XDGEvents.TdsSDKRefreshFacebookTime);
+                    }
+                    callback(user);
+                    return;
+                }
+
+                errorCallback(new XDGError(ResponseCode.Common.Failed, "user is null"));
+            });
+        }
+
+        public void LoginByConsole(Action<XDGUser> successCallback, Action failCallback, Action<XDGError> errorCallback)
+        {
+            errorCallback(new XDGError(ResponseCode.Common.UnavailableService, "该平台不支持主机登录"));
+            Debug.LogError($"该平台：{Application.platform}不支持主机登录");
+        }
+
+        public void Logout()
+        {
+            var command = new Command.Builder()
+                .Service(BridgeConstants.Account.BRIDGE_NAME)
+                .Method("logout")
+                .Callback(false)
+                .OnceTime(true)
+                .CommandBuilder();
+            EngineBridge.GetInstance().CallHandler(command);
+        }
+
+        public XDGUser GetCurrentUser()
+        {
+            XDGUser resultUser = null;
+            string currentUserString = null;
+#if UNITY_ANDROID
+            using (var accountBridgeClass = new AndroidJavaClass(BridgeConstants.Account.SERVICE_IMPL))
+            {
+                currentUserString = accountBridgeClass.CallStatic<string>("getCurrentUser");
+            }
+#elif UNITY_IOS
+            IntPtr ptr = XDAccountBridgeGetUser();
+            currentUserString = Marshal.PtrToStringAnsi(ptr);
+#endif
+            if (!string.IsNullOrEmpty(currentUserString))
+            {
+                try
+                {
+                    resultUser = new XDGUser(currentUserString);
+                }
+                catch (Exception e)
+                {
+                    XDGLogger.Warn("convert current user error" + e.Message);
+                }
+            }
+
+            return resultUser;
+        }
+
+#if UNITY_IOS
+        [DllImport("__Internal")]
+        private static extern IntPtr XDAccountBridgeGetUser();
+#endif
+
+        public void OpenCustomerService(XDGRoleInfo roleInfo, string path, Dictionary<string, object> paramsMap)
+        {
+            var command = new Command.Builder()
+                .Service(BridgeConstants.Account.BRIDGE_NAME)
+                .Method("openCustomerService")
+                .Args(XDUtility.BridgeArgToDictionary("openCustomerService", roleInfo))
+                .Args("path", path)
+                .Args("params", paramsMap)
+                .Callback(false)
+                .OnceTime(true)
+                .CommandBuilder();
+            EngineBridge.GetInstance().CallHandler(command);
+        }
+
+        public void OpenUserCenter()
+        {
+            var command = new Command.Builder()
+                .Service(BridgeConstants.Account.BRIDGE_NAME)
+                .Method("openUserCenter")
+                .Callback(false)
+                .OnceTime(true)
+                .CommandBuilder();
+            EngineBridge.GetInstance().CallHandler(command);
+        }
+
+        public void OpenUserDashboard(XDGRoleInfo roleInfo)
+        {
+            var command = new Command.Builder()
+                .Service(BridgeConstants.Account.BRIDGE_NAME)
+                .Method("openUserDashboard")
+                .Args(XDUtility.BridgeArgToDictionary("openUserDashboard", roleInfo))
+                .Callback(false)
+                .OnceTime(true)
+                .CommandBuilder();
+            EngineBridge.GetInstance().CallHandler(command);
+        }
+
+        public void OpenAccountDeletion()
+        {
+            var command = new Command.Builder()
+                .Service(BridgeConstants.Account.BRIDGE_NAME)
+                .Method("openAccountDeletion")
+                .Callback(false)
+                .OnceTime(true)
+                .CommandBuilder();
+            EngineBridge.GetInstance().CallHandler(command);
+        }
+
+        public void BindByType(LoginType loginType, Action<bool, XDGError> callback)
+        {
+            var command = new Command.Builder()
+                .Service(BridgeConstants.Account.BRIDGE_NAME)
+                .Method("bindByType")
+                .Args("bindByType", loginType.FormatString())
+                .Callback(true)
+                .OnceTime(true)
+                .CommandBuilder();
+
+            EngineBridge.GetInstance().CallHandler(command, result =>
+            {
+                XDGLogger.Debug("bindByType 方法结果: " + result.ToJson());
+
+                var xdgError = result.Parse2XDGError();
+                if (xdgError != null)
+                {
+                    callback(false, xdgError);
+                    return;
+                }
+
+                var contentDic = XDGJson.Deserialize(result.content) as Dictionary<string, object>;
+                var success = XDDictionary.GetValue<bool>(contentDic, "success");
+
+                callback(success, null);
+            });
+        }
+
+        public async Task<Dictionary<string, string>> GetRequestAuthorizationHeader(HttpRequestMessage request, long timestamp)
+        {
+            var url = request.RequestUri.AbsoluteUri;
+            var method = request.Method.ToString().ToUpper();
+            var authorization = "";
+#if UNITY_ANDROID
+            using (var AccountBridgeClass = new AndroidJavaClass(BridgeConstants.Account.SERVICE_IMPL))
+            {
+                authorization = AccountBridgeClass.CallStatic<string>("getRequestAuthorizationHeaderString", url, method, timestamp);
+            }
+#elif UNITY_IOS
+            IntPtr ptr = XDAccountBridgeGetAuthorization(url, method, timestamp);
+            authorization = Marshal.PtrToStringAnsi(ptr);
+#endif
+            if (string.IsNullOrEmpty(authorization))
+            {
+                return new Dictionary<string, string>();
+            }
+
+            return new Dictionary<string, string>
+            {
+                { "Authorization", authorization }
+            };
+        }
+#if UNITY_IOS
+        [DllImport("__Internal")]
+        private static extern IntPtr XDAccountBridgeGetAuthorization(string url, string method, long timestamp);
+#endif
+
+        private async Task SyncTdsUser(XDGUser user)
+        {
+            try
+            {
+                var result = await XDGEventBus.PublishAsync<Dictionary<string, object>>(XDGEvents.TdsSDKGetUser);
+                var objectId = XDDictionary.GetValue<string>(result, "objectId");
+                if (objectId == user.UserId)
+                {
+                    return;
+                }
+
+                // XDGEventBus.Publish(XDGEvents.TdsSDKLogout);
+                var response = await HttpClient.PostAsync<LoginSyncResponse>(LoginSynUrl);
+                var sessionToken = XDDictionary.GetValue<string>(response.Data, "sessionToken");
+                if (string.IsNullOrEmpty(sessionToken))
+                {
+                    XDGLogger.Warn("[SyncTDSUser] sessionToken is Null!");
+                    return;
+                }
+
+                XDGEventBus.Publish(XDGEvents.TdsSDKSyncUser, sessionToken, user.UserId);
+            }
+            catch (Exception e)
+            {
+                XDGLogger.Warn($"[SyncTDSUser] error:{e.Message}");
+            }
+        }
+
+        private void RefreshFacebookToken()
+        {
+#if UNITY_ANDROID
+            using (var accountBridgeClass = new AndroidJavaClass(BridgeConstants.Account.SERVICE_IMPL))
+            {
+                var fbToken = accountBridgeClass.CallStatic<string>("getFacebookToken");
+                XDGLogger.Debug($"[GetFacebookToken] fbToken:{fbToken}");
+                var tokenDic = JsonConvert.DeserializeObject<Dictionary<string, object>>(fbToken);
+                if (tokenDic.ContainsKey("error"))
+                {
+                    XDGLogger.Warn($"[GetFacebookToken] error:{JsonConvert.SerializeObject(tokenDic)}");
+                    return;
+                }
+
+                var token = XDDictionary.GetValue<string>(tokenDic, "access_token");
+                var userId = XDDictionary.GetValue<string>(tokenDic, "userID");
+                XDGEventBus.Publish(XDGEvents.TdsSDKSyncFacebookToken, token, userId);
+            }
+#endif
+        }
+    }
+}
+
+#endif

package/{Mobile/XDGAccountMobile.cs.meta → Runtime/Internal/Mobile/AccountFeaturesImpl.cs.meta}

@@ -1,5 +1,5 @@
 fileFormatVersion: 2
-guid: 79e93cb99498a4778acc3f608e4f33cb
+guid: 93ae8598973a407abadb408fd6cabdfa
 MonoImporter:
   externalObjects: {}
   serializedVersion: 2

package/Runtime/Internal/Mobile/Http/LoginSyncResponse.cs

@@ -0,0 +1,14 @@
+#if UNITY_IOS || UNITY_ANDROID
+
+using System.Collections.Generic;
+using Newtonsoft.Json;
+using XD.SDK.Common.Internal;
+
+namespace XD.SDK.Account.Internal.Http
+{
+    public class LoginSyncResponse : BaseResponse
+    {
+        [JsonProperty("data")] public Dictionary<string, object> Data;
+    }
+}
+#endif

package/Runtime/Internal/Mobile/Http/LoginSyncResponse.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 2e63b267153141939359668e82217cb0
+timeCreated: 1752580026

package/Runtime/Internal/Mobile/Http/MacAuthenticationInterceptor.cs

@@ -0,0 +1,37 @@
+#if UNITY_IOS || UNITY_ANDROID
+using System.Collections.Generic;
+using System.Net.Http;
+using System.Threading;
+using System.Threading.Tasks;
+using Newtonsoft.Json;
+using XD.SDK.Common;
+using XD.SDK.Common.Internal;
+using XD.SDK.Common.Internal.Http;
+
+namespace XD.SDK.Account.Internal.Mobile
+{
+    public class MacAuthenticationInterceptor : HttpInterceptor
+    {
+        protected override async Task BeforeRequestAsync(IHttpRequest request, CancellationToken cancellationToken)
+        {
+            XDGLogger.Debug($"[MacAuthenticationInterceptor] request Url: {JsonConvert.SerializeObject(request.Url)}");
+            
+            var authDic = await GetMacToken(request.Url, request.Method);
+            var authToken = "";
+            authDic?.TryGetValue("Authorization", out authToken);
+            if (authToken != null && !string.IsNullOrEmpty(authToken))
+            {
+                request.Headers["Authorization"] = authToken;
+            }
+
+            XDGLogger.Debug($"[MacAuthenticationInterceptor] request Headers: {JsonConvert.SerializeObject(request.Headers)}");
+        }
+
+        private static Task<Dictionary<string, string>> GetMacToken(string requestUrl, HttpMethod method)
+        {
+            var httpMessage = new HttpRequestMessage(method, requestUrl);
+            return AccountFeaturesImpl.Instance.GetRequestAuthorizationHeader(httpMessage, ServerTime.GetTimestamp());
+        }
+    }
+}
+#endif

package/Runtime/Internal/Mobile/Http/MacAuthenticationInterceptor.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: ef380eb06e17405cb2fe66d5673693c5
+timeCreated: 1752575768

package/Runtime/Internal/Mobile/Http.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: ac4a3d1fe62b439facb4aebb23a8e77f
+timeCreated: 1752576069

package/{Mobile.meta → Runtime/Internal/Mobile.meta}

@@ -1,5 +1,5 @@
 fileFormatVersion: 2
-guid: a6ccd9a263baa4cb2ba13d6dd4970353
+guid: b0b8b4b67e6a469db1859cb4496e6923
 folderAsset: yes
 DefaultImporter:
   externalObjects: {}