@capgo/camera-preview 7.4.0-alpha.23 → 7.4.0-alpha.25

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

@@ -6,6 +6,7 @@ import static android.Manifest.permission.RECORD_AUDIO;
 import android.Manifest;
 import android.content.pm.ActivityInfo;
 import android.content.res.Configuration;
+import android.graphics.Color;
 import android.location.Location;
 import android.util.DisplayMetrics;
 import android.util.Log;
@@ -74,6 +75,7 @@ public class CameraPreview
   private int previousOrientationRequest =
     ActivityInfo.SCREEN_ORIENTATION_UNSPECIFIED;
   private CameraXView cameraXView;
+  private View rotationOverlay;
   private FusedLocationProviderClient fusedLocationClient;
   private Location lastLocation;
   private OrientationEventListener orientationListener;
@@ -241,6 +243,12 @@ public class CameraPreview
           lastOrientation = Configuration.ORIENTATION_UNDEFINED;
         }
 
+        // Remove any rotation overlay if present
+        if (rotationOverlay != null && rotationOverlay.getParent() != null) {
+          ((ViewGroup) rotationOverlay.getParent()).removeView(rotationOverlay);
+          rotationOverlay = null;
+        }
+
         if (cameraXView != null && cameraXView.isRunning()) {
           cameraXView.stopSession();
           cameraXView = null;
@@ -1106,6 +1114,28 @@ public class CameraPreview
     getBridge()
       .getActivity()
       .runOnUiThread(() -> {
+        // Create and show a black full-screen overlay during rotation
+        ViewGroup rootView = (ViewGroup) getBridge()
+          .getActivity()
+          .getWindow()
+          .getDecorView()
+          .getRootView();
+
+        // Remove any existing overlay
+        if (rotationOverlay != null && rotationOverlay.getParent() != null) {
+          ((ViewGroup) rotationOverlay.getParent()).removeView(rotationOverlay);
+        }
+
+        // Create new black overlay
+        rotationOverlay = new View(getContext());
+        rotationOverlay.setBackgroundColor(Color.BLACK);
+        ViewGroup.LayoutParams overlayParams = new ViewGroup.LayoutParams(
+          ViewGroup.LayoutParams.MATCH_PARENT,
+          ViewGroup.LayoutParams.MATCH_PARENT
+        );
+        rotationOverlay.setLayoutParams(overlayParams);
+        rootView.addView(rotationOverlay);
+
         // Reapply current aspect ratio to recompute layout, then emit screenResize
         String ar = cameraXView.getAspectRatio();
         Log.d(TAG, "Reapplying aspect ratio: " + ar);
@@ -1180,6 +1210,38 @@ public class CameraPreview
           oData.put("orientation", o);
           notifyListeners("orientationChange", oData);
 
+          // Don't remove the overlay here - wait for camera to fully start
+          // The overlay will be removed after a delay to ensure camera is stable
+          if (rotationOverlay != null && rotationOverlay.getParent() != null) {
+            // Shorter delay for faster transition
+            int delay = "4:3".equals(ar) ? 200 : 150;
+            rotationOverlay.postDelayed(
+              () -> {
+                if (
+                  rotationOverlay != null && rotationOverlay.getParent() != null
+                ) {
+                  rotationOverlay
+                    .animate()
+                    .alpha(0f)
+                    .setDuration(100) // Faster fade out
+                    .withEndAction(() -> {
+                      if (
+                        rotationOverlay != null &&
+                        rotationOverlay.getParent() != null
+                      ) {
+                        ((ViewGroup) rotationOverlay.getParent()).removeView(
+                            rotationOverlay
+                          );
+                        rotationOverlay = null;
+                      }
+                    })
+                    .start();
+                }
+              },
+              delay
+            );
+          }
+
           Log.d(
             TAG,
             "================================================================================"
@@ -1213,6 +1275,23 @@ public class CameraPreview
     bridge.releaseCall(pluginCall);
   }
 
+  private JSObject getViewSize(
+    double x,
+    double y,
+    double width,
+    double height
+  ) {
+    JSObject ret = new JSObject();
+    // Return values with proper rounding to avoid gaps
+    // For positions (x, y): ceil to avoid gaps at top/left
+    // For dimensions (width, height): floor to avoid gaps at bottom/right
+    ret.put("x", Math.ceil(x));
+    ret.put("y", Math.ceil(y));
+    ret.put("width", Math.floor(width));
+    ret.put("height", Math.floor(height));
+    return ret;
+  }
+
   @Override
   public void onCameraStarted(int width, int height, int x, int y) {
     PluginCall call = bridge.getSavedCall(cameraStartCallbackId);
@@ -1287,6 +1366,13 @@ public class CameraPreview
       double logicalX = x / pixelRatio;
       double logicalY = relativeY / pixelRatio;
 
+      JSObject result = getViewSize(
+        logicalX,
+        logicalY,
+        logicalWidth,
+        logicalHeight
+      );
+
       // Log exact calculations to debug one-pixel difference
       Log.d("CameraPreview", "========================");
       Log.d("CameraPreview", "FINAL POSITION CALCULATIONS:");
@@ -1360,32 +1446,23 @@ public class CameraPreview
       }
       Log.d("CameraPreview", "========================");
 
-      JSObject result = new JSObject();
-      // Return values with proper rounding to avoid gaps
-      // For positions (x, y): floor to avoid gaps at top/left
-      // For dimensions (width, height): ceil to avoid gaps at bottom/right
-      result.put("width", Math.floor(logicalWidth));
-      result.put("height", Math.floor(logicalHeight));
-      result.put("x", Math.ceil(logicalX));
-      result.put("y", Math.ceil(logicalY));
-
       // Log what we're returning
       Log.d(
         "CameraPreview",
         "Returning to JS - x: " +
-        Math.ceil(logicalX) +
+        logicalX +
         " (from " +
         logicalX +
         "), y: " +
-        Math.ceil(logicalY) +
+        logicalY +
         " (from " +
         logicalY +
         "), width: " +
-        Math.floor(logicalWidth) +
+        logicalWidth +
         " (from " +
         logicalWidth +
         "), height: " +
-        Math.floor(logicalHeight) +
+        logicalHeight +
         " (from " +
         logicalHeight +
         ")"
@@ -1497,15 +1574,26 @@ public class CameraPreview
 
     JSObject ret = new JSObject();
     // Use same rounding strategy as start method
-    double x = cameraXView.getPreviewX() / pixelRatio;
-    double y = cameraXView.getPreviewY() / pixelRatio;
-    double width = cameraXView.getPreviewWidth() / pixelRatio;
-    double height = cameraXView.getPreviewHeight() / pixelRatio;
+    double x = Math.ceil(cameraXView.getPreviewX() / pixelRatio);
+    double y = Math.ceil(cameraXView.getPreviewY() / pixelRatio);
+    double width = Math.floor(cameraXView.getPreviewWidth() / pixelRatio);
+    double height = Math.floor(cameraXView.getPreviewHeight() / pixelRatio);
 
-    ret.put("x", Math.ceil(x));
-    ret.put("y", Math.ceil(y));
-    ret.put("width", Math.floor(width));
-    ret.put("height", Math.floor(height));
+    Log.d(
+      "CameraPreview",
+      "getPreviewSize: x=" +
+      x +
+      ", y=" +
+      y +
+      ", width=" +
+      width +
+      ", height=" +
+      height
+    );
+    ret.put("x", x);
+    ret.put("y", y);
+    ret.put("width", width);
+    ret.put("height", height);
     call.resolve(ret);
   }
 

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

@@ -2728,18 +2728,83 @@ public class CameraXView implements LifecycleOwner, LifecycleObserver {
     boolean usesFillCenter =
       sessionConfig != null && sessionConfig.getAspectRatio() != null;
 
-    float widthScale = (float) containerWidth / cameraWidth;
-    float heightScale = (float) containerHeight / cameraHeight;
-    float scale;
-
+    // For FILL_CENTER with aspect ratio, we need to calculate the actual visible bounds
+    // The preview might extend beyond the container bounds and get clipped
     if (usesFillCenter) {
-      // FILL_CENTER uses max scale to fill the container
-      scale = Math.max(widthScale, heightScale);
-    } else {
-      // FIT_CENTER uses min scale to fit within the container
-      scale = Math.min(widthScale, heightScale);
+      // Calculate how the camera preview is scaled to fill the container
+      float widthScale = (float) containerWidth / cameraWidth;
+      float heightScale = (float) containerHeight / cameraHeight;
+      float scale = Math.max(widthScale, heightScale); // max for FILL_CENTER
+
+      // Calculate the scaled dimensions
+      int scaledWidth = Math.round(cameraWidth * scale);
+      int scaledHeight = Math.round(cameraHeight * scale);
+
+      // Calculate how much is clipped on each side
+      int excessWidth = Math.max(0, scaledWidth - containerWidth);
+      int excessHeight = Math.max(0, scaledHeight - containerHeight);
+
+      // For the actual visible bounds, we need to account for potential
+      // internal misalignment of PreviewView's SurfaceView
+      int adjustedWidth = containerWidth;
+      int adjustedHeight = containerHeight;
+
+      // Apply small adjustments for 4:3 ratio to prevent blue line
+      // This compensates for PreviewView's internal SurfaceView misalignment
+      String aspectRatio = sessionConfig != null
+        ? sessionConfig.getAspectRatio()
+        : null;
+      if ("4:3".equals(aspectRatio)) {
+        // For 4:3, reduce the reported width slightly to account for
+        // the SurfaceView drawing outside its bounds
+        adjustedWidth = containerWidth - 2;
+        adjustedHeight = containerHeight - 2;
+      }
+
+      Log.d(
+        TAG,
+        "getActualCameraBounds FILL_CENTER: container=" +
+        containerWidth +
+        "x" +
+        containerHeight +
+        ", camera=" +
+        cameraWidth +
+        "x" +
+        cameraHeight +
+        " (portrait=" +
+        isPortrait +
+        ")" +
+        ", scale=" +
+        scale +
+        ", scaled=" +
+        scaledWidth +
+        "x" +
+        scaledHeight +
+        ", excess=" +
+        excessWidth +
+        "x" +
+        excessHeight +
+        ", adjusted=" +
+        adjustedWidth +
+        "x" +
+        adjustedHeight +
+        ", ratio=" +
+        aspectRatio
+      );
+
+      // Return slightly inset bounds for 4:3 to avoid blue line
+      if ("4:3".equals(aspectRatio)) {
+        return new Rect(1, 1, adjustedWidth + 1, adjustedHeight + 1);
+      } else {
+        return new Rect(0, 0, containerWidth, containerHeight);
+      }
     }
 
+    // For FIT_CENTER (no aspect ratio), calculate letterboxing
+    float widthScale = (float) containerWidth / cameraWidth;
+    float heightScale = (float) containerHeight / cameraHeight;
+    float scale = Math.min(widthScale, heightScale);
+
     // Calculate the actual size of the camera content after scaling
     int scaledWidth = Math.round(cameraWidth * scale);
     int scaledHeight = Math.round(cameraHeight * scale);
@@ -2750,7 +2815,7 @@ public class CameraXView implements LifecycleOwner, LifecycleObserver {
 
     Log.d(
       TAG,
-      "getActualCameraBounds: container=" +
+      "getActualCameraBounds FIT_CENTER: container=" +
       containerWidth +
       "x" +
       containerHeight +
@@ -2763,9 +2828,6 @@ public class CameraXView implements LifecycleOwner, LifecycleObserver {
       ")" +
       ", scale=" +
       scale +
-      " (fillCenter=" +
-      usesFillCenter +
-      ")" +
       ", scaled=" +
       scaledWidth +
       "x" +
@@ -3378,6 +3440,38 @@ public class CameraXView implements LifecycleOwner, LifecycleObserver {
     int width = (int) Math.floor(actualWidth / pixelRatio);
     int height = (int) Math.floor(actualHeight / pixelRatio);
 
+    // Debug logging to understand the blue line issue
+    Log.d(
+      TAG,
+      "getCurrentPreviewBounds DEBUG: " +
+      "actualBounds=(" +
+      actualX +
+      "," +
+      actualY +
+      "," +
+      actualWidth +
+      "x" +
+      actualHeight +
+      "), " +
+      "logicalBounds=(" +
+      x +
+      "," +
+      y +
+      "," +
+      width +
+      "x" +
+      height +
+      "), " +
+      "pixelRatio=" +
+      pixelRatio +
+      ", " +
+      "insets=(" +
+      webViewLeftInset +
+      "," +
+      webViewTopInset +
+      ")"
+    );
+
     return new int[] { x, y, width, height };
   }
 

package/ios/Sources/CapgoCameraPreviewPlugin/CameraController.swift

@@ -504,23 +504,23 @@ extension CameraController {
         dataOutput?.connections.forEach { $0.videoOrientation = videoOrientation }
         photoOutput?.connections.forEach { $0.videoOrientation = videoOrientation }
     }
-    
+
     private func setDefaultZoomAfterFlip() {
         let device = (currentCameraPosition == .rear) ? rearCamera : frontCamera
         guard let device = device else {
             print("[CameraPreview] No device available for default zoom after flip")
             return
         }
-        
+
         // Set zoom to 1.0x in UI terms, accounting for display multiplier
         let multiplier = self.getDisplayZoomMultiplier()
         let targetUIZoom: Float = 1.0  // We want 1.0x in the UI
         let nativeZoom = multiplier != 1.0 ? (targetUIZoom / multiplier) : targetUIZoom
-        
+
         let minZoom = device.minAvailableVideoZoomFactor
         let maxZoom = min(device.maxAvailableVideoZoomFactor, saneMaxZoomFactor)
         let clampedZoom = max(minZoom, min(CGFloat(nativeZoom), maxZoom))
-        
+
         do {
             try device.lockForConfiguration()
             device.videoZoomFactor = clampedZoom
@@ -621,7 +621,7 @@ extension CameraController {
 
         // Update video orientation
         self.updateVideoOrientation()
-        
+
         // Set default 1.0 zoom level after camera switch to prevent iOS 18+ zoom jumps
         DispatchQueue.main.async { [weak self] in
             self?.setDefaultZoomAfterFlip()

package/ios/Sources/CapgoCameraPreviewPlugin/Plugin.swift

@@ -170,18 +170,62 @@ public class CameraPreview: CAPPlugin, CAPBridgedPlugin, CLLocationManagerDelega
         }
 
         var values: [Float] = []
-        if hasUltraWide { values.append(0.5) }
+        if hasUltraWide {
+            values.append(0.5)
+        }
         if hasWide {
             values.append(1.0)
-            values.append(2.0)
+            if self.isProModelSupportingOptical2x() {
+                values.append(2.0)
+            }
+        }
+        if hasTele {
+            // Use the virtual device's switch-over zoom factors when available
+            let displayMultiplier = self.cameraController.getDisplayZoomMultiplier()
+            var teleStep: Float
+
+            if #available(iOS 13.0, *) {
+                let switchFactors = device.virtualDeviceSwitchOverVideoZoomFactors
+                if !switchFactors.isEmpty {
+                    // Choose the highest switch-over factor (typically the wide->tele threshold)
+                    let maxSwitch = switchFactors.map { $0.floatValue }.max() ?? Float(device.maxAvailableVideoZoomFactor)
+                    teleStep = maxSwitch * displayMultiplier
+                } else {
+                    teleStep = Float(device.maxAvailableVideoZoomFactor) * displayMultiplier
+                }
+            } else {
+                teleStep = Float(device.maxAvailableVideoZoomFactor) * displayMultiplier
+            }
+            values.append(teleStep)
         }
-        if hasTele { values.append(3.0) }
 
         // Deduplicate and sort
         let uniqueSorted = Array(Set(values)).sorted()
         call.resolve(["values": uniqueSorted])
     }
 
+    private func isProModelSupportingOptical2x() -> Bool {
+        // Detects iPhone 14 Pro/Pro Max, 15 Pro/Pro Max, and 16 Pro/Pro Max
+        var systemInfo = utsname()
+        uname(&systemInfo)
+        let mirror = Mirror(reflecting: systemInfo.machine)
+        let identifier = mirror.children.reduce("") { partialResult, element in
+            guard let value = element.value as? Int8, value != 0 else { return partialResult }
+            return partialResult + String(UnicodeScalar(UInt8(value)))
+        }
+
+        // Known identifiers: 14 Pro (iPhone15,2), 14 Pro Max (iPhone15,3),
+        // 15 Pro (iPhone16,1), 15 Pro Max (iPhone16,2),
+        // 16 Pro (iPhone17,1), 16 Pro Max (iPhone17,2),
+        // 17 Pro (iPhone18,1), 17 Pro Max (iPhone18,2)
+        let supportedIdentifiers: Set<String> = [
+            "iPhone15,2", "iPhone15,3", // 14 Pro / 14 Pro Max
+            "iPhone16,1", "iPhone16,2", // 15 Pro / 15 Pro Max
+            "iPhone17,1", "iPhone17,2" // 16 Pro / 16 Pro Max
+        ]
+        return supportedIdentifiers.contains(identifier)
+    }
+
     @objc func rotated() {
         guard let previewView = self.previewView,
               let posX = self.posX,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@capgo/camera-preview",
-  "version": "7.4.0-alpha.23",
+  "version": "7.4.0-alpha.25",
   "description": "Camera preview",
   "license": "MIT",
   "repository": {