Camera Control: Полное руководство по интеграции в iOS-приложения

import AVFoundation  // Основной фреймворк для работы с камерой
import AVKit         // Для AVCaptureEventInteraction
import Photos        // Для сохранения фото в галерею

func checkCameraControlSupport() -> Bool {
    // Проверка версии iOS
    guard #available(iOS 18.0, *) else {
        print("❌ Требуется iOS 18.0 или выше")
        return false
    }
    
    // Проверка поддержки устройством
    let session = AVCaptureSession()
    guard session.supportsControls else {
        print("❌ Устройство не поддерживает Camera Control")
        return false
    }
    
    print("✅ Camera Control полностью поддерживается")
    return true
}

CameraControlApp/
├── CameraControlApp.xcodeproj
├── CameraControlApp/
│   ├── App/
│   │   ├── CameraControlApp.swift      // Точка входа (SwiftUI)
│   │   └── AppDelegate.swift           // (опционально, для UIKit)
│   ├── Camera/
│   │   ├── CameraController.swift      // Основная логика камеры
│   │   ├── CameraPreviewView.swift     // Preview для UIKit
│   │   └── CameraModel.swift           // ObservableObject для SwiftUI
│   ├── Views/
│   │   ├── CameraView.swift            // SwiftUI view камеры
│   │   └── CameraViewController.swift  // UIKit controller
│   └── Extensions/
│       └── AVCaptureSession+Extensions.swift
├── LockScreenCameraExtension/          // Extension для Lock Screen
│   ├── 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>
    <!-- Описание использования камеры (обязательно!) -->
    <key>NSCameraUsageDescription</key>
    <string>Приложению нужен доступ к камере для съёмки</string>
    
    <!-- Описание для сохранения в галерею -->
    <key>NSPhotoLibraryAddUsageDescription</key>
    <string>Для сохранения снимков в галерею</string>
</dict>
</plist>

import AVFoundation
import AVKit
import Photos
 
/// Основной контроллер камеры с поддержкой Camera Control
class CameraController: NSObject, ObservableObject {
    
    // MARK: - Публичные свойства
    
    /// Текущий коэффициент зума
    @Published var currentZoomFactor: CGFloat = 1.0
    
    /// Текущая компенсация экспозиции
    @Published var currentExposureBias: Float = 0.0
    
    /// Активен ли оверлей Camera Control
    @Published var isCameraControlActive: Bool = false
    
    /// Последний захваченный снимок (для превью)
    @Published var lastCapturedImage: UIImage?
    
    /// Статус разрешения камеры
    @Published var permissionStatus: AVAuthorizationStatus = .notDetermined
    
    // MARK: - Внутренние свойства
    
    /// Сессия захвата — центральный объект AVFoundation
    let session = AVCaptureSession()
    
    /// Очередь для конфигурации сессии (никогда не на main thread!)
    private let sessionQueue = DispatchQueue(
        label: "com.yourapp.camera.session",
        qos: .userInitiated
    )
    
    /// Выход для фото
    private let photoOutput = AVCapturePhotoOutput()
    
    /// Вход от камеры
    private var deviceInput: AVCaptureDeviceInput?
    
    /// Хранилище для наблюдателей KVO
    private var observations: [NSKeyValueObservation] = []
    
    // MARK: - Инициализация
    
    override init() {
        super.init()
        checkPermissions()
    }
    
    // MARK: - Обработка разрешений
    
    /// Проверяет и запрашивает разрешение на использование камеры
    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("⚠️ Доступ к камере запрещён")
            
        @unknown default:
            break
        }
    }
    
    // MARK: - Конфигурация сессии
    
    /// Конфигурирует AVCaptureSession
    private func configureSession() {
        sessionQueue.async { [weak self] in
            guard let self = self else { return }
            
            self.session.beginConfiguration()
            self.session.sessionPreset = .photo
            
            // Настраиваем вход от камеры
            guard self.setupCameraInput() else {
                self.session.commitConfiguration()
                return
            }
            
            // Настраиваем выход для фото
            guard self.setupPhotoOutput() else {
                self.session.commitConfiguration()
                return
            }
            
            // Настраиваем Camera Control (iOS 18+)
            if #available(iOS 18.0, *) {
                self.setupCameraControls()
            }
            
            self.session.commitConfiguration()
            self.session.startRunning()
            
            print("✅ Сессия камеры запущена")
        }
    }
    
    /// Настраивает вход от камеры
    private func setupCameraInput() -> Bool {
        guard let camera = AVCaptureDevice.default(
            .builtInWideAngleCamera,
            for: .video,
            position: .back
        ) else {
            print("❌ Камера недоступна")
            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("❌ Не удалось добавить вход камеры")
                return false
            }
        } catch {
            print("❌ Ошибка: \(error)")
            return false
        }
    }
    
    /// Настраивает выход для фото
    private func setupPhotoOutput() -> Bool {
        guard session.canAddOutput(photoOutput) else {
            print("❌ Не удалось добавить выход для фото")
            return false
        }
        
        session.addOutput(photoOutput)
        photoOutput.isHighResolutionCaptureEnabled = true
        
        if let connection = photoOutput.connection(with: .video),
           connection.isVideoStabilizationSupported {
            connection.preferredVideoStabilizationMode = .auto
        }
        
        return true
    }
    
    /// Настраивает наблюдателей за изменениями устройства
    private func setupDeviceObservers(device: AVCaptureDevice) {
        // Наблюдаем за изменением зума
        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)
        
        // Наблюдаем за изменением экспозиции
        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: - Захват фото
    
    /// Делает снимок
    func capturePhoto() {
        guard let connection = photoOutput.connection(with: .video),
              connection.isEnabled else {
            print("❌ Соединение с камерой неактивно")
            return
        }
        
        let settings = AVCapturePhotoSettings()
        settings.flashMode = .auto
        settings.isHighResolutionPhotoEnabled = true
        
        photoOutput.capturePhoto(with: settings, delegate: self)
        print("📸 Начат захват фото")
    }
    
    // MARK: - Управление
    
    /// Устанавливает зум программно
    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)")
            }
        }
    }
    
    /// Устанавливает экспозицию программно
    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("❌ Ошибка экспозиции: \(error)")
            }
        }
    }
    
    // MARK: - Жизненный цикл
    
    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 {
    
    /// Настраивает Camera Control
    func setupCameraControls() {
        // Проверяем поддержку
        guard session.supportsControls else {
            print("⚠️ Camera Control не поддерживается")
            return
        }
        
        guard let device = deviceInput?.device else {
            print("❌ Устройство камеры не найдено")
            return
        }
        
        // Удаляем существующие контролы
        for control in session.controls {
            session.removeControl(control)
        }
        
        var controls: [AVCaptureControl] = []
        
        // 1. Системный слайдер зума
        let zoomSlider = AVCaptureSystemZoomSlider(
            device: device
        ) { [weak self] zoomFactor in
            DispatchQueue.main.async {
                self?.currentZoomFactor = zoomFactor
            }
            print("🔍 Зум: \(zoomFactor)x")
        }
        controls.append(zoomSlider)
        
        // 2. Системный слайдер экспозиции
        let exposureSlider = AVCaptureSystemExposureBiasSlider(
            device: device
        ) { [weak self] bias in
            DispatchQueue.main.async {
                self?.currentExposureBias = bias
            }
            print("☀️ Экспозиция: \(bias)")
        }
        controls.append(exposureSlider)
        
        // Добавляем контролы в сессию
        for control in controls {
            if session.canAddControl(control) {
                session.addControl(control)
                print("✅ Добавлен: \(type(of: control))")
            }
        }
        
        // Устанавливаем делегат
        session.setControlsDelegate(self, queue: sessionQueue)
        
        print("✅ Camera Control настроен")
    }
    
    // MARK: - AVCaptureSessionControlsDelegate
    
    func sessionControlsDidBecomeActive(_ session: AVCaptureSession) {
        DispatchQueue.main.async { [weak self] in
            self?.isCameraControlActive = true
            print("🎮 Camera Control активирован")
        }
    }
    
    func sessionControlsDidBecomeInactive(_ session: AVCaptureSession) {
        DispatchQueue.main.async { [weak self] in
            self?.isCameraControlActive = false
            print("🎮 Camera Control деактивирован")
        }
    }
    
    func sessionControlsWillEnterFullscreenAppearance(
        _ session: AVCaptureSession
    ) {
        print("📺 Входим в полноэкранный режим")
        // Скрыть кастомные UI-элементы
    }
    
    func sessionControlsWillExitFullscreenAppearance(
        _ session: AVCaptureSession
    ) {
        print("📺 Выходим из полноэкранного режима")
        // Показать UI-элементы обратно
    }
}

// MARK: - AVCapturePhotoCaptureDelegate
 
extension CameraController: AVCapturePhotoCaptureDelegate {
    
    func photoOutput(
        _ output: AVCapturePhotoOutput,
        didFinishProcessingPhoto photo: AVCapturePhoto,
        error: Error?
    ) {
        if let error = error {
            print("❌ Ошибка: \(error.localizedDescription)")
            return
        }
        
        guard let imageData = photo.fileDataRepresentation(),
              let image = UIImage(data: imageData) else {
            print("❌ Не удалось получить изображение")
            return
        }
        
        DispatchQueue.main.async { [weak self] in
            self?.lastCapturedImage = image
        }
        
        saveToPhotoLibrary(imageData: imageData)
        print("✅ Фото захвачено")
    }
    
    private func saveToPhotoLibrary(imageData: Data) {
        PHPhotoLibrary.requestAuthorization(for: .addOnly) { status in
            guard status == .authorized else {
                print("⚠️ Нет разрешения на сохранение")
                return
            }
            
            PHPhotoLibrary.shared().performChanges {
                let request = PHAssetCreationRequest.forAsset()
                request.addResource(with: .photo, data: imageData, options: nil)
            } completionHandler: { success, error in
                if success {
                    print("✅ Сохранено в галерею")
                } else if let error = error {
                    print("❌ Ошибка: \(error.localizedDescription)")
                }
            }
        }
    }
}

// MARK: - Capture Event Handling
 
extension CameraController {
    
    /// Создаёт 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 настроен")
        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 — снимаем!")
            capturePhoto()
            
        case .cancelled:
            print("🔴 \(type): cancelled")
            
        @unknown default:
            break
        }
    }
}

import UIKit
import AVFoundation
 
/// UIView для отображения превью камеры
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 {
                // Превью камеры
                CameraPreviewRepresentable(
                    session: cameraController.session,
                    onViewCreated: { view in
                        setupCaptureInteraction(on: view)
                    }
                )
                .ignoresSafeArea()
                
                // Оверлей с контролами
                VStack {
                    topInfoBar
                    Spacer()
                    bottomControlsBar
                }
                .padding()
            }
        }
        .onAppear { cameraController.startSession() }
        .onDisappear { cameraController.stopSession() }
    }
    
    // MARK: - UI Components
    
    private var topInfoBar: some View {
        HStack {
            // Индикатор зума
            Label(
                String(format: "%.1fx", cameraController.currentZoomFactor),
                systemImage: "magnifyingglass"
            )
            .font(.caption)
            .padding(8)
            .background(.ultraThinMaterial)
            .clipShape(Capsule())
            
            Spacer()
            
            // Индикатор экспозиции
            Label(
                String(format: "%+.1f", cameraController.currentExposureBias),
                systemImage: "sun.max"
            )
            .font(.caption)
            .padding(8)
            .background(.ultraThinMaterial)
            .clipShape(Capsule())
            
            Spacer()
            
            // Индикатор Camera Control
            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) {
            // Превью последнего снимка
            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)
            }
            
            // Кнопка съёмки
            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: начинаем захват")
        
        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: сессия запущена")
            completion(nil)
        } catch {
            print("❌ Lock Screen Camera: \(error)")
            completion(error)
        }
    }
    
    func endCapture(completion: @escaping (Error?) -> Void) {
        print("📷 Lock Screen Camera: завершаем")
        
        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: фото сохранено")
            }
        }
    }
}
 
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"] = "✅ Полная поддержка"
            } else {
                report["Status"] = "⚠️ Устройство не поддерживает"
            }
        } else {
            report["iOS 18+"] = false
            report["Status"] = "❌ Требуется iOS 18+"
        }
        
        let authStatus = AVCaptureDevice.authorizationStatus(for: .video)
        switch authStatus {
        case .authorized:
            report["Permission"] = "✅ Разрешено"
        case .denied:
            report["Permission"] = "❌ Запрещено"
        case .restricted:
            report["Permission"] = "⚠️ Ограничено"
        case .notDetermined:
            report["Permission"] = "⏳ Не определено"
        @unknown default:
            report["Permission"] = "❓ Неизвестно"
        }
        
        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")
    }
}

// ✅ Правильно
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()
    // ... конфигурация ...
    self.session.commitConfiguration()
}