High Resolution Photo Capture with Fast Capture Prioritization

 import AVFoundation
 import UIKit
 
−// Pre-iOS-27: fast capture prioritization existed but balanced fast captures
−// were NOT deferred — they still blocked the next capture during processing.
−class LegacyHighResPhotoCapture: NSObject, AVCapturePhotoCaptureDelegate {
+class HighResPhotoCapture: NSObject, AVCapturePhotoCaptureDelegate {
     private let session = AVCaptureSession()
     private let photoOutput = AVCapturePhotoOutput()
+    private var selectedMaxDimensions = CMVideoDimensions(width: 0, height: 0)
 
     func configure() {
         guard session.canSetSessionPreset(.photo) else { return }
         session.beginConfiguration()
         session.sessionPreset = .photo
 
+        // Add camera input
         guard
             let device = AVCaptureDevice.default(.builtInWideAngleCamera,
                                                 for: .video,
                                                 position: .back),
             let input = try? AVCaptureDeviceInput(device: device),
             session.canAddInput(input)
         else {
             session.commitConfiguration()
             return
         }
         session.addInput(input)
 
+        // Configure photo output before commit
         photoOutput.maxPhotoQualityPrioritization = .quality
+        // Enable responsive capture to overlap capture + processing stages
         photoOutput.isResponsiveCaptureEnabled = true
−        // Deferred delivery available since iOS 17
+        // Deferred processing: proxy delivered immediately, final processed later
         photoOutput.isDeferredPhotoDeliveryEnabled = true
−        // Fast capture existed but on iOS 16–26, balanced fast captures were
−        // NOT deferred — processing still blocked subsequent captures.
+        // Fast capture: system downgrades to .balanced during rapid bursts (iOS 27: also defers those)
         photoOutput.isFastCapturePrioritizationEnabled = true
−        // NOTE: ultrawide 24/48MP not available before iOS 27 / iPhone 17
 
         guard session.canAddOutput(photoOutput) else {
             session.commitConfiguration()
             return
         }
         session.addOutput(photoOutput)
+
+        // Pick the largest supported dimensions on the active format
+        if let largest = device.activeFormat.supportedMaxPhotoDimensions.last {
+            selectedMaxDimensions = largest
+        }
+
         session.commitConfiguration()
+
+        // Pre-allocate resources for 48MP quality captures
+        let prepareSettings = AVCapturePhotoSettings()
+        prepareSettings.maxPhotoDimensions = selectedMaxDimensions
+        prepareSettings.photoQualityPrioritization = .quality
+        photoOutput.setPreparedPhotoSettingsArray([prepareSettings]) { prepared, error in
+            if prepared {
+                print("Resources pre-allocated for \(self.selectedMaxDimensions.width)x\(self.selectedMaxDimensions.height)")
+            }
+        }
+
         session.startRunning()
     }
 
     func capturePhoto() {
−        let settings = AVCapturePhotoSettings()
−        // On iOS 16-26, no pre-allocation API difference, but balanced fast
−        // captures during rapid bursts would still incur full processing delay.
−        settings.photoQualityPrioritization = .quality
−        photoOutput.capturePhoto(with: settings, delegate: self)
+        // Create a NEW settings object matching the prepared configuration
+        let captureSettings = AVCapturePhotoSettings()
+        captureSettings.maxPhotoDimensions = selectedMaxDimensions
+        captureSettings.photoQualityPrioritization = .quality
+        photoOutput.capturePhoto(with: captureSettings, delegate: self)
     }
 
+    // MARK: - AVCapturePhotoCaptureDelegate
+
     func photoOutput(_ output: AVCapturePhotoOutput,
+                     didCapturePhotoFor resolvedSettings: AVCaptureResolvedPhotoSettings) {
+        let range = resolvedSettings.photoProcessingTimeRange
+        print("Capture done. Expected processing: \(range.start.seconds)s – \(range.duration.seconds)s")
+    }
+
+    func photoOutput(_ output: AVCapturePhotoOutput,
+                     didFinishCapturingDeferredPhotoProxy deferredPhotoProxy: AVCaptureDeferredPhotoProxy?,
+                     error: Error?) {
+        guard let proxy = deferredPhotoProxy else {
+            print("Deferred proxy error: \(String(describing: error))")
+            return
+        }
+        // Save proxy to photo library; system finalises full-res image later
+        let data = proxy.fileDataRepresentation()
+        print("Deferred proxy received, \(data?.count ?? 0) bytes. Final image will be processed in background.")
+    }
+
+    func photoOutput(_ output: AVCapturePhotoOutput,
                      didFinishProcessingPhoto photo: AVCapturePhoto,
                      error: Error?) {
         guard error == nil, let data = photo.fileDataRepresentation() else { return }
−        print("Photo ready: \(data.count) bytes")
+        print("Full-res photo ready: \(data.count) bytes")
     }
 }