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

package/Core/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/Core/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/Core/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/Core/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/Core/Runtime/Internal/UI/ScrollViewEx.meta

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

package/Core/Runtime/Internal/UI.meta

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

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

@@ -0,0 +1,148 @@
+using System;
+using System.Linq;
+using System.Collections.Generic;
+using UnityEngine;
+using TapSDK.Core.Internal.Log;
+
+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) {
+            TapLog.Log($"[TapTap] 开始查找实现类: interfaceType={interfaceType.FullName}, startWith={startWith}, 当前平台={Application.platform}");
+            
+            // 跳过初始化直接使用 TapLoom会在子线程被TapSDK.Core.BridgeCallback.Invoke 初始化
+            TapLoom.Initialize();
+            
+            // 获取所有程序集
+            var allAssemblies = AppDomain.CurrentDomain.GetAssemblies();
+            TapLog.Log($"[TapTap] 已加载的程序集总数: {allAssemblies.Length}");
+            
+            // 查找以 startWith 开头的程序集
+            var matchingAssemblies = allAssemblies
+                .Where(assembly => assembly.GetName().FullName.StartsWith(startWith))
+                .ToList();
+            
+            TapLog.Log($"[TapTap] 找到匹配 '{startWith}' 的程序集数量: {matchingAssemblies.Count}");
+            
+            // 打印匹配的程序集名称
+            foreach (var assembly in matchingAssemblies) {
+                TapLog.Log($"[TapTap] 匹配的程序集: {assembly.GetName().FullName}");
+            }
+            
+            // 如果没有找到匹配的程序集，打印所有TapSDK相关的程序集
+            if (matchingAssemblies.Count == 0) {
+                var tapAssemblies = allAssemblies
+                    .Where(assembly => assembly.GetName().FullName.Contains("TapSDK") || 
+                                      assembly.GetName().FullName.Contains("TapTap"))
+                    .ToList();
+                
+                TapLog.Log($"[TapTap] 未找到匹配的程序集，但找到 {tapAssemblies.Count} 个相关程序集:");
+                foreach (var assembly in tapAssemblies) {
+                    TapLog.Log($"[TapTap]  - {assembly.GetName().FullName}");
+                }
+            }
+            
+            // 从匹配的程序集中查找实现指定接口的类
+            List<Type> allCandidateTypes = new List<Type>();
+            foreach (var assembly in matchingAssemblies) {
+                try {
+                    var types = assembly.GetTypes()
+                        .Where(type => type.IsClass && interfaceType.IsAssignableFrom(type))
+                        .ToList();
+                    
+                    TapLog.Log($"[TapTap] 在程序集 {assembly.GetName().Name} 中找到 {types.Count} 个实现 {interfaceType.Name} 的类");
+                    
+                    foreach (var type in types) {
+                        TapLog.Log($"[TapTap]  - {type.FullName} (IsPublic: {type.IsPublic}, IsAbstract: {type.IsAbstract})");
+                        allCandidateTypes.Add(type);
+                    }
+                }
+                catch (Exception ex) {
+                    TapLog.Error($"[TapTap] 获取程序集 {assembly.GetName().Name} 中的类型时出错: {ex.Message}");
+                }
+            }
+            
+            // 使用原始逻辑查找实现类
+            Type bridgeImplementationType = null;
+            try {
+                bridgeImplementationType = matchingAssemblies
+                    .SelectMany(assembly => {
+                        try {
+                            return assembly.GetTypes();
+                        } catch {
+                            return Type.EmptyTypes;
+                        }
+                    })
+                    .SingleOrDefault(clazz => interfaceType.IsAssignableFrom(clazz) && clazz.IsClass);
+                
+                TapLog.Log($"[TapTap] SingleOrDefault 查找结果: {(bridgeImplementationType != null ? bridgeImplementationType.FullName : "null")}");
+                
+                // 如果使用 SingleOrDefault 没找到，尝试使用 FirstOrDefault
+                if (bridgeImplementationType == null && allCandidateTypes.Count > 0) {
+                    TapLog.Log($"[TapTap] SingleOrDefault 未找到实现，但有 {allCandidateTypes.Count} 个候选类型，尝试使用 FirstOrDefault");
+                    bridgeImplementationType = allCandidateTypes.FirstOrDefault();
+                    TapLog.Log($"[TapTap] FirstOrDefault 查找结果: {(bridgeImplementationType != null ? bridgeImplementationType.FullName : "null")}");
+                }
+                
+                // 如果找到多个实现，可能是 SingleOrDefault 失败的原因
+                if (allCandidateTypes.Count > 1) {
+                    TapLog.Warning($"[TapTap] 找到多个实现 {interfaceType.Name} 的类，这可能导致 SingleOrDefault 返回 null");
+                    foreach (var type in allCandidateTypes) {
+                        TapLog.Warning($"[TapTap]  - {type.FullName}");
+                    }
+                }
+            }
+            catch (Exception ex) {
+                TapLog.Error($"[TapTap] 在查找实现类时发生异常: {ex.Message}\n{ex.StackTrace}");
+            }
+            
+            if (bridgeImplementationType == null) {
+                TapLog.Warning($"[TapTap] TapSDK 无法为 {interfaceType} 找到平台 {Application.platform} 上的实现类。");
+                
+                // 尝试在所有程序集中查找实现（不限制命名空间前缀）
+                if (matchingAssemblies.Count == 0) {
+                    TapLog.Log("[TapTap] 尝试在所有程序集中查找实现...");
+                    List<Type> implementationsInAllAssemblies = new List<Type>();
+                    
+                    foreach (var assembly in allAssemblies) {
+                        try {
+                            var types = assembly.GetTypes()
+                                .Where(type => type.IsClass && !type.IsAbstract && interfaceType.IsAssignableFrom(type))
+                                .ToList();
+                            
+                            if (types.Count > 0) {
+                                TapLog.Log($"[TapTap] 在程序集 {assembly.GetName().Name} 中找到 {types.Count} 个实现");
+                                implementationsInAllAssemblies.AddRange(types);
+                            }
+                        }
+                        catch { /* 忽略错误 */ }
+                    }
+                    
+                    if (implementationsInAllAssemblies.Count > 0) {
+                        TapLog.Log($"[TapTap] 在所有程序集中找到 {implementationsInAllAssemblies.Count} 个实现:");
+                        foreach (var type in implementationsInAllAssemblies) {
+                            TapLog.Log($"[TapTap]  - {type.FullName} (在程序集 {type.Assembly.GetName().Name} 中)");
+                        }
+                    }
+                }
+                
+                return null;
+            }
+            
+            try {
+                TapLog.Log($"[TapTap] 创建 {bridgeImplementationType.FullName} 的实例");
+                return Activator.CreateInstance(bridgeImplementationType);
+            }
+            catch (Exception ex) {
+                TapLog.Error($"[TapTap] 创建实例时出错: {ex.Message}");
+                return null;
+            }
+        }
+    }
+}

package/Core/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/Core/Runtime/Internal/Utils/EventManager.cs

@@ -0,0 +1,47 @@
+using System;
+using System.Collections.Generic;
+using TapSDK.UI;
+
+namespace TapSDK.Core.Internal.Utils
+{
+    public sealed class EventManager : Singleton<EventManager> 
+    {
+        public const string OnApplicationPause = "OnApplicationPause";
+        public const string OnApplicationQuit = "OnApplicationQuit";
+
+        public const string OnComplianceUserChanged = "OnComplianceUserChanged";
+        public const string OnTapUserChanged = "OnTapUserChanged";
+        public const string IsLaunchedFromTapTapPCFinished = "IsLaunchedFromTapTapPCFinished";
+        private Dictionary<string, Action<object>> eventRegistries = new Dictionary<string, Action<object>>();
+        
+        public static void AddListener(string eventName, Action<object> listener) {
+            if (listener == null) return;
+            if (string.IsNullOrEmpty(eventName)) return;
+            Action<object> thisEvent;
+            if (Instance.eventRegistries.TryGetValue(eventName, out thisEvent)) {
+                thisEvent += listener;
+                Instance.eventRegistries[eventName] = thisEvent;
+            } else {
+                thisEvent += listener;
+                Instance.eventRegistries.Add(eventName, thisEvent);
+            }
+        }
+        
+        public static void RemoveListener(string eventName, Action<object> listener) {
+            if (listener == null) return;
+            if (string.IsNullOrEmpty(eventName)) return;
+            Action<object> thisEvent;
+            if (Instance.eventRegistries.TryGetValue(eventName, out thisEvent)) {
+                thisEvent -= listener;
+                Instance.eventRegistries[eventName] = thisEvent;
+            }
+        }
+
+        public static void TriggerEvent(string eventName, object message) {
+            Action<object> thisEvent = null;
+            if (Instance.eventRegistries.TryGetValue(eventName, out thisEvent)) {
+                thisEvent.Invoke(message);
+            }
+        }
+    }
+}

package/Core/Runtime/Internal/Utils/EventManager.cs.meta

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

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

@@ -0,0 +1,158 @@
+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;
+using TapSDK.Core.Internal.Log;
+
+namespace TapSDK.Core.Internal.Utils {
+    public class ImageUtils {
+        private readonly static string OldCacheDirName = "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)) {
+                TapLog.Warning(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) {
+                    TapLog.Warning(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) {
+                        TapLog.Warning(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) {
+                        TapLog.Warning($"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 newCacheDirPath = Path.Combine(Application.persistentDataPath, OldCacheDirName);
+                if (TapTapSDK.taptapSdkOptions != null && !string.IsNullOrEmpty(TapTapSDK.taptapSdkOptions.clientId) ){
+                    newCacheDirPath = Path.Combine(Application.persistentDataPath, OldCacheDirName + "_" + TapTapSDK.taptapSdkOptions.clientId);
+                }
+                if(!Directory.Exists(newCacheDirPath)) {
+                    string oldPath = Path.Combine(Application.persistentDataPath, OldCacheDirName);
+                    if (Directory.Exists(oldPath)) {
+                        Directory.Move(oldPath, newCacheDirPath);
+                    }
+                }
+               
+                if (!Directory.Exists(newCacheDirPath)) {
+                    Directory.CreateDirectory(newCacheDirPath);
+                }
+                return newCacheDirPath;
+            }
+        }
+    }
+}