capacitor-plugin-camera-forked 3.0.103 → 3.0.111

package/CapacitorPluginCameraForked.podspec

@@ -11,8 +11,11 @@ Pod::Spec.new do |s|
   s.author = package['author']
   s.source = { :git => package['repository']['url'], :tag => s.version.to_s }
   s.source_files = 'ios/Plugin/**/*.{swift,h,m,c,cc,mm,cpp}'
+  s.resources = ['ios/Plugin/*.tflite']
   s.ios.deployment_target  = '13.0'
   s.dependency 'Capacitor'
-  s.dependency 'TensorFlowLiteSwift'
+  s.dependency 'TensorFlowLiteSwift', '~> 2.17.0'
+  s.dependency 'TensorFlowLiteC', '~> 2.17.0'
+  s.static_framework = true
   s.swift_version = '5.1'
 end

package/README.md

@@ -105,6 +105,7 @@ document.documentElement.style.setProperty('--ion-background-color', 'transparen
 * [`startCamera()`](#startcamera)
 * [`stopCamera()`](#stopcamera)
 * [`takeSnapshot(...)`](#takesnapshot)
+* [`detectBlur(...)`](#detectblur)
 * [`saveFrame()`](#saveframe)
 * [`takeSnapshot2(...)`](#takesnapshot2)
 * [`takePhoto(...)`](#takephoto)
@@ -289,7 +290,7 @@ stopCamera() => Promise<void>
 ### takeSnapshot(...)
 
 ```typescript
-takeSnapshot(options: { quality?: number; checkBlur?: boolean; }) => Promise<{ base64: string; blurScore?: number; }>
+takeSnapshot(options: { quality?: number; checkBlur?: boolean; }) => Promise<{ base64: string; isBlur?: boolean; }>
 ```
 
 take a snapshot as base64.
@@ -298,7 +299,24 @@ take a snapshot as base64.
 | ------------- | ------------------------------------------------------- |
 | **`options`** | <code>{ quality?: number; checkBlur?: boolean; }</code> |
 
-**Returns:** <code>Promise&lt;{ base64: string; blurScore?: number; }&gt;</code>
+**Returns:** <code>Promise&lt;{ base64: string; isBlur?: boolean; }&gt;</code>
+
+--------------------
+
+
+### detectBlur(...)
+
+```typescript
+detectBlur(options: { image: string; }) => Promise<{ isBlur: boolean; blurConfidence: number; sharpConfidence: number; }>
+```
+
+analyze an image for blur detection with detailed confidence scores.
+
+| Param         | Type                            |
+| ------------- | ------------------------------- |
+| **`options`** | <code>{ image: string; }</code> |
+
+**Returns:** <code>Promise&lt;{ isBlur: boolean; blurConfidence: number; sharpConfidence: number; }&gt;</code>
 
 --------------------
 
@@ -336,14 +354,14 @@ take a snapshot on to a canvas. Web Only
 ### takePhoto(...)
 
 ```typescript
-takePhoto(options: { pathToSave?: string; includeBase64?: boolean; }) => Promise<{ path?: string; base64?: string; blob?: Blob; blurScore?: number; }>
+takePhoto(options: { pathToSave?: string; includeBase64?: boolean; }) => Promise<{ path?: string; base64?: string; blob?: Blob; isBlur?: boolean; }>
 ```
 
 | Param         | Type                                                           |
 | ------------- | -------------------------------------------------------------- |
 | **`options`** | <code>{ pathToSave?: string; includeBase64?: boolean; }</code> |
 
-**Returns:** <code>Promise&lt;{ path?: string; base64?: string; blob?: any; blurScore?: number; }&gt;</code>
+**Returns:** <code>Promise&lt;{ path?: string; base64?: string; blob?: any; isBlur?: boolean; }&gt;</code>
 
 --------------------
 
@@ -520,9 +538,34 @@ measuredByPercentage: 0 in pixel, 1 in percent
 
 ## Blur Detection
 
-The plugin includes blur detection capabilities using the Laplacian variance algorithm, providing consistent results across all platforms.
+The plugin includes blur detection capabilities using TensorFlow Lite models with Laplacian variance fallback, providing consistent results across all platforms.
+
+#### Analyze Existing Images
 
-#### Basic Usage
+Use the `detectBlur` method to analyze any base64 image with detailed confidence scores:
+
+```typescript
+// Analyze an existing image (base64 string or data URL)
+const result = await CameraPreview.detectBlur({
+  image: "data:image/jpeg;base64,/9j/4AAQSkZJRgABAQEASABIAAD..."
+  // or just the base64 string: "/9j/4AAQSkZJRgABAQEASABIAAD..."
+});
+
+console.log('Is Blurry:', result.isBlur);           // boolean: true/false
+console.log('Blur Confidence:', result.blurConfidence);   // 0.0-1.0 (higher = more blurry)  
+console.log('Sharp Confidence:', result.sharpConfidence); // 0.0-1.0 (higher = more sharp)
+
+// Use confidence scores for advanced logic
+if (result.blurConfidence > 0.7) {
+  console.log('High confidence this image is blurry');
+} else if (result.sharpConfidence > 0.8) {
+  console.log('High confidence this image is sharp');
+} else {
+  console.log('Uncertain blur status - manual review needed');
+}
+```
+
+#### Basic Usage (Capture + Detection)
 
 ```typescript
 // Take a snapshot with blur detection
@@ -562,8 +605,15 @@ const resultWithBlur = await CameraPreview.takeSnapshot({
 });
 ```
 
-#### Understanding Blur Scores
+#### Understanding Blur Results
+
+**New `detectBlur` Method (Recommended):**
+- Returns standardized **confidence scores** (0.0-1.0 range) across all platforms
+- `blurConfidence`: Higher values indicate more blur (>0.7 = likely blurry)
+- `sharpConfidence`: Higher values indicate more sharpness (>0.8 = likely sharp)  
+- `isBlur`: Simple boolean result based on confidence thresholds
 
+**Legacy `takeSnapshot` Method:**
 - **Higher values** = Sharper images
 - **Lower values** = Blurrier images
 - **Threshold guidelines**: 
@@ -571,6 +621,20 @@ const resultWithBlur = await CameraPreview.takeSnapshot({
   - Android/Web: Consider values below `50-100` as blurry
   - Adjust thresholds based on your specific quality requirements
 
+#### When to Use Which Method
+
+**Use `detectBlur` for:**
+- Analyzing already captured images
+- Batch processing multiple images  
+- Getting detailed confidence scores for advanced decision logic
+- Post-processing workflows
+- When you need consistent confidence values across platforms
+
+**Use `takeSnapshot` with `checkBlur: true` for:**
+- Real-time capture with immediate blur feedback
+- Simple blur detection during image capture
+- When you only need a basic blur/sharp indication
+
 #### Performance Impact
 
 | Platform | Without Blur Detection | With Blur Detection | Overhead |
@@ -581,8 +645,10 @@ const resultWithBlur = await CameraPreview.takeSnapshot({
 
 #### Implementation Notes
 
-- Uses Laplacian variance algorithm across all platforms
-- Pixel sampling for performance optimization
+- **TensorFlow Lite models** for advanced blur detection with high accuracy
+- **Laplacian variance fallback** when TFLite models unavailable
+- Pixel sampling for performance optimization  
 - Hardware acceleration on iOS with Core Image
 - Client-side threshold logic for maximum flexibility
 - Cross-platform algorithm consistency
+- **Dual API**: `takeSnapshot` for capture+detection, `detectBlur` for analyzing existing images

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

@@ -67,9 +67,8 @@ public class BlurDetectionHelper {
             // Try to use GPU acceleration if available
             try {
                 options.setUseXNNPACK(true);
-                Log.d(TAG, "Using XNNPACK acceleration");
             } catch (Exception e) {
-                Log.w(TAG, "XNNPACK not available, using CPU");
+                // XNNPACK not available, using CPU
             }
             
             tflite = new Interpreter(tfliteModel, options);
@@ -82,12 +81,8 @@ public class BlurDetectionHelper {
                     tflite.getOutputTensor(0).dataType()
             );
             
-            // Log tensor information and update INPUT_SIZE based on model
+            // Update INPUT_SIZE based on actual model input shape
             int[] inputShape = tflite.getInputTensor(0).shape();
-            Log.d(TAG, "Input tensor shape: " + java.util.Arrays.toString(inputShape));
-            Log.d(TAG, "Input tensor type: " + tflite.getInputTensor(0).dataType());
-            Log.d(TAG, "Output tensor shape: " + java.util.Arrays.toString(tflite.getOutputTensor(0).shape()));
-            Log.d(TAG, "Output tensor type: " + tflite.getOutputTensor(0).dataType());
             
             // Update INPUT_SIZE based on actual model input shape
             // Expected format: [batch, height, width, channels] or [batch, channels, height, width]
@@ -95,29 +90,23 @@ public class BlurDetectionHelper {
                 // Assume format is [batch, height, width, channels]
                 int modelInputSize = inputShape[1]; // height dimension
                 if (modelInputSize != INPUT_SIZE) {
-                    Log.w(TAG, "Model expects input size " + modelInputSize + " but code was configured for " + INPUT_SIZE);
                     INPUT_SIZE = modelInputSize;
-                    Log.i(TAG, "Updated INPUT_SIZE to " + INPUT_SIZE + " to match model");
                     
                     // Recreate image processor with correct size
                     imageProcessor = new ImageProcessor.Builder()
                         .add(new ResizeWithCropOrPadOp(INPUT_SIZE, INPUT_SIZE))
                         .add(new ResizeOp(INPUT_SIZE, INPUT_SIZE, ResizeOp.ResizeMethod.BILINEAR))
                         .build();
-                    Log.d(TAG, "Recreated ImageProcessor with INPUT_SIZE = " + INPUT_SIZE);
                 }
             }
             
             isInitialized = true;
-            Log.d(TAG, "TFLite blur detection model initialized successfully");
             return true;
             
         } catch (IOException e) {
-            Log.e(TAG, "Error loading TFLite model: " + e.getMessage());
             isInitialized = false;
             return false;
         } catch (Exception e) {
-            Log.e(TAG, "Error initializing TFLite model: " + e.getMessage());
             isInitialized = false;
             return false;
         }
@@ -142,27 +131,17 @@ public class BlurDetectionHelper {
             inputImageBuffer.load(processedBitmap);
             inputImageBuffer = imageProcessor.process(inputImageBuffer);
 
-            // Debug: Log buffer info
+            // Get tensor buffer
             ByteBuffer tensorBuffer = inputImageBuffer.getBuffer();
-            Log.d(TAG, "TensorImage buffer size: " + tensorBuffer.remaining() + " bytes");
-            Log.d(TAG, "TensorImage buffer capacity: " + tensorBuffer.capacity() + " bytes");
-            Log.d(TAG, "TensorImage data type: " + inputImageBuffer.getDataType());
-            Log.d(TAG, "Model input tensor type: " + tflite.getInputTensor(0).dataType());
-            Log.d(TAG, "Expected buffer size: " + (INPUT_SIZE * INPUT_SIZE * 3 * 4) + " bytes");
 
             // Check if we need normalization based on data types
             ByteBuffer inferenceBuffer;
             if (inputImageBuffer.getDataType() == DataType.UINT8 && tflite.getInputTensor(0).dataType() == DataType.FLOAT32) {
-                Log.d(TAG, "Converting UINT8 to FLOAT32 with normalization");
                 inferenceBuffer = normalizeImageBuffer(tensorBuffer);
-                Log.d(TAG, "Normalized buffer size: " + inferenceBuffer.remaining() + " bytes");
             } else if (inputImageBuffer.getDataType() == DataType.FLOAT32) {
-                Log.d(TAG, "Using FLOAT32 buffer directly (may need normalization check)");
                 // Check if values are in [0,1] range or [0,255] range
                 inferenceBuffer = checkAndNormalizeFloat32Buffer(tensorBuffer);
-                Log.d(TAG, "Final buffer size: " + inferenceBuffer.remaining() + " bytes");
             } else {
-                Log.d(TAG, "Using buffer directly");
                 inferenceBuffer = tensorBuffer;
             }
 
@@ -172,24 +151,12 @@ public class BlurDetectionHelper {
             // Get output probabilities
             float[] probabilities = outputProbabilityBuffer.getFloatArray();
             
-            // Log probabilities for debugging
-            Log.d(TAG, "Output probabilities length: " + probabilities.length);
-            for (int i = 0; i < probabilities.length && i < 5; i++) {
-                Log.d(TAG, "probabilities[" + i + "] = " + probabilities[i]);
-            }
-            
             // probabilities[0] = blur probability, probabilities[1] = sharp probability
             double blurConfidence = probabilities.length > 0 ? probabilities[0] : 0.0;
             double sharpConfidence = probabilities.length > 1 ? probabilities[1] : 0.0;
 
-            // Fallback to Laplacian algorithm
-            double laplacianScore = calculateLaplacianBlurScore(bitmap);
-            
-            // Determine if image is blurry TFLite confidence or Laplacian score < 50
-            boolean isBlur = (blurConfidence > sharpConfidence && blurConfidence > 0.99) || (laplacianScore < 50 && sharpConfidence < 0.1);
-            
-            Log.d(TAG, String.format("TFLite Blur Detection - Blur: %.6f, Sharp: %.6f, Label: %s", 
-                    blurConfidence, sharpConfidence, isBlur ? "blur" : "sharp"));
+            // 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;
@@ -199,16 +166,10 @@ public class BlurDetectionHelper {
             // Fallback to Laplacian algorithm
             double laplacianScore = calculateLaplacianBlurScore(bitmap);
             boolean isBlur = laplacianScore < 150;
-            Log.d(TAG, String.format("Laplacian Fallback - Score: %.2f, Label: %s", 
-                    laplacianScore, isBlur ? "blur" : "sharp"));
             return isBlur ? 1.0 : 0.0;
         }
     }
 
-
-
-
-
     /**
      * Check if float32 buffer needs normalization and normalize if needed
      * @param float32Buffer Input buffer with float32 pixel values
@@ -227,14 +188,10 @@ public class BlurDetectionHelper {
             maxSample = Math.max(maxSample, value);
         }
         
-        Log.d(TAG, "Sample max value from buffer: " + maxSample);
-        
         // If max value is > 1.5, assume it's in [0,255] range and needs normalization
         if (maxSample > 1.5f) {
-            Log.d(TAG, "Buffer appears to be in [0,255] range, normalizing to [0,1]");
             return normalizeFloat32Buffer(float32Buffer);
         } else {
-            Log.d(TAG, "Buffer appears to be already normalized [0,1]");
             float32Buffer.rewind();
             return float32Buffer;
         }
@@ -254,8 +211,6 @@ public class BlurDetectionHelper {
          float32Buffer.rewind();
          FloatBuffer sourceFloats = float32Buffer.asFloatBuffer();
          
-         Log.d(TAG, "Normalizing float32 buffer: " + sourceFloats.remaining() + " values, target: " + pixelCount);
-         
          while (sourceFloats.hasRemaining() && normalizedFloats.hasRemaining()) {
              float pixelValue = sourceFloats.get();
              float normalizedValue = pixelValue / 255.0f;
@@ -263,7 +218,6 @@ public class BlurDetectionHelper {
          }
          
          normalizedBuffer.rewind();
-         Log.d(TAG, "Normalized buffer created with " + normalizedBuffer.remaining() + " bytes");
          return normalizedBuffer;
      }
 
@@ -282,8 +236,6 @@ public class BlurDetectionHelper {
          // Reset uint8 buffer position
          uint8Buffer.rewind();
          
-         Log.d(TAG, "Converting UINT8 to FLOAT32: " + uint8Buffer.remaining() + " uint8 values to " + pixelCount + " float values");
-         
          // Convert each uint8 pixel to normalized float32
          while (uint8Buffer.hasRemaining() && floatBuffer.hasRemaining()) {
              int pixelValue = uint8Buffer.get() & 0xFF; // Convert to unsigned int
@@ -292,7 +244,6 @@ public class BlurDetectionHelper {
          }
          
          float32Buffer.rewind();
-         Log.d(TAG, "UINT8 to FLOAT32 conversion complete, buffer size: " + float32Buffer.remaining() + " bytes");
          return float32Buffer;
      }
 
@@ -342,6 +293,87 @@ public class BlurDetectionHelper {
         return count > 0 ? variance / count : 0.0;
     }
 
+    /**
+     * Detect blur with detailed confidence scores
+     * @param bitmap Input image bitmap
+     * @return Map with isBlur, blurConfidence, and sharpConfidence
+     */
+    public java.util.Map<String, Object> detectBlurWithConfidence(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("isBlur", isBlur);
+            result.put("blurConfidence", blurConfidence);
+            result.put("sharpConfidence", sharpConfidence);
+            return result;
+        }
+
+        try {
+            // Use the original bitmap directly (no image enhancement)
+            Bitmap processedBitmap = bitmap;
+            
+            // Preprocess image for model (resize and potential enhancement)
+            inputImageBuffer.load(processedBitmap);
+            inputImageBuffer = imageProcessor.process(inputImageBuffer);
+
+            // Get tensor buffer
+            ByteBuffer tensorBuffer = inputImageBuffer.getBuffer();
+
+            // Check if we need normalization based on data types
+            ByteBuffer inferenceBuffer;
+            if (inputImageBuffer.getDataType() == DataType.UINT8 && tflite.getInputTensor(0).dataType() == DataType.FLOAT32) {
+                inferenceBuffer = normalizeImageBuffer(tensorBuffer);
+            } else if (inputImageBuffer.getDataType() == DataType.FLOAT32) {
+                // Check if values are in [0,1] range or [0,255] range
+                inferenceBuffer = checkAndNormalizeFloat32Buffer(tensorBuffer);
+            } else {
+                inferenceBuffer = tensorBuffer;
+            }
+
+            // Run inference
+            tflite.run(inferenceBuffer, outputProbabilityBuffer.getBuffer().rewind());
+
+            // Get output probabilities
+            float[] probabilities = outputProbabilityBuffer.getFloatArray();
+            
+            // probabilities[0] = blur probability, probabilities[1] = sharp probability
+            double blurConfidence = probabilities.length > 0 ? probabilities[0] : 0.0;
+            double sharpConfidence = probabilities.length > 1 ? probabilities[1] : 0.0;
+
+            // 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);
+            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;
+            double normalizedScore = Math.max(0.0, Math.min(1.0, laplacianScore / 300.0));
+            double sharpConfidence = normalizedScore;
+            double blurConfidence = 1.0 - normalizedScore;
+            
+            result.put("isBlur", isBlur);
+            result.put("blurConfidence", blurConfidence);
+            result.put("sharpConfidence", sharpConfidence);
+            return result;
+        }
+    }
+
     /**
      * Check if image is blurry
      * @param bitmap Input image
@@ -372,7 +404,6 @@ public class BlurDetectionHelper {
             tflite = null;
         }
         isInitialized = false;
-        Log.d(TAG, "TFLite blur detection model closed");
     }
 
     /**

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

@@ -7,6 +7,7 @@ import android.content.pm.PackageManager;
 import android.content.res.Configuration;
 import android.content.res.Resources;
 import android.graphics.Bitmap;
+import android.graphics.BitmapFactory;
 import android.graphics.Color;
 import android.graphics.drawable.Drawable;
 import android.net.Uri;
@@ -1372,6 +1373,60 @@ public class CameraPreviewPlugin extends Plugin {
         }
     }
 
+    @PluginMethod
+    public void detectBlur(PluginCall call) {
+        String imageString = call.getString("image");
+        if (imageString == null) {
+            call.reject("Image parameter is required");
+            return;
+        }
+        
+        try {
+            // Convert base64 string to Bitmap
+            String base64String = imageString;
+            if (imageString.startsWith("data:")) {
+                base64String = imageString.substring(imageString.indexOf(",") + 1);
+            }
+            
+            byte[] decodedBytes = Base64.decode(base64String, Base64.DEFAULT);
+            Bitmap bitmap = BitmapFactory.decodeByteArray(decodedBytes, 0, decodedBytes.length);
+            
+            if (bitmap == null) {
+                call.reject("Invalid image data");
+                return;
+            }
+            
+            // Use the new confidence detection method
+            if (blurDetectionHelper != null && blurDetectionHelper.isInitialized()) {
+                java.util.Map<String, Object> result = blurDetectionHelper.detectBlurWithConfidence(bitmap);
+                
+                JSObject jsResult = new JSObject();
+                jsResult.put("isBlur", result.get("isBlur"));
+                jsResult.put("blurConfidence", result.get("blurConfidence"));
+                jsResult.put("sharpConfidence", result.get("sharpConfidence"));
+                
+                call.resolve(jsResult);
+            } else {
+                // Fallback to Laplacian algorithm with confidence scores
+                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;
+                
+                JSObject result = new JSObject();
+                result.put("isBlur", isBlur);
+                result.put("blurConfidence", blurConfidence);
+                result.put("sharpConfidence", sharpConfidence);
+                
+                call.resolve(result);
+            }
+            
+        } catch (Exception e) {
+            call.reject("Failed to process image: " + e.getMessage());
+        }
+    }
+
     @PluginMethod
     public void getOrientation(PluginCall call) {
         int orientation = getContext().getResources().getConfiguration().orientation;

package/dist/docs.json

@@ -189,7 +189,7 @@
       },
       {
         "name": "takeSnapshot",
-        "signature": "(options: { quality?: number; checkBlur?: boolean; }) => Promise<{ base64: string; blurScore?: number; }>",
+        "signature": "(options: { quality?: number; checkBlur?: boolean; }) => Promise<{ base64: string; isBlur?: boolean; }>",
         "parameters": [
           {
             "name": "options",
@@ -197,12 +197,28 @@
             "type": "{ quality?: number | undefined; checkBlur?: boolean | undefined; }"
           }
         ],
-        "returns": "Promise<{ base64: string; blurScore?: number | undefined; }>",
+        "returns": "Promise<{ base64: string; isBlur?: boolean | undefined; }>",
         "tags": [],
         "docs": "take a snapshot as base64.",
         "complexTypes": [],
         "slug": "takesnapshot"
       },
+      {
+        "name": "detectBlur",
+        "signature": "(options: { image: string; }) => Promise<{ isBlur: boolean; blurConfidence: number; sharpConfidence: number; }>",
+        "parameters": [
+          {
+            "name": "options",
+            "docs": "",
+            "type": "{ image: string; }"
+          }
+        ],
+        "returns": "Promise<{ isBlur: boolean; blurConfidence: number; sharpConfidence: number; }>",
+        "tags": [],
+        "docs": "analyze an image for blur detection with detailed confidence scores.",
+        "complexTypes": [],
+        "slug": "detectblur"
+      },
       {
         "name": "saveFrame",
         "signature": "() => Promise<{ success: boolean; }>",
@@ -233,7 +249,7 @@
       },
       {
         "name": "takePhoto",
-        "signature": "(options: { pathToSave?: string; includeBase64?: boolean; }) => Promise<{ path?: string; base64?: string; blob?: Blob; blurScore?: number; }>",
+        "signature": "(options: { pathToSave?: string; includeBase64?: boolean; }) => Promise<{ path?: string; base64?: string; blob?: Blob; isBlur?: boolean; }>",
         "parameters": [
           {
             "name": "options",
@@ -241,7 +257,7 @@
             "type": "{ pathToSave?: string | undefined; includeBase64?: boolean | undefined; }"
           }
         ],
-        "returns": "Promise<{ path?: string | undefined; base64?: string | undefined; blob?: any; blurScore?: number | undefined; }>",
+        "returns": "Promise<{ path?: string | undefined; base64?: string | undefined; blob?: any; isBlur?: boolean | undefined; }>",
         "tags": [],
         "docs": "",
         "complexTypes": [

package/dist/esm/definitions.d.ts

@@ -46,7 +46,17 @@ export interface CameraPreviewPlugin {
         checkBlur?: boolean;
     }): Promise<{
         base64: string;
-        blurScore?: number;
+        isBlur?: boolean;
+    }>;
+    /**
+    * analyze an image for blur detection with detailed confidence scores.
+    */
+    detectBlur(options: {
+        image: string;
+    }): Promise<{
+        isBlur: boolean;
+        blurConfidence: number;
+        sharpConfidence: number;
     }>;
     /**
     * save a frame internally. Android and iOS only.
@@ -70,7 +80,7 @@ export interface CameraPreviewPlugin {
         path?: string;
         base64?: string;
         blob?: Blob;
-        blurScore?: number;
+        isBlur?: boolean;
     }>;
     toggleTorch(options: {
         on: boolean;

package/dist/esm/definitions.js.map

@@ -1 +1 @@
-{"version":3,"file":"definitions.js","sourceRoot":"","sources":["../../src/definitions.ts"],"names":[],"mappings":"AAuEA,MAAM,CAAN,IAAY,cAOX;AAPD,WAAY,cAAc;IACxB,yEAAmB,CAAA;IACnB,yEAAmB,CAAA;IACnB,yEAAmB,CAAA;IACnB,2EAAoB,CAAA;IACpB,qEAAiB,CAAA;IACjB,qEAAiB,CAAA;AACnB,CAAC,EAPW,cAAc,KAAd,cAAc,QAOzB","sourcesContent":["import { PluginListenerHandle } from \"@capacitor/core\";\n\nexport interface CameraPreviewPlugin {\n  initialize(options?: { quality?: number }): Promise<void>;\n  getResolution(): Promise<{resolution: string}>;\n  setResolution(options: {resolution: number}): Promise<void>;\n  getAllCameras(): Promise<{cameras: string[]}>;\n  getSelectedCamera(): Promise<{selectedCamera: string}>;\n  selectCamera(options: {cameraID: string; }): Promise<void>;\n  setScanRegion(options: {region:ScanRegion}): Promise<void>;\n  setZoom(options: {factor: number}): Promise<void>;\n  setFocus(options: {x: number, y: number}): Promise<void>;\n  /**\n  * Web Only\n  */\n  setDefaultUIElementURL(url:string): Promise<void>;\n  /**\n  * Web Only\n  */\n  setElement(ele:HTMLElement): Promise<void>;\n  startCamera(): Promise<void>;\n  stopCamera(): Promise<void>;\n  /**\n  * take a snapshot as base64.\n  */\n  takeSnapshot(options:{quality?:number, checkBlur?:boolean}): Promise<{base64:string, blurScore?: number}>;\n  /**\n  * save a frame internally. Android and iOS only.\n  */\n  saveFrame(): Promise<{success:boolean}>;\n  /**\n  * take a snapshot on to a canvas. Web Only\n  */\n  takeSnapshot2(options:{canvas:HTMLCanvasElement,maxLength?:number}): Promise<{scaleRatio?:number}>;\n  takePhoto(options: {pathToSave?:string,includeBase64?: boolean}): Promise<{path?:string,base64?:string,blob?:Blob, blurScore?: number}>;\n  toggleTorch(options: {on: boolean}): Promise<void>;\n  /**\n  * get the orientation of the device.\n  */\n  getOrientation(): Promise<{\"orientation\":\"PORTRAIT\"|\"LANDSCAPE\"}>;\n  startRecording(): Promise<void>;\n  stopRecording(options:{includeBase64?:boolean}): Promise<{path?:string,base64?:string,blob?:Blob}>;\n  setLayout(options: {top: string, left:string, width:string, height:string}): Promise<void>;\n  requestCameraPermission(): Promise<void>;\n  requestMicroPhonePermission(): Promise<void>;\n  isOpen():Promise<{isOpen:boolean}>;\n  addListener(\n    eventName: 'onPlayed',\n    listenerFunc: onPlayedListener,\n  ): Promise<PluginListenerHandle>;\n  addListener(\n    eventName: 'onOrientationChanged',\n    listenerFunc: onOrientationChangedListener,\n  ): Promise<PluginListenerHandle>;\n  removeAllListeners(): Promise<void>;\n}\n\nexport type onPlayedListener = (result:{resolution:string}) => void;\nexport type onOrientationChangedListener = () => void;\n\n/**\n * measuredByPercentage: 0 in pixel, 1 in percent\n */\nexport interface ScanRegion{\n  left: number;\n  top: number;\n  right: number;\n  bottom: number;\n  measuredByPercentage: number;\n}\n\nexport enum EnumResolution {\n  RESOLUTION_AUTO = 0,\n  RESOLUTION_480P = 1,\n  RESOLUTION_720P = 2,\n  RESOLUTION_1080P = 3,\n  RESOLUTION_2K = 4,\n  RESOLUTION_4K = 5\n}\n"]}
+{"version":3,"file":"definitions.js","sourceRoot":"","sources":["../../src/definitions.ts"],"names":[],"mappings":"AA2EA,MAAM,CAAN,IAAY,cAOX;AAPD,WAAY,cAAc;IACxB,yEAAmB,CAAA;IACnB,yEAAmB,CAAA;IACnB,yEAAmB,CAAA;IACnB,2EAAoB,CAAA;IACpB,qEAAiB,CAAA;IACjB,qEAAiB,CAAA;AACnB,CAAC,EAPW,cAAc,KAAd,cAAc,QAOzB","sourcesContent":["import { PluginListenerHandle } from \"@capacitor/core\";\n\nexport interface CameraPreviewPlugin {\n  initialize(options?: { quality?: number }): Promise<void>;\n  getResolution(): Promise<{resolution: string}>;\n  setResolution(options: {resolution: number}): Promise<void>;\n  getAllCameras(): Promise<{cameras: string[]}>;\n  getSelectedCamera(): Promise<{selectedCamera: string}>;\n  selectCamera(options: {cameraID: string; }): Promise<void>;\n  setScanRegion(options: {region:ScanRegion}): Promise<void>;\n  setZoom(options: {factor: number}): Promise<void>;\n  setFocus(options: {x: number, y: number}): Promise<void>;\n  /**\n  * Web Only\n  */\n  setDefaultUIElementURL(url:string): Promise<void>;\n  /**\n  * Web Only\n  */\n  setElement(ele:HTMLElement): Promise<void>;\n  startCamera(): Promise<void>;\n  stopCamera(): Promise<void>;\n  /**\n  * take a snapshot as base64.\n  */\n  takeSnapshot(options:{quality?:number, checkBlur?:boolean}): Promise<{base64:string, isBlur?: boolean}>;\n  /**\n  * analyze an image for blur detection with detailed confidence scores.\n  */\n  detectBlur(options:{image: string}): Promise<{isBlur: boolean, blurConfidence: number, sharpConfidence: number}>;\n  /**\n  * save a frame internally. Android and iOS only.\n  */\n  saveFrame(): Promise<{success:boolean}>;\n  /**\n  * take a snapshot on to a canvas. Web Only\n  */\n  takeSnapshot2(options:{canvas:HTMLCanvasElement,maxLength?:number}): Promise<{scaleRatio?:number}>;\n  takePhoto(options: {pathToSave?:string,includeBase64?: boolean}): Promise<{path?:string,base64?:string,blob?:Blob, isBlur?: boolean}>;\n  toggleTorch(options: {on: boolean}): Promise<void>;\n  /**\n  * get the orientation of the device.\n  */\n  getOrientation(): Promise<{\"orientation\":\"PORTRAIT\"|\"LANDSCAPE\"}>;\n  startRecording(): Promise<void>;\n  stopRecording(options:{includeBase64?:boolean}): Promise<{path?:string,base64?:string,blob?:Blob}>;\n  setLayout(options: {top: string, left:string, width:string, height:string}): Promise<void>;\n  requestCameraPermission(): Promise<void>;\n  requestMicroPhonePermission(): Promise<void>;\n  isOpen():Promise<{isOpen:boolean}>;\n  addListener(\n    eventName: 'onPlayed',\n    listenerFunc: onPlayedListener,\n  ): Promise<PluginListenerHandle>;\n  addListener(\n    eventName: 'onOrientationChanged',\n    listenerFunc: onOrientationChangedListener,\n  ): Promise<PluginListenerHandle>;\n  removeAllListeners(): Promise<void>;\n}\n\nexport type onPlayedListener = (result:{resolution:string}) => void;\nexport type onOrientationChangedListener = () => void;\n\n/**\n * measuredByPercentage: 0 in pixel, 1 in percent\n */\nexport interface ScanRegion{\n  left: number;\n  top: number;\n  right: number;\n  bottom: number;\n  measuredByPercentage: number;\n}\n\nexport enum EnumResolution {\n  RESOLUTION_AUTO = 0,\n  RESOLUTION_480P = 1,\n  RESOLUTION_720P = 2,\n  RESOLUTION_1080P = 3,\n  RESOLUTION_2K = 4,\n  RESOLUTION_4K = 5\n}\n"]}

package/dist/esm/web.d.ts

@@ -58,7 +58,14 @@ export declare class CameraPreviewWeb extends WebPlugin implements CameraPreview
         checkBlur?: boolean;
     }): Promise<{
         base64: string;
-        blurScore?: number;
+        isBlur?: boolean;
+    }>;
+    detectBlur(options: {
+        image: string;
+    }): Promise<{
+        isBlur: boolean;
+        blurConfidence: number;
+        sharpConfidence: number;
     }>;
     takeSnapshot2(options: {
         canvas: HTMLCanvasElement;