react-native-tvos 0.85.3-1 → 0.86.0-0

package/ReactAndroid/src/main/java/com/facebook/react/devsupport/inspector/FrameTimingsObserver.kt

@@ -97,16 +97,15 @@ internal class FrameTimingsObserver(
     }
   }
 
-  private val frameMetricsListener =
-      Window.OnFrameMetricsAvailableListener { _, frameMetrics, _ ->
-        // Guard against calls after stop()
-        if (!isTracing) {
-          return@OnFrameMetricsAvailableListener
-        }
-        val beginTimestamp = frameMetrics.getMetric(FrameMetrics.VSYNC_TIMESTAMP)
-        val endTimestamp = beginTimestamp + frameMetrics.getMetric(FrameMetrics.TOTAL_DURATION)
-        emitFrameTiming(beginTimestamp, endTimestamp)
-      }
+  private val frameMetricsListener = Window.OnFrameMetricsAvailableListener { _, frameMetrics, _ ->
+    // Guard against calls after stop()
+    if (!isTracing) {
+      return@OnFrameMetricsAvailableListener
+    }
+    val beginTimestamp = frameMetrics.getMetric(FrameMetrics.VSYNC_TIMESTAMP)
+    val endTimestamp = beginTimestamp + frameMetrics.getMetric(FrameMetrics.TOTAL_DURATION)
+    emitFrameTiming(beginTimestamp, endTimestamp)
+  }
 
   private fun emitFrameTiming(beginTimestamp: Long, endTimestamp: Long) {
     val frameId = frameCounter++

package/ReactAndroid/src/main/java/com/facebook/react/devsupport/inspector/InspectorNetworkRequestListener.kt

@@ -11,11 +11,13 @@ import com.facebook.jni.HybridData
 import com.facebook.proguard.annotations.DoNotStrip
 import com.facebook.proguard.annotations.DoNotStripAny
 import com.facebook.soloader.SoLoader
+import com.facebook.soloader.annotation.SoLoaderLibrary
 
 /**
  * JNI wrapper for `jsinspectormodern::NetworkRequestListener`. Handles the `ScopedExecutor`
  * callback use on the C++ side.
  */
+@SoLoaderLibrary("reactnativejni")
 @DoNotStripAny
 internal class InspectorNetworkRequestListener(
     @field:DoNotStrip private val mHybridData: HybridData

package/ReactAndroid/src/main/java/com/facebook/react/devsupport/perfmonitor/PerfMonitorOverlayView.kt

@@ -142,8 +142,9 @@ internal class PerfMonitorOverlayView(
     val dialog =
         createAnchoredDialog(dpToPx(12f), dpToPx(12f)).apply { setContentView(containerLayout) }
     dialog.window?.apply {
-      attributes =
-          attributes?.apply { flags = flags or WindowManager.LayoutParams.FLAG_NOT_FOCUSABLE }
+      attributes = attributes?.apply {
+        flags = flags or WindowManager.LayoutParams.FLAG_NOT_FOCUSABLE
+      }
     }
 
     return dialog
@@ -158,14 +159,13 @@ internal class PerfMonitorOverlayView(
           setCancelable(false)
         }
     dialog.window?.apply {
-      attributes =
-          attributes?.apply {
-            width = WindowManager.LayoutParams.WRAP_CONTENT
-            height = WindowManager.LayoutParams.WRAP_CONTENT
-            gravity = Gravity.TOP or Gravity.END
-            x = offsetX.toInt()
-            y = offsetY.toInt()
-          }
+      attributes = attributes?.apply {
+        width = WindowManager.LayoutParams.WRAP_CONTENT
+        height = WindowManager.LayoutParams.WRAP_CONTENT
+        gravity = Gravity.TOP or Gravity.END
+        x = offsetX.toInt()
+        y = offsetY.toInt()
+      }
     }
     dialog.window?.decorView?.let { decorView ->
       ViewCompat.setOnApplyWindowInsetsListener(decorView) { view, windowInsets ->

package/ReactAndroid/src/main/java/com/facebook/react/fabric/AnimationBackendChoreographer.kt

@@ -46,24 +46,26 @@ internal class AnimationBackendChoreographer(
   }
 
   fun pause() {
+    val shouldRemove: Boolean
     synchronized(paused) {
-      if (!paused.getAndSet(true) && callbackPosted.getAndSet(false)) {
-        reactChoreographer.removeFrameCallback(
-            ReactChoreographer.CallbackType.NATIVE_ANIMATED_MODULE,
-            choreographerCallback,
-        )
-      }
+      shouldRemove = !paused.getAndSet(true) && callbackPosted.getAndSet(false)
+    }
+    if (shouldRemove) {
+      reactChoreographer.removeFrameCallback(
+          ReactChoreographer.CallbackType.NATIVE_ANIMATED_MODULE,
+          choreographerCallback,
+      )
     }
   }
 
   private fun scheduleCallback() {
-    synchronized(paused) {
-      if (!paused.get() && !callbackPosted.getAndSet(true)) {
-        reactChoreographer.postFrameCallback(
-            ReactChoreographer.CallbackType.NATIVE_ANIMATED_MODULE,
-            choreographerCallback,
-        )
-      }
+    val shouldPost: Boolean
+    synchronized(paused) { shouldPost = !paused.get() && !callbackPosted.getAndSet(true) }
+    if (shouldPost) {
+      reactChoreographer.postFrameCallback(
+          ReactChoreographer.CallbackType.NATIVE_ANIMATED_MODULE,
+          choreographerCallback,
+      )
     }
   }
 

package/ReactAndroid/src/main/java/com/facebook/react/fabric/DevToolsReactPerfLogger.kt

@@ -134,7 +134,10 @@ public class DevToolsReactPerfLogger : FabricMarkerListener {
       }
       commitPoint.addPoint(name, FabricCommitPointData(timestamp, counter))
 
-      if (name == ReactMarkerConstants.FABRIC_BATCH_EXECUTION_END && timestamp > 0) {
+      if (
+          (name == ReactMarkerConstants.FABRIC_BATCH_EXECUTION_END ||
+              name == ReactMarkerConstants.FABRIC_UPDATE_UI_MAIN_THREAD_END) && timestamp > 0
+      ) {
         onFabricCommitEnd(commitPoint)
         fabricCommitMarkers.remove(instanceKey)
       }

package/ReactAndroid/src/main/java/com/facebook/react/fabric/FabricUIManager.java

@@ -27,7 +27,6 @@ import android.view.accessibility.AccessibilityEvent;
 import androidx.annotation.AnyThread;
 import androidx.annotation.Nullable;
 import androidx.annotation.UiThread;
-import androidx.core.util.Preconditions;
 import androidx.core.view.ViewCompat.FocusDirection;
 import com.facebook.common.logging.FLog;
 import com.facebook.infer.annotation.Assertions;
@@ -102,6 +101,7 @@ import java.util.List;
 import java.util.Map;
 import java.util.Queue;
 import java.util.Set;
+import java.util.concurrent.ConcurrentLinkedQueue;
 import java.util.concurrent.CopyOnWriteArrayList;
 
 /**
@@ -193,6 +193,13 @@ public class FabricUIManager
   @ThreadConfined(UI)
   private final Set<SynchronousEvent> mSynchronousEvents = new HashSet<>();
 
+  /**
+   * Queue of surface IDs that need their React revision merged. Drained during doFrame so that
+   * synchronous events dispatched by the merge are processed in the same frame.
+   */
+  private final ConcurrentLinkedQueue<Integer> mPendingReactRevisionMerges =
+      new ConcurrentLinkedQueue<>();
+
   /**
    * This is used to keep track of whether or not the FabricUIManager has been destroyed. Once the
    * Catalyst instance is being destroyed, we should cease all operation here.
@@ -201,6 +208,8 @@ public class FabricUIManager
 
   private boolean mDriveCxxAnimations = false;
 
+  private @Nullable ViewTransitionSnapshotManager mViewTransitionSnapshotManager;
+
   private long mDispatchViewUpdatesTime = 0l;
   private long mCommitStartTime = 0l;
   private long mLayoutTime = 0l;
@@ -537,7 +546,7 @@ public class FabricUIManager
 
     return (NativeArray)
         TextLayoutManager.measureLines(
-            mReactApplicationContext,
+            mReactApplicationContext.getAssets(),
             attributedString,
             paragraphAttributes,
             PixelUtil.toPixelFromDIP(width),
@@ -611,7 +620,6 @@ public class FabricUIManager
   @ThreadConfined(ANY)
   @UnstableReactNativeAPI
   public long measureText(
-      int surfaceId,
       ReadableMapBuffer attributedString,
       ReadableMapBuffer paragraphAttributes,
       float minWidth,
@@ -620,24 +628,10 @@ public class FabricUIManager
       float maxHeight,
       @Nullable float[] attachmentsPositions) {
 
-    ReactContext context;
-    if (surfaceId > 0) {
-      SurfaceMountingManager surfaceMountingManager =
-          mMountingManager.getSurfaceManagerEnforced(surfaceId, "measureText");
-      if (surfaceMountingManager.isStopped()) {
-        return 0;
-      }
-      context = surfaceMountingManager.getContext();
-      Assertions.assertNotNull(
-          context, "Context in SurfaceMountingManager is null. surfaceId: " + surfaceId);
-    } else {
-      context = mReactApplicationContext;
-    }
-
     ViewManager textViewManager = mViewManagerRegistry.get(ReactTextViewManager.REACT_CLASS);
 
     return TextLayoutManager.measureText(
-        context,
+        mReactApplicationContext.getAssets(),
         attributedString,
         paragraphAttributes,
         getYogaSize(minWidth, maxWidth),
@@ -654,19 +648,16 @@ public class FabricUIManager
   @ThreadConfined(ANY)
   @UnstableReactNativeAPI
   public PreparedLayout prepareTextLayout(
-      int surfaceId,
       ReadableMapBuffer attributedString,
       ReadableMapBuffer paragraphAttributes,
       float minWidth,
       float maxWidth,
       float minHeight,
       float maxHeight) {
-    SurfaceMountingManager surfaceMountingManager =
-        mMountingManager.getSurfaceManagerEnforced(surfaceId, "prepareTextLayout");
     ViewManager textViewManager = mViewManagerRegistry.get(ReactTextViewManager.REACT_CLASS);
 
     return TextLayoutManager.createPreparedLayout(
-        Preconditions.checkNotNull(surfaceMountingManager.getContext()),
+        mReactApplicationContext.getAssets(),
         attributedString,
         paragraphAttributes,
         getYogaSize(minWidth, maxWidth),
@@ -822,6 +813,40 @@ public class FabricUIManager
         ReactMarkerConstants.FABRIC_UPDATE_UI_MAIN_THREAD_END, null, commitNumber);
   }
 
+  /** Called from C++ via JNI. */
+  @SuppressLint("NotInvokedPrivateMethod")
+  @SuppressWarnings("unused")
+  @AnyThread
+  @ThreadConfined(ANY)
+  private void captureViewSnapshot(final int reactTag, final int surfaceId) {
+    getViewTransitionSnapshotManager().captureViewSnapshot(reactTag, surfaceId);
+  }
+
+  /** Called from C++ via JNI. */
+  @SuppressLint("NotInvokedPrivateMethod")
+  @SuppressWarnings("unused")
+  @AnyThread
+  @ThreadConfined(ANY)
+  private void setViewSnapshot(final int sourceTag, final int targetTag, final int surfaceId) {
+    getViewTransitionSnapshotManager().setViewSnapshot(sourceTag, targetTag);
+  }
+
+  /** Called from C++ via JNI. */
+  @SuppressLint("NotInvokedPrivateMethod")
+  @SuppressWarnings("unused")
+  @AnyThread
+  @ThreadConfined(ANY)
+  private void clearPendingSnapshots() {
+    getViewTransitionSnapshotManager().clearPendingSnapshots();
+  }
+
+  private synchronized ViewTransitionSnapshotManager getViewTransitionSnapshotManager() {
+    if (mViewTransitionSnapshotManager == null) {
+      mViewTransitionSnapshotManager = new ViewTransitionSnapshotManager(this, mMountingManager);
+    }
+    return mViewTransitionSnapshotManager;
+  }
+
   @SuppressLint("NotInvokedPrivateMethod")
   @SuppressWarnings("unused")
   @AnyThread
@@ -975,13 +1000,7 @@ public class FabricUIManager
         mBinding.mergeReactRevision(surfaceId);
       }
     } else {
-      UiThreadUtil.runOnUiThread(
-          () -> {
-            FabricUIManagerBinding binding = mBinding;
-            if (binding != null) {
-              binding.mergeReactRevision(surfaceId);
-            }
-          });
+      mPendingReactRevisionMerges.add(surfaceId);
     }
   }
 
@@ -992,15 +1011,8 @@ public class FabricUIManager
   @UnstableReactNativeAPI
   public void experimental_prefetchResources(
       int surfaceId, String componentName, ReadableMapBuffer params) {
-    if (ReactNativeFeatureFlags.enableImagePrefetchingOnUiThreadAndroid()) {
-      mMountItemDispatcher.addMountItem(
-          new PrefetchResourcesMountItem(surfaceId, componentName, params));
-    } else {
-      SurfaceMountingManager surfaceMountingManager = mMountingManager.getSurfaceManager(surfaceId);
-      if (surfaceMountingManager != null) {
-        surfaceMountingManager.experimental_prefetchResources(surfaceId, componentName, params);
-      }
-    }
+    mMountItemDispatcher.addMountItem(
+        new PrefetchResourcesMountItem(surfaceId, componentName, params));
   }
 
   void setBinding(FabricUIManagerBinding binding) {
@@ -1067,11 +1079,13 @@ public class FabricUIManager
     return surfaceManager.getView(reactTag);
   }
 
+  @Deprecated
   @Override
   public void receiveEvent(int reactTag, String eventName, @Nullable WritableMap params) {
     receiveEvent(View.NO_ID, reactTag, eventName, false, params, EventCategoryDef.UNSPECIFIED);
   }
 
+  @Deprecated
   @Override
   public void receiveEvent(
       int surfaceId, int reactTag, String eventName, @Nullable WritableMap params) {
@@ -1091,7 +1105,9 @@ public class FabricUIManager
    * @param canCoalesceEvent
    * @param params
    * @param eventCategory
+   * @deprecated Use the overload with eventTimestamp parameter instead.
    */
+  @Deprecated
   public void receiveEvent(
       int surfaceId,
       int reactTag,
@@ -1099,9 +1115,34 @@ public class FabricUIManager
       boolean canCoalesceEvent,
       @Nullable WritableMap params,
       @EventCategoryDef int eventCategory) {
-    receiveEvent(surfaceId, reactTag, eventName, canCoalesceEvent, params, eventCategory, false);
+    receiveEvent(
+        surfaceId,
+        reactTag,
+        eventName,
+        canCoalesceEvent,
+        params,
+        eventCategory,
+        false,
+        SystemClock.uptimeMillis());
   }
 
+  /**
+   * receiveEvent API that emits an event to C++. If {@code canCoalesceEvent} is true, that signals
+   * that C++ may coalesce the event optionally. Otherwise, coalescing can happen in Java before
+   * emitting.
+   *
+   * <p>{@code customCoalesceKey} is currently unused.
+   *
+   * @param surfaceId
+   * @param reactTag
+   * @param eventName
+   * @param canCoalesceEvent
+   * @param params
+   * @param eventCategory
+   * @param experimentalIsSynchronous
+   * @deprecated Use the overload with eventTimestamp parameter instead.
+   */
+  @Deprecated
   @Override
   public void receiveEvent(
       int surfaceId,
@@ -1111,6 +1152,43 @@ public class FabricUIManager
       @Nullable WritableMap params,
       @EventCategoryDef int eventCategory,
       boolean experimentalIsSynchronous) {
+    receiveEvent(
+        surfaceId,
+        reactTag,
+        eventName,
+        canCoalesceEvent,
+        params,
+        eventCategory,
+        experimentalIsSynchronous,
+        SystemClock.uptimeMillis());
+  }
+
+  /**
+   * receiveEvent API that emits an event to C++. If {@code canCoalesceEvent} is true, that signals
+   * that C++ may coalesce the event optionally. Otherwise, coalescing can happen in Java before
+   * emitting.
+   *
+   * <p>{@code customCoalesceKey} is currently unused.
+   *
+   * @param surfaceId
+   * @param reactTag
+   * @param eventName
+   * @param canCoalesceEvent
+   * @param params
+   * @param eventCategory
+   * @param experimentalIsSynchronous
+   * @param eventTimestamp
+   */
+  @Override
+  public void receiveEvent(
+      int surfaceId,
+      int reactTag,
+      String eventName,
+      boolean canCoalesceEvent,
+      @Nullable WritableMap params,
+      @EventCategoryDef int eventCategory,
+      boolean experimentalIsSynchronous,
+      long eventTimestamp) {
 
     if (ReactBuildConfig.DEBUG && surfaceId == View.NO_ID) {
       FLog.d(TAG, "Emitted event without surfaceId: [%d] %s", reactTag, eventName);
@@ -1128,7 +1206,13 @@ public class FabricUIManager
         // access to the event emitter later when the view is mounted. For now just save the event
         // in the view state and trigger it later.
         mMountingManager.enqueuePendingEvent(
-            surfaceId, reactTag, eventName, canCoalesceEvent, params, eventCategory);
+            surfaceId,
+            reactTag,
+            eventName,
+            canCoalesceEvent,
+            params,
+            eventCategory,
+            eventTimestamp);
       } else {
         // This can happen if the view has disappeared from the screen (because of async events)
         FLog.i(TAG, "Unable to invoke event: " + eventName + " for reactTag: " + reactTag);
@@ -1142,13 +1226,13 @@ public class FabricUIManager
       boolean firstEventForFrame =
           mSynchronousEvents.add(new SynchronousEvent(surfaceId, reactTag, eventName));
       if (firstEventForFrame) {
-        eventEmitter.dispatchEventSynchronously(eventName, params);
+        eventEmitter.dispatchEventSynchronously(eventName, params, eventTimestamp);
       }
     } else {
       if (canCoalesceEvent) {
-        eventEmitter.dispatchUnique(eventName, params);
+        eventEmitter.dispatchUnique(eventName, params, eventTimestamp);
       } else {
-        eventEmitter.dispatch(eventName, params, eventCategory);
+        eventEmitter.dispatch(eventName, params, eventCategory, eventTimestamp);
       }
     }
   }
@@ -1505,6 +1589,18 @@ public class FabricUIManager
         return;
       }
 
+      // Drain pending React revision merges first so that animations,
+      // preallocation, and mount items operate against the latest revision.
+      if (ReactNativeFeatureFlags.enableFabricCommitBranching()) {
+        FabricUIManagerBinding binding = mBinding;
+        if (binding != null) {
+          Integer mergeSurfaceId;
+          while ((mergeSurfaceId = mPendingReactRevisionMerges.poll()) != null) {
+            binding.mergeReactRevision(mergeSurfaceId);
+          }
+        }
+      }
+
       // Drive any animations from C++.
       // There is a race condition here between getting/setting
       // `mDriveCxxAnimations` which shouldn't matter; it's safe to call

package/ReactAndroid/src/main/java/com/facebook/react/fabric/ViewTransitionSnapshotManager.kt

@@ -0,0 +1,223 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+package com.facebook.react.fabric
+
+import android.graphics.Bitmap
+import android.graphics.Canvas
+import android.graphics.Rect
+import android.os.Build
+import android.os.Handler
+import android.os.Looper
+import android.view.PixelCopy
+import android.view.View
+import android.view.Window
+import androidx.annotation.RequiresApi
+import androidx.annotation.UiThread
+import androidx.core.graphics.createBitmap
+import com.facebook.infer.annotation.ThreadConfined
+import com.facebook.react.bridge.UIManager
+import com.facebook.react.bridge.UIManagerListener
+import com.facebook.react.bridge.UiThreadUtil
+import com.facebook.react.common.annotations.UnstableReactNativeAPI
+import com.facebook.react.fabric.mounting.MountingManager
+
+/**
+ * Manages bitmap snapshots of views during view transitions. Captures bitmaps from old views and
+ * applies them to pseudo-element shadow nodes, re-applying after each mount cycle since views may
+ * be recreated. Cleans up entries whose views have been deleted.
+ */
+@OptIn(UnstableReactNativeAPI::class)
+internal class ViewTransitionSnapshotManager(
+    private val uiManager: FabricUIManager,
+    private val mountingManager: MountingManager,
+) : UIManagerListener {
+
+  companion object {
+    private fun captureSoftwareBitmap(view: View): Bitmap? {
+      if (view.width > 0 && view.height > 0) {
+        val bitmap = createBitmap(view.width, view.height)
+        view.draw(Canvas(bitmap))
+        return bitmap
+      }
+      return null
+    }
+  }
+
+  // Captured bitmaps keyed by source tag. Populated by onBitmapCaptured.
+  @ThreadConfined(ThreadConfined.UI) private val viewSnapshots = LinkedHashMap<Int, Bitmap>()
+
+  // Source→target tag mapping. Populated by setViewSnapshot.
+  // A snapshot is resolved when both maps contain an entry for the same source tag.
+  @ThreadConfined(ThreadConfined.UI) private val pendingTargets = LinkedHashMap<Int, Int>()
+
+  @ThreadConfined(ThreadConfined.UI) private var listenerRegistered = false
+
+  private val mainHandler = Handler(Looper.getMainLooper())
+
+  @UiThread
+  private fun onBitmapCaptured(reactTag: Int, bitmap: Bitmap) {
+    viewSnapshots[reactTag] = bitmap
+    if (reactTag in pendingTargets) {
+      ensureListenerRegistered()
+    }
+  }
+
+  @UiThread
+  private fun ensureListenerRegistered() {
+    if (!listenerRegistered) {
+      listenerRegistered = true
+      uiManager.addUIManagerEventListener(this)
+    }
+  }
+
+  /**
+   * Captures a bitmap snapshot of the view identified by the given tag. On API 26+, uses PixelCopy
+   * to capture directly from the GPU-composited surface (faster for complex views, captures
+   * hardware-accelerated content). Falls back to View.draw() on older APIs.
+   */
+  fun captureViewSnapshot(reactTag: Int, surfaceId: Int) {
+    UiThreadUtil.runOnUiThread {
+      val smm = mountingManager.getSurfaceManager(surfaceId) ?: return@runOnUiThread
+      if (!smm.getViewExists(reactTag)) return@runOnUiThread
+      val view = smm.getView(reactTag)
+      if (view.width <= 0 || view.height <= 0) return@runOnUiThread
+
+      val window =
+          if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+            (view.context as? com.facebook.react.bridge.ReactContext)?.getCurrentActivity()?.window
+          } else {
+            null
+          }
+
+      if (window != null) {
+        captureHardwareBitmap(view, reactTag, window)
+      } else {
+        // Software fallback runs synchronously, so onBitmapCaptured always
+        // completes before setViewSnapshot is called.
+        captureSoftwareBitmap(view)?.let { onBitmapCaptured(reactTag, it) }
+      }
+    }
+  }
+
+  @RequiresApi(Build.VERSION_CODES.O)
+  private fun captureHardwareBitmap(view: View, reactTag: Int, window: Window) {
+    val location = IntArray(2)
+    view.getLocationInWindow(location)
+
+    val viewWidth = view.width
+    val viewHeight = view.height
+
+    if (viewWidth <= 0 || viewHeight <= 0) {
+      // Nothing to capture.
+      return
+    }
+
+    // The view's rect in window coordinates.
+    val viewRect = Rect(location[0], location[1], location[0] + viewWidth, location[1] + viewHeight)
+
+    // Clamp to window bounds — PixelCopy only captures what's visible on the
+    // window surface. Without clamping, off-screen portions are black/empty
+    // and the partial result gets stretched to fill the pseudo-element.
+    val windowWidth = window.decorView.width
+    val windowHeight = window.decorView.height
+    val clampedRect =
+        Rect(
+            viewRect.left.coerceAtLeast(0),
+            viewRect.top.coerceAtLeast(0),
+            viewRect.right.coerceAtMost(windowWidth),
+            viewRect.bottom.coerceAtMost(windowHeight),
+        )
+
+    if (clampedRect.isEmpty) {
+      // Entirely off-screen — nothing to capture.
+      return
+    }
+
+    val clampedBitmap = createBitmap(clampedRect.width(), clampedRect.height())
+    // Offset of the clamped region within the full view.
+    val offsetX = clampedRect.left - viewRect.left
+    val offsetY = clampedRect.top - viewRect.top
+
+    // PixelCopy callback is posted to mainHandler, so onBitmapCaptured may run after
+    // setViewSnapshot has already recorded the target tag for this source tag.
+    try {
+      PixelCopy.request(
+          window,
+          clampedRect,
+          clampedBitmap,
+          { copyResult ->
+            if (copyResult == PixelCopy.SUCCESS) {
+              // Compose the clamped capture into a full-size bitmap at the
+              // correct offset so it aligns with the pseudo-element's bounds.
+              val fullBitmap = createBitmap(viewWidth, viewHeight)
+              Canvas(fullBitmap)
+                  .drawBitmap(clampedBitmap, offsetX.toFloat(), offsetY.toFloat(), null)
+              clampedBitmap.recycle()
+              onBitmapCaptured(reactTag, fullBitmap)
+            } else {
+              // Fall back to software rendering if the view is still valid.
+              clampedBitmap.recycle()
+              captureSoftwareBitmap(view)?.let { onBitmapCaptured(reactTag, it) }
+            }
+          },
+          mainHandler,
+      )
+    } catch (e: IllegalArgumentException) {
+      // Window surface may have been destroyed (e.g., device idle/sleep).
+      // Fall back to software rendering if the view is still valid.
+      clampedBitmap.recycle()
+      captureSoftwareBitmap(view)?.let { onBitmapCaptured(reactTag, it) }
+    }
+  }
+
+  /**
+   * Maps a previously captured bitmap from a source view to a target pseudo-element view. If the
+   * bitmap is already available, the snapshot becomes resolved and will be re-applied after mount
+   * cycles.
+   */
+  fun setViewSnapshot(sourceTag: Int, targetTag: Int) {
+    UiThreadUtil.runOnUiThread {
+      pendingTargets[sourceTag] = targetTag
+      if (sourceTag in viewSnapshots) {
+        ensureListenerRegistered()
+      }
+    }
+  }
+
+  /**
+   * Clears all snapshots. Called when a view transition ends to release bitmaps and unregister the
+   * mount listener.
+   */
+  fun clearPendingSnapshots() {
+    UiThreadUtil.runOnUiThread {
+      viewSnapshots.clear()
+      pendingTargets.clear()
+      if (listenerRegistered) {
+        listenerRegistered = false
+        uiManager.removeUIManagerEventListener(this)
+      }
+    }
+  }
+
+  override fun willDispatchViewUpdates(uiManager: UIManager) {}
+
+  override fun willMountItems(uiManager: UIManager) {}
+
+  @UiThread
+  override fun didMountItems(uiManager: UIManager) {
+    for ((sourceTag, targetTag) in pendingTargets) {
+      val smm = mountingManager.getSurfaceManagerForView(targetTag) ?: continue
+      val bitmap = viewSnapshots[sourceTag] ?: continue
+      smm.applyViewSnapshot(targetTag, bitmap)
+    }
+  }
+
+  override fun didDispatchMountItems(uiManager: UIManager) {}
+
+  override fun didScheduleMountItems(uiManager: UIManager) {}
+}