@thinkingai/ae-cli 1.0.30 → 6.0.16

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

@@ -0,0 +1,366 @@
+---
+code: c++_sdk_advanced
+name: "Cpp-Advanced"
+wikiToken: TBTtw1Tr4iCeZhk24otcOIK6nVf
+parentWikiToken: COFfwkFwFiK0qMkfjJNc7DcMnLc
+updateTime: 1774251998000
+sourceUrl: https://docs-v2.thinkingdata.cn/?version=v6.0&lan=en-US&code=c%2B%2B_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 `Identify` to set the distinct ID:
+```cpp
+// set distinct ID as Thinker
+ThinkingAnalyticsAPI::Identify("Thinker");
+```
+
+If you need to get the current distinct ID, please call `DistinctID()`:
+```cpp
+// Return distinct ID
+ThinkingAnalyticsAPI::DistinctID().c_str()
+```
+
+### **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. 
+```cpp
+// The login unique identifier of the user, corresponding to the #account_id in data tracking. #Account_id now is TE
+ThinkingAnalyticsAPI::Login("TE");
+```
+
+<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. 
+```cpp
+ThinkingAnalyticsAPI::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 business requirements.
+### **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:
+```cpp
+TDJSONObject event_properties;
+event_properties.SetString("product_name", "product name");
+ThinkingAnalyticsAPI::Track("product_buy", event_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.
+```cpp
+TDJSONObject jsonObject1;
+jsonObject1.SetString("test","test");
+TDFirstEvent *firstEvent = new TDFirstEvent("device_activation",jsonObject1);
+ThinkingAnalyticsAPI::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:
+```cpp
+//set the user ID as the first_check_id of the first event to track the first initialization event of the user.
+TDJSONObject jsonObject1;
+jsonObject1.SetString("test","test");
+TDFirstEvent *firstEvent = new TDFirstEvent("account_activation",jsonObject1);
+firstEvent->setFirstCheckId("TE");
+ThinkingAnalyticsAPI::Track(firstEvent);
+```
+
+<quote-container>
+Note: Since the server has to check whether the event is the First Event, First Event 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.
+```cpp
+ //The event property status is 3 after reporting, with the price being 100
+TDJSONObject jsonObject;
+jsonObject.SetNumber("status", 3);
+jsonObject.SetNumber("price", 100);
+TDUpdatableEvent *updatableEvent = new TDUpdatableEvent("UPDATABLE_EVENT",jsonObject,"test_event_id");
+ThinkingAnalyticsAPI::Track(updatableEvent);
+
+//The event property status is 5 after reporting, with the price remaining the same
+TDJSONObject jsonObject1;
+jsonObject1.SetNumber("status", 5);
+TDUpdatableEvent *updatableEvent1 = new TDUpdatableEvent("UPDATABLE_EVENT",jsonObject1,"test_event_id");
+ThinkingAnalyticsAPI::Track(updatableEvent1);
+```
+
+### **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.
+```cpp
+// 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
+TDJSONObject jsonObject;
+jsonObject.SetNumber("status", 3);
+jsonObject.SetNumber("price", 100);
+TDOverWritableEvent *event = new TDOverWritableEvent("OVERWRITE_EVENT",jsonObject,"test_event_id");
+ThinkingAnalyticsAPI::Track(event);
+
+//The event property status is 5 after reporting, with the price deleted
+TDJSONObject jsonObject1;
+jsonObject1.SetNumber("status", 5);
+TDOverWritableEvent *event1 = new TDOverWritableEvent("OVERWRITE_EVENT",jsonObject1,"test_event_id");
+ThinkingAnalyticsAPI::Track(event1);
+```
+
+## **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:
+```cpp
+TDJSONObject userProperties;
+//the username now is TA
+userProperties.SetString("username", "TA");
+ThinkingAnalyticsAPI::UserSet(userProperties);
+//the userName now is TE
+TDJSONObject userProperties1;
+userProperties1.SetString("username", "TE");
+ThinkingAnalyticsAPI::UserSet(userProperties1)
+```
+
+### 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:
+```cpp
+//first_payment_time is 2018-01-01 01:23:45.678
+TDJSONObject userProperties;
+userProperties.SetString("first_payment_time","2018-01-01 01:23:45.678");
+ThinkingAnalyticsAPI::UserSetOnce(userProperties);
+
+//first_payment_time is still 2018-01-01 01:23:45.678
+TDJSONObject userProperties1;
+userProperties1.SetString("first_pay_time","2018-12-31 01:23:45.678");
+ThinkingAnalyticsAPI::UserSetOnce(userProperties1);
+```
+
+###  3.3 UserAdd
+When you want to upload numeric property 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:
+```cpp
+//in this case, the total_revenue is 30
+TDJSONObject userProperties;
+userProperties.SetNumber("total_revenue",30;
+ThinkingAnalyticsAPI::UserAdd(userProperties);
+//in this case, the total_revenue is 678
+TDJSONObject userProperties1;
+userProperties1.SetNumber("total_revenue",648);
+ThinkingAnalyticsAPI::UserAdd(userProperties1);
+```
+
+<quote-container>
+The set property 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.
+```cpp
+ThinkingAnalyticsAPI::UserUnset("userUnset_key");
+```
+
+### 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 query the events data triggered by the user.
+```cpp
+ThinkingAnalyticsAPI::UserDelete();
+```
+
+### 3.6 UserAppend
+You can call `U``ser``A``ppend` to add user properties of array type.
+```cpp
+TDJSONObject userProperties;
+vector<string> listValue;
+listValue.push_back("apple");
+listValue.push_back("ball");
+userProperties.SetList("user_list",listValue);
+ThinkingAnalyticsAPI::UserAppend(userProperties);
+```
+
+### 3.7 UserUniAppend
+You can call UserUniqAppend to append user attributes of array type. Calling the UserUniqAppend interface will deduplicate the appended user attributes. The UserAppend interface does not deduplicate, and user attributes may be duplicated.
+```cpp
+//user_list value is ["apple"，"ball"]
+TDJSONObject userProperties1;
+vector<string> listValue1;
+listValue1.push_back("apple");
+listValue1.push_back("ball");
+userProperties1.SetList("user_list",listValue1);
+ThinkingAnalyticsAPI::UserAppend(userProperties1);
+
+//user_list value is ["apple","apple","ball","cube"]
+TDJSONObject userProperties2;
+vector<string> listValue1;
+listValue2.push_back("apple");
+listValue2.push_back("cube");
+userProperties2.SetList("user_list",listValue2);
+ThinkingAnalyticsAPI::UserAppend(userProperties2);
+
+//user_list value is ["apple"，"ball","cube"]
+ThinkingAnalyticsAPI::UserUniqAppend(userProperties2);
+
+```
+
+## Others
+### **4.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
+ThinkingAnalyticsAPI::EnableLog(true);
+```
+
+### **4.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 integrate, 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 integrate
+    </lark-td>
+  </lark-tr>
+</lark-table>
+
+### 

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

@@ -0,0 +1,103 @@
+---
+code: c++_sdk_release_notes
+name: "Release Notes"
+wikiToken: RXP9wUaJwi2fZhknp9XcfycJnqg
+parentWikiToken: COFfwkFwFiK0qMkfjJNc7DcMnLc
+updateTime: 1774249209000
+sourceUrl: https://docs-v2.thinkingdata.cn/?version=v6.0&lan=en-US&code=c%2B%2B_sdk_release_notes
+---
+
+## v1.5.3
+**Date: 10/11/2025**
+**Notes：**
+- Known issues fixed
+## v1.5.1
+**Date: 08/01/2025**
+**Notes：**
+- Known issues fixed
+## v1.5.0
+**Date: 06/025/2025**
+**Notes：**
+- Thread optimization for configuration information retrieval
+- Solve the problem of massive data duplication
+## v1.4.5-beta.1
+**Date: 06/06/2025**
+**Notes：**
+- Support multi-process
+- Add custom timezone function
+- Fix known issues
+## v1.4.3.3
+**Date: 05/29/2025**
+**Notes：**
+- Fixed known issues
+## v1.4.3.2
+**Date: 03/28/2025**
+**Notes：**
+- Fixed known issues
+## v1.4.1
+**Date: 01/04/2024**
+**Notes：**
+- Support custom storage paths for account IDs, visitor IDs, and static public attributes
+## v1.4.0
+**Date: ****12****/****05****/202****3**
+**Notes：**
+- Support custom database storage path
+## v1.3.9
+**Date: 11/01/2023**
+**Notes：**
+- Preset attribute collection and obtaining public preset attributes
+- Dynamic public properties
+- Debug, DebugOnly mode
+- Data caching policy configuration (minimum data storage capacity, maximum retention time)
+- Support UserUniqAppend
+## v1.3.8
+**Date: 09/05/2023**
+**Notes：**
+- Code specifications, log specifications, comment specifications
+- Statistics of event duration
+- Get super properties, clear super properties, clear a certain super property
+- Support scheduled data reporting strategy
+- Support server side disable event
+- Supports obtaining device ID
+## v1.3.7.1
+**Date: 09/01/2023**
+**Notes：**
+- Fix bugs
+## v1.3.7
+**Date: 06/26/2023**
+**Notes：**
+- Fixed the problem of converting reported data from original string to array.
+- Support data transmission encryption
+- Support time calibration
+- Add encryption failure callback
+## v1.3.6
+**Date: 05/26/2023**
+**Notes：**
+- Use semaphore to optimize data sending efficiency
+- Support dll access
+## v1.3.5
+**Date: **05/12/2023
+**Notes：**
+- Optimize SDK code to avoid null pointer operations
+- Add local log output
+- Add global error callback
+## v1.3.4
+**Date:** 2023/03/30
+**Notes:**
+- Optimize SDK code
+## v1.3.3
+**Date:** 2023/03/21
+**Notes:**
+- Optimize SDK code
+## v1.2.0
+**Date:** 2022/10/26
+**Notes:**
+- Standardize the API naming of the SDK
+- Optimize SDK code
+##  v1.0.0
+**Date:** 2022/03/31
+**Notes:**
+- Support setting of visitor ID and user account
+- Support event and user attribute reporting
+- Support reporting of first, update and rewrite events
+- Support Mac and Windows data reporting

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

@@ -0,0 +1,201 @@
+---
+code: cpp_sdk_installation
+name: "Cpp"
+wikiToken: COFfwkFwFiK0qMkfjJNc7DcMnLc
+parentWikiToken: KaFCwNeV3iRxjNkpT3QcDMg3n5V
+updateTime: 1774251998000
+sourceUrl: https://docs-v2.thinkingdata.cn/?version=v6.0&lan=en-US&code=cpp_sdk_installation
+---
+
+::: tip
+Before you begin, please read [<text color="purple" underline="true">Preparation before Data Ingestion</text>](https://thinkingdata.feishu.cn/wiki/OhD8we9iai6Xk5kM1QNc8ITRnQe)
+You can get the[ C++ SDK Source Code](https%3A%2F%2Fgithub.com%2FThinkingDataAnalytics%2Fcpp-sdk) on GitHub.
+Supported platforms:  Mac , Windows .
+Supported C++ Version: 11 and above versions, and the size is about 144KB
+ :::
+**Latest version:** 1.5.3
+**Update time:** 10/112025
+**Resource download: **[SDK Source Code](https%3A%2F%2Fgithub.com%2FThinkingDataAnalytics%2Fcpp-sdk)
+
+## **1. ****SDK**** Integration**
+### 1.1 Download SDK
+Download the SDK source code, unzip it and enter `cpp-client/cpp`folder.
+`include` is the SDK header file.
+`src` is the SDK source code file.
+ `thirdparty` is the dependent third-party library.
+### **1.2 Dependencies**
+The C++ SDK depends on sqlite, curl, zlib and openssl libraries. Due to differences in platform feature, the formats of the libraries are also different. You can use the compiled library, or you can compile the library yourself.
+#### **1.2.1 Libraries compiled using ****TE**
+The library is generated by the MGWin compiler on the x64 platform of Windows, and the compiled library in the thirdparty folder is configured into the project. (.dll is a dynamic library, .lib is a static library)
+<image token="SAWGbph63oYM3kxVvpAcgkwhnff" width="1532" height="270" align="left"/>
+
+#### **1.2.2 Libraries  Compile by yourself**
+Here take the windows platform as an example:
+Download the curl library, https://github.com/curl/curl/releases/tag/curl-7_61_1. After decompression, switch to the `winbuild` directory and compile. The compilation command is as follows. The compilation result is under the `curl` directory `builds`.
+```cpp
+nmake /f Makefile.vc mode=static ENABLE_IDN=no
+```
+
+Download the zlib library, https://github.com/madler/zlib/releases/tag/v1.2.11, after decompression, execute the compilation command, the compilation result is in the `zlib` directory.
+```cpp
+nmake -f win32/Makefile.msc
+```
+
+Download the sqlite library, https://www.sqlite.org/download.html, select the library of the specified platform.
+Download the openssl library, https://github.com/openssl/openssl, select the library of the specified platform.
+<callout emoji="round_pushpin" background-color="light-orange" border-color="light-orange">
+In addition to the command line, you can also use IDE (Integrated Development Environment), such as Visual Studio, Clion, etc. to generate libraries for the corresponding platform.
+</callout>
+
+### 1.3 **SDK**** Integration**
+#### **1.3.1 CMake **
+Use CMake to integrate the C++ SDK, copy the cpp folder to the project, and add the following configurations for Windows and Mac in the CMakeLists.txt file:
+Set version of C++:
+```apache
+set(CMAKE_CXX_STANDARD 11)
+```
+
+Import header file:
+```makefile
+include_directories(cpp/include)
+```
+
+Windows platform configuration:
+```powershell
+if(WIN32)
+    if(CMAKE_SIZEOF_VOID_P EQUAL 8) # x64
+        include_directories(cpp/thirdparty/x64/curl/include cpp/thirdparty/x64/zlib/include cpp/thirdparty/x64/sqlite/include cpp/thirdparty/x64/openssl/include)
+        link_directories(cpp/thirdparty/x64/curl/lib cpp/thirdparty/x64/zlib/lib cpp/thirdparty/x64/sqlite/lib cpp/thirdparty/x64/openssl/lib)
+    else() # Win32
+        include_directories(cpp/thirdparty/x86/curl/include cpp/thirdparty/x86/zlib/include cpp/thirdparty/x86/sqlite/include cpp/thirdparty/x86/openssl/include)
+        link_directories(cpp/thirdparty/x86/curl/lib cpp/thirdparty/x86/zlib/lib cpp/thirdparty/x86/sqlite/lib cpp/thirdparty/x86/openssl/lib)
+    endif()
+    add_library(thinkingdata SHARED cpp/src/ta_analytics_sdk.cpp cpp/src/ta_cpp_helper.cpp cpp/src/ta_cpp_network.cpp cpp/src/ta_cpp_utils.cpp cpp/src/ta_sqlite.cpp cpp/src/ta_timer.cpp cpp/src/ta_event_task.cpp cpp/src/ta_cpp_send.cpp cpp/src/ta_json_object.cpp cpp/src/ta_cJSON.c cpp/src/ta_encrypt.cpp cpp/src/ta_calibrated_time.cpp cpp/src/ta_flush_task.cpp)
+    target_link_libraries(thinkingdata libcurl sqlite3 zlibwapi libssl libcrypto)
+endif()
+```
+
+Mac platform configuration:
+```c
+if (CMAKE_HOST_APPLE)
+    find_library(COCOA Cocoa)
+    find_library(IOKIT IOKit)
+    find_package(OpenSSL REQUIRED)
+    include_directories(${OPENSSL_INCLUDE_DIR})
+    link_directories(${OPENSSL_LIBRARIES})
+    add_library(thinkingdata SHARED cpp/src/ta_analytics_sdk.cpp cpp/src/ta_cpp_helper.cpp cpp/src/ta_cpp_network.cpp cpp/src/ta_cpp_utils.cpp cpp/src/ta_sqlite.cpp cpp/src/ta_timer.cpp cpp/src/ta_event_task.cpp cpp/src/ta_cpp_send.cpp cpp/src/ta_json_object.cpp cpp/src/ta_cJSON.c cpp/src/ta_mac_tool.mm cpp/src/ta_encrypt.cpp cpp/src/ta_calibrated_time.cpp cpp/src/ta_flush_task.cpp)
+    target_link_libraries(thinkingdata curl z sqlite3 ${OPENSSL_LIBRARIES} ${COCOA} ${IOKIT})
+endif()
+```
+
+#### **1.3.2 Libraries  Compile by yourself**
+1. Download the SDK code and cd to the cmakelist file directory
+2. Execute the following command
+```java
+//Windows platform uses visual studio to compile
+//x86
+cmake -S . -B build -G "Visual Studio 17 2022" -A Win32
+ //x64
+cmake -S . -B build -G "Visual Studio 17 2022" -A x64
+```
+
+```asm
+//Mac
+// arm64 m1
+arch -arm64 cmake -B build
+arch -arm64 cmake --build build
+
+//x86_64  intel
+arch -x86_64 cmake -B build
+arch -x86_64 cmake --build build
+```
+
+#### **1.3.3 Using source code integration**
+After completing the three-party dependency configuration in step 1 and 2, add the include and src folders to the project.
+<image token="Nt1DbY1Ypo3wrhxYdQZcKmaAnDg" width="1078" height="258" align="center"/>
+
+#### 1.3.4 Use compiled library
+[SDK Download](https%3A%2F%2Fdownload.thinkingdata.cn%2Fclient%2Frelease%2Fta_cpp_client.zip)
+After downloading and decompressing, you can find the corresponding dll files for x64 and x86 platforms, which can be used directly.
+## **2. Initialization**
+```cpp
+#include "ta_analytics_sdk.h"
+#include "ta_json_object.h"
+
+using namespace thinkingdata;
+
+ThinkingAnalyticsAPI::Init(SERVER_URL, APPID);
+```
+
+Instruction on parameters:
+- `APPID`: 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.
+  - 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`.
+## **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 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.
+```cpp
+// The login unique identifier of the user, corresponding to the #account_id in data tracking. #Account_id now is TE
+ThinkingAnalyticsAPI::Login("TE");
+```
+
+<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:
+```cpp
+TDJSONObject event_properties;
+event_properties.SetString("name1", "name1"); //string
+event_properties.SetNumber("test_number_int", 3); //number
+event_properties.SetBool("test_bool", true); //boolean
+event_properties.SetDateTime("test_time1", time(NULL), 0); //time
+std::vector<std::string> test_list;
+test_list.push_back("item11");
+test_list.push_back("item21");
+event_properties.SetList("test_list1", test_list); //array
+ThinkingAnalyticsAPI::Track("CPP_event", event_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.3 **User Properties**
+You can set general user properties by calling `user_set` 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: 
+```cpp
+TDJSONObject userProperties;
+userProperties.SetString("user_name", "TE");
+ThinkingAnalyticsAPI::UserSet(userProperties);
+```
+
+## 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:
+```cpp
+#include "ta_analytics_sdk.h"
+using namespace thinkingdata;
+
+if (privacy policy is authorized) {
+    ThinkingAnalyticsAPI::Init(SERVER_URL, APPID);
+    ThinkingAnalyticsAPI::Login("TE");
+    TDJSONObject event_properties;
+    event_properties.SetString("name1", "name1");//string
+    event_properties.SetNumber("test_number_int", 3);//number
+    event_properties.SetBool("test_bool", true);//boolean
+    event_properties.SetDateTime("test_time1", time(NULL), 0);//time
+    std::vector<std::string> test_list;
+    test_list.push_back("item11");
+    test_list.push_back("item21");
+    event_properties.SetList("test_list1", test_list);//array
+    ThinkingAnalyticsAPI::Track("CPP_event", event_properties);;
+    
+    TDJSONObject userProperties;
+    userProperties1.SetString("user_name", "TE");
+    ThinkingAnalyticsAPI::UserSet(userProperties);
+}
+```
+
+
+### 
+## 
+###