Accessing the main camera

At a glance

Project structure

Source bundle/
└── AccessingTheMainCamera/
    ├── CameraSessionManager.swift  # CameraSessionManager, CameraConfiguration
    ├── CameraFeed.swift  # CameraFeed
    ├── CameraFrameView.swift  # CameraFrameView, SampleBufferPreview
    ├── AccessingTheMainCameraApp.swift  # AccessingTheMainCameraApp
    ├── MainCameraView.swift  # MainCameraView
    └── ContentView.swift  # ContentView

Structure observations

• The runtime boundary is WindowGroup; the pruned tree lists only files that explain lifecycle, state, or framework integration.
• App code is split into role-named views, models, managers, providers, components, or systems.

Overall architecture

flowchart LR
    AccessingTheMainCameraApp_1["AccessingTheMainCameraApp"]
    WindowGroup_2["WindowGroup"]
    MainCameraView_3["MainCameraView"]
    CameraSessionManager_4["CameraSessionManager"]
    ARKit_CameraFrameProvider___AVFoundation_5["ARKit CameraFrameProvider + AVFoundation"]
    AccessingTheMainCameraApp_1 --> WindowGroup_2
    WindowGroup_2 --> MainCameraView_3
    MainCameraView_3 --> CameraSessionManager_4
    CameraSessionManager_4 --> ARKit_CameraFrameProvider___AVFoundation_5

Reference code

AccessingTheMainCamera/AccessingTheMainCameraApp.swift:11 — the app or executable entry declares the outer scene lifecycle.

struct AccessingTheMainCameraApp: App {

    var body: some Scene {
        WindowGroup {
            ContentView()
        }
     }
}

The diagram is a responsibility flow, not a claim that every adjacent node directly calls the next. It keeps scene ownership, shared state, RealityKit content, and framework-provider work at separate levels.

Ownership and state

classDiagram
    MainCameraView *-- CameraSessionManager : sessionManager
    CameraConfiguration --> ARKitSession : arkitSession
    CameraConfiguration --> CameraFrameProvider : cameraFrameProvider
    CameraFrameView --> CALayer : preview

Ownership evidence

AccessingTheMainCamera/MainCameraView.swift:11 — representative stored state or the nearest verified lifecycle anchor.

    @State private var sessionManager = CameraSessionManager()

Ownership here is deliberately narrow: @Environment and weak references are shared links, initialized @State or stored services are lifecycle ownership, and a RealityView content closure owns additions to its entity graph without making the SwiftUI view a reference-type owner.

Class and protocol design

The source defines no local substitution protocol in the reviewed boundary. Its protocol use is framework-facing (App, View, RealityKit/ARKit protocols, or platform adapters), so this document does not label the whole app protocol-oriented.

Access control

No reviewed declaration uses fileprivate, public, open; unmodified Swift declarations are internal.

Reference code

AccessingTheMainCamera/CameraSessionManager.swift:58 — representative visibility boundary.

    private(set) var accessDenied = false
    static let isSupported = CameraFrameProvider.isSupported
    
    // MARK: - Configuration
    /// The configuration for the camera frame format.
    var configuration: CameraConfiguration = .default {
        // ...
    }

Logic ownership and placement

Design patterns

Naming conventions

• Role suffixes are evidence, not decoration: App: AccessingTheMainCameraApp; Manager: CameraSessionManager; View: CameraFrameView, ContentView, MainCameraView.
• Protocols: no app-defined protocol in the reviewed source.
• Commands use verb-led methods: run, clearCameraFeeds, handleCameraSettingChange, observeCameraAccess, observeCameraFrameUpdates, restart, runCameraFrameProvider, update.
• Files generally match their primary type; Views, Models, Managers, Providers, Components, Systems, and Packages folders describe architectural roles where present.

Architecture takeaways

• Treat AccessingTheMainCameraApp as the owner of scene declarations, not as the owner of every RealityKit entity created later.
• Keep view-local interaction in SwiftUI, but move provider sessions, playback resources, shared game state, or transport state into a stable owner when their lifetime exceeds one render pass.
• Run ARKit providers for the scene lifetime and consume their asynchronous updates in cancellable tasks; map anchors to entities at the boundary.

Source map

• Official Apple documentation