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

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

@@ -1281,11 +1281,116 @@ public class CameraPreview
       Log.d("CameraPreview", "12. PIXEL RATIO - " + pixelRatio);
       Log.d("CameraPreview", "========================");
 
+      // Calculate logical values with proper rounding to avoid sub-pixel issues
+      double logicalWidth = width / pixelRatio;
+      double logicalHeight = height / pixelRatio;
+      double logicalX = x / pixelRatio;
+      double logicalY = relativeY / pixelRatio;
+
+      // Log exact calculations to debug one-pixel difference
+      Log.d("CameraPreview", "========================");
+      Log.d("CameraPreview", "FINAL POSITION CALCULATIONS:");
+      Log.d(
+        "CameraPreview",
+        "Pixel values: x=" +
+        x +
+        ", y=" +
+        relativeY +
+        ", width=" +
+        width +
+        ", height=" +
+        height
+      );
+      Log.d("CameraPreview", "Pixel ratio: " + pixelRatio);
+      Log.d(
+        "CameraPreview",
+        "Logical values (exact): x=" +
+        logicalX +
+        ", y=" +
+        logicalY +
+        ", width=" +
+        logicalWidth +
+        ", height=" +
+        logicalHeight
+      );
+      Log.d(
+        "CameraPreview",
+        "Logical values (rounded): x=" +
+        Math.round(logicalX) +
+        ", y=" +
+        Math.round(logicalY) +
+        ", width=" +
+        Math.round(logicalWidth) +
+        ", height=" +
+        Math.round(logicalHeight)
+      );
+
+      // Check if previewContainer has any padding or margin that might cause offset
+      if (cameraXView != null) {
+        View previewContainer = cameraXView.getPreviewContainer();
+        if (previewContainer != null) {
+          Log.d(
+            "CameraPreview",
+            "PreviewContainer padding: left=" +
+            previewContainer.getPaddingLeft() +
+            ", top=" +
+            previewContainer.getPaddingTop() +
+            ", right=" +
+            previewContainer.getPaddingRight() +
+            ", bottom=" +
+            previewContainer.getPaddingBottom()
+          );
+          ViewGroup.LayoutParams params = previewContainer.getLayoutParams();
+          if (params instanceof ViewGroup.MarginLayoutParams) {
+            ViewGroup.MarginLayoutParams marginParams =
+              (ViewGroup.MarginLayoutParams) params;
+            Log.d(
+              "CameraPreview",
+              "PreviewContainer margins: left=" +
+              marginParams.leftMargin +
+              ", top=" +
+              marginParams.topMargin +
+              ", right=" +
+              marginParams.rightMargin +
+              ", bottom=" +
+              marginParams.bottomMargin
+            );
+          }
+        }
+      }
+      Log.d("CameraPreview", "========================");
+
       JSObject result = new JSObject();
-      result.put("width", width / pixelRatio);
-      result.put("height", height / pixelRatio);
-      result.put("x", x / pixelRatio);
-      result.put("y", relativeY / pixelRatio);
+      // 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) +
+        " (from " +
+        logicalX +
+        "), y: " +
+        Math.ceil(logicalY) +
+        " (from " +
+        logicalY +
+        "), width: " +
+        Math.floor(logicalWidth) +
+        " (from " +
+        logicalWidth +
+        "), height: " +
+        Math.floor(logicalHeight) +
+        " (from " +
+        logicalHeight +
+        ")"
+      );
+
       call.resolve(result);
       bridge.releaseCall(call);
       cameraStartCallbackId = null; // Prevent re-use
@@ -1391,10 +1496,16 @@ public class CameraPreview
     float pixelRatio = metrics.density;
 
     JSObject ret = new JSObject();
-    ret.put("x", cameraXView.getPreviewX() / pixelRatio);
-    ret.put("y", cameraXView.getPreviewY() / pixelRatio);
-    ret.put("width", cameraXView.getPreviewWidth() / pixelRatio);
-    ret.put("height", cameraXView.getPreviewHeight() / pixelRatio);
+    // 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;
+
+    ret.put("x", Math.ceil(x));
+    ret.put("y", Math.ceil(y));
+    ret.put("width", Math.floor(width));
+    ret.put("height", Math.floor(height));
     call.resolve(ret);
   }
 

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

@@ -135,6 +135,10 @@ public class CameraXView implements LifecycleOwner, LifecycleObserver {
     return isRunning;
   }
 
+  public View getPreviewContainer() {
+    return previewContainer;
+  }
+
   private void saveImageToGallery(byte[] data) {
     try {
       // Detect image format from byte array header
@@ -268,6 +272,13 @@ public class CameraXView implements LifecycleOwner, LifecycleObserver {
     previewContainer.setClickable(true);
     previewContainer.setFocusable(true);
 
+    // Disable any potential drawing artifacts that might cause 1px offset
+    previewContainer.setLayerType(View.LAYER_TYPE_HARDWARE, null);
+
+    // Ensure no clip bounds that might cause visual offset
+    previewContainer.setClipChildren(false);
+    previewContainer.setClipToPadding(false);
+
     // Create and setup the preview view
     previewView = new PreviewView(context);
     // Match iOS behavior: FIT when no aspect ratio, FILL when aspect ratio is set
@@ -3353,10 +3364,19 @@ public class CameraXView implements LifecycleOwner, LifecycleObserver {
     int webViewTopInset = getWebViewTopInset();
     int webViewLeftInset = getWebViewLeftInset();
 
-    int x = Math.max(0, (int) ((actualX - webViewLeftInset) / pixelRatio));
-    int y = Math.max(0, (int) ((actualY - webViewTopInset) / pixelRatio));
-    int width = (int) (actualWidth / pixelRatio);
-    int height = (int) (actualHeight / pixelRatio);
+    // Use proper rounding strategy 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
+    int x = Math.max(
+      0,
+      (int) Math.ceil((actualX - webViewLeftInset) / pixelRatio)
+    );
+    int y = Math.max(
+      0,
+      (int) Math.ceil((actualY - webViewTopInset) / pixelRatio)
+    );
+    int width = (int) Math.floor(actualWidth / pixelRatio);
+    int height = (int) Math.floor(actualHeight / pixelRatio);
 
     return new int[] { x, y, width, height };
   }

package/ios/Sources/CapgoCameraPreviewPlugin/CameraController.swift

@@ -504,6 +504,33 @@ 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
+            device.unlockForConfiguration()
+            self.zoomFactor = clampedZoom
+            print("[CameraPreview] Set default zoom after flip: UI=\(targetUIZoom)x, native=\(clampedZoom), multiplier=\(multiplier)")
+        } catch {
+            print("[CameraPreview] Failed to set default zoom after flip: \(error)")
+        }
+    }
 
     func switchCameras() throws {
         guard let currentCameraPosition = currentCameraPosition,
@@ -594,6 +621,11 @@ 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()
+        }
     }
 
     func captureImage(width: Int?, height: Int?, aspectRatio: String?, quality: Float, gpsLocation: CLLocation?, completion: @escaping (UIImage?, Data?, [AnyHashable: Any]?, Error?) -> Void) {

package/package.json

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