Camera Control: Complete Integration Guide for iOS Apps

import AVFoundation  // Main framework for camera work
import AVKit         // For AVCaptureEventInteraction
import Photos        // For saving photos to gallery

func checkCameraControlSupport() -> Bool {
    // Check iOS version
    guard #available(iOS 18.0, *) else {
        print("❌ Requires iOS 18.0 or higher")
        return false
    }
    
    // Check device support
    let session = AVCaptureSession()
    guard session.supportsControls else {
        print("❌ Device doesn't support Camera Control")
        return false
    }
    
    print("✅ Camera Control fully supported")
    return true
}

CameraControlApp/
├── CameraControlApp.xcodeproj
├── CameraControlApp/
│   ├── App/
│   │   ├── CameraControlApp.swift      // Entry point (SwiftUI)
│   │   └── AppDelegate.swift           // (optional, for UIKit)
│   ├── Camera/
│   │   ├── CameraController.swift      // Main camera logic
│   │   ├── CameraPreviewView.swift     // Preview for UIKit
│   │   └── CameraModel.swift           // ObservableObject for SwiftUI
│   ├── Views/
│   │   ├── CameraView.swift            // SwiftUI camera view
│   │   └── CameraViewController.swift  // UIKit controller
│   └── Extensions/
│       └── AVCaptureSession+Extensions.swift
├── LockScreenCameraExtension/          // Lock Screen Extension
│   ├── LockScreenCameraExtension.swift
│   └── Info.plist
└── Tests/
    └── CameraControlTests.swift

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" 
  "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
<plist version="1.0">
<dict>
    <!-- Camera usage description (required!) -->
    <key>NSCameraUsageDescription</key>
    <string>App needs camera access for photo capture</string>
    
    <!-- Photo library save description -->
    <key>NSPhotoLibraryAddUsageDescription</key>
    <string>To save photos to gallery</string>
</dict>
</plist>

import AVFoundation
import AVKit
import Photos
 
/// Main camera controller with Camera Control support
class CameraController: NSObject, ObservableObject {
    
    // MARK: - Public Properties
    
    /// Current zoom factor
    @Published var currentZoomFactor: CGFloat = 1.0
    
    /// Current exposure bias
    @Published var currentExposureBias: Float = 0.0
    
    /// Whether Camera Control overlay is active
    @Published var isCameraControlActive: Bool = false
    
    /// Last captured image (for preview)
    @Published var lastCapturedImage: UIImage?
    
    /// Camera permission status
    @Published var permissionStatus: AVAuthorizationStatus = .notDetermined
    
    // MARK: - Internal Properties
    
    /// Capture session — central AVFoundation object
    let session = AVCaptureSession()
    
    /// Queue for session configuration (never on main thread!)
    private let sessionQueue = DispatchQueue(
        label: "com.yourapp.camera.session",
        qos: .userInitiated
    )
    
    /// Photo output
    private let photoOutput = AVCapturePhotoOutput()
    
    /// Camera input
    private var deviceInput: AVCaptureDeviceInput?
    
    /// Storage for KVO observers
    private var observations: [NSKeyValueObservation] = []
    
    // MARK: - Initialization
    
    override init() {
        super.init()
        checkPermissions()
    }
    
    // MARK: - Permission Handling
    
    /// Checks and requests camera permission
    func checkPermissions() {
        switch AVCaptureDevice.authorizationStatus(for: .video) {
        case .authorized:
            permissionStatus = .authorized
            configureSession()
            
        case .notDetermined:
            sessionQueue.suspend()
            AVCaptureDevice.requestAccess(for: .video) { [weak self] granted in
                guard let self = self else { return }
                DispatchQueue.main.async {
                    self.permissionStatus = granted ? .authorized : .denied
                }
                if granted {
                    self.configureSession()
                }
                self.sessionQueue.resume()
            }
            
        case .denied, .restricted:
            permissionStatus = .denied
            print("⚠️ Camera access denied")
            
        @unknown default:
            break
        }
    }
    
    // MARK: - Session Configuration
    
    /// Configures AVCaptureSession
    private func configureSession() {
        sessionQueue.async { [weak self] in
            guard let self = self else { return }
            
            self.session.beginConfiguration()
            self.session.sessionPreset = .photo
            
            // Configure camera input
            guard self.setupCameraInput() else {
                self.session.commitConfiguration()
                return
            }
            
            // Configure photo output
            guard self.setupPhotoOutput() else {
                self.session.commitConfiguration()
                return
            }
            
            // Configure Camera Control (iOS 18+)
            if #available(iOS 18.0, *) {
                self.setupCameraControls()
            }
            
            self.session.commitConfiguration()
            self.session.startRunning()
            
            print("✅ Camera session started")
        }
    }
    
    /// Configures camera input
    private func setupCameraInput() -> Bool {
        guard let camera = AVCaptureDevice.default(
            .builtInWideAngleCamera,
            for: .video,
            position: .back
        ) else {
            print("❌ Camera unavailable")
            return false
        }
        
        do {
            let input = try AVCaptureDeviceInput(device: camera)
            
            if session.canAddInput(input) {
                session.addInput(input)
                deviceInput = input
                setupDeviceObservers(device: camera)
                return true
            } else {
                print("❌ Failed to add camera input")
                return false
            }
        } catch {
            print("❌ Error: \(error)")
            return false
        }
    }
    
    /// Configures photo output
    private func setupPhotoOutput() -> Bool {
        guard session.canAddOutput(photoOutput) else {
            print("❌ Failed to add photo output")
            return false
        }
        
        session.addOutput(photoOutput)
        photoOutput.isHighResolutionCaptureEnabled = true
        
        if let connection = photoOutput.connection(with: .video),
           connection.isVideoStabilizationSupported {
            connection.preferredVideoStabilizationMode = .auto
        }
        
        return true
    }
    
    /// Sets up device change observers
    private func setupDeviceObservers(device: AVCaptureDevice) {
        // Observe zoom changes
        let zoomObserver = device.observe(
            \.videoZoomFactor,
            options: [.new]
        ) { [weak self] device, change in
            guard let newValue = change.newValue else { return }
            DispatchQueue.main.async {
                self?.currentZoomFactor = newValue
            }
        }
        observations.append(zoomObserver)
        
        // Observe exposure changes
        let exposureObserver = device.observe(
            \.exposureTargetBias,
            options: [.new]
        ) { [weak self] device, change in
            guard let newValue = change.newValue else { return }
            DispatchQueue.main.async {
                self?.currentExposureBias = newValue
            }
        }
        observations.append(exposureObserver)
    }
    
    // MARK: - Photo Capture
    
    /// Captures a photo
    func capturePhoto() {
        guard let connection = photoOutput.connection(with: .video),
              connection.isEnabled else {
            print("❌ Camera connection inactive")
            return
        }
        
        let settings = AVCapturePhotoSettings()
        settings.flashMode = .auto
        settings.isHighResolutionPhotoEnabled = true
        
        photoOutput.capturePhoto(with: settings, delegate: self)
        print("📸 Photo capture started")
    }
    
    // MARK: - Controls
    
    /// Sets zoom programmatically
    func setZoom(_ factor: CGFloat) {
        guard let device = deviceInput?.device else { return }
        
        let clampedFactor = min(
            max(factor, device.minAvailableVideoZoomFactor),
            device.maxAvailableVideoZoomFactor
        )
        
        sessionQueue.async {
            do {
                try device.lockForConfiguration()
                device.videoZoomFactor = clampedFactor
                device.unlockForConfiguration()
            } catch {
                print("❌ Zoom error: \(error)")
            }
        }
    }
    
    /// Sets exposure bias programmatically
    func setExposureBias(_ bias: Float) {
        guard let device = deviceInput?.device else { return }
        
        let clampedBias = min(
            max(bias, device.minExposureTargetBias),
            device.maxExposureTargetBias
        )
        
        sessionQueue.async {
            do {
                try device.lockForConfiguration()
                device.setExposureTargetBias(clampedBias) { _ in }
                device.unlockForConfiguration()
            } catch {
                print("❌ Exposure error: \(error)")
            }
        }
    }
    
    // MARK: - Lifecycle
    
    func startSession() {
        sessionQueue.async { [weak self] in
            guard let self = self, !self.session.isRunning else { return }
            self.session.startRunning()
        }
    }
    
    func stopSession() {
        sessionQueue.async { [weak self] in
            guard let self = self, self.session.isRunning else { return }
            self.session.stopRunning()
        }
    }
    
    deinit {
        observations.removeAll()
        stopSession()
    }
}

// MARK: - Camera Control Setup (iOS 18+)
 
@available(iOS 18.0, *)
extension CameraController: AVCaptureSessionControlsDelegate {
    
    /// Configures Camera Control
    func setupCameraControls() {
        // Check support
        guard session.supportsControls else {
            print("⚠️ Camera Control not supported")
            return
        }
        
        guard let device = deviceInput?.device else {
            print("❌ Camera device not found")
            return
        }
        
        // Remove existing controls
        for control in session.controls {
            session.removeControl(control)
        }
        
        var controls: [AVCaptureControl] = []
        
        // 1. System zoom slider
        let zoomSlider = AVCaptureSystemZoomSlider(
            device: device
        ) { [weak self] zoomFactor in
            DispatchQueue.main.async {
                self?.currentZoomFactor = zoomFactor
            }
            print("🔍 Zoom: \(zoomFactor)x")
        }
        controls.append(zoomSlider)
        
        // 2. System exposure slider
        let exposureSlider = AVCaptureSystemExposureBiasSlider(
            device: device
        ) { [weak self] bias in
            DispatchQueue.main.async {
                self?.currentExposureBias = bias
            }
            print("☀️ Exposure: \(bias)")
        }
        controls.append(exposureSlider)
        
        // Add controls to session
        for control in controls {
            if session.canAddControl(control) {
                session.addControl(control)
                print("✅ Added: \(type(of: control))")
            }
        }
        
        // Set delegate
        session.setControlsDelegate(self, queue: sessionQueue)
        
        print("✅ Camera Control configured")
    }
    
    // MARK: - AVCaptureSessionControlsDelegate
    
    func sessionControlsDidBecomeActive(_ session: AVCaptureSession) {
        DispatchQueue.main.async { [weak self] in
            self?.isCameraControlActive = true
            print("🎮 Camera Control activated")
        }
    }
    
    func sessionControlsDidBecomeInactive(_ session: AVCaptureSession) {
        DispatchQueue.main.async { [weak self] in
            self?.isCameraControlActive = false
            print("🎮 Camera Control deactivated")
        }
    }
    
    func sessionControlsWillEnterFullscreenAppearance(
        _ session: AVCaptureSession
    ) {
        print("📺 Entering fullscreen mode")
        // Hide custom UI elements
    }
    
    func sessionControlsWillExitFullscreenAppearance(
        _ session: AVCaptureSession
    ) {
        print("📺 Exiting fullscreen mode")
        // Show UI elements back
    }
}

// MARK: - AVCapturePhotoCaptureDelegate
 
extension CameraController: AVCapturePhotoCaptureDelegate {
    
    func photoOutput(
        _ output: AVCapturePhotoOutput,
        didFinishProcessingPhoto photo: AVCapturePhoto,
        error: Error?
    ) {
        if let error = error {
            print("❌ Error: \(error.localizedDescription)")
            return
        }
        
        guard let imageData = photo.fileDataRepresentation(),
              let image = UIImage(data: imageData) else {
            print("❌ Failed to get image")
            return
        }
        
        DispatchQueue.main.async { [weak self] in
            self?.lastCapturedImage = image
        }
        
        saveToPhotoLibrary(imageData: imageData)
        print("✅ Photo captured")
    }
    
    private func saveToPhotoLibrary(imageData: Data) {
        PHPhotoLibrary.requestAuthorization(for: .addOnly) { status in
            guard status == .authorized else {
                print("⚠️ No permission to save")
                return
            }
            
            PHPhotoLibrary.shared().performChanges {
                let request = PHAssetCreationRequest.forAsset()
                request.addResource(with: .photo, data: imageData, options: nil)
            } completionHandler: { success, error in
                if success {
                    print("✅ Saved to gallery")
                } else if let error = error {
                    print("❌ Error: \(error.localizedDescription)")
                }
            }
        }
    }
}

// MARK: - Capture Event Handling
 
extension CameraController {
    
    /// Creates AVCaptureEventInteraction
    @available(iOS 17.2, *)
    func createCaptureEventInteraction(
        for view: UIView
    ) -> AVCaptureEventInteraction {
        let interaction = AVCaptureEventInteraction(
            primary: { [weak self] event in
                self?.handleCaptureEvent(event, isPrimary: true)
            },
            secondary: { [weak self] event in
                self?.handleCaptureEvent(event, isPrimary: false)
            }
        )
        
        interaction.isEnabled = true
        view.addInteraction(interaction)
        
        print("✅ AVCaptureEventInteraction configured")
        return interaction
    }
    
    private func handleCaptureEvent(
        _ event: AVCaptureEvent,
        isPrimary: Bool
    ) {
        let type = isPrimary ? "Primary" : "Secondary"
        
        switch event.phase {
        case .began:
            print("🔵 \(type): began")
            
        case .ended:
            print("🟢 \(type): ended — capturing!")
            capturePhoto()
            
        case .cancelled:
            print("🔴 \(type): cancelled")
            
        @unknown default:
            break
        }
    }
}

import UIKit
import AVFoundation
 
/// UIView for displaying camera preview
class CameraPreviewView: UIView {
    
    override class var layerClass: AnyClass {
        return AVCaptureVideoPreviewLayer.self
    }
    
    var videoPreviewLayer: AVCaptureVideoPreviewLayer {
        return layer as! AVCaptureVideoPreviewLayer
    }
    
    override init(frame: CGRect) {
        super.init(frame: frame)
        setupPreviewLayer()
    }
    
    required init?(coder: NSCoder) {
        super.init(coder: coder)
        setupPreviewLayer()
    }
    
    private func setupPreviewLayer() {
        videoPreviewLayer.videoGravity = .resizeAspectFill
        backgroundColor = .black
    }
    
    func setSession(_ session: AVCaptureSession) {
        videoPreviewLayer.session = session
    }
}

import SwiftUI
import AVFoundation
 
struct CameraPreviewRepresentable: UIViewRepresentable {
    let session: AVCaptureSession
    let onViewCreated: ((UIView) -> Void)?
    
    init(
        session: AVCaptureSession,
        onViewCreated: ((UIView) -> Void)? = nil
    ) {
        self.session = session
        self.onViewCreated = onViewCreated
    }
    
    func makeUIView(context: Context) -> CameraPreviewView {
        let view = CameraPreviewView()
        view.setSession(session)
        onViewCreated?(view)
        return view
    }
    
    func updateUIView(_ uiView: CameraPreviewView, context: Context) {}
}

import SwiftUI
import AVKit
 
struct CameraView: View {
    @StateObject private var cameraController = CameraController()
    @State private var captureInteraction: AVCaptureEventInteraction?
    
    var body: some View {
        GeometryReader { geometry in
            ZStack {
                // Camera preview
                CameraPreviewRepresentable(
                    session: cameraController.session,
                    onViewCreated: { view in
                        setupCaptureInteraction(on: view)
                    }
                )
                .ignoresSafeArea()
                
                // Control overlay
                VStack {
                    topInfoBar
                    Spacer()
                    bottomControlsBar
                }
                .padding()
            }
        }
        .onAppear { cameraController.startSession() }
        .onDisappear { cameraController.stopSession() }
    }
    
    // MARK: - UI Components
    
    private var topInfoBar: some View {
        HStack {
            // Zoom indicator
            Label(
                String(format: "%.1fx", cameraController.currentZoomFactor),
                systemImage: "magnifyingglass"
            )
            .font(.caption)
            .padding(8)
            .background(.ultraThinMaterial)
            .clipShape(Capsule())
            
            Spacer()
            
            // Exposure indicator
            Label(
                String(format: "%+.1f", cameraController.currentExposureBias),
                systemImage: "sun.max"
            )
            .font(.caption)
            .padding(8)
            .background(.ultraThinMaterial)
            .clipShape(Capsule())
            
            Spacer()
            
            // Camera Control indicator
            if cameraController.isCameraControlActive {
                Label("Active", systemImage: "button.horizontal.top.press")
                    .font(.caption)
                    .padding(8)
                    .background(Color.blue.opacity(0.8))
                    .foregroundColor(.white)
                    .clipShape(Capsule())
            }
        }
    }
    
    private var bottomControlsBar: some View {
        HStack(spacing: 50) {
            // Last photo preview
            if let lastImage = cameraController.lastCapturedImage {
                Image(uiImage: lastImage)
                    .resizable()
                    .aspectRatio(contentMode: .fill)
                    .frame(width: 60, height: 60)
                    .clipShape(RoundedRectangle(cornerRadius: 10))
            } else {
                RoundedRectangle(cornerRadius: 10)
                    .fill(Color.gray.opacity(0.3))
                    .frame(width: 60, height: 60)
            }
            
            // Capture button
            Button(action: { cameraController.capturePhoto() }) {
                Circle()
                    .strokeBorder(.white, lineWidth: 4)
                    .frame(width: 80, height: 80)
                    .overlay(
                        Circle()
                            .fill(.white)
                            .padding(8)
                    )
            }
            
            // Placeholder
            Color.clear.frame(width: 60, height: 60)
        }
        .padding(.bottom, 30)
    }
    
    private func setupCaptureInteraction(on view: UIView) {
        if #available(iOS 17.2, *) {
            captureInteraction = cameraController
                .createCaptureEventInteraction(for: view)
        }
    }
}

import LockedCameraCapture
import AVFoundation
import Photos
import UIKit
 
@main
class LockScreenCameraExtension: NSObject, LockedCameraCaptureExtension {
    
    private var captureSession: LockedCameraCaptureSession?
    private var photoOutput: LockedCameraCapturePhotoOutput?
    
    func beginCapture(
        with device: LockedCameraCaptureDevice,
        completion: @escaping (Error?) -> Void
    ) {
        print("📷 Lock Screen Camera: starting capture")
        
        captureSession = LockedCameraCaptureSession()
        photoOutput = LockedCameraCapturePhotoOutput()
        
        guard let session = captureSession,
              let output = photoOutput else {
            completion(LockScreenCameraError.initializationFailed)
            return
        }
        
        do {
            try session.addInput(device)
            try session.addOutput(output)
            session.startRunning()
            
            print("✅ Lock Screen Camera: session started")
            completion(nil)
        } catch {
            print("❌ Lock Screen Camera: \(error)")
            completion(error)
        }
    }
    
    func endCapture(completion: @escaping (Error?) -> Void) {
        print("📷 Lock Screen Camera: ending")
        
        captureSession?.stopRunning()
        captureSession = nil
        photoOutput = nil
        
        completion(nil)
    }
    
    func captureOutput(
        _ output: LockedCameraCaptureOutput,
        didOutput sampleBuffer: CMSampleBuffer,
        from connection: LockedCameraCaptureConnection
    ) {
        guard let imageBuffer = CMSampleBufferGetImageBuffer(sampleBuffer) else {
            return
        }
        
        let ciImage = CIImage(cvImageBuffer: imageBuffer)
        let context = CIContext()
        
        guard let cgImage = context.createCGImage(
            ciImage,
            from: ciImage.extent
        ) else {
            return
        }
        
        let uiImage = UIImage(cgImage: cgImage)
        
        guard let jpegData = uiImage.jpegData(compressionQuality: 0.9) else {
            return
        }
        
        saveToPhotoLibrary(imageData: jpegData)
    }
    
    private func saveToPhotoLibrary(imageData: Data) {
        PHPhotoLibrary.shared().performChanges {
            let request = PHAssetCreationRequest.forAsset()
            request.addResource(with: .photo, data: imageData, options: nil)
        } completionHandler: { success, error in
            if success {
                print("✅ Lock Screen: photo saved")
            }
        }
    }
}
 
enum LockScreenCameraError: Error {
    case initializationFailed
}

struct CameraControlDiagnostics {
    
    static func runDiagnostics() -> [String: Any] {
        var report: [String: Any] = [:]
        
        report["Device"] = UIDevice.current.model
        report["iOS Version"] = UIDevice.current.systemVersion
        
        if #available(iOS 18.0, *) {
            report["iOS 18+"] = true
            
            let session = AVCaptureSession()
            report["supportsControls"] = session.supportsControls
            
            if session.supportsControls {
                report["Status"] = "✅ Full support"
            } else {
                report["Status"] = "⚠️ Device not supported"
            }
        } else {
            report["iOS 18+"] = false
            report["Status"] = "❌ Requires iOS 18+"
        }
        
        let authStatus = AVCaptureDevice.authorizationStatus(for: .video)
        switch authStatus {
        case .authorized:
            report["Permission"] = "✅ Authorized"
        case .denied:
            report["Permission"] = "❌ Denied"
        case .restricted:
            report["Permission"] = "⚠️ Restricted"
        case .notDetermined:
            report["Permission"] = "⏳ Not determined"
        @unknown default:
            report["Permission"] = "❓ Unknown"
        }
        
        return report
    }
    
    static func printDiagnostics() {
        let report = runDiagnostics()
        
        print("\n" + String(repeating: "=", count: 50))
        print("📊 CAMERA CONTROL DIAGNOSTICS")
        print(String(repeating: "=", count: 50))
        
        for (key, value) in report.sorted(by: { $0.key < $1.key }) {
            print("  \(key): \(value)")
        }
        
        print(String(repeating: "=", count: 50) + "\n")
    }
}

// ✅ Correct
let zoomSlider = AVCaptureSystemZoomSlider(device: device) { [weak self] factor in
    DispatchQueue.main.async {
        self?.currentZoomFactor = factor
    }
}

if #available(iOS 18.0, *), session.supportsControls {
    setupCameraControls()
} else {
    showTraditionalControls()
}

func sessionControlsDidBecomeActive(_ session: AVCaptureSession) {
    DispatchQueue.main.async {
        self.zoomSlider.isHidden = true
    }
}

sessionQueue.async {
    self.session.beginConfiguration()
    // ... configuration ...
    self.session.commitConfiguration()
}