ルーム管理

import Foundation
import AtomicXCore

func createAndJoinRoom() {
    // 1. Configure room creation parameters
    // CreateRoomOptions defines basic room properties and initial permissions
    var options = CreateRoomOptions()
    options.roomName = "Team Meeting Room"           // Room display name
    options.password = ""                            // Room password (optional)
    
    // 2. Preset room permissions
    options.isAllCameraDisabled = false              // Disable all member 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
    // Handles creation if room does not exist and joining logic
    RoomStore.shared.createAndJoinRoom(roomID: "roomID", roomType: .standard, options: options) { result in
        switch result {
        case .success():
            print("Room created and joined successfully")
        case .failure(let error):
            print("Failed to create and join room [Error Code: \(error.code)]: \(error.message)")
        }
    }
}

import Foundation
import AtomicXCore

func joinRoom() {
    // 1. Prepare join room parameters
    // joinRoom is used to join a known, ongoing room
    let roomPassword = "" // Room password. Pass empty string or nil if no password.
    
    // 2. Call RoomStore join room API
    // Verifies room existence, user access, and password correctness
    RoomStore.shared.joinRoom(roomID: "roomID", roomType: .standard, password: roomPassword) { result in
        switch result {
        case .success():
            print("Joined room successfully")
        case .failure(let error):
            print("Failed to join room [Error Code: \(error.code)]: \(error.message)")
        }
    }
}

import Foundation
import AtomicXCore

func leaveRoom() {
    // 1. Business logic
    // leaveRoom is for regular members or owners to voluntarily exit the room.
    // Unlike endRoom, if the owner calls leaveRoom, only they exit—the room remains active.
    
    // 2. Call RoomStore leave room API
    // Stops audio/video streams and notifies the server to remove the current user from the room
    RoomStore.shared.leaveRoom { result in
        switch result {
        case .success():
            print("Left room successfully")
        case .failure(let error):
            print("Failed to leave room [Error Code: \(error.code)]: \(error.message)")
        }
    }
}

import Foundation
import AtomicXCore

func endRoom() {
    // 1. Business logic
    // endRoom permanently dissolves the current room.
    // Note: This is usually restricted to the owner. After dissolution, all members are forcibly exited.
    
    // 2. Call RoomStore end room API
    // Sends a dissolution command to the server and notifies all online participants
    RoomStore.shared.endRoom { result in
        switch result {
        case .success():
            print("Room dissolved successfully")
        case .failure(let error):
            print("Failed to dissolve room [Error Code: \(error.code)]: \(error.message)")
        }
    }
}

import Foundation
import AtomicXCore

func updateRoomInfo() {
    // 1. Configure room update parameters
    // UpdateRoomOptions defines the properties to update
    var options = UpdateRoomOptions()
    options.roomName = "New Meeting Room Name"  // Update room display name
    
    // 2. Set modification flags
    // ModifyFlag specifies which fields to update
    var modifyFlag: UpdateRoomOptions.ModifyFlag = []
    modifyFlag.insert(.roomName)       // Flag to update room name
    
    // 3. Call RoomStore update room info API
    // Submits the update request to the server and synchronizes to all room 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

func getRoomInfo() {
    // 1. Business logic
    // getRoomInfo retrieves detailed information for a specified room,
    // including room name, creator, participant count, permission settings, and more.
    
    // 2. Call RoomStore get room info API
    // Fetches the latest room status and configuration from the server
    RoomStore.shared.getRoomInfo(roomID: "roomID") { result in
        switch result {
        case .success(let roomInfo):
            print("Room information retrieved successfully, roomInfo: \(roomInfo)")
        case .failure(let error):
            print("Failed to retrieve room information [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) // Ensure UI updates are handled on the 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) // Ensure UI updates are handled on the main thread
        .sink { roomInfo in
            if let newRoomInfo = roomInfo {
                print("Room information updated. New room info: \(newRoomInfo)")
            }
        }
        .store(in: &cancellableSet)
}