tvOS

import LiveKit
import UIKit

class RoomViewController: UIViewController {
    lazy var videoView: VideoView = {
        let videoView = VideoView()
        view.addSubview(videoView)
        videoView.layoutMode = .fill
        return videoView
    }()

    override func viewDidLoad() {
        super.viewDidLoad()
        
        Task {
            try await connectToRoom()
        }
    }

    func connectToRoom() async throws {
        let room = Room(delegate: self)
        try await room.connect(url: url, token: token)
    }
}

extension RoomViewController: RoomDelegate {
    func room(_: Room, participant: RemoteParticipant, didSubscribeTrack publication: RemoteTrackPublication) {
        guard let track = publication.track as? VideoTrack else { return }
        
        DispatchQueue.main.async {
            self.videoView.track = track
        }
    }
}

videoView.renderMode = .metal // or .sampleBuffer

// Control how video fits within the view
videoView.layoutMode = .fill // .fill or .fit

// Mirror video if needed
videoView.mirrorMode = .auto // .auto, .mirror, or .off

import AVFoundation

// Check for available cameras
let devices = try await CameraCapturer.captureDevices()

if !devices.isEmpty {
    // External camera is available
    let options = CameraCaptureOptions(
        dimensions: .h720_169,
        fps: 30
    )
    
    try await room.localParticipant.setCamera(
        enabled: true,
        captureOptions: options
    )
} else {
    print("No camera devices available on tvOS")
}

if let cameraCapturer = cameraTrack?.capturer as? CameraCapturer {
    if cameraCapturer.isMultitaskingAccessSupported {
        cameraCapturer.isMultitaskingAccessEnabled = true
    }
}

// Audio tracks are automatically played when subscribed
func room(_: Room, participant: RemoteParticipant, didSubscribeTrack publication: RemoteTrackPublication) {
    if publication.kind == .audio {
        print("Subscribed to audio track: \(publication.sid)")
        // Audio will play automatically
    }
}

import AVFoundation

// Audio session is automatically managed by the SDK
// For manual control:
AudioManager.shared.audioSession.isAutomaticConfigurationEnabled = false

// Configure manually
let session = AVAudioSession.sharedInstance()
try session.setCategory(.playback, mode: .default)
try session.setActive(true)

// Attempt to enable microphone (may fail if no hardware available)
do {
    try await room.localParticipant.setMicrophone(enabled: true)
} catch {
    print("Microphone not available: \(error)")
}

// Send data to all participants
try await room.localParticipant.publish(data: data, options: DataPublishOptions(
    reliable: true
))

// Receive data
func room(_: Room, participant: RemoteParticipant, didReceiveData data: Data, forTopic topic: String) {
    print("Received data from \(participant.identity): \(data.count) bytes")
}

<key>NSCameraUsageDescription</key>
<string>This app needs camera access for video calls</string>

<key>NSMicrophoneUsageDescription</key>
<string>This app needs microphone access for audio calls</string>

import SwiftUI
import LiveKit

struct VideoCallView: View {
    @StateObject var room = Room()

    var body: some View {
        ZStack {
            Color.black.ignoresSafeArea()
            
            if let videoTrack = room.remoteParticipants.first?.videoTracks.first?.track {
                SwiftUIVideoView(videoTrack)
                    .aspectRatio(16/9, contentMode: .fit)
            } else {
                Text("Waiting for video...")
                    .foregroundColor(.white)
            }
        }
        .onAppear {
            Task {
                try await room.connect(url: url, token: token)
            }
        }
    }
}

import UIKit

class ParticipantCell: UICollectionViewCell {
    let videoView = VideoView()
    
    override var canBecomeFocused: Bool {
        return true
    }
    
    override func didUpdateFocus(in context: UIFocusUpdateContext, with coordinator: UIFocusAnimationCoordinator) {
        super.didUpdateFocus(in: context, with: coordinator)
        
        coordinator.addCoordinatedAnimations({
            if self.isFocused {
                self.transform = CGAffineTransform(scaleX: 1.1, y: 1.1)
            } else {
                self.transform = .identity
            }
        }, completion: nil)
    }
}

# Build for tvOS Simulator
xcodebuild build -scheme LiveKit -destination 'platform=tvOS Simulator'

# Run tests
xcodebuild test -scheme LiveKit -only-testing LiveKitCoreTests -destination 'platform=tvOS Simulator'

# List available simulators
xcrun simctl list devices tvOS

// Correct: Update VideoView on main thread
DispatchQueue.main.async {
    videoView.track = track
}

// Or use MainActor
Task { @MainActor in
    videoView.track = track
}