1369 lines
		
	
	
		
			54 KiB
		
	
	
	
		
			C#
		
	
			
		
		
	
	
			1369 lines
		
	
	
		
			54 KiB
		
	
	
	
		
			C#
		
	
/*
 | 
						|
 * 
 | 
						|
    Copyright 2019, ThinkingData, Inc
 | 
						|
    Licensed under the Apache License, Version 2.0 (the "License");
 | 
						|
    you may not use this file except in compliance with the License.
 | 
						|
    You may obtain a copy of the License at
 | 
						|
 | 
						|
        http://www.apache.org/licenses/LICENSE-2.0
 | 
						|
 | 
						|
    Unless required by applicable law or agreed to in writing, software
 | 
						|
    distributed under the License is distributed on an "AS IS" BASIS,
 | 
						|
    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 | 
						|
    See the License for the specific language governing permissions and
 | 
						|
    limitations under the License.
 | 
						|
    SDK VERSION:2.6.1
 | 
						|
 */
 | 
						|
#if !(UNITY_5_4_OR_NEWER)
 | 
						|
#define DISABLE_TA
 | 
						|
#warning "Your Unity version is not supported by us - ThinkingAnalyticsSDK disabled"
 | 
						|
#endif
 | 
						|
 | 
						|
using System;
 | 
						|
using System.Collections.Generic;
 | 
						|
using ThinkingAnalytics.Utils;
 | 
						|
using ThinkingAnalytics.Wrapper;
 | 
						|
using UnityEngine;
 | 
						|
using ThinkingAnalytics.TAException;
 | 
						|
using UnityEngine.SceneManagement;
 | 
						|
 | 
						|
namespace ThinkingAnalytics
 | 
						|
{
 | 
						|
    [DisallowMultipleComponent]
 | 
						|
    public class ThinkingAnalyticsAPI : MonoBehaviour
 | 
						|
    {
 | 
						|
        #region settings
 | 
						|
        [System.Serializable]
 | 
						|
        public struct Token
 | 
						|
        {
 | 
						|
            public string appid;
 | 
						|
            public string serverUrl;
 | 
						|
            public TAMode mode;
 | 
						|
            public TATimeZone timeZone;
 | 
						|
            public string timeZoneId;
 | 
						|
            public bool enableEncrypt; // enable data encryption, default is false (iOS/Android only)
 | 
						|
            public int encryptVersion; // secret key version (iOS/Android only)
 | 
						|
            public string encryptPublicKey; // public secret key (iOS/Android only)
 | 
						|
            public SSLPinningMode pinningMode; // SSL Pinning mode, default is NONE (iOS/Android only)
 | 
						|
            public bool allowInvalidCertificates; // allow invalid certificates, default is false (iOS/Android only)
 | 
						|
            public bool validatesDomainName; // enable to verify domain name, default is true (iOS/Android only)
 | 
						|
            private string instanceName; // instances name
 | 
						|
 | 
						|
            public Token(string appId, string serverUrl, TAMode mode = TAMode.NORMAL, TATimeZone timeZone = TATimeZone.Local, string timeZoneId = null, string instanceName = null)
 | 
						|
            {
 | 
						|
                this.appid = appId.Replace(" ", "");
 | 
						|
                this.serverUrl = serverUrl;
 | 
						|
                this.mode = mode;
 | 
						|
                this.timeZone = timeZone;
 | 
						|
                this.timeZoneId = timeZoneId;
 | 
						|
                this.enableEncrypt = false;
 | 
						|
                this.encryptVersion = 0;
 | 
						|
                this.encryptPublicKey = null;
 | 
						|
                this.pinningMode = SSLPinningMode.NONE;
 | 
						|
                this.allowInvalidCertificates = false;
 | 
						|
                this.validatesDomainName = true;
 | 
						|
                if (!string.IsNullOrEmpty(instanceName))
 | 
						|
                {
 | 
						|
                    instanceName = instanceName.Replace(" ", "");
 | 
						|
                }
 | 
						|
                this.instanceName = instanceName;
 | 
						|
            }
 | 
						|
 | 
						|
            public string GetInstanceName()
 | 
						|
            {
 | 
						|
                return this.instanceName;
 | 
						|
            }
 | 
						|
 | 
						|
            public string getTimeZoneId()
 | 
						|
            {
 | 
						|
#if UNITY_STANDALONE_WIN
 | 
						|
                switch (timeZone)
 | 
						|
                {
 | 
						|
                    case TATimeZone.UTC:
 | 
						|
                        return "UTC";
 | 
						|
                    case TATimeZone.Asia_Shanghai:
 | 
						|
                        return "China Standard Time";
 | 
						|
                    case TATimeZone.Asia_Tokyo:
 | 
						|
                        return "Tokyo Standard Time";
 | 
						|
                    case TATimeZone.America_Los_Angeles:
 | 
						|
                        return "Pacific Standard Time";
 | 
						|
                    case TATimeZone.America_New_York:
 | 
						|
                        return "Eastern Standard Time";
 | 
						|
                    case TATimeZone.Other:
 | 
						|
                        return timeZoneId;
 | 
						|
                    default:
 | 
						|
                        break;
 | 
						|
                }
 | 
						|
#else
 | 
						|
                switch (timeZone)
 | 
						|
                {
 | 
						|
                    case TATimeZone.UTC:
 | 
						|
                        return "UTC";
 | 
						|
                    case TATimeZone.Asia_Shanghai:
 | 
						|
                        return "Asia/Shanghai";
 | 
						|
                    case TATimeZone.Asia_Tokyo:
 | 
						|
                        return "Asia/Tokyo";
 | 
						|
                    case TATimeZone.America_Los_Angeles:
 | 
						|
                        return "America/Los_Angeles";
 | 
						|
                    case TATimeZone.America_New_York:
 | 
						|
                        return "America/New_York";
 | 
						|
                    case TATimeZone.Other:
 | 
						|
                        return timeZoneId;
 | 
						|
                    default:
 | 
						|
                        break;
 | 
						|
                }
 | 
						|
#endif
 | 
						|
                return null;
 | 
						|
            }
 | 
						|
        }
 | 
						|
 | 
						|
        public enum TATimeZone
 | 
						|
        {
 | 
						|
            Local,
 | 
						|
            UTC,
 | 
						|
            Asia_Shanghai,
 | 
						|
            Asia_Tokyo,
 | 
						|
            America_Los_Angeles,
 | 
						|
            America_New_York,
 | 
						|
            Other = 100
 | 
						|
        }
 | 
						|
 | 
						|
        public enum TAMode
 | 
						|
        {
 | 
						|
            NORMAL = 0,
 | 
						|
            DEBUG = 1,
 | 
						|
            DEBUG_ONLY = 2
 | 
						|
        }
 | 
						|
 | 
						|
        public enum NetworkType
 | 
						|
        {
 | 
						|
            DEFAULT = 1,
 | 
						|
            WIFI = 2,
 | 
						|
            ALL = 3
 | 
						|
        }
 | 
						|
 | 
						|
        [Header("Configuration")]
 | 
						|
        [Tooltip("Enable Start SDK Manually")]
 | 
						|
        public bool startManually = true;
 | 
						|
 | 
						|
        [Tooltip("Enable Log")]
 | 
						|
        public bool enableLog = true;
 | 
						|
        [Tooltip("Sets the Network Type")]
 | 
						|
        public NetworkType networkType = NetworkType.DEFAULT;
 | 
						|
 | 
						|
        [Header("Project")]
 | 
						|
        [Tooltip("Project Setting, APP ID is given when the project is created")]
 | 
						|
        [HideInInspector]
 | 
						|
        public Token[] tokens = new Token[1];
 | 
						|
 | 
						|
#endregion
 | 
						|
 | 
						|
        /// <summary>
 | 
						|
        /// Whether to enable logs
 | 
						|
        /// </summary>
 | 
						|
        /// <param name="enable">enable logs</param>
 | 
						|
        public static void EnableLog(bool enable, string appId = "")
 | 
						|
        {
 | 
						|
            if (sThinkingAnalyticsAPI != null)
 | 
						|
            {
 | 
						|
                sThinkingAnalyticsAPI.enableLog = enable;
 | 
						|
                TD_Log.EnableLog(enable);
 | 
						|
                ThinkingAnalyticsWrapper.EnableLog(enable);
 | 
						|
            }
 | 
						|
        }
 | 
						|
        /// <summary>
 | 
						|
        /// Set custom distinct ID, to replace the distinct ID generated by the system 
 | 
						|
        /// </summary>
 | 
						|
        /// <param name="distinctId">distinct ID</param>
 | 
						|
        /// <param name="appId">project ID (optional)</param>
 | 
						|
        public static void Identify(string distinctId, string appId = "")
 | 
						|
        {
 | 
						|
            if (tracking_enabled)
 | 
						|
            {
 | 
						|
                ThinkingAnalyticsWrapper.Identify(distinctId, appId);
 | 
						|
            }
 | 
						|
            else
 | 
						|
            {
 | 
						|
                System.Reflection.MethodBase method = System.Reflection.MethodBase.GetCurrentMethod();
 | 
						|
                object[] parameters = new object[] { distinctId, appId };
 | 
						|
                eventCaches.Add(new Dictionary<string, object>() {
 | 
						|
                    { "method", method},
 | 
						|
                    { "parameters", parameters}
 | 
						|
                });
 | 
						|
            }
 | 
						|
        }
 | 
						|
 | 
						|
        /// <summary>
 | 
						|
        /// Returns the current distinct ID
 | 
						|
        /// </summary>
 | 
						|
        /// <returns>distinct ID</returns>
 | 
						|
        /// <param name="appId">project ID (optional)</param>
 | 
						|
        public static string GetDistinctId(string appId = "")
 | 
						|
        {
 | 
						|
            if (tracking_enabled)
 | 
						|
            {
 | 
						|
                return ThinkingAnalyticsWrapper.GetDistinctId(appId);
 | 
						|
            }
 | 
						|
            return null;
 | 
						|
        }
 | 
						|
 | 
						|
        /// <summary>
 | 
						|
        /// Set account ID. This method does not upload Login events
 | 
						|
        /// </summary>
 | 
						|
        /// <param name="account">account ID</param>
 | 
						|
        /// <param name="appId">project ID (optional)</param>
 | 
						|
        public static void Login(string account, string appId = "")
 | 
						|
        {
 | 
						|
            if (tracking_enabled)
 | 
						|
            {
 | 
						|
                ThinkingAnalyticsWrapper.Login(account, appId);
 | 
						|
            }
 | 
						|
            else
 | 
						|
            {
 | 
						|
                System.Reflection.MethodBase method = System.Reflection.MethodBase.GetCurrentMethod();
 | 
						|
                object[] parameters = new object[] { account, appId };
 | 
						|
                eventCaches.Add(new Dictionary<string, object>() {
 | 
						|
                    { "method", method},
 | 
						|
                    { "parameters", parameters}
 | 
						|
                });
 | 
						|
            }
 | 
						|
        }
 | 
						|
 | 
						|
        /// <summary>
 | 
						|
        /// Clear account ID. This method does not upload Logout events
 | 
						|
        /// </summary>
 | 
						|
        /// <param name="appId">project ID (optional) </param>
 | 
						|
        public static void Logout(string appId = "")
 | 
						|
        {
 | 
						|
            if (tracking_enabled)
 | 
						|
            {
 | 
						|
                ThinkingAnalyticsWrapper.Logout(appId);
 | 
						|
            }
 | 
						|
            else
 | 
						|
            {
 | 
						|
                System.Reflection.MethodBase method = System.Reflection.MethodBase.GetCurrentMethod();
 | 
						|
                object[] parameters = new object[] { appId };
 | 
						|
                eventCaches.Add(new Dictionary<string, object>() {
 | 
						|
                    { "method", method},
 | 
						|
                    { "parameters", parameters}
 | 
						|
                });
 | 
						|
            }
 | 
						|
        }
 | 
						|
 | 
						|
        /// <summary>
 | 
						|
        /// Enable auto-tracking
 | 
						|
        /// </summary>
 | 
						|
        /// <param name="events">auto-tracking events</param>
 | 
						|
        /// <param name="properties">properties for auto-tracking events (optional)</param>
 | 
						|
        /// <param name="appId">project ID (optional)</param>
 | 
						|
        public static void EnableAutoTrack(AUTO_TRACK_EVENTS events, Dictionary<string, object> properties = null, string appId = "")
 | 
						|
        {
 | 
						|
            if (tracking_enabled)
 | 
						|
            {
 | 
						|
                if (properties == null)
 | 
						|
                {
 | 
						|
                    properties = new Dictionary<string, object>();
 | 
						|
                }
 | 
						|
                ThinkingAnalyticsWrapper.EnableAutoTrack(events, properties, appId);
 | 
						|
                if ((events & AUTO_TRACK_EVENTS.APP_CRASH) != 0 && !TD_PublicConfig.DisableCSharpException)
 | 
						|
                {
 | 
						|
                    ThinkingSDKExceptionHandler.RegisterTAExceptionHandler(properties);
 | 
						|
                }
 | 
						|
                if ((events & AUTO_TRACK_EVENTS.APP_SCENE_LOAD) != 0)
 | 
						|
                {
 | 
						|
                    SceneManager.sceneLoaded -= ThinkingAnalyticsAPI.OnSceneLoaded;
 | 
						|
                    SceneManager.sceneLoaded += ThinkingAnalyticsAPI.OnSceneLoaded;
 | 
						|
                }
 | 
						|
                if ((events & AUTO_TRACK_EVENTS.APP_SCENE_UNLOAD) != 0)
 | 
						|
                {
 | 
						|
                    SceneManager.sceneUnloaded -= ThinkingAnalyticsAPI.OnSceneUnloaded;
 | 
						|
                    SceneManager.sceneUnloaded += ThinkingAnalyticsAPI.OnSceneUnloaded;
 | 
						|
                }
 | 
						|
            }
 | 
						|
            else
 | 
						|
            {
 | 
						|
                System.Reflection.MethodBase method = System.Reflection.MethodBase.GetCurrentMethod();
 | 
						|
                object[] parameters = new object[] { events, properties, appId };
 | 
						|
                eventCaches.Add(new Dictionary<string, object>() {
 | 
						|
                    { "method", method},
 | 
						|
                    { "parameters", parameters}
 | 
						|
                });
 | 
						|
            }
 | 
						|
        }
 | 
						|
 | 
						|
        /// <summary>
 | 
						|
        /// Enable auto-tracking
 | 
						|
        /// </summary>
 | 
						|
        /// <param name="events">auto-tracking events</param>
 | 
						|
        /// <param name="eventCallback">callback for auto-tracking events (optional)</param>
 | 
						|
        /// <param name="appId">project ID (optional)</param>
 | 
						|
        public static void EnableAutoTrack(AUTO_TRACK_EVENTS events, IAutoTrackEventCallback eventCallback, string appId = "")
 | 
						|
        {
 | 
						|
            if (tracking_enabled)
 | 
						|
            {
 | 
						|
                ThinkingAnalyticsWrapper.EnableAutoTrack(events, eventCallback, appId);
 | 
						|
                if ((events & AUTO_TRACK_EVENTS.APP_CRASH) != 0 && !TD_PublicConfig.DisableCSharpException)
 | 
						|
                {
 | 
						|
                    ThinkingSDKExceptionHandler.RegisterTAExceptionHandler(eventCallback);
 | 
						|
                }
 | 
						|
                if ((events & AUTO_TRACK_EVENTS.APP_SCENE_LOAD) != 0)
 | 
						|
                {
 | 
						|
                    SceneManager.sceneLoaded -= ThinkingAnalyticsAPI.OnSceneLoaded;
 | 
						|
                    SceneManager.sceneLoaded += ThinkingAnalyticsAPI.OnSceneLoaded;
 | 
						|
                }
 | 
						|
                if ((events & AUTO_TRACK_EVENTS.APP_SCENE_UNLOAD) != 0)
 | 
						|
                {
 | 
						|
                    SceneManager.sceneUnloaded -= ThinkingAnalyticsAPI.OnSceneUnloaded;
 | 
						|
                    SceneManager.sceneUnloaded += ThinkingAnalyticsAPI.OnSceneUnloaded;
 | 
						|
                }
 | 
						|
            }
 | 
						|
            else
 | 
						|
            {
 | 
						|
                System.Reflection.MethodBase method = System.Reflection.MethodBase.GetCurrentMethod();
 | 
						|
                object[] parameters = new object[] { events, eventCallback, appId };
 | 
						|
                eventCaches.Add(new Dictionary<string, object>() {
 | 
						|
                    { "method", method},
 | 
						|
                    { "parameters", parameters}
 | 
						|
                });
 | 
						|
            }
 | 
						|
 | 
						|
        }
 | 
						|
 | 
						|
        /// <summary>
 | 
						|
        /// Set properties for auto-tracking events
 | 
						|
        /// </summary>
 | 
						|
        /// <param name="events">auto-tracking events</param>
 | 
						|
        /// <param name="properties">properties for auto-tracking events</param>
 | 
						|
        /// <param name="appId">project ID (optional)</param>
 | 
						|
        public static void SetAutoTrackProperties(AUTO_TRACK_EVENTS events, Dictionary<string, object> properties, string appId = "")
 | 
						|
        {
 | 
						|
            if (tracking_enabled)
 | 
						|
            {
 | 
						|
                ThinkingAnalyticsWrapper.SetAutoTrackProperties(events, properties, appId);
 | 
						|
                if ((events & AUTO_TRACK_EVENTS.APP_CRASH) != 0 && !TD_PublicConfig.DisableCSharpException)
 | 
						|
                {
 | 
						|
                    ThinkingSDKExceptionHandler.SetAutoTrackProperties(properties);
 | 
						|
                }
 | 
						|
            }
 | 
						|
            else
 | 
						|
            {
 | 
						|
                System.Reflection.MethodBase method = System.Reflection.MethodBase.GetCurrentMethod();
 | 
						|
                object[] parameters = new object[] { events, properties, appId };
 | 
						|
                eventCaches.Add(new Dictionary<string, object>() {
 | 
						|
                    { "method", method},
 | 
						|
                    { "parameters", parameters}
 | 
						|
                });
 | 
						|
            }
 | 
						|
        }
 | 
						|
 | 
						|
        /// <summary>
 | 
						|
        /// Track a Event
 | 
						|
        /// </summary>
 | 
						|
        /// <param name="eventName">event name</param>
 | 
						|
        /// <param name="appId">project ID (optional)</param>
 | 
						|
        public static void Track(string eventName, string appId = "")
 | 
						|
        {
 | 
						|
            Track(eventName, null, appId);
 | 
						|
        }
 | 
						|
 | 
						|
        /// <summary>
 | 
						|
        /// Track a Event
 | 
						|
        /// </summary>
 | 
						|
        /// <param name="eventName">the event name</param>
 | 
						|
        /// <param name="properties">properties for the event</param>
 | 
						|
        /// <param name="appId">project ID (optional)</param>
 | 
						|
        public static void Track(string eventName, Dictionary<string, object> properties, string appId = "")
 | 
						|
        {
 | 
						|
            if (tracking_enabled)
 | 
						|
            {
 | 
						|
                ThinkingAnalyticsWrapper.Track(eventName, properties, appId);
 | 
						|
            }
 | 
						|
            else
 | 
						|
            {
 | 
						|
                System.Reflection.MethodBase method = System.Reflection.MethodBase.GetCurrentMethod();
 | 
						|
                object[] parameters = new object[] { eventName, properties, appId };
 | 
						|
                eventCaches.Add(new Dictionary<string, object>() {
 | 
						|
                    { "method", method},
 | 
						|
                    { "parameters", parameters}
 | 
						|
                });
 | 
						|
            }
 | 
						|
        }
 | 
						|
 | 
						|
        /// <summary>
 | 
						|
        /// Track a Event
 | 
						|
        /// </summary>
 | 
						|
        /// <param name="eventName">the event name</param>
 | 
						|
        /// <param name="properties">properties for the event</param>
 | 
						|
        /// <param name="date">date for the event</param>
 | 
						|
        /// <param name="appId">project ID (optional)</param>
 | 
						|
        [Obsolete("Method is deprecated, please use Track(string eventName, Dictionary<string, object> properties, DateTime date, TimeZoneInfo timeZone, string appId = \"\") instead.")]
 | 
						|
        public static void Track(string eventName, Dictionary<string, object> properties, DateTime date, string appId = "")
 | 
						|
        {
 | 
						|
            if (tracking_enabled)
 | 
						|
            {
 | 
						|
                ThinkingAnalyticsWrapper.Track(eventName, properties, date, appId);
 | 
						|
            }
 | 
						|
            else
 | 
						|
            {
 | 
						|
                System.Reflection.MethodBase method = System.Reflection.MethodBase.GetCurrentMethod();
 | 
						|
                object[] parameters = new object[] { eventName, properties, date, appId };
 | 
						|
                eventCaches.Add(new Dictionary<string, object>() {
 | 
						|
                    { "method", method},
 | 
						|
                    { "parameters", parameters}
 | 
						|
                });
 | 
						|
            }
 | 
						|
        }
 | 
						|
 | 
						|
        /// <summary>
 | 
						|
        /// Track a Event
 | 
						|
        /// </summary>
 | 
						|
        /// <param name="eventName">the event name</param>
 | 
						|
        /// <param name="properties">properties for the event</param>
 | 
						|
        /// <param name="date">date for the event</param>
 | 
						|
        /// <param name="timeZone">time zone for the event</param>
 | 
						|
        /// <param name="appId">project ID (optional)</param>
 | 
						|
        public static void Track(string eventName, Dictionary<string, object> properties, DateTime date, TimeZoneInfo timeZone, string appId = "")
 | 
						|
        {
 | 
						|
            if (tracking_enabled)
 | 
						|
            {
 | 
						|
                ThinkingAnalyticsWrapper.Track(eventName, properties, date, timeZone, appId);
 | 
						|
            }
 | 
						|
            else
 | 
						|
            {
 | 
						|
                System.Reflection.MethodBase method = System.Reflection.MethodBase.GetCurrentMethod();
 | 
						|
                object[] parameters = new object[] { eventName, properties, date, timeZone, appId };
 | 
						|
                eventCaches.Add(new Dictionary<string, object>() {
 | 
						|
                    { "method", method},
 | 
						|
                    { "parameters", parameters}
 | 
						|
                });
 | 
						|
            }
 | 
						|
        }
 | 
						|
 | 
						|
        /// <summary>
 | 
						|
        /// Track a Special Event (First Event/Updatable Event/Overwritable Event)
 | 
						|
        /// </summary>
 | 
						|
        /// <param name="analyticsEvent">the special event</param>
 | 
						|
        /// <param name="appId">project ID (optional)</param>
 | 
						|
        public static void Track(ThinkingAnalyticsEvent analyticsEvent, string appId = "")
 | 
						|
        {
 | 
						|
            if (tracking_enabled)
 | 
						|
            {
 | 
						|
                ThinkingAnalyticsWrapper.Track(analyticsEvent, appId);
 | 
						|
            }
 | 
						|
            else
 | 
						|
            {
 | 
						|
                System.Reflection.MethodBase method = System.Reflection.MethodBase.GetCurrentMethod();
 | 
						|
                object[] parameters = new object[] { analyticsEvent, appId };
 | 
						|
                eventCaches.Add(new Dictionary<string, object>() {
 | 
						|
                    { "method", method},
 | 
						|
                    { "parameters", parameters}
 | 
						|
                });
 | 
						|
            }
 | 
						|
        }
 | 
						|
 | 
						|
        /// <summary>
 | 
						|
        /// Quickly track a Special Event
 | 
						|
        /// </summary>
 | 
						|
        /// <param name="eventName">the event name, 'SceneView' for scene view event, 'AppClick' for click event</param>
 | 
						|
        /// <param name="properties"> event properties </param>
 | 
						|
        /// <param name="appId"></param>
 | 
						|
        public static void QuickTrack(string eventName, Dictionary<string, object> properties = null, string appId = "")
 | 
						|
        {
 | 
						|
            if (tracking_enabled)
 | 
						|
            {
 | 
						|
                ThinkingAnalyticsWrapper.QuickTrack(eventName, properties, appId);
 | 
						|
            }
 | 
						|
            else
 | 
						|
            {
 | 
						|
                System.Reflection.MethodBase method = System.Reflection.MethodBase.GetCurrentMethod();
 | 
						|
                object[] parameters = new object[] { eventName, properties, appId };
 | 
						|
                eventCaches.Add(new Dictionary<string, object>() {
 | 
						|
                    { "method", method},
 | 
						|
                    { "parameters", parameters}
 | 
						|
                });
 | 
						|
            }
 | 
						|
        }
 | 
						|
 | 
						|
        /// <summary>
 | 
						|
        /// Report events data to TE server immediately
 | 
						|
        /// </summary>
 | 
						|
        /// <param name="appId">project ID (optional)</param>
 | 
						|
        public static void Flush(string appId = "")
 | 
						|
        {
 | 
						|
            if (tracking_enabled)
 | 
						|
            {
 | 
						|
                ThinkingAnalyticsWrapper.Flush(appId);
 | 
						|
            }
 | 
						|
            else
 | 
						|
            {
 | 
						|
                System.Reflection.MethodBase method = System.Reflection.MethodBase.GetCurrentMethod();
 | 
						|
                object[] parameters = new object[] { appId };
 | 
						|
                eventCaches.Add(new Dictionary<string, object>() {
 | 
						|
                    { "method", method},
 | 
						|
                    { "parameters", parameters}
 | 
						|
                });
 | 
						|
            }
 | 
						|
        }
 | 
						|
 | 
						|
        /// <summary>
 | 
						|
        /// Scenes load Delegate
 | 
						|
        /// </summary>
 | 
						|
        /// <param name="scene">the load scene</param>
 | 
						|
        /// <param name="mode">the scene loading mode</param>
 | 
						|
        public static void OnSceneLoaded(Scene scene, LoadSceneMode mode)
 | 
						|
        {
 | 
						|
            if (tracking_enabled)
 | 
						|
            {
 | 
						|
                ThinkingAnalyticsWrapper.TrackSceneLoad(scene);
 | 
						|
            }
 | 
						|
            else
 | 
						|
            {
 | 
						|
                System.Reflection.MethodBase method = System.Reflection.MethodBase.GetCurrentMethod();
 | 
						|
                object[] parameters = new object[] { scene, mode };
 | 
						|
                eventCaches.Add(new Dictionary<string, object>() {
 | 
						|
                    { "method", method},
 | 
						|
                    { "parameters", parameters}
 | 
						|
                });
 | 
						|
            }
 | 
						|
        }
 | 
						|
 | 
						|
        /// <summary>
 | 
						|
        /// Scenes unload Delegate
 | 
						|
        /// </summary>
 | 
						|
        /// <param name="scene">the unload scene</param>
 | 
						|
        public static void OnSceneUnloaded(Scene scene)
 | 
						|
        {
 | 
						|
            if (tracking_enabled)
 | 
						|
            {
 | 
						|
                ThinkingAnalyticsWrapper.TrackSceneUnload(scene);
 | 
						|
            }
 | 
						|
            else
 | 
						|
            {
 | 
						|
                System.Reflection.MethodBase method = System.Reflection.MethodBase.GetCurrentMethod();
 | 
						|
                object[] parameters = new object[] { scene };
 | 
						|
                eventCaches.Add(new Dictionary<string, object>() {
 | 
						|
                    { "method", method},
 | 
						|
                    { "parameters", parameters}
 | 
						|
                });
 | 
						|
            }
 | 
						|
        }
 | 
						|
 | 
						|
        /// <summary>
 | 
						|
        /// Super Properties, refer to properties that would be uploaded by each event
 | 
						|
        /// </summary>
 | 
						|
        /// <param name="superProperties">super properties for events</param>
 | 
						|
        /// <param name="appId">project ID (optional)</param>
 | 
						|
        public static void SetSuperProperties(Dictionary<string, object> superProperties, string appId = "")
 | 
						|
        {
 | 
						|
            if (tracking_enabled)
 | 
						|
            {
 | 
						|
                ThinkingAnalyticsWrapper.SetSuperProperties(superProperties, appId);
 | 
						|
            }
 | 
						|
            else
 | 
						|
            {
 | 
						|
                System.Reflection.MethodBase method = System.Reflection.MethodBase.GetCurrentMethod();
 | 
						|
                object[] parameters = new object[] { superProperties, appId };
 | 
						|
                eventCaches.Add(new Dictionary<string, object>() {
 | 
						|
                    { "method", method},
 | 
						|
                    { "parameters", parameters}
 | 
						|
                });
 | 
						|
            }
 | 
						|
        }
 | 
						|
 | 
						|
        /// <summary>
 | 
						|
        /// Delete Property form current Super Properties
 | 
						|
        /// </summary>
 | 
						|
        /// <param name="property">property name</param>
 | 
						|
        /// <param name="appId">project ID (optional)</param>
 | 
						|
        public static void UnsetSuperProperty(string property, string appId  = "")
 | 
						|
        {
 | 
						|
            if (tracking_enabled)
 | 
						|
            {
 | 
						|
                ThinkingAnalyticsWrapper.UnsetSuperProperty(property, appId);
 | 
						|
            }
 | 
						|
            else
 | 
						|
            {
 | 
						|
                System.Reflection.MethodBase method = System.Reflection.MethodBase.GetCurrentMethod();
 | 
						|
                object[] parameters = new object[] { property, appId };
 | 
						|
                eventCaches.Add(new Dictionary<string, object>() {
 | 
						|
                    { "method", method},
 | 
						|
                    { "parameters", parameters}
 | 
						|
                });
 | 
						|
            }
 | 
						|
        }
 | 
						|
 | 
						|
        /// <summary>
 | 
						|
        /// Returns current Super Properties
 | 
						|
        /// </summary>
 | 
						|
        /// <returns>current super properties</returns>
 | 
						|
        /// <param name="appId">project ID (optional)</param>
 | 
						|
        public static Dictionary<string, object> GetSuperProperties(string appId = "")
 | 
						|
        {
 | 
						|
            if (tracking_enabled)
 | 
						|
            {
 | 
						|
                return ThinkingAnalyticsWrapper.GetSuperProperties(appId);
 | 
						|
            }
 | 
						|
            return null;
 | 
						|
        }
 | 
						|
 | 
						|
        /// <summary>
 | 
						|
        /// Clear current Super Properties
 | 
						|
        /// </summary>
 | 
						|
        /// <param name="appId">project ID (optional)</param>
 | 
						|
        public static void ClearSuperProperties(string appId = "")
 | 
						|
        {
 | 
						|
            if (tracking_enabled)
 | 
						|
            {
 | 
						|
                ThinkingAnalyticsWrapper.ClearSuperProperty(appId);
 | 
						|
            }
 | 
						|
            else
 | 
						|
            {
 | 
						|
                System.Reflection.MethodBase method = System.Reflection.MethodBase.GetCurrentMethod();
 | 
						|
                object[] parameters = new object[] { appId };
 | 
						|
                eventCaches.Add(new Dictionary<string, object>() {
 | 
						|
                    { "method", method},
 | 
						|
                    { "parameters", parameters}
 | 
						|
                });
 | 
						|
            }
 | 
						|
        }
 | 
						|
 | 
						|
        /// <summary>
 | 
						|
        /// Returns current Preset Properties
 | 
						|
        /// </summary>
 | 
						|
        /// <returns>current preset properties</returns>
 | 
						|
        /// <param name="appId">project ID (optional)</param>
 | 
						|
        public static TDPresetProperties GetPresetProperties(string appId = "")
 | 
						|
        {
 | 
						|
            if (tracking_enabled)
 | 
						|
            {
 | 
						|
                Dictionary<string, object> properties = ThinkingAnalyticsWrapper.GetPresetProperties(appId);
 | 
						|
                TDPresetProperties presetProperties = new TDPresetProperties(properties);
 | 
						|
                return presetProperties;
 | 
						|
            }
 | 
						|
            return null;
 | 
						|
        }
 | 
						|
 | 
						|
        /// <summary>
 | 
						|
        /// Sets the Dynamic Super Properties.
 | 
						|
        /// </summary>
 | 
						|
        /// <param name="dynamicSuperProperties">dynamic super properties interface</param>
 | 
						|
        /// <param name="appId">project ID (optional)</param>
 | 
						|
        public static void SetDynamicSuperProperties(IDynamicSuperProperties dynamicSuperProperties, string appId = "")
 | 
						|
        {
 | 
						|
            if (tracking_enabled)
 | 
						|
            {
 | 
						|
                ThinkingAnalyticsWrapper.SetDynamicSuperProperties(dynamicSuperProperties, appId);
 | 
						|
            }
 | 
						|
            else
 | 
						|
            {
 | 
						|
                System.Reflection.MethodBase method = System.Reflection.MethodBase.GetCurrentMethod();
 | 
						|
                object[] parameters = new object[] { dynamicSuperProperties, appId };
 | 
						|
                eventCaches.Add(new Dictionary<string, object>() {
 | 
						|
                    { "method", method},
 | 
						|
                    { "parameters", parameters}
 | 
						|
                });
 | 
						|
            }
 | 
						|
        }
 | 
						|
 | 
						|
        /// <summary>
 | 
						|
        /// Records Event Duration, call TimeEvent to start timing for the Event, call Track to end timing
 | 
						|
        /// </summary>
 | 
						|
        /// <param name="eventName">the event name</param>
 | 
						|
        /// <param name="appId">project ID (optional)</param>
 | 
						|
        public static void TimeEvent(string eventName, string appId = "")
 | 
						|
        {
 | 
						|
            if (tracking_enabled)
 | 
						|
            {
 | 
						|
                ThinkingAnalyticsWrapper.TimeEvent(eventName, appId);
 | 
						|
            }
 | 
						|
            else
 | 
						|
            {
 | 
						|
                System.Reflection.MethodBase method = System.Reflection.MethodBase.GetCurrentMethod();
 | 
						|
                object[] parameters = new object[] { eventName, appId };
 | 
						|
                eventCaches.Add(new Dictionary<string, object>() {
 | 
						|
                    { "method", method},
 | 
						|
                    { "parameters", parameters}
 | 
						|
                });
 | 
						|
            }
 | 
						|
        }
 | 
						|
 | 
						|
        /// <summary>
 | 
						|
        /// Sets User Properties, this will overwrite the original properties value
 | 
						|
        /// </summary>
 | 
						|
        /// <param name="properties">user properties</param>
 | 
						|
        /// <param name="appId">project ID (optional)</param>
 | 
						|
        public static void UserSet(Dictionary<string, object> properties, string appId = "")
 | 
						|
        {
 | 
						|
            if (tracking_enabled)
 | 
						|
            {
 | 
						|
                ThinkingAnalyticsWrapper.UserSet(properties, appId);
 | 
						|
            }
 | 
						|
            else
 | 
						|
            {
 | 
						|
                System.Reflection.MethodBase method = System.Reflection.MethodBase.GetCurrentMethod();
 | 
						|
                object[] parameters = new object[] { properties, appId };
 | 
						|
                eventCaches.Add(new Dictionary<string, object>() {
 | 
						|
                    { "method", method},
 | 
						|
                    { "parameters", parameters}
 | 
						|
                });
 | 
						|
            }
 | 
						|
        }
 | 
						|
 | 
						|
        /// <summary>
 | 
						|
        /// Sets User Properties, this will overwrite the original properties value
 | 
						|
        /// </summary>
 | 
						|
        /// <param name="properties">user properties</param>
 | 
						|
        /// <param name="dateTime">date time</param>
 | 
						|
        /// <param name="appId">project ID (optional)</param>
 | 
						|
        public static void UserSet(Dictionary<string, object> properties, DateTime dateTime, string appId = "")
 | 
						|
        {
 | 
						|
            if (tracking_enabled)
 | 
						|
            {
 | 
						|
                ThinkingAnalyticsWrapper.UserSet(properties, dateTime, appId);
 | 
						|
            }
 | 
						|
            else
 | 
						|
            {
 | 
						|
                System.Reflection.MethodBase method = System.Reflection.MethodBase.GetCurrentMethod();
 | 
						|
                object[] parameters = new object[] { properties , dateTime, appId};
 | 
						|
                eventCaches.Add(new Dictionary<string, object>() {
 | 
						|
                    { "method", method},
 | 
						|
                    { "parameters", parameters}
 | 
						|
                });
 | 
						|
            }
 | 
						|
        }
 | 
						|
 | 
						|
        /// <summary>
 | 
						|
        /// Unsets one of User Porperties, this would not create properties that have not been created in TE
 | 
						|
        /// </summary>
 | 
						|
        /// <param name="property">the user property name</param>
 | 
						|
        /// <param name="appId">project ID (optional)</param>
 | 
						|
        public static void UserUnset(string property, string appId = "")
 | 
						|
        {
 | 
						|
            List<string> properties = new List<string>();
 | 
						|
            properties.Add(property);
 | 
						|
            UserUnset(properties, appId);
 | 
						|
        }
 | 
						|
 | 
						|
 | 
						|
        /// <summary>
 | 
						|
        /// Unsets some of User Porperties, this would not create properties that have not been created in TE
 | 
						|
        /// </summary>
 | 
						|
        /// <param name="properties">the user properties name</param>
 | 
						|
        /// <param name="appId">project ID (optional)</param>
 | 
						|
        public static void UserUnset(List<string> properties, string appId = "")
 | 
						|
        {
 | 
						|
            if (tracking_enabled)
 | 
						|
            {
 | 
						|
                ThinkingAnalyticsWrapper.UserUnset(properties, appId);
 | 
						|
            }
 | 
						|
            else
 | 
						|
            {
 | 
						|
                System.Reflection.MethodBase method = System.Reflection.MethodBase.GetCurrentMethod();
 | 
						|
                object[] parameters = new object[] { properties, appId };
 | 
						|
                eventCaches.Add(new Dictionary<string, object>() {
 | 
						|
                    { "method", method},
 | 
						|
                    { "parameters", parameters}
 | 
						|
                });
 | 
						|
            }
 | 
						|
 | 
						|
        }
 | 
						|
 | 
						|
        /// <summary>
 | 
						|
        /// Unsets some of User Porperties, this would not create properties that have not been created in TE
 | 
						|
        /// </summary>
 | 
						|
        /// <param name="properties">the user properties name</param>
 | 
						|
        /// <param name="dateTime">date time</param>
 | 
						|
        /// <param name="appId">project ID (optional)</param>
 | 
						|
        public static void UserUnset(List<string> properties, DateTime dateTime, string appId = "")
 | 
						|
        {
 | 
						|
            if (tracking_enabled)
 | 
						|
            {
 | 
						|
                ThinkingAnalyticsWrapper.UserUnset(properties, dateTime, appId);
 | 
						|
            }
 | 
						|
            else
 | 
						|
            {
 | 
						|
                System.Reflection.MethodBase method = System.Reflection.MethodBase.GetCurrentMethod();
 | 
						|
                object[] parameters = new object[] { properties, dateTime, appId };
 | 
						|
                eventCaches.Add(new Dictionary<string, object>() {
 | 
						|
                    { "method", method},
 | 
						|
                    { "parameters", parameters}
 | 
						|
                });
 | 
						|
            }
 | 
						|
        }
 | 
						|
 | 
						|
        /// <summary>
 | 
						|
        /// Sets User Properties for Once. This message would be neglected, if such property had been set before
 | 
						|
        /// </summary>
 | 
						|
        /// <param name="properties">user properties</param>
 | 
						|
        /// <param name="appId">project ID (optional)</param>
 | 
						|
        public static void UserSetOnce(Dictionary<string, object> properties, string appId = "")
 | 
						|
        {
 | 
						|
            if (tracking_enabled)
 | 
						|
            {
 | 
						|
                ThinkingAnalyticsWrapper.UserSetOnce(properties, appId);
 | 
						|
            }
 | 
						|
            else
 | 
						|
            {
 | 
						|
                System.Reflection.MethodBase method = System.Reflection.MethodBase.GetCurrentMethod();
 | 
						|
                object[] parameters = new object[] { properties, appId };
 | 
						|
                eventCaches.Add(new Dictionary<string, object>() {
 | 
						|
                    { "method", method},
 | 
						|
                    { "parameters", parameters}
 | 
						|
                });
 | 
						|
            }
 | 
						|
 | 
						|
        }
 | 
						|
 | 
						|
        /// <summary>
 | 
						|
        /// Sets User Properties for Once. The property would be neglected, if such property had been set before
 | 
						|
        /// </summary>
 | 
						|
        /// <param name="properties">user properties</param>
 | 
						|
        /// <param name="dateTime">date time</param>
 | 
						|
        /// <param name="appId">project ID (optional)</param>
 | 
						|
        public static void UserSetOnce(Dictionary<string, object> properties, DateTime dateTime, string appId = "")
 | 
						|
        {
 | 
						|
            if (tracking_enabled)
 | 
						|
            {
 | 
						|
                ThinkingAnalyticsWrapper.UserSetOnce(properties, dateTime, appId);
 | 
						|
            }
 | 
						|
            else
 | 
						|
            {
 | 
						|
                System.Reflection.MethodBase method = System.Reflection.MethodBase.GetCurrentMethod();
 | 
						|
                object[] parameters = new object[] { properties, dateTime,appId };
 | 
						|
                eventCaches.Add(new Dictionary<string, object>() {
 | 
						|
                    { "method", method},
 | 
						|
                    { "parameters", parameters}
 | 
						|
                });
 | 
						|
            }
 | 
						|
 | 
						|
        }
 | 
						|
 | 
						|
        /// <summary>
 | 
						|
        /// Accumulates the property. If the property has not been set, it would be given a value of 0 before computing. 
 | 
						|
        /// </summary>
 | 
						|
        /// <param name="property">the property name</param>
 | 
						|
        /// <param name="value">value of the property</param>
 | 
						|
        /// <param name="appId">project ID (optional)</param>
 | 
						|
        public static void UserAdd(string property, object value, string appId = "")
 | 
						|
        {
 | 
						|
            Dictionary<string, object> properties = new Dictionary<string, object>()
 | 
						|
            {
 | 
						|
                { property, value }
 | 
						|
            };
 | 
						|
            UserAdd(properties, appId);
 | 
						|
        }
 | 
						|
 | 
						|
        /// <summary>
 | 
						|
        /// Accumulates the property. If the property has not been set, it would be given a value of 0 before computing. 
 | 
						|
        /// </summary>
 | 
						|
        /// <param name="properties">user properties</param>
 | 
						|
        /// <param name="appId">project ID (optional)</param>
 | 
						|
        public static void UserAdd(Dictionary<string, object> properties, string appId = "")
 | 
						|
        {
 | 
						|
            if (tracking_enabled)
 | 
						|
            {
 | 
						|
                ThinkingAnalyticsWrapper.UserAdd(properties, appId);
 | 
						|
            }
 | 
						|
            else
 | 
						|
            {
 | 
						|
                System.Reflection.MethodBase method = System.Reflection.MethodBase.GetCurrentMethod();
 | 
						|
                object[] parameters = new object[] { properties, appId };
 | 
						|
                eventCaches.Add(new Dictionary<string, object>() {
 | 
						|
                    { "method", method},
 | 
						|
                    { "parameters", parameters}
 | 
						|
                });
 | 
						|
            }
 | 
						|
        }
 | 
						|
 | 
						|
        /// <summary>
 | 
						|
        /// Accumulates the property, type of Number. If the property has not been set, it would be given a value of 0 before computing. 
 | 
						|
        /// </summary>
 | 
						|
        /// <param name="properties">user properties</param>
 | 
						|
        /// <param name="dateTime">date time</param>
 | 
						|
        /// <param name="appId">project ID (optional)</param>
 | 
						|
        public static void UserAdd(Dictionary<string, object> properties, DateTime dateTime, string appId = "")
 | 
						|
        {
 | 
						|
            if (tracking_enabled)
 | 
						|
            {
 | 
						|
                ThinkingAnalyticsWrapper.UserAdd(properties, dateTime, appId);
 | 
						|
            }
 | 
						|
            else
 | 
						|
            {
 | 
						|
                System.Reflection.MethodBase method = System.Reflection.MethodBase.GetCurrentMethod();
 | 
						|
                object[] parameters = new object[] { properties, dateTime, appId };
 | 
						|
                eventCaches.Add(new Dictionary<string, object>() {
 | 
						|
                    { "method", method},
 | 
						|
                    { "parameters", parameters}
 | 
						|
                });
 | 
						|
            }
 | 
						|
        }
 | 
						|
 | 
						|
        /// <summary>
 | 
						|
        /// Appends the property, type of List.
 | 
						|
        /// </summary>
 | 
						|
        /// <param name="properties">user properties</param>
 | 
						|
        /// <param name="appId">project ID (optional)</param>
 | 
						|
        public static void UserAppend(Dictionary<string, object> properties, string appId = "")
 | 
						|
        {
 | 
						|
            if (tracking_enabled)
 | 
						|
            {
 | 
						|
                ThinkingAnalyticsWrapper.UserAppend(properties, appId);
 | 
						|
            }
 | 
						|
            else
 | 
						|
            {
 | 
						|
                System.Reflection.MethodBase method = System.Reflection.MethodBase.GetCurrentMethod();
 | 
						|
                object[] parameters = new object[] { properties, appId };
 | 
						|
                eventCaches.Add(new Dictionary<string, object>() {
 | 
						|
                    { "method", method},
 | 
						|
                    { "parameters", parameters}
 | 
						|
                });
 | 
						|
            }
 | 
						|
        }
 | 
						|
 | 
						|
        /// <summary>
 | 
						|
        /// Appends the property, type of List.
 | 
						|
        /// </summary>
 | 
						|
        /// <param name="properties">user properties</param>
 | 
						|
        /// <param name="dateTime">date time</param>
 | 
						|
        /// <param name="appId">project ID (optional)</param>
 | 
						|
        public static void UserAppend(Dictionary<string, object> properties, DateTime dateTime, string appId = "")
 | 
						|
        {
 | 
						|
            if (tracking_enabled)
 | 
						|
            {
 | 
						|
                ThinkingAnalyticsWrapper.UserAppend(properties, dateTime, appId);
 | 
						|
            }
 | 
						|
            else
 | 
						|
            {
 | 
						|
                System.Reflection.MethodBase method = System.Reflection.MethodBase.GetCurrentMethod();
 | 
						|
                object[] parameters = new object[] { properties, dateTime, appId };
 | 
						|
                eventCaches.Add(new Dictionary<string, object>() {
 | 
						|
                    { "method", method},
 | 
						|
                    { "parameters", parameters}
 | 
						|
                });
 | 
						|
            }
 | 
						|
        }
 | 
						|
 | 
						|
        /// <summary>
 | 
						|
        /// Appends the property Uniquely, type of List. If the property has been set, it would be neglected
 | 
						|
        /// </summary>
 | 
						|
        /// <param name="properties">user properties</param>
 | 
						|
        /// <param name="appId">project ID (optional)</param>
 | 
						|
        public static void UserUniqAppend(Dictionary<string, object> properties, string appId = "")
 | 
						|
        {
 | 
						|
            if (tracking_enabled)
 | 
						|
            {
 | 
						|
                ThinkingAnalyticsWrapper.UserUniqAppend(properties, appId);
 | 
						|
            }
 | 
						|
            else
 | 
						|
            {
 | 
						|
                System.Reflection.MethodBase method = System.Reflection.MethodBase.GetCurrentMethod();
 | 
						|
                object[] parameters = new object[] { properties, appId };
 | 
						|
                eventCaches.Add(new Dictionary<string, object>() {
 | 
						|
                    { "method", method},
 | 
						|
                    { "parameters", parameters}
 | 
						|
                });
 | 
						|
            }
 | 
						|
        }
 | 
						|
 | 
						|
        /// <summary>
 | 
						|
        /// Appends the property Uniquely, type of List. If the property has been set, it would be neglected
 | 
						|
        /// </summary>
 | 
						|
        /// <param name="properties">user prpoerties</param>
 | 
						|
        /// <param name="dateTime">date time</param>
 | 
						|
        /// <param name="appId">project ID (optional)</param>
 | 
						|
        public static void UserUniqAppend(Dictionary<string, object> properties, DateTime dateTime, string appId = "")
 | 
						|
        {
 | 
						|
            if (tracking_enabled)
 | 
						|
            {
 | 
						|
                ThinkingAnalyticsWrapper.UserUniqAppend(properties, dateTime, appId);
 | 
						|
            }
 | 
						|
            else
 | 
						|
            {
 | 
						|
                System.Reflection.MethodBase method = System.Reflection.MethodBase.GetCurrentMethod();
 | 
						|
                object[] parameters = new object[] { properties, dateTime, appId };
 | 
						|
                eventCaches.Add(new Dictionary<string, object>() {
 | 
						|
                    { "method", method},
 | 
						|
                    { "parameters", parameters}
 | 
						|
                });
 | 
						|
            }
 | 
						|
        }
 | 
						|
 | 
						|
        /// <summary>
 | 
						|
        /// Deletes All Properties for a user, the events triggered by the user are still exist
 | 
						|
        /// </summary>
 | 
						|
        /// <param name="appId">project ID (optional)</param>
 | 
						|
        public static void UserDelete(string appId = "")
 | 
						|
        {
 | 
						|
            if (tracking_enabled)
 | 
						|
            {
 | 
						|
                ThinkingAnalyticsWrapper.UserDelete(appId);
 | 
						|
            }
 | 
						|
            else
 | 
						|
            {
 | 
						|
                System.Reflection.MethodBase method = System.Reflection.MethodBase.GetCurrentMethod();
 | 
						|
                object[] parameters = new object[] { appId };
 | 
						|
                eventCaches.Add(new Dictionary<string, object>() {
 | 
						|
                    { "method", method},
 | 
						|
                    { "parameters", parameters}
 | 
						|
                });
 | 
						|
            }
 | 
						|
        }
 | 
						|
 | 
						|
        /// <summary>
 | 
						|
        /// Deletes All Properties for a user, the events triggered by the user are still exist
 | 
						|
        /// </summary>
 | 
						|
        /// <param name="dateTime">date time</param>
 | 
						|
        /// <param name="appId">project ID (optional)</param>
 | 
						|
        public static void UserDelete(DateTime dateTime, string appId = "")
 | 
						|
        {
 | 
						|
            if (tracking_enabled)
 | 
						|
            {
 | 
						|
                ThinkingAnalyticsWrapper.UserDelete(dateTime, appId);
 | 
						|
            }
 | 
						|
            else
 | 
						|
            {
 | 
						|
                System.Reflection.MethodBase method = System.Reflection.MethodBase.GetCurrentMethod();
 | 
						|
                object[] parameters = new object[] { dateTime, appId };
 | 
						|
                eventCaches.Add(new Dictionary<string, object>() {
 | 
						|
                    { "method", method},
 | 
						|
                    { "parameters", parameters}
 | 
						|
                });
 | 
						|
            }
 | 
						|
        }
 | 
						|
 | 
						|
        /// <summary>
 | 
						|
        /// Sets Network Type for report date to TE
 | 
						|
        /// </summary>
 | 
						|
        /// <param name="networkType">network type, see NetworkType</param>
 | 
						|
        /// <param name="appId">project ID (optional)</param>
 | 
						|
        public static void SetNetworkType(NetworkType networkType, string appId =  "")
 | 
						|
        {
 | 
						|
            if (tracking_enabled)
 | 
						|
            {
 | 
						|
                ThinkingAnalyticsWrapper.SetNetworkType(networkType);
 | 
						|
            }
 | 
						|
            else
 | 
						|
            {
 | 
						|
                System.Reflection.MethodBase method = System.Reflection.MethodBase.GetCurrentMethod();
 | 
						|
                object[] parameters = new object[] { networkType, appId };
 | 
						|
                eventCaches.Add(new Dictionary<string, object>() {
 | 
						|
                    { "method", method},
 | 
						|
                    { "parameters", parameters}
 | 
						|
                });
 | 
						|
            }
 | 
						|
        }
 | 
						|
 | 
						|
        /// <summary>
 | 
						|
        /// Gets the device identifier.
 | 
						|
        /// </summary>
 | 
						|
        /// <returns>The device identifier.</returns>
 | 
						|
        public static string GetDeviceId()
 | 
						|
        {
 | 
						|
            if (tracking_enabled)
 | 
						|
            {
 | 
						|
                return ThinkingAnalyticsWrapper.GetDeviceId();
 | 
						|
            } 
 | 
						|
            return null;
 | 
						|
        }
 | 
						|
 | 
						|
        /// <summary>
 | 
						|
        /// Sets Data Report Status
 | 
						|
        /// </summary>
 | 
						|
        /// <param name="status">data report status, see TA_TRACK_STATUS</param>
 | 
						|
        /// <param name="appId">project ID (optional)</param>
 | 
						|
        public static void SetTrackStatus(TA_TRACK_STATUS status, string appId = "")
 | 
						|
        {
 | 
						|
            if (tracking_enabled)
 | 
						|
            {
 | 
						|
                ThinkingAnalyticsWrapper.SetTrackStatus(status, appId);
 | 
						|
            }
 | 
						|
            else
 | 
						|
            {
 | 
						|
                System.Reflection.MethodBase method = System.Reflection.MethodBase.GetCurrentMethod();
 | 
						|
                object[] parameters = new object[] { status, appId };
 | 
						|
                eventCaches.Add(new Dictionary<string, object>() {
 | 
						|
                    { "method", method},
 | 
						|
                    { "parameters", parameters}
 | 
						|
                });
 | 
						|
            }
 | 
						|
        }
 | 
						|
 | 
						|
        /// <summary>
 | 
						|
        /// Stops Report Event Data, and Clear Cache Data (include unreported event data, custom distinct ID, account ID, Super Properties)
 | 
						|
        /// </summary>
 | 
						|
        /// <param name="appId">project ID (optional)</param>
 | 
						|
        [Obsolete("Method is deprecated, please use SetTrackStatus() instead.")]
 | 
						|
        public static void OptOutTracking(string appId = "")
 | 
						|
        {
 | 
						|
            if (tracking_enabled)
 | 
						|
            {
 | 
						|
                ThinkingAnalyticsWrapper.OptOutTracking(appId);
 | 
						|
            }
 | 
						|
            else
 | 
						|
            {
 | 
						|
                System.Reflection.MethodBase method = System.Reflection.MethodBase.GetCurrentMethod();
 | 
						|
                object[] parameters = new object[] { appId };
 | 
						|
                eventCaches.Add(new Dictionary<string, object>() {
 | 
						|
                    { "method", method},
 | 
						|
                    { "parameters", parameters}
 | 
						|
                });
 | 
						|
            }
 | 
						|
        }
 | 
						|
 | 
						|
        /// <summary>
 | 
						|
        /// Stops Report Event Data, and Clear Cache Data (include unreported event data, custom distinct ID, account ID, super properties), and Delete User
 | 
						|
        /// </summary>
 | 
						|
        /// <param name="appId">project ID (optional)</param>
 | 
						|
        [Obsolete("Method is deprecated, please use SetTrackStatus() instead.")]
 | 
						|
        public static void OptOutTrackingAndDeleteUser(string appId = "")
 | 
						|
        {
 | 
						|
            if (tracking_enabled)
 | 
						|
            {
 | 
						|
                ThinkingAnalyticsWrapper.OptOutTrackingAndDeleteUser(appId);
 | 
						|
            }
 | 
						|
            else
 | 
						|
            {
 | 
						|
                System.Reflection.MethodBase method = System.Reflection.MethodBase.GetCurrentMethod();
 | 
						|
                object[] parameters = new object[] { appId };
 | 
						|
                eventCaches.Add(new Dictionary<string, object>() {
 | 
						|
                    { "method", method},
 | 
						|
                    { "parameters", parameters}
 | 
						|
                });
 | 
						|
            }
 | 
						|
        }
 | 
						|
 | 
						|
        /// <summary>
 | 
						|
        /// Resumes Report Event Data
 | 
						|
        /// </summary>
 | 
						|
        /// <param name="appId">project ID (optional)</param>
 | 
						|
        [Obsolete("Method is deprecated, please use SetTrackStatus() instead.")]
 | 
						|
        public static void OptInTracking(string appId = "")
 | 
						|
        {
 | 
						|
            if (tracking_enabled)
 | 
						|
            {
 | 
						|
                ThinkingAnalyticsWrapper.OptInTracking(appId);
 | 
						|
            }
 | 
						|
            else
 | 
						|
            {
 | 
						|
                System.Reflection.MethodBase method = System.Reflection.MethodBase.GetCurrentMethod();
 | 
						|
                object[] parameters = new object[] { appId };
 | 
						|
                eventCaches.Add(new Dictionary<string, object>() {
 | 
						|
                    { "method", method},
 | 
						|
                    { "parameters", parameters}
 | 
						|
                });
 | 
						|
            }
 | 
						|
        }
 | 
						|
 | 
						|
        /// <summary>
 | 
						|
        /// Enable Report Event Data
 | 
						|
        /// </summary>
 | 
						|
        /// <param name="enabled">Whether to enable reported data</param>
 | 
						|
        /// <param name="appId">project ID (optional)</param>
 | 
						|
        [Obsolete("Method is deprecated, please use SetTrackStatus() instead.")]
 | 
						|
        public static void EnableTracking(bool enabled, string appId = "")
 | 
						|
        {
 | 
						|
            if (tracking_enabled)
 | 
						|
            {
 | 
						|
                ThinkingAnalyticsWrapper.EnableTracking(enabled, appId);
 | 
						|
            }
 | 
						|
            else
 | 
						|
            {
 | 
						|
                System.Reflection.MethodBase method = System.Reflection.MethodBase.GetCurrentMethod();
 | 
						|
                object[] parameters = new object[] { enabled, appId };
 | 
						|
                eventCaches.Add(new Dictionary<string, object>() {
 | 
						|
                    { "method", method},
 | 
						|
                    { "parameters", parameters}
 | 
						|
                });
 | 
						|
            }
 | 
						|
        }
 | 
						|
 | 
						|
        /// <summary>
 | 
						|
        /// Creats Light Instance, it has same project ID to main instance, diffent distinct ID, account ID, super properties
 | 
						|
        /// </summary>
 | 
						|
        /// <param name="appId">project ID (optional)</param>
 | 
						|
        /// <returns>light instance token </returns>
 | 
						|
        public static string CreateLightInstance(string appId = "") {
 | 
						|
            if (tracking_enabled)
 | 
						|
            {
 | 
						|
                return ThinkingAnalyticsWrapper.CreateLightInstance();
 | 
						|
            }
 | 
						|
            return null;
 | 
						|
        }
 | 
						|
 | 
						|
        /// <summary>
 | 
						|
        /// Calibrate Event Time, calibrated times are used for events after that
 | 
						|
        /// </summary>
 | 
						|
        /// <param name="timestamp">currnt Unix timestamp, units Ms </param>
 | 
						|
        public static void CalibrateTime(long timestamp)
 | 
						|
        {
 | 
						|
            ThinkingAnalyticsWrapper.CalibrateTime(timestamp);
 | 
						|
        }
 | 
						|
 | 
						|
        /// <summary>
 | 
						|
        /// Calibrate Event Time, calibrated times are used for events after that
 | 
						|
        /// If NTP server is not returns in 3s, the time will not be re-calibrated
 | 
						|
        /// </summary>
 | 
						|
        /// <param name="ntpServer">NTP server, e.g 'time.asia.apple.com' </param>
 | 
						|
        public static void CalibrateTimeWithNtp(string ntpServer)
 | 
						|
        {
 | 
						|
            ThinkingAnalyticsWrapper.CalibrateTimeWithNtp(ntpServer);
 | 
						|
        }
 | 
						|
 | 
						|
        /// <summary>
 | 
						|
        /// Cross Platform
 | 
						|
        /// Share TE account system info to other platforms
 | 
						|
        /// </summary>
 | 
						|
        /// <param name="shareType">type of platforms, see TAThirdPartyShareType</param>
 | 
						|
        /// <param name="properties">properties of platforms</param>
 | 
						|
        /// <param name="appId">project ID (optional)</param>
 | 
						|
        public static void EnableThirdPartySharing(TAThirdPartyShareType shareType, Dictionary<string, object> properties = null, string appId = "")
 | 
						|
        {
 | 
						|
            if (tracking_enabled)
 | 
						|
            {
 | 
						|
                ThinkingAnalyticsWrapper.EnableThirdPartySharing(shareType, properties, appId);
 | 
						|
            }
 | 
						|
            else
 | 
						|
            {
 | 
						|
                System.Reflection.MethodBase method = System.Reflection.MethodBase.GetCurrentMethod();
 | 
						|
                object[] parameters = new object[] { shareType };
 | 
						|
                eventCaches.Add(new Dictionary<string, object>() {
 | 
						|
                    { "method", method},
 | 
						|
                    { "parameters", parameters}
 | 
						|
                });
 | 
						|
            }
 | 
						|
        }
 | 
						|
 | 
						|
        /// <summary>
 | 
						|
        /// Gets the Local Country/Region Code
 | 
						|
        /// the two-letter code defined in ISO 3166 for the country/region
 | 
						|
        /// </summary>
 | 
						|
        /// <returns>country/region code</returns>
 | 
						|
        public static string GetLocalRegion()
 | 
						|
        {
 | 
						|
            return System.Globalization.RegionInfo.CurrentRegion.TwoLetterISORegionName;
 | 
						|
        }
 | 
						|
 | 
						|
        /// <summary>
 | 
						|
        /// Start Thinking Analytics SDK
 | 
						|
        /// </summary>
 | 
						|
        /// <param name="appId">project ID</param>
 | 
						|
        /// <param name="serverUrl">project URL</param>
 | 
						|
        public static void StartThinkingAnalytics(string appId, string serverUrl)
 | 
						|
        {
 | 
						|
            ThinkingAnalyticsAPI.TAMode mode = ThinkingAnalyticsAPI.TAMode.NORMAL;
 | 
						|
            ThinkingAnalyticsAPI.TATimeZone timeZone = ThinkingAnalyticsAPI.TATimeZone.Local;
 | 
						|
            ThinkingAnalyticsAPI.Token token = new ThinkingAnalyticsAPI.Token(appId, serverUrl, mode, timeZone);
 | 
						|
            ThinkingAnalyticsAPI.StartThinkingAnalytics(token);
 | 
						|
        }
 | 
						|
 | 
						|
        /// <summary>
 | 
						|
        /// Start Thinking Analytics SDK
 | 
						|
        /// </summary>
 | 
						|
        /// <param name="token">project setting, see ThinkingAnalyticsAPI.Token</param>
 | 
						|
        public static void StartThinkingAnalytics(ThinkingAnalyticsAPI.Token token)
 | 
						|
        {
 | 
						|
            ThinkingAnalyticsAPI.Token[] tokens = new ThinkingAnalyticsAPI.Token[1];
 | 
						|
            tokens[0] = token;
 | 
						|
            ThinkingAnalyticsAPI.StartThinkingAnalytics(tokens);
 | 
						|
        }
 | 
						|
 | 
						|
        /// <summary>
 | 
						|
        /// Start Thinking Analytics SDK
 | 
						|
        /// </summary>
 | 
						|
        /// <param name="tokens">projects setting, see ThinkingAnalyticsAPI.Token</param>
 | 
						|
        public static void StartThinkingAnalytics(Token[] tokens = null)
 | 
						|
        {
 | 
						|
#if DISABLE_TA
 | 
						|
            tracking_enabled = false;
 | 
						|
#else
 | 
						|
            tracking_enabled = true;
 | 
						|
#endif
 | 
						|
 | 
						|
            if (tracking_enabled)
 | 
						|
            {
 | 
						|
                TD_PublicConfig.GetPublicConfig();
 | 
						|
                TD_Log.EnableLog(sThinkingAnalyticsAPI.enableLog);
 | 
						|
                ThinkingAnalyticsWrapper.EnableLog(sThinkingAnalyticsAPI.enableLog);
 | 
						|
                ThinkingAnalyticsWrapper.SetVersionInfo(TD_PublicConfig.LIB_VERSION);
 | 
						|
                if (tokens == null)
 | 
						|
                {
 | 
						|
                    tokens = sThinkingAnalyticsAPI.tokens;
 | 
						|
                }
 | 
						|
                try
 | 
						|
                {
 | 
						|
                    for (int i = 0; i < tokens.Length; i++)
 | 
						|
                    {
 | 
						|
                        Token token = tokens[i];
 | 
						|
                        if (!string.IsNullOrEmpty(token.appid))
 | 
						|
                        {
 | 
						|
                            token.appid = token.appid.Replace(" ", "");
 | 
						|
                            if(TD_Log.GetEnable()) TD_Log.d("ThinkingAnalytics start with APPID: " + token.appid + ", SERVERURL: " + token.serverUrl + ", MODE: " + token.mode);
 | 
						|
                            ThinkingAnalyticsWrapper.ShareInstance(token, sThinkingAnalyticsAPI);
 | 
						|
                            ThinkingAnalyticsWrapper.SetNetworkType(sThinkingAnalyticsAPI.networkType);
 | 
						|
                        }
 | 
						|
                    }
 | 
						|
                }
 | 
						|
                catch (Exception ex)
 | 
						|
                {
 | 
						|
                    if(TD_Log.GetEnable()) TD_Log.d("ThinkingAnalytics start Error: " + ex.Message);
 | 
						|
                }
 | 
						|
            }
 | 
						|
 | 
						|
            FlushEventCaches();
 | 
						|
        }
 | 
						|
 | 
						|
        #region internal
 | 
						|
        private static void FlushEventCaches()
 | 
						|
        {
 | 
						|
            List<Dictionary<string, object>> tmpEventCaches = new List<Dictionary<string, object>>(eventCaches);
 | 
						|
            eventCaches.Clear();
 | 
						|
            foreach (Dictionary<string, object> eventCache in tmpEventCaches)
 | 
						|
            {
 | 
						|
                if (eventCache.ContainsKey("method") && eventCache.ContainsKey("parameters"))
 | 
						|
                {
 | 
						|
                    System.Reflection.MethodBase method = (System.Reflection.MethodBase)eventCache["method"];
 | 
						|
                    object[] parameters = (object[])eventCache["parameters"];
 | 
						|
                    method.Invoke(null, parameters);
 | 
						|
                }
 | 
						|
            }
 | 
						|
        }
 | 
						|
 | 
						|
        private void Awake()
 | 
						|
        {
 | 
						|
            if (sThinkingAnalyticsAPI == null)
 | 
						|
            {
 | 
						|
                sThinkingAnalyticsAPI = this;
 | 
						|
                DontDestroyOnLoad(gameObject);
 | 
						|
            } 
 | 
						|
            else
 | 
						|
            {
 | 
						|
                Destroy(gameObject);
 | 
						|
                return;
 | 
						|
            }
 | 
						|
 | 
						|
            if (this.startManually == false) 
 | 
						|
            {
 | 
						|
                ThinkingAnalyticsAPI.StartThinkingAnalytics();
 | 
						|
            }
 | 
						|
        }
 | 
						|
 | 
						|
        private void Start()
 | 
						|
        {
 | 
						|
        }
 | 
						|
 | 
						|
        private void OnApplicationQuit()
 | 
						|
        {
 | 
						|
            //Scene scene = SceneManager.GetActiveScene();
 | 
						|
            //if (scene != null)
 | 
						|
            //{
 | 
						|
            //    OnSceneUnloaded(scene);
 | 
						|
            //}
 | 
						|
        }
 | 
						|
 | 
						|
        private static ThinkingAnalyticsAPI sThinkingAnalyticsAPI;
 | 
						|
        private static bool tracking_enabled = false;
 | 
						|
        private static List<Dictionary<string, object>> eventCaches = new List<Dictionary<string, object>>();
 | 
						|
        #endregion
 | 
						|
    }
 | 
						|
}
 |