@tencent-rtc/mcp 1.6.3 → 1.6.5

package/resource/knowledge/livekit/core-sdk/live/android/live-audio-effect.md

@@ -1,226 +0,0 @@
-This document provides guidance on integrating audio effect controls into your live streaming application using the `AudioEffectStore` and `DeviceStore` modules from the **AtomicXCore** framework. These modules enable features such as microphone volume control, ear monitoring, and a variety of voice changing and reverb effects.
-
-## Core Features
-
-By combining `AudioEffectStore` and DeviceStore, you can implement the following core features:
-- **Microphone Volume Adjustment**: Control the local microphone (capture) volume, which determines the volume your audience hears.
-
-- **Ear Monitoring**: Allow hosts or co-hosts to hear their own voice in real time through headphones for monitoring and pronunciation correction.
-
-- **Voice Effects**: Apply various voice changing effects, such as "Little Girl", "Deep Male", "Naughty Child", and more.
-
-- **Reverb Effects**: Simulate different acoustic environments, such as KTV, metallic, deep, bright, and others.
-
-## Core Concepts
-
-|**Core Concept**|**Type**|**Core Responsibility & Description**|
-|---------|---------|---------|
-|`AudioChangerType`|`enum`|Enumerates available voice effects, such as "child", "man", etc.|
-|`AudioReverbType`|`enum`|Enumerates available reverb effects, such as "ktv", "hall", etc.|
-|`AudioEffectState`|`data`|Represents the current state of the audio effect module, typically used for UI rendering. Includes voice effect state, reverb state, ear monitoring enabled state, and ear monitor volume.|
-|`AudioEffectStore`|`abstract`|Singleton data management class for audio effects. Use it to invoke audio effect APIs. After calling an API, the corresponding state property is automatically updated. Subscribe to this reactive state to receive and monitor updates.|
-|`DeviceState`|`data`|Represents the current state of the device module, typically used for UI rendering. Core properties include camera and microphone status.|
-|`DeviceStore`|`abstract`|Singleton data management class for device operations. Use it to control the camera and microphone. After calling an API, the corresponding state property is automatically updated. Subscribe to this reactive state to receive and monitor updates.|
-
-## Implementation
-
-### 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: Obtain Store Instances
-
-`AudioEffectStore` and `DeviceStore` are singleton objects. Access their instances anywhere in your project via the shared property. For a complete implementation example, see [AudioEffectPanel.kt](https://github.com/Tencent-RTC/TUIKit_Android/blob/main/live/tuilivekit/src/main/java/com/trtc/uikit/livekit/component/audioeffect/AudioEffectPanel.kt) in the TUILiveKit open-source UI demo.
-``` java
-import io.trtc.tuikit.atomicxcore.api.device.AudioEffectStore
-import io.trtc.tuikit.atomicxcore.api.device.DeviceStore
-
-val audioEffectStore = AudioEffectStore.shared()
-val deviceStore = DeviceStore.shared()
-```
-
-### Step 3: Implement In-Ear Monitoring
-
-Ear monitoring allows users to hear their own microphone audio in real time. Manage ear monitoring using the following APIs.
-
-> **Note：**Ear monitoring typically requires headphones to function properly.
->
-
-#### Implementation
-1. **Toggle Ear Monitoring**: Use a `Switch` control to enable or disable ear monitoring.
-
-2. **Set Ear Monitor Volume**: Use a `SeekBar` (or similar control) to adjust the ear monitor volume. Map the UI control's value to the [0, 150] range and call setVoiceEarMonitorVolume(volume).
-
-3. **Listen for State Updates**: Subscribe to ear monitor state changes to update the UI in real time.
-
-#### Code Example
-``` java
-import io.trtc.tuikit.atomicxcore.api.device.AudioEffectStore
-import kotlinx.coroutines.CoroutineScope
-import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.launch
-
-// 1. Enable ear monitoring (prompt the user to connect headphones)
-audioEffectStore.setVoiceEarMonitorEnable(true)
-
-// 2. Set ear monitor volume
-audioEffectStore.setVoiceEarMonitorVolume(80)
-
-// 3. Disable ear monitoring
-audioEffectStore.setVoiceEarMonitorEnable(false)
-
-// 4. Listen for state updates
-CoroutineScope(Dispatchers.Main).launch {
-  audioEffectStore.audioEffectState.earMonitorVolume.collect {
-    print("Ear monitor volume: $it")
-    // Update UI with the value
-  }
-}
-```
-
-#### setVoiceEarMonitorEnable Parameters
-| <strong>Parameter Name</strong> | <strong>Type</strong> | <strong>Description</strong> |
-| --- | --- | --- |
-| <code>enable</code> | <code>Boolean</code> | Whether to enable ear monitoring.<br>- true: Enable<br>- false: Disable |
-
-#### setVoiceEarMonitorVolume Parameters
-| <strong>Parameter Name</strong> | <strong>Type</strong> | <strong>Description</strong> |
-| --- | --- | --- |
-| <code>volume</code> | <code>Int</code> | Ear monitor volume.<br>- Range: [0, 150]<br>- Default: 100 |
-
-### Step 4: Implement Microphone Volume Adjustment
-
-To adjust the microphone (capture) volume, call `setCaptureVolume(volume) `on `DeviceStore` with the desired value.
-
-#### Implementation
-1. **Set Capture Volume**: Use a `SeekBar` or similar control to adjust the microphone volume. Map the UI control's value to the [0, 150] range and call `setCaptureVolume(volume)`.
-
-2. **Listen for State Updates**: Subscribe to capture volume state changes to update the UI in real time.
-
-#### Code Example
-``` java
-import kotlinx.coroutines.CoroutineScope
-import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.launch
-import io.trtc.tuikit.atomicxcore.api.device.DeviceStore
-
-// 1. Adjust microphone volume
-deviceStore.setCaptureVolume(80)
-
-// 2. Listen for volume changes
-CoroutineScope(Dispatchers.Main).launch {
-   deviceStore.deviceState.captureVolume.collect {
-     print("Capture volume: $it")
-     // Update UI with the value
-   }
-}
-```
-
-#### setCaptureVolume Parameters
-| <strong>Parameter Name</strong> | <strong>Type</strong> | <strong>Description</strong> |
-| --- | --- | --- |
-| <code>volume</code> | <code>Int</code> | Microphone (capture) volume.<br>- Range: [0, 150]<br>- Default: 100 |
-
-### Step 5: Implement Voice Effects
-
-To apply a voice effect, call `setAudioChangerType(type)` with the desired `AudioChangerType` enum value.
-
-#### Code Example
-``` java
-import io.trtc.tuikit.atomicxcore.api.device.AudioEffectStore
-import io.trtc.tuikit.atomicxcore.api.device.AudioChangerType
-
-// Set voice effect to "Little Girl"
-audioEffectStore.setAudioChangerType(AudioChangerType.LITTLE_GIRL)
-
-// Disable voice effect
-audioEffectStore.setAudioChangerType(AudioChangerType.NONE)
-```
-
-#### setAudioChangerType Parameters
-
-|**Parameter Name**|**Type**|**Description**|
-|---------|---------|---------|
-|`type`|`AudioChangerType`|Voice effect enum value.|
-
-### Step 6: Implement Reverb Effects
-
-To apply a reverb effect, call `setAudioReverbType(type)` with the desired `AudioReverbType` enum value.
-``` java
-import io.trtc.tuikit.atomicxcore.api.device.AudioEffectStore
-import io.trtc.tuikit.atomicxcore.api.device.AudioReverbType
-
-// Set reverb to "KTV"
-audioEffectStore.setAudioReverbType(AudioReverbType.KTV)
-
-// Disable reverb
-audioEffectStore.setAudioReverbType(AudioReverbType.NONE)
-```
-
-#### setAudioReverbType Parameters
-
-|**Parameter Name**|**Type**|**Description**|
-|---------|---------|---------|
-|`type`|`AudioReverbType`|Reverb effect enum value.|
-
-### Step 7: Reset Audio Effect Settings
-
-> **Note：**
->
-
-> `AudioEffectStore` and `DeviceStore` are singletons, so audio effect and device settings are globally applied. To prevent settings from one live room affecting others, reset audio effect and device settings when the current live room ends.
->
-
-Reset audio effect settings in the following scenarios:
-1. When the current live room ends.
-
-2. To provide a "one-click restore" feature, call the`reset()`() method on each store.
-
-   ``` java
-   import io.trtc.tuikit.atomicxcore.api.device.AudioEffectStore
-   import io.trtc.tuikit.atomicxcore.api.device.DeviceStore
-
-   // One-click reset for all voice and reverb effects
-   AudioEffectStore.shared().reset()
-   DeviceStore.shared().reset()
-   ```
-
-## API Documentation
-
-For detailed information on all public interfaces and properties of [AudioEffectStore](https://tencent-rtc.github.io/TUIKit_Android/-atomic-x%20-core%20-a-p-i/io.trtc.tuikit.atomicxcore.api.device/-audio-effect-store/index.html), [DeviceStore](https://tencent-rtc.github.io/TUIKit_Android/-atomic-x%20-core%20-a-p-i/io.trtc.tuikit.atomicxcore.api.device/-device-store/index.html), and their related classes, refer to the official API documentation for the [AtomicXCore](https://tencent-rtc.github.io/TUIKit_iOS/documentation/atomicxcore) framework.
-
-|**Store/Component**|**Feature Description**|**API Documentation**|
-|---------|---------|---------|
-|AudioEffectStore|Manage audio effects: configure and retrieve real-time audio effect status.|[API Documentation](https://tencent-rtc.github.io/TUIKit_Android/-atomic-x%20-core%20-a-p-i/io.trtc.tuikit.atomicxcore.api.device/-audio-effect-store/index.html)|
-|DeviceStore|Manage devices: control camera and microphone, and retrieve real-time device status.|[API Documentation](https://tencent-rtc.github.io/TUIKit_Android/-atomic-x%20-core%20-a-p-i/io.trtc.tuikit.atomicxcore.api.device/-device-store/index.html)|
-
-## FAQs
-
-### Are there any restrictions on when to call audio effect and device APIs?
-
-No. `AudioEffectStore` and `DeviceStore` settings are globally effective. You can call relevant APIs (such as setting voice effects, reverb, or ear monitoring) at any time before or after entering a live room. Settings take effect immediately and persist.
-
-### What is the difference between "Microphone Volume" and "Ear Monitor Volume"?
-
-This is a common point of confusion:
-- **Microphone Volume (Capture Volume)**: Set via `DeviceStore.setCaptureVolume()`. Controls the volume your audience hears.
-
-- **Ear Monitor Volume**: Set via `AudioEffectStore.setVoiceEarMonitorVolume()`.  It only determines the volume level you hear in your in-ear monitor and does not affect the audience.
-
-### Why does a newly created live room already have audio effects, or why is the volume too high or too low?
-
-Because `AudioEffectStore` and `DeviceStore` are singletons, audio effect and device settings are globally applied. If you previously set audio effects and did not reset them, those settings persist. Call the `reset()` method at the appropriate time to clear them.
-
-### Why can't I hear my own voice after enabling "Ear Monitoring"?
-
-Check the following:
-1. **Are headphones connected?** Ear monitoring generally requires headphones. Ensure wired or Bluetooth headphones are connected.
-
-2. **Is the ear monitor volume set to 0?** Check that the ear monitor volume is above 0.
-
-3. **Is the microphone enabled?** Confirm that the microphone is enabled in DeviceStore (i.e., openLocalMicrophone has been called).
-
-### Can voice effects and reverb be enabled at the same time?
-
-Yes. `AudioChangerType` and `AudioReverbType` can be enabled simultaneously. For example, you can set both `AudioChangerType.LITTLE_GIRL`and `AudioReverbType.KTV` at the same time.

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

@@ -1,438 +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 a paginated list of all currently public live rooms.
-
-- **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
-
-|**Core Concept**|**Type**|**Core Responsibility & Description**|
-|---------|---------|---------|
-|`LiveInfo`|`data class`|Represents the complete information model of a live room. Includes the live room ID (liveID), name (liveName), owner information (liveOwner), and custom metadata (metaData), among other properties.|
-|`LiveListState`|`data class`|Represents the current state of the live list module. The core property liveList is a StateFlow containing the fetched live room list; currentLive represents the information of the live room the user is currently in.|
-|`LiveListListener`|`abstract class`|Handles global live room events, including onLiveEnded (live ended) and onKickedOutOfLive (user removed from live), for responding to key room state changes.|
-|`LiveListStore`|`abstract class`|The core management class for interacting with the live room list and room lifecycle. 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 RecyclerView to layout live room cards. When a user taps a card, retrieve the liveId for that room and navigate to the audience viewing page.
-``` kotlin
-import android.content.Intent
-import android.os.Bundle
-import android.view.LayoutInflater
-import android.view.View
-import android.view.ViewGroup
-import androidx.appcompat.app.AppCompatActivity
-import androidx.recyclerview.widget.GridLayoutManager
-import androidx.recyclerview.widget.RecyclerView
-import io.trtc.tuikit.atomicxcore.api.CompletionHandler
-import io.trtc.tuikit.atomicxcore.api.live.LiveInfo
-import io.trtc.tuikit.atomicxcore.api.live.LiveListStore
-import kotlinx.coroutines.*
-import kotlinx.coroutines.flow.*
-
-class LiveListActivity : AppCompatActivity() {
-    private val liveListStore = LiveListStore.shared()
-    private var liveList: List<LiveInfo> = emptyList()
-    private val coroutineScope = CoroutineScope(Dispatchers.Main)
-
-    private lateinit var recyclerView: RecyclerView
-    private lateinit var adapter: LiveListAdapter
-
-    override fun onCreate(savedInstanceState: Bundle?) {
-        super.onCreate(savedInstanceState)
-        setContentView(R.layout.activity_live_list)
-        setupUI()
-        bindStore()
-        fetchLiveList()
-    }
-
-    private fun bindStore() {
-        // Subscribe to the state to automatically receive list updates
-        coroutineScope.launch {
-            liveListStore.liveState.liveList.collect { fetchedList ->
-                liveList = fetchedList
-                adapter.notifyDataSetChanged()
-            }
-        }
-    }
-
-    private fun fetchLiveList() {
-        liveListStore.fetchLiveList(
-            cursor = "",
-            count = 20,
-            completion = object : CompletionHandler {
-                override fun onSuccess() {
-                    println("Live room list fetched successfully")
-                }
-
-                override fun onFailure(code: Int, desc: String) {
-                    println("Failed to fetch live room list: $desc")
-                }
-            }
-        )
-    }
-
-    // When a user clicks an item in the list
-    private fun onLiveItemClick(liveInfo: LiveInfo) {
-        // Create the audience viewing page and pass the liveId
-        val intent = Intent(this, YourAudienceActivity::class.java)
-        intent.putExtra("liveId", liveInfo.liveID)
-        startActivity(intent)
-    }
-
-    // --- RecyclerView related methods ---
-    private fun setupUI() {
-        recyclerView = findViewById(R.id.recyclerView)
-        adapter = LiveListAdapter(liveList) { liveInfo ->
-            onLiveItemClick(liveInfo)
-        }
-        recyclerView.layoutManager = GridLayoutManager(this, 2)
-        recyclerView.adapter = adapter
-    }
-
-    override fun onDestroy() {
-        super.onDestroy()
-        coroutineScope.cancel()
-    }
-}
-
-// RecyclerView Adapter
-class LiveListAdapter(
-    private var liveList: List<LiveInfo>,
-    private val onItemClick: (LiveInfo) -> Unit
-) : RecyclerView.Adapter<LiveListAdapter.LiveViewHolder>() {
-
-    class LiveViewHolder(itemView: View) : RecyclerView.ViewHolder(itemView) {
-        // Define your ViewHolder view components
-        // val titleTextView: TextView = itemView.findViewById(R.id.titleTextView)
-        // val coverImageView: ImageView = itemView.findViewById(R.id.coverImageView)
-    }
-
-    override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): LiveViewHolder {
-        val view = LayoutInflater.from(parent.context)
-            .inflate(R.layout.item_live_card, parent, false)
-        return LiveViewHolder(view)
-    }
-
-    override fun onBindViewHolder(holder: LiveViewHolder, position: Int) {
-        val liveInfo = liveList[position]
-        // Set data to ViewHolder
-        // holder.titleTextView.text = liveInfo.liveName
-        // Load cover image, etc.
-
-        holder.itemView.setOnClickListener {
-            onItemClick(liveInfo)
-        }
-    }
-
-    override fun getItemCount(): Int = liveList.size
-}
-```
-
-#### LiveInfo Parameter Reference
-
-|**Parameter Name**|**Type**|**Description**|
-|---------|---------|---------|
-|`liveID`|`String`|Unique identifier for the live room|
-|`liveName`|`String`|Title of the live room|
-|`coverURL`|`String`|Cover image URL for the live room|
-|`liveOwner`|[LiveUserInfo](https://tencent-rtc.github.io/TUIKit_Android/-atomic-x%20-core%20-a-p-i/io.trtc.tuikit.atomicxcore.api.live/-live-user-info/index.html)|Personal information of the room owner|
-|`totalViewerCount`|`Int`|Total number of viewers in the live room|
-|`categoryList`|`List<Int>`|List of category tags for the live room|
-|`notice`|`String`|Announcement information for the live room|
-|`metaData`|`Map<String, String>`|Developer-defined metadata for implementing advanced 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 selects a category while going live, the `fetchLiveList` API returns LiveInfo objects that include these category details. After retrieving the full live room list, filter it on the client based on the user’s selected category and refresh the UI.
-
-#### Code Example
-
-The following example shows how to extend a `LiveListManager` within `LiveListActivity` to handle data retrieval and filtering logic.
-``` kotlin
-import android.os.Bundle
-import androidx.appcompat.app.AppCompatActivity
-import androidx.recyclerview.widget.RecyclerView
-import io.trtc.tuikit.atomicxcore.api.live.LiveInfo
-import io.trtc.tuikit.atomicxcore.api.live.LiveListStore
-import kotlinx.coroutines.*
-import kotlinx.coroutines.flow.*
-
-// 1. Create a data manager to encapsulate data retrieval and filtering logic
-class LiveListManager {
-    private val liveListStore = LiveListStore.shared()
-    private var fullLiveList: List<LiveInfo> = emptyList()
-
-    // Expose the final filtered live list externally
-    private val _filteredLiveList = MutableStateFlow<List<LiveInfo>>(emptyList())
-    val filteredLiveList: StateFlow<List<LiveInfo>> = _filteredLiveList
-
-    init {
-        // Listen for full list changes
-        CoroutineScope(Dispatchers.Main).launch {
-            liveListStore.liveState.liveList.collect { fetchedList ->
-                fullLiveList = fetchedList
-                // By default, publish the complete list
-                _filteredLiveList.value = fetchedList
-            }
-        }
-    }
-
-    fun fetchFirstPage() {
-        liveListStore.fetchLiveList(cursor = "", count = 20, completion = null)
-    }
-
-    /// Filter the live list by category
-    fun filterLiveList(categoryId: Int?) {
-        if (categoryId == null) {
-            // If categoryId is null, show the complete list
-            _filteredLiveList.value = fullLiveList
-            return
-        }
-
-        val filteredList = fullLiveList.filter { liveInfo ->
-            liveInfo.categoryList.contains(categoryId)
-        }
-        _filteredLiveList.value = filteredList
-    }
-}
-
-// 2. Use the Manager in your LiveListActivity
-class LiveListActivity : AppCompatActivity() {
-    private val manager = LiveListManager()
-    private lateinit var recyclerView: RecyclerView
-
-    override fun onCreate(savedInstanceState: Bundle?) {
-        super.onCreate(savedInstanceState)
-        setContentView(R.layout.activity_live_list)
-        // setupUI()
-
-        // Bind data
-        CoroutineScope(Dispatchers.Main).launch {
-            manager.filteredLiveList.collect { filteredList ->
-                // Refresh UI
-               // adapter.updateList(filteredList)
-            }
-        }
-
-        // Fetch first page
-        manager.fetchFirstPage()
-    }
-
-    // When the user clicks a top category tag
-    fun onCategorySelected(categoryId: Int) {
-        manager.filterLiveList(categoryId)
-    }
-
-    // ... (RecyclerView related code)
-}
-```
-
-### Scenario 2: Swipe-to-Play for Live Room List
-
-Users can switch between live rooms by swiping up and down. When a new live room is centered on the screen, the video preview automatically starts playing. When it leaves the screen, playback stops automatically 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 `RecyclerView.ViewHolder`. By monitoring the scroll state of the `RecyclerView`, you can precisely control when to start or stop streaming in each ViewHolder, achieving "play on swipe in, stop on swipe out" behavior.
-
-#### Code Example
-
-We create a custom `LiveFeedViewHolder` that holds a `LiveCoreView` internally. We then manage the playback state of these ViewHolders in the `Activity`.
-``` kotlin
-import android.os.Bundle
-import android.view.LayoutInflater
-import android.view.View
-import android.view.ViewGroup
-import androidx.appcompat.app.AppCompatActivity
-import androidx.recyclerview.widget.LinearLayoutManager
-import androidx.recyclerview.widget.RecyclerView
-import io.trtc.tuikit.atomicxcore.api.live.LiveInfo
-import io.trtc.tuikit.atomicxcore.api.view.CoreViewType
-import io.trtc.tuikit.atomicxcore.api.view.LiveCoreView
-
-// 1. Custom RecyclerView.ViewHolder, containing a LiveCoreView internally
-class LiveFeedViewHolder(itemView: View) : RecyclerView.ViewHolder(itemView) {
-    private var liveCoreView: LiveCoreView? = null
-
-    fun setLiveInfo(liveInfo: LiveInfo) {
-        // Create a new LiveCoreView for the new live info
-        liveCoreView = LiveCoreView(itemView.context, viewType = CoreViewType.PLAY_VIEW)
-        liveCoreView?.let { view ->
-            (itemView as ViewGroup).addView(view)
-            view.layoutParams = ViewGroup.LayoutParams(
-                ViewGroup.LayoutParams.MATCH_PARENT,
-                ViewGroup.LayoutParams.MATCH_PARENT
-            )
-        }
-    }
-
-    fun startPlay(roomId: String) {
-        liveCoreView?.startPreviewLiveStream(roomId, false, callback = null)
-    }
-
-    fun stopPlay(roomId: String) {
-        liveCoreView?.stopPreviewLiveStream(roomId)
-    }
-}
-
-// 2. Manage playback logic in the Activity
-class LiveFeedActivity : AppCompatActivity() {
-
-    private lateinit var recyclerView: RecyclerView
-    private var liveList: List<LiveInfo> = emptyList()
-    private var currentPlayingPosition: Int = -1
-
-    override fun onCreate(savedInstanceState: Bundle?) {
-        super.onCreate(savedInstanceState)
-        setContentView(R.layout.activity_live_feed)
-        setupRecyclerView()
-    }
-
-    private fun setupRecyclerView() {
-        recyclerView = findViewById(R.id.recyclerView)
-        recyclerView.layoutManager = LinearLayoutManager(this, LinearLayoutManager.VERTICAL, false)
-        recyclerView.adapter = LiveFeedAdapter(liveList) { position ->
-            playVideoAtPosition(position)
-        }
-
-        // Listen for scroll state
-        recyclerView.addOnScrollListener(object : RecyclerView.OnScrollListener() {
-            override fun onScrollStateChanged(recyclerView: RecyclerView, newState: Int) {
-                super.onScrollStateChanged(recyclerView, newState)
-                if (newState == RecyclerView.SCROLL_STATE_IDLE) {
-                    val layoutManager = recyclerView.layoutManager as LinearLayoutManager
-                    val firstVisiblePosition = layoutManager.findFirstCompletelyVisibleItemPosition()
-                    if (firstVisiblePosition != RecyclerView.NO_POSITION) {
-                        playVideoAtPosition(firstVisiblePosition)
-                    }
-                }
-            }
-        })
-    }
-
-    private fun playVideoAtPosition(position: Int) {
-        // Only switch playback when the centered position changes
-        if (currentPlayingPosition != position) {
-            // Stop current playback
-            if (currentPlayingPosition != -1) {
-                val currentViewHolder = recyclerView.findViewHolderForAdapterPosition(currentPlayingPosition)
-                if (currentViewHolder is LiveFeedViewHolder) {
-                    val liveInfo = liveList[currentPlayingPosition]
-                    currentViewHolder.stopPlay(liveInfo.liveID)
-                }
-            }
-
-            // Start new playback
-            val newViewHolder = recyclerView.findViewHolderForAdapterPosition(position)
-            if (newViewHolder is LiveFeedViewHolder) {
-                val liveInfo = liveList[position]
-                newViewHolder.startPlay(liveInfo.liveID)
-                currentPlayingPosition = position
-            }
-        }
-    }
-
-    // RecyclerView Adapter
-    inner class LiveFeedAdapter(
-        private var liveList: List<LiveInfo>,
-        private val onItemClick: (Int) -> Unit
-    ) : RecyclerView.Adapter<LiveFeedViewHolder>() {
-
-        override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): LiveFeedViewHolder {
-            val view = LayoutInflater.from(parent.context)
-                .inflate(R.layout.item_live_feed, parent, false)
-            return LiveFeedViewHolder(view)
-        }
-
-        override fun onBindViewHolder(holder: LiveFeedViewHolder, position: Int) {
-            val liveInfo = liveList[position]
-            holder.setLiveInfo(liveInfo)
-            holder.itemView.setOnClickListener {
-                onItemClick(position)
-            }
-        }
-
-        override fun getItemCount(): Int = liveList.size
-    }
-}
-```
-
-## API Documentation
-
-For detailed information on all public interfaces, properties, and methods of [LiveListStore](https://tencent-rtc.github.io/TUIKit_Android/-atomic-x%20-core%20-a-p-i/io.trtc.tuikit.atomicxcore.api.live/-live-list-store/index.html) and related classes, refer to the official API documentation included with the [AtomicXCore](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 linking.|[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)|
-|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).|[API Documentation](https://tencent-rtc.github.io/TUIKit_Android/-atomic-x%20-core%20-a-p-i/io.trtc.tuikit.atomicxcore.api.live/-live-list-store/index.html)|
-
-## 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.