@capgo/camera-preview 7.7.0 → 7.8.0

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,6 +80,7 @@ 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) {
@@ -689,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");
@@ -1766,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();

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

@@ -56,6 +56,14 @@ import androidx.camera.core.resolutionselector.AspectRatioStrategy;
 import androidx.camera.core.resolutionselector.ResolutionSelector;
 import androidx.camera.core.resolutionselector.ResolutionStrategy;
 import androidx.camera.lifecycle.ProcessCameraProvider;
+import androidx.camera.video.FallbackStrategy;
+import androidx.camera.video.FileOutputOptions;
+import androidx.camera.video.Quality;
+import androidx.camera.video.QualitySelector;
+import androidx.camera.video.Recorder;
+import androidx.camera.video.Recording;
+import androidx.camera.video.VideoCapture;
+import androidx.camera.video.VideoRecordEvent;
 import androidx.camera.view.PreviewView;
 import androidx.core.content.ContextCompat;
 import androidx.exifinterface.media.ExifInterface;
@@ -99,10 +107,19 @@ public class CameraXView implements LifecycleOwner, LifecycleObserver {
     void onCameraStartError(String message);
   }
 
+  public interface VideoRecordingCallback {
+    void onSuccess(String filePath);
+    void onError(String message);
+  }
+
   private ProcessCameraProvider cameraProvider;
   private Camera camera;
   private ImageCapture imageCapture;
   private ImageCapture sampleImageCapture;
+  private VideoCapture<Recorder> videoCapture;
+  private Recording currentRecording;
+  private File currentVideoFile;
+  private VideoRecordingCallback currentVideoCallback;
   private PreviewView previewView;
   private GridOverlayView gridOverlayView;
   private FrameLayout previewContainer;
@@ -725,6 +742,17 @@ public class CameraXView implements LifecycleOwner, LifecycleObserver {
           .setTargetRotation(rotation)
           .build();
         sampleImageCapture = imageCapture;
+
+        // Setup VideoCapture with rotation and quality fallback
+        QualitySelector qualitySelector = QualitySelector.fromOrderedList(
+          Arrays.asList(Quality.FHD, Quality.HD, Quality.SD),
+          FallbackStrategy.higherQualityOrLowerThan(Quality.FHD)
+        );
+        Recorder recorder = new Recorder.Builder()
+          .setQualitySelector(qualitySelector)
+          .build();
+        videoCapture = VideoCapture.withOutput(recorder);
+
         preview.setSurfaceProvider(previewView.getSurfaceProvider());
         // Unbind any existing use cases and bind new ones
         cameraProvider.unbindAll();
@@ -732,7 +760,8 @@ public class CameraXView implements LifecycleOwner, LifecycleObserver {
           this,
           currentCameraSelector,
           preview,
-          imageCapture
+          imageCapture,
+          videoCapture
         );
 
         // Log details about the active camera
@@ -3702,4 +3731,103 @@ public class CameraXView implements LifecycleOwner, LifecycleObserver {
       Log.e(TAG, "triggerAutoFocus: Failed to trigger autofocus", e);
     }
   }
+
+  public void startRecordVideo() throws Exception {
+    if (videoCapture == null) {
+      throw new Exception("VideoCapture is not initialized");
+    }
+
+    if (currentRecording != null) {
+      throw new Exception("Video recording is already in progress");
+    }
+
+    // Create output file
+    String fileName = "video_" + System.currentTimeMillis() + ".mp4";
+    File outputDir = new File(
+      context.getExternalFilesDir(Environment.DIRECTORY_MOVIES),
+      "CameraPreview"
+    );
+    if (!outputDir.exists()) {
+      outputDir.mkdirs();
+    }
+    currentVideoFile = new File(outputDir, fileName);
+
+    FileOutputOptions outputOptions = new FileOutputOptions.Builder(
+      currentVideoFile
+    ).build();
+
+    // Create recording event listener
+    androidx.core.util.Consumer<VideoRecordEvent> videoRecordEventListener =
+      videoRecordEvent -> {
+        if (videoRecordEvent instanceof VideoRecordEvent.Start) {
+          Log.d(TAG, "Video recording started");
+        } else if (videoRecordEvent instanceof VideoRecordEvent.Finalize) {
+          VideoRecordEvent.Finalize finalizeEvent =
+            (VideoRecordEvent.Finalize) videoRecordEvent;
+          handleRecordingFinalized(finalizeEvent);
+        }
+      };
+
+    // Start recording
+    if (sessionConfig != null && !sessionConfig.isDisableAudio()) {
+      currentRecording = videoCapture
+        .getOutput()
+        .prepareRecording(context, outputOptions)
+        .withAudioEnabled()
+        .start(
+          ContextCompat.getMainExecutor(context),
+          videoRecordEventListener
+        );
+    } else {
+      currentRecording = videoCapture
+        .getOutput()
+        .prepareRecording(context, outputOptions)
+        .start(
+          ContextCompat.getMainExecutor(context),
+          videoRecordEventListener
+        );
+    }
+
+    Log.d(
+      TAG,
+      "Video recording started to: " + currentVideoFile.getAbsolutePath()
+    );
+  }
+
+  public void stopRecordVideo(VideoRecordingCallback callback) {
+    if (currentRecording == null) {
+      callback.onError("No video recording in progress");
+      return;
+    }
+
+    // Store the callback to use when recording is finalized
+    currentVideoCallback = callback;
+    currentRecording.stop();
+
+    Log.d(TAG, "Video recording stop requested");
+  }
+
+  private void handleRecordingFinalized(
+    VideoRecordEvent.Finalize finalizeEvent
+  ) {
+    if (!finalizeEvent.hasError()) {
+      Log.d(TAG, "Video recording completed successfully");
+      if (currentVideoCallback != null) {
+        String filePath = "file://" + currentVideoFile.getAbsolutePath();
+        currentVideoCallback.onSuccess(filePath);
+      }
+    } else {
+      Log.e(TAG, "Video recording failed: " + finalizeEvent.getError());
+      if (currentVideoCallback != null) {
+        currentVideoCallback.onError(
+          "Video recording failed: " + finalizeEvent.getError()
+        );
+      }
+    }
+
+    // Clean up
+    currentRecording = null;
+    currentVideoFile = null;
+    currentVideoCallback = null;
+  }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@capgo/camera-preview",
-  "version": "7.7.0",
+  "version": "7.8.0",
   "description": "Camera preview",
   "license": "MIT",
   "repository": {