com.taptap.sdk.login 4.3.0-aplha.13

package/Standalone/Runtime/Internal2/AccountManager.cs

@@ -0,0 +1,87 @@
+using System.Collections.Generic;
+using JetBrains.Annotations;
+using Newtonsoft.Json;
+using TapSDK.Core;
+
+namespace TapSDK.Login.Internal
+{
+    public class AccountManager
+    {
+        private static readonly string _accessToken = "taptapsdk_accesstoken";
+        private static readonly string _profile = "taptapsdk_profile";
+        private static readonly string _account = "taptapsdk_account";
+        
+        private static AccountManager _instance;
+
+        private AccountManager()
+        {
+        }
+
+        public static AccountManager Instance
+        {
+            get
+            {
+                if (_instance == null)
+                {
+                    _instance = new AccountManager();
+                    // 自动初始化
+                    _instance.Init();
+                }
+                return _instance;
+            }
+        }
+
+        private TapTapAccount _tapAccount;
+        [CanBeNull]
+        public TapTapAccount Account
+        {
+            get
+            {
+                return _tapAccount;
+            }
+            set
+            {
+                _tapAccount = value;
+                if (value == null)
+                {
+                    DataStorage.SaveString(_account, null);
+                }
+                else
+                {
+                    DataStorage.SaveString(_account, value.ToJson());
+                }
+            }
+        }
+
+        public void Init()
+        {
+            var accountStr = DataStorage.LoadString(_account);
+            if (!string.IsNullOrEmpty(accountStr))
+            {
+                Account = new TapTapAccount(Json.Deserialize(accountStr) as Dictionary<string, object>);
+            }
+            else
+            {
+                var accessTokenStr = DataStorage.LoadString(_accessToken);
+                if (string.IsNullOrEmpty(accessTokenStr))
+                {
+                    return;
+                }
+            
+                var profileStr = DataStorage.LoadString(_profile);
+                if (string.IsNullOrEmpty(profileStr))
+                {
+                    return;
+                }
+                var accessToken = JsonConvert.DeserializeObject<AccessToken>(accessTokenStr);
+                var profile = JsonConvert.DeserializeObject<Profile>(profileStr);
+                Account = new TapTapAccount(accessToken, profile.openid, profile.unionid, profile.name, profile.avatar, profile.email);
+            }
+        }
+
+        public void ClearCache()
+        {
+            Account = null;
+        }
+    }
+}

package/Standalone/Runtime/Internal2/AccountManager.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 000f0a993f0348ffb92533caedcdcce3
+timeCreated: 1716541112

package/Standalone/Runtime/Internal2/AuthorizationProviderImpl.cs

@@ -0,0 +1,13 @@
+using System.Threading.Tasks;
+using TapSDK.Login.Standalone;
+
+namespace TapSDK.Login.Internal
+{
+    public class AuthorizationProviderImpl : IAuthorizationProvider
+    {
+        public Task<AccessToken> Authorize(string[] scopes = null)
+        {
+            return TapLoginStandaloneImpl.Instance.Authorize(scopes);
+        }
+    }
+}

package/Standalone/Runtime/Internal2/AuthorizationProviderImpl.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 4afa00fbfdd84703a615d052000a9888
+timeCreated: 1717472965

package/Standalone/Runtime/Internal2/Http/LoginHttpClient.cs

@@ -0,0 +1,139 @@
+using System;
+using System.Net;
+using System.Text;
+using System.Linq;
+using System.Collections.Generic;
+using System.Net.Http;
+using System.Net.Http.Headers;
+using System.Threading.Tasks;
+using System.Security.Cryptography;
+using Newtonsoft.Json;
+using TapSDK.Core;
+using TapSDK.Core.Internal.Json;
+using TapSDK.Core.Internal.Http;
+
+namespace TapSDK.Login.Internal.Http {
+    public class LoginHttpClient {
+        private readonly HttpClient client;
+
+        public LoginHttpClient() {
+            client = new HttpClient();
+            client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/x-www-form-urlencoded"));
+        }
+
+        public Task<T> Get<T>(string url,
+            Dictionary<string, object> headers = null,
+            Dictionary<string, object> queryParams = null) {
+            return Request<T>(url, HttpMethod.Get, headers, null, queryParams);
+        }
+
+        public Task<T> Post<T>(string url,
+            Dictionary<string, object> headers = null,
+            object data = null,
+            Dictionary<string, object> queryParams = null) {
+            return Request<T>(url, HttpMethod.Post, headers, data, queryParams);
+        }
+
+        public Task<T> Put<T>(string url,
+            Dictionary<string, object> headers = null,
+            object data = null,
+            Dictionary<string, object> queryParams = null) {
+            return Request<T>(url, HttpMethod.Put, headers, data, queryParams);
+        }
+
+        public Task Delete(string url,
+            Dictionary<string, object> headers = null,
+            object data = null,
+            Dictionary<string, object> queryParams = null) {
+            return Request<Dictionary<string, object>>(url, HttpMethod.Delete, headers, data, queryParams);
+        }
+
+        async Task<T> Request<T>(string url,
+            HttpMethod method,
+            Dictionary<string, object> headers = null,
+            object data = null,
+            Dictionary<string, object> queryParams = null) {
+            url = BuildUrl(url, queryParams);
+            HttpRequestMessage request = new HttpRequestMessage {
+                RequestUri = new Uri(url),
+                Method = method,
+            };
+            FillHeaders(request.Headers, headers);
+
+            string content = null;
+            if (data != null) {
+                content = JsonConvert.SerializeObject(data);
+                Dictionary<string, string> formData = JsonConvert.DeserializeObject<Dictionary<string, object>>(content)
+                    .ToDictionary(item => item.Key, item => item.Value.ToString());
+                FormUrlEncodedContent requestContent = new FormUrlEncodedContent(formData);
+                request.Content = requestContent;
+            }
+            TapHttpUtils.PrintRequest(client, request, content);
+            HttpResponseMessage response = await client.SendAsync(request, HttpCompletionOption.ResponseHeadersRead);
+            request.Dispose();
+
+            string resultString = await response.Content.ReadAsStringAsync();
+            response.Dispose();
+            TapHttpUtils.PrintResponse(response, resultString);
+
+            if (response.IsSuccessStatusCode) {
+                T ret = JsonConvert.DeserializeObject<T>(resultString,
+                    TapJsonConverter.Default);
+                return ret;
+            }
+            throw HandleErrorResponse(response.StatusCode, resultString);
+        }
+
+        TapException HandleErrorResponse(HttpStatusCode statusCode, string responseContent) {
+            int code = (int)statusCode;
+            string message = responseContent;
+            try {
+                ErrorResponse response = JsonConvert.DeserializeObject<ErrorResponse>(responseContent,
+                    TapJsonConverter.Default);
+                code = response.Data.Code;
+                message = response.Data.Error;
+            } catch (Exception e) {
+                TapLogger.Error(e);
+            }
+            return new TapException(code, message);
+        }
+
+        string BuildUrl(string url, Dictionary<string, object> queryParams) {
+            if (queryParams != null) {
+                IEnumerable<string> queryPairs = queryParams.Select(kv => $"{kv.Key}={kv.Value}");
+                string queries = string.Join("&", queryPairs);
+                url = $"{url}?{queries}";
+            }
+            return url;
+        }
+
+        void FillHeaders(HttpRequestHeaders headers, Dictionary<string, object> reqHeaders = null) {
+            // 额外 headers
+            if (reqHeaders != null) {
+                foreach (KeyValuePair<string, object> kv in reqHeaders) {
+                    headers.Add(kv.Key, kv.Value.ToString());
+                }
+            }
+
+            // 签名
+            long timestamp = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds();
+            string hash = GetMd5Hash($"{timestamp}");
+            string sign = $"{hash},{timestamp}";
+            headers.Add("X-LC-Sign", sign);
+        }
+
+        static string GetMd5Hash(string input) {
+            MD5 md5 = MD5.Create();
+            byte[] data = md5.ComputeHash(Encoding.UTF8.GetBytes(input));
+            return ToHex(data);
+        }
+
+        static string ToHex(byte[] bytes) {
+            StringBuilder sb = new StringBuilder();
+            for (int i = 0; i < bytes.Length; i++) {
+                sb.Append(bytes[i].ToString("x2"));
+            }
+            return sb.ToString();
+        }
+    }
+}

package/Standalone/Runtime/Internal2/Http/LoginHttpClient.cs.meta

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

package/Standalone/Runtime/Internal2/Http/Response/ErrorResponse.cs

@@ -0,0 +1,16 @@
+using Newtonsoft.Json;
+
+namespace TapSDK.Login.Internal.Http {
+    public class ErrorData {
+        [JsonProperty("code")]
+        public int Code { get; set; }
+
+        [JsonProperty("error")]
+        public string Error { get; set; }
+    }
+
+    public class ErrorResponse {
+        [JsonProperty("data")]
+        public ErrorData Data { get; set; }
+    }
+}

package/Standalone/Runtime/Internal2/Http/Response/ErrorResponse.cs.meta

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

package/Standalone/Runtime/Internal2/Http/Response/ProfileResponse.cs

@@ -0,0 +1,28 @@
+using Newtonsoft.Json;
+
+namespace TapSDK.Login.Internal.Http {
+    public class ProfileData {
+        [JsonProperty("openid")]
+        public string OpenId { get; set; }
+
+        [JsonProperty("unionid")]
+        public string UnionId { get; set; }
+
+        [JsonProperty("name")]
+        public string Name { get; set; }
+
+        [JsonProperty("gender")]
+        public string Gender { get; set; }
+
+        [JsonProperty("avatar")]
+        public string Avatar { get; set; }
+        
+        [JsonProperty("email")]
+        public string Email { get; set; }
+    }
+
+    public class ProfileResponse {
+        [JsonProperty("data")]
+        public ProfileData Data { get; set; }
+    }
+}

package/Standalone/Runtime/Internal2/Http/Response/ProfileResponse.cs.meta

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

package/Standalone/Runtime/Internal2/Http/Response/QRCodeResponse.cs

@@ -0,0 +1,22 @@
+using Newtonsoft.Json;
+
+namespace TapSDK.Login.Internal.Http {
+    public class QRCodeData {
+        [JsonProperty("device_code")]
+        public string DeviceCode { get; set; }
+
+        [JsonProperty("expires_in")]
+        public int ExpiresIn { get; set; }
+
+        [JsonProperty("qrcode_url")]
+        public string Url { get; set; }
+
+        [JsonProperty("interval")]
+        public int Interval { get; set; }
+    }
+
+    public class QRCodeResponse {
+        [JsonProperty("data")]
+        public QRCodeData Data { get; set; }
+    }
+}

package/Standalone/Runtime/Internal2/Http/Response/QRCodeResponse.cs.meta

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

package/Standalone/Runtime/Internal2/Http/Response/TokenResponse.cs

@@ -0,0 +1,33 @@
+using System.Collections.Generic;
+using Newtonsoft.Json;
+
+namespace TapSDK.Login.Internal.Http {
+    public class TokenData {
+        [JsonProperty("kid")]
+        public string Kid { get; set; }
+
+        [JsonProperty("access_token")]
+        public string Token { get; set; }
+
+        [JsonProperty("token_type")]
+        public string TokenType { get; set; }
+
+        [JsonProperty("mac_key")]
+        public string MacKey { get; set; }
+
+        [JsonProperty("mac_algorithm")]
+        public string MacAlgorithm { get; set; }
+
+        [JsonProperty("scope")]
+        public string Scope { get; set; }
+
+        [JsonIgnore]
+        public HashSet<string> Scopes => !string.IsNullOrEmpty(Scope) ? 
+            new HashSet<string>(Scope.Split(' ')) : new HashSet<string>();
+    }
+
+    public class TokenResponse {
+        [JsonProperty("data")]
+        public TokenData Data { get; set; }
+    }
+}

package/Standalone/Runtime/Internal2/Http/Response/TokenResponse.cs.meta

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

package/Standalone/Runtime/Internal2/Http/Response.meta

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

package/Standalone/Runtime/Internal2/Http.meta

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

package/Standalone/Runtime/Internal2/LoginService.cs

@@ -0,0 +1,127 @@
+using System;
+using System.Collections.Generic;
+using System.Threading.Tasks;
+using System.Security.Cryptography;
+using System.Text;
+using UnityEngine;
+using TapSDK.Login.Internal.Http;
+
+namespace TapSDK.Login.Internal {
+    public static class LoginService {
+        private static readonly LoginHttpClient httpClient = new LoginHttpClient();
+
+        public static LoginHttpClient HttpClient => httpClient;
+
+        public static async Task<QRCodeData> GetQRCodeUrl(string clientId, string[] scopes) {
+            Dictionary<string, object> data = new Dictionary<string, object> {
+                { "client_id", clientId },
+                { "response_type", "device_code" },
+                { "scope", string.Join(",", scopes) },
+                { "version", TapTapSdk.Version },
+                { "platform", "unity" },
+                { "info", "{\"device_id\":\"" + SystemInfo.deviceModel + "\"}" }
+            };
+            QRCodeResponse response = await httpClient.Post<QRCodeResponse>(TapTapSdk.CurrentRegion.CodeUrl(), 
+                data: data);
+            return response.Data;
+        }
+
+        public static async Task<TokenData> Authorize(string clientId, string code) {
+            Dictionary<string, string> data = new Dictionary<string, string> {
+                { "client_id", clientId },
+                { "grant_type", "authorization_code" },
+                { "secret_type", "hmac-sha-1" },
+                { "code", code },
+                { "redirect_uri", WebLoginRequestManager.Instance.GetCurrentRequest().GetRedirectUri() },
+                { "code_verifier", WebLoginRequestManager.Instance.GetCodeVerifier() }
+            };
+            TokenResponse response = await httpClient.Post<TokenResponse>(TapTapSdk.CurrentRegion.TokenUrl(), 
+                data: data);
+            return response.Data;
+        }
+
+        public static async Task<TokenData> RequestScanQRCodeResult(string clientId, string deviceCode) {
+            Dictionary<string, string> data = new Dictionary<string, string> {
+                { "grant_type", "device_token" },
+                { "client_id", clientId },
+                { "secret_type", "hmac-sha-1" },
+                { "code", deviceCode },
+                { "version", "1.0" },
+                { "platform", "unity" },
+                { "info", "{\"device_id\":\"" + SystemInfo.deviceModel + "\"}" }
+            };
+            TokenResponse response = await httpClient.Post<TokenResponse>(TapTapSdk.CurrentRegion.TokenUrl(), 
+                data: data);
+            return response.Data;
+        }
+
+        public static async Task<ProfileData> GetProfile(string clientId, AccessToken token, int timestamp = 0) {
+            string url = TapTapSdk.CurrentRegion.ProfileUrl(token.scopeSet.Contains(TapTapLogin.TAP_LOGIN_SCOPE_PUBLIC_PROFILE)) + clientId;
+            var uri = new Uri(url);
+            var ts = timestamp;
+            if (ts == 0) {
+                var dt = DateTime.UtcNow - new DateTime(1970, 1, 1);
+                ts = (int)dt.TotalSeconds;
+            }
+            var sign = "MAC " + GetAuthorizationHeader(token.kid,
+                token.macKey,
+                token.macAlgorithm,
+                "GET",
+                uri.PathAndQuery,
+                uri.Host,
+                "443", ts);
+            Dictionary<string, object> headers = new Dictionary<string, object> {
+                { "Authorization", sign }
+            };
+            ProfileResponse response = await httpClient.Get<ProfileResponse>(url, headers: headers);
+            return response.Data;
+        }
+        
+        public static string GetAuthorizationHeader(string kid,
+            string macKey,
+            string macAlgorithm,
+            string method,
+            string uri,
+            string host,
+            string port,
+            int timestamp) {
+            var nonce = new System.Random().Next().ToString();
+
+            var normalizedString = $"{timestamp}\n{nonce}\n{method}\n{uri}\n{host}\n{port}\n\n";
+
+            HashAlgorithm hashGenerator;
+            switch (macAlgorithm) {
+                case "hmac-sha-256":
+                    hashGenerator = new HMACSHA256(Encoding.ASCII.GetBytes(macKey));
+                    break;
+                case "hmac-sha-1":
+                    hashGenerator = new HMACSHA1(Encoding.ASCII.GetBytes(macKey));
+                    break;
+                default:
+                    throw new InvalidOperationException("Unsupported MAC algorithm");
+            }
+
+            var hash = Convert.ToBase64String(hashGenerator.ComputeHash(Encoding.ASCII.GetBytes(normalizedString)));
+
+            var authorizationHeader = new StringBuilder();
+            authorizationHeader.AppendFormat(@"id=""{0}"",ts=""{1}"",nonce=""{2}"",mac=""{3}""",
+                kid, timestamp, nonce, hash);
+
+            return authorizationHeader.ToString();
+        }
+
+        public static async Task<TokenData> RefreshToken(string clientId, string accessToken) {
+            Dictionary<string, object> data = new Dictionary<string, object> {
+                { "client_id", clientId },
+                { "grant_type", "refresh_token" },
+                { "token", accessToken },
+                { "token_type_hint", "access_token" },
+                { "platform", "unity" },
+                { "info", "{\"device_id\":\"" + SystemInfo.deviceModel + "\"}" }
+            };
+            TokenResponse response = await httpClient.Post<TokenResponse>(TapTapSdk.CurrentRegion.TokenUrl(), 
+                data: data);
+            return response.Data;
+        }
+    }
+}

package/Standalone/Runtime/Internal2/LoginService.cs.meta

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

package/Standalone/Runtime/Internal2/QRCodeUtils.cs

@@ -0,0 +1,50 @@
+using System.Collections.Generic;
+using ZXing;
+using ZXing.Common;
+using ZXing.QrCode.Internal;
+using UnityEngine;
+
+namespace TapSDK.Login.Internal {
+    public class QRCodeUtils {
+        public static Texture2D EncodeQrImage(string content, int width, int height) {
+            var writer = new MultiFormatWriter();
+            var hints = new Dictionary<EncodeHintType, object> {
+                { EncodeHintType.CHARACTER_SET, "UTF-8" },
+                //hints.Add(EncodeHintType.MARGIN, 0);
+                { EncodeHintType.ERROR_CORRECTION, ErrorCorrectionLevel.M }
+            };
+            var bitMatrix = writer.encode(content, BarcodeFormat.QR_CODE, width, height, hints);
+            bitMatrix = DeleteWhite(bitMatrix);
+            var w = bitMatrix.Width;
+            var h = bitMatrix.Height;
+            var texture = new Texture2D(w, h);
+            for (var x = 0; x < h; x++) {
+                for (var y = 0; y < w; y++) {
+                    texture.SetPixel(y, x, bitMatrix[x, y] ? Color.black : Color.white);
+                }
+            }
+
+            texture.Apply();
+            texture.filterMode = FilterMode.Point;
+            return texture;
+        }
+
+        private static BitMatrix DeleteWhite(BitMatrix matrix) {
+            var rec = matrix.getEnclosingRectangle();
+            var resWidth = rec[2];
+            var resHeight = rec[3];
+
+            var resMatrix = new BitMatrix(resWidth, resHeight);
+            resMatrix.clear();
+            for (var i = 0; i < resWidth; i++) {
+                for (var j = 0; j < resHeight; j++){
+                    if (matrix[i + rec[0], j + rec[1]]) {
+                        resMatrix.flip(i, j);
+                    }
+                }
+            }
+
+            return resMatrix;
+        }
+    }
+}

package/Standalone/Runtime/Internal2/QRCodeUtils.cs.meta

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