Voice Chat Room

import AtomicXCore

//  AppDelegate.swift
func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?) -> Bool {
    LoginStore.shared.login(sdkAppID: 1400000001,                  // Replace with your SDKAppID
                            userID: "test_001",                    // Replace with your UserID
                            userSig: "xxxxxxxxxxx") { result in    // Replace with your UserSig
      switch result {
        case .success(let info):
        debugPrint("login success")
        case .failure(let error):
        debugPrint("login failed code:\(error.code), message:\(error.message)")
      }
    }
    return true
}

import UIKit
import AtomicXCore
import Combine

class YourAnchorViewController: UIViewController {

    private let liveListStore = LiveListStore.shared
    private let deviceStore = DeviceStore.shared

    // Initialize LiveSeatStore with liveID
    private let liveID = "test_voice_room_001"
    private lazy var liveSeatStore = LiveSeatStore.create(liveID: liveID)

    // Manage subscription lifecycle
    private var cancellables = Set<AnyCancellable>()

    override func viewDidLoad() {
        super.viewDidLoad()
        // Initialize your layout here
        // setupUI() 

        // Listen for seat list changes
        observeSeatList()
    }

    private func observeSeatList() {
        // Subscribe to seat list updates and refresh seat UI
        liveSeatStore.state
            .subscribe(StatePublisherSelector(keyPath: \LiveSeatState.seatList))
            .removeDuplicates()
            .receive(on: DispatchQueue.main)
            .sink { [weak self] seatInfoList in
                // Update seat UI with seatInfoList
                // Example: self?.updateMicSeatView(seatInfoList)
                print("Seat list updated: \(seatInfoList.count) seats")
            }
            .store(in: &cancellables)
    }
}

import UIKit
import AtomicXCore

class YourAnchorViewController: UIViewController {
    // ... other code ...

    private func openDevices() {
        DeviceStore.shared.openLocalMicrophone(completion: nil)
    }
}

import UIKit
import AtomicXCore

class YourAnchorViewController: UIViewController {
    // ... other code ...
    private let liveID = "test_voice_room_001"
    
    override func viewDidLoad() {
        super.viewDidLoad()
        // ... other code ...

        // Start voice chat
        startLive()
    }

    private func startLive() {
        var liveInfo = LiveInfo()

        liveInfo.liveID = liveID
        liveInfo.liveName = "test voice chat room"
        liveInfo.isSeatEnabled = true
        liveInfo.keepOwnerOnSeat = true
        liveInfo.seatLayoutTemplateID = 70 // Use correct ID per product spec
        liveInfo.seatMode = .apply
        liveInfo.maxSeatCount = 10

        liveListStore.createLive(liveInfo) { [weak self] result in
            guard let self = self else { return }
            switch result {
            case .success(let liveInfo):
                print("Response startLive onSuccess")
                // Host is on seat by default; unmute microphone if needed
                liveSeatStore.unmuteMicrophone(completion: nil)
            case .failure(let errorInfo):
                print("Response startLive onError: \(errorInfo.message)")
            }
        }
    }
}

import UIKit
import AtomicXCore
import Combine

class YourAnchorViewController: UIViewController {
    // ... other code ...
    private var cancellables = Set<AnyCancellable>()
    private lazy var liveSeatStore = LiveSeatStore.create(liveID: "your_live_id")

    override func viewDidLoad() {
        super.viewDidLoad()
        // ... other code ...

        observeSeatList()
    }

    private func observeSeatList() {
        liveSeatStore.state
            .subscribe(StatePublisherSelector(keyPath: \LiveSeatState.seatList))
            .removeDuplicates()
            .receive(on: DispatchQueue.main)
            .sink { [weak self] seatInfoList in
                // seatInfoList contains the latest seat data
                print("Seat list updated: \(seatInfoList.count) seats")
            }
            .store(in: &cancellables)
    }
}

import UIKit
import AtomicXCore
import RTCRoomEngine

class YourAnchorViewController: UIViewController {
    // ... other code ...

    private func stopLive() {
        liveListStore.endLive { result in
            switch result {
            case .success(let data):
                print("endLive success")
            case .failure(let errorInfo):
                print("endLive error: \(errorInfo.message)")
            }
        }
    }
}

import UIKit
import AtomicXCore
import Combine

class YourAudienceViewController: UIViewController {

    private let liveListStore = LiveListStore.shared

    // Use the same liveID as the host
    private let liveID = "test_voice_room_001" 
    private lazy var liveSeatStore = LiveSeatStore.create(liveID: liveID)

    private var cancellables = Set<AnyCancellable>()

    override func viewDidLoad() {
        super.viewDidLoad()
        // Initialize your layout here
        // setupUI()

        observeSeatList()
    }

    private func observeSeatList() {
        liveSeatStore.state
            .subscribe(StatePublisherSelector(keyPath: \LiveSeatState.seatList))
            .removeDuplicates()
            .receive(on: DispatchQueue.main)
            .sink { [weak self] seatInfoList in
                // Update seat UI with seatInfoList
                // Example: self?.updateMicSeatView(seatInfoList)
                print("AudienceVC Seat list updated: \(seatInfoList.count) seats")
            }
            .store(in: &cancellables)
    }
}

import UIKit
import AtomicXCore

class YourAudienceViewController: UIViewController {

    // ... other code ...
    override func viewDidLoad() {
        super.viewDidLoad()
        // ... other code ...

        joinLive()
    }

    private func joinLive() {
        liveListStore.joinLive(liveID: liveID) { result in
            DispatchQueue.main.async {
                switch result {
                case .success(let liveInfo):
                    print("joinLive success")
                case .failure(let errorInfo):
                    print("joinLive error: \(errorInfo.message)")
                }
            }
        }
    }
}

import UIKit
import AtomicXCore

class YourAudienceViewController: UIViewController {
    // ... other code ...
    
    private func leaveLive() {
        liveListStore.leaveLive { result in
            switch result {
            case .success:
                print("leaveLive success")
            case .failure(let errorInfo):
                print("leaveLive error: \(errorInfo.message)")
            }
        }
    }
}

import UIKit
import AtomicXCore
import Combine

class YourAnchorViewController: UIViewController {
    // ... (other code omitted) ...
    private var cancellables = Set<AnyCancellable>()

    override func viewDidLoad() {
        super.viewDidLoad()
        // ... (other code omitted) ...

        observeSpeakingUsersState()
    }

    private func observeSpeakingUsersState() {
        liveSeatStore.state           
            .subscribe(StatePublisherSelector(keyPath: \LiveSeatState.speakingUsers))
            .removeDuplicates()
            .receive(on: DispatchQueue.main)
            .sink { [weak self] speakingUserMap in
                // Update UI to indicate which users are speaking
                print("Speaking users updated: \(speakingUserMap.count) users")
            }
            .store(in: &cancellables)
    }
}

import AtomicXCore
import Combine

// 1. Define a background music model (recommended: Codable)
struct MusicModel: Codable {
    let musicId: String
    let musicName: String
}

// 2. Host side: Push background music info
func updateBackgroundMusic(music: MusicModel) {
    guard let jsonData = try? JSONEncoder().encode(music),
          let jsonString = String(data: jsonData, encoding: .utf8) else { return }

    let metaData = ["music_info": jsonString]

    LiveListStore.shared.updateLiveMetaData(metaData) { result in
        if case .success = result {
            print("Background music \(music.musicName) pushed successfully")
        } else if case .failure(let error) = result {
            print("Background music push failed: \(error.message)")
        }
    }
}

// 3. Audience side: Subscribe and update business logic
private func subscribeToDataUpdates() {
    LiveListStore.shared.state
        // Listen for metaData changes in the current room
        .subscribe(StatePublisherSelector(keyPath: \LiveListState.currentLive))
        .map { $0.metaData["music_info"] }
        .removeDuplicates()
        .receive(on: DispatchQueue.main)
        .sink { jsonString in
            guard let jsonString = jsonString,
                  let data = jsonString.data(using: .utf8),
                  let music = try? JSONDecoder().decode(MusicModel.self, from: data) else {
                return
            }
            // Update business state, play new music
            // ... (e.g.: playMusic(music))
        }
        .store(in: &cancellables)
}