@thinkingai/ae-cli 1.0.28 → 6.0.16

package/wiki/te-docs/raw/advanced-data-type/updated-event.md

@@ -0,0 +1,87 @@
+---
+code: track_update_and_track_overwrite
+name: "Updated Event"
+wikiToken: BtlUwIB0piMzhdkMjz2cmndrnFb
+parentWikiToken: DyTywDmeWiYzq2kLIQlcsNsJnff
+updateTime: 1774249365000
+sourceUrl: https://docs-v2.thinkingdata.cn/?version=v6.0&lan=en-US&code=track_update_and_track_overwrite
+---
+This chapter will introduce how to use the special data structure of the TA system - updated event. An updated event is a **special kind of event data to** update the event property value in the data. It is suitable for recording event data that contains variable state values or variable cumulative values, such as cost events, which can update the property `cost amount` over time.
+::: warning
+The storage and processing performance overhead of updated events is relatively high. To ensure data processing efficiency and query performance, it is only applicable to events with a small number and strong update requirements in special business scenarios. It is strongly recommended to use an updated event with the assistance of TA personnel
+ :::
+## **I. Data structure**
+<quote-container>
+For TA's client SDK or server SDK, please refer to the corresponding SDK access guide. The chapters "Updated events" and "Rewritable events" in this User Guide will provide detailed interface calling methods
+</quote-container>
+
+To use the "updated event" property, two adjustments need to be made in the data:
+1. Set the field `#type` that identifies the data type to `track_update` or `track_overwrite`. These two data types represent the update methods of two events: updating some properties and overwriting all properties
+2. Add the field `#event_id`, which is the unique identification of the event; when updating the properties, search the corresponding event data according to `#event_name` and `#event_id`, and update the data; the `#event_id` of different events is independent of each other, so each updated event has a separate unique identification system
+The following is a data sample, and you can pay attention to the location of `#event_id`:
+```json
+{
+  "#account_id": "ABCDEFG-123-abc",
+  "#distinct_id": "F53A58ED-E5DA-4F18-B082-7E1228746E88",
+  "#type": "track_update",
+  "#event_id": "F53A58ED-E5DA-4F18-B082-7E1228746E88",
+  "#time": "2020-08-18 14:37:28.527",
+  "#event_name": "test_event",
+  "properties": {
+    "argString": "abc"
+  }
+}
+```
+
+## **II. Data processing logic**
+The processing logic of an updated event is very different from that of ordinary event data: **Please note that if the **`#type`** of event data is **`track`**, the data cannot be updated later**; if the `#type` of event data is `track_update` or `track_overwrite`, it will be regarded as an updated event, and then any one of the two types of data can be used to update the property.
+When the TA system receives `track_update` or `track_overwrite`, different processing methods are available. This section will describe the processing logics of these two types of data in details.
+### 2.1 **Processing logic of track_update**
+When `#type` in the data is `track_update`, the processing logic of the data is event property update. When the system receives this type of data, it will check whether the corresponding event data exists according to the `#event_id` field. If it exists, it will update the corresponding field. The specific processing logic is as follows:
+1. If the data corresponding to #`#event_id` does not exist in this event, the data will be regarded as new data and will be directly stored
+2. If `#event_id` exists, the event property in the new data will update the previous value. If there is a new property, the new property will also be added. The property not included in the new data will not be updated, so you need to pass in the properties to be updated
+3. In addition, `#time`, the event time, will also be updated by new data, so there is a need to set the time in the new data reasonably in the actual business scenario
+### 2.2 **Processing logic of track_overwrite**
+When `#type` in the data is `track_overwrite`, the processing logic of the data is event rewriting. When the system receives this type of data, it will check whether the corresponding event data exists according to the `#event_id` field. If it exists, it will delete the data and write new event data into the system (equivalent to substituting the deleted data). The specific processing logic is as follows:
+1. If the data corresponding to `#event_id` does not exist in this event, the data will be regarded as new data and will be directly stored
+2. If `#event_id` exists, all content of the event data will be rewritten. To update some properties, you can use `track_update`
+3. In addition, `#time`, the event time, will also be updated by new data, so there is a need to set the time in the new data reasonably according to the actual business scenario
+## III. **Best Practices**
+### **Advertising cost**
+When analyzing the advertising effect, it is often necessary to calculate the ROI input-output ratio of advertising space or material, that is, the ratio of user value to user cost. The user value, that is, the sum of direct payment and value generated by other methods, is easy to record; while the cost data will depend on the data rules of the advertisers, and the general cost amount will be continuously updated, which is not suitable for recording as per general event data.
+Since the cost data will continue to change, the advertising cost data is highly recommended to be recorded in an updated manner. When recording the advertising cost data for the first time, the following data can be uploaded:
+```json
+{
+  "#account_id": "admin",
+  "#distinct_id": "F53A58ED-E5DA-4F18-B082-7E1228746E88",
+  "#type": "track_update",
+  "#event_id": "2020-09-01_google_7-Tier1-0527_adset1_adname1",
+  "#time": "2020-09-01 00:00:00.000",
+  "#event_name": "ad_cost",
+  "properties": {
+    "channel": "google",
+    "campaignid": "7-Tier1-0527",
+    "adset": "adset1",
+    "adname": "adname1",
+    "cost": 100
+  }
+}
+```
+
+The above data will add an updated event of cost, where #event_id is composed of date, channel, activity name, ad group, and ad name, which is the unique ID of cost. According to data logic, this is also the cost event that can be updated at the finest granularity; the `cost` field records the advertising cost, namely RMB 100.
+As time goes by, the advertising channel pushes new cost data, and the new advertising cost is RMB 200. Then the following data can be sent, where `#event_id` needs to be consistent with the previous data, which means updating the previous data; the `cost` field is updated, and the new cost RMB 200 is passed in; since `#time` will also be updated by new data, it needs to be consistent with the previous one, and the cost data is passed in (converted to time type). Other fields such as channels, activities, and advertising spaces do not need to be updated, so the data can be left blank.
+```json
+{
+  "#account_id": "admin",
+  "#distinct_id": "F53A58ED-E5DA-4F18-B082-7E1228746E88",
+  "#type": "track_update",
+  "#event_id": "2020-09-01_google_7-Tier1-0527_adset1_adname1",
+  "#time": "2020-09-01 00:00:00.000",
+  "#event_name": "ad_cost",
+  "properties": {
+    "cost": 200
+  }
+}
+```
+
+When the system receives this event, it will query whether the `#event_id` already exists. If it exists, it will update the `#time` and `cost` fields in the original data (that is, the first sample data), that is, the cost amount of the cost event has been updated.

package/wiki/te-docs/raw/advanced-data-type.md

@@ -0,0 +1,16 @@
+---
+code: advanced_data_type
+name: "Advanced Data Type"
+wikiToken: DyTywDmeWiYzq2kLIQlcsNsJnff
+parentWikiToken: Hx0SwfT0aiwGRekQp2ocJ7okn0g
+updateTime: 1776412217000
+sourceUrl: https://docs-v2.thinkingdata.cn/?version=v6.0&lan=en-US&code=advanced_data_type
+---
+
+This chapter mainly introduces the advanced data type in the AE system. The advanced data type will have additional data processing logics when the system receives such data. The structure is also somewhat different from the standard data structure. You can view the corresponding document to learn about the capabilities of each advanced data type
+::: warning
+The advanced data will have high performance overheads. To ensure data processing efficiency, it is recommended to use it only in appropriate scenarios
+ :::
+The current advanced data types are as follows:
+- [<text underline="true">updated event:</text>](https://thinkingdata.feishu.cn/wiki/BtlUwIB0piMzhdkMjz2cmndrnFb)<text underline="true"> special events that can update event properties</text>
+- [<text underline="true">first event check</text>](https://thinkingdata.feishu.cn/wiki/IlCawoKZKiytCMkqRPvcpz3Ln5g)<text underline="true">: </text>By adding the first event check ID to determine whether the event occurred for the first time, only the data whose ID appears for the first time is allowed to be stored in the database

package/wiki/te-docs/raw/data-ingestion-guide/about-gdpr.md

@@ -0,0 +1,55 @@
+---
+code: about_gdpr
+name: "About GDPR"
+wikiToken: EJ1rwNvTqi15UKkGJswcboO4ntc
+parentWikiToken: AWr4wIMGYi9FB7ksPi4c17kNnxh
+updateTime: 1774252027000
+sourceUrl: https://docs-v2.thinkingdata.cn/?version=v6.0&lan=en-US&code=about_gdpr
+---
+
+## Introduction to GDPR
+
+<quote-container>
+On May 25, 2018, the European Union issued the "General Data Protection Regulation" (GDPR, General Data Protection Regulation). GDPR can be called the strictest and most detailed law in history to protect user data security.
+</quote-container>
+
+At a time when the demand for going to sea is increasingly strong, Chinese enterprises will face GDPR supervision in data collection, processing and application.
+GDPR mainly protects the personal data of EU users. For apps or games that provide services to the EU, GDPR should be complied with.
+GDPR defines two types of roles, a data controller and a data processor. ThinkingAnalytics, the core data product of Digital Technology (hereinafter referred to as TA system), belongs to the role of data processor in most scenarios, while our customers belong to the data controller. Both types of roles are bound by GDPR, so when using our products, we will fully help customers achieve GDPR compliance and avoid latent risks.
+As a data controller, you are responsible for complying with the six principles set out in the GDPR. Failure to comply with the following principles will be punished:
+- Lawfulness, fairness and transparency: the need to process personal data in a legal, fair and transparent manner
+- Purpose limitation: Data collected can only be used for limited purposes
+- Data minimisation: collecting only necessary and meaningful data
+- Accuracy: Data needs to be accurate and timely, and methods can be taken to update and delete inaccurate information
+- Storage limitation: Data needs to be cleaned up after the processing purpose is completed
+- Data integrity and confidentiality (integrity and confidentiality): need to ensure the security of data storage, prevent unauthorized data access, prevent data from being destroyed or lost
+In addition, the following rights of users need to be protected:
+- Right to be Informed: Data controllers need to provide users with information about their data controllers, the types of personal data, the purpose of processing data, and legal basis, etc
+- Right of access: Users can obtain personal data and process personal data
+- Right to rectification: the user has the right to correct incorrect personal data
+- Right to erasure: Users have the right to delete personal data
+- Right to restriction of processing: Under certain circumstances (such as inaccurate data), users can restrict the processing of their personal data
+- Right to data portability: users can transfer personal data to other data controllers
+- Veto power (Right to object): Users can revoke their previous consent to the processing of personal data
+- Right not to be subject to a decision based solely on automated processing, including profiling: Users need to be informed whether personal data will be used by automated decisions (including user profiles) and have the right to refuse data to be used by these systems
+It should also be noted that data collection requires the user's consent, which needs to be clear and explicit, and the user can withdraw the previous consent based on "veto power".
+As a professional service provider, Digital Technology is committed to providing efficient and compliant solutions to help Chinese companies grow their offshore business. The following are the relevant compliance measures and suggestions of Digital Technology for the core content of GDPR:
+## GDPR Compliance Measures
+### Fully Support Customized Acquisition to Ensure Data Acquisition Compliance
+The TA system provides a full custom collection scheme at the data collection end, that is, customers can decide the collection of user information and behavior data according to actual needs and business scope. And all data collection schemes provided by TA system, including but not limited to client side SDK, server level SDK, data docking tool Logbus , etc., fully support the above principles and will not force the collection of any data related to user privacy. When developers need to collect relevant data from the client side for business needs, the client side of the user will also have relevant prompts to ensure the user's right to know. For specific data collection related schemes, please refer to the [<text underline="true">access guide</text>](https://thinkingdata.feishu.cn/wiki/AWr4wIMGYi9FB7ksPi4c17kNnxh).
+In addition, we also recommend that customers only collect the minimum data set that meets their needs through the custom collection function provided by the TA system when the collection target is clear, in order to comply with the principle of "data minimization".
+### Support User Data Update, Deletion, Transfer
+TA system in the data collection side, support methods such as `user_set `and `user_delete `, the specified user data is updated and deleted. At the same time, we also provide `enableTracking `method, which can suspend all data reporting of a client and call the interface when the user does not agree with the data collection.
+For data that has been received and stored by the TA system, the user data and related event data of a specific user can be deleted by the data deletion tool provided by the TA system. For specific operations, please refer to the [data deletion tool](https://thinkingdata.feishu.cn/wiki/Twatwe2vYi0ng0kFz8yczOIpn2o).
+For storage data, TA system provides a variety of export methods, such as [<text underline="true">export data API</text>](https://thinkingdata.feishu.cn/wiki/HpUrwBMDNiGb1skKYYVc5qMnn2P).
+In summary, on the basis of the above custom collection, TA system can support the update, deletion and transfer of relevant user data as developers' collection needs and users' actual needs change, thus providing users with the "right to correct", "right to delete" and "right to transfer" stipulated in GDPR.
+### The Whole LifeCycle of Data is Transparent, Auditable, Highly Available and Reliable
+TA system is a collection of data collection, reception, processing, storage, calculation, application in one of the user behavior analysis tools, data in the whole Life Time every link, are transparent and auditable. The TA system supports access and operation of all data components in the link, thus ensuring that every process of any piece of data from generation to application is traceable.
+If in the actual data application process, for specific reasons, it is necessary to audit a certain link in the system, counting technology will provide relevant technical support as much as possible to ensure the transparency of the whole process.
+At the same time, TA system has realized high availability and reliability of all components, ensuring the integrity of data service and data storage, which conforms to the principle of "data integrity and confidentiality".
+## Other Suggestions
+As a third-party data service provider, Count Technology is always committed to helping customers complete GDPR compliance from the product level. At the same time, it is also recommended that our customers increase their attention to user privacy. The following are some suggested measures from the developer level
+A. Writing and completing a privacy policy
+It is strongly recommended that you write your product's privacy policy and include standard terms on GDPR compliance, which will help your users to further understand the product's privacy protection policy.
+B. Protecting users' right to information
+In your product, you need to provide a clear application for data collection consent, and data collection is only allowed when the user agrees, so as to ensure that the user is informed when the user data is collected, not collected by default.

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

@@ -0,0 +1,431 @@
+---
+code: android_sdk_autotrack
+name: "Automatic Event Tracking"
+wikiToken: D7ykw75weigcIfk3ZoichHbKnuv
+parentWikiToken: LqfmwtW1xi0jzwkrKpscKEzFnme
+updateTime: 1774249039000
+sourceUrl: https://docs-v2.thinkingdata.cn/?version=v6.0&lan=en-US&code=android_sdk_autotrack
+---
+
+Android SDK Automatic Event Tracking events including installation,open,close and etc.
+## **1. Introduction **
+TE  provides Apis for automatic data tracking. You can select the data to be tracked based on your needs.
+Currently, the following types of events can be tracked automatically:
+1. Install:  behavior of APP installation
+2. Open APP: including activiting APP and resuming APP from the background
+3. Close APP: including disabling the APP and calling in the background while tracking the duration of the enabling process
+4. View Page:The user views the screen in the APP (`Activity/Fragment`)
+5. Click:The user clicks on the UI element  in the APP
+6. Crash:Record crash information when the APP crashes
+See below for more details on how to start tracking these events.
+## **2. Enable Auto-Tracking**
+You can call `enableAutoTrack` to enable the auto-tracking function:
+```java
+//APP install event TDAnalytics.TDAutoTrackEventType.APP_INSTALL
+//APP enable event TDAnalytics.TDAutoTrackEventType.APP_START
+//APP disable event TDAnalytics.TDAutoTrackEventType.APP_END
+//APP view screen event TDAnalytics.TDAutoTrackEventType.APP_VIEW_SCREEN
+//APP click view event TDAnalytics.TDAutoTrackEventType.APP_CLICK
+//APP crash event TDAnalytics.TDAutoTrackEventType.APP_CRASH
+//enable autotrack event
+TDAnalytics.enableAutoTrack(TDAnalytics.TDAutoTrackEventType.APP_START | TDAnalytics.TDAutoTrackEventType.APP_END
+        | TDAnalytics.TDAutoTrackEventType.APP_INSTALL | TDAnalytics.TDAutoTrackEventType.APP_VIEW_SCREEN | TDAnalytics.TDAutoTrackEventType.APP_CLICK
+        | TDAnalytics.TDAutoTrackEventType.APP_CRASH);
+```
+
+::: tip
+ If you need to track  Clicks event or Fragment Views, please integrate  [<text underline="true">auto-tracking plugin</text>](https://thinkingdata.feishu.cn/docx/Ju0Sd9wpNoraLtxVJv7cbiHqn0e).
+ :::
+## Instructions
+### 3.1 Installation Events
+APP install event would record the installation of the APP and be reported when the APP is being activated. The event is triggered when the APP is activated for the first time after installation. APP upgrade would not trigger an  installation event.  If the user reinstalls the app after uninstalling it, the installing event will be triggered again.
+- Event name: ta_app_install
+### 3.2 Active** Events**
+APP started event would be triggered when the user enables the APP or resumes the APP from the background. A detailed description of the start event is as follows:
+- Event name: ta_app_start
+- Preset property: `#resume_from_background`, Boolean  type, indicating whether the APP is enabled by the user or resumed from the background. If the value is true, it means the APP is resumed from the background; if the value is false, it means the APP is enabled by the user directly. 
+- It should be noted that SDK no longer allows the start events triggered by enabling the APP silently . To change the settings, you can add the resource file `ta_public_config.xml` under res/values
+```xml
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+   <bool name="TAEnableBackgroundStartEvent">true</bool>
+</resources>
+```
+
+
+### 3.3 Inactive Events
+APP end event would be triggered when the user disables the APP or moves the APP to the background. Detailed description of the end event is as follows:
+- Event name: ta_app_end
+- Preset property:`#duration`, numeric type, indicating the duration of each APP (unit: second).
+### 3.4 View Page Events
+APP view screen event would be triggered when the user views the screen (`Activity`). Detailed event introduction is as follows: 
+- Event name: ta_app_view
+- Preset property: 
+  `#screen_name`, string  type, package name, and category name of `Activity`
+  `#title`, string type,  title of `Activity`, value: the value of `title` property of `Activity`
+Other properties could be added to view screen events to expand their analysis value. Methods for defining the properties of view screen events are as follows
+#### 3.4.1 ** View Page Events of Auto-Tracking Fragment**
+As for the Fragment of `android.support.v4.app.Fragment`, the following method could be used to track view screen events automatically: 
+After SDK is initialized, call the following method to enable the auto-tracking function of Fragment
+```java
+TDAnalytics.trackFragmentAppViewScreen();
+```
+
+As for the Fragment of `android.app.Fragment`, the following method could be used to track view screen events automatically:
+```java
+TDAnalytics.trackViewScreen(targetFragment);
+```
+
+- `targetFragment` can be replaced by the Fragment that requires uploading of the view screen event
+#### 3.4.2 **Define The Properties of View Page Events**
+As for the view page events of `Activity`, properties could be added by implementing  the interface `ScreenAutoTracker`. URL information and other self-defined properties could be added for view page events through the following two methods:
+```java
+public class MainActivity extends AppCompatActivity implements ScreenAutoTracker {
+    private Context mContext;
+
+    @Override
+    public String getScreenUrl() {
+        return "thinkingdata://page/main";
+    }
+
+    @Override
+    public JSONObject getTrackProperties() throws JSONException {
+        JSONObject jsonObject = new JSONObject();
+        jsonObject.put("param1", "ABCD");
+        jsonObject.put("param2", "thinkingdata");
+        return jsonObject;
+    }
+}
+```
+
+The returned value of `getScreenUrl`would be used as the URL Schema of the `Activity`. When the view event of the page is triggered, preset property `#url` will be added. Meanwhile, SDK will fetch the URL Schema of the page before redirection. If it succeeds, it will be added to the preset property `#referrer` as the forward address.
+The returned value of `getTrackProperties` is the self-defined property of the view event of the screen, and would join the view event of the screen automatically 
+As for the view screen event of `Fragment`, we provide two ways to add properties 
+-  Add attributes by `@ThinkingDataFragmentTitle`
+```java
+@ThinkingDataFragmentTitle(title = "myFragment")
+public class ListViewFragment extends BaseFragment {
+  // your fragment implementations
+}
+```
+
+- Implements `ScreenAutoTracker` 
+```java
+  @Override
+  public JSONObject getTrackProperties() {
+      try {
+          JSONObject properties = new JSONObject();
+          properties.put("#title", "RecyclerViewFragment");
+          return properties;
+      } catch (JSONException e) {
+          // ignore
+      }
+      return null;
+  }
+```
+
+
+### 3.5 C**licked Events**
+App view click event would be triggered when the user clicks the element
+- Event name: ta_app_click
+- Preset property:
+  `#screen_name`, character string type, `package.class` of the `Activity` to which the view belongs
+  `#title`, character string type, the title of the `Activity` to which the view belongs, value: the value of `title` property of `Activity`
+  `#element_content`, character string type, the content of the view 
+  `#element_type`, character string type, type of the view 
+  `#element_id`，character string type, the ID of the view, `android:id` should be used by default
+  `#element_position`，character string type, uploaded when the view is in its `position`
+  `#element_selector`，character string type, the splicing of the `viewPath` of the view
+#### 3.5.1 **Define ViewID**
+The viewID should be `android:id` by default. If such property is unavailable, or the user wants to define the view ID, the following method could be used to cover `#element_id` property
+```java
+TDAnalytics.setViewID(view,viewID);
+```
+
+As for `Dialog`, the following method could be applied: 
+```java
+//android.app.Dialog
+TDAnalytics.setViewID(view,viewID);
+```
+
+or
+```java
+//android.support.v7.app.AlertDialog
+TDAnalytics.setViewID(view,viewID);
+```
+
+Parameter `view` is the view that needs a view ID, while parameter `viewID` is the preset view ID. When the clicking event of the view is being uploaded, the value of `#element_id` will be the value uploaded.
+#### 3.5.2 **Define The Properties of Clicked Events**
+You can apply the following method to add self-defined properties for Clicking a certain view.
+```java
+TDAnalytics.setViewProperties(view,properties);
+```
+
+Parameter view is the view that needs self-defined properties, while parameter `properties` (type:`JSONObject`) are the present self-defined properties, which will be added when the click event of the view is uploaded.
+Besides, as for `ExpandableListView`, `ListView` and `GridView`, you can also add self-defined properties when clicking a certain item by realizing interface with an Adapter.
+- `ExpandableListView` should implements `ThinkingExpandableListViewItemTrackProperties` interface
+```java
+public interface ThinkingExpandableListViewItemTrackProperties {
+    /**
+     * Add properties when clicking items at groupPosition and childPosition
+     * @param groupPosition
+     * @param childPosition
+     * @return
+     * @throws JSONException
+     */
+    JSONObject getThinkingChildItemTrackProperties(int groupPosition, int childPosition) throws JSONException;
+
+    /**
+     * Add properties when clicking items at groupPosition
+     * @param groupPosition
+     * @return
+     * @throws JSONException
+     */
+    JSONObject getThinkingGroupItemTrackProperties(int groupPosition) throws JSONException;
+}
+```
+
+
+- `ListView` and `GridView` should implement `ThinkingAdapterViewItemTrackProperties` interface
+```java
+public interface ThinkingAdapterViewItemTrackProperties {
+    /**
+     * Add properties when clicking items in the position 
+     * @param position
+     * @return
+     * @throws JSONException
+     */
+    JSONObject getThinkingItemTrackProperties(int position) throws JSONException;
+}
+```
+
+
+#### 3.5.3 **Add **`**Activity**`** information for Clicked Event of **`**AlertDialog**`
+As for the clicked event of `AlertDialog (android.app.AlertDialog and android.support.v7.app.AlertDialog`), the following methods could be applied to bind with the screen (`Activity`) concerned. In this case, the `#screen_name`  and  `#title` property of the screen would be added to the click event.
+- Please apply the following method to call `dialog.show()`and display dialog:
+```java
+dialog.setOwnerActivity(targetActivity);
+```
+
+- Please apply the following method to call `builder.show()` and display dialog:
+```java
+builder.show().setOwnerActivity(activity);
+```
+
+#### 3.5.4 Add** Clicked Events by Adding Annotation **`**@ThinkingDataTrackViewOnClick**`
+If you use the calling method of adding a clicked event for viewing through `android:onclick`, you can add annotation `@ThinkingDataTrackViewOnClick`. When the calling method is being implemented, SDK will upload the view click event.
+```java
+@ThinkingDataTrackViewOnClick
+public void buttonOnClick(View v){}
+```
+
+If the `buttonOnClick` method is being called, the clicked event will be uploaded
+### 3.6** Crash Events**
+When an unexpected crash occurs in the APP, an APP crash event would be reported
+- Event name: ta_app_crash
+- Preset property:`#app_crashed_reason`, character string type, record the stack trace upon crash
+## **4.Ignore Auto-Tracking Event**
+You can ignore the auto-tracking event of activity or view by the following means
+### 4.1 View Page Events
+As for certain screens (`Activity`), if you do not want to transmit auto-tracking events (including view screen event and view click event), you can ignore them by the following means:
+```java
+//ignore a single screen
+TDAnalytics.ignoreAutoTrackActivity(MainActivity.class);
+//ignore multiple screens
+List<Class<?>> classList = new ArrayList<>();
+classList.add(MainActivity.class);
+TDAnalytics.ignoreAutoTrackActivities(classList);
+```
+
+You can also add annotation `@ThinkingDataIgnoreTrackAppViewScreen` before `Activity` or `Fragment` to ignore the view screen event of a certain `Activity` or `Fragment`
+```java
+//ignore the view screen event of TestActivity
+@ThinkingDataIgnoreTrackAppViewScreen
+public class TestActivity extends AppCompatActivity {
+    ...
+}
+```
+
+`@ThinkingDataIgnoreTrackAppViewScreenAndAppClick` before `Activity` to ignore the view screen event of a certain `Activity` as well as the view click event under the screen
+```java
+//ignore the view screen event ofTestActivity as well as the view click event under the screen
+@ThinkingDataIgnoreTrackAppViewScreenAndAppClick
+public class TestActivity extends AppCompatActivity {
+    ...
+}
+```
+
+### 4.2 Clicked Events
+1. You can apply the following method to ignore the click event of a certain view type
+```java
+TDAnalytics.ignoreViewType(ignoredClass);
+```
+
+- `ignoredClass` is the type of view that needs to be ignored. For example, `Dialog` and `Checkbox`, etc.
+2. You can apply the following method to ignore the click event of a certain element (view)
+```java
+TDAnalytics.ignoreView(targetView);
+```
+
+- `targetView` is the View to be ignored
+## **Tracking Events By Annotation**
+If you need to monitor the call time of a certain method, or an event needs to be uploaded once a method is called, you can use annotation `@ThinkingDataTrackEvent` to set the event to be uploaded rapidly. It should be noted that variables could not be uploaded for properties. Therefore, only simple events could be uploaded.
+```java
+//use annotation
+@ThinkingDataTrackEvent(eventName = "event_name", properties = "{\"paramString\":\"value\",\"paramNumber\":123,\"paramBoolean\":true}")
+public void fun(){}
+```
+
+In this case, if method `fun` is called, an even named `event_name` and such properties as `"paramString":"value"`, `"paramNumber":123` and `"paramBoolean":true` will be uploaded
+## **6.Preset Properties of Auto-Tracking Events**
+The following preset properties are the properties set specially for each auto-tracking event
+- Preset properties of APP start event (ta_app_start)
+
+<lark-table rows="4" cols="4" column-widths="143,133,140,328">
+
+  <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>
+      #resume_from_background
+    </lark-td>
+    <lark-td>
+      Resume from the background or not
+    </lark-td>
+    <lark-td>
+      Bool
+    </lark-td>
+    <lark-td>
+      Indicating whether the APP is enabled by the user or resumed from the background. If the value is true, it means the APP is resumed from the background; if the value is false, it means the APP is enabled by the user directly.
+    </lark-td>
+  </lark-tr>
+  <lark-tr>
+    <lark-td>
+      #start_reason
+    </lark-td>
+    <lark-td>
+      APP enable source
+    </lark-td>
+    <lark-td>
+      Text
+    </lark-td>
+    <lark-td>
+      The content is JSON character string; when the APP is enabled by url or intent method, the `url `content and the` data` in intent would be recorded automatically. For the sample, please refer to:
+      `{url:"thinkingdata://","data":{}}`
+    </lark-td>
+  </lark-tr>
+  <lark-tr>
+    <lark-td>
+      #background_duration
+    </lark-td>
+    <lark-td>
+      Background duration
+    </lark-td>
+    <lark-td>
+      Numeric value
+    </lark-td>
+    <lark-td>
+      Record the background duration of the APP in the time interval between two start events (Unit: second)
+    </lark-td>
+  </lark-tr>
+</lark-table>
+
+- Preset properties of APP end event (ta_app_end)
+<sheet token="Xny0sLWUchPLLQtxkdBcolDwnah_JyO46Y"/>
+
+- Preset properties of APP view screen event (ta_app_view)
+<sheet token="Xny0sLWUchPLLQtxkdBcolDwnah_UeETsg"/>
+
+- Preset properties of APP view click event
+<sheet token="Xny0sLWUchPLLQtxkdBcolDwnah_lC5ttn"/>
+
+- Preset properties of APP crash event (ta_app_crash)
+<sheet token="Xny0sLWUchPLLQtxkdBcolDwnah_QsujSs"/>
+
+## **7. Optional Plugin **
+::: tip
+ This plugin should only be integrated when you need to enable the view click event and Fragment view screen. 
+ :::
+::: tip 
+Starting from version 2.1.0, it is compatible with Gradle8.0.
+ :::
+
+<lark-table rows="4" cols="2" column-widths="230,590">
+
+  <lark-tr>
+    <lark-td>
+      Android Analytics SDK version
+    </lark-td>
+    <lark-td>
+      plugin version
+    </lark-td>
+  </lark-tr>
+  <lark-tr>
+    <lark-td>
+      [oldest - 3.0.0)
+    </lark-td>
+    <lark-td>
+      1.2.0
+    </lark-td>
+  </lark-tr>
+  <lark-tr>
+    <lark-td>
+      [3.0.0 - 3.1.0]
+    </lark-td>
+    <lark-td>
+      2.1.0
+    </lark-td>
+  </lark-tr>
+  <lark-tr>
+    <lark-td>
+      (3.1.0 - latest]
+    </lark-td>
+    <lark-td>
+      2.2.0
+    </lark-td>
+  </lark-tr>
+</lark-table>
+
+```groovy {wrap}
+buildscript {
+    repositories {
+        google()
+        jcenter()
+    }
+    dependencies {
+        classpath 'cn.thinkingdata.android:android-gradle-plugin2:2.2.0'
+    }
+}
+```
+
+Relevant parameters of the plugin could be configured in the build.gradle file of the project
+```nginx {wrap}
+apply plugin: 'cn.thinkingdata.android'
+android {
+
+}
+ThinkingAnalytics {
+    debug = true
+    exclude = []
+    sdk{
+        disableAndroidID = false
+    }
+}
+```
+
+If you want to open the compile log, you can set debug as true, whose default value is false.
+If you do not want to  scan the class under a certain route, you can set 
+`exclude = ['cn.thinkingdata.android','android.support']`
+Code isolation of sensitive properties (e.g., Android ID) can be configured by setting `disableAndroidID`` = ``true`

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

@@ -0,0 +1,49 @@
+---
+code: android_sdk_debug
+name: "Debugging and Logging"
+wikiToken: BlXiw3X5zi7Cakk0EPQcFw8pnyb
+parentWikiToken: LqfmwtW1xi0jzwkrKpscKEzFnme
+updateTime: 1774251961000
+sourceUrl: https://docs-v2.thinkingdata.cn/?version=v6.0&lan=en-US&code=android_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
+```java
+TDAnalytics.enableLog(true);
+```
+
+<quote-container>
+After opening the log, you can check data tracking of SDK by filtering logs related to ThinkingAnalytics in IDE.
+</quote-container>
+
+## **2. Debugging**
+You need to follow the following two steps to enable the Debug mode:
+1. Enable the debug mode at the client side
+The sample code for enabling the Debug mode on the client side is as follows:
+```java
+// obtain TDConfig instance
+TDConfig config = TDConfig.getInstance(this, TE_APP_ID, TE_SERVER_URL);
+/*
+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
+ */
+config.setMode(TDConfig.ModeEnum.DEBUG);
+// initialize SDK
+TDAnalytics.init(config);
+```
+
+2. 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="SbaLbQVQzoxZLTxGVR8cnqcmnCh" width="2782" height="1284" align="left"/>
+
+
+Device ID can be get by the following three methods:
+- #device_id property in the event data of TE
+- Client log: DeviceID would be printed as log after SDK is initialized
+- Call API：[Device ID](https://thinkingdata.feishu.cn/wiki/LqfmwtW1xi0jzwkrKpscKEzFnme)
+<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>