react-native-tvos 0.81.1-2 → 0.82.0-0rc0

package/ReactAndroid/src/main/java/com/facebook/react/views/scroll/ReactScrollViewHelper.kt

@@ -19,6 +19,7 @@ import androidx.annotation.RequiresApi
 import androidx.core.view.ViewCompat.FocusDirection
 import androidx.core.view.ViewCompat.FocusRealDirection
 import com.facebook.common.logging.FLog
+import com.facebook.react.animated.NativeAnimatedModule
 import com.facebook.react.bridge.ReactContext
 import com.facebook.react.bridge.WritableMap
 import com.facebook.react.bridge.WritableNativeMap
@@ -65,44 +66,42 @@ public object ReactScrollViewHelper {
 
   /** Shared by [ReactScrollView] and [ReactHorizontalScrollView]. */
   @JvmStatic
-  public fun <T> emitScrollEvent(scrollView: T, xVelocity: Float, yVelocity: Float) where
-  T : HasScrollEventThrottle?,
-  T : ViewGroup {
+  public fun <T> emitScrollEvent(scrollView: T, xVelocity: Float, yVelocity: Float)
+      where T : HasScrollEventThrottle?, T : ViewGroup {
     emitScrollEvent(scrollView, ScrollEventType.SCROLL, xVelocity, yVelocity)
   }
 
   @JvmStatic
-  public fun <T> emitScrollBeginDragEvent(scrollView: T) where
-  T : HasScrollEventThrottle?,
-  T : ViewGroup {
+  public fun <T> emitScrollBeginDragEvent(scrollView: T)
+      where T : HasScrollEventThrottle?, T : ViewGroup {
     emitScrollEvent(scrollView, ScrollEventType.BEGIN_DRAG)
   }
 
   @JvmStatic
-  public fun <T> emitScrollEndDragEvent(scrollView: T, xVelocity: Float, yVelocity: Float) where
-  T : HasScrollEventThrottle?,
-  T : ViewGroup {
+  public fun <T> emitScrollEndDragEvent(scrollView: T, xVelocity: Float, yVelocity: Float)
+      where T : HasScrollEventThrottle?, T : ViewGroup {
     emitScrollEvent(scrollView, ScrollEventType.END_DRAG, xVelocity, yVelocity)
   }
 
   @JvmStatic
-  public fun <T> emitScrollMomentumBeginEvent(scrollView: T, xVelocity: Int, yVelocity: Int) where
-  T : HasScrollEventThrottle?,
-  T : ViewGroup {
+  public fun <T> emitScrollMomentumBeginEvent(scrollView: T, xVelocity: Int, yVelocity: Int)
+      where T : HasScrollEventThrottle?, T : ViewGroup {
     emitScrollEvent(
-        scrollView, ScrollEventType.MOMENTUM_BEGIN, xVelocity.toFloat(), yVelocity.toFloat())
+        scrollView,
+        ScrollEventType.MOMENTUM_BEGIN,
+        xVelocity.toFloat(),
+        yVelocity.toFloat(),
+    )
   }
 
   @JvmStatic
-  public fun <T> emitScrollMomentumEndEvent(scrollView: T) where
-  T : HasScrollEventThrottle?,
-  T : ViewGroup {
+  public fun <T> emitScrollMomentumEndEvent(scrollView: T)
+      where T : HasScrollEventThrottle?, T : ViewGroup {
     emitScrollEvent(scrollView, ScrollEventType.MOMENTUM_END)
   }
 
-  private fun <T> emitScrollEvent(scrollView: T, scrollEventType: ScrollEventType) where
-  T : HasScrollEventThrottle?,
-  T : ViewGroup {
+  private fun <T> emitScrollEvent(scrollView: T, scrollEventType: ScrollEventType)
+      where T : HasScrollEventThrottle?, T : ViewGroup {
     emitScrollEvent(scrollView, scrollEventType, 0f, 0f)
   }
 
@@ -116,8 +115,10 @@ public object ReactScrollViewHelper {
     // Throttle the scroll event if scrollEventThrottle is set to be equal or more than 17 ms.
     // We limit the delta to 17ms so that small throttles intended to enable 60fps updates will not
     // inadvertently filter out any scroll events.
-    if (scrollEventType == ScrollEventType.SCROLL &&
-        scrollView.scrollEventThrottle >= max(17, now - scrollView.lastScrollDispatchTime)) {
+    if (
+        scrollEventType == ScrollEventType.SCROLL &&
+            scrollView.scrollEventThrottle >= max(17, now - scrollView.lastScrollDispatchTime)
+    ) {
       // Scroll events are throttled.
       return
     }
@@ -146,13 +147,28 @@ public object ReactScrollViewHelper {
               contentView.width,
               contentView.height,
               scrollView.width,
-              scrollView.height))
+              scrollView.height,
+          )
+      )
       if (scrollEventType == ScrollEventType.SCROLL) {
         scrollView.lastScrollDispatchTime = now
       }
     }
   }
 
+  // TODO: Remove this once C++ animation driver is complete
+  @JvmStatic
+  @JvmName("notifyUserDrivenScrollEnded_internal")
+  internal fun notifyUserDrivenScrollEnded(scrollView: ViewGroup) {
+    val reactContext = scrollView.context as? ReactContext
+    if (reactContext != null) {
+      val nativeAnimated = reactContext.getNativeModule(NativeAnimatedModule::class.java)
+      if (nativeAnimated != null) {
+        nativeAnimated.userDrivenScrollEnded(scrollView.id)
+      }
+    }
+  }
+
   /** This is only for Java listeners. onLayout events emitted to JS are handled elsewhere. */
   @JvmStatic
   public fun emitLayoutEvent(scrollView: ViewGroup) {
@@ -249,11 +265,8 @@ public object ReactScrollViewHelper {
    * y), then apply that to the animator.
    */
   @JvmStatic
-  public fun <T> smoothScrollTo(scrollView: T, x: Int, y: Int) where
-  T : HasFlingAnimator?,
-  T : HasScrollState?,
-  T : HasStateWrapper?,
-  T : ViewGroup {
+  public fun <T> smoothScrollTo(scrollView: T, x: Int, y: Int)
+      where T : HasFlingAnimator?, T : HasScrollState?, T : HasStateWrapper?, T : ViewGroup {
     if (DEBUG_MODE) {
       FLog.i(TAG, "smoothScrollTo[%d] x %d y %d", scrollView.id, x, y)
     }
@@ -283,7 +296,7 @@ public object ReactScrollViewHelper {
       scrollView: T,
       currentValue: Int,
       postAnimationValue: Int,
-      velocity: Int
+      velocity: Int,
   ): Int where T : HasFlingAnimator?, T : HasScrollState?, T : ViewGroup {
     val scrollState = scrollView.reactScrollViewScrollState
     val velocityDirectionMask = if (velocity != 0) velocity / abs(velocity) else 0
@@ -294,8 +307,9 @@ public object ReactScrollViewHelper {
     // the final animated value, we will return the final animated value. This is because follow up
     // animation should consider the "would be" animated location, so that previous quick small
     // scrolls are still working.
-    return if (!scrollState.isFinished ||
-        (scrollState.isCanceled && isMovingTowardsAnimatedValue)) {
+    return if (
+        !scrollState.isFinished || (scrollState.isCanceled && isMovingTowardsAnimatedValue)
+    ) {
       postAnimationValue
     } else {
       currentValue
@@ -303,24 +317,24 @@ public object ReactScrollViewHelper {
   }
 
   @JvmStatic
-  public fun <T> updateFabricScrollState(scrollView: T) where
-  T : HasFlingAnimator?,
-  T : HasScrollState?,
-  T : HasStateWrapper?,
-  T : ViewGroup {
+  public fun <T> updateFabricScrollState(scrollView: T)
+      where T : HasFlingAnimator?, T : HasScrollState?, T : HasStateWrapper?, T : ViewGroup {
     updateFabricScrollState(scrollView, scrollView.scrollX, scrollView.scrollY)
   }
 
   /**
    * Called on any stabilized onScroll change to propagate content offset value to a Shadow Node.
    */
-  public fun <T> updateFabricScrollState(scrollView: T, scrollX: Int, scrollY: Int) where
-  T : HasScrollState?,
-  T : HasStateWrapper?,
-  T : ViewGroup {
+  public fun <T> updateFabricScrollState(scrollView: T, scrollX: Int, scrollY: Int)
+      where T : HasScrollState?, T : HasStateWrapper?, T : ViewGroup {
     if (DEBUG_MODE) {
       FLog.i(
-          TAG, "updateFabricScrollState[%d] scrollX %d scrollY %d", scrollView.id, scrollX, scrollY)
+          TAG,
+          "updateFabricScrollState[%d] scrollX %d scrollY %d",
+          scrollView.id,
+          scrollX,
+          scrollY,
+      )
     }
     if (ViewUtil.getUIManagerType(scrollView.id) == UIManagerType.LEGACY) {
       return
@@ -340,10 +354,8 @@ public object ReactScrollViewHelper {
   }
 
   @JvmStatic
-  public fun <T> forceUpdateState(scrollView: T) where
-  T : HasScrollState?,
-  T : HasStateWrapper?,
-  T : ViewGroup {
+  public fun <T> forceUpdateState(scrollView: T)
+      where T : HasScrollState?, T : HasStateWrapper?, T : ViewGroup {
     val scrollState = scrollView.reactScrollViewScrollState
     val scrollAwayPaddingTop = scrollState.scrollAwayPaddingTop
     val scrollPos = scrollState.lastStateUpdateScroll
@@ -351,7 +363,12 @@ public object ReactScrollViewHelper {
     val scrollY = scrollPos.y
     if (DEBUG_MODE) {
       FLog.i(
-          TAG, "updateFabricScrollState[%d] scrollX %d scrollY %d", scrollView.id, scrollX, scrollY)
+          TAG,
+          "updateFabricScrollState[%d] scrollX %d scrollY %d",
+          scrollView.id,
+          scrollX,
+          scrollY,
+      )
     }
     val stateWrapper = scrollView.stateWrapper
     if (stateWrapper != null) {
@@ -359,22 +376,21 @@ public object ReactScrollViewHelper {
       newStateData.putDouble(CONTENT_OFFSET_LEFT, toDIPFromPixel(scrollX.toFloat()).toDouble())
       newStateData.putDouble(CONTENT_OFFSET_TOP, toDIPFromPixel(scrollY.toFloat()).toDouble())
       newStateData.putDouble(
-          SCROLL_AWAY_PADDING_TOP, toDIPFromPixel(scrollAwayPaddingTop.toFloat()).toDouble())
+          SCROLL_AWAY_PADDING_TOP,
+          toDIPFromPixel(scrollAwayPaddingTop.toFloat()).toDouble(),
+      )
       stateWrapper.updateState(newStateData)
     }
   }
 
   @JvmStatic
-  public fun <T> updateStateOnScrollChanged(
-      scrollView: T,
-      xVelocity: Float,
-      yVelocity: Float
-  ) where
-  T : HasFlingAnimator?,
-  T : HasScrollEventThrottle?,
-  T : HasScrollState?,
-  T : HasStateWrapper?,
-  T : ViewGroup {
+  public fun <T> updateStateOnScrollChanged(scrollView: T, xVelocity: Float, yVelocity: Float)
+      where
+          T : HasFlingAnimator?,
+          T : HasScrollEventThrottle?,
+          T : HasScrollState?,
+          T : HasStateWrapper?,
+          T : ViewGroup {
     // Race an UpdateState with every onScroll. This makes it more likely that, in Fabric,
     // when JS processes the scroll event, the C++ ShadowNode representation will have a
     // "more correct" scroll position. It will frequently be /incorrect/ but this decreases
@@ -383,11 +399,8 @@ public object ReactScrollViewHelper {
     emitScrollEvent(scrollView, xVelocity, yVelocity)
   }
 
-  public fun <T> registerFlingAnimator(scrollView: T) where
-  T : HasFlingAnimator?,
-  T : HasScrollState?,
-  T : HasStateWrapper?,
-  T : ViewGroup {
+  public fun <T> registerFlingAnimator(scrollView: T)
+      where T : HasFlingAnimator?, T : HasScrollState?, T : HasStateWrapper?, T : ViewGroup {
     scrollView
         .getFlingAnimator()
         .addListener(
@@ -400,22 +413,23 @@ public object ReactScrollViewHelper {
 
               override fun onAnimationEnd(animator: Animator) {
                 scrollView.reactScrollViewScrollState.isFinished = true
+                notifyUserDrivenScrollEnded(scrollView)
                 updateFabricScrollState(scrollView)
               }
 
               override fun onAnimationCancel(animator: Animator) {
                 scrollView.reactScrollViewScrollState.isCanceled = true
+                notifyUserDrivenScrollEnded(scrollView)
               }
 
               override fun onAnimationRepeat(animator: Animator) = Unit
-            })
+            }
+        )
   }
 
   @JvmStatic
-  public fun <T> dispatchMomentumEndOnAnimationEnd(scrollView: T) where
-  T : HasFlingAnimator?,
-  T : HasScrollEventThrottle?,
-  T : ViewGroup {
+  public fun <T> dispatchMomentumEndOnAnimationEnd(scrollView: T)
+      where T : HasFlingAnimator?, T : HasScrollEventThrottle?, T : ViewGroup {
     scrollView
         .getFlingAnimator()
         .addListener(
@@ -433,7 +447,8 @@ public object ReactScrollViewHelper {
               }
 
               override fun onAnimationRepeat(animator: Animator) = Unit
-            })
+            }
+        )
   }
 
   @JvmStatic
@@ -442,7 +457,7 @@ public object ReactScrollViewHelper {
       velocityX: Int,
       velocityY: Int,
       maximumOffsetX: Int,
-      maximumOffsetY: Int
+      maximumOffsetY: Int,
   ): Point where T : HasFlingAnimator?, T : HasScrollState?, T : ViewGroup {
     val scrollState = scrollView.reactScrollViewScrollState
     // ScrollView can *only* scroll for 250ms when using smoothScrollTo and there's
@@ -452,14 +467,22 @@ public object ReactScrollViewHelper {
     scroller.setFriction(1.0f - scrollState.decelerationRate)
 
     // predict where a fling would end up so we can scroll to the nearest snap offset
-    val width = scrollView.width - scrollView.getPaddingStart() - scrollView.getPaddingEnd()
+    val width = scrollView.width - scrollView.paddingStart - scrollView.paddingEnd
     val height = scrollView.height - scrollView.paddingBottom - scrollView.paddingTop
     val finalAnimatedPositionScroll = scrollState.finalAnimatedPositionScroll
     scroller.fling(
         getNextFlingStartValue(
-            scrollView, scrollView.scrollX, finalAnimatedPositionScroll.x, velocityX), // startX
+            scrollView,
+            scrollView.scrollX,
+            finalAnimatedPositionScroll.x,
+            velocityX,
+        ), // startX
         getNextFlingStartValue(
-            scrollView, scrollView.scrollY, finalAnimatedPositionScroll.y, velocityY), // startY
+            scrollView,
+            scrollView.scrollY,
+            finalAnimatedPositionScroll.y,
+            velocityY,
+        ), // startY
         velocityX, // velocityX
         velocityY, // velocityY
         0, // minX
@@ -467,8 +490,8 @@ public object ReactScrollViewHelper {
         0, // minY
         maximumOffsetY, // maxY
         width / 2, // overX
-        height / 2 // overY
-        )
+        height / 2, // overY
+    )
     return Point(scroller.finalX, scroller.finalY)
   }
 
@@ -506,7 +529,7 @@ public object ReactScrollViewHelper {
   public fun resolveAbsoluteDirection(
       @FocusRealDirection direction: Int,
       horizontal: Boolean,
-      layoutDirection: Int
+      layoutDirection: Int,
   ): Int {
     val rtl: Boolean = layoutDirection == View.LAYOUT_DIRECTION_RTL
 
@@ -526,7 +549,7 @@ public object ReactScrollViewHelper {
         scrollView: ViewGroup?,
         scrollEventType: ScrollEventType?,
         xVelocity: Float,
-        yVelocity: Float
+        yVelocity: Float,
     )
 
     public fun onLayout(scrollView: ViewGroup?)
@@ -575,7 +598,7 @@ public object ReactScrollViewHelper {
     /** Set the final scroll position after scrolling animation is finished */
     public fun setFinalAnimatedPositionScroll(
         finalAnimatedPositionScrollX: Int,
-        finalAnimatedPositionScrollY: Int
+        finalAnimatedPositionScrollY: Int,
     ): ReactScrollViewScrollState {
       finalAnimatedPositionScroll.set(finalAnimatedPositionScrollX, finalAnimatedPositionScrollY)
       return this
@@ -584,7 +607,7 @@ public object ReactScrollViewHelper {
     /** Set the Fabric state of last scroll position */
     public fun setLastStateUpdateScroll(
         lastStateUpdateScrollX: Int,
-        lastStateUpdateScrollY: Int
+        lastStateUpdateScrollY: Int,
     ): ReactScrollViewScrollState {
       lastStateUpdateScroll.set(lastStateUpdateScrollX, lastStateUpdateScrollY)
       return this

package/ReactAndroid/src/main/java/com/facebook/react/views/scroll/ReactScrollViewManager.kt

@@ -15,6 +15,7 @@ import com.facebook.react.bridge.ReadableArray
 import com.facebook.react.bridge.ReadableMap
 import com.facebook.react.bridge.ReadableType
 import com.facebook.react.bridge.RetryableMountingLayerException
+import com.facebook.react.internal.featureflags.ReactNativeFeatureFlags
 import com.facebook.react.module.annotations.ReactModule
 import com.facebook.react.uimanager.BackgroundStyleApplicator.setBorderColor
 import com.facebook.react.uimanager.BackgroundStyleApplicator.setBorderRadius
@@ -56,6 +57,24 @@ public open class ReactScrollViewManager
 constructor(private val fpsListener: FpsListener? = null) :
     ViewGroupManager<ReactScrollView>(), ScrollCommandHandler<ReactScrollView> {
 
+  init {
+    if (ReactNativeFeatureFlags.enableViewRecyclingForScrollView()) {
+      setupViewRecycling()
+    }
+  }
+
+  override fun prepareToRecycleView(
+      reactContext: ThemedReactContext,
+      view: ReactScrollView,
+  ): ReactScrollView? {
+    // BaseViewManager
+    val preparedView = super.prepareToRecycleView(reactContext, view)
+    if (preparedView != null) {
+      preparedView.recycleView()
+    }
+    return preparedView
+  }
+
   override fun getName(): String = REACT_CLASS
 
   public override fun createViewInstance(context: ThemedReactContext): ReactScrollView =
@@ -187,7 +206,8 @@ constructor(private val fpsListener: FpsListener? = null) :
   @Deprecated(
       message =
           "ReceiveCommand with an int commandId param is deprecated. Use the overload where commandId is a string.",
-      ReplaceWith("receiveCommand(scrollView, commandId, args)"))
+      ReplaceWith("receiveCommand(scrollView, commandId, args)"),
+  )
   override fun receiveCommand(scrollView: ReactScrollView, commandId: Int, args: ReadableArray?) {
     receiveCommand(this, scrollView, commandId, args)
   }
@@ -195,7 +215,7 @@ constructor(private val fpsListener: FpsListener? = null) :
   override fun receiveCommand(
       scrollView: ReactScrollView,
       commandId: String,
-      args: ReadableArray?
+      args: ReadableArray?,
   ) {
     receiveCommand<ReactScrollView>(this, scrollView, commandId, args)
   }
@@ -220,8 +240,10 @@ constructor(private val fpsListener: FpsListener? = null) :
               ViewProps.BORDER_TOP_LEFT_RADIUS,
               ViewProps.BORDER_TOP_RIGHT_RADIUS,
               ViewProps.BORDER_BOTTOM_RIGHT_RADIUS,
-              ViewProps.BORDER_BOTTOM_LEFT_RADIUS],
-      defaultFloat = Float.NaN)
+              ViewProps.BORDER_BOTTOM_LEFT_RADIUS,
+          ],
+      defaultFloat = Float.NaN,
+  )
   public fun setBorderRadius(view: ReactScrollView?, index: Int, borderRadius: Float) {
     if (view != null) {
       val radius =
@@ -246,8 +268,10 @@ constructor(private val fpsListener: FpsListener? = null) :
               ViewProps.BORDER_LEFT_WIDTH,
               ViewProps.BORDER_RIGHT_WIDTH,
               ViewProps.BORDER_TOP_WIDTH,
-              ViewProps.BORDER_BOTTOM_WIDTH],
-      defaultFloat = Float.NaN)
+              ViewProps.BORDER_BOTTOM_WIDTH,
+          ],
+      defaultFloat = Float.NaN,
+  )
   public fun setBorderWidth(view: ReactScrollView?, index: Int, width: Float) {
     if (view != null) {
       setBorderWidth(view, LogicalEdge.entries[index], width)
@@ -261,8 +285,10 @@ constructor(private val fpsListener: FpsListener? = null) :
               "borderLeftColor",
               "borderRightColor",
               "borderTopColor",
-              "borderBottomColor"],
-      customType = "Color")
+              "borderBottomColor",
+          ],
+      customType = "Color",
+  )
   @Suppress("UNUSED_PARAMETER")
   public fun setBorderColor(view: ReactScrollView?, index: Int, color: Int?) {
     if (view != null) {
@@ -282,7 +308,8 @@ constructor(private val fpsListener: FpsListener? = null) :
     val child =
         scrollView.getChildAt(0)
             ?: throw RetryableMountingLayerException(
-                "scrollToEnd called on ScrollView without child")
+                "scrollToEnd called on ScrollView without child"
+            )
 
     // ScrollView always has one child - the scrollable area
     val bottom = child.height + scrollView.paddingBottom
@@ -324,13 +351,13 @@ constructor(private val fpsListener: FpsListener? = null) :
         // no-op
       }
     }
-    if (view.getFadingEdgeLengthStart() > 0 || view.getFadingEdgeLengthEnd() > 0) {
-      view.setVerticalFadingEdgeEnabled(true)
+    if (view.fadingEdgeLengthStart > 0 || view.fadingEdgeLengthEnd > 0) {
+      view.isVerticalFadingEdgeEnabled = true
       view.setFadingEdgeLength(
-          Math.round(
-              Math.max(view.getFadingEdgeLengthStart(), view.getFadingEdgeLengthEnd()).dpToPx()))
+          Math.round(Math.max(view.fadingEdgeLengthStart, view.fadingEdgeLengthEnd).dpToPx())
+      )
     } else {
-      view.setVerticalFadingEdgeEnabled(false)
+      view.isVerticalFadingEdgeEnabled = false
       view.setFadingEdgeLength(0)
     }
   }
@@ -344,7 +371,8 @@ constructor(private val fpsListener: FpsListener? = null) :
   public fun setMaintainVisibleContentPosition(view: ReactScrollView, value: ReadableMap?) {
     if (value != null) {
       view.setMaintainVisibleContentPosition(
-          MaintainVisibleScrollPositionHelper.Config.fromReadableMap(value))
+          MaintainVisibleScrollPositionHelper.Config.fromReadableMap(value)
+      )
     } else {
       view.setMaintainVisibleContentPosition(null)
     }
@@ -353,7 +381,7 @@ constructor(private val fpsListener: FpsListener? = null) :
   override fun updateState(
       view: ReactScrollView,
       props: ReactStylesDiffMap,
-      stateWrapper: StateWrapper
+      stateWrapper: StateWrapper,
   ): Any? {
     view.setStateWrapper(stateWrapper)
     return null
@@ -413,6 +441,7 @@ constructor(private val fpsListener: FpsListener? = null) :
             getJSEventName(ScrollEventType.MOMENTUM_BEGIN) to
                 mapOf("registrationName" to "onMomentumScrollBegin"),
             getJSEventName(ScrollEventType.MOMENTUM_END) to
-                mapOf("registrationName" to "onMomentumScrollEnd"))
+                mapOf("registrationName" to "onMomentumScrollEnd"),
+        )
   }
 }

package/ReactAndroid/src/main/java/com/facebook/react/views/scroll/ScrollEvent.kt

@@ -144,13 +144,16 @@ public class ScrollEvent private constructor() : Event<ScrollEvent>() {
               contentWidth,
               contentHeight,
               scrollViewWidth,
-              scrollViewHeight)
+              scrollViewHeight,
+          )
         }
 
     @Deprecated(
         "Use the obtain version that explicitly takes surfaceId as an argument",
         ReplaceWith(
-            "obtain(surfaceId, viewTag, scrollEventType, scrollX, scrollY, xVelocity, yVelocity, contentWidth, contentHeight, scrollViewWidth, scrollViewHeight)"))
+            "obtain(surfaceId, viewTag, scrollEventType, scrollX, scrollY, xVelocity, yVelocity, contentWidth, contentHeight, scrollViewWidth, scrollViewHeight)"
+        ),
+    )
     @JvmStatic
     public fun obtain(
         viewTag: Int,
@@ -162,7 +165,7 @@ public class ScrollEvent private constructor() : Event<ScrollEvent>() {
         contentWidth: Int,
         contentHeight: Int,
         scrollViewWidth: Int,
-        scrollViewHeight: Int
+        scrollViewHeight: Int,
     ): ScrollEvent =
         obtain(
             ViewUtil.NO_SURFACE_ID,