@tencent-rtc/mcp 1.7.3 → 1.7.5

package/resource/knowledge/callkit/best-practice/flutter/background-incoming-call-no-notification.md

@@ -0,0 +1,99 @@
+---
+title: TUICallKit Flutter — No System Notification, No Answer/Decline Buttons, App Not Launched on Background/Lock-Screen Incoming Calls (Notification / VoIP / Permission Troubleshooting)
+product: call
+frameworks: [flutter, android, ios]
+scope: platform_specific
+tags: [TUICallKit, Flutter, Android, iOS, background incoming call, lock screen, TIMPush, VoIP, CallKit, Notification, enableIncomingBanner, overlay permission]
+version_range: ">=2.0.0"
+---
+
+# TUICallKit Flutter — No System Notification, No Answer/Decline Buttons, App Not Launched on Background/Lock-Screen Incoming Calls (Notification / VoIP / Permission Troubleshooting)
+
+## 1. Key Takeaway
+
+- Android: To fully support **system notification + answer/decline buttons + auto-launch the app** for background/lock-screen incoming calls, you need TIMPush (FCM or vendor push channels) + the `enableIncomingBanner` switch + **overlay permission** and **background launch permission**. Missing any one of these will degrade the experience (e.g., ringtone only without notification/buttons, or app not launched).
+- iOS: **TIMPush currently does not support iOS VoIP push** (explicitly stated in the official documentation, updated 2026-08-12). The Flutter iOS side can only use **APNs regular push**. It cannot use the system-level CallKit incoming call UI. Therefore, when the app is killed or the screen is locked, iOS **cannot** auto-launch an answer/decline button screen like Android. It can only receive a regular notification; tapping the notification wakes the app.
+- Troubleshooting direction: First determine the platform (Android: permission troubleshooting; iOS: push type capability boundary). The root causes and fixes are entirely different — do not apply the same solution to both.
+- If the app is in the **foreground** and receives a call but shows no buttons / does not launch the call UI: This is unrelated to push. Check whether `enableIncomingBanner` is configured or overlay permission is missing (Android), or whether the `onCallReceived` event listener is missing (iOS/Android common).
+
+## 2. Field Reference
+
+| Field / Capability | Purpose | Notes |
+|---|---|---|
+| `TIMPush` (`tencent_cloud_chat_push` plugin) | General offline push solution | Android supports VoIP-type push (via FCM or vendor channels); iOS **currently supports APNs only**, not VoIP |
+| `TUIOfflinePushInfo.iOSPushType` | Specify iOS push type | Can only be set to `TUICallIOSOfflinePushType.APNs`; setting it to VoIP-related values has no effect under current official capabilities |
+| `enableIncomingBanner` | Control callee-side incoming call display mode | `false` (default): directly tries to launch the full-screen call UI; `true`: shows a banner notification first, requires **overlay permission** to display |
+| Overlay permission (display over other apps) | Android system permission | Required for showing custom incoming call banners and call floating windows; missing this prevents banners/answer buttons from appearing |
+| Background launch permission | Android system permission (strictly enforced by some vendors like vivo) | Required for launching the call UI when the app is in the background; missing this prevents auto-launching the app |
+| iOS CallKit / PushKit | iOS native system-level incoming call capability | Flutter TUICallKit **does not provide** official integration docs for this; only the native iOS SDK has related documentation |
+
+## 3. Flow
+
+User symptom: ringtone heard but no system notification, no answer/decline buttons at the top, app not launched -> Determine platform first:
+
+**Android troubleshooting path**: Confirm TIMPush is integrated and push is registered -> Confirm the IM console has the correct FCM certificate uploaded with message type set to "pass-through (data) message" -> Confirm `enableIncomingBanner(true)` has been called -> Confirm the device has granted **overlay permission** and **background launch permission** (permission names vary by vendor; vivo/Redmi may require manual enabling) -> If the UI still does not launch, check whether the main Activity's task root logic (`isTaskRoot()`) is missing, and confirm the Activity launch mode is **not** `singleTask`.
+
+**iOS troubleshooting path**: Confirm expectations are realistic — **iOS currently does not officially support VoIP push**, so system-level incoming call UI (answer/decline buttons, auto-launch when app is killed / screen locked) is not achievable -> For APNs regular push scenarios, verify the certificate is correctly uploaded, `iOSPushType` is set to `APNs`, and `TencentCloudChatPush().registerPush` is correctly called -> If the business absolutely requires the system-level incoming call experience, evaluate implementing a native bridge for PushKit + CallKit (beyond the scope of the official standard solution; requires custom implementation and maintenance).
+
+## 4. Standard Usage
+
+1. Both platforms: Install and register the `tencent_cloud_chat_push` plugin. Immediately call `TencentCloudChatPush().registerPush(...)` after a successful login.
+
+2. **Android**:
+   - Integrate FCM (or required vendor) push channels. In the IM console, set the message type to "pass-through (data) message".
+   - Call `TUICallKit.instance.enableIncomingBanner(true)` to enable the incoming call banner (if banner + button display is desired).
+   - Request overlay and background launch permissions:
+
+     ``` kotlin
+     PermissionRequester.newInstance(
+         PermissionRequester.FLOAT_PERMISSION,
+         PermissionRequester.BG_START_PERMISSION
+     ).request()
+     ```
+
+   - In the app's default launch Activity (e.g., SplashActivity, and the **launch mode must not be `singleTask`**), add:
+
+     ``` java
+     if (!isTaskRoot() && getIntent() != null
+         && getIntent().hasCategory(Intent.CATEGORY_LAUNCHER)
+         && Intent.ACTION_MAIN.equals(getIntent().getAction())) {
+         finish();
+         return;
+     }
+     ```
+
+3. **iOS**:
+   - For APNs regular push only: Apply for and upload the APNs certificate. Set `offlinePushInfo.iOSPushType = TUICallIOSOfflinePushType.APNs`.
+   - Clearly communicate to the business team: The iOS side **cannot** achieve "auto-launch system-level answer/decline buttons after the app is killed / screen locked" through the official standard solution. Users can only receive a notification and tap it to wake the app and enter the call flow.
+   - If this experience is absolutely required, a custom native PushKit + CallKit bridge solution must be developed (not within the official TUICallKit support scope).
+
+4. Both platforms: When receiving a call while in the **foreground**, you can listen for the `onCallReceived` event and use plugins like `flutter_local_notifications` to customize the notification appearance (independent of the offline push pipeline).
+
+## 5. Verification
+
+- Android: App in background / screen locked. After receiving an incoming call, a banner or full-screen UI is displayed with visible answer/decline buttons. Tapping correctly launches/wakes the app.
+- iOS: App in background. An APNs notification is received. Tapping the notification wakes the app and enters the call flow. **Do not** expect a system-level answer/decline incoming call screen when the app is killed or the screen is locked (not supported by current official capabilities).
+- Both platforms: When receiving a call in the foreground, the call invitation UI or custom notification is displayed correctly.
+
+## 6. Common Mistakes
+
+- Mistake 1: Treating Android and iOS background incoming call issues as the same problem. The root causes are entirely different (Android: permission configuration; iOS: official capability boundary). Applying the same solution (e.g., only checking permissions) will not resolve the iOS issue.
+- Mistake 2: Believing that setting `iOSPushType = VoIP` on iOS will enable the system-level incoming call UI. TIMPush currently **does not support** iOS VoIP; setting this value has no effect. Only `APNs` is the currently supported valid value.
+- Mistake 3: On Android, only configuring the push certificate without enabling overlay permission and background launch permission. Mistakenly thinking push was not received, when in reality the push was received but insufficient system permissions prevented the UI from launching (check logs first to confirm whether `onCallReceived` was triggered, then troubleshoot permissions).
+
+## 7. Problem Definition (Search Anchor)
+
+Flutter TUICallKit app receives incoming calls in background/lock screen but only hears a ringtone — no system notification, no answer/decline buttons, and app does not auto-launch. What configurations are needed for Android and iOS respectively (Notification, CallKit, VoIP Push, TIMPush).
+
+## 8. Alternative Phrasings (Search Recall)
+
+- Flutter TUICallKit no notification on background incoming call?
+- Does TUICallKit Flutter iOS support VoIP incoming calls?
+- Flutter incoming call banner not showing answer/decline buttons?
+- Android background incoming call not launching the app?
+
+## 9. References (Optional)
+
+- Flutter offline push Notification configuration: `https://cloud.tencent.com/document/product/647/106014`
+- Flutter VoIP configuration (official iOS limitation note): `https://cloud.tencent.com/document/product/647/106015`
+- Android callee-side incoming call display strategy and permission troubleshooting: `https://cloud.tencent.com/document/product/647/78767`

package/resource/knowledge/callkit/best-practice/flutter/ios-keep-call-alive-background.md

@@ -0,0 +1,93 @@
+---
+title: TUICallKit Flutter iOS — Call Audio Interrupted When App Goes to Background / Screen Locked (Background Modes + AVAudioSession Configuration)
+product: call
+frameworks: [flutter, ios]
+scope: platform_specific
+tags: [TUICallKit, Flutter, iOS, VoIP, AVAudioSession, Background Modes, UIBackgroundModes, playAndRecord, keep alive, background, CallKit, MethodChannel]
+version_range: ">=2.0.0"
+---
+
+# TUICallKit Flutter iOS — Call Audio Interrupted When App Goes to Background / Screen Locked (Background Modes + AVAudioSession Configuration)
+
+## 1. Key Takeaway
+
+- Required: iOS restricts background apps from accessing the microphone/speaker. If not configured correctly, audio capture/playback will be interrupted by the system when the app goes to background or the screen is locked.
+- Root cause: Background Modes not declared, or `AVAudioSession` not manually configured to the `.playAndRecord` category. TUICallKit **does not automatically configure** `AVAudioSession`; developers must set it up in the native layer.
+- Fix: Enable three Background Modes items in Xcode (this is **not** iOS-version-specific — all versions require this) + configure `AVAudioSession` in the native layer before the call starts via Flutter `MethodChannel`.
+- No CallKit integration required: This solution does not depend on the iOS `CallKit` framework. Background audio keep-alive for voice/video calls is achieved purely through Background Modes + `AVAudioSession`.
+- Clarification (avoid misuse): Apple's `com.apple.developer.avfoundation.multitasking-camera-access` entitlement is exclusively for **camera background capture in Picture-in-Picture (PiP) scenarios**. It is unrelated to this problem (audio call background keep-alive) — do not confuse the two.
+
+## 2. Field Reference
+
+| Field / Capability | Purpose | Notes |
+|---|---|---|
+| `Audio, AirPlay, and Picture in Picture` | Background Modes capability | Maintains background audio capture/playback capability; must be enabled for all iOS versions |
+| `Voice over IP` | Background Modes capability | Supports VoIP background execution; must be enabled for **all versions**, not just iOS 18+ |
+| `Remote notifications` (optional) | Background Modes capability | For receiving offline push notifications; not required for audio keep-alive |
+| `AVAudioSession.Category.playAndRecord` | Audio session category | Supports simultaneous playback and recording; must be set **manually** before the call — the SDK does not configure this automatically |
+| `.allowBluetooth` / `.allowBluetoothA2DP` | Audio session options | Enables Bluetooth headset and high-quality Bluetooth audio (A2DP) support |
+| `MethodChannel` | Flutter-native communication bridge | `AVAudioSession` configuration must be done in the native Swift/ObjC layer; Flutter triggers it via MethodChannel |
+
+## 3. Flow
+
+App goes to background / screen locked -> iOS restricts background microphone/speaker access -> If not configured, call audio is interrupted (remote participant cannot hear local audio) -> Check: verify Background Modes has `Audio, AirPlay, and Picture in Picture` + `Voice over IP` enabled -> Identify: verify `AVAudioSession.setCategory(.playAndRecord)` and `setActive(true)` are called before the call starts -> Fix: declare Background Modes in Xcode + configure `AVAudioSession` in native layer + trigger via Flutter `MethodChannel` -> Verify: call audio continues after going to background / locking screen; `Info.plist` contains `audio` / `voip` in `UIBackgroundModes`.
+
+## 4. Standard Usage
+
+1. In Xcode, open the project, select `Target` > `Signing & Capabilities` > `+ Capability`, search for and add `Background Modes`. Check `Audio, AirPlay, and Picture in Picture` and `Voice over IP` (`Remote notifications` is optional, for offline push). After configuration, `Info.plist` will automatically contain:
+
+   ``` xml
+   <key>UIBackgroundModes</key>
+   <array>
+       <string>audio</string>
+       <string>voip</string>
+   </array>
+   ```
+
+2. Implement the audio session configuration method in the iOS native layer (Swift). Call it before the call starts (in the call view's `viewDidLoad`, before initiating `calls`, or before accepting `accept`):
+
+   ``` swift
+   import AVFoundation
+
+   func setupAudioSessionForCall() {
+       let audioSession = AVAudioSession.sharedInstance()
+       do {
+           // .playAndRecord: supports simultaneous playback and recording
+           // .allowBluetooth / .allowBluetoothA2DP: supports Bluetooth headset and high-quality Bluetooth audio
+           try audioSession.setCategory(.playAndRecord, options: [.allowBluetooth, .allowBluetoothA2DP])
+           try audioSession.setActive(true)
+       } catch {
+           // Audio session configuration failed
+       }
+   }
+   ```
+
+3. Register a `MethodChannel` on the Flutter side. Call the native `setupAudioSessionForCall()` when a call starts (`calls` / `accept` succeeds). When the call ends, you can restore or deactivate `AVAudioSession` to avoid affecting other audio scenarios.
+
+4. You do not need to integrate the iOS `CallKit` framework to achieve the above background audio keep-alive. If you later need system incoming call UI / lock-screen answer capabilities, that requires additional `CallKit` integration (a separate capability, not a prerequisite for background keep-alive).
+
+## 5. Verification
+
+- After going to background or locking the screen, call audio capture/playback is not interrupted; the remote participant can still hear the local audio.
+- `Info.plist` correctly contains `audio` and `voip` in `UIBackgroundModes`.
+- Background audio keep-alive works correctly even without integrating `CallKit`.
+
+## 6. Common Mistakes
+
+- Mistake 1: Assuming TUICallKit Flutter/iOS SDK has built-in `AVAudioSession` configuration. In reality, the SDK does not configure this automatically; developers must explicitly call `setCategory` / `setActive` in the native layer.
+- Mistake 2: Confusing "call audio background keep-alive" with "Picture-in-Picture (PiP) camera background capture". Applying for the `com.apple.developer.avfoundation.multitasking-camera-access` entitlement for a voice/video call — this entitlement is only for **camera video** background capture in PiP scenarios and is unrelated to audio call keep-alive. Regular calls do not need it.
+- Mistake 3: Thinking `Voice over IP` only needs to be checked on iOS 18+. In fact, the three Background Modes items are not iOS-version-specific — all versions (iOS 15+) require the same configuration.
+
+## 7. Problem Definition (Search Anchor)
+
+Flutter TUICallKit iOS call audio interrupted when app goes to background or screen is locked. Whether Background Modes and AVAudioSession configuration is required. Whether CallKit integration is needed. Difference from the Picture-in-Picture approach.
+
+## 8. Alternative Phrasings (Search Recall)
+
+- TUICallKit Flutter iOS no sound after going to background?
+- Flutter iOS call audio stops when screen is locked?
+- Can voice calls stay alive in background without CallKit?
+- How to configure AVAudioSession playAndRecord for background audio capture?
+
+## 9. References (Optional)
+- Tencent Cloud TRTC iOS Picture-in-Picture documentation (the actual use case for `multitasking-camera-access` entitlement): `https://cloud.tencent.com/document/product/647/128652`

package/resource/knowledge/callkit/best-practice/flutter/ios-startup-crash-version-voip.md

@@ -0,0 +1,68 @@
+---
+title: TUICallKit Flutter iOS Startup Crash Troubleshooting (Minimum OS Version, Release Symbol Stripping, VoIP PushKit Applicability)
+product: call
+frameworks: [flutter, ios]
+scope: platform_specific
+tags: [TUICallKit, Flutter, iOS, crash, startup crash, tencent_calls_uikit, PushKit, CallKit, VoIP, symbol not found, minimum OS version]
+version_range: ">=2.0.0"
+---
+
+# TUICallKit Flutter iOS Startup Crash Troubleshooting (Minimum OS Version, Release Symbol Stripping, VoIP PushKit Applicability)
+
+## 1. Key Takeaway
+
+- Minimum OS version: The Flutter plugin `tencent_calls_uikit` officially requires iOS **12.0** or later. iOS 16 falls within this range and is natively compatible — no additional adaptation is needed.
+- Flutter TUICallKit's **standard offline push solution does not integrate PushKit VoIP**. It only provides APNs regular push (data message). Therefore, the iOS 13+ rule of "app gets killed if a VoIP push is received without reporting to CallKit" **does not apply** to standard integrations that have not been custom-extended.
+- The most common real cause of Flutter TUICallKit iOS startup crashes: **Xcode symbol stripping optimization in Release builds incorrectly removes TRTC C symbols**, resulting in `symbol not found`. This is unrelated to VoIP/PushKit/CallKit.
+- If developers **additionally integrate PushKit VoIP on their own** (beyond the TUICallKit official standard solution), they must comply with Apple's mandatory rule: "after receiving a VoIP push, `reportNewIncomingCall` / `reportNewIncomingConversation` must be called immediately; otherwise the system will kill the app." This is the responsibility of the custom extension, not a built-in TUICallKit behavior.
+
+## 2. Field Reference
+
+| Field / Capability | Purpose | Notes |
+|---|---|---|
+| `tencent_calls_uikit` | Flutter TUICallKit plugin package name | Officially requires iOS 12.0+. This is a different dependency level from `TXLiteAVSDK_Professional` (a separate library with podspec declaring iOS 8.0) — do not confuse the two |
+| APNs (remote push) | Official offline push solution for Flutter TUICallKit | Implemented via the `tencent_cloud_chat_push` plugin; iOS side only involves APNs certificate configuration, not PushKit |
+| PushKit VoIP | iOS native system-level incoming call push mechanism | Flutter TUICallKit **official documentation does not provide** this approach; only native iOS (Swift/ObjC) integration docs include it (based on `LiveCommunicationKit` / `CallKit`) |
+| `reportNewIncomingCall` / `reportNewIncomingConversation` | Mandatory reporting interface after receiving VoIP push | Only required when **PushKit VoIP is registered**; failure to report within 5 seconds causes a system kill. Not applicable to standard Flutter solutions that have not integrated PushKit |
+| Deployment Postprocessing / Strip Style | Xcode Build Settings options | Used to prevent Release builds from incorrectly stripping TRTC FFI-related C symbols — this is the known real cause of Flutter TUICallKit crashes |
+
+## 3. Flow
+
+App launches or receives a call-related event -> Crash / fails to launch -> Troubleshooting direction 1: Check if this is a **Release build** without symbol stripping settings configured -> If so, TRTC C symbols were incorrectly removed causing `symbol not found` -> Fix: set `Deployment Postprocessing = Yes` + `Strip Style = Non-Global Symbols` -> Verify: Release build runs normally without crashes.
+
+Troubleshooting direction 2 (only applicable when the project has **additionally self-integrated PushKit VoIP**): VoIP push received -> `reportNewIncomingCall` / `reportNewIncomingConversation` not called within 5 seconds -> System forcefully kills the app -> Fix: report immediately in the `PKPushRegistryDelegate`'s `didReceiveIncomingPushWith` callback.
+
+## 4. Standard Usage
+
+1. Confirm the project's `tencent_calls_uikit` dependency version and target device OS version: iOS 12.0 and above are officially supported. iOS 16 requires no special adaptation.
+2. If a `symbol not found` crash occurs when running the iOS Release build, in Xcode's `Build Settings`:
+   - Set **Deployment Postprocessing** to **Yes**.
+   - Set **Strip Style** (Release configuration) to **Non-Global Symbols**.
+3. If the business only needs standard offline incoming call notification capability, integrate the **APNs** solution following the official Flutter `tencent_cloud_chat_push` plugin documentation. There is **no need** to additionally integrate PushKit VoIP (the official Flutter solution does not provide this capability).
+4. If the business has a strong requirement to achieve system-level VoIP incoming call experience on Flutter iOS (e.g., system incoming call UI when the screen is locked / process is killed), developers must implement a custom native bridge (`MethodChannel` + native Swift layer referencing the iOS native CallKit/PushKit integration guide) and strictly comply with the "report within 5 seconds" rule to avoid crashes. This is a custom extension, not a built-in TUICallKit Flutter capability.
+
+## 5. Verification
+
+- On iOS 16 (and other versions above 12.0), TUICallKit Flutter starts, logs in, and makes/receives calls normally with no OS compatibility issues.
+- No `symbol not found` crash occurs when running the Release build.
+- Standard projects that have not additionally integrated PushKit will not be killed by the system due to the "VoIP push not reported" rule (because the standard solution has not registered PushKit VoIP, this rule is not triggered).
+
+## 6. Common Mistakes
+
+- Mistake 1: Confusing the version requirements of the underlying library `TXLiteAVSDK_Professional` with the Flutter plugin `tencent_calls_uikit`. They are different dependency levels and should be verified separately.
+- Mistake 2: Believing the most common cause of Flutter TUICallKit iOS startup crashes is "PushKit VoIP not reported to CallKit". The official Flutter standard solution has not integrated PushKit VoIP, so this rule does not apply to standard integrations. The actual most common cause is `symbol not found` due to Release symbol stripping.
+- Mistake 3: Thinking you can directly call native iOS `CXProvider.reportNewIncomingCall` or `LiveCommunicationKit` APIs from the Flutter side. These are native Swift/ObjC APIs that cannot be called directly from Flutter — they must be implemented through a native bridge layer (and TUICallKit does not officially provide this bridge).
+
+## 7. Problem Definition (Search Anchor)
+
+Flutter TUICallKit iOS startup crash troubleshooting: minimum OS version requirement, iOS 16 compatibility, and whether PushKit VoIP CallKit reporting rules apply to standard Flutter integrations.
+
+## 8. Alternative Phrasings (Search Recall)
+
+- Flutter TUICallKit iOS won't open / crashes on startup — how to troubleshoot?
+- Does tencent_calls_uikit support iOS 16?
+- Does TUICallKit Flutter need PushKit VoIP integration?
+- Flutter iOS Release build symbol not found — how to fix?
+
+## 9. References (Optional)
+- `tencent_calls_uikit` official minimum version requirement (iOS 12.0+): `https://pub.dev/packages/tencent_calls_uikit`

package/resource/knowledge/callkit/core-sdk/miniprogram/call-engine.md

@@ -0,0 +1,386 @@
+TUICallEngine API is the **No-UI interface** for the audio/video calling component. If TUICallKit's built-in interaction does not meet your needs, you can use this API to build a custom calling experience.
+
+Due to mini program development limitations, you need to bindevents to `live-pusher` first. See [TUICallKit](https://cloud.tencent.com/document/product/647/78760) for details.
+
+> **Note:**
+> - To provide better audio/video communication capabilities, the original `@trtc/call-engine-lite-wx` package has been officially deprecated. Developers are advised to migrate to the new [@trtc/call-engine-lite-wx](https://www.npmjs.com/package/@trtc/call-engine-lite-wx) package.
+> - The new package includes optimized API adjustments. Some legacy interfaces are no longer compatible, and cleaner, more stable new interfaces are provided.
+
+## API Overview
+
+### Instance Creation and Event Callbacks
+
+| API | Description |
+|---------|---------|
+| [createInstance](#createInstance) | Create a TUICallEngine instance (static method) |
+| [destroyInstance](#destroyInstance) | Destroy a TUICallEngine instance (static method) |
+| [on](#on) | Register an event listener |
+| [off](#off) | Unregister an event listener |
+
+### Call Operation APIs
+
+| API | Description |
+|---------|---------|
+| [calls](#calls) | Initiate a 1v1 call |
+| [inviteUser](#inviteUser) | Invite other users to join a group call |
+| [join](#join) | Actively join an ongoing group call |
+| [accept](#accept) | Accept a call |
+| [reject](#reject) | Reject a call |
+| [hangup](#hangup) | Hang up a call |
+
+### Device Control APIs
+
+| API | Description |
+|---------|---------|
+| [openCamera](#openCamera) | Enable camera |
+| [closeCamera](#closeCamera) | Disable camera |
+| [switchCamera](#switchCamera) | Switch between front/rear camera |
+| [openMicrophone](#openMicrophone) | Enable microphone |
+| [closeMicrophone](#closeMicrophone) | Disable microphone |
+| [selectAudioPlaybackDevice](#selectAudioPlaybackDevice) | Select audio playback device (earpiece/speaker) |
+
+### Other APIs
+
+| API | Description |
+|---------|---------|
+| [setSelfInfo](#setSelfInfo) | Set user avatar and nickname |
+| [setLogLevel](#setLogLevel) | Set log level |
+| [setBeautyLevel](#setBeautyLevel) | Set beauty filter level, supports disabling default beauty |
+
+## API Details
+``` javascript
+ import TUICallEngine, { TUICallEvent } from '@trtc/call-engine-lite-wx ';
+```
+
+### createInstance
+
+Create a TUICallEngine singleton instance.
+``` javascript
+ wx.$TUICallEngine = TUICallEngine.createInstance({
+    tim,
+    sdkAppID,
+ });
+```
+
+**Parameters**
+
+| Parameter | Type | Description | Required |
+|---------|---------|---------|---------|
+| sdkAppID | Number | The SDKAppID used by Tencent Cloud to identify customers | Yes |
+| tim | ChatSDK | TIM instance | No |
+
+### destroyInstance
+
+Destroy the TUICallEngine singleton instance.
+``` javascript
+TUICallEngine.destroyInstance();
+```
+
+### on
+
+Register an event listener to listen for all TUICallEngine events.
+``` javascript
+let handleNewInvitationReceived = function(event) {
+    // Received an invitation
+};
+wx.$TUICallEngine.on(TUICallEvent.ON_CALL_RECEIVED, handleNewInvitationReceived, this);
+```
+
+**Parameters**
+
+| Parameter | Type | Description | Required |
+|---------|---------|---------|---------|
+| eventName | TUICallEvent | Event name | Yes |
+| handler | Function | Event callback function | Yes |
+| context | Any | Current execution context (this) | Yes |
+
+### off
+
+Remove an event listener.
+``` javascript
+let handleNewInvitationReceived = function(event) {
+    // Received an invitation
+};
+wx.$TUICallEngine.off(TUICallEvent.ON_CALL_RECEIVED, handleNewInvitationReceived);
+```
+
+**Parameters**
+
+| Parameter | Type | Description | Required |
+|---------|---------|---------|---------|
+| eventName | TUICallEvent | Event name | Yes |
+| handler | Function | Event callback function | Yes |
+
+### login
+
+Login interface.
+``` javascript
+const params = {
+    userID: 'john', // Your user ID
+    userSig: 'xxxx', // Signature
+};
+let promise = wx.$TUICallEngine.login(params);
+promise.then(() => {
+    //success
+}).catch(error => {
+    console.warn('login error:', error);
+});
+```
+
+**Parameters:**
+
+| Parameter | Type | Description | Required |
+|---------|---------|---------|---------|
+| userID | String | Current user ID. String type, only allows letters (a-z, A-Z), digits (0-9), hyphens (-), and underscores (_) | Yes |
+| userSig | String | Tencent Cloud security signature. See [How to Calculate UserSig](https://cloud.tencent.com/document/product/647/17275) for details. | Yes |
+
+### logout
+
+Logout interface.
+``` javascript
+let promise = wx.$TUICallEngine.logout();
+promise.then(() => {
+    // logout success
+}).catch(error => {
+    console.warn('logout error:', error);
+});
+```
+
+### calls
+
+Initiate a single or multi-party call.
+
+> **Note**
+> Offline push is only supported on mobile terminals (Android or iOS). Web and WeChat Mini Programs do not support it.
+>
+
+``` javascript
+import { CallMediaType } from '@trtc/call-engine-lite-wx';
+let promise = wx.$TUICallEngine.groupCall({
+    userIDList: ['user1', 'user2'],
+    type: CallMediaType.AUDIO,
+});
+promise.then(() => {
+    // groupCall success
+}).catch(error => {
+    console.warn('groupCall error:', error);
+});
+```
+
+**Parameters:**
+
+| Parameter | Type | Description | Required |
+|---------|---------|---------|---------|
+| userIDList | Array\<String\> | List of callee userIDs | Yes |
+| type | [CallMediaType](https://cloud.tencent.com/document/product/647/78759#CallMediaType) | Call media type | Yes |
+| chatGroupID | String | IM group ID when used with Chat | Yes |
+| timeout | Number | Timeout in seconds | No |
+| roomID | Number | Audio/video room ID for this call. Currently only numeric room IDs are supported; string room IDs will be supported in future versions | No |
+| userData | String | Extension field: used to add extra information in the invitation signaling | No |
+
+### inviteUser
+
+Invite users to join the current group call.
+
+Use case: When a user in an ongoing group call wants to invite others to join.
+``` javascript
+const userIDList = ['jack', 'john'];
+const params = {
+    userIDList
+};
+wx.$TUICallEngine.inviteUser(params).then(() => {
+    // success
+}).catch(error => {
+    console.error('inviteUser error:', error);
+});
+```
+
+**Parameters:**
+
+| Parameter | Type | Description | Required |
+|---------|---------|---------|---------|
+| params | Object | Invite parameters | Yes |
+| params.userIDList | Array\<String\> | List of callee userIDs | Yes |
+
+### join
+
+Actively join an ongoing group call.
+``` javascript
+const params = { callId: xxx };
+wx.$TUICallEngine.join(params).then(() => {
+    // success
+}).catch(error => {
+    console.error('join error:', error);
+});
+```
+
+**Parameters:**
+
+| Parameter | Type | Description | Required |
+|---------|---------|---------|---------|
+| params | Object | Join parameters | Yes |
+| params.callId | String | Unique ID of this call | Yes |
+
+### accept
+
+Accept the current call. When you receive the `EVENT.ON_CALL_RECEIVED` event callback as the callee, call this method to accept the incoming call.
+``` javascript
+wx.$TUICallEngine.on(TUICallEvent.ON_CALL_RECEIVED, () => {
+    wx.$TUICallEngine.accept().promise.then(() => {
+        // accept success
+    }).catch(error => {
+        console.warn('accept error:', error);
+    });
+});
+```
+
+### reject
+
+Reject the current call. When you receive the `EVENT.ON_CALL_RECEIVED` callback as the callee, call this method to reject the incoming call.
+``` javascript
+wx.$TUICallEngine.on(TUICallEvent.ON_CALL_RECEIVED, () => {
+    wx.$TUICallEngine.reject().then(() => {
+        // reject success
+    }).catch(error => {
+        console.warn('reject error:', error);
+    });
+});
+```
+
+### hangup
+
+Hang up the current call. Call this method to end the call when you are in an ongoing call.
+``` javascript
+wx.$TUICallEngine.hangup().then(() => {
+     // hangup success
+ }).catch(error => {
+     console.warn('hangup error:', error);
+ });
+```
+
+### openCamera
+
+Enable the camera.
+``` javascript
+wx.$TUICallEngine.openCamera().then(() => {
+    // openCamera success
+}).catch(error => {
+    console.warn('openCamera error:', error);
+});
+```
+
+### closeCamera
+
+Disable the camera. Other users in the call will receive a callback notification.
+``` javascript
+wx.$TUICallEngine.closeCamera().then(() => {
+    // closeCamera success
+}).catch(error => {
+    console.warn('closeCamera error:', error);
+});
+```
+
+### switchCamera
+
+Switch between front and rear cameras.
+``` javascript
+wx.$TUICallEngine.switchCamera().then(() => {
+    // switchCamera success
+}).catch(error => {
+    console.warn('switchCamera error:', error);
+});
+```
+
+### openMicrophone
+
+Enable the microphone. Other users in the call will receive a callback notification.
+``` javascript
+wx.$TUICallEngine.openMicrophone().then(() => {
+    // openMicrophone success
+}).catch(error => {
+    console.warn('openMicrophone error:', error);
+});
+```
+
+### closeMicrophone
+
+Disable the microphone. Other users in the call will receive a callback notification.
+``` javascript
+wx.$TUICallEngine.closeMicrophone().then(() => {
+    // closeMicrophone success
+}).catch(error => {
+    console.warn('closeMicrophone error:', error);
+});
+```
+
+### selectAudioPlaybackDevice
+
+Select the audio playback device. Currently supports earpiece and speaker. In a call scenario, use this to enable/disable hands-free mode.
+``` javascript
+wx.$TUICallEngine.selectAudioPlaybackDevice(AUDIO_PLAYBACK_DEVICE.EAR).then(() => {
+    // selectAudioPlaybackDevice success
+}).catch(error => {
+    console.warn('selectAudioPlaybackDevice error:', error);
+});
+```
+
+**Parameters:**
+
+| Parameter | Type | Description | Required |
+|---------|---------|---------|---------|
+| type | [AUDIO_PLAYBACK_DEVICE](https://cloud.tencent.com/document/product/647/78759#AUDIO_PLAYBACK_DEVICE) | Speaker: AUDIO_PLAYBACK_DEVICE.SPEAKER<br>Earpiece: AUDIO_PLAYBACK_DEVICE.EAR | Yes |
+
+### setSelfInfo
+
+Set user avatar and nickname.
+``` javascript
+wx.$TUICallEngine.setSelfInfo("nickname", "avatar URL").then(() => {
+    // setSelfInfo success
+}).catch(error => {
+    console.warn('setSelfInfo error:', error);
+});
+```
+
+**Parameters:**
+
+| Parameter | Type | Description |
+|---------|---------|---------|
+| nickName | String | Set nickname |
+| avatar | String | Avatar URL |
+
+### setLogLevel
+
+Set the log level. Logs below the specified level will not be output.
+``` javascript
+wx.$TUICallEngine.setLogLevel(level)
+```
+
+**Parameters:**
+| Parameter | Value | Description |
+| --- | --- | --- |
+| level | 0 | Normal level, verbose logs. Recommended during integration |
+|  | 1 | Release level, SDK outputs key information only. Recommended for production |
+|  | 2 | Warning level, SDK outputs only warnings and errors |
+|  | 3 | Error level, SDK outputs only errors |
+|  | 4 | No logs, SDK will not print any logs |
+
+### setBeautyLevel
+
+Set beauty filter level, supports disabling the default beauty filter.
+``` javascript
+const params = {
+  style: 0, // 0-smooth; 1-natural
+  beautyLevel: 5,
+  whitenessLevel: 6,
+};
+
+wx.$TUICallEngine.setBeautyLevel(params);
+```
+
+**Parameters:**
+
+| Parameter | Type | Description |
+|---------|---------|---------|
+| style | number | Beauty skin smoothing mode. 0-smooth; 1-natural. Default: 0. |
+| beautyLevel | number | Beauty level, range [0 - 9]. 0 means off, 1-9 higher value means stronger effect. |
+| whitenessLevel | number | Whitening level, range [0 - 9]. 0 means off, 1-9 higher value means stronger effect. |