@capgo/camera-preview 7.4.0-beta.1 → 7.4.0-beta.3

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

@@ -4,7 +4,6 @@ import android.content.Context;
 import android.hardware.camera2.CameraAccessException;
 import android.hardware.camera2.CameraManager;
 import android.os.Build;
-import android.os.HandlerThread;
 import android.util.Base64;
 import android.util.Log;
 import android.util.Size;
@@ -32,29 +31,42 @@ import com.ahm.capacitor.camera.preview.model.LensInfo;
 import com.ahm.capacitor.camera.preview.model.ZoomFactors;
 import com.google.common.util.concurrent.ListenableFuture;
 import java.nio.ByteBuffer;
-import java.nio.file.Files;
 import java.util.Arrays;
 import java.util.Collections;
 import java.util.List;
 import java.util.ArrayList;
 import java.util.Objects;
-import java.util.concurrent.ExecutionException;
 import java.util.concurrent.Executor;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
 import androidx.camera.camera2.interop.Camera2CameraInfo;
 import androidx.camera.camera2.interop.ExperimentalCamera2Interop;
 import android.hardware.camera2.CameraCharacteristics;
-import androidx.camera.extensions.ExtensionMode;
 import java.util.Set;
 import androidx.camera.core.ZoomState;
 import androidx.camera.core.ResolutionInfo;
+import android.content.Intent;
+import android.net.Uri;
+import android.os.Environment;
+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.text.SimpleDateFormat;
+import java.util.Locale;
+import androidx.exifinterface.media.ExifInterface;
+import org.json.JSONObject;
+import java.nio.file.Files;
+import android.graphics.BitmapFactory;
+import android.graphics.Bitmap;
+import android.graphics.Matrix;
+import java.io.ByteArrayOutputStream;
+import android.location.Location;
 
 public class CameraXView implements LifecycleOwner {
     private static final String TAG = "CameraPreview CameraXView";
 
     public interface CameraXViewListener {
-        void onPictureTaken(String result);
+        void onPictureTaken(String base64, JSONObject exif);
         void onPictureTakenError(String message);
         void onSampleTaken(String result);
         void onSampleTakenError(String message);
@@ -102,6 +114,26 @@ public class CameraXView implements LifecycleOwner {
         return isRunning;
     }
 
+    private void saveImageToGallery(byte[] data) {
+        try {
+            File photo = new File(
+                Environment.getExternalStoragePublicDirectory(Environment.DIRECTORY_PICTURES),
+                "IMG_" + new SimpleDateFormat("yyyyMMdd_HHmmss", Locale.US).format(new java.util.Date()) + ".jpg"
+            );
+            FileOutputStream fos = new FileOutputStream(photo);
+            fos.write(data);
+            fos.close();
+
+            // Notify the gallery of the new image
+            Intent mediaScanIntent = new Intent(Intent.ACTION_MEDIA_SCANNER_SCAN_FILE);
+            Uri contentUri = Uri.fromFile(photo);
+            mediaScanIntent.setData(contentUri);
+            context.sendBroadcast(mediaScanIntent);
+        } catch (IOException e) {
+            Log.e(TAG, "Error saving image to gallery", e);
+        }
+    }
+
     public void startSession(CameraSessionConfiguration config) {
         this.sessionConfig = config;
         cameraExecutor = Executors.newSingleThreadExecutor();
@@ -167,6 +199,7 @@ public class CameraXView implements LifecycleOwner {
         webView.setBackgroundColor(android.graphics.Color.WHITE);
     }
 
+    @OptIn(markerClass = ExperimentalCamera2Interop.class)
     private void bindCameraUseCases() {
         if (cameraProvider == null) return;
         mainExecutor.execute(() -> {
@@ -188,7 +221,6 @@ public class CameraXView implements LifecycleOwner {
                 Log.d(TAG, "Use cases bound. Inspecting active camera and use cases.");
                 CameraInfo cameraInfo = camera.getCameraInfo();
                 Log.d(TAG, "Bound Camera ID: " + Camera2CameraInfo.from(cameraInfo).getCameraId());
-                Log.d(TAG, "Implementation Type: " + cameraInfo.getImplementationType());
 
                 // Log zoom state
                 ZoomState zoomState = cameraInfo.getZoomState().getValue();
@@ -256,22 +288,6 @@ public class CameraXView implements LifecycleOwner {
         return builder.build();
     }
 
-    private static boolean isIsLogical(CameraManager cameraManager, String cameraId) throws CameraAccessException {
-        CameraCharacteristics characteristics = cameraManager.getCameraCharacteristics(cameraId);
-        int[] capabilities = characteristics.get(CameraCharacteristics.REQUEST_AVAILABLE_CAPABILITIES);
-
-        boolean isLogical = false;
-        if (capabilities != null) {
-           for (int capability : capabilities) {
-               if (capability == CameraCharacteristics.REQUEST_AVAILABLE_CAPABILITIES_LOGICAL_MULTI_CAMERA) {
-                   isLogical = true;
-                   break;
-               }
-           }
-        }
-        return isLogical;
-    }
-
     private static String getCameraId(androidx.camera.core.CameraInfo cameraInfo) {
         try {
             // Generate a stable ID based on camera characteristics
@@ -303,7 +319,7 @@ public class CameraXView implements LifecycleOwner {
         }
     }
 
-    public void capturePhoto(int quality) {
+    public void capturePhoto(int quality, final boolean saveToGallery, Integer width, Integer height, Location location) {
         Log.d(TAG, "capturePhoto: Starting photo capture with quality: " + quality);
 
         if (imageCapture == null) {
@@ -313,9 +329,8 @@ public class CameraXView implements LifecycleOwner {
             return;
         }
 
-        ImageCapture.OutputFileOptions outputFileOptions = new ImageCapture.OutputFileOptions.Builder(
-            new java.io.File(context.getCacheDir(), "temp_image.jpg")
-        ).build();
+        File tempFile = new File(context.getCacheDir(), "temp_image.jpg");
+        ImageCapture.OutputFileOptions outputFileOptions = new ImageCapture.OutputFileOptions.Builder(tempFile).build();
 
         imageCapture.takePicture(
             outputFileOptions,
@@ -331,31 +346,37 @@ public class CameraXView implements LifecycleOwner {
 
                 @Override
                 public void onImageSaved(@NonNull ImageCapture.OutputFileResults output) {
-                    // Convert to base64
                     try {
-                        java.io.File tempFile = new java.io.File(context.getCacheDir(), "temp_image.jpg");
-                        byte[] bytes;
-
-                        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
-                            bytes = Files.readAllBytes(tempFile.toPath());
-                        } else {
-                            // Fallback for older Android versions
-                            java.io.FileInputStream fis = new java.io.FileInputStream(tempFile);
-                            bytes = new byte[(int) tempFile.length()];
-                            fis.read(bytes);
-                            fis.close();
+                        byte[] bytes = Files.readAllBytes(tempFile.toPath());
+                        ExifInterface exifInterface = new ExifInterface(tempFile.getAbsolutePath());
+                        
+                        if (location != null) {
+                            exifInterface.setGpsInfo(location);
+                        }
+                        
+                        JSONObject exifData = getExifData(exifInterface);
+
+                        if (width != null && height != null) {
+                            Bitmap bitmap = BitmapFactory.decodeByteArray(bytes, 0, bytes.length);
+                            Bitmap resizedBitmap = resizeBitmap(bitmap, width, height);
+                            ByteArrayOutputStream stream = new ByteArrayOutputStream();
+                            resizedBitmap.compress(Bitmap.CompressFormat.JPEG, quality, stream);
+                            bytes = stream.toByteArray();
+                        }
+                        
+                        if (saveToGallery) {
+                            saveImageToGallery(bytes);
                         }
 
                         String base64 = Base64.encodeToString(bytes, Base64.NO_WRAP);
-
-                        // Clean up temp file
+                        
                         tempFile.delete();
 
                         if (listener != null) {
-                            listener.onPictureTaken(base64);
+                            listener.onPictureTaken(base64, exifData);
                         }
                     } catch (Exception e) {
-                        Log.e(TAG, "capturePhoto: Error converting to base64", e);
+                        Log.e(TAG, "capturePhoto: Error processing image", e);
                         if (listener != null) {
                             listener.onPictureTakenError("Error processing image: " + e.getMessage());
                         }
@@ -365,6 +386,170 @@ public class CameraXView implements LifecycleOwner {
         );
     }
 
+    private Bitmap resizeBitmap(Bitmap bitmap, int width, int height) {
+        return Bitmap.createScaledBitmap(bitmap, width, height, true);
+    }
+    
+    private JSONObject getExifData(ExifInterface exifInterface) {
+        JSONObject exifData = new JSONObject();
+        try {
+            // Add all available exif tags to a JSON object
+            for (String[] tag : EXIF_TAGS) {
+                String value = exifInterface.getAttribute(tag[0]);
+                if (value != null) {
+                    exifData.put(tag[1], value);
+                }
+            }
+        } catch (Exception e) {
+            Log.e(TAG, "getExifData: Error reading exif data", e);
+        }
+        return exifData;
+    }
+
+    private static final String[][] EXIF_TAGS = new String[][]{
+        {ExifInterface.TAG_APERTURE_VALUE, "ApertureValue"},
+        {ExifInterface.TAG_ARTIST, "Artist"},
+        {ExifInterface.TAG_BITS_PER_SAMPLE, "BitsPerSample"},
+        {ExifInterface.TAG_BRIGHTNESS_VALUE, "BrightnessValue"},
+        {ExifInterface.TAG_CFA_PATTERN, "CFAPattern"},
+        {ExifInterface.TAG_COLOR_SPACE, "ColorSpace"},
+        {ExifInterface.TAG_COMPONENTS_CONFIGURATION, "ComponentsConfiguration"},
+        {ExifInterface.TAG_COMPRESSED_BITS_PER_PIXEL, "CompressedBitsPerPixel"},
+        {ExifInterface.TAG_COMPRESSION, "Compression"},
+        {ExifInterface.TAG_CONTRAST, "Contrast"},
+        {ExifInterface.TAG_COPYRIGHT, "Copyright"},
+        {ExifInterface.TAG_CUSTOM_RENDERED, "CustomRendered"},
+        {ExifInterface.TAG_DATETIME, "DateTime"},
+        {ExifInterface.TAG_DATETIME_DIGITIZED, "DateTimeDigitized"},
+        {ExifInterface.TAG_DATETIME_ORIGINAL, "DateTimeOriginal"},
+        {ExifInterface.TAG_DEVICE_SETTING_DESCRIPTION, "DeviceSettingDescription"},
+        {ExifInterface.TAG_DIGITAL_ZOOM_RATIO, "DigitalZoomRatio"},
+        {ExifInterface.TAG_DNG_VERSION, "DNGVersion"},
+        {ExifInterface.TAG_EXIF_VERSION, "ExifVersion"},
+        {ExifInterface.TAG_EXPOSURE_BIAS_VALUE, "ExposureBiasValue"},
+        {ExifInterface.TAG_EXPOSURE_INDEX, "ExposureIndex"},
+        {ExifInterface.TAG_EXPOSURE_MODE, "ExposureMode"},
+        {ExifInterface.TAG_EXPOSURE_PROGRAM, "ExposureProgram"},
+        {ExifInterface.TAG_EXPOSURE_TIME, "ExposureTime"},
+        {ExifInterface.TAG_FILE_SOURCE, "FileSource"},
+        {ExifInterface.TAG_FLASH, "Flash"},
+        {ExifInterface.TAG_FLASHPIX_VERSION, "FlashpixVersion"},
+        {ExifInterface.TAG_FLASH_ENERGY, "FlashEnergy"},
+        {ExifInterface.TAG_FOCAL_LENGTH, "FocalLength"},
+        {ExifInterface.TAG_FOCAL_LENGTH_IN_35MM_FILM, "FocalLengthIn35mmFilm"},
+        {ExifInterface.TAG_FOCAL_PLANE_RESOLUTION_UNIT, "FocalPlaneResolutionUnit"},
+        {ExifInterface.TAG_FOCAL_PLANE_X_RESOLUTION, "FocalPlaneXResolution"},
+        {ExifInterface.TAG_FOCAL_PLANE_Y_RESOLUTION, "FocalPlaneYResolution"},
+        {ExifInterface.TAG_F_NUMBER, "FNumber"},
+        {ExifInterface.TAG_GAIN_CONTROL, "GainControl"},
+        {ExifInterface.TAG_GPS_ALTITUDE, "GPSAltitude"},
+        {ExifInterface.TAG_GPS_ALTITUDE_REF, "GPSAltitudeRef"},
+        {ExifInterface.TAG_GPS_AREA_INFORMATION, "GPSAreaInformation"},
+        {ExifInterface.TAG_GPS_DATESTAMP, "GPSDateStamp"},
+        {ExifInterface.TAG_GPS_DEST_BEARING, "GPSDestBearing"},
+        {ExifInterface.TAG_GPS_DEST_BEARING_REF, "GPSDestBearingRef"},
+        {ExifInterface.TAG_GPS_DEST_DISTANCE, "GPSDestDistance"},
+        {ExifInterface.TAG_GPS_DEST_DISTANCE_REF, "GPSDestDistanceRef"},
+        {ExifInterface.TAG_GPS_DEST_LATITUDE, "GPSDestLatitude"},
+        {ExifInterface.TAG_GPS_DEST_LATITUDE_REF, "GPSDestLatitudeRef"},
+        {ExifInterface.TAG_GPS_DEST_LONGITUDE, "GPSDestLongitude"},
+        {ExifInterface.TAG_GPS_DEST_LONGITUDE_REF, "GPSDestLongitudeRef"},
+        {ExifInterface.TAG_GPS_DIFFERENTIAL, "GPSDifferential"},
+        {ExifInterface.TAG_GPS_DOP, "GPSDOP"},
+        {ExifInterface.TAG_GPS_IMG_DIRECTION, "GPSImgDirection"},
+        {ExifInterface.TAG_GPS_IMG_DIRECTION_REF, "GPSImgDirectionRef"},
+        {ExifInterface.TAG_GPS_LATITUDE, "GPSLatitude"},
+        {ExifInterface.TAG_GPS_LATITUDE_REF, "GPSLatitudeRef"},
+        {ExifInterface.TAG_GPS_LONGITUDE, "GPSLongitude"},
+        {ExifInterface.TAG_GPS_LONGITUDE_REF, "GPSLongitudeRef"},
+        {ExifInterface.TAG_GPS_MAP_DATUM, "GPSMapDatum"},
+        {ExifInterface.TAG_GPS_MEASURE_MODE, "GPSMeasureMode"},
+        {ExifInterface.TAG_GPS_PROCESSING_METHOD, "GPSProcessingMethod"},
+        {ExifInterface.TAG_GPS_SATELLITES, "GPSSatellites"},
+        {ExifInterface.TAG_GPS_SPEED, "GPSSpeed"},
+        {ExifInterface.TAG_GPS_SPEED_REF, "GPSSpeedRef"},
+        {ExifInterface.TAG_GPS_STATUS, "GPSStatus"},
+        {ExifInterface.TAG_GPS_TIMESTAMP, "GPSTimeStamp"},
+        {ExifInterface.TAG_GPS_TRACK, "GPSTrack"},
+        {ExifInterface.TAG_GPS_TRACK_REF, "GPSTrackRef"},
+        {ExifInterface.TAG_GPS_VERSION_ID, "GPSVersionID"},
+        {ExifInterface.TAG_IMAGE_DESCRIPTION, "ImageDescription"},
+        {ExifInterface.TAG_IMAGE_LENGTH, "ImageLength"},
+        {ExifInterface.TAG_IMAGE_UNIQUE_ID, "ImageUniqueID"},
+        {ExifInterface.TAG_IMAGE_WIDTH, "ImageWidth"},
+        {ExifInterface.TAG_INTEROPERABILITY_INDEX, "InteroperabilityIndex"},
+        {ExifInterface.TAG_ISO_SPEED, "ISOSpeed"},
+        {ExifInterface.TAG_ISO_SPEED_LATITUDE_YYY, "ISOSpeedLatitudeyyy"},
+        {ExifInterface.TAG_ISO_SPEED_LATITUDE_ZZZ, "ISOSpeedLatitudezzz"},
+        {ExifInterface.TAG_JPEG_INTERCHANGE_FORMAT, "JPEGInterchangeFormat"},
+        {ExifInterface.TAG_JPEG_INTERCHANGE_FORMAT_LENGTH, "JPEGInterchangeFormatLength"},
+        {ExifInterface.TAG_LIGHT_SOURCE, "LightSource"},
+        {ExifInterface.TAG_MAKE, "Make"},
+        {ExifInterface.TAG_MAKER_NOTE, "MakerNote"},
+        {ExifInterface.TAG_MAX_APERTURE_VALUE, "MaxApertureValue"},
+        {ExifInterface.TAG_METERING_MODE, "MeteringMode"},
+        {ExifInterface.TAG_MODEL, "Model"},
+        {ExifInterface.TAG_NEW_SUBFILE_TYPE, "NewSubfileType"},
+        {ExifInterface.TAG_OECF, "OECF"},
+        {ExifInterface.TAG_OFFSET_TIME, "OffsetTime"},
+        {ExifInterface.TAG_OFFSET_TIME_DIGITIZED, "OffsetTimeDigitized"},
+        {ExifInterface.TAG_OFFSET_TIME_ORIGINAL, "OffsetTimeOriginal"},
+        {ExifInterface.TAG_ORF_ASPECT_FRAME, "ORFAspectFrame"},
+        {ExifInterface.TAG_ORF_PREVIEW_IMAGE_LENGTH, "ORFPreviewImageLength"},
+        {ExifInterface.TAG_ORF_PREVIEW_IMAGE_START, "ORFPreviewImageStart"},
+        {ExifInterface.TAG_ORF_THUMBNAIL_IMAGE, "ORFThumbnailImage"},
+        {ExifInterface.TAG_ORIENTATION, "Orientation"},
+        {ExifInterface.TAG_PHOTOMETRIC_INTERPRETATION, "PhotometricInterpretation"},
+        {ExifInterface.TAG_PIXEL_X_DIMENSION, "PixelXDimension"},
+        {ExifInterface.TAG_PIXEL_Y_DIMENSION, "PixelYDimension"},
+        {ExifInterface.TAG_PLANAR_CONFIGURATION, "PlanarConfiguration"},
+        {ExifInterface.TAG_PRIMARY_CHROMATICITIES, "PrimaryChromaticities"},
+        {ExifInterface.TAG_RECOMMENDED_EXPOSURE_INDEX, "RecommendedExposureIndex"},
+        {ExifInterface.TAG_REFERENCE_BLACK_WHITE, "ReferenceBlackWhite"},
+        {ExifInterface.TAG_RELATED_SOUND_FILE, "RelatedSoundFile"},
+        {ExifInterface.TAG_RESOLUTION_UNIT, "ResolutionUnit"},
+        {ExifInterface.TAG_ROWS_PER_STRIP, "RowsPerStrip"},
+        {ExifInterface.TAG_RW2_ISO, "RW2ISO"},
+        {ExifInterface.TAG_RW2_JPG_FROM_RAW, "RW2JpgFromRaw"},
+        {ExifInterface.TAG_RW2_SENSOR_BOTTOM_BORDER, "RW2SensorBottomBorder"},
+        {ExifInterface.TAG_RW2_SENSOR_LEFT_BORDER, "RW2SensorLeftBorder"},
+        {ExifInterface.TAG_RW2_SENSOR_RIGHT_BORDER, "RW2SensorRightBorder"},
+        {ExifInterface.TAG_RW2_SENSOR_TOP_BORDER, "RW2SensorTopBorder"},
+        {ExifInterface.TAG_SAMPLES_PER_PIXEL, "SamplesPerPixel"},
+        {ExifInterface.TAG_SATURATION, "Saturation"},
+        {ExifInterface.TAG_SCENE_CAPTURE_TYPE, "SceneCaptureType"},
+        {ExifInterface.TAG_SCENE_TYPE, "SceneType"},
+        {ExifInterface.TAG_SENSING_METHOD, "SensingMethod"},
+        {ExifInterface.TAG_SENSITIVITY_TYPE, "SensitivityType"},
+        {ExifInterface.TAG_SHARPNESS, "Sharpness"},
+        {ExifInterface.TAG_SHUTTER_SPEED_VALUE, "ShutterSpeedValue"},
+        {ExifInterface.TAG_SOFTWARE, "Software"},
+        {ExifInterface.TAG_SPATIAL_FREQUENCY_RESPONSE, "SpatialFrequencyResponse"},
+        {ExifInterface.TAG_SPECTRAL_SENSITIVITY, "SpectralSensitivity"},
+        {ExifInterface.TAG_STANDARD_OUTPUT_SENSITIVITY, "StandardOutputSensitivity"},
+        {ExifInterface.TAG_STRIP_BYTE_COUNTS, "StripByteCounts"},
+        {ExifInterface.TAG_STRIP_OFFSETS, "StripOffsets"},
+        {ExifInterface.TAG_SUBFILE_TYPE, "SubfileType"},
+        {ExifInterface.TAG_SUBJECT_AREA, "SubjectArea"},
+        {ExifInterface.TAG_SUBJECT_DISTANCE, "SubjectDistance"},
+        {ExifInterface.TAG_SUBJECT_DISTANCE_RANGE, "SubjectDistanceRange"},
+        {ExifInterface.TAG_SUBJECT_LOCATION, "SubjectLocation"},
+        {ExifInterface.TAG_SUBSEC_TIME, "SubSecTime"},
+        {ExifInterface.TAG_SUBSEC_TIME_DIGITIZED, "SubSecTimeDigitized"},
+        {ExifInterface.TAG_SUBSEC_TIME_ORIGINAL, "SubSecTimeOriginal"},
+        {ExifInterface.TAG_THUMBNAIL_IMAGE_LENGTH, "ThumbnailImageLength"},
+        {ExifInterface.TAG_THUMBNAIL_IMAGE_WIDTH, "ThumbnailImageWidth"},
+        {ExifInterface.TAG_TRANSFER_FUNCTION, "TransferFunction"},
+        {ExifInterface.TAG_USER_COMMENT, "UserComment"},
+        {ExifInterface.TAG_WHITE_BALANCE, "WhiteBalance"},
+        {ExifInterface.TAG_WHITE_POINT, "WhitePoint"},
+        {ExifInterface.TAG_X_RESOLUTION, "XResolution"},
+        {ExifInterface.TAG_Y_CB_CR_COEFFICIENTS, "YCbCrCoefficients"},
+        {ExifInterface.TAG_Y_CB_CR_POSITIONING, "YCbCrPositioning"},
+        {ExifInterface.TAG_Y_CB_CR_SUB_SAMPLING, "YCbCrSubSampling"},
+        {ExifInterface.TAG_Y_RESOLUTION, "YResolution"}
+    };
+
     public void captureSample(int quality) {
         Log.d(TAG, "captureSample: Starting sample capture with quality: " + quality);
 
@@ -498,11 +683,10 @@ public class CameraXView implements LifecycleOwner {
         }
     }
 
-    public static ZoomFactors getZoomFactorsStatic(Context context) {
+    public static ZoomFactors getZoomFactorsStatic() {
         try {
             // For static method, return default zoom factors
             // We can try to detect if ultra-wide is available by checking device list
-            List<com.ahm.capacitor.camera.preview.model.CameraDevice> devices = getAvailableDevicesStatic(context);
 
             float minZoom = 1.0f;
             float maxZoom = 10.0f;
@@ -519,7 +703,7 @@ public class CameraXView implements LifecycleOwner {
 
     public ZoomFactors getZoomFactors() {
         if (camera == null) {
-            return getZoomFactorsStatic(context);
+            return getZoomFactorsStatic();
         }
 
         try {
@@ -546,8 +730,6 @@ public class CameraXView implements LifecycleOwner {
 
         try {
             float currentZoom = Objects.requireNonNull(camera.getCameraInfo().getZoomState().getValue()).getZoomRatio();
-            float minZoom = camera.getCameraInfo().getZoomState().getValue().getMinZoomRatio();
-            float maxZoom = camera.getCameraInfo().getZoomState().getValue().getMaxZoomRatio();
 
             // Determine device type based on zoom capabilities
             String deviceType = "wideAngle";
@@ -594,46 +776,6 @@ public class CameraXView implements LifecycleOwner {
         }
     }
 
-    private List<androidx.camera.core.CameraInfo> getAvailableCamerasForCurrentPosition() {
-        if (cameraProvider == null) {
-            Log.w(TAG, "getAvailableCamerasForCurrentPosition: cameraProvider is null");
-            return Collections.emptyList();
-        }
-
-        List<androidx.camera.core.CameraInfo> allCameras = cameraProvider.getAvailableCameraInfos();
-        List<androidx.camera.core.CameraInfo> sameFacingCameras = new ArrayList<>();
-
-        Log.d(TAG, "getAvailableCamerasForCurrentPosition: Total cameras available: " + allCameras.size());
-
-        // Determine current facing direction from the session config to avoid restricted API call
-        boolean isCurrentBack = "back".equals(sessionConfig.getPosition());
-        Log.d(TAG, "getAvailableCamerasForCurrentPosition: Looking for " + (isCurrentBack ? "back" : "front") + " cameras");
-
-        for (int i = 0; i < allCameras.size(); i++) {
-            androidx.camera.core.CameraInfo cameraInfo = allCameras.get(i);
-            boolean isCameraBack = isBackCamera(cameraInfo);
-            String cameraId = getCameraId(cameraInfo);
-
-            Log.d(TAG, "getAvailableCamerasForCurrentPosition: Camera " + i + " - ID: " + cameraId + ", isBack: " + isCameraBack);
-
-            try {
-                float minZoom = Objects.requireNonNull(cameraInfo.getZoomState().getValue()).getMinZoomRatio();
-                float maxZoom = cameraInfo.getZoomState().getValue().getMaxZoomRatio();
-                Log.d(TAG, "getAvailableCamerasForCurrentPosition: Camera " + i + " zoom range: " + minZoom + "-" + maxZoom);
-            } catch (Exception e) {
-                Log.w(TAG, "getAvailableCamerasForCurrentPosition: Cannot get zoom info for camera " + i + ": " + e.getMessage());
-            }
-
-            if (isCameraBack == isCurrentBack) {
-                sameFacingCameras.add(cameraInfo);
-                Log.d(TAG, "getAvailableCamerasForCurrentPosition: Added camera " + i + " (" + cameraId + ") to same-facing list");
-            }
-        }
-
-        Log.d(TAG, "getAvailableCamerasForCurrentPosition: Found " + sameFacingCameras.size() + " cameras for " + (isCurrentBack ? "back" : "front"));
-        return sameFacingCameras;
-    }
-
     public static List<Size> getSupportedPictureSizes(String facing) {
         List<Size> sizes = new ArrayList<>();
         try {
@@ -786,13 +928,13 @@ public class CameraXView implements LifecycleOwner {
                     Log.d(TAG, "switchToDevice: Found matching CameraInfo for deviceId: " + deviceId);
                     final CameraInfo finalTarget = targetCameraInfo;
 
-                    CameraSelector newSelector = new CameraSelector.Builder()
+                    // This filter will receive a list of all cameras and must return the one we want.
+
+                    currentCameraSelector = new CameraSelector.Builder()
                         .addCameraFilter(cameras -> {
                             // This filter will receive a list of all cameras and must return the one we want.
                             return Collections.singletonList(finalTarget);
                         }).build();
-
-                    currentCameraSelector = newSelector;
                     currentDeviceId = deviceId;
                     bindCameraUseCases(); // Rebind with the new, highly specific selector
                 } else {

package/dist/docs.json

@@ -57,7 +57,7 @@
       },
       {
         "name": "capture",
-        "signature": "(options: CameraPreviewPictureOptions) => Promise<{ value: string; }>",
+        "signature": "(options: CameraPreviewPictureOptions) => Promise<{ value: string; exif: ExifData; }>",
         "parameters": [
           {
             "name": "options",
@@ -65,7 +65,7 @@
             "type": "CameraPreviewPictureOptions"
           }
         ],
-        "returns": "Promise<{ value: string; }>",
+        "returns": "Promise<{ value: string; exif: ExifData; }>",
         "tags": [
           {
             "name": "param",
@@ -82,6 +82,7 @@
         ],
         "docs": "Captures a picture from the camera.",
         "complexTypes": [
+          "ExifData",
           "CameraPreviewPictureOptions"
         ],
         "slug": "capture"
@@ -688,7 +689,7 @@
           "name": "disableAudio",
           "tags": [
             {
-              "text": "false",
+              "text": "true",
               "name": "default"
             }
           ],
@@ -774,6 +775,14 @@
         }
       ]
     },
+    {
+      "name": "ExifData",
+      "slug": "exifdata",
+      "docs": "Represents EXIF data extracted from an image.",
+      "tags": [],
+      "methods": [],
+      "properties": []
+    },
     {
       "name": "CameraPreviewPictureOptions",
       "slug": "camerapreviewpictureoptions",
@@ -820,6 +829,38 @@
             "PictureFormat"
           ],
           "type": "PictureFormat"
+        },
+        {
+          "name": "saveToGallery",
+          "tags": [
+            {
+              "text": "false",
+              "name": "default"
+            },
+            {
+              "text": "7.5.0",
+              "name": "since"
+            }
+          ],
+          "docs": "If true, the captured image will be saved to the user's gallery.",
+          "complexTypes": [],
+          "type": "boolean | undefined"
+        },
+        {
+          "name": "withExifLocation",
+          "tags": [
+            {
+              "text": "false",
+              "name": "default"
+            },
+            {
+              "text": "7.6.0",
+              "name": "since"
+            }
+          ],
+          "docs": "If true, the plugin will attempt to add GPS location data to the image's EXIF metadata.\nThis may prompt the user for location permissions.",
+          "complexTypes": [],
+          "type": "boolean | undefined"
         }
       ]
     },

package/dist/esm/definitions.d.ts

@@ -140,7 +140,7 @@ export interface CameraPreviewOptions {
     enableHighResolution?: boolean;
     /**
      * If true, disables the audio stream, preventing audio permission requests.
-     * @default false
+     * @default true
      */
     disableAudio?: boolean;
     /**
@@ -192,6 +192,23 @@ export interface CameraPreviewPictureOptions {
      * @default "jpeg"
      */
     format?: PictureFormat;
+    /**
+     * If true, the captured image will be saved to the user's gallery.
+     * @default false
+     * @since 7.5.0
+     */
+    saveToGallery?: boolean;
+    /**
+     * If true, the plugin will attempt to add GPS location data to the image's EXIF metadata.
+     * This may prompt the user for location permissions.
+     * @default false
+     * @since 7.6.0
+     */
+    withExifLocation?: boolean;
+}
+/** Represents EXIF data extracted from an image. */
+export interface ExifData {
+    [key: string]: any;
 }
 export type PictureFormat = "jpeg" | "png";
 /** Defines a standard picture size with width and height. */
@@ -262,6 +279,7 @@ export interface CameraPreviewPlugin {
      */
     capture(options: CameraPreviewPictureOptions): Promise<{
         value: string;
+        exif: ExifData;
     }>;
     /**
      * Captures a single frame from the camera preview stream.

package/dist/esm/definitions.js.map

@@ -1 +1 @@
-{"version":3,"file":"definitions.js","sourceRoot":"","sources":["../../src/definitions.ts"],"names":[],"mappings":"AAIA,MAAM,CAAN,IAAY,UAQX;AARD,WAAY,UAAU;IACpB,sCAAwB,CAAA;IACxB,sCAAwB,CAAA;IACxB,qCAAuB,CAAA;IACvB,sCAAwB,CAAA;IACxB,2BAAa,CAAA;IACb,oCAAsB,CAAA;IACtB,+BAAiB,CAAA;AACnB,CAAC,EARW,UAAU,KAAV,UAAU,QAQrB","sourcesContent":["export type CameraPosition = \"rear\" | \"front\";\n\nexport type FlashMode = CameraPreviewFlashMode;\n\nexport enum DeviceType {\n  ULTRA_WIDE = \"ultraWide\",\n  WIDE_ANGLE = \"wideAngle\",\n  TELEPHOTO = \"telephoto\",\n  TRUE_DEPTH = \"trueDepth\",\n  DUAL = \"dual\",\n  DUAL_WIDE = \"dualWide\",\n  TRIPLE = \"triple\",\n}\n\n/**\n * Represents a single camera lens on a device. A {@link CameraDevice} can have multiple lenses.\n */\nexport interface CameraLens {\n  /** A human-readable name for the lens, e.g., \"Ultra-Wide\". */\n  label: string;\n  /** The type of the camera lens. */\n  deviceType: DeviceType;\n  /** The focal length of the lens in millimeters. */\n  focalLength: number;\n  /** The base zoom factor for this lens (e.g., 0.5 for ultra-wide, 1.0 for wide). */\n  baseZoomRatio: number;\n  /** The minimum zoom factor supported by this specific lens. */\n  minZoom: number;\n  /** The maximum zoom factor supported by this specific lens. */\n  maxZoom: number;\n}\n\n/**\n * Represents a physical camera on the device (e.g., the front-facing camera).\n */\nexport interface CameraDevice {\n  /** A unique identifier for the camera device. */\n  deviceId: string;\n  /** A human-readable name for the camera device. */\n  label: string;\n  /** The physical position of the camera on the device. */\n  position: CameraPosition;\n  /** A list of all available lenses for this camera device. */\n  lenses: CameraLens[];\n  /** The overall minimum zoom factor available across all lenses on this device. */\n  minZoom: number;\n  /** The overall maximum zoom factor available across all lenses on this device. */\n  maxZoom: number;\n  /** Identifies whether the device is a logical camera (composed of multiple physical lenses). */\n  isLogical: boolean;\n}\n\n/**\n * Represents the detailed information of the currently active lens.\n */\nexport interface LensInfo {\n  /** The focal length of the active lens in millimeters. */\n  focalLength: number;\n  /** The device type of the active lens. */\n  deviceType: DeviceType;\n  /** The base zoom ratio of the active lens (e.g., 0.5x, 1.0x). */\n  baseZoomRatio: number;\n  /** The current digital zoom factor applied on top of the base zoom. */\n  digitalZoom: number;\n}\n\n/**\n * Defines the configuration options for starting the camera preview.\n */\nexport interface CameraPreviewOptions {\n  /** \n   * The parent element to attach the video preview to.\n   * @platform web\n   */\n  parent?: string;\n  /** \n   * A CSS class name to add to the preview element.\n   * @platform web\n   */\n  className?: string;\n  /** \n   * The width of the preview in pixels. Defaults to the screen width.\n   * @platform android, ios, web\n   */\n  width?: number;\n  /** \n   * The height of the preview in pixels. Defaults to the screen height.\n   * @platform android, ios, web\n   */\n  height?: number;\n  /** \n   * The horizontal origin of the preview, in pixels.\n   * @platform android, ios\n   */\n  x?: number;\n  /** \n   * The vertical origin of the preview, in pixels.\n   * @platform android, ios\n   */\n  y?: number;\n  /** \n   * Adjusts the y-position to account for safe areas (e.g., notches).\n   * @platform ios\n   * @default false\n   */\n  includeSafeAreaInsets?: boolean;\n  /** \n   * If true, places the preview behind the webview.\n   * @platform android\n   * @default true\n   */\n  toBack?: boolean;\n  /** \n   * Bottom padding for the preview, in pixels.\n   * @platform android, ios\n   */\n  paddingBottom?: number;\n  /** \n   * Whether to rotate the preview when the device orientation changes.\n   * @platform ios\n   * @default true\n   */\n  rotateWhenOrientationChanged?: boolean;\n  /** \n   * The camera to use.\n   * @default \"rear\"\n   */\n  position?: CameraPosition | string;\n  /** \n   * If true, saves the captured image to a file and returns the file path.\n   * If false, returns a base64 encoded string.\n   * @default false\n   */\n  storeToFile?: boolean;\n  /** \n   * If true, prevents the plugin from rotating the image based on EXIF data.\n   * @platform android\n   * @default false\n   */\n  disableExifHeaderStripping?: boolean;\n  /** \n   * If true, enables high-resolution image capture.\n   * @platform ios\n   * @default false\n   */\n  enableHighResolution?: boolean;\n  /** \n   * If true, disables the audio stream, preventing audio permission requests.\n   * @default false\n   */\n  disableAudio?: boolean;\n  /** \n   * If true, locks the device orientation while the camera is active.\n   * @platform android\n   * @default false\n   */\n  lockAndroidOrientation?: boolean;\n  /** \n   * If true, allows the camera preview's opacity to be changed.\n   * @platform android, web\n   * @default false\n   */\n  enableOpacity?: boolean;\n  /** \n   * If true, enables pinch-to-zoom functionality on the preview.\n   * @platform android\n   * @default false\n   */\n  enableZoom?: boolean;\n  /** \n   * If true, uses the video-optimized preset for the camera session.\n   * @platform ios\n   * @default false\n   */\n  enableVideoMode?: boolean;\n  /** \n   * The `deviceId` of the camera to use. If provided, `position` is ignored.\n   * @platform ios\n   */\n  deviceId?: string;\n}\n\n/**\n * Defines the options for capturing a picture.\n */\nexport interface CameraPreviewPictureOptions {\n  /** The desired height of the picture in pixels. If not provided, the device default is used. */\n  height?: number;\n  /** The desired width of the picture in pixels. If not provided, the device default is used. */\n  width?: number;\n  /** \n   * The quality of the captured image, from 0 to 100.\n   * Does not apply to `png` format.\n   * @default 85\n   */\n  quality?: number;\n  /** \n   * The format of the captured image.\n   * @default \"jpeg\"\n   */\n  format?: PictureFormat;\n}\n\nexport type PictureFormat = \"jpeg\" | \"png\";\n\n/** Defines a standard picture size with width and height. */\nexport interface PictureSize {\n  /** The width of the picture in pixels. */\n  width: number;\n  /** The height of the picture in pixels. */\n  height: number;\n}\n\n/** Represents the supported picture sizes for a camera facing a certain direction. */\nexport interface SupportedPictureSizes {\n  /** The camera direction (\"front\" or \"rear\"). */\n  facing: string;\n  /** A list of supported picture sizes for this camera. */\n  supportedPictureSizes: PictureSize[];\n}\n\n/**\n * Defines the options for capturing a sample frame from the camera preview.\n */\nexport interface CameraSampleOptions {\n  /** \n   * The quality of the captured sample, from 0 to 100.\n   * @default 85\n   */\n  quality?: number;\n}\n\n/**\n * The available flash modes for the camera.\n * 'torch' is a continuous light mode.\n */\nexport type CameraPreviewFlashMode =\n  | \"off\"\n  | \"on\"\n  | \"auto\"\n  | \"torch\";\n\n/**\n * Defines the options for setting the camera preview's opacity.\n */\nexport interface CameraOpacityOptions {\n  /** \n   * The opacity percentage, from 0.0 (fully transparent) to 1.0 (fully opaque).\n   * @default 1.0\n   */\n  opacity?: number;\n}\n\n/**\n * The main interface for the CameraPreview plugin.\n */\nexport interface CameraPreviewPlugin {\n  /**\n   * Starts the camera preview.\n   *\n   * @param {CameraPreviewOptions} options - The configuration for the camera preview.\n   * @returns {Promise<void>} A promise that resolves when the camera preview is started.\n   * @since 0.0.1\n   */\n  start(options: CameraPreviewOptions): Promise<void>;\n\n  /**\n   * Stops the camera preview.\n   *\n   * @returns {Promise<void>} A promise that resolves when the camera preview is stopped.\n   * @since 0.0.1\n   */\n  stop(): Promise<void>;\n\n  /**\n   * Captures a picture from the camera.\n   *\n   * @param {CameraPreviewPictureOptions} options - The options for capturing the picture.\n   * @returns {Promise<{ value: string }>} A promise that resolves with the captured image data.\n   * The `value` is a base64 encoded string unless `storeToFile` is true, in which case it's a file path.\n   * @since 0.0.1\n   */\n  capture(options: CameraPreviewPictureOptions): Promise<{ value: string }>;\n\n  /**\n   * Captures a single frame from the camera preview stream.\n   *\n   * @param {CameraSampleOptions} options - The options for capturing the sample.\n   * @returns {Promise<{ value: string }>} A promise that resolves with the sample image as a base64 encoded string.\n   * @since 0.0.1\n   */\n  captureSample(options: CameraSampleOptions): Promise<{ value: string }>;\n\n  /**\n   * Gets the flash modes supported by the active camera.\n   *\n   * @returns {Promise<{ result: CameraPreviewFlashMode[] }>} A promise that resolves with an array of supported flash modes.\n   * @since 0.0.1\n   */\n  getSupportedFlashModes(): Promise<{\n    result: CameraPreviewFlashMode[];\n  }>;\n\n  /**\n   * Gets the horizontal field of view (FoV) for the active camera.\n   * Note: This can be an estimate on some devices.\n   *\n   * @returns {Promise<{ result: number }>} A promise that resolves with the horizontal field of view in degrees.\n   * @since 0.0.1\n   */\n  getHorizontalFov(): Promise<{\n    result: number;\n  }>;\n\n  /**\n   * Gets the supported picture sizes for all cameras.\n   *\n   * @returns {Promise<{ supportedPictureSizes: SupportedPictureSizes[] }>} A promise that resolves with the list of supported sizes.\n   * @since 7.4.0\n   */\n  getSupportedPictureSizes(): Promise<{\n    supportedPictureSizes: SupportedPictureSizes[];\n  }>;\n\n  /**\n   * Sets the flash mode for the active camera.\n   *\n   * @param {{ flashMode: CameraPreviewFlashMode | string }} options - The desired flash mode.\n   * @returns {Promise<void>} A promise that resolves when the flash mode is set.\n   * @since 0.0.1\n   */\n  setFlashMode(options: {\n    flashMode: CameraPreviewFlashMode | string;\n  }): Promise<void>;\n\n  /**\n   * Toggles between the front and rear cameras.\n   *\n   * @returns {Promise<void>} A promise that resolves when the camera is flipped.\n   * @since 0.0.1\n   */\n  flip(): Promise<void>;\n\n  /**\n   * Sets the opacity of the camera preview.\n   *\n   * @param {CameraOpacityOptions} options - The opacity options.\n   * @returns {Promise<void>} A promise that resolves when the opacity is set.\n   * @since 0.0.1\n   */\n  setOpacity(options: CameraOpacityOptions): Promise<void>;\n\n  /**\n   * Stops an ongoing video recording.\n   *\n   * @returns {Promise<{ videoFilePath: string }>} A promise that resolves with the path to the recorded video file.\n   * @since 0.0.1\n   */\n  stopRecordVideo(): Promise<{ videoFilePath: string }>;\n\n  /**\n   * Starts recording a video.\n   *\n   * @param {CameraPreviewOptions} options - The options for video recording.\n   * @returns {Promise<void>} A promise that resolves when video recording starts.\n   * @since 0.0.1\n   */\n  startRecordVideo(options: CameraPreviewOptions): Promise<void>;\n\n  /**\n   * Checks if the camera preview is currently running.\n   *\n   * @returns {Promise<{ isRunning: boolean }>} A promise that resolves with the running state.\n   * @since 7.4.0\n   */\n  isRunning(): Promise<{ isRunning: boolean }>;\n\n  /**\n   * Gets all available camera devices.\n   *\n   * @returns {Promise<{ devices: CameraDevice[] }>} A promise that resolves with the list of available camera devices.\n   * @since 7.4.0\n   */\n  getAvailableDevices(): Promise<{ devices: CameraDevice[] }>;\n\n  /**\n   * Gets the current zoom state, including min/max and current lens info.\n   *\n   * @returns {Promise<{ min: number; max: number; current: number; lens: LensInfo }>} A promise that resolves with the zoom state.\n   * @since 7.4.0\n   */\n  getZoom(): Promise<{ \n    min: number; \n    max: number; \n    current: number;\n    lens: LensInfo;\n  }>;\n\n  /**\n   * Sets the camera's zoom level.\n   *\n   * @param {{ level: number; ramp?: boolean }} options - The desired zoom level. `ramp` is currently unused.\n   * @returns {Promise<void>} A promise that resolves when the zoom level is set.\n   * @since 7.4.0\n   */\n  setZoom(options: { level: number; ramp?: boolean }): Promise<void>;\n\n  /**\n   * Gets the current flash mode.\n   *\n   * @returns {Promise<{ flashMode: FlashMode }>} A promise that resolves with the current flash mode.\n   * @since 7.4.0\n   */\n  getFlashMode(): Promise<{ flashMode: FlashMode }>;\n\n  /**\n   * Removes all registered listeners.\n   *\n   * @since 7.4.0\n   */\n  removeAllListeners(): Promise<void>;\n\n  /**\n   * Switches the active camera to the one with the specified `deviceId`.\n   *\n   * @param {{ deviceId: string }} options - The ID of the device to switch to.\n   * @returns {Promise<void>} A promise that resolves when the camera is switched.\n   * @since 7.4.0\n   */\n  setDeviceId(options: { deviceId: string }): Promise<void>;\n\n  /**\n   * Gets the ID of the currently active camera device.\n   *\n   * @returns {Promise<{ deviceId: string }>} A promise that resolves with the current device ID.\n   * @since 7.4.0\n   */\n  getDeviceId(): Promise<{ deviceId: string }>;\n}\n"]}
+{"version":3,"file":"definitions.js","sourceRoot":"","sources":["../../src/definitions.ts"],"names":[],"mappings":"AAIA,MAAM,CAAN,IAAY,UAQX;AARD,WAAY,UAAU;IACpB,sCAAwB,CAAA;IACxB,sCAAwB,CAAA;IACxB,qCAAuB,CAAA;IACvB,sCAAwB,CAAA;IACxB,2BAAa,CAAA;IACb,oCAAsB,CAAA;IACtB,+BAAiB,CAAA;AACnB,CAAC,EARW,UAAU,KAAV,UAAU,QAQrB","sourcesContent":["export type CameraPosition = \"rear\" | \"front\";\n\nexport type FlashMode = CameraPreviewFlashMode;\n\nexport enum DeviceType {\n  ULTRA_WIDE = \"ultraWide\",\n  WIDE_ANGLE = \"wideAngle\",\n  TELEPHOTO = \"telephoto\",\n  TRUE_DEPTH = \"trueDepth\",\n  DUAL = \"dual\",\n  DUAL_WIDE = \"dualWide\",\n  TRIPLE = \"triple\",\n}\n\n/**\n * Represents a single camera lens on a device. A {@link CameraDevice} can have multiple lenses.\n */\nexport interface CameraLens {\n  /** A human-readable name for the lens, e.g., \"Ultra-Wide\". */\n  label: string;\n  /** The type of the camera lens. */\n  deviceType: DeviceType;\n  /** The focal length of the lens in millimeters. */\n  focalLength: number;\n  /** The base zoom factor for this lens (e.g., 0.5 for ultra-wide, 1.0 for wide). */\n  baseZoomRatio: number;\n  /** The minimum zoom factor supported by this specific lens. */\n  minZoom: number;\n  /** The maximum zoom factor supported by this specific lens. */\n  maxZoom: number;\n}\n\n/**\n * Represents a physical camera on the device (e.g., the front-facing camera).\n */\nexport interface CameraDevice {\n  /** A unique identifier for the camera device. */\n  deviceId: string;\n  /** A human-readable name for the camera device. */\n  label: string;\n  /** The physical position of the camera on the device. */\n  position: CameraPosition;\n  /** A list of all available lenses for this camera device. */\n  lenses: CameraLens[];\n  /** The overall minimum zoom factor available across all lenses on this device. */\n  minZoom: number;\n  /** The overall maximum zoom factor available across all lenses on this device. */\n  maxZoom: number;\n  /** Identifies whether the device is a logical camera (composed of multiple physical lenses). */\n  isLogical: boolean;\n}\n\n/**\n * Represents the detailed information of the currently active lens.\n */\nexport interface LensInfo {\n  /** The focal length of the active lens in millimeters. */\n  focalLength: number;\n  /** The device type of the active lens. */\n  deviceType: DeviceType;\n  /** The base zoom ratio of the active lens (e.g., 0.5x, 1.0x). */\n  baseZoomRatio: number;\n  /** The current digital zoom factor applied on top of the base zoom. */\n  digitalZoom: number;\n}\n\n/**\n * Defines the configuration options for starting the camera preview.\n */\nexport interface CameraPreviewOptions {\n  /** \n   * The parent element to attach the video preview to.\n   * @platform web\n   */\n  parent?: string;\n  /** \n   * A CSS class name to add to the preview element.\n   * @platform web\n   */\n  className?: string;\n  /** \n   * The width of the preview in pixels. Defaults to the screen width.\n   * @platform android, ios, web\n   */\n  width?: number;\n  /** \n   * The height of the preview in pixels. Defaults to the screen height.\n   * @platform android, ios, web\n   */\n  height?: number;\n  /** \n   * The horizontal origin of the preview, in pixels.\n   * @platform android, ios\n   */\n  x?: number;\n  /** \n   * The vertical origin of the preview, in pixels.\n   * @platform android, ios\n   */\n  y?: number;\n  /** \n   * Adjusts the y-position to account for safe areas (e.g., notches).\n   * @platform ios\n   * @default false\n   */\n  includeSafeAreaInsets?: boolean;\n  /** \n   * If true, places the preview behind the webview.\n   * @platform android\n   * @default true\n   */\n  toBack?: boolean;\n  /** \n   * Bottom padding for the preview, in pixels.\n   * @platform android, ios\n   */\n  paddingBottom?: number;\n  /** \n   * Whether to rotate the preview when the device orientation changes.\n   * @platform ios\n   * @default true\n   */\n  rotateWhenOrientationChanged?: boolean;\n  /** \n   * The camera to use.\n   * @default \"rear\"\n   */\n  position?: CameraPosition | string;\n  /** \n   * If true, saves the captured image to a file and returns the file path.\n   * If false, returns a base64 encoded string.\n   * @default false\n   */\n  storeToFile?: boolean;\n  /** \n   * If true, prevents the plugin from rotating the image based on EXIF data.\n   * @platform android\n   * @default false\n   */\n  disableExifHeaderStripping?: boolean;\n  /** \n   * If true, enables high-resolution image capture.\n   * @platform ios\n   * @default false\n   */\n  enableHighResolution?: boolean;\n  /** \n   * If true, disables the audio stream, preventing audio permission requests.\n   * @default true\n   */\n  disableAudio?: boolean;\n  /** \n   * If true, locks the device orientation while the camera is active.\n   * @platform android\n   * @default false\n   */\n  lockAndroidOrientation?: boolean;\n  /** \n   * If true, allows the camera preview's opacity to be changed.\n   * @platform android, web\n   * @default false\n   */\n  enableOpacity?: boolean;\n  /** \n   * If true, enables pinch-to-zoom functionality on the preview.\n   * @platform android\n   * @default false\n   */\n  enableZoom?: boolean;\n  /** \n   * If true, uses the video-optimized preset for the camera session.\n   * @platform ios\n   * @default false\n   */\n  enableVideoMode?: boolean;\n  /** \n   * The `deviceId` of the camera to use. If provided, `position` is ignored.\n   * @platform ios\n   */\n  deviceId?: string;\n}\n\n/**\n * Defines the options for capturing a picture.\n */\nexport interface CameraPreviewPictureOptions {\n  /** The desired height of the picture in pixels. If not provided, the device default is used. */\n  height?: number;\n  /** The desired width of the picture in pixels. If not provided, the device default is used. */\n  width?: number;\n  /** \n   * The quality of the captured image, from 0 to 100.\n   * Does not apply to `png` format.\n   * @default 85\n   */\n  quality?: number;\n  /** \n   * The format of the captured image.\n   * @default \"jpeg\"\n   */\n  format?: PictureFormat;\n  /**\n   * If true, the captured image will be saved to the user's gallery.\n   * @default false\n   * @since 7.5.0\n   */\n  saveToGallery?: boolean;\n  /**\n   * If true, the plugin will attempt to add GPS location data to the image's EXIF metadata.\n   * This may prompt the user for location permissions.\n   * @default false\n   * @since 7.6.0\n   */\n  withExifLocation?: boolean;\n}\n\n/** Represents EXIF data extracted from an image. */\nexport interface ExifData {\n  [key: string]: any;\n}\n\nexport type PictureFormat = \"jpeg\" | \"png\";\n\n/** Defines a standard picture size with width and height. */\nexport interface PictureSize {\n  /** The width of the picture in pixels. */\n  width: number;\n  /** The height of the picture in pixels. */\n  height: number;\n}\n\n/** Represents the supported picture sizes for a camera facing a certain direction. */\nexport interface SupportedPictureSizes {\n  /** The camera direction (\"front\" or \"rear\"). */\n  facing: string;\n  /** A list of supported picture sizes for this camera. */\n  supportedPictureSizes: PictureSize[];\n}\n\n/**\n * Defines the options for capturing a sample frame from the camera preview.\n */\nexport interface CameraSampleOptions {\n  /** \n   * The quality of the captured sample, from 0 to 100.\n   * @default 85\n   */\n  quality?: number;\n}\n\n/**\n * The available flash modes for the camera.\n * 'torch' is a continuous light mode.\n */\nexport type CameraPreviewFlashMode =\n  | \"off\"\n  | \"on\"\n  | \"auto\"\n  | \"torch\";\n\n/**\n * Defines the options for setting the camera preview's opacity.\n */\nexport interface CameraOpacityOptions {\n  /** \n   * The opacity percentage, from 0.0 (fully transparent) to 1.0 (fully opaque).\n   * @default 1.0\n   */\n  opacity?: number;\n}\n\n/**\n * The main interface for the CameraPreview plugin.\n */\nexport interface CameraPreviewPlugin {\n  /**\n   * Starts the camera preview.\n   *\n   * @param {CameraPreviewOptions} options - The configuration for the camera preview.\n   * @returns {Promise<void>} A promise that resolves when the camera preview is started.\n   * @since 0.0.1\n   */\n  start(options: CameraPreviewOptions): Promise<void>;\n\n  /**\n   * Stops the camera preview.\n   *\n   * @returns {Promise<void>} A promise that resolves when the camera preview is stopped.\n   * @since 0.0.1\n   */\n  stop(): Promise<void>;\n\n  /**\n   * Captures a picture from the camera.\n   *\n   * @param {CameraPreviewPictureOptions} options - The options for capturing the picture.\n   * @returns {Promise<{ value: string }>} A promise that resolves with the captured image data.\n   * The `value` is a base64 encoded string unless `storeToFile` is true, in which case it's a file path.\n   * @since 0.0.1\n   */\n  capture(\n    options: CameraPreviewPictureOptions\n  ): Promise<{ value: string; exif: ExifData }>;\n\n  /**\n   * Captures a single frame from the camera preview stream.\n   *\n   * @param {CameraSampleOptions} options - The options for capturing the sample.\n   * @returns {Promise<{ value: string }>} A promise that resolves with the sample image as a base64 encoded string.\n   * @since 0.0.1\n   */\n  captureSample(options: CameraSampleOptions): Promise<{ value: string }>;\n\n  /**\n   * Gets the flash modes supported by the active camera.\n   *\n   * @returns {Promise<{ result: CameraPreviewFlashMode[] }>} A promise that resolves with an array of supported flash modes.\n   * @since 0.0.1\n   */\n  getSupportedFlashModes(): Promise<{\n    result: CameraPreviewFlashMode[];\n  }>;\n\n  /**\n   * Gets the horizontal field of view (FoV) for the active camera.\n   * Note: This can be an estimate on some devices.\n   *\n   * @returns {Promise<{ result: number }>} A promise that resolves with the horizontal field of view in degrees.\n   * @since 0.0.1\n   */\n  getHorizontalFov(): Promise<{\n    result: number;\n  }>;\n\n  /**\n   * Gets the supported picture sizes for all cameras.\n   *\n   * @returns {Promise<{ supportedPictureSizes: SupportedPictureSizes[] }>} A promise that resolves with the list of supported sizes.\n   * @since 7.4.0\n   */\n  getSupportedPictureSizes(): Promise<{\n    supportedPictureSizes: SupportedPictureSizes[];\n  }>;\n\n  /**\n   * Sets the flash mode for the active camera.\n   *\n   * @param {{ flashMode: CameraPreviewFlashMode | string }} options - The desired flash mode.\n   * @returns {Promise<void>} A promise that resolves when the flash mode is set.\n   * @since 0.0.1\n   */\n  setFlashMode(options: {\n    flashMode: CameraPreviewFlashMode | string;\n  }): Promise<void>;\n\n  /**\n   * Toggles between the front and rear cameras.\n   *\n   * @returns {Promise<void>} A promise that resolves when the camera is flipped.\n   * @since 0.0.1\n   */\n  flip(): Promise<void>;\n\n  /**\n   * Sets the opacity of the camera preview.\n   *\n   * @param {CameraOpacityOptions} options - The opacity options.\n   * @returns {Promise<void>} A promise that resolves when the opacity is set.\n   * @since 0.0.1\n   */\n  setOpacity(options: CameraOpacityOptions): Promise<void>;\n\n  /**\n   * Stops an ongoing video recording.\n   *\n   * @returns {Promise<{ videoFilePath: string }>} A promise that resolves with the path to the recorded video file.\n   * @since 0.0.1\n   */\n  stopRecordVideo(): Promise<{ videoFilePath: string }>;\n\n  /**\n   * Starts recording a video.\n   *\n   * @param {CameraPreviewOptions} options - The options for video recording.\n   * @returns {Promise<void>} A promise that resolves when video recording starts.\n   * @since 0.0.1\n   */\n  startRecordVideo(options: CameraPreviewOptions): Promise<void>;\n\n  /**\n   * Checks if the camera preview is currently running.\n   *\n   * @returns {Promise<{ isRunning: boolean }>} A promise that resolves with the running state.\n   * @since 7.4.0\n   */\n  isRunning(): Promise<{ isRunning: boolean }>;\n\n  /**\n   * Gets all available camera devices.\n   *\n   * @returns {Promise<{ devices: CameraDevice[] }>} A promise that resolves with the list of available camera devices.\n   * @since 7.4.0\n   */\n  getAvailableDevices(): Promise<{ devices: CameraDevice[] }>;\n\n  /**\n   * Gets the current zoom state, including min/max and current lens info.\n   *\n   * @returns {Promise<{ min: number; max: number; current: number; lens: LensInfo }>} A promise that resolves with the zoom state.\n   * @since 7.4.0\n   */\n  getZoom(): Promise<{ \n    min: number; \n    max: number; \n    current: number;\n    lens: LensInfo;\n  }>;\n\n  /**\n   * Sets the camera's zoom level.\n   *\n   * @param {{ level: number; ramp?: boolean }} options - The desired zoom level. `ramp` is currently unused.\n   * @returns {Promise<void>} A promise that resolves when the zoom level is set.\n   * @since 7.4.0\n   */\n  setZoom(options: { level: number; ramp?: boolean }): Promise<void>;\n\n  /**\n   * Gets the current flash mode.\n   *\n   * @returns {Promise<{ flashMode: FlashMode }>} A promise that resolves with the current flash mode.\n   * @since 7.4.0\n   */\n  getFlashMode(): Promise<{ flashMode: FlashMode }>;\n\n  /**\n   * Removes all registered listeners.\n   *\n   * @since 7.4.0\n   */\n  removeAllListeners(): Promise<void>;\n\n  /**\n   * Switches the active camera to the one with the specified `deviceId`.\n   *\n   * @param {{ deviceId: string }} options - The ID of the device to switch to.\n   * @returns {Promise<void>} A promise that resolves when the camera is switched.\n   * @since 7.4.0\n   */\n  setDeviceId(options: { deviceId: string }): Promise<void>;\n\n  /**\n   * Gets the ID of the currently active camera device.\n   *\n   * @returns {Promise<{ deviceId: string }>} A promise that resolves with the current device ID.\n   * @since 7.4.0\n   */\n  getDeviceId(): Promise<{ deviceId: string }>;\n}\n"]}