Supporting Center Stage front camera in your iOS app

At a glance

Project structure

CenterStageFrontCamera/CenterStageFrontCam/
├── CenterStageFrontCam.swift
├── CameraModel.swift
├── CaptureService.swift
├── Capture/
│   ├── DeviceLookup.swift
│   ├── PhotoCapture.swift
│   └── MovieCapture.swift
├── Model/
│   ├── Camera.swift
│   ├── CameraState.swift
│   └── DataTypes.swift
├── Views/
│   ├── CameraUI.swift
│   ├── Controls/
│   ├── Overlays/
│   └── Toolbars/
└── Support/

The source separates observable app state from capture mechanics. PreviewCameraModel is a protocol-compatible fake kept under Preview Content.

Overall architecture

flowchart LR
    App["CenterStageFrontCam"] --> View["CameraView / CameraUI"]
    View --> CameraAPI["Camera protocol"]
    CameraAPI --> Model["CameraModel @Observable"]
    Model --> Service["CaptureService actor"]
    Model --> Library["MediaLibrary"]
    Service --> Session["AVCaptureSession"]
    Service --> Photo["PhotoCapture"]
    Service --> Movie["MovieCapture"]
    Service --> Monitor["Smart framing monitor"]

Reference code

CenterStageFrontCamera/CenterStageFrontCam/CameraModel.swift:12 — the source explicitly defines the mediator boundary (abridged).

@Observable
final class CameraModel: Camera {
    // ...
}

Calling this MVVM is an interpretation, but it is strongly supported by this declared mediation role and the model-driven generic views.

Ownership and state

classDiagram
    CenterStageFrontCam *-- CameraModel
    CameraModel *-- CaptureService
    CameraModel *-- MediaLibrary
    CameraModel *-- CameraState
    CaptureService *-- AVCaptureSession
    CaptureService *-- PhotoCapture
    CaptureService *-- MovieCapture
    CameraUI --> CameraModel : observes via Camera

Ownership evidence

CenterStageFrontCamera/CenterStageFrontCam/CameraModel.swift:23 — read-only UI state and private owned collaborators (abridged).

private(set) var status = CameraStatus.unknown
private(set) var captureActivity = CaptureActivity.idle
private(set) var thumbnail: CGImage?

private let mediaLibrary = MediaLibrary()
private let captureService = CaptureService()
private var cameraState = CameraState()

Class and protocol design

classDiagram
    class Camera {
        <<protocol>>
        start()
        capturePhoto()
        toggleRecording()
    }
    CameraModel ..|> Camera
    PreviewCameraModel ..|> Camera
    class OutputService {
        <<protocol>>
        output
        updateConfiguration()
    }
    PhotoCapture ..|> OutputService
    MovieCapture ..|> OutputService
    CaptureService --> OutputService

Reference code

CenterStageFrontCamera/CenterStageFrontCam/Model/Camera.swift:11 and CenterStageFrontCamera/CenterStageFrontCam/Model/DataTypes.swift:170 — UI substitution and capture-output capabilities are separate protocols (abridged).

@MainActor
protocol Camera: AnyObject, SendableMetatype {
    var status: CameraStatus { get }
    var previewSource: PreviewSource { get }
    func start() async
    func capturePhoto() async
    func toggleRecording() async
}

protocol OutputService {
    associatedtype Output: AVCaptureOutput
    nonisolated var output: Output { get }
    nonisolated func updateConfiguration(for device: AVCaptureDevice)
}

The first protocol makes views previewable without hardware. The second lets CaptureService configure heterogeneous photo/movie outputs through shared behavior.

Access control

CenterStageFrontCamera/CenterStageFrontCam/CaptureService.swift:13 (abridged):

actor CaptureService {
    private(set) var captureActivity: CaptureActivity = .idle
    nonisolated let captureActivityStream: AsyncStream<CaptureActivity>
    nonisolated let previewSource: PreviewSource
    private let captureSession = AVCaptureSession()
    private let photoCapture = PhotoCapture()
    private let movieCapture = MovieCapture()
}

Logic ownership and placement

Design patterns

Naming conventions

• Protocols name capabilities (Camera, OutputService, PreviewSource, PreviewTarget).
• Concrete types use responsibility nouns (CaptureService, MediaLibrary, DeviceLookup).
• Commands are verbs (start, capturePhoto, toggleRecording, applyRecommendedFraming).
• State uses is/should/prefers; private(set) marks externally readable results.
• Files generally match their primary type; view subfolders group Controls, Overlays, and Toolbars.

Architecture takeaways

• Put the observable main-actor model between SwiftUI and the actor-owned capture graph.
• Use capability protocols where there is a real substitute: previews and heterogeneous capture outputs.
• Publish immutable streams/preview endpoints from the actor; retain mutation inside it.
• Keep photo/movie capture and Photos persistence as distinct owners.

Source map

Source caveat: the catalog marks the required iOS, iPadOS, Mac Catalyst, and Xcode 27 APIs as beta at review time.

• Official Apple documentation