com.xd.sdk.account 6.29.0 → 7.0.0

package/Runtime/Internal/Standalone/LoginModule/Phone/PhoneModuleIO.cs

@@ -0,0 +1,392 @@
+#if UNITY_EDITOR || UNITY_STANDALONE
+using System;
+using System.Collections.Generic;
+using System.Threading.Tasks;
+using UnityEngine;
+using XD.SDK.Common;
+using XD.SDK.Common.Internal;
+using XD.SDK.Common.Internal.Standalone;
+using XDHttpClient = XD.SDK.Common.Internal.Standalone.XDHttpClient;
+
+namespace XD.SDK.Account.Internal.Standalone
+{
+    public static class PhoneModuleIO
+    {
+        
+        private static readonly string XDG_LOGIN_CODE_SEND = "api/login/v1/verification/code/send";
+        private static readonly string XDG_UNBIND_CODE_SEND = "api/account/v1/unbind/verification/code/send";
+
+        public const int RISK_CONTROL = 40024;
+        public const int RISK_CONTROL_FAILED = 40025;
+        public const int INVALID_PHONE_NUMBER_FORMAT = 40022;
+        public const int INVALID_VERIFY_CODE = 40114;
+        public const int LOGIN_REQUEST_FREQUENTLY = 42900;
+
+        internal static readonly Color PhoneUIColor = new Color(255.0f / 255.0f, 102.0f / 255.0f, 0.0f / 255.0f);
+
+        internal static readonly Color PhoneUIDisableColor =
+            new Color(185.0f / 255.0f, 190.0f / 255.0f, 193.0f / 255.0f);
+
+        internal static readonly Color PhoneUIBlackColor = new Color(17.0f / 255.0f, 17.0f / 255.0f, 17.0f / 255.0f);
+
+        private static PhoneAlertIO loginAlert;
+        private static CodeUnbindAlert unbindAlert;
+
+        public static Task LoginOrBind(bool login)
+        {
+            TaskCompletionSource<object> tcs = new TaskCompletionSource<object>();
+            AliyunTrack.LoginAuthorize();
+            if (login)
+            {
+                AliyunTrack.LoginTrackPhoneData();
+            }
+
+            loginAlert = UIManager.ShowUI<PhoneAlertIO>("XDPhoneAlertIO",
+                new Dictionary<string, object>() { { "login", login } }, async (code, data) =>
+                {
+                    switch (code)
+                    {
+                        case PhoneAlertIO.CLOSE_CODE:
+                            UIManager.Dismiss();
+                            AliyunTrack.LoginAuthorizeFail("cancel");
+                            tcs.TrySetException(XDGErrorExtensions.CancelledError());
+                            break;
+                        case PhoneAlertIO.SEND_CODE:
+                        {
+                            try
+                            {
+                                PhoneAlertIO.Data phoneData = data as PhoneAlertIO.Data;
+                                if (phoneData?.phoneNumber.Length != 0)
+                                {
+                                    await RequestLoginVerifyCode(phoneData?.areaCode, phoneData?.phoneNumber);
+                                }
+                                else
+                                {
+                                    loginAlert.UpdatePhoneNumberError(XDLocalization.GetCurrentLocalizableString()
+                                        .PhoneNumberEmpty);
+                                }
+                            }
+                            catch (Exception)
+                            {
+                                UIManager.DismissLoading();
+                            }
+                        }
+                            break;
+                        case PhoneAlertIO.LOGIN_OR_BIND:
+                        {
+                            try
+                            {
+                                PhoneAlertIO.Data phoneData = data as PhoneAlertIO.Data;
+                                if (phoneData?.phoneNumber.Length != 0)
+                                {
+                                    if (phoneData?.code.Length != 0)
+                                    {
+                                        if (login)
+                                        {
+                                            await LoginByPhone(phoneData?.areaCode, phoneData?.phoneNumber,
+                                                phoneData?.code);
+                                        }
+                                        else
+                                        {
+                                            await BindByPhone(phoneData?.areaCode, phoneData?.phoneNumber,
+                                                phoneData?.code);
+                                        }
+
+                                        UIManager.Dismiss();
+                                        tcs.TrySetResult(null);
+                                    }
+                                    else
+                                    {
+                                        loginAlert.UpdateCodeError(XDLocalization.GetCurrentLocalizableString()
+                                            .CodeEmpty);
+                                    }
+                                }
+                                else
+                                {
+                                    loginAlert.UpdatePhoneNumberError(XDLocalization.GetCurrentLocalizableString()
+                                        .PhoneNumberEmpty);
+                                }
+                            }
+                            catch (XDGError e)
+                            {
+                                if (e.Code == INVALID_VERIFY_CODE)
+                                {
+                                    loginAlert.UpdateCodeError(e.ErrorMsg);
+                                }
+                                else if (e.Code == INVALID_PHONE_NUMBER_FORMAT)
+                                {
+                                    loginAlert.UpdatePhoneNumberError(e.ErrorMsg);
+                                }
+                                else
+                                {
+                                    UIManager.ShowToast(e.ErrorMsg);
+                                }
+                            }
+                            catch (Exception e)
+                            {
+                                tcs.TrySetException(e);
+                            }
+                        }
+                            break;
+                    }
+                });
+            return tcs.Task;
+        }
+
+        public static Task Unbind(Dictionary<string, object> extras)
+        {
+            TaskCompletionSource<object> tcs = new TaskCompletionSource<object>();
+
+            unbindAlert = UIManager.ShowUI<CodeUnbindAlert>("XDCodeUnbindAlert", extras, async (code, data) =>
+            {
+                switch (code)
+                {
+                    case CodeUnbindAlert.CLOSE_CODE:
+                        UIManager.Dismiss();
+                        tcs.TrySetException(XDGErrorExtensions.CancelledError());
+                        break;
+                    case CodeUnbindAlert.SEND_CODE:
+                    {
+                        try
+                        {
+                            await RequestUnbindVerifyCode();
+                        }
+                        catch (Exception)
+                        {
+                            UIManager.DismissLoading();
+                        }
+                    }
+                        break;
+                    case CodeUnbindAlert.UNBIND:
+                    {
+                        try
+                        {
+                            CodeUnbindAlert.Data phoneData = data as CodeUnbindAlert.Data;
+                            await UnbindByPhone(phoneData?.code);
+                            UIManager.Dismiss();
+                            tcs.TrySetResult(null);
+                        }
+                        catch (XDGError e)
+                        {
+                            if (e.Code == INVALID_VERIFY_CODE)
+                            {
+                                unbindAlert.UpdateCodeError(e.ErrorMsg);
+                            }
+                            else
+                            {
+                                UIManager.ShowToast(e.ErrorMsg);
+                            }
+                        }
+                        catch (Exception e)
+                        {
+                            tcs.TrySetException(e);
+                        }
+                    }
+                        break;
+                }
+            });
+            return tcs.Task;
+        }
+
+        private static async Task<RequestVerifyCodeData> RequestLoginVerifyCode(string areaCode, string phoneNumber,
+            string riskControlData = null)
+        {
+            Dictionary<string, object> data = new Dictionary<string, object>
+            {
+                { "type", "SMS" },
+                { "areaCode", areaCode }, // 当前版本固定国内
+                { "phoneNumber", phoneNumber }
+            };
+            Dictionary<string, object> headers = null;
+            if (riskControlData != null)
+            {
+                headers = new Dictionary<string, object>()
+                {
+                    { "Risk-Authenticate-Sig", riskControlData }
+                };
+            }
+
+            RequestVerifyCodeData response = null;
+            UIManager.ShowLoading(true);
+            try
+            {
+                loginAlert?.SetSendButtonEnable(false);
+                response = (await XDHttpClient.Client.PostAsync<RequestVerifyCodeResponse>(XDG_LOGIN_CODE_SEND, headers: headers,
+                    data: data))?.Data;
+                loginAlert?.SetSendButtonEnable(true);
+                if (response != null) loginAlert?.UpdateCanResendSeconds(response.ReSendInterval);
+                UIManager.ShowToast(XDLocalization.GetCurrentLocalizableString()?.CodeSendSuccess);
+                AliyunTrack.LoginMobileVerifyCodeSendSuccess();
+            }
+            catch (XDGError e)
+            {
+                loginAlert?.SetSendButtonEnable(true);
+                if (e.Code == RISK_CONTROL || e.Code == RISK_CONTROL_FAILED)
+                {
+                    TaskCompletionSource<RequestVerifyCodeData> tcs = new TaskCompletionSource<RequestVerifyCodeData>();
+
+                    string scene = e.ExtraData["captcha_scene"] as string;
+
+                    async void Callback(string token, XDGError error)
+                    {
+                        if (!string.IsNullOrEmpty(token))
+                        {
+                            try
+                            {
+                                AliyunTrack.TriggerCaptchaSuccess("login_sms");
+                                RequestVerifyCodeData codeData =
+                                    await RequestLoginVerifyCode(areaCode, phoneNumber, token);
+                                tcs.TrySetResult(codeData);
+                            }
+                            catch (XDGError exception)
+                            {
+                                tcs.TrySetException(exception);
+                            }
+                        }
+                        else
+                        {
+                            tcs.TrySetException(error as XDGError ?? throw new InvalidOperationException());
+                        }
+                    }
+
+                    AliyunTrack.TriggerCaptchaStart("login_sms");
+                    XDGCaptcha.ValidateWithCaptcha(scene, new Dictionary<string, string>(){{"eventSessionId", AliyunTrack.LoginEventSessionId}}, Callback);
+                    response = await tcs.Task;
+                }
+                else if (e.Code == INVALID_PHONE_NUMBER_FORMAT)
+                {
+                    loginAlert?.UpdatePhoneNumberError(e.ErrorMsg);
+                }
+                else
+                {
+                    UIManager.ShowToast(e.ErrorMsg);
+                }
+            }
+            catch (Exception)
+            {
+                loginAlert?.SetSendButtonEnable(true);
+                UIManager.DismissLoading();
+                AliyunTrack.LoginMobileVerifyCodeSendFail();
+                throw;
+            }
+
+            UIManager.DismissLoading();
+            return response;
+        }
+
+        private static async Task<RequestVerifyCodeData> RequestUnbindVerifyCode(string riskControlData = null)
+        {
+            Dictionary<string, object> data = new Dictionary<string, object>
+            {
+                { "type", "SMS" }
+            };
+            Dictionary<string, object> headers = null;
+            if (riskControlData != null)
+            {
+                headers = new Dictionary<string, object>()
+                {
+                    { "Risk-Authenticate-Sig", riskControlData }
+                };
+            }
+
+            RequestVerifyCodeData response = null;
+            try
+            {
+                unbindAlert?.SetSendButtonEnable(false);
+                response = (await XDHttpClient.Client.PostAsync<RequestVerifyCodeResponse>(XDG_UNBIND_CODE_SEND, headers: headers,
+                    data: data))?.Data;
+                unbindAlert?.SetSendButtonEnable(true);
+                if (response != null) unbindAlert?.UpdateCanResendSeconds(response.ReSendInterval);
+                UIManager.ShowToast(XDLocalization.GetCurrentLocalizableString()?.CodeSendSuccess);
+            }
+            catch (XDGError e)
+            {
+                unbindAlert?.SetSendButtonEnable(true);
+                if (e.Code == RISK_CONTROL || e.Code == RISK_CONTROL_FAILED)
+                {
+                    TaskCompletionSource<RequestVerifyCodeData> tcs = new TaskCompletionSource<RequestVerifyCodeData>();
+
+                    string scene = e.ExtraData["captcha_scene"] as string;
+
+                    async void Callback(string token, XDGError error)
+                    {
+                        if (!string.IsNullOrEmpty(token))
+                        {
+                            try
+                            {
+                                RequestVerifyCodeData codeData = await RequestUnbindVerifyCode(token);
+                                tcs.TrySetResult(codeData);
+                            }
+                            catch (XDGError exception)
+                            {
+                                tcs.TrySetException(exception);
+                            }
+                        }
+                        else
+                        {
+                            tcs.TrySetException(error as XDGError ?? throw new InvalidOperationException());
+                        }
+                    }
+                    XDGCaptcha.ValidateWithCaptcha(scene, new Dictionary<string, string>(){{"eventSessionId", AliyunTrack.LoginEventSessionId}}, Callback);
+                    response = await tcs.Task;
+                }
+                else
+                {
+                    UIManager.ShowToast(e.ErrorMsg);
+                }
+            }
+            catch (Exception)
+            {
+                loginAlert?.SetSendButtonEnable(true);
+                UIManager.DismissLoading();
+                throw;
+            }
+
+            return response;
+        }
+
+        private static async Task LoginByPhone(string areaCode, string phoneNumber, string code)
+        {
+            Dictionary<string, object> authData = new Dictionary<string, object>
+            {
+                { "type", (int)LoginType.Phone },
+                { "token", $"{areaCode} {phoneNumber}" },
+                { "secret", code },
+                { "subType", "text" }
+            };
+            try
+            {
+                await AccessTokenModule.Login(authData, null);
+                AliyunTrack.LoginMobileVerifyCodePassSuccess();
+            }
+            catch (XDGError e)
+            {
+                AliyunTrack.LoginMobileVerifyCodePassFail(e.ErrorMsg);
+                throw;
+            }
+        }
+
+        private static async Task BindByPhone(string areaCode, string phoneNumber, string code)
+        {
+            Dictionary<string, object> authData = new Dictionary<string, object>
+            {
+                { "type", (int)LoginType.Phone },
+                { "token", $"{areaCode} {phoneNumber}" },
+                { "secret", code },
+                { "subType", "text" }
+            };
+            await XDHttpClient.Client.PostAsync<BaseResponse>(UserModule.XDG_BIND_INTERFACE, data: authData);
+        }
+
+        private static async Task UnbindByPhone(string code)
+        {
+            Dictionary<string, object> data = new Dictionary<string, object>()
+            {
+                { "type", (int)LoginType.Phone },
+                { "verificationCode", code }
+            };
+            await XDHttpClient.Client.PostAsync<BaseResponse>(UserModule.XDG_UNBIND_INTERFACE, data: data);
+        }
+    }
+}
+#endif

package/Runtime/Internal/Standalone/LoginModule/Phone/PhoneModuleIO.cs.meta

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

package/Runtime/Internal/Standalone/LoginModule/Phone.meta

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

package/Runtime/Internal/Standalone/LoginModule.meta

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

package/Runtime/Internal/Standalone/SupportModule/SupportModule.cs

@@ -0,0 +1,228 @@
+#if UNITY_EDITOR || UNITY_STANDALONE
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Threading;
+using System.Threading.Tasks;
+using Newtonsoft.Json;
+using UnityEngine;
+using XD.SDK.Common;
+using XD.SDK.Common.Internal.Standalone;
+
+namespace XD.SDK.Account.Internal.Standalone
+{
+    public class SupportModule
+    {
+        private static SupportModule _instance;
+
+        private static readonly object LockObj = new object();
+
+        private SupportModule()
+        {
+        }
+
+        public static SupportModule Instance
+        {
+            get
+            {
+                if (_instance != null) return _instance;
+                lock (LockObj)
+                {
+                    if (_instance == null)
+                    {
+                        _instance = new SupportModule();
+                    }
+                }
+
+                return _instance;
+            }
+        }
+
+        public void TryStartPolling()
+        {
+            if (!ConfigModule.CustomerDisable)
+            {
+                StartCheckUnRead();
+                return;
+            }
+
+            XDGLogger.Debug("XSupportManager is disabled by config, skipping polling start");
+        }
+
+        private const string XdgSupportUserUnreadCheck = "api/support/v1/user/unread/check";
+
+        private const string XdgSupportAnonymousUnreadCheck = "api/support/v1/user/anonymous/unread/check";
+
+        private const string XdgSupportUserGetURL = "api/support/v1/user/url/get";
+
+        private const string XdgSupportAnonymousGetURL = "api/support/v1/user/anonymous/url/get";
+
+        private int nextCheckUnreadTime = 10;
+
+        private bool bLastHasRead;
+
+        private CancellationTokenSource cts = new CancellationTokenSource();
+
+        public static void OpenCustomerService(XDGRoleInfo roleInfo, string path, Dictionary<string, object> paramsMap)
+        {
+            RequestSupportUrl(roleInfo, path, paramsMap, (success, xd, url) =>
+            {
+                if (!success)
+                {
+                    return;
+                }
+
+                if (xd)
+                {
+                    WebRequest.OpenWebPage(url, (code, data) => { });
+                }
+                else
+                {
+                    UIManager.ShowUI<XDWebViewAlert>("XDWebViewAlert", new Dictionary<string, object>
+                    {
+                        {
+                            "url", url
+                        }
+                    }, (code, data) =>
+                    {
+                        if (code == XDWebViewAlert.CLOSE_CODE)
+                        {
+                            UIManager.Dismiss();
+                        }
+                    });
+                }
+            });
+        }
+
+        private static async void CheckUnRead()
+        {
+            XDGLogger.Debug("Support check unread");
+            try
+            {
+                string requestUrl;
+                Dictionary<string, object> queryMap;
+                if (UserModule.GetCurrentUser() != null)
+                {
+                    requestUrl = XdgSupportUserUnreadCheck;
+                    queryMap = null;
+                }
+                else
+                {
+                    requestUrl = XdgSupportAnonymousUnreadCheck;
+                    queryMap = new Dictionary<string, object>()
+                    {
+                        { "anonymousId", SystemInfo.deviceUniqueIdentifier }
+                    };
+                }
+
+                var response = await XDHttpClient.Client.GetAsync<SupportBaseResponse<SupportUnReadResponse>>(
+                    requestUrl,null, queryMap);
+
+                var bHasUnRead = response.Data.HasUnread;
+                var bUnReadStatusChange = bHasUnRead != Instance.bLastHasRead;
+                Instance.bLastHasRead = bHasUnRead;
+                var nextTimeInterval = bUnReadStatusChange ? 10 : IncreaseTimeInterval();
+                Instance.nextCheckUnreadTime = response.Data.IntervalSec > 0 ? response.Data.IntervalSec : nextTimeInterval;
+                XDGLogger.Debug($"Support Check UnRead Success, hasUnread:{response.Data.HasUnread} interval:{response.Data.IntervalSec}");
+                if (bUnReadStatusChange)
+                {
+                    AccountFeaturesImpl.Instance.GetUserStatusCallback()
+                        .Invoke(response.Data.HasUnread ? XDGUserStatusCodeType.SupportHasUnRead : XDGUserStatusCodeType.SupportNoUnRead, null);
+                }
+            }
+            catch (XDGError e)
+            {
+                UIManager.ShowToast(e.ErrorMsg);
+                Instance.nextCheckUnreadTime = IncreaseTimeInterval();
+            }
+
+            StartCheckUnRead();
+        }
+
+        private static int IncreaseTimeInterval()
+        {
+            var currentInterval = Instance.nextCheckUnreadTime;
+            return currentInterval >= 300 ? currentInterval : (currentInterval += 10);
+        }
+
+        private static void StartCheckUnRead()
+        {
+            try
+            {
+                Instance.cts.Cancel();
+            }
+            catch (ObjectDisposedException e)
+            {
+                XDGLogger.Warn($"Support Cancel CheckUnRead Action error:{e.Message}");
+            }
+
+            Instance.cts = new CancellationTokenSource();
+            if (Instance.nextCheckUnreadTime > 0)
+            {
+                TaskDispatcher.RunSafeAsync(async () =>
+                {
+                    try
+                    {
+                        await Task.Delay(Instance.nextCheckUnreadTime * 1000, Instance.cts.Token);
+                        await TaskDispatcher.SwitchToMainThread(Instance.cts.Token);
+                        CheckUnRead();
+                    }
+                    catch (TaskCanceledException e)
+                    {
+                        XDGLogger.Warn($"Support Start CheckUnRead Action error:{e.Message}");
+                    }
+                });
+                return;
+            }
+
+            CheckUnRead();
+        }
+
+        private static async void RequestSupportUrl(XDGRoleInfo roleInfo, string path, Dictionary<string, object> extra, Action<bool, bool, string> action)
+        {
+            XDGLogger.Debug("Support RequestSupportUrl");
+            try
+            {
+                if (path == null)
+                {
+                    path = "";
+                }
+
+                if (extra == null)
+                {
+                    extra = new Dictionary<string, object>();
+                }
+
+                if (roleInfo != null)
+                {
+                    extra.Add("role_id", roleInfo.RoleId);
+                    extra.Add("role_name", roleInfo.RoleName);
+                    extra.Add("server_id", roleInfo.ServerId);
+                }
+
+                var data = new Dictionary<string, object>
+                {
+                    { "path", path },
+                    { "urlEncodedUserParams", Uri.EscapeDataString(JsonConvert.SerializeObject(extra)) }
+                };
+
+                var query = new Dictionary<string, object>()
+                {
+                    { "anonymousId", SystemInfo.deviceUniqueIdentifier }
+                };
+
+                var response = await XDHttpClient.Client.PostAsync<SupportBaseResponse<SupportUrlResponse>>(UserModule.current == null
+                    ? XdgSupportAnonymousGetURL
+                    : XdgSupportUserGetURL, null, data, UserModule.current == null ? query : null);
+
+                action.Invoke(true, response.Data.XD, response.Data.Url);
+            }
+            catch (XDGError e)
+            {
+                XDGLogger.Warn($"Support RequestSupportUrl error:{e.ErrorMsg}");
+                action.Invoke(false, false, null);
+            }
+        }
+    }
+}
+#endif

package/Runtime/Internal/Standalone/SupportModule/SupportModule.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 97b8c4893e324feb964059732a111251
+timeCreated: 1746669710

package/Runtime/Internal/Standalone/SupportModule/SupportResponse.cs

@@ -0,0 +1,27 @@
+#if UNITY_EDITOR || UNITY_STANDALONE
+
+using Newtonsoft.Json;
+using XD.SDK.Common.Internal;
+
+namespace XD.SDK.Account.Internal.Standalone
+{
+    public class SupportBaseResponse<T> : BaseResponse
+    {
+        [JsonProperty("data")] public T Data { get; set; }
+    }
+
+    public class SupportUnReadResponse
+    {
+        [JsonProperty("hasUnread")] public bool HasUnread { get; set; }
+
+        [JsonProperty("intervalSec")] public int IntervalSec { get; set; }
+    }
+
+    public class SupportUrlResponse
+    {
+        [JsonProperty("url")] public string Url { get; set; }
+
+        [JsonProperty("isXD")] public bool XD { get; set; }
+    }
+}
+#endif

package/Runtime/Internal/Standalone/SupportModule/SupportResponse.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: ce2e53d437014853afc83885c352d6db
+timeCreated: 1746670881

package/Runtime/Internal/Standalone/SupportModule.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: de78a5ae8d9a410995fffdf7d7f43909
+timeCreated: 1746669700