test(replay): Cover SurfaceView capture paths

Add unit tests for the new SurfaceView capture support and extract a
compositeSurfaceViewInto helper so the drawing contract can be verified
with hand-built bitmaps (Robolectric's ShadowPixelCopy cannot produce
meaningful SurfaceView pixels because there is no real GL producer).

The tests cover:
- ViewHierarchyNode.fromView returns SurfaceViewHierarchyNode vs. generic
- View.traverse collects SurfaceView nodes when a list is supplied, not
  when it is null, and skips invisible SurfaceViews
- PixelCopyStrategy leaves hasSurfaceViews false when the option is off
- PixelCopyStrategy flags hasSurfaceViews true when the option is on
- PixelCopyStrategy completes gracefully when a SurfaceView has no valid
  surface (the common Robolectric case)
- compositeSurfaceViewInto fills transparent holes behind existing window
  content via DST_OVER, and respects both window offset and scale factors

Also fixes a latent NPE in captureSurfaceViews when SurfaceHolder.surface
is null (not just invalid) — happens before the surface is created.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: romtsn

sentry-android-replay/src/main/java/io/sentry/android/replay/screenshot/PixelCopyStrategy.kt

@@ -170,7 +170,9 @@ internal class PixelCopyStrategy(
 
     for ((index, node) in surfaceViewNodes.withIndex()) {
       val surfaceView = node.surfaceViewRef.get()
-      if (surfaceView == null || !surfaceView.holder.surface.isValid) {
+      // holder.surface can be null before the surface is created — guard against NPE.
+      val surface = surfaceView?.holder?.surface
+      if (surfaceView == null || surface == null || !surface.isValid) {
         onCaptureComplete()
         continue
       }
@@ -220,18 +222,19 @@ internal class PixelCopyStrategy(
           if (capture == null) continue
           if (capture.bitmap.isRecycled) continue
 
-          val left = (capture.x - windowLocation[0]) * config.scaleFactorX
-          val top = (capture.y - windowLocation[1]) * config.scaleFactorY
-          tmpSrcRect.set(0, 0, capture.bitmap.width, capture.bitmap.height)
-          tmpDstRect.set(
-            left,
-            top,
-            left + capture.bitmap.width * config.scaleFactorX,
-            top + capture.bitmap.height * config.scaleFactorY,
+          compositeSurfaceViewInto(
+            screenshotCanvas,
+            dstOverPaint,
+            tmpSrcRect,
+            tmpDstRect,
+            capture.bitmap,
+            capture.x,
+            capture.y,
+            windowLocation[0],
+            windowLocation[1],
+            config.scaleFactorX,
+            config.scaleFactorY,
           )
-
-          // DST_OVER draws the SurfaceView content behind the existing Window content
-          screenshotCanvas.drawBitmap(capture.bitmap, tmpSrcRect, tmpDstRect, dstOverPaint)
           capture.bitmap.recycle()
         }
 
@@ -277,3 +280,38 @@ internal class PixelCopyStrategy(
     )
   }
 }
+
+/**
+ * Composites [sourceBitmap] (a SurfaceView capture) onto [destCanvas] (wrapping the recording
+ * screenshot) using [destPaint] (expected to have DST_OVER xfermode), so the SurfaceView content
+ * draws _behind_ existing Window content — filling the transparent holes the Window PixelCopy
+ * leaves where SurfaceViews are.
+ *
+ * Extracted for testability — the compositing is pure drawing logic that can be driven with
+ * hand-built bitmaps, while the surrounding [PixelCopyStrategy.captureSurfaceViews] flow depends
+ * on a real SurfaceView producer that Robolectric cannot provide.
+ */
+internal fun compositeSurfaceViewInto(
+  destCanvas: Canvas,
+  destPaint: Paint,
+  tmpSrc: Rect,
+  tmpDst: RectF,
+  sourceBitmap: Bitmap,
+  sourceX: Int,
+  sourceY: Int,
+  windowX: Int,
+  windowY: Int,
+  scaleFactorX: Float,
+  scaleFactorY: Float,
+) {
+  val left = (sourceX - windowX) * scaleFactorX
+  val top = (sourceY - windowY) * scaleFactorY
+  tmpSrc.set(0, 0, sourceBitmap.width, sourceBitmap.height)
+  tmpDst.set(
+    left,
+    top,
+    left + sourceBitmap.width * scaleFactorX,
+    top + sourceBitmap.height * scaleFactorY,
+  )
+  destCanvas.drawBitmap(sourceBitmap, tmpSrc, tmpDst, destPaint)
+}

sentry-android-replay/src/test/java/io/sentry/android/replay/screenshot/PixelCopyStrategyTest.kt

@@ -1,9 +1,19 @@
 package io.sentry.android.replay.screenshot
 
 import android.app.Activity
+import android.graphics.Bitmap
+import android.graphics.Canvas
+import android.graphics.Color
+import android.graphics.Paint
+import android.graphics.PorterDuff
+import android.graphics.PorterDuffXfermode
+import android.graphics.Rect
+import android.graphics.RectF
 import android.os.Bundle
 import android.os.Handler
 import android.os.Looper
+import android.view.SurfaceView
+import android.widget.FrameLayout
 import android.widget.LinearLayout
 import android.widget.LinearLayout.LayoutParams
 import android.widget.TextView
@@ -18,18 +28,23 @@ import java.util.concurrent.ScheduledExecutorService
 import java.util.concurrent.atomic.AtomicReference
 import kotlin.test.BeforeTest
 import kotlin.test.Test
+import kotlin.test.assertEquals
 import kotlin.test.assertFalse
+import kotlin.test.assertTrue
 import org.junit.runner.RunWith
 import org.mockito.kotlin.any
 import org.mockito.kotlin.doAnswer
 import org.mockito.kotlin.mock
+import org.mockito.kotlin.verify
 import org.mockito.kotlin.whenever
 import org.robolectric.Robolectric.buildActivity
 import org.robolectric.Shadows.shadowOf
 import org.robolectric.annotation.Config
+import org.robolectric.annotation.GraphicsMode
 import org.robolectric.shadows.ShadowPixelCopy
 
 @Config(shadows = [ShadowPixelCopy::class], sdk = [30])
+@GraphicsMode(GraphicsMode.Mode.NATIVE)
 @RunWith(AndroidJUnit4::class)
 class PixelCopyStrategyTest {
 
@@ -54,6 +69,18 @@ class PixelCopyStrategyTest {
         debugOverlayDrawable,
       )
     }
+
+    /** Executor mock that runs submitted tasks synchronously on the calling thread. */
+    fun inlineExecutor(): ScheduledExecutorService {
+      return mock {
+        doAnswer {
+            (it.arguments[0] as Runnable).run()
+            null // submit(Runnable) returns Future<?>; returning Unit breaks the cast
+          }
+          .whenever(mock)
+          .submit(any<Runnable>())
+      }
+    }
   }
 
   private val fixture = Fixture()
@@ -101,6 +128,125 @@ class PixelCopyStrategyTest {
 
     if (failure.get() != null) throw failure.get()
   }
+
+  @Test
+  fun `capture does not flag hasSurfaceViews when option is disabled`() {
+    val activity = buildActivity(ActivityWithSurfaceView::class.java).setup()
+    shadowOf(Looper.getMainLooper()).idle()
+
+    // Default: isCaptureSurfaceViews = false
+    val strategy = fixture.getSut(executor = fixture.inlineExecutor())
+    strategy.capture(activity.get().findViewById(android.R.id.content))
+    shadowOf(Looper.getMainLooper()).idle()
+
+    assertFalse(strategy.hasSurfaceViews())
+    assertTrue(strategy.lastCaptureSuccessful())
+    verify(fixture.callback).onScreenshotRecorded(any<Bitmap>())
+  }
+
+  @Test
+  fun `capture flags hasSurfaceViews when option is enabled and SurfaceView is present`() {
+    val activity = buildActivity(ActivityWithSurfaceView::class.java).setup()
+    shadowOf(Looper.getMainLooper()).idle()
+
+    fixture.options.sessionReplay.isCaptureSurfaceViews = true
+
+    val strategy = fixture.getSut(executor = fixture.inlineExecutor())
+    strategy.capture(activity.get().findViewById(android.R.id.content))
+    shadowOf(Looper.getMainLooper()).idle()
+
+    assertTrue(strategy.hasSurfaceViews())
+  }
+
+  @Test
+  fun `capture completes when SurfaceView surface is not valid`() {
+    // In Robolectric the SurfaceView holder surface is not valid — this exercises the
+    // `surfaceView.holder.surface.isValid == false` branch: each SurfaceView skips its
+    // PixelCopy and onCaptureComplete still fires, eventually running the compositor and
+    // callback.
+    val activity = buildActivity(ActivityWithSurfaceView::class.java).setup()
+    shadowOf(Looper.getMainLooper()).idle()
+    fixture.options.sessionReplay.isCaptureSurfaceViews = true
+
+    val strategy = fixture.getSut(executor = fixture.inlineExecutor())
+    strategy.capture(activity.get().findViewById(android.R.id.content))
+    shadowOf(Looper.getMainLooper()).idle()
+
+    assertTrue(strategy.lastCaptureSuccessful())
+    verify(fixture.callback).onScreenshotRecorded(any<Bitmap>())
+  }
+
+  @Test
+  fun `compositeSurfaceViewInto draws source behind existing destination with DST_OVER`() {
+    // Destination ("Window capture"): 100x100, opaque red in the top half,
+    // fully transparent in the bottom half (the "hole" where the SurfaceView sits).
+    val dest = Bitmap.createBitmap(100, 100, Bitmap.Config.ARGB_8888)
+    val destCanvas = Canvas(dest)
+    destCanvas.drawColor(Color.RED)
+    val clearPaint = Paint().apply { xfermode = PorterDuffXfermode(PorterDuff.Mode.CLEAR) }
+    destCanvas.drawRect(0f, 50f, 100f, 100f, clearPaint)
+
+    // Source ("SurfaceView capture"): 100x50, solid blue — matches the hole.
+    val source = Bitmap.createBitmap(100, 50, Bitmap.Config.ARGB_8888)
+    source.eraseColor(Color.BLUE)
+
+    val dstOverPaint = Paint().apply { xfermode = PorterDuffXfermode(PorterDuff.Mode.DST_OVER) }
+    compositeSurfaceViewInto(
+      destCanvas = destCanvas,
+      destPaint = dstOverPaint,
+      tmpSrc = Rect(),
+      tmpDst = RectF(),
+      sourceBitmap = source,
+      sourceX = 0,
+      sourceY = 50,
+      windowX = 0,
+      windowY = 0,
+      scaleFactorX = 1f,
+      scaleFactorY = 1f,
+    )
+
+    // Top region: still red (DST_OVER must not overwrite existing opaque pixels).
+    assertEquals(Color.RED, dest.getPixel(50, 10))
+    assertEquals(Color.RED, dest.getPixel(50, 49))
+    // Bottom region: now blue (source filled the transparent hole).
+    assertEquals(Color.BLUE, dest.getPixel(50, 50))
+    assertEquals(Color.BLUE, dest.getPixel(99, 99))
+  }
+
+  @Test
+  fun `compositeSurfaceViewInto respects scale factors and window offset`() {
+    // Destination is 50x50 (scaled recording), fully transparent.
+    val dest = Bitmap.createBitmap(50, 50, Bitmap.Config.ARGB_8888)
+    val destCanvas = Canvas(dest)
+
+    // Source is 40x40, solid green; its on-screen location is (20, 20).
+    val source = Bitmap.createBitmap(40, 40, Bitmap.Config.ARGB_8888)
+    source.eraseColor(Color.GREEN)
+
+    val dstOverPaint = Paint().apply { xfermode = PorterDuffXfermode(PorterDuff.Mode.DST_OVER) }
+    compositeSurfaceViewInto(
+      destCanvas = destCanvas,
+      destPaint = dstOverPaint,
+      tmpSrc = Rect(),
+      tmpDst = RectF(),
+      sourceBitmap = source,
+      sourceX = 20,
+      sourceY = 20,
+      windowX = 10, // window is at (10, 10)
+      windowY = 10,
+      scaleFactorX = 0.5f, // 0.5x scale → destination coords halve
+      scaleFactorY = 0.5f,
+    )
+
+    // Expected destination rect: ((20-10)*0.5, (20-10)*0.5) = (5, 5), size 40*0.5 = 20x20
+    // → occupies pixels [5..25) × [5..25). Check inside, on the edge, and just outside.
+    assertEquals(Color.GREEN, dest.getPixel(5, 5))
+    assertEquals(Color.GREEN, dest.getPixel(15, 15))
+    assertEquals(Color.GREEN, dest.getPixel(24, 24))
+    // Just outside the rect — still transparent.
+    assertEquals(0, dest.getPixel(4, 4))
+    assertEquals(0, dest.getPixel(25, 25))
+  }
 }
 
 private class SimpleActivity : Activity() {
@@ -123,3 +269,28 @@ private class SimpleActivity : Activity() {
     setContentView(linearLayout)
   }
 }
+
+private class ActivityWithSurfaceView : Activity() {
+  override fun onCreate(savedInstanceState: Bundle?) {
+    super.onCreate(savedInstanceState)
+    val root =
+      FrameLayout(this).apply {
+        setBackgroundColor(android.R.color.white)
+        layoutParams =
+          FrameLayout.LayoutParams(
+            FrameLayout.LayoutParams.MATCH_PARENT,
+            FrameLayout.LayoutParams.MATCH_PARENT,
+          )
+      }
+    root.addView(
+      TextView(this).apply {
+        text = "Overlay"
+        layoutParams = FrameLayout.LayoutParams(200, 50)
+      }
+    )
+    root.addView(
+      SurfaceView(this).apply { layoutParams = FrameLayout.LayoutParams(200, 200) }
+    )
+    setContentView(root)
+  }
+}