AVCam: Building a camera app

At a glance

Project structure

AVCam/
├── AVCamApp.swift
├── CameraModel.swift
├── CameraView.swift
├── CaptureService.swift
├── Capture/
│   ├── DeviceLookup.swift
│   ├── PhotoCapture.swift
│   ├── MovieCapture.swift
│   └── SPCObserver.swift
├── Model/
│   ├── Camera.swift
│   ├── CameraState.swift
│   ├── DataTypes.swift
│   ├── Intent/AVCamCaptureIntent.swift
│   └── MediaLibrary.swift
├── Views/
│   ├── CameraPreview.swift
│   ├── Controls/
│   ├── Overlays/
│   └── Toolbars/
└── Support/
AVCamCaptureExtension/
AVCamControlCenterExtension/

Structure observations

• Capture mechanics are separated from observable screen state and from SwiftUI view composition.
• PhotoCapture and MovieCapture isolate output-specific behavior under Capture/; shared app-facing contracts and value types live under Model/.
• Preview bridging lives with views because it adapts an AVCaptureVideoPreviewLayer-backed UIView to SwiftUI.
• The app, capture extension, and Control Center extension are separate targets but share model intent/state concepts.

Overall architecture

flowchart LR
    App["AVCamApp"] --> View["CameraView<Camera>"]
    App --> Model["CameraModel"]
    View --> Model
    Model --> Capture["CaptureService actor"]
    Model --> Library["MediaLibrary actor"]
    Capture --> Outputs["PhotoCapture + MovieCapture"]
    Capture --> Session["AVCaptureSession"]
    Library --> Photos["PhotoKit"]

Reference code

AVCam/AVCamApp.swift:13 — composition root

struct AVCamApp: App {
    @State private var camera = CameraModel()

    var body: some Scene {
        WindowGroup {
            CameraView(camera: camera)
                .task {
                    await camera.start()
                }
        }
    }
}

Interpretation

AVCamApp is the composition root and long-lived owner of CameraModel. The model mediates all view intents and observable state; it delegates capture and photo-library work instead of owning framework details. Calling this MVVM is an architectural interpretation supported by the source comments and dependency direction, not a type named ViewModel.

Ownership and state

classDiagram
    AVCamApp *-- CameraModel : State creates
    CameraView --> CameraModel : observes and sends intents
    CameraModel *-- CaptureService : creates
    CameraModel *-- MediaLibrary : creates
    CaptureService *-- AVCaptureSession : creates
    CaptureService *-- PhotoCapture : creates
    CaptureService *-- MovieCapture : creates
    CaptureService *-- DefaultPreviewSource : exposes capability

Ownership evidence

AVCam/CameraModel.swift:63 — model dependencies

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

Class and protocol design

classDiagram
    class Camera {
        <<protocol>>
    }
    class OutputService {
        <<protocol>>
    }
    class PreviewSource {
        <<protocol>>
    }
    class PreviewTarget {
        <<protocol>>
    }
    CameraModel ..|> Camera
    PreviewCameraModel ..|> Camera
    CameraView --> Camera
    PhotoCapture ..|> OutputService
    MovieCapture ..|> OutputService
    DefaultPreviewSource ..|> PreviewSource
    CameraPreview --> PreviewSource
    CameraPreview ..> PreviewTarget

Reference code

AVCam/CameraView.swift:12 — protocol-oriented view dependency

@MainActor
struct CameraView<CameraModel: Camera>: PlatformView {
    @State var camera: CameraModel
    // ...
}

Access control

Reference code

AVCam/CameraModel.swift:24 — read-only view state

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

No public, open, or fileprivate declaration appears in the AVCam Swift sources.

Logic ownership and placement

Design patterns

Main application flow

sequenceDiagram
    actor User
    participant View as CameraView
    participant Model as CameraModel
    participant Service as CaptureService
    participant Photo as PhotoCapture
    participant Library as MediaLibrary
    User->>View: Tap shutter
    View->>Model: capturePhoto()
    Model->>Service: capturePhoto(features)
    Service->>Photo: capturePhoto(features)
    Photo-->>Model: Photo
    Model->>Library: save(photo)
    Library-->>Model: thumbnail stream update
    Model-->>View: observable thumbnail/activity

Reference code

AVCam/CameraModel.swift:153 — photo flow coordinator

func capturePhoto() async {
    do {
        let photo = try await captureService.capturePhoto(with: currentPhotoFeatures)
        try await mediaLibrary.save(photo: photo)
    } catch {
        self.error = error
    }
}

Naming conventions

• Types: role nouns (CameraModel, CaptureService, MediaLibrary) and feature-specific services (PhotoCapture, MovieCapture).
• Protocols: capability or endpoint nouns (Camera, OutputService, PreviewSource, PreviewTarget).
• Methods: user commands (capturePhoto, toggleRecording, switchVideoDevices) and setup verbs (setUpSession, configureControls).
• State: Boolean names use is, should, or prefers; state snapshots use noun types such as CaptureActivity and CaptureCapabilities.
• Files: primary type per file; folders group feature mechanics, model contracts, views, and extensions.

Architecture takeaways

• The main actor owns presentation state; a dedicated actor owns the AVFoundation graph and its serial executor.
• Views depend on a Camera capability, allowing Simulator/preview substitution without conditional UI architecture.
• Output-specific delegates and state stay in PhotoCapture and MovieCapture, preventing CaptureService from becoming the only implementation class.
• A narrow preview-source protocol crosses the UI/capture boundary without publishing the capture session.
• private(set) makes observable state readable while keeping mutation authority explicit.

Source map

• Official Apple documentation