@capgo/camera-preview 8.8.1 → 8.10.0

package/README.md

@@ -427,6 +427,9 @@ Documentation for the [uploader](https://github.com/Cap-go/capacitor-uploader)
 * [`getExposureCompensationRange()`](#getexposurecompensationrange)
 * [`getExposureCompensation()`](#getexposurecompensation)
 * [`setExposureCompensation(...)`](#setexposurecompensation)
+* [`getWhiteBalanceModes()`](#getwhitebalancemodes)
+* [`getWhiteBalanceMode()`](#getwhitebalancemode)
+* [`setWhiteBalanceMode(...)`](#setwhitebalancemode)
 * [`getSupportedVideoFrameRates()`](#getsupportedvideoframerates)
 * [`getVideoFrameRate()`](#getvideoframerate)
 * [`setVideoFrameRate(...)`](#setvideoframerate)
@@ -1379,6 +1382,52 @@ Sets the exposure compensation (EV bias). Value will be clamped to range.
 --------------------
 
 
+### getWhiteBalanceModes()
+
+```typescript
+getWhiteBalanceModes() => Promise<{ modes: WhiteBalanceMode[]; }>
+```
+
+Returns the white-balance modes supported by the active camera.
+Modes can include: 'AUTO', 'LOCK', 'CONTINUOUS'. `CUSTOM` is not listed
+until manual gains support is implemented.
+
+**Returns:** <code>Promise&lt;{ modes: WhiteBalanceMode[]; }&gt;</code>
+
+--------------------
+
+
+### getWhiteBalanceMode()
+
+```typescript
+getWhiteBalanceMode() => Promise<{ mode: WhiteBalanceMode; }>
+```
+
+Returns the current white-balance mode.
+
+**Returns:** <code>Promise&lt;{ mode: <a href="#whitebalancemode">WhiteBalanceMode</a>; }&gt;</code>
+
+--------------------
+
+
+### setWhiteBalanceMode(...)
+
+```typescript
+setWhiteBalanceMode(options: { mode: WhiteBalanceMode; }) => Promise<void>
+```
+
+Sets the white-balance mode. `CONTINUOUS` keeps auto white balance running
+(recommended; avoids a warm/yellow cast), `LOCK` freezes the current gains,
+`AUTO` performs a one-time adjustment. `CUSTOM` is reserved and rejected
+until manual gains support is implemented.
+
+| Param         | Type                                                                     |
+| ------------- | ------------------------------------------------------------------------ |
+| **`options`** | <code>{ mode: <a href="#whitebalancemode">WhiteBalanceMode</a>; }</code> |
+
+--------------------
+
+
 ### getSupportedVideoFrameRates()
 
 ```typescript
@@ -1516,15 +1565,17 @@ Defines the options for capturing a picture.
 | **`embedTimestamp`**             | <code>boolean</code>                                    | If true, the plugin will embed a timestamp in the top-right corner of the image.                                                                                                                                                                                                                                                                                                      | <code>false</code>   | 7.17.0 |
 | **`embedLocation`**              | <code>boolean</code>                                    | If true, the plugin will embed the current location in the top-right corner of the image. Requires `withExifLocation` to be enabled.                                                                                                                                                                                                                                                  | <code>false</code>   | 7.18.0 |
 | **`photoQualityPrioritization`** | <code>'speed' \| 'balanced' \| 'quality'</code>         | Sets the priority for photo quality vs. capture speed. - "speed": Prioritizes faster capture times, may reduce image quality. - "balanced": Aims for a balance between quality and speed. - "quality": Prioritizes image quality, may reduce capture speed. See https://developer.apple.com/documentation/avfoundation/avcapturephotosettings/photoqualityprioritization for details. | <code>"speed"</code> | 7.21.0 |
+| **`mirrorFrontCamera`**          | <code>boolean</code>                                    | If true and the front camera is active, horizontally mirror the captured photo so it matches a selfie-style preview. Rear camera captures are never mirrored. Defaults to false to preserve the previous non-mirrored behavior.                                                                                                                                                       | <code>false</code>   | 8.10.0 |
 
 
 #### CameraSampleOptions
 
 Defines the options for capturing a sample frame from the camera preview.
 
-| Prop          | Type                | Description                                        | Default         |
-| ------------- | ------------------- | -------------------------------------------------- | --------------- |
-| **`quality`** | <code>number</code> | The quality of the captured sample, from 0 to 100. | <code>85</code> |
+| Prop                    | Type                 | Description                                                                                                                                                                                                                     | Default            | Since  |
+| ----------------------- | -------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------ | ------ |
+| **`quality`**           | <code>number</code>  | The quality of the captured sample, from 0 to 100.                                                                                                                                                                              | <code>85</code>    |        |
+| **`mirrorFrontCamera`** | <code>boolean</code> | If true and the front camera is active, horizontally mirror the captured sample so it matches a selfie-style preview. Rear camera samples are never mirrored. Defaults to false to preserve the previous non-mirrored behavior. | <code>false</code> | 8.10.0 |
 
 
 #### CameraPermissionStatus
@@ -1774,6 +1825,15 @@ Reusable exposure mode type for cross-platform support.
 <code>'AUTO' | 'LOCK' | 'CONTINUOUS' | 'CUSTOM'</code>
 
 
+#### WhiteBalanceMode
+
+Reusable white-balance mode type for cross-platform support.
+`CUSTOM` is reserved for a future manual white-balance gains API and is not
+returned by `getWhiteBalanceModes()` until implemented.
+
+<code>'AUTO' | 'LOCK' | 'CONTINUOUS' | 'CUSTOM'</code>
+
+
 ### Enums
 
 

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

@@ -195,6 +195,49 @@ public class CameraPreview extends Plugin implements CameraXView.CameraXViewList
         }
     }
 
+    @PluginMethod
+    public void getWhiteBalanceModes(PluginCall call) {
+        if (cameraXView == null || !cameraXView.isRunning()) {
+            call.reject("Camera is not running");
+            return;
+        }
+        JSArray arr = new JSArray();
+        for (String m : cameraXView.getWhiteBalanceModes()) arr.put(m);
+        JSObject ret = new JSObject();
+        ret.put("modes", arr);
+        call.resolve(ret);
+    }
+
+    @PluginMethod
+    public void getWhiteBalanceMode(PluginCall call) {
+        if (cameraXView == null || !cameraXView.isRunning()) {
+            call.reject("Camera is not running");
+            return;
+        }
+        JSObject ret = new JSObject();
+        ret.put("mode", cameraXView.getWhiteBalanceMode());
+        call.resolve(ret);
+    }
+
+    @PluginMethod
+    public void setWhiteBalanceMode(PluginCall call) {
+        if (cameraXView == null || !cameraXView.isRunning()) {
+            call.reject("Camera is not running");
+            return;
+        }
+        String mode = call.getString("mode");
+        if (mode == null || mode.isEmpty()) {
+            call.reject("mode parameter is required");
+            return;
+        }
+        try {
+            cameraXView.setWhiteBalanceMode(mode);
+            call.resolve();
+        } catch (Exception e) {
+            call.reject("Failed to set white balance mode: " + e.getMessage());
+        }
+    }
+
     @PluginMethod
     public void getExposureModes(PluginCall call) {
         if (cameraXView == null || !cameraXView.isRunning()) {
@@ -484,8 +527,9 @@ public class CameraPreview extends Plugin implements CameraXView.CameraXViewList
         Integer height = call.getInt("height");
         final boolean embedTimestamp = Boolean.TRUE.equals(call.getBoolean("embedTimestamp"));
         final boolean embedLocation = Boolean.TRUE.equals(call.getBoolean("embedLocation"));
+        final boolean mirrorFrontCamera = Boolean.TRUE.equals(call.getBoolean("mirrorFrontCamera"));
 
-        cameraXView.capturePhoto(quality, saveToGallery, width, height, location, embedTimestamp, embedLocation);
+        cameraXView.capturePhoto(quality, saveToGallery, width, height, location, embedTimestamp, embedLocation, mirrorFrontCamera);
     }
 
     @PluginMethod
@@ -497,7 +541,8 @@ public class CameraPreview extends Plugin implements CameraXView.CameraXViewList
         bridge.saveCall(call);
         sampleCallbackId = call.getCallbackId();
         Integer quality = Objects.requireNonNull(call.getInt("quality", 85));
-        cameraXView.captureSample(quality);
+        final boolean mirrorFrontCamera = Boolean.TRUE.equals(call.getBoolean("mirrorFrontCamera"));
+        cameraXView.captureSample(quality, mirrorFrontCamera);
     }
 
     @PluginMethod

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

@@ -191,6 +191,7 @@ public class CameraXView implements LifecycleOwner, LifecycleObserver {
     private Runnable pendingFrameRateBindSuccess;
     private java.util.function.Consumer<String> pendingFrameRateBindError;
     private String currentExposureMode = "CONTINUOUS"; // Default behavior
+    private String currentWhiteBalanceMode = "CONTINUOUS"; // Default behavior
     // Capture/stop coordination
     private final Object captureLock = new Object();
     private volatile boolean isCapturingPhoto = false;
@@ -1183,6 +1184,7 @@ public class CameraXView implements LifecycleOwner, LifecycleObserver {
                 }
 
                 resetExposureCompensationToDefault();
+                reapplyCameraControlModes();
 
                 // Log details about the active camera
                 Log.d(TAG, "Use cases bound. Inspecting active camera and use cases.");
@@ -2024,7 +2026,8 @@ public class CameraXView implements LifecycleOwner, LifecycleObserver {
         Integer height,
         Location location,
         final boolean embedTimestamp,
-        final boolean embedLocation
+        final boolean embedLocation,
+        final boolean mirrorFrontCamera
     ) {
         if (imageCapture == null) {
             if (listener != null) {
@@ -2058,7 +2061,9 @@ public class CameraXView implements LifecycleOwner, LifecycleObserver {
                 ", embedTimestamp: " +
                 embedTimestamp +
                 ", embedLocation: " +
-                embedLocation
+                embedLocation +
+                ", mirrorFrontCamera: " +
+                mirrorFrontCamera
         );
 
         boolean dispatched = false;
@@ -2114,6 +2119,7 @@ public class CameraXView implements LifecycleOwner, LifecycleObserver {
                             if (width != null || height != null) {
                                 Bitmap bitmap = BitmapFactory.decodeByteArray(originalCaptureBytes, 0, originalCaptureBytes.length);
                                 bitmap = applyExifOrientation(bitmap, exifInterface);
+                                bitmap = maybeMirrorFrontCameraBitmap(bitmap, mirrorFrontCamera);
                                 Bitmap resizedBitmap = resizeBitmapToMaxDimensions(bitmap, width, height);
                                 if (embedTimestamp || embedLocation) {
                                     resizedBitmap = drawTimestampAndLocationOntoBitmap(
@@ -2142,6 +2148,7 @@ public class CameraXView implements LifecycleOwner, LifecycleObserver {
                                 // No explicit size/ratio: crop to match current preview content
                                 Bitmap originalBitmap = BitmapFactory.decodeByteArray(originalCaptureBytes, 0, originalCaptureBytes.length);
                                 originalBitmap = applyExifOrientation(originalBitmap, exifInterface);
+                                originalBitmap = maybeMirrorFrontCameraBitmap(originalBitmap, mirrorFrontCamera);
                                 Bitmap previewCropped = cropBitmapToMatchPreview(originalBitmap);
                                 if (embedTimestamp || embedLocation) {
                                     previewCropped = drawTimestampAndLocationOntoBitmap(
@@ -2399,6 +2406,29 @@ public class CameraXView implements LifecycleOwner, LifecycleObserver {
         }
     }
 
+    private boolean shouldMirrorFrontCamera(boolean mirrorFrontCamera) {
+        return mirrorFrontCamera && sessionConfig != null && "front".equals(sessionConfig.getPosition());
+    }
+
+    private Bitmap maybeMirrorFrontCameraBitmap(Bitmap bitmap, boolean mirrorFrontCamera) {
+        if (bitmap == null || !shouldMirrorFrontCamera(mirrorFrontCamera)) {
+            return bitmap;
+        }
+        return mirrorBitmapHorizontally(bitmap);
+    }
+
+    private Bitmap mirrorBitmapHorizontally(Bitmap bitmap) {
+        Matrix matrix = new Matrix();
+        matrix.preScale(-1.0f, 1.0f);
+        Bitmap mirrored = Bitmap.createBitmap(bitmap, 0, 0, bitmap.getWidth(), bitmap.getHeight(), matrix, true);
+        if (mirrored != bitmap) {
+            try {
+                bitmap.recycle();
+            } catch (Exception ignore) {}
+        }
+        return mirrored;
+    }
+
     private Bitmap applyExifOrientation(Bitmap bitmap, ExifInterface exif) {
         try {
             int orientation = exif.getAttributeInt(ExifInterface.TAG_ORIENTATION, ExifInterface.ORIENTATION_UNDEFINED);
@@ -2761,7 +2791,7 @@ public class CameraXView implements LifecycleOwner, LifecycleObserver {
     // Note: We avoid temporary files for EXIF writes. When we transform pixels (resize/crop),
     // we recompress JPEG in-memory and update EXIF info only in the returned JSON, not in the bytes.
 
-    public void captureSample(int quality) {
+    public void captureSample(int quality, final boolean mirrorFrontCamera) {
         if (sampleImageCapture == null) {
             if (listener != null) {
                 listener.onSampleTakenError("Camera not ready");
@@ -2773,7 +2803,7 @@ public class CameraXView implements LifecycleOwner, LifecycleObserver {
             Log.d(TAG, "captureSample: Ignored because stop is pending");
             return;
         }
-        Log.d(TAG, "captureSample: Starting sample capture with quality: " + quality);
+        Log.d(TAG, "captureSample: Starting sample capture with quality: " + quality + ", mirrorFrontCamera: " + mirrorFrontCamera);
 
         boolean dispatched = false;
         try {
@@ -2795,6 +2825,20 @@ public class CameraXView implements LifecycleOwner, LifecycleObserver {
                         try {
                             // Convert ImageProxy to byte array
                             byte[] bytes = imageProxyToByteArray(image);
+                            if (shouldMirrorFrontCamera(mirrorFrontCamera)) {
+                                Bitmap bitmap = BitmapFactory.decodeByteArray(bytes, 0, bytes.length);
+                                if (bitmap != null) {
+                                    Bitmap mirrored = mirrorBitmapHorizontally(bitmap);
+                                    ByteArrayOutputStream stream = new ByteArrayOutputStream();
+                                    mirrored.compress(Bitmap.CompressFormat.JPEG, quality, stream);
+                                    bytes = stream.toByteArray();
+                                    if (mirrored != bitmap) {
+                                        try {
+                                            bitmap.recycle();
+                                        } catch (Exception ignore) {}
+                                    }
+                                }
+                            }
                             String base64 = Base64.encodeToString(bytes, Base64.NO_WRAP);
 
                             if (listener != null) {
@@ -3278,13 +3322,29 @@ public class CameraXView implements LifecycleOwner, LifecycleObserver {
 
     @OptIn(markerClass = ExperimentalCamera2Interop.class)
     public void setExposureMode(String mode) throws Exception {
-        if (camera == null) {
-            throw new Exception("Camera not initialized");
-        }
         if (mode == null) {
             throw new Exception("mode is required");
         }
         String normalized = mode.toUpperCase(Locale.US);
+        if (!"LOCK".equals(normalized) && !"CONTINUOUS".equals(normalized)) {
+            throw new Exception("Unsupported exposure mode: " + mode);
+        }
+        final String modeToApply = normalized;
+        mainExecutor.execute(() -> {
+            try {
+                applyExposureMode(modeToApply);
+                currentExposureMode = modeToApply;
+            } catch (Exception e) {
+                Log.e(TAG, "setExposureMode: Failed to apply mode", e);
+            }
+        });
+    }
+
+    @OptIn(markerClass = ExperimentalCamera2Interop.class)
+    private void applyExposureMode(String normalized) throws Exception {
+        if (camera == null) {
+            throw new Exception("Camera not initialized");
+        }
 
         Camera2CameraControl c2 = Camera2CameraControl.from(camera.getCameraControl());
         switch (normalized) {
@@ -3293,8 +3353,7 @@ public class CameraXView implements LifecycleOwner, LifecycleObserver {
                     .setCaptureRequestOption(CaptureRequest.CONTROL_AE_LOCK, true)
                     .setCaptureRequestOption(CaptureRequest.CONTROL_AE_MODE, CaptureRequest.CONTROL_AE_MODE_ON)
                     .build();
-                mainExecutor.execute(() -> c2.setCaptureRequestOptions(opts));
-                currentExposureMode = "LOCK";
+                c2.setCaptureRequestOptions(opts);
                 break;
             }
             case "CONTINUOUS": {
@@ -3302,12 +3361,117 @@ public class CameraXView implements LifecycleOwner, LifecycleObserver {
                     .setCaptureRequestOption(CaptureRequest.CONTROL_AE_LOCK, false)
                     .setCaptureRequestOption(CaptureRequest.CONTROL_AE_MODE, CaptureRequest.CONTROL_AE_MODE_ON)
                     .build();
-                mainExecutor.execute(() -> c2.setCaptureRequestOptions(opts));
-                currentExposureMode = "CONTINUOUS";
+                c2.setCaptureRequestOptions(opts);
                 break;
             }
             default:
-                throw new Exception("Unsupported exposure mode: " + mode);
+                throw new Exception("Unsupported exposure mode: " + normalized);
+        }
+    }
+
+    // ===================== White Balance APIs =====================
+    public java.util.List<String> getWhiteBalanceModes() {
+        if (camera == null) {
+            return Arrays.asList("LOCK", "CONTINUOUS");
+        }
+
+        java.util.List<String> modes = new java.util.ArrayList<>();
+        try {
+            Camera2CameraInfo c2Info = Camera2CameraInfo.from(camera.getCameraInfo());
+            int[] available = c2Info.getCameraCharacteristic(CameraCharacteristics.CONTROL_AWB_AVAILABLE_MODES);
+            Boolean lockAvailable = c2Info.getCameraCharacteristic(CameraCharacteristics.CONTROL_AWB_LOCK_AVAILABLE);
+
+            if (available != null) {
+                for (int awbMode : available) {
+                    if (awbMode == CaptureRequest.CONTROL_AWB_MODE_AUTO && !modes.contains("CONTINUOUS")) {
+                        modes.add("CONTINUOUS");
+                    }
+                }
+            }
+            if (Boolean.TRUE.equals(lockAvailable) && !modes.contains("LOCK")) {
+                modes.add("LOCK");
+            }
+        } catch (Exception e) {
+            Log.w(TAG, "getWhiteBalanceModes: Failed to query capabilities, using defaults", e);
+            return Arrays.asList("LOCK", "CONTINUOUS");
+        }
+
+        if (modes.isEmpty()) {
+            return Arrays.asList("LOCK", "CONTINUOUS");
+        }
+        return modes;
+    }
+
+    public String getWhiteBalanceMode() {
+        return currentWhiteBalanceMode;
+    }
+
+    @OptIn(markerClass = ExperimentalCamera2Interop.class)
+    public void setWhiteBalanceMode(String mode) throws Exception {
+        if (mode == null) {
+            throw new Exception("mode is required");
+        }
+        String normalized = mode.toUpperCase(Locale.US);
+        if ("CUSTOM".equals(normalized)) {
+            throw new Exception("CUSTOM white balance is not supported; manual gains are not yet exposed");
+        }
+        if (!"LOCK".equals(normalized) && !"AUTO".equals(normalized) && !"CONTINUOUS".equals(normalized)) {
+            throw new Exception("Unsupported white balance mode: " + mode);
+        }
+        final String modeToApply = normalized;
+        mainExecutor.execute(() -> {
+            try {
+                applyWhiteBalanceMode(modeToApply);
+                currentWhiteBalanceMode = modeToApply;
+            } catch (Exception e) {
+                Log.e(TAG, "setWhiteBalanceMode: Failed to apply mode", e);
+            }
+        });
+    }
+
+    @OptIn(markerClass = ExperimentalCamera2Interop.class)
+    private void applyWhiteBalanceMode(String normalized) throws Exception {
+        if (camera == null) {
+            throw new Exception("Camera not initialized");
+        }
+
+        Camera2CameraControl c2 = Camera2CameraControl.from(camera.getCameraControl());
+        switch (normalized) {
+            case "LOCK": {
+                CaptureRequestOptions opts = new CaptureRequestOptions.Builder()
+                    .setCaptureRequestOption(CaptureRequest.CONTROL_AWB_LOCK, true)
+                    .setCaptureRequestOption(CaptureRequest.CONTROL_AWB_MODE, CaptureRequest.CONTROL_AWB_MODE_AUTO)
+                    .build();
+                c2.setCaptureRequestOptions(opts);
+                break;
+            }
+            case "AUTO":
+            case "CONTINUOUS": {
+                CaptureRequestOptions opts = new CaptureRequestOptions.Builder()
+                    .setCaptureRequestOption(CaptureRequest.CONTROL_AWB_LOCK, false)
+                    .setCaptureRequestOption(CaptureRequest.CONTROL_AWB_MODE, CaptureRequest.CONTROL_AWB_MODE_AUTO)
+                    .build();
+                c2.setCaptureRequestOptions(opts);
+                break;
+            }
+            default:
+                throw new Exception("Unsupported white balance mode: " + normalized);
+        }
+    }
+
+    private void reapplyCameraControlModes() {
+        if (camera == null) {
+            return;
+        }
+        try {
+            applyExposureMode(currentExposureMode);
+        } catch (Exception e) {
+            Log.w(TAG, "reapplyCameraControlModes: Failed to reapply exposure mode", e);
+        }
+        try {
+            applyWhiteBalanceMode(currentWhiteBalanceMode);
+        } catch (Exception e) {
+            Log.w(TAG, "reapplyCameraControlModes: Failed to reapply white balance mode", e);
         }
     }
 

package/dist/docs.json

@@ -1495,6 +1495,63 @@
         "complexTypes": [],
         "slug": "setexposurecompensation"
       },
+      {
+        "name": "getWhiteBalanceModes",
+        "signature": "() => Promise<{ modes: WhiteBalanceMode[]; }>",
+        "parameters": [],
+        "returns": "Promise<{ modes: WhiteBalanceMode[]; }>",
+        "tags": [
+          {
+            "name": "platform",
+            "text": "android, ios"
+          }
+        ],
+        "docs": "Returns the white-balance modes supported by the active camera.\nModes can include: 'AUTO', 'LOCK', 'CONTINUOUS'. `CUSTOM` is not listed\nuntil manual gains support is implemented.",
+        "complexTypes": [
+          "WhiteBalanceMode"
+        ],
+        "slug": "getwhitebalancemodes"
+      },
+      {
+        "name": "getWhiteBalanceMode",
+        "signature": "() => Promise<{ mode: WhiteBalanceMode; }>",
+        "parameters": [],
+        "returns": "Promise<{ mode: WhiteBalanceMode; }>",
+        "tags": [
+          {
+            "name": "platform",
+            "text": "android, ios"
+          }
+        ],
+        "docs": "Returns the current white-balance mode.",
+        "complexTypes": [
+          "WhiteBalanceMode"
+        ],
+        "slug": "getwhitebalancemode"
+      },
+      {
+        "name": "setWhiteBalanceMode",
+        "signature": "(options: { mode: WhiteBalanceMode; }) => Promise<void>",
+        "parameters": [
+          {
+            "name": "options",
+            "docs": "",
+            "type": "{ mode: WhiteBalanceMode; }"
+          }
+        ],
+        "returns": "Promise<void>",
+        "tags": [
+          {
+            "name": "platform",
+            "text": "android, ios"
+          }
+        ],
+        "docs": "Sets the white-balance mode. `CONTINUOUS` keeps auto white balance running\n(recommended; avoids a warm/yellow cast), `LOCK` freezes the current gains,\n`AUTO` performs a one-time adjustment. `CUSTOM` is reserved and rejected\nuntil manual gains support is implemented.",
+        "complexTypes": [
+          "WhiteBalanceMode"
+        ],
+        "slug": "setwhitebalancemode"
+      },
       {
         "name": "getSupportedVideoFrameRates",
         "signature": "() => Promise<{ frameRates: number[]; }>",
@@ -2286,6 +2343,22 @@
           "docs": "Sets the priority for photo quality vs. capture speed.\n- \"speed\": Prioritizes faster capture times, may reduce image quality.\n- \"balanced\": Aims for a balance between quality and speed.\n- \"quality\": Prioritizes image quality, may reduce capture speed.\nSee https://developer.apple.com/documentation/avfoundation/avcapturephotosettings/photoqualityprioritization for details.",
           "complexTypes": [],
           "type": "'speed' | 'balanced' | 'quality' | undefined"
+        },
+        {
+          "name": "mirrorFrontCamera",
+          "tags": [
+            {
+              "text": "false",
+              "name": "default"
+            },
+            {
+              "text": "8.10.0",
+              "name": "since"
+            }
+          ],
+          "docs": "If true and the front camera is active, horizontally mirror the captured photo\nso it matches a selfie-style preview. Rear camera captures are never mirrored.\nDefaults to false to preserve the previous non-mirrored behavior.",
+          "complexTypes": [],
+          "type": "boolean | undefined"
         }
       ]
     },
@@ -2307,6 +2380,22 @@
           "docs": "The quality of the captured sample, from 0 to 100.",
           "complexTypes": [],
           "type": "number | undefined"
+        },
+        {
+          "name": "mirrorFrontCamera",
+          "tags": [
+            {
+              "text": "false",
+              "name": "default"
+            },
+            {
+              "text": "8.10.0",
+              "name": "since"
+            }
+          ],
+          "docs": "If true and the front camera is active, horizontally mirror the captured sample\nso it matches a selfie-style preview. Rear camera samples are never mirrored.\nDefaults to false to preserve the previous non-mirrored behavior.",
+          "complexTypes": [],
+          "type": "boolean | undefined"
         }
       ]
     },
@@ -3210,6 +3299,29 @@
           "complexTypes": []
         }
       ]
+    },
+    {
+      "name": "WhiteBalanceMode",
+      "slug": "whitebalancemode",
+      "docs": "Reusable white-balance mode type for cross-platform support.\n`CUSTOM` is reserved for a future manual white-balance gains API and is not\nreturned by `getWhiteBalanceModes()` until implemented.",
+      "types": [
+        {
+          "text": "'AUTO'",
+          "complexTypes": []
+        },
+        {
+          "text": "'LOCK'",
+          "complexTypes": []
+        },
+        {
+          "text": "'CONTINUOUS'",
+          "complexTypes": []
+        },
+        {
+          "text": "'CUSTOM'",
+          "complexTypes": []
+        }
+      ]
     }
   ],
   "pluginConfigs": []

package/dist/esm/definitions.d.ts

@@ -411,6 +411,14 @@ export interface CameraPreviewPictureOptions {
      * @default "speed"
      */
     photoQualityPrioritization?: 'speed' | 'balanced' | 'quality';
+    /**
+     * If true and the front camera is active, horizontally mirror the captured photo
+     * so it matches a selfie-style preview. Rear camera captures are never mirrored.
+     * Defaults to false to preserve the previous non-mirrored behavior.
+     * @default false
+     * @since 8.10.0
+     */
+    mirrorFrontCamera?: boolean;
 }
 /** Represents EXIF data extracted from an image. */
 export interface ExifData {
@@ -440,6 +448,14 @@ export interface CameraSampleOptions {
      * @default 85
      */
     quality?: number;
+    /**
+     * If true and the front camera is active, horizontally mirror the captured sample
+     * so it matches a selfie-style preview. Rear camera samples are never mirrored.
+     * Defaults to false to preserve the previous non-mirrored behavior.
+     * @default false
+     * @since 8.10.0
+     */
+    mirrorFrontCamera?: boolean;
 }
 /**
  * The available flash modes for the camera.
@@ -448,6 +464,12 @@ export interface CameraSampleOptions {
 export type CameraPreviewFlashMode = 'off' | 'on' | 'auto' | 'torch';
 /** Reusable exposure mode type for cross-platform support. */
 export type ExposureMode = 'AUTO' | 'LOCK' | 'CONTINUOUS' | 'CUSTOM';
+/**
+ * Reusable white-balance mode type for cross-platform support.
+ * `CUSTOM` is reserved for a future manual white-balance gains API and is not
+ * returned by `getWhiteBalanceModes()` until implemented.
+ */
+export type WhiteBalanceMode = 'AUTO' | 'LOCK' | 'CONTINUOUS' | 'CUSTOM';
 /**
  * Defines the options for setting the camera preview's opacity.
  */
@@ -1065,6 +1087,32 @@ export interface CameraPreviewPlugin {
     setExposureCompensation(options: {
         value: number;
     }): Promise<void>;
+    /**
+     * Returns the white-balance modes supported by the active camera.
+     * Modes can include: 'AUTO', 'LOCK', 'CONTINUOUS'. `CUSTOM` is not listed
+     * until manual gains support is implemented.
+     * @platform android, ios
+     */
+    getWhiteBalanceModes(): Promise<{
+        modes: WhiteBalanceMode[];
+    }>;
+    /**
+     * Returns the current white-balance mode.
+     * @platform android, ios
+     */
+    getWhiteBalanceMode(): Promise<{
+        mode: WhiteBalanceMode;
+    }>;
+    /**
+     * Sets the white-balance mode. `CONTINUOUS` keeps auto white balance running
+     * (recommended; avoids a warm/yellow cast), `LOCK` freezes the current gains,
+     * `AUTO` performs a one-time adjustment. `CUSTOM` is reserved and rejected
+     * until manual gains support is implemented.
+     * @platform android, ios
+     */
+    setWhiteBalanceMode(options: {
+        mode: WhiteBalanceMode;
+    }): Promise<void>;
     /**
      * Lists the video frame rates supported by the active camera for the current format.
      * Supported values depend on the selected camera, lens, and video quality.