capacitor-plugin-camera-forked 3.0.8 → 3.0.9

package/ios/Plugin/CameraPreviewPlugin.swift

@@ -28,6 +28,9 @@ public class CameraPreviewPlugin: CAPPlugin, AVCaptureVideoDataOutputSampleBuffe
     var lastValidOrientation = "portrait"
     var focusView: UIView?
     var isFocusAnimating = false
+    var focusCompletionTimer: Timer?
+    var lastFocusTime: Date = Date()
+    private let focusThrottleInterval: TimeInterval = 0.5
     @objc func initialize(_ call: CAPPluginCall) {
         // Initialize a camera view for previewing video.
         DispatchQueue.main.sync {
@@ -152,6 +155,10 @@ public class CameraPreviewPlugin: CAPPlugin, AVCaptureVideoDataOutputSampleBuffe
             // If the input can be added, add it to the session.
             if self.captureSession.canAddInput(videoInput) {
                 self.captureSession.addInput(videoInput)
+                
+                // Configure camera device for optimal focus performance
+                try self.configureCameraForOptimalFocus(device: videoDevice)
+                
                 self.previewView.videoPreviewLayer.session = self.captureSession
                 self.previewView.videoPreviewLayer.videoGravity = AVLayerVideoGravity.resizeAspectFill
                 
@@ -169,7 +176,12 @@ public class CameraPreviewPlugin: CAPPlugin, AVCaptureVideoDataOutputSampleBuffe
                 
                 self.photoOutput = AVCapturePhotoOutput()
                 self.photoOutput.isHighResolutionCaptureEnabled = true
-                //self.photoOutput.
+                
+                // Configure photo output for better focus
+                if #available(iOS 13.0, *) {
+                    self.photoOutput.maxPhotoQualityPrioritization = .quality
+                }
+                
                 if self.captureSession.canAddOutput(self.photoOutput) {
                     self.captureSession.addOutput(photoOutput)
                 }
@@ -195,13 +207,100 @@ public class CameraPreviewPlugin: CAPPlugin, AVCaptureVideoDataOutputSampleBuffe
             print(error)
         }
     }
+    
+    private func configureCameraForOptimalFocus(device: AVCaptureDevice) throws {
+        try device.lockForConfiguration()
+        
+        // Set optimal focus mode for continuous operation
+        if device.isFocusModeSupported(.continuousAutoFocus) {
+            device.focusMode = .continuousAutoFocus
+        }
+        
+        // Set optimal exposure mode
+        if device.isExposureModeSupported(.continuousAutoExposure) {
+            device.exposureMode = .continuousAutoExposure
+        }
+        
+        // Enable subject area change monitoring for responsive focus
+        device.isSubjectAreaChangeMonitoringEnabled = true
+        
+        // Configure white balance for better color accuracy
+        if device.isWhiteBalanceModeSupported(.continuousAutoWhiteBalance) {
+            device.whiteBalanceMode = .continuousAutoWhiteBalance
+        }
+        
+        // Set focus range restriction if supported (helps with faster focus)
+        if device.isAutoFocusRangeRestrictionSupported {
+            device.autoFocusRangeRestriction = .none // Allow full range for versatility
+        }
+        
+        // Enable smooth auto focus if available (iOS 7+)
+        if device.isSmoothAutoFocusSupported {
+            device.isSmoothAutoFocusEnabled = true
+        }
+        
+        device.unlockForConfiguration()
+    }
+    
     func takePhotoWithAVFoundation(){
         //self.captureSession.sessionPreset = AVCaptureSession.Preset.hd4K3840x2160
         let photoSettings: AVCapturePhotoSettings
-        photoSettings = AVCapturePhotoSettings()
+        
+        // Use HEIF format if available for better quality
+        if #available(iOS 11.0, *), self.photoOutput.availablePhotoCodecTypes.contains(.hevc) {
+            photoSettings = AVCapturePhotoSettings(format: [AVVideoCodecKey: AVVideoCodecType.hevc])
+        } else {
+            photoSettings = AVCapturePhotoSettings()
+        }
+        
         photoSettings.isHighResolutionPhotoEnabled = true
         
-        self.photoOutput.capturePhoto(with: photoSettings, delegate: self)
+        // Enable auto-focus before capture for better focus accuracy
+        if #available(iOS 11.0, *) {
+            photoSettings.photoQualityPrioritization = .quality
+        }
+        
+        // Enable auto-focus and auto-exposure for optimal capture
+        if #available(iOS 14.1, *) {
+            photoSettings.isAutoContentAwareDistortionCorrectionEnabled = true
+        }
+        
+        // Trigger focus before capture if the device supports it
+        let device = self.videoInput.device
+        if device.isFocusModeSupported(.autoFocus) {
+            do {
+                try device.lockForConfiguration()
+                
+                // Temporarily switch to autoFocus for the photo capture
+                let previousFocusMode = device.focusMode
+                device.focusMode = .autoFocus
+                
+                device.unlockForConfiguration()
+                
+                // Wait a brief moment for focus to settle, then capture
+                DispatchQueue.main.asyncAfter(deadline: .now() + 0.1) {
+                    self.photoOutput.capturePhoto(with: photoSettings, delegate: self)
+                    
+                    // Restore previous focus mode after a short delay
+                    DispatchQueue.main.asyncAfter(deadline: .now() + 0.5) {
+                        do {
+                            try device.lockForConfiguration()
+                            device.focusMode = previousFocusMode
+                            device.unlockForConfiguration()
+                        } catch {
+                            print("Could not restore focus mode: \(error)")
+                        }
+                    }
+                }
+            } catch {
+                // If focus configuration fails, capture anyway
+                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)
+        }
     }
     
     public func photoOutput(_ output: AVCapturePhotoOutput, didFinishProcessingPhoto photo: AVCapturePhoto, error: Error?) {
@@ -545,6 +644,12 @@ public class CameraPreviewPlugin: CAPPlugin, AVCaptureVideoDataOutputSampleBuffe
         if let x = call.getFloat("x"), let y = call.getFloat("y"),
            x >= 0.0 && x <= 1.0, y >= 0.0 && y <= 1.0 {
             let point = CGPoint(x: CGFloat(x), y: CGFloat(y))
+            
+            // 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
@@ -557,6 +662,35 @@ public class CameraPreviewPlugin: CAPPlugin, AVCaptureVideoDataOutputSampleBuffe
         }
     }
     
+    private func resetFocusIfStuck() {
+        // Remove any existing focus indicator
+        focusView?.removeFromSuperview()
+        focusCompletionTimer?.invalidate()
+        isFocusAnimating = false
+        
+        // Reset focus to continuous mode
+        let device = self.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) {
+        resetFocusIfStuck()
+        
+        // Reset to center focus
+        let centerPoint = CGPoint(x: 0.5, y: 0.5)
+        focusWithPoint(point: centerPoint)
+        
+        call.resolve()
+    }
+    
     @objc func handleTapToFocus(_ gesture: UITapGestureRecognizer) {
         let location = gesture.location(in: self.previewView)
         let convertedPoint = self.previewView.videoPreviewLayer.captureDevicePointConverted(fromLayerPoint: location)
@@ -567,55 +701,114 @@ public class CameraPreviewPlugin: CAPPlugin, AVCaptureVideoDataOutputSampleBuffe
     
     func focusWithPoint(point: CGPoint) {
         let device = self.videoInput.device
+        
+        let now = Date()
+        if now.timeIntervalSince(lastFocusTime) < focusThrottleInterval {
+            return
+        }
+        lastFocusTime = now
+        
         do {
             try device.lockForConfiguration()
             
+            focusCompletionTimer?.invalidate()
+            
             if device.isFocusPointOfInterestSupported {
                 device.focusPointOfInterest = point
-                device.focusMode = .autoFocus
+                
+                if device.isFocusModeSupported(.continuousAutoFocus) {
+                    device.focusMode = .continuousAutoFocus
+                } else if device.isFocusModeSupported(.autoFocus) {
+                    device.focusMode = .autoFocus
+                } else {
+                    device.focusMode = .locked
+                }
+                
+                if device.focusMode == .autoFocus {
+                    NotificationCenter.default.addObserver(
+                        self,
+                        selector: #selector(subjectAreaDidChange),
+                        name: .AVCaptureDeviceSubjectAreaDidChange,
+                        object: device
+                    )
+                }
             }
             
             if device.isExposurePointOfInterestSupported {
                 device.exposurePointOfInterest = point
-                device.exposureMode = .continuousAutoExposure
+                
+                if device.isExposureModeSupported(.continuousAutoExposure) {
+                    device.exposureMode = .continuousAutoExposure
+                } else if device.isExposureModeSupported(.autoExpose) {
+                    device.exposureMode = .autoExpose
+                }
             }
             
+            device.isSubjectAreaChangeMonitoringEnabled = true
+            
             device.unlockForConfiguration()
             
+            focusCompletionTimer = Timer.scheduledTimer(withTimeInterval: 2.0, repeats: false) { [weak self] _ in
+                DispatchQueue.main.async {
+                    self?.hideFocusIndicatorWithCompletion()
+                }
+            }
+            
         } 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 hideFocusIndicatorWithCompletion() {
+        guard 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
+        }
+    }
+    
     func showFocusView(at point: CGPoint) {
         if isFocusAnimating {
             self.focusView?.removeFromSuperview()
+            focusCompletionTimer?.invalidate()
         }
         
-        // Create focus view if needed
+        // Create focus view if needed - but make it invisible
         if self.focusView == nil {
-            self.focusView = UIView(frame: CGRect(x: 0, y: 0, width: 75, height: 75))
-            self.focusView?.layer.borderColor = UIColor.yellow.cgColor
-            self.focusView?.layer.borderWidth = 1.0
+            self.focusView = UIView(frame: CGRect(x: 0, y: 0, width: 80, height: 80))
+            // Make the focus view completely transparent
+            self.focusView?.layer.borderColor = UIColor.clear.cgColor
+            self.focusView?.layer.borderWidth = 0.0
+            self.focusView?.layer.cornerRadius = 40
             self.focusView?.backgroundColor = .clear
+            self.focusView?.alpha = 0.0
+            
+            // Remove the inner circle to make it completely invisible
+            // No inner circle added
         }
         
         self.focusView?.center = point
-        self.focusView?.alpha = 0.0
+        self.focusView?.alpha = 0.0  // Keep invisible
+        self.focusView?.transform = CGAffineTransform.identity
         self.previewView.addSubview(self.focusView!)
         
         self.isFocusAnimating = true
         
-        UIView.animate(withDuration: 0.3, delay: 0.0, options: .curveEaseInOut, animations: {
-            self.focusView?.alpha = 1.0
-        }, completion: { _ in
-            UIView.animate(withDuration: 0.3, delay: 0.5, options: .curveEaseInOut, animations: {
-                self.focusView?.alpha = 0.0
-            }, completion: { _ in
-                self.focusView?.removeFromSuperview()
-                self.isFocusAnimating = false
-            })
-        })
+        // Skip the animation since the view is invisible
+        // Focus functionality still works, just no visual feedback
     }
     
     @objc func requestCameraPermission(_ call: CAPPluginCall) {
@@ -718,4 +911,9 @@ public class CameraPreviewPlugin: CAPPlugin, AVCaptureVideoDataOutputSampleBuffe
         takePhotoWithAVFoundation()
     }
     
+    deinit {
+        NotificationCenter.default.removeObserver(self)
+        focusCompletionTimer?.invalidate()
+    }
+    
 }

package/package.json

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