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

package/Runtime/Internal/Standalone/UserModule.cs

@@ -0,0 +1,597 @@
+#if UNITY_EDITOR || UNITY_STANDALONE
+using System;
+using System.IO;
+using System.Threading.Tasks;
+using System.Collections.Generic;
+using System.Linq;
+using UnityEngine;
+using XD.SDK.Common;
+using XD.SDK.Common.Internal;
+using XD.SDK.Common.Internal.Events;
+using XD.SDK.Common.Internal.Standalone;
+
+namespace XD.SDK.Account.Internal.Standalone
+{
+    public class UserModule
+    {
+        public class CodeScope
+        {
+            // Code Scope 个人信息页
+            public static readonly string USER_INFO = "userinfo";
+        }
+
+        // 获取用户信息
+        private static readonly string XDG_USER_PROFILE = "api/account/v2/info";
+
+        // 与leanCloud同步
+        private static readonly string XDG_LOGIN_SYN = "api/login/v1/syn";
+
+        // 获取用户绑定信息
+        private static readonly string XDG_BIND_LIST = "api/account/v1/bind/list";
+
+        // 绑定接口
+        public static readonly string XDG_BIND_INTERFACE = "api/account/v1/bind";
+
+        // 解绑接口
+        public static readonly string XDG_UNBIND_INTERFACE = "api/account/v1/unbind";
+
+        // 取消注销申请
+        public static readonly string XDG_CANCEL_DELETE = "api/account/v1/cancel-delete";
+
+        // 获取授权Code
+        public static readonly string XDG_AUTH_CODE = "/api/account/v1/apply/code";
+
+        // 个人信息页
+        public static readonly string XDG_PERSONAL_INFO = "/personal-info";
+
+        private static readonly Persistence persistence = new Persistence(Path.Combine(Application.persistentDataPath,
+            XDGConstants.XD_PERSISTENCE_NAME,
+            "user_v2"));
+
+        public static XDGUser current = null;
+
+        static UserModule()
+        {
+            // 迁移旧数据
+            string v1Path = Path.Combine(Application.persistentDataPath,
+                XDGConstants.XD_PERSISTENCE_NAME,
+                "user");
+            if (File.Exists(v1Path))
+            {
+                // 迁移
+                try
+                {
+                    string v2Path = Path.Combine(Application.persistentDataPath,
+                        XDGConstants.XD_PERSISTENCE_NAME,
+                        "user_v2");
+                    string encryptedData = EncryptionUtils.Encrypt(File.ReadAllText(v1Path), SystemInfo.deviceUniqueIdentifier);
+                    File.WriteAllText(v2Path, encryptedData);
+
+                    File.Delete(v1Path);
+                }
+                catch (Exception e)
+                {
+                    XDGLogger.Warn(e.Message);
+                }
+            }
+        }
+
+        public static XDGUser GetCurrentUser()
+        {
+            return current;
+        }
+
+        public static async Task<XDGUser> GetLocalUser()
+        {
+            if (current == null)
+            {
+                current = await persistence.Load<XDGUser>(SystemInfo.deviceUniqueIdentifier);
+            }
+
+            return current;
+        }
+
+        public static void ClearUserData()
+        {
+            persistence.Delete();
+            current = null;
+        }
+
+        public static async Task<List<Bind>> GetBindList()
+        {
+            BindResponse response = await XDHttpClient.Client.GetAsync<BindResponse>(XDG_BIND_LIST);
+            return response.Binds;
+        }
+
+        public static async Task Bind(LoginType loginType)
+        {
+            if (loginType == LoginType.Phone)
+            {
+                AliyunTrack.ResetPhoneLoginData();
+                if (XDGCommonInternal.IsCn())
+                {
+                    await PhoneModule.Bind();
+                }
+                else
+                {
+                    await PhoneModuleIO.LoginOrBind(false);
+                }
+
+                return;
+            }
+            else if (loginType == LoginType.Email)
+            {
+                if (XDGCommonInternal.IsCn())
+                {
+                    XDGLogger.Warn("暂不支持的登录方式");
+                    throw new XDGError(ResponseCode.Common.UnavailableService, "暂不支持的登录方式");
+                }
+                else
+                {
+                    await EmailModule.LoginOrBind(false);
+                }
+
+                return;
+            }
+
+            Dictionary<string, object> authData = await GetLoginAuthData(loginType);
+            await XDHttpClient.Client.PostAsync<BaseResponse>(XDG_BIND_INTERFACE, data: authData);
+        }
+
+        public static Task Unbind(LoginType loginType, Dictionary<string, object> extras = null)
+        {
+            if (loginType == LoginType.Phone)
+            {
+                AliyunTrack.ResetPhoneLoginData();
+                // 手机号解绑需要验证码
+                if (XDGCommonInternal.IsCn())
+                {
+                    return PhoneModule.Unbind(extras);
+                }
+                else
+                {
+                    return PhoneModuleIO.Unbind(extras);
+                }
+            }
+            else if (loginType == LoginType.Email)
+            {
+                if (XDGCommonInternal.IsCn())
+                {
+                    XDGLogger.Warn("暂不支持的登录方式");
+                    throw new XDGError(ResponseCode.Common.UnavailableService, "暂不支持的登录方式");
+                }
+                else
+                {
+                    return EmailModule.Unbind(extras);
+                }
+            }
+
+            Dictionary<string, object> data = new Dictionary<string, object>()
+            {
+                { "type", (int)loginType }
+            };
+            return XDHttpClient.Client.PostAsync<BaseResponse>(XDG_UNBIND_INTERFACE, data: data);
+        }
+
+        public static async Task<XDGUser> Login(LoginType loginType)
+        {
+            if (XDGCommonInternal.IsCn() && loginType == LoginType.Email)
+            {
+                XDGLogger.Warn("暂不支持的登录方式");
+                throw new XDGError(ResponseCode.Common.UnavailableService, "暂不支持的登录方式");
+            }
+
+            if (loginType == LoginType.Console)
+            {
+                return await LoginByConsole();
+            }
+            
+            var localUser = await GetLocalUser();
+
+            if (loginType == LoginType.Default)
+            {
+                if (localUser == null)
+                {
+                    XDGLogger.Warn("缺少本地登录信息");
+                    if (ConfigModule.UsingTapPC && !ConfigModule.DisableAutoLogin2Tap)
+                    {
+                        return await Login(LoginType.TapTap);
+                    }
+                    throw new XDGError(ResponseCode.Common.Failed, XDLocalization.GetCurrentLocalizableString().LoginFailed);
+                }
+
+                if (localUser.GetLoginType() == LoginType.TapTap)
+                {
+                    try
+                    {
+                        var token = await XDGEventBus.PublishAsync<Dictionary<string, object>>(XDGEvents.TapSDKGetAccessToken);
+                        
+                        if (token == null || !token.ContainsKey("token"))
+                        {
+                            XDGLogger.Warn("Third token expired.");
+                            throw new XDGError(ResponseCode.Account.TokenExpired, "Third token expired.");
+                        }
+                    }
+                    catch (Exception e)
+                    {
+                        XDGLogger.Warn(e.Message);
+                        throw new XDGError(ResponseCode.Common.Failed, e.Message);
+                    }
+                }
+                
+                try
+                {
+                    localUser = await FetchUserInfo();
+                }
+                catch (XDHttpException e)
+                {
+                    if (e.HttpStatusCode == 401 || e.Code == 40311 || e.Code == 40312)
+                    {
+                        throw e;
+                    }
+                }
+                catch (Exception e)
+                {
+                    XDGLogger.Warn(e.Message);
+                }
+
+                _ = AccessTokenModule.Refresh();
+                
+                return localUser;
+            }
+
+            try
+            {
+                AliyunTrack.LoginEnableAuthorizeTrack();
+                // 单独处理手机号登录
+                if (loginType == LoginType.Phone)
+                {
+                    AliyunTrack.ResetPhoneLoginData();
+                    AliyunTrack.LoginEnableSDKLoginTrack();
+                    if (XDGCommonInternal.IsCn())
+                    {
+                        await PhoneModule.Login();
+                    }
+                    else
+                    {
+                        await PhoneModuleIO.LoginOrBind(true);
+                    }
+
+                    UIManager.ShowLoading();
+                }
+                else if (loginType == LoginType.Email)
+                {
+                    AliyunTrack.ResetEmailLoginData();
+                    AliyunTrack.LoginEnableSDKLoginTrack();
+                    await EmailModule.LoginOrBind(true);
+                    UIManager.ShowLoading();
+                }
+                else
+                {
+                    Dictionary<string, object> loginParams = await GetLoginAuthData(loginType);
+                    UIManager.ShowLoading();
+                    Dictionary<string, object> cacheData = GetCacheData(loginType);
+                    await AccessTokenModule.Login(loginParams, cacheData);
+                }
+
+                AliyunTrack.LoginEnableSDKLoginTrack();
+                var user = await FetchUserInfo();
+                try
+                {
+                    await SyncTDSUser(user.UserId);
+                }
+                catch (Exception e)
+                {
+                    XDGLogger.Warn(e.ToString());
+                }
+                XDGLogger.Debug(string.Format($"xd userID: {user.UserId}"));
+                return user;
+            }
+            catch (XDGError e)
+            {
+                UIManager.DismissLoading();
+                if (e.ExtraData != null)
+                {
+                    LocalizableString localizableString = XDLocalization.GetCurrentLocalizableString();
+                    if (e.Code == 40021 || e.Code == 40901 || e.Code == 40902)
+                    {
+                        string title = null;
+                        string content = null;
+                        string lt = e.ExtraData["loginType"] as string;
+                        string email = e.ExtraData["email"] as string;
+                        if (e.Code == 40021)
+                        {
+                            title = localizableString.EmailNotVerified;
+                            content = string.Format(localizableString.LoginEmailNotVerified, lt, email, lt);
+                        }
+                        else if (e.Code == 40901)
+                        {
+                            title = localizableString.AccountAlreadyExists;
+                            string conflicts = string.Join("/",
+                                (e.ExtraData["conflicts"] as List<object>).Select(item => (item as Dictionary<string, object>)["loginType"]));
+                            content = string.Format(localizableString.LoginEmailConflict, lt, email, conflicts);
+                        }
+                        else if (e.Code == 40902)
+                        {
+                            title = localizableString.AccountAlreadyExists;
+                            string conflicts = string.Join("/",
+                                (e.ExtraData["conflicts"] as List<object>).Select(item => (item as Dictionary<string, object>)["loginType"]));
+                            content = string.Format(localizableString.BindEmailConflict, lt, email, lt, conflicts);
+                        }
+
+                        Dictionary<string, object> conf = new Dictionary<string, object>
+                        {
+                            { ConfirmDialog.TITLE_KEY, title },
+                            { ConfirmDialog.CONTENT_KEY, content },
+                            { ConfirmDialog.CONFIRM_TEXT_KEY, localizableString.IUnderstand }
+                        };
+
+                        TaskCompletionSource<XDGUser> tcs = new TaskCompletionSource<XDGUser>();
+                        UIManager.ShowUI<ConfirmDialog>(conf, (code, data) =>
+                        {
+                            UIManager.Dismiss();
+                            // e.ExtraData = null;
+                            tcs.TrySetException(e);
+                        });
+                        return await tcs.Task;
+                    }
+                    else
+                    {
+                        throw e;
+                    }
+                }
+                else
+                {
+                    throw e;
+                }
+            }
+            finally
+            {
+                UIManager.DismissLoading();
+            }
+        }
+
+        public static async Task<XDGUser> LoginByConsole()
+        {
+            // 判断当前有接入哪个主机 SDK
+            if (SteamUtils.IsSDKSupported)
+            {
+                try
+                {
+                    AliyunTrack.LoginStart("Default_Steam", "Steam");
+                    UIManager.ShowLoading();
+                    
+                    XDGAccessToken localToken = await AccessTokenModule.GetLocalAccessToken();
+                    string steamId = SteamAuth.GetSteamIdFromSDK();
+                    XDGUser user;
+                    XDGLogger.Debug($"LoginByConsole steamId: {steamId} localToken: {localToken} steamId: {steamId}" );
+                    if (!string.IsNullOrEmpty(localToken?.SteamId) && !string.IsNullOrEmpty(steamId) && localToken?.SteamId == steamId)
+                    {
+                        try
+                        {
+                            user = await FetchUserInfo();
+                            // 同自动登录一样，触发刷新 token
+                            _ = AccessTokenModule.Refresh();
+                        }
+                        catch (XDGError e)
+                        {
+                            if (e.Code == ResponseCode.Account.TokenExpired)
+                            {
+                                // Token 过期
+                                AliyunTrack.LoginEnableSlientAuthorize();
+                                user = await LoginByConsoleInternal();
+                            }
+                            else
+                            {
+                                throw e;
+                            }
+                        }
+                    }
+                    else
+                    {
+                        // 当前 steamId 与缓存 steamId 不一致，则使用当前 steam 信息重新授权（相当于忽略本地缓存）
+                        user = await LoginByConsoleInternal();
+                    }
+
+                    try
+                    {
+                        await SyncTDSUser(user.UserId);
+                    }
+                    catch (Exception e)
+                    {
+                        XDGLogger.Warn(e.ToString());
+                    }
+
+                    XDGLogger.Debug(string.Format($"xd userID: {user.UserId}"));
+                    return user;
+                }
+                finally
+                {
+                    UIManager.DismissLoading();
+                }
+            }
+            // 尝试其他主机 SDK
+            throw new NotImplementedException("NO supported console sdk.");
+        }
+
+        internal static async Task<XDGUser> LoginByConsoleInternal()
+        {
+            AliyunTrack.LoginEnableAuthorizeTrack();
+            Dictionary<string, object> authData = await SteamAuth.GetAuthDataFromSDK();
+            Dictionary<string, object> cacheData = SteamAuth.GetCacheData();
+            AliyunTrack.LoginEnableSDKLoginTrack();
+            await AccessTokenModule.SignIn(authData, cacheData);
+            return await FetchUserInfo();
+        }
+
+        internal static async Task<Dictionary<string, object>> GetLoginAuthData(LoginType loginType)
+        {
+            switch (loginType)
+            {
+                case LoginType.Guest:
+                    return GuestAuth.GetAuthData();
+                case LoginType.TapTap:
+                    return await TapAuth.GetAuthData();
+                case LoginType.Apple:
+                    return await AppleAuth.GetAuthData();
+                case LoginType.Google:
+                    return await GoogleAuth.GetAuthData();
+                case LoginType.Steam:
+                    return await SteamAuth.GetAuthData();
+                case LoginType.Facebook:
+                    return await FacebookAuth.GetAuthData();
+                default:
+                    return new Dictionary<string, object>();
+            }
+        }
+
+        internal static Dictionary<string, object> GetCacheData(LoginType loginType)
+        {
+            switch (loginType)
+            {
+                case LoginType.Steam:
+                    return SteamAuth.GetCacheData();
+                default:
+                    return null;
+            }
+        }
+
+        private static async Task SyncTDSUser(string userId)
+        {
+            // 效果等于 BecomeWithSessionToken,为了少一次网络请求
+            // SyncTokenResponse tokenResponse = await XDHttpClient.Client.PostAsync<SyncTokenResponse>(XDG_LOGIN_SYN);
+            // TDSUser user = TDSUser.CreateWithoutData(TDSUser.CLASS_NAME, userId) as TDSUser;
+            // user.SessionToken = tokenResponse.SyncToken.SessionToken;
+            // await user.SaveToLocal();
+            var token = await XDHttpClient.Client.PostAsync<SyncTokenResponse>(XDG_LOGIN_SYN);
+            
+            XDGEventBus.Publish(XDGEvents.TdsSDKSyncUser, token.SyncToken.SessionToken, userId);
+        }
+
+        public static async Task<XDGUser> FetchUserInfo()
+        {
+            try
+            {
+                ProfileResponse response = await XDHttpClient.Client.GetAsync<ProfileResponse>(XDG_USER_PROFILE);
+
+                if (current == null)
+                {
+                    current = response.User;
+                }
+                else
+                {
+                    current.Update(response.User);
+                }
+
+                await persistence.Save(current, SystemInfo.deviceUniqueIdentifier);
+                AliyunTrack.LoginPreSuccess();
+                return current;
+            }
+            catch (XDHttpException xdException)
+            {
+                if (xdException.Code == 40312 && xdException.ExtraData != null)
+                {
+                    var extra = xdException.ExtraData["extra"] as Dictionary<string, object>;
+                    var realNameUrl = extra?["url"] as string;
+                    if (!string.IsNullOrEmpty(realNameUrl))
+                    {
+                        var tcs = new TaskCompletionSource<XDGUser>();
+                        XDGCommon.OpenWebPage(realNameUrl, async (action, data) =>
+                        {
+                            if (action == WebActionEnum.CLOSE)
+                            {
+                                if (data != null)
+                                {
+                                    data.TryGetValue("success", out var success);
+                                    if (success is bool)
+                                    {
+                                        if ((bool)success)
+                                        {
+                                            tcs.SetResult(await FetchUserInfo());
+                                        }
+                                        return;
+                                    }
+                                }
+                            }
+
+                            tcs.TrySetException(xdException);
+                        });
+                        return await tcs.Task;
+                    }
+                }
+
+                if (xdException.Code == 40311 && xdException.ExtraData != null)
+                {
+                    var title = xdException.ExtraData["title"] as string;
+                    var content = xdException.ExtraData["content"] as string;
+                    var negativeButton = xdException.ExtraData["negativeButton"] as string;
+                    var positiveButton = xdException.ExtraData["positiveButton"] as string;
+
+                    if (title != null && content != null)
+                    {
+                        var config = new Dictionary<string, object>
+                        {
+                            { Dialog.TITLE_KEY, title },
+                            { Dialog.CONTENT_KEY, content },
+                            { Dialog.PRIMARY_TEXT_KEY, positiveButton },
+                            { Dialog.SECONDARY_TEXT_KEY, negativeButton }
+                        };
+
+                        var tcs = new TaskCompletionSource<XDGUser>();
+                        UIManager.ShowUI<Dialog>("Dialog", config, async (code, data) =>
+                        {
+                            if (code == 1 || code == -1)
+                            {
+                                UIManager.Dismiss();
+                                tcs.TrySetException(xdException);
+                            }
+                            else
+                            {
+                                await CancelDelete();
+                                UIManager.Dismiss();
+                                tcs.SetResult(await FetchUserInfo());
+                            }
+                        });
+                        UIManager.DismissLoading();
+                        return await tcs.Task;
+                    }
+                }
+
+                var errorMsg = xdException.Message;
+                // 所有 40801 错误代表 401 授权失败,需要明示原因为 XD_TOKEN_EXPIRED
+                if (xdException.Code == ResponseCode.Account.TokenExpired || xdException.HttpStatusCode == 401)
+                    errorMsg = "XD_TOKEN_EXPIRED";
+                AliyunTrack.LoginPreFail(errorMsg);
+                throw xdException;
+            }
+            catch (Exception e)
+            {
+                AliyunTrack.LoginPreFail(e.Message);
+                throw e;
+            }
+        }
+
+        private static async Task CancelDelete()
+        {
+            UIManager.ShowLoading();
+            try
+            {
+                await XDHttpClient.Client.PostAsync<BaseResponse>(XDG_CANCEL_DELETE);
+                UIManager.DismissLoading();
+            }
+            catch (Exception e)
+            {
+                UIManager.DismissLoading();
+                var errorMsg = XDLocalization.GetCurrentLocalizableString().NetworkErrorSafeRetry;
+                if (e is XDGError xdException && !string.IsNullOrEmpty(xdException.ErrorMsg))
+                {
+                    errorMsg = xdException.ErrorMsg;
+                }
+
+                UIManager.ShowToast(errorMsg);
+                throw e;
+            }
+        }
+    }
+}
+#endif

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

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

package/Runtime/Internal/Standalone/WebFunction/AccessTokenWebFunction.cs

@@ -0,0 +1,47 @@
+#if UNITY_EDITOR || UNITY_STANDALONE
+
+using System;
+using System.Collections.Generic;
+using XD.SDK.Common;
+using XD.SDK.Common.Internal;
+using XD.SDK.Common.Internal.Standalone;
+
+namespace XD.SDK.Account.Internal.Standalone
+{
+    public class AccessTokenWebFunction : IWebFunction
+    {
+        public string GetName()
+        {
+            return "getAccessToken";
+        }
+
+        public async void Handler(IBridgeWebView webView, string data, Action<object> callbackFunction)
+        {
+            XDGLogger.Debug($"message from javascript by:{GetName()} with data:{data}");
+            var token = await AccessTokenModule.GetLocalAccessToken();
+            if (token == null)
+            {
+                callbackFunction(new WebBridgeResponse.Failed
+                {
+                    Msg = "AccessToken is null!"
+                });
+                return;
+            }
+
+            var result = new Dictionary<string, object>
+            {
+                { "expireIn", token.ExpireIn },
+                { "macKey", token.MacKey },
+                { "macAlgorithm", token.MacAlgorithm },
+                { "tokenType", token.TokenType },
+                { "kid", token.Kid }
+            };
+
+            callbackFunction(new WebBridgeResponse.Success
+            {
+                Data = result
+            });
+        }
+    }
+}
+#endif

package/Runtime/Internal/Standalone/WebFunction/AccessTokenWebFunction.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 567b5e9620564fe89dc5767d53ec2393
+timeCreated: 1753339498

package/Runtime/Internal/Standalone/WebFunction.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: df785d454b4044e8b6234b3d167a6ee3
+timeCreated: 1753339610

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

@@ -1,5 +1,5 @@
 fileFormatVersion: 2
-guid: 5a0325abf107a43c988e1612aeddd17b
+guid: 89cb1a6563bc46879d197296e3f88d58
 folderAsset: yes
 DefaultImporter:
   externalObjects: {}

package/Runtime/Internal/XDGAccountEventHandler.cs

@@ -0,0 +1,21 @@
+using UnityEngine;
+using XD.SDK.Common.Internal.Events;
+
+#if UNITY_EDITOR || UNITY_STANDALONE
+using XD.SDK.Account.Internal.Standalone;
+#endif
+
+namespace XD.SDK.Account
+{
+    public static class XDGAccountEventHandler
+    {
+        [RuntimeInitializeOnLoadMethod(RuntimeInitializeLoadType.BeforeSceneLoad)]
+        static void RegisterEventHandlers()
+        {
+            XDGEventBus.Subscribe(XDGEvents.AccountGetCurrentUser, _ => XDGAccount.GetCurrentUser());
+#if UNITY_EDITOR || UNITY_STANDALONE
+            XDGEventBus.SubscribeAsync(XDGEvents.AccountGetAccessToken, async _ => await AccessTokenModule.GetLocalAccessToken());
+#endif
+        }
+    }
+}