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

package/Runtime/Internal/Platform/ITapEventPlatform.cs

@@ -0,0 +1,37 @@
+using System;
+
+namespace TapSDK.Core.Internal {
+    public interface ITapEventPlatform {
+        void SetUserID(string userID);
+        
+        void SetUserID(string userID, string properties);
+        void ClearUser();
+
+        string GetDeviceId();
+    
+        void LogEvent(string name, string properties);
+
+        void DeviceInitialize(string properties);
+
+        void DeviceUpdate(string properties);
+        void DeviceAdd(string properties);
+
+        void UserInitialize(string properties);
+
+        void UserUpdate(string properties);
+
+        void UserAdd(string properties);
+
+        void AddCommonProperty(string key, string value);
+
+        void AddCommon(string properties);
+
+        void ClearCommonProperty(string key);
+        void ClearCommonProperties(string[] keys);
+
+        void ClearAllCommonProperties();
+        void LogChargeEvent(string orderID, string productName, long amount, string currencyType, string paymentMethod, string properties);
+    
+        void RegisterDynamicProperties(Func<string> callback);
+    }
+}

package/Runtime/Internal/Platform/ITapEventPlatform.cs.meta

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

package/Runtime/Internal/Platform/PlatformTypeUtils.cs

@@ -0,0 +1,46 @@
+using System;
+using System.Linq;
+using UnityEngine;
+
+namespace TapSDK.Core.Internal {
+    public static class PlatformTypeUtils {
+        /// <summary>
+        /// 创建平台接口实现类对象
+        /// </summary>
+        /// <param name="interfaceType"></param>
+        /// <param name="startWith"></param>
+        /// <returns></returns>
+        public static object CreatePlatformImplementationObject(Type interfaceType, string startWith) {
+            Debug.Log($"Searching for types in assemblies starting with: {startWith} that implement: {interfaceType}");
+
+            // 获取所有符合条件的程序集
+            var assemblies = AppDomain.CurrentDomain.GetAssemblies()
+                .Where(assembly => assembly.GetName().FullName.StartsWith(startWith));
+
+            foreach (var assembly in assemblies) {
+                Debug.Log($"Found assembly: {assembly.GetName().FullName}");
+            }
+
+            // 获取符合条件的类型
+            Type platformSupportType = assemblies
+                .SelectMany(assembly => assembly.GetTypes())
+                .SingleOrDefault(clazz => interfaceType.IsAssignableFrom(clazz) && clazz.IsClass);
+
+            if (platformSupportType != null) {
+                Debug.Log($"Found type: {platformSupportType.FullName}, creating instance...");
+                try
+                {
+                    return Activator.CreateInstance(platformSupportType);
+                }
+                catch (Exception ex)
+                {
+                    Debug.LogError($"Failed to create instance of {platformSupportType.FullName}: {ex}");
+                }
+            } else {
+                Debug.LogError($"No type found that implements {interfaceType} in assemblies starting with {startWith}");
+            }
+
+            return null;
+        }
+    }
+}

package/Runtime/Internal/Platform/PlatformTypeUtils.cs.meta

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

package/Runtime/Internal/Platform.meta

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

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

@@ -0,0 +1,27 @@
+using System;
+namespace TapSDK.UI
+{
+    public enum EOpenMode
+    {
+        Sync,
+
+        Async,
+    }
+
+    [Flags]
+    public enum EAnimationMode
+    {
+        None = 0,
+
+        Alpha = 1 << 0,
+
+        Scale = 1 << 1,
+        
+        RightSlideIn = 1 << 2,
+        
+        UpSlideIn = 1 << 3,
+        ToastSlideIn = 1 << 4,
+
+        AlphaAndScale =  Alpha | Scale,
+    }
+}

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

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

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

@@ -0,0 +1,240 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+using UnityEngine;
+using UnityEngine.EventSystems;
+using UnityEngine.Serialization;
+using UnityEngine.UI;
+
+namespace  TapTap.UI
+{
+    /// <summary>
+    /// 修复UnityUGui中Canvas画布在Windows平台宽高比过长（横屏拉很长）导致UI的最右边一部分无法被点击的Bug,现发现与2021.3.x版本
+    /// </summary>
+    public class GraphicRaycasterBugFixed : GraphicRaycaster
+    {
+        [NonSerialized] private List<Graphic> m_RaycastResults = new List<Graphic>();
+        private Canvas _Canvas;
+        private Canvas canvasBugFixed
+        {
+            get
+            {
+                if (_Canvas != null)
+                    return _Canvas;
+     
+                _Canvas = GetComponent<Canvas>();
+                return _Canvas;
+            }
+        }
+        /// <summary>
+        /// Perform the raycast against the list of graphics associated with the Canvas.
+        /// </summary>
+        /// <param name="eventData">Current event data</param>
+        /// <param name="resultAppendList">List of hit objects to append new results to.</param>
+        public override void Raycast(PointerEventData eventData, List<RaycastResult> resultAppendList)
+        {
+            if (canvasBugFixed == null)
+                return;
+     
+            var canvasGraphics = GraphicRegistry.GetGraphicsForCanvas(canvasBugFixed);
+            if (canvasGraphics == null || canvasGraphics.Count == 0)
+                return;
+     
+            int displayIndex;
+            var currentEventCamera = eventCamera; // Property can call Camera.main, so cache the reference
+     
+            if (canvasBugFixed.renderMode == RenderMode.ScreenSpaceOverlay || currentEventCamera == null)
+                displayIndex = canvasBugFixed.targetDisplay;
+            else
+                displayIndex = currentEventCamera.targetDisplay;
+     
+            //!! 不同之处
+            var eventPosition = Display.RelativeMouseAt(eventData.position); 
+            //MultipleDisplayUtilities.RelativeMouseAtScaled(eventData.position);
+            if (eventPosition != Vector3.zero)
+            {
+                // We support multiple display and display identification based on event position.
+     
+                int eventDisplayIndex = (int)eventPosition.z;
+     
+                // Discard events that are not part of this display so the user does not interact with multiple displays at once.
+                if (eventDisplayIndex != displayIndex)
+                    return;
+            }
+            else
+            {
+                // The multiple display system is not supported on all platforms, when it is not supported the returned position
+                // will be all zeros so when the returned index is 0 we will default to the event data to be safe.
+                eventPosition = eventData.position;
+
+                // We dont really know in which display the event occured. We will process the event assuming it occured in our display.
+            }
+     
+            // Convert to view space
+            Vector2 pos;
+            if (currentEventCamera == null)
+            {
+                // Multiple display support only when not the main display. For display 0 the reported
+                // resolution is always the desktops resolution since its part of the display API,
+                // so we use the standard none multiple display method. (case 741751)
+                float w = Screen.width;
+                float h = Screen.height;
+                if (displayIndex > 0 && displayIndex < Display.displays.Length)
+                {
+                    w = Display.displays[displayIndex].systemWidth;
+                    h = Display.displays[displayIndex].systemHeight;
+                }
+                pos = new Vector2(eventPosition.x / w, eventPosition.y / h);
+            }
+            else
+                pos = currentEventCamera.ScreenToViewportPoint(eventPosition);
+     
+            // If it's outside the camera's viewport, do nothing
+            if (pos.x < 0f || pos.x > 1f || pos.y < 0f || pos.y > 1f)
+                return;
+     
+            float hitDistance = float.MaxValue;
+     
+            Ray ray = new Ray();
+     
+            if (currentEventCamera != null)
+                ray = currentEventCamera.ScreenPointToRay(eventPosition);
+     
+            if (canvasBugFixed.renderMode != RenderMode.ScreenSpaceOverlay && blockingObjects != BlockingObjects.None)
+            {
+                float distanceToClipPlane = 100.0f;
+     
+                if (currentEventCamera != null)
+                {
+                    float projectionDirection = ray.direction.z;
+                    distanceToClipPlane = Mathf.Approximately(0.0f, projectionDirection)
+                        ? Mathf.Infinity
+                        : Mathf.Abs((currentEventCamera.farClipPlane - currentEventCamera.nearClipPlane) / projectionDirection);
+                }
+    #if PACKAGE_PHYSICS
+                    if (blockingObjects == BlockingObjects.ThreeD || blockingObjects == BlockingObjects.All)
+                    {
+                        if (ReflectionMethodsCache.Singleton.raycast3D != null)
+                        {
+                            var hits = ReflectionMethodsCache.Singleton.raycast3DAll(ray, distanceToClipPlane, (int)m_BlockingMask);
+                            if (hits.Length > 0)
+                                hitDistance = hits[0].distance;
+                        }
+                    }
+    #endif
+    #if PACKAGE_PHYSICS2D
+                    if (blockingObjects == BlockingObjects.TwoD || blockingObjects == BlockingObjects.All)
+                    {
+                        if (ReflectionMethodsCache.Singleton.raycast2D != null)
+                        {
+                            var hits = ReflectionMethodsCache.Singleton.getRayIntersectionAll(ray, distanceToClipPlane, (int)m_BlockingMask);
+                            if (hits.Length > 0)
+                                hitDistance = hits[0].distance;
+                        }
+                    }
+    #endif
+            }
+     
+            m_RaycastResults.Clear();
+     
+            Raycast(canvasBugFixed, currentEventCamera, eventPosition, canvasGraphics, m_RaycastResults);
+     
+            int totalCount = m_RaycastResults.Count;
+            for (var index = 0; index < totalCount; index++)
+            {
+                var go = m_RaycastResults[index].gameObject;
+                bool appendGraphic = true;
+     
+                if (ignoreReversedGraphics)
+                {
+                    if (currentEventCamera == null)
+                    {
+                        // If we dont have a camera we know that we should always be facing forward
+                        var dir = go.transform.rotation * Vector3.forward;
+                        appendGraphic = Vector3.Dot(Vector3.forward, dir) > 0;
+                    }
+                    else
+                    {
+                        // If we have a camera compare the direction against the cameras forward.
+                        var cameraForward = currentEventCamera.transform.rotation * Vector3.forward * currentEventCamera.nearClipPlane;
+                        // !!不同之处
+                        appendGraphic = Vector3.Dot(go.transform.position - currentEventCamera.transform.position - cameraForward, go.transform.forward) >= 0;
+                    }
+                }
+     
+                if (appendGraphic)
+                {
+                    float distance = 0;
+                    Transform trans = go.transform;
+                    Vector3 transForward = trans.forward;
+     
+                    if (currentEventCamera == null || canvasBugFixed.renderMode == RenderMode.ScreenSpaceOverlay)
+                        distance = 0;
+                    else
+                    {
+                        // http://geomalgorithms.com/a06-_intersect-2.html
+                        distance = (Vector3.Dot(transForward, trans.position - ray.origin) / Vector3.Dot(transForward, ray.direction));
+     
+                        // Check to see if the go is behind the camera.
+                        if (distance < 0)
+                            continue;
+                    }
+     
+                    if (distance >= hitDistance)
+                        continue;
+     
+                    var castResult = new RaycastResult
+                    {
+                        gameObject = go,
+                        module = this,
+                        distance = distance,
+                        screenPosition = eventPosition,
+                        displayIndex = displayIndex,
+                        index = resultAppendList.Count,
+                        depth = m_RaycastResults[index].depth,
+                        sortingLayer = canvasBugFixed.sortingLayerID,
+                        sortingOrder = canvasBugFixed.sortingOrder,
+                        worldPosition = ray.origin + ray.direction * distance,
+                        worldNormal = -transForward
+                    };
+                    resultAppendList.Add(castResult);
+                }
+            }
+        }
+        /// <summary>
+        /// Perform a raycast into the screen and collect all graphics underneath it.
+        /// </summary>
+        [NonSerialized] static readonly List<Graphic> s_SortedGraphics = new List<Graphic>();
+        private static void Raycast(Canvas canvas, Camera eventCamera, Vector2 pointerPosition, IList<Graphic> foundGraphics, List<Graphic> results)
+        {
+            // Necessary for the event system
+            int totalCount = foundGraphics.Count;
+            for (int i = 0; i < totalCount; ++i)
+            {
+                Graphic graphic = foundGraphics[i];
+     
+                // -1 means it hasn't been processed by the canvas, which means it isn't actually drawn
+                if (!graphic.raycastTarget || graphic.canvasRenderer.cull || graphic.depth == -1)
+                    continue;
+     
+                if (!RectTransformUtility.RectangleContainsScreenPoint(graphic.rectTransform, pointerPosition, eventCamera))
+                    continue;
+     
+                if (eventCamera != null && eventCamera.WorldToScreenPoint(graphic.rectTransform.position).z > eventCamera.farClipPlane)
+                    continue;
+     
+                if (graphic.Raycast(pointerPosition, eventCamera))
+                {
+                    s_SortedGraphics.Add(graphic);
+                }
+            }
+     
+            s_SortedGraphics.Sort((g1, g2) => g2.depth.CompareTo(g1.depth));
+            totalCount = s_SortedGraphics.Count;
+            for (int i = 0; i < totalCount; ++i)
+                results.Add(s_SortedGraphics[i]);
+     
+            s_SortedGraphics.Clear();
+        }
+    }
+}

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

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 39341cb1058fe4bdebd02bc59f5c08e1
+timeCreated: 1678941027

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

@@ -0,0 +1,29 @@
+using UnityEngine;
+
+namespace TapSDK.UI
+{
+    public class LoadingPanelController : BasePanelController
+    {
+        public Transform rotater;
+
+        public float speed = 10;
+        /// <summary>
+        /// bind ugui components for every panel
+        /// </summary>
+        protected override void BindComponents()
+        {
+            rotater = transform.Find("Image");;
+        }
+
+        private void Update()
+        {
+            if (rotater != null)
+            {
+                var localEuler = rotater.localEulerAngles;
+                var z = rotater.localEulerAngles.z;
+                z += Time.deltaTime * speed;
+                rotater.localEulerAngles = new Vector3(localEuler.x, localEuler.y, z);
+            }
+        }
+    }
+}

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

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

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

@@ -0,0 +1,102 @@
+using System;
+using UnityEngine;
+
+namespace TapSDK.UI
+{
+    public class MonoSingleton<T> : MonoBehaviour where T : Component
+    {
+        private static T _instance;
+
+        public static T Instance
+        {
+            get
+            {
+                if (_instance == null && Application.isPlaying)
+                {
+                    CreateInstance();
+                }
+
+                return _instance;
+            }
+        }
+
+        private static void CreateInstance()
+        {
+            Type theType = typeof(T);
+
+            _instance = (T)FindObjectOfType(theType);
+
+            if (_instance == null)
+            {
+                var go = new GameObject(typeof(T).Name);
+                _instance = go.AddComponent<T>();
+
+                GameObject rootObj = GameObject.Find("TapSDKSingletons");
+                if (rootObj == null)
+                {
+                    rootObj = new GameObject("TapSDKSingletons");
+                    DontDestroyOnLoad(rootObj);
+                }
+
+                go.transform.SetParent(rootObj.transform);
+            }
+        }
+
+        public static void DestroyInstance()
+        {
+            if (_instance != null)
+            {
+                Destroy(_instance.gameObject);
+            }
+        }
+
+        public static bool HasInstance()
+        {
+            return _instance != null;
+        }
+
+        protected virtual void Awake()
+        {
+            if (_instance != null && _instance.gameObject != gameObject)
+            {
+                if (Application.isPlaying)
+                {
+                    Destroy(gameObject);
+                }
+                else
+                {
+                    DestroyImmediate(gameObject); // UNITY_EDITOR
+                }
+
+                return;
+            }
+            else if (_instance == null)
+            {
+                _instance = GetComponent<T>();
+            }
+
+            DontDestroyOnLoad(gameObject);
+
+            Init();
+        }
+
+        protected virtual void OnDestroy()
+        {
+            Uninit();
+
+            if (_instance != null && _instance.gameObject == gameObject)
+            {
+                _instance = null;
+            }
+        }
+
+        public virtual void Init()
+        {
+        }
+
+        public virtual void Uninit()
+        {
+        }
+
+    }
+}

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

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

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

@@ -0,0 +1,29 @@
+using System;
+
+namespace TapSDK.UI
+{
+    public class Singleton<T> where T : class
+    {
+        private static T _instance;
+        private static readonly object _lock = new object();
+
+        public static T Instance
+        {
+            get
+            {
+                if (_instance == null)
+                {
+                    lock (_lock)
+                    {
+                        if (_instance == null)
+                        {
+                            _instance = (T)Activator.CreateInstance(typeof(T), true);
+                        }
+                    }
+                }
+
+                return _instance;
+            }
+        }
+    }
+}

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

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

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

@@ -0,0 +1,45 @@
+using System;
+using UnityEngine;
+using UnityEngine.UI;
+
+namespace TapSDK.UI
+{
+    public class TipPanelOpenParam : AbstractOpenPanelParameter
+    {
+        public string text;
+
+        public Color textColor;
+
+        public TextAnchor textAnchor;
+
+        public TipPanelOpenParam(string text, Color textColor, TextAnchor textAnchor)
+        {
+            this.text = text;
+            this.textColor = textColor;
+            this.textAnchor = textAnchor;
+        }
+    }
+    public class TipPanelController : BasePanelController
+    {
+        public Text text;
+
+        protected override void BindComponents()
+        {
+            base.BindComponents();
+            text = transform.Find("Text").GetComponent<Text>();
+        }
+
+        protected override void OnLoadSuccess()
+        {
+            base.OnLoadSuccess();
+            TipPanelOpenParam param = this.openParam as TipPanelOpenParam;
+            if (param != null)
+            {
+                text.text = param.text;
+                text.color = param.textColor;
+                text.alignment = param.textAnchor;
+            }
+        }
+
+    }
+}

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

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 4bf8716943aca4601b13dfac46ccf44b
+timeCreated: 1690867588