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

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

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

package/Standalone/Runtime/Internal/UI.cs

@@ -0,0 +1,22 @@
+using UnityEngine;
+
+namespace TapSDK.Login.Internal
+{
+    internal static class UIOperation
+    {
+        // ReSharper disable Unity.PerformanceAnalysis
+        public static T GetComponent<T>(GameObject obj) where T : Component
+        {
+            T component = obj.GetComponent<T>();
+
+            if (component == null)
+            {
+                component = obj.AddComponent<T>();
+            }
+
+            return component;
+        }
+
+    }
+}
+

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

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

package/Standalone/Runtime/Internal/UIAnimator.cs

@@ -0,0 +1,77 @@
+using System;
+using System.Collections;
+using UnityEngine;
+
+namespace TapSDK.Login.Internal
+{
+    [DisallowMultipleComponent]
+    internal class UIAnimator : MonoBehaviour
+    {
+        public delegate void Action();
+
+        // ReSharper disable Unity.PerformanceAnalysis
+        public void DoExitAnimation(UIElement exit, UIElement resume, Action onAnimationEnd = null)
+        {
+            float exitDuration = 0, resumeDuration = 0;
+
+            if (exit != null)
+            {
+                exitDuration = exit.DoExitAnimation();
+            }
+
+            if (resume != null)
+            {
+                resumeDuration = resume.DoResumeAnimation();
+            }
+
+            BlockForSecond(Math.Max(exitDuration, resumeDuration) + 0.1f, onAnimationEnd);
+        }
+
+        public void DoEnterAnimation(UIElement pause, UIElement enter, Action onAnimationEnd = null)
+        {
+            float pauseDuration = 0, enterDuration = 0;
+
+            if (pause != null)
+            {
+                pauseDuration = pause.DoPauseAnimation();
+            }
+
+            if (enter != null)
+            {
+                enterDuration = enter.DoEnterAnimation();
+            }
+
+            BlockForSecond(Math.Max(pauseDuration, enterDuration) + 0.1f, onAnimationEnd);
+        }
+
+        private void BlockForSecond(float duration, Action callback = null)
+        {
+            if (duration > 0)
+            {
+                StartCoroutine(BlockCoroutine(duration, () =>
+                {
+                    if (callback != null)
+                    {
+                        callback();
+                    }
+                }));
+            }
+            else
+            {
+                if (callback != null)
+                {
+                    callback();
+                }
+            }
+        }
+
+        private IEnumerator BlockCoroutine(float blockDuration, Action onBlockEnd = null)
+        {
+            yield return new WaitForSeconds(blockDuration);
+            if (onBlockEnd != null)
+            {
+                onBlockEnd();
+            }
+        }
+    }
+}

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

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

package/Standalone/Runtime/Internal/UIBase.cs

@@ -0,0 +1,27 @@
+using UnityEngine;
+
+namespace TapSDK.Login.Internal
+{
+    internal class UIBase : MonoBehaviour
+    {
+        public virtual void OnEnter()
+        {
+
+        }
+
+        public virtual void OnPause()
+        {
+            gameObject.SetActive(false);
+        }
+
+        public virtual void OnResume()
+        {
+            gameObject.SetActive(true);
+        }
+
+        public virtual void OnExit()
+        {
+            Destroy(gameObject);
+        }
+    }
+}

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

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

package/Standalone/Runtime/Internal/UIElement.cs

@@ -0,0 +1,185 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+
+namespace TapSDK.Login.Internal
+{
+    internal class UIElement : UIBase
+	{
+
+        protected Dictionary<string, object> extra = null;
+        public event Action<int, object> Callback;
+
+        protected bool animationLaunched = false;
+        protected float transitionDurationTime = 0.2f;
+
+        private static readonly int animType = 0;
+
+        public virtual Dictionary<string, object> Extra
+        {
+            get
+            {
+                return extra;
+            }
+
+            set
+            {
+                extra = value;
+            }
+        }
+
+        public UIManager Manager { set; private get; }
+
+        public void ClearCallback()
+        {
+            Callback = null;
+        }
+
+        protected virtual void OnCallback(int code, object data)
+        {
+            if (Callback != null)
+            {
+                Callback(code, data);
+            }
+        }
+
+        protected UIManager GetUIManager()
+        {
+            return Manager;
+        }
+
+        protected internal virtual float DoPauseAnimation()
+        {
+            return 0f;
+        }
+
+        protected internal virtual float DoResumeAnimation()
+        {
+            return 0f;
+        }
+
+        protected internal virtual float DoExitAnimation()
+        {
+            StartCoroutine(PlayExit());
+            return transitionDurationTime;
+        }
+
+        protected internal virtual float DoEnterAnimation()
+        {
+            StartCoroutine(PlayEnter());
+            return transitionDurationTime;
+        }
+
+        // ReSharper disable Unity.PerformanceAnalysis
+        public virtual IEnumerator PlayExit()
+        {
+            if (animType == 0)
+            {
+                if (!animationLaunched)
+                {
+                    animationLaunched = true;
+                    float startTime = Time.time;
+                    float endTime = startTime + transitionDurationTime;
+                    CanvasGroup canvasGroup = UIOperation.GetComponent<CanvasGroup>(gameObject);
+                    canvasGroup.alpha = 1f;
+                    while (Time.time < endTime)
+                    {
+                        yield return new WaitForEndOfFrame();
+                        float delta = (Time.time - startTime) / transitionDurationTime;
+                        canvasGroup.alpha = 1 - delta;
+                    }
+                }
+                animationLaunched = false;
+                yield return null;
+            }
+            else
+            {
+                if (!animationLaunched)
+                {
+                    animationLaunched = true;
+                    float startTime = Time.time;
+                    float endTime = startTime + transitionDurationTime;
+                    RectTransform rectTransform = transform.GetComponent<RectTransform>();
+                    float targetX = rectTransform.position.x + Screen.width / 2 + rectTransform.rect.width / 2 + 200;
+                    Vector3 startV3 = new Vector3(
+                        rectTransform.position.x,
+                        rectTransform.position.y,
+                        rectTransform.position.z
+                    );
+                    rectTransform.position = startV3;
+                    while (Time.time < endTime)
+                    {
+                        yield return new WaitForEndOfFrame();
+                        float delta = (Time.time - startTime) / transitionDurationTime;
+                        Vector3 currentV3 = new Vector3(
+                            rectTransform.position.x + (targetX - rectTransform.position.x) * delta,
+                            rectTransform.position.y,
+                            rectTransform.position.z
+                        );
+                        rectTransform.position = currentV3;
+                    }
+                }
+                animationLaunched = false;
+                yield return null;
+            }
+
+        }
+
+        public virtual IEnumerator PlayEnter()
+        {
+            if (animType == 0)
+            {
+                if (!animationLaunched)
+                {
+                    animationLaunched = true;
+                    float startTime = Time.time;
+                    float endTime = startTime + transitionDurationTime;
+                    CanvasGroup canvasGroup = UIOperation.GetComponent<CanvasGroup>(gameObject);
+                    canvasGroup.alpha = 0f;
+                    while (Time.time < endTime)
+                    {
+                        yield return new WaitForEndOfFrame();
+                        float delta = (Time.time - startTime) / transitionDurationTime;
+                        canvasGroup.alpha = delta;
+                    }
+                }
+                animationLaunched = false;
+                yield return null;
+            }
+            else
+            {
+                if (!animationLaunched)
+                {
+                    animationLaunched = true;
+                    float startTime = Time.time;
+                    float endTime = startTime + transitionDurationTime;
+                    RectTransform rectTransform = transform.GetComponent<RectTransform>();
+                    float targetX = rectTransform.position.x;
+                    Vector3 startV3 = new Vector3(
+                        rectTransform.position.x + Screen.width / 2 + rectTransform.rect.width / 2 + 200,
+                        rectTransform.position.y,
+                        rectTransform.position.z
+                    );
+                    rectTransform.position = startV3;
+                    while (Time.time < endTime)
+                    {
+                        yield return new WaitForEndOfFrame();
+                        float delta = (Time.time - startTime) / transitionDurationTime;
+                        Vector3 currentV3 = new Vector3(
+                            rectTransform.position.x + (targetX - rectTransform.position.x) * delta,
+                            rectTransform.position.y,
+                            rectTransform.position.z
+                        );
+                        rectTransform.position = currentV3;
+                    }
+                }
+                animationLaunched = false;
+                yield return null;
+            }
+
+        }
+
+    }
+}
+

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

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

package/Standalone/Runtime/Internal/UIManager.cs

@@ -0,0 +1,100 @@
+using System;
+using System.Collections.Generic;
+using UnityEngine;
+using Object = UnityEngine.Object;
+
+namespace TapSDK.Login.Internal
+{
+    internal class UIManager : MonoBehaviour
+    {
+        public static readonly int RESULT_FAILED = -1;
+        public static readonly int RESULT_SUCCESS = 0;
+        public static readonly int RESULT_BACK = 1;
+        public static readonly int RESULT_CLOSE = 2;
+
+        private GameObject containerObj;
+
+
+        private readonly List<UIElement> uiElements = new List<UIElement>();
+        
+
+        public void Pop()
+        {
+            PopUIElement(null);
+        }
+
+        private void PopUIElement(string targetName)
+        {
+            if (containerObj == null || uiElements.Count == 0)
+            {
+                Debug.LogError("No UIElement can be popped.");
+            }
+            else
+            {
+                UIElement element = uiElements[uiElements.Count - 1];
+
+                if (targetName != null && !targetName.Equals(element.name))
+                {
+                    Debug.LogError("Could not find specify UIElement : " + targetName);
+                    return;
+                }
+
+                uiElements.RemoveAt(uiElements.Count - 1);
+
+                UIElement lastElement = null;
+                if (uiElements.Count > 0)
+                {
+                    lastElement = uiElements[uiElements.Count - 1];
+                }
+
+                UIAnimator animator = UIOperation.GetComponent<UIAnimator>(containerObj);
+                if (lastElement != null)
+                {
+                    lastElement.OnResume();
+                }
+
+                animator.DoExitAnimation(element, lastElement, () =>
+                {
+                    element.OnExit();
+                    if (uiElements.Count == 0)
+                    {
+                        DestroyContainer();
+                        Destroy(gameObject);
+                    }
+                });
+            }
+        }
+
+        private void CreateContainer()
+        {
+            containerObj = Instantiate(Resources.Load("Prefabs/TapTapSdkWindow")) as GameObject;
+            containerObj.name = "TapTapSdkWindow";
+            DontDestroyOnLoad(containerObj);
+            UIElement containerElement = UIOperation.GetComponent<ContainerWindow>(containerObj);
+            UIAnimator containerAnimator = UIOperation.GetComponent<UIAnimator>(containerObj);
+            containerElement.Manager = this;
+            containerElement.OnEnter();
+            containerAnimator.DoEnterAnimation(null, containerElement,
+                () =>
+                {
+                    
+                });
+        }
+
+        // ReSharper disable Unity.PerformanceAnalysis
+        private void DestroyContainer()
+        {
+            if (containerObj != null)
+            {
+                UIElement containerElement = UIOperation.GetComponent<ContainerWindow>(containerObj);
+                UIAnimator containerAnimator = UIOperation.GetComponent<UIAnimator>(containerObj);
+                containerElement.OnEnter();
+                containerAnimator.DoExitAnimation(containerElement, null, () =>
+                {
+                    Destroy(containerObj);
+                    containerObj = null;
+                });
+            }
+        }
+    }
+}

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

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

package/Standalone/Runtime/Internal/WebLoginRequestManager.cs

@@ -0,0 +1,185 @@
+using System;
+using System.Collections.Generic;
+using System.Net;
+using System.Net.Sockets;
+using System.Security.Cryptography;
+using System.Text;
+using System.Linq;
+using TapSDK.Core;
+using UnityEngine;
+using Random = System.Random;
+
+namespace TapSDK.Login.Internal
+{
+    public class WebLoginRequestManager
+    {
+        private static volatile WebLoginRequestManager _instance;
+        private static readonly object ObjLock = new object();
+
+        public static WebLoginRequestManager Instance
+        {
+            get
+            {
+                if (_instance != null) return _instance;
+                lock (ObjLock)
+                {
+                    if (_instance == null)
+                    {
+                        _instance = new WebLoginRequestManager();
+                    }
+                }
+
+                return _instance;
+            }
+        }
+
+        private string _codeVerifier;
+
+        private WebLoginRequest _currentRequest;
+
+        public void CreateNewLoginRequest(string[] scopes)
+        {
+            _codeVerifier = CodeUtil.GenerateCodeVerifier();
+            _currentRequest = new WebLoginRequest(scopes, _codeVerifier);
+        }
+
+        public string GetCodeVerifier()
+        {
+            return _codeVerifier;
+        }
+
+        public WebLoginRequest GetCurrentRequest()
+        {
+            return _currentRequest;
+        }
+    }
+
+    public class WebLoginRequest
+    {
+        private readonly string[] _scopes;
+        private readonly string _state;
+        private readonly string _codeChallenge;
+        private string _redirectHost;
+
+        public WebLoginRequest(string[] scopes, string codeVerifier)
+        {
+            this._scopes = scopes;
+            _codeChallenge = CodeUtil.GetCodeChallenge(codeVerifier);
+            _state = Guid.NewGuid().ToString("N");
+        }
+
+        public string GetWebLoginUrl()
+        {
+            var data = new Dictionary<string, string>
+            {
+                { "client_id", TapTapSdk.ClientId },
+                { "response_type", "code" },
+                { "redirect_uri", GetRedirectUri() },
+                { "state", _state },
+                { "code_challenge", _codeChallenge },
+                { "code_challenge_method", "S256" },
+                { "scope", string.Join(",", _scopes) },
+                { "flow", "pc_localhost" }
+            };
+            var paramStr = MapToParameters(data);
+
+            return TapTapSdk.CurrentRegion.AccountUrl() + paramStr;
+        }
+
+        private static string MapToParameters(Dictionary<string, string> data)
+        {
+            IEnumerable<string> kvs = data
+                .Select(kv => $"{Uri.EscapeDataString(kv.Key)}={Uri.EscapeDataString(kv.Value)}");
+            return string.Join("&", kvs);
+        }
+
+        public string GetState()
+        {
+            return _state;
+        }
+
+        public string GetRedirectHost()
+        {
+            if (string.IsNullOrEmpty(_redirectHost))
+            {
+                _redirectHost = CodeUtil.GetRedirectUri();
+            }
+
+            return _redirectHost;
+        }
+
+        public string GetRedirectUri()
+        {
+            return GetRedirectHost() + "authorize";
+        }
+    }
+
+    public static class CodeUtil
+    {
+        public static string GetRedirectUri()
+        {
+            var redirectUri = $"http://{IPAddress.Loopback}:{GetRandomUnusedPort()}/";
+            TapLogger.Debug($"redirect uri:{redirectUri}");
+            return redirectUri;
+        }
+
+        public static string GetTapTapOAuthRedirectUri()
+        {
+            return $"open-taptap-{TapTapSdk.ClientId}://{GetTapTapOAuthPrefix()}";
+        }
+
+        public static string GetTapTapOAuthPrefix()
+        {
+            return "authorize";
+        }
+
+        private static int GetRandomUnusedPort()
+        {
+            var listener = new TcpListener(IPAddress.Loopback, 0);
+            listener.Start();
+            var port = ((IPEndPoint)listener.LocalEndpoint).Port;
+            listener.Stop();
+            return port;
+        }
+
+        public static string GenerateCodeVerifier()
+        {
+            const string baseStr = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-._~";
+            var random = new Random();
+            var builder = new StringBuilder();
+            int l = baseStr.Length;
+            for (var i = 0; i < 128; i++)
+            {
+                var number = random.Next(l);
+                builder.Append(baseStr[number]);
+            }
+
+            return builder.ToString();
+        }
+
+        public static string GetCodeChallenge(string codeVerifier)
+        {
+            return Base64UrlEncodeNoPadding(SHA256(codeVerifier));
+        }
+
+        private static string Base64UrlEncodeNoPadding(byte[] buffer)
+        {
+            var base64 = Convert.ToBase64String(buffer);
+
+            // Converts base64 to base64url.
+            base64 = base64.Replace("+", "-");
+            base64 = base64.Replace("/", "_");
+            // Strips padding.
+            base64 = base64.Replace("=", "");
+
+            return base64;
+        }
+
+        private static byte[] SHA256(string inputStirng)
+        {
+            var bytes = Encoding.ASCII.GetBytes(inputStirng);
+            var sha256 = new SHA256Managed();
+            return sha256.ComputeHash(bytes);
+        }
+    }
+}

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

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

package/Standalone/Runtime/Internal.meta

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