@capgo/camera-preview 7.7.0 → 7.8.1-alpha.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/ios/Sources/CapgoCameraPreviewPlugin/CameraController.swift

@@ -100,7 +100,48 @@ class CameraController: NSObject {
     private func parseAspectRatio(_ aspectRatio: String) -> (width: CGFloat, height: CGFloat)? {
         let components = aspectRatio.split(separator: ":").compactMap { Float(String($0)) }
         guard components.count == 2 else { return nil }
-        return (width: CGFloat(components[0]), height: CGFloat(components[1]))
+
+        // Check if device is in portrait orientation by looking at the current interface orientation
+        var isPortrait = false
+        if let windowScene = UIApplication.shared.connectedScenes.first as? UIWindowScene {
+            print("[CameraPreview] parseAspectRatio - windowScene.interfaceOrientation: \(windowScene.interfaceOrientation)")
+            switch windowScene.interfaceOrientation {
+            case .portrait, .portraitUpsideDown:
+                isPortrait = true
+            case .landscapeLeft, .landscapeRight:
+                isPortrait = false
+            case .unknown:
+                // Fallback to device orientation
+                isPortrait = UIDevice.current.orientation.isPortrait
+            @unknown default:
+                isPortrait = UIDevice.current.orientation.isPortrait
+            }
+        } else {
+            // Fallback to device orientation
+            isPortrait = UIDevice.current.orientation.isPortrait
+        }
+
+        let originalWidth = CGFloat(components[0])
+        let originalHeight = CGFloat(components[1])
+        print("[CameraPreview] parseAspectRatio - isPortrait: \(isPortrait) originalWidth: \(originalWidth) originalHeight: \(originalHeight)")
+
+        let finalWidth: CGFloat
+        let finalHeight: CGFloat
+
+        if isPortrait {
+            // For portrait mode, swap width and height to maintain portrait orientation
+            // 4:3 becomes 3:4, 16:9 becomes 9:16
+            finalWidth = originalHeight
+            finalHeight = originalWidth
+            print("[CameraPreview] parseAspectRatio - Portrait mode: \(aspectRatio) -> \(finalWidth):\(finalHeight) (ratio: \(finalWidth/finalHeight))")
+        } else {
+            // For landscape mode, keep original orientation
+            finalWidth = originalWidth
+            finalHeight = originalHeight
+            print("[CameraPreview] parseAspectRatio - Landscape mode: \(aspectRatio) -> \(finalWidth):\(finalHeight) (ratio: \(finalWidth/finalHeight))")
+        }
+
+        return (width: finalWidth, height: finalHeight)
     }
 }
 
@@ -340,6 +381,38 @@ extension CameraController {
         }
     }
 
+    /// Update the requested aspect ratio at runtime and reconfigure session/preview accordingly
+    func updateAspectRatio(_ aspectRatio: String?) {
+        // Update internal state
+        self.requestedAspectRatio = aspectRatio
+
+        // Reconfigure session preset to match the new ratio for optimal capture resolution
+        if let captureSession = self.captureSession {
+            captureSession.beginConfiguration()
+            self.configureSessionPreset(for: aspectRatio)
+            captureSession.commitConfiguration()
+        }
+
+        // Update preview layer geometry on the main thread
+        DispatchQueue.main.async { [weak self] in
+            guard let self = self, let previewLayer = self.previewLayer else { return }
+            if let superlayer = previewLayer.superlayer {
+                let bounds = superlayer.bounds
+                if let aspect = aspectRatio {
+                    let frame = self.calculateAspectRatioFrame(for: aspect, in: bounds)
+                    previewLayer.frame = frame
+                    previewLayer.videoGravity = .resizeAspectFill
+                } else {
+                    previewLayer.frame = bounds
+                    previewLayer.videoGravity = .resizeAspect
+                }
+
+                // Keep grid overlay in sync with preview
+                self.gridOverlayView?.frame = previewLayer.frame
+            }
+        }
+    }
+
     private func setInitialZoom(level: Float?) {
         let device = (currentCameraPosition == .rear) ? rearCamera : frontCamera
         guard let device = device else {
@@ -544,7 +617,7 @@ extension CameraController {
     }
 
     private func updateVideoOrientationOnMainThread() {
-        let videoOrientation: AVCaptureVideoOrientation
+        var videoOrientation: AVCaptureVideoOrientation
 
         // Use window scene interface orientation
         if let windowScene = UIApplication.shared.connectedScenes.first as? UIWindowScene {
@@ -695,7 +768,7 @@ extension CameraController {
     }
 
     func captureImage(width: Int?, height: Int?, quality: Float, gpsLocation: CLLocation?, completion: @escaping (UIImage?, Data?, [AnyHashable: Any]?, Error?) -> Void) {
-        print("[CameraPreview] captureImage called - width: \(width ?? -1), height: \(height ?? -1)")
+        print("[CameraPreview] captureImage called - width: \(width ?? -1), height: \(height ?? -1), requestedAspectRatio: \(self.requestedAspectRatio ?? "nil")")
 
         guard let photoOutput = self.photoOutput else {
             completion(nil, nil, nil, NSError(domain: "Camera", code: 0, userInfo: [NSLocalizedDescriptionKey: "Photo output is not available"]))
@@ -764,18 +837,9 @@ extension CameraController {
                 print("[CameraPreview] Resized to max dimensions: \(finalImage.size.width)x\(finalImage.size.height)")
             } else if let aspectRatio = self.requestedAspectRatio {
                 // No max dimensions specified, but aspect ratio is specified
-                // If we used session preset (low-res), image should already be correct aspect ratio
-                // If we used high-res (shouldn't happen without max dimensions), crop it
-                let imageAspectRatio = image.size.width / image.size.height
-                if let targetRatio = self.parseAspectRatio(aspectRatio) {
-                    let targetAspectRatio = targetRatio.width / targetRatio.height
-
-                    // Allow small tolerance for aspect ratio comparison
-                    if abs(imageAspectRatio - targetAspectRatio) > 0.01 {
-                        finalImage = self.cropImageToAspectRatio(image: image, aspectRatio: aspectRatio) ?? image
-                        print("[CameraPreview] Cropped to match aspect ratio \(aspectRatio): \(finalImage.size.width)x\(finalImage.size.height)")
-                    }
-                }
+                // Always apply aspect ratio cropping to ensure correct orientation
+                finalImage = self.cropImageToAspectRatio(image: image, aspectRatio: aspectRatio) ?? image
+                print("[CameraPreview] Applied aspect ratio cropping for \(aspectRatio): \(finalImage.size.width)x\(finalImage.size.height)")
             }
 
             completion(finalImage, photoData, metadata, nil)
@@ -857,13 +921,27 @@ extension CameraController {
 
     func cropImageToAspectRatio(image: UIImage, aspectRatio: String) -> UIImage? {
         guard let ratio = parseAspectRatio(aspectRatio) else {
+            print("[CameraPreview] cropImageToAspectRatio - Failed to parse aspect ratio: \(aspectRatio)")
             return image
         }
 
-        let imageSize = image.size
+        // Only normalize the image orientation if it's not already correct
+        let normalizedImage: UIImage
+        if image.imageOrientation == .up {
+            normalizedImage = image
+            print("[CameraPreview] cropImageToAspectRatio - Image already has correct orientation")
+        } else {
+            normalizedImage = image.fixedOrientation() ?? image
+            print("[CameraPreview] cropImageToAspectRatio - Normalized image orientation from \(image.imageOrientation.rawValue) to .up")
+        }
+
+        let imageSize = normalizedImage.size
         let imageAspectRatio = imageSize.width / imageSize.height
         let targetAspectRatio = ratio.width / ratio.height
 
+        print("[CameraPreview] cropImageToAspectRatio - Original image: \(imageSize.width)x\(imageSize.height) (ratio: \(imageAspectRatio))")
+        print("[CameraPreview] cropImageToAspectRatio - Target ratio: \(ratio.width):\(ratio.height) (ratio: \(targetAspectRatio))")
+
         var cropRect: CGRect
 
         if imageAspectRatio > targetAspectRatio {
@@ -871,19 +949,36 @@ extension CameraController {
             let targetWidth = imageSize.height * targetAspectRatio
             let xOffset = (imageSize.width - targetWidth) / 2
             cropRect = CGRect(x: xOffset, y: 0, width: targetWidth, height: imageSize.height)
+            print("[CameraPreview] cropImageToAspectRatio - Horizontal crop: \(cropRect)")
         } else {
             // Image is taller than target - crop vertically (center crop)
             let targetHeight = imageSize.width / targetAspectRatio
             let yOffset = (imageSize.height - targetHeight) / 2
             cropRect = CGRect(x: 0, y: yOffset, width: imageSize.width, height: targetHeight)
+            print("[CameraPreview] cropImageToAspectRatio - Vertical crop: \(cropRect) - Target height: \(targetHeight)")
         }
 
-        guard let cgImage = image.cgImage,
+        // Validate crop rect is within image bounds
+        if cropRect.minX < 0 || cropRect.minY < 0 ||
+           cropRect.maxX > imageSize.width || cropRect.maxY > imageSize.height {
+            print("[CameraPreview] cropImageToAspectRatio - Warning: Crop rect \(cropRect) exceeds image bounds \(imageSize)")
+            // Adjust crop rect to fit within image bounds
+            cropRect = cropRect.intersection(CGRect(origin: .zero, size: imageSize))
+            print("[CameraPreview] cropImageToAspectRatio - Adjusted crop rect: \(cropRect)")
+        }
+
+        guard let cgImage = normalizedImage.cgImage,
               let croppedCGImage = cgImage.cropping(to: cropRect) else {
+            print("[CameraPreview] cropImageToAspectRatio - Failed to crop image")
             return nil
         }
 
-        return UIImage(cgImage: croppedCGImage, scale: image.scale, orientation: image.imageOrientation)
+        let croppedImage = UIImage(cgImage: croppedCGImage, scale: normalizedImage.scale, orientation: .up)
+        let finalAspectRatio = croppedImage.size.width / croppedImage.size.height
+        print("[CameraPreview] cropImageToAspectRatio - Final cropped image: \(croppedImage.size.width)x\(croppedImage.size.height) (ratio: \(finalAspectRatio))")
+
+        // Create the cropped image with normalized orientation
+        return croppedImage
     }
 
     func cropImageToMatchPreview(image: UIImage, previewLayer: AVCaptureVideoPreviewLayer) -> UIImage? {
@@ -1861,7 +1956,8 @@ extension CameraController: AVCapturePhotoCaptureDelegate {
         }
 
         // Pass through original file data and metadata so callers can preserve EXIF
-        self.photoCaptureCompletionBlock?(image.fixedOrientation(), imageData, photo.metadata, nil)
+        // Don't call fixedOrientation() here - let the completion block handle it after cropping
+        self.photoCaptureCompletionBlock?(image, imageData, photo.metadata, nil)
     }
 }
 

package/ios/Sources/CapgoCameraPreviewPlugin/Plugin.swift

@@ -310,6 +310,10 @@ public class CameraPreview: CAPPlugin, CAPBridgedPlugin, CLLocationManagerDelega
         }
 
         self.aspectRatio = newAspectRatio
+
+        // Propagate to camera controller so capture output and preview align
+        self.cameraController.updateAspectRatio(newAspectRatio)
+
         DispatchQueue.main.async {
             call.resolve(self.rawSetAspectRatio())
         }

package/package.json

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