LiveKit Swift SDK

The SDK manages the internal audio engine through an AudioEngineObserver chain. You can customize this chain to manage AVAudioSession manually or provide custom lifecycle hooks.

• iOS, visionOS, tvOS default: [AudioManager.shared.audioSession, AudioManager.shared.mixer]
• macOS default: [AudioManager.shared.mixer]

If you want to manage AVAudioSession yourself on iOS/tvOS but keep the default mixer setup, keep the default observers and set isAutomaticConfigurationEnabled = false.

Warning: Configure the chain once early in app startup. Avoid changing it while the engine is in use. Setting an empty array [] disables all observers, including session handling and mixer setup.

// Default chain for iOS/visionOS/tvOS
AudioManager.shared.set(engineObservers: [AudioManager.shared.audioSession, AudioManager.shared.mixer])

// Default chain for macOS
AudioManager.shared.set(engineObservers: [AudioManager.shared.mixer])

LiveKit for Swift can be installed via Swift Package Manager (SPM) or CocoaPods. Swift Package Manager is the recommended method.

Swift Package Manager (SPM)

Via Package.swift Add the LiveKit dependency to your Package.swift file:

let package = Package(
  ...
  dependencies: [
    .package(name: "LiveKit", url: "https://github.com/livekit/client-sdk-swift.git", .upToNextMajor("2.16.0")),
  ],
  targets: [
    .target(
      name: "MyApp",
      dependencies: ["LiveKit"]
    )
  ]
)

Via Xcode UI

1. Go to Project Settings -> Swift Packages.
2. Add a new package using the URL: https://github.com/livekit/client-sdk-swift.

Pre-built XCFramework

For faster integration and CI builds, use the pre-compiled binary distribution. This bundles LiveKit.xcframework and its dependencies (LiveKitWebRTC, RustLiveKitUniFFI).

URL: https://github.com/livekit/client-sdk-swift-xcframework

CocoaPods

Note: CocoaPods support is deprecated and will become read-only in 2027. It is strongly recommended to migrate to Swift Package Manager.

To integrate with CallKit, you must coordinate the timing between AVAudioSession and the SDK's audio engine to prevent the engine from starting outside of CallKit's active window.

1. Initialization: As early as possible (before connecting to a Room), disable automatic configuration and set engine availability to .none:

   AudioManager.shared.audioSession.isAutomaticConfigurationEnabled = false
   try AudioManager.shared.setEngineAvailability(.none)

2. Coordination: In your CXProviderDelegate, manage the engine availability based on the session state:
   • In provider(_:didActivate:): Configure the session category and set engine availability to .default.
   • In provider(_:didDeactivate:): Set engine availability to .none.

// 1. Early setup
AudioManager.shared.audioSession.isAutomaticConfigurationEnabled = false
try AudioManager.shared.setEngineAvailability(.none)

// 2. In CXProviderDelegate
func provider(_: CXProvider, didActivate session: AVAudioSession) {
  do {
    try session.setCategory(.playAndRecord, mode: .voiceChat, options: [.mixWithOthers])
    try AudioManager.shared.setEngineAvailability(.default)
  } catch {
    // Handle error
  }
}

func provider(_: CXProvider, didDeactivate _: AVAudioSession) {
  do {
    try AudioManager.shared.setEngineAvailability(.none)
  } catch {
    // Handle error
  }
}

For apps that need to provide audio to a LiveKit room without requesting permission to use the physical microphone, you can use Manual Rendering Mode.

Warning: In manual mode, the audio engine does not access any audio devices. Remote audio will not be played automatically; you are responsible for handling audio playback yourself.

To set up manual mode:

1. Enable manual rendering mode via AudioManager.shared.setManualRenderingMode(true).
2. Enable the microphone track on the local participant (this enables the track in the room without triggering physical microphone access).
3. Continuously provide audio buffers using AudioManager.shared.mixer.capture(appAudio:).

// 1. Enable manual rendering mode
try AudioManager.shared.setManualRenderingMode(true)

// 2. Enable the microphone track (does not access physical hardware in manual mode)
try await room.localParticipant.setMicrophone(enabled: true)

// 3. Provide audio buffers continuously
AudioManager.shared.mixer.capture(appAudio: yourAudioBuffer)

By default, LiveKit automatically manages the AVAudioSession. It typically uses the .playback category and switches to .playAndRecord when a local track is published.

To take manual control of the AVAudioSession:

1. Disable automatic configuration: AudioManager.shared.audioSession.isAutomaticConfigurationEnabled = false
2. Ensure the session is configured with category .playAndRecord and mode .voiceChat or .videoChat before publishing the microphone.

Optimization Tips:

• Reduce Latency: To reduce microphone publishing latency, pre-warm the audio engine using: try await AudioManager.shared.setRecordingAlwaysPreparedMode(true).
• Custom Observers: You can provide a custom AudioEngineObserver chain via AudioManager.shared.set(engineObservers:) to monitor the audio engine lifecycle.

// Disable automatic configuration to manage AVAudioSession manually
AudioManager.shared.audioSession.isAutomaticConfigurationEnabled = false

// Pre-warm the engine to reduce mic publish latency
try await AudioManager.shared.setRecordingAlwaysPreparedMode(true)