@thinkingai/ae-cli 1.0.30 → 6.0.16

package/wiki/te-docs/raw/data-ingestion-guide/client-sdk/game-engine/unity/unity-advanced/third-party-integration.md

@@ -0,0 +1,77 @@
+---
+code: unity_sdk_thirdparty
+name: "Third-party Integration"
+wikiToken: VFkdwuFNAiHedqkdbItc6oXznQ1
+parentWikiToken: A3TawLiiwiV2LZkUDTAc1YuOnmd
+updateTime: 1774249098000
+sourceUrl: https://docs-v2.thinkingdata.cn/?version=v6.0&lan=en-US&code=unity_sdk_thirdparty
+---
+
+The sample codes for the synchronization of multiple platform data are as follows:
+```csharp
+TDAnalytics.EnableThirdPartySharing(TDThirdPartyType.APPSFLYER | TDThirdPartyType.ADJUST | TDThirdPartyType.TRADPLUS | TDThirdPartyType.TRACKING | TDThirdPartyType.TOPON | TDThirdPartyType.BRANCH | TDThirdPartyType.IRONSOURCE);
+```
+
+## **1. Appsflyer**
+Call  this API before AppsFlyer SDK calls the Start API：
+```csharp
+TDAnalytics.EnableThirdPartySharing(TDThirdPartyType.APPSFLYER);
+```
+
+After the created role is registered (optional)：
+```csharp
+TDAnalytics.Login("account_id");
+TDAnalytics.EnableThirdPartySharing(TDThirdPartyType.APPSFLYER);
+```
+
+<quote-container>
+Note: Every time you call the `Login` or `SetDistinctId`, you need to call `EnableThirdPartySharing` synchronously to update the user ID.
+</quote-container>
+
+## **2. Adjust**
+To be called before Adjust SDK initialization：
+```csharp
+TDAnalytics.EnableThirdPartySharing(TDThirdPartyType.ADJUST);
+```
+
+After the created role is registered (optional)：
+```csharp
+TDAnalytics.Login("account_id");
+TDAnalytics.EnableThirdPartySharing(TDThirdPartyType.ADJUST);
+```
+
+## **3. Branch**
+To be called before the Branch initialize the session：
+```java
+TDAnalytics.EnableThirdPartySharing(TDThirdPartyType.BRANCH);
+```
+
+After the created role is registered (optional)：
+```java
+TDAnalytics.Login("account_id");
+TDAnalytics.EnableThirdPartySharing(TDThirdPartyType.BRANCH);
+```
+
+## **4. TopOn**
+To be called before ATSDK.*init：*
+```java
+TDAnalytics.EnableThirdPartySharing(TDThirdPartyType.TOPON);
+```
+
+## **5. ReYun**
+To be called after the account is registered:
+```java
+TDAnalytics.EnableThirdPartySharing(TDThirdPartyType.TRACKING);
+```
+
+## **6.** **Trad****P****lus**
+To be called before TradPlus SDK initialization*:*
+```java
+TDAnalytics.EnableThirdPartySharing(TDThirdPartyType.TRADPLUS);
+```
+
+## **7.** **IronSource**
+To be called after IronSource SDK initialization:
+```java
+TDAnalytics.EnableThirdPartySharing(TDThirdPartyType.IRONSOURCE);
+```

package/wiki/te-docs/raw/data-ingestion-guide/client-sdk/game-engine/unity/unity-advanced.md

@@ -0,0 +1,396 @@
+---
+code: unity_sdk_advanced
+name: "Unity-Advanced"
+wikiToken: A3TawLiiwiV2LZkUDTAc1YuOnmd
+parentWikiToken: NaFYwOKI1iN5mgkTPQwcZY0tnRg
+updateTime: 1774249091000
+sourceUrl: https://docs-v2.thinkingdata.cn/?version=v6.0&lan=en-US&code=unity_sdk_advanced
+---
+## **1. Managing User Identity**
+SDK instances would use random UUID as the default distinct ID of each user by default, which would be used as the identity identification ID of users under an unlogged-in state. It should be noted that the distinct ID would change after the user reinstalled the App or use the APP with a new device.
+### **1.1. Identify**
+::: tip
+Generally speaking, you do not need to customize a distinct ID Please ensure that you understand [<text underline="true">User Identification Rules</text>](https%3A%2F%2Fthinkingdata.feishu.cn%2Fwiki%2FORyZwNANpi12XBkyGgUccSy0ntb)<text color="purple" underline="true"> </text>before setting a distinct ID. 
+If you need to change the distinct ID, please call the api immediately after SDK is initialized. To avoid the generation of useless accounts, please do not call such a process multiple times.
+:::
+If your App has its own distinct ID management system for each user, you can call `SetDistinctId` to set the distinct ID:
+```csharp
+// set distinct ID as Thinker
+TDAnalytics.SetDistinctId("Thinker");
+```
+
+If you need to get the current distinct ID, please call `GetDistinctId`:
+```csharp
+// return distinct ID
+String distinctId = TDAnalytics.GetDistinctId();
+```
+
+### **1.2 Login**
+When the users  log in, `Login` could be called to set the account ID of the user. TE  would use the account ID as the identity identification ID, and the account ID that has been set would be saved before `Logout` is called. The previous account ID would be replaced if `Login` has been called multiple times.
+```csharp
+// The login unique identifier of the user, corresponding to the #account_id in data tracking. #Account_id now is TE
+TDAnalytics.Login("TA");
+```
+
+<quote-container>
+**Login events wouldn't be uploaded in this method.**
+</quote-container>
+
+### **1.3 Removing Account ID**
+After the user logs out, `Logout` could be called to remove the account ID. The distinct ID would be used as the identity identification ID before the next time `Login` is called. 
+```csharp
+TDAnalytics.Logout();
+```
+
+It is recommended that you call logout upon explicit logout event. For example, call `Logout` when the user commits the behavior of canceling an account; do not call such a process when the App is closed.
+<quote-container>
+**Logout events wouldn't be uploaded in this method.**
+</quote-container>
+
+## **2. Sending Events**
+After SDK is initialized, you can track user behaviour data. In general, ordinary events could meet business requirements. You can also use the First/Updatable event based on your own service scenario.
+### **2.1 Ordinary Events**
+ You can call `Track` to upload events. It is suggested that you set event properties based on the data tracking plan drafted previously. Here is an example of a user buying an item:
+```csharp
+Dictionary<string, object> properties = new Dictionary<string, object>(){
+    {"product_name", "product name"}
+};
+TDAnalytics.Track("product_buy", properties);
+```
+
+### **2.2 First Events**
+The First Events refers to events that would only be recorded once for the ID of a certain device or other dimensions. For example, under certain scenarios, you may want to record the activation event on a certain device. In this case, you can perform data tracking with the First Event.
+```csharp
+Dictionary<string, object> properties = new Dictionary<string, object>() { 
+    { "status", 1} 
+};
+TDFirstEventModel firstEvent = new TDFirstEventModel("first_event");
+firstEvent.Properties = properties;
+TDAnalytics.Track(firstEvent);
+```
+
+If you want to judge whether an event is the First Event from other dimensions, you can define a first_check_id for the First Event:
+```csharp
+//set the user ID as the first_check_id of the first event to track the first initialization event of the user.
+Dictionary<string, object> properties = new Dictionary<string, object>(){
+    {"key", "value"}
+};
+TDFirstEventModel firstEvent = new TDFirstEventModel("first_event", "any-user-id");
+firstEvent.Properties = properties;
+TDAnalytics.Track(firstEvent);
+```
+
+<quote-container>
+Note: Since the server has to check whether the event is the First event, the First event will be put in storage one hour later by default.
+</quote-container>
+
+### **2.3 Updatable Events**
+You can meet the requirements for event data modification under specific scenarios through Updatable Events. The ID of Updatable Events should be specified and uploaded when the objects of Updatable Events are created. TE would determine the data to be updated according to the event name and event ID.
+```csharp
+ //The event property status is 3 after reporting, with the price being 100
+TDUpdatableEventModel updatableEvent = new TDUpdatableEventModel("UPDATABLE_EVENT", "test_event_id");
+updatableEvent.Properties = new Dictionary<string, object>{
+    {"status", 3},
+    {"price", 100}
+};
+TDAnalytics.Track(updatableEvent);
+
+//The event property status is 5 after reporting, with the price remaining the same
+TDUpdatableEventModel updatableEvent_new = new TDUpdatableEventModel("UPDATABLE_EVENT", "test_event_id");
+updatableEvent_new.Properties = new Dictionary<string, object>{
+    {"status", 5}
+};
+TDAnalytics.Track(updatableEvent_new);
+```
+
+### **2.4 Overwritable Events**
+Despite the similarity with Updatable Events, Overwritable Events would replace all historical data with the latest data. Looking from the perspective of effect, such a process is equivalent to the behavior of deleting the previous data while putting the latest data in storage. TE would determine the data to be updated according to the event name and event ID.
+```csharp
+// Instance: Assume the event name is OVERWRITE_EVENT when reporting an overwritable event
+//The event property status is 3 after reporting, with the price being 100
+TDOverwritableEventModel overWritableEvent = new TDOverwritableEventModel("OVERWRITABLE_EVENT", "test_event_id");
+overWritableEvent.Properties = new Dictionary<string, object>{
+    {"status", 3},
+    {"price", 100}
+};
+TDAnalytics.Track(overWritableEvent);
+
+//The event property status is 5 after reporting, with the price deleted
+TDOverwritableEventModel overWritableEvent_new = new TDOverwritableEventModel("OVERWRITABLE_EVENT", "test_event_id");
+overWritableEvent_new.Properties = new Dictionary<string, object>{
+    {"status", 5}
+};
+TDAnalytics.Track(overWritableEvent_new);
+```
+
+### **2.5 Super Properties**
+Super properties refer to properties that would be uploaded by each event. Super properties could be divided into `static super properties` and `dynamic super properties`based on the update frequency. You can select different methods for super property setting according to business requirements; we recommend that you set super properties first before sending events. In the same event, when the keys of super properties, self-defined event properties, and preset properties are the same, we would assign value according to the following priority:  `self-defined properties>dynamic super properties>static super properties>preset properties`.
+#### **2.5.1 Static Super Properties**
+Static super properties are properties that all events might have and would change with a low frequency, for example, the user membership class. After setting static super properties through `SetSuperProperties`, SDK would use the preset super properties as the event properties when tracking events.
+```csharp
+Dictionary<string, object> superProperties = new Dictionary<string, object>(){ 
+    {"vip_level", 2}
+};
+TDAnalytics.SetSuperProperties(superProperties);
+```
+
+Static super properties would be saved in local storage, and should not be called every time the App is closed. If such properties already exist, the reset properties would replace the original properties. If such properties do not exist, properties would be newly created. In addition to property setting, we also provide other APIs to set and manage static super properties and meet general business requirements.
+```csharp
+//clear super property named 'CHANNEL'
+TDAnalytics.UnsetSuperProperty("CHANNEL");
+//clear all super properties
+TDAnalytics.ClearSuperProperties();
+//get all super properties
+TDAnalytics.GetSuperProperties();
+```
+
+#### **2.5.2 Dynamic super properties**
+Dynamic super properties that all events might have and would change with a high frequency, for example, the quantity of the gold coins the user possesses. After setting dynamic super properties through `SetDynamicSuperProperties`, SDK would obtain the properties in `GetDynamicSuperProperties` during event tracking automatically, and add such properties to the event triggered.
+```csharp
+// 1. implement dynamic properties interface, this is an example of setting the dynamic change of gold coins
+public class DynamicProp : TDDynamicSuperPropertiesHandler
+{    
+    int coin = 0;
+    public Dictionary<string, object> GetDynamicSuperProperties()
+    {  
+         coin++;
+         return new Dictionary<string, object>() {
+             {"coin",coin}
+         };
+    }
+}
+// 2. set dynamic properties
+TDAnalytics.SetDynamicSuperProperties(new DynamicProp());
+```
+
+### **2.6 Timing Events**
+If you need to record the duration of a certain event, you can call `TimeEvent` . Configure the name of the event you want to record. When you upload the event, `#duration` would be added to your event property automatically to record the duration of the event (unit: second). It should be noted that only one task can be timed with the same event name.
+```csharp
+//The following instance has recorded the time the user spent on a certain product page
+//The user enters the product page and starts the timing
+TDAnalytics.TimeEvent("stay_shop");
+/**do someting
+    .......
+**/
+//the timing would end when the user leaves the product page. "stay_shop" event would carry#duration, a property representing event duration. 
+TDAnalytics.Track("stay_shop");
+```
+
+## **3. User Properties**
+User property setting APIs supported by TE  include: `UserSet`,`UserSetOnce`,`UserAdd`,`UserUnset`,`UserDelete`,`UserAppend`,`UserUniqAppend`.
+### **3.1 UserSet**
+You can call `UserSet` to set general user properties. The original properties would be replaced if the properties uploaded via the API are used. The type of newly-created user properties must conform to that of the uploaded properties. User name setting is taken as the example here:
+
+```csharp
+//the username now is TA
+TDAnalytics.UserSet(new Dictionary<string, object>(){
+    {"user_name", "TA"}
+});
+//the username now is TE
+TDAnalytics.UserSet(new Dictionary<string, object>(){
+    {"user_name", "TE"}
+});
+```
+
+### **3.2 UserSetOnce**
+If the user property you want to upload only needs to be set once, you can call `UserSetOnce` to set the property. If such property had been set before, this message would be neglected. Let's take the setting of the first payment time as an example:
+```csharp
+//first_payment_time is '2018-01-01 01:23:45.678'
+TDAnalytics.UserSetOnce(new Dictionary<string, object>(){
+    {"first_payment_time","2018-01-01 01:23:45.678"}
+});
+ //first_payment_time is '2018-01-01 01:23:45.678' as before
+TDAnalytics.UserSetOnce(new Dictionary<string, object>(){
+    {"first_payment_time","2018-12-31 01:23:45.678"}
+});
+```
+
+### **3.3 UserAdd**
+When you want to upload numeric attributes for cumulative operation, you can call `UserAdd`.
+If the property has not been set, it would be given a value of 0 before computing. A negative value could be uploaded, which is equivalent to subtraction operation. Let's take the accumulative payment amount as an example:
+```csharp
+//current total_revenue is 30
+TDAnalytics.UserAdd(new Dictionary<string, object>(){
+    {"total_revenue",30}
+});
+//current total_revenue is 678
+TDAnalytics.UserAdd(new Dictionary<string, object>(){
+    {"total_revenue",648}
+})
+```
+
+<quote-container>
+The set attribute key is a string, and the Value is only allowed to be a numeric value.
+</quote-container>
+
+### **3.4 UserUnset**
+When you need to clear the user properties of users, you can call `UserUnset` to clear specific properties.  `UserUnset` would not create properties that have not been created in the cluster.
+```csharp
+// delete a user property named 'userPropertyName'
+TDAnalytics.UserUnset("userPropertyName");
+// delete some user properties as List
+List<string> listProps = new List<string>();
+listProps.Add("aaa");
+listProps.Add("bbb");
+listProps.Add("ccc");
+
+TDAnalytics.UserUnset(listProps);
+```
+
+### **3.5 UserDelete**
+You can call `UserDelete` to delete a user. After deleting the user, you would no longer be able to inquire about its user property, but could still obtain the events data triggered by the user.
+```csharp
+TDAnalytics.UserDelete();
+```
+
+### **3.6 UserAppend**
+You can call `UserAppend` to add user properties of array type.
+```csharp
+List<string> stringList = new List<string>();
+stringList.Add("apple");
+stringList.Add("ball");
+// call UserAppend to add elements for user property user_list. In this case, mon-existing elements would be newly created
+TDAnalytics.UserAppend(new Dictionary<string, object>{
+    {"user_list", stringList }
+});
+```
+
+### **3.7 UserUniqAppend**
+Since the v2.4.0, you can call `UserUniqAppend` to add user properties of array type. You can delete duplicated user property by calling `UserUniqAppend` interface. If you call `UserAppend` API, duplicated user property might not be deleted.
+```csharp
+//the property value of user_list is ["apple"，"ball"]
+List<string> stringList = new List<string>();
+stringList.Add("apple");
+stringList.Add("ball");
+TDAnalytics.UserAppend(new Dictionary<string, object>{
+    {"user_list", stringList}
+});
+
+List<string> stringList1 = new List<string>();
+stringList1.Add("apple");
+stringList1.Add("cube");
+//the property value of user_list is ["apple","apple","ball","cube"]
+TDAnalytics.UserAppend(new Dictionary<string, object>{
+    {"user_list", stringList1}
+});
+//the property value of user_list is ["apple","ball","cube"]
+TDAnalytics.UserUniqAppend(new Dictionary<string, object>{
+    {"user_list", stringList1}
+});
+```
+
+## **4. Encryption**
+Since v2.4.0, SDK supports the encryption function for iOS/Android devices, while the client side supports AES+RSA in encrypting data and the server in the decryption of data. The encryption/decryption capability should be realized through coordination between the client side and the server. For detailed information, please consult our customer success manager.
+```csharp
+TDConfig tdConfig = new TDConfig(appId, serverUrl);
+tdConfig.EnableEncrypt("YOUR_ENCRYPT_PUBLIC_KEY", 1);
+TDAnalytics.Init(tdConfig);
+```
+
+## **5. Other**
+### 5.1  Device ID
+You can call `GetDeviceId` to obtain the device ID:
+```csharp
+TDAnalytics.GetDeviceId();
+```
+
+### 5.2 Default Timezone
+SDK would use the local time as the event time by default. You can also assign a  timezone by setting the default timezone API. In this way, the time of all events could be aligned according to the timezone set by you:
+```csharp
+TDConfig tdConfig = new TDConfig(appId, serverUrl);
+tdConfig.timezone = TDTimeZone.UTC;
+TDAnalytics.Init(tdConfig);
+```
+
+<quote-container>
+The local timezone information of the device would be lost if a specific timezone is used to align event time. If you need to save the local timezone information of the device, please add relevant properties for the event.
+</quote-container>
+
+### 5.3 Time Calibration
+SDK would use local time as the event time by default. If the user modifies the device time manually,  analysis would be affected. At this time, time calibration could be performed to ensure the accuracy of event time. We provide two time calibration methods: `timestamp` and `NTP`.
+- You can use the current timestamp obtained from the server to calibrate the time of SDK. Thereafter, all calling operations not assigned with a specific time would use the calibrated time as the occurrence time, including event data and user property setting.
+```csharp
+// 1585633785954 is the current unix time stamp, with the unit being millisecond; 
+// the corresponding Beijing time is 2020-03-31 13:49:45
+TDAnalytics.CalibrateTime(1585633785954);
+```
+
+- You can also set the address of NTP server, after which SDK would try to obtain the current time from the uploaded NTP server address and calibrate the SDK time. If you failed to obtain the current return results within the default timeout interval (3s), local time would be used to track data.
+```csharp
+// use the NTP service of Apple Inc for time calibration 
+TDAnalytics.CalibrateTimeWithNtp("time.apple.com");
+```
+
+<quote-container>
+1. Using NTP service for time calibration would create some uncertainties. It is suggested that you use a time stamp for time calibration as the priority
+2. You should select your NTP server address carefully to ensure that the device of the user could obtain server time rapidly under sound network conditions
+</quote-container>
+
+### 5.4 Flush
+You can call the `Flush` API to report data to TE  immediately .
+```csharp
+TDAnalytics.Flush();
+```
+
+### 5.5 Country/Region code
+In some business scenarios, if you need to know the country/region code of the user device, you can get it through`GetLocalRegion`
+```csharp
+TDAnalytics.GetLocalRegion();
+```
+
+### 5.6 Supports Lua-style invocation.
+If you need to directly call in a Lua file, you can use the encapsulated Lua API. [Click to download](https%3A%2F%2Fdownload.thinkingdata.cn%2Fclient%2Funity%2Fta_unity_lua_sdk.zip).
+After downloading, import TDAnalytics.lua and TDAnalyticsProxy.cs into your project.
+The usage example is as follows:
+```lua
+local config = {
+    appId = "AppId",
+    serverUrl = "ServerUrl",
+    enableLog = true, -- Enable logging, default is false
+    mode = 'debug' -- Default is 'normal'
+}
+
+-- Initialize the SDK
+TDAnalytics.init(config);
+
+-- If the user is logged in, set the user's account ID as the unique identifier
+TDAnalytics.login("TA")
+
+-- After setting common event properties, every event will include these properties
+local superProperties = {}
+superProperties["channel"] = "ta" -- String
+superProperties["age"] = 1 -- Number
+superProperties["isSuccess"] = true -- Boolean
+superProperties["birthday"] = os.date("%Y-%m-%d %H:%M:%S") -- Time
+superProperties["object"] = { key="value" } -- Object
+superProperties["object_arr"] = { { key="value" } } -- Array of objects
+superProperties["arr"] = { "value" } -- Array
+TDAnalytics.setSuperProperties(superProperties) -- Set common event properties
+
+-- Send an event
+TDAnalytics.track("product_buy", {
+    product_name="Product Name"
+});
+
+-- Set user properties
+TDAnalytics.userSet({
+    user_name = "TE"
+})
+```
+
+### 5.7 WeChat automatic data collection
+For the WeChat Mini-Game platform, the following automatic event collection is currently supported: show events, hide events, and launch events. The integration steps are as follows:
+- Download the WeChat Mini-Game Plugin:
+      Go to the menu: Window → Package Manager → + → Add package from git url
+      PackageManager Git URL: https://github.com/wechat-miniprogram/minigame-tuanjie-transform-sdk.git
+- Define Custom Macro:
+  Go to the menu: Edit → Project Settings → Scripting Define Symbols
+  Add a new global macro: TD_WEIXIN_GAME_MODE
+  Click the Apply button to save the settings.
+- Add Assembly Dependency:
+  In the Project window, navigate to: ThinkingAnalytics → TDAnalytics (Assembly Definition) → Assembly Definition References → + → Select WxWasmSDKRuntime
+Example usage:
+```json
+// Enable automatic event collection, supporting show, hide, and launch events
+TDAnalytics.EnableAutoTrack(TDAutoTrackEventType.AppStart | TDAutoTrackEventType.AppEnd | TDAutoTrackEventType.AppInstall);
+```

package/wiki/te-docs/raw/data-ingestion-guide/client-sdk/game-engine/unity.md

@@ -0,0 +1,176 @@
+---
+code: unity_sdk_installation
+name: "Unity"
+wikiToken: NaFYwOKI1iN5mgkTPQwcZY0tnRg
+parentWikiToken: FgrswqlHEiE45HkQve4cU0NFnbd
+updateTime: 1779765101000
+sourceUrl: https://docs-v2.thinkingdata.cn/?version=v6.0&lan=en-US&code=unity_sdk_installation
+---
+::: tip
+Before  you begin, please read [Preparations before Data Ingestion](https://thinkingdata.feishu.cn/wiki/OhD8we9iai6Xk5kM1QNc8ITRnQe)
+Unity SDK Support:  iOS, Android, Unity Editor, Windows, Mac, WebGL, Switch, Xbox、PS4/5, Wechat Mini Game, Douyin Mini Game, OPPO Quick Game.
+The lowest Unity Editor version required is 5.4.0
+The size of Unity SDK is around 320 KB
+ :::
+**Latest version:** v3.4.8
+**Update time:** 2026/05/26
+**Resource download: **[**SDK**](https%3A%2F%2Fdownload.thinkingdata.cn%2Fclient%2FUnity%2Fta_unity_sdk_v3.4.8.zip)**, **[**Source Code**](https%3A%2F%2Fgithub.com%2FThinkingDataAnalytics%2Funity-sdk%2Ftags)
+::: warning Notice 
+The current documentation applies to v3.0.0 and later versions. For historical versions, please refer to the [Data Ingestion Guide - Unity (V2)](https%3A%2F%2Fdocs.thinkingdata.cn%2Fta-manual%2Fv4.1%2Fen%2Finstallation%2Finstallation_menu%2Fclient_sdk%2Fgame_engine_sdk_installation%2Funity_sdk_installation%2Funity_sdk_installation.html), [SDK Download (v2.6.1)](https%3A%2F%2Fdownload.thinkingdata.cn%2Fclient%2FUnity%2Fta_unity_sdk_v2.6.1.zip). 
+:::
+## **1. ****SDK**** Integration**
+### **1.1 Manual Integration**
+1. Download and unzip [Unity SDK](https%3A%2F%2Fdownload.thinkingdata.cn%2Fclient%2FUnity%2Fta_unity_sdk_v3.4.8.zip)
+2. Double click `ta_unity_sdk.unitypackage` to import SDK. Or open menu`Assets > Import Package > Custom Package`, select `ta_unity_sdk.unitypackage` to import SDK
+<callout emoji="unicorn_face" background-color="light-orange" border-color="light-orange">
+When upgrading the unitypackage from version 3.3.0 to 3.4+.x, you must delete the original SDK first before importing the new package.
+This is because: An occasional TS file loss issue may occur when exporting to the HarmonyOS platform using the Unity Engine. Currently, all relevant files have been renamed to .tslib. If the previous files are not deleted, a file naming conflict will arise.
+</callout>
+
+### **1.2 Package Manager Integration**
+After version 2.4.1 , Unity SDK support `Package Manager` Integration
+3. Open menu `Window` - `Package Manager` 
+4. Click `+` , and select `Add package from git URL...`
+5. Input `https://github.com/ThinkingDataAnalytics/unity-sdk.git` , and click `Add`, wait for loading to complete
+## **2. Initialization**
+We recommend to initialize the SDK manually, and also provide a way to automatically initialize the SDK by loading prefabs.
+### **2.1 Manual initialization**
+```csharp
+//Initialize SDK
+//Method 1
+TDAnalytics.Init("APPID","SERVER");
+//Method 2
+TDConfig config = new TDConfig("APPID","SERVER");
+TDAnalytics.Init(config);
+```
+
+### **2.2 Automatic initialization**
+<callout emoji="first_place_medal" background-color="light-orange" border-color="light-orange">
+HarmonyOS currently does not support automatic collection.
+</callout>
+
+6. Add prefab named `TDAnalytics` to GameObject, and set project information
+<image token="Br9obI1KUonQEyxC5CPcXwAinvb" width="724" height="636" align="center"/>
+
+The configuration items in the picture are:
+**Configuration**
+- **Start Manually: **Enable manual initialization
+  - If `Start Manually` is selected, you need to call `TDAnalytics.Init()` to complete SDK initialization
+  - If `Start Manually` is not selected, SDK will be initialized when the prefab ThinkingAnalytics is loaded
+- **Enable Log: **Enable log output
+  - If `Enable Log`  is selected, SDK will output  log on the consoles to debugging. You can check whether the event data is correctly reported to TE in the Unity Editor.  For invalid properties, a warning log will be displayed on the console
+**Tokens**
+One Token represents one instance. If you need to report data to multiple projects, you can click "+" to add project configuration
+- **APP ID: **The APPID of your project, which can be found on the project management page of the TE.
+- **SERVER URL**: 
+  - If you are using a SaaS version, please check the receiver URL on this page
+<image token="HnN8berA7o8DU1xkBEpchChOnig" width="1674" height="1318" align="left"/>
+
+- If you are using a privatized deployment version, please bind the data tracking URL with a domain name and configure it with an HTTPS certificate: `https://bind the domain name with the data tracking URL`
+<quote-container>
+Since some devices restrict HTTP requests by default, please use HTTPS protocol only.
+</quote-container>
+
+- **MODE**: The SDK mode, please be sure to use the NORMAL mode in the production environment.
+### 2.3 Initialize via ProjectSettings
+If the SDK version is greater than or equal to 3.3.0-beta.1, you can configure the initialization parameters through ProjectSettings.
+<image token="QOKfbyOB8ofB3IxMN89cf5DVn8c" width="2104" height="1296" align="center"/>
+
+- **APP ID**: The APPID of your project, which can be found on the project management page of the TE.
+- **SERVER URL**: Need to be configured, which is the URL of the data receiving end:
+  - If you are using a cloud service, enter the following URL: https://global-receiver-ta.thinkingdata.cn
+  - If you are using a privately deployed version, please enter the following URL: https://data collection address
+- **MODE**: SDK instance running mode. Please use NORMAL mode for the build environment.
+- **Enable Log : **Log switch
+- **Network Type ：**Set the reporting network status
+- **Time Zone ：**Set the default time zone
+<quote-container>
+注意：由于一些设备默认禁止明文传输，因此强烈建议您使用 HTTPS 格式的接收端地址
+</quote-container>
+
+## **3. Common Features**
+We suggest that you read [User Identification Rules](https://thinkingdata.feishu.cn/wiki/Pov9wECdsi2QQsk4NN9cEPsvnyc) before using common features; SDK would generate a random number that would be used as the distinct ID, and save the ID locally. Before the user logs in, the distinct ID would be used as the identification ID.   Note: The distinct ID would change after the user reinstalled the App or used the APP with a new device.
+### **3.1 Login**
+When the users log in , `Login` could be called to set the account ID of the user. TE platform would use the account ID as the identification ID, and this ID would be saved before `Logout` is called. The previous account ID would be replaced if `Login` has been called multiple times.
+```csharp
+// The login unique identifier of the user, corresponding to the #account_id in data tracking. #Account_id now is TE
+TDAnalytics.Login("TE");
+```
+
+<quote-container>
+**Login events wouldn't be uploaded in this method.**
+</quote-container>
+
+### 3.2 **Super Properties**
+Super properties refer to properties that each event might have. You can call `SetSuperProperties` to set super properties. It is recommended that you set super properties first before sending data. Some important properties (e.g., the membership class of users, source channels, etc.) should be set in each event. At this time, you can set these properties as super properties.
+```csharp
+Dictionary<string, object> superProperties = new Dictionary<string, object>();
+superProperties["channel"] = "te";//string
+superProperties["age"] = 1;//number
+superProperties["isSuccess"] = true;//boolean
+superProperties["birthday"] = DateTime.Now;//time
+superProperties["object"] = new Dictionary<string, object>(){{ "key", "value"}};//object
+superProperties["object_arr"] = new List<object>() {new Dictionary<string, object>(){{ "key", "value" }}};//object array
+superProperties["arr"] = new List<object>() { "value" };//array
+TDAnalytics.SetSuperProperties(superProperties);//set super properties
+```
+
+Super properties would be saved in local storage, and will not need to be called every time the App is opened. If the super properties set previously are uploaded after calling `SetSuperProperties`, previous properties would be replaced. 
+- Key is the name of the property and refers to the string type. It must start with a character, and contain numbers, characters (insensitive to case, and upper cases would be transformed into lower cases by TE) and underscores "_", with a maximum length of 50 characters. 
+- Value, the value of the property, supports string, numbers, boolean, time, object, array object, and array
+<quote-container>
+**The requirements for event properties and user properties are the same with that for super properties**
+</quote-container>
+
+### **3.3 Automatically Track Events**
+The following code is an example of install, active and inactive events. To get more information about the automatic tracking of SDK, please refer to [Automatic Event Tracking](https://thinkingdata.feishu.cn/wiki/VK92wPhIqirJJAknRxLcG3fsnNe)
+```csharp
+//enable auto-tracking events
+TDAnalytics.EnableAutoTrack(TDAutoTrackEventType.AppInstall | TDAutoTrackEventType.AppStart | TDAutoTrackEventType.AppEnd);
+```
+
+### **3.4 Sending Events**
+You can call `Track` to upload events. It is suggested that you set event properties based on the data tracking plan drafted previously. Here is an example of a user buying an item:
+```csharp
+Dictionary<string, object> properties = new Dictionary<string, object>(){{"product_name", "商品名"}};
+TDAnalytics.Track("product_buy", properties);
+```
+
+The event name is string type. It could only start with a character and could contain figures, characters, and an underline "_", with a maximum length of 50 characters.
+### **3.5 User Properties**
+You can set general user properties by calling `UserSet` api. The original properties would be replaced by the properties uploaded via this api. The data type of newly-created user properties must be the same as the uploaded properties. User name setting is taken as the example here:
+```csharp
+//the username now is TA
+TDAnalytics.UserSet(new Dictionary<string, object>(){{"user_name", "TA"}});
+//the username now is TE
+TDAnalytics.UserSet(new Dictionary<string, object>(){{"user_name", "TE"}});
+```
+
+## **4. Best Practice**
+The following sample code covers all the above-mentioned operations. It is recommended that the SDK be used in the following steps:
+```csharp
+if (privacy policy is authorized)
+{  
+   //Initialize SDK
+   TDAnalytics.Init("APPID", "SERVER");
+   //if the user has logged in, the account ID of the user could be set as the unique identifier 
+   TDAnalytics.Login("TE");
+   //After setting super properties, each event would have super properties
+   Dictionary<string, object> superProperties = new Dictionary<string, object>();
+   superProperties["channel"] = "te";//string
+   superProperties["age"] = 1;//number
+   superProperties["isSuccess"] = true;//boolean
+   superProperties["birthday"] = DateTime.Now;//time
+   superProperties["object"] = new Dictionary<string, object>(){{ "key", "value"}};//object
+   superProperties["object_arr"] = new List<object>() {new Dictionary<string, object>(){{ "key", "value" }}};//object array
+   superProperties["arr"] = new List<object>() { "value" };//array
+   TDAnalytics.SetSuperProperties(superProperties);//set super properties
+   //Enable auto-tracking
+   TDAnalytics.EnableAutoTrack(TDAutoTrackEventType.AppInstall | TDAutoTrackEventType.AppStart | TDAutoTrackEventType.AppEnd);
+   //Upload events
+   Dictionary<string, object> properties = new Dictionary<string, object>(){{"product_name", "商品名"}};
+   TDAnalytics.Track("product_buy", properties);
+   //Set user properties
+   TDAnalytics.UserSet(new Dictionary<string, object>(){{"user_name", "TA"}});
+}
+```