react-native-rectangle-doc-scanner 10.38.0 → 10.40.0

package/android/src/camera2/kotlin/com/reactnativerectangledocscanner/CameraController.kt

@@ -118,11 +118,11 @@ class CameraController(
         Log.d(TAG, "[CAMERAX] TextureView visibility: ${textureView.visibility}")
         Log.d(TAG, "[CAMERAX] TextureView isAvailable: ${textureView.isAvailable}")
 
-        // Force portrait orientation (app is portrait-only)
-        val targetRotation = android.view.Surface.ROTATION_0
-        Log.d(TAG, "[CAMERAX] Setting target rotation to ROTATION_0 (portrait-only app)")
+        val targetRotation = textureView.display?.rotation ?: android.view.Surface.ROTATION_0
+        Log.d(TAG, "[CAMERAX] Setting target rotation to $targetRotation")
 
         preview = Preview.Builder()
+            .setTargetAspectRatio(AspectRatio.RATIO_4_3)
             .setTargetRotation(targetRotation)  // Force portrait
             .build()
             .also { previewUseCase ->
@@ -185,7 +185,7 @@ class CameraController(
         // ImageAnalysis UseCase for document detection
         imageAnalyzer = ImageAnalysis.Builder()
             .setBackpressureStrategy(ImageAnalysis.STRATEGY_KEEP_ONLY_LATEST)
-            .setTargetResolution(android.util.Size(1920, 1440))  // Higher resolution for better small-edge detection
+            .setTargetAspectRatio(AspectRatio.RATIO_4_3)
             .setTargetRotation(targetRotation)  // Match preview rotation
             .build()
             .also {
@@ -201,6 +201,7 @@ class CameraController(
         // ImageCapture UseCase
         imageCapture = ImageCapture.Builder()
             .setCaptureMode(ImageCapture.CAPTURE_MODE_MAXIMIZE_QUALITY)
+            .setTargetAspectRatio(AspectRatio.RATIO_4_3)
             .setTargetRotation(targetRotation)  // Match preview rotation
             .build()
 
@@ -494,8 +495,6 @@ class CameraController(
             return
         }
 
-        // Get sensor orientation to determine correct rotation
-        val sensorOrientation = getCameraSensorOrientation()
         val displayRotationDegrees = when (textureView.display?.rotation ?: Surface.ROTATION_0) {
             Surface.ROTATION_0 -> 0
             Surface.ROTATION_90 -> 90
@@ -507,36 +506,16 @@ class CameraController(
         Log.d(
             TAG,
             "[TRANSFORM] View: ${viewWidth}x${viewHeight}, Buffer: ${bufferWidth}x${bufferHeight}, " +
-                "Sensor: ${sensorOrientation}°, Display: ${displayRotationDegrees}°"
+                "Display: ${displayRotationDegrees}°"
         )
 
         val matrix = android.graphics.Matrix()
         val centerX = viewWidth / 2f
         val centerY = viewHeight / 2f
 
-        // Calculate rotation from buffer to display coordinates.
-        // CameraX accounts for sensor orientation via targetRotation. Some tablets with landscape
-        // sensors report Display 90 in portrait but render upside down; add a 180° fix for that case.
-        val tabletUpsideDownFix = if (sensorOrientation == 0 && displayRotationDegrees == 90) 180 else 0
-        val rotationDegrees = ((displayRotationDegrees + tabletUpsideDownFix) % 360).toFloat()
-
-        Log.d(TAG, "[TRANSFORM] Applying rotation: ${rotationDegrees}°")
-
-        if (rotationDegrees != 0f) {
-            matrix.postRotate(rotationDegrees, centerX, centerY)
-        }
-
-        // After rotation, determine effective buffer size
-        val rotatedBufferWidth = if (rotationDegrees == 90f || rotationDegrees == 270f) {
-            bufferHeight
-        } else {
-            bufferWidth
-        }
-        val rotatedBufferHeight = if (rotationDegrees == 90f || rotationDegrees == 270f) {
-            bufferWidth
-        } else {
-            bufferHeight
-        }
+        // Preview buffers are already rotated to match targetRotation.
+        val rotatedBufferWidth = bufferWidth
+        val rotatedBufferHeight = bufferHeight
 
         // Scale to fill the view while maintaining aspect ratio (center-crop).
         val scaleX = viewWidth.toFloat() / rotatedBufferWidth.toFloat()

package/dist/DocScanner.js

@@ -121,24 +121,14 @@ const mirrorRectangleHorizontally = (rectangle, imageWidth) => ({
 const mapRectangleToView = (rectangle, imageWidth, imageHeight, viewWidth, viewHeight, density) => {
     const viewWidthPx = viewWidth * density;
     const viewHeightPx = viewHeight * density;
-    const scale = react_native_1.Platform.OS === 'ios'
-        ? Math.max(viewWidthPx / imageWidth, viewHeightPx / imageHeight)
-        : Math.min(viewWidthPx / imageWidth, viewHeightPx / imageHeight);
+    const scale = Math.max(viewWidthPx / imageWidth, viewHeightPx / imageHeight);
     const scaledImageWidth = imageWidth * scale;
     const scaledImageHeight = imageHeight * scale;
-    const offsetX = react_native_1.Platform.OS === 'ios'
-        ? (scaledImageWidth - viewWidthPx) / 2
-        : (viewWidthPx - scaledImageWidth) / 2;
-    const offsetY = react_native_1.Platform.OS === 'ios'
-        ? (scaledImageHeight - viewHeightPx) / 2
-        : (viewHeightPx - scaledImageHeight) / 2;
+    const offsetX = (scaledImageWidth - viewWidthPx) / 2;
+    const offsetY = (scaledImageHeight - viewHeightPx) / 2;
     const mapPoint = (point) => ({
-        x: react_native_1.Platform.OS === 'ios'
-            ? (point.x * scale - offsetX) / density
-            : (point.x * scale + offsetX) / density,
-        y: react_native_1.Platform.OS === 'ios'
-            ? (point.y * scale - offsetY) / density
-            : (point.y * scale + offsetY) / density,
+        x: (point.x * scale - offsetX) / density,
+        y: (point.y * scale - offsetY) / density,
     });
     return {
         topLeft: mapPoint(rectangle.topLeft),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-rectangle-doc-scanner",
-  "version": "10.38.0",
+  "version": "10.40.0",
   "description": "Native-backed document scanner for React Native with customizable overlays.",
   "license": "MIT",
   "main": "dist/index.js",

package/src/DocScanner.tsx

@@ -188,30 +188,15 @@ const mapRectangleToView = (
 ): Rectangle => {
   const viewWidthPx = viewWidth * density;
   const viewHeightPx = viewHeight * density;
-  const scale =
-    Platform.OS === 'ios'
-      ? Math.max(viewWidthPx / imageWidth, viewHeightPx / imageHeight)
-      : Math.min(viewWidthPx / imageWidth, viewHeightPx / imageHeight);
+  const scale = Math.max(viewWidthPx / imageWidth, viewHeightPx / imageHeight);
   const scaledImageWidth = imageWidth * scale;
   const scaledImageHeight = imageHeight * scale;
-  const offsetX =
-    Platform.OS === 'ios'
-      ? (scaledImageWidth - viewWidthPx) / 2
-      : (viewWidthPx - scaledImageWidth) / 2;
-  const offsetY =
-    Platform.OS === 'ios'
-      ? (scaledImageHeight - viewHeightPx) / 2
-      : (viewHeightPx - scaledImageHeight) / 2;
+  const offsetX = (scaledImageWidth - viewWidthPx) / 2;
+  const offsetY = (scaledImageHeight - viewHeightPx) / 2;
 
   const mapPoint = (point: Point): Point => ({
-    x:
-      Platform.OS === 'ios'
-        ? (point.x * scale - offsetX) / density
-        : (point.x * scale + offsetX) / density,
-    y:
-      Platform.OS === 'ios'
-        ? (point.y * scale - offsetY) / density
-        : (point.y * scale + offsetY) / density,
+    x: (point.x * scale - offsetX) / density,
+    y: (point.y * scale - offsetY) / density,
   });
 
   return {