capacitor-camera-view 2.4.0 → 3.0.0

package/ios/Sources/CameraViewPlugin/CameraEvents.swift

@@ -15,7 +15,7 @@ public struct BarcodeDetectedEvent: Sendable {
     /// Raw bytes as they were encoded in the barcode when the platform exposes them.
     public let rawBytes: [UInt8]?
 
-    /// The type of barcode detected (e.g., "org.iso.QRCode").
+    /// The type of barcode detected, normalized to the shared BarcodeType vocabulary (e.g., "qr").
     public let type: String
 
     /// The bounding rectangle of the barcode in screen coordinates.
@@ -97,37 +97,59 @@ public protocol CameraEventDelegate: AnyObject {
     /// Called when a barcode is detected in the camera feed.
     /// - Parameter event: The barcode detection event with all relevant data.
     func cameraDidDetectBarcode(_ event: BarcodeDetectedEvent)
-}
 
-// MARK: - Notification Names
+    /// Called when the capture session is interrupted (e.g. phone call, another
+    /// app claiming the camera, iPad Split View camera loss).
+    /// - Parameter reason: A stable string describing the interruption reason.
+    func cameraWasInterrupted(reason: String)
+
+    /// Called when a capture-session interruption ends and the session resumes.
+    func cameraInterruptionEnded()
 
-/// Extension for camera-related notification names.
-/// These maintain backwards compatibility with the NotificationCenter-based event system.
-public extension Notification.Name {
-    /// Posted when a barcode is detected.
-    /// UserInfo contains: "value", "displayValue", "rawBytes", "type", "boundingRect"
-    static let cameraViewBarcodeDetected = Notification.Name("barcodeDetected")
+    /// Called when the capture session hits a runtime error.
+    /// - Parameters:
+    ///   - message: A human-readable description of the error.
+    ///   - code: The underlying `AVError` code, when available.
+    func cameraRuntimeError(message: String, code: Int?)
+}
+
+/// Default no-op implementations so conformers only implement the events they
+/// care about (and adding new events here stays source-compatible).
+public extension CameraEventDelegate {
+    func cameraWasInterrupted(reason: String) {}
+    func cameraInterruptionEnded() {}
+    func cameraRuntimeError(message: String, code: Int?) {}
 }
 
 // MARK: - Event Emitter Helper
 
-/// Helper class for emitting camera events through both delegate and NotificationCenter.
-/// This maintains backwards compatibility while enabling the new typed delegate pattern.
+/// Helper class for emitting camera events through the typed delegate.
 internal final class CameraEventEmitter {
     /// Weak reference to the delegate to avoid retain cycles.
     weak var delegate: CameraEventDelegate?
 
-    /// Emits a barcode detected event through both channels.
+    /// Emits a barcode detected event to the delegate.
     /// - Parameter event: The barcode detection event to emit.
     func emitBarcodeDetected(_ event: BarcodeDetectedEvent) {
-        // Call typed delegate first (preferred path)
         delegate?.cameraDidDetectBarcode(event)
+    }
+
+    /// Emits a camera interruption event to the delegate.
+    /// - Parameter reason: A stable string describing the interruption reason.
+    func emitCameraInterrupted(reason: String) {
+        delegate?.cameraWasInterrupted(reason: reason)
+    }
+
+    /// Emits a camera resumed event to the delegate.
+    func emitCameraResumed() {
+        delegate?.cameraInterruptionEnded()
+    }
 
-        // Also post to NotificationCenter for backwards compatibility
-        NotificationCenter.default.post(
-            name: .cameraViewBarcodeDetected,
-            object: nil,
-            userInfo: event.toDictionary()
-        )
+    /// Emits a camera runtime error event to the delegate.
+    /// - Parameters:
+    ///   - message: A human-readable description of the error.
+    ///   - code: The underlying `AVError` code, when available.
+    func emitCameraRuntimeError(message: String, code: Int?) {
+        delegate?.cameraRuntimeError(message: message, code: code)
     }
 }

package/ios/Sources/CameraViewPlugin/CameraSessionConfiguration.swift

@@ -25,6 +25,26 @@ public struct CameraSessionConfiguration: Sendable {
 
     /// Initial zoom factor.
     let zoomFactor: CGFloat?
+
+    /// Whether to prioritize photo quality over capture responsiveness.
+    /// When `false` (default) the plugin opts into the iOS 17+ responsive-capture
+    /// pipeline (zero-shutter-lag, responsive capture, fast capture prioritization)
+    /// where supported. When `true` those optimizations are skipped so captures
+    /// always prioritize quality.
+    let prioritizeQuality: Bool
+
+    /// Desired sensor aspect ratio ("4:3" or "16:9") for both the preview and
+    /// photo capture. `nil` keeps the default `.photo` session preset (4:3).
+    let aspectRatio: String?
+
+    /// Optional upper bound, in pixels, for the longer edge of captured
+    /// photos. `nil` keeps the photo output's default dimensions.
+    let captureMaxDimension: Int?
+
+    /// How the preview is scaled into its container. `"fit"` letterboxes the
+    /// whole frame (`.resizeAspect`); any other value (including `nil`) keeps
+    /// the default cover behavior (`.resizeAspectFill`).
+    let previewScaleMode: String?
 }
 
 /// Maps a Capacitor plugin call to a CameraSessionConfiguration struct.
@@ -37,6 +57,10 @@ public func sessionConfigFromPluginCall(_ call: CAPPluginCall) -> CameraSessionC
     let preferredCameraDeviceTypes = call.getArray("preferredCameraDeviceTypes") as? [String]
     let useTripleCameraIfAvailable = call.getBool("useTripleCameraIfAvailable", false)
     let zoomFactor = call.getDouble("zoomFactor").map { CGFloat($0) }
+    let prioritizeQuality = call.getBool("prioritizeQuality", false)
+    let aspectRatio = call.getString("aspectRatio")
+    let captureMaxDimension = call.getInt("captureMaxDimension")
+    let previewScaleMode = call.getString("previewScaleMode")
 
     // Parse barcode types if provided
     let barcodeTypes: [AVMetadataObject.ObjectType]?
@@ -54,6 +78,10 @@ public func sessionConfigFromPluginCall(_ call: CAPPluginCall) -> CameraSessionC
         position: position,
         preferredCameraDeviceTypes: preferredCameraDeviceTypes,
         useTripleCameraIfAvailable: useTripleCameraIfAvailable,
-        zoomFactor: zoomFactor
+        zoomFactor: zoomFactor,
+        prioritizeQuality: prioritizeQuality,
+        aspectRatio: aspectRatio,
+        captureMaxDimension: captureMaxDimension,
+        previewScaleMode: previewScaleMode
     )
 }

package/ios/Sources/CameraViewPlugin/CameraViewManager+BarcodeScan.swift

@@ -1,6 +1,17 @@
 import AVFoundation
 import CoreImage
 import Foundation
+import QuartzCore
+
+/// Suppression window (seconds) during which a repeat of the same barcode
+/// (identical value + type) is not re-emitted. A genuinely new code still emits
+/// immediately. Kept consistent with the Android and web implementations.
+private let barcodeSuppressionWindow: TimeInterval = 0.5
+
+/// Once the per-key dedupe map grows past this size, expired entries are pruned
+/// so a long session scanning many different codes stays bounded. Kept
+/// consistent with the Android and web implementations.
+private let barcodeDedupeMapPruneThreshold = 64
 
 extension CameraViewManager: AVCaptureMetadataOutputObjectsDelegate {
     /// Set up metadata output for the capture session in case it's not configured yet
@@ -23,7 +34,7 @@ extension CameraViewManager: AVCaptureMetadataOutputObjectsDelegate {
             }
 
             captureSession.addOutput(newOutput)
-            newOutput.setMetadataObjectsDelegate(self, queue: DispatchQueue.main)
+            newOutput.setMetadataObjectsDelegate(self, queue: barcodeMetadataQueue)
             metadataOutput = newOutput
         }
 
@@ -43,6 +54,16 @@ extension CameraViewManager: AVCaptureMetadataOutputObjectsDelegate {
         if let metadataOutput = captureSession.outputs.first(where: { $0 is AVCaptureMetadataOutput }) {
             captureSession.removeOutput(metadataOutput)
         }
+        resetBarcodeDedupeState()
+    }
+
+    /// Clears the per-key dedupe map so a freshly (re)started detection session
+    /// emits immediately. Hops onto `barcodeMetadataQueue` because the map is
+    /// confined to that queue.
+    internal func resetBarcodeDedupeState() {
+        barcodeMetadataQueue.async { [weak self] in
+            self?.recentBarcodeEmitTimes.removeAll()
+        }
     }
 
     /// Delegate method called when metadata objects are detected in the camera feed
@@ -71,32 +92,66 @@ extension CameraViewManager: AVCaptureMetadataOutputObjectsDelegate {
             return
         }
 
-        let barcodeType = metadataObject.type.rawValue
-
-        // Transform the metadata object to the coordinate space of the video preview layer
-        // This is necessary to get the correct bounding box for the detected barcode
-        // Which in our case should always equal to the device's screen
-        // This way we can simply use pixel coordinates to get the bounding box of the detected barcode and easily show it in the webview
-        guard let transformedMetadataObject = videoPreviewLayer.transformedMetadataObject(for: metadataObject)
-        else {
+        // Normalize onto the shared BarcodeType vocabulary so the emitted `type`
+        // matches web and Android.
+        let barcodeType = convertToStringBarcodeType(metadataObject.type) ?? metadataObject.type.rawValue
+
+        // Suppress re-emission of the same code within the suppression window so
+        // a static barcode in view produces a bounded event rate instead of one
+        // event per frame. Timestamps are tracked per key so multiple codes in
+        // frame can't defeat the window by alternating. The raw-bytes hash is
+        // part of the key so two distinct binary-only codes (empty `stringValue`)
+        // don't suppress each other. Runs on the serial `barcodeMetadataQueue`,
+        // so no locking is needed.
+        let rawBytesKeyComponent = rawBytes.map { String($0.hashValue) } ?? ""
+        let barcodeKey = "\(barcodeType)\u{0}\(barcodeValue)\u{0}\(rawBytesKeyComponent)"
+        // Monotonic clock: a backward wall-clock jump must not extend the window.
+        let now = CACurrentMediaTime()
+        if let lastEmit = recentBarcodeEmitTimes[barcodeKey], now - lastEmit < barcodeSuppressionWindow {
             return
         }
 
-        let boundingRect = BarcodeDetectedEvent.BoundingRect(
-            x: Double(transformedMetadataObject.bounds.origin.x),
-            y: Double(transformedMetadataObject.bounds.origin.y),
-            width: Double(transformedMetadataObject.bounds.width),
-            height: Double(transformedMetadataObject.bounds.height)
-        )
-
-        eventEmitter.emitBarcodeDetected(
-            BarcodeDetectedEvent(
-                value: barcodeValue,
-                rawBytes: rawBytes,
-                type: barcodeType,
-                boundingRect: boundingRect
+        // Prune expired entries once the map grows, keeping it bounded during
+        // long sessions that scan many different codes.
+        if recentBarcodeEmitTimes.count > barcodeDedupeMapPruneThreshold {
+            recentBarcodeEmitTimes = recentBarcodeEmitTimes.filter {
+                now - $0.value < barcodeSuppressionWindow
+            }
+        }
+        // Recorded before the main-queue hop below so the map is only ever
+        // touched from `barcodeMetadataQueue`.
+        recentBarcodeEmitTimes[barcodeKey] = now
+
+        // `videoPreviewLayer` is a `CALayer` mutated concurrently by the main
+        // thread, so every layer access has to be main-confined. Only the cheap
+        // parse / dedupe work above stays on the private queue.
+        DispatchQueue.main.async { [weak self] in
+            guard let self = self else { return }
+
+            // Transform the metadata object into the preview layer's coordinate
+            // space, which equals the webview's, so the bounding box can be used
+            // as pixel coordinates directly.
+            guard let transformedMetadataObject = self.videoPreviewLayer.transformedMetadataObject(for: metadataObject)
+            else {
+                return
+            }
+
+            let boundingRect = BarcodeDetectedEvent.BoundingRect(
+                x: Double(transformedMetadataObject.bounds.origin.x),
+                y: Double(transformedMetadataObject.bounds.origin.y),
+                width: Double(transformedMetadataObject.bounds.width),
+                height: Double(transformedMetadataObject.bounds.height)
             )
-        )
+
+            self.eventEmitter.emitBarcodeDetected(
+                BarcodeDetectedEvent(
+                    value: barcodeValue,
+                    rawBytes: rawBytes,
+                    type: barcodeType,
+                    boundingRect: boundingRect
+                )
+            )
+        }
     }
 
     private func getRawBytes(from metadataObject: AVMetadataMachineReadableCodeObject) -> [UInt8]? {

package/ios/Sources/CameraViewPlugin/CameraViewManager+DeferredStart.swift

@@ -0,0 +1,37 @@
+import AVFoundation
+import Foundation
+
+/// Deferred Start (iOS 26+) lets `startRunning()` return as soon as the preview
+/// pipeline is up and initializes the remaining outputs shortly afterwards,
+/// roughly halving the time until the first frame is visible.
+///
+/// The photo and video data outputs are deferred; the preview layer is not,
+/// since it is the one consumer that must be live immediately and its first
+/// frame is what triggers the deferred initialization. The metadata output is
+/// added in its own transaction after the session is already running, so it
+/// never contributes to `startRunning()` latency.
+extension CameraViewManager {
+
+    /// Marks an output as deferrable so the session does not prepare its
+    /// resources until after `startRunning()` has returned.
+    ///
+    /// No-op below iOS 26 and on outputs that don't support deferral (setting the
+    /// flag on those raises `NSInvalidArgumentException`). Must be called inside
+    /// the configuration transaction that adds the output.
+    internal func deferStart(of output: AVCaptureOutput, _ deferred: Bool = true) {
+        if #available(iOS 26.0, *), output.isDeferredStartSupported {
+            output.isDeferredStartEnabled = deferred
+        }
+    }
+
+    /// Lets the session decide when to run the deferred initialization.
+    ///
+    /// Set explicitly rather than relying on the default, which is only `true`
+    /// for host apps linked against the iOS 26 SDK or later. Must be called
+    /// inside a configuration transaction on the session queue.
+    internal func configureAutomaticDeferredStart() {
+        if #available(iOS 26.0, *) {
+            captureSession.automaticallyRunsDeferredStart = true
+        }
+    }
+}

package/ios/Sources/CameraViewPlugin/CameraViewManager+Focus.swift

@@ -0,0 +1,131 @@
+import AVFoundation
+import Foundation
+
+/// How long a one-shot tap-to-focus is held before continuous auto focus and
+/// exposure are restored, so focus is never left permanently locked. A
+/// subsequent `setFocusPoint` call cancels and replaces the pending restore.
+private let cameraFocusResetDelay: TimeInterval = 3.0
+
+extension CameraViewManager {
+    /// Focuses and meters the camera at a point expressed in the preview
+    /// layer's coordinate space (CSS/viewport pixels), i.e. tap-to-focus.
+    ///
+    /// The layer point is converted to a normalized device point on the main
+    /// thread (preview-layer geometry is main-thread only), then the device is
+    /// configured on `sessionQueue`. A one-shot `.autoFocus`/`.autoExpose` is
+    /// applied and continuous auto modes are restored after a short delay.
+    ///
+    /// - Parameters:
+    ///   - x: Horizontal coordinate in CSS/viewport pixels from the left edge.
+    ///   - y: Vertical coordinate in CSS/viewport pixels from the top edge.
+    ///   - completion: Called on the main queue with `nil` on success or an error.
+    // swiftlint:disable:next identifier_name
+    func setFocusPoint(x: CGFloat, y: CGFloat, completion: @escaping (Error?) -> Void) {
+        guard captureSession.isRunning else {
+            completion(CameraError.sessionNotRunning)
+            return
+        }
+
+        let layerPoint = CGPoint(x: x, y: y)
+
+        // `captureDevicePointConverted(fromLayerPoint:)` accounts for the
+        // layer's `videoGravity` and its connection's rotation, so the mapping
+        // holds in both scale modes and in both orientations.
+        DispatchQueue.main.async { [weak self] in
+            guard let self = self else { return }
+            let devicePoint = self.videoPreviewLayer.captureDevicePointConverted(fromLayerPoint: layerPoint)
+
+            self.sessionQueue.async {
+                do {
+                    try self.applyFocusPoint(devicePoint)
+                    DispatchQueue.main.async { completion(nil) }
+                } catch {
+                    DispatchQueue.main.async { completion(error) }
+                }
+            }
+        }
+    }
+
+    /// Applies the one-shot focus/exposure point of interest to the current
+    /// device and schedules the continuous-mode restore. Must run on
+    /// `sessionQueue`.
+    ///
+    /// Fixed-focus cameras (some front cameras) degrade to exposure-only
+    /// metering. If neither focus nor exposure at a point is supported, throws
+    /// `CameraError.focusNotSupported`.
+    private func applyFocusPoint(_ devicePoint: CGPoint) throws {
+        guard let device = currentCameraDevice else {
+            throw CameraError.cameraUnavailable
+        }
+
+        let canFocus = device.isFocusPointOfInterestSupported && device.isFocusModeSupported(.autoFocus)
+        let canExpose = device.isExposurePointOfInterestSupported && device.isExposureModeSupported(.autoExpose)
+
+        guard canFocus || canExpose else {
+            throw CameraError.focusNotSupported
+        }
+
+        do {
+            try device.lockForConfiguration()
+            defer { device.unlockForConfiguration() }
+
+            if canFocus {
+                device.focusPointOfInterest = devicePoint
+                device.focusMode = .autoFocus
+            }
+
+            if canExpose {
+                device.exposurePointOfInterest = devicePoint
+                device.exposureMode = .autoExpose
+            }
+        } catch {
+            throw CameraError.configurationFailed(error)
+        }
+
+        scheduleFocusReset()
+    }
+
+    /// Schedules restoration of continuous auto focus/exposure after
+    /// `cameraFocusResetDelay`, cancelling any previously scheduled restore so
+    /// rapid taps don't reset a later focus. Must run on `sessionQueue`.
+    private func scheduleFocusReset() {
+        focusResetWorkItem?.cancel()
+
+        let workItem = DispatchWorkItem { [weak self] in
+            self?.restoreContinuousFocusAndExposure()
+        }
+        focusResetWorkItem = workItem
+
+        sessionQueue.asyncAfter(deadline: .now() + cameraFocusResetDelay, execute: workItem)
+    }
+
+    /// Restores continuous auto focus/exposure centered on the frame, so a
+    /// one-shot tap-to-focus never leaves the camera permanently locked.
+    /// Best-effort: configuration failures are ignored. Runs on `sessionQueue`.
+    private func restoreContinuousFocusAndExposure() {
+        guard let device = currentCameraDevice else { return }
+
+        do {
+            try device.lockForConfiguration()
+            defer { device.unlockForConfiguration() }
+
+            let center = CGPoint(x: 0.5, y: 0.5)
+
+            if device.isFocusPointOfInterestSupported {
+                device.focusPointOfInterest = center
+            }
+            if device.isFocusModeSupported(.continuousAutoFocus) {
+                device.focusMode = .continuousAutoFocus
+            }
+
+            if device.isExposurePointOfInterestSupported {
+                device.exposurePointOfInterest = center
+            }
+            if device.isExposureModeSupported(.continuousAutoExposure) {
+                device.exposureMode = .continuousAutoExposure
+            }
+        } catch {
+            // Best-effort restore; nothing actionable if the device is busy.
+        }
+    }
+}

package/ios/Sources/CameraViewPlugin/CameraViewManager+Lifecycle.swift

@@ -0,0 +1,156 @@
+import AVFoundation
+import Foundation
+import UIKit
+
+/// Handles app lifecycle transitions and `AVCaptureSession` interruption /
+/// runtime-error notifications.
+///
+/// Backgrounding pauses the session (and finalizes any in-flight recording so
+/// its JS promise settles); returning to the foreground resumes it. Session
+/// interruptions (phone calls, Control Center audio capture, iPad camera loss)
+/// and runtime errors are surfaced to JS as `cameraInterrupted`,
+/// `cameraResumed`, and `cameraRuntimeError` events, and a media-services reset
+/// restarts the session automatically.
+extension CameraViewManager {
+
+    // MARK: - App Lifecycle Observers
+
+    /// Sets up observers for app background/foreground transitions.
+    ///
+    /// Uses `didEnterBackground`/`willEnterForeground` rather than
+    /// `willResignActive`/`didBecomeActive` on purpose: resign/active also fire
+    /// for Control Center pull-downs, notification banners, and permission
+    /// dialogs, none of which should tear down the session.
+    internal func setupAppLifecycleObservers() {
+        NotificationCenter.default.addObserver(
+            self,
+            selector: #selector(handleAppDidEnterBackground),
+            name: UIApplication.didEnterBackgroundNotification,
+            object: nil
+        )
+
+        NotificationCenter.default.addObserver(
+            self,
+            selector: #selector(handleAppWillEnterForeground),
+            name: UIApplication.willEnterForegroundNotification,
+            object: nil
+        )
+    }
+
+    /// Pauses the camera session when the app enters the background.
+    ///
+    /// Stopping the running session finalizes any in-flight recording, which
+    /// invokes the recording delegate and settles a pending `stopRecording`
+    /// promise (with the partial file or an error) rather than leaving it to
+    /// hang.
+    @objc internal func handleAppDidEnterBackground() {
+        guard captureSession.isRunning else { return }
+        sessionQueue.async { [weak self] in
+            self?.captureSession.stopRunning()
+        }
+    }
+
+    /// Resumes the camera session when the app returns to the foreground.
+    @objc internal func handleAppWillEnterForeground() {
+        guard !captureSession.isRunning else { return }
+        sessionQueue.async { [weak self] in
+            // Re-checked on the session queue: `isRunning` can have changed
+            // since the cheap check above, and `isSessionStoppedByUser` is
+            // confined to this queue.
+            guard let self = self, !self.isSessionStoppedByUser, !self.captureSession.isRunning else { return }
+            self.captureSession.startRunning()
+        }
+    }
+
+    // MARK: - Interruption & Runtime-Error Observers
+
+    /// Sets up observers for capture-session interruption and runtime-error
+    /// notifications, scoped to this manager's `captureSession`.
+    internal func setupInterruptionObservers() {
+        NotificationCenter.default.addObserver(
+            self,
+            selector: #selector(handleSessionWasInterrupted(_:)),
+            name: AVCaptureSession.wasInterruptedNotification,
+            object: captureSession
+        )
+
+        NotificationCenter.default.addObserver(
+            self,
+            selector: #selector(handleSessionInterruptionEnded(_:)),
+            name: AVCaptureSession.interruptionEndedNotification,
+            object: captureSession
+        )
+
+        NotificationCenter.default.addObserver(
+            self,
+            selector: #selector(handleSessionRuntimeError(_:)),
+            name: AVCaptureSession.runtimeErrorNotification,
+            object: captureSession
+        )
+    }
+
+    /// Handles a capture-session interruption (e.g. phone call, another app
+    /// using the camera, iPad Split View camera loss) by emitting
+    /// `cameraInterrupted` with a reason.
+    @objc internal func handleSessionWasInterrupted(_ notification: Notification) {
+        eventEmitter.emitCameraInterrupted(
+            reason: interruptionReasonString(from: notification)
+        )
+    }
+
+    /// Handles the end of a capture-session interruption. AVFoundation resumes
+    /// the session automatically; we just surface `cameraResumed` to JS.
+    @objc internal func handleSessionInterruptionEnded(_ notification: Notification) {
+        eventEmitter.emitCameraResumed()
+    }
+
+    /// Handles a capture-session runtime error by emitting `cameraRuntimeError`
+    /// and restarting the session when media services were reset.
+    @objc internal func handleSessionRuntimeError(_ notification: Notification) {
+        let error = notification.userInfo?[AVCaptureSessionErrorKey] as? AVError
+        let message = error?.localizedDescription
+            ?? "Unknown capture session runtime error"
+        eventEmitter.emitCameraRuntimeError(
+            message: message,
+            code: error?.code.rawValue
+        )
+
+        // A media-services reset invalidates the session; restart it so the
+        // preview recovers instead of staying frozen.
+        guard error?.code == .mediaServicesWereReset else { return }
+        sessionQueue.async { [weak self] in
+            guard let self = self, !self.isSessionStoppedByUser, !self.captureSession.isRunning else { return }
+            self.captureSession.startRunning()
+        }
+    }
+
+    // MARK: - Helpers
+
+    /// Maps an interruption notification's reason to a stable JS string that
+    /// mirrors the `CameraInterruptionReason` TypeScript union.
+    private func interruptionReasonString(from notification: Notification) -> String {
+        guard
+            let reasonValue = notification.userInfo?[
+                AVCaptureSessionInterruptionReasonKey
+            ] as? Int,
+            let reason = AVCaptureSession.InterruptionReason(rawValue: reasonValue)
+        else {
+            return "unknown"
+        }
+
+        switch reason {
+        case .videoDeviceNotAvailableInBackground:
+            return "videoDeviceNotAvailableInBackground"
+        case .audioDeviceInUseByAnotherClient:
+            return "audioDeviceInUseByAnotherClient"
+        case .videoDeviceInUseByAnotherClient:
+            return "videoDeviceInUseByAnotherClient"
+        case .videoDeviceNotAvailableWithMultipleForegroundApps:
+            return "videoDeviceNotAvailableWithMultipleForegroundApps"
+        case .videoDeviceNotAvailableDueToSystemPressure:
+            return "videoDeviceNotAvailableDueToSystemPressure"
+        @unknown default:
+            return "unknown"
+        }
+    }
+}