com.xd.sdk.tap 0.0.6-xd.1

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

@@ -0,0 +1,192 @@
+using System;
+using System.Collections.Generic;
+using System.Threading.Tasks;
+using System.Security.Cryptography;
+using System.Text;
+using UnityEngine;
+using TapSDK.Login.Internal.Http;
+using TapSDK.Core.Standalone.Internal.Http;
+using TapSDK.Login.Standalone.Internal.Http;
+
+namespace TapSDK.Login.Internal
+{
+    public static class LoginService
+    {
+        private static readonly TapHttp tapHttp = TapHttp
+            .NewBuilder("TapLogin", TapTapLogin.Version)
+            .Sign(new TapLoginSign())
+            .Build();
+
+        public static async Task<QRCodeData> GetQRCodeUrl(string clientId, string[] scopes)
+        {
+            Dictionary<string, string> data = new Dictionary<string, string> {
+                { "client_id", clientId },
+                { "response_type", "device_code" },
+                { "scope", string.Join(",", scopes) },
+                { "version", TapTapLogin.Version },
+                { "platform", "unity" },
+                { "info", "{\"device_id\":\"" + SystemInfo.deviceModel + "\"}" }
+            };
+            TapHttpResult<QRCodeData> result = await tapHttp.PostFormAsync<QRCodeData>(TapTapSdk.CurrentRegion.CodeUrl(), form: data);
+            if (result.IsSuccess)
+            {
+                return result.Data;
+            }
+            else
+            {
+                throw result.HttpException;
+            }
+        }
+
+        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() }
+            };
+            TapHttpResult<TokenData> result = await tapHttp.PostFormAsync<TokenData>(TapTapSdk.CurrentRegion.TokenUrl(), form: data);
+            if (result.IsSuccess)
+            {
+                return result.Data;
+            }
+            else
+            {
+                throw result.HttpException;
+            }
+        }
+
+         public static async Task<TokenData> Authorize(string clientId, string code, string codeVerify) {
+            Dictionary<string, string> data = new Dictionary<string, string> {
+                { "client_id", clientId },
+                { "grant_type", "authorization_code" },
+                { "secret_type", "hmac-sha-1" },
+                { "code", code },
+                { "redirect_uri", "tapoauth://authorize" },
+                { "code_verifier", codeVerify }
+            };
+            TapHttpResult<TokenData> result = await tapHttp.PostFormAsync<TokenData>(TapTapSdk.CurrentRegion.TokenUrl(), form: data);
+            if (result.IsSuccess)
+            {
+                return result.Data;
+            }
+            else
+            {
+                throw result.HttpException;
+            }
+        }
+
+        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 + "\"}" }
+            };
+            TapHttpResult<TokenData> result = await tapHttp.PostFormAsync<TokenData>(TapTapSdk.CurrentRegion.TokenUrl(), form: data);
+            if (result.IsSuccess)
+            {
+                return result.Data;
+            }
+            else
+            {
+                throw result.HttpException;
+            }
+        }
+
+        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, string> headers = new Dictionary<string, string> {
+                { "Authorization", sign }
+            };
+
+            TapHttpResult<ProfileData> result = await tapHttp.GetAsync<ProfileData>(url, headers: headers);
+            if(result.IsSuccess)
+            {
+                return result.Data;
+            }
+            else
+            {
+                throw result.HttpException;
+            }   
+        }
+
+        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, string> data = new Dictionary<string, string> {
+                { "client_id", clientId },
+                { "grant_type", "refresh_token" },
+                { "token", accessToken },
+                { "token_type_hint", "access_token" },
+                { "platform", "unity" },
+                { "info", "{\"device_id\":\"" + SystemInfo.deviceModel + "\"}" }
+            };
+            TapHttpResult<TokenData> result = await tapHttp.PostFormAsync<TokenData>(TapTapSdk.CurrentRegion.TokenUrl(), form: data);
+            if(result.IsSuccess)
+            {
+                return result.Data;
+            }
+            else
+            {
+                throw result.HttpException;
+            }       
+        }
+    }
+}

package/Login/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/Login/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/Login/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: 

package/Login/Standalone/Runtime/Internal2/TapLoginClientBridge.cs

@@ -0,0 +1,87 @@
+using System.Threading.Tasks;
+using System;
+using TapSDK.Core.Standalone;
+
+namespace TapSDK.Login.Internal
+{
+#if UNITY_STANDALONE_WIN
+    internal class TapLoginClientBridge
+    {
+        private static TaskCompletionSource<TapLoginResponseByTapClient> taskCompletionSource;
+
+        public static async Task<TapLoginResponseByTapClient> LoginWithScopesAsync(string[] scopes, string responseType, string redirectUri,
+    string codeChallenge, string state, string codeChallengeMethod, string versonCode, string sdkUa, string info)
+        {
+            taskCompletionSource = new TaskCompletionSource<TapLoginResponseByTapClient>();
+            await Task.Run(() =>
+                {
+                    try
+                    {
+                        bool isStartSuccess = TapClientStandalone.StartLoginWithScopes(scopes, responseType, redirectUri, codeChallenge, state, codeChallengeMethod, versonCode, sdkUa, info, LoginDelegate);
+                        if (!isStartSuccess)
+                        {
+                            taskCompletionSource.TrySetResult(new TapLoginResponseByTapClient("发起授权失败，请确认 Tap 客户端是否正常运行"));
+                            taskCompletionSource = null;
+                        }
+                    }
+                    catch (Exception e)
+                    {
+                        taskCompletionSource.TrySetResult(new TapLoginResponseByTapClient(false, e.Message));
+                        taskCompletionSource = null;
+                    }
+                }
+            );
+            return await taskCompletionSource.Task;
+        }
+
+        private static void LoginDelegate(bool isCancel, string redirectUri)
+        {
+            if (taskCompletionSource != null)
+            {
+                taskCompletionSource.TrySetResult(new TapLoginResponseByTapClient(isCancel, redirectUri));
+                taskCompletionSource = null;
+            }
+        }
+
+        // 使用客户端登录结果返回值
+        public class TapLoginResponseByTapClient
+        {
+
+            public bool isCancel = false;
+
+            public string redirectUri;
+
+            public bool isFail = false;
+
+            public string errorMsg;
+
+            public TapLoginResponseByTapClient(bool isCancel, string redirctUri)
+            {
+                this.redirectUri = redirctUri;
+                this.isCancel = isCancel;
+            }
+
+            public TapLoginResponseByTapClient(string errorMsg)
+            {
+                isFail = true;
+                isCancel = false;
+                this.errorMsg = errorMsg;
+            }
+
+
+        }
+
+        // 使用客户端登录结果回调
+        public interface TapLoginCallbackWithTapClient
+        {
+            void onSuccess(TapLoginResponseByTapClient response);
+
+            void onFailure(string error);
+
+            void onCancel();
+        }
+
+
+    }
+#endif
+}

package/Login/Standalone/Runtime/Internal2/TapLoginClientBridge.cs.meta

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

package/Login/Standalone/Runtime/Internal2/TapLoginService.cs

@@ -0,0 +1,45 @@
+using System;
+using System.Threading.Tasks;
+using TapSDK.Core.Internal.Log;
+using TapSDK.Core.Standalone.Internal.Service;
+using TapSDK.Login.Internal;
+
+namespace TapSDK.Login.Standalone.Internal
+{
+    internal class TapLoginService : ITapLoginService
+    {
+        public string ObtainAuthorizationAsync(string url, string method)
+        {
+            TapTapAccount tapAccount = AccountManager.Instance.Account;
+            if (tapAccount == null)
+            {
+                return null;
+            }
+            AccessToken token = tapAccount.accessToken;
+            if (token == null)
+            {
+                return null;
+            }
+            var dt = DateTime.UtcNow - new DateTime(1970, 1, 1);
+            var ts = (int)dt.TotalSeconds;
+            string port = "443";
+            if (url.StartsWith("http://"))
+            {
+                port = "80";
+            }
+            UriBuilder uri = new UriBuilder(url);
+            string host = uri.Host;
+            string pathAndQuery = url.Substring(url.LastIndexOf(host) + host.Length);
+            var sign = "MAC " + LoginService.GetAuthorizationHeader(
+                token.kid,
+                token.macKey,
+                token.macAlgorithm,
+                method,
+                pathAndQuery,
+                host,
+                port,
+                ts);
+            return sign;
+        }
+    }
+}

package/Login/Standalone/Runtime/Internal2/TapLoginService.cs.meta

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