@thinkingai/ae-cli 1.0.28 → 6.0.16

package/wiki/te-docs/raw/data-ingestion-guide/client-sdk/c/c-advanced.md

@@ -0,0 +1,419 @@
+---
+code: csharp_sdk_advanced
+name: "C#-Advanced"
+wikiToken: Lx4bwX6lEiEdy7kLndmcs86JnSh
+parentWikiToken: ENH2wrxtFicwM7koUgtcPsaCnOE
+updateTime: 1774252000000
+sourceUrl: https://docs-v2.thinkingdata.cn/?version=v6.0&lan=en-US&code=csharp_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://thinkingdata.feishu.cn/wiki/Pov9wECdsi2QQsk4NN9cEPsvnyc)<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 `SetIdentity` to set the distinct ID:
+```csharp
+TDAnalytics.SetDistinctId("Thinker");
+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 `Log``o``ut` is called. The previous account ID would be replaced if `Login` has been called multiple times.
+```csharp
+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. 
+```java
+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>
+
+## **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> dic = new Dictionary<string, object>();
+dic.Add("product_name", "product name");
+TDAnalytics.Track( "product_buy",dic);
+```
+
+### **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> dic = new Dictionary<string, object>();
+dic.Add("key", "value");
+TDFirstEventModel firstEventModel = new TDFirstEventModel("device_activation", dic);
+TDAnalytics.Track(firstEventModel);
+```
+
+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
+Dictionary<string, Object> dic = new Dictionary<string, object>();
+dic.Add("key", "value");
+TDFirstEventModel firstEventModel = new TDFirstEventModel("device_activation", dic,"TA");
+TDAnalytics.Track(firstEventModel);
+```
+
+<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
+Dictionary<string, Object> dic = new Dictionary<string, object>();
+dic.Add("price", 100);
+dic.Add("status",3);
+TDUpdatableEventModel updatableEventModel = new TDUpdatableEventModel("UPDATABLE_EVENT", dic, "updateEventId");
+TDAnalytics.Track(updatableEventModel);
+
+//The event property status is 5 after reporting, with the price remaining the same
+Dictionary<string, Object> dic1 = new Dictionary<string, object>();
+dic1.Add("status",5);
+TDUpdatableEventModel updatableEventModel = new TDUpdatableEventModel("UPDATABLE_EVENT", dic1,"updateEventId");
+TDAnalytics.Track(updatableEventModel);
+```
+
+###  **2.4 Overwritable Events**
+Despite the similarity with Updatable Events, Overwritable Events would replace all historical data with the latest date. 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
+Dictionary<string, Object> dic = new Dictionary<string, object>();
+dic.Add("price", 100);
+dic.Add("status",3);
+TDOverwritableEventModel overwritableEventModel = new TDOverwritableEventModel("OVERWRITABLE_EVENT", dic,"eventId");
+TDAnalytics.Track(overwritableEventModel);
+
+//The event property status is 5 after reporting, with the price deleted
+Dictionary<string, Object> dic1 = new Dictionary<string, object>();
+dic1.Add("status",5);
+TDOverwritableEventModel overwritableEventModel = new TDOverwritableEventModel("OVERWRITABLE_EVENT", dic1,"eventId");
+TDAnalytics.Track(overwritableEventModel);
+```
+
+### **2.5 Common event properties**
+Public event attributes refer to the attributes that are uploaded for each event.
+#### 2.5.1 Static public event attributes
+Static public event attributes are attributes that change infrequently and are carried by each event, such as user membership level. After setting static public event attributes through setSuperProperties, the SDK will obtain the set public event attributes as event attributes when collecting events.
+```javascript
+Dictionary<string, object> superProperties = new Dictionary<string, object>();
+superProperties["vip_level"] = 2;
+TDAnalytics.SetSuperProperties(superProperties);
+```
+
+Static public event attributes will be saved in the cache and do not need to be called every time the App is started. If the attribute already exists, the re-set attribute will overwrite the original attribute value; if the attribute did not exist before, a new attribute will be created. In addition to attribute settings, we also provide other APIs to manage static public event attributes to meet daily business needs.
+```javascript
+//Clear a public event property
+TDAnalytics.UnsetSuperProperties("Channel");
+//Clear all public event properties
+TDAnalytics.ClearSuperProperties();
+//Get all public event properties
+var superProperties = TDAnalytics.GetSuperProperties();
+```
+
+#### 2.5.2 Dynamic public event attributes
+Dynamic public event attributes are attributes that change frequently and are carried by each event, such as the number of gold coins of a user. After setting the dynamic public attribute class through SetDynamicSuperProperties, the SDK will automatically obtain the attributes when collecting events and add them to the triggered events.
+```javascript
+static Dictionary<string, object> GetDynamicSuperProperties()
+{
+return new Dictionary<string, object> { { "coin", 10 } };
+}
+
+TDAnalytics.Init(config);
+TDAnalytics.SetDynamicSuperProperties(GetDynamicSuperProperties);
+```
+
+### 2.6 Recording event duration
+If you need to record the duration of an event, you can call timeEvent to start timing. Configure the event name you want to time. When you upload the event, the #duration attribute will be automatically added to your event attributes to indicate the recorded duration in seconds. It should be noted that there can only be one task being timed for the same event name.
+```javascript
+//The user enters the product page and starts timing
+TDAnalytics.TimeEvent("stay_shop");
+/**do someting
+.......
+**/
+//The user leaves the product page and the timing ends. The "stay_shop" event will have the attribute #duration indicating the duration of the event
+TDAnalytics.Track("stay_shop");
+```
+
+## **3. User Properties**
+User property setting APIs supported by TE  include:  `UserSet`,`UserSetOnce`,`UserAdd`,`UserUnset`,`UserDelete`,`UserAppend`
+### 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 ignored. 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_pay_time","2018-01-01 01:23:45.67"}});
+//first_payment_time is still 2018-01-01 01:23:45.678
+TDAnalytics.UserSetOnce(new Dictionary<string, object>(){{"first_pay_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
+//in this case, the total_revenue is 30
+TDAnalytics.UserAdd(new Dictionary<string, object>(){{"total_revenue",30}});
+//in this case, the 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
+List<string> list2 = new List<string>();
+list2.Add("nickname");
+list2.Add("age");
+TDAnalytics.UserUnSet(list2);
+```
+
+###  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
+Dictionary<string, object> dictionary = new Dictionary<string, object>();
+List<string> list6 = new List<string>();
+list6.Add("true");
+list6.Add("test");
+dictionary.Add("arrkey4", list6);
+TDAnalytics.UserAppend( dictionary);
+```
+
+## Encryption function
+Starting from v2.0.0-beta.1, SDK supports the use of AES+RSA to encrypt data. The data encryption function requires the cooperation of the client and the server. Please consult the customer success personnel for specific usage methods.
+```javascript
+TDConfig config = new TDConfig();
+config.AppId = appid;
+config.ServerUrl = server_url;
+config.EnableEncrypt = true;
+config.Version = 1;
+config.PublicKey = "publickKey";
+TDAnalytics.Init(config);
+```
+
+## **Others**
+### **5****.1 Printing Log**
+During the process of SDK integration, you can perform real-time debugging by checking SDK's logs in the IDE console or using the Debug feature of TE.
+```cpp
+// After enabling, the log will be viewed in the ta_event_log.txt file in the project root directory
+TDAnalytics.EnableLogType(TDLogType.LogTxt);
+```
+
+### **5****.2** **Preset Properties of All Events**
+
+<lark-table rows="10" cols="4" column-widths="169,152,140,259">
+
+  <lark-tr>
+    <lark-td>
+      ** Property name **
+    </lark-td>
+    <lark-td>
+      **Display name **
+    </lark-td>
+    <lark-td>
+      ** Property type **
+    </lark-td>
+    <lark-td>
+      ** Instruction **
+    </lark-td>
+  </lark-tr>
+  <lark-tr>
+    <lark-td>
+      #ip
+    </lark-td>
+    <lark-td>
+      IP address
+    </lark-td>
+    <lark-td>
+      Text
+    </lark-td>
+    <lark-td>
+      IP address of the user, based on which TE would get the geographical location of the user
+    </lark-td>
+  </lark-tr>
+  <lark-tr>
+    <lark-td>
+      #country
+    </lark-td>
+    <lark-td>
+      Country
+    </lark-td>
+    <lark-td>
+      Text
+    </lark-td>
+    <lark-td>
+      The country where the user is located; generated based on the IP address
+    </lark-td>
+  </lark-tr>
+  <lark-tr>
+    <lark-td>
+      #country_code
+    </lark-td>
+    <lark-td>
+      Country code
+    </lark-td>
+    <lark-td>
+      Text
+    </lark-td>
+    <lark-td>
+      The code of the country where the user is located (ISO 3166-1 alpha-2, two English characters in upper case); generated based on the IP address
+    </lark-td>
+  </lark-tr>
+  <lark-tr>
+    <lark-td>
+      #province
+    </lark-td>
+    <lark-td>
+      Province
+    </lark-td>
+    <lark-td>
+      Text
+    </lark-td>
+    <lark-td>
+      The province or state where the user is located; generated based on the IP address
+    </lark-td>
+  </lark-tr>
+  <lark-tr>
+    <lark-td>
+      #city
+    </lark-td>
+    <lark-td>
+      City
+    </lark-td>
+    <lark-td>
+      Text
+    </lark-td>
+    <lark-td>
+      The city where the user is located; generated based on the IP address
+    </lark-td>
+  </lark-tr>
+  <lark-tr>
+    <lark-td>
+      #os
+    </lark-td>
+    <lark-td>
+      OS
+    </lark-td>
+    <lark-td>
+      Text
+    </lark-td>
+    <lark-td>
+      E.g., Android, iOS, Mac OS, etc.
+    </lark-td>
+  </lark-tr>
+  <lark-tr>
+    <lark-td>
+      #device_id
+    </lark-td>
+    <lark-td>
+      Device ID
+    </lark-td>
+    <lark-td>
+      Text
+    </lark-td>
+    <lark-td>
+      The ID of the user device; IDFV or UUID of the user for iOS; androidID for Android
+    </lark-td>
+  </lark-tr>
+  <lark-tr>
+    <lark-td>
+      #lib
+    </lark-td>
+    <lark-td>
+      SDK type
+    </lark-td>
+    <lark-td>
+      Text
+    </lark-td>
+    <lark-td>
+      The type of the SDK to which you access, e.g., Android，iOS, etc.
+    </lark-td>
+  </lark-tr>
+  <lark-tr>
+    <lark-td>
+      #lib_version
+    </lark-td>
+    <lark-td>
+      SDK version
+    </lark-td>
+    <lark-td>
+      Text
+    </lark-td>
+    <lark-td>
+      The version of the SDK to which you access
+    </lark-td>
+  </lark-tr>
+</lark-table>
+
+### 5.3 Time Calibration
+The SDK uses the local time as the event occurrence time by default. If the user manually modifies the device time and affects your business analysis, you can calibrate the time to ensure the accuracy of the event occurrence time. We provide a timestamp time calibration method.
+- You can use the current timestamp obtained from the server to calibrate the SDK time. After that, all calls without a specified time, including event data and user attribute setting operations, will use the calibrated time as the occurrence time.
+```javascript
+// 1585633785954 is the current unix timestamp in milliseconds, corresponding to Beijing time 2020-03-31 13:49:45
+TDAnalytics.CalibrateTime(1585633785954);
+```
+
+- You can also set automatic time calibration, after which the SDK will try to obtain the current time from the config interface and calibrate the SDK time. If the correct return result is not obtained, the local time will be used to report the data later.
+```javascript
+TDConfig config = new TDConfig();
+config.AppId = appid;
+config.ServerUrl = server_url;
+config.EnableAutoCalibrated = true;
+TDAnalytics.Init(config);
+```
+
+### 5.4 Send data immediately
+In some business scenarios, if you expect data to be reported to the TE server immediately, you can do so by calling the flush interface
+```javascript
+TDAnalytics.Flush();
+```
+
+### 5.5 Get device ID
+You can get the device ID by calling getDeviceId:
+```javascript
+TDAnalytics.GetDeviceId();
+```
+
+### 5.6 Set the default time zone
+By default, the SDK uses the local time when the interface is called as the event occurrence time for reporting. You can also specify the default time zone by setting the default time zone interface, so that all events will be aligned with the time zone you set:
+```javascript
+TDConfig config = new TDConfig();
+config.AppId = appid;
+config.ServerUrl = server_url;
+config.ZoneOffset = 5;
+TDAnalytics.Init(config);
+```
+
+Note: Aligning event times with a specified time zone will lose the device's local time zone information. If you need to keep the device's local time zone information, you currently need to add relevant attributes to the event yourself.

package/wiki/te-docs/raw/data-ingestion-guide/client-sdk/c/release-notes.md

@@ -0,0 +1,45 @@
+---
+code: client_csharp_sdk_release_note
+name: "Release Notes"
+wikiToken: Ob12wuqdUiupq4kKfBlcmSkPnUc
+parentWikiToken: ENH2wrxtFicwM7koUgtcPsaCnOE
+updateTime: 1774249215000
+sourceUrl: https://docs-v2.thinkingdata.cn/?version=v6.0&lan=en-US&code=client_csharp_sdk_release_note
+---
+
+## v2.0.1
+**Date: 10/13/2025 **[**下载**](https%3A%2F%2Fdownload.thinkingdata.cn%2Fclient%2Fcsharp%2Ftd_analytics_csharp_client_v2.0.1.zip)
+**Notes：**
+- Known issues fixed
+## v2.0.0
+**Date: 10/09/2025 **[**下载**](https%3A%2F%2Fdownload.thinkingdata.cn%2Fclient%2Fcsharp%2Ftd_analytics_csharp_client_v2.0.0.zip)
+**Notes：**
+- Supports automatic time calibration
+- Supports timing events
+- Newly added encryption function
+- Supports custom time zone function
+## v1.3.0
+**Date: 11/08/2023**
+**Notes：**
+- Code specifications and comment specifications
+- Supports obtaining visitor ID
+- Support timestamp calibration
+- Get static public properties
+- Add UserUniqAppend API
+## v1.2.0
+**Date: **04/06/2023
+**Notes：**
+- Optimize code
+- Compatible with mac os
+## v1.1.0
+**Date:** 2022/09/27
+**Notes:**
+- Support for complex data types
+- Standardize external API
+##  v1.0.0
+**Date:** 2022/06/09
+**Notes:**
+- Support setting of visitor ID and user account
+- Support event and user attribute reporting
+- Support reporting of first, update and rewrite events
+- Support Windows data reporting

package/wiki/te-docs/raw/data-ingestion-guide/client-sdk/c.md

@@ -0,0 +1,110 @@
+---
+code: csharp_client_sdk_installation
+name: "C#"
+wikiToken: ENH2wrxtFicwM7koUgtcPsaCnOE
+parentWikiToken: KaFCwNeV3iRxjNkpT3QcDMg3n5V
+updateTime: 1774251999000
+sourceUrl: https://docs-v2.thinkingdata.cn/?version=v6.0&lan=en-US&code=csharp_client_sdk_installation
+---
+::: tip
+Before you begin, please read [Preparations before Data Ingestion](https://thinkingdata.feishu.cn/wiki/OhD8we9iai6Xk5kM1QNc8ITRnQe)
+Supported platforms: Windows.
+ :::
+**Latest version:** 2.0.1
+**Update time:** 10/13/2025
+**Resource download: **[SDK Source Code](https%3A%2F%2Fgithub.com%2FThinkingDataAnalytics%2Fcsharp-client-sdk)
+## 1. **SDK**** Integration**
+### 1.1 Download SDK
+Download Source Code from [GitHub](https%3A%2F%2Fgithub.com%2FThinkingDataAnalytics%2Fcsharp-client-sdk),  add the files in the `TDAnalyticsSDK` directory to the project.
+The SDK relies on `Newtonsoft.Json` for json parsing. If you are using `Visual Studio`, please use `NuGet` to add `Newtonsoft.Json` library.
+### 1.2 Add dynamic library
+- Download the dll and unzip it (you can download any one)
+  - [github link](https%3A%2F%2Fgithub.com%2FThinkingDataAnalytics%2Fcsharp-client-sdk%2Fblob%2Fmain%2Fdll%2Fta_csharp_sdk.zip)
+  - [official website link](https%3A%2F%2Fdownload.thinkingdata.cn%2Fclient%2Frelease%2Ftd_analytics_csharp_client.zip)
+- For Windows platform, you can find the dll file in the windowswen folder and copy it to the project root directory. (Note: If the dll conflicts with the existing dll in the project, just use the existing one in the project)
+<image token="VlfNbOkbdoVtTux2HEHcUhqpnxg" width="728" height="335" align="center"/>
+
+- Mac platform
+  - Step 1: Install sqlite, curl, zlib, openssl through homebrew
+  - Step 2: Find the dll file in the macOS folder and copy it to the project root directory
+  <image token="U1rVbMHfToJZc3xPTcqcQ9RWndg" width="731" height="217" align="center"/>
+
+## **2. Initialization**
+```csharp
+using ThinkingData.Analytics;
+TDAnalytics.Init(APPID,SERVER_URL)
+```
+
+Instruction on parameters:
+- `APPID`: The APP ID 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="OOXjbbcBioOIm8x1ZPMcYlCFnFr" width="1280" height="1007" align="center"/>
+
+
+- If you use the private deployment version, you can customize the data tracking URL .
+## **3. Common Features**
+We suggested 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 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
+TDAnalytics.Login("TA");
+```
+
+<quote-container>
+**Login events wouldn't be uploaded in this method.**
+</quote-container>
+
+
+### **3.2 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> dic = new Dictionary<string, object>();
+dic.Add("channel", "te");//string
+dic.Add("id", 618834);//number
+dic.Add("isSuccess", true);//boolean
+dic.Add("create_date", Convert.ToDateTime("2019-7-8 20:23:22"));//time
+List<string> arr = new List<string>();
+arr.Add("value");
+dic.Add("arr", arr);//array
+TDAnalytics.Track("product_buy", dic);
+```
+
+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.2 User Properties**
+You can set 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
+TDAnalytics.UserSet(new Dictionary<string, object>(){{"user_name", "TA"}});
+```
+
+## **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
+using ThinkingData.Analytics;
+
+TDAnalytics.Init(APPID,SERVER_URL)
+//if the user has logged in, the account ID of the user could be set as the unique identifier 
+TDAnalytics.Login("TA");
+//track
+Dictionary<string, Object> dic = new Dictionary<string, object>();
+dic.Add("channel", "te");//string
+dic.Add("id", 618834);//number
+dic.Add("isSuccess", true);//boolean
+dic.Add("create_date", Convert.ToDateTime("2019-7-8 20:23:22"));//time
+List<string> arr = new List<string>();
+arr.Add("value");
+dic.Add("arr", arr);//array
+TDAnalytics.Track("product_buy", dic);
+// object
+Dictionary<string, object> json = new Dictionary<string, object>();
+json.Add("key", "value");
+dic.Add("object", json);
+//array object
+List<Dictionary<string, object>> arr1 = new List<Dictionary<string, object>>();
+Dictionary<string, object> json1 = new Dictionary<string, object>();
+json1.Add("key", "value");
+arr1.Add(json1);
+dic.Add("objects", arr1);
+//Set user properties
+TDAnalytics.UserSet(new Dictionary<string, object>(){{"user_name", "TA"}});
+```

package/wiki/te-docs/raw/data-ingestion-guide/client-sdk/client-side-sdk-faq.md

@@ -0,0 +1,52 @@
+---
+code: client_sdk_faq
+name: "Client-side SDK FAQ"
+wikiToken: YQC3wSRR2iGPkYkAHieczG6ZnJe
+parentWikiToken: KaFCwNeV3iRxjNkpT3QcDMg3n5V
+updateTime: 1774252003000
+sourceUrl: https://docs-v2.thinkingdata.cn/?version=v6.0&lan=en-US&code=client_sdk_faq
+---
+
+## **What is the client-side ****SDK**** tracking policy?**
+Native client-side SDK (including Unity, Unreal, Flutter, etc. ) data would be stored in the local database firstly. Data tracking would be triggered under the following situations:
+- App enters the background
+- Track once every 30S (can be set in TA background)
+- Trigger tracking when the number of cached data exceeds 30 items (can be set in TE)
+- Call flush interface actively
+Mini-program, mini-game SDK, and JavaScript SDK would be reported in real-time without local storage.
+## **What is the value logic of the ****device ID****?**
+The value logic of the device of native client-side SDK (including Unity, Unreal, Flutter, etc. ) is as follows:
+- Android: Take Android ID as the value
+For systems below Android 8.0, Android ID is the unique device identifier. It would only change after being re-flashed or reset.  Shared by all apps. For systems of Android 8.0 or later versions, each combination of the app signature key, user, and the device has its unique ANDROID_ID value. Therefore, apps operating on the same device with different signature keys would no longer see the same Android ID (which also applies to the same user). A special condition: if the device on which the APP installed by the user is below 8.0, the APP was uninstalled later and reinstalled after the device was upgraded to 8.0, Android ID would become different. If the APP is not reinstalled, the Android ID would not change. 
+- iOS: obtain IDFV first. Use a random UUID if failed to obtain IDFV. The first device ID value would be stored in the key string and no longer change, although IDFC changes subsequently. 
+Mini-program, mini-game, and JavaScript interface could not obtain similar device numbers, with a random ID used as the device ID. If the user deletes the cache, the device ID would change. 
+## **What is the lowest system version supported by client-side ****SDK****?**
+The lowest version supported by the client-side SDK is Android 4.0 and iOS 8.0
+## **How to identify tracking problems?**
+Common problems could be identified rapidly through client-side logs. We described how to enable client-side logs in various data ingestion guidance. 
+In Android, you can enable client-side logs by calling the `enableTrackLog` api. You can filter the logs of Android SDK through `ThinkingAnalytics`.
+```java
+ThinkingAnalyticsSDK.enableTrackLog(true);
+```
+
+In iOS, you can enable log printing by calling `setLogLevel` and filter logs of iOS SDK through `THINKING`.
+```objectivec
+[ThinkingAnalyticsSDK setLogLevel:TDLoggingLevelDebug]
+```
+
+After opening the logs, you can send the logs to our technical support engineer to help you identify the problem. 
+If you are not sure whether the receiver URL is correct, you can detect the accessibility of the receiver URL by inspecting the interface. Visit https://YOUR_RECEIVER_URL/health-check. If the page returns ok, it means the address of the receiving end is configured correctly.
+Besides, with the functions of the [tracking management](https://thinkingdata.feishu.cn/wiki/K443wTChAiFc47kBz8ucXqVfnSf) module, you can also identify the problems related to data tracking swiftly. 
+## **What are the precautions for data tracking through Unity ****SDK****?**
+1. The initialization of SDK is completed in Awake(). Therefore, the calling process could not be triggered in Awake
+2. All the interfaces could only be called in the main thread by default. 
+3. We can tell whether the APP could enter the foreground or retreat to the background according to the life cycle of the components of the Android system. However, Unity could not ensure that the program could initialize SDK from the very beginning. Therefore, the first enable event could only be identified when the APP retreat to the background. Currently, we would supplement a ta_app_start (being tracked at a relatively late time) when the APP retreat to the background for the first time. However, the event time #event_time is correct and would not influence subsequent analysis)
+## **What is the content of crash events? How to track crash events?**
+
+The client-side SDK supports the tracking of some crash logs. It is necessary to enable auto-tracking of APP Crash after SDK initialization. The event name corresponding to the crash event is: ta_app_crash.
+Conditions under which crash event tracking would be triggered:
+- Android platform: no anomaly is captured in the virtual machine
+- iOS platform: 
+  - Unix signal anomalies include: SIGABRT, SIGILL, SIGSEGV, SIGFPE, SIGBUS
+  - NSException anomaly
+- Tracking of C$ anomaly in the Unity engine