capacitor-plugin-camera-forked 3.0.93 → 3.0.94

package/android/src/main/java/com/tonyxlh/capacitor/camera/CameraPreviewPlugin.java

@@ -328,9 +328,6 @@ public class CameraPreviewPlugin extends Plugin {
                 
                 camera.getCameraControl().startFocusAndMetering(initialFocus);
                 
-                // Enable continuous auto-focus by starting a background focus monitoring
-                startContinuousAutoFocus();
-                
                 Log.d("Camera", "Initialized responsive auto-focus with continuous monitoring");
             } catch (Exception e) {
                 Log.e("Camera", "Failed to initialize responsive auto-focus: " + e.getMessage());
@@ -338,65 +335,69 @@ public class CameraPreviewPlugin extends Plugin {
         }
     }
 
-    /**
-     * Start continuous auto-focus monitoring for better focus stability
-     */
-    private void startContinuousAutoFocus() {
-        if (camera != null && previewView != null) {
-            // Use a separate executor for continuous focus to avoid blocking
-            ExecutorService focusExecutor = Executors.newSingleThreadExecutor();
-            
-            focusExecutor.execute(new Runnable() {
-                @Override
-                public void run() {
-                    try {
-                        while (camera != null && camera.getCameraInfo().getCameraState().getValue().getType() == CameraState.Type.OPEN) {
-                            Thread.sleep(800); // Check every 800ms for faster transitions
-                            
-                            getActivity().runOnUiThread(new Runnable() {
-                                @Override
-                                public void run() {
-                                    try {
-                                        // Trigger auto-focus at center to maintain continuous focus
-                                        MeteringPointFactory factory = previewView.getMeteringPointFactory();
-                                        float centerX = previewView.getWidth() / 2.0f;
-                                        float centerY = previewView.getHeight() / 2.0f;
-                                        MeteringPoint centerPoint = factory.createPoint(centerX, centerY);
-                                        
-                                        FocusMeteringAction continuousAction = new FocusMeteringAction.Builder(centerPoint)
-                                            .setAutoCancelDuration(1, TimeUnit.SECONDS) // Fast 1 second for responsive transitions
-                                            .build();
-                                        
-                                        camera.getCameraControl().startFocusAndMetering(continuousAction);
-                                    } catch (Exception e) {
-                                        Log.d("Camera", "Continuous focus update failed: " + e.getMessage());
-                                    }
-                                }
-                            });
-                        }
-                    } catch (InterruptedException e) {
-                        Log.d("Camera", "Continuous auto-focus stopped");
-                    }
-                }
-            });
-        }
-    }
-
     @PluginMethod
     public void startCamera(PluginCall call) {
         getActivity().runOnUiThread(new Runnable() {
             public void run() {
                 try {
-                    camera = cameraProvider.bindToLifecycle((LifecycleOwner) getContext(), cameraSelector, useCaseGroup);
+                    // Validate that all required components are ready
+                    if (cameraProvider == null) {
+                        call.reject("Camera provider not initialized");
+                        return;
+                    }
+                    if (cameraSelector == null) {
+                        call.reject("Camera selector not initialized");
+                        return;
+                    }
+                    if (useCaseGroup == null) {
+                        call.reject("Camera use cases not initialized");
+                        return;
+                    }
+                    if (previewView == null) {
+                        call.reject("Preview view not initialized");
+                        return;
+                    }
+
+                    // Ensure preview surface is properly connected
+                    if (preview != null) {
+                        preview.setSurfaceProvider(previewView.getSurfaceProvider());
+                    }
+
+                    // Make UI changes first
                     previewView.setVisibility(View.VISIBLE);
                     previewView.setBackgroundColor(Color.BLACK);
                     makeWebViewTransparent();
-                    
-                    // Initialize responsive auto-focus for better performance
-                    initializeResponsiveAutoFocus();
-                    
-                    triggerOnPlayed();
-                    call.resolve();
+
+                    // Small delay to ensure preview surface is ready
+                    exec.execute(new Runnable() {
+                        @Override
+                        public void run() {
+                            try {
+                                Thread.sleep(50); // Brief delay for surface initialization
+                                
+                                getActivity().runOnUiThread(new Runnable() {
+                                    @Override
+                                    public void run() {
+                                        try {
+                                            // Bind camera to lifecycle
+                                            camera = cameraProvider.bindToLifecycle((LifecycleOwner) getContext(), cameraSelector, useCaseGroup);
+                                            
+                                            // Initialize responsive auto-focus for better performance
+                                            initializeResponsiveAutoFocus();
+                                            
+                                            triggerOnPlayed();
+                                            call.resolve();
+                                        } catch (Exception e) {
+                                            e.printStackTrace();
+                                            call.reject("Failed to bind camera: " + e.getMessage());
+                                        }
+                                    }
+                                });
+                            } catch (InterruptedException e) {
+                                call.reject("Camera start interrupted: " + e.getMessage());
+                            }
+                        }
+                    });
                 } catch (Exception e) {
                     e.printStackTrace();
                     call.reject(e.getMessage());
@@ -508,24 +509,8 @@ public class CameraPreviewPlugin extends Plugin {
                                                 .setAutoCancelDuration(1, TimeUnit.SECONDS) // Fast 1 second for zoom focus
                                                 .build();
                                             
-                                            ListenableFuture<FocusMeteringResult> zoomFocusFuture = 
-                                                camera.getCameraControl().startFocusAndMetering(zoomFocusAction);
-                                            
-                                            zoomFocusFuture.addListener(new Runnable() {
-                                                @Override
-                                                public void run() {
-                                                    try {
-                                                        FocusMeteringResult result = zoomFocusFuture.get();
-                                                        if (result.isFocusSuccessful()) {
-                                                            Log.d("Camera", "Zoom-triggered focus successful for factor: " + factor);
-                                                        } else {
-                                                            Log.d("Camera", "Zoom-triggered focus failed, will rely on continuous AF");
-                                                        }
-                                                    } catch (Exception e) {
-                                                        Log.d("Camera", "Zoom focus result check failed: " + e.getMessage());
-                                                    }
-                                                }
-                                            }, ContextCompat.getMainExecutor(getContext()));
+                                            // Trigger focus after zoom change - simplified without result handling
+                                            camera.getCameraControl().startFocusAndMetering(zoomFocusAction);
                                         }
                                     } catch (Exception e) {
                                         Log.d("Camera", "Auto-focus after zoom failed: " + e.getMessage());
@@ -609,39 +594,24 @@ public class CameraPreviewPlugin extends Plugin {
             // Start focus and metering with result callback
             ListenableFuture<FocusMeteringResult> future = camera.getCameraControl().startFocusAndMetering(action);
 
-            // Add callback to handle the result with enhanced focus maintenance
+            // Simple callback to return focus result
             future.addListener(new Runnable() {
                 @Override
                 public void run() {
-                try {
-                    FocusMeteringResult result = future.get();
                     JSObject response = new JSObject();
-                    response.put("success", true);
-                    response.put("autoFocusSuccessful", result.isFocusSuccessful());
-
-                    if (includeExposure) {
-                    // Note: CameraX FocusMeteringResult doesn't provide separate exposure success status
-                    // We'll indicate that exposure was attempted along with focus
-                    response.put("autoExposureSuccessful", result.isFocusSuccessful());
-                    }
-
-                    response.put("x", x);
-                    response.put("y", y);
-
-                    // If focus failed, try a backup focus attempt to reduce need for multiple taps
-                    if (!result.isFocusSuccessful()) {
-                        Log.d("Camera", "Initial focus failed, attempting backup focus");
-                        performBackupFocus(previewX, previewY);
-                    } else {
-                        // If manual focus was successful, maintain it with a follow-up action
-                        maintainFocusAtPoint(previewX, previewY);
+                    try {
+                        FocusMeteringResult result = future.get();
+                        response.put("success", true);
+                        response.put("autoFocusSuccessful", result.isFocusSuccessful());
+                        response.put("x", x);
+                        response.put("y", y);
+                        
+                        call.resolve(response);
+                    } catch (Exception e) {
+                        response.put("success", false);
+                        Log.e("Camera", "Focus operation failed", e);
+                        call.resolve(response);
                     }
-
-                    call.resolve(response);
-                } catch (Exception e) {
-                    Log.e("Camera", "Focus operation failed", e);
-                    call.reject("Focus operation failed: " + e.getMessage());
-                }
                 }
             }, ContextCompat.getMainExecutor(getContext()));
 
@@ -653,112 +623,6 @@ public class CameraPreviewPlugin extends Plugin {
         });
     }
 
-    /**
-     * Perform backup focus attempt if initial focus fails
-     * This reduces the need for users to tap multiple times
-     */
-    private void performBackupFocus(float previewX, float previewY) {
-        if (camera == null || previewView == null) return;
-        
-        // Wait a moment for the camera to settle
-        ExecutorService backupFocusExecutor = Executors.newSingleThreadExecutor();
-        backupFocusExecutor.execute(new Runnable() {
-            @Override
-            public void run() {
-                                    try {
-                        Thread.sleep(200); // Wait 200ms for faster backup focus
-                    
-                    getActivity().runOnUiThread(new Runnable() {
-                        @Override
-                        public void run() {
-                            try {
-                                if (camera != null && previewView != null) {
-                                    MeteringPointFactory factory = previewView.getMeteringPointFactory();
-                                    MeteringPoint backupPoint = factory.createPoint(previewX, previewY);
-                                    
-                                    // Try with fast duration for responsive backup focus
-                                    FocusMeteringAction backupAction = new FocusMeteringAction.Builder(backupPoint, 
-                                        FocusMeteringAction.FLAG_AF | FocusMeteringAction.FLAG_AE)
-                                        .setAutoCancelDuration(1, TimeUnit.SECONDS) // Fast 1 second for backup
-                                        .build();
-                                    
-                                    ListenableFuture<FocusMeteringResult> backupFuture = 
-                                        camera.getCameraControl().startFocusAndMetering(backupAction);
-                                    
-                                    backupFuture.addListener(new Runnable() {
-                                        @Override
-                                        public void run() {
-                                            try {
-                                                FocusMeteringResult backupResult = backupFuture.get();
-                                                if (backupResult.isFocusSuccessful()) {
-                                                    Log.d("Camera", "Backup focus successful");
-                                                    maintainFocusAtPoint(previewX, previewY);
-                                                } else {
-                                                    Log.d("Camera", "Backup focus also failed");
-                                                }
-                                            } catch (Exception e) {
-                                                Log.d("Camera", "Backup focus exception: " + e.getMessage());
-                                            }
-                                        }
-                                    }, ContextCompat.getMainExecutor(getContext()));
-                                }
-                            } catch (Exception e) {
-                                Log.d("Camera", "Backup focus setup failed: " + e.getMessage());
-                            }
-                        }
-                    });
-                } catch (InterruptedException e) {
-                    Log.d("Camera", "Backup focus interrupted");
-                }
-            }
-        });
-    }
-
-    /**
-     * Maintain focus at a specific point with repeated focus actions for stability
-     */
-    private void maintainFocusAtPoint(float previewX, float previewY) {
-        if (camera == null || previewView == null) return;
-        
-        // Use a separate executor for focus maintenance
-        ExecutorService focusMaintainExecutor = Executors.newSingleThreadExecutor();
-        
-        focusMaintainExecutor.execute(new Runnable() {
-            @Override
-            public void run() {
-                try {
-                    // Maintain focus for 2 seconds with quick refocus for responsive transitions
-                    for (int i = 0; i < 2; i++) {
-                        Thread.sleep(1000); // Wait 1 second between focus actions
-                        
-                        getActivity().runOnUiThread(new Runnable() {
-                            @Override
-                            public void run() {
-                                try {
-                                    if (camera != null && camera.getCameraInfo().getCameraState().getValue().getType() == CameraState.Type.OPEN) {
-                                        MeteringPointFactory factory = previewView.getMeteringPointFactory();
-                                        MeteringPoint maintainPoint = factory.createPoint(previewX, previewY);
-                                        
-                                        FocusMeteringAction maintainAction = new FocusMeteringAction.Builder(maintainPoint)
-                                            .setAutoCancelDuration(1, TimeUnit.SECONDS) // Fast 1 second maintenance
-                                            .build();
-                                        
-                                        camera.getCameraControl().startFocusAndMetering(maintainAction);
-                                        Log.d("Camera", "Maintaining focus at tapped point");
-                                    }
-                                } catch (Exception e) {
-                                    Log.d("Camera", "Focus maintenance failed: " + e.getMessage());
-                                }
-                            }
-                        });
-                    }
-                } catch (InterruptedException e) {
-                    Log.d("Camera", "Focus maintenance interrupted");
-                }
-            }
-        });
-    }
-
     @PluginMethod
     public void setAutoFocusMode(PluginCall call) {
         if (camera == null) {
@@ -928,9 +792,7 @@ public class CameraPreviewPlugin extends Plugin {
                     .build();
                 
                 camera.getCameraControl().startFocusAndMetering(restartAction);
-                
-                // Restart the continuous auto-focus monitoring
-                startContinuousAutoFocus();
+
             }
 
             JSObject result = new JSObject();

package/ios/Plugin/CameraPreviewPlugin.swift

@@ -33,6 +33,9 @@ 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)
     
@@ -874,51 +877,17 @@ 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))
             
-            // Check if focus is currently animating and reset if stuck
-            if isFocusAnimating {
-                resetFocusIfStuck()
-            }
-            
+            // Simplified focus without complex throttling or maintenance
             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) {
-        resetFocusIfStuck()
-        
-        // Reset to center focus
+        // Simple reset to center focus
         let centerPoint = CGPoint(x: 0.5, y: 0.5)
         focusWithPoint(point: centerPoint)
         
@@ -930,72 +899,40 @@ 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()
             
-            focusCompletionTimer?.invalidate()
-            
-            if device.isFocusPointOfInterestSupported {
+            // Cancel any existing focus/exposure operations
+            if device.isFocusModeSupported(.autoFocus) && device.isFocusPointOfInterestSupported {
                 device.focusPointOfInterest = point
-                
-                // Use autoFocus for more aggressive focusing on specific points
-                if device.isFocusModeSupported(.autoFocus) {
-                    device.focusMode = .autoFocus
-                    
-                    // Set up observer for focus completion
-                    NotificationCenter.default.addObserver(
-                        self,
-                        selector: #selector(subjectAreaDidChange),
-                        name: .AVCaptureDeviceSubjectAreaDidChange,
-                        object: device
-                    )
-                } else if device.isFocusModeSupported(.continuousAutoFocus) {
-                    device.focusMode = .continuousAutoFocus
-                }
+                device.focusMode = .autoFocus
             }
             
-            if device.isExposurePointOfInterestSupported {
+            if device.isExposureModeSupported(.autoExpose) && device.isExposurePointOfInterestSupported {
                 device.exposurePointOfInterest = point
-                
-                // Use autoExpose for specific point exposure
-                if device.isExposureModeSupported(.autoExpose) {
-                    device.exposureMode = .autoExpose
-                } else if device.isExposureModeSupported(.continuousAutoExposure) {
-                    device.exposureMode = .continuousAutoExposure
-                }
+                device.exposureMode = .autoExpose
             }
             
-            // Ensure full focus range is available for close objects
+            // Ensure full focus range is available
             if device.isAutoFocusRangeRestrictionSupported {
                 device.autoFocusRangeRestriction = .none
             }
             
-            device.isSubjectAreaChangeMonitoringEnabled = true
-            
             device.unlockForConfiguration()
             
-            // Switch back to continuous focus after a delay to maintain automatic focus
-            DispatchQueue.main.asyncAfter(deadline: .now() + 1.5) { [weak self] in
-                self?.returnToContinuousFocus()
-            }
+            // Cancel any existing timer
+            continuousFocusReturnTimer?.invalidate()
             
-            focusCompletionTimer = Timer.scheduledTimer(withTimeInterval: 2.0, repeats: false) { [weak self] _ in
-                DispatchQueue.main.async {
-                    self?.hideFocusIndicatorWithCompletion()
-                }
+            // 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
+                self?.returnToContinuousFocus()
             }
             
         } catch {
@@ -1003,26 +940,16 @@ public class CameraPreviewPlugin: CAPPlugin, AVCaptureVideoDataOutputSampleBuffe
         }
     }
     
-    @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 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
             }
@@ -1033,58 +960,6 @@ 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
-            }
-        }
-    }
-    
-    // func showFocusView(at point: CGPoint) {
-    //     DispatchQueue.main.async { [weak self] in
-    //         guard let self = self else { return }
-            
-    //         if self.isFocusAnimating {
-    //             self.focusView?.removeFromSuperview()
-    //             self.focusCompletionTimer?.invalidate()
-    //         }
-            
-    //         // Create focus view if needed - but make it invisible
-    //         if self.focusView == nil {
-    //             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  // Keep invisible
-    //         self.focusView?.transform = CGAffineTransform.identity
-    //         self.previewView.addSubview(self.focusView!)
-            
-    //         self.isFocusAnimating = true
-            
-    //         // Skip the animation since the view is invisible
-    //         // Focus functionality still works, just no visual feedback
-    //     }
-    // }
-    
     @objc func requestCameraPermission(_ call: CAPPluginCall) {
         AVCaptureDevice.requestAccess(for: .video) { granted in
             DispatchQueue.main.async {
@@ -1200,14 +1075,59 @@ public class CameraPreviewPlugin: CAPPlugin, AVCaptureVideoDataOutputSampleBuffe
     }
     
     @objc func takePhoto(_ call: CAPPluginCall) {
-        call.keepAlive = true
         takePhotoCall = call
-        takePhotoWithAVFoundation()
+        
+        // Configure photo settings
+        let photoSettings = AVCapturePhotoSettings()
+        photoSettings.isHighResolutionPhotoEnabled = true
+        
+        // Use JPEG format with quality setting
+        if #available(iOS 11.0, *) {
+            photoSettings.photoQualityPrioritization = .quality
+        }
+        
+        // Configure for optimal photo capture without complex focus management
+        guard let device = videoInput?.device else {
+            self.photoOutput.capturePhoto(with: photoSettings, delegate: self)
+            return
+        }
+        
+        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
+                }
+                
+                // Set exposure for photo
+                if device.isExposureModeSupported(.autoExpose) {
+                    device.exposureMode = .autoExpose
+                }
+                
+                device.unlockForConfiguration()
+                
+                // Wait briefly for focus, then capture
+                DispatchQueue.main.asyncAfter(deadline: .now() + 0.3) {
+                    self.photoOutput.capturePhoto(with: photoSettings, delegate: self)
+                }
+            } 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 {
-        NotificationCenter.default.removeObserver(self)
         focusCompletionTimer?.invalidate()
+        continuousFocusReturnTimer?.invalidate()
     }
     
 }

package/package.json

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