@capgo/camera-preview 7.4.0-alpha.3 → 7.4.0-alpha.32

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

@@ -5,13 +5,19 @@ 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;
 import android.util.Size;
+import android.view.OrientationEventListener;
 import android.view.View;
 import android.view.ViewGroup;
 import android.webkit.WebView;
+import androidx.core.graphics.Insets;
+import androidx.core.view.ViewCompat;
+import androidx.core.view.WindowInsetsCompat;
 import com.ahm.capacitor.camera.preview.model.CameraDevice;
 import com.ahm.capacitor.camera.preview.model.CameraSessionConfiguration;
 import com.ahm.capacitor.camera.preview.model.LensInfo;
@@ -56,6 +62,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 =
@@ -67,8 +75,31 @@ 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;
+  private int lastOrientation = Configuration.ORIENTATION_UNDEFINED;
+
+  @PluginMethod
+  public void getOrientation(PluginCall call) {
+    int orientation = getContext()
+      .getResources()
+      .getConfiguration()
+      .orientation;
+    String o;
+    if (orientation == Configuration.ORIENTATION_PORTRAIT) {
+      // We don't distinguish upside-down reliably on Android, report generic portrait
+      o = "portrait";
+    } else if (orientation == Configuration.ORIENTATION_LANDSCAPE) {
+      o = "landscape";
+    } else {
+      o = "unknown";
+    }
+    JSObject ret = new JSObject();
+    ret.put("orientation", o);
+    call.resolve(ret);
+  }
 
   @PluginMethod
   public void start(PluginCall call) {
@@ -205,6 +236,19 @@ public class CameraPreview
           .getActivity()
           .setRequestedOrientation(previousOrientationRequest);
 
+        // Disable and clear orientation listener
+        if (orientationListener != null) {
+          orientationListener.disable();
+          orientationListener = null;
+          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;
@@ -215,6 +259,10 @@ public class CameraPreview
 
   @PluginMethod
   public void getSupportedFlashModes(PluginCall call) {
+    if (cameraXView == null || !cameraXView.isRunning()) {
+      call.reject("Camera is not running");
+      return;
+    }
     List<String> supportedFlashModes = cameraXView.getSupportedFlashModes();
     JSArray jsonFlashModes = new JSArray();
     for (String mode : supportedFlashModes) {
@@ -268,6 +316,10 @@ public class CameraPreview
 
   @PluginMethod
   public void getZoom(PluginCall call) {
+    if (cameraXView == null || !cameraXView.isRunning()) {
+      call.reject("Camera is not running");
+      return;
+    }
     ZoomFactors zoomFactors = cameraXView.getZoomFactors();
     JSObject result = new JSObject();
     result.put("min", zoomFactors.getMin());
@@ -276,6 +328,57 @@ public class CameraPreview
     call.resolve(result);
   }
 
+  @PluginMethod
+  public void getZoomButtonValues(PluginCall call) {
+    if (cameraXView == null || !cameraXView.isRunning()) {
+      call.reject("Camera is not running");
+      return;
+    }
+    // Build a sorted set to dedupe and order ascending
+    java.util.Set<Double> sorted = new java.util.TreeSet<>();
+    sorted.add(1.0);
+    sorted.add(2.0);
+
+    // Try to detect ultra-wide to include its min zoom (often 0.5)
+    try {
+      List<CameraDevice> devices = CameraXView.getAvailableDevicesStatic(
+        getContext()
+      );
+      ZoomFactors zoomFactors = cameraXView.getZoomFactors();
+      boolean hasUltraWide = false;
+      boolean hasTelephoto = false;
+      float minUltra = 0.5f;
+
+      for (CameraDevice device : devices) {
+        for (com.ahm.capacitor.camera.preview.model.LensInfo lens : device.getLenses()) {
+          if ("ultraWide".equals(lens.getDeviceType())) {
+            hasUltraWide = true;
+            // Use overall minZoom for that device as the button value to represent UW
+            minUltra = Math.max(minUltra, zoomFactors.getMin());
+          } else if ("telephoto".equals(lens.getDeviceType())) {
+            hasTelephoto = true;
+          }
+        }
+      }
+      if (hasUltraWide) {
+        sorted.add((double) minUltra);
+      }
+      if (hasTelephoto) {
+        sorted.add(3.0);
+      }
+    } catch (Exception ignored) {
+      // Ignore and keep defaults
+    }
+
+    JSObject result = new JSObject();
+    JSArray values = new JSArray();
+    for (Double v : sorted) {
+      values.put(v);
+    }
+    result.put("values", values);
+    call.resolve(result);
+  }
+
   @PluginMethod
   public void setZoom(PluginCall call) {
     if (cameraXView == null || !cameraXView.isRunning()) {
@@ -287,9 +390,8 @@ public class CameraPreview
       call.reject("level parameter is required");
       return;
     }
-    Boolean autoFocus = call.getBoolean("autoFocus", true);
     try {
-      cameraXView.setZoom(level, autoFocus);
+      cameraXView.setZoom(level);
       call.resolve();
     } catch (Exception e) {
       call.reject("Failed to set zoom: " + e.getMessage());
@@ -922,6 +1024,229 @@ public class CameraPreview
         bridge.saveCall(call);
         cameraStartCallbackId = call.getCallbackId();
         cameraXView.startSession(config);
+
+        // Setup orientation listener to mirror iOS screenResize emission
+        if (orientationListener == null) {
+          lastOrientation = getContext()
+            .getResources()
+            .getConfiguration()
+            .orientation;
+          orientationListener = new OrientationEventListener(getContext()) {
+            @Override
+            public void onOrientationChanged(int orientation) {
+              if (orientation == ORIENTATION_UNKNOWN) return;
+              int current = getContext()
+                .getResources()
+                .getConfiguration()
+                .orientation;
+              if (current != lastOrientation) {
+                lastOrientation = current;
+                // Post to next frame so WebView has updated bounds before we recompute layout
+                getBridge()
+                  .getActivity()
+                  .getWindow()
+                  .getDecorView()
+                  .post(() -> handleOrientationChange());
+              }
+            }
+          };
+          if (orientationListener.canDetectOrientation()) {
+            orientationListener.enable();
+          }
+        }
+      });
+  }
+
+  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(() -> {
+        // 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);
+
+        // 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]);
+          data.put("width", bounds[2]);
+          data.put("height", bounds[3]);
+          notifyListeners("screenResize", data);
+
+          // Also emit orientationChange with a unified string value
+          String o;
+          if (current == Configuration.ORIENTATION_PORTRAIT) {
+            o = "portrait";
+          } else if (current == Configuration.ORIENTATION_LANDSCAPE) {
+            o = "landscape";
+          } else {
+            o = "unknown";
+          }
+          JSObject oData = new JSObject();
+          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,
+            "================================================================================"
+          );
+        });
       });
   }
 
@@ -950,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);
@@ -1018,11 +1360,114 @@ public class CameraPreview
       Log.d("CameraPreview", "12. PIXEL RATIO - " + pixelRatio);
       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);
+      // 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;
+
+      JSObject result = getViewSize(
+        logicalX,
+        logicalY,
+        logicalWidth,
+        logicalHeight
+      );
+
+      // 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", "========================");
+
+      // Log what we're returning
+      Log.d(
+        "CameraPreview",
+        "Returning to JS - x: " +
+        logicalX +
+        " (from " +
+        logicalX +
+        "), y: " +
+        logicalY +
+        " (from " +
+        logicalY +
+        "), width: " +
+        logicalWidth +
+        " (from " +
+        logicalWidth +
+        "), height: " +
+        logicalHeight +
+        " (from " +
+        logicalHeight +
+        ")"
+      );
+
       call.resolve(result);
       bridge.releaseCall(call);
       cameraStartCallbackId = null; // Prevent re-use
@@ -1128,10 +1573,27 @@ 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 = 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);
+
+    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);
   }
 
@@ -1191,4 +1653,116 @@ public class CameraPreview
       call.resolve(ret);
     });
   }
+
+  @PluginMethod
+  public void deleteFile(PluginCall call) {
+    String path = call.getString("path");
+    if (path == null || path.isEmpty()) {
+      call.reject("path parameter is required");
+      return;
+    }
+    try {
+      java.io.File f = new java.io.File(android.net.Uri.parse(path).getPath());
+      boolean deleted = f.exists() && f.delete();
+      JSObject ret = new JSObject();
+      ret.put("success", deleted);
+      call.resolve(ret);
+    } catch (Exception e) {
+      call.reject("Failed to delete file: " + e.getMessage());
+    }
+  }
+
+  @PluginMethod
+  public void getSafeAreaInsets(PluginCall call) {
+    JSObject ret = new JSObject();
+    int orientation = getContext()
+      .getResources()
+      .getConfiguration()
+      .orientation;
+
+    int notchInsetPx = 0;
+
+    try {
+      View decorView = getBridge().getActivity().getWindow().getDecorView();
+      WindowInsetsCompat insets = ViewCompat.getRootWindowInsets(decorView);
+
+      if (insets != null) {
+        // Get display cutout insets (notch, punch hole, etc.)
+        // this.Capacitor.Plugins.CameraPreview.getSafeAreaInsets()
+        Insets cutout = insets.getInsets(
+          WindowInsetsCompat.Type.displayCutout()
+        );
+
+        // Get system bars insets (status bar, navigation bars)
+        Insets sysBars = insets.getInsets(WindowInsetsCompat.Type.systemBars());
+
+        // In portrait mode, notch is at the top
+        // In landscape mode, notch is typically at the left side (or right, but left is more common)
+        if (orientation == Configuration.ORIENTATION_PORTRAIT) {
+          // Portrait: return top inset (notch/status bar)
+          notchInsetPx = Math.max(cutout.top, sysBars.top);
+
+          // If no cutout detected but we have system bars, use status bar height as fallback
+          if (cutout.top == 0 && sysBars.top > 0) {
+            notchInsetPx = sysBars.top;
+          }
+        } else if (orientation == Configuration.ORIENTATION_LANDSCAPE) {
+          // Landscape: return left inset (notch moved to side)
+          notchInsetPx = Math.max(cutout.left, sysBars.left);
+
+          // If no cutout detected but we have system bars, use left system bar as fallback
+          if (cutout.left == 0 && sysBars.left > 0) {
+            notchInsetPx = sysBars.left;
+          }
+
+          // Additional fallback: some devices might have the notch on the right in landscape
+          // If left is 0, check right side as well
+          if (notchInsetPx == 0) {
+            notchInsetPx = Math.max(cutout.right, sysBars.right);
+          }
+        } else {
+          // Unknown orientation, default to top
+          notchInsetPx = Math.max(cutout.top, sysBars.top);
+        }
+      } else {
+        // Fallback to status bar height if WindowInsets are not available
+        notchInsetPx = getStatusBarHeightPx();
+      }
+    } catch (Exception e) {
+      // Final fallback
+      notchInsetPx = getStatusBarHeightPx();
+    }
+
+    // Convert pixels to dp for consistency with JS layout units
+    float density = getContext().getResources().getDisplayMetrics().density;
+    ret.put("orientation", orientation);
+    ret.put("top", notchInsetPx / density);
+    call.resolve(ret);
+  }
+
+  private boolean approxEqualPx(int a, int b) {
+    return Math.abs(a - b) <= 2; // within 2px tolerance
+  }
+
+  private int getStatusBarHeightPx() {
+    int result = 0;
+    int resourceId = getContext()
+      .getResources()
+      .getIdentifier("status_bar_height", "dimen", "android");
+    if (resourceId > 0) {
+      result = getContext().getResources().getDimensionPixelSize(resourceId);
+    }
+    return result;
+  }
+
+  private int getNavigationBarHeightPx() {
+    int result = 0;
+    int resourceId = getContext()
+      .getResources()
+      .getIdentifier("navigation_bar_height", "dimen", "android");
+    if (resourceId > 0) {
+      result = getContext().getResources().getDimensionPixelSize(resourceId);
+    }
+    return result;
+  }
 }