@react-native-harness/ui 1.6.0 → 1.7.0

package/Package.swift

@@ -0,0 +1,40 @@
+// swift-tools-version: 6.0
+
+import PackageDescription
+
+// React Native resolves these dependencies from
+// build/generated/autolinking/libs/HarnessUI in the app's iOS directory.
+let package = Package(
+    name: "HarnessUI",
+    platforms: [.iOS("15.1")],
+    products: [
+        .library(name: "HarnessUI", targets: ["HarnessUI"]),
+    ],
+    dependencies: [
+        .package(name: "ReactNative", path: "../../../../xcframeworks"),
+        .package(name: "React-GeneratedCode", path: "../../../ios"),
+    ],
+    targets: [
+        .target(
+            name: "HarnessUI",
+            dependencies: [
+                .product(name: "ReactHeaders", package: "ReactNative"),
+                .product(name: "ReactNativeHeaders", package: "ReactNative"),
+                .product(name: "ReactNativeDependenciesHeaders", package: "ReactNative"),
+                .product(name: "ReactAppHeaders", package: "React-GeneratedCode"),
+            ],
+            path: "ios",
+            publicHeadersPath: ".",
+            cxxSettings: [
+                .define("DEBUG", .when(configuration: .debug)),
+                .define("NDEBUG", .when(configuration: .release)),
+            ],
+            linkerSettings: [
+                .linkedFramework("UIKit"),
+                .linkedFramework("Foundation"),
+                .linkedFramework("CoreGraphics"),
+            ]
+        ),
+    ],
+    cxxLanguageStandard: .cxx20
+)

package/README.md

@@ -26,6 +26,13 @@ pnpm add @react-native-harness/ui
 yarn add @react-native-harness/ui
 ```
 
+### iOS with Swift Package Manager
+
+For apps using React Native's SwiftPM integration, run `npx react-native spm` from
+the app directory after installing this package. The package includes the
+`HarnessUI` SwiftPM manifest and autolinking metadata; no local manifest patch is
+needed. Apps using CocoaPods can continue to use `pod install`.
+
 ## Usage
 
 Import the UI testing utilities in your test files:

package/android/src/main/java/com/harnessui/HarnessUIModule.kt

@@ -41,9 +41,10 @@ class HarnessUIModule(
     override fun queryAllByAccessibilityLabel(label: String): WritableArray = helper.queryAllByAccessibilityLabel(label)
 
     override fun captureScreenshot(
-        bounds: ReadableMap?,
+        options: ReadableMap,
         promise: Promise,
     ) {
+        val bounds = if (options.hasKey("bounds")) options.getMap("bounds") else null
         helper.captureScreenshot(bounds, promise)
     }
 

package/android/src/main/java/com/harnessui/UIHelperImpl.kt

@@ -3,12 +3,23 @@ package com.harnessui
 import android.content.Context
 import android.graphics.Bitmap
 import android.graphics.Canvas
+import android.graphics.Matrix
+import android.graphics.Paint
+import android.graphics.PorterDuff
+import android.graphics.PorterDuffXfermode
 import android.graphics.Rect
+import android.graphics.RectF
+import android.os.Build
 import android.os.Handler
 import android.os.Looper
 import android.os.SystemClock
 import android.util.Log
 import android.view.MotionEvent
+import android.view.PixelCopy
+import android.view.SurfaceView
+import android.view.View
+import android.view.ViewGroup
+import android.view.Window
 import android.view.inputmethod.EditorInfo
 import android.view.inputmethod.InputMethodManager
 import android.widget.EditText
@@ -24,6 +35,9 @@ import java.io.ByteArrayOutputStream
 import java.nio.ByteBuffer
 import java.util.concurrent.CountDownLatch
 import java.util.concurrent.TimeUnit
+import kotlin.math.floor
+import kotlin.math.min
+import kotlin.math.roundToInt
 
 /**
  * UI helper implementation for HarnessUI.
@@ -36,6 +50,8 @@ class UIHelperImpl(
         private const val TAG = "HarnessUI"
         private const val TAP_DURATION_MS = 50L // Duration between touch down and up
         private const val EVENT_PROCESSING_DELAY_MS = 10L // Delay after touch up for React Native to process the event
+        private const val GEOMETRY_FUDGE_FACTOR = 0.0656f // How far the renderer widens a box it snaps to pixels
+        private const val COPY_ATTEMPTS = 4 // Requests of a copy the renderer abandons at its 500 ms buffer fence wait
     }
 
     private val mainHandler = Handler(Looper.getMainLooper())
@@ -250,7 +266,8 @@ class UIHelperImpl(
                     return@runOnUiThread
                 }
 
-            val root = activity.window.decorView.rootView
+            val window = activity.window
+            val root = window.decorView.rootView
             val density = root.resources.displayMetrics.density
 
             try {
@@ -258,99 +275,417 @@ class UIHelperImpl(
                 val nativeId = if (bounds != null && bounds.hasKey("nativeId")) bounds.getString("nativeId") else null
 
                 if (!nativeId.isNullOrEmpty()) {
+                    // Element screenshots never fall back to a window/region capture.
                     val targetView = ViewRegistry.get(nativeId)
-                    if (targetView != null) {
-                        val width = targetView.width
-                        val height = targetView.height
-
-                        if (width > 0 && height > 0) {
-                            val location = IntArray(2)
-                            targetView.getLocationOnScreen(location)
-                            val viewRect = Rect(location[0], location[1], location[0] + width, location[1] + height)
-                            val rootRect = Rect(0, 0, root.width, root.height)
-
-                            val isFullyOnScreen = rootRect.contains(viewRect)
-                            val bitmap = Bitmap.createBitmap(width, height, Bitmap.Config.ARGB_8888)
-                            val canvas = Canvas(bitmap)
-
-                            if (isFullyOnScreen) {
-                                Log.i(TAG, "View $nativeId is fully on screen. Using screen-based screenshotting.")
-                                // Translate canvas to capture the view from the root view hierarchy
-                                canvas.translate(-location[0].toFloat(), -location[1].toFloat())
-                                root.draw(canvas)
-                            } else {
-                                Log.i(TAG, "View $nativeId is partially/fully off screen. Using direct view render.")
-                                // Draw the specific view directly
-                                targetView.draw(canvas)
-                            }
+                    if (targetView == null) {
+                        Log.w(TAG, "View with nativeId $nativeId not found for screenshot")
+                        promise.resolve(null)
+                        return@runOnUiThread
+                    }
 
-                            val outputStream = ByteArrayOutputStream()
-                            bitmap.compress(Bitmap.CompressFormat.PNG, 100, outputStream)
-                            val pngBytes = outputStream.toByteArray()
-                            bitmap.recycle()
+                    val width = targetView.width
+                    val height = targetView.height
 
-                            val base64String = android.util.Base64.encodeToString(pngBytes, android.util.Base64.NO_WRAP)
-                            promise.resolve(base64String)
-                            return@runOnUiThread
-                        }
+                    if (width <= 0 || height <= 0) {
+                        Log.w(TAG, "View $nativeId has zero size ($width x $height), nothing to capture")
+                        promise.resolve(null)
+                        return@runOnUiThread
+                    }
+
+                    val viewRect = rectInWindow(targetView)
+                    val rootRect = Rect(0, 0, root.width, root.height)
+
+                    if (targetView.isAttachedToWindow && !viewRect.isEmpty && rootRect.contains(viewRect)) {
+                        Log.i(TAG, "View $nativeId is fully on screen. Using screen-based screenshotting.")
+                        captureWindowRegion(window, viewRect, promise)
                     } else {
-                        Log.w(TAG, "View with nativeId $nativeId not found for screenshot, falling back to window screenshot")
+                        Log.i(TAG, "View $nativeId is not fully on screen. Using direct view render.")
+                        promise.resolve(encodePng(drawView(targetView)))
                     }
+                    return@runOnUiThread
                 }
 
-                // Determine capture dimensions
-                val captureX: Int
-                val captureY: Int
-                val captureWidth: Int
-                val captureHeight: Int
-
                 // Check if bounds are provided and have non-zero dimensions
-                val hasBounds = bounds != null && bounds.getDouble("width") > 0 && bounds.getDouble("height") > 0
-
-                if (hasBounds) {
-                    // Convert dp to px for bounds
-                    captureX = (bounds!!.getDouble("x") * density).toInt()
-                    captureY = (bounds.getDouble("y") * density).toInt()
-                    captureWidth = (bounds.getDouble("width") * density).toInt()
-                    captureHeight = (bounds.getDouble("height") * density).toInt()
-                    Log.i(TAG, "Capturing region: x=$captureX y=$captureY w=$captureWidth h=$captureHeight")
-                } else {
-                    captureX = 0
-                    captureY = 0
-                    captureWidth = root.width
-                    captureHeight = root.height
-                    Log.i(TAG, "Capturing full window: w=$captureWidth h=$captureHeight")
-                }
+                val region =
+                    if (bounds != null && bounds.getDouble("width") > 0 && bounds.getDouble("height") > 0) {
+                        // Convert dp to px, rounding each edge (not the size) so the region covers the same
+                        // pixels React Native lays out for a view with these bounds.
+                        val boundsX = bounds.getDouble("x")
+                        val boundsY = bounds.getDouble("y")
+                        val left = (boundsX * density).roundToInt()
+                        val top = (boundsY * density).roundToInt()
+                        val right = ((boundsX + bounds.getDouble("width")) * density).roundToInt()
+                        val bottom = ((boundsY + bounds.getDouble("height")) * density).roundToInt()
+                        Log.i(TAG, "Capturing region: x=$left y=$top w=${right - left} h=${bottom - top}")
+                        Rect(left, top, right, bottom)
+                    } else {
+                        Log.i(TAG, "Capturing full window: w=${root.width} h=${root.height}")
+                        Rect(0, 0, root.width, root.height)
+                    }
+
+                captureWindowRegion(window, region, promise)
+            } catch (e: Exception) {
+                Log.e(TAG, "Screenshot capture failed", e)
+                promise.resolve(null)
+            }
+        }
+    }
+
+    // A software draw of the view tree leaves out pixels a view keeps on a surface of its own: a TextureView draws
+    // nothing into a software canvas, and a SurfaceView's content lives on a separate surface behind the window, which
+    // leaves a transparent hole over it. PixelCopy reads the window's surface, which the TextureViews render into, and
+    // each SurfaceView's surface, each at the latest frame it holds when its copy runs. A SurfaceView set above its
+    // window with setZOrderOnTop punches no hole, so it stays hidden: before Android 16 only hidden API tells one
+    // apart, and the SDK this module compiles against by default predates getCompositionOrder().
+    private fun captureWindowRegion(
+        window: Window,
+        region: Rect,
+        promise: Promise,
+    ) {
+        val decorView = window.decorView
+        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.O) {
+            promise.resolve(encodePng(drawWindowRegion(decorView, region)))
+            return
+        }
+        // A window that is not shown, as while the screen is off, has nothing on the screen to copy.
+        if (!decorView.isShown) {
+            Log.e(TAG, "Screenshot capture failed: the window is not shown")
+            promise.resolve(null)
+            return
+        }
 
-                // Create bitmap and canvas
-                val bitmap = Bitmap.createBitmap(captureWidth, captureHeight, Bitmap.Config.ARGB_8888)
-                val canvas = Canvas(bitmap)
+        // PixelCopy stretches a source rect that runs past the window over the whole bitmap, so only the part on the
+        // window is copied, and placed at its offset in the region.
+        val copiedRegion = Rect(0, 0, decorView.width, decorView.height)
+        if (!copiedRegion.intersect(region)) {
+            promise.resolve(encodePng(drawWindowRegion(decorView, region)))
+            return
+        }
 
-                // Translate canvas if capturing a specific region
-                canvas.translate(-captureX.toFloat(), -captureY.toFloat())
+        val surfaceViews =
+            collectSurfaceViews(decorView).filter { surfaceView ->
+                !surfaceView.rect.isEmpty && Rect.intersects(copiedRegion, surfaceView.rect)
+            }
+        val surfaceLayers = arrayOfNulls<SurfaceLayer>(surfaceViews.size)
+        var windowSource: WindowSource = WindowSource.ViewTree
+        var copyFailure: String? = null
+        var pendingCopies = surfaceViews.size + 1
 
-                // Draw the view hierarchy
-                root.draw(canvas)
+        fun failCopy(reason: String) {
+            copyFailure = copyFailure ?: reason
+        }
 
-                // Convert to PNG bytes
-                val outputStream = ByteArrayOutputStream()
-                bitmap.compress(Bitmap.CompressFormat.PNG, 100, outputStream)
-                val pngBytes = outputStream.toByteArray()
+        fun onCopyFinished() {
+            pendingCopies -= 1
+            if (pendingCopies > 0) {
+                return
+            }
+            val layers = surfaceLayers.filterNotNull()
 
-                // Clean up
-                bitmap.recycle()
+            fun abandon() {
+                when (val source = windowSource) {
+                    is WindowSource.Copy -> source.pixels.recycle()
+                    WindowSource.ViewTree -> Unit
+                }
+                layers.forEach { layer -> layer.pixels.recycle() }
+                promise.resolve(null)
+            }
 
-                // Return as Base64 string for efficiency
-                val base64String = android.util.Base64.encodeToString(pngBytes, android.util.Base64.NO_WRAP)
-                Log.i(TAG, "Screenshot captured successfully (${pngBytes.size} bytes)")
-                promise.resolve(base64String)
+            val failure = copyFailure
+            if (failure != null) {
+                Log.e(TAG, "Screenshot capture failed: $failure")
+                abandon()
+                return
+            }
+            var screenshot: Bitmap? = null
+            try {
+                screenshot =
+                    when (val source = windowSource) {
+                        is WindowSource.Copy -> placeInRegion(source.pixels, copiedRegion, region)
+                        WindowSource.ViewTree -> drawWindowRegion(decorView, region)
+                    }
+                drawBehind(screenshot, layers, Rect(copiedRegion).apply { offset(-region.left, -region.top) })
+                promise.resolve(encodePng(screenshot))
             } catch (e: Exception) {
                 Log.e(TAG, "Screenshot capture failed", e)
-                promise.resolve(null)
+                screenshot?.recycle()
+                abandon()
+            }
+        }
+
+        // Before Android 9, PixelCopy does not offset the rect it is given by the window's surface insets, which a
+        // window with elevation has, so such a window's view tree is drawn instead.
+        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.P && decorView.z > 0f) {
+            onCopyFinished()
+        } else {
+            val windowPixels = Bitmap.createBitmap(copiedRegion.width(), copiedRegion.height(), Bitmap.Config.ARGB_8888)
+            val copyWindow = { listener: PixelCopy.OnPixelCopyFinishedListener ->
+                PixelCopy.request(window, Rect(copiedRegion), windowPixels, listener, mainHandler)
+            }
+            requestCopy(copyWindow) { outcome ->
+                when (outcome) {
+                    is CopyOutcome.Finished ->
+                        if (outcome.result == PixelCopy.SUCCESS) {
+                            windowSource = WindowSource.Copy(windowPixels)
+                        } else {
+                            windowPixels.recycle()
+                            failCopy("PixelCopy of the window failed with result ${outcome.result}")
+                        }
+                    is CopyOutcome.SourceGone -> {
+                        windowPixels.recycle()
+                        failCopy("PixelCopy cannot read the window, which has no surface: ${outcome.error.message}")
+                    }
+                }
+                onCopyFinished()
+            }
+        }
+
+        // A SurfaceView's buffer can differ in size from its view, as a video decoder's does, and the screen shows it
+        // scaled to the view's box, so the whole buffer is copied, at no more than the view's own size, and drawn into
+        // the box.
+        surfaceViews.forEachIndexed { index, surfaceView ->
+            val pixels =
+                Bitmap.createBitmap(
+                    min(surfaceView.rect.width(), surfaceView.view.width),
+                    min(surfaceView.rect.height(), surfaceView.view.height),
+                    Bitmap.Config.ARGB_8888,
+                )
+            val box = Rect(surfaceView.rect).apply { offset(-region.left, -region.top) }
+            val copySurface = { listener: PixelCopy.OnPixelCopyFinishedListener ->
+                PixelCopy.request(surfaceView.view, pixels, listener, mainHandler)
+            }
+            requestCopy(copySurface) { outcome ->
+                when (outcome) {
+                    is CopyOutcome.Finished ->
+                        when (val result = outcome.result) {
+                            PixelCopy.SUCCESS -> surfaceLayers[index] = SurfaceLayer(pixels, box)
+                            // A surface with no frame yet, one that is gone and a protected one hold nothing a copy can
+                            // read, so they add no layer.
+                            PixelCopy.ERROR_SOURCE_NO_DATA, PixelCopy.ERROR_SOURCE_INVALID -> pixels.recycle()
+                            else -> {
+                                failCopy("PixelCopy of a SurfaceView failed with result $result")
+                                pixels.recycle()
+                            }
+                        }
+                    is CopyOutcome.SourceGone -> {
+                        Log.w(TAG, "PixelCopy cannot read a SurfaceView, whose surface is gone", outcome.error)
+                        pixels.recycle()
+                    }
+                }
+                onCopyFinished()
             }
         }
     }
 
+    private sealed interface WindowSource {
+        class Copy(val pixels: Bitmap) : WindowSource
+
+        object ViewTree : WindowSource
+    }
+
+    private sealed interface CopyOutcome {
+        class Finished(val result: Int) : CopyOutcome
+
+        class SourceGone(val error: IllegalArgumentException) : CopyOutcome
+    }
+
+    // The renderer abandons a copy whose source buffer is still being drawn when its fence wait ends (ERROR_TIMEOUT),
+    // so a slow GPU gets the copy requested again, up to COPY_ATTEMPTS times, before it counts as failed.
+    private fun requestCopy(
+        request: (PixelCopy.OnPixelCopyFinishedListener) -> Unit,
+        attempt: Int = 1,
+        onOutcome: (CopyOutcome) -> Unit,
+    ) {
+        try {
+            request(
+                PixelCopy.OnPixelCopyFinishedListener { result ->
+                    if (result == PixelCopy.ERROR_TIMEOUT && attempt < COPY_ATTEMPTS) {
+                        requestCopy(request, attempt + 1, onOutcome)
+                    } else {
+                        onOutcome(CopyOutcome.Finished(result))
+                    }
+                },
+            )
+        } catch (e: IllegalArgumentException) {
+            onOutcome(CopyOutcome.SourceGone(e))
+        }
+    }
+
+    private fun drawView(view: View): Bitmap =
+        drawRegion(Rect(0, 0, view.width, view.height)) { canvas -> drawScrolled(view, canvas) }
+
+    // The window's view tree drawn in software where the window shows it, through the root view's transform and the
+    // window's pan and cut at the window's edges, so the region and the SurfaceViews' boxes line up with it.
+    private fun drawWindowRegion(
+        rootView: View,
+        region: Rect,
+    ): Bitmap =
+        drawRegion(region) { canvas ->
+            canvas.clipRect(0, 0, rootView.width, rootView.height)
+            canvas.concat(viewToWindow(rootView))
+            drawScrolled(rootView, canvas)
+        }
+
+    // A view draws its content in its scrolled space, which the parent's draw otherwise translates it into.
+    private fun drawScrolled(
+        view: View,
+        canvas: Canvas,
+    ) {
+        canvas.translate(-view.scrollX.toFloat(), -view.scrollY.toFloat())
+        view.draw(canvas)
+    }
+
+    private fun drawRegion(
+        region: Rect,
+        draw: (Canvas) -> Unit,
+    ): Bitmap {
+        val bitmap = Bitmap.createBitmap(region.width(), region.height(), Bitmap.Config.ARGB_8888)
+        try {
+            val canvas = Canvas(bitmap)
+            canvas.translate(-region.left.toFloat(), -region.top.toFloat())
+            draw(canvas)
+        } catch (e: Exception) {
+            bitmap.recycle()
+            throw e
+        }
+        return bitmap
+    }
+
+    private fun placeInRegion(
+        pixels: Bitmap,
+        pixelsRegion: Rect,
+        region: Rect,
+    ): Bitmap {
+        if (pixelsRegion == region) {
+            return pixels
+        }
+        val bitmap = Bitmap.createBitmap(region.width(), region.height(), Bitmap.Config.ARGB_8888)
+        Canvas(bitmap).drawBitmap(
+            pixels,
+            (pixelsRegion.left - region.left).toFloat(),
+            (pixelsRegion.top - region.top).toFloat(),
+            null,
+        )
+        pixels.recycle()
+        return bitmap
+    }
+
+    // Each layer goes behind what is drawn already, so the layers are drawn last to first, stacking the SurfaceViews in
+    // the order of the view tree. The screen stacks a media overlay above the others, which no public API reports
+    // before Android 16, and the rest in the order their surfaces were created, which no API reports. Nothing is drawn
+    // outside the window's part of the region.
+    private fun drawBehind(
+        screenshot: Bitmap,
+        layers: List<SurfaceLayer>,
+        windowPart: Rect,
+    ) {
+        val canvas = Canvas(screenshot)
+        canvas.clipRect(windowPart)
+        val behind = Paint(Paint.FILTER_BITMAP_FLAG).apply { xfermode = PorterDuffXfermode(PorterDuff.Mode.DST_OVER) }
+        layers.asReversed().forEach { layer ->
+            canvas.drawBitmap(layer.pixels, null, layer.box, behind)
+            layer.pixels.recycle()
+        }
+    }
+
+    private class SurfaceLayer(
+        val pixels: Bitmap,
+        val box: Rect,
+    )
+
+    private class SurfaceViewInWindow(
+        val view: SurfaceView,
+        val rect: Rect,
+    )
+
+    private fun collectSurfaceViews(
+        view: View,
+        found: MutableList<SurfaceViewInWindow> = mutableListOf(),
+    ): List<SurfaceViewInWindow> {
+        when {
+            view.visibility != View.VISIBLE -> Unit
+            view is SurfaceView ->
+                if (view.width > 0 && view.height > 0 && view.holder.surface.isValid) {
+                    found.add(SurfaceViewInWindow(view, rectInWindow(view)))
+                }
+            view is ViewGroup ->
+                for (index in 0 until view.childCount) {
+                    collectSurfaceViews(view.getChildAt(index), found)
+                }
+        }
+        return found
+    }
+
+    // A view's own space mapped into the window through its own and its ancestors' transforms, composed into one as
+    // the renderer composes them, then the pan the window applies to all of its views.
+    private fun viewToWindow(view: View): Matrix {
+        val transform = Matrix()
+        var current = view
+        while (true) {
+            transform.postConcat(current.matrix)
+            transform.postTranslate(current.left.toFloat(), current.top.toFloat())
+            val parent = current.parent as? View ?: break
+            transform.postTranslate(-parent.scrollX.toFloat(), -parent.scrollY.toFloat())
+            current = parent
+        }
+        // The root view's location in the window is its own corner, already composed above, rounded to whole pixels,
+        // plus the pan.
+        val rootLocation = IntArray(2)
+        current.getLocationInWindow(rootLocation)
+        val rootCorner = floatArrayOf(0f, 0f).also { corner -> current.matrix.mapPoints(corner) }
+        transform.postTranslate(
+            (rootLocation[0] - (rootCorner[0] + current.left).roundToInt()).toFloat(),
+            (rootLocation[1] - (rootCorner[1] + current.top).roundToInt()).toFloat(),
+        )
+        return transform
+    }
+
+    // The box a view covers in the window, as UIKit's convertRect:toView: gives it, rounded as the renderer rounds the
+    // box it shows a SurfaceView's surface in: snapped to pixel boundaries under translation alone, outward under any
+    // other transform. A box with no area stays empty whatever its rounding would give.
+    private fun rectInWindow(view: View): Rect {
+        val transform = viewToWindow(view)
+        val bounds = RectF(0f, 0f, view.width.toFloat(), view.height.toFloat()).also { rect -> transform.mapRect(rect) }
+        return when {
+            bounds.isEmpty -> Rect()
+            isTranslation(transform) -> snapToPixelBoundaries(bounds)
+            else -> Rect().also { rect -> bounds.roundOut(rect) }
+        }
+    }
+
+    // As the renderer snaps a box under translation alone: to the nearest pixel, and from Android 10
+    // (Rect::snapGeometryToPixelBoundaries) with an edge within GEOMETRY_FUDGE_FACTOR of a half pixel going outward.
+    private fun snapToPixelBoundaries(bounds: RectF): Rect {
+        val fudge = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) GEOMETRY_FUDGE_FACTOR else 0f
+        return Rect(
+            floor(bounds.left + 0.5f - fudge).toInt(),
+            floor(bounds.top + 0.5f - fudge).toInt(),
+            floor(bounds.right + 0.5f + fudge).toInt(),
+            floor(bounds.bottom + 0.5f + fudge).toInt(),
+        )
+    }
+
+    private fun isTranslation(matrix: Matrix): Boolean {
+        val values = FloatArray(9).also { matrix.getValues(it) }
+        return values[Matrix.MSCALE_X] == 1f &&
+            values[Matrix.MSCALE_Y] == 1f &&
+            values[Matrix.MSKEW_X] == 0f &&
+            values[Matrix.MSKEW_Y] == 0f &&
+            values[Matrix.MPERSP_0] == 0f &&
+            values[Matrix.MPERSP_1] == 0f
+    }
+
+    private fun encodePng(bitmap: Bitmap): String {
+        try {
+            val outputStream = ByteArrayOutputStream()
+            bitmap.compress(Bitmap.CompressFormat.PNG, 100, outputStream)
+            Log.i(TAG, "Screenshot captured successfully (${outputStream.size()} bytes)")
+            return android.util.Base64.encodeToString(outputStream.toByteArray(), android.util.Base64.NO_WRAP)
+        } finally {
+            bitmap.recycle()
+        }
+    }
+
     // =========================================================================
     // Text Input
     // =========================================================================

package/dist/NativeHarnessUI.d.ts

@@ -21,7 +21,9 @@ interface Spec extends TurboModule {
     queryAllByTestId(testId: string): ViewInfo[];
     queryByAccessibilityLabel(label: string): ViewInfo | null;
     queryAllByAccessibilityLabel(label: string): ViewInfo[];
-    captureScreenshot(bounds: ViewInfo | null): Promise<string | null>;
+    captureScreenshot(options: {
+        bounds?: ViewInfo;
+    }): Promise<string | null>;
     typeChar(character: string): Promise<void>;
     blur(options: {
         submitEditing?: boolean;

package/dist/NativeHarnessUI.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"NativeHarnessUI.d.ts","sourceRoot":"","sources":["../src/NativeHarnessUI.ts"],"names":[],"mappings":"AAAA,OAAO,EAAuB,KAAK,WAAW,EAAE,MAAM,cAAc,CAAC;AAErE;;GAEG;AACH,MAAM,WAAW,WAAW;IAC1B,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;CAChB;AAED;;;GAGG;AACH,MAAM,WAAW,QAAS,SAAQ,WAAW;IAC3C,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED,UAAU,IAAK,SAAQ,WAAW;IAChC,aAAa,CAAC,QAAQ,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACrE,aAAa,CAAC,MAAM,EAAE,MAAM,GAAG,QAAQ,GAAG,IAAI,CAAC;IAC/C,gBAAgB,CAAC,MAAM,EAAE,MAAM,GAAG,QAAQ,EAAE,CAAC;IAC7C,yBAAyB,CAAC,KAAK,EAAE,MAAM,GAAG,QAAQ,GAAG,IAAI,CAAC;IAC1D,4BAA4B,CAAC,KAAK,EAAE,MAAM,GAAG,QAAQ,EAAE,CAAC;IACxD,iBAAiB,CAAC,MAAM,EAAE,QAAQ,GAAG,IAAI,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAAC;IACnE,QAAQ,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAC3C,IAAI,CAAC,OAAO,EAAE;QAAE,aAAa,CAAC,EAAE,OAAO,CAAA;KAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CAC3D;;AAED,wBAAmE"}
+{"version":3,"file":"NativeHarnessUI.d.ts","sourceRoot":"","sources":["../src/NativeHarnessUI.ts"],"names":[],"mappings":"AAAA,OAAO,EAAuB,KAAK,WAAW,EAAE,MAAM,cAAc,CAAC;AAErE;;GAEG;AACH,MAAM,WAAW,WAAW;IAC1B,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;CAChB;AAED;;;GAGG;AACH,MAAM,WAAW,QAAS,SAAQ,WAAW;IAC3C,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED,UAAU,IAAK,SAAQ,WAAW;IAChC,aAAa,CAAC,QAAQ,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACrE,aAAa,CAAC,MAAM,EAAE,MAAM,GAAG,QAAQ,GAAG,IAAI,CAAC;IAC/C,gBAAgB,CAAC,MAAM,EAAE,MAAM,GAAG,QAAQ,EAAE,CAAC;IAC7C,yBAAyB,CAAC,KAAK,EAAE,MAAM,GAAG,QAAQ,GAAG,IAAI,CAAC;IAC1D,4BAA4B,CAAC,KAAK,EAAE,MAAM,GAAG,QAAQ,EAAE,CAAC;IACxD,iBAAiB,CAAC,OAAO,EAAE;QAAE,MAAM,CAAC,EAAE,QAAQ,CAAA;KAAE,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAAC;IAC1E,QAAQ,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAC3C,IAAI,CAAC,OAAO,EAAE;QAAE,aAAa,CAAC,EAAE,OAAO,CAAA;KAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CAC3D;;AAED,wBAAmE"}

package/dist/WebHarnessUI.js

@@ -49,8 +49,8 @@ const WebHarnessUI = {
         const elements = document.querySelectorAll(`[aria-label="${label}"]`);
         return Array.from(elements).map(getElementViewInfo);
     },
-    captureScreenshot: async (bounds) => {
-        let captureBounds = bounds;
+    captureScreenshot: async ({ bounds }) => {
+        let captureBounds = bounds ?? null;
         if (bounds?.nativeId && bounds.width === 0 && bounds.height === 0) {
             const element = window.__RN_HARNESS_VIEW_REGISTRY__.get(bounds.nativeId);
             if (element) {

package/dist/screen.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"screen.d.ts","sourceRoot":"","sources":["../src/screen.ts"],"names":[],"mappings":"AAAA,OAAO,EAAiB,KAAK,WAAW,EAAE,MAAM,YAAY,CAAC;AAI7D;;;GAGG;AACH,MAAM,MAAM,gBAAgB,GAAG;IAC7B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;CAC3B,CAAC;AAMF;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC/B,sDAAsD;IACtD,IAAI,EAAE,UAAU,CAAC;IACjB,gEAAgE;IAChE,KAAK,EAAE,MAAM,CAAC;IACd,iEAAiE;IACjE,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,MAAM,MAAM,GAAG;IACnB;;;OAGG;IACH,YAAY,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,OAAO,CAAC,gBAAgB,CAAC,CAAC;IAE5D;;;OAGG;IACH,eAAe,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,OAAO,CAAC,gBAAgB,EAAE,CAAC,CAAC;IAEjE;;;OAGG;IACH,aAAa,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,gBAAgB,GAAG,IAAI,CAAC;IAE3D;;;OAGG;IACH,gBAAgB,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,gBAAgB,EAAE,CAAC;IAEzD;;;OAGG;IACH,wBAAwB,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,OAAO,CAAC,gBAAgB,CAAC,CAAC;IAEvE;;;OAGG;IACH,2BAA2B,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,OAAO,CAAC,gBAAgB,EAAE,CAAC,CAAC;IAE5E;;;OAGG;IACH,yBAAyB,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,gBAAgB,GAAG,IAAI,CAAC;IAEtE;;;OAGG;IACH,4BAA4B,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,gBAAgB,EAAE,CAAC;IAEpE;;;;OAIG;IACH,UAAU,EAAE,CACV,MAAM,CAAC,EAAE,gBAAgB,GAAG,WAAW,KACpC,OAAO,CAAC,gBAAgB,GAAG,IAAI,CAAC,CAAC;CACvC,CAAC;AA8HF,eAAO,MAAM,MAAM,QAAiB,CAAC"}
+{"version":3,"file":"screen.d.ts","sourceRoot":"","sources":["../src/screen.ts"],"names":[],"mappings":"AAAA,OAAO,EAAiB,KAAK,WAAW,EAAE,MAAM,YAAY,CAAC;AAI7D;;;GAGG;AACH,MAAM,MAAM,gBAAgB,GAAG;IAC7B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;CAC3B,CAAC;AAMF;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC/B,sDAAsD;IACtD,IAAI,EAAE,UAAU,CAAC;IACjB,gEAAgE;IAChE,KAAK,EAAE,MAAM,CAAC;IACd,iEAAiE;IACjE,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,MAAM,MAAM,GAAG;IACnB;;;OAGG;IACH,YAAY,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,OAAO,CAAC,gBAAgB,CAAC,CAAC;IAE5D;;;OAGG;IACH,eAAe,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,OAAO,CAAC,gBAAgB,EAAE,CAAC,CAAC;IAEjE;;;OAGG;IACH,aAAa,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,gBAAgB,GAAG,IAAI,CAAC;IAE3D;;;OAGG;IACH,gBAAgB,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,gBAAgB,EAAE,CAAC;IAEzD;;;OAGG;IACH,wBAAwB,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,OAAO,CAAC,gBAAgB,CAAC,CAAC;IAEvE;;;OAGG;IACH,2BAA2B,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,OAAO,CAAC,gBAAgB,EAAE,CAAC,CAAC;IAE5E;;;OAGG;IACH,yBAAyB,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,gBAAgB,GAAG,IAAI,CAAC;IAEtE;;;OAGG;IACH,4BAA4B,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,gBAAgB,EAAE,CAAC;IAEpE;;;;OAIG;IACH,UAAU,EAAE,CACV,MAAM,CAAC,EAAE,gBAAgB,GAAG,WAAW,KACpC,OAAO,CAAC,gBAAgB,GAAG,IAAI,CAAC,CAAC;CACvC,CAAC;AAgIF,eAAO,MAAM,MAAM,QAAiB,CAAC"}

package/dist/screen.js

@@ -80,7 +80,7 @@ const createScreen = () => {
                     targetHeight = target.height;
                 }
             }
-            const base64String = await HarnessUI.captureScreenshot(captureBounds);
+            const base64String = await HarnessUI.captureScreenshot(captureBounds ? { bounds: captureBounds } : {});
             if (!base64String) {
                 return null;
             }