@capgo/camera-preview 7.6.1 → 7.8.0

package/README.md

@@ -95,6 +95,53 @@ await CameraPreview.deleteFile({ path: filePath })
 ```
 
 
+## Exposure controls (iOS & Android)
+
+This plugin exposes camera exposure controls on iOS and Android:
+
+- Exposure modes: `"AUTO" | "LOCK" | "CONTINUOUS" | "CUSTOM"`
+- Exposure compensation (EV bias): get range `{ min, max, step }`, read current value, and set new value
+
+Platform notes:
+
+- iOS: The camera starts in `CONTINUOUS` by default. Switching to `AUTO` or `CONTINUOUS` resets EV to 0. The `step` value is approximated to 0.1 since iOS does not expose the bias step.
+- Android: AE lock/unlock and mode are handled via CameraX + Camera2 interop. The `step` value comes from CameraX `ExposureState` and may vary per device.
+
+Example (TypeScript):
+
+```ts
+import { CameraPreview } from '@capgo/camera-preview';
+
+// Query supported modes
+const { modes } = await CameraPreview.getExposureModes();
+console.log('Supported exposure modes:', modes);
+
+// Get current mode
+const { mode } = await CameraPreview.getExposureMode();
+console.log('Current exposure mode:', mode);
+
+// Set mode (AUTO | LOCK | CONTINUOUS | CUSTOM)
+await CameraPreview.setExposureMode({ mode: 'CONTINUOUS' });
+
+// Get EV range (with step)
+const { min, max, step } = await CameraPreview.getExposureCompensationRange();
+console.log('EV range:', { min, max, step });
+
+// Read current EV
+const { value: currentEV } = await CameraPreview.getExposureCompensation();
+console.log('Current EV:', currentEV);
+
+// Increment EV by one step and clamp to range
+const nextEV = Math.max(min, Math.min(max, currentEV + step));
+await CameraPreview.setExposureCompensation({ value: nextEV });
+```
+
+Example app (Ionic):
+
+- Exposure mode toggle (sun icon) cycles through modes.
+- EV controls (+/−) are placed in a top‑right floating action bar, outside the preview area.
+
+
 # Installation
 
 ```
@@ -267,6 +314,12 @@ Documentation for the [uploader](https://github.com/Cap-go/capacitor-uploader)
 * [`deleteFile(...)`](#deletefile)
 * [`getSafeAreaInsets()`](#getsafeareainsets)
 * [`getOrientation()`](#getorientation)
+* [`getExposureModes()`](#getexposuremodes)
+* [`getExposureMode()`](#getexposuremode)
+* [`setExposureMode(...)`](#setexposuremode)
+* [`getExposureCompensationRange()`](#getexposurecompensationrange)
+* [`getExposureCompensation()`](#getexposurecompensation)
+* [`setExposureCompensation(...)`](#setexposurecompensation)
 * [Interfaces](#interfaces)
 * [Type Aliases](#type-aliases)
 * [Enums](#enums)
@@ -828,6 +881,89 @@ Gets the current device orientation in a cross-platform format.
 --------------------
 
 
+### getExposureModes()
+
+```typescript
+getExposureModes() => Promise<{ modes: ExposureMode[]; }>
+```
+
+Returns the exposure modes supported by the active camera.
+Modes can include: 'locked', 'auto', 'continuous', 'custom'.
+
+**Returns:** <code>Promise&lt;{ modes: ExposureMode[]; }&gt;</code>
+
+--------------------
+
+
+### getExposureMode()
+
+```typescript
+getExposureMode() => Promise<{ mode: ExposureMode; }>
+```
+
+Returns the current exposure mode.
+
+**Returns:** <code>Promise&lt;{ mode: <a href="#exposuremode">ExposureMode</a>; }&gt;</code>
+
+--------------------
+
+
+### setExposureMode(...)
+
+```typescript
+setExposureMode(options: { mode: ExposureMode; }) => Promise<void>
+```
+
+Sets the exposure mode.
+
+| Param         | Type                                                             |
+| ------------- | ---------------------------------------------------------------- |
+| **`options`** | <code>{ mode: <a href="#exposuremode">ExposureMode</a>; }</code> |
+
+--------------------
+
+
+### getExposureCompensationRange()
+
+```typescript
+getExposureCompensationRange() => Promise<{ min: number; max: number; step: number; }>
+```
+
+Returns the exposure compensation (EV bias) supported range.
+
+**Returns:** <code>Promise&lt;{ min: number; max: number; step: number; }&gt;</code>
+
+--------------------
+
+
+### getExposureCompensation()
+
+```typescript
+getExposureCompensation() => Promise<{ value: number; }>
+```
+
+Returns the current exposure compensation (EV bias).
+
+**Returns:** <code>Promise&lt;{ value: number; }&gt;</code>
+
+--------------------
+
+
+### setExposureCompensation(...)
+
+```typescript
+setExposureCompensation(options: { value: number; }) => Promise<void>
+```
+
+Sets the exposure compensation (EV bias). Value will be clamped to range.
+
+| Param         | Type                            |
+| ------------- | ------------------------------- |
+| **`options`** | <code>{ value: number; }</code> |
+
+--------------------
+
+
 ### Interfaces
 
 
@@ -1023,6 +1159,13 @@ Canonical device orientation values across platforms.
 <code>"portrait" | "landscape" | "landscape-left" | "landscape-right" | "portrait-upside-down" | "unknown"</code>
 
 
+#### ExposureMode
+
+Reusable exposure mode type for cross-platform support.
+
+<code>"AUTO" | "LOCK" | "CONTINUOUS" | "CUSTOM"</code>
+
+
 ### Enums
 
 

package/android/build.gradle

@@ -53,13 +53,13 @@ dependencies {
     implementation 'androidx.coordinatorlayout:coordinatorlayout:1.3.0'
 
     // CameraX dependencies
-    def camerax_version = "1.5.0-beta01"
+    def camerax_version = "1.5.0-rc01"
     implementation "androidx.camera:camera-core:${camerax_version}"
     implementation "androidx.camera:camera-camera2:${camerax_version}"
     implementation "androidx.camera:camera-lifecycle:${camerax_version}"
     implementation "androidx.camera:camera-view:${camerax_version}"
     implementation "androidx.camera:camera-extensions:${camerax_version}"
-    
+
     testImplementation "junit:junit:$junitVersion"
     androidTestImplementation "androidx.test.ext:junit:$androidxJunitVersion"
     androidTestImplementation "androidx.test.espresso:espresso-core:$androidxEspressoCoreVersion"

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

@@ -80,8 +80,106 @@ public class CameraPreview
   private Location lastLocation;
   private OrientationEventListener orientationListener;
   private int lastOrientation = Configuration.ORIENTATION_UNDEFINED;
+  private boolean lastDisableAudio = true;
 
   @PluginMethod
+  public void getExposureModes(PluginCall call) {
+    if (cameraXView == null || !cameraXView.isRunning()) {
+      call.reject("Camera is not running");
+      return;
+    }
+    JSArray arr = new JSArray();
+    for (String m : cameraXView.getExposureModes()) arr.put(m);
+    JSObject ret = new JSObject();
+    ret.put("modes", arr);
+    call.resolve(ret);
+  }
+
+  @PluginMethod
+  public void getExposureMode(PluginCall call) {
+    if (cameraXView == null || !cameraXView.isRunning()) {
+      call.reject("Camera is not running");
+      return;
+    }
+    JSObject ret = new JSObject();
+    ret.put("mode", cameraXView.getExposureMode());
+    call.resolve(ret);
+  }
+
+  @PluginMethod
+  public void setExposureMode(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.setExposureMode(mode);
+      call.resolve();
+    } catch (Exception e) {
+      call.reject("Failed to set exposure mode: " + e.getMessage());
+    }
+  }
+
+  @PluginMethod
+  public void getExposureCompensationRange(PluginCall call) {
+    if (cameraXView == null || !cameraXView.isRunning()) {
+      call.reject("Camera is not running");
+      return;
+    }
+    try {
+      float[] range = cameraXView.getExposureCompensationRange();
+      JSObject ret = new JSObject();
+      ret.put("min", range[0]);
+      ret.put("max", range[1]);
+      ret.put("step", range.length > 2 ? range[2] : 0.1);
+      call.resolve(ret);
+    } catch (Exception e) {
+      call.reject(
+        "Failed to get exposure compensation range: " + e.getMessage()
+      );
+    }
+  }
+
+  @PluginMethod
+  public void getExposureCompensation(PluginCall call) {
+    if (cameraXView == null || !cameraXView.isRunning()) {
+      call.reject("Camera is not running");
+      return;
+    }
+    try {
+      float value = cameraXView.getExposureCompensation();
+      JSObject ret = new JSObject();
+      ret.put("value", value);
+      call.resolve(ret);
+    } catch (Exception e) {
+      call.reject("Failed to get exposure compensation: " + e.getMessage());
+    }
+  }
+
+  @PluginMethod
+  public void setExposureCompensation(PluginCall call) {
+    if (cameraXView == null || !cameraXView.isRunning()) {
+      call.reject("Camera is not running");
+      return;
+    }
+    Float value = call.getFloat("value");
+    if (value == null) {
+      call.reject("value parameter is required");
+      return;
+    }
+    try {
+      cameraXView.setExposureCompensation(value);
+      call.resolve();
+    } catch (Exception e) {
+      call.reject("Failed to set exposure compensation: " + e.getMessage());
+    }
+  }
+
   public void getOrientation(PluginCall call) {
     int orientation = getContext()
       .getResources()
@@ -592,6 +690,7 @@ public class CameraPreview
     final boolean disableAudio = Boolean.TRUE.equals(
       call.getBoolean("disableAudio", true)
     );
+    this.lastDisableAudio = disableAudio;
     final String aspectRatio = call.getString("aspectRatio", "4:3");
     final String gridMode = call.getString("gridMode", "none");
     final String positioning = call.getString("positioning", "top");
@@ -1669,6 +1768,101 @@ public class CameraPreview
     }
   }
 
+  @PluginMethod
+  public void startRecordVideo(PluginCall call) {
+    if (cameraXView == null || !cameraXView.isRunning()) {
+      call.reject("Camera is not running");
+      return;
+    }
+
+    boolean disableAudio = call.getBoolean("disableAudio") != null
+      ? Boolean.TRUE.equals(call.getBoolean("disableAudio"))
+      : this.lastDisableAudio;
+    String permissionAlias = disableAudio
+      ? CAMERA_ONLY_PERMISSION_ALIAS
+      : CAMERA_WITH_AUDIO_PERMISSION_ALIAS;
+
+    if (PermissionState.GRANTED.equals(getPermissionState(permissionAlias))) {
+      try {
+        cameraXView.startRecordVideo();
+        call.resolve();
+      } catch (Exception e) {
+        call.reject("Failed to start video recording: " + e.getMessage());
+      }
+    } else {
+      requestPermissionForAlias(
+        permissionAlias,
+        call,
+        "handleVideoRecordingPermissionResult"
+      );
+    }
+  }
+
+  @PluginMethod
+  public void stopRecordVideo(PluginCall call) {
+    if (cameraXView == null || !cameraXView.isRunning()) {
+      call.reject("Camera is not running");
+      return;
+    }
+
+    try {
+      bridge.saveCall(call);
+      final String cbId = call.getCallbackId();
+      cameraXView.stopRecordVideo(
+        new CameraXView.VideoRecordingCallback() {
+          @Override
+          public void onSuccess(String filePath) {
+            PluginCall saved = bridge.getSavedCall(cbId);
+            if (saved != null) {
+              JSObject result = new JSObject();
+              result.put("videoFilePath", filePath);
+              saved.resolve(result);
+              bridge.releaseCall(saved);
+            }
+          }
+
+          @Override
+          public void onError(String message) {
+            PluginCall saved = bridge.getSavedCall(cbId);
+            if (saved != null) {
+              saved.reject("Failed to stop video recording: " + message);
+              bridge.releaseCall(saved);
+            }
+          }
+        }
+      );
+    } catch (Exception e) {
+      call.reject("Failed to stop video recording: " + e.getMessage());
+    }
+  }
+
+  @PermissionCallback
+  private void handleVideoRecordingPermissionResult(PluginCall call) {
+    // Use the persisted session value to determine which permission we requested
+    String permissionAlias = this.lastDisableAudio
+      ? CAMERA_ONLY_PERMISSION_ALIAS
+      : CAMERA_WITH_AUDIO_PERMISSION_ALIAS;
+
+    // Check if either permission is granted (mirroring handleCameraPermissionResult)
+    if (
+      PermissionState.GRANTED.equals(
+        getPermissionState(CAMERA_ONLY_PERMISSION_ALIAS)
+      ) ||
+      PermissionState.GRANTED.equals(
+        getPermissionState(CAMERA_WITH_AUDIO_PERMISSION_ALIAS)
+      )
+    ) {
+      try {
+        cameraXView.startRecordVideo();
+        call.resolve();
+      } catch (Exception e) {
+        call.reject("Failed to start video recording: " + e.getMessage());
+      }
+    } else {
+      call.reject("Permission denied for video recording");
+    }
+  }
+
   @PluginMethod
   public void getSafeAreaInsets(PluginCall call) {
     JSObject ret = new JSObject();