capacitor-plugin-camera-forked 3.0.96 → 3.0.99

package/ios/Plugin/CameraPreviewPlugin.swift

@@ -33,9 +33,6 @@ public class CameraPreviewPlugin: CAPPlugin, AVCaptureVideoDataOutputSampleBuffe
     private let focusThrottleInterval: TimeInterval = 0.5
     var currentCameraDevice: AVCaptureDevice?
     
-    // Simple focus management with fixed delay
-    var continuousFocusReturnTimer: Timer?
-    
     // Store the desired JPEG quality, set during initialization
     var desiredJpegQuality: CGFloat = 0.95 // Default to high quality (0.0-1.0)
     
@@ -379,21 +376,31 @@ public class CameraPreviewPlugin: CAPPlugin, AVCaptureVideoDataOutputSampleBuffe
                 
                 device.unlockForConfiguration()
                 
+                if device.isAdjustingFocus {
                 // Wait longer for focus to settle, especially for close objects
-                DispatchQueue.main.asyncAfter(deadline: .now() + 0.3) {
-                    self.photoOutput.capturePhoto(with: photoSettings, delegate: self)
-                    
-                    // Restore previous settings after capture
-                    DispatchQueue.main.asyncAfter(deadline: .now() + 0.8) {
-                        do {
-                            try device.lockForConfiguration()
-                            device.focusMode = previousFocusMode
-                            device.exposureMode = previousExposureMode
-                            device.unlockForConfiguration()
-                        } catch {
-                            print("Could not restore camera settings: \(error)")
+                    DispatchQueue.main.asyncAfter(deadline: .now() + 0.3) {
+                        self.photoOutput.capturePhoto(with: photoSettings, delegate: self)
+                        
+                        // Restore previous settings after capture
+                        DispatchQueue.main.asyncAfter(deadline: .now() + 0.8) {
+                            do {
+                                try device.lockForConfiguration()
+                                device.focusMode = previousFocusMode
+                                device.exposureMode = previousExposureMode
+                                device.unlockForConfiguration()
+                                
+                                // Focus to center after settings restoration to ensure optimal focus state
+                                DispatchQueue.main.asyncAfter(deadline: .now() + 0.1) {
+                                    self.focusToCenterSafely()
+                                }
+                            } catch {
+                                print("Could not restore camera settings: \(error)")
+                            }
                         }
                     }
+                } else {
+                    self.photoOutput.capturePhoto(with: photoSettings, delegate: self)
+
                 }
             } catch {
                 // If focus configuration fails, capture anyway
@@ -425,6 +432,10 @@ public class CameraPreviewPlugin: CAPPlugin, AVCaptureVideoDataOutputSampleBuffe
                     let image = UIImage(data: imageData)
                     let base64 = getBase64FromImage(image: image!, quality: desiredJpegQuality)
                     ret["base64"] = base64
+                    
+                    // Detect blur if base64 is included
+                    let blurScore = calculateBlurScore(image: image!)
+                    ret["blurScore"] = blurScore
                 }
                 do {
                     
@@ -435,6 +446,11 @@ public class CameraPreviewPlugin: CAPPlugin, AVCaptureVideoDataOutputSampleBuffe
                 }
                 takePhotoCall.resolve(ret)
                 takePhotoCall = nil
+                
+                // Focus to center after photo capture to ensure optimal focus state for next operation
+                DispatchQueue.main.asyncAfter(deadline: .now() + 0.2) {
+                    self.focusToCenterSafely()
+                }
             }
         }
     }
@@ -480,10 +496,24 @@ public class CameraPreviewPlugin: CAPPlugin, AVCaptureVideoDataOutputSampleBuffe
                 let qualityValue = takeSnapshotCall.getFloat("quality") ?? 100.0
                 let quality = CGFloat(qualityValue / 100.0) // Convert percentage to 0.0-1.0 range
                 let base64 = getBase64FromImage(image: normalized, quality: quality);
+                
                 var ret = PluginCallResultData()
                 ret["base64"] = base64
+                
+                // Only detect blur if checkBlur option is true
+                let shouldCheckBlur = takeSnapshotCall.getBool("checkBlur", false)
+                if shouldCheckBlur {
+                    let blurScore = calculateBlurScore(image: normalized)
+                    ret["blurScore"] = blurScore
+                }
+                
                 takeSnapshotCall.resolve(ret)
                 takeSnapshotCall = nil
+                
+                // Focus to center after snapshot to ensure optimal focus state for next operation
+                DispatchQueue.main.asyncAfter(deadline: .now() + 0.2) {
+                    self.focusToCenterSafely()
+                }
             }
             if saveFrameCall != nil {
                 CameraPreviewPlugin.frameTaken = normalized
@@ -491,6 +521,11 @@ public class CameraPreviewPlugin: CAPPlugin, AVCaptureVideoDataOutputSampleBuffe
                 ret["success"] = true
                 saveFrameCall.resolve(ret)
                 saveFrameCall = nil
+                
+                // Focus to center after frame save to ensure optimal focus state for next operation
+                DispatchQueue.main.asyncAfter(deadline: .now() + 0.2) {
+                    self.focusToCenterSafely()
+                }
             }
         }
     }
@@ -866,6 +901,12 @@ public class CameraPreviewPlugin: CAPPlugin, AVCaptureVideoDataOutputSampleBuffe
             factor = min(factor, device.maxAvailableVideoZoomFactor)
             device.videoZoomFactor = factor
             device.unlockForConfiguration()
+            
+            // Trigger focus to center after zoom change
+            // if device.isFocusModeSupported(.autoFocus) {
+            //     let centerPoint = CGPoint(x: 0.5, y: 0.5)
+            //     focusWithPoint(point: centerPoint)
+            // }
         } catch {
             print("Zoom could not be used")
         }
@@ -877,17 +918,51 @@ public class CameraPreviewPlugin: CAPPlugin, AVCaptureVideoDataOutputSampleBuffe
            x >= 0.0 && x <= 1.0, y >= 0.0 && y <= 1.0 {
             let point = CGPoint(x: CGFloat(x), y: CGFloat(y))
             
-            // Simplified focus without complex throttling or maintenance
+            // Check if focus is currently animating and reset if stuck
+            if isFocusAnimating {
+                resetFocusIfStuck()
+            }
+            
             focusWithPoint(point: point)
             
+            // Calculate the point in the preview layer's coordinate space
+            //let previewPoint = CGPoint(x: point.x * previewView.bounds.width,
+            //                         y: point.y * previewView.bounds.height)
+            // showFocusView(at: previewPoint)
             call.resolve()
         } else {
             call.reject("Invalid coordinates. Provide normalized x,y values (0.0-1.0)")
         }
     }
     
+    private func resetFocusIfStuck() {
+        DispatchQueue.main.async { [weak self] in
+            guard let self = self else { return }
+            
+            // Remove any existing focus indicator
+            self.focusView?.removeFromSuperview()
+            self.focusCompletionTimer?.invalidate()
+            self.isFocusAnimating = false
+            
+            // Reset focus to continuous mode
+            guard let videoInput = self.videoInput else { return }
+            let device = videoInput.device
+            do {
+                try device.lockForConfiguration()
+                if device.isFocusModeSupported(.continuousAutoFocus) {
+                    device.focusMode = .continuousAutoFocus
+                }
+                device.unlockForConfiguration()
+            } catch {
+                print("Could not reset focus: \(error)")
+            }
+        }
+    }
+    
     @objc func resetFocus(_ call: CAPPluginCall) {
-        // Simple reset to center focus
+        resetFocusIfStuck()
+        
+        // Reset to center focus
         let centerPoint = CGPoint(x: 0.5, y: 0.5)
         focusWithPoint(point: centerPoint)
         
@@ -899,57 +974,103 @@ public class CameraPreviewPlugin: CAPPlugin, AVCaptureVideoDataOutputSampleBuffe
         let convertedPoint = self.previewView.videoPreviewLayer.captureDevicePointConverted(fromLayerPoint: location)
         
         focusWithPoint(point: convertedPoint)
+        // showFocusView(at: location)
     }
     
     func focusWithPoint(point: CGPoint) {
         guard let videoInput = self.videoInput else { return }
         let device = videoInput.device
         
+        let now = Date()
+        if now.timeIntervalSince(lastFocusTime) < focusThrottleInterval {
+            return
+        }
+        lastFocusTime = now
+        
         do {
             try device.lockForConfiguration()
             
-            // Cancel any existing focus/exposure operations
-            if device.isFocusModeSupported(.autoFocus) && device.isFocusPointOfInterestSupported {
+            focusCompletionTimer?.invalidate()
+            
+            if device.isFocusPointOfInterestSupported {
                 device.focusPointOfInterest = point
-                device.focusMode = .autoFocus
+                
+                // Use autoFocus for more aggressive focusing on specific points
+                if device.isFocusModeSupported(.autoFocus) {
+                    device.focusMode = .autoFocus
+                } else if device.isFocusModeSupported(.continuousAutoFocus) {
+                    device.focusMode = .continuousAutoFocus
+                }
             }
             
-            if device.isExposureModeSupported(.autoExpose) && device.isExposurePointOfInterestSupported {
+            if device.isExposurePointOfInterestSupported {
                 device.exposurePointOfInterest = point
-                device.exposureMode = .autoExpose
+                
+                // Use autoExpose for specific point exposure
+                if device.isExposureModeSupported(.autoExpose) {
+                    device.exposureMode = .autoExpose
+                } else if device.isExposureModeSupported(.continuousAutoExposure) {
+                    device.exposureMode = .continuousAutoExposure
+                }
             }
             
-            // Ensure full focus range is available
+            // Ensure full focus range is available for close objects
             if device.isAutoFocusRangeRestrictionSupported {
                 device.autoFocusRangeRestriction = .none
             }
             
-            device.unlockForConfiguration()
+            device.isSubjectAreaChangeMonitoringEnabled = true
             
-            // Cancel any existing timer
-            continuousFocusReturnTimer?.invalidate()
+            device.unlockForConfiguration()
             
-            // Return to continuous focus after fixed delay
-            // This provides predictable behavior - user has 2 seconds to take photo after tap-to-focus
-            continuousFocusReturnTimer = Timer.scheduledTimer(withTimeInterval: 2.0, repeats: false) { [weak self] _ in
+            // Switch back to continuous focus after a delay to maintain automatic focus
+            DispatchQueue.main.asyncAfter(deadline: .now() + 1) { [weak self] in
                 self?.returnToContinuousFocus()
             }
+        
             
         } catch {
             print("Could not focus: \(error.localizedDescription)")
         }
     }
     
+    // @objc private func subjectAreaDidChange(notification: NSNotification) {
+    //     DispatchQueue.main.async { [weak self] in
+    //         self?.hideFocusIndicatorWithCompletion()
+    //     }
+        
+    //     NotificationCenter.default.removeObserver(self, name: .AVCaptureDeviceSubjectAreaDidChange, object: notification.object)
+    // }
+    
+    private func focusToCenterSafely() {
+        // Check if enough time has passed since last focus operation to avoid conflicts
+        let now = Date()
+        if now.timeIntervalSince(lastFocusTime) < focusThrottleInterval {
+            return
+        }
+        
+        // Only focus if not currently adjusting focus to avoid interrupting ongoing operations
+        guard let videoInput = self.videoInput else { return }
+        let device = videoInput.device
+        
+        if !device.isAdjustingFocus {
+            let centerPoint = CGPoint(x: 0.5, y: 0.5)
+            focusWithPoint(point: centerPoint)
+        }
+    }
+    
     private func returnToContinuousFocus() {
         guard let videoInput = self.videoInput else { return }
         let device = videoInput.device
         do {
             try device.lockForConfiguration()
             
+            // Return to continuous auto focus for automatic operation
             if device.isFocusModeSupported(.continuousAutoFocus) {
                 device.focusMode = .continuousAutoFocus
             }
             
+            // Return to continuous auto exposure
             if device.isExposureModeSupported(.continuousAutoExposure) {
                 device.exposureMode = .continuousAutoExposure
             }
@@ -960,6 +1081,22 @@ public class CameraPreviewPlugin: CAPPlugin, AVCaptureVideoDataOutputSampleBuffe
         }
     }
     
+
+    
+    // private func hideFocusIndicatorWithCompletion() {
+    //     DispatchQueue.main.async { [weak self] in
+    //         guard let self = self, let focusView = self.focusView else { return }
+            
+    //         UIView.animate(withDuration: 0.2, animations: {
+    //             focusView.alpha = 0.0
+    //             focusView.transform = CGAffineTransform(scaleX: 0.8, y: 0.8)
+    //         }) { _ in
+    //             focusView.removeFromSuperview()
+    //             focusView.transform = CGAffineTransform.identity
+    //             self.isFocusAnimating = false
+    //         }
+    //     }
+    // }
     @objc func requestCameraPermission(_ call: CAPPluginCall) {
         AVCaptureDevice.requestAccess(for: .video) { granted in
             DispatchQueue.main.async {
@@ -1005,6 +1142,15 @@ public class CameraPreviewPlugin: CAPPlugin, AVCaptureVideoDataOutputSampleBuffe
     
     @objc func takeSnapshot(_ call: CAPPluginCall) {
         call.keepAlive = true
+        
+        let device = videoInput.device
+        if device.isFocusModeSupported(.autoFocus) {
+            // Trigger focus to center before capturing
+            let centerPoint = CGPoint(x: 0.5, y: 0.5)
+            focusWithPoint(point: centerPoint)
+        }
+
+        // Set the call
         takeSnapshotCall = call
     }
     
@@ -1075,59 +1221,88 @@ public class CameraPreviewPlugin: CAPPlugin, AVCaptureVideoDataOutputSampleBuffe
     }
     
     @objc func takePhoto(_ call: CAPPluginCall) {
+        call.keepAlive = true
         takePhotoCall = call
+        takePhotoWithAVFoundation()
+    }
+    
+    deinit {
+        NotificationCenter.default.removeObserver(self)
+        focusCompletionTimer?.invalidate()
+    }
+    
+    // MARK: - Blur Detection
+    private func calculateBlurScore(image: UIImage) -> Double {
+        guard let cgImage = image.cgImage else { return 0.0 }
         
-        // Configure photo settings
-        let photoSettings = AVCapturePhotoSettings()
-        photoSettings.isHighResolutionPhotoEnabled = true
+        let context = CIContext()
+        let ciImage = CIImage(cgImage: cgImage)
         
-        // Use JPEG format with quality setting
-        if #available(iOS 11.0, *) {
-            photoSettings.photoQualityPrioritization = .quality
-        }
+        // Convert to grayscale for better blur detection
+        let grayscaleFilter = CIFilter(name: "CIColorControls")!
+        grayscaleFilter.setValue(ciImage, forKey: kCIInputImageKey)
+        grayscaleFilter.setValue(0.0, forKey: kCIInputSaturationKey)
         
-        // Configure for optimal photo capture without complex focus management
-        guard let device = videoInput?.device else {
-            self.photoOutput.capturePhoto(with: photoSettings, delegate: self)
-            return
-        }
+        guard let grayscaleImage = grayscaleFilter.outputImage else { return 0.0 }
         
-        if device.isFocusModeSupported(.autoFocus) {
-            do {
-                try device.lockForConfiguration()
-                
-                // Set to auto focus for capture
-                device.focusMode = .autoFocus
-                
-                // Ensure full focus range
-                if device.isAutoFocusRangeRestrictionSupported {
-                    device.autoFocusRangeRestriction = .none
-                }
+        // Apply Laplacian filter for edge detection
+        let laplacianKernel: [Float] = [
+            0, -1, 0,
+            -1, 4, -1,
+            0, -1, 0
+        ]
+        
+        let convolutionFilter = CIFilter(name: "CIConvolution3X3")!
+        convolutionFilter.setValue(grayscaleImage, forKey: kCIInputImageKey)
+        convolutionFilter.setValue(CIVector(values: laplacianKernel, count: 9), forKey: "inputWeights")
+        
+        guard let filteredImage = convolutionFilter.outputImage else { return 0.0 }
+        
+        // Calculate variance of the Laplacian
+        let extent = filteredImage.extent
+        let inputExtent = CIVector(x: extent.origin.x, y: extent.origin.y, z: extent.size.width, w: extent.size.height)
+        
+        let averageFilter = CIFilter(name: "CIAreaAverage")!
+        averageFilter.setValue(filteredImage, forKey: kCIInputImageKey)
+        averageFilter.setValue(inputExtent, forKey: kCIInputExtentKey)
+        
+        guard let averageImage = averageFilter.outputImage else { return 0.0 }
+        
+        var bitmap = [UInt8](repeating: 0, count: 4)
+        context.render(averageImage, toBitmap: &bitmap, rowBytes: 4, bounds: CGRect(x: 0, y: 0, width: 1, height: 1), format: .RGBA8, colorSpace: nil)
+        
+        let average = Double(bitmap[0]) / 255.0
+        
+        // Calculate variance by processing small samples of the image
+        let sampleSize = min(100, Int(extent.width), Int(extent.height))
+        let stepX = extent.width / Double(sampleSize)
+        let stepY = extent.height / Double(sampleSize)
+        
+        var variance = 0.0
+        var sampleCount = 0
+        
+        for i in 0..<sampleSize {
+            for j in 0..<sampleSize {
+                let x = extent.origin.x + Double(i) * stepX
+                let y = extent.origin.y + Double(j) * stepY
+                let sampleRect = CGRect(x: x, y: y, width: 1, height: 1)
                 
-                // Set exposure for photo
-                if device.isExposureModeSupported(.autoExpose) {
-                    device.exposureMode = .autoExpose
-                }
+                let sampleFilter = CIFilter(name: "CIAreaAverage")!
+                sampleFilter.setValue(filteredImage, forKey: kCIInputImageKey)
+                sampleFilter.setValue(CIVector(cgRect: sampleRect), forKey: kCIInputExtentKey)
                 
-                device.unlockForConfiguration()
-                
-                // Wait briefly for focus, then capture
-                DispatchQueue.main.asyncAfter(deadline: .now() + 0.3) {
-                    self.photoOutput.capturePhoto(with: photoSettings, delegate: self)
+                if let sampleImage = sampleFilter.outputImage {
+                    var sampleBitmap = [UInt8](repeating: 0, count: 4)
+                    context.render(sampleImage, toBitmap: &sampleBitmap, rowBytes: 4, bounds: CGRect(x: 0, y: 0, width: 1, height: 1), format: .RGBA8, colorSpace: nil)
+                    
+                    let value = Double(sampleBitmap[0]) / 255.0
+                    variance += pow(value - average, 2)
+                    sampleCount += 1
                 }
-            } catch {
-                print("Could not configure focus for capture: \(error)")
-                self.photoOutput.capturePhoto(with: photoSettings, delegate: self)
             }
-        } else {
-            // Capture immediately if auto focus isn't supported
-            self.photoOutput.capturePhoto(with: photoSettings, delegate: self)
         }
-    }
-    
-    deinit {
-        focusCompletionTimer?.invalidate()
-        continuousFocusReturnTimer?.invalidate()
+        
+        return sampleCount > 0 ? variance / Double(sampleCount) : 0.0
     }
     
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "capacitor-plugin-camera-forked",
-  "version": "3.0.96",
+  "version": "3.0.99",
   "description": "A capacitor camera plugin - A custom Capacitor camera plugin with additional features.",
   "main": "dist/plugin.cjs.js",
   "module": "dist/esm/index.js",