capacitor-plugin-camera-forked 3.0.99 → 3.0.101

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

@@ -339,6 +339,9 @@ 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());
@@ -645,6 +648,15 @@ public class CameraPreviewPlugin extends Plugin {
                         response.put("autoFocusSuccessful", 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);
+                        }
                         
                         call.resolve(response);
                     } catch (Exception e) {
@@ -834,7 +846,9 @@ public class CameraPreviewPlugin extends Plugin {
                     .build();
                 
                 camera.getCameraControl().startFocusAndMetering(restartAction);
-
+                
+                // Restart the continuous auto-focus monitoring
+                startContinuousAutoFocus();
             }
 
             JSObject result = new JSObject();
@@ -1404,4 +1418,154 @@ public class CameraPreviewPlugin extends Plugin {
         return count > 0 ? variance / count : 0.0;
     }
 
+    /**
+     * 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");
+                    }
+                }
+            });
+        }
+    }
+
+    /**
+     * 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");
+                }
+            }
+        });
+    }
+
 }

package/ios/Plugin/CameraPreviewPlugin.swift

@@ -1235,74 +1235,80 @@ public class CameraPreviewPlugin: CAPPlugin, AVCaptureVideoDataOutputSampleBuffe
     private func calculateBlurScore(image: UIImage) -> Double {
         guard let cgImage = image.cgImage else { return 0.0 }
         
-        let context = CIContext()
-        let ciImage = CIImage(cgImage: cgImage)
+        let width = cgImage.width
+        let height = cgImage.height
         
-        // Convert to grayscale for better blur detection
-        let grayscaleFilter = CIFilter(name: "CIColorControls")!
-        grayscaleFilter.setValue(ciImage, forKey: kCIInputImageKey)
-        grayscaleFilter.setValue(0.0, forKey: kCIInputSaturationKey)
+        // Create bitmap context to access pixel data
+        let bytesPerPixel = 4
+        let bytesPerRow = bytesPerPixel * width
+        let bitsPerComponent = 8
         
-        guard let grayscaleImage = grayscaleFilter.outputImage else { return 0.0 }
+        guard let context = CGContext(
+            data: nil,
+            width: width,
+            height: height,
+            bitsPerComponent: bitsPerComponent,
+            bytesPerRow: bytesPerRow,
+            space: CGColorSpaceCreateDeviceRGB(),
+            bitmapInfo: CGImageAlphaInfo.premultipliedLast.rawValue
+        ) else { return 0.0 }
         
-        // 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)
+        // Draw image into context
+        context.draw(cgImage, in: CGRect(x: 0, y: 0, width: width, height: height))
         
-        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)
+        guard let pixelData = context.data else { return 0.0 }
+        let data = pixelData.bindMemory(to: UInt8.self, capacity: width * height * bytesPerPixel)
         
+        // Convert to grayscale and apply Laplacian kernel (same as Android/Web)
         var variance = 0.0
-        var sampleCount = 0
+        var count = 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)
+        // Sample every 4th pixel for performance (same as Android/Web)
+        let step = 4
+        for y in stride(from: step, to: height - step, by: step) {
+            for x in stride(from: step, to: width - step, by: step) {
+                let idx = (y * width + x) * bytesPerPixel
                 
-                let sampleFilter = CIFilter(name: "CIAreaAverage")!
-                sampleFilter.setValue(filteredImage, forKey: kCIInputImageKey)
-                sampleFilter.setValue(CIVector(cgRect: sampleRect), forKey: kCIInputExtentKey)
+                // Convert to grayscale using same formula as Android/Web
+                let r = Double(data[idx])
+                let g = Double(data[idx + 1]) 
+                let b = Double(data[idx + 2])
+                let gray = 0.299 * r + 0.587 * g + 0.114 * b
                 
-                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
-                }
+                // Calculate neighbors for 3x3 Laplacian kernel
+                let neighbors: [Double] = [
+                    // Top row
+                    getGrayscaleValue(data: data, x: x-1, y: y-1, width: width, bytesPerPixel: bytesPerPixel),
+                    getGrayscaleValue(data: data, x: x, y: y-1, width: width, bytesPerPixel: bytesPerPixel),
+                    getGrayscaleValue(data: data, x: x+1, y: y-1, width: width, bytesPerPixel: bytesPerPixel),
+                    // Middle row (left and right)
+                    getGrayscaleValue(data: data, x: x-1, y: y, width: width, bytesPerPixel: bytesPerPixel),
+                    getGrayscaleValue(data: data, x: x+1, y: y, width: width, bytesPerPixel: bytesPerPixel),
+                    // Bottom row
+                    getGrayscaleValue(data: data, x: x-1, y: y+1, width: width, bytesPerPixel: bytesPerPixel),
+                    getGrayscaleValue(data: data, x: x, y: y+1, width: width, bytesPerPixel: bytesPerPixel),
+                    getGrayscaleValue(data: data, x: x+1, y: y+1, width: width, bytesPerPixel: bytesPerPixel)
+                ]
+                
+                // Apply 3x3 Laplacian kernel (matches Android/Web implementation)
+                let laplacian = -neighbors[0] - neighbors[1] - neighbors[2] +
+                               -neighbors[3] + 8 * gray - neighbors[4] +
+                               -neighbors[5] - neighbors[6] - neighbors[7]
+                
+                variance += laplacian * laplacian
+                count += 1
             }
         }
         
-        return sampleCount > 0 ? variance / Double(sampleCount) : 0.0
+        return count > 0 ? variance / Double(count) : 0.0
+    }
+    
+    private func getGrayscaleValue(data: UnsafePointer<UInt8>, x: Int, y: Int, width: Int, bytesPerPixel: Int) -> Double {
+        let idx = (y * width + x) * bytesPerPixel
+        let r = Double(data[idx])
+        let g = Double(data[idx + 1])
+        let b = Double(data[idx + 2])
+        return 0.299 * r + 0.587 * g + 0.114 * b
     }
     
 }

package/package.json

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