@tencent-rtc/mcp 1.4.7 → 1.6.0-beta.1

package/resource/{doc → knowledge}/livekit/core-sdk/live/flutter/live-barrage.md

@@ -1,35 +1,36 @@
-This document aims to guide Flutter developers on how to use the `BarrageStore` module in the `AtomicXCore` framework to quickly integrate a bullet screen system with various features and outstanding performance for your live stream app.
+This guide shows how to use the `BarrageStore` module in the `AtomicXCore` framework to quickly add a robust, high-performance barrage (live chat overlay) system to your live streaming app.
 
 ## Core Features
 
-`BarrageStore` provides a complete bullet screen solution for your live stream app. Core features include:
-- Receive and show danmakus information in live rooms.
+`BarrageStore` delivers a complete live comment solution for live streaming apps. Key features include:
+- Receiving and displaying live comments in the live room.
 
-- Send text bullet screen for audience interaction.
+- Sending live comments to engage with your audience.
 
-- Send custom business bullet screen to support complex scenarios such as gift and likes.
+- Sending custom live comments to support advanced scenarios such as gifts, likes, and more.
 
-- Insert a system prompt in the local message list (for example, "Welcome XX to enter live room").
+- Inserting system tips into the local message list (e.g., "Welcome to the live room").
 
-## Core Concept Analysis
-| **Core Concept** | **Type** | **Core Responsibility and Description** |
-| --- | --- | --- |
-| [Barrage](https://tencent-rtc.github.io/TUIKit_Flutter/api_barrage_barrage_store/Barrage-class.html) | `class` | Represents a data model for a Danmu Message. It contains all key information such as sender information (`sender`), message content (`textContent` or `data`), and message type (`messageType`). |
-| [BarrageState](https://tencent-rtc.github.io/TUIKit_Flutter/api_barrage_barrage_store/BarrageState-class.html) | `class` | Represents the current status of the bullet screen module. Its core attribute `messageList` is a `ValueListenable<List<Barrage>>`, storing all Danmu messages in the live streaming room in chronological order, serving as the data source for UI rendering. |
-| [BarrageStore](https://tencent-rtc.github.io/TUIKit_Flutter/api_barrage_barrage_store/BarrageStore-class.html) | `class` | This is the core management class for danmu function interaction. Through it, you can send messages (`sendTextMessage`, `sendCustomMessage`) and receive and listen to ALL Danmu Message updates by listening to its `barrageState.messageList` property. |
+## Core Concepts
+
+|**Core Concept**|**Type**|**Core Responsibility and Description**|
+|---------|---------|---------|
+|[Barrage](https://tencent-rtc.github.io/TUIKit_Flutter/api_barrage_barrage_store/Barrage-class.html)|`class`|Represents a data model for a live comments. It contains all key information such as sender information (`sender`), message content (`textContent` or `data`), and message type (`messageType`).|
+|[BarrageState](https://tencent-rtc.github.io/TUIKit_Flutter/api_barrage_barrage_store/BarrageState-class.html)|`class`|Represents the current status of the live comment module. Its core attribute `messageList` is a `ValueListenable<List<Barrage>>`, storing all live comments in the live streaming room in chronological order, serving as the data source for UI rendering.|
+|[BarrageStore](https://tencent-rtc.github.io/TUIKit_Flutter/api_barrage_barrage_store/BarrageStore-class.html)|`class`|The central manager for live comments. Use it to send messages (`sendTextMessage`, `sendCustomMessage`) and listen to its `barrageState.messageList` property to receive and track all live comments updates.|
 
 ## Implementation Steps
 
-### Step 1: Integrating the Component
+### Step 1: Integrate the Component
 - **Live streaming**: Refer to quick integration for seamless integration with **AtomicXCore** and service access.
 
 - **Voice chat room**: Refer to quick integration for seamless integration with **AtomicXCore** and service access.
 
    Return to the current project after integration.
 
-### Step 2: Initialize and Listen to the Bullet Screen
+### Step 2: Initialize and Listen for Live Comment Updates
 
-Retrieve a `BarrageStore` instance bound to the current live streaming room `liveId`, and set a listener to receive the latest **Full** barrage message list in real time.
+Create a `BarrageStore` instance bound to the current live room's `liveId`, and set up a listener to receive real-time updates of the complete live comment list.
 ``` java
 import 'package:flutter/foundation.dart';
 import 'package:atomic_x_core/atomicxcore.dart';
@@ -69,9 +70,9 @@ class BarrageManager {
 }
 ```
 
-### Step 3: Send Text Bullet Screen
+### Step 3: Send a Live Comment
 
-Call the `sendTextMessage` method to broadcast a text message to all users in the live streaming room.
+Call the `sendTextMessage` method to broadcast a live comment to all users in the live streaming room.
 ``` java
 extension BarrageManagerSend on BarrageManager {
   Send a text bullet screen
@@ -82,7 +83,7 @@ extension BarrageManagerSend on BarrageManager {
       return;
     }
 
-    // Call the core API to sendMessage
+    // Call this API to send a message
     final result = await barrageStore.sendTextMessage(
       text: text,
       extensionInfo: null,
@@ -98,15 +99,16 @@ extension BarrageManagerSend on BarrageManager {
 }
 ```
 
-**API parameter:**
-| **Parameter** | **Type** | **Description** |
-| --- | --- | --- |
-| `text` | `String` | The text content to be sent. |
-| `extensionInfo` | `Map<String, String>?` | Attach extra extended information applicable to business customization. |
+**API parameters:**
+
+|**Parameter**|**Type**|**Description**|
+|---------|---------|---------|
+|`text`|`String`|The text content to be sent.|
+|`extensionInfo`|`Map<String, String>?`|Additional extension info.|
 
-### Step 4: Send Custom Barrage Item
+### Step 4: Send Custom Live Comments
 
-Send a message containing custom business logic, such as gift, like or gaming interaction command. This message is transparent to other clients and requires the business layer to parse.
+Send messages containing custom business data, such as gifts or likes. These messages are invisible to other clients and must be parsed by your business logic.
 ``` java
 import 'dart:convert';
 
@@ -123,7 +125,7 @@ extension BarrageManagerCustom on BarrageManager {
     final giftData = {"gift_id": giftId, "gift_count": giftCount};
     final jsonString = jsonEncode(giftData);
 
-    // 3. Call the core API to send custom messages
+    // 3. Call this API to send custom messages
     final result = await barrageStore.sendCustomMessage(
       businessID: businessID,
       data: jsonString,
@@ -138,13 +140,14 @@ extension BarrageManagerCustom on BarrageManager {
 }
 ```
 
-**API parameter:**
-| **Parameter** | **Type** | **Description** |
-| --- | --- | --- |
-| `businessID` | `String` | Business unique identifier, such as "live_gift", used for recipient to distinguish different custom messages. |
-| `data` | `String` | Business data, typically strings in JSON format. |
+**API parameters:**
+
+|**Parameter**|**Type**|**Description**|
+|---------|---------|---------|
+|`businessID`|`String`|Unique business identifier (e.g., "live_gift") to distinguish custom messages.|
+|`data`|`String`|Business data, typically a JSON-formatted string.|
 
-### Step 5: Insert Prompt Message Locally
+### Step 5: Insert Local Tip Messages
 
 Insert a local message into the current user's message list. This message will not be sent to other users in the live streaming room. It is suitable for displaying system welcome, warning or operation prompt information.
 ``` java
@@ -157,17 +160,17 @@ extension BarrageManagerLocal on BarrageManager {
       Welcome ${user.userName} to the live room.
     );
 
-    // 2. Call API to insert it into the local list
+    // 2. Call this API to insert it into the local list
     barrageStore.appendLocalTip(welcomeTip);
   }
 }
 ```
 
-### Step 6: Manage User Speaking (Mute and Unblock)
+### Step 6: Manage User Messaging Permissions (Mute & Unmute)
 
 As an Anchor or admin, you can manage the user speaking permission in the live streaming room to maintain a healthy communication environment.
 
-#### Forbid/Unblock Single-User Speaking
+#### Mute or Unmute Individual Users
 
 Mute or unblock designated users can be achieved by the `disableSendMessage` API in `LiveAudienceStore`.
 ``` java
@@ -194,7 +197,7 @@ if (result.isSuccess) {
 
 #### Enable/Disable Global Mute
 
-To mute all users in the live streaming room (normally excluding the Anchor), you need to update the live room information through `LiveListStore`.
+To mute all users in the live room (typically excluding the host), update the live room info via `LiveListStore`.
 ``` java
 // 1. Get the LiveListStore singleton
 final liveListStore = LiveListStore.shared;
@@ -359,23 +362,21 @@ class _BarrageWidgetState extends State<BarrageWidget> {
 }
 ```
 
-## Advanced Features: Optimizing Performance in High Concurrency Scenarios
+## Advanced Usage: Performance Optimization for High-Concurrency
 
-After using `BarrageStore` to build the danmaku function, this chapter will guide you on how to handle more complex business scenarios, ensuring it can still provide users with a smooth and stable experience in real, complex high-concurrency live broadcasting scenarios. This chapter will focus on three core business scenarios, offering clear optimization schemes and example code.
+After integrating the live comment feature with `BarrageStore`, you may need to handle more demanding scenarios to ensure a smooth and stable user experience, especially during high-concurrency live streams. The following use cases provide practical optimization strategies and code samples.
 
-### Scenario One: High-Concurrency Bullet Screen Scenario
+### Scenario 1: Handle High-Concurrency Live Comments
 
-#### Scenario Description
-
-During a popular event, a large number of audience flooded into the live streaming room, with bullet screens updating at a frequency of dozens per second.
+During major events, a large number of viewers may join the live room, causing live comments to refresh dozens of times per second.
 
 #### **Technical Challenge**
 
-The SDK returns the complete bullet screen list at an extremely high frequency. Each time the UI is rebuilt, the main thread will be blocked by intensive UI layout and rendering operations, causing interface lag.
+The SDK pushes the complete the live comment list at high frequency. If the UI rebuilds on every update, the main thread can become overloaded with layout and rendering, resulting in lag.
 
-#### **Optimization Scheme: **Batch Processing & Traffic Peak Shaving
+#### **O**ptimization Strategy: Batch Processing and Debouncing
 
-Do not respond to every data update, but set a time threshold (such as 300 ms). Only when the distance from the last UI refresh exceeds this threshold, execute the next refresh operation. This reduces UI redraws from dozens per second to 3-4 per second, significantly improving smoothness.
+Instead of responding to every update, set a time threshold (e.g., 300ms). Only refresh the UI if enough time has passed since the last update. This reduces UI redraws from dozens per second to just a few, greatly improving smoothness.
 ``` java
 class BarrageUIManager {
   List<Barrage>? _latestMessageList;
@@ -412,19 +413,17 @@ class BarrageUIManager {
 }
 ```
 
-### Scenario 2: Guarantee Memory Stability for Long-Term Live Stream
-
-#### Scenario Description
+### Scenario 2: Maintain Memory Stability for Long Streams
 
-Your application requires support for uninterrupted live streaming lasting several hours or even around the clock, such as game live broadcast or slow live streaming. During this period, the App must maintain stable operation and cannot exit unexpectedly due to long-running.
+Your app may need to support hours-long or even all-day continuous live streaming, such as gaming or slow live streams. The app must remain stable and avoid crashes due to long-term operation.
 
 #### Technical Challenge
 
-The full `messageList` returned by the SDK will grow infinitely during long-term live streams. Even if the UI layer implements traffic throttling, the huge array held by the data layer will continue to occupy memory, eventually causing the app to crash.
+The SDK's `messageList` grows indefinitely during long streams. Even with throttled UI updates, the underlying data array can consume excessive memory, eventually leading to crash
 
-#### **Optimization Scheme**: Fixed Capacity Circular Buffer
+#### **O**ptimization Strategy: Fixed-Size Circular Buffer
 
-**Only let your own data source (DataSource) hold a finite number of messages**. Regardless of how large the full list returned by the SDK is, your application only takes the latest part for display.
+**Limit the number of messages your data source retains**. Regardless of the SDK's full list size, only display the latest messages in your app.
 ``` java
 void _refreshUIIfNeeded() {
   final fullList = _latestMessageList;
@@ -442,17 +441,15 @@ void _refreshUIIfNeeded() {
 }
 ```
 
-## API documentation
+## API Documentation
 
 For detailed information about ALL public interfaces, attributes, and methods of [BarrageStore](https://tencent-rtc.github.io/TUIKit_Flutter/api_barrage_barrage_store/BarrageStore-class.html) and its related classes, see the official API documentation included with the [AtomicXCore](https://tencent-rtc.github.io/TUIKit_Flutter/index.html) framework.
 
 ## FAQs
 
-### How to Achieve Various Bullet Screen Styles Such As Color Bullet Screen and Gift Bullet Screen
-
-This is actually achieved by the custom message `sendCustomMessage`. `BarrageStore` does not limit your business imagination.
+### How can I implement colored live comments, gifts, or other custom styles?
 
-**Implementation Approach**
+Use custom messages with `sendCustomMessage`. `BarrageStore` gives you full flexibility for business-specific live comments.
 1. **Define data structure:** Work with your client and server team to define the JSON structure of custom messages. For example, a color bullet screen can be defined as follows:
 
    ``` json
@@ -460,34 +457,34 @@ This is actually achieved by the custom message `sendCustomMessage`. `BarrageSto
    ```
 2. **Sender:** During sending, convert this JSON structure to a string and send it via the `data` parameter of `sendCustomMessage`. `businessId` can be set to a unique identifier representing your business, such as "`barrage_style_v1`".
 
-3. **Receiver**: After receiving the Danmu Message, check whether its `messageType` is `.custom` and whether `businessId` matches. If matched, parse the `data` string (usually parsing JSON), and render your custom UI style based on the parsed data (such as `color, text`).
+3. **Receiver**: After receiving the live comments, check whether its `messageType` is `.custom` and whether `businessId` matches. If matched, parse the `data` string (usually parsing JSON), and render your custom UI style based on the parsed data (such as `color, text`).
 
-### Different Classes and Files Call `BarrageStore.create("some_id")`. Will This Create Multiple Instances and Cause Chaos?
+### If I call BarrageStore.create("some_id") in different classes or files, will this create multiple instances?
 
-No worries at all. `AtomicXCore`'s internal mechanism will underwrite that as long as the `liveId` passed in is identical, the `BarrageStore` instance obtained will always be the same one bound to the live streaming room. You can use it wherever required without manually managing the singleton.
+No. The internal logic of `AtomicXCore` ensures that as long as you use the same liveId, you always get the same `BarrageStore` instance for that live room. You don't need to manage the singleton yourself.
 
-### Why Call SendTextMessage but Can'T See Messages Sent in the Message List?
+### Why can't I see my sent message in the message list after calling sendTextMessage?
 
-**Take the following steps to troubleshoot:**
-1. **Check returned results**: The `sendTextMessage` method has a complete callback. Please check if the callback returned a successful status or failure. If unsuccessful, the error information will specify the issue (such as "You are muted", "network error").
+**Troubleshooting**:
+1. **Check the result**: The sendTextMessage method provides a completion callback. Check if the result is success or failure. If it failed, the error message will indicate the reason (e.g., "You have been muted", "Network error", etc.).
 
-2. **Confirm the timing of listening**: Underwrite your `barrageStore.state` subscription occurs after the `liveId` live stream starts. If you start listening before joining the live streaming room, you may miss some messages.
+2. **Confirm subscription timing**: Make sure you subscribe to barrageStore.state after the live room for the corresponding liveId has started. If you start listening before joining the live room, you may miss some messages.
 
-3. **Check liveId**: Confirm the `liveId` used when creating the `BarrageStore` instance, joining the live streaming room, and sending messages is the same, including case sensitivity.
+3. **Check liveId**: Ensure the liveId used when creating the BarrageStore instance, joining the live room, and sending messages is exactly the same (case-sensitive).
 
-4. **Network issue**: Check whether the current network connection of the device is normal. Sending messages depends on the network.
+4. **Network issues**: Make sure the device has a working network connection. Message sending depends on network connectivity.
 
-### How to Show New Audience the History Danmu Messages When They Enter the Live Room
+### How can new viewers see barrage messages sent before they joined the live room?
 
-`AtomicXCore` supports pulling history Danmu Messages, but this requires you to perform one simple configuration in the **server console**. Once configured, the SDK will automatically handle everything subsequently with no need to write additional code.
+`AtomicXCore` supports pulling history live comments, but this requires you to perform one simple configuration in the **server console**. Once configured, the SDK will automatically handle everything subsequently with no need to write additional code.
 
-#### **Procedure 1: Perform Configuration in the Live Console**
+#### **Step 1: **Configure in the Live Console
 1. Log in to the [**console > Live > Configuration**](https://console.trtc.io/live/configuration), and select the target application at the **top**.
 
 2. On the Live configuration page, select **new member pull historical messages**, modify **new member viewable latest message count**, supports a maximum of **50**.
 
    **Step 2: Client Seamless Retrieval**
 
-   After completing the above configuration, your client-side code **requires no modification**.
+   After this configuration, no client code changes are needed.
 
-   When a new user joins the live room, the `AtomicXCore` underlying layer will automatically pull your configuration history message count. These historical messages will be pushed to your UI layer through your realized `BarrageStore.barrageState` subscription channel, just like real-time messages. Your application will naturally receive and show these historical bullet screens, same as receiving real-time bullet screens.
+   When a new user joins the live room, `AtomicXCore` automatically retrieves the configured number of historical messages at the SDK level. These messages are delivered to your UI via the same `v` subscription you already use. Your app will receive and display these historical barrages just like real-time messages.

package/resource/{doc → knowledge}/livekit/core-sdk/live/flutter/live-base-beauty.md

@@ -14,22 +14,21 @@
 ## Core Concepts
 
 Before starting integration, we first learn about the core concepts related to `BaseBeautyStore` in the following table:
-| **Core Concepts** | **Type** | **Core Responsibilities and Description** |
-| --- | --- | --- |
-| [BaseBeautyState](https://tencent-rtc.github.io/TUIKit_Flutter/api_device_base_beauty_store/BaseBeautyState-class.html) | `class` | Represents the current status of the beauty module. It includes the intensity values of currently effective skin smoothing (`smoothLevel`), whitening (`whitenessLevel`), and rosy (`ruddyLevel`). All attributes are `ValueListenable<double>` data type and support subscription listening. |
-| [BaseBeautyStore](https://tencent-rtc.github.io/TUIKit_Flutter/api_device_base_beauty_store/BaseBeautyStore-class.html) | `class` | This is the core management class for interacting with the basic beauty filter feature. It is a Global Singleton (`shared`), responsible for ALL basic beauty parameter settings, reset and state synchronization. |
+
+|**Core Concepts**|**Type**|**Core Responsibilities and Description**|
+|---------|---------|---------|
+|[BaseBeautyState](https://tencent-rtc.github.io/TUIKit_Flutter/api_device_base_beauty_store/BaseBeautyState-class.html)|`class`|Represents the current status of the beauty module. It includes the intensity values of currently effective skin smoothing (`smoothLevel`), whitening (`whitenessLevel`), and rosy (`ruddyLevel`). All attributes are `ValueListenable<double>` data type and support subscription listening.|
+|[BaseBeautyStore](https://tencent-rtc.github.io/TUIKit_Flutter/api_device_base_beauty_store/BaseBeautyStore-class.html)|`class`|This is the core management class for interacting with the basic beauty filter feature. It is a Global Singleton (`shared`), responsible for ALL basic beauty parameter settings, reset and state synchronization.|
 
 ## Implementation Steps
 
-### Step 1: Integrating the Component
+### Step 1: Integrate the Component
 
 Refer to Quick Connection for seamless integration with **AtomicXCore** and access completed.
 
-### Step 2: Getting the Instance and Listening to the Status
+### Step 2: Obtain the Instance and Listen to the State
 
 Get the Global Singleton of `BaseBeautyStore` and set a listener to get the current beauty effect parameter status in real time.
-
-#### Implementation Method
 1. **Get the singleton**: Directly use `BaseBeautyStore.shared` to get the globally unique `BaseBeautyStore` instance.
 
 2. **Subscription status**: Listen for changes in the `baseBeautyState` properties via `addListener` to get beauty parameter updates in real time.
@@ -77,11 +76,9 @@ class BeautyManager {
 }
 ```
 
-### Step 3: Set Beauty Parameter
+### Step 3: Set Beauty Parameters
 
 When the user drags the beauty effect slider or clicks the preset button, call the appropriate API to set the intensity of beauty effects.
-
-#### Implementation Method
 1. **Get intensity value**: Obtain the intensity value set by the user from the UI control (such as `Slider`). The parameter range accepted by the SDK API is `0-9`, where `0` means disabling the effect and `9` indicates the most obvious effect. You need to map the value of the UI control (for example, `0.0 - 1.0` of the Slider) to the range of `0 - 9`.
 
 2. **API call**: Call `setSmoothLevel()`, `setWhitenessLevel()`, and `setRuddyLevel()` to set the intensity of skin smoothing, whitening, and rosy effect.
@@ -110,13 +107,9 @@ extension BeautyManagerExtension on BeautyManager {
 }
 ```
 
-### Step 4: Reset Beauty Effect
-
-When the user clicks the "Reset" or "Disable Beauty Effects" button, restore all beauty parameters to the default value (usually 0).
+### Step 4: Reset Beauty Effects
 
-#### Implementation Method
-
-**Calling the API**: call directly the `baseBeautyStore.reset()` method.
+When the user clicks the "**Reset**" or "**Disable Beauty Effects**" button, call the `baseBeautyStore.reset()` method to restore all beauty parameters to the default value (usually 0).
 
 #### Sample Code
 ``` java
@@ -128,9 +121,9 @@ extension BeautyManagerReset on BeautyManager {
 }
 ```
 
-## Building a Beauty Effect UI
+## Build a Beauty Effect UI
 
-Flutter recommended using `ValueListenableBuilder` to build responsive UI, which auto-updates the interface when beauty effect parameters change:
+Flutter recommends using `ValueListenableBuilder` to build responsive UI, which auto-updates the interface when beauty effect parameters change:
 ``` java
 class BeautySliderWidget extends StatelessWidget {
   final beautyStore = BaseBeautyStore.shared;
@@ -214,7 +207,7 @@ class BeautySliderWidget extends StatelessWidget {
 }
 ```
 
-## Complete Example
+## Complete Sample Code
 ``` java
 import 'package:flutter/material.dart';
 import 'package:atomic_x_core/atomicxcore.dart';
@@ -301,44 +294,47 @@ class BeautySettingsPage extends StatelessWidget {
 
 ### Basic Beauty Filter Vs Advanced Beauty Effect
 
-AtomicXCore also provided advanced beauty effect support to meet requirements of different scenes:
-| **Comparison Item** | **Basic Beauty Filter (BaseBeautyStore)** | **Advanced Beauty Effect (TencentEffect Requires Additional Integration)** |
-| --- | --- | --- |
-| Core Features | Skin smoothing, whitening, rosy | Includes basic beauty filter, with various effects like V-face, eye distance adjustment, nose slimming, 3D stickers, filters, and makeup. |
-| Billing | free (included in AtomicXCore license) | Payment (Tencent Effect SDK License must be bought extra). |
-| integration method | default built-in, direct use `BaseBeautyStore.shared` | Additional integration of the `TencentEffect` component is required and authenticate. |
-| Recommended scenarios | Scenarios with low beauty effect requirements that need quick implementation of basic beauty effect features | Scenarios with high beauty effect requirements that require various advanced functions such as beauty shaping, stickers, and filters. |
+AtomicXCore also provides advanced beauty features for more demanding scenarios:
+
+|Comparison Item|Basic Beauty (BaseBeautyStore)|Advanced Beauty (TencentEffect, requires additional integration)|
+|---------|---------|---------|
+|Core Features|Skin smoothing, whitening, rosy|All basic beauty features, plus V-shaped face, eye distance, nose slimming, 3D stickers, filters, makeup, and more|
+|Pricing|Free (included with AtomicXCore license)|Paid (requires separate TencentEffect SDK license)|
+|Integration Method|Built-in by default, use BaseBeautyStore.shared directly|Requires additional integration of the TencentEffect component and authentication|
+|Recommended Scenarios|Use for simple beauty requirements or when you need to quickly enable basic beauty features|Use for advanced beauty requirements, including shaping, stickers, filters, and other enhanced effects|
 
-### Integrate Advanced Beauty Effect
+### Integrate Advanced Beauty
 
-If you need to use the advanced beauty function, refer to the [Advanced Beauty](https://trtc.io/document/73778?product=beautyar&menulabel=core%20sdk&platform=flutter) document for integration. After successful integration and authentication of `TencentEffect`, you can control ALL beauty effects through the API provided by `TencentEffect`.
+If you need to use the advanced beauty function, refer to the [Advanced Beauty](https://trtc.io/document/73778) document for integration. After successful integration and authentication of `TencentEffect`, you can control ALL beauty effects through the API provided by `TencentEffect`.
 
 ## API Reference
 
 ### BaseBeautyStore
-| **Property/Method** | **Type** | **Note** |
-| --- | --- | --- |
-| `shared` | `BaseBeautyStore` | Singleton instance |
-| `baseBeautyState` | `BaseBeautyState` | Beauty effect status |
-| `setSmoothLevel` | `void` | Set the skin smoothing strength (0-9). |
-| `setWhitenessLevel` | `void` | Set the brightening strength (0-9). |
-| `setRuddyLevel` | `void` | Set the rosy strength (0-9). |
-| `reset` | `void` | Reset all beauty parameters to default value (0). |
+
+|**Property/Method**|**Type**|**Description**|
+|---------|---------|---------|
+|`shared`|`BaseBeautyStore`|Singleton instance|
+|`baseBeautyState`|`BaseBeautyState`|Beauty effect status|
+|`setSmoothLevel`|`void`|Set the skin smoothing strength (0-9).|
+|`setWhitenessLevel`|`void`|Set the brightening strength (0-9).|
+|`setRuddyLevel`|`void`|Set the rosy strength (0-9).|
+|`reset`|`void`|Reset all beauty parameters to default value (0).|
 
 ### BaseBeautyState
-| **Attribute** | **Type** | **Note** |
-| --- | --- | --- |
-| `smoothLevel` | `ValueListenable<double>` | Skin smoothing strength (0-9). |
-| `whitenessLevel` | `ValueListenable<double>` | Brightening strength (0-9). |
-| `ruddyLevel` | `ValueListenable<double>` | Rosy strength (0-9). |
+
+|**Attribute**|**Type**|**Description**|
+|---------|---------|---------|
+|`smoothLevel`|`ValueListenable<double>`|Skin smoothing strength (0-9).|
+|`whitenessLevel`|`ValueListenable<double>`|Brightening strength (0-9).|
+|`ruddyLevel`|`ValueListenable<double>`|Rosy strength (0-9).|
 
 ## FAQs
 
-### I Set Up the Beauty Parameter, Why No Effect?
+### Beauty parameters have no effect after being set
 
-Please check the following points:
-1. **Is the camera enabled**: You must successfully turn on the camera (e.g. by `DeviceStore.shared.openLocalCamera()`) before the beauty effect can apply to the video stream.
+If you do not see any beauty effect after setting the parameters, check the following:
+1. Camera enabled: Make sure the camera is open (for example, using `DeviceStore.shared.openLocalCamera()`). Beauty effects are only applied to the video stream when the camera is active.
 
-2. **Whether to use advanced beauty effect**: If you integrated `TencentEffect` (advanced beauty), ensure you use the API provided by `TencentEffect` to adjust the beauty effect.
+2. Advanced beauty integration: If you have integrated TencentEffect (advanced beauty), ensure you are using the APIs provided by TencentEffect to adjust beauty settings.
 
-3. **Parameter range**: If you use basic beauty filter, confirm the strength value passed in is within the effective range (a double value between `0` and `9`).
+3. Parameter range: For basic beauty, verify that the intensity values you provide are within the valid range (0 to 9, as a double).