Center Stage Front Camera APIs

import AVFoundation
import SwiftUI

@MainActor
final class CenterStageCameraModel: NSObject, ObservableObject {
    let session = AVCaptureSession()
    private var device: AVCaptureDevice?
    private var smartFramingObservation: NSKeyValueObservation?

    func configure() {
        session.beginConfiguration()
        defer { session.commitConfiguration() }

        // Find the Center Stage front camera (square ultra-wide sensor)
        let discovery = AVCaptureDevice.DiscoverySession(
            deviceTypes: [.builtInUltraWideCamera],
            mediaType: .video,
            position: .front
        )
        guard let cam = discovery.devices.first else { return }
        self.device = cam

        guard let input = try? AVCaptureDeviceInput(device: cam) else { return }
        if session.canAddInput(input) { session.addInput(input) }

        let photoOutput = AVCapturePhotoOutput()
        if session.canAddOutput(photoOutput) { session.addOutput(photoOutput) }

        // Find a format supporting dynamic aspect ratio (4032 photo format)
        let targetRatios: [AVCaptureDevice.DynamicAspectRatio] = [.ratio4x3, .ratio3x4]
        guard let bestFormat = cam.formats.first(where: { format in
            let supported = format.supportedDynamicAspectRatios
            return targetRatios.allSatisfy { supported.contains($0) }
        }) else { return }

        try? cam.lockForConfiguration()
        cam.activeFormat = bestFormat
        // Start in 4x3 landscape orientation
        cam.dynamicAspectRatio = .ratio4x3

        // Enable the smart framing monitor for auto zoom + rotate
        let monitor = cam.smartFramingMonitor
        monitor.enabledFramings = monitor.supportedFramings
        cam.unlockForConfiguration()

        // Observe framing recommendations and apply them
        smartFramingObservation = monitor.observe(
            \.recommendedFraming,
            options: [.new]
        ) { [weak self] mon, _ in
            guard let recommendation = mon.recommendedFraming else { return }
            Task { @MainActor in
                self?.applyRecommendation(recommendation)
            }
        }

        monitor.startMonitoring()
    }

    private func applyRecommendation(
        _ framing: AVCaptureSmartFramingMonitor.Framing
    ) {
        guard let cam = device else { return }
        try? cam.lockForConfiguration()
        // Apply aspect ratio first, then zoom for smooth transition
        cam.dynamicAspectRatio = framing.aspectRatio
        cam.videoZoomFactor = framing.zoomFactor
        cam.unlockForConfiguration()
    }

    func tapToRotate() {
        guard let cam = device else { return }
        try? cam.lockForConfiguration()
        // Toggle between landscape and portrait
        cam.dynamicAspectRatio = (cam.dynamicAspectRatio == .ratio4x3) ? .ratio3x4 : .ratio4x3
        cam.unlockForConfiguration()
    }
}

struct CenterStageCameraView: View {
    @StateObject private var model = CenterStageCameraModel()

    var body: some View {
        ZStack(alignment: .bottom) {
            CameraPreview(session: model.session)
                .ignoresSafeArea()
            Button("Tap to Rotate") {
                model.tapToRotate()
            }
            .buttonStyle(.borderedProminent)
            .padding()
        }
        .task { model.configure() }
    }
}

struct CameraPreview: UIViewRepresentable {
    let session: AVCaptureSession
    func makeUIView(context: Context) -> UIView {
        let view = UIView()
        let layer = AVCaptureVideoPreviewLayer(session: session)
        layer.videoGravity = .resizeAspectFill
        layer.frame = UIScreen.main.bounds
        view.layer.addSublayer(layer)
        Task.detached { self.session.startRunning() }
        return view
    }
    func updateUIView(_ uiView: UIView, context: Context) {}
}