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

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

@@ -0,0 +1,172 @@
+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;
+
+         private bool isPause = false;
+        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("TapLoom");
+                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();
+            }
+        }
+
+        private void OnApplicationPause(bool pauseStatus) {
+             if (pauseStatus && isPause == false) {
+                isPause = true;
+                EventManager.TriggerEvent(EventManager.OnApplicationPause, true);
+            }
+            else if (!pauseStatus && isPause) {
+                isPause = false;
+                EventManager.TriggerEvent(EventManager.OnApplicationPause, false);
+            }
+        }
+
+         private void OnApplicationQuit(){
+            EventManager.TriggerEvent(EventManager.OnApplicationQuit, true);
+        }
+    }
+}

package/Core/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: 

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

@@ -0,0 +1,69 @@
+using System;
+using UnityEngine;
+using UnityEngine.UI;
+public class TapMessage : MonoBehaviour {
+
+    public enum Time
+    {
+        threeSecond,
+        twoSecond,
+        oneSecond
+    };
+    public enum Position
+    {
+        top,
+        bottom
+    };
+    public static void ShowMessage ( string msg, TapMessage.Position position, TapMessage.Time time )
+    {
+
+        //Load message prefab from resources folder
+        GameObject messagePrefab = Resources.Load ( "TapMessage" ) as GameObject;
+        //Get container object of message
+        GameObject containerObject = messagePrefab.gameObject.transform.GetChild ( 0 ).gameObject;
+        //Get text object
+        GameObject textObject = containerObject.gameObject.transform.GetChild ( 0 ).GetChild ( 0 ).gameObject;
+        //Get text property
+        Text msg_text = textObject.GetComponent<Text> ( );
+        //Set message to text ui
+        msg_text.text = msg;
+        //Set position of container object of message
+        SetPosition ( containerObject.GetComponent<RectTransform> ( ), position );
+        //Spawn message object with all changes
+        GameObject clone = Instantiate ( messagePrefab );
+        // Destroy clone of message object according to the time
+        RemoveClone ( clone, time );
+    }
+
+    private static void SetPosition ( RectTransform rectTransform, Position position )
+    {
+        if (position == Position.top)
+        {
+            rectTransform.anchorMin = new Vector2 ( 0.5f, 1f );
+            rectTransform.anchorMax = new Vector2 ( 0.5f, 1f );
+            rectTransform.anchoredPosition = new Vector3 ( 0.5f, -100f, 0 );
+        }
+        else
+        {
+            rectTransform.anchorMin = new Vector2 ( 0.5f, 0 );
+            rectTransform.anchorMax = new Vector2 ( 0.5f, 0 );
+            rectTransform.anchoredPosition = new Vector3 ( 0.5f, 100f, 0 );
+        }
+    }
+
+    private static void RemoveClone ( GameObject clone, Time time )
+    {
+        if (time == Time.oneSecond)
+        {
+            Destroy ( clone.gameObject, 1f );
+        }
+        else if (time == Time.twoSecond)
+        {
+            Destroy ( clone.gameObject, 2f );
+        }
+        else
+        {
+            Destroy ( clone.gameObject, 3f );
+        }
+    }
+}

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

@@ -0,0 +1,13 @@
+fileFormatVersion: 2
+guid: 87a6eaa9efa41844890325132c22595a
+timeCreated: 1532842822
+licenseType: Free
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

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

@@ -0,0 +1,21 @@
+using TapSDK.Core.Internal.Log;
+
+
+namespace TapSDK.Core.Internal.Utils
+{
+    public class TapVerifyInitStateUtils
+    {
+    
+        public static void ShowVerifyErrorMsg(string error, string errorMsg)
+        {
+            if (error != null || error.Length > 0)
+            {
+                TapMessage.ShowMessage(error, TapMessage.Position.bottom, TapMessage.Time.twoSecond);
+            }
+            if (errorMsg != null && errorMsg.Length > 0)
+            {
+                TapLog.Error(errorMsg);
+            }
+        }
+    }
+}

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

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

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

@@ -0,0 +1,34 @@
+using System;
+using System.Linq;
+using System.Collections.Specialized;
+
+namespace TapSDK.Core.Internal.Utils {
+    public class UrlUtils {
+        public static NameValueCollection ParseQueryString(string query) { 
+            NameValueCollection nvc = new NameValueCollection();
+
+            if (query.StartsWith("?")) {
+                query = query.Substring(1);
+            }
+
+            foreach (var param in query.Split('&')) {
+                string[] pair = param.Split('=');
+                if (pair.Length == 2) {
+                    string key = Uri.UnescapeDataString(pair[0]);
+                    string value = Uri.UnescapeDataString(pair[1]);
+                    nvc[key] = value;
+                }
+            }
+
+            return nvc;
+        }
+
+        public static string ToQueryString(NameValueCollection nvc) {
+            var array = (from key in nvc.AllKeys
+                        from value in nvc.GetValues(key)
+                        select $"{Uri.EscapeDataString(key)}={Uri.EscapeDataString(value)}"
+                        ).ToArray();
+            return string.Join("&", array);
+        }
+    }
+}

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

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

package/Core/Runtime/Internal/Utils.meta

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

package/Core/Runtime/Internal.meta

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

package/Core/Runtime/Public/DataStorage.cs

@@ -0,0 +1,173 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Net.NetworkInformation;
+using System.Security.Cryptography;
+using System.Text;
+using TapSDK.Core.Internal.Log;
+using UnityEngine;
+
+namespace TapSDK.Core
+{
+    public static class DataStorage
+    {
+        private static Dictionary<string, string> dataCache;
+        private static byte[] Keys = { 0x12, 0x34, 0x56, 0x78, 0x90, 0xAB, 0xCD, 0xEF };
+        public static void SaveString(string key, string value)
+        {
+            string storageKey = GenerateStorageKey(key);
+            SaveStringToCache(storageKey, value);
+            string encodeValue = EncodeString(value);
+            PlayerPrefs.SetString(storageKey, encodeValue);
+        }
+
+        public static string LoadString(string key)
+        {
+            string storageKey = GenerateStorageKey(key);
+            string value = LoadStringFromCache(storageKey);
+            if (!string.IsNullOrEmpty(value))
+            {
+                return value;
+            }
+            value = PlayerPrefs.HasKey(storageKey) ? DecodeString(PlayerPrefs.GetString(storageKey)) : null;
+            // 尝试从本地获取旧版本数据
+            if (value == null)
+            {
+                value = PlayerPrefs.HasKey(key) ? DecodeString(PlayerPrefs.GetString(key)) : null;
+                // 旧版本存在有效数据时，转储为新的 storageKey
+                if (value != null)
+                {
+                    PlayerPrefs.SetString(storageKey, EncodeString(value));
+                    PlayerPrefs.DeleteKey(key);
+                }
+            }
+            if (value != null)
+            {
+                SaveStringToCache(storageKey, value);
+            }
+            return value;
+        }
+
+        public static void RemoveCacheKey(string key)
+        {
+            if (!string.IsNullOrEmpty(key))
+            {
+                PlayerPrefs.DeleteKey(key);
+                PlayerPrefs.DeleteKey(GenerateStorageKey(key));
+            }
+        }
+
+        private static void SaveStringToCache(string key, string value)
+        {
+            if (dataCache == null)
+            {
+                dataCache = new Dictionary<string, string>();
+            }
+            if (dataCache.ContainsKey(key))
+            {
+                dataCache[key] = value;
+            }
+            else
+            {
+                dataCache.Add(key, value);
+            }
+        }
+        
+        private static string LoadStringFromCache(string key)
+        {
+            if (dataCache == null)
+            {
+                dataCache = new Dictionary<string, string>();
+            }
+            return dataCache.ContainsKey(key) ? dataCache[key] : null;
+        }
+        
+        private static string EncodeString(string encryptString)
+        {
+            if (Platform.IsAndroid() || Platform.IsIOS())
+            {
+                return encryptString;
+            }
+            try
+            {
+                byte[] rgbKey = Encoding.UTF8.GetBytes(GetMacAddress().Substring(0, 8));
+                byte[] rgbIV = Keys;
+                byte[] inputByteArray = Encoding.UTF8.GetBytes(encryptString);
+                DESCryptoServiceProvider dCSP = new DESCryptoServiceProvider();
+                MemoryStream mStream = new MemoryStream();
+                CryptoStream cStream = new CryptoStream(mStream, dCSP.CreateEncryptor(rgbKey, rgbIV), CryptoStreamMode.Write);
+                cStream.Write(inputByteArray, 0, inputByteArray.Length);
+                cStream.FlushFinalBlock();
+                cStream.Close();
+                return Convert.ToBase64String(mStream.ToArray());
+            }
+            catch
+            {
+                return encryptString;
+            }
+        }
+
+        private static string DecodeString(string decryptString)
+        {
+            if (Platform.IsAndroid() || Platform.IsIOS())
+            {
+                return decryptString;
+            }
+            try
+            {
+                byte[] rgbKey = Encoding.UTF8.GetBytes(GetMacAddress().Substring(0, 8));
+                byte[] rgbIV = Keys;
+                byte[] inputByteArray = Convert.FromBase64String(decryptString);
+                DESCryptoServiceProvider DCSP = new DESCryptoServiceProvider();
+                MemoryStream mStream = new MemoryStream();
+                CryptoStream cStream = new CryptoStream(mStream, DCSP.CreateDecryptor(rgbKey, rgbIV), CryptoStreamMode.Write);
+                cStream.Write(inputByteArray, 0, inputByteArray.Length);
+                cStream.FlushFinalBlock();
+                cStream.Close();
+                return Encoding.UTF8.GetString(mStream.ToArray());
+            }
+            catch (Exception e)
+            {
+                TapLog.Log(e.Message);
+                return decryptString;
+            }
+        }
+
+        private static string GetMacAddress()
+        {
+            string physicalAddress = "FFFFFFFFFFFF";
+            if (Platform.IsAndroid() || Platform.IsIOS())
+            {
+                return physicalAddress;
+            }
+            NetworkInterface[] nice = NetworkInterface.GetAllNetworkInterfaces();
+
+            foreach (NetworkInterface adaper in nice)
+            {
+                if (adaper.Description == "en0")
+                {
+                    physicalAddress = adaper.GetPhysicalAddress().ToString();
+                    break;
+                }
+                else
+                {
+                    physicalAddress = adaper.GetPhysicalAddress().ToString();
+
+                    if (physicalAddress != "")
+                    {
+                        break;
+                    };
+                }
+            }
+            return physicalAddress;
+        }
+
+        // 生成存储在本地文件中 key
+        private static string GenerateStorageKey(string originKey){
+            if(TapTapSDK.taptapSdkOptions != null && !string.IsNullOrEmpty(TapTapSDK.taptapSdkOptions.clientId)){
+                return originKey + "_" + TapTapSDK.taptapSdkOptions.clientId;
+            }
+           return originKey;
+        }
+    }
+}

package/Core/Runtime/Public/DataStorage.cs.meta

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

package/Core/Runtime/Public/ITapPropertiesProxy.cs

@@ -0,0 +1,6 @@
+
+namespace TapSDK.Core {
+    public interface ITapPropertiesProxy {
+        string GetProperties();
+    }
+}

package/Core/Runtime/Public/ITapPropertiesProxy.cs.meta

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