@thinkingai/ae-cli 1.0.30 → 6.0.16-1

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

@@ -0,0 +1,28 @@
+---
+code: corona_sdk_compliance
+name: "Compliance"
+wikiToken: Tt0Awcm2biW6LYkDB7NcLOfynEb
+parentWikiToken: QjOXwKuZFiw4JLk477Fcuzmnnnb
+updateTime: 1774249160000
+sourceUrl: https://docs-v2.thinkingdata.cn/?version=v6.0&lan=en-US&code=corona_sdk_compliance
+---
+## **1. Filling out SDK-related Contents in The Privacy Policy**
+### **1.1 Collecting and Acquiring Data**
+The following content is suggested to fill out  in accordance with the actual conditions in the column of collecting and acquiring your personal data in the *Privacy Policy*. 
+When you activate and use the APP, we would collect information about your device (including IDFV, AndroidID, OS, device model, device manufacturer, system version, application process information, etc.) through TDAnalytics-SDK to analyze the effect you achieved by using the App via statistics.
+### **1.2 Sharing with authorized partners**
+The following content is suggested to fill out in accordance with the actual conditions in the column of sharing with authorized partners in the *Privacy Policy*.
+TDAnalytics-SDK: collect information about your device (including IDFV, AndroidID, OS, device model, device manufacturer, system version, application process information, etc.) and your network information to perform data analysis ,so as to improve our products and services
+## **2. ****SDK**** Compliance Steps**
+ThinkingData SDK needs to be initialized after the user agrees with the *Privacy Policy.*
+```lua
+ local TDAnalytics = require("TDAnalytics")
+-- determine whether to enable data tracking according to the Privacy Policy
+if (authorized) {
+    local params = {
+        appId = "YOUR_APP_ID",
+        serverUrl = "YOUR_SERVER_URL"
+    }
+    TDAnalytics.init(params)
+}
+```

package/wiki/te-docs/raw/data-ingestion-guide/client-sdk/game-engine/corona/corona-advanced/automatic-event-tracking.md

@@ -0,0 +1,29 @@
+---
+code: corona_sdk_autotrack
+name: "Automatic Event Tracking"
+wikiToken: QsdxwfT04iDDK8kNLAEc6z5YnRb
+parentWikiToken: VgpBwhQ5aiThtUklu2Gc60vnngg
+updateTime: 1774249154000
+sourceUrl: https://docs-v2.thinkingdata.cn/?version=v6.0&lan=en-US&code=corona_sdk_autotrack
+---
+
+Corona SDK Automatic Event Tracking events including installation, open, close.
+- `appInstall`: behavior of APP installation
+- `appStart`: Open APP, including activiting APP and resuming APP from the background
+- `appEnd`: Close APP, including disabling the APP and calling in the background while tracking the duration of the enabling process
+You can enable auto-tracking during initialization
+```lua
+-- enable auto-tracking
+local params = {
+    appId = "YOUR_APP_ID",
+    serverUrl = "YOUR_SERVER_URL",
+    autoTrack = {
+        "appStart", "appEnd", "appInstall"
+    }
+}
+TDAnalytics.init( params )
+```
+
+<quote-container>
+Note: If you need to set distinct ID, please call `setDistinctId` before enabling auto-tracking.
+</quote-container>

package/wiki/te-docs/raw/data-ingestion-guide/client-sdk/game-engine/corona/corona-advanced/debugging-and-logging.md

@@ -0,0 +1,58 @@
+---
+code: corona_sdk_debug
+name: "Debugging and Logging"
+wikiToken: KD2swm89oihx9jkaOtWc3tbHnLc
+parentWikiToken: VgpBwhQ5aiThtUklu2Gc60vnngg
+updateTime: 1774251986000
+sourceUrl: https://docs-v2.thinkingdata.cn/?version=v6.0&lan=en-US&code=corona_sdk_debug
+---
+
+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.
+## Printing Log
+```lua
+-- enable printing logs
+local params = {
+    appId = "YOUR_APP_ID",
+    serverUrl = "YOUR_SERVER_URL",
+    enableLog = true, -- true:enable printing logs, false:disable printing logs
+}
+-- initialize SDK
+TDAnalytics.init( params )
+```
+
+<quote-container>
+After opening the log, you can check data tracking of SDK by filtering logs related to ThinkingData in IDE.
+</quote-container>
+
+## **2. Debugging**
+You need to follow the following two steps to enable the Debug mode:
+2. Enable the debug mode at the client side
+The sample code for enabling the Debug mode on the client side is as follows:
+```lua
+--[[
+ Set the operation mode as the Debug mode
+ normal mode: the data would be saved in caches and reported according to relevant cache policies under the NORMAL mode by default. It is recommended to use the mode in an online environment
+ debug mode: report data item by item. If problems occur, the user would be notified with logs and anomalies. It is recommended to use the Debug mode in an online environment
+ debugOnly mode: data would be verified without being stored; it is not recommended to use the DebugOnly mode in an online environment
+]]--
+local params = {
+    appId = "YOUR_APP_ID",
+    serverUrl = "YOUR_SERVER_URL",
+    debugMode = "debug",  -- normal, debug, debugOnly
+}
+-- initialize SDK
+TDAnalytics.init( params )
+```
+
+3. Add Device
+To avoid launching the Debug mode in the production environment, it is required that only specified device can enable Debug mode. The Debug mode can only be enabled for devices whose IDs have been configured in the "Debugger" sector on the "Tracking Management" page of TE when the client side has enabled the Debug mode.
+<image token="AjpSb0APLolIhhxsLmgcx1ZunRb" width="2782" height="1284" align="left"/>
+
+
+Device ID could be obtained by the following three means:
+- #Device_id property in the event data of TE
+- Client-side log: DeviceID would be printed as log after SDK is initialized
+- Call API：[Device ID](https://thinkingdata.feishu.cn/wiki/VgpBwhQ5aiThtUklu2Gc60vnngg)
+<quote-container>
+The Debug mode may undermine the data tracking quality and stability of the App. It could only be used for data verification at the integration stage, and should not be used in the online environment.
+</quote-container>

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

@@ -0,0 +1,43 @@
+---
+code: corona_sdk_preset_properties
+name: "Preset Properties"
+wikiToken: C2SDwUKQ2iYFz9kgSDnc1U8yntc
+parentWikiToken: VgpBwhQ5aiThtUklu2Gc60vnngg
+updateTime: 1774251987000
+sourceUrl: https://docs-v2.thinkingdata.cn/?version=v6.0&lan=en-US&code=corona_sdk_preset_properties
+---
+
+<quote-container>
+Preset Properties will have differences on different platforms, for details: [Android](https://thinkingdata.feishu.cn/wiki/MBnZwHrO0ibkd9ksCSBc7dxEnic), [iOS](https://thinkingdata.feishu.cn/wiki/Ny61w1VIbi5Qeok94fRcJhulned). 
+</quote-container>
+
+### **1. Getting Preset Properties**
+If you need to use the preset properties of the client SDK when tracking events on the server, then you can use `getPresetProperties` to get these properties and upload them to the server.
+```lua
+-- get preset properties object
+TDAnalytics.getPresetProperties( function (ret)
+    local presetProperties = ret
+    print( "current presetProperties = " .. presetProperties )
+end )
+--[[
+   {
+        "#carrier": "T-Mobile", -- information about operator of the SIM card. Operation information of the primary card should be got under dual-card dual-standby mode 
+        "#os": "Android", -- device os name, e.g., Android, iOS
+        "#device_id": "abb8e87bfb5ce66c", -- device ID
+        "#screen_height": 2264, -- screen height
+        "#screen_width": 1080, -- screen height
+        "#bundle_id": "com.sw.thinkingdatademo", -- bundle ID
+        "#manufacturer": "realme", -- device manufacturer, e.g. HuaWei
+        "#device_model": "RMX1991", -- device model
+        "#system_language": "zh", -- system language
+        "#os_version": "10", -- os version
+        "#network_type": "WIFI", -- network type
+        "#zone_offset": 8， -- time zone offset
+        "#app_version":"1.0" -- APP version
+    }
+]]--
+```
+
+<quote-container>
+IP, nation and city information are parsed and generated by the server. The client shall not provide the api to get such properties
+</quote-container>

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

@@ -0,0 +1,204 @@
+---
+code: corona_sdk_advanced
+name: "Corona-Advanced"
+wikiToken: VgpBwhQ5aiThtUklu2Gc60vnngg
+parentWikiToken: QjOXwKuZFiw4JLk477Fcuzmnnnb
+updateTime: 1774251985000
+sourceUrl: https://docs-v2.thinkingdata.cn/?version=v6.0&lan=en-US&code=corona_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 `setDistinctId` to set the distinct ID:
+```lua
+-- set distinct ID as Thinker
+TDAnalytics.setDistinctId("Thinker");
+```
+
+If you need to obtain the current distinct ID, please call `getDistinctId`:
+```lua
+-- returns distinct ID
+TDAnalytics.getDistinctId( function (ret)
+    print( "distinctId = " .. ret )
+end )
+```
+
+### **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.
+```lua
+-- 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>
+Note: 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. 
+```lua
+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 users 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:
+```lua
+local properties = { 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.
+```lua
+TDAnalytics.trackFirst("device_activation", {test_string="first_string"})
+```
+
+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:
+```lua
+-- set the user ID as the first_check_id of the first event to track the first initialization event of the user.
+TDAnalytics.trackFirst("account_activation", {test_string="first_string"} , "TA")
+```
+
+<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.
+```lua
+-- The event property status is 3 after reporting, with the price being 100
+TDAnalytics.trackUpdate("UPDATABLE_EVENT", {
+    status = 3,
+    price = 100
+}, "Update_EventId")
+
+-- The event property status is 5 after reporting, with the price remaining the same
+TDAnalytics.trackUpdate("UPDATABLE_EVENT", {
+    status = 5
+}, "Update_EventId")
+```
+
+### **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.
+```lua
+-- The event property status is 3 after reporting, with the price being 100
+TDAnalytics.trackOverwrite("OVERWRITABLE_EVENT", {
+    status = 3,
+    price = 100
+}, "Overwrite_EventId")
+
+-- The event property status is 5 after reporting, with the price deleted
+TDAnalytics.trackOverwrite("OVERWRITABLE_EVENT", {
+    status = 5
+}, "Overwrite_EventId")
+```
+
+### **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>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.
+```lua
+-- set super properties
+TDAnalytics.setSuperProperties({vip_level = 2})
+```
+
+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.
+```lua
+-- clear a super property named 'Channel'
+TDAnalytics.unsetSuperProperties("Channel")
+-- clear all super properties
+TDAnalytics.clearSuperProperties()
+-- get all super properties
+TDAnalytics.getSuperProperties( function (ret)
+    local superProperties = ret
+    print( "current superProperties = " .. superProperties )
+end )
+```
+
+### **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.
+```lua
+-- 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 some thing...
+-- 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` .
+### **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:
+```lua
+-- current username is TA
+TDAnalytics.userSet({user_name = "TA"})
+-- current username is TE
+TDAnalytics.userSet({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:
+```lua
+--first_payment_time is '2018-01-01 01:23:45.678'
+TDAnalytics.userSetOnce({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({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:
+```lua
+-- current total_revenue is 30
+TDAnalytics.userAdd({total_revenue = 30})
+-- current total_revenue is 678
+TDAnalytics.userAdd({total_revenue = 648})
+```
+
+<quote-container>
+The 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.
+```lua
+-- remove a user property named 'age'
+TDAnalytics.userUnset("age")
+```
+
+### **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.
+```lua
+-- remove all user properties
+TDAnalytics.userDelete()
+```
+
+### **3.6 UserAppend**
+You can call `userAppend` to add user properties of array type.
+```lua
+-- append user properties with array
+TDAnalytics.userAppend({user_list = {"apple", "ball"}})
+```
+
+## **4. Other**
+### **4.1  ****Device ID**
+You can call `getDeviceId` to obtain the device ID:
+```lua
+-- get device ID
+TDAnalytics.getDeviceId( function (ret)
+    print( "deviceId = " .. ret )
+end )
+```

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

@@ -0,0 +1,29 @@
+---
+code: corona_sdk_release_note
+name: "Release Notes"
+wikiToken: WFj4wJBoXihzDgkEzFbc6UJjnHh
+parentWikiToken: QjOXwKuZFiw4JLk477Fcuzmnnnb
+updateTime: 1774249161000
+sourceUrl: https://docs-v2.thinkingdata.cn/?version=v6.0&lan=en-US&code=corona_sdk_release_note
+---
+
+## 2.0.1
+**Date:  2023/11/24 **[Download](https://download.thinkingdata.cn/client/Corona/ta_corona_sdk_v2.0.1.zip)
+**Notes：**
+- Code optimization
+## 2.0.0
+**Date:  2023/09/06 **[Download](https://download.thinkingdata.cn/client/Corona/ta_corona_sdk_v2.0.0.zip)
+**Notes：**
+- Code optimization
+## 1.0.1
+**Date:  2023/03/21 **[Download](https://download.thinkingdata.cn/client/Corona/ta_corona_sdk_v1.0.1.zip)
+**Notes：**
+- Code optimization
+## 1.0.0
+**Date:  2022/09/15**
+**Notes：**
+- Support setting of visitor ID and user account
+- Support event and user attribute reporting
+- Support automatic reporting of startup/shutdown/installation events
+- Support public attribute interface
+- Support timeEvent interface

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

@@ -0,0 +1,269 @@
+---
+code: corona_sdk_installation
+name: "Corona"
+wikiToken: QjOXwKuZFiw4JLk477Fcuzmnnnb
+parentWikiToken: FgrswqlHEiE45HkQve4cU0NFnbd
+updateTime: 1774251985000
+sourceUrl: https://docs-v2.thinkingdata.cn/?version=v6.0&lan=en-US&code=corona_sdk_installation
+---
+
+::: tip
+Before you begin, please read [Preparations before Data Ingestion](https://thinkingdata.feishu.cn/wiki/OhD8we9iai6Xk5kM1QNc8ITRnQe)
+Corona SDK supports iOS, Android
+The size of Corona SDK (aar format) is around 0.5 MB
+ :::
+**Latest version:** v2.0.1
+**Update time:** November 24, 2023
+**Resource download: **[SDK](https%3A%2F%2Fdownload.thinkingdata.cn%2Fclient%2Frelease%2Fta_corona_sdk.zip), [Source Code](https%3A%2F%2Fgithub.com%2FThinkingDataAnalytics%2Fcorona-sdk%2Ftags)
+::: warning Notice 
+The current documentation applies to v2.0.0 and later versions. For historical versions, please refer to the [Data Ingestion Guide - Corona (V1)](https%3A%2F%2Fdocs.thinkingdata.cn%2Fta-manual%2Fv4.1%2Fen%2Finstallation%2Finstallation_menu%2Fclient_sdk%2Fgame_engine_sdk_installation%2Fcorona_sdk_installation%2Fcorona_sdk_installation.html), [SDK Download (v1.0.1)](https%3A%2F%2Fdownload.thinkingdata.cn%2Fclient%2FCorona%2Fta_corona_sdk_v1.0.1.zip). 
+:::
+## **1. ****SDK**** Integration**
+- **Corona Setting**
+  - Download and unzip [Corona SDK](https://download.thinkingdata.cn/client/release/ta_corona_sdk.zip), and copy `TDAnalytics.lua` to Corona
+- **Android Setting**
+  - Copy `android/ThinkingPluginProxy.java` to `android/plugin/src/main/java/plugin/library`
+  - Open Android project file with Android Studio, then switch to Android Mode. Add dependencies in `build.gradle` and click `Sync Now` to update it
+```bash
+dependencies {
+    implementation 'cn.thinkingdata.android:ThinkingAnalyticsSDK:3.0.0'
+}
+```
+
+<image token="IAW9b4t1yoS1zlxkTVmcx5TVnwg" width="1278" height="997" align="center"/>
+
+- Add code to `plugin.library.LuaLoader` like this
+::: tip
+If you don't add any code in `plugin.library.LuaLoader`, you can copy `android/LuaLoader.java` to `android/plugin/src/main/java/plugin/library` to replace the original file
+:::
+```java
+public int invoke(LuaState L) {
+   NamedJavaFunction[] luaFunctions = new NamedJavaFunction[] {
+      ...
+      // TDAnalytics: add code
+      new ThinkingBridgingWrapper(),
+      ...
+   };
+   String libName = L.toString( 1 );
+   L.register(libName, luaFunctions);
+   return 1;
+}
+
+public void dispatchEvent(final String message) {
+   CoronaEnvironment.getCoronaActivity().getRuntimeTaskDispatcher().send( new CoronaRuntimeTask() {
+      @Override
+      public void executeUsing(CoronaRuntime runtime) {
+
+         LuaState L = runtime.getLuaState();
+         CoronaLua.newEvent( L, EVENT_NAME );
+         
+         ...
+         // TDAnalytics: add code
+         JSONObject jsonObject = null;
+         String newMessage = null;
+         String type = null;
+         try {
+            jsonObject = new JSONObject(message);
+            newMessage = jsonObject.optString("message");
+            type = jsonObject.optString("type");
+         } catch (Exception ignored) {
+         }
+
+         if (!TextUtils.isEmpty(newMessage) && !TextUtils.isEmpty(type)) {
+            L.pushString(newMessage);
+            L.setField(-2, "message");
+            L.pushString(type);
+            L.setField(-2, "type");
+         } else  {
+            L.pushString(message);
+            L.setField(-2, "message");
+         }
+         ...
+         
+         try {
+            CoronaLua.dispatchEvent( L, fListener, 0 );
+         } catch (Exception ignored) {
+         }
+      }
+   } );
+}
+
+...
+// TDAnalytics: add code
+@SuppressWarnings({"WeakerAccess", "SameReturnValue"})
+public int thinkingBridging(LuaState L) {
+   CoronaActivity activity = CoronaEnvironment.getCoronaActivity();
+   if (activity == null) {
+      return 0;
+   }
+
+   String word = L.checkString( 1 );
+   JSONObject params = null;
+   try {
+      params = new JSONObject(word);
+   } catch (JSONException e) {
+      params = new JSONObject();
+   }
+   String method = params.optString("method");
+   if (method.length() > 0) {
+      try {
+         Class aClass = Class.forName("plugin.library.ThinkingPluginProxy");
+         Method aMethod = aClass.getDeclaredMethod(method, JSONObject.class);
+         JSONObject jsonObject = (JSONObject) aMethod.invoke(aClass, params);
+         if (jsonObject != null && jsonObject.getClass() == JSONObject.class && jsonObject.has("message")) {
+            (new Thread() {
+               @Override
+               public void run() {
+                  dispatchEvent(jsonObject.toString());
+               }
+            }).start();
+         }
+      } catch (Exception e) {
+         e.printStackTrace();
+      }
+   }
+   return 0;
+}
+...
+
+...
+// TDAnalytics: add code
+@SuppressWarnings("unused")
+private class ThinkingBridgingWrapper implements NamedJavaFunction {
+   @Override
+   public String getName() {
+      return "thinkingBridging";
+   }
+   
+   @Override
+   public int invoke(LuaState L) {
+      return thinkingBridging(L);
+   }
+}
+...
+```
+
+
+- **iOS**** Setting**
+  - Open iOS project with Xcode, add files in `ios/ThinkingAnalyticsSDK` to directory named App
+<image token="MUGMb5urConcL4xWQexcfXHwnSf" width="1278" height="994" align="left"/>
+
+- Enable ARC support, select **TARGETS** -> **App** -> **Build Settings** -> **Objective-C Automatic Reference Counting**, and set it to **YES**
+<image token="Ov9gbxSQpoLPcOxiMCFcFOrtnQc" width="2556" height="1988" align="center"/>
+
+- Disable ARC for **ThinkingPluginLibrary.mm**, select **TARGETS** -> **App** -> **Build Phases** -> **Compile Sources** -> **ThinkingPluginLibrary.mm**, and add **-fno-objc-arc**
+<image token="Tkp7bK8MnoDVfKxNZcucEYnHnMc" width="2556" height="1988" align="center"/>
+
+## **2. Initialization**
+```lua
+-- import TDAnalytics
+local TDAnalytics = require("TDAnalytics")
+
+-- initialize TDAnalytics
+local params = {
+    appId = "YOUR_APP_ID",
+    serverUrl = "YOUR_SERVER_URL"
+}
+TDAnalytics.init(params)
+```
+
+<quote-container>
+Note: Since some devices restrict HTTP requests by default, please use HTTPS protocol only.
+</quote-container>
+
+## **3. Common Features**
+We suggested that you read [User Identification Rules](https://thinkingdata.feishu.cn/wiki/Pov9wECdsi2QQsk4NN9cEPsvnyc) before using common functions; 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 use 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.
+```lua
+-- 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>
+Note: 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.
+```lua
+-- set super properties
+TDAnalytics.setSuperProperties({
+    channel = "App Store",
+    trip = {"Car", "Train"}
+})
+```
+
+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>
+Note: 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 tracking installation, open_app and close_app events. To get more information about the automatic tracking of SDK, please refer to [Automatic Event Tracking](https://thinkingdata.feishu.cn/wiki/QsdxwfT04iDDK8kNLAEc6z5YnRb)
+```lua
+-- enable auto-tracking
+-- appInstall=enable auto-track APP installation
+-- appStart=enable auto-track open APP
+-- appEnd=enable auto-track close APP
+local params = {
+    appId = "YOUR_APP_ID",
+    serverUrl = "YOUR_SERVER_URL",
+    autoTrack = {
+        "appStart", "appEnd", "appInstall"
+    }
+}
+TDAnalytics.init( params )
+```
+
+### **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:
+```lua
+TDAnalytics.track("product_buy", {product_name="product name"});
+```
+
+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 `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: 
+```lua
+-- set user properties
+TDAnalytics.userSet({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:
+```lua
+-- import ThinkingAnalyticsAPI
+local TDAnalytics = require("TDAnalytics")
+
+if (privacy policy is authorized) {
+    -- initialize SDK
+    local params = {
+        appId = "YOUR_APP_ID",
+        serverUrl = "YOUR_SERVER_URL"
+    }
+    TDAnalytics.init(params)
+    
+    -- 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
+    local superProperties = {}
+    superProperties["channel"] = "TE" -- 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 object
+    superProperties["arr"] = { "value" } -- array
+    TDAnalytics.setSuperProperties(superProperties) -- set super properties
+    
+    -- track event
+    TDAnalytics.track("product_buy", {product_name="product name"});
+    
+    -- set user properties
+    TDAnalytics.userSet({user_name = "TE"})
+}
+```