@tencent-rtc/mcp 1.6.4 → 1.6.6

package/resource/knowledge/livekit/core-sdk/live/ios/live-live-list.md

@@ -1,349 +0,0 @@
-`LiveListStore` is the core module of **AtomicXCore** responsible for managing the live room list, creating and joining rooms, and maintaining room state. With `LiveListStore`, you can implement comprehensive live streaming lifecycle management in your application.
-
-## Core Features
-- **Live Room List Fetching**: Retrieve all currently public live rooms, returned one page at a time.
-
-- **Live Lifecycle Management**: Provides a complete set of interfaces for the entire live streaming workflow, including room creation, going live, joining, leaving, and ending a live session.
-
-- **Real-Time Event Listening**: Listen for key events such as live session end or users being removed from a room.
-
-## Core Concepts
-| <strong>Core Concept</strong> | <strong>Type</strong> | <strong>Core Responsibility & Description</strong> |
-| --- | --- | --- |
-| <code>LiveInfo</code> | <code>struct</code> | - Represents the complete information model of a live room.<br>- Includes the live room ID (<code>liveID</code>), name (<code>liveName</code>), owner information (<code>liveOwner</code>), and custom metadata (<code>metaData</code>), among other properties. |
-| <code>LiveListState</code> | <code>struct</code> | - Represents the current state of the live list module.<br>- The core property <code>liveList</code> is a StateFlow containing the fetched live room list;<br>- <code>currentLive</code> represents the information of the live room the user is currently in. |
-| <code>LiveListEvent</code> | <code>enum</code> | Handles global live room events, including <code>.onLiveEnded</code> (live ended) and <code>.onKickedOutOfLive</code> (user removed from live), for responding to key room state changes. |
-| <code>LiveListStore</code> | <code>class</code> | - The core management class for interacting with the live room list and room lifecycle.<br>- It is a global singleton responsible for all operations such as creating, joining, and updating live room information. |
-
-## Implementation
-
-### Step 1: Component Integration
-- **Video Live Streaming**：Refer to Quick Start to integrate AtomicXCore and complete the implementation of the Host Video Streaming and Audience Join and Watch features.
-
-- **Voice Chat Room**：Refer to Quick Start to integrate AtomicXCore and complete the implementation of the Host Audio Streaming and Audience Join and Watch features.
-
-### Step 2: Implement Audience Entry from Live Room List
-
-Create a page to display the live room list using `UICollectionView` to lay out live room cards. When a user taps a card, retrieve the `liveID` for that room and navigate to the audience viewing page.
-``` swift
-import AtomicXCore
-import SnapKit
-import RTCRoomEngine
-import Combine
-
-class LiveListViewController: UIViewController, UICollectionViewDataSource, UICollectionViewDelegate, UICollectionViewDelegateFlowLayout {
-
-    private let liveListStore = LiveListStore.shared
-    private var cancellables = Set<AnyCancellable>()
-    private var liveList: [LiveInfo] = []
-    private var collectionView: UICollectionView!
-
-    override func viewDidLoad() {
-        super.viewDidLoad()
-        setupUI()
-        bindStore()
-        fetchLiveList()
-    }
-
-    private func bindStore() {
-        // Subscribe to state to automatically receive list updates
-        liveListStore.state
-            .subscribe(StatePublisherSelector(keyPath: \LiveListState.liveList))
-            .receive(on: DispatchQueue.main)
-            .sink { [weak self] fetchedList in
-                self?.liveList = fetchedList
-                self?.collectionView.reloadData()
-            }
-            .store(in: &cancellables)
-    }
-
-    private func fetchLiveList() {
-        liveListStore.fetchLiveList(cursor: "", count: 20) { result in
-            if case .failure(let error) = result {
-                print("Failed to fetch live room list: \(error.localizedDescription)")
-            }
-        }
-    }
-
-    // Called when the user taps a cell in the list
-    func collectionView(_ collectionView: UICollectionView, didSelectItemAt indexPath: IndexPath) {
-        let selectedLiveInfo = liveList[indexPath.item]
-        // Create the audience viewing page and pass in the liveID
-        let audienceVC = YourAudienceViewController(liveId: selectedLiveInfo.liveID)
-        audienceVC.modalPresentationStyle = .fullScreen
-        present(audienceVC, animated: true)
-    }
-
-    // --- UICollectionViewDataSource, Delegate, and UI setup methods ---
-    private func setupUI() {
-        let layout = UICollectionViewFlowLayout()
-        // ... (Customize your layout as needed)
-        collectionView = UICollectionView(frame: view.bounds, collectionViewLayout: layout)
-        collectionView.dataSource = self
-        collectionView.delegate = self
-        collectionView.register(UICollectionViewCell.self, forCellWithReuseIdentifier: "LiveCell")
-        view.addSubview(collectionView)
-    }
-
-    func collectionView(_ collectionView: UICollectionView, numberOfItemsInSection section: Int) -> Int {
-        return liveList.count
-    }
-
-    func collectionView(_ collectionView: UICollectionView, cellForItemAt indexPath: IndexPath) -> UICollectionViewCell {
-        let cell = collectionView.dequeueReusableCell(withReuseIdentifier: "LiveCell", for: indexPath)
-        cell.backgroundColor = .lightGray // Customize your cell style
-        // let liveInfo = liveList[indexPath.item]
-        // ... (e.g.: cell.titleLabel.text = liveInfo.liveName)
-        return cell
-    }
-
-    func collectionView(_ collectionView: UICollectionView, layout collectionViewLayout: UICollectionViewLayout, sizeForItemAt indexPath: IndexPath) -> CGSize {
-        // Adjust cell size for single or double column layout as needed
-        let width = (view.bounds.width - 30) / 2
-        return CGSize(width: width, height: width * 1.2)
-    }
-}
-```
-
-#### LiveInfo Parameter Reference
-
-|**Parameter Name**|**Type**|**Description**|
-|---------|---------|---------|
-|`liveID`|`String`|Unique identifier for the live room|
-|`liveName`|`String`|Title of the live room|
-|`coverURL`|`String`|URL of the live room cover image|
-|`liveOwner`|[LiveUserInfo](https://tencent-rtc.github.io/TUIKit_iOS/documentation/atomicxcore/liveuserinfo)|Personal information of the room owner|
-|`totalViewerCount`|`Int`|Total number of viewers in the live room|
-|`categoryList`|`[NSNumber]`|List of category tags for the live room|
-|`notice`|`String`|Announcement information for the live room|
-|`metaData`|`[String: String]`|Developer-defined metadata for implementing complex business scenarios|
-
-## Advanced Features
-
-### Scenario 1: Category Filtering for Live Room List
-
-On the live plaza page, users can select category tags such as "Hot", "Music", "Games", etc. When a tag is selected, the live room list dynamically filters to display only rooms in the chosen category, helping users quickly discover relevant content.
-
-#### Implementation
-
-Use the `categoryList` property in the `LiveInfo` model. When the host sets a category at the start of the stream, the `LiveInfo` object returned by `fetchLiveList` includes this category data. After fetching the full live room list, filter it on the client side based on the selected category and update the UI.
-
-#### Code Example
-
-The following example shows how to extend a `LiveListManager` in `LiveListViewController` to handle data fetching and category filtering:
-``` swift
-import AtomicXCore
-import Combine
-
-// 1. Data manager for fetching and filtering
-class LiveListManager {
-    private let liveListStore = LiveListStore.shared
-    private var cancellables = Set<AnyCancellable>()
-    private var fullLiveList: [LiveInfo] = []
-
-    // Publisher for the filtered live list
-    let filteredLiveListPublisher = CurrentValueSubject<[LiveInfo], Never>([])
-
-    init() {
-        liveListStore.state
-            .subscribe(StatePublisherSelector(keyPath: \LiveListState.liveList))
-            .receive(on: DispatchQueue.main)
-            .sink { [weak self] fetchedList in
-                self?.fullLiveList = fetchedList
-                // By default, publish the complete list
-                self?.filteredLiveListPublisher.send(fetchedList)
-            }
-            .store(in: &cancellables)
-    }
-
-    func fetchFirstPage() {
-        liveListStore.fetchLiveList(cursor: "", count: 20) { _ in }
-    }
-
-    /// Filter the live list by category
-    func filterLiveList(by categoryId: NSNumber?) {
-        guard let categoryId = categoryId else {
-            // Show the full list if no category is selected
-            filteredLiveListPublisher.send(fullLiveList)
-            return
-        }
-        let filteredList = fullLiveList.filter { liveInfo in
-            liveInfo.categoryList.contains(categoryId)
-        }
-        filteredLiveListPublisher.send(filteredList)
-    }
-}
-
-// 2. Use the manager in your LiveListViewController
-class LiveListViewController: UIViewController, UICollectionViewDataSource, UICollectionViewDelegate {
-
-    private let manager = LiveListManager()
-    private var cancellables = Set<AnyCancellable>()
-    private var liveList: [LiveInfo] = []
-    private var collectionView: UICollectionView!
-
-    override func viewDidLoad() {
-        super.viewDidLoad()
-        // ... setupUI ...
-
-        // Bind data
-        manager.filteredLiveListPublisher
-            .receive(on: DispatchQueue.main)
-            .sink { [weak self] filteredList in
-                self?.liveList = filteredList
-                self?.collectionView.reloadData()
-            }
-            .store(in: &cancellables)
-
-        // Fetch the first page
-        manager.fetchFirstPage()
-    }
-
-    // Handle category selection (e.g., UISegmentedControl)
-    @objc func categorySegmentDidChange(_ sender: UISegmentedControl) {
-        let selectedCategoryId: NSNumber? = 1 // Example: "Music" category ID is 1
-        manager.filterLiveList(by: selectedCategoryId)
-    }
-
-    // ... (UICollectionView related code)
-}
-```
-
-### Scenario 2: Swipe-to-Play for Live Room List
-
-Users can switch between live rooms by swiping up or down. When a new live room is centered on the screen, its video will automatically start preview playback; when it is swiped away or no longer visible on the screen, playback will automatically stop to save bandwidth and device resources.
-
-> **Note：**
->
-
-> **Swipe-to-Play **is currently only supported for Video Live Streaming.
->
-
-#### Interaction Flow
-
-#### Implementation
-
-`LiveCoreView` supports multiple instances. Create a separate `LiveCoreView` for each `UICollectionViewCell`. By listening to the scroll delegate methods of `UICollectionView`, you can control when the `LiveCoreView` in each cell should start or stop streaming, enabling "play on swipe in, stop on swipe out".
-
-#### Code Example
-
-Create a custom `LiveFeedCell` containing a `LiveCoreView`. Then, manage playback state in your view controller:
-``` swift
-import UIKit
-import AtomicXCore
-
-// 1. Custom UICollectionViewCell with LiveCoreView
-class LiveFeedCell: UICollectionViewCell {
-    private var liveCoreView: LiveCoreView?
-
-    func setLiveInfo(_ liveInfo: LiveInfo) {
-        // Create a new LiveCoreView for the new live info
-        liveCoreView = LiveCoreView(viewType: .playView)
-        guard let liveCoreView = liveCoreView else { return }
-        contentView.addSubview(liveCoreView)
-        liveCoreView.frame = contentView.bounds
-    }
-
-    func startPlay(roomId: String) {
-        liveCoreView?.startPreviewLiveStream(roomId: roomId, isMuteAudio: false)
-    }
-
-    func stopPlay(roomId: String) {
-        liveCoreView?.stopPreviewLiveStream(roomId: roomId)
-    }
-}
-
-// 2. Manage playback in the ViewController
-class LiveFeedViewController: UIViewController, UICollectionViewDataSource, UICollectionViewDelegate {
-
-    private var collectionView: UICollectionView!
-    private var liveList: [LiveInfo] = []
-    private var currentPlayingIndexPath: IndexPath?
-
-    // Called when scrolling stops
-    func scrollViewDidEndDecelerating(_ scrollView: UIScrollView) {
-        let page = Int(scrollView.contentOffset.y / view.frame.height)
-        let indexPath = IndexPath(item: page, section: 0)
-        // Switch playback only when the centered cell changes
-        if currentPlayingIndexPath != indexPath {
-            playVideo(at: indexPath)
-        }
-    }
-
-    // Called when a cell is about to leave the screen
-    func collectionView(_ collectionView: UICollectionView, didEndDisplaying cell: UICollectionViewCell, forItemAt indexPath: IndexPath) {
-        if let liveCell = cell as? LiveFeedCell {
-            let liveInfo = liveList[indexPath.item]
-            liveCell.stopPlay(roomId: liveInfo.liveID)
-        }
-    }
-
-    private func playVideo(at indexPath: IndexPath) {
-        if let cell = collectionView.cellForItem(at: indexPath) as? LiveFeedCell {
-            let liveInfo = liveList[indexPath.item]
-            cell.startPlay(roomId: liveInfo.liveID)
-            currentPlayingIndexPath = indexPath
-        }
-    }
-
-    // ... (Other UICollectionViewDataSource methods)
-    func collectionView(_ collectionView: UICollectionView, cellForItemAt indexPath: IndexPath) -> UICollectionViewCell {
-        let cell = collectionView.dequeueReusableCell(withReuseIdentifier: "LiveFeedCell", for: indexPath) as! LiveFeedCell
-        cell.setLiveInfo(liveList[indexPath.item])
-        return cell
-    }
-}
-```
-
-## **API Documentation**
-
-For detailed information on all public interfaces, properties, and methods of [LiveListStore](https://tencent-rtc.github.io/TUIKit_iOS/documentation/atomicxcore/liveliststore) and related classes, refer to the official API documentation included with the [AtomicXCore](https://tencent-rtc.github.io/TUIKit_iOS/documentation/atomicxcore) framework. The relevant Stores used in this document are as follows:
-| <strong>Store/Component</strong> | <strong>Feature Description</strong> | <strong>API Documentation</strong> |
-| --- | --- | --- |
-| LiveCoreView | - Core view component for live video stream display and interaction.<br>- Responsible for video stream rendering and view widget handling, supporting scenarios such as host streaming, audience co-hosting, and host linking. | <a href="https://tencent-rtc.github.io/TUIKit_iOS/documentation/atomicxcore/livecoreview">API Documentation</a> |
-| LiveListStore | Full lifecycle management of live rooms: create, join, leave, destroy rooms; query room list; modify live information (name, announcement, etc.); listen to live status (such as being removed or ended). | <a href="https://tencent-rtc.github.io/TUIKit_iOS/documentation/atomicxcore/liveliststore">API Documentation</a> |
-
-## FAQs
-
-### Is the list data for voice chat rooms and video live rooms the same?
-
-Yes. The data is unified; you do not need to fetch them separately. `LiveListStore` is a global singleton that manages the lifecycle of all "live" rooms in your application, including both video live rooms and voice chat rooms.
-
-### How do I distinguish between voice chat rooms and video live rooms in the live room list?
-
-`LiveListStore` does not differentiate between room business types. You must filter and categorize the list after fetching, at the application or UI layer.
-
-We recommend two approaches:
-
-**Approach 1 (Recommended): Use seatLayoutTemplateID for differentiation.**
-
-This template ID defines the room layout. For supported template IDs and effects, refer to Run And Test.
-- **Step 1: Specify ID when creating a room**
-
-  - When calling `LiveListStore.shared.createLive`, set the `seatLayoutTemplateID` property of `LiveInfo` based on your business scenario:
-
-  - Voice chat rooms: Use template IDs in the range 1–199.
-
-  - Video live rooms: Use template IDs in the range 200–999.
-
-- **Step 2: Filter when fetching the list**
-
-  - On the client side, after receiving the list in `LiveListStore.state.liveList`, determine the business scenario by checking the template ID range.
-
-      > **Note：**
-      >
-
-      > If the seatLayoutTemplateID does not match your business scenario (voice chat room or video live room), seat layout features may not work as expected.
-      >
-
-      **Approach 2:****Add a business prefix to **`liveID`**.**
-
-      This is an optional, application-layer convention to help you filter rooms quickly.
-
-- **Step 1: Add prefix when creating a room**
-
-  - When generating liveID and calling createLive, assign different prefixes for each business type. For example: video live room IDs start with "Live_" (e.g., Live_12345), voice chat room IDs start with "voice_" (e.g., voice_67890).
-
-- **Step 2: Check prefix when fetching the list**
-
-  - On the client side, after fetching the list, distinguish rooms by checking the liveID prefix.

package/resource/knowledge/livekit/core-sdk/voice/android/voice-audience-list.md

@@ -1,269 +0,0 @@
-`LiveAudienceStore` is a module in `AtomicXCore` designed for managing audience information in live streaming rooms. With `LiveAudienceStore`, you can implement a comprehensive audience list and management system for your live streaming application.
-
-## Core Features
-- **Real-Time Audience List**: Retrieve and display all audience information currently present in the live room.
-
-- **Audience Count Statistics**: Access the accurate, real-time total number of viewers in the live room.
-
-- **Audience Activity Monitoring**: Subscribe to events to instantly detect when viewers join or leave.
-
-- **Administrator Privileges**: The host can promote regular viewers to administrators or revoke their admin status.
-
-- **Room Management**: The host or administrator can remove (kick out) any regular viewer from the live room.
-
-## Core Concepts
-
-|**Core Concept**|**Type**|**Core Responsibilities & Description**|
-|---------|---------|---------|
-|`LiveUserInfo`|data class|Represents the basic information model of an audience member (user). It contains the user's unique identifier (`userID`), nickname (`userName`), and avatar URL (`avatarURL`).|
-|`LiveAudienceState`|data class|Represents the current state of the audience module. Its core property `audienceList` is a StateFlow that stores the real-time state of the audience list; `audienceCount` represents the real-time state of the current total number of viewers.|
-|`LiveAudienceListener`|abstract class|Represents real-time audience activity events. It includes `onAudienceJoined` (audience joins) and `onAudienceLeft` (audience leaves), used for incremental updates to the audience list.|
-|`LiveAudienceStore`|abstract class|This is the core management class for interacting with audience list functionality. Through it, you can obtain audience list snapshots, perform management operations, and subscribe to its `LiveAudienceListener` for real-time updates.|
-
-## Implementation Guide
-
-### Step 1: Component Integration
-- **Video Live Streaming**: Please refer to Quick Start to integrate AtomicXCore
-
-- **Voice Chat Room**: Please refer to Quick Start to integrate AtomicXCore.
-
-### Step 2: Initialize and Retrieve the Audience List
-
-Obtain a `LiveAudienceStore` instance bound to the current live room's `liveId`, and fetch the current audience list for the initial display.
-``` kotlin
-import kotlinx.coroutines.*
-import kotlinx.coroutines.flow.*
-import io.trtc.tuikit.atomicxcore.api.CompletionHandler
-import io.trtc.tuikit.atomicxcore.api.live.LiveAudienceStore
-import io.trtc.tuikit.atomicxcore.api.live.LiveUserInfo
-
-class AudienceManager(
-    private val liveId: String
-) {
-    private val audienceStore: LiveAudienceStore = LiveAudienceStore.create(liveId)
-    private val scope = CoroutineScope(Dispatchers.Main)
-
-    // Expose the [full] audience list state flow for UI layer subscription
-    private val _audienceList = MutableStateFlow<List<LiveUserInfo>>(emptyList())
-    val audienceList: StateFlow<List<LiveUserInfo>> = _audienceList.asStateFlow()
-
-    // Expose the audience count state flow
-    private val _audienceCount = MutableStateFlow(0)
-    val audienceCount: StateFlow<Int> = _audienceCount.asStateFlow()
-
-    init {
-        // 1. Subscribe to state and events, see next section for implementation
-        subscribeToAudienceState()
-        subscribeToAudienceEvents()
-
-        // 2. Actively fetch initial data for the first screen
-        fetchInitialAudienceList()
-    }
-
-    /// Actively fetch a snapshot of the audience list once
-    private fun fetchInitialAudienceList() {
-        audienceStore.fetchAudienceList(object : CompletionHandler {
-            override fun onSuccess() {
-                println("Successfully fetched the initial audience list")
-                // After success, the data will be automatically updated via the state subscription channel below
-            }
-
-            override fun onFailure(code: Int, desc: String) {
-                println("Failed to fetch the initial audience list: $desc")
-            }
-        })
-    }
-
-    // ... subsequent code
-}
-```
-
-### Step 3: Listen to Audience List State and Real-Time Activity
-
-Subscribe to the `liveAudienceState` of `audienceStore` and add a `LiveAudienceListener` to receive full list snapshots and real-time audience join/leave events. Use these updates to drive UI changes.
-``` kotlin
-class AudienceManager {
-    /// Subscribe to state for audience count and list snapshots
-    private fun subscribeToAudienceState() {
-        scope.launch {
-            // audienceList is a full snapshot
-            audienceStore.liveAudienceState.audienceList.collect { audienceList ->
-                _audienceList.value = audienceList
-            }
-        }
-
-        scope.launch {
-            // audienceCount is the real-time total
-            audienceStore.liveAudienceState.audienceCount.collect { count ->
-                _audienceCount.value = count
-            }
-        }
-    }
-
-    private val liveAudienceListener = object : LiveAudienceListener() {
-        override fun onAudienceJoined(newAudience: LiveUserInfo) {
-            println("Audience ${newAudience.userName} joined the live room")
-            // Incremental update: add the new audience member to the end of the current list
-            val currentList = _audienceList.value.toMutableList()
-            if (!currentList.any { it.userID == newAudience.userID }) {
-                currentList.add(newAudience)
-                _audienceList.value = currentList
-            }
-        }
-
-        override fun onAudienceLeft(departedAudience: LiveUserInfo) {
-            println("Audience ${departedAudience.userName} left the live room")
-            // Incremental update: remove the departed audience member from the current list
-            val currentList = _audienceList.value.toMutableList()
-            currentList.removeAll { it.userID == departedAudience.userID }
-            _audienceList.value = currentList
-        }
-    }
-
-    /// Subscribe to events to handle real-time audience join/leave
-    private fun subscribeToAudienceEvents() {
-        audienceStore.addLiveAudienceListener(liveAudienceListener)
-    }
-}
-```
-
-### Step 4: Manage Audience (Kick and Set Administrator)
-
-As a host or administrator, you can manage viewers in the live room.
-
-#### 4.1 Kick a Viewer Out of the Live Room
-
-Call the `kickUserOutOfRoom` method to remove a specified user from the live room.
-``` kotlin
-class AudienceManager {
-    fun kick(userId: String) {
-        audienceStore.kickUserOutOfRoom(userId, object : CompletionHandler {
-            override fun onSuccess() {
-                println("Successfully kicked user $userId out of the room")
-                // After a successful kick, you will receive an onAudienceLeft event
-            }
-
-            override fun onFailure(code: Int, desc: String) {
-                println("Failed to kick user $userId: $desc")
-            }
-        })
-    }
-}
-```
-
-#### 4.2 Set or Revoke Administrator Status
-
-Use the `setAdministrator` and `revokeAdministrator` methods to manage a user's administrator status.
-``` kotlin
-class AudienceManager {
-    /// Promote user to administrator
-    fun promoteToAdmin(userId: String) {
-        audienceStore.setAdministrator(userId, object : CompletionHandler {
-            override fun onSuccess() {
-                println("Successfully promoted user $userId to administrator")
-            }
-
-            override fun onFailure(code: Int, desc: String) {
-                println("Failed to set administrator: $desc")
-            }
-        })
-    }
-
-    /// Revoke user's administrator status
-    fun revokeAdmin(userId: String) {
-        audienceStore.revokeAdministrator(userId, object : CompletionHandler {
-            override fun onSuccess() {
-                println("Successfully revoked administrator status for user $userId")
-            }
-
-            override fun onFailure(code: Int, desc: String) {
-                println("Failed to revoke administrator: $desc")
-            }
-        })
-    }
-}
-```
-
-## Advanced Features
-
-### Display a Welcome Message in the Barrage Area When a Viewer Joins
-
-When a new viewer enters the live room, a welcome message such as `"Welcome [user nickname] to the live room"` is automatically displayed locally in the barrage/chat area.
-
-#### Implementation
-
-Add a listener for the audience join event `LiveAudienceListener.onAudienceJoined` in `LiveAudienceStore` to receive real-time notifications when a new viewer joins. When triggered, extract the new viewer's nickname and call the `appendLocalTip` method of BarrageStore to insert the message locally.
-``` kotlin
-import io.trtc.tuikit.atomicxcore.api.live.LiveAudienceListener
-import io.trtc.tuikit.atomicxcore.api.live.LiveAudienceStore
-import io.trtc.tuikit.atomicxcore.api.live.LiveUserInfo
-import io.trtc.tuikit.atomicxcore.api.barrage.Barrage
-import io.trtc.tuikit.atomicxcore.api.barrage.BarrageStore
-import io.trtc.tuikit.atomicxcore.api.barrage.BarrageType
-
-class LiveRoomManager(
-    private val liveId: String
-) {
-
-    init {
-        // Initialize two core managers
-        setupWelcomeMessageFlow()
-    }
-
-    private val liveAudienceListener = object : LiveAudienceListener() {
-        override fun onAudienceJoined(audience: LiveUserInfo) {
-            // 3. Create a local tip message
-            val welcomeTip = Barrage().apply {
-                liveID = liveId
-                messageType = BarrageType.TEXT
-                textContent = "Welcome ${audience.userName} to the live room."
-            }
-
-            // 4. Get an instance of BarrageStore (this will be the same instance due to internal mechanisms)
-            val barrageStore = BarrageStore.create(liveId)
-
-            // 5. Use BarrageStore's method to insert it into the barrage list
-            barrageStore.appendLocalTip(welcomeTip)
-        }
-    }
-
-    private fun setupWelcomeMessageFlow() {
-        // 1. Get an instance of LiveAudienceStore
-        val audienceStore = LiveAudienceStore.create(liveId)
-
-        // 2. Subscribe to audience events
-        audienceStore.addLiveAudienceListener(liveAudienceListener)
-    }
-}
-```
-
-## API Documentation
-
-For detailed information on all public interfaces, properties, and methods of [LiveAudienceStore](https://tencent-rtc.github.io/TUIKit_Android/-atomic-x%20-core%20-a-p-i/io.trtc.tuikit.atomicxcore.api.live/-live-audience-store/index.html) and its related classes, refer to the official API documentation included with the [AtomicX Core](https://tencent-rtc.github.io/TUIKit_Android/index.html) framework. The relevant Stores used in this document are as follows:
-
-|**Store/Component**|**Feature Description**|**API Documentation**|
-|---------|---------|---------|
-|LiveCoreView|Core view component for live video stream display and interaction: responsible for video stream rendering and view widget handling, supporting scenarios such as host streaming, audience co-hosting, and host-to-host connection.|[API Documentation](https://tencent-rtc.github.io/TUIKit_Android/-atomic-x%20-core%20-a-p-i/io.trtc.tuikit.atomicxcore.api.view/-live-core-view/index.html)|
-|LiveAudienceStore|Audience management: obtain real-time audience list (ID / name / avatar), count audience numbers, and listen for audience join/leave events.|[API Documentation](https://tencent-rtc.github.io/TUIKit_Android/-atomic-x%20-core%20-a-p-i/io.trtc.tuikit.atomicxcore.api.view/-live-core-view/index.html)|
-|BarrageStore|Barrage feature: send text/custom barrage, maintain barrage list, and listen to barrage status in real time.|[API Documentation](https://tencent-rtc.github.io/TUIKit_Android/-atomic-x%20-core%20-a-p-i/io.trtc.tuikit.atomicxcore.api.barrage/-barrage-store/index.html)|
-
-## FAQs
-
-### How is the online audience count (audienceCount) in LiveAudienceState updated? What are the timing and frequency?
-
-The update of `audienceCount` is not always strictly real-time. The mechanism is as follows:
-- **Active Join/Leave**: When a user actively joins or leaves the live room, the audience count change notification is triggered instantly. You will quickly observe the change in `audienceCount` in `LiveAudienceState`.
-
-- **Unexpected Disconnection**: If a user disconnects unexpectedly due to network issues, app crashes, and so on, the system determines their actual status using a heartbeat mechanism. Only when the user has no heartbeat for 90 consecutive seconds does the system consider them offline and trigger a count change notification.
-
-- **Update Mechanism and Frequency Control:**
-
-  - Whether triggered instantly or with a delay, all audience count change notifications are broadcast as messages within the room.
-
-  - There is an upper limit to the total number of messages per second in a room, with a per-room message rate limit of 40 messages per second.
-
-  - Key Point: In scenarios with extremely high message traffic, such as "barrage storms" or rapid-fire gifting, if the message rate in the room exceeds the 40 messages/second threshold, to ensure the delivery of core messages (such as barrage), audience count change messages may be dropped by the rate-limiting policy.
-
-- **What does this mean for developers?**
-
-   `audienceCount` is a near real-time, high-precision estimate, but in extreme high-concurrency scenarios, there may be brief delays or data loss. We recommend using it for UI display only, and not as the sole basis for billing, statistics, or other scenarios requiring absolute accuracy.