visionOS

import LiveKit
import UIKit

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

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

videoView.renderMode = .sampleBuffer // Recommended for visionOS

// Control how video fits within the view
videoView.layoutMode = .fit // .fit recommended for spatial layouts

// Mirror video
videoView.mirrorMode = .auto

import AVFoundation

// The Persona camera is available as systemPreferredCamera
if let personaCamera = AVCaptureDevice.systemPreferredCamera {
    print("Persona camera available: \(personaCamera.localizedName)")
    
    let options = CameraCaptureOptions(
        dimensions: .h720_169,
        fps: 30
    )
    
    try await room.localParticipant.setCamera(
        enabled: true,
        captureOptions: options
    )
}

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

// On visionOS, this typically returns [systemPreferredCamera]
for device in devices {
    print("Camera: \(device.localizedName)")
}

#elseif os(visionOS)
// For visionOS, there is no DiscoverySession so return the Persona camera if available.
let devices: [AVCaptureDevice] = [.systemPreferredCamera].compactMap { $0 }

import AVFoundation

// Audio session configuration for visionOS
let session = AVAudioSession.sharedInstance()
try session.setCategory(.playAndRecord, mode: .videoChat, options: [.mixWithOthers])
try session.setActive(true)

// Automatic configuration (default)
AudioManager.shared.audioSession.isAutomaticConfigurationEnabled = true

// Manual configuration
AudioManager.shared.audioSession.isAutomaticConfigurationEnabled = false
let session = AVAudioSession.sharedInstance()
try session.setCategory(.playAndRecord, mode: .videoChat)
try session.setActive(true)

// Enable microphone
try await room.localParticipant.setMicrophone(enabled: true)

// Custom audio settings
let audioOptions = AudioCaptureOptions(
    echoCancellation: true,
    noiseSuppression: true
)

import SwiftUI
import LiveKit

struct SpatialVideoView: View {
    @StateObject var room = Room()
    @State private var participants: [RemoteParticipant] = []

    var body: some View {
        ZStack {
            // Background
            Color.black.ignoresSafeArea()
            
            // Participant videos in spatial layout
            HStack(spacing: 20) {
                ForEach(participants, id: \.sid) { participant in
                    if let videoTrack = participant.videoTracks.first?.track {
                        SwiftUIVideoView(videoTrack)
                            .frame(width: 400, height: 300)
                            .cornerRadius(12)
                    }
                }
            }
        }
        .onAppear {
            Task {
                try await room.connect(url: url, token: token)
                participants = Array(room.remoteParticipants.values)
            }
        }
    }
}

import SwiftUI

@main
struct MyVisionApp: App {
    var body: some Scene {
        WindowGroup {
            ContentView()
        }
        
        // Volumetric window for immersive video
        WindowGroup(id: "videoCall") {
            SpatialVideoView()
        }
        .windowStyle(.volumetric)
        .defaultSize(width: 800, height: 600, depth: 400, in: .points)
    }
}

import SwiftUI
import RealityKit

struct ImmersiveVideoSpace: View {
    @StateObject var room = Room()
    
    var body: some View {
        RealityView { content in
            // Add 3D content with video textures
        }
        .onAppear {
            Task {
                try await room.connect(url: url, token: token)
            }
        }
    }
}

// Register immersive space
@main
struct MyVisionApp: App {
    var body: some Scene {
        ImmersiveSpace(id: "videoSpace") {
            ImmersiveVideoSpace()
        }
    }
}

// Send data
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: \(data.count) bytes")
}

<key>NSCameraUsageDescription</key>
<string>This app needs camera access to show your Persona in video calls</string>

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

import AVFoundation

// Request camera permission (Persona)
let cameraStatus = AVCaptureDevice.authorizationStatus(for: .video)
if cameraStatus == .notDetermined {
    let granted = await AVCaptureDevice.requestAccess(for: .video)
    print("Camera permission: \(granted)")
}

// Request microphone permission
let micStatus = AVCaptureDevice.authorizationStatus(for: .audio)
if micStatus == .notDetermined {
    let granted = await AVCaptureDevice.requestAccess(for: .audio)
    print("Microphone permission: \(granted)")
}

// Screen sharing may work differently on visionOS
// Check availability first
do {
    try await room.localParticipant.setScreenShare(enabled: true)
} catch {
    print("Screen sharing not available: \(error)")
}

// WebSocket connections work normally
try await room.connect(url: url, token: token)

// Network quality monitoring
func room(_: Room, participant: RemoteParticipant, didUpdateConnectionQuality quality: ConnectionQuality) {
    print("Connection quality: \(quality)")
}

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

# List available simulators
xcrun simctl list devices visionOS

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

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