com.xd.sdk.common 6.29.0 → 7.0.0

package/Runtime/Internal/Standalone/Track/AliyunTrack.cs.meta

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

package/Runtime/Internal/Standalone/Track/TrackHttpClient.cs

@@ -0,0 +1,91 @@
+#if UNITY_EDITOR || UNITY_STANDALONE
+using System;
+using System.Collections.Generic;
+using System.Threading.Tasks;
+using System.Net.Http;
+using System.Net.Http.Headers;
+using System.Threading;
+using Newtonsoft.Json;
+
+namespace XD.SDK.Common.Internal.Standalone {
+    public class TrackHttpClient {
+        private class RetryHandler : DelegatingHandler
+        {
+            private const int MAX_RETRY_COUNT = 3;
+            public RetryHandler() : base(new HttpClientHandler()) {}
+
+            protected override async Task<HttpResponseMessage> SendAsync(
+                HttpRequestMessage request,
+                CancellationToken cancellationToken)
+            {
+                HttpResponseMessage response = null;
+                for (int i = 0; i < MAX_RETRY_COUNT; i++)
+                {
+                    response = await base.SendAsync(request, cancellationToken);
+                    if (response.IsSuccessStatusCode) {
+                        return response;
+                    }
+                }
+
+                return response;
+            }
+        }
+        private static HttpClient client;
+
+        internal static HttpClient Client {
+            get {
+                if (client == null) {
+                    client = new HttpClient(new RetryHandler());
+                    client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
+                    client.Timeout = TimeSpan.FromSeconds(10);
+                }
+                return client;
+            }
+        }
+
+        public static async Task<HttpResponseMessage> Request(string path,
+            HttpMethod method,
+            Dictionary<string, object> headers = null,
+            object data = null) 
+        {
+            string url = path;
+            HttpRequestMessage request = new HttpRequestMessage {
+                RequestUri = new Uri(url),
+                Method = method,
+            };
+            FillHeaders(request.Headers, headers);
+
+            string content = null;
+            if (data != null) {
+                content = JsonConvert.SerializeObject(data);
+                StringContent requestContent = new StringContent(content);
+                requestContent.Headers.ContentType = new MediaTypeHeaderValue("application/json");
+                request.Content = requestContent;
+            }
+
+            XDHttpUtils.PrintRequest(Client, request, content);
+            HttpResponseMessage response = null;
+            try
+            {
+                response = await Client.SendAsync(request, HttpCompletionOption.ResponseHeadersRead);
+                request.Dispose();
+                return response;
+            }
+            catch (Exception e)
+            {
+                request.Dispose();
+                throw e;
+            }
+        }
+
+        static 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());
+                }
+            }
+        }
+    }
+}
+#endif

package/Runtime/Internal/Standalone/Track/TrackHttpClient.cs.meta

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

package/Runtime/Internal/Standalone/Track.meta

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

package/Runtime/Internal/Standalone/UI/Base/ContainerWindow.cs

@@ -0,0 +1,49 @@
+#if UNITY_EDITOR || UNITY_STANDALONE
+using System.Collections;
+using UnityEngine;
+using UnityEngine.UI;
+
+namespace XD.SDK.Common.Internal.Standalone {
+    public class ContainerWindow : UIElement {
+        void Awake(){
+            transitionDurationTime = 0.1f;
+        }
+
+        public override IEnumerator PlayExit(){
+            if (!animationLaunched){
+                animationLaunched = true;
+                float startTime = Time.time;
+                float endTime = startTime + transitionDurationTime;
+                CanvasGroup canvasGroup = UI.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;
+        }
+
+        public override IEnumerator PlayEnter(){
+            if (!animationLaunched){
+                animationLaunched = true;
+                float startTime = Time.time;
+                float endTime = startTime + transitionDurationTime;
+                CanvasGroup canvasGroup = UI.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;
+        }
+    }
+}
+#endif

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

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

package/Runtime/Internal/Standalone/UI/Base/HyperlinkText.cs

@@ -0,0 +1,339 @@
+#if UNITY_EDITOR || UNITY_STANDALONE
+using System;
+using System.Collections.Generic;
+using System.Text;
+using System.Text.RegularExpressions;
+using UnityEngine;
+using UnityEngine.Events;
+using UnityEngine.EventSystems;
+using UnityEngine.UI;
+
+namespace XD.SDK.Common.Internal.Standalone {
+    /// <summary>
+    /// 文本控件,支持超链接
+    /// </summary>
+    public class HyperlinkText : Text, IPointerClickHandler {
+        /// <summary>
+        /// 超链接类
+        /// </summary>
+        private class HyperlinkInfo {
+            /// <summary>
+            /// 超链接的字符串的开始字符的第一个顶点的索引
+            /// </summary>
+            public int startIndex;
+
+
+            /// <summary>
+            /// 超链接的字符串的最后字符的最后一个顶点的索引 
+            /// </summary>
+            public int endIndex;
+
+            public string linkUrl;
+
+            /// <summary>
+            /// 超链接的覆盖区域
+            /// </summary>
+            public List<ClickAreas> clickAreas = new List<ClickAreas>();
+        }
+
+        /// <summary>
+        /// 点击区域
+        /// </summary>
+        private class ClickAreas {
+            public float xMin;
+            public float xMax;
+            public float yMin;
+            public float yMax;
+
+            public ClickAreas(float xMin, float xMax, float yMin, float yMax) {
+                this.xMin = xMin;
+                this.xMax = xMax;
+                this.yMin = yMin;
+                this.yMax = yMax;
+            }
+        }
+
+        public Action<string> OnClicked;
+
+        /// <summary>
+        /// 解析完最终的文本
+        /// </summary>
+        private string colorAddedStr;
+
+        /// <summary>
+        /// 超链接信息列表
+        /// </summary>
+        private readonly List<HyperlinkInfo> hrefInfos = new List<HyperlinkInfo>();
+
+        /// <summary>
+        /// 文本构造器
+        /// </summary>
+        protected static readonly StringBuilder textRebuild = new StringBuilder();
+
+        [Serializable]
+        public class HrefClickEvent : UnityEvent<string> { }
+
+        [SerializeField]
+        private HrefClickEvent onHrefClickCB = new HrefClickEvent();
+
+        /// <summary>
+        /// 超链接点击事件
+        /// </summary>
+        public HrefClickEvent onHrefClick {
+            get { return onHrefClickCB; }
+            set { onHrefClickCB = value; }
+        }
+
+        /// <summary>
+        /// 每个字符的面片有4个顶点
+        /// </summary>
+        const int perCharVerCount = 4;
+
+        const string pattern = @"<a href=([^>\n\s]+)>(.*?)(</a>)";
+
+        public string colorStartStr = ""; // "<color=#15C5CE>";
+
+        public string colorEndStr = ""; // "</color>";
+
+        const string otherPattern = "<.+?>";
+
+        /// <summary>
+        /// 超链接正则
+        /// </summary>
+        private static readonly Regex s_HrefRegex =
+            new Regex(pattern, RegexOptions.Singleline);
+
+        private HyperlinkText mHyperlinkText;
+
+        /// <summary>
+        /// 其他富文本正则
+        /// </summary>
+        private static readonly Regex otherRegex =
+            new Regex(otherPattern, RegexOptions.Singleline);
+
+        protected override void Awake() {
+            base.Awake();
+            mHyperlinkText = GetComponent<HyperlinkText>();
+        }
+
+
+        protected override void OnEnable() {
+            base.OnEnable();
+            mHyperlinkText.onHrefClick.AddListener(OnHyperlinkTextInfo);
+        }
+
+        protected override void OnDisable() {
+            base.OnDisable();
+            mHyperlinkText.onHrefClick.RemoveListener(OnHyperlinkTextInfo);
+        }
+
+
+        public override void SetVerticesDirty() {
+            base.SetVerticesDirty();
+#if UNITY_EDITOR
+#pragma warning disable CS0618 // 类型或成员已过时
+        if (UnityEditor.PrefabUtility.GetPrefabType(this) == UnityEditor.PrefabType.Prefab)
+#pragma warning restore CS0618 // 类型或成员已过时
+        {
+            return;
+        }
+#endif
+
+            colorAddedStr = GetDealedText(text);
+
+
+        }
+
+        protected override void OnPopulateMesh(VertexHelper toFill) {
+            //print("OnPopulateMesh ");
+
+            var orignText = m_Text;
+            m_Text = colorAddedStr;
+            base.OnPopulateMesh(toFill);
+
+            m_Text = orignText;
+
+
+            //UGUI的网格处理类
+            UIVertex vert = new UIVertex();
+
+            // 重新创建超链接包围框
+            foreach (var hrefInfo in hrefInfos) {
+                hrefInfo.clickAreas.Clear();
+
+                //toFill.currentVertCount表示当前Text组件的所有网格的最后一个网格的顶点索引
+                //hrefInfo.startIndex大于它 是startIndex大于它运算出错了 运算出错 则跳过包围框生成
+                if (hrefInfo.startIndex >= toFill.currentVertCount) {
+                    continue;
+                }
+
+                //获取startIndex所指示的顶点
+                toFill.PopulateUIVertex(ref vert, hrefInfo.startIndex);
+
+                var pos = vert.position;
+                var bounds = new Bounds(pos, Vector3.zero);
+                float xMin = 0, xMax = 0, yMin = 0, yMax = 0;
+                int index = 0;
+                int startIndex = hrefInfo.startIndex;
+                int endIndex = hrefInfo.endIndex;
+                for (int i = startIndex, m = endIndex; i < m; i++) {
+                    if (i >= toFill.currentVertCount) {
+                        break;
+                    }
+
+                    toFill.PopulateUIVertex(ref vert, i);
+                    pos = vert.position;
+
+                    index++;
+                    if (index == 1) // 第一个节点
+                    {
+                        xMin = pos.x;
+                        yMax = pos.y;
+                    } else if (index == 3) // 第三个节点
+                      {
+                        xMax = pos.x;
+                        yMin = pos.y;
+                    }
+                    if (index == 4) {
+                        hrefInfo.clickAreas.Add(new ClickAreas(xMin, xMax, yMin, yMax));
+                        index = 0;
+                    }
+                }
+            }
+        }
+
+        /// <summary>
+        /// 生成超链接文本的显示区域矩形和链接信息
+        /// 用于在点击的时候判断是否点击中了超链接
+        /// </summary>
+        /// <returns>  
+        /// 返回超链接解析后的最后输出文本
+        /// 即在原字符串的基础上用颜色标签的文本
+        /// 代替<a href=xx><\a>这样text组件识别不了的标签</returns>
+        protected virtual string GetDealedText(string originText) {
+            textRebuild.Clear();
+            hrefInfos.Clear();
+
+            //startIndex表示上次匹配正则的字符串的最后字符的索引+1
+            //例如这段话
+            //aa<a href=666>[本篇博客]</a>aa
+            //第一次匹配到的字符串是<a href=666>[本篇博客]</a>
+            //则它最后的字符在整个字符串的索引是24
+            //则startIndex在这时候为24+1即倒数第二个a的索引
+            var matchNextCharIndex = 0;
+
+            // 实际显示中 尖括号里面的是不显示的 
+            // 上面那句话里面实际显示的就aa 和[本篇博客] 
+            // 这些字符的最后字符]的索引是8
+            // 所以actualStartIndex表示的下次匹配的开始索引是9
+            var actualNextCharIndex = 0;
+
+            // 在第一个匹配正则式的字符串之前的字符串
+            // 或者这次匹配正则式的字符串与
+            // 上次匹配的字符串之间的字符串
+            var beforeStr = string.Empty;
+
+            //beforeStr的清空所有空白符形式
+            var beforeStrNoBlank = string.Empty;
+
+            //这次匹配到的字符串之前的字符串的最后一个字符的索引
+            //例如aa<a href=666>[本篇博客]</a>aa
+            //第一次匹配的时候 beforeStrLastCharIndex是上面字符串第二个a的索引
+            var beforeStrLastCharIndex = 0;
+
+
+            // match.Groups[0]是常量pattern字符串匹配到的所有字符串
+            // match.Groups[1]是常量pattern字符串里面第一个小括号匹配到的字符串
+            // match.Groups[2]是常量pattern字符串里面第二个小括号匹配到的字符串
+            // 依次类推
+
+            foreach (Match match in s_HrefRegex.Matches(originText)) {
+
+                beforeStr = originText.Substring(matchNextCharIndex,
+                    match.Index - matchNextCharIndex);
+
+                //将firstStr里面的所有空白符（包括'\n''\t'' '等）去掉
+                //这是因为空白字符不参与字体的网格生成  
+                //超链接字符前面空白字符不能纳入超链接的可点击区域计算
+                //否则生成的点击区域会有问题
+                beforeStrNoBlank = Regex.Replace(beforeStr, @"\s", "");
+
+                textRebuild.Append(beforeStr);
+                textRebuild.Append(colorStartStr);  // 超链接颜色
+
+                // 计算其他富文本长度
+                int otherLength = 0;
+                foreach (var item in otherRegex.Matches(beforeStr)) {
+                    otherLength += item.ToString().Length;
+                }
+
+                var url = match.Groups[1];
+                var hyperText = match.Groups[2];
+                // 计算链接里面富文本长度
+                int otherHyperTextLength = 0;
+                foreach (var item in otherRegex.Matches(hyperText.ToString())) {
+                    otherHyperTextLength += item.ToString().Length;
+                }
+
+                beforeStrLastCharIndex = beforeStrNoBlank.Length + actualNextCharIndex - otherLength;
+                //DebugFunc(actualNextCharIndex, beforeStr, beforeStrNoBlank, match, url);
+
+                var hrefInfo = new HyperlinkInfo {
+                    //因为 后面要根据startIndex和endIndex去获取实际的顶点，如果这两变量
+                    //纳入了空白符的计算 会导致变量偏大，从而获取的顶点是后面的字的顶点
+                    startIndex = beforeStrLastCharIndex * perCharVerCount,
+
+                    endIndex = (beforeStrLastCharIndex + hyperText.Length - otherHyperTextLength) * perCharVerCount,
+
+                    linkUrl = url.Value
+                };
+
+                hrefInfos.Add(hrefInfo);
+
+                textRebuild.Append(hyperText.Value);
+                textRebuild.Append(colorEndStr);
+
+
+                matchNextCharIndex = match.Index + match.Length;
+
+                actualNextCharIndex += beforeStrNoBlank.Length + hyperText.Length - otherLength - otherHyperTextLength;
+            }
+
+            //将最后一次匹配之后的字符串加上去
+            textRebuild.Append(originText.Substring(matchNextCharIndex, originText.Length - matchNextCharIndex));
+
+            return textRebuild.ToString();
+        }
+
+        /// <summary>
+        /// 点击事件检测是否点击到超链接文本
+        /// </summary>
+        /// <param name="eventData"></param>
+        public void OnPointerClick(PointerEventData eventData) {
+            Vector2 lp = Vector2.zero;
+
+            //将点击点从屏幕坐标系转换到rectTransform的局部坐标系
+            RectTransformUtility.ScreenPointToLocalPointInRectangle(rectTransform,
+                eventData.position, eventData.pressEventCamera, out lp);
+
+            foreach (var hrefInfo in hrefInfos) {
+                foreach (var item in hrefInfo.clickAreas) {
+                    if (lp.x > item.xMin && lp.x < item.xMax && lp.y > item.yMin && lp.y < item.yMax) {
+                        onHrefClickCB.Invoke(hrefInfo.linkUrl);
+                        break;
+                    }
+                }
+
+            }
+        }
+
+        /// <summary>
+        /// 当前点击超链接回调
+        /// </summary>
+        /// <param name="info">回调信息</param>
+        private void OnHyperlinkTextInfo(string url) {
+            OnClicked?.Invoke(url);
+        }
+    }
+}
+#endif

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

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

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

@@ -0,0 +1,17 @@
+#if UNITY_EDITOR || UNITY_STANDALONE
+using UnityEngine;
+
+namespace XD.SDK.Common.Internal.Standalone {
+    public static class UI{
+        public static T GetComponent<T>(GameObject obj) where T : UnityEngine.Component {
+            T component = obj.GetComponent<T>();
+
+            if (component == null){
+                component = obj.AddComponent<T>();
+            }
+
+            return component;
+        }
+    }
+}
+#endif

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

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

package/Runtime/Internal/Standalone/UI/Base/UIAnimator.cs

@@ -0,0 +1,60 @@
+#if UNITY_EDITOR || UNITY_STANDALONE
+using UnityEngine;
+using System.Collections;
+using System;
+
+namespace XD.SDK.Common.Internal.Standalone {
+    [DisallowMultipleComponent]
+    public class UIAnimator : MonoBehaviour {
+        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();
+            }
+        }
+    }
+}
+#endif

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

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

package/Runtime/Internal/Standalone/UI/Base/UIBase.cs

@@ -0,0 +1,22 @@
+#if UNITY_EDITOR || UNITY_STANDALONE
+using UnityEngine;
+
+namespace XD.SDK.Common.Internal.Standalone {
+    public 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);
+        }
+    }
+}
+#endif

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

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