Live Comments

import kotlinx.coroutines.*
import kotlinx.coroutines.flow.*
import io.trtc.tuikit.atomicxcore.api.barrage.Barrage
import io.trtc.tuikit.atomicxcore.api.barrage.BarrageStore

class BarrageManager(
    private val liveId: String
) {
    private val barrageStore: BarrageStore = BarrageStore.create(liveId)
    private val scope = CoroutineScope(Dispatchers.Main)
    
    // Expose the [full] message list as a Flow for the UI layer to subscribe to
    private val _messagesFlow = MutableStateFlow<List<Barrage>>(emptyList())
    val messagesFlow: StateFlow<List<Barrage>> = _messagesFlow.asStateFlow()
    
    init {
        // Start listening for barrage messages immediately after initialization
        subscribeToBarrageUpdates()
    }

    private fun subscribeToBarrageUpdates() {
        scope.launch {
            barrageStore.barrageState.messageList
                .collect { messageList ->
                    // When messageList updates, pass the new list to the UI layer via Flow
                    // Note: This is the [complete list], including all historical messages
                    _messagesFlow.value = messageList
                }
        }
    }
}

import io.trtc.tuikit.atomicxcore.api.CompletionHandler
import io.trtc.tuikit.atomicxcore.api.barrage.BarrageStore

class BarrageManager(
    private val liveId: String
) {
    private val barrageStore: BarrageStore = BarrageStore.create(liveId)

    // Send a text barrage
    fun sendTextMessage(text: String) {
        // We recommend adding a non-empty check to avoid sending invalid messages
        if (text.isEmpty()) {
            return
        }
        
        // Call the core API to send the message
        barrageStore.sendTextMessage(
            text,
            mapOf(
                "custom key" to "custom value",
            ),
            object : CompletionHandler {
                override fun onSuccess() {
                    println("Text barrage '$text' sent successfully")
                }

                override fun onFailure(code: Int, desc: String) {
                    println("Failed to send text barrage: $desc")
                }
            }
        )
    }
}

class BarrageManager(
    private val liveId: String
) {
    // Send a custom barrage, for example, to send a gift
    fun sendGiftMessage(giftId: String, giftCount: Int) {
        // 1. Define a business-recognizable ID
        val businessId = "live_gift"

        // 2. Encode business data as a JSON string
        val giftData = mapOf(
            "gift_id" to giftId,
            "gift_count" to giftCount
        )

        val jsonString = try {
            // Use Gson or another JSON library for serialization
            // Here we assume Gson is used
            Gson().toJson(giftData)
        } catch (e: Exception) {
            return
        }

        // 3. Call the core API to send the custom message
        barrageStore.sendCustomMessage(
            businessId,
            jsonString,
            object : CompletionHandler {
                override fun onSuccess() {
                    println("Gift message (custom barrage) sent successfully")
                }
                
                override fun onFailure(code: Int, desc: String) {
                    println("Failed to send gift message: $desc")
                }
            }
        )
    }
}

class BarrageManager(
    private val liveId: String
) {
    // Insert a welcome tip into the local message list
    fun showWelcomeMessage(user: LiveUserInfo) {
        // 1. Create a Barrage message
        val welcomeTip = Barrage(
            liveID = liveId,
            messageType = BarrageType.TEXT, // You can reuse the text type for display
            textContent = "Welcome ${user.userName} to the live room!",
            sender = LiveUserInfo() // sender can be left empty or set to a system user identifier
        )

        // 2. Call the API to append it to the local list
        barrageStore.appendLocalTip(welcomeTip)
    }
}

import io.trtc.tuikit.atomicxcore.api.*
import io.trtc.tuikit.atomicxcore.api.live.LiveAudienceStore

// 1. Get the LiveAudienceStore instance bound to the current live room
val audienceStore = LiveAudienceStore.create(liveId)

// 2. Define the user ID to operate on and the mute status
val userIdToMute = "user_id_to_be_muted"
val shouldDisable = true // true to mute, false to unmute

// 3. Call the interface to perform the operation
audienceStore.disableSendMessage(
    userIdToMute,
    shouldDisable,
    object : CompletionHandler {
        override fun onSuccess() {
            println("${if (shouldDisable) "Muted" else "Unmuted"} user $userIdToMute successfully")
        }

        override fun onFailure(code: Int, desc: String) {
            println("Operation failed: $desc")
        }
    }
)

import io.trtc.tuikit.atomicxcore.api.CompletionHandler
import io.trtc.tuikit.atomicxcore.api.live.LiveInfo
import io.trtc.tuikit.atomicxcore.api.live.LiveListStore

// 1. Get the LiveListStore singleton
val liveListStore = LiveListStore.shared()

// 2. Get the current live room info and modify the global mute status
val currentLiveInfo = liveListStore.liveState.currentLive.value.copy(
    isMessageDisable = true // true to enable global mute, false to disable
)

// 3. Call the update interface and specify the modification flag
liveListStore.updateLiveInfo(
    currentLiveInfo,
    listOf(LiveInfo.ModifyFlag.IS_MESSAGE_DISABLE),
    object : CompletionHandler {
        override fun onSuccess() {
            println("Global mute status updated successfully")
        }

        override fun onFailure(code: Int, desc: String) {
            println("Operation failed: $desc")
        }
    }
)

import android.os.Handler
import androidx.recyclerview.widget.RecyclerView
import io.trtc.tuikit.atomicxcore.api.barrage.Barrage

private const val UPDATE_DURATION_MS = 300L

class BarrageUIManager() {
    private var timestampOnLastUpdate = 0L

    private var dataSource: ArrayList<Barrage> = ArrayList()
    private val updateViewTask = Runnable { notifyDataSetChanged() }
    private val handler = Handler()
    private val adapter = BarrageAdapter(dataSource)

    // This method is called frequently from outside, passing in the latest full list
    fun update(newList: List<Barrage>) {
        handler.removeCallbacks(updateViewTask)
        dataSource.clear()
        dataSource.addAll(newList)
        // If the refresh interval is less than 0.3 seconds, do not refresh
        if (System.currentTimeMillis() - timestampOnLastUpdate < UPDATE_DURATION_MS) {
            handler.postDelayed(updateViewTask, UPDATE_DURATION_MS)
            return
        }
    }

    private fun notifyDataSetChanged() {
        adapter.notifyDataSetChanged()
        timestampOnLastUpdate = System.currentTimeMillis()
    }
}

class BarrageAdapter(dataSource: ArrayList<Barrage>): RecyclerView.Adapter<RecyclerView.ViewHolder>() {
    // Implement adapter capabilities here
}

class BarrageUIManager(
    private val recyclerView: RecyclerView
) {
    private val capacity: Int = 500 // Only retain the latest 500 messages
    // ... (other code as above) ...

    private fun refreshUIIfNeeded() {
        val fullList = this.latestMessageList ?: return
        val adapter = recyclerView.adapter ?: return
        this.latestMessageList = null 

        // Only take the latest N messages
        val cappedList = fullList.takeLast(capacity)
        
        dataSource.clear()
        dataSource.addAll(cappedList)
        adapter.notifyDataSetChanged()
    }
}

import android.view.LayoutInflater
import androidx.asynclayoutinflater.view.AsyncLayoutInflater
import androidx.recyclerview.widget.RecyclerView

// In your custom Barrage ViewHolder
class BarrageViewHolder(
    itemView: View
) : RecyclerView.ViewHolder(itemView) {

    // ... (Declarations for TextView, ImageView, etc.)

    companion object {
        fun create(parent: ViewGroup): BarrageViewHolder {
            // Use async layout inflater to reduce main thread blocking
            val inflater = AsyncLayoutInflater(parent.context)
            val view = LayoutInflater.from(parent.context)
                .inflate(R.layout.item_barrage, parent, false)
            return BarrageViewHolder(view)
        }
    }

    fun bind(viewModel: BarrageViewModel) {
        // Set your TextView text, ImageView images, etc. here
        // With async layout inflation, final rendering is done on a background thread whenever possible
    }

    // Advanced performance optimization: fully manual drawing
    // For finer control, use Canvas to manually draw text and images
    // Generate the Bitmap on a background thread, then draw it in the main thread's onDraw method for fully asynchronous rendering
}