com.xd.sdk.account 6.29.1 → 7.0.0

package/Runtime/Internal/Standalone/UI/PhoneVerification/RiskControlAlert.cs

@@ -0,0 +1,190 @@
+#if UNITY_EDITOR || UNITY_STANDALONE
+using System;
+using System.Threading.Tasks;
+using System.Collections.Generic;
+using System.Net.NetworkInformation;
+using System.Net.Sockets;
+using Newtonsoft.Json;
+using UnityEngine;
+using UnityEngine.UI;
+using Vuplex.WebView;
+using XD.SDK.Common;
+using XD.SDK.Common.Internal.Standalone;
+
+namespace XD.SDK.Account.Internal.Standalone {
+    public class RiskControlAlert : UIElement {
+        public const int CONTROL_DONE_CODE = 0;
+        public const int CLOSE_CODE = -1;
+        public const int BACK_CODE = 1;
+
+        private Button backButton;
+        private Button closeButton;
+
+        private CanvasWebViewPrefab canvasWebViewPrefab;
+
+        public static async Task<int> Control(Func<string, Task<RequestVerifyCodeData>> requestVerifyCodeFunc) {
+            RiskControlAlert alert = null;
+            string riskControlData = null;
+            TaskCompletionSource<int> tcs = new TaskCompletionSource<int>();
+            try {
+                UIManager.ShowLoading(true);
+                RequestVerifyCodeData verifyCodeData = await requestVerifyCodeFunc(riskControlData);
+                tcs.TrySetResult(verifyCodeData.ReSendInterval);
+            } catch (XDGError e) {
+                if (e.Code == PhoneModule.RISK_CONTROL) {
+                    // 触发风控
+                    alert = UIManager.ShowUI<RiskControlAlert>("XDRiskControlAlert", null, async (code, data) => {
+                        if (code == CLOSE_CODE) {
+                            UIManager.Dismiss();
+                            tcs.TrySetException(XDGErrorExtensions.CancelledError());
+                        } else if (code == BACK_CODE) {
+                            UIManager.Dismiss();
+                        } else if (code == CONTROL_DONE_CODE) {
+                            riskControlData = data as string;
+                            try {
+                                UIManager.ShowLoading();
+                                RequestVerifyCodeData result = await requestVerifyCodeFunc(riskControlData);
+                                tcs.TrySetResult(result.ReSendInterval);
+                            } catch (XDGError ex) {
+                                UIManager.DismissLoading();
+                                if (ex.Code == PhoneModule.RISK_CONTROL) {
+                                    // 触发风控
+                                    await alert.Reload();
+                                } else if (ex.Code == PhoneModule.RISK_CONTROL_FAILED) {
+                                    // 滑动验证失败
+                                    await alert.Reload();
+                                    UIManager.ShowToast(e.Message);
+                                } else {
+                                    tcs.TrySetException(ex);
+                                }
+                            } finally {
+                                UIManager.DismissLoading();
+                            }
+                        }
+                    });
+                } else {
+                    tcs.TrySetException(e);
+                }
+            } catch (Exception e) {
+                tcs.TrySetException(e);
+            } finally {
+                UIManager.DismissLoading();
+            }
+
+            return await tcs.Task;
+        }
+
+        private void Awake() {
+            Transform webviewContainer = transform.Find("WebViewContainer");
+            canvasWebViewPrefab = CanvasWebViewPrefab.Instantiate();
+            canvasWebViewPrefab.transform.SetParent(webviewContainer);
+            RectTransform rectTransform = canvasWebViewPrefab.GetComponent<RectTransform>();
+            rectTransform.offsetMin = Vector2.zero;
+            rectTransform.offsetMax = Vector2.zero;
+
+            backButton = transform.Find("BackButton").GetComponent<Button>();
+            backButton.onClick.AddListener(OnBackClicked);
+
+            closeButton = transform.Find("CloseButton").GetComponent<Button>();
+            closeButton.onClick.AddListener(OnCloseClicked);
+        }
+
+        private async void Start() {
+            UIManager.ShowLoading();
+
+            await canvasWebViewPrefab.WaitUntilInitialized();
+
+            canvasWebViewPrefab.DragMode = DragMode.DragWithinPage;
+
+            canvasWebViewPrefab.WebView.MessageEmitted += (sender, eventArgs) => {
+                XDGLogger.Debug(eventArgs.Value);
+                Dictionary<string, string> response = JsonConvert.DeserializeObject<Dictionary<string, string>>(eventArgs.Value);
+                Dictionary<string, object> data = JsonConvert.DeserializeObject<Dictionary<string, object>>(response["message"]);
+                string riskControlData = JsonConvert.SerializeObject(data["data"]);
+                XDGLogger.Debug(riskControlData);
+                UIManager.Dismiss();
+
+                OnCallback(CONTROL_DONE_CODE, riskControlData);
+            };
+
+            await Reload();
+        }
+
+        private string GetIP()
+        {
+            string output = "";
+
+            foreach (NetworkInterface item in NetworkInterface.GetAllNetworkInterfaces())
+            {
+#if UNITY_EDITOR_WIN || UNITY_STANDALONE_WIN
+                NetworkInterfaceType _type1 = NetworkInterfaceType.Wireless80211;
+                NetworkInterfaceType _type2 = NetworkInterfaceType.Ethernet;
+
+                if ((item.NetworkInterfaceType == _type1 || item.NetworkInterfaceType == _type2) && item.OperationalStatus == OperationalStatus.Up)
+#endif 
+                {
+                    foreach (UnicastIPAddressInformation ip in item.GetIPProperties().UnicastAddresses)
+                    {
+                        //IPv4
+                        if (ip.Address.AddressFamily == AddressFamily.InterNetwork)
+                        {
+                            output = ip.Address.ToString();
+                            XDGLogger.Debug($"ip local: {output}");
+                        }
+                    }
+                }
+            }
+            return output;
+        }
+        private async Task Reload() {
+            UIManager.ShowLoading();
+            var ip = GetIP();
+            canvasWebViewPrefab.WebView.LoadUrl($"https://login-xdsdk.xd.cn/awsc?platform={Platform}&eventSessionId={AliyunTrack.LoginEventSessionId}&login_type=Phone&sub_login_type=2&xd_client_id={ConfigModule.ClientId}&device_id={SystemInfo.deviceUniqueIdentifier}&os={SystemInfo.operatingSystem}&ip={ip}&app_version={Application.version}&language={XDLocalization.CurrentLang.ToString()}");
+            await canvasWebViewPrefab.WebView.WaitForNextPageLoadToFinish();
+            // 注入 js
+            _ = canvasWebViewPrefab.WebView.ExecuteJavaScript(@";(function (window) {
+              window._xd_jsbridge = {
+                invoke: function (json) {
+                  try {
+                    window.vuplex.postMessage({ type: 'verify', message: json });
+                  } catch (error) {
+                    console.error('xd-jsbridge error::', error)
+                  }
+                },
+              };
+            })(window);");
+
+            UIManager.DismissLoading();
+        }
+
+        private string Platform {
+            get {
+                if (Application.platform == RuntimePlatform.Android)
+                {
+                    return "Android";
+                }
+                else if (Application.platform == RuntimePlatform.IPhonePlayer)
+                {
+                    return "IOS";
+                }
+                else
+                {
+                    return "PC";
+                }
+            }
+        }
+
+        #region UI Events
+
+        private void OnBackClicked() {
+            OnCallback(BACK_CODE, null);
+        }
+
+        private void OnCloseClicked() {
+            OnCallback(CLOSE_CODE, null);
+        }
+
+        #endregion
+    }
+}
+#endif

package/Runtime/Internal/Standalone/UI/PhoneVerification/RiskControlAlert.cs.meta

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

package/Runtime/Internal/Standalone/UI/PhoneVerification/VerifyCodeInputAlert.cs

@@ -0,0 +1,164 @@
+#if UNITY_EDITOR || UNITY_STANDALONE
+using System;
+using System.Threading.Tasks;
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+using UnityEngine.UI;
+using XD.SDK.Common;
+using XD.SDK.Common.Internal.Standalone;
+
+namespace XD.SDK.Account.Internal.Standalone {
+    public class VerifyCodeInputAlert : UIElement {
+        public const int INPUT_DONE_CODE = 0;
+        public const int CLOSE_CODE = -1;
+        public const int RESEND_CODE = 1;
+        public const int BACK_CODE = 2;
+
+        private const int VERIFY_CODE_LENGTH = 6;
+
+        public Action OnBack { get; set; }
+        public Action<string, string, string> OnVerify { get; set; }
+
+        private Button backButton;
+        private Button closeButton;
+        private Text titleText;
+        private Text phoneNumberTipsText;
+        private InputField codeInput;
+        private Text errorCodeTipsText;
+        private Button reSendButton;
+
+        public static async Task Verify(string phoneNumber,
+            Func<string, Task<RequestVerifyCodeData>> requestVerifyCodeFunc,
+            Func<string, Task> verifyFunc) {
+
+            TaskCompletionSource<object> tcs = new TaskCompletionSource<object>();
+
+            int resendInterval;
+            try {
+                // 通过风控
+                resendInterval = await RiskControlAlert.Control(requestVerifyCodeFunc);
+
+                // 输入验证码
+                Dictionary<string, object> conf = new Dictionary<string, object> {
+                    { "phoneNumber", phoneNumber },
+                    { "reSendInterval", resendInterval }
+                };
+                VerifyCodeInputAlert alert = null;
+
+                AliyunTrack.LoginMobileVerifyCodeInput();
+                alert = UIManager.ShowUI<VerifyCodeInputAlert>("XDVerifyCodeInputAlert", conf, async (code, data) => {
+                    if (code == CLOSE_CODE) {
+                        UIManager.Dismiss();
+                        tcs.TrySetException(XDGErrorExtensions.CancelledError());
+                    } else if (code == BACK_CODE) {
+                        UIManager.Dismiss();
+                    } else if (code == RESEND_CODE) {
+                        try {
+                            resendInterval = await RiskControlAlert.Control(requestVerifyCodeFunc);
+                            alert.Extra["reSendInterval"] = resendInterval;
+                            alert.Start();
+                            AliyunTrack.LoginMobileVerifyCodeInput();
+                        } catch (TaskCanceledException) {
+                            UIManager.Dismiss();
+                            tcs.TrySetException(XDGErrorExtensions.CancelledError());
+                        }
+                    } else if (code == INPUT_DONE_CODE) {
+
+                        try {
+                            await verifyFunc(data as string);
+                            tcs.TrySetResult(null);
+                            UIManager.Dismiss();
+                        } catch (XDGError e) {
+                            if (e.Code == PhoneModule.INVALID_VERIFY_CODE) {
+                                alert.VerifyFailed();
+                                AliyunTrack.LoginMobileVerifyCodePassFail(e.ErrorMsg);
+                            } else {
+                                AliyunTrack.LoginMobileVerifyCodePassFail(e.ErrorMsg);
+                                tcs.TrySetException(e);
+                                UIManager.Dismiss();
+                            }
+                        } catch (Exception e) {
+                            tcs.TrySetException(e);
+                            UIManager.Dismiss();
+                        }
+                    }
+                });
+            } catch (TaskCanceledException) {
+                tcs.TrySetException(XDGErrorExtensions.CancelledError());
+            }
+            
+            await tcs.Task;
+        }
+
+        private void Awake() {
+            backButton = transform.Find("Alert/BackButton").GetComponent<Button>();
+            closeButton = transform.Find("Alert/CloseButton").GetComponent<Button>();
+            titleText = transform.Find("Alert/TitleText").GetComponent<Text>();
+            phoneNumberTipsText = transform.Find("Alert/PhoneNumberTips").GetComponent<Text>();
+            codeInput = transform.Find("Alert/Input/CodeInput").GetComponent<InputField>();
+            errorCodeTipsText = transform.Find("Alert/ErrorCodeTips").GetComponent<Text>();
+            reSendButton = transform.Find("Alert/ReSendButton").GetComponent<Button>();
+
+            errorCodeTipsText.gameObject.SetActive(false);
+
+            closeButton.onClick.AddListener(OnCloseClicked);
+            backButton.onClick.AddListener(OnVerifyDialogBackClicked);
+            codeInput.onValueChanged.AddListener(OnCodeInputValueChanged);
+            reSendButton.onClick.AddListener(OnReSendClicked);
+        }
+
+        private void Start()
+        {
+            phoneNumberTipsText.text = $"已发送至 {Extra["phoneNumber"]}";
+            // 倒计时
+            StartCoroutine(UpdateResendInterval());
+            codeInput.Select();
+        }
+
+        IEnumerator UpdateResendInterval() {
+            int resendInterval = (int) Extra["reSendInterval"];
+            while (resendInterval > 0) {
+                reSendButton.interactable = false;
+                Text reSendText = reSendButton.GetComponentInChildren<Text>();
+                reSendText.text = $"{resendInterval} 秒后可重新发送";
+                yield return new WaitForSeconds(1);
+                resendInterval--;
+            }
+            reSendButton.interactable = true;
+            reSendButton.GetComponentInChildren<Text>().text = "重新发送";
+        }
+
+        public void VerifyFailed() {
+            errorCodeTipsText.gameObject.SetActive(true);
+        }
+
+        #region UI Events
+
+        private void OnCloseClicked() {
+            OnCallback(CLOSE_CODE, null);
+        }
+
+        private void OnVerifyDialogBackClicked() {
+            OnCallback(BACK_CODE, null);
+        }
+
+        private void OnCodeInputValueChanged(string code) {
+            errorCodeTipsText.gameObject.SetActive(false);
+
+            if (code?.Length != VERIFY_CODE_LENGTH) {
+                return;
+            }
+
+            // 请求校验验证码
+            OnCallback(INPUT_DONE_CODE, code);
+        }
+
+        private void OnReSendClicked() {
+            OnCallback(RESEND_CODE, null);
+        }
+
+        #endregion
+    }
+}
+#endif

package/Runtime/Internal/Standalone/UI/PhoneVerification/VerifyCodeInputAlert.cs.meta

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

package/Runtime/Internal/Standalone/UI/PhoneVerification.meta

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

package/Runtime/Internal/Standalone/UI.meta

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