com.xd.sdk.account 6.29.1 → 7.0.0

package/Runtime/Internal/Standalone/LoginModule/Email/EmailModule.cs

@@ -0,0 +1,374 @@
+#if UNITY_EDITOR || UNITY_STANDALONE
+using System;
+using System.Collections.Generic;
+using System.Threading.Tasks;
+using XD.SDK.Common;
+using XD.SDK.Common.Internal;
+using XD.SDK.Common.Internal.Standalone;
+
+
+namespace XD.SDK.Account.Internal.Standalone
+{
+    public static class EmailModule
+    {
+        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_EMAIL_FORMAT = 40031;
+        public const int INVALID_VERIFY_CODE = 40114;
+
+        private static EmailAlert loginAlert;
+        private static CodeUnbindAlert unbindAlert;
+
+        public static Task LoginOrBind(bool login)
+        {
+            TaskCompletionSource<object> tcs = new TaskCompletionSource<object>();
+            AliyunTrack.LoginAuthorize();
+            if (login)
+            {
+                AliyunTrack.LoginTrackEmailData();
+            }
+
+            loginAlert = UIManager.ShowUI<EmailAlert>("XDEmailAlert", new Dictionary<string, object>() { { "login", login } }, async (code, data) =>
+            {
+                switch (code)
+                {
+                    case EmailAlert.CLOSE_CODE:
+                        UIManager.Dismiss();
+                        AliyunTrack.LoginAuthorizeFail("cancel");
+                        tcs.TrySetException(XDGErrorExtensions.CancelledError());
+                        break;
+                    case EmailAlert.SEND_CODE:
+                        try
+                        {
+                            EmailAlert.Data emailData = data as EmailAlert.Data;
+                            if (emailData?.email.Length != 0)
+                            {
+                                await RequestLoginVerifyCode(emailData?.email);
+                            }
+                            else
+                            {
+                                loginAlert.UpdateEmailError(XDLocalization.GetCurrentLocalizableString().EmailEmpty);
+                            }
+                        }
+                        catch (Exception)
+                        {
+                            UIManager.DismissLoading();
+                        }
+
+                        break;
+                    case EmailAlert.LOGIN_OR_BIND:
+                        try
+                        {
+                            EmailAlert.Data emailData = data as EmailAlert.Data;
+                            if (emailData?.email.Length != 0)
+                            {
+                                if (emailData?.code.Length != 0)
+                                {
+                                    if (login)
+                                    {
+                                        await LoginByEmail(emailData?.email, emailData?.code);
+                                    }
+                                    else
+                                    {
+                                        await BindByEmail(emailData?.email, emailData?.code);
+                                    }
+
+                                    UIManager.Dismiss();
+                                    tcs.TrySetResult(null);
+                                }
+                                else
+                                {
+                                    loginAlert.UpdateCodeError(XDLocalization.GetCurrentLocalizableString().CodeEmpty);
+                                }
+                            }
+                            else
+                            {
+                                loginAlert.UpdateEmailError(XDLocalization.GetCurrentLocalizableString().EmailEmpty);
+                            }
+                        }
+                        catch (XDGError e)
+                        {
+                            if (e.Code == INVALID_VERIFY_CODE)
+                            {
+                                loginAlert.UpdateCodeError(e.ErrorMsg);
+                            }
+                            else if (e.Code == INVALID_EMAIL_FORMAT)
+                            {
+                                loginAlert.UpdateEmailError(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();
+                        AliyunTrack.LoginAuthorizeFail("cancel");
+                        AliyunTrack.LoginFail("cancel");
+                        tcs.TrySetException(XDGErrorExtensions.CancelledError());
+                        break;
+                    case CodeUnbindAlert.SEND_CODE:
+                    {
+                        try
+                        {
+                            await RequestUnbindVerifyCode();
+                        }
+                        catch (Exception)
+                        {
+                            UIManager.DismissLoading();
+                        }
+                    }
+                        break;
+                    case CodeUnbindAlert.UNBIND:
+                    {
+                        try
+                        {
+                            CodeUnbindAlert.Data unbindData = data as CodeUnbindAlert.Data;
+                            await UnbindByEmail(unbindData?.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 email, string riskControlData = null)
+        {
+            Dictionary<string, object> data = new Dictionary<string, object>
+            {
+                { "type", "EMAIL" },
+                { "email", email },
+            };
+            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);
+                AliyunTrack.SendEmailCode(true);
+                UIManager.ShowToast(XDLocalization.GetCurrentLocalizableString()?.CodeSendSuccess);
+            }
+            catch (XDGError e)
+            {
+                AliyunTrack.SendEmailCode(false);
+                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_email");
+                                RequestVerifyCodeData codeData = await RequestLoginVerifyCode(email, token);
+                                tcs.TrySetResult(codeData);
+                            }
+                            catch (XDGError exception)
+                            {
+                                tcs.TrySetException(exception);
+                            }
+                        }
+                        else
+                        {
+                            tcs.TrySetException(error as XDGError ?? throw new InvalidOperationException());
+                        }
+                    }
+
+                    AliyunTrack.TriggerCaptchaStart("login_email");
+                    XDGCaptcha.ValidateWithCaptcha(scene, new Dictionary<string, string>(){{"eventSessionId", AliyunTrack.LoginEventSessionId}}, Callback);
+                    response = await tcs.Task;
+                }
+                else if (e.Code == INVALID_EMAIL_FORMAT)
+                {
+                    loginAlert?.UpdateEmailError(e.ErrorMsg);
+                }
+                else
+                {
+                    UIManager.ShowToast(e.ErrorMsg);
+                }
+            }
+            catch (Exception)
+            {
+                loginAlert?.SetSendButtonEnable(true);
+                AliyunTrack.SendEmailCode(false);
+                UIManager.DismissLoading();
+                throw;
+            }
+
+            UIManager.DismissLoading();
+            return response;
+        }
+
+        private static async Task<RequestVerifyCodeData> RequestUnbindVerifyCode(string riskControlData = null)
+        {
+            Dictionary<string, object> data = new Dictionary<string, object>
+            {
+                { "type", "EMAIL" }
+            };
+            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)
+            {
+                unbindAlert?.SetSendButtonEnable(true);
+                UIManager.DismissLoading();
+                throw;
+            }
+
+            return response;
+        }
+
+        private static async Task LoginByEmail(string email, string code)
+        {
+            Dictionary<string, object> authData = new Dictionary<string, object>
+            {
+                { "type", (int)LoginType.Email },
+                { "token", email },
+                { "secret", code },
+                { "subType", "text" }
+            };
+            try
+            {
+                await AccessTokenModule.Login(authData, null);
+                AliyunTrack.EmailCodeVerifyResult(true);
+            }
+            catch (XDGError e)
+            {
+                AliyunTrack.EmailCodeVerifyResult(false, e.ErrorMsg);
+                throw;
+            }
+        }
+
+        private static async Task BindByEmail(string email, string code)
+        {
+            Dictionary<string, object> authData = new Dictionary<string, object>
+            {
+                { "type", (int)LoginType.Email },
+                { "token", email },
+                { "secret", code },
+                { "subType", "text" }
+            };
+            await XDHttpClient.Client.PostAsync<BaseResponse>(UserModule.XDG_BIND_INTERFACE, data: authData);
+        }
+
+        private static async Task UnbindByEmail(string code)
+        {
+            Dictionary<string, object> data = new Dictionary<string, object>()
+            {
+                { "type", (int)LoginType.Email },
+                { "verificationCode", code }
+            };
+            await XDHttpClient.Client.PostAsync<BaseResponse>(UserModule.XDG_UNBIND_INTERFACE, data: data);
+        }
+    }
+}
+
+
+#endif

package/Runtime/Internal/Standalone/LoginModule/Email/EmailModule.cs.meta

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

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

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

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

@@ -0,0 +1,245 @@
+#if UNITY_EDITOR || UNITY_STANDALONE
+using System;
+using System.Collections.Generic;
+using System.Threading.Tasks;
+using XD.SDK.Common;
+using XD.SDK.Common.Internal;
+using XD.SDK.Common.Internal.Standalone;
+
+
+namespace XD.SDK.Account.Internal.Standalone
+{
+    public class PhoneModule
+    {
+        public const int INVALID_PHONE_NUMBER_FORMAT = 40022;
+        public const int REQUEST_CODE_FREQUENTLY = 42901;
+        public const int LOGIN_REQUEST_FREQUENTLY = 42900;
+        public const int RISK_CONTROL = 40024;
+        public const int RISK_CONTROL_FAILED = 40025;
+        public const int INVALID_VERIFY_CODE = 40114;
+        public const int LOGIN_FREQUENTLY = 42900;
+        public const int INVALILD_TOKEN = 40113;
+
+        public static Task Login()
+        {
+            // 手机登录总流程
+            TaskCompletionSource<object> tcs = new TaskCompletionSource<object>();
+            PhoneNumberInputAlert alert = null;
+            AliyunTrack.LoginAuthorize();
+            AliyunTrack.LoginTrackPhoneData();
+
+            alert = UIManager.ShowUI<PhoneNumberInputAlert>("XDPhoneNumberInputAlert", null, async (code, data) =>
+            {
+                if (code == PhoneNumberInputAlert.CLOSE_CODE)
+                {
+                    // 关闭不结束 Task，同 Web 授权
+                    UIManager.Dismiss();
+                    AliyunTrack.LoginAuthorizeFail("cancel");
+                    AliyunTrack.LoginFail("cancel");
+                    tcs.TrySetException(XDGErrorExtensions.CancelledError());
+                }
+                else if (code == PhoneNumberInputAlert.NEXT_CODE)
+                {
+                    // 已经拿到手机号
+                    PhoneNumberInputAlert.Data input = data as PhoneNumberInputAlert.Data;
+                    string areaCode = input.AreaCode;
+                    string phoneNumber = input.PhoneNumber;
+                    try
+                    {
+                        // 验证码阶段
+                        await VerifyCodeInputAlert.Verify(
+                            phoneNumber,
+                            riskControlData => RequestLoginVerifyCode(areaCode, phoneNumber, riskControlData),
+                            verificationCode => LoginByPhone(areaCode, phoneNumber, verificationCode)
+                        );
+                        AliyunTrack.LoginAuthorizeSuccess();
+                        tcs.TrySetResult(null);
+                        UIManager.Dismiss();
+                    }
+                    catch (XDGError e)
+                    {
+                        if (e.Code == INVALID_PHONE_NUMBER_FORMAT)
+                        {
+                            alert.CheckPhoneNumberValid(phoneNumber);
+                        }
+                        else if (e.Code == REQUEST_CODE_FREQUENTLY)
+                        {
+                            // 频繁登录
+                            UIManager.ShowToast(e.Message);
+                        }
+                        else
+                        {
+                            // 其他异常
+                            if (string.IsNullOrEmpty(e.Message))
+                            {
+                                // TODO 翻译
+                                UIManager.ShowToast("发送失败");
+                            }
+                            else
+                            {
+                                UIManager.ShowToast(e.Message);
+                            }
+                        }
+                    }
+                    catch (TaskCanceledException tce)
+                    {
+                        // 退出不处理
+                        AliyunTrack.LoginAuthorizeFail(tce.Message);
+                        UIManager.Dismiss();
+                        AliyunTrack.LoginFail("cancel");
+                    }
+                    catch (Exception e)
+                    {
+                        AliyunTrack.LoginAuthorizeFail(e.Message);
+                        UIManager.ShowToast("发送失败");
+                    }
+                }
+            });
+            return tcs.Task;
+        }
+
+        public static Task Bind()
+        {
+            TaskCompletionSource<object> tcs = new TaskCompletionSource<object>();
+            UIManager.ShowUI<PhoneNumberInputAlert>("XDPhoneNumberInputAlert", null, async (code, data) =>
+            {
+                if (code == PhoneNumberInputAlert.CLOSE_CODE)
+                {
+                    UIManager.Dismiss();
+                    tcs.TrySetException(XDGErrorExtensions.CancelledError());
+                }
+                else if (code == PhoneNumberInputAlert.NEXT_CODE)
+                {
+                    try
+                    {
+                        PhoneNumberInputAlert.Data input = data as PhoneNumberInputAlert.Data;
+                        string areaCode = input.AreaCode;
+                        string phoneNumber = input.PhoneNumber;
+                        await VerifyCodeInputAlert.Verify(
+                            phoneNumber,
+                            riskControlData => RequestLoginVerifyCode(areaCode, phoneNumber, riskControlData),
+                            verificationCode => BindByPhone(areaCode, phoneNumber, verificationCode)
+                        );
+                        tcs.TrySetResult(null);
+                        UIManager.Dismiss();
+                    }
+                    catch (TaskCanceledException)
+                    {
+                        UIManager.Dismiss();
+                    }
+                    catch (XDGError e)
+                    {
+                        if (e.Code == REQUEST_CODE_FREQUENTLY)
+                        {
+                            // 频繁登录
+                            UIManager.ShowToast(e.Message);
+                        }
+                        else
+                        {
+                            tcs.TrySetException(e);
+                        }
+                    }
+                }
+            });
+            return tcs.Task;
+        }
+
+        public static async Task Unbind(Dictionary<string, object> extras)
+        {
+            string phoneNumber = extras["openId"] as string;
+            await VerifyCodeInputAlert.Verify(phoneNumber,
+                riskControlData => RequestUnbindVerifyCode(riskControlData),
+                code => UnbindByPhone(code));
+        }
+
+        private static async Task<RequestVerifyCodeData> RequestLoginVerifyCode(string areaCode, string phoneNumber,
+            string riskControlData = null)
+        {
+            string path = "api/login/v1/verification/code/send";
+            Dictionary<string, object> data = new Dictionary<string, object>
+            {
+                { "areaCode", areaCode }, // 当前版本固定国内
+                { "phoneNumber", phoneNumber }
+            };
+            Dictionary<string, object> headers = null;
+            if (riskControlData != null)
+            {
+                headers = new Dictionary<string, object>()
+                {
+                    { "Risk-Authenticate-Sig", riskControlData }
+                };
+            }
+
+            RequestVerifyCodeResponse response = null;
+            UIManager.ShowLoading(true);
+            try
+            {
+                response = await XDHttpClient.Client.PostAsync<RequestVerifyCodeResponse>(path,
+                    headers: headers, data: data);
+                AliyunTrack.LoginMobileVerifyCodeSendSuccess();
+            }
+            catch (Exception)
+            {
+                UIManager.DismissLoading();
+                AliyunTrack.LoginMobileVerifyCodeSendFail();
+                throw;
+            }
+
+            UIManager.DismissLoading();
+            return response?.Data;
+        }
+
+        private static async Task<RequestVerifyCodeData> RequestUnbindVerifyCode(string riskControlData = null)
+        {
+            string path = "api/account/v1/unbind/verification/code/send";
+            Dictionary<string, object> headers = null;
+            if (riskControlData != null)
+            {
+                headers = new Dictionary<string, object>()
+                {
+                    { "Risk-Authenticate-Sig", riskControlData }
+                };
+            }
+
+            RequestVerifyCodeResponse response = await XDHttpClient.Client.PostAsync<RequestVerifyCodeResponse>(path,
+                headers: headers);
+            return response.Data;
+        }
+
+        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" }
+            };
+            await AccessTokenModule.Login(authData, null);
+            AliyunTrack.LoginMobileVerifyCodePassSuccess();
+        }
+
+        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/PhoneModule.cs.meta

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