com.xd.sdk.account 6.29.1 → 7.0.1

package/Runtime/Internal/Standalone/AccountFeaturesImpl.cs

@@ -0,0 +1,461 @@
+#if UNITY_EDITOR || UNITY_STANDALONE
+using System;
+using System.Collections.Generic;
+using System.Net.Http;
+using System.Security.Cryptography;
+using System.Text;
+using System.Threading.Tasks;
+using UnityEngine;
+using XD.SDK.Account.Standalone;
+using XD.SDK.Common;
+using XD.SDK.Common.Internal;
+using XD.SDK.Common.Internal.Events;
+using XD.SDK.Common.Internal.Standalone;
+using Random = System.Random;
+
+namespace XD.SDK.Account.Internal.Standalone
+{
+    public class AccountFeaturesImpl : IXDGAccountExtended
+    {
+        private static AccountFeaturesImpl _instance;
+
+        private static readonly object LockObj = new object();
+
+        public static AccountFeaturesImpl Instance
+        {
+            get
+            {
+                if (_instance == null)
+                {
+                    lock (LockObj)
+                    {
+                        if (_instance == null)
+                        {
+                            _instance = new AccountFeaturesImpl();
+                        }
+                    }
+                }
+
+                return _instance;
+            }
+        }
+
+        private AccountFeaturesImpl()
+        {
+        }
+
+        internal static Action<XDGUserStatusCodeType, string> UserStatusChangeCallback;
+
+        public void AddUserStatusChangeCallback(Action<XDGUserStatusCodeType, string> callback)
+        {
+            UserStatusChangeCallback = callback;
+        }
+
+        public Action<XDGUserStatusCodeType, string> GetUserStatusCallback()
+        {
+            return UserStatusChangeCallback;
+        }
+
+        public async void LoginByType(LoginType loginType, Action<XDGUser> callback, Action<XDGError> errorCallback)
+        {
+            try
+            {
+                var user = await LoginByTypeInternal(loginType);
+                XDGCommonInternal.TrackUser(user.UserId);
+                callback.Invoke(await InvokeXdgPaymentCheckRefundStatusWithUI(user));
+            }
+            catch (XDGError xe)
+            {
+                errorCallback?.Invoke(xe);
+            }
+            catch (Exception e)
+            {
+                errorCallback?.Invoke(new XDGError(ResponseCode.Common.Failed, e.Message));
+            }
+        }
+
+        // 向后兼容的便捷方法
+        public void LoginByConsole(Action<XDGUser> successCallback, Action failCallback, Action<XDGError> errorCallback)
+        {
+            LoginByType(LoginType.Console, successCallback, errorCallback);
+        }
+
+        public void Logout()
+        {
+            try
+            {
+                InternalLogout();
+            }
+            catch (Exception e)
+            {
+                XDGLogger.Error(new XDGError(ResponseCode.Common.Failed, e.Message));
+            }
+        }
+
+        public XDGUser GetCurrentUser()
+        {
+            return UserModule.GetCurrentUser();
+        }
+
+        public void OpenCustomerService(XDGRoleInfo roleInfo, string path, Dictionary<string, object> paramsMap)
+        {
+            SupportModule.OpenCustomerService(roleInfo, path, paramsMap);
+        }
+
+        public void OpenUserCenter()
+        {
+            var user = UserModule.current;
+            if (user == null)
+            {
+                XDGLogger.Warn("请先登录");
+                UIManager.ShowToast(XDLocalization.GetCurrentLocalizableString().NotLogin);
+                return;
+            }
+
+            UIManager.ShowUI<UserCenterAlert>(null, null);
+        }
+
+        public async void OpenUserDashboard(XDGRoleInfo roleInfo)
+        {
+            try
+            {
+                if (!XDGCommonInternal.IsCn())
+                {
+                    UIManager.ShowToast("Service not available in current region.");
+                    return;
+                }
+
+                var user = UserModule.current;
+                if (user == null)
+                {
+                    XDGLogger.Warn("请先登录");
+                    UIManager.ShowToast(XDLocalization.GetCurrentLocalizableString().NotLogin);
+                    return;
+                }
+
+                Dictionary<string, object> authData = new Dictionary<string, object>()
+                    { { "scope", UserModule.CodeScope.USER_INFO } };
+                try
+                {
+                    var response = await XDHttpClient.Client.PostAsync<RequestAuthCodeResponse>(UserModule.XDG_AUTH_CODE, data: authData);
+
+                    var queries = new Dictionary<string, object>
+                    {
+                        ["serverId"] = roleInfo.ServerId,
+                        ["roleId"] = roleInfo.RoleId,
+                        ["roleName"] = roleInfo.RoleName,
+                        ["extra"] = roleInfo.Extra
+                    };
+                    var url = AuthConstants.CN_PERSONAL_INFO + UserModule.XDG_PERSONAL_INFO + "?" +
+                              XDUrlUtils.ToQueryString(queries);
+                    
+                    UIManager.ShowUI<XDWebViewAlert>("XDWebViewAlert", new Dictionary<string, object>
+                    {
+                        {
+                            "url", url
+                        },
+                        {
+                            "env", new Dictionary<string, string>()
+                            {
+                                { "clientId", ConfigModule.ClientId },
+                                { "authCode", response.Data.Code },
+                                { "platform", XDUtility.GetPlatform() },
+                                { "sdkLang", XDLocalization.GetLanguageKey() },
+                                { "language", Application.systemLanguage.ToString() },
+                                { "sdkVer", XDGConstants.SDK_VERSION },
+                                { "deviceId", SystemInfo.deviceUniqueIdentifier },
+                            }
+                        }
+                    }, (code, data) =>
+                    {
+                        if (code == XDWebViewAlert.CLOSE_CODE)
+                        {
+                            UIManager.Dismiss();
+                            UIManager.DismissLoading();
+                        }
+                    });
+                }
+                catch (XDGError e)
+                {
+                    UIManager.ShowToast(e.ErrorMsg);
+                }
+            }
+            catch (Exception e)
+            {
+                XDGLogger.Error(new XDGError(ResponseCode.Common.Failed, e.Message));
+            }
+        }
+
+        public async void OpenAccountDeletion()
+        {
+            try
+            {
+                await CancelAccount();
+            }
+            catch (XDGError e)
+            {
+                XDGLogger.Error(new XDGError(ResponseCode.Common.Failed, e.ErrorMsg));
+            }
+        }
+
+        public async void BindByType(LoginType loginType, Action<bool, XDGError> callback)
+        {
+            try
+            {
+                await UserModule.Bind(loginType);
+                callback?.Invoke(true, null);
+            }
+            catch (XDGError e)
+            {
+                callback?.Invoke(false, new XDGError(ResponseCode.Common.Failed, e.ErrorMsg));
+            }
+        }
+
+        public async Task<Dictionary<string, string>> GetRequestAuthorizationHeader(HttpRequestMessage request,
+            long timestamp)
+        {
+            var auth = await GetMacToken(request.RequestUri, request.Method, timestamp);
+            if (string.IsNullOrEmpty(auth))
+            {
+                return new Dictionary<string, string>();
+            }
+
+            return new Dictionary<string, string>
+            {
+                { "Authorization", auth }
+            };
+        }
+
+        private async Task<XDGUser> LoginByTypeInternal(LoginType loginType)
+        {
+            if (!XDGCommonInternal.IsInitialized())
+            {
+                throw XDGErrorExtensions.NotInitError();
+            }
+
+            // 登录埋点
+            AliyunTrack.LoginStart(loginType.ToString());
+            try
+            {
+                var user = await UserModule.Login(loginType);
+                AliyunTrack.LoginAntiAddictionStartup();
+                var complianceResult =
+                    await XDGEventBus.PublishAsync<Dictionary<string, object>>(XDGEvents.TapSDKComplianceStartup, ConfigModule.IsGlobal, user.UserId);
+                // TODO 统一走回调进行埋点
+                // AliyunTrack.LoginAntiAddictionResult(XDDictionary.GetValue(complianceResult, "code", -100),
+                // XDDictionary.GetValue<string>(complianceResult, "reason"),
+                // XDDictionary.GetValue<string>(complianceResult, "extras"));
+                if (XDDictionary.GetValue<bool>(complianceResult, "success"))
+                {
+                    await AgreementModule.SignAgreement(user.UserId);
+                    return user;
+                }
+
+                ClearUserCache();
+                throw new XDGError("防沉迷校验失败");
+            }
+            catch (XDHttpException e)
+            {
+                if ((e.HttpStatusCode == 401 && loginType == LoginType.Default) || e.Code == 40311 || e.Code == 40312)
+                {
+                    InternalLogout("LOGOUT_API", false);
+                }
+
+                var errorMsg = e.Message;
+                if (e.Code == ResponseCode.Account.TokenExpired)
+                    errorMsg = "XD_TOKEN_EXPIRED";
+                AliyunTrack.LoginFail(errorMsg);
+                throw;
+            }
+            catch (Exception e)
+            {
+                AliyunTrack.LoginFail(e.Message);
+                AgreementModule.ClearLocalSignedAgreements();
+                throw;
+            }
+        }
+
+        public void InternalLogout(string logoutType = "LOGOUT_API", bool needNotify = true, bool bShowAgreement = true)
+        {
+            // SDK 登陆成功
+            AliyunTrack.LoginLogout(logoutType);
+
+            XDGEventBus.Publish(XDGEvents.TdsSDKLogout);
+            XDGEventBus.Publish(XDGEvents.TapSDKLogout);
+            if (logoutType != "SWITCH_ACCOUNT" && logoutType != "COMPLIANCE_EXIT")
+            {
+                XDGEventBus.Publish(XDGEvents.TapSDKComplianceExit, ConfigModule.IsGlobal);
+            }
+            
+            ClearUserCache();
+
+            if (bShowAgreement)
+            {
+                _ = AgreementModule.ConfirmAgreement().ContinueWith(t =>
+                {
+                    if (!t.IsFaulted)
+                    {
+                        if (needNotify)
+                        {
+                            UserStatusChangeCallback?.Invoke(XDGUserStatusCodeType.ProtocolAgreedAfterLogout, null);
+                        }
+                    }
+                }, TaskScheduler.FromCurrentSynchronizationContext());
+            }
+
+            if (needNotify)
+            {
+                UserStatusChangeCallback?.Invoke(XDGUserStatusCodeType.LOGOUT, null);
+            }
+        }
+
+        private static void ClearUserCache()
+        {
+            AccessTokenModule.ClearToken();
+            UserModule.ClearUserData();
+            AgreementModule.ClearLocalSignedAgreements();
+        }
+
+        private async Task CancelAccount()
+        {
+            var current = UserModule.current;
+            if (current == null)
+            {
+                XDGLogger.Warn("请先登录");
+                UIManager.ShowToast(XDLocalization.GetCurrentLocalizableString().NotLogin);
+                return;
+            }
+
+            string cancelUrl = ConfigModule.CancelUrl;
+            if (string.IsNullOrEmpty(cancelUrl))
+            {
+                XDGLogger.Warn("没有有效的注销 url");
+                return;
+            }
+
+            try
+            {
+                UIManager.ShowLoading();
+                var accessToken = await AccessTokenModule.GetLocalAccessToken();
+                var queryParams = new Dictionary<string, object>
+                {
+                    { "kid", accessToken?.Kid },
+                    { "mac_key", accessToken?.MacKey },
+                    { "source", "game" },
+                    { "cn", ConfigModule.IsGlobal ? "0" : "1" },
+                    { "sdk_lang", XDLocalization.GetLanguageKey() },
+                    { "version", XDGConstants.SDK_VERSION },
+                    { "client_id", ConfigModule.ClientId },
+                    { "did", SystemInfo.deviceUniqueIdentifier }
+                };
+                var ipInfo = await IPInfoModule.GetIpInfo();
+                if (ipInfo != null)
+                {
+                    queryParams["country_code"] = ipInfo.CountryCode;
+                }
+
+                if (!string.IsNullOrEmpty(ConfigModule.Region))
+                {
+                    queryParams["region"] = ConfigModule.Region;
+                }
+
+                var url = $"{cancelUrl}?{XDUrlUtils.ToQueryString(queryParams)}";
+                XDGLogger.Debug($"cancel url: {url}");
+
+                // 打开内置浏览器
+                var data = new Dictionary<string, object>
+                {
+                    { "url", url }
+                };
+                Action<int, object> callback = (code, obj) =>
+                {
+                    if (code == CancelAccountAlert.CANCEL_DONE_CODE)
+                    {
+                        InternalLogout();
+                    }
+                };
+                UIManager.ShowUI<CancelAccountAlert>("CancelAccountAlert", data, callback);
+            }
+            finally
+            {
+                UIManager.DismissLoading();
+            }
+        }
+
+        private static async Task<XDGUser> InvokeXdgPaymentCheckRefundStatusWithUI(XDGUser user)
+        {
+            try
+            {
+                await XDGEventBus.PublishAsync<object>(XDGEvents.PaymentCheckRefundStatusWithUI);
+            }
+            catch (Exception e)
+            {
+                XDGLogger.Warn($"[InvokeXdgPaymentCheckRefundStatusWithUI] Error:{e.Message}");
+            }
+
+            return user;
+        }
+
+        private static readonly string LetterStr = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
+        private static readonly string GetMethod = "GET";
+        private static readonly string PostMethod = "POST";
+
+        private static Task<string> GetMacToken(Uri uri, HttpMethod method, long timestamp)
+        {
+            if (method == HttpMethod.Get)
+            {
+                return GetMacToken(uri, GetMethod, timestamp);
+            }
+            else if (method == HttpMethod.Post)
+            {
+                return GetMacToken(uri, PostMethod, timestamp);
+            }
+
+            return null;
+        }
+
+        private static async Task<string> GetMacToken(Uri uri, string method, long timestamp)
+        {
+            var accessToken = await AccessTokenModule.GetLocalAccessToken();
+            string authToken = null;
+            if (accessToken != null)
+            {
+                string nonce = GetRandomStr(5);
+                string md = method.ToUpper();
+
+                string pathAndQuery = uri.PathAndQuery;
+                string domain = uri.Host.ToLower();
+                string port = $"{uri.Port}";
+
+                var dataStr = $"{timestamp}\n{nonce}\n{md}\n{pathAndQuery}\n{domain}\n{port}\n";
+                var mac = Base64WithSecret(accessToken.MacKey, dataStr);
+                authToken = $"MAC id=\"{accessToken.Kid}\",ts=\"{timestamp}\",nonce=\"{nonce}\",mac=\"{mac}\"";
+            }
+
+            return authToken;
+        }
+
+        private static string GetRandomStr(int length)
+        {
+            var SB = new StringBuilder();
+            var rd = new Random();
+            for (int i = 0; i < length; i++)
+            {
+                SB.Append(LetterStr.Substring(rd.Next(0, LetterStr.Length), 1));
+            }
+
+            return SB.ToString();
+        }
+
+        private static string Base64WithSecret(string secret, string data)
+        {
+            var secretBytes = UTF8Encoding.UTF8.GetBytes(secret);
+            var hmac = new HMACSHA1(secretBytes);
+            var dataBytes = UTF8Encoding.UTF8.GetBytes(data);
+            var calcHash = hmac.ComputeHash(dataBytes);
+            var calcHashString = Convert.ToBase64String(calcHash);
+            return calcHashString;
+        }
+    }
+}
+#endif

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

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

package/Runtime/Internal/Standalone/Auth/AppleAuth.cs

@@ -0,0 +1,27 @@
+#if UNITY_EDITOR || UNITY_STANDALONE
+using System.Collections.Generic;
+using System.Net;
+using System.Threading.Tasks;
+using XD.SDK.Common;
+using XD.SDK.Common.Internal.Standalone;
+
+namespace XD.SDK.Account.Internal.Standalone
+{
+    internal class AppleAuth : WebAuth
+    {
+        static List<HttpListener> servers = new List<HttpListener>();
+
+        internal static Task<Dictionary<string, object>> GetAuthData()
+        {
+            Dictionary<string, object> queryParams = new Dictionary<string, object>
+            {
+                { "auth_type", "apple" },
+                { "client_id", ConfigModule.Apple.ClientId },
+                { "state", LocalServerUtils.GenerateRandomDataBase64url(32) }
+            };
+
+            return StartListener(servers, LoginType.Apple, queryParams);
+        }
+    }
+}
+#endif

package/Runtime/Internal/Standalone/Auth/AppleAuth.cs.meta

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

package/Runtime/Internal/Standalone/Auth/FacebookAuth.cs

@@ -0,0 +1,27 @@
+#if UNITY_EDITOR || UNITY_STANDALONE
+using System.Collections.Generic;
+using System.Net;
+using System.Threading.Tasks;
+using XD.SDK.Common;
+using XD.SDK.Common.Internal.Standalone;
+namespace XD.SDK.Account.Internal.Standalone
+{
+    public class FacebookAuth : WebAuth
+    {
+        static List<HttpListener> servers = new List<HttpListener>();
+
+        internal static Task<Dictionary<string, object>> GetAuthData()
+        {
+            Dictionary<string, object> queryParams = new Dictionary<string, object>
+            {
+                { "auth_type", "facebook" },
+                { "client_id", ConfigModule.Facebook.AppId },
+                { "state", LocalServerUtils.GenerateRandomDataBase64url(32) }
+            };
+
+            return StartListener(servers, LoginType.Facebook, queryParams);
+        }
+    }
+}
+
+#endif

package/Runtime/Internal/Standalone/Auth/FacebookAuth.cs.meta

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

package/Runtime/Internal/Standalone/Auth/GoogleAuth.cs

@@ -0,0 +1,27 @@
+#if UNITY_EDITOR || UNITY_STANDALONE
+using System.Collections.Generic;
+using System.Net;
+using System.Threading.Tasks;
+using XD.SDK.Common;
+using XD.SDK.Common.Internal.Standalone;
+
+namespace XD.SDK.Account.Internal.Standalone
+{
+    internal class GoogleAuth : WebAuth
+    {
+        static List<HttpListener> servers = new List<HttpListener>();
+
+        internal static Task<Dictionary<string, object>> GetAuthData()
+        {
+            Dictionary<string, object> queryParams = new Dictionary<string, object>
+            {
+                { "auth_type", "google" },
+                { "client_id", ConfigModule.Google.ClientIdForPC },
+                { "state", LocalServerUtils.GenerateRandomDataBase64url(32) }
+            };
+
+            return StartListener(servers, LoginType.Google, queryParams);
+        }
+    }
+}
+#endif

package/Runtime/Internal/Standalone/Auth/GoogleAuth.cs.meta

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

package/Runtime/Internal/Standalone/Auth/GuestAuth.cs

@@ -0,0 +1,22 @@
+#if UNITY_EDITOR || UNITY_STANDALONE
+using System.Collections.Generic;
+using UnityEngine;
+using XD.SDK.Common;
+
+namespace XD.SDK.Account.Internal.Standalone
+{
+    public class GuestAuth
+    {
+        public static Dictionary<string, object> GetAuthData()
+        {
+            AliyunTrack.LoginAuthorize();
+            AliyunTrack.LoginAuthorizeSuccess();
+            return new Dictionary<string, object>
+            {
+                { "type", (int)LoginType.Guest },
+                { "token", SystemInfo.deviceUniqueIdentifier }
+            };
+        }
+    }
+}
+#endif

package/Runtime/Internal/Standalone/Auth/GuestAuth.cs.meta

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

package/Runtime/Internal/Standalone/Auth/PhoneAuth.cs

@@ -0,0 +1,43 @@
+#if UNITY_EDITOR || UNITY_STANDALONE
+using System;
+using System.Collections.Generic;
+using System.Threading.Tasks;
+
+namespace XD.SDK.Common.Internal.Standalone {
+    public class PhoneAuth {
+        //internal static Task<object> Login() {
+        //    TaskCompletionSource<object> tcs = new TaskCompletionSource<object>();
+
+        //    UIManager.ShowUI<PhoneVerificationAlert>("XDPhoneLoginAlert", null, async (code, data) => {
+        //        PhoneVerificationAlert.VerificationData verificationData = data as PhoneVerificationAlert.VerificationData;
+        //        try {
+        //            UIManager.ShowLoading();
+        //            Dictionary<string, object> authData = new Dictionary<string, object> {
+        //                { "type", (int) Account.LoginType.Phone },
+        //                { "token", verificationData.PhoneNumber },
+        //                { "secret", verificationData.Code },
+        //                { "subType", "text" }
+        //            };
+        //            await AccessTokenModule.Login(authData, null);
+        //            UIManager.Dismiss();
+        //            tcs.TrySetResult(null);
+        //        } catch (XDException e) {
+        //            if (e.code == 40114) {
+        //                // 验证码错误
+        //                verificationData.PhoneVerificationAlert.VerifyFailed();
+        //            } else {
+        //                tcs.TrySetException(e);
+        //            }
+        //        } catch (Exception e) {
+        //            tcs.TrySetException(e);
+        //        } finally {
+        //            UIManager.DismissLoading();
+        //        }
+        //    });
+
+        //    return tcs.Task;
+        //}
+
+    }
+}
+#endif

package/Runtime/Internal/Standalone/Auth/PhoneAuth.cs.meta

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