Capturing consistent color images

At a glance

Project structure

ConstantColorCam/
├── ConstantColorCamApp.swift
├── ContentView.swift
├── CameraView.swift
├── DataModel.swift
├── Camera.swift
├── ViewFinderView.swift
├── PhotosTabView.swift
├── PhotoLibrary.swift
└── Assets.xcassets/

Structure observations

• View composition is split into focused SwiftUI files; capture and result mechanics are concentrated in Camera.swift.
• DataModel has one job: convert the camera’s CIImage preview stream to SwiftUI Image state.
• There is no app-defined protocol between DataModel and Camera; the relationship is concrete.

Overall architecture

flowchart LR
    App["ConstantColorCamApp"] --> CameraView["CameraView"]
    CameraView --> Model["DataModel"]
    Model --> Camera["Camera"]
    Camera --> Session["AVCaptureSession"]
    Session --> Video["Video data output"]
    Video --> Stream["AsyncStream<CIImage>"]
    Stream --> Model
    Model --> Finder["ViewFinderView"]
    Session --> Photo["Photo output"]
    Photo --> Camera
    Camera --> Results["Captured image/confidence state"]
    Results --> PhotosView["PhotosTabView"]
    Camera --> Library["PhotoKit save"]

Reference code

ConstantColorCam/DataModel.swift:12 — preview bridge

var camera = Camera()
var viewfinderImage: Image?

func handleCameraPreviews() async {
    let imageStream = camera.previewStream.map { $0.image }
    for await image in imageStream {
        Task { @MainActor in
            viewfinderImage = image
        }
    }
}

Interpretation

The observable model bridges the camera’s framework-oriented preview stream into SwiftUI image state. Camera setup, capture settings, photo classification, and saving all remain inside the concrete Camera object. Calling DataModel a view model is directly supported by its file comment; the broader architecture is MVVM-style rather than a fully abstracted MVVM stack.

Ownership and state

classDiagram
    CameraView *-- DataModel : State creates
    DataModel *-- Camera : creates
    Camera *-- AVCaptureSession : creates
    Camera *-- AVCapturePhotoOutput : creates during setup
    Camera *-- AVCaptureVideoDataOutput : creates during setup
    Camera *-- AsyncStream : creates
    Camera --> PhotosTabView : supplies result values through CameraView

Ownership evidence

ConstantColorCam/CameraView.swift:11 and ConstantColorCam/DataModel.swift:10 — root model ownership

struct CameraView: View {
    @State private var model = DataModel()
}

@Observable
final class DataModel {
    var camera = Camera()
}

Class and protocol design

The sample defines no app-specific protocol for capture or preview. Camera directly conforms to AVFoundation delegate protocols in extensions; PhotoLibrary is a stateless authorization helper with a static method.

Access control

Reference code

ConstantColorCam/DataModel.swift:33 — same-file conversion helper

fileprivate extension CIImage {
    var image: Image? {
        let ciContext = CIContext()
        guard let cgImage = ciContext.createCGImage(self, from: self.extent) else { return nil }
        return Image(decorative: cgImage, scale: 1, orientation: .up)
    }
}

No public, open, or private(set) declaration appears in this sample’s Swift source.

Logic ownership and placement

Design patterns

Main application flow

sequenceDiagram
    actor User
    participant View as CameraView
    participant Camera
    participant Output as AVCapturePhotoOutput
    participant Results as PhotosTabView
    User->>View: Tap shutter
    View->>View: Validate option combination
    View->>Camera: set options and takePhoto()
    Camera->>Output: capturePhoto(settings, delegate)
    Output-->>Camera: didFinishProcessingPhoto
    Camera->>Camera: classify constant/fallback/normal result
    Camera-->>Results: photosViewVisible and image state

Reference code

ConstantColorCam/Camera.swift:389 — capture settings handoff

func takePhoto() {
    guard let photoOutput else { return }
    let photoSettings = AVCapturePhotoSettings()
    sessionQueue.async {
        photoSettings.flashMode = self.flashEnabled ? .on : .off
        photoSettings.isConstantColorEnabled = self.constantColorEnabled
        photoSettings.isConstantColorFallbackPhotoDeliveryEnabled = self.fallBackPhotoDeliveryEnabled
        photoOutput.capturePhoto(with: photoSettings, delegate: self)
    }
}

Naming conventions

• Types: concise responsibility nouns (DataModel, Camera, PhotoLibrary) and SwiftUI role suffixes (CameraView, PhotosTabView).
• Methods: command names (takePhoto, switchCaptureDevice) and event/bridge names (handleCameraPreviews).
• State: Boolean properties use is..., ...Enabled, ...Supported, ...Visible, or ...Available.
• Files: generally one primary type or closely related SwiftUI subviews per file.
• There are no app-defined protocol naming conventions to assess.

Architecture takeaways

• An AsyncStream is a compact bridge from capture callbacks to an observable SwiftUI model.
• DataModel remains narrow, but Camera intentionally combines session, result, and save logic for sample readability.
• fileprivate limits the one-off Core Image conversion to its sole source file.
• Unlike AVCam, captured-result and setting properties use mutable internal access; ownership is conventional rather than compiler-enforced.
• UI option validation lives in the screen, while AVFoundation capability/configuration checks stay in the camera object.

Source map

• Official Apple documentation