Camera Control: Guía completa de integración para apps iOS

import AVFoundation  // Framework principal para trabajo con cámara
import AVKit         // Para AVCaptureEventInteraction
import Photos        // Para guardar fotos en la galería

func checkCameraControlSupport() -> Bool {
    // Verificar versión de iOS
    guard #available(iOS 18.0, *) else {
        print("❌ Requiere iOS 18.0 o superior")
        return false
    }
    
    // Verificar soporte del dispositivo
    let session = AVCaptureSession()
    guard session.supportsControls else {
        print("❌ El dispositivo no soporta Camera Control")
        return false
    }
    
    print("✅ Camera Control completamente soportado")
    return true
}

CameraControlApp/
├── CameraControlApp.xcodeproj
├── CameraControlApp/
│   ├── App/
│   │   ├── CameraControlApp.swift      // Punto de entrada (SwiftUI)
│   │   └── AppDelegate.swift           // (opcional, para UIKit)
│   ├── Camera/
│   │   ├── CameraController.swift      // Lógica principal de cámara
│   │   ├── CameraPreviewView.swift     // Preview para UIKit
│   │   └── CameraModel.swift           // ObservableObject para SwiftUI
│   ├── Views/
│   │   ├── CameraView.swift            // Vista de cámara SwiftUI
│   │   └── CameraViewController.swift  // Controlador UIKit
│   └── Extensions/
│       └── AVCaptureSession+Extensions.swift
├── LockScreenCameraExtension/          // Extensión Lock Screen
│   ├── LockScreenCameraExtension.swift
│   └── Info.plist
└── Tests/
    └── CameraControlTests.swift

import AVFoundation
import AVKit
import Photos
 
/// Controlador principal de cámara con soporte Camera Control
class CameraController: NSObject, ObservableObject {
    
    // MARK: - Propiedades públicas
    
    /// Factor de zoom actual
    @Published var currentZoomFactor: CGFloat = 1.0
    
    /// Compensación de exposición actual
    @Published var currentExposureBias: Float = 0.0
    
    /// Si el overlay de Camera Control está activo
    @Published var isCameraControlActive: Bool = false
    
    /// Última imagen capturada (para preview)
    @Published var lastCapturedImage: UIImage?
    
    /// Estado de permiso de cámara
    @Published var permissionStatus: AVAuthorizationStatus = .notDetermined
    
    // MARK: - Propiedades internas
    
    /// Sesión de captura — objeto central de AVFoundation
    let session = AVCaptureSession()
    
    /// Cola para configuración de sesión (¡nunca en main thread!)
    private let sessionQueue = DispatchQueue(
        label: "com.yourapp.camera.session",
        qos: .userInitiated
    )
    
    /// Salida de foto
    private let photoOutput = AVCapturePhotoOutput()
    
    /// Entrada de cámara
    private var deviceInput: AVCaptureDeviceInput?
    
    /// Almacenamiento para observadores KVO
    private var observations: [NSKeyValueObservation] = []
    
    // MARK: - Inicialización
    
    override init() {
        super.init()
        checkPermissions()
    }
    
    // MARK: - Manejo de permisos
    
    /// Verifica y solicita permiso de cámara
    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("⚠️ Acceso a cámara denegado")
            
        @unknown default:
            break
        }
    }
    
    // MARK: - Configuración de sesión
    
    /// Configura AVCaptureSession
    private func configureSession() {
        sessionQueue.async { [weak self] in
            guard let self = self else { return }
            
            self.session.beginConfiguration()
            self.session.sessionPreset = .photo
            
            // Configurar entrada de cámara
            guard self.setupCameraInput() else {
                self.session.commitConfiguration()
                return
            }
            
            // Configurar salida de foto
            guard self.setupPhotoOutput() else {
                self.session.commitConfiguration()
                return
            }
            
            // Configurar Camera Control (iOS 18+)
            if #available(iOS 18.0, *) {
                self.setupCameraControls()
            }
            
            self.session.commitConfiguration()
            self.session.startRunning()
            
            print("✅ Sesión de cámara iniciada")
        }
    }
    
    /// Configura entrada de cámara
    private func setupCameraInput() -> Bool {
        guard let camera = AVCaptureDevice.default(
            .builtInWideAngleCamera,
            for: .video,
            position: .back
        ) else {
            print("❌ Cámara no disponible")
            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("❌ No se pudo agregar entrada de cámara")
                return false
            }
        } catch {
            print("❌ Error: \(error)")
            return false
        }
    }
    
    /// Configura salida de foto
    private func setupPhotoOutput() -> Bool {
        guard session.canAddOutput(photoOutput) else {
            print("❌ No se pudo agregar salida de foto")
            return false
        }
        
        session.addOutput(photoOutput)
        photoOutput.isHighResolutionCaptureEnabled = true
        
        if let connection = photoOutput.connection(with: .video),
           connection.isVideoStabilizationSupported {
            connection.preferredVideoStabilizationMode = .auto
        }
        
        return true
    }
    
    /// Configura observadores de cambios del dispositivo
    private func setupDeviceObservers(device: AVCaptureDevice) {
        // Observar cambios de zoom
        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)
        
        // Observar cambios de exposición
        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: - Captura de foto
    
    /// Captura una foto
    func capturePhoto() {
        guard let connection = photoOutput.connection(with: .video),
              connection.isEnabled else {
            print("❌ Conexión de cámara inactiva")
            return
        }
        
        let settings = AVCapturePhotoSettings()
        settings.flashMode = .auto
        settings.isHighResolutionPhotoEnabled = true
        
        photoOutput.capturePhoto(with: settings, delegate: self)
        print("📸 Captura de foto iniciada")
    }
    
    // MARK: - Controles
    
    /// Establece zoom programáticamente
    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("❌ Error de zoom: \(error)")
            }
        }
    }
    
    // MARK: - Ciclo de vida
    
    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: - Configuración Camera Control (iOS 18+)
 
@available(iOS 18.0, *)
extension CameraController: AVCaptureSessionControlsDelegate {
    
    /// Configura Camera Control
    func setupCameraControls() {
        // Verificar soporte
        guard session.supportsControls else {
            print("⚠️ Camera Control no soportado")
            return
        }
        
        guard let device = deviceInput?.device else {
            print("❌ Dispositivo de cámara no encontrado")
            return
        }
        
        // Eliminar controles existentes
        for control in session.controls {
            session.removeControl(control)
        }
        
        var controls: [AVCaptureControl] = []
        
        // 1. Slider de zoom del sistema
        let zoomSlider = AVCaptureSystemZoomSlider(
            device: device
        ) { [weak self] zoomFactor in
            DispatchQueue.main.async {
                self?.currentZoomFactor = zoomFactor
            }
            print("🔍 Zoom: \(zoomFactor)x")
        }
        controls.append(zoomSlider)
        
        // 2. Slider de exposición del sistema
        let exposureSlider = AVCaptureSystemExposureBiasSlider(
            device: device
        ) { [weak self] bias in
            DispatchQueue.main.async {
                self?.currentExposureBias = bias
            }
            print("☀️ Exposición: \(bias)")
        }
        controls.append(exposureSlider)
        
        // Agregar controles a la sesión
        for control in controls {
            if session.canAddControl(control) {
                session.addControl(control)
                print("✅ Agregado: \(type(of: control))")
            }
        }
        
        // Establecer delegado
        session.setControlsDelegate(self, queue: sessionQueue)
        
        print("✅ Camera Control configurado")
    }
    
    // MARK: - AVCaptureSessionControlsDelegate
    
    func sessionControlsDidBecomeActive(_ session: AVCaptureSession) {
        DispatchQueue.main.async { [weak self] in
            self?.isCameraControlActive = true
            print("🎮 Camera Control activado")
        }
    }
    
    func sessionControlsDidBecomeInactive(_ session: AVCaptureSession) {
        DispatchQueue.main.async { [weak self] in
            self?.isCameraControlActive = false
            print("🎮 Camera Control desactivado")
        }
    }
}

// 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("❌ No se pudo obtener la imagen")
            return
        }
        
        DispatchQueue.main.async { [weak self] in
            self?.lastCapturedImage = image
        }
        
        saveToPhotoLibrary(imageData: imageData)
        print("✅ Foto capturada")
    }
    
    private func saveToPhotoLibrary(imageData: Data) {
        PHPhotoLibrary.requestAuthorization(for: .addOnly) { status in
            guard status == .authorized else {
                print("⚠️ Sin permiso para guardar")
                return
            }
            
            PHPhotoLibrary.shared().performChanges {
                let request = PHAssetCreationRequest.forAsset()
                request.addResource(with: .photo, data: imageData, options: nil)
            } completionHandler: { success, error in
                if success {
                    print("✅ Guardado en galería")
                }
            }
        }
    }
}

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: iniciando captura")
        
        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: sesión iniciada")
            completion(nil)
        } catch {
            print("❌ Lock Screen Camera: \(error)")
            completion(error)
        }
    }
    
    func endCapture(completion: @escaping (Error?) -> Void) {
        captureSession?.stopRunning()
        captureSession = nil
        photoOutput = nil
        completion(nil)
    }
}
 
enum LockScreenCameraError: Error {
    case initializationFailed
}

// ✅ Correcto
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
    }
}