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

package/Login/Standalone/Runtime/Internal/LoginLanguage.cs.meta

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

package/Login/Standalone/Runtime/Internal/Tracker/TapLoginTracker.cs

@@ -0,0 +1,114 @@
+using System;
+using System.Collections.Generic;
+using Newtonsoft.Json;
+using TapSDK.Core.Standalone.Internal.Openlog;
+
+namespace TapSDK.Login.Standalone.Internal
+{
+    internal class TapLoginTracker
+    {
+
+        private const string ACTION_INIT = "init";
+        private const string ACTION_START = "start";
+        private const string ACTION_SUCCESS = "success";
+        private const string ACTION_FAIL = "fail";
+        private const string ACTION_CANCEL = "cancel";
+
+        internal static string LOGIN_TYPE_CLIENT = "pc_client";
+        internal static string LOGIN_TYPE_CODE = "pc_code";
+        internal static string LOGIN_TYPE_BROWSER = "pc_browser";
+
+        private static TapLoginTracker instance;
+
+        private TapOpenlogStandalone openlog;
+
+        private TapLoginTracker()
+        {
+            openlog = new TapOpenlogStandalone("TapLogin", TapTapLogin.Version);
+        }
+
+        public static TapLoginTracker Instance
+        {
+            get
+            {
+                if (instance == null)
+                {
+                    instance = new TapLoginTracker();
+                }
+                return instance;
+            }
+        }
+
+        internal void TrackInit()
+        {
+            ReportLog(ACTION_INIT);
+        }
+
+        internal void TrackStart(string funcNace, string seesionId, string loginType = null)
+        {
+            Dictionary<string, string> parameters = new Dictionary<string, string>
+            {
+                { "func_name", funcNace },
+                { "session_id", seesionId },
+            };
+            if (loginType != null) {
+                parameters["login_type"] = loginType;
+            }
+            ReportLog(ACTION_START, new Dictionary<string, string>()
+            {
+                { "args", JsonConvert.SerializeObject(parameters) }
+            });
+        }
+
+        internal void TrackSuccess(string funcNace, string seesionId, string loginType)
+        {
+            Dictionary<string, string> parameters = new Dictionary<string, string>
+            {
+                { "func_name", funcNace },
+                { "session_id", seesionId },
+                { "login_type", loginType }
+            };
+            ReportLog(ACTION_SUCCESS, new Dictionary<string, string>()
+            {
+                { "args", JsonConvert.SerializeObject(parameters) }
+            });
+        }
+
+        internal void TrackCancel(string funcNace, string seesionId, string loginType = null)
+        {
+            Dictionary<string, string> parameters = new Dictionary<string, string>
+            {
+                { "func_name", funcNace },
+                { "session_id", seesionId },
+            };
+            if (loginType != null) {
+                parameters["login_type"] = loginType;
+            }
+            ReportLog(ACTION_CANCEL, new Dictionary<string, string>()
+            {
+                { "args", JsonConvert.SerializeObject(parameters) }
+            });
+        }
+
+        internal void TrackFailure(string funcNace, string seesionId, string loginType, int errorCode = -1, string errorMessage = null)
+        {
+            Dictionary<string, string> parameters = new Dictionary<string, string>
+            {
+                { "func_name", funcNace },
+                { "session_id", seesionId },
+                { "error_code", errorCode.ToString() },
+                { "error_msg", errorMessage },
+                { "login_type", loginType }
+            };
+            ReportLog(ACTION_FAIL, new Dictionary<string, string>()
+            {
+                { "args", JsonConvert.SerializeObject(parameters) }
+            });
+        }
+
+        private void ReportLog(string action, Dictionary<string, string> parameters = null)
+        {
+            openlog.LogBusiness(action, parameters);
+        }
+    }
+}

package/Login/Standalone/Runtime/Internal/Tracker/TapLoginTracker.cs.meta

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

package/Login/Standalone/Runtime/Internal/Tracker.meta

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

package/Login/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/Login/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/Login/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/Login/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/Login/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/Login/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/Login/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/Login/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/Login/Standalone/Runtime/Internal/UIManager.cs

@@ -0,0 +1,101 @@
+using System;
+using System.Collections.Generic;
+using TapSDK.Core.Internal.Log;
+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)
+            {
+                TapLog.Error("No UIElement can be popped.");
+            }
+            else
+            {
+                UIElement element = uiElements[uiElements.Count - 1];
+
+                if (targetName != null && !targetName.Equals(element.name))
+                {
+                    TapLog.Error("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/Login/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: