react-native-tvos 0.81.3-0 → 0.82.0-0

package/ReactAndroid/src/main/java/com/facebook/react/views/{virtualview → virtual/view}/ReactVirtualView.kt

@@ -5,7 +5,7 @@
  * LICENSE file in the root directory of this source tree.
  */
 
-package com.facebook.react.views.virtualview
+package com.facebook.react.views.virtual.view
 
 import android.content.Context
 import android.graphics.Rect
@@ -18,15 +18,19 @@ import com.facebook.common.logging.FLog
 import com.facebook.react.R
 import com.facebook.react.common.build.ReactBuildConfig
 import com.facebook.react.internal.featureflags.ReactNativeFeatureFlags
+import com.facebook.react.uimanager.ReactClippingViewGroup
 import com.facebook.react.uimanager.ReactRoot
 import com.facebook.react.views.scroll.ReactHorizontalScrollView
 import com.facebook.react.views.scroll.ReactScrollView
 import com.facebook.react.views.scroll.ReactScrollViewHelper
 import com.facebook.react.views.scroll.ScrollEventType
 import com.facebook.react.views.view.ReactViewGroup
+import com.facebook.react.views.virtual.VirtualViewMode
+import com.facebook.react.views.virtual.VirtualViewModeChangeEmitter
+import com.facebook.react.views.virtual.VirtualViewRenderState
 import com.facebook.systrace.Systrace
 
-internal class ReactVirtualView(context: Context) :
+public class ReactVirtualView(context: Context) :
     ReactViewGroup(context),
     ReactScrollViewHelper.ScrollListener,
     ReactScrollViewHelper.LayoutChangeListener,
@@ -34,14 +38,18 @@ internal class ReactVirtualView(context: Context) :
 
   internal var mode: VirtualViewMode? = null
   internal var renderState: VirtualViewRenderState = VirtualViewRenderState.Unknown
-  internal var modeChangeEmitter: ModeChangeEmitter? = null
+  internal var modeChangeEmitter: VirtualViewModeChangeEmitter? = null
   internal var prerenderRatio: Double = ReactNativeFeatureFlags.virtualViewPrerenderRatio()
   internal val debugLogEnabled: Boolean = ReactNativeFeatureFlags.enableVirtualViewDebugFeatures()
-  internal val detectWindowFocus = ReactNativeFeatureFlags.enableVirtualViewWindowFocusDetection()
+  private val hysteresisRatio: Double = ReactNativeFeatureFlags.virtualViewHysteresisRatio()
 
   private val onWindowFocusChangeListener =
-      ViewTreeObserver.OnWindowFocusChangeListener {
-        dispatchOnModeChangeIfNeeded(checkRectChange = false)
+      if (ReactNativeFeatureFlags.enableVirtualViewWindowFocusDetection()) {
+        ViewTreeObserver.OnWindowFocusChangeListener {
+          dispatchOnModeChangeIfNeeded(checkRectChange = false)
+        }
+      } else {
+        null
       }
 
   private var parentScrollView: View? = null
@@ -50,6 +58,7 @@ internal class ReactVirtualView(context: Context) :
   private val lastRect: Rect = Rect()
   private val targetRect: Rect = Rect()
   private val thresholdRect: Rect = Rect()
+  private val lastClippingRect: Rect = Rect()
 
   /** Cumulative offset of parents' `left` values within the scroll view */
   private var offsetX: Int = 0
@@ -71,6 +80,7 @@ internal class ReactVirtualView(context: Context) :
     offsetX = 0
     offsetY = 0
     offsetChanged = false
+    lastClippingRect.setEmpty()
   }
 
   override fun onAttachedToWindow() {
@@ -87,7 +97,7 @@ internal class ReactVirtualView(context: Context) :
           ReactScrollViewHelper.addLayoutChangeListener(this)
         }
     debugLog("onAttachedToWindow")
-    if (detectWindowFocus) {
+    if (onWindowFocusChangeListener != null) {
       viewTreeObserver.addOnWindowFocusChangeListener(onWindowFocusChangeListener)
     }
     dispatchOnModeChangeIfNeeded(checkRectChange = false)
@@ -97,8 +107,8 @@ internal class ReactVirtualView(context: Context) :
     super.onDetachedFromWindow()
     ReactScrollViewHelper.removeScrollListener(this)
     ReactScrollViewHelper.removeLayoutChangeListener(this)
-    if (detectWindowFocus) {
-      viewTreeObserver.addOnWindowFocusChangeListener(onWindowFocusChangeListener)
+    if (onWindowFocusChangeListener != null) {
+      viewTreeObserver.removeOnWindowFocusChangeListener(onWindowFocusChangeListener)
     }
     cleanupLayoutListeners()
   }
@@ -121,7 +131,7 @@ internal class ReactVirtualView(context: Context) :
       oldLeft: Int,
       oldTop: Int,
       oldRight: Int,
-      oldBottom: Int
+      oldBottom: Int,
   ) {
     offsetChanged = offsetChanged || oldLeft != left || oldTop != top
     dispatchOnModeChangeIfNeeded(true)
@@ -135,7 +145,7 @@ internal class ReactVirtualView(context: Context) :
       scrollView: ViewGroup?,
       scrollEventType: ScrollEventType?,
       xVelocity: Float,
-      yVelocity: Float
+      yVelocity: Float,
   ) {
     if (scrollView == parentScrollView) {
       dispatchOnModeChangeIfNeeded(checkRectChange = false)
@@ -163,6 +173,42 @@ internal class ReactVirtualView(context: Context) :
     }
   }
 
+  override fun onSizeChanged(w: Int, h: Int, oldw: Int, oldh: Int) {
+    super.onSizeChanged(w, h, oldw, oldh)
+    dispatchOnModeChangeIfNeeded(true)
+  }
+
+  // Note: We co-opt subview clipping on ReactVirtualView by returning the
+  // clipping rect of the ScrollView. This means we clip the children of ReactVirtualView
+  // when they are out of the viewport, but not ReactVirtualView itself.
+  override fun updateClippingRect(excludedViews: Set<Int>?) {
+    if (!_removeClippedSubviews) {
+      return
+    }
+
+    // If no ScrollView, or ScrollView has disabled removeClippedSubviews, use default behavior
+    if (
+        parentScrollView == null ||
+            !((parentScrollView as ReactClippingViewGroup).removeClippedSubviews ?: false)
+    ) {
+      super.updateClippingRect(excludedViews)
+      return
+    }
+
+    val clippingRect = checkNotNull(clippingRect)
+
+    (parentScrollView as ReactClippingViewGroup).getClippingRect(clippingRect)
+    clippingRect.intersect(targetRect)
+    clippingRect.offset(-targetRect.left, -targetRect.top)
+
+    if (lastClippingRect == clippingRect) {
+      return
+    }
+
+    updateClippingToRect(clippingRect, excludedViews)
+    lastClippingRect.set(clippingRect)
+  }
+
   private fun dispatchOnModeChangeIfNeeded(checkRectChange: Boolean) {
     modeChangeEmitter ?: return
     val scrollView = parentScrollView ?: return
@@ -177,6 +223,8 @@ internal class ReactVirtualView(context: Context) :
         bottom + offsetY,
     )
     scrollView.getDrawingRect(thresholdRect)
+    val visibleHeight = thresholdRect.height()
+    val visibleWidth = thresholdRect.width()
 
     // TODO: Validate whether this is still the case and whether these checks are still needed.
     // updateRects will initially get called before the targetRect has any dimensions set, so if
@@ -189,6 +237,9 @@ internal class ReactVirtualView(context: Context) :
       }
       return
     }
+
+    updateClippingRect()
+
     if (checkRectChange) {
       if (!lastRect.isEmpty && lastRect == targetRect) {
         debugLog("dispatchOnModeChangeIfNeeded") { "no rect change" }
@@ -199,7 +250,7 @@ internal class ReactVirtualView(context: Context) :
 
     val newMode: VirtualViewMode
     if (rectsOverlap(targetRect, thresholdRect)) {
-      if (detectWindowFocus) {
+      if (onWindowFocusChangeListener != null) {
         if (hasWindowFocus()) {
           newMode = VirtualViewMode.Visible
         } else {
@@ -212,15 +263,32 @@ internal class ReactVirtualView(context: Context) :
       var prerender = false
       if (prerenderRatio > 0.0) {
         thresholdRect.inset(
-            (-thresholdRect.width() * prerenderRatio).toInt(),
-            (-thresholdRect.height() * prerenderRatio).toInt())
+            (-visibleWidth * prerenderRatio).toInt(),
+            (-visibleHeight * prerenderRatio).toInt(),
+        )
         prerender = rectsOverlap(targetRect, thresholdRect)
       }
       if (prerender) {
         newMode = VirtualViewMode.Prerender
       } else {
-        newMode = VirtualViewMode.Hidden
-        thresholdRect.setEmpty()
+        val _mode = mode // local variable so Kotlin knows its not nullable
+        if (_mode != null && hysteresisRatio > 0.0) {
+          thresholdRect.inset(
+              (-visibleWidth * hysteresisRatio).toInt(),
+              (-visibleHeight * hysteresisRatio).toInt(),
+          )
+          if (rectsOverlap(targetRect, thresholdRect)) {
+            // In hysteresis window, no change to mode
+            newMode = _mode
+            debugLog("dispatchOnModeChangeIfNeeded") { "hysteresis, mode=$newMode" }
+          } else {
+            newMode = VirtualViewMode.Hidden
+            thresholdRect.setEmpty()
+          }
+        } else {
+          newMode = VirtualViewMode.Hidden
+          thresholdRect.setEmpty()
+        }
       }
     }
     debugLog("dispatchOnModeChangeIfNeeded") {
@@ -265,7 +333,8 @@ internal class ReactVirtualView(context: Context) :
     debugLog("Mode change") { "$oldMode->$newMode" }
     Systrace.beginSection(
         Systrace.TRACE_TAG_REACT,
-        "VirtualView::mode change $oldMode -> $newMode, nativeID=$nativeId")
+        "VirtualView::mode change $oldMode -> $newMode, nativeID=$nativeId",
+    )
     when (newMode) {
       VirtualViewMode.Visible -> {
         if (renderState == VirtualViewRenderState.Unknown) {
@@ -367,15 +436,6 @@ internal class ReactVirtualView(context: Context) :
   }
 }
 
-internal fun interface ModeChangeEmitter {
-  fun emitModeChange(
-      mode: VirtualViewMode,
-      targetRect: Rect,
-      thresholdRect: Rect,
-      synchronous: Boolean,
-  )
-}
-
 private const val DEBUG_TAG: String = "ReactVirtualView"
 
 private val IS_DEBUG_BUILD =

package/ReactAndroid/src/main/java/com/facebook/react/views/{virtualview → virtual/view}/ReactVirtualViewManager.kt

@@ -5,7 +5,7 @@
  * LICENSE file in the root directory of this source tree.
  */
 
-package com.facebook.react.views.virtualview
+package com.facebook.react.views.virtual.view
 
 import android.graphics.Rect
 import androidx.annotation.VisibleForTesting
@@ -13,16 +13,20 @@ import com.facebook.react.internal.featureflags.ReactNativeFeatureFlags
 import com.facebook.react.module.annotations.ReactModule
 import com.facebook.react.uimanager.ThemedReactContext
 import com.facebook.react.uimanager.UIManagerHelper
-import com.facebook.react.uimanager.ViewGroupManager
 import com.facebook.react.uimanager.ViewManagerDelegate
 import com.facebook.react.uimanager.annotations.ReactProp
 import com.facebook.react.uimanager.events.EventDispatcher
 import com.facebook.react.viewmanagers.VirtualViewManagerDelegate
 import com.facebook.react.viewmanagers.VirtualViewManagerInterface
+import com.facebook.react.views.view.ReactClippingViewManager
+import com.facebook.react.views.virtual.VirtualViewMode
+import com.facebook.react.views.virtual.VirtualViewModeChangeEmitter
+import com.facebook.react.views.virtual.VirtualViewModeChangeEvent
+import com.facebook.react.views.virtual.VirtualViewRenderState
 
 @ReactModule(name = ReactVirtualViewManager.REACT_CLASS)
-internal class ReactVirtualViewManager :
-    ViewGroupManager<ReactVirtualView>(), VirtualViewManagerInterface<ReactVirtualView> {
+public class ReactVirtualViewManager :
+    ReactClippingViewManager<ReactVirtualView>(), VirtualViewManagerInterface<ReactVirtualView> {
 
   private val _delegate = VirtualViewManagerDelegate(this)
 
@@ -78,11 +82,11 @@ internal class ReactVirtualViewManager :
 }
 
 @VisibleForTesting
-internal class VirtualViewEventEmitter(
+public class VirtualViewEventEmitter(
     private val viewId: Int,
     private val surfaceId: Int,
-    private val dispatcher: EventDispatcher
-) : ModeChangeEmitter {
+    private val dispatcher: EventDispatcher,
+) : VirtualViewModeChangeEmitter {
   override fun emitModeChange(
       mode: VirtualViewMode,
       targetRect: Rect,
@@ -97,6 +101,7 @@ internal class VirtualViewEventEmitter(
             targetRect,
             thresholdRect,
             synchronous,
-        ))
+        )
+    )
   }
 }

package/ReactAndroid/src/main/java/com/facebook/react/views/virtual/viewexperimental/ReactVirtualViewExperimental.kt

@@ -0,0 +1,256 @@
+/*
+ * 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.views.virtual.viewexperimental
+
+import android.content.Context
+import android.graphics.Rect
+import android.view.View
+import android.view.ViewParent
+import androidx.annotation.VisibleForTesting
+import com.facebook.common.logging.FLog
+import com.facebook.react.R
+import com.facebook.react.common.build.ReactBuildConfig
+import com.facebook.react.internal.featureflags.ReactNativeFeatureFlags
+import com.facebook.react.uimanager.ReactRoot
+import com.facebook.react.views.scroll.VirtualView
+import com.facebook.react.views.scroll.VirtualViewContainer
+import com.facebook.react.views.view.ReactViewGroup
+import com.facebook.react.views.virtual.VirtualViewMode
+import com.facebook.react.views.virtual.VirtualViewModeChangeEmitter
+import com.facebook.react.views.virtual.VirtualViewRenderState
+
+public class ReactVirtualViewExperimental(context: Context) :
+    ReactViewGroup(context), VirtualView, View.OnLayoutChangeListener {
+
+  internal var mode: VirtualViewMode? = null
+  internal var modeChangeEmitter: VirtualViewModeChangeEmitter? = null
+  internal var renderState: VirtualViewRenderState = VirtualViewRenderState.Unknown
+
+  private var scrollView: VirtualViewContainer? = null
+
+  private val lastContainerRelativeRect: Rect = Rect()
+  override val containerRelativeRect: Rect = Rect()
+  private var offsetX: Int = 0
+  private var offsetY: Int = 0
+  private var hadLayout: Boolean = false
+
+  internal val nativeId: String?
+    get() = getTag(R.id.view_tag_native_id) as? String
+
+  override fun onAttachedToWindow() {
+    super.onAttachedToWindow()
+    doAttachedToWindow()
+  }
+
+  @VisibleForTesting
+  internal fun doAttachedToWindow() {
+    scrollView = getScrollView()
+    // onAttachedToWindow is usually called before layout but there are cases where it's called
+    // after. If called after, we need to report the updated layout to the VirtualViewContainer
+    if (hadLayout) {
+      updateParentOffset()
+      reportRectChangeToContainer()
+    }
+    debugLog("doAttachedToWindow")
+  }
+
+  /** From [View#onLayout] */
+  // This is when the view itself has layout changes
+  override fun onLayout(changed: Boolean, left: Int, top: Int, right: Int, bottom: Int) {
+    super.onLayout(changed, left, top, right, bottom)
+    hadLayout = true
+    if (changed) {
+      containerRelativeRect.set(
+          left + offsetX,
+          top + offsetY,
+          right + offsetX,
+          bottom + offsetY,
+      )
+      debugLog("onLayout") { "containerRelativeRect=$containerRelativeRect" }
+      reportRectChangeToContainer()
+    }
+  }
+
+  // Here we're subscribing to all parent views up to scrollView and when their layout changes
+  override fun onLayoutChange(
+      v: View?,
+      left: Int,
+      top: Int,
+      right: Int,
+      bottom: Int,
+      oldLeft: Int,
+      oldTop: Int,
+      oldRight: Int,
+      oldBottom: Int,
+  ) {
+    if (oldLeft != left || oldTop != top) {
+      updateParentOffset()
+      debugLog("onLayoutChange") { "containerRelativeRect=$containerRelativeRect" }
+      reportRectChangeToContainer()
+    }
+  }
+
+  override fun onSizeChanged(w: Int, h: Int, oldw: Int, oldh: Int) {
+    super.onSizeChanged(w, h, oldw, oldh)
+    containerRelativeRect.set(
+        left + offsetX,
+        top + offsetY,
+        right + offsetX,
+        bottom + offsetY,
+    )
+    debugLog("onSizeChanged") { "container=$containerRelativeRect" }
+    reportRectChangeToContainer()
+  }
+
+  override fun onDetachedFromWindow() {
+    super.onDetachedFromWindow()
+    recycleView()
+  }
+
+  override internal fun recycleView() {
+    cleanupLayoutListeners()
+    scrollView?.virtualViewContainerState?.remove(this)
+    scrollView = null
+    mode = null
+    modeChangeEmitter = null
+    hadLayout = false
+    lastContainerRelativeRect.setEmpty()
+    containerRelativeRect.setEmpty()
+  }
+
+  override val virtualViewID: String
+    get() {
+      return "${nativeId ?: "unknown"}:::${id}"
+    }
+
+  override fun onModeChange(newMode: VirtualViewMode, thresholdRect: Rect) {
+    modeChangeEmitter ?: return
+    scrollView ?: return
+
+    if (newMode == mode) {
+      return
+    }
+
+    val oldMode = mode
+    mode = newMode
+
+    debugLog("onModeChange") { "$oldMode->$newMode" }
+
+    when (newMode) {
+      VirtualViewMode.Visible -> {
+        if (renderState == VirtualViewRenderState.Unknown) {
+          // Feature flag is disabled, so use the former logic.
+          modeChangeEmitter?.emitModeChange(
+              VirtualViewMode.Visible,
+              containerRelativeRect,
+              thresholdRect,
+              synchronous = true,
+          )
+        } else {
+          // If the previous mode was prerender and the result of dispatching that event was
+          // committed, we do not need to dispatch an event for visible.
+          val wasPrerenderCommitted =
+              oldMode == VirtualViewMode.Prerender && renderState == VirtualViewRenderState.Rendered
+          if (!wasPrerenderCommitted) {
+            modeChangeEmitter?.emitModeChange(
+                VirtualViewMode.Visible,
+                containerRelativeRect,
+                thresholdRect,
+                synchronous = true,
+            )
+          }
+        }
+      }
+      VirtualViewMode.Prerender -> {
+        if (oldMode != VirtualViewMode.Visible) {
+          modeChangeEmitter?.emitModeChange(
+              VirtualViewMode.Prerender,
+              containerRelativeRect,
+              thresholdRect,
+              synchronous = false,
+          )
+        }
+      }
+      VirtualViewMode.Hidden -> {
+        modeChangeEmitter?.emitModeChange(
+            VirtualViewMode.Hidden,
+            containerRelativeRect,
+            thresholdRect,
+            synchronous = false,
+        )
+      }
+    }
+  }
+
+  private fun updateParentOffset() {
+    val virtualViewScrollView = scrollView ?: return
+    offsetX = 0
+    offsetY = 0
+    var parent: ViewParent? = parent
+    while (parent != null && parent != virtualViewScrollView) {
+      if (parent is View) {
+        offsetX += parent.left
+        offsetY += parent.top
+      }
+      parent = parent.parent
+    }
+    containerRelativeRect.set(
+        left + offsetX,
+        top + offsetY,
+        right + offsetX,
+        bottom + offsetY,
+    )
+  }
+
+  private fun reportRectChangeToContainer() {
+    if (lastContainerRelativeRect == containerRelativeRect) {
+      debugLog("reportRectChangeToContainer") { "no rect change $containerRelativeRect" }
+      return
+    }
+    scrollView?.virtualViewContainerState?.onChange(this)
+    lastContainerRelativeRect.set(containerRelativeRect)
+  }
+
+  private fun getScrollView(): VirtualViewContainer? = traverseParentStack(true)
+
+  private fun cleanupLayoutListeners() {
+    traverseParentStack(false)
+  }
+
+  private fun traverseParentStack(addListeners: Boolean): VirtualViewContainer? {
+    var parent: ViewParent? = parent
+    while (parent != null) {
+      if (parent is VirtualViewContainer) {
+        return parent
+      }
+      if (parent is ReactRoot) {
+        // don't look past the root - it could traverse into a separate hierarchy
+        return null
+      }
+      if (parent is View) {
+        // always remove, to ensure listeners aren't added more than once
+        parent.removeOnLayoutChangeListener(this)
+        if (addListeners) {
+          parent.addOnLayoutChangeListener(this)
+        }
+      }
+      parent = parent.parent
+    }
+    return null
+  }
+
+  internal inline fun debugLog(subtag: String, block: () -> String = { "" }) {
+    if (IS_DEBUG_BUILD && ReactNativeFeatureFlags.enableVirtualViewDebugFeatures()) {
+      FLog.d("$DEBUG_TAG:[$virtualViewID]:$subtag", "${block()}")
+    }
+  }
+}
+
+private const val DEBUG_TAG: String = "ReactVirtualViewExperimental"
+private val IS_DEBUG_BUILD =
+    ReactBuildConfig.DEBUG || ReactBuildConfig.IS_INTERNAL_BUILD || ReactBuildConfig.ENABLE_PERFETTO

package/ReactAndroid/src/main/java/com/facebook/react/views/virtual/viewexperimental/ReactVirtualViewExperimentalManager.kt

@@ -0,0 +1,110 @@
+/*
+ * 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.views.virtual.viewexperimental
+
+import android.graphics.Rect
+import androidx.annotation.VisibleForTesting
+import com.facebook.react.internal.featureflags.ReactNativeFeatureFlags
+import com.facebook.react.module.annotations.ReactModule
+import com.facebook.react.uimanager.ThemedReactContext
+import com.facebook.react.uimanager.UIManagerHelper
+import com.facebook.react.uimanager.ViewGroupManager
+import com.facebook.react.uimanager.ViewManagerDelegate
+import com.facebook.react.uimanager.annotations.ReactProp
+import com.facebook.react.uimanager.events.EventDispatcher
+import com.facebook.react.viewmanagers.VirtualViewExperimentalManagerDelegate
+import com.facebook.react.viewmanagers.VirtualViewExperimentalManagerInterface
+import com.facebook.react.views.virtual.VirtualViewMode
+import com.facebook.react.views.virtual.VirtualViewModeChangeEmitter
+import com.facebook.react.views.virtual.VirtualViewModeChangeEvent
+import com.facebook.react.views.virtual.VirtualViewRenderState
+
+@ReactModule(name = ReactVirtualViewExperimentalManager.REACT_CLASS)
+public class ReactVirtualViewExperimentalManager :
+    ViewGroupManager<ReactVirtualViewExperimental>(),
+    VirtualViewExperimentalManagerInterface<ReactVirtualViewExperimental> {
+
+  private val _delegate = VirtualViewExperimentalManagerDelegate(this)
+
+  override fun getDelegate(): ViewManagerDelegate<ReactVirtualViewExperimental> = _delegate
+
+  override fun getName(): String = REACT_CLASS
+
+  override fun createViewInstance(reactContext: ThemedReactContext): ReactVirtualViewExperimental =
+      ReactVirtualViewExperimental(reactContext)
+
+  @ReactProp(name = "initialHidden")
+  override fun setInitialHidden(view: ReactVirtualViewExperimental, value: Boolean) {
+    if (view.mode == null) {
+      view.mode = if (value) VirtualViewMode.Hidden else VirtualViewMode.Visible
+    }
+  }
+
+  @ReactProp(name = "renderState")
+  override fun setRenderState(view: ReactVirtualViewExperimental, value: Int) {
+    // If disabled, `renderState` will always be `VirtualViewRenderState.Unknown`.
+    if (ReactNativeFeatureFlags.enableVirtualViewRenderState()) {
+      view.renderState =
+          when (value) {
+            1 -> VirtualViewRenderState.Rendered
+            2 -> VirtualViewRenderState.None
+            else -> VirtualViewRenderState.Unknown
+          }
+    }
+  }
+
+  override fun setNativeId(view: ReactVirtualViewExperimental, nativeId: String?) {
+    super.setNativeId(view, nativeId)
+  }
+
+  override fun addEventEmitters(
+      reactContext: ThemedReactContext,
+      view: ReactVirtualViewExperimental,
+  ) {
+    val dispatcher = UIManagerHelper.getEventDispatcherForReactTag(reactContext, view.id) ?: return
+    view.modeChangeEmitter =
+        VirtualViewEventEmitter(view.id, UIManagerHelper.getSurfaceId(reactContext), dispatcher)
+  }
+
+  override fun prepareToRecycleView(
+      reactContext: ThemedReactContext,
+      view: ReactVirtualViewExperimental,
+  ): ReactVirtualViewExperimental? {
+    view.recycleView()
+    return super.prepareToRecycleView(reactContext, view)
+  }
+
+  public companion object {
+    public const val REACT_CLASS: String = "VirtualViewExperimental"
+  }
+}
+
+@VisibleForTesting
+public class VirtualViewEventEmitter(
+    private val viewId: Int,
+    private val surfaceId: Int,
+    private val dispatcher: EventDispatcher,
+) : VirtualViewModeChangeEmitter {
+  override fun emitModeChange(
+      mode: VirtualViewMode,
+      targetRect: Rect,
+      thresholdRect: Rect,
+      synchronous: Boolean,
+  ) {
+    dispatcher.dispatchEvent(
+        VirtualViewModeChangeEvent(
+            surfaceId,
+            viewId,
+            mode,
+            targetRect,
+            thresholdRect,
+            synchronous,
+        )
+    )
+  }
+}

package/ReactAndroid/src/main/java/com/facebook/systrace/Systrace.kt

@@ -110,6 +110,6 @@ internal object Systrace {
   enum class EventScope(val code: Char) {
     THREAD('t'),
     PROCESS('p'),
-    GLOBAL('g')
+    GLOBAL('g'),
   }
 }

package/ReactAndroid/src/main/java/com/facebook/systrace/SystraceMessage.kt

@@ -43,7 +43,8 @@ internal object SystraceMessage {
                 " (${java.lang.String.join(", ", args)})"
               } else {
                 ""
-              })
+              },
+      )
     }
 
     override fun arg(key: String, value: Any): Builder {