@capgo/camera-preview 8.3.8 → 8.4.1

package/android/src/main/java/app/capgo/capacitor/camera/preview/CameraXView.java

@@ -22,9 +22,11 @@ import android.hardware.camera2.CameraCharacteristics;
 import android.hardware.camera2.CameraManager;
 import android.hardware.camera2.CaptureRequest;
 import android.location.Location;
+import android.media.Image;
 import android.media.MediaScannerConnection;
 import android.os.Build;
 import android.os.Environment;
+import android.os.SystemClock;
 import android.util.Base64;
 import android.util.DisplayMetrics;
 import android.util.Log;
@@ -47,9 +49,11 @@ import androidx.camera.core.AspectRatio;
 import androidx.camera.core.Camera;
 import androidx.camera.core.CameraInfo;
 import androidx.camera.core.CameraSelector;
+import androidx.camera.core.ExperimentalGetImage;
 import androidx.camera.core.ExposureState;
 import androidx.camera.core.FocusMeteringAction;
 import androidx.camera.core.FocusMeteringResult;
+import androidx.camera.core.ImageAnalysis;
 import androidx.camera.core.ImageCapture;
 import androidx.camera.core.ImageCaptureException;
 import androidx.camera.core.ImageProxy;
@@ -83,6 +87,11 @@ import app.capgo.capacitor.camera.preview.model.CameraSessionConfiguration;
 import app.capgo.capacitor.camera.preview.model.LensInfo;
 import app.capgo.capacitor.camera.preview.model.ZoomFactors;
 import com.google.common.util.concurrent.ListenableFuture;
+import com.google.mlkit.vision.barcode.BarcodeScanner;
+import com.google.mlkit.vision.barcode.BarcodeScannerOptions;
+import com.google.mlkit.vision.barcode.BarcodeScanning;
+import com.google.mlkit.vision.barcode.common.Barcode;
+import com.google.mlkit.vision.common.InputImage;
 import java.io.ByteArrayInputStream;
 import java.io.ByteArrayOutputStream;
 import java.io.File;
@@ -104,6 +113,7 @@ import java.util.concurrent.Executor;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
 import java.util.concurrent.RejectedExecutionException;
+import org.json.JSONArray;
 import org.json.JSONObject;
 
 public class CameraXView implements LifecycleOwner, LifecycleObserver {
@@ -116,11 +126,18 @@ public class CameraXView implements LifecycleOwner, LifecycleObserver {
         void onPictureTakenError(String message);
         void onSampleTaken(String result);
         void onSampleTakenError(String message);
+        void onBarcodesScanned(JSONArray barcodes);
+        void onBarcodeScanError(String message);
         void onCameraStarted(int width, int height, int x, int y);
         void onCameraStartError(String message);
         void onCameraStopped(CameraXView source);
     }
 
+    public interface BarcodeScannerStartCallback {
+        void onStarted();
+        void onError(String message);
+    }
+
     public interface VideoRecordingCallback {
         void onSuccess(String filePath);
         void onError(String message);
@@ -130,6 +147,8 @@ public class CameraXView implements LifecycleOwner, LifecycleObserver {
     private Camera camera;
     private ImageCapture imageCapture;
     private ImageCapture sampleImageCapture;
+    private ImageAnalysis barcodeAnalysis;
+    private BarcodeScanner barcodeScanner;
     private VideoCapture<Recorder> videoCapture;
     private Recording currentRecording;
     private File currentVideoFile;
@@ -168,6 +187,10 @@ public class CameraXView implements LifecycleOwner, LifecycleObserver {
     private volatile boolean isCapturingPhoto = false;
     private volatile boolean stopRequested = false;
     private volatile boolean previewDetachedOnDeferredStop = false;
+    private volatile boolean isBarcodeScannerActive = false;
+    private volatile boolean isBarcodeFrameProcessing = false;
+    private volatile long lastBarcodeFrameAtMs = 0L;
+    private volatile long barcodeDetectionIntervalMs = 500L;
 
     // Operation coordination (acts like a semaphore to prevent stop during active ops)
     private final Object operationLock = new Object();
@@ -601,6 +624,7 @@ public class CameraXView implements LifecycleOwner, LifecycleObserver {
 
         mainExecutor.execute(() -> {
             try {
+                stopBarcodeScannerInternal(false);
                 lifecycleRegistry.setCurrentState(Lifecycle.State.DESTROYED);
                 if (cameraProvider != null) {
                     cameraProvider.unbindAll();
@@ -1519,6 +1543,262 @@ public class CameraXView implements LifecycleOwner, LifecycleObserver {
         );
     }
 
+    public void startBarcodeScanner(List<String> formats, int detectionIntervalMs, BarcodeScannerStartCallback callback) {
+        if (!isRunning || cameraProvider == null || currentCameraSelector == null || cameraExecutor == null) {
+            callback.onError("Camera is not running");
+            return;
+        }
+
+        mainExecutor.execute(() -> {
+            try {
+                stopBarcodeScannerInternal(true);
+                barcodeScanner = createBarcodeScanner(formats);
+                barcodeDetectionIntervalMs = Math.max(100L, detectionIntervalMs);
+                lastBarcodeFrameAtMs = 0L;
+                isBarcodeFrameProcessing = false;
+                isBarcodeScannerActive = true;
+
+                ResolutionSelector barcodeResolutionSelector = new ResolutionSelector.Builder()
+                    .setResolutionStrategy(
+                        new ResolutionStrategy(new Size(1280, 720), ResolutionStrategy.FALLBACK_RULE_CLOSEST_LOWER_THEN_HIGHER)
+                    )
+                    .build();
+
+                barcodeAnalysis = new ImageAnalysis.Builder()
+                    .setBackpressureStrategy(ImageAnalysis.STRATEGY_KEEP_ONLY_LATEST)
+                    .setResolutionSelector(barcodeResolutionSelector)
+                    .build();
+                barcodeAnalysis.setAnalyzer(cameraExecutor, this::analyzeBarcodeImage);
+
+                cameraProvider.bindToLifecycle(this, currentCameraSelector, barcodeAnalysis);
+                callback.onStarted();
+            } catch (Exception e) {
+                stopBarcodeScannerInternal(true);
+                callback.onError("Failed to start barcode scanner: " + e.getMessage());
+            }
+        });
+    }
+
+    public void stopBarcodeScanner() {
+        mainExecutor.execute(() -> stopBarcodeScannerInternal(true));
+    }
+
+    private void stopBarcodeScannerInternal(boolean unbindAnalysis) {
+        isBarcodeScannerActive = false;
+        isBarcodeFrameProcessing = false;
+        lastBarcodeFrameAtMs = 0L;
+
+        if (barcodeAnalysis != null) {
+            barcodeAnalysis.clearAnalyzer();
+            if (unbindAnalysis && cameraProvider != null) {
+                try {
+                    cameraProvider.unbind(barcodeAnalysis);
+                } catch (Exception e) {
+                    Log.w(TAG, "stopBarcodeScannerInternal: failed to unbind barcode analysis", e);
+                }
+            }
+            barcodeAnalysis = null;
+        }
+
+        if (barcodeScanner != null) {
+            try {
+                barcodeScanner.close();
+            } catch (Exception e) {
+                Log.w(TAG, "stopBarcodeScannerInternal: failed to close scanner", e);
+            }
+            barcodeScanner = null;
+        }
+    }
+
+    private BarcodeScanner createBarcodeScanner(List<String> formats) {
+        if (formats == null || formats.isEmpty()) {
+            return BarcodeScanning.getClient();
+        }
+
+        int[] mlKitFormats = toMlKitBarcodeFormats(formats);
+        if (mlKitFormats.length == 0) {
+            throw new IllegalArgumentException("No supported barcode formats requested");
+        }
+
+        BarcodeScannerOptions.Builder builder = new BarcodeScannerOptions.Builder();
+        int[] extraFormats = Arrays.copyOfRange(mlKitFormats, 1, mlKitFormats.length);
+        builder.setBarcodeFormats(mlKitFormats[0], extraFormats);
+        return BarcodeScanning.getClient(builder.build());
+    }
+
+    private int[] toMlKitBarcodeFormats(List<String> formats) {
+        if (formats == null || formats.isEmpty()) {
+            return new int[0];
+        }
+
+        List<Integer> mappedFormats = new ArrayList<>();
+        for (String format : formats) {
+            int mappedFormat = toMlKitBarcodeFormat(format);
+            if (mappedFormat != -1 && !mappedFormats.contains(mappedFormat)) {
+                mappedFormats.add(mappedFormat);
+            }
+        }
+
+        int[] result = new int[mappedFormats.size()];
+        for (int i = 0; i < mappedFormats.size(); i++) {
+            result[i] = mappedFormats.get(i);
+        }
+        return result;
+    }
+
+    private int toMlKitBarcodeFormat(String format) {
+        if (format == null) {
+            return -1;
+        }
+
+        switch (format) {
+            case "aztec":
+                return Barcode.FORMAT_AZTEC;
+            case "codabar":
+                return Barcode.FORMAT_CODABAR;
+            case "code_39":
+                return Barcode.FORMAT_CODE_39;
+            case "code_93":
+                return Barcode.FORMAT_CODE_93;
+            case "code_128":
+                return Barcode.FORMAT_CODE_128;
+            case "data_matrix":
+                return Barcode.FORMAT_DATA_MATRIX;
+            case "ean_8":
+                return Barcode.FORMAT_EAN_8;
+            case "ean_13":
+                return Barcode.FORMAT_EAN_13;
+            case "itf":
+                return Barcode.FORMAT_ITF;
+            case "pdf417":
+                return Barcode.FORMAT_PDF417;
+            case "qr_code":
+                return Barcode.FORMAT_QR_CODE;
+            case "upc_a":
+                return Barcode.FORMAT_UPC_A;
+            case "upc_e":
+                return Barcode.FORMAT_UPC_E;
+            default:
+                return -1;
+        }
+    }
+
+    @OptIn(markerClass = ExperimentalGetImage.class)
+    private void analyzeBarcodeImage(@NonNull ImageProxy imageProxy) {
+        BarcodeScanner scanner = barcodeScanner;
+        long now = SystemClock.elapsedRealtime();
+
+        if (
+            !isBarcodeScannerActive ||
+            scanner == null ||
+            isBarcodeFrameProcessing ||
+            now - lastBarcodeFrameAtMs < barcodeDetectionIntervalMs
+        ) {
+            imageProxy.close();
+            return;
+        }
+
+        Image mediaImage = imageProxy.getImage();
+        if (mediaImage == null) {
+            imageProxy.close();
+            return;
+        }
+
+        isBarcodeFrameProcessing = true;
+        lastBarcodeFrameAtMs = now;
+
+        InputImage image = InputImage.fromMediaImage(mediaImage, imageProxy.getImageInfo().getRotationDegrees());
+        scanner
+            .process(image)
+            .addOnSuccessListener((barcodes) -> {
+                if (!isBarcodeScannerActive || barcodes.isEmpty() || listener == null) {
+                    return;
+                }
+
+                JSONArray result = new JSONArray();
+                for (Barcode barcode : barcodes) {
+                    JSONObject barcodeJson = barcodeToJson(barcode);
+                    if (barcodeJson != null) {
+                        result.put(barcodeJson);
+                    }
+                }
+
+                if (result.length() > 0) {
+                    listener.onBarcodesScanned(result);
+                }
+            })
+            .addOnFailureListener((e) -> {
+                if (isBarcodeScannerActive && listener != null) {
+                    listener.onBarcodeScanError("Barcode scan failed: " + e.getMessage());
+                }
+            })
+            .addOnCompleteListener((task) -> {
+                isBarcodeFrameProcessing = false;
+                imageProxy.close();
+            });
+    }
+
+    private JSONObject barcodeToJson(Barcode barcode) {
+        String value = barcode.getRawValue();
+        if (value == null || value.isEmpty()) {
+            return null;
+        }
+
+        JSONObject barcodeJson = new JSONObject();
+        try {
+            barcodeJson.put("value", value);
+            barcodeJson.put("format", fromMlKitBarcodeFormat(barcode.getFormat()));
+
+            String displayValue = barcode.getDisplayValue();
+            if (displayValue != null) {
+                barcodeJson.put("displayValue", displayValue);
+            }
+
+            byte[] rawBytes = barcode.getRawBytes();
+            if (rawBytes != null && rawBytes.length > 0) {
+                barcodeJson.put("rawBytes", Base64.encodeToString(rawBytes, Base64.NO_WRAP));
+            }
+        } catch (Exception e) {
+            Log.w(TAG, "barcodeToJson: failed to serialize barcode", e);
+            return null;
+        }
+
+        return barcodeJson;
+    }
+
+    private String fromMlKitBarcodeFormat(int format) {
+        switch (format) {
+            case Barcode.FORMAT_AZTEC:
+                return "aztec";
+            case Barcode.FORMAT_CODABAR:
+                return "codabar";
+            case Barcode.FORMAT_CODE_39:
+                return "code_39";
+            case Barcode.FORMAT_CODE_93:
+                return "code_93";
+            case Barcode.FORMAT_CODE_128:
+                return "code_128";
+            case Barcode.FORMAT_DATA_MATRIX:
+                return "data_matrix";
+            case Barcode.FORMAT_EAN_8:
+                return "ean_8";
+            case Barcode.FORMAT_EAN_13:
+                return "ean_13";
+            case Barcode.FORMAT_ITF:
+                return "itf";
+            case Barcode.FORMAT_PDF417:
+                return "pdf417";
+            case Barcode.FORMAT_QR_CODE:
+                return "qr_code";
+            case Barcode.FORMAT_UPC_A:
+                return "upc_a";
+            case Barcode.FORMAT_UPC_E:
+                return "upc_e";
+            default:
+                return "unknown";
+        }
+    }
+
     private void copyMutableSessionConfigState(CameraSessionConfiguration source, CameraSessionConfiguration target) {
         target.setCentered(source.isCentered());
         target.setTargetZoom(source.getTargetZoom());

package/dist/docs.json

@@ -128,6 +128,52 @@
         ],
         "slug": "capturesample"
       },
+      {
+        "name": "startBarcodeScanner",
+        "signature": "(options?: BarcodeScannerOptions | undefined) => Promise<void>",
+        "parameters": [
+          {
+            "name": "options",
+            "docs": "",
+            "type": "BarcodeScannerOptions | undefined"
+          }
+        ],
+        "returns": "Promise<void>",
+        "tags": [
+          {
+            "name": "since",
+            "text": "8.8.0"
+          },
+          {
+            "name": "platform",
+            "text": "android, ios, web"
+          }
+        ],
+        "docs": "Starts barcode scanning on the active camera preview.\n\nThe scanner reuses the current camera session and emits `barcodeScanned` events.\nCall `stopBarcodeScanner()` when scanning is no longer needed.\n\nAndroid uses the lightweight Google Play Services ML Kit model. If the model is not installed yet,\nfirst scans may return no result until Google Play Services finishes downloading it.",
+        "complexTypes": [
+          "BarcodeScannerOptions"
+        ],
+        "slug": "startbarcodescanner"
+      },
+      {
+        "name": "stopBarcodeScanner",
+        "signature": "() => Promise<void>",
+        "parameters": [],
+        "returns": "Promise<void>",
+        "tags": [
+          {
+            "name": "since",
+            "text": "8.8.0"
+          },
+          {
+            "name": "platform",
+            "text": "android, ios, web"
+          }
+        ],
+        "docs": "Stops barcode scanning while keeping the camera preview running.",
+        "complexTypes": [],
+        "slug": "stopbarcodescanner"
+      },
       {
         "name": "getSupportedFlashModes",
         "signature": "() => Promise<{ result: CameraPreviewFlashMode[]; }>",
@@ -899,6 +945,72 @@
         ],
         "slug": "addlistenerorientationchange-"
       },
+      {
+        "name": "addListener",
+        "signature": "(eventName: 'barcodeScanned', listenerFunc: (data: BarcodeScannedEvent) => void) => Promise<PluginListenerHandle>",
+        "parameters": [
+          {
+            "name": "eventName",
+            "docs": "",
+            "type": "'barcodeScanned'"
+          },
+          {
+            "name": "listenerFunc",
+            "docs": "",
+            "type": "(data: BarcodeScannedEvent) => void"
+          }
+        ],
+        "returns": "Promise<PluginListenerHandle>",
+        "tags": [
+          {
+            "name": "since",
+            "text": "8.8.0"
+          },
+          {
+            "name": "platform",
+            "text": "android, ios, web"
+          }
+        ],
+        "docs": "Adds a listener for barcode scan results.",
+        "complexTypes": [
+          "PluginListenerHandle",
+          "BarcodeScannedEvent"
+        ],
+        "slug": "addlistenerbarcodescanned-"
+      },
+      {
+        "name": "addListener",
+        "signature": "(eventName: 'barcodeScanError', listenerFunc: (data: BarcodeScanErrorEvent) => void) => Promise<PluginListenerHandle>",
+        "parameters": [
+          {
+            "name": "eventName",
+            "docs": "",
+            "type": "'barcodeScanError'"
+          },
+          {
+            "name": "listenerFunc",
+            "docs": "",
+            "type": "(data: BarcodeScanErrorEvent) => void"
+          }
+        ],
+        "returns": "Promise<PluginListenerHandle>",
+        "tags": [
+          {
+            "name": "since",
+            "text": "8.8.0"
+          },
+          {
+            "name": "platform",
+            "text": "android, web"
+          }
+        ],
+        "docs": "Adds a listener for non-fatal barcode scanner errors.",
+        "complexTypes": [
+          "PluginListenerHandle",
+          "BarcodeScanErrorEvent"
+        ],
+        "slug": "addlistenerbarcodescanerror-"
+      },
       {
         "name": "deleteFile",
         "signature": "(options: { path: string; }) => Promise<{ success: boolean; }>",
@@ -1224,7 +1336,7 @@
           "name": "includeSafeAreaInsets",
           "tags": [
             {
-              "text": "ios",
+              "text": "android, ios",
               "name": "platform"
             },
             {
@@ -1511,6 +1623,54 @@
           "docs": "Sets the quality of video for recording.\nOptions: 'low', 'medium', 'high'",
           "complexTypes": [],
           "type": "'low' | 'medium' | 'high' | undefined"
+        },
+        {
+          "name": "barcodeScanner",
+          "tags": [
+            {
+              "text": "android, ios, web",
+              "name": "platform"
+            },
+            {
+              "text": "8.8.0",
+              "name": "since"
+            }
+          ],
+          "docs": "Starts barcode scanning together with the camera preview.\nSet to `true` or pass options to scan all supported formats.\nOmit this option to keep barcode scanning disabled at startup.",
+          "complexTypes": [
+            "BarcodeScannerOptions"
+          ],
+          "type": "boolean | BarcodeScannerOptions | undefined"
+        }
+      ]
+    },
+    {
+      "name": "BarcodeScannerOptions",
+      "slug": "barcodescanneroptions",
+      "docs": "",
+      "tags": [],
+      "methods": [],
+      "properties": [
+        {
+          "name": "formats",
+          "tags": [],
+          "docs": "Restricts detection to the given formats. Leaving this empty scans all supported formats.\nRestricting formats can improve scanning speed.",
+          "complexTypes": [
+            "BarcodeScannerFormat"
+          ],
+          "type": "BarcodeScannerFormat[] | undefined"
+        },
+        {
+          "name": "detectionInterval",
+          "tags": [
+            {
+              "text": "500",
+              "name": "default"
+            }
+          ],
+          "docs": "Minimum delay between native scan attempts in milliseconds.\nLower values scan more often but use more CPU.",
+          "complexTypes": [],
+          "type": "number | undefined"
         }
       ]
     },
@@ -1993,6 +2153,79 @@
         }
       ]
     },
+    {
+      "name": "BarcodeScannedEvent",
+      "slug": "barcodescannedevent",
+      "docs": "",
+      "tags": [],
+      "methods": [],
+      "properties": [
+        {
+          "name": "barcodes",
+          "tags": [],
+          "docs": "Barcodes decoded from the current frame.",
+          "complexTypes": [
+            "BarcodeScanResult"
+          ],
+          "type": "BarcodeScanResult[]"
+        }
+      ]
+    },
+    {
+      "name": "BarcodeScanResult",
+      "slug": "barcodescanresult",
+      "docs": "",
+      "tags": [],
+      "methods": [],
+      "properties": [
+        {
+          "name": "value",
+          "tags": [],
+          "docs": "Decoded barcode value.",
+          "complexTypes": [],
+          "type": "string"
+        },
+        {
+          "name": "format",
+          "tags": [],
+          "docs": "Barcode format.",
+          "complexTypes": [
+            "BarcodeFormat"
+          ],
+          "type": "BarcodeFormat"
+        },
+        {
+          "name": "displayValue",
+          "tags": [],
+          "docs": "Human-readable value when the platform exposes one.",
+          "complexTypes": [],
+          "type": "string | undefined"
+        },
+        {
+          "name": "rawBytes",
+          "tags": [],
+          "docs": "Base64-encoded raw bytes when the platform exposes them.",
+          "complexTypes": [],
+          "type": "string | undefined"
+        }
+      ]
+    },
+    {
+      "name": "BarcodeScanErrorEvent",
+      "slug": "barcodescanerrorevent",
+      "docs": "",
+      "tags": [],
+      "methods": [],
+      "properties": [
+        {
+          "name": "message",
+          "tags": [],
+          "docs": "Native scanner error message.",
+          "complexTypes": [],
+          "type": "string"
+        }
+      ]
+    },
     {
       "name": "SafeAreaInsets",
       "slug": "safeareainsets",
@@ -2140,6 +2373,65 @@
         }
       ]
     },
+    {
+      "name": "BarcodeScannerFormat",
+      "slug": "barcodescannerformat",
+      "docs": "",
+      "types": [
+        {
+          "text": "'aztec'",
+          "complexTypes": []
+        },
+        {
+          "text": "'codabar'",
+          "complexTypes": []
+        },
+        {
+          "text": "'code_39'",
+          "complexTypes": []
+        },
+        {
+          "text": "'code_93'",
+          "complexTypes": []
+        },
+        {
+          "text": "'code_128'",
+          "complexTypes": []
+        },
+        {
+          "text": "'data_matrix'",
+          "complexTypes": []
+        },
+        {
+          "text": "'ean_8'",
+          "complexTypes": []
+        },
+        {
+          "text": "'ean_13'",
+          "complexTypes": []
+        },
+        {
+          "text": "'itf'",
+          "complexTypes": []
+        },
+        {
+          "text": "'pdf417'",
+          "complexTypes": []
+        },
+        {
+          "text": "'qr_code'",
+          "complexTypes": []
+        },
+        {
+          "text": "'upc_a'",
+          "complexTypes": []
+        },
+        {
+          "text": "'upc_e'",
+          "complexTypes": []
+        }
+      ]
+    },
     {
       "name": "PictureFormat",
       "slug": "pictureformat",
@@ -2256,6 +2548,23 @@
         }
       ]
     },
+    {
+      "name": "BarcodeFormat",
+      "slug": "barcodeformat",
+      "docs": "",
+      "types": [
+        {
+          "text": "BarcodeScannerFormat",
+          "complexTypes": [
+            "BarcodeScannerFormat"
+          ]
+        },
+        {
+          "text": "'unknown'",
+          "complexTypes": []
+        }
+      ]
+    },
     {
       "name": "ExposureMode",
       "slug": "exposuremode",