react-native-theme-reveal 0.0.0-stage → 0.1.0

package/android/build.gradle

@@ -0,0 +1,32 @@
+apply plugin: 'com.android.library'
+
+group = 'expo.modules.themereveal'
+version = '0.1.0'
+
+def expoModulesCorePlugin = new File(project(":expo-modules-core").projectDir.absolutePath, "ExpoModulesCorePlugin.gradle")
+apply from: expoModulesCorePlugin
+applyKotlinExpoModulesCorePlugin()
+useCoreDependencies()
+useExpoPublishing()
+
+buildscript {
+  ext.safeExtGet = { prop, fallback ->
+    rootProject.ext.has(prop) ? rootProject.ext.get(prop) : fallback
+  }
+}
+
+android {
+  namespace "expo.modules.themereveal"
+  compileSdkVersion safeExtGet("compileSdkVersion", 36)
+  defaultConfig {
+    minSdkVersion safeExtGet("minSdkVersion", 24)
+    targetSdkVersion safeExtGet("targetSdkVersion", 36)
+    versionCode 1
+    versionName "0.1.0"
+  }
+}
+
+dependencies {
+  implementation 'com.facebook.react:react-android'
+  testImplementation 'junit:junit:4.13.2'
+}

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1,2 @@
+<manifest>
+</manifest>

package/android/src/main/baseline-prof.txt

@@ -0,0 +1,4 @@
+# Baseline Profile for react-native-theme-reveal: every class and method of the module, so a Play install compiles the
+# switch path ahead of time.
+HSPLexpo/modules/themereveal/**->**(**)**
+Lexpo/modules/themereveal/**;

package/android/src/main/java/expo/modules/themereveal/CapturePlan.kt

@@ -0,0 +1,199 @@
+package expo.modules.themereveal
+
+import android.graphics.HardwareRenderer
+import android.os.Build
+import kotlin.math.min
+
+// js: name JS sees for it (src/types.ts CapturePath).
+internal enum class CapturePath(val js: String) {
+  GPU("gpu"),
+  PIXEL_COPY("pixelcopy"),
+}
+
+// Why a GPU capture gave no bitmap.
+internal enum class GpuFailure {
+  // Renderer lost its surface, was stopped or dropped the frame. Next switch tries the GPU again.
+  SYNC,
+
+  // No image arrived within GPU_TIMEOUT_MS.
+  TIMEOUT,
+
+  // Capture threw.
+  ERROR,
+}
+
+// What a warm-up prepares for the first switch.
+internal enum class WarmUp {
+  // GPU capture's classes, reader and renderer. No bitmap kept, the GPU capture makes its own.
+  GPU,
+
+  // One window-size bitmap for PixelCopy, kept with one copy into it.
+  KEPT_BITMAP,
+}
+
+internal class LightSource(val x: Float, val y: Float, val z: Float, val radius: Float)
+
+internal object CapturePlan {
+  // First capture in a fresh process took 50 ms on a Pixel 8 Pro, a warm one 12-32 ms on both lab phones.
+  const val GPU_TIMEOUT_MS = 250L
+
+  private const val SYNC_FAILED = HardwareRenderer.SYNC_LOST_SURFACE_REWARD_IF_FOUND or
+    HardwareRenderer.SYNC_CONTEXT_IS_STOPPED or HardwareRenderer.SYNC_FRAME_DROPPED
+
+  // GPU capture renders in sRGB, so a wide color window stays on PixelCopy. So does a window without hardware
+  // acceleration, since its software canvas can't draw the hardware bitmap. Same for a view change waiting for its
+  // frame while force dark can apply: the capture would sync it first, without the force dark transform.
+  fun path(
+    apiLevel: Int,
+    defaultColorMode: Boolean,
+    hardwareAccelerated: Boolean,
+    pendingUnderForceDark: Boolean,
+    gpuOff: Boolean,
+  ): CapturePath =
+    if (apiLevel >= Build.VERSION_CODES.Q && defaultColorMode && hardwareAccelerated && !pendingUnderForceDark &&
+      !gpuOff
+    ) {
+      CapturePath.GPU
+    } else {
+      CapturePath.PIXEL_COPY
+    }
+
+  // ViewRootImpl turns on force dark for a light theme that allows it, in night mode. From API 36 the color
+  // inversion setting can darken a light theme too, and apps can't read that setting.
+  fun forceDarkCanApply(apiLevel: Int, nightMode: Boolean, lightTheme: Boolean, forceDarkAllowed: Boolean): Boolean =
+    apiLevel >= Build.VERSION_CODES.Q && nightMode && lightTheme &&
+      (forceDarkAllowed || apiLevel >= Build.VERSION_CODES.BAKLAVA)
+
+  // Warm-up prepares the path the activity window's first switch takes: GPU capture on API 29+, otherwise
+  // PixelCopy. hasLight: the theme has the light values for shadows (GpuSnapshot.lightOf).
+  fun warmUp(
+    apiLevel: Int,
+    defaultColorMode: Boolean,
+    hardwareAccelerated: Boolean,
+    hasLight: Boolean,
+    gpuOff: Boolean,
+  ): WarmUp =
+    if (hasLight && path(apiLevel, defaultColorMode, hardwareAccelerated, false, gpuOff) == CapturePath.GPU) {
+      WarmUp.GPU
+    } else {
+      WarmUp.KEPT_BITMAP
+    }
+
+  fun syncFailed(result: Int): Boolean = result and SYNC_FAILED != 0
+
+  // A timeout or error can repeat on every switch, so the process stops trying the GPU. A timeout while the warm-up's
+  // pre-create holds the copy thread (copyThreadBusy) says nothing about the GPU, so the next switch tries it.
+  fun turnsGpuOff(failure: GpuFailure, copyThreadBusy: Boolean): Boolean = when (failure) {
+    GpuFailure.SYNC -> false
+    GpuFailure.TIMEOUT -> !copyThreadBusy
+    GpuFailure.ERROR -> true
+  }
+
+  // Where ThreadedRenderer.setLightCenter puts a window's light: above the display's horizontal center, lightY from
+  // its top, shifted into window space. From API 34 the height scales with the display's smallest side.
+  fun light(
+    apiLevel: Int,
+    displayWidth: Int,
+    displayHeight: Int,
+    density: Float,
+    windowLeft: Int,
+    windowTop: Int,
+    lightY: Float,
+    lightZ: Float,
+    lightRadius: Float,
+  ): LightSource {
+    val z = if (apiLevel >= Build.VERSION_CODES.UPSIDE_DOWN_CAKE) {
+      val ratio = min(displayWidth, displayHeight) / (450f * density)
+      lightZ * (ratio + 2) / 3f
+    } else {
+      lightZ
+    }
+    return LightSource(displayWidth / 2f - windowLeft, lightY - windowTop, z, lightRadius)
+  }
+}
+
+// GPU jobs on the copy thread: the warm-up's pre-creates, plus the RenderThread reveal's prepared targets and
+// pre-imports. All of them count as pre-creates here. Releases of captures and targets (GpuSnapshot.free) run on that
+// thread too and aren't counted. A GPU capture's image arrives on that thread, so it can wait behind a pre-create
+// past the timeout. The first such timeout of each pre-create is forgiven and the GPU path stays on. If that
+// pre-create still holds the copy thread at a later switch, that switch skips the GPU capture. So a pre-create that
+// never returns costs only one switch the timeout. Main thread only.
+internal class PreCreates {
+  // How many have started.
+  var count = 0
+    private set
+  private var running = 0
+  private var forgivenAt = -1
+
+  // One is queued or running.
+  val busy: Boolean
+    get() = running > 0
+
+  fun started() {
+    count++
+    running++
+  }
+
+  fun finished() {
+    running--
+  }
+
+  // At a switch's start, the copy thread is still running a pre-create that already cost a switch the timeout.
+  fun skipsGpu(): Boolean = running > 0 && forgivenAt == count
+
+  // A failed GPU capture. busyAtStart and countAtStart are read when the capture started.
+  fun turnsGpuOff(failure: GpuFailure, busyAtStart: Boolean, countAtStart: Int): Boolean {
+    val copyThreadBusy = busyAtStart || running > 0 || count != countAtStart
+    if (failure == GpuFailure.TIMEOUT && copyThreadBusy) forgivenAt = count
+    return CapturePlan.turnsGpuOff(failure, copyThreadBusy)
+  }
+}
+
+// How a GPU capture ends: image, timeout or failure, whichever comes first. The rest get dropped and a late bitmap
+// is recycled. onResult runs once. release runs once, after onResult for an image and before it for a failure.
+// afterImage runs that release after an image: right away by default, or later (after the overlay's frame). Main
+// thread only.
+internal class CaptureEnd<B : Any>(
+  private val release: () -> Unit,
+  private val recycle: (B) -> Unit,
+  private val cancelTimeout: () -> Unit,
+  private val onResult: (B?, GpuFailure?) -> Unit,
+  private val afterImage: (() -> Unit) -> Unit = { it() },
+) {
+  private var finished = false
+
+  fun image(bitmap: B?) {
+    if (finished) {
+      bitmap?.let(recycle)
+      return
+    }
+    finished = true
+    cancelTimeout()
+    if (bitmap == null) {
+      release()
+      onResult(null, GpuFailure.ERROR)
+      return
+    }
+    // Overlay goes up first, then the renderer goes away, once afterImage runs it.
+    try {
+      onResult(bitmap, null)
+    } finally {
+      afterImage(release)
+    }
+  }
+
+  fun timeout() {
+    if (finished) return
+    finished = true
+    release()
+    onResult(null, GpuFailure.TIMEOUT)
+  }
+
+  fun fail(failure: GpuFailure) {
+    if (finished) return
+    finished = true
+    cancelTimeout()
+    release()
+    onResult(null, failure)
+  }
+}

package/android/src/main/java/expo/modules/themereveal/CaptureRules.kt

@@ -0,0 +1,50 @@
+package expo.modules.themereveal
+
+internal object CaptureRules {
+  // A press-in capture no switch uses is freed after this long, so a long press doesn't hold on to a full-window
+  // bitmap.
+  const val TIMEOUT_MS = 3_000L
+
+  // A capture's PixelCopy result is kept only if nothing voided the capture (ticket), no prepare started during the
+  // copy (generation) and no overlay is showing. Otherwise it could hold a frame from before another switch.
+  fun keepResult(
+    ticket: Int,
+    currentTicket: Int,
+    generation: Int,
+    currentGeneration: Int,
+    overlayShown: Boolean,
+  ): Boolean = ticket == currentTicket && generation == currentGeneration && !overlayShown
+
+  // A held capture can stand in for prepare's own capture if nothing voided it (ticket, a guard: voiding also frees
+  // it), no other prepare ran since it started (generation is the one before this prepare's), it shows the window
+  // prepare would capture, that window still has the snapshot's size, and it's no older than TIMEOUT_MS.
+  fun usable(
+    ticket: Int,
+    currentTicket: Int,
+    generation: Int,
+    generationBefore: Int,
+    sameWindow: Boolean,
+    snapshotW: Int,
+    snapshotH: Int,
+    coverW: Int,
+    coverH: Int,
+    takenAtMs: Long,
+    nowMs: Long,
+  ): Boolean {
+    val age = nowMs - takenAtMs
+    return ticket == currentTicket && generation == generationBefore && sameWindow &&
+      Motion.sameSize(snapshotW, snapshotH, coverW, coverH) && age >= 0 && age < TIMEOUT_MS
+  }
+
+  // The capture target for the next switch (KeptTarget) is only prepared while no switch or press-in is using the
+  // copy thread or the RenderThread: no overlay showing, no press-in capture running or held, no switch capture
+  // running. The prepare blocks the copy thread, which is where those captures get their images. Foreground only,
+  // too.
+  fun keepsTargetNow(
+    overlayShown: Boolean,
+    captureRunning: Boolean,
+    captureHeld: Boolean,
+    switchCapturing: Boolean,
+    resumed: Boolean,
+  ): Boolean = !overlayShown && !captureRunning && !captureHeld && !switchCapturing && resumed
+}

package/android/src/main/java/expo/modules/themereveal/GpuSnapshot.kt

@@ -0,0 +1,367 @@
+package expo.modules.themereveal
+
+import android.app.Activity
+import android.content.res.Configuration
+import android.graphics.Bitmap
+import android.graphics.Canvas
+import android.graphics.ColorSpace
+import android.graphics.HardwareRenderer
+import android.graphics.PixelFormat
+import android.graphics.Rect
+import android.graphics.RenderNode
+import android.hardware.HardwareBuffer
+import android.media.ImageReader
+import android.os.Build
+import android.os.Handler
+import android.util.DisplayMetrics
+import android.util.TypedValue
+import android.util.Log
+import android.view.Choreographer
+import android.view.View
+import androidx.annotation.RequiresApi
+
+// Elevation shadows: where the light is and how dark its shadows are.
+internal class Lighting(val source: LightSource, val ambientAlpha: Float, val spotAlpha: Float)
+
+// GPU capture target made ready ahead of the capture (GpuSnapshot.prepareOutput): its reader, its renderer with the
+// surface already made, and its root node. release frees it, once, unless a capture took it. Called on main, the work
+// runs on the copy thread (GpuSnapshot.free). what names it in the debug log.
+@RequiresApi(Build.VERSION_CODES.Q)
+internal class GpuOutput(
+  val width: Int,
+  val height: Int,
+  val reader: ImageReader,
+  val renderer: HardwareRenderer,
+  val node: RenderNode,
+  private val readerHandler: Handler,
+) {
+  fun release(what: String = "an unused prepared target") =
+    GpuSnapshot.free(readerHandler, renderer, reader, node, what)
+}
+
+// API 29+: window snapshot drawn on the GPU into a hardware bitmap. No readback to the CPU and no upload back to the
+// GPU like PixelCopy needs.
+@RequiresApi(Build.VERSION_CODES.Q)
+internal object GpuSnapshot {
+  private const val USAGE = HardwareBuffer.USAGE_GPU_SAMPLED_IMAGE or HardwareBuffer.USAGE_GPU_COLOR_OUTPUT
+
+  private const val TAG = "ThemeReveal"
+
+  // Debug log name for releasing a capture's own renderer, as opposed to an unused or kept target.
+  const val CAPTURE_RENDERER = "a capture's renderer"
+
+  // Longest a capture's release waits for the frame after its image. No frame comes while the screen is off.
+  private const val RELEASE_TIMEOUT_MS = 100L
+
+  // Light the window's renderer uses for elevation shadows (ThreadedRenderer), or null if the theme doesn't define
+  // it.
+  fun lightOf(activity: Activity, decor: View): Lighting? {
+    val display = decor.display ?: return null
+    val theme = activity.theme
+    val value = TypedValue()
+    fun dimension(name: String): Float? {
+      // lightY, lightZ and lightRadius are private framework attributes.
+      @Suppress("DiscouragedApi")
+      val id = activity.resources.getIdentifier(name, "attr", "android")
+      if (id == 0 || !theme.resolveAttribute(id, value, true)) return null
+      return value.getDimension(activity.resources.displayMetrics)
+    }
+    val lightY = dimension("lightY") ?: return null
+    val lightZ = dimension("lightZ") ?: return null
+    val radius = dimension("lightRadius") ?: return null
+    if (!theme.resolveAttribute(android.R.attr.ambientShadowAlpha, value, true)) return null
+    val ambient = value.float
+    if (!theme.resolveAttribute(android.R.attr.spotShadowAlpha, value, true)) return null
+    val spot = value.float
+    val metrics = DisplayMetrics()
+    @Suppress("DEPRECATION")
+    display.getRealMetrics(metrics)
+    val inWindow = IntArray(2).also { decor.getLocationInWindow(it) }
+    val onScreen = WindowSnapshot.locationOf(decor)
+    val source = CapturePlan.light(
+      Build.VERSION.SDK_INT,
+      metrics.widthPixels,
+      metrics.heightPixels,
+      metrics.density,
+      onScreen[0] - inWindow[0],
+      onScreen[1] - inWindow[1],
+      lightY,
+      lightZ,
+      radius,
+    )
+    return Lighting(source, ambient, spot)
+  }
+
+  // Draws a window's views the way its renderer does: in place in the window, with Z order and shadows. Child views
+  // draw the display lists they already have. UI thread only.
+  fun drawWindow(canvas: Canvas, decor: View) {
+    val at = IntArray(2).also { decor.getLocationInWindow(it) }
+    val count = canvas.save()
+    canvas.translate(at[0].toFloat(), at[1].toFloat())
+    canvas.enableZ()
+    decor.draw(canvas)
+    canvas.disableZ()
+    canvas.restoreToCount(count)
+  }
+
+  // Warm-up, off the main thread: a 1x1 capture with no window in it. Loads the reader's and renderer's classes and
+  // native code and draws one frame, so the first switch doesn't have to. Draws no view, so it can run off main.
+  fun preCreate() {
+    val node = RenderNode("ThemeRevealWarmUp")
+    val images = ImageReader.newInstance(1, 1, PixelFormat.RGBA_8888, 1, USAGE)
+    var renderer: HardwareRenderer? = null
+    try {
+      node.setPosition(0, 0, 1, 1)
+      node.beginRecording(1, 1)
+      node.endRecording()
+      val output = HardwareRenderer()
+      renderer = output
+      output.setSurface(images.surface)
+      output.setContentRoot(node)
+      output.setOpaque(false)
+      output.setLightSourceGeometry(0f, 0f, 1f, 1f)
+      output.setLightSourceAlpha(0f, 0f)
+      output.createRenderRequest().syncAndDraw()
+      // Waits until the frame is drawn.
+      output.stop()
+      images.acquireLatestImage()?.use { image ->
+        image.hardwareBuffer?.use { Bitmap.wrapHardwareBuffer(it, ColorSpace.get(ColorSpace.Named.SRGB))?.recycle() }
+      }
+    } finally {
+      renderer?.destroy()
+      images.close()
+      node.discardDisplayList()
+    }
+  }
+
+  // Target side of pre-importing a held snapshot.
+  private const val PRE_IMPORT_SIZE = 8
+
+  // Records the snapshot, drawn scaled down, into a tiny node. Runs on the UI thread so freeing the bitmap can't
+  // race the recording. The display list keeps the bitmap's buffer alive until preImport discards it. Draws no
+  // view.
+  fun preImportNode(bitmap: Bitmap): RenderNode {
+    val node = RenderNode("ThemeRevealPreImport")
+    try {
+      node.setPosition(0, 0, PRE_IMPORT_SIZE, PRE_IMPORT_SIZE)
+      val canvas = node.beginRecording(PRE_IMPORT_SIZE, PRE_IMPORT_SIZE)
+      try {
+        canvas.drawBitmap(bitmap, null, Rect(0, 0, PRE_IMPORT_SIZE, PRE_IMPORT_SIZE), null)
+      } finally {
+        node.endRecording()
+      }
+    } catch (thrown: RuntimeException) {
+      node.discardDisplayList()
+      throw thrown
+    }
+    return node
+  }
+
+  // Draws the node into a tiny offscreen target and waits for the frame, then frees target and node. The shared
+  // RenderThread imports the snapshot's buffer as a texture now, during the hold, instead of in the overlay's first
+  // frame. Draws no view, so it runs off main.
+  fun preImport(node: RenderNode) {
+    var images: ImageReader? = null
+    var renderer: HardwareRenderer? = null
+    try {
+      val reader = ImageReader.newInstance(PRE_IMPORT_SIZE, PRE_IMPORT_SIZE, PixelFormat.RGBA_8888, 1, USAGE)
+      images = reader
+      val output = HardwareRenderer()
+      renderer = output
+      output.setSurface(reader.surface)
+      output.setContentRoot(node)
+      output.setOpaque(false)
+      output.setLightSourceGeometry(0f, 0f, 1f, 1f)
+      output.setLightSourceAlpha(0f, 0f)
+      output.createRenderRequest().syncAndDraw()
+      // Waits until the frame is drawn.
+      output.stop()
+      reader.acquireLatestImage()?.close()
+    } finally {
+      renderer?.destroy()
+      images?.close()
+      node.discardDisplayList()
+    }
+  }
+
+  // Gets a width x height capture target ready for a later capture: draws one empty frame into it and waits for that
+  // frame, so the surface exists on the RenderThread and its buffer is allocated. The capture's frame reuses that
+  // buffer. Draws no view, so it runs off main, on readerHandler's thread. The renderer stays started, since stop()
+  // would let its surface go.
+  fun prepareOutput(width: Int, height: Int, readerHandler: Handler): GpuOutput {
+    val node = RenderNode("ThemeRevealSnapshot")
+    var images: ImageReader? = null
+    var renderer: HardwareRenderer? = null
+    try {
+      val reader = ImageReader.newInstance(width, height, PixelFormat.RGBA_8888, 1, USAGE)
+      images = reader
+      node.setPosition(0, 0, width, height)
+      node.beginRecording(width, height)
+      node.endRecording()
+      val output = HardwareRenderer()
+      renderer = output
+      output.setSurface(reader.surface)
+      output.setContentRoot(node)
+      output.setOpaque(false)
+      output.setLightSourceGeometry(0f, 0f, 1f, 1f)
+      output.setLightSourceAlpha(0f, 0f)
+      // Waits until the frame is presented, so its image is already in the reader.
+      output.createRenderRequest().setWaitForPresent(true).syncAndDraw()
+      // Back to the reader, so the capture's frame dequeues this buffer again.
+      reader.acquireNextImage()?.close()
+      return GpuOutput(width, height, reader, output, node, readerHandler)
+    } catch (thrown: Throwable) {
+      renderer?.destroy()
+      images?.close()
+      node.discardDisplayList()
+      throw thrown
+    }
+  }
+
+  // Runs release on handler after the next frame, which is the overlay's frame when an image just attached the
+  // overlay. release only posts the work to the copy thread (free), so its RenderThread work lands after that frame.
+  // A timeout runs it if no frame comes.
+  private fun afterNextFrame(handler: Handler, release: () -> Unit) {
+    val once = Once(release)
+    lateinit var timeout: Runnable
+    val frame = Choreographer.FrameCallback {
+      handler.removeCallbacks(timeout)
+      // A message posted after this one runs after the frame's traversal.
+      handler.post { once.run() }
+    }
+    timeout = Runnable {
+      Choreographer.getInstance().removeFrameCallback(frame)
+      once.run()
+    }
+    Choreographer.getInstance().postFrameCallback(frame)
+    handler.postDelayed(timeout, RELEASE_TIMEOUT_MS)
+  }
+
+  // Frees a capture's renderer, reader and node on readerHandler's thread (the reader's own) instead of main:
+  // renderer.destroy waits for the RenderThread, 1.0-19.4 ms on a Mi 11 Lite. By then nothing else uses them. Main is
+  // done with the renderer, and its stop() and the image listener already ran on that same thread, so the close can't
+  // free an image the listener is still reading. A bitmap from the image holds its own reference to the buffer.
+  fun free(
+    readerHandler: Handler,
+    renderer: HardwareRenderer?,
+    reader: ImageReader?,
+    node: RenderNode,
+    what: String = CAPTURE_RENDERER,
+  ) {
+    readerHandler.post {
+      val start = System.nanoTime()
+      try {
+        renderer?.destroy()
+      } finally {
+        reader?.close()
+        node.discardDisplayList()
+      }
+      if (Log.isLoggable(TAG, Log.DEBUG)) {
+        val ms = (System.nanoTime() - start) / 1e6
+        Log.d(TAG, "released $what in %.1f ms on the copy thread".format(ms))
+      }
+    }
+  }
+
+  // Force dark can darken this activity's windows (see CapturePlan.forceDarkCanApply).
+  fun forceDarkCanApply(activity: Activity): Boolean {
+    val value = TypedValue()
+    val theme = activity.theme
+    val lightTheme = !theme.resolveAttribute(android.R.attr.isLightTheme, value, true) || value.data != 0
+    val allowed = theme.resolveAttribute(android.R.attr.forceDarkAllowed, value, true) && value.data != 0
+    val night = activity.resources.configuration.uiMode and Configuration.UI_MODE_NIGHT_MASK ==
+      Configuration.UI_MODE_NIGHT_YES
+    return CapturePlan.forceDarkCanApply(Build.VERSION.SDK_INT, night, lightTheme, allowed)
+  }
+
+  // Records draw on the UI thread, renders it into a hardware buffer and calls onResult once on handler, with the
+  // bitmap or with null and the reason. readerHandler gets the image, since taking it waits for the GPU to finish.
+  // redraw lists the decor views of windows that had a view change waiting for its frame. prepared: a target from
+  // prepareOutput, made with the same readerHandler, to draw into instead of a new one. The capture takes it and frees
+  // it when done. One of another size is freed right away.
+  fun capture(
+    width: Int,
+    height: Int,
+    light: Lighting,
+    redraw: List<View>,
+    handler: Handler,
+    readerHandler: Handler,
+    draw: (Canvas) -> Unit,
+    prepared: GpuOutput?,
+    onResult: (Bitmap?, GpuFailure?) -> Unit,
+  ) {
+    val ready = prepared?.takeIf { it.width == width && it.height == height }
+    if (prepared != null && ready == null) prepared.release()
+    val node = ready?.node ?: RenderNode("ThemeRevealSnapshot")
+    var reader: ImageReader? = null
+    var renderer: HardwareRenderer? = null
+    lateinit var timeout: Runnable
+    val end = CaptureEnd<Bitmap>(
+      release = {
+        if (ready != null) ready.release(CAPTURE_RENDERER) else free(readerHandler, renderer, reader, node)
+      },
+      recycle = { it.recycle() },
+      cancelTimeout = { handler.removeCallbacks(timeout) },
+      onResult = onResult,
+      afterImage = { release -> afterNextFrame(handler, release) },
+    )
+    timeout = Runnable { end.timeout() }
+    try {
+      node.setPosition(0, 0, width, height)
+      val canvas = node.beginRecording(width, height)
+      try {
+        draw(canvas)
+      } finally {
+        node.endRecording()
+      }
+      val images = ready?.reader ?: ImageReader.newInstance(width, height, PixelFormat.RGBA_8888, 1, USAGE)
+      reader = images
+      images.setOnImageAvailableListener({ source ->
+        val bitmap = try {
+          source.acquireLatestImage()?.use { image ->
+            image.hardwareBuffer?.use { Bitmap.wrapHardwareBuffer(it, ColorSpace.get(ColorSpace.Named.SRGB)) }
+          }
+        } catch (_: RuntimeException) {
+          null
+        }
+        // Front of the queue, like the PixelCopy listener, so the overlay can still make a frame that's due.
+        handler.postAtFrontOfQueue { end.image(bitmap) }
+      }, readerHandler)
+      val output = ready?.renderer ?: HardwareRenderer()
+      renderer = output
+      if (ready == null) {
+        output.setSurface(images.surface)
+        output.setContentRoot(node)
+        output.setOpaque(false)
+      }
+      output.setLightSourceGeometry(light.source.x, light.source.y, light.source.z, light.source.radius)
+      output.setLightSourceAlpha(light.ambientAlpha, light.spotAlpha)
+      val result = output.createRenderRequest().syncAndDraw()
+      // The sync consumed the damage of views that changed since the window's last frame, so the window would skip
+      // redrawing them. Redraw these windows in full.
+      redraw.forEach { it.invalidate() }
+      if (CapturePlan.syncFailed(result)) {
+        end.fail(GpuFailure.SYNC)
+        return
+      }
+      // A RenderThread animation in the window (a ripple, say) would make this renderer redraw the whole window
+      // every vsync until release. Stop it once its frame is drawn. stop() waits for that on the RenderThread, so
+      // it runs off the main thread. The release (free) runs later on the same thread.
+      readerHandler.post {
+        try {
+          output.stop()
+        } catch (_: RuntimeException) {
+          // Nothing to stop.
+        }
+      }
+    } catch (_: RuntimeException) {
+      end.fail(GpuFailure.ERROR)
+      return
+    } catch (_: OutOfMemoryError) {
+      // HardwareRenderer throws it when HWUI can't make its native proxy.
+      end.fail(GpuFailure.ERROR)
+      return
+    }
+    handler.postDelayed(timeout, CapturePlan.GPU_TIMEOUT_MS)
+  }
+}