LiveKit Flutter SDK

Certificate pinning is available on native platforms via RoomOptions.networkOptions. It applies to SDK-owned WSS signaling and internal HTTPS requests, but not to WebRTC media, TURN, or application-owned token endpoints.

Key Rules:

• Web Support: Pinning is not supported on Flutter web. Configuring it on web will cause Room.connect to throw an UnsupportedError.
• Host Matching: Supports exact hosts, single-label wildcards (*.livekit.cloud), and multi-label wildcards (**.livekit.cloud). Use **.livekit.cloud to ensure coverage for LiveKit Cloud regional failover hosts.
• SPKI Pins: Use SPKI SHA-256 pins in primaryPins and backupPins. The SDK matches these against the leaf certificate's public key only. Do not pin intermediate or root CA keys, as Dart does not expose the full chain.
• Leaf Certificates: Use pinnedLeafCertificates to require an exact peer leaf certificate. If using private PKI, you must also configure trustedCertificates to anchor the validation.

// Example: SPKI Pinning
final roomOptions = RoomOptions(
  networkOptions: NetworkOptions(
    certificatePinning: CertificatePinningOptions(
      rules: [
        CertificatePinningRule(
          hosts: ['**.livekit.cloud'],
          primaryPins: ['sha256/current-public-key-pin'],
          backupPins: [
            'sha256/next-public-key-pin-1',
            'sha256/next-public-key-pin-2',
          ],
        ),
      ],
    ),
  ),
);

final room = Room(roomOptions: roomOptions);
await room.connect(url, token);

// Example: Exact Leaf Certificate and Custom Trust Store
final certificate = await CertificateBytes.fromAsset(
  'assets/livekit_leaf_cert.pem',
);

final roomOptions = RoomOptions(
  networkOptions: NetworkOptions(
    certificatePinning: CertificatePinningOptions(
      rules: [
        CertificatePinningRule(
          hosts: ['my-project.livekit.cloud'],
          pinnedLeafCertificates: [certificate],
          trustedCertificates: [certificate],
        ),
      ],
    ),
  ),
);

LiveKit uses the AudioManager singleton to manage platform audio sessions (iOS/Android) and audio engine state.

Automatic Mode (Default)

By default, LiveKit manages the session automatically using a communication intent. This is ideal for standard calls and requires no setup. On iOS, this uses playAndRecord when the microphone is active and playback for listen-only playout. On Android, it uses communication mode with voice call routing and audio focus.

Manual Mode

To take full control of the session (e.g., for a playback-only app or custom platform configurations), switch to manual mode. In manual mode, LiveKit stops managing the session based on room or engine lifecycle, and your app becomes responsible for the session.

Key Capabilities

• Session Control: Switch between automatic and manual modes.
• Speaker Routing: Control whether audio prefers the speaker or a headset.
• State Observation: Monitor the native audio engine state (playout and recording status).
• Audio Processing: Manage signal processing like echo cancellation and noise suppression.

import 'package:livekit_client/livekit_client.dart';

// Access the singleton
final audioManager = AudioManager.instance;

// Switch to manual mode
await audioManager.setAudioSessionManagementMode(AudioSessionManagementMode.manual);

// Switch back to automatic mode
await audioManager.setAudioSessionManagementMode(AudioSessionManagementMode.automatic);

The legacy Hardware audio members are deprecated and have been moved to AudioManager. Use the following mapping to update your code:

Note on configuration: The onConfigureNativeAudio hook is removed. Instead of using a custom configuration function, use explicit options via setAudioSessionOptions, which triggers manual mode.

// Before: assigning onConfigureNativeAudio with a custom function.
// After:
await AudioManager.instance.setAudioSessionOptions(
  AudioSessionOptions.communication(
    apple: const AppleAudioSessionConfiguration(
      category: AppleAudioCategory.playAndRecord,
      mode: AppleAudioMode.videoChat,
    ),
  ),
);

When preset constructors like AudioSessionOptions.communication() are insufficient, you can pin exact platform values using AudioManager.instance.setAudioSessionOptions.

Important: Supplying options via setAudioSessionOptions switches the SDK to manual mode.

• Apple: The AppleAudioSessionConfiguration is applied verbatim. You must specify the category, categoryOptions, and mode.
• Android: The AndroidAudioSessionConfiguration is applied. Any field left null is omitted, allowing the native manager to retain its current value for that field.

await AudioManager.instance.setAudioSessionOptions(
  AudioSessionOptions.communication(
    apple: const AppleAudioSessionConfiguration(
      category: AppleAudioCategory.playAndRecord,
      categoryOptions: {
        AppleAudioCategoryOption.allowBluetooth,
        AppleAudioCategoryOption.mixWithOthers,
      },
      mode: AppleAudioMode.voiceChat,
    ),
    android: AndroidAudioSessionConfiguration.communication,
  ),
);

LiveKit depends on Flutter WebRTC, which requires several permissions to be declared in your AndroidManifest.xml. You must include permissions for camera, audio recording, network state, and Bluetooth.

<manifest xmlns:android="http://schemas.android.com/apk/res/android" package="com.your.package">
  <uses-feature android:name="android.hardware.camera" />
  <uses-feature android:name="android.hardware.camera.autofocus" />
  <uses-permission android:name="android.permission.CAMERA" />
  <uses-permission android:name="android.permission.RECORD_AUDIO" />
  <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
  <uses-permission android:name="android.permission.CHANGE_NETWORK_STATE" />
  <uses-permission android:name="android.permission.MODIFY_AUDIO_SETTINGS" />
  <uses-permission android:name="android.permission.BLUETOOTH" android:maxSdkVersion="30" />
  <uses-permission android:name="android.permission.BLUETOOTH_CONNECT" />
  <uses-permission android:name="android.permission.BLUETOOTH_ADMIN" android:maxSdkVersion="30" />
  ...
</manifest>

Screen sharing is supported across all platforms using room.localParticipant.setScreenShareEnabled(true). Platform-specific requirements apply:

Android

Requires a media projection foreground service. In AndroidManifest.xml, declare the service with mediaProjection type:

<service
    android:name="de.julianassmann.flutter_background.IsolateHolderService"
    android:enabled="true"
    android:exported="false"
    android:foregroundServiceType="mediaProjection" />

Crucial: You must call Helper.requestCapturePermission() from flutter_webrtc and verify it returns true before enabling screen share.

iOS

Requires a broadcast extension. Follow the flutter-webrtc iOS setup guide.

Desktop (Windows/macOS)

Use ScreenSelectDialog to allow users to pick a source, then create a track using LocalVideoTrack.createScreenShareTrack.

// Desktop Screen Share Example
try {
  final source = await showDialog<DesktopCapturerSource>(
    context: context,
    builder: (context) => ScreenSelectDialog(),
  );
  if (source == null) {
    print('cancelled screenshare');
    return;
  }
  print('DesktopCapturerSource: ${source.id}');
  var track = await LocalVideoTrack.createScreenShareTrack(
    ScreenShareCaptureOptions(
      sourceId: source.id,
      maxFrameRate: 15.0,
    ),
  );
  await room.localParticipant.publishVideoTrack(track);
} catch (e) {
  print('could not publish screen sharing: $e');
}