Live Battles

import AtomicXCore
import Combine

// Host A's view controller
class AnchorAViewController {
    private let liveId = "Host A's Room ID"
    private var cancellables: Set<AnyCancellable> = []
    private lazy var coHostStore: CoHostStore = {
        return CoHostStore.create(liveID: self.liveId)
    }()

    // User clicks the "Co-host" button and selects Host B
    func inviteHostB(targetHostLiveId: String) {
        let layout: CoHostLayoutTemplate = .hostDynamicGrid // Choose a layout template
        let timeout: TimeInterval = 30.0 // Invitation timeout

        coHostStore.requestHostConnection(targetHost: targetHostLiveId,
                                          layoutTemplate: layout,
                                          timeout: timeout) { result in
            switch result {
            case .success():
                print("Co-hosting invitation sent, waiting for response...")
            case .failure(let error):
                print("Failed to send invitation: \(error.message)")
            }
        }
    }
}

// Set up listener during AnchorAViewController initialization
func setupListeners() {
    coHostStore.coHostEventPublisher
        .sink { [weak self] event in
            switch event {
            case .onCoHostRequestAccepted(let invitee):
                print("Host \(invitee.userName) accepted your co-hosting invitation")
            case .onCoHostRequestRejected(let invitee):
                print("Host \(invitee.userName) rejected your invitation")
            case .onCoHostRequestTimeout:
                print("Invitation timed out, no response from the other party")
            default:
                break
            }
        }
        .store(in: &cancellables)
}

import AtomicXCore
import Combine

// Host B's view controller
class AnchorBViewController {
    // ... coHostStore and cancellables initialization ...

    // Set up listener during initialization
    func setupListeners() {
        coHostStore.coHostEventPublisher
            .sink { [weak self] event in
                if case let .onCoHostRequestReceived(inviter, _) = event {
                    print("Received co-hosting invitation from host \(inviter.userName)")
                    // self?.showInvitationDialog(from: inviter)
                }
            }
            .store(in: &cancellables)
    }
}

// Part of AnchorBViewController
func acceptInvitation(fromHostLiveId: String) {
    coHostStore.acceptHostConnection(fromHostLiveID: fromHostLiveId, completion: nil)
}

func rejectInvitation(fromHostLiveId: String) {
    coHostStore.rejectHostConnection(fromHostLiveID: fromHostLiveId, completion: nil)
}

// Part of AnchorAViewController
private lazy var battleStore: BattleStore = BattleStore.create(liveID: self.liveId)

func startPK(with opponentUserId: String) {
    var config = BattleConfig(duration: 300) // PK lasts 5 minutes
    battleStore.requestBattle(config: config, userIDList: [opponentUserId], timeout: 30.0, completion: nil)
}

// Add to AnchorAViewController's setupListeners method
battleStore.battleEventPublisher
    .sink { [weak self] event in
        switch event {
        case .onBattleStarted:
            print("PK started")
        case .onBattleEnded:
            print("PK ended")
        default:
            break
        }
    }
    .store(in: &cancellables)

// Add to AnchorBViewController's setupListeners method
battleStore.battleEventPublisher
    .sink { [weak self] event in
        if case let .onBattleRequestReceived(battleId, inviter, _) = event {
            print("Received PK challenge from host \(inviter.userName)")
            // Show dialog for Host B to choose "Accept" or "Reject"
            // self?.showPKChallengeDialog(battleId: battleId)
        }
    }
    .store(in: &cancellables)

// Part of AnchorBViewController
// User clicks "Accept Challenge"
func acceptPK(battleId: String) {
    battleStore.acceptBattle(battleID: battleId) { result in
        // ...
    }
}

// User clicks "Reject Challenge"
func rejectPK(battleId: String) {
    battleStore.rejectBattle(battleID: battleId) { result in
        // ...
    }
}

func stopPK(battleId: String) {
    battleStore.exitBattle(battleID: battleId) { result in
        switch result {
        case .success:
            print("PK ended")
            // UI receives onBattleEnded event; refresh UI in callback
        case .failure(let error):
            print("Failed to end PK: \(error.message)")
        }
    }
}

func stopConnection() {
    coHostStore.exitHostConnection { result in
        switch result {
        case .success:
            print("Co-hosting disconnected, back to solo live")
            // UI receives onCoHostUserLeft event
        case .failure(let error):
            print("Failed to disconnect co-hosting: \(error.message)")
        }
    }
}

func setupAdditionalListeners() {
    // Listen for PK end event
    battleStore.battleEventPublisher
        .sink { [weak self] event in
            if case .onBattleEnded(let battleInfo, let reason) = event {
                print("Received PK end event, reason: \(reason)")
                // self?.removeBattleUI()
            }
        }
        .store(in: &cancellables)

    // Listen for co-host disconnect event
    coHostStore.coHostEventPublisher
        .sink { [weak self] event in
            if case .onCoHostUserLeft(let userInfo) = event {
                print("Anchor \(userInfo.userName) has left co-hosting")
                // self?.resetToSingleStreamLayout()
            }
        }
        .store(in: &cancellables)
}

import UIKit
import SnapKit

// Custom floating user info view (foreground)
class CustomSeatView: UIView {
   lazy var nameLabel: UILabel = {
        let label = UILabel()
        label.textColor = .white
        label.font = .systemFont(ofSize: 14)
        return label
    }()

    override init(frame: CGRect) {
        super.init(frame: frame)
        backgroundColor = UIColor.black.withAlphaComponent(0.5)
        addSubview(nameLabel)
        nameLabel.snp.makeConstraints { make in
            make.bottom.equalToSuperview().offset(-5)
            make.leading.equalToSuperview().offset(5)
        }
    }
}

import UIKit
import SnapKit

// Custom avatar placeholder view (background)
class CustomAvatarView: UIView {
    lazy var avatarImageView: UIImageView = {
        let imageView = UIImageView()
        imageView.tintColor = .gray
        return imageView
    }()

    override init(frame: CGRect) {
        super.init(frame: frame)
        backgroundColor = .clear
        layer.cornerRadius = 30
        addSubview(avatarImageView)
        avatarImageView.snp.makeConstraints { make in
            make.center.equalToSuperview()
            make.width.height.equalTo(60)
        }
    }
}

import AtomicXCore
import RTCRoomEngine

// 1. In your view controller, conform to the VideoViewDelegate protocol
class YourViewController: UIViewController, VideoViewDelegate {

    // ... other code ...

    // 2. Fully implement the protocol method, handling both viewLayer types
    func createCoHostView(seatInfo: TUISeatFullInfo, viewLayer: ViewLayer) -> UIView? {
        guard let userId = seatInfo.userId, !userId.isEmpty else {
            return nil
        }
        if viewLayer == .foreground {
            let seatView = CustomSeatView()
            seatView.nameLabel.text = seatInfo.userName
            return seatView
        } else { // viewLayer == .background
            let avatarView = CustomAvatarView()
            // Optionally load the user's avatar using seatInfo.userAvatar
            return avatarView
        }
    }
}

import AtomicXCore
import RTCRoomEngine
import SnapKit

// Custom PK user view
class CustomBattleUserView: UIView {
    private let scoreView: UIView = {
        let view = UIView()
        view.backgroundColor = .black.withAlphaComponent(0.4)
        view.layer.cornerRadius = 12
        return view
    }()

    private lazy var scoreLabel: UILabel = {
        let label = UILabel()
        label.textColor = .white
        label.font = .systemFont(ofSize: 14, weight: .bold)
        return label
    }()

    private var userId: String
    private let battleStore: BattleStore
    private var cancellableSet: Set<AnyCancellable> = []

    init(liveId: String, battleUser: TUIBattleUser) {
        self.userId = battleUser.userId
        self.battleStore = BattleStore.create(liveID: liveId)
        super.init(frame: .zero)
        backgroundColor = .clear
        isUserInteractionEnabled = false
        setupUI()
        subscribeBattleState()
    }

    private func setupUI() {
        addSubview(scoreView)
        scoreView.addSubview(scoreLabel)
        scoreLabel.snp.makeConstraints { make in
            make.leading.trailing.equalToSuperview().inset(5)
        }
        scoreView.snp.makeConstraints { make in
            make.height.equalTo(24)
            make.bottom.equalToSuperview().offset(-5)
            make.trailing.equalToSuperview().offset(-5)
        }
    }

    // Subscribe to PK score changes
    private func subscribeBattleState() {
        battleStore.state
            .subscribe(StatePublisherSelector(keyPath: \BattleState.battleScore))
            .removeDuplicates()
            .receive(on: RunLoop.main)
            .sink { battleScore in
                guard let score = battleScore[self.userId] else { return }
                self.scoreLabel.text = "\(score)"
            }
            .store(in: &cancellableSet)
    }
}

// 1. Let your view controller conform to the VideoViewDelegate protocol
extension YourViewController: VideoViewDelegate {

    public func createBattleView(battleUser: TUIBattleUser) -> UIView? {
        // CustomBattleUserView is your custom PK user info view
        let customView = CustomBattleUserView(liveId: liveId, battleUser: battleUser)
        return customView
    }

}

// Let your view controller conform to the VideoViewDelegate protocol and set the delegate
extension YourViewController: VideoViewDelegate {
    func createBattleContainerView() -> UIView? {
        return CustomBattleContainerView()
    }
}