iPhone Duo SDK Explained: New iOS 27.1 SwiftUI, UIKit and Camera APIs

Summary. The iPhone Duo SDK is the iOS 27.1 SDK that ships in Xcode 27.1, and as of 18 September 2026 Apple still lists the Xcode 27.1 beta as coming later this month. It adds arrangement views for layouts that span the fold, reserved regions for the fold and the two front cameras, vertical toolbars and tab bars, a hinge API, direction-aware camera APIs and a camera capture accessory that puts content on the outer display. iPhone Duo becomes available on 23 October running iOS 27.1, so the window for testing against the real SDK is short.

Beyond the headline facts of two displays and a hinge, Apple's developer documentation defines a named set of SwiftUI, UIKit, AVFoundation and AVKit APIs for this device. This iPhone Duo developer guide works directly from that documentation and Apple's six iPhone Duo Tech Talks: what Xcode 27.1 will include, what each new API does, where the camera story changes, and what is new versus existing iPad-style adaptivity applied to a new shape.

The iPhone Duo SDK at a glance

Apple's guidance centres on one Technology Overview, "Preparing your app for iPhone Duo", with a Human Interface Guidelines companion, "Designing for iPhone Duo". Six Tech Talks back it up:

• Design for iPhone Duo

• Prepare your app for iPhone Duo

• Raise the bar with iPhone Duo (vertical bars)

• Strike a pose with adaptive layouts on iPhone Duo (arrangement views and reserved regions)

• Multiple displays and scenes on iPhone Duo (hinge, windows, Split View, capture accessory)

• Build a great camera experience for iPhone Duo

The overview also links two WWDC sessions: "Make your UIKit app more flexible" from WWDC25 and "Modernize your UIKit app" from WWDC26. Neither mentions iPhone Duo. They cover the scene-based, resizable UIKit foundation the device builds on, which is why an app that already resizes well starts ahead.

Apple describes iPhone Duo as a foldable phone with a compact outer display and a large inner display, each with a front camera, and the inner front-facing camera is hidden when not in use. Apple's Newsroom puts the displays at 5.4 inches outside and 7.6 inches inside, with the same aspect ratio, which is why content scales between them. For what Apple has and has not confirmed about the hardware, see what Apple published about iPhone Duo specs.

As the phone opens, closes, partially folds and rotates, content moves between displays and adjusts for rotated positions, and when it is partially folded, views adapt to the folding region. Framework-provided views and containers handle the fold and the inner front camera automatically. Your custom views are the part that needs work.

iPhone Duo SDK status and timeline (updated 18 September 2026)

The newest Xcode beta is not the one you need. Xcode 27.2 beta shipped on 16 September, but its release notes say iPhone Duo SDK and simulator support will arrive in an upcoming Xcode 27.1. Times below are in Pacific Time (PT) and India Standard Time (IST).

Dates for the device come from Apple's Newsroom, and the SDK and event dates from Apple Developer News and the iPhone Duo developer page. Apple has not yet said when App Store Connect will accept builds made with the iOS 27.1 SDK.

Which SDK your app is built with decides what users see

Your app runs on iPhone Duo whether or not you rebuild it, but the SDK you build with decides how much of the screen it gets.

• Built with an SDK older than iOS 27: the app still works. With the phone closed it uses the space to the left of the status bar and camera; with the phone open it runs at a familiar size and aspect ratio.

• Built with the iOS 27 SDK: on the inner display, the app extends to the left of the status bar area.

• Built with the iOS 27.1 SDK: the app extends to the edge of the screen, and standard navigation and toolbar buttons lay out vertically under the status bar.

Rebuilding has a prerequisite. The UIScene life cycle is required when building with the iOS 27 SDKs, and an app without it no longer launches. If you have not moved yet, start with our UIScene lifecycle migration guide. UIRequiresFullScreen offers no way out either: iPhone Duo still honours the key, but your app still resizes when someone opens or closes the phone. For a full audit, work through our iPhone Duo readiness checklist for the iOS 27.1 SDK.

iPhone Duo API quick reference

Symbols below are spelled as they appear in Apple's documentation. "iOS 27.1 beta" means the documentation marks the symbol as new in the iOS and iPadOS 27.1 beta. Entries marked iOS 27.0 or earlier are not specific to iPhone Duo but matter on it.

Layout: arrangement views and reserved regions

ArrangementView: split and overlay

If one API shapes how you lay out screens for this device, it is ArrangementView in SwiftUI and UIArrangementViewController in UIKit. Apple presents it as optional (evaluate whether it helps your layout handle the fold), and it is not exclusive to iPhone Duo: it is declared for iOS, iPadOS and Mac Catalyst, and Apple recommends it across all of an app's supported devices.

An arrangement view is a layout container for a primary view and a secondary view, with two styles, split and overlay. In SwiftUI the default .automatic style resolves to split.

• Split: the two views sit side by side when the container is wider than it is tall, and stack with the primary view on top when it is taller than it is wide. The arrangement view adjusts that placement around reserved regions such as the fold.

• Overlay: the primary view sits over the secondary view when there is no active division, which is the case when iPhone Duo is closed or fully open. When the phone is partially open, the overlay splits across the fold, with the primary view in the trailing or bottom part and the secondary view in the leading or top part. The HIG adds that you can collapse the secondary view when you do not want it to appear.

You can restrict an arrangement to an axis. This is Apple's SwiftUI example for a horizontal-only split:

            ArrangementView {
    PrimaryView()
} secondary: {
    SecondaryView()
}
.arrangementViewStyle(.split.axes(.horizontal))
          

When a split is limited to axes that do not include its primary axis, the arrangement shows only the primary view. With .split.axes(.horizontal) in a view that is taller than it is wide, only PrimaryView appears, which is the point: show one view in a vertical layout and two side by side. The UIKit equivalent sets both view controllers and applies the same arrangement:

            let arrangementVC = UIArrangementViewController()
arrangementVC.setViewController(primaryVC, for: .primary)
arrangementVC.setViewController(secondaryVC, for: .secondary)
arrangementVC.updateArrangement(.split.axes(.horizontal))
          

Where you put the container matters. Apple's overview says to avoid placing an arrangement view inside a navigation split view, list, scroll view or any container that might make part of it inaccessible. The HIG and the "Strike a pose" Tech Talk phrase the navigation part the other way round: keep navigation containers such as NavigationStack, NavigationSplitView and TabView around an arrangement view rather than inside it. The overview and the Tech Talk agree on lists and scroll views, so never nest an arrangement view inside one.

Reserved regions: divisions vs occlusions

Reserved regions come in two kinds, and they are different problems. A division happens when the folding region splits a large view into smaller views; that is the fold cutting your layout in two. An occlusion is an area where a hardware element, such as a camera, covers your content.

On iPhone Duo the occlusions are the front cameras. The inner front-facing camera blocks your view only while it is active, and the outer front-facing camera always occludes it. The HIG adds that the outer camera region expands into the Dynamic Island for Live Activities.

In SwiftUI, call reservedRegions(kind:options:layoutDirectionBehavior:) on a GeometryProxy, from a GeometryReader or from onGeometryChange. Only kind is required, as .division or .occlusion. In UIKit, UIView.reservedRegions(kind:options:) returns UIView.ReservedRegion values (you will also see "UIViewReservedRegion", which appears to be the Objective-C spelling; in Swift it is the nested type). Each region carries a frame, margins, a kind, an identifier and isActive.

The active state is the detail that matters most. The fold's region is active when iPhone Duo is partially open and inactive when it is fully open, and when the phone is flat it is inactive with a width of zero. The inner camera's occlusion is active only while that camera is in use. So check the state every time instead of caching a frame once.

Apple's sources disagree on the default query. The Tech Talk says only active regions come back unless you pass .includeInactive, while the symbol documentation says the method returns intersecting regions whether or not they are active. Passing the option explicitly makes your code correct either way, and inactive regions are useful for high-level decisions, such as Apple's suggestion to prefer an even number of grid columns whenever a division region exists:

            GeometryReader { proxy in
    let divisions = proxy.reservedRegions(kind: .division, options: .includeInactive)
    // PhotoGrid is your own view; an even column count keeps cells off the fold
    PhotoGrid(columns: divisions.isEmpty ? 3 : 4)
}
          

In right-to-left languages, SwiftUI mirrors region frames by default, according to the reservedRegions(kind:options:layoutDirectionBehavior:) documentation. Pass .fixed as the layoutDirectionBehavior to get unmirrored frames that match the hardware. For worked layouts, custom styles and sizing, read our ArrangementView and reserved regions deep dive.

Vertical bars: toolbars, tab bars and the icon rule

In some poses, iPhone Duo presents navigation bars, toolbars and tab bars together, vertically, along the side of the display: on the outer display when the phone is closed, and for some views in the leading or trailing position on the inner display when it is open. The inner display in portrait keeps standard horizontal bars, while in landscape its bars sit on the side.

The behaviour arrives when you rebuild against the latest SDK and use the bars that navigation containers provide: the toolbar modifier on a NavigationStack or NavigationSplitView, or a UINavigationController or UITabBarController. Content inside custom bars built from UIToolbar, UINavigationBar or UITabBar is not considered.

You can opt out with .toolbarVerticalBehavior(.disabled) in SwiftUI, or by overriding preferredVerticalBarBehavior to return .disabled in UIKit. Apple suggests doing that only for UIs better served by horizontal bars, such as a fullscreen video player or a calculator, and treating it as a stable choice rather than toggling it per view state.

The system does not apply vertical bars everywhere:

• Inspectors always present bars horizontally, because the detail column next to them already has a vertical bar.

• Split views give the sidebar and content view horizontal bars and the detail view vertical bars.

• Sheets use vertical bars by default on the outer display. On the inner display, sheets are centred by default; their bars are horizontal for centred or leading placements and vertical for trailing placements. Set placement with presentationPlacement(_:) in SwiftUI or UISheetPresentationController.preferredPlacement in UIKit.

The rule that changes how you author toolbar items is about icons and titles. An item presented vertically always uses its icon; presented horizontally it prefers an icon but can fall back to its title; in the overflow menu it shows both. So a toolbar item with a title and no icon is not presented vertically. It does not disappear: it stays in the horizontal bar. Under the default .automatic axis behaviour, image items support both axes, while text items and custom views support only the horizontal one.

Custom views can opt in. Give the item the .verticalPreferred axis behaviour and it can move into the vertical bar, provided the view fits the bar's fixed width or has a vertically adapted layout:

            .toolbar {
    ToolbarItem {
        ZoomSlider() // your custom view, sized for the bar's fixed width
    }
    .axisBehavior(.verticalPreferred)
}
          

axisBehavior has three values, .automatic, .horizontalOnly and .verticalPreferred, and it decides which bar an item may use rather than whether it appears. Apple suggests .horizontalOnly for custom items that switch between a symbol and text. For teams porting an app that leans on title-only buttons, the fix is concrete: give every item that matters an icon.

The rest of the bar toolkit:

• Overflow order: visibilityPriority(_:) in SwiftUI and UIBarButtonItem.visibilityPriority in UIKit decide what overflows first, and items overflow from bottom to top by default. The HIG suggests setting priority on whole groups first. In SwiftUI, visibilityPriority(_:) dates from iOS 27.0 and is declared on other platforms too, so it is not new for iPhone Duo. ToolbarOverflowMenu and additionalOverflowItems put items straight into the overflow menu.

• Item order: Back or Close goes at the top, then prominent actions such as Done. Use topBarPinnedTrailing or pinnedTrailingGroup for Done-style actions, and cancellationAction or leadingItemGroups for a custom Back or Close button.

• Bar compression: when a toolbar and a tab bar compete for space, toolbarVerticalCompressionBehavior(_:) in SwiftUI and UINavigationItem.verticalBarCompressionBehavior in UIKit set which one gives way. By default the toolbar compresses first, which suits navigation-focused views; task-oriented views should keep the toolbar.

• Custom layouts: read the toolbarVerticalEdge environment value or the verticalBarEdge trait to learn which side the bar is on. Both report the preferred edge whether or not a bar is visible, and nil (or UIVerticalBarEdgeUnspecified) where the system never places a vertical bar.

• Hero images: extend them under a vertical bar with backgroundExtensionEffect() or UIBackgroundExtensionView.

• Right-to-left languages: vertical bars stay on the same physical side, because they are aligned with the hardware.

For how vertical bars interact with Split View and the Dynamic Island, see our guide to iOS 27.1 vertical bars and Split View.

iPhone Duo hinge API: onHingeChange and UIHingeInteraction

iOS 27.1 also exposes the hinge itself. In SwiftUI, onHingeChange(isEnabled:_:) calls your closure with the previous and current DeviceHingeContext. Its hinge property is an optional DeviceHinge with an angle and a status of .closed, .partiallyOpen or .fullyOpen, and a nil hinge means the device has no hinge.

            StringsView(bend: bend)
    .onHingeChange { _, newContext in
        // A nil hinge means this device has no hinge
        if let hinge = newContext.hinge, hinge.status == .partiallyOpen {
            bend = hinge.angle.degrees // drive an effect, not layout
        } else {
            bend = 0 // reset when closed, fully open or hingeless
        }
    }
          

In UIKit, create a UIHingeInteraction with an update handler and add it to a view. Each update carries a hinge of type UIHinge, which is nil when the view leaves a hierarchy that provides hinge updates. UIHinge.angle is a CGFloat in radians, and UIHinge.status adds .unknown to the three states SwiftUI reports.

Apple is clear about scope. Hinge data is observed live and suits interactions and effects, such as the guitar pitch-bend demo in the Tech Talk, but layout should come from the arrangement and reserved-region APIs. Do not rely on a particular update rate or precision, and read status when closed, partially open or fully open is all you need.

iPhone Duo camera APIs

Apple's camera guidance solves a problem no previous iPhone had. An app that captures photos or video with AVKit or AVFoundation can use the outer display's front camera, the inner display's front camera or the rear cameras, and when a person opens, closes or rotates the phone, your app may change which display it is on, so the camera you are using may point the opposite way. Apple's answer is to choose cameras by the direction they face, as its AVKit article "Choosing a camera by the direction it faces" sets out.

Existing front-camera apps keep working

On iPhone Duo, the familiar front camera is a virtual device. Discover it as before, with .builtInWideAngleCamera or .builtInUltraWideCamera at the .front position, and the system moves between the two physical front cameras for you, so an app that captures from the front camera today works unchanged. To find out which physical camera is streaming, read activePrimaryConstituent, an existing API since iOS 15:

            let discovery = AVCaptureDevice.DiscoverySession(
    deviceTypes: [.builtInWideAngleCamera, .builtInUltraWideCamera],
    mediaType: .video,
    position: .front
)
if let frontCamera = discovery.devices.first {
    // On iPhone Duo this is the virtual front camera
    let streamingCamera = frontCamera.activePrimaryConstituent
}
          

Virtual or individual front cameras

The virtual camera trades capability for convenience. It offers only what both physical cameras share.

Depth is available only when you use the individual cameras, and both front cameras have square sensors. If your app needs 4K selfies or depth, adopt the individual device types and the direction coordinator.

Which way is each camera facing?

AVCaptureDeviceDirectionCoordinator lives in AVKit, not AVFoundation. You create it with a view, a list of device types and a change handler, and it reports an AVCaptureDeviceDirectionMap of forwardFacingDeviceDescriptors and backwardFacingDeviceDescriptors relative to that view, also readable through deviceDirections. An app that shows previews on both displays creates one coordinator per view. List the rear cameras you capture from alongside the two physical front cameras, because the coordinator leaves out the virtual front camera and a rear camera can face forward. Create the coordinator on the main actor, keep a strong reference to it while its view is onscreen, and hand each descriptor to the actor that owns your capture session instead of calling AVFoundation from the change handler.

            import AVKit

let coordinator = AVCaptureDeviceDirectionCoordinator(
    view: previewView,
    deviceTypes: [.builtInOuterUltraWideCamera, .builtInInnerUltraWideCamera, .builtInDualWideCamera],
    changeHandler: { directions in
        // Relative to previewView; changes as the phone opens, closes or rotates
        updateCameraChoice(forward: directions.forwardFacingDeviceDescriptors,
                           backward: directions.backwardFacingDeviceDescriptors)
    }
)
          

Apple sums up the split neatly: on iPhone Duo, position still reports where a camera sits, and the coordinator reports which way it faces.

Mirroring

A capture connection mirrors any camera whose position is .front, whichever way it faces. On iPhone Duo, decide mirroring from the direction map instead, and set automaticallyAdjustsVideoMirroring to false before you assign isVideoMirrored, or the assignment throws an exception:

            connection.automaticallyAdjustsVideoMirroring = false // must come first
connection.isVideoMirrored = shouldMirror // decided from the direction map, not position
          

Apple's Photos & Camera Q&A on 23 September covers the two front cameras, the virtual front camera, direction changes and preview polish, so bring questions there.

Dual-display capture: CameraCaptureAccessory and UISceneAccessory

When iPhone Duo is fully open and capturing photos or video with the rear camera, it can show content on the outer display while your app runs on the inner display. Apple calls this a camera capture accessory, and its stated purpose is to "provide content to the person in front of the camera".

The system, not your app, decides when and where that content appears. It is available only when:

• the phone is open and your app is full screen on the inner display;

• your app is in the foreground;

• your app has an active camera capture session.

It goes away when capture stops, when the app leaves the foreground, or when the phone is folded closed. Apple says to treat it as an enhancement the system can withdraw at any time, so do not put anything essential there.

The APIs:

• SwiftUI: attach sceneAccessory(content:) (iOS 27.0) to a view and put a CameraCaptureAccessory (iOS 27.1 beta) inside it. Use its isEnabled initialiser to switch it on or off, and onAvailabilityChange(perform:) to react when the system makes it available or withdraws it.

• UIKit: create the accessory with UISceneAccessory.cameraCapture(sceneConfiguration:userInfo:) and pass it to registerSceneAccessory(_:) on a view controller. You get back a UISceneAccessoryRegistration with isAvailable and isEnabled, and you remove it with unregisterSceneAccessory(_:).

The simulator has no camera, so this feature has to be tested on hardware.

Multiple windows and Split View on iPhone Duo

iPhone Duo is the first iPhone to run multiple windows of one app, but only on the inner display. New windows cannot be created on the outer display, so requests for new scenes can fail there. Handle errors when you request a scene, and prefer UIWindowScene.ActivationAction, which hides itself automatically when new windows are not available.

Every app also takes part in Split View multitasking, where two apps sit side by side in a 50/50 layout on the inner display. A second layout stacks a pinned picture-in-picture video with your app, which resizes vertically around it. You cannot opt out, so test those sizes. In Split View, vertical bars can appear on the left, and safe areas and layout margins are often asymmetric on iPhone Duo.

Xcode 27.1, the iPhone Duo simulator and testing without hardware

As of 18 September 2026, Apple's iPhone Duo developer page lists the Xcode 27.1 beta as "Coming later this month", and Apple Developer News says a beta will be available later this month. The iPhone Duo simulator lives in Device Hub and requires Xcode 27.1; its control buttons open, close, rotate and fold the simulated phone.

Do not read the Xcode 27.2 beta as a shortcut. It is the newer version number, but its release notes say iPhone Duo SDK and simulator support will arrive in an upcoming Xcode 27.1, not in the 27.2 beta.

Build with Xcode 27.1 or later to use all of the screen. In earlier versions, your app does not extend under the status bar and camera; it runs in the compatibility layouts described in the SDK tiers above. Two more tooling notes:

• The app-modernisation agent skill introduced in "Modernize your UIKit app" is renamed App Resizability in Xcode 27.1, and it now supports SwiftUI and iPhone Duo.

• The simulator has no camera, so capture flows, the direction coordinator and the camera capture accessory need a real device.

Until the Xcode 27.1 beta arrives, the resize mode in Xcode 27's Device Hub and Previews, iPad and iPhone Mirroring are the closest places to exercise your resizing code. Apple says an app that already works on iPad and Mac, or resizes in iPhone Mirroring, is well on its way to supporting iPhone Duo.

What's new on iPhone Duo vs existing iPad adaptivity

Apple's overview says that if your app already works on iPad and Mac, or you have prepared it to resize in iPhone Mirroring, "you're well on your way to supporting iPhone Duo". Apple's advice for everyone else is to adopt standard layout controls and containers and to use size classes and scene geometry. Then you still handle reserved regions such as the fold and consider an arrangement view.

The size-class and orientation rows come from the "Prepare" Tech Talk, the windows and multitasking rows from the multiple-displays and design talks.

What is genuinely new is narrower than the hype: the arrangement view pair (new, though not exclusive to iPhone Duo), reserved regions with their division and occlusion kinds and active state, vertical bars with the icon rule, the hinge API, direction-aware camera handling with the virtual front camera, the camera capture accessory, and multiple windows on an iPhone. Everything else is existing adaptive-layout discipline applied to a new physical shape, which is good news for teams that already built size-class-based layouts rather than orientation-based ones.

What Apple tells you to stop doing

Apple's documentation is as useful for what it rules out as for what it adds:

• Idiom and orientation checks for layout. The overview says not to use userInterfaceIdiom or UIInterfaceOrientation for layout decisions in a UIKit app and to observe horizontalSizeClass and verticalSizeClass through automatic trait tracking instead. The "Prepare" Tech Talk repeats it: as with idiom, avoid orientation checks and use size classes.

• Hand-built bars. Do not build custom bars from raw UIToolbar, UINavigationBar or UITabBar instances. Put toolbar items on a view controller inside a navigation controller, or use the SwiftUI toolbar modifier on a navigation container, so the system can present them vertically.

• Fixed iPhone dimensions and screen sizes. Size views relative to their container, and base layout calculations on the scene's or containing view's bounds rather than the screen.

• The main screen. On a device with two displays, UIScreen.main is ambiguous. Use the environment, the trait collection or scene bounds, and if you need a screen, get it from the window scene. The Tech Talk says it will be deprecated in a future release; its documentation page already lists a deprecation at iOS 26.

• Assuming a front camera faces the user. Use the direction coordinator and decide mirroring from its map.

The thread running through all of Apple's iPhone Duo guidance is a discipline more than any single API: adapt by size and container bounds rather than orientation or device idiom, and treat the fold and the cameras as regions your layout works with from the start instead of obstacles patched around later. Teams that built that discipline for iPad are closer to done than the device's novelty suggests; teams that did not now have a well-documented reason to start.

If you are budgeting the work, our guide to iPhone Duo app support costs breaks down the engagement options.

iPhone Duo developer events: Group Labs, Q&As and workshops

Apple set up three kinds of support sessions around the launch, and the first has already taken place.

• Group Labs (taken place): two online livestreams booked through Meet with Apple, on 16 September at 8–9 p.m. PT (08:30–09:30 IST on 17 September) and 17 September at 8–9 a.m. PT (20:30–21:30 IST). Their agenda covered layouts across displays and poses, the hinge, Split View multitasking and camera experiences. Registration for both has closed.

• Q&As on the Apple Developer Forums, 23 September: registration runs through Meet with Apple, with two windows per topic.

• Workshops: hands-on sessions around the world, listed as coming later this month.

Building the app in Flutter? Our iPhone Duo Flutter guide covers what Flutter can and cannot see on the device today, and how to prepare a Flutter app for it.

How eCorpIT can help

eCorpIT is a Gurugram-based technology organisation, founded in 2021, assessed at CMMI Level 5 and MSME certified, with senior-led engineering teams working across AWS, Microsoft and Google platforms. For iPhone Duo, our iOS engineers rebuild apps against the iOS 27.1 SDK, including the UIScene move it depends on; adopt ArrangementView and reserved regions where a two-pane layout helps; audit toolbars so the actions that matter carry icons and behave in vertical bars; and rework camera flows around the direction coordinator, mirroring and the camera capture accessory. You can hire eCorpIT iOS developers for a scoped audit, or see our foldable and large-screen app development service for a full adoption project. Talk to us at /contact-us/.

Last updated: 18 September 2026.

References

1. Get Ready for iPhone Duo — Apple Developer

1. Preparing your app for iPhone Duo — Apple Developer Documentation

1. Latest News — Apple Developer

1. Designing for iPhone Duo — Apple Human Interface Guidelines

1. Design for iPhone Duo (Tech Talk) — Apple Developer

1. Prepare your app for iPhone Duo (Tech Talk) — Apple Developer

1. Raise the bar with iPhone Duo (Tech Talk) — Apple Developer

1. Strike a pose with adaptive layouts on iPhone Duo (Tech Talk) — Apple Developer

1. Leverage multiple displays and scenes on iPhone Duo (Tech Talk) — Apple Developer

1. Build a great camera experience for iPhone Duo (Tech Talk) — Apple Developer

1. Make your UIKit app more flexible (WWDC25) — Apple Developer

1. Modernize your UIKit app (WWDC26) — Apple Developer

1. Apple unveils iPhone Duo — Apple Newsroom

1. Xcode 27.2 Beta Release Notes — Apple Developer Documentation

1. onHingeChange(isEnabled:_:) — Apple Developer Documentation (SwiftUI)

1. Choosing a camera by the direction it faces — Apple Developer Documentation (AVKit)

1. Registering a camera capture accessory on iPhone Duo — Apple Developer Documentation (AVFoundation)