Room Management (Android)

import android.util.Log
import io.trtc.tuikit.atomicxcore.api.CompletionHandler
import io.trtc.tuikit.atomicxcore.api.room.CreateRoomOptions
import io.trtc.tuikit.atomicxcore.api.room.RoomStore
import io.trtc.tuikit.atomicxcore.api.room.RoomType

private val roomID = "webinar_123456"
private val roomType = RoomType.WEBINAR

fun createAndJoinRoom() {
    // 1. Configure room creation parameters
    // CreateRoomOptions defines basic room attributes and member management settings
    val options = CreateRoomOptions(
        roomName = "Team Meeting Room",           // Room display name
        // 2. Set initial room permission controls
        isAllCameraDisabled = false,       // Disable all members' cameras
        isAllMessageDisabled = false,      // Mute all members
        isAllMicrophoneDisabled = false,   // Mute all members
        isAllScreenShareDisabled = false   // Disable screen sharing for all members
    )

    // 3. Call RoomStore to create and join the room
    // This method automatically handles room creation (if it doesn't exist) and joining logic
    RoomStore.shared().createAndJoinRoom(roomID, roomType, options, object : CompletionHandler {
        override fun onSuccess() {
            Log.d("Room", "Room created and joined successfully")
        }

        override fun onFailure(code: Int, desc: String) {
            Log.e("Room", "Failed to create and join room [Error code: $code]: $desc")
        }
    })
}

import android.util.Log
import io.trtc.tuikit.atomicxcore.api.CompletionHandler
import io.trtc.tuikit.atomicxcore.api.room.RoomStore
import io.trtc.tuikit.atomicxcore.api.room.RoomType

private val roomID = "webinar_123456"
private val roomType = RoomType.WEBINAR

fun joinRoom() {
    // 1. Prepare parameters for joining the room
    // joinRoom is used to join a known and ongoing room

    // 2. Call RoomStore to join the room
    RoomStore.shared().joinRoom(roomID, roomType, completion = object : CompletionHandler {
        override fun onSuccess() {
            Log.d("Room", "Joined room successfully")
        }

        override fun onFailure(code: Int, desc: String) {
            Log.e("Room", "Failed to join room [Error code: $code]: $desc")
        }
    })
}

import android.util.Log
import io.trtc.tuikit.atomicxcore.api.room.RoomStore
import io.trtc.tuikit.atomicxcore.api.CompletionHandler

fun leaveRoom() {
    // 1. Business logic description
    // leaveRoom is used for regular members or hosts to voluntarily exit the room
    // Unlike endRoom, when the host calls leaveRoom, only they leave; the room remains active

    // 2. Call RoomStore to leave the room
    // This operation stops audio/video streams and notifies the server to remove the current user from the room
    RoomStore.shared().leaveRoom(object : CompletionHandler {
        override fun onSuccess() {
            Log.d("Room", "Left room successfully")
        }

        override fun onFailure(code: Int, desc: String) {
            Log.e("Room", "Failed to leave room [Error code: $code]: $desc")
        }
    })
}

import android.util.Log
import io.trtc.tuikit.atomicxcore.api.CompletionHandler
import io.trtc.tuikit.atomicxcore.api.room.RoomStore

fun endRoom() {
    // 1. Business logic description
    // endRoom is used to permanently dissolve the current room
    // Note: This operation is typically restricted to the host (Owner); after dissolution, all members are forcibly removed

    // 2. Call RoomStore to dissolve the room
    // This method sends a dissolution command to the server and notifies all online members that the room has ended
    RoomStore.shared().endRoom(object : CompletionHandler {
        override fun onSuccess() {
            Log.d("Room", "Room dissolved successfully")
        }

        override fun onFailure(code: Int, desc: String) {
            Log.e("Room", "Failed to dissolve room [Error code: $code]: $desc")
        }
    })
}

import android.util.Log
import io.trtc.tuikit.atomicxcore.api.room.RoomStore
import io.trtc.tuikit.atomicxcore.api.room.UpdateRoomOptions
import io.trtc.tuikit.atomicxcore.api.CompletionHandler

private val roomID = "webinar_123456"

fun updateRoomInfo() {
    // 1. Configure room update parameters
    // UpdateRoomOptions is used to define which room attributes to update
    val options = UpdateRoomOptions(
        roomName = "New Webinar Name"     // Update room display name
    )

    // 2. Set modification flags
    // modifyFlagList specifies which fields to update, supports combining multiple flags
    val modifyFlagList = listOf(UpdateRoomOptions.ModifyFlag.ROOM_NAME)

    // 3. Call RoomStore to update room information
    // This method submits the update request to the server and synchronizes it to all room members
    RoomStore.shared().updateRoomInfo(roomID, options, modifyFlagList, object : CompletionHandler {
        override fun onSuccess() {
            Log.d("Room", "Room information updated successfully")
        }

        override fun onFailure(code: Int, desc: String) {
            Log.e("Room", "Failed to update room information [Error code: $code]: $desc")
        }
    })
}

import android.util.Log
import io.trtc.tuikit.atomicxcore.api.room.RoomStore
import io.trtc.tuikit.atomicxcore.api.room.RoomInfo
import io.trtc.tuikit.atomicxcore.api.room.GetRoomInfoCompletionHandler

private val roomID = "webinar_123456"

fun getRoomInfo() {
    // 1. Business logic description
    // getRoomInfo is used to retrieve detailed information for a specified room
    // You can get the room name, creator, permission settings, and other complete information

    // 2. Call RoomStore to get room information
    // This operation fetches the latest room status and configuration from the server
    RoomStore.shared().getRoomInfo(roomID, object : GetRoomInfoCompletionHandler {
        override fun onSuccess(roomInfo: RoomInfo) {
            Log.d("Room", "Room information retrieved successfully, roomInfo: $roomInfo")
        }

        override fun onFailure(code: Int, desc: String) {
            Log.e("Room", "Failed to retrieve room information [Error code: $code]: $desc")
        }
    })
}

import android.content.Context
import android.util.AttributeSet
import android.util.Log
import android.widget.FrameLayout
import io.trtc.tuikit.atomicxcore.api.room.RoomInfo
import io.trtc.tuikit.atomicxcore.api.room.RoomListener
import io.trtc.tuikit.atomicxcore.api.room.RoomStore

class RoomMainView @JvmOverloads constructor(
    context: Context,
    attrs: AttributeSet? = null,
    defStyleAttr: Int = 0
) : FrameLayout(context, attrs, defStyleAttr) {

    // Room event listener
    private val roomListener = object : RoomListener() {
        override fun onRoomEnded(roomInfo: RoomInfo) {
            Log.d("Room", "The current room has ended")
            // Recommended action: Close the current page and return to the previous screen
        }
    }

    override fun onAttachedToWindow() {
        super.onAttachedToWindow()
        // Add room event listener
        RoomStore.shared().addRoomListener(roomListener)
    }

    override fun onDetachedFromWindow() {
        super.onDetachedFromWindow()
        // Remove listener to prevent memory leaks
        RoomStore.shared().removeRoomListener(roomListener)
    }
}

import android.util.Log
import io.trtc.tuikit.atomicxcore.api.room.RoomStore
import kotlinx.coroutines.CoroutineScope
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.launch

// Subscribe to changes in the current room information
private fun subscribeCurrentRoomState() {
    CoroutineScope(Dispatchers.Main).launch {
        RoomStore.shared().state.currentRoom.collect { roomInfo ->
            Log.d("Room", "Room information updated, new room info: $roomInfo")
        }
    }
}