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

package/Compliance/Standalone/Runtime/Internal/TapTapComplianceManager.cs

@@ -0,0 +1,269 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Threading.Tasks;
+using TapSDK.Compliance.Internal;
+using TapSDK.Compliance.Localization;
+using TapSDK.UI;
+using TapSDK.Compliance.Model;
+using TapSDK.Core;
+using UnityEngine;
+using TapSDK.Login;
+using Network = TapSDK.Compliance.Internal.Network;
+using TapSDK.Core.Internal.Log;
+
+namespace TapSDK.Compliance 
+{
+    public class TapTapComplianceManager
+    {
+        public static string UserId;
+
+        public static string ClientId { get; private set; }
+
+        public static TapTapComplianceOption config;
+        
+        private static bool needResumePoll;
+
+        public static TapTapComplianceOption ComplianceConfig => config == null ? config = new TapTapComplianceOption() : config;
+
+        public static ComplianceLocalizationItems LocalizationItems
+        {
+            get
+            {
+                if (_ComplianceLocalizationItems == null)
+                {
+                    var textAsset = Resources.Load<TextAsset>(ComplianceLocalizationItems.PATH);
+                    _ComplianceLocalizationItems = ComplianceLocalizationItems.FromJson(textAsset.text);
+                }
+                return _ComplianceLocalizationItems;
+            }
+        }
+        private static ComplianceLocalizationItems _ComplianceLocalizationItems;
+        public static bool CanPlay = false;
+
+        private static PlayableResult _currentPlayableResult;
+        internal static PlayableResult CurrentPlayableResult
+        {
+            get => _currentPlayableResult;
+            set
+            {
+                if (CurrentRemainSeconds == null)
+                {
+                    CompliancePoll.StartCountdownRemainTime();
+                }
+
+                if (value != null)
+                {
+                    CurrentRemainSeconds = value.RemainTime;
+                }
+                _currentPlayableResult = value;
+            }
+        }
+
+        private static UserComplianceConfigResult _currentUserAntiResult;
+        public  static UserComplianceConfigResult CurrentUserAntiResult
+        {
+            get => _currentUserAntiResult;
+            set
+            {
+                Config.userLocalConfig = value.localConfig;
+                _currentUserAntiResult = value;
+            }
+        }
+
+        internal static string CurrentSession = "";
+
+        internal static int? CurrentRemainSeconds {get; set; }
+
+        private static BaseComplianceWorker worker;
+
+        /// <summary>
+        /// 初始化, 建议使用这个接口,因为默认调用了 SetRegion,如果使用另一个 Init 接口,需要在 Init 之后,手动调用 SetRegion
+        /// </summary>
+        /// <param name="config"></param>
+        public static void Init(string clientId, string clientToken, TapTapComplianceOption config) 
+        {
+            if (config == null)
+            {
+                throw new ArgumentNullException(nameof(config));
+            }
+
+            TapTapComplianceManager.config = config;
+            if (string.IsNullOrEmpty(clientId)) 
+            {
+                throw new ArgumentNullException(nameof(clientId));
+            }
+            TapTapComplianceManager.ClientId = clientId;
+            Network.SetGameInfo(clientId, clientToken);
+            Network.InitSetting();
+            var textAsset = Resources.Load<TextAsset>(ComplianceLocalizationItems.PATH);
+            _ComplianceLocalizationItems = ComplianceLocalizationItems.FromJson(textAsset.text);
+        }
+        
+        public static void SetTestEnvironment(bool enable) {
+            Network.SetTestEnvironment(enable);
+            if (enable)
+                UIManager.Instance.OpenTip("当前处于防沉迷调试模式", Color.red, TextAnchor.UpperRight);
+            else {
+                UIManager.Instance.CloseTip();
+            }
+        }
+        /// <summary>
+        /// 启动
+        /// </summary>
+        /// <param name="userId">用户名</param>
+        /// <returns></returns>
+        public static async Task<int> StartUp(string userId) {
+            if (string.IsNullOrEmpty(userId)) 
+            {
+                throw new ArgumentNullException(nameof(userId));
+            }
+            
+            UserId = userId;
+            UIManager.Instance.OpenLoading();
+            InitWorker();
+            bool isSuccess = await UpdateConfig(userId);
+            if(isSuccess){
+                return await Worker.StartUp(UserId);
+            }else{
+                UIManager.Instance.CloseLoading();
+                return StartUpResult.INVALID_CLIENT_OR_NETWORK_ERROR;
+            }
+        }
+        
+        private static void InitWorker() {
+            var worker = Worker;
+            TapTapComplianceManager.worker = worker;
+        }
+        
+        private static async Task<bool> UpdateConfig(string userId) {
+            return await worker.FetchConfigAsync(userId);
+        }
+
+        /// <summary>
+        /// 登出
+        /// </summary>
+        public static void Logout() 
+        {
+            CurrentRemainSeconds = null;
+            CurrentPlayableResult = null;
+            Worker.Logout();
+        }
+
+        internal static void ClearUserCache(){
+            CurrentRemainSeconds = null;
+            CurrentPlayableResult = null;
+            Worker.Logout(false);
+        }
+
+
+        /// <summary>
+        /// 检查支付
+        /// </summary>
+        /// <param name="amount"></param>
+        /// <returns></returns>
+        public static async Task<PayableResult> CheckPayLimit(long amount)
+        {
+            return await Worker.CheckPayableAsync(amount);
+        }
+
+        /// <summary>
+        /// 上报支付
+        /// </summary>
+        /// <param name="amount"></param>
+        /// <returns></returns>
+        public static Task SubmitPayResult(long amount) 
+        {
+            return Worker.SubmitPayResult(amount);
+        }
+        
+        /// <summary>
+        /// 轮询时,检查可玩性
+        /// </summary>
+        /// <returns></returns>
+        internal static async Task<PlayableResult> CheckPlayableOnPolling()
+        {
+            CurrentPlayableResult = await Worker.CheckPlayableOnPollingAsync();
+            return CurrentPlayableResult;
+        }
+        
+        public static void EnterGame()
+        {
+            if (CanPlay && needResumePoll)
+            {
+                TapLog.Log("enter game in antiAddiciton  " );
+                CompliancePoll.StartUp();
+                needResumePoll = false;
+            }
+        }
+
+        public static void LeaveGame()
+        {
+            if (CanPlay && CompliancePoll.StartPoll)
+            {
+                TapLog.Log("leave game in antiAddiciton ");
+                CompliancePoll.Logout();
+                needResumePoll = true;
+            }
+        }
+
+        /// <summary>
+        /// 是否使用移动版 UI,否则就是用 Standalone 版本 UI
+        /// </summary>
+        /// <returns></returns>
+        public static bool IsUseMobileUI()
+        {
+            return false;
+        }
+
+         /// 首次通过，弹防沉迷提示文案
+        internal static void ShowAntiAddictionTip()
+        {
+            if (string.IsNullOrEmpty(UserId)){
+                return;
+            }
+            var userIdEncode = "compliance_tip_" + Tool.EncryptString(UserId);
+            var hasShowTip = !string.IsNullOrEmpty(DataStorage.LoadString(userIdEncode));
+            if (!hasShowTip)
+            {
+                TapMessage.ShowMessage("已通过防沉迷校验，祝您游戏愉快！", position:TapMessage.Position.bottom, time:TapMessage.Time.threeSecond);
+                DataStorage.SaveString(userIdEncode, "1");
+            }
+        }
+        
+        public static bool? useMobileUI;
+        
+        #region Worker
+        
+        private static BaseComplianceWorker currentWorker ;
+
+        private static BaseComplianceWorker GetWorker()
+        {
+            if (currentWorker == null){
+                currentWorker = GetChinaWorker();
+            }
+            return currentWorker;
+            
+        }
+
+        private static BaseComplianceWorker Worker => GetWorker();
+
+        private static BaseComplianceWorker GetChinaWorker() {
+            // get ChinaComplianceWorker from TapSDK.Compliance.Standalone.Runtime dll
+            Type baseWorkerType = typeof(BaseComplianceWorker);
+            Type[] chinaWorkerType = AppDomain.CurrentDomain.GetAssemblies()
+                .Where(asssembly => asssembly.GetName().FullName.StartsWith("TapSDK.Compliance.Standalone.Runtime"))
+                .SelectMany(assembly => assembly.GetTypes())
+                .Where(clazz => baseWorkerType.IsAssignableFrom(clazz) && clazz.IsClass)
+                .ToArray();
+            if (chinaWorkerType != null && chinaWorkerType.Length > 0) {
+                return Activator.CreateInstance(chinaWorkerType[0]) as BaseComplianceWorker;
+            }
+
+            return null;
+        }
+
+        #endregion
+    }
+}

package/Compliance/Standalone/Runtime/Internal/TapTapComplianceManager.cs.meta

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

package/Compliance/Standalone/Runtime/Internal/Tool.cs

@@ -0,0 +1,212 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Security.Cryptography;
+using System.Text;
+using TapSDK.Core.Internal.Log;
+using UnityEngine;
+
+namespace TapSDK.Compliance.Internal
+{
+    public static class Tool
+    {
+        public static int GetMonthDayCount(int year, int month)
+        {
+            switch (month)
+            {
+                case 1:
+                case 3:
+                case 5:
+                case 7:
+                case 8:
+                case 10:
+                case 12:
+                    return 31;
+                case 2:
+                    return IsLeapYear(year) ? 29 : 28;
+                default:
+                    return 30;
+            }
+        }
+
+        public static bool IsLeapYear(int year)
+        {
+            return year % 4 == 0 && year % 100 != 0 || year % 400 == 0;
+        }
+        
+        /// <summary>
+        /// md5加密
+        /// </summary>
+        /// <param name="str"></param>
+        /// <returns></returns>
+        public static string EncryptString(string str)
+        {
+            MD5 md5 = MD5.Create();
+            // 将字符串转换成字节数组
+            byte[] byteOld = Encoding.UTF8.GetBytes(str);
+            // 调用加密方法
+            byte[] byteNew = md5.ComputeHash(byteOld);
+            // 将加密结果转换为字符串
+            StringBuilder sb = new StringBuilder();
+            foreach (byte b in byteNew)
+            {
+                // 将字节转换成16进制表示的字符串，
+                sb.Append(b.ToString("x2"));
+            }
+
+            // 返回加密的字符串
+            return sb.ToString();
+        }
+
+        /// <summary>
+        /// Encrypt the content with public key (in string)
+        /// </summary>
+        /// <param name="input"></param>
+        /// <param name="key"></param>
+        /// <returns></returns>
+        public static string RsaEncrypt(string input, string key)
+        {
+            //https://stackoverflow.com/questions/11506891/how-to-load-the-rsa-public-key-from-file-in-c-sharp
+            try
+            {
+                var base64Info = Convert.FromBase64String(key);
+                RSACryptoServiceProvider rsa = DecodeX509PublicKey(base64Info);
+                int chunckSize = 245;
+                var encodeInfo = Encoding.UTF8.GetBytes(input);
+                
+                // 用来存储加密后的数据的列表
+                List<byte[]> encryptedDataList = new List<byte[]>();
+
+                // 分段加密
+                for (int i = 0; i < encodeInfo.Length; i += chunckSize) {
+                    int blockSize = Math.Min(chunckSize, encodeInfo.Length - i);
+                    byte[] blockData = new byte[blockSize];
+                    Buffer.BlockCopy(encodeInfo, i, blockData, 0, blockSize);
+                    byte[] encryptedBlock = rsa.Encrypt(blockData, false);
+                    encryptedDataList.Add(encryptedBlock);
+                }
+                // 将加密后的数据拼接在一起
+                byte[] encryptedData = encryptedDataList.SelectMany(x => x).ToArray();
+                // 最终的加密结果可以保存到文件或通过网络传输
+                string encryptedString = Convert.ToBase64String(encryptedData);
+                return encryptedString;
+            }
+            catch (Exception e)
+            {
+                TapLog.Error(" TapCompliance RSA Encrypt Error!");
+                return null;
+            }
+        }
+
+        private static bool CompareBytearrays(byte[] a, byte[] b)
+        {
+            if (a.Length != b.Length)
+                return false;
+            int i = 0;
+            foreach (byte c in a)
+            {
+                if (c != b[i])
+                    return false;
+                i++;
+            }
+
+            return true;
+        }
+
+        private static RSACryptoServiceProvider DecodeX509PublicKey(byte[] x509Key)
+        {
+            // encoded OID sequence for  PKCS #1 rsaEncryption szOID_RSA_RSA = "1.2.840.113549.1.1.1"
+            byte[] seqOid = { 0x30, 0x0D, 0x06, 0x09, 0x2A, 0x86, 0x48, 0x86, 0xF7, 0x0D, 0x01, 0x01, 0x01, 0x05, 0x00 };
+            // ---------  Set up stream to read the asn.1 encoded SubjectPublicKeyInfo blob  ------
+            MemoryStream mem = new MemoryStream(x509Key);
+            BinaryReader binaryReader = new BinaryReader(mem);    //wrap Memory Stream with BinaryReader for easy reading
+
+            try
+            {
+
+                var twoBytes = binaryReader.ReadUInt16();
+                if (twoBytes == 0x8130) //data read as little endian order (actual data order for Sequence is 30 81)
+                    binaryReader.ReadByte();    //advance 1 byte
+                else if (twoBytes == 0x8230)
+                    binaryReader.ReadInt16();   //advance 2 bytes
+                else
+                    return null;
+
+                var seq = binaryReader.ReadBytes(15);
+                if (!CompareBytearrays(seq, seqOid))    //make sure Sequence for OID is correct
+                    return null;
+
+                twoBytes = binaryReader.ReadUInt16();
+                if (twoBytes == 0x8103) //data read as little endian order (actual data order for Bit String is 03 81)
+                    binaryReader.ReadByte();    //advance 1 byte
+                else if (twoBytes == 0x8203)
+                    binaryReader.ReadInt16();   //advance 2 bytes
+                else
+                    return null;
+
+                var bt = binaryReader.ReadByte();
+                if (bt != 0x00)     //expect null byte next
+                    return null;
+
+                twoBytes = binaryReader.ReadUInt16();
+                if (twoBytes == 0x8130) //data read as little endian order (actual data order for Sequence is 30 81)
+                    binaryReader.ReadByte();    //advance 1 byte
+                else if (twoBytes == 0x8230)
+                    binaryReader.ReadInt16();   //advance 2 bytes
+                else
+                    return null;
+
+                twoBytes = binaryReader.ReadUInt16();
+                byte lowByte;
+                byte highByte = 0x00;
+
+                if (twoBytes == 0x8102) //data read as little endian order (actual data order for Integer is 02 81)
+                    lowByte = binaryReader.ReadByte();  // read next bytes which is bytes in modulus
+                else if (twoBytes == 0x8202)
+                {
+                    highByte = binaryReader.ReadByte(); //advance 2 bytes
+                    lowByte = binaryReader.ReadByte();
+                }
+                else
+                    return null;
+                byte[] modInt = { lowByte, highByte, 0x00, 0x00 };   //reverse byte order since asn.1 key uses big endian order
+                int modSize = BitConverter.ToInt32(modInt, 0);
+
+                byte firstByte = binaryReader.ReadByte();
+                binaryReader.BaseStream.Seek(-1, SeekOrigin.Current);
+
+                if (firstByte == 0x00)
+                {   //if first byte (highest order) of modulus is zero, don't include it
+                    binaryReader.ReadByte();    //skip this null byte
+                    modSize -= 1;   //reduce modulus buffer size by 1
+                }
+
+                byte[] modulus = binaryReader.ReadBytes(modSize);   //read the modulus bytes
+
+                if (binaryReader.ReadByte() != 0x02)            //expect an Integer for the exponent data
+                    return null;
+                int expBytes = binaryReader.ReadByte();        // should only need one byte for actual exponent data (for all useful values)
+                byte[] exponent = binaryReader.ReadBytes(expBytes);
+
+                // ------- create RSACryptoServiceProvider instance and initialize with public key -----
+                RSACryptoServiceProvider rsa = new RSACryptoServiceProvider();
+                RSAParameters rsaKeyInfo = new RSAParameters
+                {
+                    Modulus = modulus,
+                    Exponent = exponent
+                };
+                rsa.ImportParameters(rsaKeyInfo);
+                return rsa;
+            }
+            catch (Exception)
+            {
+                return null;
+            }
+
+            finally { binaryReader.Close(); }
+            
+        }
+    }
+}
+

package/Compliance/Standalone/Runtime/Internal/Tool.cs.meta

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

package/Compliance/Standalone/Runtime/Internal/Tracker/TapComplianceTracker.cs

@@ -0,0 +1,109 @@
+using System;
+using System.Collections.Generic;
+using Newtonsoft.Json;
+using TapSDK.Core.Standalone.Internal.Openlog;
+
+namespace TapSDK.Compliance.Standalone.Internal
+{
+    internal class TapComplianceTracker
+    {
+
+        private const string ACTION_INIT = "init";
+        private const string ACTION_START = "start";
+        private const string ACTION_SUCCESS = "success";
+        private const string ACTION_FAIL = "fail";
+        private const string ACTION_CANCEL = "cancel";
+
+        private static TapComplianceTracker instance;
+
+        private TapOpenlogStandalone openlog;
+
+        internal string currentVerifyType;
+
+        private TapComplianceTracker()
+        {
+            openlog = new TapOpenlogStandalone("TapCompliance", TapTapCompliance.Version);
+        }
+
+        public static TapComplianceTracker Instance
+        {
+            get
+            {
+                if (instance == null)
+                {
+                    instance = new TapComplianceTracker();
+                }
+                return instance;
+            }
+        }
+
+        internal void TrackInit()
+        {
+            ReportLog(ACTION_INIT);
+        }
+
+        internal void TrackStart(string funcNace, string seesionId)
+        {
+            currentVerifyType = "fast_verify";
+            Dictionary<string, string> parameters = new Dictionary<string, string>
+            {
+                { "func_name", funcNace },
+                { "session_id", seesionId },
+            };
+            ReportLog(ACTION_START, new Dictionary<string, string>()
+            {
+                { "args", JsonConvert.SerializeObject(parameters) }
+            });
+        }
+
+        internal void TrackSuccess(string funcNace, string seesionId)
+        {
+            Dictionary<string, string> parameters = new Dictionary<string, string>
+            {
+                { "func_name", funcNace },
+                { "session_id", seesionId },
+                { "identity_verify_type", currentVerifyType }
+            };
+            ReportLog(ACTION_SUCCESS, new Dictionary<string, string>()
+            {
+                { "args", JsonConvert.SerializeObject(parameters) }
+            });
+        }
+
+        internal void TrackCancel(string funcNace, string seesionId)
+        {
+            Dictionary<string, string> parameters = new Dictionary<string, string>
+            {
+                { "func_name", funcNace },
+                { "session_id", seesionId },
+                { "identity_verify_type", currentVerifyType }
+            };
+            ReportLog(ACTION_CANCEL, new Dictionary<string, string>()
+            {
+                { "args", JsonConvert.SerializeObject(parameters) }
+            });
+        }
+        
+        internal void TrackFailure(string funcNace, string seesionId, int errorCode = -1, string errorMessage = null)
+        {
+            Dictionary<string, string> parameters = new Dictionary<string, string>
+            {
+                { "func_name", funcNace },
+                { "session_id", seesionId },
+                { "error_code", errorCode.ToString() },
+                { "error_msg", errorMessage },
+                { "identity_verify_type", currentVerifyType }
+            };
+            ReportLog(ACTION_FAIL, new Dictionary<string, string>()
+            {
+                { "args", JsonConvert.SerializeObject(parameters) }
+            });
+        }
+
+
+        private void ReportLog(string action, Dictionary<string, string> parameters = null)
+        {
+            openlog.LogBusiness(action, parameters);
+        }
+    }
+}

package/Compliance/Standalone/Runtime/Internal/Tracker/TapComplianceTracker.cs.meta

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

package/Compliance/Standalone/Runtime/Internal/Tracker.meta

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