@tencent-rtc/mcp 1.7.2 → 1.7.3

package/resource/knowledge/chat/best-practice/common/web-sdk-log-level.md

@@ -0,0 +1,76 @@
+---
+title: Web Chat SDK Disabling/Adjusting Local Browser Log Output (setLogLevel)
+product: chat
+frameworks: [web, miniprogram]
+scope: platform_common
+tags: [setLogLevel, log, log level, disable log, local log, browser log, console log, release, production, create, initialization log]
+version_range: ">=3.0.0"
+---
+
+# Web Chat SDK Disabling/Adjusting Local Browser Log Output (setLogLevel)
+
+## 1. Key Conclusions
+
+- Use `chat.setLogLevel(level)` to control the SDK's local log output level. Setting `level` to `4` disables all SDK log printing.
+- `setLogLevel` must be called **after** the `chat` instance is created via `create`.
+- `setLogLevel` only affects logs produced **after** the call succeeds; initialization logs printed before the call cannot be suppressed. This is expected behavior by design.
+- For production, it is recommended to set the level to `1` (release) so that only critical information is printed, rather than setting it to `4` to disable all logs, in order to retain the diagnostic clues needed for troubleshooting.
+
+## 2. Field/Capability Reference
+
+| Field/Capability | Purpose | Notes |
+|---|---|---|
+| `chat.setLogLevel(level)` | Sets the local log level | Must be called after the instance is created via `create` |
+| `level = 0` | Normal level | Verbose output; recommended during integration and debugging |
+| `level = 1` | Release level | Prints only critical information; recommended for production |
+| `level = 2` | Warning level | Prints only warning- and error-level logs |
+| `level = 3` | Error level | Prints only error-level logs |
+| `level = 4` | No-log level | Prints no logs (fully disabled) |
+
+## 3. Mechanism/Sequence
+
+`create` creates the `chat` instance -> the SDK prints initialization logs (these logs are not controlled by `setLogLevel`) -> call `chat.setLogLevel(level)` -> from the moment the call succeeds, log output is filtered according to the configured level.
+
+## 4. Standard Usage
+
+1. Call `create` to create the `chat` instance.
+2. Immediately call `chat.setLogLevel(level)` with the target level (pass `4` to disable all logs; pass `1` to keep critical information in production).
+3. To use different levels across environments, set the corresponding `level` after initialization based on your environment variables.
+
+``` javascript
+// Set the log level immediately after creating the instance
+const chat = TencentCloudChat.create({ SDKAppID });
+
+// Disable all local SDK logs
+chat.setLogLevel(4);
+
+// Or: keep only critical information in production
+// chat.setLogLevel(1);
+```
+
+## 5. Result Verification
+
+- After setting `level = 4`, no SDK logs appear in the browser console for output produced after the `setLogLevel` call succeeds.
+- After setting `level = 1`, only critical information is printed; warning and normal logs are filtered out.
+- Initialization logs between `create` and `setLogLevel` still appear. This is expected behavior.
+
+## 6. Common Pitfalls
+
+- Pitfall 1: Expecting `setLogLevel(4)` to also clear initialization logs (logs printed before the call cannot be suppressed).
+- Pitfall 2: Calling `setLogLevel` before `create` (it only takes effect when called after the instance is created).
+- Pitfall 3: Setting `4` directly in production to disable all logs, leaving no logs to investigate online issues (use `1` to retain critical information).
+
+## 7. Problem Definition (Retrieval Aid, Minimal)
+
+How to disable or adjust local (console) browser log output for the Web/Mini Program Chat SDK.
+
+## 8. Synonymous Phrasing Coverage (Retrieval Recall, Minimal)
+
+- How do I disable local browser logs in the web IM SDK?
+- What does each `chat.setLogLevel` level mean?
+- How should I set the IM SDK log level in production?
+- Why are initialization logs still printed after I called setLogLevel?
+
+## 9. References (Optional)
+
+- Web Chat SDK setLogLevel API reference: `https://web.sdk.qcloud.com/im/doc/v3/en/SDK.html#setLogLevel`

package/resource/knowledge/chat/best-practice/miniprogram/desktop-wechat-miniprogram-error.md

@@ -0,0 +1,79 @@
+---
+title: IM SDK Errors When Running in Desktop WeChat Mini Program (tencent_cloud_im_csig_flutter_for_web_25F_cy is undefined / WebSocket is not a constructor) and the Upgrade Fix
+product: chat
+frameworks: [miniprogram]
+scope: platform_specific
+tags: [desktop WeChat, mac WeChat 4.x, windows WeChat 3.9.x, uniapp mini program, WeChat native mini program, WebSocket is not a constructor, tencent_cloud_im_csig, cannot read properties of undefined, tim-wx-sdk, "@tencentcloud/chat", "@tencentcloud/lite-chat", v2, v3, v4, version upgrade, compatibility]
+version_range: ">=3.5.7"
+---
+
+# IM SDK Errors When Running in Desktop WeChat Mini Program (csig undefined / WebSocket is not a constructor) and the Upgrade Fix
+
+## 1. Key Conclusions
+
+- The root cause is that the underlying API attributes of desktop WeChat (mac 4.x / windows 3.9.x) mini programs have changed, causing the IM SDK to misidentify its runtime environment.
+- The two errors are different symptoms of the same root cause: a WeChat mini program packaged with uniapp reports `cannot read properties of undefined (reading 'tencent_cloud_im_csig_flutter_for_web_25F_cy')`; a WeChat native mini program reports `TypeError: WebSocket is not a constructor`.
+- This issue has been handled for compatibility in both IM SDK v3 (`3.5.7`) and v4 (`4.2.4`). Upgrading to the latest release of the corresponding major version fixes it.
+- v2/v3/v4 interfaces are backward compatible and allow smooth migration, but v3 and v4 each contain breaking changes. Assess that there is no risk to your business before upgrading.
+
+## 2. Field/Capability Reference
+
+| Field/Capability | Purpose | Notes |
+|---|---|---|
+| `tim-wx-sdk` | v2 package name | Legacy version; upgrading to the latest v4 is recommended |
+| `@tencentcloud/chat` | v3 package name | Issue fixed (`>=3.5.7`); v3 no longer receives new features |
+| `@tencentcloud/lite-chat` | v4 package name | Issue fixed (`>=4.2.4`); recommended version |
+| Missing `tencent_cloud_im_csig...` attribute | uniapp mini program error signal | Undefined due to changed underlying API attributes in desktop WeChat |
+| `WebSocket is not a constructor` | Native mini program error signal | Desktop WeChat runtime misidentified; constructor unavailable |
+
+## 3. Mechanism/Sequence
+
+Desktop WeChat is upgraded (mac 4.x / windows 3.9.x) -> the underlying mini program API attributes change -> the IM SDK misidentifies its runtime environment -> a uniapp-packaged mini program hits undefined when reading the `tencent_cloud_im_csig...` attribute (reporting `cannot read properties of undefined`) or a native mini program fails to construct `WebSocket` (reporting `WebSocket is not a constructor`) -> after upgrading to v3 (`>=3.5.7`) or v4 (`>=4.2.4`) with compatibility handling, the SDK correctly identifies the desktop WeChat runtime and the error disappears.
+
+## 4. Standard Usage
+
+1. Confirm your current IM SDK version and package name: v2 (`tim-wx-sdk`) / v3 (`@tencentcloud/chat`) / v4 (`@tencentcloud/lite-chat`).
+2. Choose the upgrade target based on your current version:
+   - Currently v4 (`@tencentcloud/lite-chat`): upgrade to the latest v4 release.
+   - Currently v3 (`@tencentcloud/chat`): upgrade to the latest v3 release (v3 no longer receives new features), or upgrade to the latest v4 release.
+   - Currently v2 (`tim-wx-sdk`): upgrade to the latest v4 release.
+3. Before upgrading, read the corresponding migration guide and assess the impact of breaking changes on your business:
+   - v3 breaking changes: `https://web.sdk.qcloud.com/im/doc/v3/en/tutorial-07-breakingchanges.html`
+   - v2 to v3 guide: `https://web.sdk.qcloud.com/im/doc/v3/en/tutorial-05-integration.html`
+   - v4 breaking changes: `https://web.sdk.qcloud.com/im/doc/v3/en/tutorial-04-comparison-v4.html`
+   - v3 to v4 guide: `https://web.sdk.qcloud.com/im/doc/v3/en/tutorial-03-integration-v4.html`
+4. Complete the upgrade and verify via regression: rerun the uniapp mini program and the WeChat native mini program on desktop WeChat (mac 4.x / windows 3.9.x) and confirm the errors no longer occur.
+
+## 5. Result Verification
+
+- After upgrading to v3 (`>=3.5.7`) or v4 (`>=4.2.4`), the uniapp mini program on desktop WeChat no longer reports `cannot read properties of undefined (reading 'tencent_cloud_im_csig...')`.
+- The WeChat native mini program no longer reports `TypeError: WebSocket is not a constructor`.
+- The IM SDK initializes and establishes a connection normally in the desktop WeChat runtime.
+
+## 6. Common Pitfalls
+
+- Pitfall 1: Assuming it is a uniapp packaging configuration or business code bug (it is actually an SDK environment-identification issue caused by changed underlying desktop WeChat API attributes).
+- Pitfall 2: Considering it resolved after verifying only on mobile WeChat (the issue only appears on desktop WeChat mac 4.x / windows 3.9.x).
+- Pitfall 3: Upgrading across versions without reading breaking changes (v3 and v4 each have breaking changes; assess business impact first).
+- Pitfall 4: Confusing package names (v3 is `@tencentcloud/chat`, v4 is `@tencentcloud/lite-chat`, v2 is `tim-wx-sdk`).
+
+## 7. Problem Definition (Retrieval Aid, Minimal)
+
+When running the IM SDK in a uniapp-packaged WeChat mini program or a WeChat native mini program on desktop WeChat (mac 4.x / windows 3.9.x), it reports the csig attribute as undefined or `WebSocket is not a constructor`.
+
+## 8. Synonymous Phrasing Coverage (Retrieval Recall, Minimal)
+
+- What should I do when the desktop WeChat mini program IM SDK reports WebSocket is not a constructor?
+- Why does a uniapp mini program report tencent_cloud_im_csig undefined on mac/windows WeChat?
+- IM initialization fails when running a mini program on Windows 3.9 / Mac 4.x WeChat?
+- Which version should the IM SDK be upgraded to in order to fix desktop WeChat compatibility?
+- How to resolve the missing native WebSocket constructor in the AppService logic layer of the PC WeChat mini program?
+- On PC, tim-im app-service.js reports WebSocket is not a constructor?
+- The mini program logic layer has no native WebSocket constructor / the WebSocket constructor is unavailable?
+
+## 9. References (Optional)
+
+- v3 breaking changes: `https://web.sdk.qcloud.com/im/doc/v3/en/tutorial-07-breakingchanges.html`
+- v2 to v3 guide: `https://web.sdk.qcloud.com/im/doc/v3/en/tutorial-05-integration.html`
+- v4 breaking changes: `https://web.sdk.qcloud.com/im/doc/v3/en/tutorial-04-comparison-v4.html`
+- v3 to v4 guide: `https://web.sdk.qcloud.com/im/doc/v3/en/tutorial-03-integration-v4.html`

package/resource/knowledge/roomkit/best-practice/vue/screen-share-auto-stop-on-leave.md

@@ -0,0 +1,62 @@
+---
+title: Whether Screen Sharing Stops Automatically When Leaving the Room/Ending the Meeting in TUIRoomKit Vue3
+product: room
+frameworks: [vue, web]
+scope: platform_specific
+tags: [TUIRoomKit, screen share, stopScreenShare, startScreenShare, leaveRoom, endRoom, leave room, end meeting, close browser, useDeviceState, useRoomState, screenStatus, vue3, Atomicx]
+version_range: ">=2.0.0"
+---
+
+# Whether Screen Sharing Stops Automatically When Leaving the Room/Ending the Meeting in TUIRoomKit Vue3
+
+## 1. Key Conclusions
+
+- Leaving the room (`leaveRoom`), ending the meeting (`endRoom`), and exit actions such as closing the browser or closing the web page all automatically end the current screen share. The business side does not need to manually call `stopScreenShare` again.
+- Screen sharing is part of the room session: leaving the room releases the user's sharing channel, and screen sharing stops accordingly.
+- No extra cleanup code is needed to "stop screen sharing when leaving the room." You only need to explicitly call `stopScreenShare` when **actively stopping** screen sharing during the meeting (without leaving the room).
+- This behavior is consistent between UI-less integration (`tuikit-atomicx-vue3`) and integration with UI (`@tencentcloud/roomkit-web-vue3`).
+
+## 2. Field/Capability Reference
+
+| Field/Capability | Purpose | Notes |
+|---|---|---|
+| `startScreenShare` | Starts screen sharing | Provided by `useDeviceState()`; once started, the share is visible to other room members |
+| `stopScreenShare` | Stops screen sharing | Only needs to be called explicitly when **actively stopping during the meeting without leaving the room** |
+| `screenStatus` | Screen share status | Provided by `useDeviceState()`; `DeviceStatus.On` indicates sharing is active |
+| `leaveRoom` | Leave the room | A member exits the room; the member's screen share ends automatically |
+| `endRoom` | End the meeting | The host dismisses the room; screen sharing ends automatically |
+| Close browser/web page | Abnormal/normal exit | Disconnects the room session; screen sharing ends accordingly |
+
+## 3. Mechanism/Sequence
+
+The user starts screen sharing during the meeting (`startScreenShare`, `screenStatus = On`) -> an exit action is triggered (`leaveRoom` / `endRoom` / closing the browser or web page) -> the room session disconnects and the user's sharing channel is released -> screen sharing stops automatically, and other room members no longer see the shared content.
+
+## 4. Standard Usage
+
+1. Start screen sharing during the meeting: call `startScreenShare` from `useDeviceState()`.
+2. To stop sharing **without leaving the room**: explicitly call `stopScreenShare`.
+3. When the user leaves the room: just call `leaveRoom` (or the host calls `endRoom`); screen sharing ends automatically, and there is no need to call `stopScreenShare` first.
+4. Exit scenarios such as closing the browser / closing the web page: no extra handling is needed; screen sharing ends automatically as the room session disconnects.
+
+## 5. Result Verification
+
+- After calling `leaveRoom` / `endRoom`, the user's screen share stops and the shared content disappears for other room members.
+- After closing the browser or web page, other room members no longer receive the user's screen-sharing stream.
+- When staying in the room and calling only `stopScreenShare`, screen sharing stops while the user remains in the room.
+
+## 6. Common Pitfalls
+
+- Pitfall 1: Assuming you must manually call `stopScreenShare` before leaving, otherwise the screen share lingers (leaving the room ends the share automatically).
+- Pitfall 2: Assuming screen sharing continues after closing the browser/web page (the share ends once the room session disconnects).
+- Pitfall 3: Conflating the responsibilities of `leaveRoom`/`endRoom` with `stopScreenShare` (the former leaves the room and cleans up automatically; the latter only stops sharing without leaving the room).
+
+## 7. Problem Definition (Retrieval Aid, Minimal)
+
+In TUIRoomKit Vue3, whether screen sharing stops automatically when the user calls `leaveRoom`/`endRoom` or closes the browser/web page.
+
+## 8. Synonymous Phrasing Coverage (Retrieval Recall, Minimal)
+
+- Does `leaveRoom` / `endRoom` automatically `stopScreenShare`?
+- Does screen sharing continue after leaving the room?
+- Does screen sharing end automatically after closing the browser/web page?
+- Do I need to manually stop screen sharing before leaving the room?

package/resource/knowledge/roomkit/core-sdk/react/network-proxy.md

@@ -0,0 +1,83 @@
+The Conference SDK is built on Tencent Cloud Chat (IM) and Tencent Real-Time Communication (TRTC). It supports configuring the IM and TRTC proxies together in intranet / firewall environments, which is suitable for scenarios such as private deployment and enterprise intranet isolation where a direct connection to Tencent Cloud services is not available.
+
+## Proxy architecture
+
+|Proxy server|Proxy link|
+|---------|---------|
+|IM proxy|Proxies the signaling channels for IM login, message sending/receiving, etc. (WebSocket), as well as the upload and download of resources such as chat images and files.|
+|TRTC WebSocket proxy (e.g. Nginx)|Proxies the signaling channels for TRTC room entry, control, etc. (WebSocket), and is responsible for room management and user state synchronization.|
+|TRTC TURN Server|Relays TRTC audio and video media streams.|
+
+> **Note:**
+> The proxy servers (IM proxy, Nginx, TURN) need to be deployed by yourself. For how to set them up, see [TRTC Web SDK handling firewall restrictions](https://web.sdk.qcloud.com/trtc/webrtc/v5/doc/zh-cn/tutorial-34-advanced-proxy.html).
+>
+
+## API and parameters
+
+The Conference SDK allows you to configure the intranet proxy uniformly through the `callExperimentalAPI` interface before calling `login()`:
+``` typescript
+callExperimentalAPI({
+  api: 'setNetworkProxy',
+  params: {
+    im?: { /* IM proxy parameters */ },
+    rtc?: { /* TRTC proxy parameters */ },
+  },
+});
+```
+
+### IM proxy parameters
+
+|Parameter|Type|Description|
+|---------|---------|---------|
+|`proxyServer`|String|IM signaling WebSocket proxy address.|
+|`fileUploadProxy`|String|IM file upload proxy address.|
+|`fileDownloadProxy`|String|IM file download proxy address.|
+
+### TRTC proxy parameters
+
+|Parameter|Type|Description|
+|---------|---------|---------|
+|`websocketProxy`|String|TRTC signaling WebSocket proxy address, e.g. `wss://proxy.example.com/ws/`.|
+|`turnServer`|Array|List of TURN servers. Each item contains `url` / `username` / `credential`.|
+|`iceTransportPolicy`|`'relay' \| 'all'`|Client-side ICE transport policy. In an intranet environment, it is recommended to set it to `'relay'` to force a connection to the TURN server.|
+
+## Sample code
+
+``` typescript
+import { callExperimentalAPI } from 'tuikit-atomicx-react';
+import { useLoginState, useRoomState } from 'tuikit-atomicx-react/room';
+
+callExperimentalAPI({
+  api: 'setNetworkProxy',
+  params: {
+    im: {
+      proxyServer: 'wss://proxy.example.com:8080',
+      fileUploadProxy: 'https://proxy.example.com:8080',
+      fileDownloadProxy: 'https://proxy.example.com:8080',
+    },
+    rtc: {
+      websocketProxy: 'wss://proxy.example.com/ws/',
+      turnServer: [
+        { url: '14.3.3.3:3478', username: 'turn', credential: 'turn' },
+      ],
+      iceTransportPolicy: 'relay',
+    },
+  },
+});
+
+const { login } = useLoginState();
+await login({ sdkAppId, userId, userSig });
+
+const { createAndJoinRoom } = useRoomState();
+await createAndJoinRoom({ roomId });
+```
+
+## FAQs
+
+### A user can join the conference normally on the public network, but cannot join it on the intranet?
+
+Check whether `setNetworkProxy` was called before `login()`. If it is already configured but still fails, check the TURN port and the outbound allowlist of the proxy server.
+
+### A user can join the conference but cannot see the remote video or hear the remote audio?
+
+Confirm that `turnServer` is reachable, and set `iceTransportPolicy` to `'relay'` in an intranet environment.

package/resource/knowledge/roomkit/core-sdk/vue/network-proxy.md

@@ -0,0 +1,83 @@
+The Conference SDK is built on Tencent Cloud Chat (IM) and Tencent Real-Time Communication (TRTC). It supports configuring the IM and TRTC proxies together in intranet / firewall environments, which is suitable for scenarios such as private deployment and enterprise intranet isolation where a direct connection to Tencent Cloud services is not available.
+
+## Proxy architecture
+
+|Proxy server|Proxy link|
+|---------|---------|
+|IM proxy|Proxies the signaling channels for IM login, message sending/receiving, etc. (WebSocket), as well as the upload and download of resources such as chat images and files.|
+|TRTC WebSocket proxy (e.g. Nginx)|Proxies the signaling channels for TRTC room entry, control, etc. (WebSocket), and is responsible for room management and user state synchronization.|
+|TRTC TURN Server|Relays TRTC audio and video media streams.|
+
+> **Note:**
+> The proxy servers (IM proxy, Nginx, TURN) need to be deployed by yourself. For how to set them up, see [TRTC Web SDK handling firewall restrictions](https://web.sdk.qcloud.com/trtc/webrtc/v5/doc/zh-cn/tutorial-34-advanced-proxy.html).
+>
+
+## API and parameters
+
+The Conference SDK allows you to configure the intranet proxy uniformly through the `callExperimentalAPI` interface before calling `login()`:
+``` typescript
+callExperimentalAPI({
+  api: 'setNetworkProxy',
+  params: {
+    im?: { /* IM proxy parameters */ },
+    rtc?: { /* TRTC proxy parameters */ },
+  },
+});
+```
+
+### IM proxy parameters
+
+|Parameter|Type|Description|
+|---------|---------|---------|
+|`proxyServer`|String|IM signaling WebSocket proxy address.|
+|`fileUploadProxy`|String|IM file upload proxy address.|
+|`fileDownloadProxy`|String|IM file download proxy address.|
+
+### TRTC proxy parameters
+
+|Parameter|Type|Description|
+|---------|---------|---------|
+|`websocketProxy`|String|TRTC signaling WebSocket proxy address, e.g. `wss://proxy.example.com/ws/`.|
+|`turnServer`|Array|List of TURN servers. Each item contains `url` / `username` / `credential`.|
+|`iceTransportPolicy`|`'relay' \| 'all'`|Client-side ICE transport policy. In an intranet environment, it is recommended to set it to `'relay'` to force a connection to the TURN server.|
+
+## Sample code
+
+``` typescript
+import { callExperimentalAPI } from 'tuikit-atomicx-vue3';
+import { useLoginState, useRoomState } from 'tuikit-atomicx-vue3/room';
+
+callExperimentalAPI({
+  api: 'setNetworkProxy',
+  params: {
+    im: {
+      proxyServer: 'wss://proxy.example.com:8080',
+      fileUploadProxy: 'https://proxy.example.com:8080',
+      fileDownloadProxy: 'https://proxy.example.com:8080',
+    },
+    rtc: {
+      websocketProxy: 'wss://proxy.example.com/ws/',
+      turnServer: [
+        { url: '14.3.3.3:3478', username: 'turn', credential: 'turn' },
+      ],
+      iceTransportPolicy: 'relay',
+    },
+  },
+});
+
+const { login } = useLoginState();
+await login({ sdkAppId, userId, userSig });
+
+const { createAndJoinRoom } = useRoomState();
+await createAndJoinRoom({ roomId });
+```
+
+## FAQs
+
+### A user can join the conference normally on the public network, but cannot join it on the intranet?
+
+Check whether `setNetworkProxy` was called before `login()`. If it is already configured but still fails, check the TURN port and the outbound allowlist of the proxy server.
+
+### A user can join the conference but cannot see the remote video or hear the remote audio?
+
+Confirm that `turnServer` is reachable, and set `iceTransportPolicy` to `'relay'` in an intranet environment.

package/resource/knowledge/roomkit/core-sdk/vue/recording.md

@@ -0,0 +1,245 @@
+This document guides developers in implementing cloud recording in the no-UI integration solution for standard meetings. You can control the start and stop of recording through `startRecording()` / `stopRecording()` provided by `useRoomState()`, and monitor recording state changes in real time through `currentRoom.recordingInfo` and `RoomEvent`.
+
+> **Version note:**
+>
+> The cloud recording interfaces (`startRecording` / `stopRecording`) are supported since **tuikit-atomicx-vue3 6.4.0** and **tuikit-atomicx-react 6.2.0**. Make sure the version you use meets the requirement.
+>
+
+## Prerequisites
+- The user has completed login authentication through `useLoginState`.
+
+- The user has entered a standard meeting room through `useRoomState`.
+
+- Cloud recording package activation and storage configuration have been completed:
+
+  - Purchase a Conference SDK package that includes cloud recording capability.
+
+  - Enable the recording file storage service: Recording files can be stored in [Cloud VOD (VOD)](https://console.cloud.tencent.com/vod) or [Cloud Object Storage (COS)](https://console.cloud.tencent.com/cos). Complete the activation in the corresponding console and record the storage information.
+
+  - [Submit a ticket](https://console.cloud.tencent.com/workorder/category), select the **Real-Time Communication** product, and apply to configure the cloud recording storage information for your SDKAppID.
+
+## Recording effect
+
+The Conference SDK uses **mixed-stream recording** mode by default, mixing the audio and video streams published in the room into one complete recording file. The recording layout **switches automatically** with the in-meeting state, and the recording task is not restarted during the switch:
+
+|**In-meeting state**|**Mixed-stream layout**|**Maximum number of views**|
+|---------|---------|---------|
+|No screen sharing / whiteboard|Grid layout|Up to **25** video views|
+|With screen sharing / whiteboard|Screen sharing layout (sharing as the main view)|Up to **1** screen sharing + **16** video views|
+|Audio only|-|—|
+
+## Interface description
+
+Conference SDK no-UI integration provides recording control and state subscription capabilities through `useRoomState()`. The recording task is fully managed by the server, and the client is only responsible for starting and stopping it.
+
+|**Type**|**Name**|**Description**|
+|---------|---------|---------|
+|Method|`startRecording(): Promise<void>`|Starts cloud recording. Only the **room owner or administrator** can call it, and it must be called after successfully entering the room.|
+|Method|`stopRecording(): Promise<void>`|Stops cloud recording. Only the **room owner or administrator** can call it.|
+|State|`currentRoom.recordingInfo`|The recording information of the current room, including the `status` field (`RecordingStatus.Recording` indicates recording in progress).|
+|Event|`RoomEvent.onRecordingStarted`|Triggered when the recording task starts successfully. The callback parameter is `{ roomInfo, operator }`.|
+|Event|`RoomEvent.onRecordingStopped`|Triggered when the recording task stops. The callback parameter is `{ roomInfo, operator, reason }`. `reason` can distinguish between active stop and abnormal interruption.|
+
+## Step 1: Start cloud recording
+
+### Permission requirements
+
+Only the **room owner or administrator** can call `startRecording()`; other roles calling it will throw a permission error. Only one recording task can exist in the same room at a time, and repeated calls will also return an error.
+
+### Sample code
+
+【Vue3】
+``` typescript
+import { useRoomState } from 'tuikit-atomicx-vue3/room';
+
+const { startRecording } = useRoomState();
+
+await startRecording();
+```
+
+【React】
+``` typescript
+import { useRoomState } from 'tuikit-atomicx-react/room';
+
+const { startRecording } = useRoomState();
+
+await startRecording();
+```
+
+### Error handling
+
+`startRecording()` throws an error when it fails. Common error cases are as follows:
+
+|**Error code**|**Meaning**|**Suggested handling**|
+|---------|---------|---------|
+|`100001`|Backend system error.|Retry later; if it persists, submit a ticket for investigation.|
+|`100004`|The room does not exist.|Confirm that you have successfully entered the room through `createAndJoinRoom()` or `joinRoom()` before calling the recording interface.|
+|`100006`|No permission; must be the room owner or administrator.|Check the current user role; only the room owner or administrator can start recording.|
+|`101072`|The recording configuration does not exist or is not enabled.|Confirm that you have completed the console package activation, ticket configuration, and value-added feature switch. .|
+
+【Vue3】
+``` typescript
+import { useRoomState } from 'tuikit-atomicx-vue3/room';
+
+const { startRecording } = useRoomState();
+
+try {
+  await startRecording();
+} catch (error: any) {
+  switch (error?.code) {
+    case 100001:
+      console.error('Backend system error, please retry later.');
+      break;
+    case 100004:
+      console.error('The room does not exist, please confirm you have entered the room before starting recording.');
+      break;
+    case 100006:
+      console.error('Insufficient permission, only the room owner or administrator can start recording.');
+      break;
+    case 101072:
+      console.error('The recording configuration does not exist or is not enabled, please check the console activation configuration.');
+      break;
+    default:
+      console.error('Failed to start recording:', error);
+  }
+}
+```
+
+【React】
+``` typescript
+import { useRoomState } from 'tuikit-atomicx-react/room';
+
+const { startRecording } = useRoomState();
+
+try {
+  await startRecording();
+} catch (error: any) {
+  switch (error?.code) {
+    case 100001:
+      console.error('Backend system error, please retry later.');
+      break;
+    case 100002:
+      console.error('Parameter error, please check the passed parameters.');
+      break;
+    case 100004:
+      console.error('The room does not exist, please confirm you have entered the room before starting recording.');
+      break;
+    case 100006:
+      console.error('Insufficient permission, only the room owner or administrator can start recording.');
+      break;
+    case 101072:
+      console.error('The recording configuration does not exist or is not enabled, please check the console activation configuration.');
+      break;
+    default:
+      console.error('Failed to start recording:', error);
+  }
+}
+```
+
+## Step 2: Stop cloud recording
+
+### Preconditions
+
+There is a recording task in progress (`RecordingStatus.Recording`) in the current room.
+
+### Permission requirements
+
+Only the **room owner or administrator** can call `stopRecording()`.
+
+### Sample code
+
+【Vue3】
+``` typescript
+import { useRoomState } from 'tuikit-atomicx-vue3/room';
+
+const { stopRecording } = useRoomState();
+
+try {
+  await stopRecording();
+} catch (error: any) {
+  console.error('Failed to stop recording:', error);
+}
+```
+
+【React】
+``` typescript
+import { useRoomState } from 'tuikit-atomicx-react/room';
+
+const { stopRecording } = useRoomState();
+
+try {
+  await stopRecording();
+} catch (error: any) {
+  console.error('Failed to stop recording:', error);
+}
+```
+
+## Step 3: Monitor recording state changes
+
+### Preconditions
+- You have successfully entered the room.
+
+- It is recommended to subscribe to events **immediately** after entering the room to avoid missing recording notifications initiated by other ends (such as a mobile room owner).
+
+### Sample code
+
+【Vue3】
+``` typescript
+import { useRoomState, RecordingStatus, RecordingStopReason, RoomEvent } from 'tuikit-atomicx-vue3/room';
+
+const { currentRoom, subscribeEvent } = useRoomState();
+
+// Actively query the current recording state
+const isRecording = currentRoom.value?.recordingInfo?.status === RecordingStatus.Recording;
+
+// Listen for recording start
+subscribeEvent(RoomEvent.onRecordingStarted, ({ operator }) => {
+  console.log('Recording started, operator:', operator.userId);
+});
+
+// Listen for recording stop
+subscribeEvent(RoomEvent.onRecordingStopped, ({ operator, reason }) => {
+  if (reason === RecordingStopReason.StoppedByUser) {
+    console.log('Recording stopped, operator:', operator.userId);
+  } else if (reason === RecordingStopReason.RecorderLeftRoom) {
+    console.warn('Recording interrupted abnormally, the recording robot has left the room. Restart recording if needed.');
+  }
+});
+```
+
+【React】
+``` typescript
+import { useRoomState, RecordingStatus, RecordingStopReason, RoomEvent } from 'tuikit-atomicx-react/room';
+
+const { currentRoom, subscribeEvent } = useRoomState();
+
+// Actively query the current recording state
+const isRecording = currentRoom?.recordingInfo?.status === RecordingStatus.Recording;
+
+// Listen for recording start
+subscribeEvent(RoomEvent.onRecordingStarted, ({ operator }) => {
+  console.log('Recording started, operator:', operator.userId);
+});
+
+// Listen for recording stop
+subscribeEvent(RoomEvent.onRecordingStopped, ({ operator, reason }) => {
+  if (reason === RecordingStopReason.StoppedByUser) {
+    console.log('Recording stopped, operator:', operator.userId);
+  } else if (reason === RecordingStopReason.RecorderLeftRoom) {
+    console.warn('Recording interrupted abnormally, the recording robot has left the room. Restart recording if needed.');
+  }
+});
+```
+
+### Error cases
+
+The `reason` field of the `onRecordingStopped` event identifies the reason the recording stopped:
+
+|**Enum value**|**Value**|**Description**|
+|---------|---------|---------|
+|`RecordingStopReason.StoppedByUser`|`0`|The room owner or administrator actively called `stopRecording()` for a normal stop.|
+|`RecordingStopReason.RecorderLeftRoom`|`1`|The recording robot left the room abnormally and the recording was interrupted. It is recommended to prompt the user and decide whether to restart recording based on business needs.|
+
+> **Note:**
+> - The cloud recording feature requires completing package purchase, storage service activation, and ticket configuration in advance. Confirm that you have completed all steps in the **Prerequisites** of this document.
+> - Recording files are stored in the Cloud VOD (VOD) or Cloud Object Storage (COS) you configured. Go to the corresponding console to view and manage them.