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

package/Runtime/Internal/UI/ScrollViewEx/ScrollView/ScrollView.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: bac7eb1be8f6f40459d388c929d1946f
+timeCreated: 1533042733
+licenseType: Free
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Runtime/Internal/UI/ScrollViewEx/ScrollView/ScrollViewEx.cs

@@ -0,0 +1,245 @@
+// -----------------------------------------------------------------------
+// <copyright file="ScrollViewEx.cs" company="AillieoTech">
+// Copyright (c) AillieoTech. All rights reserved.
+// </copyright>
+// -----------------------------------------------------------------------
+
+namespace TapSDK.UI.AillieoTech
+{
+    using System;
+    using UnityEngine;
+    using UnityEngine.EventSystems;
+    using UnityEngine.Serialization;
+
+    [RequireComponent(typeof(RectTransform))]
+    [DisallowMultipleComponent]
+    public class ScrollViewEx : ScrollView
+    {
+        [SerializeField]
+        [FormerlySerializedAs("m_pageSize")]
+        private int pageSize = 50;
+
+        private int startOffset = 0;
+
+        private Func<int> realItemCountFunc;
+
+        private Vector2 lastPosition;
+
+        private bool reloadFlag = false;
+
+        public override void SetUpdateFunc(Action<int, RectTransform> func)
+        {
+            if (func != null)
+            {
+                var f = func;
+                func = (index, rect) =>
+                {
+                    f(index + this.startOffset, rect);
+                };
+            }
+
+            base.SetUpdateFunc(func);
+        }
+
+        public override void SetItemSizeFunc(Func<int, Vector2> func)
+        {
+            if (func != null)
+            {
+                var f = func;
+                func = (index) =>
+                {
+                    return f(index + this.startOffset);
+                };
+            }
+
+            base.SetItemSizeFunc(func);
+        }
+
+        public override void SetItemCountFunc(Func<int> func)
+        {
+            this.realItemCountFunc = func;
+            if (func != null)
+            {
+                var f = func;
+                func = () => Mathf.Min(f(), this.pageSize);
+            }
+
+            base.SetItemCountFunc(func);
+        }
+
+        public override void OnDrag(PointerEventData eventData)
+        {
+            if (this.reloadFlag)
+            {
+                this.reloadFlag = false;
+                this.OnEndDrag(eventData);
+                this.OnBeginDrag(eventData);
+
+                return;
+            }
+
+            base.OnDrag(eventData);
+        }
+
+        protected override void Awake()
+        {
+            base.Awake();
+
+            this.lastPosition = Vector2.up;
+            this.onValueChanged.AddListener(this.OnValueChanged);
+        }
+
+        protected override void InternalScrollTo(int index)
+        {
+            var count = 0;
+            if (this.realItemCountFunc != null)
+            {
+                count = this.realItemCountFunc();
+            }
+
+            index = Mathf.Clamp(index, 0, count - 1);
+            this.startOffset = Mathf.Clamp(index - (this.pageSize / 2), 0, count - this.itemCountFunc());
+            this.UpdateData(true);
+            base.InternalScrollTo(index - this.startOffset);
+        }
+
+        private void OnValueChanged(Vector2 position)
+        {
+            int toShow;
+            int critical;
+            bool downward;
+            int pin;
+
+            Vector2 delta = position - this.lastPosition;
+            this.lastPosition = position;
+
+            this.reloadFlag = false;
+
+            if (((int)this.layoutType & flagScrollDirection) == 1)
+            {
+                // 垂直滚动 只计算y向
+                if (delta.y < 0)
+                {
+                    // 向上
+                    toShow = this.criticalItemIndex[CriticalItemType.DownToShow];
+                    critical = this.pageSize - 1;
+                    if (toShow < critical)
+                    {
+                        return;
+                    }
+
+                    pin = critical - 1;
+                    downward = false;
+                }
+                else if (delta.y > 0)
+                {
+                    // 向下
+                    toShow = this.criticalItemIndex[CriticalItemType.UpToShow];
+                    critical = 0;
+                    if (toShow > critical)
+                    {
+                        return;
+                    }
+
+                    pin = critical + 1;
+                    downward = true;
+                }
+                else
+                {
+                    return;
+                }
+            }
+            else
+            {
+                // = 0
+                // 水平滚动 只计算x向
+                if (delta.x > 0)
+                {
+                    // 向右
+                    toShow = this.criticalItemIndex[CriticalItemType.UpToShow];
+                    critical = 0;
+                    if (toShow > critical)
+                    {
+                        return;
+                    }
+
+                    pin = critical + 1;
+                    downward = true;
+                }
+                else if (delta.x < 0)
+                {
+                    // 向左
+                    toShow = this.criticalItemIndex[CriticalItemType.DownToShow];
+                    critical = this.pageSize - 1;
+                    if (toShow < critical)
+                    {
+                        return;
+                    }
+
+                    pin = critical - 1;
+                    downward = false;
+                }
+                else
+                {
+                    return;
+                }
+            }
+
+            // 该翻页了 翻半页吧
+            var old = this.startOffset;
+            if (downward)
+            {
+                this.startOffset -= this.pageSize / 2;
+            }
+            else
+            {
+                this.startOffset += this.pageSize / 2;
+            }
+
+            var realDataCount = 0;
+            if (this.realItemCountFunc != null)
+            {
+                realDataCount = this.realItemCountFunc();
+            }
+
+            this.startOffset = Mathf.Clamp(this.startOffset, 0, Mathf.Max(realDataCount - this.pageSize, 0));
+
+            if (old != this.startOffset)
+            {
+                this.reloadFlag = true;
+
+                // 记录 原先的速度
+                Vector2 oldVelocity = this.velocity;
+
+                // 计算 pin元素的世界坐标
+                Rect rect = this.GetItemLocalRect(pin);
+
+                Vector2 oldWorld = this.content.TransformPoint(rect.position);
+                var dataCount = 0;
+                if (this.itemCountFunc != null)
+                {
+                    dataCount = this.itemCountFunc();
+                }
+
+                if (dataCount > 0)
+                {
+                    this.EnsureItemRect(0);
+                    if (dataCount > 1)
+                    {
+                        this.EnsureItemRect(dataCount - 1);
+                    }
+                }
+
+                // 根据 pin元素的世界坐标 计算出content的position
+                var pin2 = pin + old - this.startOffset;
+                Rect rect2 = this.GetItemLocalRect(pin2);
+                Vector2 newWorld = this.content.TransformPoint(rect2.position);
+                Vector2 deltaWorld = newWorld - oldWorld;
+                Vector2 deltaLocal = this.content.InverseTransformVector(deltaWorld);
+                this.SetContentAnchoredPosition(this.content.anchoredPosition - deltaLocal);
+                this.UpdateData(true);
+                this.velocity = oldVelocity;
+            }
+        }
+    }
+}

package/Runtime/Internal/UI/ScrollViewEx/ScrollView/ScrollViewEx.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 17ff80d59e3504ef385ee40177f0b4a4
+timeCreated: 1533042733
+licenseType: Free
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Runtime/Internal/UI/ScrollViewEx/ScrollView.meta

@@ -0,0 +1,9 @@
+fileFormatVersion: 2
+guid: ab23454192f22412c8ae6f7699645396
+folderAsset: yes
+timeCreated: 1533284978
+licenseType: Free
+DefaultImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Runtime/Internal/UI/ScrollViewEx.meta

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

package/Runtime/Internal/UI.meta

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

package/Runtime/Internal/Utils/BridgeUtils.cs

@@ -0,0 +1,29 @@
+using System;
+using System.Linq;
+using UnityEngine;
+
+namespace TapSDK.Core.Internal.Utils {
+    public static class BridgeUtils {
+        public static bool IsSupportMobilePlatform => Application.platform == RuntimePlatform.Android ||
+            Application.platform == RuntimePlatform.IPhonePlayer;
+
+        public static bool IsSupportStandalonePlatform => Application.platform == RuntimePlatform.OSXPlayer ||
+            Application.platform == RuntimePlatform.WindowsPlayer ||
+            Application.platform == RuntimePlatform.LinuxPlayer;
+
+        public static object CreateBridgeImplementation(Type interfaceType, string startWith) {
+            // 跳过初始化直接使用 TapLoom会在子线程被TapSDK.Core.BridgeCallback.Invoke 初始化
+            TapLoom.Initialize();
+            Type bridgeImplementationType = AppDomain.CurrentDomain.GetAssemblies()
+                .Where(asssembly => asssembly.GetName().FullName.StartsWith(startWith))
+                .SelectMany(assembly => assembly.GetTypes())
+                .SingleOrDefault(clazz => interfaceType.IsAssignableFrom(clazz) && clazz.IsClass);
+            if (bridgeImplementationType == null){
+                Debug.LogWarningFormat(
+                    $"[TapTap] TapSDK Can't find bridge implementation for {interfaceType} on platform {Application.platform}.");
+                return null;
+            }
+            return Activator.CreateInstance(bridgeImplementationType);
+        }
+    }
+}

package/Runtime/Internal/Utils/BridgeUtils.cs.meta

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

package/Runtime/Internal/Utils/ImageUtils.cs

@@ -0,0 +1,147 @@
+using System;
+using System.Collections.Generic;
+using System.Threading.Tasks;
+using System.Security.Cryptography;
+using System.Text;
+using System.IO;
+using UnityEngine;
+using UnityEngine.Networking;
+
+namespace TapSDK.Core.Internal.Utils {
+    public class ImageUtils {
+        private readonly static string CacheDirName = "tap-cache";
+
+        private readonly static MD5 md5 = MD5.Create();
+
+        private readonly static Dictionary<string, WeakReference<Texture>> cachedTextures = new Dictionary<string, WeakReference<Texture>>();
+
+        public static async Task<Texture> LoadImage(string url, int timeout = 30, bool useMemoryCache = true) {
+            if (string.IsNullOrEmpty(url)) {
+                TapLogger.Warn(string.Format($"ImageUtils Fetch image is null! url is null or empty!"));
+                return null;
+            }
+
+            if (cachedTextures.TryGetValue(url, out WeakReference<Texture> refTex) &&
+                refTex.TryGetTarget(out Texture tex)) {
+                // 从内存加载
+                return tex;
+            } else {
+                try {
+                    // 从本地缓存加载
+                    Texture cachedImage = await LoadCachedImaged(url, timeout);
+
+                    if (useMemoryCache) {
+                        cachedTextures[url] = new WeakReference<Texture>(cachedImage);
+                    }
+
+                    return cachedImage;
+                } catch (Exception e) {
+                    TapLogger.Warn(e.Message);
+                    try {
+                        // 从网络加载
+                        Texture2D newTex = await FetchImage(url, timeout);
+
+                        if (useMemoryCache) {
+                            cachedTextures[url] = new WeakReference<Texture>(newTex);
+                        }
+
+                        // 缓存到本地
+                        _ = CacheImage(url, newTex);
+
+                        return newTex;
+                    } catch (Exception ex) {
+                        TapLogger.Warn(ex.Message);
+                        return null;
+                    }
+                }
+            }
+        }
+
+        public static async Task<Texture2D> FetchImage(string url, int timeout = 30) {
+            using (UnityWebRequest request = UnityWebRequestTexture.GetTexture(url)) {
+                request.timeout = timeout;
+                UnityWebRequestAsyncOperation operation = request.SendWebRequest();
+                while (!operation.isDone) {
+                    await Task.Delay(30);
+                }
+
+                if (request.isNetworkError || request.isHttpError) {
+                    throw new Exception("Fetch image error.");
+                } else {
+                    Texture2D texture = ((DownloadHandlerTexture)request.downloadHandler)?.texture;
+                    if (texture == null) {
+                        TapLogger.Warn($"ImageUtils Fetch image is null! url: {url}");
+                    }
+                    return texture;
+                }
+            }
+        }
+
+        static async Task<Texture> LoadCachedImaged(string url, int timeout = 30) {
+            string cachedImagePath = GetCachedPath(url);
+            if (!File.Exists(cachedImagePath)) {
+                throw new Exception("No cached image.");
+            }
+            string cachedImageUrl = $"file://{cachedImagePath}";
+            using (UnityWebRequest request = UnityWebRequestTexture.GetTexture(cachedImageUrl)) {
+                request.timeout = timeout;
+                UnityWebRequestAsyncOperation operation = request.SendWebRequest();
+                while (!operation.isDone) {
+                    await Task.Delay(30);
+                }
+
+                if (request.isNetworkError || request.isHttpError) {
+                    RemoveCachedImage(cachedImagePath);
+                    throw new Exception("Load cache image error.");
+                } else {
+                    var texture = ((DownloadHandlerTexture)request.downloadHandler)?.texture;
+                    if (texture == null) {
+                        RemoveCachedImage(cachedImagePath);
+                        throw new Exception("Cached image is invalid.");
+                    }
+                    return texture;
+                }
+            }
+        }
+
+        static async Task CacheImage(string url, Texture2D tex) {
+            string cacheImagePath = GetCachedPath(url);
+            // 写入缓存
+            byte[] imageData = tex.EncodeToPNG();
+            using (FileStream fileStream = new FileStream(cacheImagePath, FileMode.Create, FileAccess.Write, FileShare.None, bufferSize: 4096, useAsync: true)) {
+                await fileStream.WriteAsync(imageData, 0, imageData.Length);
+            }
+        }
+
+        static void RemoveCachedImage(string cachedImagePath) {
+            try {
+                File.Delete(cachedImagePath);
+            } finally {
+
+            }
+        }
+
+        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();
+        }
+
+        static string GetCachedPath(string url) {
+            string cachedHashName = ToHex(md5.ComputeHash(Encoding.UTF8.GetBytes(url)));
+            return Path.Combine(CacheDirPath, cachedHashName);
+        }
+
+        static string CacheDirPath {
+            get {
+                string path = Path.Combine(Application.persistentDataPath, CacheDirName);
+                if (!Directory.Exists(path)) {
+                    Directory.CreateDirectory(path);
+                }
+                return path;
+            }
+        }
+    }
+}

package/Runtime/Internal/Utils/ImageUtils.cs.meta

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

package/Runtime/Internal/Utils/TapLoom.cs

@@ -0,0 +1,155 @@
+using UnityEngine;
+using System.Collections;
+using System.Collections.Generic;
+using System;
+using System.Threading;
+using System.Linq;
+
+namespace TapSDK.Core.Internal.Utils
+{
+    public class TapLoom : MonoBehaviour
+    {
+        public static int maxThreads = 8;
+        static int numThreads;
+
+        private static TapLoom _current;
+        private int _count;
+        public static TapLoom Current
+        {
+            get
+            {
+                Initialize();
+                return _current;
+            }
+        }
+
+        void Awake()
+        {
+            _current = this;
+            initialized = true;
+        }
+
+        static bool initialized;
+
+        public static void Initialize()
+        {
+            if (!initialized)
+            {
+
+                if (!Application.isPlaying)
+                    return;
+                initialized = true;
+                var g = new GameObject("Loom");
+                DontDestroyOnLoad(g);
+                _current = g.AddComponent<TapLoom>();
+            }
+
+        }
+
+        private List<Action> _actions = new List<Action>();
+        public struct DelayedQueueItem
+        {
+            public float time;
+            public Action action;
+        }
+        private List<DelayedQueueItem> _delayed = new List<DelayedQueueItem>();
+
+        List<DelayedQueueItem> _currentDelayed = new List<DelayedQueueItem>();
+
+        public static void QueueOnMainThread(Action action)
+        {
+            QueueOnMainThread(action, 0f);
+        }
+        public static void QueueOnMainThread(Action action, float time)
+        {
+            if (time != 0)
+            {
+                lock (Current._delayed)
+                {
+                    Current._delayed.Add(new DelayedQueueItem { time = Time.time, action = action });
+                }
+            }
+            else
+            {
+                lock (Current._actions)
+                {
+                    Current._actions.Add(action);
+                }
+            }
+        }
+
+        public static Thread RunAsync(Action a)
+        {
+            Initialize();
+            while (numThreads >= maxThreads)
+            {
+                Thread.Sleep(1);
+            }
+            Interlocked.Increment(ref numThreads);
+            ThreadPool.QueueUserWorkItem(RunAction, a);
+            return null;
+        }
+
+        private static void RunAction(object action)
+        {
+            try
+            {
+                ((Action)action)();
+            }
+            catch
+            {
+            }
+            finally
+            {
+                Interlocked.Decrement(ref numThreads);
+            }
+
+        }
+
+
+        void OnDisable()
+        {
+            if (_current == this)
+            {
+
+                _current = null;
+            }
+        }
+
+
+
+        // Use this for initialization  
+        void Start()
+        {
+
+        }
+
+        List<Action> _currentActions = new List<Action>();
+
+        // Update is called once per frame  
+        void Update()
+        {
+            lock (_actions)
+            {
+                _currentActions.Clear();
+                _currentActions.AddRange(_actions);
+                _actions.Clear();
+            }
+            foreach (var a in _currentActions)
+            {
+                a();
+            }
+            lock (_delayed)
+            {
+                _currentDelayed.Clear();
+                _currentDelayed.AddRange(_delayed.Where(d => d.time <= Time.time));
+                foreach (var item in _currentDelayed)
+                    _delayed.Remove(item);
+            }
+            foreach (var delayed in _currentDelayed)
+            {
+                delayed.action();
+            }
+        }
+    }
+}

package/Runtime/Internal/Utils/TapLoom.cs.meta

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