Room Management (iOS)

import Foundation
import AtomicXCore

private let roomID = "webinar_123456"
private let roomType = .webinar

func createAndJoinRoom() {
    // 1. Configure room creation parameters
    // CreateRoomOptions defines the room's basic properties and member management settings
    var options = CreateRoomOptions()
    options.roomName = "Team webinar"           // Room display name
    options.password = ""                   // Room password (optional)

    // 2. Set global room permissions
    options.isAllCameraDisabled = false     // Disable all members' cameras
    options.isAllMessageDisabled = false    // Mute all members
    options.isAllMicrophoneDisabled = false // Mute all microphones
    options.isAllScreenShareDisabled = false // Disable screen sharing for all members

    // 3. Create and join room
    // Automatically handles room creation (if needed) and joining logic
    RoomStore.shared.createAndJoinRoom(roomID: roomID, roomType: roomType, options: options) { result in
        switch result {
        case .success():
            print("Successfully created and joined the room")
        case .failure(let error):
            print("Failed to create and join the room [Error code: \(error.code)]: \(error.message)")
        }
    }
}

import Foundation
import AtomicXCore

private let roomID = "webinar_123456"
private let roomType = .webinar

func joinRoom() {
    // 1. Prepare join parameters
    // joinRoom is used to enter an existing room
    let roomPassword = "" // Room password, empty or nil if not set

    // 2. Call joinRoom API
    // This checks room existence, user ban status, and password correctness
    RoomStore.shared.joinRoom(roomID: roomID, roomType: roomType, password: roomPassword) { result in
        switch result {
        case .success():
            print("Successfully joined the room")
        case .failure(let error):
            print("Failed to join the room [Error code: \(error.code)]: \(error.message)")
        }
    }
}

import Foundation
import AtomicXCore

func leaveRoom() {
    // 1. Description
    // leaveRoom is for members or host to voluntarily exit the room
    // Unlike endRoom, when the host leaves, only they exit; the room persists

    // 2. Call leaveRoom API
    // Stops audio/video streams and removes the user from the room server-side
    RoomStore.shared.leaveRoom { result in
        switch result {
        case .success():
            print("Successfully left the room")
        case .failure(let error):
            print("Failed to leave the room [Error code: \(error.code)]: \(error.message)")
        }
    }
}

import Foundation
import AtomicXCore

func endRoom() {
    // 1. Description
    // endRoom permanently dissolves the current room
    // Typically called only by the host. All members are removed after dissolution

    // 2. Call endRoom API
    // Sends the dissolve command to the server and notifies all participants
    RoomStore.shared.endRoom { result in
        switch result {
        case .success():
            print("Room ended successfully")
        case .failure(let error):
            print("Failed to end room [Error code: \(error.code)]: \(error.message)")
        }
    }
}

import Foundation
import AtomicXCore

private let roomID = "webinar_123456"

func updateRoomInfo() {
    // 1. Configure update parameters
    // UpdateRoomOptions defines which room properties to update
    var options = UpdateRoomOptions()
    options.roomName = "webinar room"  // New room display name

    // 2. Set modify flags
    // ModifyFlag specifies fields to update
    var modifyFlag: UpdateRoomOptions.ModifyFlag = []
    modifyFlag.insert(.roomName)       // Mark roomName for update

    // 3. Call updateRoomInfo API
    // Sends update request to the server and syncs changes to all members
    RoomStore.shared.updateRoomInfo(roomID: roomID, options: options, modifyFlag: modifyFlag) { result in
        switch result {
        case .success():
            print("Room information updated successfully")
        case .failure(let error):
            print("Failed to update room information [Error code: \(error.code)]: \(error.message)")
        }
    }
}

import Foundation
import AtomicXCore

private let roomID = "webinar_123456"

func getRoomInfo() {
    // 1. Description
    // getRoomInfo fetches detailed info for a specified room
    // Includes room name, creator, participant count, permissions, etc.

    // 2. Call getRoomInfo API
    // Fetches the latest room state/configuration from the server
    RoomStore.shared.getRoomInfo(roomID: roomID) { result in
        switch result {
        case .success(let roomInfo):
            print("Successfully retrieved room info, roomInfo: \(roomInfo)")
        case .failure(let error):
            print("Failed to retrieve room info [Error code: \(error.code)]: \(error.message)")
        }
    }
}

import Foundation
import AtomicXCore
import Combine

private var cancellableSet = Set<AnyCancellable>()

/// Set up room event listener
private func subscribeRoomEvent() {
    RoomStore.shared.roomEventPublisher
        .receive(on: DispatchQueue.main) // UI updates on main thread
        .sink { event in
            switch event {
            case .onRoomEnded(let roomInfo):
                print("The current room has ended")
            default: break
            }
        }
        .store(in: &cancellableSet)
}

import Foundation
import AtomicXCore
import Combine

private var cancellableSet = Set<AnyCancellable>()

private func subscribeRoomState() {
    /// Set up current room state listener
    RoomStore.shared.state
        .subscribe(StatePublisherSelector(keyPath: \.currentRoom))
        .receive(on: DispatchQueue.main) // UI updates on main thread
        .sink { roomInfo in
            if let newRoomInfo = roomInfo {
                print("Room info updated. New room info: \(newRoomInfo)")
            }
        }
        .store(in: &cancellableSet)
}