@capgo/camera-preview 7.4.0-alpha.19 → 7.4.0-alpha.22

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

@@ -61,6 +61,8 @@ public class CameraPreview
   extends Plugin
   implements CameraXView.CameraXViewListener {
 
+  private static final String TAG = "CameraPreview CameraXView";
+
   static final String CAMERA_WITH_AUDIO_PERMISSION_ALIAS = "cameraWithAudio";
   static final String CAMERA_ONLY_PERMISSION_ALIAS = "cameraOnly";
   static final String CAMERA_WITH_LOCATION_PERMISSION_ALIAS =
@@ -1031,7 +1033,12 @@ public class CameraPreview
                 .orientation;
               if (current != lastOrientation) {
                 lastOrientation = current;
-                handleOrientationChange();
+                // Post to next frame so WebView has updated bounds before we recompute layout
+                getBridge()
+                  .getActivity()
+                  .getWindow()
+                  .getDecorView()
+                  .post(() -> handleOrientationChange());
               }
             }
           };
@@ -1044,13 +1051,115 @@ public class CameraPreview
 
   private void handleOrientationChange() {
     if (cameraXView == null || !cameraXView.isRunning()) return;
+
+    Log.d(
+      TAG,
+      "======================== ORIENTATION CHANGE DETECTED ========================"
+    );
+
+    // Get comprehensive display and orientation information
+    android.util.DisplayMetrics metrics = getContext()
+      .getResources()
+      .getDisplayMetrics();
+    int screenWidthPx = metrics.widthPixels;
+    int screenHeightPx = metrics.heightPixels;
+    float density = metrics.density;
+    int screenWidthDp = (int) (screenWidthPx / density);
+    int screenHeightDp = (int) (screenHeightPx / density);
+
+    int current = getContext().getResources().getConfiguration().orientation;
+    Log.d(TAG, "New orientation: " + current + " (1=PORTRAIT, 2=LANDSCAPE)");
+    Log.d(
+      TAG,
+      "Screen dimensions - Pixels: " +
+      screenWidthPx +
+      "x" +
+      screenHeightPx +
+      ", DP: " +
+      screenWidthDp +
+      "x" +
+      screenHeightDp +
+      ", Density: " +
+      density
+    );
+
+    // Get WebView dimensions before rotation
+    WebView webView = getBridge().getWebView();
+    int webViewWidth = webView.getWidth();
+    int webViewHeight = webView.getHeight();
+    Log.d(TAG, "WebView dimensions: " + webViewWidth + "x" + webViewHeight);
+
+    // Get current preview bounds before rotation
+    int[] oldBounds = cameraXView.getCurrentPreviewBounds();
+    Log.d(
+      TAG,
+      "Current preview bounds before rotation: x=" +
+      oldBounds[0] +
+      ", y=" +
+      oldBounds[1] +
+      ", width=" +
+      oldBounds[2] +
+      ", height=" +
+      oldBounds[3]
+    );
+
     getBridge()
       .getActivity()
       .runOnUiThread(() -> {
         // Reapply current aspect ratio to recompute layout, then emit screenResize
         String ar = cameraXView.getAspectRatio();
-        cameraXView.setAspectRatio(ar, null, null, () -> {
+        Log.d(TAG, "Reapplying aspect ratio: " + ar);
+
+        // Re-get dimensions after potential layout pass
+        android.util.DisplayMetrics newMetrics = getContext()
+          .getResources()
+          .getDisplayMetrics();
+        int newScreenWidthPx = newMetrics.widthPixels;
+        int newScreenHeightPx = newMetrics.heightPixels;
+        int newWebViewWidth = webView.getWidth();
+        int newWebViewHeight = webView.getHeight();
+
+        Log.d(
+          TAG,
+          "New screen dimensions after rotation: " +
+          newScreenWidthPx +
+          "x" +
+          newScreenHeightPx
+        );
+        Log.d(
+          TAG,
+          "New WebView dimensions after rotation: " +
+          newWebViewWidth +
+          "x" +
+          newWebViewHeight
+        );
+
+        // Force aspect ratio recalculation on orientation change
+        cameraXView.forceAspectRatioRecalculation(ar, null, null, () -> {
           int[] bounds = cameraXView.getCurrentPreviewBounds();
+          Log.d(
+            TAG,
+            "New bounds after orientation change: x=" +
+            bounds[0] +
+            ", y=" +
+            bounds[1] +
+            ", width=" +
+            bounds[2] +
+            ", height=" +
+            bounds[3]
+          );
+          Log.d(
+            TAG,
+            "Bounds change: deltaX=" +
+            (bounds[0] - oldBounds[0]) +
+            ", deltaY=" +
+            (bounds[1] - oldBounds[1]) +
+            ", deltaWidth=" +
+            (bounds[2] - oldBounds[2]) +
+            ", deltaHeight=" +
+            (bounds[3] - oldBounds[3])
+          );
+
           JSObject data = new JSObject();
           data.put("x", bounds[0]);
           data.put("y", bounds[1]);
@@ -1059,10 +1168,6 @@ public class CameraPreview
           notifyListeners("screenResize", data);
 
           // Also emit orientationChange with a unified string value
-          int current = getContext()
-            .getResources()
-            .getConfiguration()
-            .orientation;
           String o;
           if (current == Configuration.ORIENTATION_PORTRAIT) {
             o = "portrait";
@@ -1074,6 +1179,11 @@ public class CameraPreview
           JSObject oData = new JSObject();
           oData.put("orientation", o);
           notifyListeners("orientationChange", oData);
+
+          Log.d(
+            TAG,
+            "================================================================================"
+          );
         });
       });
   }
@@ -1171,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
@@ -1281,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);
   }