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     // UIKit预览
│   │   └── CameraModel.swift           // SwiftUI的ObservableObject
│   ├── Views/
│   │   ├── CameraView.swift            // SwiftUI相机视图
│   │   └── CameraViewController.swift  // UIKit控制器
│   └── Extensions/
│       └── AVCaptureSession+Extensions.swift
├── LockScreenCameraExtension/          // 锁屏扩展
│   ├── LockScreenCameraExtension.swift
│   └── Info.plist
└── Tests/
    └── CameraControlTests.swift

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()
    
    /// 会话配置队列（绝对不要在主线程上！）
    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 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设置 (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已停用")
        }
    }
}

// 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("✅ 已保存到相册")
                }
            }
        }
    }
}

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("📷 锁屏相机: 开始捕获")
        
        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("✅ 锁屏相机: 会话已启动")
            completion(nil)
        } catch {
            print("❌ 锁屏相机: \(error)")
            completion(error)
        }
    }
    
    func endCapture(completion: @escaping (Error?) -> Void) {
        captureSession?.stopRunning()
        captureSession = nil
        photoOutput = nil
        completion(nil)
    }
}
 
enum LockScreenCameraError: Error {
    case initializationFailed
}

// ✅ 正确
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
    }
}