@carviz/capacitor-camera-preview 7.0.0

package/android/src/main/java/com/ahm/capacitor/camera/preview/Preview.java

@@ -0,0 +1,384 @@
+package com.ahm.capacitor.camera.preview;
+
+import android.app.Activity;
+import android.content.Context;
+import android.graphics.SurfaceTexture;
+import android.hardware.Camera;
+import android.util.DisplayMetrics;
+import android.util.Log;
+import android.view.Surface;
+import android.view.SurfaceHolder;
+import android.view.TextureView;
+import android.view.View;
+import android.widget.RelativeLayout;
+import java.io.IOException;
+import java.util.List;
+
+class Preview extends RelativeLayout implements SurfaceHolder.Callback, TextureView.SurfaceTextureListener {
+
+    private final String TAG = "Preview";
+
+    CustomSurfaceView mSurfaceView;
+    CustomTextureView mTextureView;
+    SurfaceHolder mHolder;
+    SurfaceTexture mSurface;
+    Camera.Size mPreviewSize;
+    List<Camera.Size> mSupportedPreviewSizes;
+    Camera mCamera;
+    int cameraId;
+    int displayOrientation;
+    int facing = Camera.CameraInfo.CAMERA_FACING_BACK;
+    int viewWidth;
+    int viewHeight;
+    private boolean enableOpacity = false;
+    private float opacity = 1F;
+
+    Preview(Context context) {
+        this(context, false);
+    }
+
+    Preview(Context context, boolean enableOpacity) {
+        super(context);
+        this.enableOpacity = enableOpacity;
+        if (!enableOpacity) {
+            mSurfaceView = new CustomSurfaceView(context);
+            addView(mSurfaceView);
+            requestLayout();
+
+            // Install a SurfaceHolder.Callback so we get notified when the
+            // underlying surface is created and destroyed.
+            mHolder = mSurfaceView.getHolder();
+            mHolder.addCallback(this);
+            mHolder.setType(SurfaceHolder.SURFACE_TYPE_PUSH_BUFFERS);
+        } else {
+            // Use a TextureView so we can manage opacity
+            mTextureView = new CustomTextureView(context);
+            // Install a SurfaceTextureListener so we get notified
+            mTextureView.setSurfaceTextureListener(this);
+            mTextureView.setLayerType(View.LAYER_TYPE_HARDWARE, null);
+            addView(mTextureView);
+            requestLayout();
+        }
+    }
+
+    public void setCamera(Camera camera, int cameraId) {
+        if (camera != null) {
+            mCamera = camera;
+            this.cameraId = cameraId;
+            mSupportedPreviewSizes = mCamera.getParameters().getSupportedPreviewSizes();
+            setCameraDisplayOrientation();
+
+            List<String> mFocusModes = mCamera.getParameters().getSupportedFocusModes();
+
+            Camera.Parameters params = mCamera.getParameters();
+            if (mFocusModes.contains("continuous-picture")) {
+                params.setFocusMode(Camera.Parameters.FOCUS_MODE_CONTINUOUS_PICTURE);
+            } else if (mFocusModes.contains("auto")) {
+                params.setFocusMode(Camera.Parameters.FOCUS_MODE_AUTO);
+            }
+            mCamera.setParameters(params);
+        }
+    }
+
+    public int getDisplayOrientation() {
+        return displayOrientation;
+    }
+
+    public int getCameraFacing() {
+        return facing;
+    }
+
+    public void printPreviewSize(String from) {
+        Log.d(TAG, "printPreviewSize from " + from + ": > width: " + mPreviewSize.width + " height: " + mPreviewSize.height);
+    }
+
+    public void setCameraPreviewSize() {
+        if (mCamera != null) {
+            Camera.Parameters parameters = mCamera.getParameters();
+            parameters.setPreviewSize(mPreviewSize.width, mPreviewSize.height);
+            mCamera.setParameters(parameters);
+        }
+    }
+
+    public void setCameraDisplayOrientation() {
+        Camera.CameraInfo info = new Camera.CameraInfo();
+        int rotation = ((Activity) getContext()).getWindowManager().getDefaultDisplay().getRotation();
+        int degrees = 0;
+        DisplayMetrics dm = new DisplayMetrics();
+
+        Camera.getCameraInfo(cameraId, info);
+        ((Activity) getContext()).getWindowManager().getDefaultDisplay().getMetrics(dm);
+
+        switch (rotation) {
+            case Surface.ROTATION_0:
+                degrees = 0;
+                break;
+            case Surface.ROTATION_90:
+                degrees = 90;
+                break;
+            case Surface.ROTATION_180:
+                degrees = 180;
+                break;
+            case Surface.ROTATION_270:
+                degrees = 270;
+                break;
+        }
+        facing = info.facing;
+        if (info.facing == Camera.CameraInfo.CAMERA_FACING_FRONT) {
+            displayOrientation = (info.orientation + degrees) % 360;
+            displayOrientation = (360 - displayOrientation) % 360;
+        } else {
+            displayOrientation = (info.orientation - degrees + 360) % 360;
+        }
+
+        Log.d(TAG, "screen is rotated " + degrees + "deg from natural");
+        Log.d(
+            TAG,
+            (info.facing == Camera.CameraInfo.CAMERA_FACING_FRONT ? "front" : "back") +
+            " camera is oriented -" +
+            info.orientation +
+            "deg from natural"
+        );
+        Log.d(TAG, "need to rotate preview " + displayOrientation + "deg");
+        mCamera.setDisplayOrientation(displayOrientation);
+    }
+
+    public void switchCamera(Camera camera, int cameraId) {
+        try {
+            setCamera(camera, cameraId);
+
+            Log.d("CameraPreview", "before set camera");
+
+            View v;
+            if (enableOpacity) {
+                camera.setPreviewTexture(mSurface);
+                v = mTextureView;
+            } else {
+                camera.setPreviewDisplay(mHolder);
+                v = mSurfaceView;
+            }
+
+            Log.d("CameraPreview", "before getParameters");
+
+            Camera.Parameters parameters = camera.getParameters();
+
+            Log.d("CameraPreview", "before setPreviewSize");
+
+            mSupportedPreviewSizes = parameters.getSupportedPreviewSizes();
+            mPreviewSize = getOptimalPreviewSize(mSupportedPreviewSizes, v.getWidth(), v.getHeight());
+            parameters.setPreviewSize(mPreviewSize.width, mPreviewSize.height);
+            Log.d(TAG, mPreviewSize.width + " " + mPreviewSize.height);
+
+            camera.setParameters(parameters);
+        } catch (IOException exception) {
+            Log.e(TAG, exception.getMessage());
+        }
+    }
+
+    @Override
+    protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
+        // We purposely disregard child measurements because act as a
+        // wrapper to a SurfaceView that centers the camera preview instead
+        // of stretching it.
+        final int width = resolveSize(getSuggestedMinimumWidth(), widthMeasureSpec);
+        final int height = resolveSize(getSuggestedMinimumHeight(), heightMeasureSpec);
+        setMeasuredDimension(width, height);
+
+        if (mSupportedPreviewSizes != null) {
+            mPreviewSize = getOptimalPreviewSize(mSupportedPreviewSizes, width, height);
+        }
+    }
+
+    @Override
+    protected void onLayout(boolean changed, int l, int t, int r, int b) {
+        if (changed && getChildCount() > 0) {
+            final View child = getChildAt(0);
+
+            int width = r - l;
+            int height = b - t;
+
+            int previewWidth = width;
+            int previewHeight = height;
+
+            if (mPreviewSize != null) {
+                previewWidth = mPreviewSize.width;
+                previewHeight = mPreviewSize.height;
+
+                if (displayOrientation == 90 || displayOrientation == 270) {
+                    previewWidth = mPreviewSize.height;
+                    previewHeight = mPreviewSize.width;
+                }
+                //        LOG.d(TAG, "previewWidth:" + previewWidth + " previewHeight:" + previewHeight);
+            }
+
+            int nW;
+            int nH;
+            int top;
+            int left;
+
+            float scale = 1.0f;
+
+            // Center the child SurfaceView within the parent.
+            if (width * previewHeight < height * previewWidth) {
+                Log.d(TAG, "center horizontally");
+                int scaledChildWidth = (int) ((previewWidth * height / previewHeight) * scale);
+                nW = (width + scaledChildWidth) / 2;
+                nH = (int) (height * scale);
+                top = 0;
+                left = (width - scaledChildWidth) / 2;
+            } else {
+                Log.d(TAG, "center vertically");
+                int scaledChildHeight = (int) ((previewHeight * width / previewWidth) * scale);
+                nW = (int) (width * scale);
+                nH = (height + scaledChildHeight) / 2;
+                top = (height - scaledChildHeight) / 2;
+                left = 0;
+            }
+            child.layout(left, top, nW, nH);
+
+            Log.d("layout", "left:" + left);
+            Log.d("layout", "top:" + top);
+            Log.d("layout", "right:" + nW);
+            Log.d("layout", "bottom:" + nH);
+        }
+    }
+
+    public void surfaceCreated(SurfaceHolder holder) {
+        // The Surface has been created, acquire the camera and tell it where
+        // to draw.
+        try {
+            if (mCamera != null) {
+                mSurfaceView.setWillNotDraw(false);
+                mCamera.setPreviewDisplay(holder);
+            }
+        } catch (Exception exception) {
+            Log.e(TAG, "Exception caused by setPreviewDisplay()", exception);
+        }
+    }
+
+    public void surfaceDestroyed(SurfaceHolder holder) {
+        // Surface will be destroyed when we return, so stop the preview.
+        try {
+            if (mCamera != null) {
+                mCamera.stopPreview();
+            }
+        } catch (Exception exception) {
+            Log.e(TAG, "Exception caused by surfaceDestroyed()", exception);
+        }
+    }
+
+    private Camera.Size getOptimalPreviewSize(List<Camera.Size> sizes, int w, int h) {
+        final double ASPECT_TOLERANCE = 0.1;
+        double targetRatio = (double) w / h;
+        if (displayOrientation == 90 || displayOrientation == 270) {
+            targetRatio = (double) h / w;
+        }
+
+        if (sizes == null) {
+            return null;
+        }
+
+        Camera.Size optimalSize = null;
+        double minDiff = Double.MAX_VALUE;
+
+        int targetHeight = h;
+
+        // Try to find an size match aspect ratio and size
+        for (Camera.Size size : sizes) {
+            double ratio = (double) size.width / size.height;
+            if (Math.abs(ratio - targetRatio) > ASPECT_TOLERANCE) continue;
+            if (Math.abs(size.height - targetHeight) < minDiff) {
+                optimalSize = size;
+                minDiff = Math.abs(size.height - targetHeight);
+            }
+        }
+
+        // Cannot find the one match the aspect ratio, ignore the requirement
+        if (optimalSize == null) {
+            minDiff = Double.MAX_VALUE;
+            for (Camera.Size size : sizes) {
+                if (Math.abs(size.height - targetHeight) < minDiff) {
+                    optimalSize = size;
+                    minDiff = Math.abs(size.height - targetHeight);
+                }
+            }
+        }
+
+        Log.d(TAG, "optimal preview size: w: " + optimalSize.width + " h: " + optimalSize.height);
+        return optimalSize;
+    }
+
+    public void surfaceChanged(SurfaceHolder holder, int format, int w, int h) {
+        if (mCamera != null) {
+            try {
+                // Now that the size is known, set up the camera parameters and begin
+                // the preview.
+                mSupportedPreviewSizes = mCamera.getParameters().getSupportedPreviewSizes();
+                if (mSupportedPreviewSizes != null) {
+                    mPreviewSize = getOptimalPreviewSize(mSupportedPreviewSizes, w, h);
+                }
+                startCamera();
+            } catch (Exception exception) {
+                Log.e(TAG, "Exception caused by surfaceChanged()", exception);
+            }
+        }
+    }
+
+    private void startCamera() {
+        Camera.Parameters parameters = mCamera.getParameters();
+        parameters.setPreviewSize(mPreviewSize.width, mPreviewSize.height);
+        requestLayout();
+        //mCamera.setDisplayOrientation(90);
+        mCamera.setParameters(parameters);
+        mCamera.startPreview();
+    }
+
+    //  Texture Callbacks
+
+    public void onSurfaceTextureAvailable(SurfaceTexture surface, int width, int height) {
+        // The Surface has been created, acquire the camera and tell it where
+        // to draw.
+        try {
+            mSurface = surface;
+            if (mSupportedPreviewSizes != null) {
+                mPreviewSize = getOptimalPreviewSize(mSupportedPreviewSizes, width, height);
+            }
+            if (mCamera != null) {
+                mTextureView.setAlpha(opacity);
+                mCamera.setPreviewTexture(surface);
+                startCamera();
+            }
+        } catch (Exception exception) {
+            Log.e(TAG, "Exception caused by onSurfaceTextureAvailable()", exception);
+        }
+    }
+
+    public void onSurfaceTextureSizeChanged(SurfaceTexture surface, int width, int height) {}
+
+    public boolean onSurfaceTextureDestroyed(SurfaceTexture surface) {
+        try {
+            if (mCamera != null) {
+                mCamera.stopPreview();
+            }
+        } catch (Exception exception) {
+            Log.e(TAG, "Exception caused by onSurfaceTextureDestroyed()", exception);
+            return false;
+        }
+        return true;
+    }
+
+    public void onSurfaceTextureUpdated(SurfaceTexture surface) {}
+
+    public void setOneShotPreviewCallback(Camera.PreviewCallback callback) {
+        if (mCamera != null) {
+            mCamera.setOneShotPreviewCallback(callback);
+        }
+    }
+
+    public void setOpacity(final float opacity) {
+        this.opacity = opacity;
+        if (mCamera != null && enableOpacity) {
+            mTextureView.setAlpha(opacity);
+        }
+    }
+}

package/android/src/main/java/com/ahm/capacitor/camera/preview/TapGestureDetector.java

@@ -0,0 +1,24 @@
+package com.ahm.capacitor.camera.preview;
+
+import android.view.GestureDetector;
+import android.view.MotionEvent;
+
+class TapGestureDetector extends GestureDetector.SimpleOnGestureListener {
+
+    private final String TAG = "TapGestureDetector";
+
+    @Override
+    public boolean onDown(MotionEvent e) {
+        return false;
+    }
+
+    @Override
+    public boolean onSingleTapUp(MotionEvent e) {
+        return true;
+    }
+
+    @Override
+    public boolean onSingleTapConfirmed(MotionEvent e) {
+        return true;
+    }
+}

package/android/src/main/res/layout/bridge_layout_main.xml

@@ -0,0 +1,15 @@
+<?xml version="1.0" encoding="utf-8"?>
+<androidx.coordinatorlayout.widget.CoordinatorLayout xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:app="http://schemas.android.com/apk/res-auto"
+    xmlns:tools="http://schemas.android.com/tools"
+    android:layout_width="match_parent"
+    android:layout_height="match_parent"
+    tools:context="com.getcapacitor.BridgeActivity"
+    >
+
+    <WebView
+        android:id="@+id/webview"
+        android:layout_width="fill_parent"
+        android:layout_height="fill_parent" />
+
+</androidx.coordinatorlayout.widget.CoordinatorLayout>

package/android/src/main/res/layout/camera_activity.xml

@@ -0,0 +1,68 @@
+<?xml version="1.0" encoding="utf-8"?>
+<FrameLayout
+  android:layout_width="match_parent"
+  android:layout_height="match_parent"
+  tools:context="com.ahm.capacitor.camera.preview.CameraActivity"
+  android:id="@+id/frame_container"
+  xmlns:android="http://schemas.android.com/apk/res/android"
+  xmlns:tools="http://schemas.android.com/tools"
+  android:layout_gravity="center_horizontal|top"
+  android:layout_weight=".7">
+
+  <RelativeLayout
+    android:layout_width="match_parent"
+    android:layout_height="match_parent"
+    android:gravity="center_horizontal|top"
+    android:id="@+id/frame_camera_cont"
+    android:layout_gravity="center_horizontal|top">
+
+    <FrameLayout
+      android:layout_width="match_parent"
+      android:layout_height="match_parent"
+      android:id="@+id/video_view"
+
+      android:scaleType="fitXY"
+      android:layout_gravity="top" />
+
+    <ImageView
+      android:layout_width="match_parent"
+      android:layout_height="match_parent"
+      android:id="@+id/picture_view"
+      android:layout_gravity="center|bottom"
+      android:adjustViewBounds="true"
+      android:scaleType="fitXY" />
+
+    <ImageView
+      android:layout_width="match_parent"
+      android:layout_height="match_parent"
+      android:id="@+id/frame_view"
+      android:layout_gravity="center_horizontal|bottom"
+      android:adjustViewBounds="true"
+      android:scaleType="centerInside" />
+
+  </RelativeLayout>
+
+  <FrameLayout
+    android:layout_width="match_parent"
+    android:layout_height="match_parent"
+    android:id="@+id/camera_loader"
+    android:scaleType="fitXY"
+    android:layout_gravity="top"
+    android:layout_alignWithParentIfMissing="false"
+    android:layout_alignParentTop="false"
+    android:layout_alignParentLeft="false"
+    android:layout_alignParentBottom="false"
+    android:layout_alignParentRight="false"
+    android:visibility="invisible"
+    android:background="#ff000000">
+
+    <ProgressBar
+      android:layout_width="wrap_content"
+      android:layout_height="wrap_content"
+      android:id="@+id/camera_loader_spinner"
+      android:layout_gravity="center"
+      android:indeterminate="false"
+      android:indeterminateBehavior="cycle"
+      android:indeterminateOnly="true"/>
+  </FrameLayout>
+</FrameLayout>

package/android/src/main/res/values/camera_ids.xml

@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+  <item type="id" name="camera_container" />
+</resources>

package/android/src/main/res/values/camera_theme.xml

@@ -0,0 +1,9 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+  <style name="CameraPreviewTheme" parent="android:Theme.Light">
+    <item name="android:windowIsFloating">true</item>  
+    <item name="android:windowCloseOnTouchOutside">false</item>  
+    <item name="android:colorBackgroundCacheHint">@null</item>  
+    <item name="android:backgroundDimEnabled">false</item>  
+  </style>
+</resources>

package/android/src/main/res/values/colors.xml

@@ -0,0 +1,3 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+</resources>

package/android/src/main/res/values/strings.xml

@@ -0,0 +1,3 @@
+<resources>
+    <string name="my_string">Just a simple string</string>
+</resources>

package/android/src/main/res/values/styles.xml

@@ -0,0 +1,3 @@
+<resources>
+
+</resources>

package/android/src/test/java/com/getcapacitor/ExampleUnitTest.java

@@ -0,0 +1,18 @@
+package com.getcapacitor;
+
+import static org.junit.Assert.*;
+
+import org.junit.Test;
+
+/**
+ * Example local unit test, which will execute on the development machine (host).
+ *
+ * @see <a href="http://d.android.com/tools/testing">Testing documentation</a>
+ */
+public class ExampleUnitTest {
+
+    @Test
+    public void addition_isCorrect() throws Exception {
+        assertEquals(4, 2 + 2);
+    }
+}

package/dist/esm/definitions.d.ts

@@ -0,0 +1,86 @@
+import type { PermissionState } from '@capacitor/core';
+export type CameraPosition = 'rear' | 'front';
+export interface CameraPreviewOptions {
+    /** Parent element to attach the video preview element to (applicable to the web platform only) */
+    parent?: string;
+    /** Class name to add to the video preview element (applicable to the web platform only) */
+    className?: string;
+    /** The preview width in pixels, default window.screen.width */
+    width?: number;
+    /** The preview height in pixels, default window.screen.height */
+    height?: number;
+    /** The x origin, default 0 (applicable to the android and ios platforms only) */
+    x?: number;
+    /** The y origin, default 0 (applicable to the android and ios platforms only) */
+    y?: number;
+    /**  Brings your html in front of your preview, default false (applicable to the android only) */
+    toBack?: boolean;
+    /** The preview bottom padding in pixes. Useful to keep the appropriate preview sizes when orientation changes (applicable to the android and ios platforms only) */
+    paddingBottom?: number;
+    /** Rotate preview when orientation changes (applicable to the ios platforms only; default value is true) */
+    rotateWhenOrientationChanged?: boolean;
+    /** Choose the camera to use 'front' or 'rear', default 'front' */
+    position?: CameraPosition | string;
+    /** Defaults to false - Capture images to a file and return the file path instead of returning base64 encoded data */
+    storeToFile?: boolean;
+    /** Defaults to false - Android Only - Disable automatic rotation of the image, and let the browser deal with it */
+    disableExifHeaderStripping?: boolean;
+    /** Defaults to false - iOS only - Activate high resolution image capture so that output images are from the highest resolution possible on the device **/
+    enableHighResolution?: boolean;
+    /**  Android Only - Locks device orientation when camera is showing. */
+    lockAndroidOrientation?: boolean;
+    /** Defaults to false - Android and Web only.  Set if camera preview can change opacity. */
+    enableOpacity?: boolean;
+    /** Defaults to false - Android and iOS only.  Set if camera preview will support pinch to zoom. */
+    enableZoom?: boolean;
+}
+export interface CameraPreviewPictureOptions {
+    /** The picture height, respecting the default aspect ratio of the device - Android only */
+    height?: number;
+    /** The picture width, respecting the default aspect ratio of the device - Android only */
+    width?: number;
+    /**
+     * The picture quality, 0 - 100, default 85 on `iOS/Android`.
+     * If left undefined, the `web` implementation will export a PNG, otherwise a JPEG will be generated
+     */
+    quality?: number;
+}
+export interface CameraSampleOptions {
+    /** The picture quality, 0 - 100, default 85 */
+    quality?: number;
+}
+export type CameraPreviewFlashMode = 'off' | 'on' | 'auto' | 'red-eye' | 'torch';
+export interface CameraOpacityOptions {
+    /** The percent opacity to set for camera view, default 1 */
+    opacity?: number;
+}
+export interface CameraPreviewPlugin {
+    /** Starts the camera preview instance */
+    start(options: CameraPreviewOptions): Promise<{}>;
+    /** Stops the camera preview instance */
+    stop(): Promise<{}>;
+    /** Captures a picture from the camera preview */
+    capture(options: CameraPreviewPictureOptions): Promise<{
+        value: string;
+    }>;
+    /** Captures a sample image from the video stream - Android / iOS only */
+    captureSample(options: CameraSampleOptions): Promise<{
+        value: string;
+    }>;
+    /** Get the flash modes supported by the camera device currently started */
+    getSupportedFlashModes(): Promise<{
+        result: CameraPreviewFlashMode[];
+    }>;
+    /** Set the flash mode */
+    setFlashMode(options: {
+        flashMode: CameraPreviewFlashMode | string;
+    }): Promise<void>;
+    /** Switch between rear and front camera - Android / iOS only */
+    flip(): Promise<void>;
+    /** Changes the opacity of the shown camera preview - Android / Web only */
+    setOpacity(options: CameraOpacityOptions): Promise<{}>;
+    /** Check camera permission */
+    checkPermissions(): Promise<PermissionState>;
+    /** Request camera permission */
+    requestPermissions(): Promise<PermissionState>;
+}

package/dist/esm/definitions.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=definitions.js.map

package/dist/esm/definitions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"definitions.js","sourceRoot":"","sources":["../../src/definitions.ts"],"names":[],"mappings":""}

package/dist/esm/index.d.ts

@@ -0,0 +1,4 @@
+import type { CameraPreviewPlugin } from './definitions';
+declare const CameraPreview: CameraPreviewPlugin;
+export * from './definitions';
+export { CameraPreview };

package/dist/esm/index.js

@@ -0,0 +1,7 @@
+import { registerPlugin } from '@capacitor/core';
+const CameraPreview = registerPlugin('CameraPreview', {
+    web: () => import('./web').then((m) => new m.CameraPreviewWeb()),
+});
+export * from './definitions';
+export { CameraPreview };
+//# sourceMappingURL=index.js.map

package/dist/esm/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAIjD,MAAM,aAAa,GAAG,cAAc,CAAsB,eAAe,EAAE;IACzE,GAAG,EAAE,GAAG,EAAE,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,IAAI,CAAC,CAAC,gBAAgB,EAAE,CAAC;CACjE,CAAC,CAAC;AAEH,cAAc,eAAe,CAAC;AAC9B,OAAO,EAAE,aAAa,EAAE,CAAC"}

package/dist/esm/web.d.ts

@@ -0,0 +1,24 @@
+import { WebPlugin } from '@capacitor/core';
+import type { CameraPreviewOptions, CameraPreviewPictureOptions, CameraPreviewPlugin, CameraPreviewFlashMode, CameraSampleOptions, CameraOpacityOptions } from './definitions';
+export declare class CameraPreviewWeb extends WebPlugin implements CameraPreviewPlugin {
+    /**
+     *  track which camera is used based on start options
+     *  used in capture
+     */
+    private isBackCamera;
+    constructor();
+    start(options: CameraPreviewOptions): Promise<{}>;
+    stop(): Promise<any>;
+    capture(options: CameraPreviewPictureOptions): Promise<any>;
+    captureSample(_options: CameraSampleOptions): Promise<any>;
+    getSupportedFlashModes(): Promise<{
+        result: CameraPreviewFlashMode[];
+    }>;
+    setFlashMode(_options: {
+        flashMode: CameraPreviewFlashMode | string;
+    }): Promise<void>;
+    flip(): Promise<void>;
+    setOpacity(_options: CameraOpacityOptions): Promise<any>;
+    checkPermissions(): Promise<PermissionState>;
+    requestPermissions(): Promise<PermissionState>;
+}