diff --git a/CHANGELOG.md b/CHANGELOG.md
index d264b72..662f077 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -13,4 +13,6 @@ Initial release.
 - Livestreams over WHIP (`publishLivestream`) and WHEP (`receiveLivestream`).
 - Background calls: Android foreground service (`ForegroundService`) and iOS CallKit session (`CallKit`)
   keep microphone capture and playback running while the app is in the background.
+- Picture-in-picture (`PictureInPictureView`, `PictureInPictureOptions`, `PictureInPictureController`),
+  matching the React Native SDK's `RTCPIPView`.
 - Behavioral differences from the Fishjam web SDK are listed in SPEC.md §22.
diff --git a/README.md b/README.md
index e2598b9..498280b 100644
--- a/README.md
+++ b/README.md
@@ -181,6 +181,75 @@ For screen sharing, also add `FOREGROUND_SERVICE_MEDIA_PROJECTION`, add `mediaPr
 </array>
 ```
 
+## Picture-in-picture
+
+`PictureInPictureView` renders a stream and offers its first video track for the system picture-in-picture
+window (iOS 15+, Android 8 / API 26+). Every view with `pipOptions` enabled is offered on its own. On iOS each
+offered view has its own controller. On Android the window belongs to the activity, so the view updated
+most recently, or the one `start()` was called on, is the one shown. It matches the React Native SDK's
+`RTCPIPView`: `pipOptions` takes the same options (`enabled`,
+`preferredSize` (default 1920×1080), `startAutomatically`, `stopAutomatically`, `allowsCameraInBackground`), plus `fallbackLabel`,
+`fallbackBackgroundColor` and `fallbackTextColor`, drawn in the app and in the window when the video track is gone, and
+`PictureInPictureController.start()` / `stop()` replace `startPIP(ref)` / `stopPIP(ref)`.
+
+```dart
+final pip = PictureInPictureController();
+
+PictureInPictureView(
+  mediaStream: remoteTrack.stream,
+  controller: pip,
+  pipOptions: const PictureInPictureOptions(
+    startAutomatically: true,
+    fallbackLabel: 'Left the call',
+    fallbackBackgroundColor: Color(0xFF112233),
+    fallbackTextColor: Color(0xFFFFFFFF),
+  ),
+  onPictureInPictureChange: (active) => setState(() => _inPip = active),
+);
+
+await pip.start(); // e.g. from a button; stop() does nothing on Android
+```
+
+When the video track is gone, the app and the window both draw `fallbackLabel` (default `No video`) in
+`fallbackTextColor` on `fallbackBackgroundColor`. `stopAutomatically` applies on iOS only.
+
+A video CallKit call already keeps the camera running in the background (see above).
+`allowsCameraInBackground: true` (iOS 16+, default `false`, as in the React Native SDK) does the same for an
+app that does not start one. On iOS 18 or newer that needs `voip` in `UIBackgroundModes`. Before iOS 18 it
+also needs the `com.apple.developer.avfoundation.multitasking-camera-access` entitlement.
+
+Keep the call alive in the background with `ForegroundService` and `CallKit` (see above), and add:
+
+**iOS** `Info.plist` (the `audio` entry is already required for background calls):
+
+```xml
+<key>UIBackgroundModes</key>
+<array>
+    <string>audio</string>
+</array>
+```
+
+**Android** `AndroidManifest.xml`, on the activity (keep the `configChanges` the Flutter template sets, so
+the activity is not recreated when picture-in-picture starts):
+
+```xml
+<activity
+    android:name=".MainActivity"
+    android:supportsPictureInPicture="true"
+    android:configChanges="orientation|keyboardHidden|keyboard|screenSize|smallestScreenSize|locale|layoutDirection|fontScale|screenLayout|density|uiMode"
+    ...>
+```
+
+**Android** `MainActivity.kt` must extend `FlutterFragmentActivity`:
+
+```kotlin
+import io.flutter.embedding.android.FlutterFragmentActivity
+
+class MainActivity : FlutterFragmentActivity()
+```
+
+Starting automatically when the app goes to the background works on iOS 15+ and Android 12 (API 31)+.
+
 For prototyping without a backend, the Fishjam dashboard offers a Sandbox API that returns peer tokens. It is
 unauthenticated: never use it in production. The [example app](example/) shows both flows.
 
diff --git a/SPEC.md b/SPEC.md
index 7c0c0cf..9027552 100644
--- a/SPEC.md
+++ b/SPEC.md
@@ -743,6 +743,80 @@ when it joins and stops them when it leaves.
 - The app adds `audio` and `voip` to `UIBackgroundModes`. Out of scope: VoIP push, incoming calls, answering,
   ring timeouts.
 
+
+## 20d. Picture-in-picture
+
+`PictureInPictureView` renders a `MediaStream` and offers its first video track for picture-in-picture (PiP),
+the floating window the OS shows while the app is in the background. It mirrors the React Native SDK's
+`RTCPIPView`, `RTCPIPOptions`, `onPictureInPictureChange` and `startPIP` / `stopPIP`. It talks to the SDK's
+native plugin over the method channel `io.fishjam.client/pip` and the event channel
+`io.fishjam.client/pip_events`.
+
+- Options (`PictureInPictureOptions`): `enabled` (default `true`), `preferredSize` (logical pixels;
+  default 1920×1080, the React Native native default. Android uses it as the aspect ratio, and uses the
+  view size for a side that is 0. iOS sets `preferredContentSize` to this size), `startAutomatically` (default `true`; iOS:
+  `canStartPictureInPictureAutomaticallyFromInline`. iOS starts the window itself when the app
+  backgrounds; calling `startPictureInPicture()` during that transition cancels the hide and leaves
+  the app on screen. Android: `setAutoEnterEnabled`, API 31+),
+  `stopAutomatically` (default `true`, iOS only: PiP stops 0.5 s after the app returns to the foreground),
+  `allowsCameraInBackground` (default `false`, iOS 16+ only: multitasking camera access on the capture
+  session, for an app that does not start a video CallKit call; a video call already does this, §20c). The
+  flag is applied again just before the app resigns active, because the capture session may not exist when
+  the option is first set. `fallbackLabel` (default `No video`), `fallbackBackgroundColor` (default `0xFF1C2945`) and
+  `fallbackTextColor` (default white) are drawn in the app and in the window when this view's video track is gone.
+  `pipOptions: null` or `enabled: false` means that view is not offered. Any number of
+  views may be offered at once. Dart does not choose among them: each offered view stays registered until
+  that view itself stops being offered.
+- Messages, all keyed by an integer `viewId` unique per mounted view:
+  - `update` `{viewId, trackId, rect, mirror, objectFit, preferredSize, startAutomatically,
+    stopAutomatically, allowsCameraInBackground, fallbackLabel, fallbackBackgroundColor, fallbackTextColor}` is sent for each offered view when it becomes offered or
+    any of these values changes. Offering or updating another view does not send `update` or `unregister`
+    for this one. `trackId` is the `flutter_webrtc` id of the first video track, or `null`. `rect`
+    `{x, y, width, height}` is the view's global rect in logical pixels, or `null` before the first layout.
+    `objectFit` is `cover` or `contain`. `preferredSize` `{width, height}` is always sent (default
+    1920×1080). Native code uses that default when the key is missing.
+  - `unregister` `{viewId}` is sent when that view stops being offered (unmounted, `pipOptions: null`, or
+    `enabled: false`), including when other views stay offered. Native code releases that view only.
+  - `start` / `stop` `{viewId}` come from `PictureInPictureController`. They are sent only for a view that
+    is offered; otherwise they do nothing. `stop` does nothing on Android (the user closes or expands the
+    window). `PictureInPictureController.setMediaStream(stream)` sends that view an `update` with the
+    stream's first video track id (or `null`), without waiting for a Flutter rebuild. Apps use it when a
+    remote track changes while the app is in the background, such as after that peer reconnects.
+  - Events `{viewId, isActive}` update `PictureInPictureController.isActive` and call
+    `onPictureInPictureChange` of that view. A view that stops being offered while active becomes inactive
+    without a callback.
+- Native code resolves `trackId` with `FlutterWebRTCPlugin.sharedSingleton` (`trackForId:peerConnectionId:` on
+  iOS, `getTrackForId` on Android, both with no peer connection id).
+- iOS (15+): one `AVPictureInPictureController` per offered view, each with an
+  `AVPictureInPictureVideoCallViewController`. The SDK does not pick a winner. Frames are drawn into an
+  `AVSampleBufferDisplayLayer` while that view's PiP is active, and also while `startAutomatically` is on,
+  because iOS will not start an empty layer when the app backgrounds. The source view is a clear view
+  placed on the video tile's rect (`rect` in the `update` message), which is where iOS animates
+  picture-in-picture from and to. `stop` while the app is in the background removes that source view,
+  because iOS ignores `stopPictureInPicture()` until the app is visible; once the window has closed, the
+  view is put back and that view's controller is created again, so a later `start` or automatic start
+  works. If a video track is set on it again while the app is still in the background and
+  `startAutomatically` is on, the window opens again. `unregister` stops that view's
+  PiP and removes its controller.
+- Android (API 26+): each offered view keeps its own settings, but the window belongs to the activity
+  (`enterPictureInPictureMode`), so one view backs it. That view is the one whose `update` arrived most
+  recently, or the one `start` was called on. A later `update` from another view replaces it; while the
+  window is already active, the new view is reported active and the previous view is not reported inactive.
+  `unregister` for a view that is not backing the window only drops that view's settings. `unregister` for
+  the view that is backing it turns auto-enter off (API 31+). If the window is already open it stays open
+  and draws the fallback label, because Android ignores a request to close it; otherwise listening stops.
+  It does not hand the window to another offered view. The activity must be a `FlutterFragmentActivity`
+  so it can report picture-in-picture mode changes; otherwise a warning is logged and those changes are
+  missed. On
+  enter the children of `android.R.id.content` are hidden and a `SurfaceViewRenderer` fed by the track fills
+  the window; on exit it is removed and the children are restored.
+- Below iOS 15 and below Android 8, `update` is sent and native code ignores it. On other platforms nothing
+  is sent. `isActive` stays `false`.
+- The plugin links WebRTC for this feature: the pod and the Swift package depend on `flutter_webrtc` (its
+  `WebRTC` product), and the Android library compiles against `:flutter_webrtc`.
+- When there is no video track, the app and the window both draw `fallbackLabel` on
+  `fallbackBackgroundColor` in `fallbackTextColor` (D24).
+
 ## 21. Logging
 
 One SDK logger, created from `FishjamClient(debug: bool)`. Messages are prefixed with `[FISHJAM]` and emitted
@@ -779,6 +853,7 @@ through `dart:developer`'s `log` only when `debug` is true. The SDK never calls
 | D25 | ICE `disconnected` only renegotiates, however long it lasts | `disconnected` for 3 s is a retryable loss (§8.4) | do not wait for a late `failed` |
 | D26 | opening the socket has no timeout | 10 s (§2.1) | an attempt on a dead network does not hang |
 | D27 | `addTracksOnReconnect` defaults to false: after a reconnection the user publishes nothing until the app adds its tracks again | defaults to true (§6) | a network switch on mobile should not silently turn off the camera and microphone |
+| D28 | (React Native SDK) `pip.fallbackView` is one view drawn in the app and in the PiP window | the app and the window both draw `fallbackLabel`, `fallbackBackgroundColor` and `fallbackTextColor` (§20d) | a Flutter widget cannot be drawn into the native PiP window |
 
 ## 23. Golden fixtures
 
diff --git a/android/build.gradle.kts b/android/build.gradle.kts
index 6d4d486..9cd5a16 100644
--- a/android/build.gradle.kts
+++ b/android/build.gradle.kts
@@ -50,3 +50,14 @@ kotlin {
         jvmTarget = org.jetbrains.kotlin.gradle.dsl.JvmTarget.JVM_17
     }
 }
+
+// Provided at runtime by flutter_webrtc (WebRTC) and the Flutter embedding (AndroidX).
+// compileOnly: the app keeps the single copy that flutter_webrtc packages.
+// flutter_webrtc 1.6.2 uses io.github.webrtc-sdk:android:150.7871.01. Gradle
+// requires a version on this line, so update it when bumping flutter_webrtc
+// in pubspec.yaml.
+dependencies {
+    compileOnly(project(":flutter_webrtc"))
+    compileOnly("io.github.webrtc-sdk:android:150.7871.01")
+    compileOnly("androidx.fragment:fragment:1.7.1")
+}
diff --git a/android/src/main/kotlin/io/fishjam/client/FishjamClientPlugin.kt b/android/src/main/kotlin/io/fishjam/client/FishjamClientPlugin.kt
index 95ddfeb..03029f9 100644
--- a/android/src/main/kotlin/io/fishjam/client/FishjamClientPlugin.kt
+++ b/android/src/main/kotlin/io/fishjam/client/FishjamClientPlugin.kt
@@ -4,6 +4,7 @@ import android.content.Context
 import android.util.Log
 import io.fishjam.client.foregroundservice.ForegroundServiceController
 import io.fishjam.client.foregroundservice.NotificationPermission
+import io.fishjam.client.pip.PictureInPictureManager
 import io.flutter.embedding.engine.plugins.FlutterPlugin
 import io.flutter.embedding.engine.plugins.activity.ActivityAware
 import io.flutter.embedding.engine.plugins.activity.ActivityPluginBinding
@@ -21,6 +22,12 @@ class FishjamClientPlugin : FlutterPlugin, ActivityAware {
     private lateinit var backgroundChannel: MethodChannel
     private val notificationPermission = NotificationPermission()
     private var activityBinding: ActivityPluginBinding? = null
+    private lateinit var pipChannel: MethodChannel
+    private lateinit var pipEvents: EventChannel
+    private var pipEventSink: EventChannel.EventSink? = null
+    private val pictureInPicture = PictureInPictureManager { viewId, active ->
+        pipEventSink?.success(mapOf("viewId" to viewId, "isActive" to active))
+    }
 
     override fun onAttachedToEngine(binding: FlutterPlugin.FlutterPluginBinding) {
         context = binding.applicationContext
@@ -43,6 +50,18 @@ class FishjamClientPlugin : FlutterPlugin, ActivityAware {
         })
         backgroundChannel = MethodChannel(binding.binaryMessenger, BACKGROUND_CHANNEL)
         backgroundChannel.setMethodCallHandler(::onBackgroundMethodCall)
+        pipChannel = MethodChannel(binding.binaryMessenger, PIP_CHANNEL)
+        pipChannel.setMethodCallHandler(pictureInPicture::handle)
+        pipEvents = EventChannel(binding.binaryMessenger, PIP_EVENTS_CHANNEL)
+        pipEvents.setStreamHandler(object : EventChannel.StreamHandler {
+            override fun onListen(arguments: Any?, events: EventChannel.EventSink) {
+                pipEventSink = events
+            }
+
+            override fun onCancel(arguments: Any?) {
+                pipEventSink = null
+            }
+        })
     }
 
     private fun onAudioMethodCall(call: MethodCall, result: Result) {
@@ -85,12 +104,16 @@ class FishjamClientPlugin : FlutterPlugin, ActivityAware {
         audioEventSink = null
         audioOutput.stopObserving()
         backgroundChannel.setMethodCallHandler(null)
+        pipChannel.setMethodCallHandler(null)
+        pipEvents.setStreamHandler(null)
+        pipEventSink = null
     }
 
     override fun onAttachedToActivity(binding: ActivityPluginBinding) {
         activityBinding = binding
         notificationPermission.activity = binding.activity
         binding.addRequestPermissionsResultListener(notificationPermission)
+        pictureInPicture.attachActivity(binding.activity)
     }
 
     override fun onDetachedFromActivityForConfigChanges() = onDetachedFromActivity()
@@ -103,6 +126,7 @@ class FishjamClientPlugin : FlutterPlugin, ActivityAware {
         activityBinding = null
         notificationPermission.activity = null
         notificationPermission.flush()
+        pictureInPicture.detachActivity()
     }
 
     /**
@@ -134,5 +158,7 @@ class FishjamClientPlugin : FlutterPlugin, ActivityAware {
         private const val AUDIO_CHANNEL = "io.fishjam.client/audio_output"
         private const val AUDIO_EVENTS_CHANNEL = "io.fishjam.client/audio_output_events"
         private const val BACKGROUND_CHANNEL = "io.fishjam.client/background"
+        private const val PIP_CHANNEL = "io.fishjam.client/pip"
+        private const val PIP_EVENTS_CHANNEL = "io.fishjam.client/pip_events"
     }
 }
diff --git a/android/src/main/kotlin/io/fishjam/client/pip/PictureInPictureManager.kt b/android/src/main/kotlin/io/fishjam/client/pip/PictureInPictureManager.kt
new file mode 100644
index 0000000..951cb22
--- /dev/null
+++ b/android/src/main/kotlin/io/fishjam/client/pip/PictureInPictureManager.kt
@@ -0,0 +1,371 @@
+package io.fishjam.client.pip
+
+import android.app.Activity
+import android.app.PictureInPictureParams
+import android.graphics.Color
+import android.os.Build
+import android.util.Log
+import android.util.Rational
+import android.view.Gravity
+import android.view.View
+import android.view.ViewGroup
+import android.widget.FrameLayout
+import android.widget.TextView
+import androidx.annotation.RequiresApi
+import androidx.core.app.OnPictureInPictureModeChangedProvider
+import androidx.core.app.PictureInPictureModeChangedInfo
+import androidx.core.util.Consumer
+import com.cloudwebrtc.webrtc.FlutterWebRTCPlugin
+import com.cloudwebrtc.webrtc.utils.EglUtils
+import io.flutter.plugin.common.MethodCall
+import io.flutter.plugin.common.MethodChannel.Result
+import org.webrtc.RendererCommon
+import org.webrtc.SurfaceViewRenderer
+import org.webrtc.VideoTrack
+
+/**
+ * Handles `io.fishjam.client/pip`. Port of the React Native SDK's
+ * `PIPManager` (`react-native-webrtc/android/.../PIPManager.java`): each
+ * `PictureInPictureView` on the Dart side registers its own settings here,
+ * keyed by view id, just like each `WebRTCView` there owns one `PIPManager`.
+ *
+ * Android's picture-in-picture window is a property of the `Activity`
+ * (`enterPictureInPictureMode`), not of a view, so only one view's settings
+ * can back the window at a time -- the one most recently updated, or the one
+ * [start] was called on. The React Native SDK has the same constraint for
+ * the same reason, despite also keeping one manager per view.
+ *
+ * While in picture-in-picture the Flutter view is hidden and a
+ * [SurfaceViewRenderer] fed by the same track fills the window, so the window
+ * shows only the video whatever the Flutter UI looks like.
+ */
+class PictureInPictureManager(private val onActiveChanged: (viewId: Int, active: Boolean) -> Unit) {
+    private var activity: Activity? = null
+    private var listening = false
+
+    private class ViewState {
+        var trackId: String? = null
+        var mirror = false
+        var objectFitContain = false
+        var startAutomatically = true
+        var preferredWidth = 0.0
+        var preferredHeight = 0.0
+        var viewWidth = 0.0
+        var viewHeight = 0.0
+        var label = "No video"
+        var backgroundColor = DEFAULT_PLACEHOLDER_BACKGROUND
+        var textColor = Color.WHITE
+    }
+
+    private val views = mutableMapOf<Int, ViewState>()
+
+    /** Whichever view's settings currently back the window. */
+    private var currentViewId: Int? = null
+    private var active = false
+
+    private val hiddenChildren = mutableListOf<Pair<View, Int>>()
+    private var container: FrameLayout? = null
+    private var renderer: SurfaceViewRenderer? = null
+    private var rendererTrack: VideoTrack? = null
+
+    private val modeListener = Consumer<PictureInPictureModeChangedInfo> { info ->
+        if (info.isInPictureInPictureMode) {
+            onEnter()
+        } else {
+            onExit()
+            if (currentViewId == null) stopListening()
+        }
+    }
+
+    fun attachActivity(activity: Activity) {
+        this.activity = activity
+        if (currentViewId != null) {
+            startListening()
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) applyParams()
+        }
+    }
+
+    fun detachActivity() {
+        if (active) onExit()
+        stopListening()
+        activity = null
+    }
+
+    fun handle(call: MethodCall, result: Result) {
+        val args = call.arguments as? Map<*, *> ?: emptyMap<String, Any>()
+        val id = (args["viewId"] as? Number)?.toInt()
+        when (call.method) {
+            "update" -> if (id != null) update(id, args)
+            "start" -> if (id != null) start(id)
+            "stop" -> Unit
+            "unregister" -> if (id != null) unregister(id)
+            else -> return result.notImplemented()
+        }
+        result.success(null)
+    }
+
+    private fun update(id: Int, args: Map<*, *>) {
+        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.O) return
+        val state = views.getOrPut(id) { ViewState() }
+        state.trackId = args["trackId"] as? String
+        state.mirror = args["mirror"] as? Boolean ?: false
+        state.objectFitContain = args["objectFit"] == "contain"
+        state.startAutomatically = args["startAutomatically"] as? Boolean ?: true
+        val preferred = args["preferredSize"] as? Map<*, *>
+        // React Native defaults to 1920×1080. A side of 0 falls back to the
+        // view size in [buildParams].
+        state.preferredWidth = preferredSide(preferred?.get("width"), DEFAULT_PREFERRED_WIDTH)
+        state.preferredHeight = preferredSide(preferred?.get("height"), DEFAULT_PREFERRED_HEIGHT)
+        val rect = args["rect"] as? Map<*, *>
+        state.viewWidth = (rect?.get("width") as? Number)?.toDouble() ?: 0.0
+        state.viewHeight = (rect?.get("height") as? Number)?.toDouble() ?: 0.0
+        state.label = args["fallbackLabel"] as? String ?: "No video"
+        state.backgroundColor = (args["fallbackBackgroundColor"] as? Number)?.toInt()
+            ?: DEFAULT_PLACEHOLDER_BACKGROUND
+        state.textColor = (args["fallbackTextColor"] as? Number)?.toInt() ?: Color.WHITE
+
+        val takesOver = currentViewId != id
+        currentViewId = id
+        if (takesOver && active) onActiveChanged(id, true)
+
+        if (active) {
+            if (state.trackId == null) {
+                showNoVideo(state)
+            } else {
+                renderer?.let {
+                    it.setMirror(state.mirror)
+                    it.setScalingType(scalingType(state))
+                }
+                attachRendererTrack(state)
+            }
+        }
+
+        startListening()
+        applyParams()
+    }
+
+    @RequiresApi(Build.VERSION_CODES.O)
+    private fun start(id: Int) {
+        val activity = activity ?: return
+        val state = views[id] ?: return
+        currentViewId = id
+        try {
+            activity.enterPictureInPictureMode(buildParams(state))
+        } catch (e: IllegalStateException) {
+            Log.e(TAG, "Failed to enter picture-in-picture", e)
+        }
+    }
+
+    private fun unregister(id: Int) {
+        val state = views.remove(id)
+        if (currentViewId != id) return
+        currentViewId = null
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S && state != null) {
+            state.startAutomatically = false
+            val activity = activity
+            if (activity != null) {
+                try {
+                    activity.setPictureInPictureParams(buildParams(state))
+                } catch (e: IllegalStateException) {
+                    Log.e(TAG, "Failed to update picture-in-picture params", e)
+                }
+            }
+        }
+        if (active) {
+            // The window stays open: restoring the Flutter view now would show
+            // the app's UI in it, and Android ignores a close request. Show
+            // "No video" until another view takes over or the user closes it.
+            showNoVideo(state)
+            return
+        }
+        stopListening()
+    }
+
+    private fun startListening() {
+        if (listening) return
+        val provider = activity as? OnPictureInPictureModeChangedProvider
+        if (provider == null) {
+            if (activity != null) {
+                Log.w(
+                    TAG,
+                    "Picture-in-picture needs MainActivity to extend FlutterFragmentActivity",
+                )
+            }
+            return
+        }
+        provider.addOnPictureInPictureModeChangedListener(modeListener)
+        listening = true
+    }
+
+    private fun stopListening() {
+        if (!listening) return
+        (activity as? OnPictureInPictureModeChangedProvider)
+            ?.removeOnPictureInPictureModeChangedListener(modeListener)
+        listening = false
+    }
+
+    @RequiresApi(Build.VERSION_CODES.O)
+    private fun buildParams(state: ViewState): PictureInPictureParams {
+        val builder = PictureInPictureParams.Builder()
+        val width = if (state.preferredWidth > 0) state.preferredWidth else state.viewWidth
+        val height = if (state.preferredHeight > 0) state.preferredHeight else state.viewHeight
+        if (width > 0 && height > 0) {
+            // Android rejects ratios outside 1:2.39 .. 2.39:1.
+            val ratio = (width / height).coerceIn(1 / MAX_RATIO, MAX_RATIO)
+            builder.setAspectRatio(Rational((ratio * 10_000).toInt(), 10_000))
+        }
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
+            builder.setAutoEnterEnabled(state.startAutomatically && listening)
+        }
+        return builder.build()
+    }
+
+    private fun applyParams() {
+        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.O) return
+        val activity = activity ?: return
+        val state = currentViewId?.let { views[it] } ?: return
+        try {
+            activity.setPictureInPictureParams(buildParams(state))
+        } catch (e: IllegalStateException) {
+            Log.e(TAG, "Failed to update picture-in-picture params", e)
+        }
+    }
+
+    private fun onEnter() {
+        setActive(true)
+        val activity = activity ?: return
+        val state = currentViewId?.let { views[it] } ?: return
+        val root = activity.findViewById<ViewGroup>(android.R.id.content) ?: return
+
+        hiddenChildren.clear()
+        for (i in 0 until root.childCount) {
+            val child = root.getChildAt(i)
+            hiddenChildren.add(child to child.visibility)
+            child.visibility = View.GONE
+        }
+
+        val surface = SurfaceViewRenderer(activity).apply {
+            setBackgroundColor(Color.BLACK)
+            setMirror(state.mirror)
+            setScalingType(scalingType(state))
+        }
+        val frame = FrameLayout(activity).apply {
+            setBackgroundColor(Color.BLACK)
+            addView(surface, FrameLayout.LayoutParams(MATCH_PARENT, MATCH_PARENT))
+        }
+        root.addView(frame, FrameLayout.LayoutParams(MATCH_PARENT, MATCH_PARENT))
+        container = frame
+
+        val eglContext = EglUtils.getRootEglBaseContext()
+        if (eglContext == null) {
+            Log.e(TAG, "Cannot create the picture-in-picture renderer: no EGL context")
+            return
+        }
+        try {
+            surface.init(eglContext, object : RendererCommon.RendererEvents {
+                override fun onFirstFrameRendered() {
+                    surface.post { surface.setBackgroundColor(Color.TRANSPARENT) }
+                }
+
+                override fun onFrameResolutionChanged(width: Int, height: Int, rotation: Int) {}
+            })
+            renderer = surface
+            attachRendererTrack(state)
+        } catch (e: RuntimeException) {
+            Log.e(TAG, "Failed to initialize the picture-in-picture renderer", e)
+        }
+    }
+
+    private fun attachRendererTrack(state: ViewState) {
+        val surface = renderer ?: return
+        rendererTrack?.let { track -> runCatching { track.removeSink(surface) } }
+        rendererTrack = null
+        val track = state.trackId?.let {
+            FlutterWebRTCPlugin.sharedSingleton?.getTrackForId(it, null) as? VideoTrack
+        }
+        track ?: return
+        try {
+            track.addSink(surface)
+            rendererTrack = track
+            surface.visibility = View.VISIBLE
+            container?.findViewWithTag<View>(FALLBACK_TAG)?.let { container?.removeView(it) }
+        } catch (e: IllegalStateException) {
+            Log.e(TAG, "Failed to add the picture-in-picture renderer to the track", e)
+        }
+    }
+
+    private fun showNoVideo(state: ViewState?) {
+        detachRendererTrack()
+        val frame = container ?: return
+        renderer?.visibility = View.GONE
+        val label = state?.label ?: "No video"
+        val background = state?.backgroundColor ?: DEFAULT_PLACEHOLDER_BACKGROUND
+        val textColor = state?.textColor ?: Color.WHITE
+        frame.setBackgroundColor(background)
+        val existing = frame.findViewWithTag<TextView>(FALLBACK_TAG)
+        if (existing != null) {
+            existing.text = label
+            existing.setTextColor(textColor)
+            return
+        }
+        frame.addView(
+            TextView(frame.context).apply {
+                tag = FALLBACK_TAG
+                text = label
+                setTextColor(textColor)
+                gravity = Gravity.CENTER
+                textSize = 18f
+            },
+            FrameLayout.LayoutParams(MATCH_PARENT, MATCH_PARENT),
+        )
+    }
+
+    private fun detachRendererTrack() {
+        val surface = renderer ?: return
+        rendererTrack?.let { track -> runCatching { track.removeSink(surface) } }
+        rendererTrack = null
+        surface.clearImage()
+    }
+
+    private fun onExit() {
+        setActive(false)
+        renderer?.let { surface ->
+            rendererTrack?.let { track -> runCatching { track.removeSink(surface) } }
+            surface.release()
+        }
+        renderer = null
+        rendererTrack = null
+
+        val root = activity?.findViewById<ViewGroup>(android.R.id.content)
+        container?.let { root?.removeView(it) }
+        container = null
+        for ((child, visibility) in hiddenChildren) child.visibility = visibility
+        hiddenChildren.clear()
+    }
+
+    private fun setActive(value: Boolean) {
+        if (active == value) return
+        active = value
+        currentViewId?.let { onActiveChanged(it, value) }
+    }
+
+    private fun preferredSide(value: Any?, fallback: Double): Double =
+        (value as? Number)?.toDouble() ?: fallback
+
+    private fun scalingType(state: ViewState) =
+        if (state.objectFitContain) {
+            RendererCommon.ScalingType.SCALE_ASPECT_FIT
+        } else {
+            RendererCommon.ScalingType.SCALE_ASPECT_FILL
+        }
+
+    private companion object {
+        const val TAG = "FishjamPictureInPicture"
+        const val FALLBACK_TAG = "pip-fallback"
+        const val DEFAULT_PLACEHOLDER_BACKGROUND = 0xFF1C2945.toInt()
+        const val DEFAULT_PREFERRED_WIDTH = 1920.0
+        const val DEFAULT_PREFERRED_HEIGHT = 1080.0
+        const val MAX_RATIO = 2.39
+        const val MATCH_PARENT = ViewGroup.LayoutParams.MATCH_PARENT
+    }
+}
diff --git a/docs/parity.md b/docs/parity.md
index 2c21e4a..6495eca 100644
--- a/docs/parity.md
+++ b/docs/parity.md
@@ -77,6 +77,20 @@ against the real `FishjamClient` in `test/client/client_fixtures_test.dart`.
 | `ReceiveLivestreamResult.stream` / `stop()` / `getStatistics()` | same names | |
 | `LivestreamError` (string enum, thrown) | `LivestreamException(LivestreamError)` | |
 
+## Picture-in-picture (React Native SDK)
+
+The React Native SDK's picture-in-picture (`@fishjam-cloud/react-native-webrtc`, SPEC §20d):
+
+| React Native SDK | Dart | Notes |
+|---|---|---|
+| `RTCPIPView` | `PictureInPictureView` | owns its renderer; `mediaStream` is a `MediaStream?` |
+| `pip: RTCPIPOptions` | `pipOptions: PictureInPictureOptions?` | same fields and defaults; `null` means not offered |
+| `enabled`, `preferredSize`, `startAutomatically`, `stopAutomatically`, `allowsCameraInBackground` | same names | `preferredSize` is a `Size`, default 1920×1080 |
+| `pip.fallbackView` | `fallbackLabel`, `fallbackBackgroundColor`, `fallbackTextColor` | drawn in the app and in the window (D24) |
+| `onPictureInPictureChange({nativeEvent: {isActive}})` | `onPictureInPictureChange(bool isActive)` | |
+| `startPIP(ref)` / `stopPIP(ref)` | `PictureInPictureController.start()` / `stop()` | the controller is passed to the view |
+| | `PictureInPictureController.isActive` | |
+
 ## Errors, guards and constants
 
 | Web SDK | Dart | Notes |
diff --git a/example/android/app/src/main/AndroidManifest.xml b/example/android/app/src/main/AndroidManifest.xml
index 50bb465..22fb203 100644
--- a/example/android/app/src/main/AndroidManifest.xml
+++ b/example/android/app/src/main/AndroidManifest.xml
@@ -26,6 +26,7 @@
             android:theme="@style/LaunchTheme"
             android:configChanges="orientation|keyboardHidden|keyboard|screenSize|smallestScreenSize|locale|layoutDirection|fontScale|screenLayout|density|uiMode"
             android:hardwareAccelerated="true"
+            android:supportsPictureInPicture="true"
             android:windowSoftInputMode="adjustResize">
             <!-- Specifies an Android theme to apply to this Activity as soon as
                  the Android process has started. This theme is visible to the user
diff --git a/example/android/app/src/main/kotlin/io/fishjam/example/fishjam_example/MainActivity.kt b/example/android/app/src/main/kotlin/io/fishjam/example/fishjam_example/MainActivity.kt
index 9488f69..b4ca295 100644
--- a/example/android/app/src/main/kotlin/io/fishjam/example/fishjam_example/MainActivity.kt
+++ b/example/android/app/src/main/kotlin/io/fishjam/example/fishjam_example/MainActivity.kt
@@ -1,5 +1,6 @@
 package io.fishjam.example.fishjam_example
 
-import io.flutter.embedding.android.FlutterActivity
+import io.flutter.embedding.android.FlutterFragmentActivity
 
-class MainActivity : FlutterActivity()
+// FlutterFragmentActivity is required for picture-in-picture.
+class MainActivity : FlutterFragmentActivity()
diff --git a/example/ios/Flutter/Debug.xcconfig b/example/ios/Flutter/Debug.xcconfig
index 592ceee..ec97fc6 100644
--- a/example/ios/Flutter/Debug.xcconfig
+++ b/example/ios/Flutter/Debug.xcconfig
@@ -1 +1,2 @@
+#include? "Pods/Target Support Files/Pods-Runner/Pods-Runner.debug.xcconfig"
 #include "Generated.xcconfig"
diff --git a/example/ios/Flutter/Release.xcconfig b/example/ios/Flutter/Release.xcconfig
index 592ceee..c4855bf 100644
--- a/example/ios/Flutter/Release.xcconfig
+++ b/example/ios/Flutter/Release.xcconfig
@@ -1 +1,2 @@
+#include? "Pods/Target Support Files/Pods-Runner/Pods-Runner.release.xcconfig"
 #include "Generated.xcconfig"
diff --git a/example/ios/Podfile b/example/ios/Podfile
new file mode 100644
index 0000000..6649374
--- /dev/null
+++ b/example/ios/Podfile
@@ -0,0 +1,43 @@
+# Uncomment this line to define a global platform for your project
+platform :ios, '15.0'
+
+# CocoaPods analytics sends network stats synchronously affecting flutter build latency.
+ENV['COCOAPODS_DISABLE_STATS'] = 'true'
+
+project 'Runner', {
+  'Debug' => :debug,
+  'Profile' => :release,
+  'Release' => :release,
+}
+
+def flutter_root
+  generated_xcode_build_settings_path = File.expand_path(File.join('..', 'Flutter', 'Generated.xcconfig'), __FILE__)
+  unless File.exist?(generated_xcode_build_settings_path)
+    raise "#{generated_xcode_build_settings_path} must exist. If you're running pod install manually, make sure flutter pub get is executed first"
+  end
+
+  File.foreach(generated_xcode_build_settings_path) do |line|
+    matches = line.match(/FLUTTER_ROOT\=(.*)/)
+    return matches[1].strip if matches
+  end
+  raise "FLUTTER_ROOT not found in #{generated_xcode_build_settings_path}. Try deleting Generated.xcconfig, then run flutter pub get"
+end
+
+require File.expand_path(File.join('packages', 'flutter_tools', 'bin', 'podhelper'), flutter_root)
+
+flutter_ios_podfile_setup
+
+target 'Runner' do
+  use_frameworks!
+
+  flutter_install_all_ios_pods File.dirname(File.realpath(__FILE__))
+  target 'RunnerTests' do
+    inherit! :search_paths
+  end
+end
+
+post_install do |installer|
+  installer.pods_project.targets.each do |target|
+    flutter_additional_ios_build_settings(target)
+  end
+end
diff --git a/example/ios/Podfile.lock b/example/ios/Podfile.lock
new file mode 100644
index 0000000..17e273c
--- /dev/null
+++ b/example/ios/Podfile.lock
@@ -0,0 +1,43 @@
+PODS:
+  - fishjam_client (0.31.0):
+    - Flutter
+    - flutter_webrtc
+    - WebRTC-SDK
+  - Flutter (1.0.0)
+  - flutter_webrtc (1.6.2):
+    - Flutter
+    - WebRTC-SDK (= 150.7871.01)
+  - integration_test (0.0.1):
+    - Flutter
+  - WebRTC-SDK (150.7871.01)
+
+DEPENDENCIES:
+  - fishjam_client (from `.symlinks/plugins/fishjam_client/ios`)
+  - Flutter (from `Flutter`)
+  - flutter_webrtc (from `.symlinks/plugins/flutter_webrtc/ios`)
+  - integration_test (from `.symlinks/plugins/integration_test/ios`)
+
+SPEC REPOS:
+  trunk:
+    - WebRTC-SDK
+
+EXTERNAL SOURCES:
+  fishjam_client:
+    :path: ".symlinks/plugins/fishjam_client/ios"
+  Flutter:
+    :path: Flutter
+  flutter_webrtc:
+    :path: ".symlinks/plugins/flutter_webrtc/ios"
+  integration_test:
+    :path: ".symlinks/plugins/integration_test/ios"
+
+SPEC CHECKSUMS:
+  fishjam_client: dd0d6cd1c268484ff423fa78c8c061c1e0896e47
+  Flutter: 71a624a5bc0c04062bf19101d501e466baf2fb47
+  flutter_webrtc: 99283145164f482a16bf7122ef407b5d59d43158
+  integration_test: 4a889634ef21a45d28d50d622cf412dc6d9f586e
+  WebRTC-SDK: 7dc931c64c00c735a614382f1a59cf65019c3c17
+
+PODFILE CHECKSUM: 53a6aebc29ccee84c41f92f409fc20cd4ca011f1
+
+COCOAPODS: 1.16.2
diff --git a/example/ios/Runner.xcodeproj/project.pbxproj b/example/ios/Runner.xcodeproj/project.pbxproj
index 2581921..7ddba4b 100644
--- a/example/ios/Runner.xcodeproj/project.pbxproj
+++ b/example/ios/Runner.xcodeproj/project.pbxproj
@@ -9,6 +9,7 @@
 /* Begin PBXBuildFile section */
 		1498D2341E8E89220040F4C2 /* GeneratedPluginRegistrant.m in Sources */ = {isa = PBXBuildFile; fileRef = 1498D2331E8E89220040F4C2 /* GeneratedPluginRegistrant.m */; };
 		331C808B294A63AB00263BE5 /* RunnerTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = 331C807B294A618700263BE5 /* RunnerTests.swift */; };
+		34041B2496A72135E4B071B4 /* Pods_Runner.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = CB543AF7CF3C2BA5E6890584 /* Pods_Runner.framework */; };
 		3B3967161E833CAA004F5970 /* AppFrameworkInfo.plist in Resources */ = {isa = PBXBuildFile; fileRef = 3B3967151E833CAA004F5970 /* AppFrameworkInfo.plist */; };
 		74858FAF1ED2DC5600515810 /* AppDelegate.swift in Sources */ = {isa = PBXBuildFile; fileRef = 74858FAE1ED2DC5600515810 /* AppDelegate.swift */; };
 		7884E8682EC3CC0700C636F2 /* SceneDelegate.swift in Sources */ = {isa = PBXBuildFile; fileRef = 7884E8672EC3CC0400C636F2 /* SceneDelegate.swift */; };
@@ -16,6 +17,7 @@
 		97C146FC1CF9000F007C117D /* Main.storyboard in Resources */ = {isa = PBXBuildFile; fileRef = 97C146FA1CF9000F007C117D /* Main.storyboard */; };
 		97C146FE1CF9000F007C117D /* Assets.xcassets in Resources */ = {isa = PBXBuildFile; fileRef = 97C146FD1CF9000F007C117D /* Assets.xcassets */; };
 		97C147011CF9000F007C117D /* LaunchScreen.storyboard in Resources */ = {isa = PBXBuildFile; fileRef = 97C146FF1CF9000F007C117D /* LaunchScreen.storyboard */; };
+		9BACA88ECB65491A0EEB688D /* Pods_RunnerTests.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = C9DD438C0078BFF7D3028213 /* Pods_RunnerTests.framework */; };
 /* End PBXBuildFile section */
 
 /* Begin PBXContainerItemProxy section */
@@ -44,9 +46,11 @@
 /* Begin PBXFileReference section */
 		1498D2321E8E86230040F4C2 /* GeneratedPluginRegistrant.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = GeneratedPluginRegistrant.h; sourceTree = "<group>"; };
 		1498D2331E8E89220040F4C2 /* GeneratedPluginRegistrant.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = GeneratedPluginRegistrant.m; sourceTree = "<group>"; };
+		28FE16A7518D0935AE2FC61F /* Pods-Runner.release.xcconfig */ = {isa = PBXFileReference; includeInIndex = 1; lastKnownFileType = text.xcconfig; name = "Pods-Runner.release.xcconfig"; path = "Target Support Files/Pods-Runner/Pods-Runner.release.xcconfig"; sourceTree = "<group>"; };
 		331C807B294A618700263BE5 /* RunnerTests.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = RunnerTests.swift; sourceTree = "<group>"; };
 		331C8081294A63A400263BE5 /* RunnerTests.xctest */ = {isa = PBXFileReference; explicitFileType = wrapper.cfbundle; includeInIndex = 0; path = RunnerTests.xctest; sourceTree = BUILT_PRODUCTS_DIR; };
 		3B3967151E833CAA004F5970 /* AppFrameworkInfo.plist */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.plist.xml; name = AppFrameworkInfo.plist; path = Flutter/AppFrameworkInfo.plist; sourceTree = "<group>"; };
+		4DCE31EA2B7306D288B2DAEC /* Pods-RunnerTests.release.xcconfig */ = {isa = PBXFileReference; includeInIndex = 1; lastKnownFileType = text.xcconfig; name = "Pods-RunnerTests.release.xcconfig"; path = "Target Support Files/Pods-RunnerTests/Pods-RunnerTests.release.xcconfig"; sourceTree = "<group>"; };
 		74858FAD1ED2DC5600515810 /* Runner-Bridging-Header.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = "Runner-Bridging-Header.h"; sourceTree = "<group>"; };
 		74858FAE1ED2DC5600515810 /* AppDelegate.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = AppDelegate.swift; sourceTree = "<group>"; };
 		7884E8672EC3CC0400C636F2 /* SceneDelegate.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = SceneDelegate.swift; sourceTree = "<group>"; };
@@ -59,20 +63,44 @@
 		97C146FD1CF9000F007C117D /* Assets.xcassets */ = {isa = PBXFileReference; lastKnownFileType = folder.assetcatalog; path = Assets.xcassets; sourceTree = "<group>"; };
 		97C147001CF9000F007C117D /* Base */ = {isa = PBXFileReference; lastKnownFileType = file.storyboard; name = Base; path = Base.lproj/LaunchScreen.storyboard; sourceTree = "<group>"; };
 		97C147021CF9000F007C117D /* Info.plist */ = {isa = PBXFileReference; lastKnownFileType = text.plist.xml; path = Info.plist; sourceTree = "<group>"; };
+		9AB6A6376A5B564C75021213 /* Pods-Runner.debug.xcconfig */ = {isa = PBXFileReference; includeInIndex = 1; lastKnownFileType = text.xcconfig; name = "Pods-Runner.debug.xcconfig"; path = "Target Support Files/Pods-Runner/Pods-Runner.debug.xcconfig"; sourceTree = "<group>"; };
+		BEA849415B99B81F15B90411 /* Pods-Runner.profile.xcconfig */ = {isa = PBXFileReference; includeInIndex = 1; lastKnownFileType = text.xcconfig; name = "Pods-Runner.profile.xcconfig"; path = "Target Support Files/Pods-Runner/Pods-Runner.profile.xcconfig"; sourceTree = "<group>"; };
+		C9B9F5A407D7DA7E78706F44 /* Pods-RunnerTests.debug.xcconfig */ = {isa = PBXFileReference; includeInIndex = 1; lastKnownFileType = text.xcconfig; name = "Pods-RunnerTests.debug.xcconfig"; path = "Target Support Files/Pods-RunnerTests/Pods-RunnerTests.debug.xcconfig"; sourceTree = "<group>"; };
+		C9DD438C0078BFF7D3028213 /* Pods_RunnerTests.framework */ = {isa = PBXFileReference; explicitFileType = wrapper.framework; includeInIndex = 0; path = Pods_RunnerTests.framework; sourceTree = BUILT_PRODUCTS_DIR; };
+		CB543AF7CF3C2BA5E6890584 /* Pods_Runner.framework */ = {isa = PBXFileReference; explicitFileType = wrapper.framework; includeInIndex = 0; path = Pods_Runner.framework; sourceTree = BUILT_PRODUCTS_DIR; };
+		EDC8FD7A4E8D5BBBA997D2A6 /* Pods-RunnerTests.profile.xcconfig */ = {isa = PBXFileReference; includeInIndex = 1; lastKnownFileType = text.xcconfig; name = "Pods-RunnerTests.profile.xcconfig"; path = "Target Support Files/Pods-RunnerTests/Pods-RunnerTests.profile.xcconfig"; sourceTree = "<group>"; };
 /* End PBXFileReference section */
 
 /* Begin PBXFrameworksBuildPhase section */
+		89B2C072CA347373FABD8C38 /* Frameworks */ = {
+			isa = PBXFrameworksBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+				9BACA88ECB65491A0EEB688D /* Pods_RunnerTests.framework in Frameworks */,
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+		};
 		97C146EB1CF9000F007C117D /* Frameworks */ = {
 			isa = PBXFrameworksBuildPhase;
 			buildActionMask = 2147483647;
 			files = (
 				78A318202AECB46A00862997 /* FlutterGeneratedPluginSwiftPackage in Frameworks */,
+				34041B2496A72135E4B071B4 /* Pods_Runner.framework in Frameworks */,
 			);
 			runOnlyForDeploymentPostprocessing = 0;
 		};
 /* End PBXFrameworksBuildPhase section */
 
 /* Begin PBXGroup section */
+		09CB05FCF369F3775B2B3891 /* Frameworks */ = {
+			isa = PBXGroup;
+			children = (
+				CB543AF7CF3C2BA5E6890584 /* Pods_Runner.framework */,
+				C9DD438C0078BFF7D3028213 /* Pods_RunnerTests.framework */,
+			);
+			name = Frameworks;
+			sourceTree = "<group>";
+		};
 		331C8082294A63A400263BE5 /* RunnerTests */ = {
 			isa = PBXGroup;
 			children = (
@@ -81,6 +109,20 @@
 			path = RunnerTests;
 			sourceTree = "<group>";
 		};
+		5CE4F8BE908145518F9F6FD7 /* Pods */ = {
+			isa = PBXGroup;
+			children = (
+				9AB6A6376A5B564C75021213 /* Pods-Runner.debug.xcconfig */,
+				28FE16A7518D0935AE2FC61F /* Pods-Runner.release.xcconfig */,
+				BEA849415B99B81F15B90411 /* Pods-Runner.profile.xcconfig */,
+				C9B9F5A407D7DA7E78706F44 /* Pods-RunnerTests.debug.xcconfig */,
+				4DCE31EA2B7306D288B2DAEC /* Pods-RunnerTests.release.xcconfig */,
+				EDC8FD7A4E8D5BBBA997D2A6 /* Pods-RunnerTests.profile.xcconfig */,
+			);
+			name = Pods;
+			path = Pods;
+			sourceTree = "<group>";
+		};
 		9740EEB11CF90186004384FC /* Flutter */ = {
 			isa = PBXGroup;
 			children = (
@@ -100,6 +142,8 @@
 				97C146F01CF9000F007C117D /* Runner */,
 				97C146EF1CF9000F007C117D /* Products */,
 				331C8082294A63A400263BE5 /* RunnerTests */,
+				5CE4F8BE908145518F9F6FD7 /* Pods */,
+				09CB05FCF369F3775B2B3891 /* Frameworks */,
 			);
 			sourceTree = "<group>";
 		};
@@ -135,8 +179,10 @@
 			isa = PBXNativeTarget;
 			buildConfigurationList = 331C8087294A63A400263BE5 /* Build configuration list for PBXNativeTarget "RunnerTests" */;
 			buildPhases = (
+				103D88911A896F4194A0F9F2 /* [CP] Check Pods Manifest.lock */,
 				331C807D294A63A400263BE5 /* Sources */,
 				331C807F294A63A400263BE5 /* Resources */,
+				89B2C072CA347373FABD8C38 /* Frameworks */,
 			);
 			buildRules = (
 			);
@@ -152,12 +198,14 @@
 			isa = PBXNativeTarget;
 			buildConfigurationList = 97C147051CF9000F007C117D /* Build configuration list for PBXNativeTarget "Runner" */;
 			buildPhases = (
+				07C3B5A3EE470508D2550EE8 /* [CP] Check Pods Manifest.lock */,
 				9740EEB61CF901F6004384FC /* Run Script */,
 				97C146EA1CF9000F007C117D /* Sources */,
 				97C146EB1CF9000F007C117D /* Frameworks */,
 				97C146EC1CF9000F007C117D /* Resources */,
 				9705A1C41CF9048500538489 /* Embed Frameworks */,
 				3B06AD1E1E4923F5004D2608 /* Thin Binary */,
+				E16E2CC2615A0974DF5FADFA /* [CP] Embed Pods Frameworks */,
 			);
 			buildRules = (
 			);
@@ -201,7 +249,7 @@
 			);
 			mainGroup = 97C146E51CF9000F007C117D;
 			packageReferences = (
-				781AD8BC2B33823900A9FFBB /* XCLocalSwiftPackageReference "Flutter/ephemeral/Packages/FlutterGeneratedPluginSwiftPackage" */,
+				781AD8BC2B33823900A9FFBB /* XCLocalSwiftPackageReference "FlutterGeneratedPluginSwiftPackage" */,
 			);
 			productRefGroup = 97C146EF1CF9000F007C117D /* Products */;
 			projectDirPath = "";
@@ -235,6 +283,50 @@
 /* End PBXResourcesBuildPhase section */
 
 /* Begin PBXShellScriptBuildPhase section */
+		07C3B5A3EE470508D2550EE8 /* [CP] Check Pods Manifest.lock */ = {
+			isa = PBXShellScriptBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+			);
+			inputFileListPaths = (
+			);
+			inputPaths = (
+				"${PODS_PODFILE_DIR_PATH}/Podfile.lock",
+				"${PODS_ROOT}/Manifest.lock",
+			);
+			name = "[CP] Check Pods Manifest.lock";
+			outputFileListPaths = (
+			);
+			outputPaths = (
+				"$(DERIVED_FILE_DIR)/Pods-Runner-checkManifestLockResult.txt",
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+			shellPath = /bin/sh;
+			shellScript = "diff \"${PODS_PODFILE_DIR_PATH}/Podfile.lock\" \"${PODS_ROOT}/Manifest.lock\" > /dev/null\nif [ $? != 0 ] ; then\n    # print error to STDERR\n    echo \"error: The sandbox is not in sync with the Podfile.lock. Run 'pod install' or update your CocoaPods installation.\" >&2\n    exit 1\nfi\n# This output is used by Xcode 'outputs' to avoid re-running this script phase.\necho \"SUCCESS\" > \"${SCRIPT_OUTPUT_FILE_0}\"\n";
+			showEnvVarsInLog = 0;
+		};
+		103D88911A896F4194A0F9F2 /* [CP] Check Pods Manifest.lock */ = {
+			isa = PBXShellScriptBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+			);
+			inputFileListPaths = (
+			);
+			inputPaths = (
+				"${PODS_PODFILE_DIR_PATH}/Podfile.lock",
+				"${PODS_ROOT}/Manifest.lock",
+			);
+			name = "[CP] Check Pods Manifest.lock";
+			outputFileListPaths = (
+			);
+			outputPaths = (
+				"$(DERIVED_FILE_DIR)/Pods-RunnerTests-checkManifestLockResult.txt",
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+			shellPath = /bin/sh;
+			shellScript = "diff \"${PODS_PODFILE_DIR_PATH}/Podfile.lock\" \"${PODS_ROOT}/Manifest.lock\" > /dev/null\nif [ $? != 0 ] ; then\n    # print error to STDERR\n    echo \"error: The sandbox is not in sync with the Podfile.lock. Run 'pod install' or update your CocoaPods installation.\" >&2\n    exit 1\nfi\n# This output is used by Xcode 'outputs' to avoid re-running this script phase.\necho \"SUCCESS\" > \"${SCRIPT_OUTPUT_FILE_0}\"\n";
+			showEnvVarsInLog = 0;
+		};
 		3B06AD1E1E4923F5004D2608 /* Thin Binary */ = {
 			isa = PBXShellScriptBuildPhase;
 			alwaysOutOfDate = 1;
@@ -266,6 +358,23 @@
 			shellPath = /bin/sh;
 			shellScript = "/bin/sh \"$FLUTTER_ROOT/packages/flutter_tools/bin/xcode_backend.sh\" build";
 		};
+		E16E2CC2615A0974DF5FADFA /* [CP] Embed Pods Frameworks */ = {
+			isa = PBXShellScriptBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+			);
+			inputFileListPaths = (
+				"${PODS_ROOT}/Target Support Files/Pods-Runner/Pods-Runner-frameworks-${CONFIGURATION}-input-files.xcfilelist",
+			);
+			name = "[CP] Embed Pods Frameworks";
+			outputFileListPaths = (
+				"${PODS_ROOT}/Target Support Files/Pods-Runner/Pods-Runner-frameworks-${CONFIGURATION}-output-files.xcfilelist",
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+			shellPath = /bin/sh;
+			shellScript = "\"${PODS_ROOT}/Target Support Files/Pods-Runner/Pods-Runner-frameworks.sh\"\n";
+			showEnvVarsInLog = 0;
+		};
 /* End PBXShellScriptBuildPhase section */
 
 /* Begin PBXSourcesBuildPhase section */
@@ -394,6 +503,7 @@
 		};
 		331C8088294A63A400263BE5 /* Debug */ = {
 			isa = XCBuildConfiguration;
+			baseConfigurationReference = C9B9F5A407D7DA7E78706F44 /* Pods-RunnerTests.debug.xcconfig */;
 			buildSettings = {
 				BUNDLE_LOADER = "$(TEST_HOST)";
 				CODE_SIGN_STYLE = Automatic;
@@ -411,6 +521,7 @@
 		};
 		331C8089294A63A400263BE5 /* Release */ = {
 			isa = XCBuildConfiguration;
+			baseConfigurationReference = 4DCE31EA2B7306D288B2DAEC /* Pods-RunnerTests.release.xcconfig */;
 			buildSettings = {
 				BUNDLE_LOADER = "$(TEST_HOST)";
 				CODE_SIGN_STYLE = Automatic;
@@ -426,6 +537,7 @@
 		};
 		331C808A294A63A400263BE5 /* Profile */ = {
 			isa = XCBuildConfiguration;
+			baseConfigurationReference = EDC8FD7A4E8D5BBBA997D2A6 /* Pods-RunnerTests.profile.xcconfig */;
 			buildSettings = {
 				BUNDLE_LOADER = "$(TEST_HOST)";
 				CODE_SIGN_STYLE = Automatic;
@@ -633,7 +745,7 @@
 /* End XCConfigurationList section */
 
 /* Begin XCLocalSwiftPackageReference section */
-		781AD8BC2B33823900A9FFBB /* XCLocalSwiftPackageReference "Flutter/ephemeral/Packages/FlutterGeneratedPluginSwiftPackage" */ = {
+		781AD8BC2B33823900A9FFBB /* XCLocalSwiftPackageReference "FlutterGeneratedPluginSwiftPackage" */ = {
 			isa = XCLocalSwiftPackageReference;
 			relativePath = Flutter/ephemeral/Packages/FlutterGeneratedPluginSwiftPackage;
 		};
diff --git a/example/ios/Runner.xcworkspace/contents.xcworkspacedata b/example/ios/Runner.xcworkspace/contents.xcworkspacedata
index 1d526a1..21a3cc1 100644
--- a/example/ios/Runner.xcworkspace/contents.xcworkspacedata
+++ b/example/ios/Runner.xcworkspace/contents.xcworkspacedata
@@ -4,4 +4,7 @@
    <FileRef
       location = "group:Runner.xcodeproj">
    </FileRef>
+   <FileRef
+      location = "group:Pods/Pods.xcodeproj">
+   </FileRef>
 </Workspace>
diff --git a/example/lib/room_screen.dart b/example/lib/room_screen.dart
index 94a3068..cc547e9 100644
--- a/example/lib/room_screen.dart
+++ b/example/lib/room_screen.dart
@@ -24,18 +24,32 @@ class RoomScreen extends StatefulWidget {
 }
 
 class _RemoteVideo {
-  _RemoteVideo(this.renderer, this.label);
+  _RemoteVideo(this.stream, this.label);
 
-  final RTCVideoRenderer renderer;
+  final MediaStream? stream;
   final String label;
 }
 
+/// Keeps the local camera running on iOS while picture-in-picture is up
+/// (it needs the `voip` background mode).
+const _pipOptions = PictureInPictureOptions(allowsCameraInBackground: true);
+
+/// iOS does not start picture-in-picture on its own when the app goes to
+/// the background while more than one view offers it. Like the React Native
+/// example, only the first remote video does. Your own camera does not:
+/// it may be off.
+const _noPip = PictureInPictureOptions(enabled: false);
+
 class _RoomScreenState extends State<RoomScreen> {
   // Tracks are published again after a reconnection, with new ids
   // (`ReconnectConfig.addTracksOnReconnect`, on by default).
   final _client = FishjamClient();
-  final _localRenderer = RTCVideoRenderer();
   final _remote = <String, _RemoteVideo>{};
+  // The picture-in-picture button always starts the first remote tile. Keep
+  // its controller when that peer reconnects: Flutter does not rebuild tiles
+  // while the app is hidden, but the controller can update the native window.
+  final _remotePip = PictureInPictureController();
+  final _localPip = PictureInPictureController();
   final _subscriptions = <StreamSubscription<Object?>>[];
 
   MediaStream? _localStream;
@@ -173,7 +187,6 @@ class _RoomScreenState extends State<RoomScreen> {
   };
 
   Future<void> _start() async {
-    await _localRenderer.initialize();
     _subscriptions.add(_client.events.listen(_onEvent));
     try {
       // Asks for camera and microphone permission.
@@ -184,7 +197,6 @@ class _RoomScreenState extends State<RoomScreen> {
       _localStream = stream;
       _camera = stream.getVideoTracks().firstOrNull;
       _microphone = stream.getAudioTracks().firstOrNull;
-      _localRenderer.srcObject = stream;
       if (mounted) setState(() {});
 
       // Keeps the call running in the background. The service types follow
@@ -247,8 +259,14 @@ class _RoomScreenState extends State<RoomScreen> {
         // tile; ready tracks come back with TrackReady.
         _clearRemoteVideos();
       case TrackRemoved(:final track):
-        unawaited(_remote.remove(track.trackId)?.renderer.dispose());
-        setState(() {});
+        final video = _remote[track.trackId];
+        // Keep the PiP window open with its fallback while this peer
+        // reconnects. Flutter does not rebuild tiles in the background, so
+        // explicitly clear its native track now.
+        if (identical(video, _remote.values.firstOrNull)) {
+          unawaited(_remotePip.setMediaStream(null));
+        }
+        setState(() => _remote.remove(track.trackId));
       case LocalTrackAdded(:final track):
         // After a reconnection the restored tracks get new ids.
         if (track.track?.id == _camera?.id) _cameraTrackId = track.trackId;
@@ -269,31 +287,26 @@ class _RoomScreenState extends State<RoomScreen> {
     }
   }
 
-  void _clearRemoteVideos() {
-    for (final video in _remote.values) {
-      unawaited(video.renderer.dispose());
-    }
-    setState(_remote.clear);
-  }
+  void _clearRemoteVideos() => setState(_remote.clear);
 
   Future<void> _addRemoteVideo(RemoteTrackContext track) async {
-    final renderer = RTCVideoRenderer();
-    await renderer.initialize();
-    // The track may have gone (or the screen closed) while initializing.
+    // The track may have gone while the event was queued.
     final current = _client.remoteTracks[track.trackId];
-    if (!mounted || current == null || !current.isReady) {
-      await renderer.dispose();
-      return;
-    }
-    renderer.srcObject = current.stream;
+    if (!mounted || current == null || !current.isReady) return;
+    final stream = current.stream;
     final peer = _client.remotePeers[track.endpointId];
     final name = switch (peer?.metadata.peer) {
       {'name': final String name} => name,
       _ => track.endpointId,
     };
-    final previous = _remote[track.trackId];
-    setState(() => _remote[track.trackId] = _RemoteVideo(renderer, name));
-    await previous?.renderer.dispose();
+    // A reconnect can deliver the new track while this app is backgrounded.
+    // The tile will not rebuild until the app returns, so update the native
+    // window immediately instead of leaving its fallback visible.
+    if (_remotePip.isActive) {
+      await _remotePip.setMediaStream(stream);
+    }
+    if (!mounted) return;
+    setState(() => _remote[track.trackId] = _RemoteVideo(stream, name));
   }
 
   /// Muting replaces the sent media with nothing; unmuting puts it back.
@@ -362,10 +375,6 @@ class _RoomScreenState extends State<RoomScreen> {
     for (final s in _subscriptions) {
       unawaited(s.cancel());
     }
-    for (final video in _remote.values) {
-      unawaited(video.renderer.dispose());
-    }
-    unawaited(_localRenderer.dispose());
     unawaited(_client.dispose());
     unawaited(ForegroundService.instance.stop());
     unawaited(_callKit.endSession());
@@ -383,12 +392,21 @@ class _RoomScreenState extends State<RoomScreen> {
   Widget build(BuildContext context) {
     final tiles = [
       _VideoTile(
-        renderer: _localRenderer,
+        stream: _localStream,
         label: '${widget.displayName} (you)',
         mirror: true,
+        pip: _localPip,
+        pipOptions: _noPip,
       ),
       for (final video in _remote.values)
-        _VideoTile(renderer: video.renderer, label: video.label),
+        _VideoTile(
+          stream: video.stream,
+          label: video.label,
+          pip: identical(video, _remote.values.first) ? _remotePip : null,
+          pipOptions: identical(video, _remote.values.first)
+              ? _pipOptions
+              : _noPip,
+        ),
     ];
     return Scaffold(
       appBar: AppBar(title: Text(_status)),
@@ -425,6 +443,15 @@ class _RoomScreenState extends State<RoomScreen> {
           onPressed: _toggleCamera,
           icon: Icon(_cameraOn ? Icons.videocam : Icons.videocam_off),
         ),
+        IconButton.filledTonal(
+          tooltip: 'Picture in picture',
+          onPressed:
+              (_remotePip.isActive || _remote.isNotEmpty
+                      ? _remotePip
+                      : _localPip)
+                  .start,
+          icon: const Icon(Icons.picture_in_picture_alt),
+        ),
         IconButton.filledTonal(
           onPressed: _chooseAudioOutput,
           icon: Icon(_audioIcon(_audio.currentAudioOutput?.type)),
@@ -442,13 +469,17 @@ class _RoomScreenState extends State<RoomScreen> {
 
 class _VideoTile extends StatelessWidget {
   const _VideoTile({
-    required this.renderer,
     required this.label,
+    required this.pipOptions,
+    this.stream,
+    this.pip,
     this.mirror = false,
   });
 
-  final RTCVideoRenderer renderer;
+  final MediaStream? stream;
   final String label;
+  final PictureInPictureController? pip;
+  final PictureInPictureOptions pipOptions;
   final bool mirror;
 
   @override
@@ -459,10 +490,11 @@ class _VideoTile extends StatelessWidget {
       children: [
         ColoredBox(
           color: Colors.black,
-          child: RTCVideoView(
-            renderer,
+          child: PictureInPictureView(
+            mediaStream: stream,
+            controller: pip,
             mirror: mirror,
-            objectFit: RTCVideoViewObjectFit.RTCVideoViewObjectFitCover,
+            pipOptions: pipOptions,
           ),
         ),
         Positioned(
diff --git a/example/pubspec.yaml b/example/pubspec.yaml
index bd3d8ad..5d6290b 100644
--- a/example/pubspec.yaml
+++ b/example/pubspec.yaml
@@ -22,4 +22,10 @@ dev_dependencies:
     sdk: flutter
 
 flutter:
+  # This app lives inside the fishjam_client plugin. With Swift Package Manager, the Flutter tool copies
+  # the whole plugin directory into build/ios/SourcePackages because the plugin's Package.swift depends
+  # on flutter_webrtc; that destination is inside the plugin, so the copy recurses. CocoaPods is used
+  # instead until the Flutter tool excludes example/ from that copy (flutter/flutter#188647).
+  config:
+    enable-swift-package-manager: false
   uses-material-design: true
diff --git a/ios/fishjam_client.podspec b/ios/fishjam_client.podspec
index e0d6989..4727ce4 100644
--- a/ios/fishjam_client.podspec
+++ b/ios/fishjam_client.podspec
@@ -12,6 +12,12 @@ audio, video and data from iOS and Android apps.
   s.source           = { :path => '.' }
   s.source_files = 'fishjam_client/Sources/fishjam_client/**/*'
   s.dependency 'Flutter'
+  # The WebRTC symbols come from flutter_webrtc's static framework, so this pod must be static too.
+  s.static_framework = true
+  # Picture-in-picture imports WebRTC. No version here: CocoaPods uses the
+  # WebRTC-SDK pin from flutter_webrtc (150.7871.01 in flutter_webrtc 1.6.2).
+  s.dependency 'flutter_webrtc'
+  s.dependency 'WebRTC-SDK'
   s.platform = :ios, '13.0'
   s.pod_target_xcconfig = { 'DEFINES_MODULE' => 'YES', 'EXCLUDED_ARCHS[sdk=iphonesimulator*]' => 'i386' }
   s.swift_version = '5.0'
diff --git a/ios/fishjam_client/Package.swift b/ios/fishjam_client/Package.swift
index c9fb4d6..9d8dec4 100644
--- a/ios/fishjam_client/Package.swift
+++ b/ios/fishjam_client/Package.swift
@@ -11,13 +11,18 @@ let package = Package(
         .library(name: "fishjam-client", targets: ["fishjam_client"])
     ],
     dependencies: [
-        .package(name: "FlutterFramework", path: "../FlutterFramework")
+        .package(name: "FlutterFramework", path: "../FlutterFramework"),
+        // The Flutter tool resolves this path to the flutter_webrtc plugin package.
+        // WebRTC below is that package's own binary (150.7871.01 in flutter_webrtc 1.6.2).
+        .package(name: "flutter_webrtc", path: "../flutter_webrtc")
     ],
     targets: [
         .target(
             name: "fishjam_client",
             dependencies: [
-                .product(name: "FlutterFramework", package: "FlutterFramework")
+                .product(name: "FlutterFramework", package: "FlutterFramework"),
+                .product(name: "flutter-webrtc", package: "flutter_webrtc"),
+                .product(name: "WebRTC", package: "flutter_webrtc")
             ]
         )
     ]
diff --git a/ios/fishjam_client/Sources/fishjam_client/FishjamClientPlugin.swift b/ios/fishjam_client/Sources/fishjam_client/FishjamClientPlugin.swift
index 06d1daa..54efd37 100644
--- a/ios/fishjam_client/Sources/fishjam_client/FishjamClientPlugin.swift
+++ b/ios/fishjam_client/Sources/fishjam_client/FishjamClientPlugin.swift
@@ -7,6 +7,7 @@ public class FishjamClientPlugin: NSObject, FlutterPlugin, FlutterStreamHandler
     self?.audioEventSink?(event)
   }
   private let callKitEvents = EventSinkHandler()
+  private let pictureInPicture = PictureInPictureManager()
   private lazy var callKit = CallKitManager { [weak self] event in
     self?.callKitEvents.sink?(event)
   }
@@ -40,6 +41,20 @@ public class FishjamClientPlugin: NSObject, FlutterPlugin, FlutterStreamHandler
       binaryMessenger: registrar.messenger()
     )
     callKitEvents.setStreamHandler(instance.callKitEvents)
+
+    let pipChannel = FlutterMethodChannel(
+      name: "io.fishjam.client/pip",
+      binaryMessenger: registrar.messenger()
+    )
+    pipChannel.setMethodCallHandler { [weak instance] call, result in
+      guard let instance else { return result(FlutterMethodNotImplemented) }
+      instance.pictureInPicture.handle(call, result: result)
+    }
+    let pipEvents = FlutterEventChannel(
+      name: "io.fishjam.client/pip_events",
+      binaryMessenger: registrar.messenger()
+    )
+    pipEvents.setStreamHandler(instance.pictureInPicture)
   }
 
   private func handleAudio(_ call: FlutterMethodCall, result: @escaping FlutterResult) {
diff --git a/ios/fishjam_client/Sources/fishjam_client/PictureInPictureManager.swift b/ios/fishjam_client/Sources/fishjam_client/PictureInPictureManager.swift
new file mode 100644
index 0000000..4a58199
--- /dev/null
+++ b/ios/fishjam_client/Sources/fishjam_client/PictureInPictureManager.swift
@@ -0,0 +1,641 @@
+import AVKit
+import Flutter
+import UIKit
+import WebRTC
+
+/// Handles `io.fishjam.client/pip`: each `PictureInPictureView` on the Dart
+/// side gets its own `PipController` here, keyed by view id. This mirrors
+/// the React Native SDK, where every `RTCView` with `pip` set owns one
+/// `PIPController` (`react-native-webrtc/ios/RCTWebRTC/PIPController.m`):
+/// there is no single "offered" view and no "most recently updated wins".
+final class PictureInPictureManager: NSObject, FlutterStreamHandler {
+  private var eventSink: FlutterEventSink?
+  private var controllers: [Int: AnyObject] = [:]
+  /// Controllers whose window is still closing. Releasing one while it is
+  /// active leaves the system window up on the last frame.
+  private var retiring: [AnyObject] = []
+
+  func handle(_ call: FlutterMethodCall, result: @escaping FlutterResult) {
+    let args = call.arguments as? [String: Any] ?? [:]
+    guard let id = args["viewId"] as? Int else { return result(nil) }
+    switch call.method {
+    case "update":
+      if #available(iOS 15.0, *) { update(viewId: id, args: args) }
+      result(nil)
+    case "start":
+      if #available(iOS 15.0, *) { controller(id)?.start() }
+      result(nil)
+    case "stop":
+      if #available(iOS 15.0, *) { controller(id)?.stop() }
+      result(nil)
+    case "unregister":
+      tearDown(viewId: id)
+      result(nil)
+    default:
+      result(FlutterMethodNotImplemented)
+    }
+  }
+
+  @available(iOS 15.0, *)
+  private func controller(_ id: Int) -> PipController? { controllers[id] as? PipController }
+
+  @available(iOS 15.0, *)
+  private func update(viewId id: Int, args: [String: Any]) {
+    // Unsupported (e.g. on the simulator), `AVPictureInPictureController`
+    // returns nil from an initializer Swift treats as non-failable.
+    guard AVPictureInPictureController.isPictureInPictureSupported(),
+      let sourceView = Self.flutterRootView()
+    else { return }
+
+    let pip: PipController
+    if let existing = controller(id) {
+      pip = existing
+    } else {
+      pip = PipController(rootView: sourceView) { [weak self] active in
+        self?.eventSink?(["viewId": id, "isActive": active])
+      }
+      controllers[id] = pip
+    }
+
+    pip.setPlaceholder(
+      label: args["fallbackLabel"] as? String ?? "No video",
+      background: Self.color(args["fallbackBackgroundColor"], fallback: 0xFF1C2945),
+      text: Self.color(args["fallbackTextColor"], fallback: 0xFFFFFFFF)
+    )
+    pip.videoTrack = (args["trackId"] as? String).flatMap(FlutterWebRtcLookup.videoTrack)
+    pip.objectFitContain = (args["objectFit"] as? String) == "contain"
+    if let rect = args["rect"] as? [String: Any] {
+      pip.setSourceFrame(
+        CGRect(
+          x: number(rect["x"]),
+          y: number(rect["y"]),
+          width: number(rect["width"]),
+          height: number(rect["height"])
+        )
+      )
+    }
+    pip.preferredSize = Self.preferredSize(args["preferredSize"])
+    pip.startAutomatically = args["startAutomatically"] as? Bool ?? true
+    pip.stopAutomatically = args["stopAutomatically"] as? Bool ?? true
+    pip.allowsCameraInBackground = args["allowsCameraInBackground"] as? Bool ?? false
+  }
+
+  private func tearDown(viewId id: Int) {
+    if #available(iOS 15.0, *) {
+      let active = controller(id)?.isActive ?? false
+      if let pip = controller(id), active {
+        retiring.append(pip)
+        pip.retire { [weak self] in
+          self?.retiring.removeAll { $0 === pip }
+        }
+      } else {
+        controller(id)?.invalidate()
+      }
+    }
+    controllers.removeValue(forKey: id)
+  }
+
+  /// React Native uses 1920×1080 when `preferredSize` is missing or not a
+  /// pair of positive numbers.
+  private static func preferredSize(_ value: Any?) -> CGSize {
+    let fallback = CGSize(width: 1920, height: 1080)
+    guard let size = value as? [String: Any] else { return fallback }
+    let width = CGFloat((size["width"] as? NSNumber)?.doubleValue ?? 0)
+    let height = CGFloat((size["height"] as? NSNumber)?.doubleValue ?? 0)
+    guard width > 0, height > 0 else { return fallback }
+    return CGSize(width: width, height: height)
+  }
+
+  private func number(_ value: Any?) -> CGFloat {
+    CGFloat((value as? NSNumber)?.doubleValue ?? 0)
+  }
+
+  /// `argb` is the 0xAARRGGBB int Dart sends for a [Color].
+  private static func color(_ value: Any?, fallback: UInt32) -> UIColor {
+    let argb = (value as? NSNumber)?.uint32Value ?? fallback
+    return UIColor(
+      red: CGFloat((argb >> 16) & 0xFF) / 255,
+      green: CGFloat((argb >> 8) & 0xFF) / 255,
+      blue: CGFloat(argb & 0xFF) / 255,
+      alpha: CGFloat((argb >> 24) & 0xFF) / 255
+    )
+  }
+
+  fileprivate static func flutterRootView() -> UIView? {
+    let windows = UIApplication.shared.connectedScenes
+      .compactMap { $0 as? UIWindowScene }
+      .flatMap(\.windows)
+    let window = windows.first(where: \.isKeyWindow) ?? windows.first
+    return window?.rootViewController?.view
+  }
+
+  func onListen(withArguments arguments: Any?, eventSink events: @escaping FlutterEventSink)
+    -> FlutterError?
+  {
+    eventSink = events
+    return nil
+  }
+
+  func onCancel(withArguments arguments: Any?) -> FlutterError? {
+    eventSink = nil
+    return nil
+  }
+}
+
+/// Port of the React Native SDK's `PIPController`
+/// (`react-native-webrtc/ios/RCTWebRTC/PIPController.m`): one instance per
+/// view, holding its own `AVPictureInPictureController`.
+@available(iOS 15.0, *)
+private final class PipController: NSObject, AVPictureInPictureControllerDelegate {
+  private let sampleView = SampleBufferVideoCallView()
+  private let callViewController = AVPictureInPictureVideoCallViewController()
+  private var pip: AVPictureInPictureController
+  private let onChange: (Bool) -> Void
+  private var activeObservation: NSKeyValueObservation?
+  private var cameraAccessApplied = false
+  private var retireCompletion: (() -> Void)?
+  private let fallbackView = PipFallbackView()
+  /// The window's `activeVideoCallSourceView`. iOS animates picture-in-picture
+  /// to and from this view's frame, so the frame is the video tile, not the
+  /// screen. `stop()` removes it while the app is hidden, because that is a
+  /// close iOS performs itself (`stopPictureInPicture()` is ignored then).
+  /// The controller created with this view then never reports
+  /// picture-in-picture as possible again, so once the window has closed the
+  /// view is put back and a new controller is created. The Flutter root
+  /// retains it until [detachSourceView] on teardown.
+  private let sourceView = UIView()
+  private weak var rootView: UIView?
+  /// Safety net for `stop()` in the background: if removing [sourceView]
+  /// does not make iOS close the window on its own, force the close once the
+  /// app returns (iOS honors `stopPictureInPicture()` again then).
+  private var closeOnForeground = false
+  /// [sourceView] was removed to close the window while the app was hidden.
+  private var sourceDetachedForClose = false
+  private var restoreScheduled = false
+  /// After that close, open the window again if a video track is set while
+  /// the app is still hidden and automatic start is on.
+  private var resumeWhenTrackReturns = false
+  private var enteringForeground = false
+  private var tornDown = false
+
+  var stopAutomatically = true
+
+  deinit {
+    sourceView.removeFromSuperview()
+  }
+
+  init(rootView: UIView, onChange: @escaping (Bool) -> Void) {
+    self.onChange = onChange
+    self.rootView = rootView
+    callViewController.view.backgroundColor = .black
+    sourceView.backgroundColor = .clear
+    sourceView.isUserInteractionEnabled = false
+    sourceView.isAccessibilityElement = false
+    // On top of the Flutter view, clear, so iOS treats the tile frame as
+    // visible. Touches pass through.
+    rootView.addSubview(sourceView)
+    pip = Self.makeController(
+      sourceView: sourceView,
+      contentViewController: callViewController
+    )
+    super.init()
+    configureController(startAutomatically: true)
+    NotificationCenter.default.addObserver(
+      self,
+      selector: #selector(willResignActive),
+      name: UIApplication.willResignActiveNotification,
+      object: nil
+    )
+    NotificationCenter.default.addObserver(
+      self,
+      selector: #selector(willEnterForeground),
+      name: UIApplication.willEnterForegroundNotification,
+      object: nil
+    )
+    NotificationCenter.default.addObserver(
+      self,
+      selector: #selector(didBecomeActive),
+      name: UIApplication.didBecomeActiveNotification,
+      object: nil
+    )
+  }
+
+  private static func makeController(
+    sourceView: UIView,
+    contentViewController: AVPictureInPictureVideoCallViewController
+  ) -> AVPictureInPictureController {
+    AVPictureInPictureController(
+      contentSource: .init(
+        activeVideoCallSourceView: sourceView,
+        contentViewController: contentViewController
+      )
+    )
+  }
+
+  private func configureController(startAutomatically automatic: Bool) {
+    pip.canStartPictureInPictureAutomaticallyFromInline = automatic
+    pip.delegate = self
+    activeObservation = pip.observe(\.isPictureInPictureActive, options: [.initial, .new]) {
+      [weak self] _, _ in
+      self?.updateShouldRender()
+    }
+  }
+
+  var isActive: Bool { pip.isPictureInPictureActive }
+
+  var videoTrack: RTCVideoTrack? {
+    didSet {
+      guard oldValue !== videoTrack else { return }
+      oldValue?.remove(sampleView)
+      if let videoTrack {
+        videoTrack.add(sampleView)
+        fallbackView.removeFromSuperview()
+        if sampleView.superview == nil { fill(callViewController.view, with: sampleView) }
+      } else {
+        sampleView.removeFromSuperview()
+        if pip.isPictureInPictureActive { showFallback() }
+      }
+      updateShouldRender()
+      guard videoTrack != nil else { return }
+      if sourceDetachedForClose {
+        scheduleRestoreAfterBackgroundClose()
+      } else {
+        resumeIfStillBackgrounded()
+      }
+    }
+  }
+
+  var objectFitContain = false {
+    didSet {
+      sampleView.sampleBufferLayer.videoGravity = objectFitContain ? .resizeAspect : .resizeAspectFill
+    }
+  }
+
+  var preferredSize: CGSize {
+    get { callViewController.preferredContentSize }
+    set {
+      guard newValue.width > 0, newValue.height > 0,
+        newValue != callViewController.preferredContentSize
+      else { return }
+      callViewController.preferredContentSize = newValue
+      sampleView.requestScaleRecalculation()
+    }
+  }
+
+  var startAutomatically: Bool {
+    get { pip.canStartPictureInPictureAutomaticallyFromInline }
+    set {
+      pip.canStartPictureInPictureAutomaticallyFromInline = newValue
+      updateShouldRender()
+    }
+  }
+
+  /// An empty sample-buffer layer is not started when the app backgrounds.
+  /// Render while automatic start is on, not only after the window is up.
+  /// Starting the window from code during the hide cancels the hide.
+  private func updateShouldRender() {
+    sampleView.shouldRender = videoTrack != nil
+      && (pip.isPictureInPictureActive || startAutomatically)
+  }
+
+  var allowsCameraInBackground = false {
+    didSet {
+      if allowsCameraInBackground || cameraAccessApplied {
+        cameraAccessApplied = Self.setMultitaskingCameraAccess(allowsCameraInBackground)
+          && allowsCameraInBackground
+      }
+    }
+  }
+
+  /// `frame` is the video tile in the Flutter view's coordinates (logical
+  /// pixels, same as points). That rectangle is where the system animation
+  /// starts and ends.
+  func setSourceFrame(_ frame: CGRect) {
+    guard frame.width > 1, frame.height > 1 else { return }
+    sourceView.frame = frame
+    sourceView.superview?.bringSubviewToFront(sourceView)
+  }
+
+  func start() {
+    if pip.isPictureInPicturePossible { pip.startPictureInPicture() }
+  }
+
+  /// The window's aspect ratio stays [preferredSize] (e.g. 16:9, matching the
+  /// React Native SDK's default) while floating. If that does not match the
+  /// tile's aspect ratio, closing to the tile animates in two visible steps:
+  /// the window first grows to fit the screen at its own aspect ratio, with
+  /// black bars for the gap to the tile's aspect, then only after that jumps
+  /// to the tile's shape. Matching the tile's aspect ratio just before the
+  /// window closes removes that first step.
+  private func matchContentSizeToTile() {
+    preferredSize = sourceView.bounds.size
+  }
+
+  func stop() {
+    guard pip.isPictureInPictureActive else { return }
+    matchContentSizeToTile()
+    if UIApplication.shared.applicationState == .background {
+      // iOS ignores an explicit stopPictureInPicture() call while the app is
+      // hidden. Removing the source view from the screen is a close the
+      // system drives itself, the same way it closes React Native's window
+      // once its RTCView unmounts, so it works while hidden too. The view is
+      // put back in [restoreAfterBackgroundClose] once the window has closed.
+      closeOnForeground = true
+      videoTrack = nil
+      sourceDetachedForClose = true
+      sourceView.removeFromSuperview()
+    }
+    pip.stopPictureInPicture()
+  }
+
+  /// Puts [sourceView] back on the Flutter root and creates a new controller.
+  /// The one that saw the view leave the hierarchy keeps
+  /// `isPictureInPicturePossible` false, so a reconnect that reuses this
+  /// object (the tile stays mounted) could never open the window again.
+  private func scheduleRestoreAfterBackgroundClose() {
+    guard sourceDetachedForClose, !restoreScheduled, !tornDown, retireCompletion == nil else {
+      return
+    }
+    restoreScheduled = true
+    DispatchQueue.main.async { [weak self] in
+      guard let self else { return }
+      self.restoreScheduled = false
+      self.restoreAfterBackgroundClose()
+    }
+  }
+
+  private func restoreAfterBackgroundClose() {
+    guard sourceDetachedForClose, !closeOnForeground, !tornDown, retireCompletion == nil else {
+      return
+    }
+    guard !pip.isPictureInPictureActive else { return }
+    attachSourceView()
+    guard sourceView.window != nil else { return }
+    sourceDetachedForClose = false
+    let automatic = pip.canStartPictureInPictureAutomaticallyFromInline
+    activeObservation = nil
+    pip.delegate = nil
+    pip = Self.makeController(
+      sourceView: sourceView,
+      contentViewController: callViewController
+    )
+    configureController(startAutomatically: automatic)
+    updateShouldRender()
+    resumeWhenTrackReturns = automatic
+      && !enteringForeground
+      && UIApplication.shared.applicationState == .background
+    resumeIfStillBackgrounded()
+    DispatchQueue.main.async { [weak self] in self?.resumeIfStillBackgrounded() }
+  }
+
+  private func attachSourceView() {
+    if rootView?.window == nil {
+      rootView = PictureInPictureManager.flutterRootView()
+    }
+    guard let rootView else { return }
+    if sourceView.superview !== rootView {
+      sourceView.removeFromSuperview()
+      rootView.addSubview(sourceView)
+    }
+    rootView.bringSubviewToFront(sourceView)
+  }
+
+  /// The track often arrives after the window has already closed (the peer
+  /// reconnects while the app is hidden). Automatic start only runs on the
+  /// transition to the background, which already happened, so open it here.
+  private func resumeIfStillBackgrounded() {
+    guard resumeWhenTrackReturns,
+      !enteringForeground,
+      !tornDown,
+      UIApplication.shared.applicationState == .background,
+      startAutomatically,
+      videoTrack != nil,
+      !pip.isPictureInPictureActive,
+      pip.isPictureInPicturePossible
+    else { return }
+    resumeWhenTrackReturns = false
+    pip.startPictureInPicture()
+  }
+
+  /// Text and colors for [fallbackView]. Applied on every update, so a
+  /// change shows up even while the window is already open.
+  func setPlaceholder(label: String, background: UIColor, text: UIColor) {
+    fallbackView.apply(label: label, background: background, text: text)
+  }
+
+  /// Same role as the React Native `PIPController` fallback view: what the
+  /// window shows once the camera track is gone.
+  private func showFallback() {
+    if fallbackView.superview == nil { fill(callViewController.view, with: fallbackView) }
+  }
+
+  /// Stop the window, then drop this controller only after iOS has closed it.
+  /// Clearing the track or releasing `self` earlier freezes the window.
+  func retire(completion: @escaping () -> Void) {
+    retireCompletion = completion
+    if pip.isPictureInPictureActive {
+      stop()
+    } else {
+      finishRetirement()
+    }
+  }
+
+  private func finishRetirement() {
+    tornDown = true
+    resumeWhenTrackReturns = false
+    videoTrack = nil
+    if cameraAccessApplied { allowsCameraInBackground = false }
+    activeObservation = nil
+    NotificationCenter.default.removeObserver(self)
+    detachSourceView()
+    let completion = retireCompletion
+    retireCompletion = nil
+    completion?()
+  }
+
+  func invalidate() {
+    tornDown = true
+    resumeWhenTrackReturns = false
+    stop()
+    videoTrack = nil
+    if cameraAccessApplied { allowsCameraInBackground = false }
+    activeObservation = nil
+    NotificationCenter.default.removeObserver(self)
+    detachSourceView()
+  }
+
+  /// The Flutter root keeps [sourceView] until this runs. `stop()` may
+  /// already have removed it.
+  private func detachSourceView() {
+    sourceView.removeFromSuperview()
+  }
+
+  /// The capture session may not exist when the option is first set (the
+  /// camera starts later), and a new session drops the flag. Set it again at
+  /// the last moment iOS still allows it.
+  @objc private func willResignActive() {
+    if allowsCameraInBackground {
+      cameraAccessApplied = Self.setMultitaskingCameraAccess(true)
+    }
+  }
+
+  @objc private func willEnterForeground() {
+    enteringForeground = true
+    // The user is opening the app. Do not pop the window back up on the way in.
+    resumeWhenTrackReturns = false
+    guard stopAutomatically || closeOnForeground else { return }
+    DispatchQueue.main.asyncAfter(deadline: .now() + 0.5) { [weak self] in
+      guard let self else { return }
+      self.stop()
+      // `didStop` normally puts the source view back. If removing it closed
+      // the window without that callback, do it here once iOS will accept
+      // `stopPictureInPicture()` again. Replacing the controller earlier
+      // drops that callback.
+      guard self.sourceDetachedForClose, !self.pip.isPictureInPictureActive else { return }
+      self.closeOnForeground = false
+      self.onChange(false)
+      self.scheduleRestoreAfterBackgroundClose()
+    }
+  }
+
+  @objc private func didBecomeActive() {
+    enteringForeground = false
+    resumeWhenTrackReturns = false
+    guard sourceDetachedForClose, !pip.isPictureInPictureActive, !closeOnForeground else { return }
+    scheduleRestoreAfterBackgroundClose()
+  }
+
+  private func fill(_ container: UIView, with view: UIView) {
+    view.translatesAutoresizingMaskIntoConstraints = false
+    container.addSubview(view)
+    NSLayoutConstraint.activate([
+      view.leadingAnchor.constraint(equalTo: container.leadingAnchor),
+      view.trailingAnchor.constraint(equalTo: container.trailingAnchor),
+      view.topAnchor.constraint(equalTo: container.topAnchor),
+      view.bottomAnchor.constraint(equalTo: container.bottomAnchor),
+    ])
+  }
+
+  private static var didLogCameraAccessFailure = false
+
+  private static func setMultitaskingCameraAccess(_ enabled: Bool) -> Bool {
+    guard #available(iOS 16.0, *) else { return false }
+    guard let session = FlutterWebRtcLookup.captureSession() else { return false }
+    guard session.isMultitaskingCameraAccessSupported else {
+      if enabled { logCameraAccessFailure() }
+      return false
+    }
+    if session.isMultitaskingCameraAccessEnabled != enabled {
+      session.beginConfiguration()
+      session.isMultitaskingCameraAccessEnabled = enabled
+      session.commitConfiguration()
+    }
+    return true
+  }
+
+  private static func logCameraAccessFailure() {
+    guard !didLogCameraAccessFailure else { return }
+    didLogCameraAccessFailure = true
+    NSLog(
+      "[FISHJAM] The camera will stop in the background: multitasking camera access is not supported. "
+        + "On iOS 18 or newer, add voip to UIBackgroundModes. Before that, the "
+        + "com.apple.developer.avfoundation.multitasking-camera-access entitlement is also required."
+    )
+  }
+
+  func pictureInPictureController(
+    _ pictureInPictureController: AVPictureInPictureController,
+    restoreUserInterfaceForPictureInPictureStopWithCompletionHandler completionHandler:
+      @escaping (Bool) -> Void
+  ) {
+    // The user tapped the window's own restore button, not `stop()`: match
+    // the tile's aspect ratio here too, for the same reason as in `stop()`.
+    matchContentSizeToTile()
+    // The tile is already on screen. Waiting here is the full-screen
+    // letterbox that plays before the move onto the tile.
+    completionHandler(true)
+  }
+
+  func pictureInPictureControllerDidStartPictureInPicture(
+    _ pictureInPictureController: AVPictureInPictureController
+  ) {
+    onChange(true)
+  }
+
+  func pictureInPictureControllerDidStopPictureInPicture(
+    _ pictureInPictureController: AVPictureInPictureController
+  ) {
+    closeOnForeground = false
+    fallbackView.removeFromSuperview()
+    updateShouldRender()
+    onChange(false)
+    if retireCompletion != nil {
+      finishRetirement()
+    } else {
+      scheduleRestoreAfterBackgroundClose()
+    }
+  }
+
+  func pictureInPictureController(
+    _ pictureInPictureController: AVPictureInPictureController,
+    failedToStartPictureInPictureWithError error: Error
+  ) {
+    NSLog("[FISHJAM] Picture-in-picture failed to start: %@", error.localizedDescription)
+  }
+}
+
+/// What the picture-in-picture window shows after the camera track is gone.
+/// Matches the React Native example's "No video" placeholder. A Flutter
+/// widget cannot be placed in this view.
+private final class PipFallbackView: UIView {
+  private let labelView = UILabel()
+
+  override init(frame: CGRect) {
+    super.init(frame: frame)
+    labelView.font = .preferredFont(forTextStyle: .headline)
+    labelView.translatesAutoresizingMaskIntoConstraints = false
+    addSubview(labelView)
+    NSLayoutConstraint.activate([
+      labelView.centerXAnchor.constraint(equalTo: centerXAnchor),
+      labelView.centerYAnchor.constraint(equalTo: centerYAnchor),
+    ])
+    apply(
+      label: "No video",
+      background: UIColor(red: 0.11, green: 0.16, blue: 0.27, alpha: 1),
+      text: .white
+    )
+  }
+
+  func apply(label: String, background: UIColor, text: UIColor) {
+    labelView.text = label
+    labelView.textColor = text
+    backgroundColor = background
+  }
+
+  @available(*, unavailable)
+  required init?(coder: NSCoder) {
+    fatalError("init(coder:) has not been implemented")
+  }
+}
+
+/// Reaches flutter_webrtc's native objects by name, so this plugin does not
+/// compile against flutter_webrtc's headers.
+private enum FlutterWebRtcLookup {
+  private static func plugin() -> NSObject? {
+    guard let type = NSClassFromString("FlutterWebRTCPlugin") as? NSObject.Type else { return nil }
+    let selector = NSSelectorFromString("sharedSingleton")
+    guard type.responds(to: selector) else { return nil }
+    return type.perform(selector)?.takeUnretainedValue() as? NSObject
+  }
+
+  static func videoTrack(id: String) -> RTCVideoTrack? {
+    guard let plugin = plugin() else { return nil }
+    let selector = NSSelectorFromString("trackForId:peerConnectionId:")
+    guard plugin.responds(to: selector) else { return nil }
+    return plugin.perform(selector, with: id, with: nil)?.takeUnretainedValue() as? RTCVideoTrack
+  }
+
+  static func captureSession() -> AVCaptureSession? {
+    (plugin()?.value(forKey: "videoCapturer") as? RTCCameraVideoCapturer)?.captureSession
+  }
+}
diff --git a/ios/fishjam_client/Sources/fishjam_client/SampleBufferVideoCallView.swift b/ios/fishjam_client/Sources/fishjam_client/SampleBufferVideoCallView.swift
new file mode 100644
index 0000000..b308ebf
--- /dev/null
+++ b/ios/fishjam_client/Sources/fishjam_client/SampleBufferVideoCallView.swift
@@ -0,0 +1,220 @@
+import AVFoundation
+import Accelerate
+import UIKit
+import WebRTC
+
+/// Draws WebRTC frames into an `AVSampleBufferDisplayLayer`, the only kind
+/// of content an `AVPictureInPictureVideoCallViewController` keeps updating
+/// while the app is in the background.
+final class SampleBufferVideoCallView: UIView, RTCVideoRenderer {
+  override class var layerClass: AnyClass { AVSampleBufferDisplayLayer.self }
+
+  var sampleBufferLayer: AVSampleBufferDisplayLayer {
+    layer as! AVSampleBufferDisplayLayer
+  }
+
+  /// Read on the WebRTC render thread. The picture-in-picture controller
+  /// turns this on while the window is open, and also while automatic start
+  /// is on, because iOS will not start an empty layer.
+  var shouldRender = false
+
+  private let converter = I420Converter()
+  private var currentRotation = -1
+
+  func requestScaleRecalculation() {
+    currentRotation = -1
+  }
+
+  func setSize(_ size: CGSize) {}
+
+  func renderFrame(_ frame: RTCVideoFrame?) {
+    guard shouldRender, let frame, let sampleBuffer = makeSampleBuffer(frame) else {
+      return
+    }
+    DispatchQueue.main.async { [weak self] in
+      guard let self, self.shouldRender else { return }
+      self.recalculateScale(rotation: frame.rotation.rawValue)
+      self.enqueue(sampleBuffer)
+    }
+  }
+
+  private func enqueue(_ sampleBuffer: CMSampleBuffer) {
+    if #available(iOS 17.0, *) {
+      let renderer = sampleBufferLayer.sampleBufferRenderer
+      if renderer.requiresFlushToResumeDecoding { renderer.flush() }
+      guard renderer.isReadyForMoreMediaData else { return }
+      renderer.enqueue(sampleBuffer)
+    } else {
+      let renderer = sampleBufferLayer
+      if renderer.requiresFlushToResumeDecoding { renderer.flush() }
+      guard renderer.isReadyForMoreMediaData else { return }
+      renderer.enqueue(sampleBuffer)
+    }
+  }
+
+  private func recalculateScale(rotation: Int) {
+    guard currentRotation != rotation else { return }
+    currentRotation = rotation
+    var scale: CGFloat = 1
+    if (rotation == 90 || rotation == 270) && bounds.width > 0 {
+      scale = bounds.height / bounds.width
+    }
+    sampleBufferLayer.transform = CATransform3DConcat(
+      CATransform3DMakeRotation(CGFloat(rotation) / 180 * .pi, 0, 0, 1),
+      CATransform3DMakeScale(scale, scale, 1)
+    )
+  }
+
+  private func makeSampleBuffer(_ frame: RTCVideoFrame) -> CMSampleBuffer? {
+    guard let pixelBuffer = pixelBuffer(from: frame) else { return nil }
+    var format: CMVideoFormatDescription?
+    guard
+      CMVideoFormatDescriptionCreateForImageBuffer(
+        allocator: kCFAllocatorDefault,
+        imageBuffer: pixelBuffer,
+        formatDescriptionOut: &format
+      ) == noErr, let format
+    else { return nil }
+
+    // RTCVideoFrame timestamps use a 90 kHz clock.
+    let time = CMTime(value: CMTimeValue(frame.timeStamp), timescale: 90_000)
+    var timing = CMSampleTimingInfo(
+      duration: .invalid,
+      presentationTimeStamp: time,
+      decodeTimeStamp: time
+    )
+    var sampleBuffer: CMSampleBuffer?
+    guard
+      CMSampleBufferCreateReadyWithImageBuffer(
+        allocator: kCFAllocatorDefault,
+        imageBuffer: pixelBuffer,
+        formatDescription: format,
+        sampleTiming: &timing,
+        sampleBufferOut: &sampleBuffer
+      ) == noErr, let sampleBuffer
+    else { return nil }
+
+    if let attachments = CMSampleBufferGetSampleAttachmentsArray(
+      sampleBuffer,
+      createIfNecessary: true
+    ), CFArrayGetCount(attachments) > 0 {
+      let dictionary = unsafeBitCast(
+        CFArrayGetValueAtIndex(attachments, 0),
+        to: CFMutableDictionary.self
+      )
+      CFDictionarySetValue(
+        dictionary,
+        Unmanaged.passUnretained(kCMSampleAttachmentKey_DisplayImmediately).toOpaque(),
+        Unmanaged.passUnretained(kCFBooleanTrue).toOpaque()
+      )
+    }
+    return sampleBuffer
+  }
+
+  private func pixelBuffer(from frame: RTCVideoFrame) -> CVPixelBuffer? {
+    if let buffer = frame.buffer as? RTCCVPixelBuffer {
+      return buffer.pixelBuffer
+    }
+    return converter.convert(frame.buffer.toI420())
+  }
+}
+
+/// Converts I420 frames (e.g. from software decoders) to BGRA pixel buffers.
+private final class I420Converter {
+  private var conversion = vImage_YpCbCrToARGB()
+  private let prepared: Bool
+  private var pool: CVPixelBufferPool?
+  private var poolWidth = 0
+  private var poolHeight = 0
+
+  init() {
+    // I420 uses the limited (video) range.
+    var range = vImage_YpCbCrPixelRange(
+      Yp_bias: 16,
+      CbCr_bias: 128,
+      YpRangeMax: 235,
+      CbCrRangeMax: 240,
+      YpMax: 255,
+      YpMin: 0,
+      CbCrMax: 255,
+      CbCrMin: 0
+    )
+    prepared =
+      vImageConvert_YpCbCrToARGB_GenerateConversion(
+        kvImage_YpCbCrToARGBMatrix_ITU_R_601_4,
+        &range,
+        &conversion,
+        kvImage420Yp8_Cb8_Cr8,
+        kvImageARGB8888,
+        vImage_Flags(kvImageNoFlags)
+      ) == kvImageNoError
+  }
+
+  func convert(_ buffer: RTCI420BufferProtocol) -> CVPixelBuffer? {
+    guard prepared else { return nil }
+    let width = Int(buffer.width)
+    let height = Int(buffer.height)
+    if pool == nil || poolWidth != width || poolHeight != height {
+      createPool(width: width, height: height)
+    }
+    guard let pool else { return nil }
+
+    var output: CVPixelBuffer?
+    guard CVPixelBufferPoolCreatePixelBuffer(kCFAllocatorDefault, pool, &output) == kCVReturnSuccess,
+      let output
+    else { return nil }
+
+    CVPixelBufferLockBaseAddress(output, [])
+    defer { CVPixelBufferUnlockBaseAddress(output, []) }
+
+    var yPlane = vImage_Buffer(
+      data: UnsafeMutableRawPointer(mutating: buffer.dataY),
+      height: vImagePixelCount(height),
+      width: vImagePixelCount(width),
+      rowBytes: Int(buffer.strideY)
+    )
+    var uPlane = vImage_Buffer(
+      data: UnsafeMutableRawPointer(mutating: buffer.dataU),
+      height: vImagePixelCount(buffer.chromaHeight),
+      width: vImagePixelCount(buffer.chromaWidth),
+      rowBytes: Int(buffer.strideU)
+    )
+    var vPlane = vImage_Buffer(
+      data: UnsafeMutableRawPointer(mutating: buffer.dataV),
+      height: vImagePixelCount(buffer.chromaHeight),
+      width: vImagePixelCount(buffer.chromaWidth),
+      rowBytes: Int(buffer.strideV)
+    )
+    var destination = vImage_Buffer(
+      data: CVPixelBufferGetBaseAddress(output),
+      height: vImagePixelCount(height),
+      width: vImagePixelCount(width),
+      rowBytes: CVPixelBufferGetBytesPerRow(output)
+    )
+    let bgra: [UInt8] = [3, 2, 1, 0]
+    let error = vImageConvert_420Yp8_Cb8_Cr8ToARGB8888(
+      &yPlane,
+      &uPlane,
+      &vPlane,
+      &destination,
+      &conversion,
+      bgra,
+      255,
+      vImage_Flags(kvImageNoFlags)
+    )
+    return error == kvImageNoError ? output : nil
+  }
+
+  private func createPool(width: Int, height: Int) {
+    poolWidth = width
+    poolHeight = height
+    let attributes: [CFString: Any] = [
+      kCVPixelBufferPixelFormatTypeKey: kCVPixelFormatType_32BGRA,
+      kCVPixelBufferWidthKey: width,
+      kCVPixelBufferHeightKey: height,
+      kCVPixelBufferIOSurfacePropertiesKey: [:] as [CFString: Any],
+    ]
+    pool = nil
+    CVPixelBufferPoolCreate(kCFAllocatorDefault, nil, attributes as CFDictionary, &pool)
+  }
+}
diff --git a/lib/fishjam_client.dart b/lib/fishjam_client.dart
index a193d7c..a388b49 100644
--- a/lib/fishjam_client.dart
+++ b/lib/fishjam_client.dart
@@ -52,6 +52,11 @@ export 'src/models/errors.dart'
 export 'src/models/events.dart';
 export 'src/models/simulcast.dart';
 export 'src/models/track.dart';
+export 'src/pip/picture_in_picture.dart'
+    show
+        PictureInPictureController,
+        PictureInPictureOptions,
+        PictureInPictureView;
 export 'src/rtc/rtc_adapter.dart' show MediaKind, PeerConnectionState, RtcStats;
 export 'src/signaling/auth.dart' show fishjamUrlFromId;
 export 'src/tracks/bandwidth.dart' show simulcastCapsKbps, singleStreamCapKbps;
diff --git a/lib/src/pip/picture_in_picture.dart b/lib/src/pip/picture_in_picture.dart
new file mode 100644
index 0000000..f26c37e
--- /dev/null
+++ b/lib/src/pip/picture_in_picture.dart
@@ -0,0 +1,392 @@
+import 'dart:async';
+
+import 'package:collection/collection.dart';
+import 'package:flutter/foundation.dart';
+import 'package:flutter/scheduler.dart';
+import 'package:flutter/services.dart';
+import 'package:flutter/widgets.dart';
+import 'package:flutter_webrtc/flutter_webrtc.dart';
+
+/// Picture-in-picture settings of a [PictureInPictureView]. Mirrors the React
+/// Native SDK's `RTCPIPOptions`.
+@immutable
+class PictureInPictureOptions {
+  const PictureInPictureOptions({
+    this.enabled = true,
+    this.preferredSize = const Size(1920, 1080),
+    this.startAutomatically = true,
+    this.stopAutomatically = true,
+    this.allowsCameraInBackground = false,
+    this.fallbackLabel = 'No video',
+    this.fallbackBackgroundColor = const Color(0xFF1C2945),
+    this.fallbackTextColor = const Color(0xFFFFFFFF),
+  });
+
+  /// Whether this view can be shown in picture-in-picture. Any
+  /// [PictureInPictureView] can set this, independently of any other: there
+  /// is no app-wide "offered view", each view has its own native controller
+  /// (like the React Native SDK's per-`RTCView` `PIPController`).
+  final bool enabled;
+
+  /// Preferred window size in logical pixels. Defaults to 1920×1080, the same
+  /// default as the React Native SDK. Android uses it as the aspect ratio,
+  /// and uses the view size for a side that is 0. iOS sets the window's
+  /// preferred content size to this.
+  final Size preferredSize;
+
+  /// Starts picture-in-picture when the app goes to the background. Android:
+  /// API 31+ only.
+  final bool startAutomatically;
+
+  /// iOS only: stops picture-in-picture when the app returns to the
+  /// foreground. On Android the system exits it when the user expands the
+  /// window.
+  final bool stopAutomatically;
+
+  /// iOS 16+ only: keeps the local camera running while in
+  /// picture-in-picture. Before iOS 18 this needs the
+  /// `com.apple.developer.avfoundation.multitasking-camera-access`
+  /// entitlement.
+  ///
+  /// The React Native SDK's docs recommend using picture-in-picture with a
+  /// remote track rather than the local camera, since the camera may stop
+  /// in the background; this option is the escape hatch for using it with
+  /// the local camera anyway.
+  final bool allowsCameraInBackground;
+
+  /// Text drawn in this view, and in the picture-in-picture window, when the
+  /// video track is gone.
+  final String fallbackLabel;
+
+  /// Background behind [fallbackLabel].
+  final Color fallbackBackgroundColor;
+
+  /// Color of [fallbackLabel].
+  final Color fallbackTextColor;
+
+  @override
+  bool operator ==(Object other) =>
+      other is PictureInPictureOptions &&
+      other.enabled == enabled &&
+      other.preferredSize == preferredSize &&
+      other.startAutomatically == startAutomatically &&
+      other.stopAutomatically == stopAutomatically &&
+      other.allowsCameraInBackground == allowsCameraInBackground &&
+      other.fallbackLabel == fallbackLabel &&
+      other.fallbackBackgroundColor == fallbackBackgroundColor &&
+      other.fallbackTextColor == fallbackTextColor;
+
+  @override
+  int get hashCode => Object.hash(
+    enabled,
+    preferredSize,
+    startAutomatically,
+    stopAutomatically,
+    allowsCameraInBackground,
+    fallbackLabel,
+    fallbackBackgroundColor,
+    fallbackTextColor,
+  );
+}
+
+/// Starts and stops picture-in-picture for the [PictureInPictureView] it is
+/// passed to. Replaces the React Native ref given to `startPIP` / `stopPIP`.
+class PictureInPictureController {
+  _PictureInPictureViewState? _view;
+  bool _isActive = false;
+
+  /// Whether the view is shown in the picture-in-picture window.
+  bool get isActive => _isActive;
+
+  /// Does nothing if the view has no [PictureInPictureView.pipOptions], or
+  /// when the OS cannot start it now.
+  Future<void> start() => _view?._send('start') ?? Future.value();
+
+  /// Does nothing on Android: the user closes or expands the window.
+  Future<void> stop() => _view?._send('stop') ?? Future.value();
+
+  /// Replaces the native picture-in-picture video without rebuilding its
+  /// [PictureInPictureView].
+  ///
+  /// Use this when a remote track is replaced while the Flutter app is in the
+  /// background, such as after that peer reconnects. Pass `null` to show the
+  /// configured fallback. Does nothing if the view is not offered.
+  Future<void> setMediaStream(MediaStream? stream) =>
+      _view?._setMediaStream(stream) ?? Future.value();
+}
+
+/// Renders the first video track of [mediaStream] and, if [pipOptions] is
+/// set, offers it for picture-in-picture. Mirrors the React Native SDK's
+/// `RTCPIPView`: each view manages its own native picture-in-picture
+/// controller, so any number of views can set [pipOptions] independently
+/// (e.g. a peer's camera and, later, your own, when the peer leaves and
+/// that view unmounts).
+///
+/// Needs iOS 15+ or Android 8+ and the app setup described in the README.
+class PictureInPictureView extends StatefulWidget {
+  const PictureInPictureView({
+    required this.mediaStream,
+    super.key,
+    this.pipOptions,
+    this.controller,
+    this.onPictureInPictureChange,
+    this.mirror = false,
+    this.objectFit = RTCVideoViewObjectFit.RTCVideoViewObjectFitCover,
+  });
+
+  /// The stream to render, e.g. `TrackContext.stream`.
+  final MediaStream? mediaStream;
+
+  /// `null` means the view is not offered for picture-in-picture.
+  final PictureInPictureOptions? pipOptions;
+  final PictureInPictureController? controller;
+
+  /// Called when this view enters (`true`) or leaves (`false`)
+  /// picture-in-picture.
+  final ValueChanged<bool>? onPictureInPictureChange;
+
+  final bool mirror;
+  final RTCVideoViewObjectFit objectFit;
+
+  @override
+  State<PictureInPictureView> createState() => _PictureInPictureViewState();
+}
+
+class _PictureInPictureViewState extends State<PictureInPictureView> {
+  static int _nextId = 0;
+
+  final int _id = _nextId++;
+  final RTCVideoRenderer _renderer = RTCVideoRenderer();
+  bool _rendererReady = false;
+  Rect? _rect;
+  bool _active = false;
+  bool _registered = false;
+  Map<String, Object?>? _lastUpdate;
+
+  bool get _offered => widget.pipOptions?.enabled ?? false;
+
+  String? get _trackId => widget.mediaStream?.getVideoTracks().firstOrNull?.id;
+
+  @override
+  void initState() {
+    super.initState();
+    widget.controller?._view = this;
+    _PipChannel.instance.register(_id, this);
+    unawaited(_initRenderer());
+  }
+
+  Future<void> _initRenderer() async {
+    await _renderer.initialize();
+    if (!mounted) return;
+    _renderer.srcObject = widget.mediaStream;
+    setState(() => _rendererReady = true);
+  }
+
+  @override
+  void didUpdateWidget(PictureInPictureView oldWidget) {
+    super.didUpdateWidget(oldWidget);
+    if (oldWidget.controller != widget.controller) {
+      if (oldWidget.controller?._view == this) {
+        oldWidget.controller!
+          .._view = null
+          .._isActive = false;
+      }
+      widget.controller
+        ?.._view = this
+        .._isActive = _active;
+    }
+    if (_rendererReady && oldWidget.mediaStream != widget.mediaStream) {
+      _renderer.srcObject = widget.mediaStream;
+    }
+  }
+
+  @override
+  void dispose() {
+    if (_registered) {
+      _registered = false;
+      _setActive(false, notify: false);
+      unawaited(_PipChannel.instance.unregisterNative(_id));
+    }
+    _PipChannel.instance.forget(_id);
+    if (widget.controller?._view == this) {
+      widget.controller!
+        .._view = null
+        .._isActive = false;
+    }
+    unawaited(_renderer.dispose());
+    super.dispose();
+  }
+
+  /// The rect is re-measured after each build only. iOS animates
+  /// picture-in-picture to and from it. A view moved without a rebuild
+  /// (e.g. scrolled) keeps its last rect.
+  void _sync(Duration _) {
+    if (!mounted) return;
+    final box = context.findRenderObject();
+    if (box is RenderBox && box.hasSize && box.attached) {
+      _rect = box.localToGlobal(Offset.zero) & box.size;
+    }
+    if (_offered && _PipChannel.supported) {
+      _registered = true;
+      final args = _updateArgs();
+      if (const DeepCollectionEquality().equals(args, _lastUpdate)) return;
+      _lastUpdate = args;
+      unawaited(_PipChannel.instance.update(args));
+    } else if (_registered) {
+      _registered = false;
+      _lastUpdate = null;
+      _setActive(false, notify: false);
+      unawaited(_PipChannel.instance.unregisterNative(_id));
+    }
+  }
+
+  Map<String, Object?> _updateArgs() {
+    final options = widget.pipOptions!;
+    final size = options.preferredSize;
+    final rect = _rect;
+    return {
+      'viewId': _id,
+      'trackId': _trackId,
+      'rect': rect == null
+          ? null
+          : {
+              'x': rect.left,
+              'y': rect.top,
+              'width': rect.width,
+              'height': rect.height,
+            },
+      'mirror': widget.mirror,
+      'objectFit':
+          widget.objectFit == RTCVideoViewObjectFit.RTCVideoViewObjectFitContain
+          ? 'contain'
+          : 'cover',
+      'preferredSize': {'width': size.width, 'height': size.height},
+      'startAutomatically': options.startAutomatically,
+      'stopAutomatically': options.stopAutomatically,
+      'allowsCameraInBackground': options.allowsCameraInBackground,
+      'fallbackLabel': options.fallbackLabel,
+      'fallbackBackgroundColor': options.fallbackBackgroundColor.toARGB32(),
+      'fallbackTextColor': options.fallbackTextColor.toARGB32(),
+    };
+  }
+
+  Future<void> _send(String method) {
+    if (!_registered) return Future.value();
+    return _PipChannel.instance.send(_id, method);
+  }
+
+  Future<void> _setMediaStream(MediaStream? stream) {
+    if (!_registered) return Future.value();
+    final args = Map<String, Object?>.from(_lastUpdate ?? _updateArgs())
+      ..['trackId'] = stream?.getVideoTracks().firstOrNull?.id;
+    _lastUpdate = args;
+    return _PipChannel.instance.update(args);
+  }
+
+  void _setActive(bool active, {required bool notify}) {
+    if (_active == active) return;
+    _active = active;
+    if (widget.controller?._view == this) widget.controller!._isActive = active;
+    if (notify) widget.onPictureInPictureChange?.call(active);
+  }
+
+  /// Label and colors for a missing video track. Same ones the native window
+  /// draws. `pipOptions` may be null: this view can render without being
+  /// offered.
+  Widget _noVideo() {
+    final options = widget.pipOptions ?? const PictureInPictureOptions();
+    return ColoredBox(
+      color: options.fallbackBackgroundColor,
+      child: Center(
+        child: Text(
+          options.fallbackLabel,
+          textAlign: TextAlign.center,
+          style: TextStyle(color: options.fallbackTextColor),
+        ),
+      ),
+    );
+  }
+
+  @override
+  Widget build(BuildContext context) {
+    SchedulerBinding.instance.addPostFrameCallback(_sync);
+    if (!_rendererReady || _trackId == null) return _noVideo();
+    return RTCVideoView(
+      _renderer,
+      mirror: widget.mirror,
+      objectFit: widget.objectFit,
+      placeholderBuilder: (_) => _noVideo(),
+    );
+  }
+}
+
+/// Talks to the native plugin. Each [PictureInPictureView] registers its own
+/// native controller, keyed by its view id: there is no "offered" list or
+/// arbitration here, only routing calls and events to the right view, like
+/// a lookup table of independent per-view controllers (the React Native
+/// SDK's model, where each `RTCView` owns one `PIPController`).
+class _PipChannel {
+  _PipChannel._();
+
+  static final _PipChannel instance = _PipChannel._();
+
+  static const _methods = MethodChannel('io.fishjam.client/pip');
+  static const _events = EventChannel('io.fishjam.client/pip_events');
+
+  final _views = <int, _PictureInPictureViewState>{};
+  StreamSubscription<Object?>? _eventSubscription;
+
+  static bool get supported =>
+      !kIsWeb &&
+      (defaultTargetPlatform == TargetPlatform.iOS ||
+          defaultTargetPlatform == TargetPlatform.android);
+
+  void register(int id, _PictureInPictureViewState view) {
+    _views[id] = view;
+    _eventSubscription ??= _events.receiveBroadcastStream().listen(_onEvent);
+  }
+
+  /// Stops routing events to [id]. Does not tell the native side: call
+  /// [unregisterNative] first if it was told about this view.
+  void forget(int id) {
+    _views.remove(id);
+    if (_views.isEmpty) {
+      unawaited(_eventSubscription?.cancel());
+      _eventSubscription = null;
+    }
+  }
+
+  Future<void> unregisterNative(int id) =>
+      _invoke('unregister', {'viewId': id});
+
+  Future<void> update(Map<String, Object?> args) {
+    if (!supported) return Future.value();
+    return _invoke('update', args);
+  }
+
+  Future<void> send(int id, String method) async {
+    if (!supported) return;
+    await _invoke(method, {'viewId': id});
+  }
+
+  Future<void> _invoke(String method, Map<String, Object?> args) async {
+    try {
+      await _methods.invokeMethod<void>(method, args);
+    } on Object catch (error, stack) {
+      FlutterError.reportError(
+        FlutterErrorDetails(
+          exception: error,
+          stack: stack,
+          library: 'fishjam_client',
+          context: ErrorDescription('while sending picture-in-picture $method'),
+        ),
+      );
+    }
+  }
+
+  void _onEvent(Object? event) {
+    if (event case {'viewId': final int id, 'isActive': final bool active}) {
+      _views[id]?._setActive(active, notify: true);
+    }
+  }
+}
diff --git a/pubspec.yaml b/pubspec.yaml
index b6b4e8f..2d2f96b 100644
--- a/pubspec.yaml
+++ b/pubspec.yaml
@@ -16,6 +16,9 @@ dependencies:
   connectivity_plus: ^7.3.2
   flutter:
     sdk: flutter
+  # flutter_webrtc 1.6.2 ships WebRTC 150.7871.01. SwiftPM and CocoaPods follow
+  # this package. Android pins the same version in android/build.gradle.kts;
+  # update that pin when bumping this dependency.
   flutter_webrtc: ^1.6.2
   http: ^1.6.0
   meta: ^1.15.0
diff --git a/test/import_boundary_test.dart b/test/import_boundary_test.dart
index 2acbbff..00541ee 100644
--- a/test/import_boundary_test.dart
+++ b/test/import_boundary_test.dart
@@ -7,6 +7,7 @@ const _allowed = {
   'lib/fishjam_client.dart',
   'lib/src/fishjam_client.dart',
   'lib/src/livestream_api.dart',
+  'lib/src/pip/picture_in_picture.dart',
   'lib/src/rtc/flutter_webrtc_adapter.dart',
 };
 
diff --git a/test/pip/picture_in_picture_test.dart b/test/pip/picture_in_picture_test.dart
new file mode 100644
index 0000000..92e8c01
--- /dev/null
+++ b/test/pip/picture_in_picture_test.dart
@@ -0,0 +1,460 @@
+import 'package:fishjam_client/fishjam_client.dart';
+import 'package:flutter/foundation.dart';
+import 'package:flutter/services.dart';
+import 'package:flutter/widgets.dart';
+import 'package:flutter_test/flutter_test.dart';
+import 'package:flutter_webrtc/flutter_webrtc.dart';
+
+const _pip = MethodChannel('io.fishjam.client/pip');
+const _pipEvents = EventChannel('io.fishjam.client/pip_events');
+const _webrtc = MethodChannel('FlutterWebRTC.Method');
+const _texture = EventChannel('FlutterWebRTC/Texture1');
+
+class _FakeTrack extends Fake implements MediaStreamTrack {
+  _FakeTrack(this.id);
+
+  @override
+  final String id;
+}
+
+class _FakeStream extends Fake implements MediaStream {
+  _FakeStream(this.id, [this._videoTracks = const []]);
+
+  @override
+  final String id;
+  final List<MediaStreamTrack> _videoTracks;
+
+  @override
+  String get ownerTag => 'owner';
+
+  @override
+  List<MediaStreamTrack> getVideoTracks() => _videoTracks;
+}
+
+final _camera = _FakeStream('s1', [_FakeTrack('video-1')]);
+
+// Each wrapper carries its view's key, so removing one view (e.g. the first
+// of two) does not misidentify a sibling at the same position as changed.
+Widget _host(List<Widget> views) => Directionality(
+  textDirection: TextDirection.ltr,
+  child: Column(
+    crossAxisAlignment: CrossAxisAlignment.start,
+    children: [
+      for (final v in views)
+        SizedBox(key: v.key, width: 200, height: 100, child: v),
+    ],
+  ),
+);
+
+void main() {
+  TestWidgetsFlutterBinding.ensureInitialized();
+  final messenger =
+      TestDefaultBinaryMessengerBinding.instance.defaultBinaryMessenger;
+
+  late List<MethodCall> calls;
+  late List<MethodCall> webrtcCalls;
+  MockStreamHandlerEventSink? events;
+
+  Future<void> emit(WidgetTester tester, Map<String, Object> event) async {
+    events!.success(event);
+    await tester.runAsync(() => Future<void>.delayed(Duration.zero));
+  }
+
+  List<MethodCall> callsOf(String method) =>
+      calls.where((c) => c.method == method).toList();
+  Map<Object?, Object?> argsOf(MethodCall call) =>
+      call.arguments as Map<Object?, Object?>;
+
+  setUp(() {
+    calls = [];
+    webrtcCalls = [];
+    events = null;
+    messenger
+      ..setMockMethodCallHandler(_pip, (call) async {
+        calls.add(call);
+        return null;
+      })
+      ..setMockMethodCallHandler(_webrtc, (call) async {
+        webrtcCalls.add(call);
+        return call.method == 'createVideoRenderer' ? {'textureId': 1} : null;
+      })
+      ..setMockStreamHandler(
+        _pipEvents,
+        MockStreamHandler.inline(
+          onListen: (_, sink) {
+            events = sink;
+          },
+        ),
+      )
+      ..setMockStreamHandler(
+        _texture,
+        MockStreamHandler.inline(onListen: (_, _) {}),
+      );
+  });
+
+  tearDown(() {
+    debugDefaultTargetPlatformOverride = null;
+    messenger
+      ..setMockMethodCallHandler(_pip, null)
+      ..setMockMethodCallHandler(_webrtc, null)
+      ..setMockStreamHandler(_pipEvents, null)
+      ..setMockStreamHandler(_texture, null);
+  });
+
+  group('PictureInPictureView (SPEC §20d)', () {
+    testWidgets('an offered view sends update with the defaults and its rect', (
+      tester,
+    ) async {
+      await tester.pumpWidget(
+        _host([
+          PictureInPictureView(
+            mediaStream: _camera,
+            pipOptions: const PictureInPictureOptions(),
+          ),
+        ]),
+      );
+      await tester.pump();
+
+      final update = argsOf(callsOf('update').last);
+      expect(update['viewId'], isA<int>());
+      expect(Map.of(update)..remove('viewId'), {
+        'trackId': 'video-1',
+        'rect': {'x': 0.0, 'y': 0.0, 'width': 200.0, 'height': 100.0},
+        'mirror': false,
+        'objectFit': 'cover',
+        'startAutomatically': true,
+        'stopAutomatically': true,
+        'allowsCameraInBackground': false,
+        'preferredSize': {'width': 1920.0, 'height': 1080.0},
+        'fallbackLabel': 'No video',
+        'fallbackBackgroundColor': 0xFF1C2945,
+        'fallbackTextColor': 0xFFFFFFFF,
+      });
+    });
+
+    testWidgets('sends every option that is set', (tester) async {
+      await tester.pumpWidget(
+        _host([
+          PictureInPictureView(
+            mediaStream: _camera,
+            mirror: true,
+            objectFit: RTCVideoViewObjectFit.RTCVideoViewObjectFitContain,
+            pipOptions: const PictureInPictureOptions(
+              preferredSize: Size(16, 9),
+              startAutomatically: false,
+              stopAutomatically: false,
+              allowsCameraInBackground: true,
+            ),
+          ),
+        ]),
+      );
+      await tester.pump();
+
+      final update = argsOf(callsOf('update').last);
+      expect(update['mirror'], true);
+      expect(update['objectFit'], 'contain');
+      expect(update['preferredSize'], {'width': 16.0, 'height': 9.0});
+      expect(update['startAutomatically'], false);
+      expect(update['stopAutomatically'], false);
+      expect(update['allowsCameraInBackground'], true);
+    });
+
+    testWidgets('a view without pip or with enabled: false is not offered', (
+      tester,
+    ) async {
+      await tester.pumpWidget(
+        _host([
+          PictureInPictureView(mediaStream: _camera),
+          PictureInPictureView(
+            mediaStream: _camera,
+            pipOptions: const PictureInPictureOptions(enabled: false),
+          ),
+        ]),
+      );
+      await tester.pump();
+      expect(calls, isEmpty);
+    });
+
+    testWidgets('rebuilding with the same values sends nothing new', (
+      tester,
+    ) async {
+      Widget view() => _host([
+        PictureInPictureView(
+          mediaStream: _camera,
+          pipOptions: const PictureInPictureOptions(),
+        ),
+      ]);
+      await tester.pumpWidget(view());
+      await tester.pump();
+      final sent = calls.length;
+      await tester.pumpWidget(view());
+      await tester.pump();
+      expect(calls.length, sent);
+    });
+
+    testWidgets('the window label and colors are sent with the update', (
+      tester,
+    ) async {
+      await tester.pumpWidget(
+        _host([
+          PictureInPictureView(
+            mediaStream: _camera,
+            pipOptions: const PictureInPictureOptions(
+              fallbackLabel: 'Left',
+              fallbackBackgroundColor: Color(0xFF112233),
+              fallbackTextColor: Color(0xFFABCDEF),
+            ),
+          ),
+        ]),
+      );
+      await tester.pump();
+      final update = argsOf(callsOf('update').last);
+      expect(update['fallbackLabel'], 'Left');
+      expect(update['fallbackBackgroundColor'], 0xFF112233);
+      expect(update['fallbackTextColor'], 0xFFABCDEF);
+    });
+
+    testWidgets('a changed value sends a new update', (tester) async {
+      Widget view({required bool mirror}) => _host([
+        PictureInPictureView(
+          mediaStream: _camera,
+          mirror: mirror,
+          pipOptions: const PictureInPictureOptions(),
+        ),
+      ]);
+      await tester.pumpWidget(view(mirror: false));
+      await tester.pump();
+      await tester.pumpWidget(view(mirror: true));
+      await tester.pump();
+      expect(argsOf(callsOf('update').last)['mirror'], true);
+    });
+
+    testWidgets('a stream without video sends a null trackId and shows the '
+        'label', (tester) async {
+      await tester.pumpWidget(
+        _host([
+          PictureInPictureView(
+            mediaStream: _FakeStream('audio-only'),
+            pipOptions: const PictureInPictureOptions(fallbackLabel: 'Left'),
+          ),
+        ]),
+      );
+      await tester.pump();
+      expect(argsOf(callsOf('update').last)['trackId'], isNull);
+      expect(find.text('Left'), findsOneWidget);
+    });
+
+    testWidgets('two offered views each get their own id and both stay '
+        'registered, like separate native controllers', (tester) async {
+      final first = PictureInPictureView(
+        key: const ValueKey('first'),
+        mediaStream: _camera,
+        pipOptions: const PictureInPictureOptions(),
+      );
+      final second = PictureInPictureView(
+        key: const ValueKey('second'),
+        mediaStream: _FakeStream('s2', [_FakeTrack('video-2')]),
+        pipOptions: const PictureInPictureOptions(),
+      );
+      await tester.pumpWidget(_host([first]));
+      await tester.pump();
+      final firstId = argsOf(callsOf('update').last)['viewId'];
+
+      await tester.pumpWidget(_host([first, second]));
+      await tester.pump();
+      final updates = callsOf('update').map(argsOf).toList();
+      final secondUpdate = updates.lastWhere((u) => u['viewId'] != firstId);
+      expect(secondUpdate['viewId'], isNot(firstId));
+      expect(secondUpdate['trackId'], 'video-2');
+      // The first view was not re-sent just because another one was added.
+      expect(callsOf('unregister'), isEmpty);
+
+      await tester.pumpWidget(_host([second]));
+      await tester.pump();
+      expect(argsOf(callsOf('unregister').single), {'viewId': firstId});
+
+      await tester.pumpWidget(_host([]));
+      await tester.pump();
+    });
+
+    testWidgets('disabling the only offered view sends unregister', (
+      tester,
+    ) async {
+      Widget view(PictureInPictureOptions? pip) =>
+          _host([PictureInPictureView(mediaStream: _camera, pipOptions: pip)]);
+      await tester.pumpWidget(view(const PictureInPictureOptions()));
+      await tester.pump();
+      await tester.pumpWidget(
+        view(const PictureInPictureOptions(enabled: false)),
+      );
+      await tester.pump();
+      expect(callsOf('unregister'), hasLength(1));
+    });
+  });
+
+  group('PictureInPictureController (SPEC §20d)', () {
+    testWidgets('start and stop are sent for the offered view', (tester) async {
+      final controller = PictureInPictureController();
+      await tester.pumpWidget(
+        _host([
+          PictureInPictureView(
+            mediaStream: _camera,
+            controller: controller,
+            pipOptions: const PictureInPictureOptions(),
+          ),
+        ]),
+      );
+      await tester.pump();
+      final id = argsOf(callsOf('update').last)['viewId'];
+
+      await controller.start();
+      await controller.stop();
+      expect(argsOf(callsOf('start').single), {'viewId': id});
+      expect(argsOf(callsOf('stop').single), {'viewId': id});
+    });
+
+    testWidgets('updates the native track without rebuilding the view', (
+      tester,
+    ) async {
+      final controller = PictureInPictureController();
+      await tester.pumpWidget(
+        _host([
+          PictureInPictureView(
+            mediaStream: _camera,
+            controller: controller,
+            pipOptions: const PictureInPictureOptions(),
+          ),
+        ]),
+      );
+      await tester.pump();
+      final id = argsOf(callsOf('update').last)['viewId'];
+
+      await controller.setMediaStream(
+        _FakeStream('s2', [_FakeTrack('video-2')]),
+      );
+
+      expect(argsOf(callsOf('update').last), containsPair('viewId', id));
+      expect(
+        argsOf(callsOf('update').last),
+        containsPair('trackId', 'video-2'),
+      );
+    });
+
+    testWidgets('start does nothing for a view that is not offered', (
+      tester,
+    ) async {
+      final hidden = PictureInPictureController();
+      final detached = PictureInPictureController();
+      await tester.pumpWidget(
+        _host([
+          PictureInPictureView(
+            mediaStream: _camera,
+            pipOptions: const PictureInPictureOptions(),
+          ),
+          PictureInPictureView(
+            mediaStream: _camera,
+            controller: hidden,
+            pipOptions: const PictureInPictureOptions(enabled: false),
+          ),
+        ]),
+      );
+      await tester.pump();
+      await hidden.start();
+      await detached.start();
+      expect(callsOf('start'), isEmpty);
+    });
+
+    testWidgets('events update isActive and call onPictureInPictureChange', (
+      tester,
+    ) async {
+      final controller = PictureInPictureController();
+      final changes = <bool>[];
+      await tester.pumpWidget(
+        _host([
+          PictureInPictureView(
+            mediaStream: _camera,
+            controller: controller,
+            onPictureInPictureChange: changes.add,
+            pipOptions: const PictureInPictureOptions(),
+          ),
+        ]),
+      );
+      await tester.pump();
+      final id = argsOf(callsOf('update').last)['viewId']! as int;
+
+      await emit(tester, {'viewId': id + 1000, 'isActive': true});
+      expect(controller.isActive, isFalse);
+
+      await emit(tester, {'viewId': id, 'isActive': true});
+      expect(controller.isActive, isTrue);
+
+      await emit(tester, {'viewId': id, 'isActive': false});
+      expect(controller.isActive, isFalse);
+      expect(changes, [true, false]);
+    });
+
+    testWidgets('a view that stops being offered while active becomes '
+        'inactive without a callback', (tester) async {
+      final controller = PictureInPictureController();
+      final changes = <bool>[];
+      Widget view(PictureInPictureOptions pip) => _host([
+        PictureInPictureView(
+          mediaStream: _camera,
+          controller: controller,
+          onPictureInPictureChange: changes.add,
+          pipOptions: pip,
+        ),
+      ]);
+      await tester.pumpWidget(view(const PictureInPictureOptions()));
+      await tester.pump();
+      final id = argsOf(callsOf('update').last)['viewId']! as int;
+      await emit(tester, {'viewId': id, 'isActive': true});
+
+      await tester.pumpWidget(
+        view(const PictureInPictureOptions(enabled: false)),
+      );
+      await tester.pump();
+      expect(controller.isActive, isFalse);
+      expect(changes, [true]);
+    });
+
+    testWidgets('nothing is sent on other platforms', (tester) async {
+      debugDefaultTargetPlatformOverride = TargetPlatform.macOS;
+      final controller = PictureInPictureController();
+      await tester.pumpWidget(
+        _host([
+          PictureInPictureView(
+            mediaStream: _camera,
+            controller: controller,
+            pipOptions: const PictureInPictureOptions(),
+          ),
+        ]),
+      );
+      await tester.pump();
+      await controller.start();
+      await tester.pumpWidget(_host([]));
+      await tester.pump();
+      expect(calls, isEmpty);
+      debugDefaultTargetPlatformOverride = null;
+    });
+  });
+
+  test('PictureInPictureOptions value equality', () {
+    expect(
+      const PictureInPictureOptions(preferredSize: Size(1, 2)),
+      const PictureInPictureOptions(preferredSize: Size(1, 2)),
+    );
+    expect(
+      const PictureInPictureOptions().hashCode,
+      const PictureInPictureOptions().hashCode,
+    );
+    expect(
+      const PictureInPictureOptions(),
+      isNot(const PictureInPictureOptions(enabled: false)),
+    );
+    expect(
+      const PictureInPictureOptions(),
+      isNot(const PictureInPictureOptions(fallbackLabel: 'Left')),
+    );
+  });
+}