Developer/tysdk-intergration
7
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Ta android + ios

Browse Source
This commit is contained in:
LYP
2024-08-07 20:22:28 +08:00
parent 69fee08c61
commit 76458664d8
722 changed files with 41709 additions and 1 deletions
Download Patch File Download Diff File Expand all files Collapse all files

941
sdk-intergration/Packages/TA/Runtime/ThinkingAnalytics/Wrapper/TDAndroidWrapper.cs Normal file
View File

@@ -0,0 +1,941 @@
#if UNITY_ANDROID && !(UNITY_EDITOR) && !TE_DISABLE_ANDROID_JAVA
using System;
using System.Collections.Generic;
using ThinkingData.Analytics.Utils;
using UnityEngine;
namespace ThinkingData.Analytics.Wrapper
{
public partial class TDWrapper
{
private static readonly string JSON_CLASS = "org.json.JSONObject";
private static readonly AndroidJavaClass sdkClass = new AndroidJavaClass("cn.thinkingdata.analytics.ThinkingAnalyticsSDK");
//private static readonly AndroidJavaClass configClass = new AndroidJavaClass("cn.thinkingdata.android.TDConfig");
private static readonly AndroidJavaObject unityAPIInstance = new AndroidJavaObject("cn.thinkingdata.engine.ThinkingAnalyticsUnityAPI");
private static Dictionary<string, AndroidJavaObject> light_instances = null;
private static TimeZoneInfo defaultTimeZone = null;
private static TDTimeZone defaultTDTimeZone = TDTimeZone.Local;
/// <summary>
/// Convert Dictionary object to JSONObject in Java.
/// </summary>
/// <returns>The JSONObject instance.</returns>
/// <param name="data">The Dictionary containing some data </param>
private static AndroidJavaObject getJSONObject(Dictionary<string, object> data)
{
if (data == null)
{
return null;
}
string dataString = serilize(data);
try
{
return new AndroidJavaObject(JSON_CLASS, dataString);
}
catch (Exception e)
{
if(TDLog.GetEnable()) TDLog.w("ThinkingAnalytics: unexpected exception: " + e);
}
return null;
}
private static string getTimeString(DateTime dateTime) {
//long dateTimeTicksUTC = TimeZoneInfo.ConvertTimeToUtc(dateTime).Ticks;
//DateTime dtFrom = new DateTime(1970, 1, 1, 0, 0, 0, 0, DateTimeKind.Utc);
//long currentMillis = (dateTimeTicksUTC - dtFrom.Ticks) / 10000;
//AndroidJavaObject date = new AndroidJavaObject("java.util.Date", currentMillis);
//return getInstance(default_appId).Call<string>("getTimeString", date);
if (defaultTimeZone == null)
{
return TDCommonUtils.FormatDate(dateTime, defaultTDTimeZone);
}
else {
return TDCommonUtils.FormatDate(dateTime, defaultTimeZone);
}
}
private static AndroidJavaObject getInstance(string appId) {
using (AndroidJavaObject context = new AndroidJavaClass("com.unity3d.player.UnityPlayer").GetStatic<AndroidJavaObject>("currentActivity"))
{
AndroidJavaObject currentInstance;
if (string.IsNullOrEmpty(appId))
{
appId = default_appId;
}
if (light_instances != null && light_instances.ContainsKey(appId))
{
currentInstance = light_instances[appId];
}
else
{
currentInstance = sdkClass.CallStatic<AndroidJavaObject>("sharedInstance", context, appId);
}
if (currentInstance == null)
{
currentInstance = sdkClass.CallStatic<AndroidJavaObject>("sharedInstance", context, default_appId);
}
return currentInstance;
}
}
private static void enableLog(bool enable) {
sdkClass.CallStatic("enableTrackLog", enable);
}
private static void setVersionInfo(string libName, string version) {
sdkClass.CallStatic("setCustomerLibInfo", libName, version);
}
private static void init(TDConfig token)
{
AndroidJavaObject context = new AndroidJavaClass("com.unity3d.player.UnityPlayer").GetStatic<AndroidJavaObject>("currentActivity");
// AndroidJavaObject config = null;
// if (!string.IsNullOrEmpty(token.GetInstanceName()))
// {
// config = configClass.CallStatic<AndroidJavaObject>("getInstance", context, token.appid, token.serverUrl, token.GetInstanceName());
// if (string.IsNullOrEmpty(default_appId)) default_appId = token.GetInstanceName();
// }
// else
// {
// config = configClass.CallStatic<AndroidJavaObject>("getInstance", context, token.appid, token.serverUrl);
// if (string.IsNullOrEmpty(default_appId)) default_appId = token.appid;
// }
// config.Call("setModeInt", (int) token.mode);
// string timeZoneId = token.getTimeZoneId();
// if (null != timeZoneId && timeZoneId.Length > 0)
// {
// AndroidJavaObject timeZone = new AndroidJavaClass("java.util.TimeZone").CallStatic<AndroidJavaObject>("getTimeZone", timeZoneId);
// if (null != timeZone)
// {
// config.Call("setDefaultTimeZone", timeZone);
// }
// }
// if (token.enableEncrypt == true)
// {
// config.Call("enableEncrypt", true);
// AndroidJavaObject secreteKey = new AndroidJavaObject("cn.thinkingdata.android.encrypt.TDSecreteKey", token.encryptPublicKey, token.encryptVersion, "AES", "RSA");
// config.Call("setSecretKey", secreteKey);
// }
// sdkClass.CallStatic<AndroidJavaObject>("sharedInstance", config);
if (string.IsNullOrEmpty(default_appId)) default_appId = token.appId;
Dictionary<string, object> configDic = new Dictionary<string, object>();
configDic["appId"] = token.appId;
configDic["serverUrl"] = token.serverUrl;
configDic["mode"] = (int) token.mode;
if (!string.IsNullOrEmpty(token.name))
{
// if (string.IsNullOrEmpty(default_appId)) default_appId = token.GetInstanceName();
configDic["instanceName"] = token.name;
}
else
{
// if (string.IsNullOrEmpty(default_appId)) default_appId = token.appid;
}
string timeZoneId = token.getTimeZoneId();
defaultTDTimeZone = token.timeZone;
if (null != timeZoneId && timeZoneId.Length > 0)
{
configDic["timeZone"] = timeZoneId;
if (defaultTimeZone == null)
{
try
{
defaultTimeZone = TimeZoneInfo.FindSystemTimeZoneById(timeZoneId);
}
catch (Exception)
{
}
}
}
else {
if (defaultTimeZone == null) {
defaultTimeZone = TimeZoneInfo.Local;
}
}
if (token.enableEncrypt == true)
{
configDic["enableEncrypt"] = true;
configDic["secretKey"] = new Dictionary<string, object>() {
{"publicKey", token.encryptPublicKey},
{"version", token.encryptVersion},
{"symmetricEncryption", "AES"},
{"asymmetricEncryption", "RSA"},
};
}
unityAPIInstance.Call("sharedInstance", context, TDMiniJson.Serialize(configDic));
}
private static void flush(string appId)
{
getInstance(appId).Call("flush");
}
private static AndroidJavaObject getDate(DateTime dateTime)
{
long dateTimeTicksUTC = TimeZoneInfo.ConvertTimeToUtc(dateTime).Ticks;
DateTime dtFrom = new DateTime(1970, 1, 1, 0, 0, 0, 0, DateTimeKind.Utc);
long currentMillis = (dateTimeTicksUTC - dtFrom.Ticks) / 10000;
return new AndroidJavaObject("java.util.Date", currentMillis);
}
private static void track(string eventName, Dictionary<string, object> properties, DateTime dateTime, string appId)
{
AndroidJavaObject date = getDate(dateTime);
AndroidJavaClass tzClass = new AndroidJavaClass("java.util.TimeZone");
AndroidJavaObject tz = null;
AndroidJavaObject javaProperties = getJSONObject(properties);
try
{
getInstance(appId).Call("track", eventName, javaProperties, date, tz);
}
catch (Exception e)
{
if (TDLog.GetEnable()) TDLog.w("ThinkingAnalytics: unexpected exception: " + e);
}
finally {
if (date != null) {
date.Dispose();
}
if (tzClass != null) {
tzClass.Dispose();
}
if (javaProperties != null) {
javaProperties.Dispose();
}
}
}
private static void track(string eventName, Dictionary<string, object> properties, DateTime dateTime, TimeZoneInfo timeZone, string appId)
{
AndroidJavaObject date = getDate(dateTime);
AndroidJavaClass tzClass = new AndroidJavaClass("java.util.TimeZone");
AndroidJavaObject tz = null;
AndroidJavaObject javaProperties = getJSONObject(properties);
if (null != timeZone && null != timeZone.Id && timeZone.Id.Length > 0)
{
if ("Local" == timeZone.Id) {
tz = tzClass.CallStatic<AndroidJavaObject>("getDefault");
}
else {
tz = tzClass.CallStatic<AndroidJavaObject>("getTimeZone", timeZone.Id);
}
}
try
{
getInstance(appId).Call("track", eventName, javaProperties, date, tz);
}
catch (Exception e)
{
if (TDLog.GetEnable()) TDLog.w("ThinkingAnalytics: unexpected exception: " + e);
}
finally {
if (date != null) {
date.Dispose();
}
if (tzClass != null) {
tzClass.Dispose();
}
if (tz != null) {
tz.Dispose();
}
if (javaProperties != null) {
javaProperties.Dispose();
}
}
}
private static void trackForAll(string eventName, Dictionary<string, object> properties)
{
string appId = "";
track(eventName, properties, appId);
}
private static void track(TDEventModel taEvent, string appId)
{
AndroidJavaObject javaEvent = null;
AndroidJavaObject javaProperties = getJSONObject(getFinalEventProperties(taEvent.Properties));
switch (taEvent.EventType)
{
case TDEventModel.TDEventType.First:
javaEvent = new AndroidJavaObject("cn.thinkingdata.analytics.TDFirstEvent",
taEvent.EventName, javaProperties);
string extraId = taEvent.GetEventId();
if (!string.IsNullOrEmpty(extraId))
{
javaEvent.Call("setFirstCheckId", extraId);
}
break;
case TDEventModel.TDEventType.Updatable:
javaEvent = new AndroidJavaObject("cn.thinkingdata.analytics.TDUpdatableEvent",
taEvent.EventName, javaProperties, taEvent.GetEventId());
break;
case TDEventModel.TDEventType.Overwritable:
javaEvent = new AndroidJavaObject("cn.thinkingdata.analytics.TDOverWritableEvent",
taEvent.EventName, javaProperties, taEvent.GetEventId());
break;
}
if (null == javaEvent) {
if(TDLog.GetEnable()) TDLog.w("Unexpected java event object. Returning...");
return;
}
AndroidJavaObject date = getDate(taEvent.GetEventTime());
AndroidJavaClass tzClass = new AndroidJavaClass("java.util.TimeZone");
AndroidJavaObject tz = null;
if (taEvent.GetEventTime() != null && taEvent.GetEventTime() != DateTime.MinValue) {
if (taEvent.GetEventTimeZone() != null) {
if ("Local" == taEvent.GetEventTimeZone().Id) {
tz = tzClass.CallStatic<AndroidJavaObject>("getDefault");
}
else {
tz = tzClass.CallStatic<AndroidJavaObject>("getTimeZone", taEvent.GetEventTimeZone().Id);
}
javaEvent.Call("setEventTime", date, tz);
}
else
{
javaEvent.Call("setEventTime", date);
}
}
try
{
getInstance(appId).Call("track", javaEvent);
}
catch (Exception e)
{
if (TDLog.GetEnable()) TDLog.w("ThinkingAnalytics: unexpected exception: " + e);
}
finally {
if (date != null) {
date.Dispose();
}
if (tzClass != null) {
tzClass.Dispose();
}
if (tz != null) {
tz.Dispose();
}
if (javaProperties != null) {
javaProperties.Dispose();
}
if (javaEvent != null) {
javaEvent.Dispose();
}
}
}
private static void track(string eventName, Dictionary<string, object> properties, string appId)
{
AndroidJavaObject javaProperties = getJSONObject(properties);
try
{
getInstance(appId).Call("track", eventName, javaProperties);
}
catch (Exception e)
{
if (TDLog.GetEnable()) TDLog.w("ThinkingAnalytics: unexpected exception: " + e);
}
finally {
if (javaProperties != null) {
javaProperties.Dispose();
}
}
}
private static void setSuperProperties(Dictionary<string, object> superProperties, string appId)
{
AndroidJavaObject javaProperties = getJSONObject(superProperties);
try
{
getInstance(appId).Call("setSuperProperties", getJSONObject(superProperties));
}
catch (Exception e)
{
if (TDLog.GetEnable()) TDLog.w("ThinkingAnalytics: unexpected exception: " + e);
}
finally {
if (javaProperties != null) {
javaProperties.Dispose();
}
}
}
private static void unsetSuperProperty(string superPropertyName, string appId)
{
getInstance(appId).Call("unsetSuperProperty", superPropertyName);
}
private static void clearSuperProperty(string appId)
{
getInstance(appId).Call("clearSuperProperties");
}
private static Dictionary<string, object> getSuperProperties(string appId)
{
Dictionary<string, object> result = null;
AndroidJavaObject superPropertyObject = getInstance(appId).Call<AndroidJavaObject>("getSuperProperties");
try
{
if (null != superPropertyObject)
{
string superPropertiesString = superPropertyObject.Call<string>("toString");
result = TDMiniJson.Deserialize(superPropertiesString);
}
}
catch (Exception e)
{
if (TDLog.GetEnable()) TDLog.w("ThinkingAnalytics: unexpected exception: " + e);
}
finally {
if (superPropertyObject != null) {
superPropertyObject.Dispose();
}
}
return result;
}
private static Dictionary<string, object> getPresetProperties(string appId)
{
Dictionary<string, object> result = null;
AndroidJavaObject presetPropertyObject = getInstance(appId).Call<AndroidJavaObject>("getPresetProperties").Call<AndroidJavaObject>("toEventPresetProperties");
try
{
if (null != presetPropertyObject)
{
string presetPropertiesString = presetPropertyObject.Call<string>("toString");
result = TDMiniJson.Deserialize(presetPropertiesString);
}
}
catch (Exception e)
{
if (TDLog.GetEnable()) TDLog.w("ThinkingAnalytics: unexpected exception: " + e);
}
finally {
if (presetPropertyObject != null) {
presetPropertyObject.Dispose();
}
}
return result;
}
private static void timeEvent(string eventName, string appId)
{
getInstance(appId).Call("timeEvent", eventName);
}
private static void timeEventForAll(string eventName)
{
getInstance("").Call("timeEvent", eventName);
}
private static void identify(string uniqueId, string appId)
{
getInstance(appId).Call("identify", uniqueId);
}
private static string getDistinctId(string appId)
{
return getInstance(appId).Call<string>("getDistinctId");
}
private static void login(string uniqueId, string appId)
{
getInstance(appId).Call("login", uniqueId);
}
private static void userSetOnce(Dictionary<string, object> properties, string appId)
{
AndroidJavaObject javaProperties = getJSONObject(properties);
try
{
getInstance(appId).Call("user_setOnce", javaProperties);
}
catch (Exception e)
{
if (TDLog.GetEnable()) TDLog.w("ThinkingAnalytics: unexpected exception: " + e);
}
finally {
if (javaProperties != null) {
javaProperties.Dispose();
}
}
}
private static void userSetOnce(Dictionary<string, object> properties, DateTime dateTime, string appId)
{
AndroidJavaObject javaProperties = getJSONObject(properties);
AndroidJavaObject date = getDate(dateTime);
try
{
getInstance(appId).Call("user_setOnce", javaProperties, date);
}
catch (Exception e)
{
if (TDLog.GetEnable()) TDLog.w("ThinkingAnalytics: unexpected exception: " + e);
}
finally {
if (javaProperties != null)
{
javaProperties.Dispose();
}
if (date != null) {
date.Dispose();
}
}
}
private static void userSet(Dictionary<string, object> properties, string appId)
{
AndroidJavaObject javaProperties = getJSONObject(properties);
try
{
getInstance(appId).Call("user_set", javaProperties);
}
catch (Exception e)
{
if (TDLog.GetEnable()) TDLog.w("ThinkingAnalytics: unexpected exception: " + e);
}
finally {
if (javaProperties != null)
{
javaProperties.Dispose();
}
}
}
private static void userSet(Dictionary<string, object> properties, DateTime dateTime, string appId)
{
AndroidJavaObject javaProperties = getJSONObject(properties);
AndroidJavaObject date = getDate(dateTime);
try
{
getInstance(appId).Call("user_set", javaProperties, date);
}
catch (Exception e)
{
if (TDLog.GetEnable()) TDLog.w("ThinkingAnalytics: unexpected exception: " + e);
}
finally {
if (javaProperties != null)
{
javaProperties.Dispose();
}
if (date != null)
{
date.Dispose();
}
}
}
private static void userUnset(List<string> properties, string appId)
{
userUnset(properties, DateTime.Now, appId);
}
private static void userUnset(List<string> properties, DateTime dateTime, string appId)
{
Dictionary<string, object> finalProperties = new Dictionary<string, object>();
foreach(string s in properties)
{
finalProperties.Add(s, 0);
}
AndroidJavaObject javaProperties = getJSONObject(finalProperties);
AndroidJavaObject date = getDate(dateTime);
try
{
getInstance(appId).Call("user_unset", javaProperties, date);
}
catch (Exception e)
{
if (TDLog.GetEnable()) TDLog.w("ThinkingAnalytics: unexpected exception: " + e);
}
finally {
if (javaProperties != null)
{
javaProperties.Dispose();
}
if (date != null)
{
date.Dispose();
}
}
}
private static void userAdd(Dictionary<string, object> properties, string appId)
{
AndroidJavaObject javaProperties = getJSONObject(properties);
try
{
getInstance(appId).Call("user_add", javaProperties);
}
catch (Exception e)
{
if (TDLog.GetEnable()) TDLog.w("ThinkingAnalytics: unexpected exception: " + e);
}
finally {
if (javaProperties != null)
{
javaProperties.Dispose();
}
}
}
private static void userAdd(Dictionary<string, object> properties, DateTime dateTime, string appId)
{
AndroidJavaObject javaProperties = getJSONObject(properties);
AndroidJavaObject date = getDate(dateTime);
try
{
getInstance(appId).Call("user_add", javaProperties, date);
}
catch (Exception e)
{
if (TDLog.GetEnable()) TDLog.w("ThinkingAnalytics: unexpected exception: " + e);
}
finally {
if (javaProperties != null)
{
javaProperties.Dispose();
}
if (date != null)
{
date.Dispose();
}
}
}
private static void userAppend(Dictionary<string, object> properties, string appId)
{
AndroidJavaObject javaProperties = getJSONObject(properties);
try
{
getInstance(appId).Call("user_append", javaProperties);
}
catch (Exception e)
{
if (TDLog.GetEnable()) TDLog.w("ThinkingAnalytics: unexpected exception: " + e);
}
finally {
if (javaProperties != null)
{
javaProperties.Dispose();
}
}
}
private static void userAppend(Dictionary<string, object> properties, DateTime dateTime, string appId)
{
AndroidJavaObject javaProperties = getJSONObject(properties);
AndroidJavaObject date = getDate(dateTime);
try
{
getInstance(appId).Call("user_append", javaProperties, date);
}
catch (Exception e)
{
if (TDLog.GetEnable()) TDLog.w("ThinkingAnalytics: unexpected exception: " + e);
}
finally {
if (javaProperties != null)
{
javaProperties.Dispose();
}
if (date != null)
{
date.Dispose();
}
}
}
private static void userUniqAppend(Dictionary<string, object> properties, string appId)
{
AndroidJavaObject javaProperties = getJSONObject(properties);
try
{
getInstance(appId).Call("user_uniqAppend", javaProperties);
}
catch (Exception e)
{
if (TDLog.GetEnable()) TDLog.w("ThinkingAnalytics: unexpected exception: " + e);
}
finally {
if (javaProperties != null)
{
javaProperties.Dispose();
}
}
}
private static void userUniqAppend(Dictionary<string, object> properties, DateTime dateTime, string appId)
{
AndroidJavaObject javaProperties = getJSONObject(properties);
AndroidJavaObject date = getDate(dateTime);
try
{
getInstance(appId).Call("user_uniqAppend", javaProperties, date);
}
catch (Exception e)
{
if (TDLog.GetEnable()) TDLog.w("ThinkingAnalytics: unexpected exception: " + e);
}
finally {
if (javaProperties != null)
{
javaProperties.Dispose();
}
if (date != null)
{
date.Dispose();
}
}
}
private static void userDelete(string appId)
{
getInstance(appId).Call("user_delete");
}
private static void userDelete(DateTime dateTime, string appId)
{
AndroidJavaObject date = getDate(dateTime);
try
{
getInstance(appId).Call("user_delete", date);
}
catch (Exception e)
{
if (TDLog.GetEnable()) TDLog.w("ThinkingAnalytics: unexpected exception: " + e);
}
finally {
if (date != null)
{
date.Dispose();
}
}
}
private static void logout(string appId)
{
getInstance(appId).Call("logout");
}
private static string getDeviceId()
{
return getInstance(default_appId).Call<string>("getDeviceId");
}
private static void setDynamicSuperProperties(TDDynamicSuperPropertiesHandler dynamicSuperProperties, string appId)
{
DynamicListenerAdapter listenerAdapter = new DynamicListenerAdapter();
if (string.IsNullOrEmpty(appId))
{
appId = default_appId;
}
unityAPIInstance.Call("setDynamicSuperPropertiesTrackerListener", appId, listenerAdapter);
}
private static void setNetworkType(TDNetworkType networkType) {
Dictionary<string, object> properties = new Dictionary<string, object>() { };
switch (networkType)
{
case TDNetworkType.Wifi:
properties["network_type"] = 1;
break;
case TDNetworkType.All:
properties["network_type"] = 2;
break;
default:
properties["network_type"] = 2;
break;
}
unityAPIInstance.Call("setNetworkType", TDMiniJson.Serialize(properties));
}
private static void enableAutoTrack(TDAutoTrackEventType events, Dictionary<string, object> properties, string appId)
{
if (string.IsNullOrEmpty(appId))
{
appId = default_appId;
}
Dictionary<string, object> propertiesNew = new Dictionary<string, object>() {
{ "appId", appId},
{ "autoTrackType", (int)events}
};
unityAPIInstance.Call("enableAutoTrack", TDMiniJson.Serialize(propertiesNew));
propertiesNew["properties"] = properties;
unityAPIInstance.Call("setAutoTrackProperties", TDMiniJson.Serialize(propertiesNew));
}
private static void enableAutoTrack(TDAutoTrackEventType events, TDAutoTrackEventHandler eventCallback, string appId)
{
AutoTrackListenerAdapter listenerAdapter = new AutoTrackListenerAdapter();
if (string.IsNullOrEmpty(appId))
{
appId = default_appId;
}
Dictionary<string, object> properties = new Dictionary<string, object>() {
{ "appId", appId},
{ "autoTrackType", (int)events}
};
unityAPIInstance.Call("enableAutoTrack", TDMiniJson.Serialize(properties), listenerAdapter);
}
private static void setAutoTrackProperties(TDAutoTrackEventType events, Dictionary<string, object> properties, string appId)
{
if (string.IsNullOrEmpty(appId))
{
appId = default_appId;
}
Dictionary<string, object> propertiesNew = new Dictionary<string, object>() {
{ "appId", appId},
{ "autoTrackType", (int)events}
};
propertiesNew["properties"] = properties;
unityAPIInstance.Call("setAutoTrackProperties", TDMiniJson.Serialize(propertiesNew));
}
private static void setTrackStatus(TDTrackStatus status, string appId)
{
AndroidJavaClass javaClass = new AndroidJavaClass("cn.thinkingdata.analytics.ThinkingAnalyticsSDK$TATrackStatus");
AndroidJavaObject trackStatus;
switch (status)
{
case TDTrackStatus.Pause:
trackStatus = javaClass.GetStatic<AndroidJavaObject>("PAUSE");
break;
case TDTrackStatus.Stop:
trackStatus = javaClass.GetStatic<AndroidJavaObject>("STOP");
break;
case TDTrackStatus.SaveOnly:
trackStatus = javaClass.GetStatic<AndroidJavaObject>("SAVE_ONLY");
break;
case TDTrackStatus.Normal:
default:
trackStatus = javaClass.GetStatic<AndroidJavaObject>("NORMAL");
break;
}
getInstance(appId).Call("setTrackStatus", trackStatus);
}
private static void optOutTracking(string appId)
{
getInstance(appId).Call("optOutTracking");
}
private static void optOutTrackingAndDeleteUser(string appId)
{
getInstance(appId).Call("optOutTrackingAndDeleteUser");
}
private static void optInTracking(string appId)
{
getInstance(appId).Call("optInTracking");
}
private static void enableTracking(bool enabled, string appId)
{
getInstance(appId).Call("enableTracking", enabled);
}
private static string createLightInstance()
{
string randomID = System.Guid.NewGuid().ToString("N");
AndroidJavaObject lightInstance = getInstance(default_appId).Call<AndroidJavaObject>("createLightInstance");
if (light_instances == null) {
light_instances = new Dictionary<string, AndroidJavaObject>();
}
light_instances.Add(randomID, lightInstance);
return randomID;
}
private static void calibrateTime(long timestamp)
{
sdkClass.CallStatic("calibrateTime", timestamp);
}
private static void calibrateTimeWithNtp(string ntpServer)
{
unityAPIInstance.Call("calibrateTimeWithNtp", ntpServer);
}
private static void enableThirdPartySharing(TDThirdPartyType shareType, Dictionary<string, object> properties, string appId)
{
Dictionary<string, object> obj = new Dictionary<string, object>() {
{ "appId", appId },
{ "type", (int)shareType }
};
obj["properties"] = properties;
unityAPIInstance.Call("enableThirdPartySharing", TDMiniJson.Serialize(obj));
}
//dynamic super properties
public interface IDynamicSuperPropertiesTrackerListener
{
string getDynamicSuperPropertiesString();
}
private class DynamicListenerAdapter : AndroidJavaProxy {
public DynamicListenerAdapter() : base("cn.thinkingdata.engine.ThinkingAnalyticsUnityAPI$DynamicSuperPropertiesTrackerListener") {}
public string getDynamicSuperPropertiesString()
{
Dictionary<string, object> ret;
if (TDWrapper.mDynamicSuperProperties != null) {
ret = TDWrapper.mDynamicSuperProperties.GetDynamicSuperProperties();
}
else {
ret = new Dictionary<string, object>();
}
//return TDMiniJson.Serialize(ret);
return serilize(ret);
}
}
//auto-tracking
public interface IAutoTrackEventTrackerListener
{
string eventCallback(int type, string appId, string properties);
}
private class AutoTrackListenerAdapter : AndroidJavaProxy {
public AutoTrackListenerAdapter() : base("cn.thinkingdata.engine.ThinkingAnalyticsUnityAPI$AutoTrackEventTrackerListener") {}
string eventCallback(int type, string appId, string properties)
{
Dictionary<string, object> ret;
if (string.IsNullOrEmpty(appId)) appId = default_appId;
if (TDWrapper.mAutoTrackEventCallbacks.ContainsKey(appId))
{
Dictionary<string, object> propertiesDic = TDMiniJson.Deserialize(properties);
ret = TDWrapper.mAutoTrackEventCallbacks[appId].GetAutoTrackEventProperties(type, propertiesDic);
}
else {
ret = new Dictionary<string, object>();
}
return serilize(ret);
}
}
}
}
#endif

11
sdk-intergration/Packages/TA/Runtime/ThinkingAnalytics/Wrapper/TDAndroidWrapper.cs.meta Normal file
View File

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

415
sdk-intergration/Packages/TA/Runtime/ThinkingAnalytics/Wrapper/TDPCWrapper.cs Normal file
View File

@@ -0,0 +1,415 @@
#if ((!(UNITY_IOS) || UNITY_EDITOR) && (!(UNITY_ANDROID) || UNITY_EDITOR)) || TE_DISABLE_ANDROID_JAVA || TE_DISABLE_IOS_OC
using System;
using System.Collections.Generic;
using ThinkingData.Analytics.Utils;
using ThinkingSDK.PC.Main;
using ThinkingSDK.PC.Utils;
using ThinkingSDK.PC.DataModel;
using ThinkingSDK.PC.Config;
namespace ThinkingData.Analytics.Wrapper
{
public partial class TDWrapper : TDDynamicSuperPropertiesHandler_PC, TDAutoTrackEventHandler_PC
{
static TDAutoTrackEventHandler mEventCallback;
public Dictionary<string, object> GetDynamicSuperProperties_PC()
{
if (mDynamicSuperProperties != null)
{
return mDynamicSuperProperties.GetDynamicSuperProperties();
}
else
{
return new Dictionary<string, object>();
}
}
public Dictionary<string, object> AutoTrackEventCallback_PC(int type, Dictionary<string, object> properties)
{
if (mEventCallback != null)
{
return mEventCallback.GetAutoTrackEventProperties(type, properties);
}
else
{
return new Dictionary<string, object>();
}
}
private static void init(TDConfig token)
{
ThinkingSDKConfig config = ThinkingSDKConfig.GetInstance(token.appId, token.serverUrl, token.name);
if (!string.IsNullOrEmpty(token.getTimeZoneId()))
{
try
{
config.SetTimeZone(TimeZoneInfo.FindSystemTimeZoneById(token.getTimeZoneId()));
}
catch (Exception)
{
//if (ThinkingSDKPublicConfig.IsPrintLog()) ThinkingSDKLogger.Print("TimeZoneInfo set failed : " + e.Message);
}
}
if (token.mode == TDMode.Debug)
{
config.SetMode(Mode.DEBUG);
}
else if (token.mode == TDMode.DebugOnly)
{
config.SetMode(Mode.DEBUG_ONLY);
}
ThinkingPCSDK.Init(token.appId, token.serverUrl, token.name, config, sMono);
}
private static void identify(string uniqueId, string appId)
{
ThinkingPCSDK.Identifiy(uniqueId, appId);
}
private static string getDistinctId(string appId)
{
return ThinkingPCSDK.DistinctId(appId);
}
private static void login(string accountId, string appId)
{
ThinkingPCSDK.Login(accountId, appId);
}
private static void logout(string appId)
{
ThinkingPCSDK.Logout(appId);
}
private static void flush(string appId)
{
ThinkingPCSDK.Flush(appId);
}
private static void setVersionInfo(string lib_name, string lib_version)
{
ThinkingPCSDK.SetLibName(lib_name);
ThinkingPCSDK.SetLibVersion(lib_version);
}
private static void track(TDEventModel taEvent, string appId)
{
ThinkingSDKEventData eventData = null;
switch (taEvent.EventType)
{
case TDEventModel.TDEventType.First:
{
eventData = new ThinkingSDKFirstEvent(taEvent.EventName);
if (!string.IsNullOrEmpty(taEvent.GetEventId()))
{
((ThinkingSDKFirstEvent)eventData).SetFirstCheckId(taEvent.GetEventId());
}
}
break;
case TDEventModel.TDEventType.Updatable:
eventData = new ThinkingSDKUpdateEvent(taEvent.EventName, taEvent.GetEventId());
break;
case TDEventModel.TDEventType.Overwritable:
eventData = new ThinkingSDKOverWritableEvent(taEvent.EventName, taEvent.GetEventId());
break;
}
if (mDynamicSuperProperties != null)
{
eventData.SetProperties(mDynamicSuperProperties.GetDynamicSuperProperties());
}
if (taEvent.Properties != null)
{
eventData.SetProperties(taEvent.Properties);
}
if (taEvent.GetEventTime() != null && taEvent.GetEventTimeZone() != null)
{
eventData.SetEventTime(taEvent.GetEventTime());
eventData.SetTimeZone(taEvent.GetEventTimeZone());
}
ThinkingPCSDK.Track(eventData, appId);
}
private static void track(string eventName, Dictionary<string, object> properties, string appId)
{
ThinkingPCSDK.Track(eventName, properties, appId);
}
private static void track(string eventName, Dictionary<string, object> properties, DateTime dateTime, string appId)
{
ThinkingPCSDK.Track(eventName, properties, dateTime, appId);
}
private static void track(string eventName, Dictionary<string, object> properties, DateTime dateTime, TimeZoneInfo timeZone, string appId)
{
ThinkingPCSDK.Track(eventName, properties, dateTime, timeZone, appId);
}
private static void trackForAll(string eventName, Dictionary<string, object> properties)
{
ThinkingPCSDK.TrackForAll(eventName, properties);
}
private static void setSuperProperties(Dictionary<string, object> superProperties, string appId)
{
ThinkingPCSDK.SetSuperProperties(superProperties, appId);
}
private static void unsetSuperProperty(string superPropertyName, string appId)
{
ThinkingPCSDK.UnsetSuperProperty(superPropertyName, appId);
}
private static void clearSuperProperty(string appId)
{
ThinkingPCSDK.ClearSuperProperties(appId);
}
private static Dictionary<string, object> getSuperProperties(string appId)
{
return ThinkingPCSDK.SuperProperties(appId);
}
private static Dictionary<string, object> getPresetProperties(string appId)
{
return ThinkingPCSDK.PresetProperties(appId);
}
private static void timeEvent(string eventName, string appId)
{
ThinkingPCSDK.TimeEvent(eventName, appId);
}
private static void timeEventForAll(string eventName)
{
ThinkingPCSDK.TimeEventForAll(eventName);
}
private static void userSet(Dictionary<string, object> properties, string appId)
{
ThinkingPCSDK.UserSet(properties, appId);
}
private static void userSet(Dictionary<string, object> properties, DateTime dateTime, string appId)
{
ThinkingPCSDK.UserSet(properties, dateTime, appId);
}
private static void userUnset(List<string> properties, string appId)
{
ThinkingPCSDK.UserUnset(properties, appId);
}
private static void userUnset(List<string> properties, DateTime dateTime, string appId)
{
ThinkingPCSDK.UserUnset(properties, dateTime, appId);
}
private static void userSetOnce(Dictionary<string, object> properties, string appId)
{
ThinkingPCSDK.UserSetOnce(properties, appId);
}
private static void userSetOnce(Dictionary<string, object> properties, DateTime dateTime, string appId)
{
ThinkingPCSDK.UserSetOnce(properties, dateTime, appId);
}
private static void userAdd(Dictionary<string, object> properties, string appId)
{
ThinkingPCSDK.UserAdd(properties, appId);
}
private static void userAdd(Dictionary<string, object> properties, DateTime dateTime, string appId)
{
ThinkingPCSDK.UserAdd(properties, dateTime, appId);
}
private static void userDelete(string appId)
{
ThinkingPCSDK.UserDelete(appId);
}
private static void userDelete(DateTime dateTime, string appId)
{
ThinkingPCSDK.UserDelete(dateTime, appId);
}
private static void userAppend(Dictionary<string, object> properties, string appId)
{
ThinkingPCSDK.UserAppend(properties, appId);
}
private static void userAppend(Dictionary<string, object> properties, DateTime dateTime, string appId)
{
ThinkingPCSDK.UserAppend(properties, dateTime, appId);
}
private static void userUniqAppend(Dictionary<string, object> properties, string appId)
{
ThinkingPCSDK.UserUniqAppend(properties, appId);
}
private static void userUniqAppend(Dictionary<string, object> properties, DateTime dateTime, string appId)
{
ThinkingPCSDK.UserUniqAppend(properties, dateTime, appId);
}
private static void setNetworkType(TDNetworkType networkType)
{
}
private static string getDeviceId()
{
return ThinkingPCSDK.GetDeviceId();
}
private static void setDynamicSuperProperties(TDDynamicSuperPropertiesHandler dynamicSuperProperties, string appId)
{
ThinkingPCSDK.SetDynamicSuperProperties(new TDWrapper());
}
private static void setTrackStatus(TDTrackStatus status, string appId)
{
ThinkingPCSDK.SetTrackStatus((ThinkingSDK.PC.Main.TDTrackStatus)status, appId);
}
private static void optOutTracking(string appId)
{
ThinkingPCSDK.OptTracking(false, appId);
}
private static void optOutTrackingAndDeleteUser(string appId)
{
ThinkingPCSDK.OptTrackingAndDeleteUser(appId);
}
private static void optInTracking(string appId)
{
ThinkingPCSDK.OptTracking(true, appId);
}
private static void enableTracking(bool enabled, string appId)
{
ThinkingPCSDK.EnableTracking(enabled);
}
private static string createLightInstance()
{
return ThinkingPCSDK.CreateLightInstance();
}
private static string getTimeString(DateTime dateTime)
{
return ThinkingPCSDK.TimeString(dateTime);
}
private static void enableAutoTrack(TDAutoTrackEventType autoTrackEvents, Dictionary<string, object> properties, string appId)
{
ThinkingSDK.PC.Main.TDAutoTrackEventType pcAutoTrackEvents = ThinkingSDK.PC.Main.TDAutoTrackEventType.None;
if ((autoTrackEvents & TDAutoTrackEventType.AppInstall) != 0)
{
pcAutoTrackEvents = pcAutoTrackEvents | ThinkingSDK.PC.Main.TDAutoTrackEventType.AppInstall;
}
if ((autoTrackEvents & TDAutoTrackEventType.AppStart) != 0)
{
pcAutoTrackEvents = pcAutoTrackEvents | ThinkingSDK.PC.Main.TDAutoTrackEventType.AppStart;
}
if ((autoTrackEvents & TDAutoTrackEventType.AppEnd) != 0)
{
pcAutoTrackEvents = pcAutoTrackEvents | ThinkingSDK.PC.Main.TDAutoTrackEventType.AppEnd;
}
if ((autoTrackEvents & TDAutoTrackEventType.AppCrash) != 0)
{
pcAutoTrackEvents = pcAutoTrackEvents | ThinkingSDK.PC.Main.TDAutoTrackEventType.AppCrash;
}
if ((autoTrackEvents & TDAutoTrackEventType.AppSceneLoad) != 0)
{
pcAutoTrackEvents = pcAutoTrackEvents | ThinkingSDK.PC.Main.TDAutoTrackEventType.AppSceneLoad;
}
if ((autoTrackEvents & TDAutoTrackEventType.AppSceneUnload) != 0)
{
pcAutoTrackEvents = pcAutoTrackEvents | ThinkingSDK.PC.Main.TDAutoTrackEventType.AppSceneUnload;
}
ThinkingPCSDK.EnableAutoTrack(pcAutoTrackEvents, properties, appId);
}
private static void enableAutoTrack(TDAutoTrackEventType autoTrackEvents, TDAutoTrackEventHandler eventCallback, string appId)
{
ThinkingSDK.PC.Main.TDAutoTrackEventType pcAutoTrackEvents = ThinkingSDK.PC.Main.TDAutoTrackEventType.None;
if ((autoTrackEvents & TDAutoTrackEventType.AppInstall) != 0)
{
pcAutoTrackEvents = pcAutoTrackEvents | ThinkingSDK.PC.Main.TDAutoTrackEventType.AppInstall;
}
if ((autoTrackEvents & TDAutoTrackEventType.AppStart) != 0)
{
pcAutoTrackEvents = pcAutoTrackEvents | ThinkingSDK.PC.Main.TDAutoTrackEventType.AppStart;
}
if ((autoTrackEvents & TDAutoTrackEventType.AppEnd) != 0)
{
pcAutoTrackEvents = pcAutoTrackEvents | ThinkingSDK.PC.Main.TDAutoTrackEventType.AppEnd;
}
if ((autoTrackEvents & TDAutoTrackEventType.AppCrash) != 0)
{
pcAutoTrackEvents = pcAutoTrackEvents | ThinkingSDK.PC.Main.TDAutoTrackEventType.AppCrash;
}
if ((autoTrackEvents & TDAutoTrackEventType.AppSceneLoad) != 0)
{
pcAutoTrackEvents = pcAutoTrackEvents | ThinkingSDK.PC.Main.TDAutoTrackEventType.AppSceneLoad;
}
if ((autoTrackEvents & TDAutoTrackEventType.AppSceneUnload) != 0)
{
pcAutoTrackEvents = pcAutoTrackEvents | ThinkingSDK.PC.Main.TDAutoTrackEventType.AppSceneUnload;
}
mEventCallback = eventCallback;
ThinkingPCSDK.EnableAutoTrack(pcAutoTrackEvents, new TDWrapper(), appId);
}
private static void setAutoTrackProperties(TDAutoTrackEventType autoTrackEvents, Dictionary<string, object> properties, string appId)
{
if ((autoTrackEvents & TDAutoTrackEventType.AppInstall) != 0)
{
ThinkingPCSDK.SetAutoTrackProperties(ThinkingSDK.PC.Main.TDAutoTrackEventType.AppInstall, properties, appId);
}
if ((autoTrackEvents & TDAutoTrackEventType.AppStart) != 0)
{
ThinkingPCSDK.SetAutoTrackProperties(ThinkingSDK.PC.Main.TDAutoTrackEventType.AppStart, properties, appId);
}
if ((autoTrackEvents & TDAutoTrackEventType.AppEnd) != 0)
{
ThinkingPCSDK.SetAutoTrackProperties(ThinkingSDK.PC.Main.TDAutoTrackEventType.AppEnd, properties, appId);
}
if ((autoTrackEvents & TDAutoTrackEventType.AppCrash) != 0)
{
ThinkingPCSDK.SetAutoTrackProperties(ThinkingSDK.PC.Main.TDAutoTrackEventType.AppCrash, properties, appId);
}
if ((autoTrackEvents & TDAutoTrackEventType.AppSceneLoad) != 0)
{
ThinkingPCSDK.SetAutoTrackProperties(ThinkingSDK.PC.Main.TDAutoTrackEventType.AppSceneLoad, properties, appId);
}
if ((autoTrackEvents & TDAutoTrackEventType.AppSceneUnload) != 0)
{
ThinkingPCSDK.SetAutoTrackProperties(ThinkingSDK.PC.Main.TDAutoTrackEventType.AppSceneUnload, properties, appId);
}
}
private static void enableLog(bool enable)
{
ThinkingPCSDK.EnableLog(enable);
}
private static void calibrateTime(long timestamp)
{
ThinkingPCSDK.CalibrateTime(timestamp);
}
private static void calibrateTimeWithNtp(string ntpServer)
{
ThinkingPCSDK.CalibrateTimeWithNtp(ntpServer);
}
private static void enableThirdPartySharing(TDThirdPartyType shareType, Dictionary<string, object> properties, string appId)
{
if (ThinkingSDKPublicConfig.IsPrintLog()) ThinkingSDKLogger.Print("Sharing data is not support on PC: " + shareType + ", " + properties + ", " + appId);
}
}
}
#endif

11
sdk-intergration/Packages/TA/Runtime/ThinkingAnalytics/Wrapper/TDPCWrapper.cs.meta Normal file
View File

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

472
sdk-intergration/Packages/TA/Runtime/ThinkingAnalytics/Wrapper/TDWrapper.cs Normal file
View File

@@ -0,0 +1,472 @@
using System;
using System.Collections.Generic;
using ThinkingData.Analytics.Utils;
using UnityEngine;
using UnityEngine.SceneManagement;
namespace ThinkingData.Analytics.Wrapper
{
public partial class TDWrapper
{
public static MonoBehaviour sMono;
private static TDDynamicSuperPropertiesHandler mDynamicSuperProperties;
private static Dictionary<string, TDAutoTrackEventHandler> mAutoTrackEventCallbacks = new Dictionary<string, TDAutoTrackEventHandler>();
private static Dictionary<string, Dictionary<string, object>> mAutoTrackProperties = new Dictionary<string, Dictionary<string, object>>();
private static Dictionary<string, TDAutoTrackEventType> mAutoTrackEventInfos = new Dictionary<string, TDAutoTrackEventType>();
private static System.Random rnd = new System.Random();
private static string default_appId = null;
// add Dictionary to Dictionary
public static void AddDictionary(Dictionary<string, object> originalDic, Dictionary<string, object> subDic)
{
if (originalDic != subDic)
{
foreach (KeyValuePair<string, object> kv in subDic)
{
originalDic[kv.Key] = kv.Value;
}
}
}
private static string serilize<T>(Dictionary<string, T> data) {
return TDMiniJson.Serialize(data, getTimeString);
}
public static void ShareInstance(TDConfig token, MonoBehaviour mono, bool initRequired = true)
{
sMono = mono;
if (string.IsNullOrEmpty(default_appId)) default_appId = token.appId;
if (initRequired) init(token);
}
public static void EnableLog(bool enable)
{
enableLog(enable);
}
public static void SetVersionInfo(string version)
{
setVersionInfo("Unity", version);
}
public static void SetDistinctId(string uniqueId, string appId)
{
identify(uniqueId, appId);
}
public static string GetDistinctId(string appId)
{
return getDistinctId(appId);
}
public static void Login(string accountId, string appId)
{
login(accountId, appId);
}
public static void Logout(string appId)
{
logout(appId);
}
public static void EnableAutoTrack(TDAutoTrackEventType events, Dictionary<string, object> properties, string appId)
{
if (string.IsNullOrEmpty(appId)) appId = default_appId;
UpdateAutoTrackSceneInfos(events, appId);
SetAutoTrackProperties(events, properties, appId);
enableAutoTrack(events, properties, appId);
if ((events & TDAutoTrackEventType.AppSceneLoad) != 0)
{
TrackSceneLoad(SceneManager.GetActiveScene(), appId);
}
}
public static void EnableAutoTrack(TDAutoTrackEventType events, TDAutoTrackEventHandler eventCallback, string appId)
{
if (string.IsNullOrEmpty(appId)) appId = default_appId;
UpdateAutoTrackSceneInfos(events, appId);
mAutoTrackEventCallbacks[appId] = eventCallback;
//mAutoTrackEventCallback = eventCallback;
enableAutoTrack(events, eventCallback, appId);
if ((events & TDAutoTrackEventType.AppSceneLoad) != 0)
{
TrackSceneLoad(SceneManager.GetActiveScene(), appId);
}
}
private static string TDAutoTrackEventType_APP_SCENE_LOAD = "AppSceneLoad";
private static string TDAutoTrackEventType_APP_SCENE_UNLOAD = "AppSceneUnload";
public static void SetAutoTrackProperties(TDAutoTrackEventType events, Dictionary<string, object> properties, string appId)
{
if ((events & TDAutoTrackEventType.AppSceneLoad) != 0)
{
if (mAutoTrackProperties.ContainsKey(TDAutoTrackEventType_APP_SCENE_LOAD))
{
AddDictionary(mAutoTrackProperties[TDAutoTrackEventType_APP_SCENE_LOAD], properties);
}
else
mAutoTrackProperties[TDAutoTrackEventType_APP_SCENE_LOAD] = properties;
}
if ((events & TDAutoTrackEventType.AppSceneUnload) != 0)
{
if (mAutoTrackProperties.ContainsKey(TDAutoTrackEventType_APP_SCENE_UNLOAD))
{
AddDictionary(mAutoTrackProperties[TDAutoTrackEventType_APP_SCENE_UNLOAD], properties);
}
else
mAutoTrackProperties[TDAutoTrackEventType_APP_SCENE_UNLOAD] = properties;
}
setAutoTrackProperties(events, properties, appId);
}
public static void TrackSceneLoad(Scene scene, string appId = "")
{
Dictionary<string, object> properties = new Dictionary<string, object>() {
{ "#scene_name", scene.name },
{ "#scene_path", scene.path }
};
if (mAutoTrackProperties.ContainsKey(TDAutoTrackEventType_APP_SCENE_LOAD))
{
AddDictionary(properties, mAutoTrackProperties[TDAutoTrackEventType_APP_SCENE_LOAD]);
}
if (string.IsNullOrEmpty(appId))
{
foreach (var kv in mAutoTrackEventInfos)
{
Dictionary<string, object> finalProperties = new Dictionary<string, object>(properties);
if (mAutoTrackEventCallbacks.ContainsKey(kv.Key))
{
AddDictionary(finalProperties, mAutoTrackEventCallbacks[kv.Key].GetAutoTrackEventProperties((int)TDAutoTrackEventType.AppSceneLoad, properties));
}
if ((kv.Value & TDAutoTrackEventType.AppSceneLoad) != 0)
{
Track("ta_scene_loaded", finalProperties, kv.Key);
}
if ((kv.Value & TDAutoTrackEventType.AppSceneUnload) != 0)
{
TimeEvent("ta_scene_unloaded", kv.Key);
}
}
}
else
{
Dictionary<string, object> finalProperties = new Dictionary<string, object>(properties);
if (mAutoTrackEventCallbacks.ContainsKey(appId))
{
AddDictionary(finalProperties, mAutoTrackEventCallbacks[appId].GetAutoTrackEventProperties((int)TDAutoTrackEventType.AppSceneLoad, properties));
}
Track("ta_scene_loaded", finalProperties, appId);
TimeEvent("ta_scene_unloaded", appId);
}
}
public static void TrackSceneUnload(Scene scene, string appId = "")
{
Dictionary<string, object> properties = new Dictionary<string, object>() {
{ "#scene_name", scene.name },
{ "#scene_path", scene.path }
};
if (mAutoTrackProperties.ContainsKey(TDAutoTrackEventType_APP_SCENE_UNLOAD))
{
AddDictionary(properties, mAutoTrackProperties[TDAutoTrackEventType_APP_SCENE_UNLOAD]);
}
foreach (var kv in mAutoTrackEventInfos)
{
Dictionary<string, object> finalProperties = new Dictionary<string, object>(properties);
if (mAutoTrackEventCallbacks.ContainsKey(kv.Key))
{
AddDictionary(finalProperties, mAutoTrackEventCallbacks[kv.Key].GetAutoTrackEventProperties((int)TDAutoTrackEventType.AppSceneUnload, properties));
}
if ((kv.Value & TDAutoTrackEventType.AppSceneUnload) != 0)
{
Track("ta_scene_unloaded", finalProperties, kv.Key);
}
}
}
private static void UpdateAutoTrackSceneInfos(TDAutoTrackEventType events, string appId = "")
{
if (string.IsNullOrEmpty(appId)) appId = default_appId;
mAutoTrackEventInfos[appId] = events;
}
private static Dictionary<string, object> getFinalEventProperties(Dictionary<string, object> properties)
{
TDPropertiesChecker.CheckProperties(properties);
if (null != mDynamicSuperProperties)
{
Dictionary<string, object> finalProperties = new Dictionary<string, object>();
TDPropertiesChecker.MergeProperties(mDynamicSuperProperties.GetDynamicSuperProperties(), finalProperties);
TDPropertiesChecker.MergeProperties(properties, finalProperties);
return finalProperties;
}
else
{
return properties;
}
}
public static void Track(string eventName, Dictionary<string, object> properties, string appId)
{
TDPropertiesChecker.CheckString(eventName);
track(eventName, getFinalEventProperties(properties), appId);
}
public static void Track(string eventName, Dictionary<string, object> properties, DateTime datetime, string appId)
{
TDPropertiesChecker.CheckString(eventName);
track(eventName, getFinalEventProperties(properties), datetime, appId);
}
public static void Track(string eventName, Dictionary<string, object> properties, DateTime datetime, TimeZoneInfo timeZone, string appId)
{
TDPropertiesChecker.CheckString(eventName);
track(eventName, getFinalEventProperties(properties), datetime, timeZone, appId);
}
public static void TrackForAll(string eventName, Dictionary<string, object> properties)
{
TDPropertiesChecker.CheckString(eventName);
trackForAll(eventName, getFinalEventProperties(properties));
}
public static void Track(TDEventModel taEvent, string appId)
{
if (null == taEvent || null == taEvent.EventType)
{
if(TDLog.GetEnable()) TDLog.w("Ignoring invalid TA event");
return;
}
if (taEvent.GetEventTime() == null)
{
if(TDLog.GetEnable()) TDLog.w("ppp null...");
}
TDPropertiesChecker.CheckString(taEvent.EventName);
TDPropertiesChecker.CheckProperties(taEvent.Properties);
track(taEvent, appId);
}
public static void QuickTrack(string eventName, Dictionary<string, object> properties, string appId)
{
if ("SceneView" == eventName)
{
if (properties == null)
{
properties = new Dictionary<string, object>() { };
}
Scene scene = SceneManager.GetActiveScene();
if (scene != null)
{
properties.Add("#scene_name", scene.name);
properties.Add("#scene_path", scene.path);
}
Track("ta_scene_view", properties, appId);
}
else if ("AppClick" == eventName)
{
if (properties == null)
{
properties = new Dictionary<string, object>() { };
}
Track("ta_app_click", properties, appId);
}
}
public static void SetSuperProperties(Dictionary<string, object> superProperties, string appId)
{
TDPropertiesChecker.CheckProperties(superProperties);
setSuperProperties(superProperties, appId);
}
public static void UnsetSuperProperty(string superPropertyName, string appId)
{
TDPropertiesChecker.CheckString(superPropertyName);
unsetSuperProperty(superPropertyName, appId);
}
public static void ClearSuperProperty(string appId)
{
clearSuperProperty(appId);
}
public static void TimeEvent(string eventName, string appId)
{
TDPropertiesChecker.CheckString(eventName);
timeEvent(eventName, appId);
}
public static void TimeEventForAll(string eventName)
{
TDPropertiesChecker.CheckString(eventName);
timeEventForAll(eventName);
}
public static Dictionary<string, object> GetSuperProperties(string appId)
{
return getSuperProperties(appId);
}
public static Dictionary<string, object> GetPresetProperties(string appId)
{
return getPresetProperties(appId);
}
public static void UserSet(Dictionary<string, object> properties, string appId)
{
TDPropertiesChecker.CheckProperties(properties);
userSet(properties, appId);
}
public static void UserSet(Dictionary<string, object> properties, DateTime dateTime, string appId)
{
TDPropertiesChecker.CheckProperties(properties);
userSet(properties, dateTime, appId);
}
public static void UserSetOnce(Dictionary<string, object> properties, string appId)
{
TDPropertiesChecker.CheckProperties(properties);
userSetOnce(properties, appId);
}
public static void UserSetOnce(Dictionary<string, object> properties, DateTime dateTime, string appId)
{
TDPropertiesChecker.CheckProperties(properties);
userSetOnce(properties, dateTime, appId);
}
public static void UserUnset(List<string> properties, string appId)
{
TDPropertiesChecker.CheckProperties(properties);
userUnset(properties, appId);
}
public static void UserUnset(List<string> properties, DateTime dateTime, string appId)
{
TDPropertiesChecker.CheckProperties(properties);
userUnset(properties, dateTime, appId);
}
public static void UserAdd(Dictionary<string, object> properties, string appId)
{
TDPropertiesChecker.CheckProperties(properties);
userAdd(properties, appId);
}
public static void UserAdd(Dictionary<string, object> properties, DateTime dateTime, string appId)
{
TDPropertiesChecker.CheckProperties(properties);
userAdd(properties, dateTime, appId);
}
public static void UserAppend(Dictionary<string, object> properties, string appId)
{
TDPropertiesChecker.CheckProperties(properties);
userAppend(properties, appId);
}
public static void UserAppend(Dictionary<string, object> properties, DateTime dateTime, string appId)
{
TDPropertiesChecker.CheckProperties(properties);
userAppend(properties, dateTime, appId);
}
public static void UserUniqAppend(Dictionary<string, object> properties, string appId)
{
TDPropertiesChecker.CheckProperties(properties);
userUniqAppend(properties, appId);
}
public static void UserUniqAppend(Dictionary<string, object> properties, DateTime dateTime, string appId)
{
TDPropertiesChecker.CheckProperties(properties);
userUniqAppend(properties, dateTime, appId);
}
public static void UserDelete(string appId)
{
userDelete(appId);
}
public static void UserDelete(DateTime dateTime, string appId)
{
userDelete(dateTime, appId);
}
public static void Flush(string appId)
{
flush(appId);
}
public static void SetNetworkType(TDNetworkType networkType)
{
setNetworkType(networkType);
}
public static string GetDeviceId()
{
return getDeviceId();
}
public static void SetDynamicSuperProperties(TDDynamicSuperPropertiesHandler dynamicSuperProperties, string appId)
{
if (!TDPropertiesChecker.CheckProperties(dynamicSuperProperties.GetDynamicSuperProperties()))
{
if(TDLog.GetEnable()) TDLog.d("Cannot set dynamic super properties due to invalid properties.");
}
mDynamicSuperProperties = dynamicSuperProperties;
setDynamicSuperProperties(dynamicSuperProperties, appId);
}
public static void SetTrackStatus(TDTrackStatus status, string appId)
{
setTrackStatus(status, appId);
}
public static void OptOutTracking(string appId)
{
optOutTracking(appId);
}
public static void OptOutTrackingAndDeleteUser(string appId)
{
optOutTrackingAndDeleteUser(appId);
}
public static void OptInTracking(string appId)
{
optInTracking(appId);
}
public static void EnableTracking(bool enabled, string appId)
{
enableTracking(enabled, appId);
}
public static string CreateLightInstance()
{
return createLightInstance();
}
public static void CalibrateTime(long timestamp)
{
calibrateTime(timestamp);
}
public static void CalibrateTimeWithNtp(string ntpServer)
{
calibrateTimeWithNtp(ntpServer);
}
public static void EnableThirdPartySharing(TDThirdPartyType shareType, Dictionary<string, object> properties = null, string appId = "")
{
if (null == properties) properties = new Dictionary<string, object>();
enableThirdPartySharing(shareType, properties, appId);
}
}
}

11
sdk-intergration/Packages/TA/Runtime/ThinkingAnalytics/Wrapper/TDWrapper.cs.meta Normal file
View File

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

516
sdk-intergration/Packages/TA/Runtime/ThinkingAnalytics/Wrapper/TDiOSWrapper.cs Normal file
View File

@@ -0,0 +1,516 @@
#if UNITY_IOS && !(UNITY_EDITOR) && !TE_DISABLE_IOS_OC
using System;
using System.Collections.Generic;
using System.Runtime.InteropServices;
using ThinkingData.Analytics.Utils;
namespace ThinkingData.Analytics.Wrapper
{
public partial class TDWrapper
{
[DllImport("__Internal")]
private static extern void ta_start(string app_id, string url, int mode, string timezone_id, bool enable_encrypt, int encrypt_version, string encrypt_public_key, int pinning_mode, bool allow_invalid_certificates, bool validates_domain_name, string instance_name);
[DllImport("__Internal")]
private static extern void ta_identify(string app_id, string unique_id);
[DllImport("__Internal")]
private static extern string ta_get_distinct_id(string app_id);
[DllImport("__Internal")]
private static extern void ta_login(string app_id, string account_id);
[DllImport("__Internal")]
private static extern void ta_logout(string app_id);
[DllImport("__Internal")]
private static extern void ta_track(string app_id, string event_name, string properties, long time_stamp_millis, string timezone);
[DllImport("__Internal")]
private static extern void ta_track_event(string app_id, string event_string);
[DllImport("__Internal")]
private static extern void ta_set_super_properties(string app_id, string properties);
[DllImport("__Internal")]
private static extern void ta_unset_super_property(string app_id, string property_name);
[DllImport("__Internal")]
private static extern void ta_clear_super_properties(string app_id);
[DllImport("__Internal")]
private static extern string ta_get_super_properties(string app_id);
[DllImport("__Internal")]
private static extern string ta_get_preset_properties(string app_id);
[DllImport("__Internal")]
private static extern void ta_time_event(string app_id, string event_name);
[DllImport("__Internal")]
private static extern void ta_user_set(string app_id, string properties);
[DllImport("__Internal")]
private static extern void ta_user_set_with_time(string app_id, string properties, long timestamp);
[DllImport("__Internal")]
private static extern void ta_user_unset(string app_id, string properties);
[DllImport("__Internal")]
private static extern void ta_user_unset_with_time(string app_id, string properties, long timestamp);
[DllImport("__Internal")]
private static extern void ta_user_set_once(string app_id, string properties);
[DllImport("__Internal")]
private static extern void ta_user_set_once_with_time(string app_id, string properties, long timestamp);
[DllImport("__Internal")]
private static extern void ta_user_add(string app_id, string properties);
[DllImport("__Internal")]
private static extern void ta_user_add_with_time(string app_id, string properties, long timestamp);
[DllImport("__Internal")]
private static extern void ta_user_delete(string app_id);
[DllImport("__Internal")]
private static extern void ta_user_delete_with_time(string app_id, long timestamp);
[DllImport("__Internal")]
private static extern void ta_user_append(string app_id, string properties);
[DllImport("__Internal")]
private static extern void ta_user_append_with_time(string app_id, string properties, long timestamp);
[DllImport("__Internal")]
private static extern void ta_user_uniq_append(string app_id, string properties);
[DllImport("__Internal")]
private static extern void ta_user_uniq_append_with_time(string app_id, string properties, long timestamp);
[DllImport("__Internal")]
private static extern void ta_flush(string app_id);
[DllImport("__Internal")]
private static extern void ta_set_network_type(int type);
[DllImport("__Internal")]
private static extern void ta_enable_log(bool is_enable);
[DllImport("__Internal")]
private static extern string ta_get_device_id();
[DllImport("__Internal")]
private static extern void ta_set_dynamic_super_properties(string app_id);
[DllImport("__Internal")]
private static extern void ta_enable_tracking(string app_id, bool enabled);
[DllImport("__Internal")]
private static extern void ta_set_track_status(string app_id, int status);
[DllImport("__Internal")]
private static extern void ta_opt_out_tracking(string app_id);
[DllImport("__Internal")]
private static extern void ta_opt_out_tracking_and_delete_user(string app_id);
[DllImport("__Internal")]
private static extern void ta_opt_in_tracking(string app_id);
[DllImport("__Internal")]
private static extern void ta_create_light_instance(string delegate_token);
[DllImport("__Internal")]
private static extern void ta_enable_autoTrack(string app_id, int events, string properties);
[DllImport("__Internal")]
private static extern void ta_enable_autoTrack_with_callback(string app_id, int events);
[DllImport("__Internal")]
private static extern void ta_set_autoTrack_properties(string app_id, int events, string properties);
[DllImport("__Internal")]
private static extern string ta_get_time_string(long timestamp);
[DllImport("__Internal")]
private static extern void ta_calibrate_time(long timestamp);
[DllImport("__Internal")]
private static extern void ta_calibrate_time_with_ntp(string ntpServer);
[DllImport("__Internal")]
private static extern void ta_config_custom_lib_info(string lib_name, string lib_version);
[DllImport("__Internal")]
private static extern void ta_enable_third_party_sharing(string app_id, int share_type, string properties);
private static TimeZoneInfo defaultTimeZone = null;
private static TDTimeZone defaultTDTimeZone = TDTimeZone.Local;
private static void init(TDConfig token)
{
registerRecieveGameCallback();
ta_start(token.appId, token.serverUrl, (int)token.mode, token.getTimeZoneId(), token.enableEncrypt, token.encryptVersion, token.encryptPublicKey, (int) token.pinningMode, token.allowInvalidCertificates, token.validatesDomainName, token.name);
string timeZoneId = token.getTimeZoneId();
defaultTDTimeZone = token.timeZone;
if (null != timeZoneId && timeZoneId.Length > 0)
{
if (defaultTimeZone == null)
{
try
{
defaultTimeZone = TimeZoneInfo.FindSystemTimeZoneById(timeZoneId);
}
catch (Exception)
{
}
}
}
else
{
if (defaultTimeZone == null)
{
defaultTimeZone = TimeZoneInfo.Local;
}
}
}
private static void identify(string uniqueId, string appId)
{
ta_identify(appId, uniqueId);
}
private static string getDistinctId(string appId)
{
return ta_get_distinct_id(appId);
}
private static void login(string accountId, string appId)
{
ta_login(appId, accountId);
}
private static void logout(string appId)
{
ta_logout(appId);
}
private static void flush(string appId)
{
ta_flush(appId);
}
private static void enableLog(bool enable)
{
ta_enable_log(enable);
}
private static void setVersionInfo(string lib_name, string lib_version) {
ta_config_custom_lib_info(lib_name, lib_version);
}
private static void track(TDEventModel taEvent, string appId)
{
Dictionary<string, object> finalEvent = new Dictionary<string, object>();
string extraId = taEvent.GetEventId();
switch (taEvent.EventType)
{
case TDEventModel.TDEventType.First:
finalEvent["event_type"] = "track_first";
break;
case TDEventModel.TDEventType.Updatable:
finalEvent["event_type"] = "track_update";
break;
case TDEventModel.TDEventType.Overwritable:
finalEvent["event_type"] = "track_overwrite";
break;
}
if (!string.IsNullOrEmpty(extraId))
{
finalEvent["extra_id"] = extraId;
}
finalEvent["event_name"] = taEvent.EventName;
finalEvent["event_properties"] = taEvent.Properties;
if (taEvent.GetEventTime() != null && taEvent.GetEventTime() != DateTime.MinValue)
{
long dateTimeTicksUTC = TimeZoneInfo.ConvertTimeToUtc(taEvent.GetEventTime()).Ticks;
DateTime dtFrom = new DateTime(1970, 1, 1, 0, 0, 0, 0, DateTimeKind.Utc);
long currentMillis = (dateTimeTicksUTC - dtFrom.Ticks) / 10000;
finalEvent["event_time"] = currentMillis;
}
if (taEvent.GetEventTimeZone() != null)
{
finalEvent["event_timezone"] = taEvent.GetEventTimeZone().Id;
}
ta_track_event(appId, serilize(finalEvent));
}
private static void track(string eventName, Dictionary<string, object> properties, string appId)
{
ta_track(appId, eventName, serilize(properties), 0, "");
}
private static void track(string eventName, Dictionary<string, object> properties, DateTime dateTime, string appId)
{
long dateTimeTicksUTC = TimeZoneInfo.ConvertTimeToUtc(dateTime).Ticks;
DateTime dtFrom = new DateTime(1970, 1, 1, 0, 0, 0, 0, DateTimeKind.Utc);
long currentMillis = (dateTimeTicksUTC - dtFrom.Ticks) / 10000;
string tz = "";
ta_track(appId, eventName, serilize(properties), currentMillis, tz);
}
private static void track(string eventName, Dictionary<string, object> properties, DateTime dateTime, TimeZoneInfo timeZone, string appId)
{
long dateTimeTicksUTC = TimeZoneInfo.ConvertTimeToUtc(dateTime).Ticks;
DateTime dtFrom = new DateTime(1970, 1, 1, 0, 0, 0, 0, DateTimeKind.Utc);
long currentMillis = (dateTimeTicksUTC - dtFrom.Ticks) / 10000;
string tz = "";
if (timeZone != null)
{
tz = timeZone.Id;
}
ta_track(appId, eventName, serilize(properties), currentMillis, tz);
}
private static void trackForAll(string eventName, Dictionary<string, object> properties)
{
string appId = "";
track(eventName, properties, appId);
}
private static void setSuperProperties(Dictionary<string, object> superProperties, string appId)
{
ta_set_super_properties(appId, serilize(superProperties));
}
private static void unsetSuperProperty(string superPropertyName, string appId)
{
ta_unset_super_property(appId, superPropertyName);
}
private static void clearSuperProperty(string appId)
{
ta_clear_super_properties(appId);
}
private static Dictionary<string, object> getSuperProperties(string appId)
{
string superPropertiesString = ta_get_super_properties(appId);
return TDMiniJson.Deserialize(superPropertiesString);
}
private static Dictionary<string, object> getPresetProperties(string appId)
{
string presetPropertiesString = ta_get_preset_properties(appId);
return TDMiniJson.Deserialize(presetPropertiesString);
}
private static void timeEvent(string eventName, string appId)
{
ta_time_event(appId, eventName);
}
private static void timeEventForAll(string eventName)
{
ta_time_event("", eventName);
}
private static void userSet(Dictionary<string, object> properties, string appId)
{
ta_user_set(appId, serilize(properties));
}
private static void userSet(Dictionary<string, object> properties, DateTime dateTime, string appId)
{
long dateTimeTicksUTC = TimeZoneInfo.ConvertTimeToUtc(dateTime).Ticks;
DateTime dtFrom = new DateTime(1970, 1, 1, 0, 0, 0, 0, DateTimeKind.Utc);
long currentMillis = (dateTimeTicksUTC - dtFrom.Ticks) / 10000;
ta_user_set_with_time(appId, serilize(properties), currentMillis);
}
private static void userUnset(List<string> properties, string appId)
{
foreach (string property in properties)
{
ta_user_unset(appId, property);
}
}
private static void userUnset(List<string> properties, DateTime dateTime, string appId)
{
long dateTimeTicksUTC = TimeZoneInfo.ConvertTimeToUtc(dateTime).Ticks;
DateTime dtFrom = new DateTime(1970, 1, 1, 0, 0, 0, 0, DateTimeKind.Utc);
long currentMillis = (dateTimeTicksUTC - dtFrom.Ticks) / 10000;
foreach (string property in properties)
{
ta_user_unset_with_time(appId, property, currentMillis);
}
}
private static void userSetOnce(Dictionary<string, object> properties, string appId)
{
ta_user_set_once(appId, serilize(properties));
}
private static void userSetOnce(Dictionary<string, object> properties, DateTime dateTime, string appId)
{
long dateTimeTicksUTC = TimeZoneInfo.ConvertTimeToUtc(dateTime).Ticks;
DateTime dtFrom = new DateTime(1970, 1, 1, 0, 0, 0, 0, DateTimeKind.Utc);
long currentMillis = (dateTimeTicksUTC - dtFrom.Ticks) / 10000;
ta_user_set_once_with_time(appId, serilize(properties), currentMillis);
}
private static void userAdd(Dictionary<string, object> properties, string appId)
{
ta_user_add(appId, serilize(properties));
}
private static void userAdd(Dictionary<string, object> properties, DateTime dateTime, string appId)
{
long dateTimeTicksUTC = TimeZoneInfo.ConvertTimeToUtc(dateTime).Ticks;
DateTime dtFrom = new DateTime(1970, 1, 1, 0, 0, 0, 0, DateTimeKind.Utc);
long currentMillis = (dateTimeTicksUTC - dtFrom.Ticks) / 10000;
ta_user_add_with_time(appId, serilize(properties), currentMillis);
}
private static void userDelete(string appId)
{
ta_user_delete(appId);
}
private static void userDelete(DateTime dateTime, string appId)
{
long dateTimeTicksUTC = TimeZoneInfo.ConvertTimeToUtc(dateTime).Ticks;
DateTime dtFrom = new DateTime(1970, 1, 1, 0, 0, 0, 0, DateTimeKind.Utc);
long currentMillis = (dateTimeTicksUTC - dtFrom.Ticks) / 10000;
ta_user_delete_with_time(appId, currentMillis);
}
private static void userAppend(Dictionary<string, object> properties, string appId)
{
ta_user_append(appId, serilize(properties));
}
private static void userAppend(Dictionary<string, object> properties, DateTime dateTime, string appId)
{
long dateTimeTicksUTC = TimeZoneInfo.ConvertTimeToUtc(dateTime).Ticks;
DateTime dtFrom = new DateTime(1970, 1, 1, 0, 0, 0, 0, DateTimeKind.Utc);
long currentMillis = (dateTimeTicksUTC - dtFrom.Ticks) / 10000;
ta_user_append_with_time(appId, serilize(properties), currentMillis);
}
private static void userUniqAppend(Dictionary<string, object> properties, string appId)
{
ta_user_uniq_append(appId, serilize(properties));
}
private static void userUniqAppend(Dictionary<string, object> properties, DateTime dateTime, string appId)
{
long dateTimeTicksUTC = TimeZoneInfo.ConvertTimeToUtc(dateTime).Ticks;
DateTime dtFrom = new DateTime(1970, 1, 1, 0, 0, 0, 0, DateTimeKind.Utc);
long currentMillis = (dateTimeTicksUTC - dtFrom.Ticks) / 10000;
ta_user_uniq_append_with_time(appId, serilize(properties), currentMillis);
}
private static void setNetworkType(TDNetworkType networkType)
{
ta_set_network_type((int)networkType);
}
private static string getDeviceId()
{
return ta_get_device_id();
}
private static void setDynamicSuperProperties(TDDynamicSuperPropertiesHandler dynamicSuperProperties, string appId)
{
ta_set_dynamic_super_properties(appId);
}
private static void setTrackStatus(TDTrackStatus status, string appId)
{
ta_set_track_status(appId, (int)status);
}
private static void optOutTracking(string appId)
{
ta_opt_out_tracking(appId);
}
private static void optOutTrackingAndDeleteUser(string appId)
{
ta_opt_out_tracking_and_delete_user(appId);
}
private static void optInTracking(string appId)
{
ta_opt_in_tracking(appId);
}
private static void enableTracking(bool enabled, string appId)
{
ta_enable_tracking(appId, enabled);
}
private static string createLightInstance()
{
string randomID = System.Guid.NewGuid().ToString("N");
ta_create_light_instance(randomID);
return randomID;
}
private static string getTimeString(DateTime dateTime)
{
//long dateTimeTicksUTC = TimeZoneInfo.ConvertTimeToUtc(dateTime).Ticks;
//DateTime dtFrom = new DateTime(1970, 1, 1, 0, 0, 0, 0, DateTimeKind.Utc);
//long currentMillis = (dateTimeTicksUTC - dtFrom.Ticks) / 10000;
//return ta_get_time_string(currentMillis);
if (defaultTimeZone == null)
{
return TDCommonUtils.FormatDate(dateTime, defaultTDTimeZone);
}
else
{
return TDCommonUtils.FormatDate(dateTime, defaultTimeZone);
}
}
private static void enableAutoTrack(TDAutoTrackEventType autoTrackEvents, Dictionary<string, object> properties, string appId)
{
ta_enable_autoTrack(appId, (int)autoTrackEvents, serilize(properties));
}
private static void enableAutoTrack(TDAutoTrackEventType autoTrackEvents, TDAutoTrackEventHandler eventCallback, string appId)
{
ta_enable_autoTrack_with_callback(appId, (int)autoTrackEvents);
}
private static void setAutoTrackProperties(TDAutoTrackEventType autoTrackEvents, Dictionary<string, object> properties, string appId)
{
ta_set_autoTrack_properties(appId, (int)autoTrackEvents, serilize(properties));
}
private static void calibrateTime(long timestamp)
{
ta_calibrate_time(timestamp);
}
private static void calibrateTimeWithNtp(string ntpServer)
{
ta_calibrate_time_with_ntp(ntpServer);
}
private static void enableThirdPartySharing(TDThirdPartyType shareType, Dictionary<string, object> properties, string appId)
{
ta_enable_third_party_sharing(appId, (int) shareType, serilize(properties));
}
private static void registerRecieveGameCallback()
{
ResultHandler handler = new ResultHandler(resultHandler);
IntPtr handlerPointer = Marshal.GetFunctionPointerForDelegate(handler);
RegisterRecieveGameCallback(handlerPointer);
}
[DllImport("__Internal")]
public static extern void RegisterRecieveGameCallback
(
IntPtr handlerPointer
);
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
public delegate string ResultHandler(string type, string jsonData);
[AOT.MonoPInvokeCallback(typeof(ResultHandler))]
static string resultHandler(string type, string jsonData)
{
if (type == "AutoTrackProperties")
{
Dictionary<string, object>properties = TDMiniJson.Deserialize(jsonData);
string appId = properties["AppID"].ToString();
int eventType = Convert.ToInt32(properties["EventType"]);
if (!string.IsNullOrEmpty(appId) && mAutoTrackEventCallbacks.ContainsKey(appId))
{
properties.Remove("EventType");
properties.Remove("AppID");
Dictionary<string, object>autoTrackProperties = mAutoTrackEventCallbacks[appId].GetAutoTrackEventProperties(eventType, properties);
//return TDMiniJson.Serialize(autoTrackProperties);
return serilize(autoTrackProperties);
}
}
else if (type == "DynamicSuperProperties")
{
if (mDynamicSuperProperties != null)
{
Dictionary<string, object>dynamicSuperProperties = mDynamicSuperProperties.GetDynamicSuperProperties();
//return TDMiniJson.Serialize(dynamicSuperProperties);
return serilize(dynamicSuperProperties);
}
}
return "{}";
}
}
}
#endif

11
sdk-intergration/Packages/TA/Runtime/ThinkingAnalytics/Wrapper/TDiOSWrapper.cs.meta Normal file
View File

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