capacitor-plugin-camera-forked 3.0.120 → 3.1.120

package/README.md

@@ -290,7 +290,7 @@ stopCamera() => Promise<void>
 ### takeSnapshot(...)
 
 ```typescript
-takeSnapshot(options: { quality?: number; checkBlur?: boolean; }) => Promise<{ base64: string; confidence?: number; }>
+takeSnapshot(options: { quality?: number; checkBlur?: boolean; }) => Promise<{ base64: string; confidence?: number; boundingBoxes?: number[][]; }>
 ```
 
 take a snapshot as base64.
@@ -299,7 +299,7 @@ take a snapshot as base64.
 | ------------- | ------------------------------------------------------- |
 | **`options`** | <code>{ quality?: number; checkBlur?: boolean; }</code> |
 
-**Returns:** <code>Promise&lt;{ base64: string; confidence?: number; }&gt;</code>
+**Returns:** <code>Promise&lt;{ base64: string; confidence?: number; boundingBoxes?: number[][]; }&gt;</code>
 
 --------------------
 

package/android/build.gradle

@@ -47,6 +47,13 @@ repositories {
     mavenCentral()
 }
 
+allprojects {
+    repositories {
+        google()
+        mavenCentral()
+    }
+}
+
 
 dependencies {
     implementation fileTree(dir: 'libs', include: ['*.jar'])
@@ -68,4 +75,7 @@ dependencies {
     implementation 'org.tensorflow:tensorflow-lite:2.14.0'
     implementation 'org.tensorflow:tensorflow-lite-support:0.4.4'
     implementation 'org.tensorflow:tensorflow-lite-gpu:2.14.0'
+    
+    // Google ML Kit dependencies for text recognition
+    implementation 'com.google.mlkit:text-recognition:16.0.1'
 }

package/android/src/main/AndroidManifest.xml

@@ -1,4 +1,11 @@
 <manifest xmlns:android="http://schemas.android.com/apk/res/android">
 
     <uses-permission android:name="android.permission.RECORD_AUDIO" />
+    
+    <application>
+        <!-- ML Kit Text Recognition model download -->
+        <meta-data
+            android:name="com.google.mlkit.vision.DEPENDENCIES"
+            android:value="ocr" />
+    </application>
 </manifest>

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

@@ -39,6 +39,10 @@ public class BlurDetectionHelper {
     private TensorImage inputImageBuffer;
     private TensorBuffer outputProbabilityBuffer;
     private boolean isInitialized = false;
+    
+    // Text recognition blur detection helper
+    private TextRecognitionBlurHelper textBlurHelper;
+    private boolean useTextRecognition = true;
 
 
     public BlurDetectionHelper() {
@@ -48,6 +52,9 @@ public class BlurDetectionHelper {
                 .add(new ResizeWithCropOrPadOp(INPUT_SIZE, INPUT_SIZE))
                 .add(new ResizeOp(INPUT_SIZE, INPUT_SIZE, ResizeOp.ResizeMethod.BILINEAR))
                 .build();
+        
+        // Initialize text recognition blur helper
+        textBlurHelper = new TextRecognitionBlurHelper();
     }
 
     /**
@@ -81,6 +88,9 @@ public class BlurDetectionHelper {
                     tflite.getOutputTensor(0).dataType()
             );
             
+            // Initialize text recognition helper
+            textBlurHelper.initialize(context);
+            
             // Update INPUT_SIZE based on actual model input shape
             int[] inputShape = tflite.getInputTensor(0).shape();
             
@@ -113,15 +123,51 @@ public class BlurDetectionHelper {
     }
 
     /**
-     * Detect blur in image using TFLite model
+     * Detect blur in image using hybrid approach (Text Recognition + TFLite)
      * @param bitmap Input image bitmap
      * @return Blur confidence score (0.0 = sharp, 1.0 = very blurry)
      */
     public double detectBlur(Bitmap bitmap) {
+        // First try text recognition if enabled
+        if (useTextRecognition && textBlurHelper != null && textBlurHelper.isInitialized()) {
+            try {
+                java.util.Map<String, Object> textResult = textBlurHelper.detectBlurWithConfidence(bitmap);
+                Boolean hasText = (Boolean) textResult.get("hasText");
+                
+                if (hasText != null && hasText) {
+                    // Image contains text, use text recognition result
+                    Boolean isBlur = (Boolean) textResult.get("isBlur");
+                    Double textConfidence = (Double) textResult.get("textConfidence");
+                    Integer wordCount = (Integer) textResult.get("wordCount");
+                    Integer readableWords = (Integer) textResult.get("readableWords");
+                    
+                    
+                    if (isBlur != null) {
+                        double blurConfidence = isBlur ? 1.0 : 0.0;
+                        return blurConfidence;
+                    } else {
+                    }
+                } else {
+                }
+            } catch (Exception e) {
+            }
+        }
+        
+        // Fallback to TFLite model
+        return detectBlurWithTFLite(bitmap);
+    }
+
+    /**
+     * Detect blur in image using TFLite model only
+     * @param bitmap Input image bitmap
+     * @return Blur confidence score (0.0 = sharp, 1.0 = very blurry)
+     */
+    public double detectBlurWithTFLite(Bitmap bitmap) {
         if (!isInitialized || tflite == null) {
-            Log.w(TAG, "TFLite model not initialized, falling back to Laplacian");
-            return calculateLaplacianBlurScore(bitmap);
+            double laplacianScore = calculateLaplacianBlurScore(bitmap);
+            return laplacianScore;
         }
+        
 
         try {
             // Use the original bitmap directly (no image enhancement)
@@ -158,11 +204,11 @@ public class BlurDetectionHelper {
             // Determine if image is blurry using TFLite confidence
             boolean isBlur = (blurConfidence >= 0.99 || sharpConfidence < 0.1);
             
+            
             // Return 1.0 for blur, 0.0 for sharp (to maintain double return type)
             return isBlur ? 1.0 : 0.0;
             
         } catch (Exception e) {
-            Log.e(TAG, "Error during TFLite inference: " + e.getMessage(), e);
             // Fallback to Laplacian algorithm
             double laplacianScore = calculateLaplacianBlurScore(bitmap);
             boolean isBlur = laplacianScore < 150;
@@ -294,24 +340,82 @@ public class BlurDetectionHelper {
     }
 
     /**
-     * Detect blur with detailed confidence scores
+     * Detect blur with detailed confidence scores using hybrid approach
      * @param bitmap Input image bitmap
-     * @return Map with isBlur, blurConfidence, and sharpConfidence
+     * @return Map with comprehensive blur detection results
      */
     public java.util.Map<String, Object> detectBlurWithConfidence(Bitmap bitmap) {
         java.util.Map<String, Object> result = new java.util.HashMap<>();
         
+        // Try text recognition first if enabled
+        if (useTextRecognition && textBlurHelper != null && textBlurHelper.isInitialized()) {
+            try {
+                java.util.Map<String, Object> textResult = textBlurHelper.detectBlurWithConfidence(bitmap);
+                Boolean hasText = (Boolean) textResult.get("hasText");
+                
+                if (hasText != null && hasText) {
+                    // Image contains text, use text recognition result
+                    Boolean isBlur = (Boolean) textResult.get("isBlur");
+                    Double textConfidence = (Double) textResult.get("textConfidence");
+                    
+                    result.put("method", "text_recognition");
+                    result.put("isBlur", isBlur);
+                    result.put("textConfidence", textConfidence);
+                    result.put("wordCount", textResult.get("wordCount"));
+                    result.put("readableWords", textResult.get("readableWords"));
+                    result.put("hasText", true);
+                    result.put("boundingBoxes", textResult.get("boundingBoxes"));
+                    
+                    // Set blur/sharp confidence based on text recognition result
+                    if (isBlur != null && textConfidence != null) {
+                        if (isBlur) {
+                            // Image is blurry - high blur confidence, low sharp confidence
+                            result.put("blurConfidence", 1.0);
+                            result.put("sharpConfidence", 0.0);
+                        } else {
+                            // Image is sharp - low blur confidence, high sharp confidence
+                            result.put("blurConfidence", 1.0 - textConfidence);
+                            result.put("sharpConfidence", textConfidence);
+                        }
+                    } else {
+                        // Default values if confidence not available
+                        result.put("blurConfidence", isBlur != null && isBlur ? 1.0 : 0.0);
+                        result.put("sharpConfidence", isBlur != null && !isBlur ? 1.0 : 0.0);
+                    }
+                    
+                    
+                    return result;
+                }
+            } catch (Exception e) {
+            }
+        }
+        
+        // Fallback to TFLite model
+        return detectBlurWithTFLiteConfidence(bitmap);
+    }
+
+    /**
+     * Detect blur with detailed confidence scores using TFLite only
+     * @param bitmap Input image bitmap
+     * @return Map with isBlur, blurConfidence, and sharpConfidence
+     */
+    public java.util.Map<String, Object> detectBlurWithTFLiteConfidence(Bitmap bitmap) {
+        java.util.Map<String, Object> result = new java.util.HashMap<>();
+        
         if (!isInitialized || tflite == null) {
-            Log.w(TAG, "TFLite model not initialized, falling back to Laplacian");
             double laplacianScore = calculateLaplacianBlurScore(bitmap);
             boolean isBlur = laplacianScore < 150;
             double normalizedScore = Math.max(0.0, Math.min(1.0, laplacianScore / 300.0));
             double sharpConfidence = normalizedScore;
             double blurConfidence = 1.0 - normalizedScore;
             
+            result.put("method", "laplacian");
             result.put("isBlur", isBlur);
             result.put("blurConfidence", blurConfidence);
             result.put("sharpConfidence", sharpConfidence);
+            result.put("laplacianScore", laplacianScore);
+            result.put("hasText", false);
+            result.put("boundingBoxes", new java.util.ArrayList<>());
             return result;
         }
 
@@ -350,16 +454,14 @@ public class BlurDetectionHelper {
             // Determine if image is blurry using TFLite confidence
             boolean isBlur = (blurConfidence >= 0.99 || sharpConfidence < 0.1);
             
-            Log.d(TAG, String.format("TFLite Blur Detection with Confidence - Blur: %.6f, Sharp: %.6f, Label: %s",
-                    blurConfidence, sharpConfidence, isBlur ? "blur" : "sharp"));
             
             result.put("isBlur", isBlur);
             result.put("blurConfidence", blurConfidence);
             result.put("sharpConfidence", sharpConfidence);
+            result.put("boundingBoxes", new java.util.ArrayList<>());
             return result;
             
         } catch (Exception e) {
-            Log.e(TAG, "Error during TFLite inference: " + e.getMessage(), e);
             // Fallback to Laplacian algorithm
             double laplacianScore = calculateLaplacianBlurScore(bitmap);
             boolean isBlur = laplacianScore < 150;
@@ -370,6 +472,7 @@ public class BlurDetectionHelper {
             result.put("isBlur", isBlur);
             result.put("blurConfidence", blurConfidence);
             result.put("sharpConfidence", sharpConfidence);
+            result.put("boundingBoxes", new java.util.ArrayList<>());
             return result;
         }
     }
@@ -395,6 +498,40 @@ public class BlurDetectionHelper {
         return isBlurry(bitmap) ? 100.0 : 0.0;
     }
 
+    /**
+     * Enable or disable text recognition for blur detection
+     * @param enable true to enable text recognition, false to use only TFLite
+     */
+    public void setTextRecognitionEnabled(boolean enable) {
+        this.useTextRecognition = enable;
+    }
+
+    /**
+     * Enable or disable dictionary check in text recognition
+     * @param enable true to enable dictionary check
+     */
+    public void setDictionaryCheckEnabled(boolean enable) {
+        if (textBlurHelper != null) {
+            textBlurHelper.setDictionaryCheckEnabled(enable);
+        }
+    }
+
+    /**
+     * Check if text recognition is enabled
+     * @return true if text recognition is enabled
+     */
+    public boolean isTextRecognitionEnabled() {
+        return useTextRecognition;
+    }
+
+    /**
+     * Get text recognition helper instance
+     * @return TextRecognitionBlurHelper instance
+     */
+    public TextRecognitionBlurHelper getTextBlurHelper() {
+        return textBlurHelper;
+    }
+
     /**
      * Clean up resources
      */
@@ -403,6 +540,10 @@ public class BlurDetectionHelper {
             tflite.close();
             tflite = null;
         }
+        if (textBlurHelper != null) {
+            textBlurHelper.close();
+            textBlurHelper = null;
+        }
         isInitialized = false;
     }
 

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

@@ -125,7 +125,6 @@ public class CameraPreviewPlugin extends Plugin {
                 desiredJpegQuality = call.getInt("quality");
                 // Ensure quality is within valid range
                 desiredJpegQuality = Math.max(1, Math.min(100, desiredJpegQuality));
-                Log.d("Camera", "Initialized with JPEG quality: " + desiredJpegQuality);
             }
 
             previewView = new PreviewView(getContext());
@@ -144,7 +143,6 @@ public class CameraPreviewPlugin extends Plugin {
             // Initialize TFLite blur detection helper
             blurDetectionHelper = new BlurDetectionHelper();
             boolean tfliteInitialized = blurDetectionHelper.initialize(getContext());
-            Log.d("Camera", "TFLite blur detection initialized: " + tfliteInitialized);
             
             cameraProviderFuture.addListener(() -> {
             try {
@@ -153,7 +151,6 @@ public class CameraPreviewPlugin extends Plugin {
                 .requireLensFacing(CameraSelector.LENS_FACING_BACK).build();
                 // Auto-optimize for photo capture on initialization with specified quality
                 setupUseCases(false); // Always use photo-optimized mode
-                Log.d("Camera", "Initialized with photo capture optimization and quality: " + desiredJpegQuality);
                 call.resolve();
             } catch (ExecutionException | InterruptedException e) {
                 e.printStackTrace();
@@ -172,10 +169,9 @@ public class CameraPreviewPlugin extends Plugin {
         Preview.Builder previewBuilder = new Preview.Builder();
         if (resolution != null) {
         previewBuilder.setTargetResolution(resolution);
-        Log.d("Camera", "Using optimal resolution: " + resolution.getWidth() + "x" + resolution.getHeight());
         } else {
-        // Fallback: let CameraX choose the best resolution automatically
-        Log.d("Camera", "Using CameraX auto-resolution selection");
+            // Fallback: let CameraX choose the best resolution automatically
+            Log.d("Camera", "Using CameraX auto-resolution selection");
         }
         preview = previewBuilder.build();
         preview.setSurfaceProvider(previewView.getSurfaceProvider());
@@ -183,7 +179,7 @@ public class CameraPreviewPlugin extends Plugin {
         // Enhanced ImageAnalysis setup
         ImageAnalysis.Builder imageAnalysisBuilder = new ImageAnalysis.Builder();
         if (resolution != null) {
-        imageAnalysisBuilder.setTargetResolution(resolution);
+            imageAnalysisBuilder.setTargetResolution(resolution);
         }
         imageAnalysisBuilder.setBackpressureStrategy(ImageAnalysis.STRATEGY_KEEP_ONLY_LATEST)
         .setImageQueueDepth(1); // Optimize for latest frame
@@ -224,9 +220,26 @@ public class CameraPreviewPlugin extends Plugin {
                         // Only detect blur if checkBlur option is true
                         boolean shouldCheckBlur = takeSnapshotCall.getBoolean("checkBlur", false);
                         if (shouldCheckBlur) {
-                            double confidence = calculateBlurConfidence(bitmap);
-                            result.put("confidence", confidence);
-                            Log.d("Camera", "Blur detection - Confidence: " + confidence);
+                            // Get blur detection result with bounding boxes in one call
+                            if (blurDetectionHelper != null && blurDetectionHelper.isInitialized()) {
+                                java.util.Map<String, Object> blurResult = blurDetectionHelper.detectBlurWithConfidence(bitmap);
+                                
+                                Double blurConfidence = (Double) blurResult.get("blurConfidence");
+                                if (blurConfidence != null) {
+                                    result.put("confidence", blurConfidence);
+                                }
+                                if (blurResult.containsKey("boundingBoxes")) {
+                                    Object boundingBoxesObj = blurResult.get("boundingBoxes");
+                                    result.put("boundingBoxes", boundingBoxesObj);
+                                } else {
+                                    result.put("boundingBoxes", new java.util.ArrayList<>());
+                                }
+                            } else {
+                                // Fallback to Laplacian algorithm
+                                double confidence = calculateBlurConfidence(bitmap);
+                                result.put("confidence", confidence);
+                                result.put("boundingBoxes", new java.util.ArrayList<>());
+                            }
                         } else {
                             Log.d("Camera", "Blur detection disabled for performance");
                         }
@@ -317,15 +330,13 @@ public class CameraPreviewPlugin extends Plugin {
         
         // Return the first (highest quality) option - CameraX will adapt if not supported
         Size optimalResolution = preferredResolutions[0];
-        Log.d("Camera", "Selected optimal resolution: " + optimalResolution.getWidth() + "x" + optimalResolution.getHeight());
         return optimalResolution;
         
         } catch (Exception e) {
-        Log.e("Camera", "Error selecting optimal resolution: " + e.getMessage());
+            Log.e("Camera", "Error selecting optimal resolution: " + e.getMessage());
         }
         
         // Fallback: return null to let CameraX auto-select
-        Log.d("Camera", "Using CameraX auto-resolution selection as fallback");
         return null;
     }
 
@@ -350,8 +361,6 @@ public class CameraPreviewPlugin extends Plugin {
                 
                 // 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());
             }
@@ -454,7 +463,6 @@ public class CameraPreviewPlugin extends Plugin {
                     useCaseGroup = null;
                     recorder = null;
                     currentRecording = null;
-                    Log.d("Camera", "Camera stopped and all references cleared.");
                     call.resolve();
                 } catch (Exception e) {
                     call.reject(e.getMessage());
@@ -660,7 +668,6 @@ public class CameraPreviewPlugin extends Plugin {
 
                         // 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
@@ -809,7 +816,6 @@ public class CameraPreviewPlugin extends Plugin {
                                             .build();
                                         
                                         camera.getCameraControl().startFocusAndMetering(adaptiveAction);
-                                        Log.d("Camera", "Adaptive focus at point: " + (currentPointIndex + 1));
                                     }
                                 } catch (Exception e) {
                                     Log.d("Camera", "Adaptive focus failed: " + e.getMessage());
@@ -1134,7 +1140,6 @@ public class CameraPreviewPlugin extends Plugin {
                                     if (bitmap != null) {
                                         double confidence = calculateBlurConfidence(bitmap);
                                         result.put("confidence", confidence);
-                                        Log.d("Camera", "Blur detection - Confidence: " + confidence);
                                     }
                                 }
                                 result.put("path", file.getAbsolutePath());
@@ -1193,9 +1198,7 @@ public class CameraPreviewPlugin extends Plugin {
                     Consumer<VideoRecordEvent> captureListener = new Consumer<VideoRecordEvent>() {
                         @Override
                         public void accept(VideoRecordEvent videoRecordEvent) {
-                            Log.d("Camera",videoRecordEvent.toString());
                             if (videoRecordEvent instanceof VideoRecordEvent.Finalize) {
-                                Log.d("Camera","finalize");
                                 Uri uri = ((VideoRecordEvent.Finalize) videoRecordEvent).getOutputResults().getOutputUri();
                                 String path = uri.getPath();
 
@@ -1308,7 +1311,6 @@ public class CameraPreviewPlugin extends Plugin {
             useCaseGroup = null;
             recorder = null;
             currentRecording = null;
-            Log.d("Camera", "handleOnPause: Camera stopped and references cleared.");
         }
         
         // Clean up TFLite resources
@@ -1341,7 +1343,6 @@ public class CameraPreviewPlugin extends Plugin {
     public void requestCameraPermission(PluginCall call) {
         boolean hasCameraPerms = getPermissionState(CAMERA) == PermissionState.GRANTED;
         if (hasCameraPerms == false) {
-            Log.d("Camera","no camera permission. request permission.");
             String[] aliases = new String[] { CAMERA };
             requestPermissionForAliases(aliases, call, "cameraPermissionsCallback");
         }else{
@@ -1363,7 +1364,6 @@ public class CameraPreviewPlugin extends Plugin {
     public void requestMicroPhonePermission(PluginCall call) {
         boolean hasCameraPerms = getPermissionState(MICROPHONE) == PermissionState.GRANTED;
         if (hasCameraPerms == false) {
-            Log.d("Camera","no microphone permission. request permission.");
             String[] aliases = new String[] { MICROPHONE };
             requestPermissionForAliases(aliases, call, "microphonePermissionsCallback");
         }else{
@@ -1473,8 +1473,19 @@ public class CameraPreviewPlugin extends Plugin {
         // Use TFLite model if available for detailed confidence
         if (blurDetectionHelper != null && blurDetectionHelper.isInitialized()) {
             java.util.Map<String, Object> result = blurDetectionHelper.detectBlurWithConfidence(bitmap);
+            Boolean isBlur = (Boolean) result.get("isBlur");
             Double blurConfidence = (Double) result.get("blurConfidence");
-            return blurConfidence != null ? blurConfidence : 0.0;
+            Double sharpConfidence = (Double) result.get("sharpConfidence");
+            
+            // Return the actual blurConfidence value for more nuanced results
+            if (blurConfidence != null) {
+                return blurConfidence;
+            } else if (isBlur != null) {
+                // Fallback to boolean if confidence not available
+                return isBlur ? 1.0 : 0.0;
+            } else {
+                return 0.0;
+            }
         } else {
             // Fallback to Laplacian algorithm with confidence calculation
             double laplacianScore = calculateLaplacianBlurScore(bitmap);
@@ -1612,7 +1623,6 @@ public class CameraPreviewPlugin extends Plugin {
                                             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");
@@ -1665,7 +1675,6 @@ public class CameraPreviewPlugin extends Plugin {
                                             .build();
                                         
                                         camera.getCameraControl().startFocusAndMetering(maintainAction);
-                                        Log.d("Camera", "Maintaining focus at tapped point");
                                     }
                                 } catch (Exception e) {
                                     Log.d("Camera", "Focus maintenance failed: " + e.getMessage());