com.taptap.sdk.core 4.3.12 → 4.4.1

package/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/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/Runtime/Public/TapTapSDK.cs

@@ -11,7 +11,7 @@ using TapSDK.Core.Internal.Log;
 
 namespace TapSDK.Core {
     public class TapTapSDK {
-        public static readonly string Version = "4.3.12";
+        public static readonly string Version = "4.4.1";
         
         public static string SDKPlatform = "TapSDK-Unity";
 

package/Standalone/Runtime/Internal/Bean/TapGatekeeper.cs

@@ -0,0 +1,42 @@
+using System;
+using System.Collections.Generic;
+using Newtonsoft.Json;
+
+namespace TapSDK.Core.Standalone.Internal.Bean
+{
+    [Serializable]
+    internal class TapGatekeeper
+    {
+        [JsonProperty("switch")]
+        public TapGatekeeperSwitch Switch { get; set; } = new TapGatekeeperSwitch();
+
+        [JsonProperty("urls")]
+        public Dictionary<string, Url> Urls { get; set; }
+
+        [JsonProperty("taptap_app_id")]
+        public int? TapTapAppId { get; set; }
+    }
+
+    [Serializable]
+    internal class TapGatekeeperSwitch
+    {
+        [JsonProperty("auto_event")]
+        public bool AutoEvent { get; set; } = true;
+
+        [JsonProperty("heartbeat")]
+        public bool Heartbeat { get; set; } = true;
+    }
+
+    [Serializable]
+    internal class Url
+    {
+        [JsonProperty("webview")]
+        public string WebView { get; set; }
+
+        [JsonProperty("browser")]
+        public string Browser { get; set; }
+
+        [JsonProperty("uri")]
+        public string TapUri { get; set; }
+    }
+}

package/Standalone/Runtime/Internal/{Http/TimeUtil.cs.meta → Bean/TapGatekeeper.cs.meta}

@@ -1,5 +1,5 @@
 fileFormatVersion: 2
-guid: aeed0ff62a8bb44d985afebaacb02087
+guid: ba3269645153d4a47b23dd75efdeab5d
 MonoImporter:
   externalObjects: {}
   serializedVersion: 2

package/Standalone/Runtime/Internal/Bean.meta

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

package/Standalone/Runtime/Internal/Constants.cs

@@ -8,8 +8,8 @@ namespace TapSDK.Core.Standalone.Internal {
         public static readonly string PROPERTY_ADD_TYPE = "add";
 
 
-        public readonly static string SERVER_URL_BJ = "https://e.tapdb.net/v2";
-        public readonly static string SERVER_URL_SG = "https://e.tapdb.ap-sg.tapapis.com/v2";
+        public readonly static string SERVER_URL_CN = "https://e.tapdb.net";
+        public readonly static string SERVER_URL_IO = "https://e.tapdb.ap-sg.tapapis.com";
         public readonly static string DEVICE_LOGIN = "device_login";
         public readonly static string USER_LOGIN = "user_login";
 

package/Standalone/Runtime/Internal/EventSender.cs

@@ -7,23 +7,35 @@ using System.Linq;
 using System.Text;
 using System.Threading;
 using System.Threading.Tasks;
+using TapSDK.Core.Internal.Log;
+using TapSDK.Core.Standalone.Internal.Http;
 using UnityEngine;
 using UnityEngine.Networking;
 
-namespace TapSDK.Core.Standalone.Internal {
+namespace TapSDK.Core.Standalone.Internal
+{
     public class EventSender : MonoBehaviour
     {
         private const string EventFilePath = "events.json";
+
+        private readonly TapLog log = new TapLog("TapEvent");
         private string persistentDataPath = Application.persistentDataPath;
-        
+
         private Queue<Dictionary<string, object>> eventQueue = new Queue<Dictionary<string, object>>();
-        private HttpClient httpClient;
+        private TapHttp tapHttp = TapHttp
+            .NewBuilder("TapSDKCore", TapTapSDK.Version)
+            .Sign(TapHttpSign.CreateNoneSign())
+            .Parser(TapHttpParser.CreateEventParser())
+            .Build();
+
         private const int MaxEvents = 50;
         private const int MaxBatchSize = 200;
         private const float SendInterval = 15f;
         private Timer timer;
         private DateTime lastSendTime;
 
+        private string domain = Constants.SERVER_URL_CN;
+
         private int QueueCount => eventQueue.Count;
 
         public EventSender()
@@ -39,12 +51,13 @@ namespace TapSDK.Core.Standalone.Internal {
             };
 
             var coreOptions = TapCoreStandalone.coreOptions;
-            if(coreOptions.region == TapTapRegionType.CN) {
-                HttpClientConfig config = new HttpClientConfig(Constants.SERVER_URL_BJ, header);
-                httpClient = new HttpClient(config);
-            } else {
-                HttpClientConfig config = new HttpClientConfig(Constants.SERVER_URL_SG, header);
-                httpClient = new HttpClient(config);
+            if (coreOptions.region == TapTapRegionType.CN)
+            {
+                domain = Constants.SERVER_URL_CN;
+            }
+            else
+            {
+                domain = Constants.SERVER_URL_IO;
             }
 
             // 加载未发送的事件
@@ -60,7 +73,7 @@ namespace TapSDK.Core.Standalone.Internal {
                 return;
             }
 
-            var  eventsToSend = new List<Dictionary<string, object>>();
+            var eventsToSend = new List<Dictionary<string, object>>();
             for (int i = 0; i < MaxBatchSize && eventQueue.Count > 0; i++)
             {
                 eventsToSend.Add(eventQueue.Dequeue());
@@ -70,21 +83,20 @@ namespace TapSDK.Core.Standalone.Internal {
                 { "data", eventsToSend }
             };
 
-            var resonse = await httpClient.Post("batch", body);
-            
-            // 判断是否请求成功
-            if (resonse == null)
+            var resonse = await tapHttp.PostJsonAsync<Boolean>(path: $"{domain}/v2/batch", json: body);
+            if (resonse.IsSuccess)
+            {
+                log.Log("Events sent successfully");
+            }
+            else
             {
+                log.Warning("Failed to send events");
                 // 将事件重新添加到队列
                 foreach (var eventParams in eventsToSend)
                 {
                     eventQueue.Enqueue(eventParams);
                 }
             }
-            else
-            {
-                Debug.Log("Events sent successfully");
-            }
             onSendComplete?.Invoke();
             SaveEvents();
         }
@@ -129,7 +141,6 @@ namespace TapSDK.Core.Standalone.Internal {
                 {
                     return;
                 }
-                
                 var savedEvents = ConvertToListOfDictionaries(Json.Deserialize(jsonData));
                 if (savedEvents == null)
                 {

package/Standalone/Runtime/Internal/Http/TapHttp.cs

@@ -0,0 +1,377 @@
+using System.Net.Http;
+
+namespace TapSDK.Core.Standalone.Internal.Http
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Net.Http.Headers;
+    using System.Threading.Tasks;
+    using System.Web;
+    using Newtonsoft.Json;
+    using TapSDK.Core.Internal.Log;
+
+    public class TapHttp
+    {
+
+        private static readonly string TAG = "Http";
+
+        private static readonly int MAX_GET_RETRY_COUNT = 3;
+
+        internal static readonly long CONNECT_TIMEOUT_MILLIS = 10 * 1000L;
+        internal static readonly long READ_TIMEOUT_MILLIS = 5 * 1000L;
+        internal static readonly long WRITE_TIMEOUT_MILLIS = 5 * 1000L;
+
+        public static readonly string HOST_CN = "https://tapsdk.tapapis.cn";
+        public static readonly string HOST_IO = "https://tapsdk.tapapis.com";
+
+        private static HttpClient client = new HttpClient();
+
+        private readonly TapHttpConfig httpConfig;
+
+        private readonly TapLog log = new TapLog(TAG);
+
+        private TapHttp() { }
+
+        internal TapHttp(TapHttpConfig httpConfig)
+        {
+            this.httpConfig = httpConfig;
+        }
+
+        public static TapHttpBuilder NewBuilder(string moduleName, string moduleVersion)
+        {
+            return new TapHttpBuilder(moduleName, moduleVersion);
+        }
+
+        public async void PostJson<T>(
+            string url,
+            Dictionary<string, string> headers = null,
+            Dictionary<string, string> queryParams = null,
+            Dictionary<string, object> json = null,
+            bool enableAuthorization = false,
+            ITapHttpRetryStrategy retryStrategy = null,
+            Action<T> onSuccess = null,
+            Action<AbsTapHttpException> onFailure = null)
+        {
+            TapHttpResult<T> tapHttpResult = await PostJsonAsync<T>(
+                path: url,
+                headers: headers,
+                queryParams: queryParams,
+                json: json,
+                enableAuthorization: enableAuthorization,
+                retryStrategy: retryStrategy
+            );
+            if (tapHttpResult.IsSuccess)
+            {
+                onSuccess?.Invoke(tapHttpResult.Data);
+            }
+            else
+            {
+                onFailure?.Invoke(tapHttpResult.HttpException);
+            }
+        }
+
+        public async void PostForm<T>(
+            string url,
+            Dictionary<string, string> headers = null,
+            Dictionary<string, string> queryParams = null,
+            Dictionary<string, string> form = null,
+            bool enableAuthorization = false,
+            ITapHttpRetryStrategy retryStrategy = null,
+            Action<T> onSuccess = null,
+            Action<AbsTapHttpException> onFailure = null)
+        {
+            TapHttpResult<T> tapHttpResult = await PostFormAsync<T>(
+                url: url,
+                headers: headers,
+                queryParams: queryParams,
+                form: form,
+                enableAuthorization: enableAuthorization,
+                retryStrategy: retryStrategy
+            );
+            if (tapHttpResult.IsSuccess)
+            {
+                onSuccess?.Invoke(tapHttpResult.Data);
+            }
+            else
+            {
+                onFailure?.Invoke(tapHttpResult.HttpException);
+            }
+        }
+
+        public async void Get<T>(
+            string url,
+            Dictionary<string, string> headers = null,
+            Dictionary<string, string> queryParams = null,
+            bool enableAuthorization = false,
+            ITapHttpRetryStrategy retryStrategy = null,
+            Action<T> onSuccess = null,
+            Action<Exception> onFailure = null
+        )
+        {
+            TapHttpResult<T> tapHttpResult = await GetAsync<T>(
+                url: url,
+                headers: headers,
+                queryParams: queryParams,
+                enableAuthorization: enableAuthorization,
+                retryStrategy: retryStrategy
+           );
+            if (tapHttpResult.IsSuccess)
+            {
+                onSuccess?.Invoke(tapHttpResult.Data);
+            }
+            else
+            {
+                onFailure?.Invoke(tapHttpResult.HttpException);
+            }
+        }
+
+        public async Task<TapHttpResult<T>> GetAsync<T>(
+            string url,
+            Dictionary<string, string> headers = null,
+            Dictionary<string, string> queryParams = null,
+            bool enableAuthorization = false,
+            ITapHttpRetryStrategy retryStrategy = null
+        )
+        {
+            if (retryStrategy == null)
+            {
+                retryStrategy = TapHttpRetryStrategy.CreateDefault(TapHttpBackoffStrategy.CreateFixed(MAX_GET_RETRY_COUNT));
+            }
+            return await Request<T>(
+                url: url,
+                method: HttpMethod.Get,
+                enableAuthorization: enableAuthorization,
+                retryStrategy: retryStrategy,
+                headers: headers,
+                queryParams: queryParams
+            );
+        }
+
+        public async Task<TapHttpResult<T>> PostJsonAsync<T>(
+            string path,
+            Dictionary<string, string> headers = null,
+            Dictionary<string, string> queryParams = null,
+            object json = null,
+            bool enableAuthorization = false,
+            ITapHttpRetryStrategy retryStrategy = null
+        )
+        {
+            if (retryStrategy == null)
+            {
+                retryStrategy = TapHttpRetryStrategy.CreateDefault(TapHttpBackoffStrategy.CreateNone());
+            }
+            string jsonStr = null;
+            if (json != null)
+            {
+                jsonStr = await Task.Run(() => JsonConvert.SerializeObject(json));
+            }
+            return await Request<T>(
+                url: path,
+                method: HttpMethod.Post,
+                enableAuthorization: enableAuthorization,
+                retryStrategy: retryStrategy,
+                headers: headers,
+                queryParams: queryParams,
+                body: jsonStr
+            );
+        }
+
+        public async Task<TapHttpResult<T>> PostFormAsync<T>(
+            string url,
+            Dictionary<string, string> headers = null,
+            Dictionary<string, string> queryParams = null,
+            Dictionary<string, string> form = null,
+            bool enableAuthorization = false,
+            ITapHttpRetryStrategy retryStrategy = null
+        )
+        {
+            if (retryStrategy == null)
+            {
+                retryStrategy = TapHttpRetryStrategy.CreateDefault(TapHttpBackoffStrategy.CreateNone());
+            }
+            return await Request<T>(
+                url: url,
+                method: HttpMethod.Post,
+                enableAuthorization: enableAuthorization,
+                retryStrategy: retryStrategy,
+                headers: headers,
+                queryParams: queryParams,
+                body: form
+            );
+        }
+
+        private async Task<TapHttpResult<T>> Request<T>(
+            string url,
+            HttpMethod method,
+            bool enableAuthorization,
+            ITapHttpRetryStrategy retryStrategy,
+            Dictionary<string, string> headers = null,
+            Dictionary<string, string> queryParams = null,
+            object body = null
+        )
+        {
+            TapHttpResult<T> tapHttpResult;
+            long nextRetryMillis;
+            do
+            {
+                tapHttpResult = await RequestInner<T>(url, method, enableAuthorization, headers, queryParams, body);
+
+                if (tapHttpResult.IsSuccess)
+                {
+                    return tapHttpResult;
+                }
+
+                nextRetryMillis = retryStrategy.NextRetryMillis(tapHttpResult.HttpException);
+                if (nextRetryMillis > 0)
+                {
+                    log.Log($"Request failed, retry after {nextRetryMillis} ms");
+                    await Task.Delay(TimeSpan.FromMilliseconds(nextRetryMillis));
+                }
+
+            } while (nextRetryMillis >= 0L);
+
+            return tapHttpResult;
+        }
+
+        private async Task<TapHttpResult<T>> RequestInner<T>(
+            string path,
+            HttpMethod method,
+            bool enableAuthorization,
+            Dictionary<string, string> headers = null,
+            Dictionary<string, string> queryParams = null,
+            object body = null
+        )
+        {
+            // 处理查询参数 
+            Dictionary<string, string> allQueryParams = new Dictionary<string, string>();
+            if (queryParams != null)
+            {
+                foreach (var param in queryParams)
+                {
+                    allQueryParams[param.Key] = param.Value;
+                }
+            }
+            var fixedQueryParams = httpConfig.Sign.GetFixedQueryParams();
+            if (fixedQueryParams != null)
+            {
+                foreach (var param in fixedQueryParams)
+                {
+                    allQueryParams[param.Key] = param.Value;
+                }
+            }
+            string host = HOST_CN;
+            if (httpConfig.Domain != null)
+            {
+                host = httpConfig.Domain;
+            }
+            else
+            {
+                if (TapCoreStandalone.coreOptions.region == TapTapRegionType.CN)
+                {
+                    host = HOST_CN;
+                }
+                else if (TapCoreStandalone.coreOptions.region == TapTapRegionType.Overseas)
+                {
+                    host = HOST_IO;
+                }
+            }
+            // 拼接查询参数
+            UriBuilder uriBuilder;
+            if (path.StartsWith("http://") || path.StartsWith("https://"))
+            {
+                uriBuilder = new UriBuilder(path);
+            }
+            else
+            {
+                if (!path.StartsWith("/"))
+                {
+                    path = "/" + path;
+                }
+                uriBuilder = new UriBuilder(uri: $"{host}{path}");
+            }
+            if (allQueryParams.Count > 0)
+            {
+                var query = HttpUtility.ParseQueryString(uriBuilder.Query);
+                foreach (var param in allQueryParams)
+                {
+                    query[param.Key] = param.Value.ToString();
+                }
+                uriBuilder.Query = query.ToString();
+            }
+            var requestUri = uriBuilder.Uri;
+
+            // 创建 HttpRequestMessage
+            var request = new HttpRequestMessage
+            {
+                Method = method,
+                RequestUri = requestUri
+            };
+
+            // 处理请求头
+            Dictionary<string, string> allHeaders = new Dictionary<string, string>();
+            if (headers != null)
+            {
+                foreach (var header in headers)
+                {
+                    allHeaders[header.Key] = header.Value;
+                }
+            }
+            Dictionary<string, string> fixedHeaders = httpConfig.Sign.GetFixedHeaders(requestUri.ToString(), method, httpConfig.ModuleName, httpConfig.ModuleVersion, enableAuthorization);
+            if (fixedHeaders != null)
+            {
+                foreach (var header in fixedHeaders)
+                {
+                    allHeaders[header.Key] = header.Value;
+                }
+            }
+            // 添加请求头
+            if (allHeaders != null)
+            {
+                foreach (var header in allHeaders)
+                {
+                    request.Headers.TryAddWithoutValidation(header.Key, header.Value.ToString());
+                }
+            }
+
+            // 根据请求类型设置请求体
+            if (method == HttpMethod.Post || method == HttpMethod.Put)
+            {
+                if (body != null)
+                {
+                    if (body is string jsonBody) // 处理 JSON 数据
+                    {
+                        StringContent requestContent = new StringContent(jsonBody);
+                        requestContent.Headers.ContentType = new MediaTypeHeaderValue("application/json");
+                        request.Content = requestContent;
+                    }
+                    else if (body is Dictionary<string, string> formData) // 处理 Form 数据
+                    {
+                        request.Content = new FormUrlEncodedContent(formData);
+                    }
+                }
+            }
+            // 签算
+            httpConfig.Sign.Sign(request);
+            try
+            {
+                if (TapTapSDK.taptapSdkOptions.enableLog)
+                {
+                    TapHttpUtils.PrintRequest(client, request, request.Content.ReadAsStringAsync().Result);
+                }
+                // 发送请求
+                HttpResponseMessage response = await client.SendAsync(request);
+                if (TapTapSDK.taptapSdkOptions.enableLog)
+                {
+                    TapHttpUtils.PrintResponse(response, response.Content.ReadAsStringAsync().Result);
+                }
+                // 解析响应
+                return await httpConfig.Parser.Parse<T>(response);
+            }
+            catch (Exception ex)
+            {
+                // 捕获并处理请求异常
+                return TapHttpResult<T>.UnknownFailure(new TapHttpUnknownException(ex));
+            }
+        }
+    }
+}

package/Standalone/Runtime/Internal/Http/{HttpClient.cs.meta → TapHttp.cs.meta}

@@ -1,5 +1,5 @@
 fileFormatVersion: 2
-guid: 5b77367f8c15c41eeb04d78ad5bdcb72
+guid: d2dd246dfad224e9aae739da577b7087
 MonoImporter:
   externalObjects: {}
   serializedVersion: 2