Skip the unchanged scroll state update when a ScrollView mounts on Android

## Summary:

On Android, every `ScrollView` commits one state update on mount that changes nothing. `onLayout` calls `scrollTo`, which calls `ReactScrollViewHelper.updateFabricScrollState`. That method dedupes against `lastStateUpdateScroll`, but this starts at `(-1, -1)`, so the first offset always gets through, even when it's the `(0, 0)` already in the state. The update then runs a full commit on the JS thread (clone, layout and differ) and sends an `UpdateState` item back to Java. On iOS, `_updateStateWithContentOffset` already skips an update when the offset hasn't changed.

Now, before a view's first update, `updateFabricScrollState` reads the offset from the state into `lastStateUpdateScroll`, and the existing dedupe does the rest. This costs one state read per view, not one per scroll frame.

I didn't start `lastStateUpdateScroll` at `(0, 0)`, because a view created for a state that already holds another offset would then skip the update that corrects the state.

## Changelog:

[ANDROID] [CHANGED] - `ScrollView` no longer commits an unchanged scroll state when it mounts

## Test Plan:

Unit tests: the new `ReactScrollViewHelperStateTest` covers a first update that matches the state (not sent), one that differs from it (sent), one without state data (sent), and later updates (sent once per offset, with one state read). The two tests that expect a skipped update fail without this change.

```
./gradlew :packages:react-native:ReactAndroid:testDebugUnitTest --tests 'com.facebook.react.views.scroll.*'
```

25 tests, 0 failures. `yarn format-kotlin` makes no further changes.

Behavior: on a Galaxy A16, a temporary Playground screen read a marker's position with `measureInWindow`, and both builds reported the same positions at every step:
- after mount with `contentOffset`, vertical and horizontal
- after `scrollTo`, vertical and horizontal
- after scrolling back to 0
- after toggling `display: none` on the parent

Measurements on a Galaxy A16 (Android 16): two release RNTester APKs built from this commit's base, one with and one without this change, with default feature flags, compiled with `cmd package compile -m speed`. A temporary Playground screen mounts and unmounts the scenario 12 times. JS thread CPU comes from `/proc/<pid>/task/<tid>/stat`. The APKs were installed in alternating blocks, A/B/B/A twice, which gives 4 fresh processes per arm for each scenario. The table shows medians per mount and unmount:

| Scenario | Without this change | With this change | Change |
|---|--:|--:|--:|
| 100 `ScrollView`s, per `ScrollView` | 1050 µs | 554 µs | −47% |
| Vertical `ScrollView` with 5 horizontal ones and 40 cards | 86.6 ms | 82.5 ms | −4.8% |
| One `ScrollView` with 300 cards | 307.0 ms | 306.2 ms | no change |
| `FlatList` with 40 cards | 92.0 ms | 92.9 ms | no change |

That's about 0.5–0.7 ms of JS time per `ScrollView` on this phone, so it only shows on screens with several of them. The 100-`ScrollView` case is artificial and shows the cost of each commit. In the second scenario the ranges overlap slightly (85.0–88.3 ms and 79.2–85.8 ms). UI thread time didn't change in any scenario.

Not tested on a device: `enableViewRecyclingForScrollView` and `enableViewCulling`. The `display: none` toggle may not recreate the view, so the case of a state that already holds another offset is covered only by the unit test. With `enableViewCulling` or `useTraitHiddenOnAndroid` on, `loadFabricScrollState` already sets `lastStateUpdateScroll`, so the new read doesn't run after that.

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Differential Revision: D129045292

Pull Request resolved: #59719

Author: hryhoriiK97

packages/react-native/ReactAndroid/src/main/java/com/facebook/react/views/scroll/ReactScrollViewHelper.kt

@@ -40,6 +40,7 @@ public object ReactScrollViewHelper {
   private val TAG = ReactScrollView::class.java.simpleName
   private val DEBUG_MODE = false // ReactBuildConfig.DEBUG
 
+  private const val UNSET_SCROLL_POSITION = -1
   private const val CONTENT_OFFSET_LEFT = "contentOffsetLeft"
   private const val CONTENT_OFFSET_TOP = "contentOffsetTop"
   private const val SCROLL_AWAY_PADDING_TOP = "scrollAwayPaddingTop"
@@ -373,6 +374,17 @@ public object ReactScrollViewHelper {
     // User driven scrolling should disable scroll state updates coming from Fabric
     scrollState.isUpdatedByScroll = true
 
+    // Until a view sends its first update it doesn't know the offset in its state. On mount that
+    // offset is usually already correct, and sending it again would only commit an unchanged tree.
+    if (scrollState.lastStateUpdateScroll.equals(UNSET_SCROLL_POSITION, UNSET_SCROLL_POSITION)) {
+      scrollView.stateWrapper?.stateData?.let { stateData ->
+        scrollState.setLastStateUpdateScroll(
+            toPixelFromDIP(stateData.getDouble(CONTENT_OFFSET_LEFT)).toInt(),
+            toPixelFromDIP(stateData.getDouble(CONTENT_OFFSET_TOP)).toInt(),
+        )
+      }
+    }
+
     // Dedupe events to reduce JNI traffic
     if (scrollState.lastStateUpdateScroll.equals(scrollX, scrollY)) {
       return
@@ -660,7 +672,7 @@ public object ReactScrollViewHelper {
       /** Get the padding on the bottom for tab bar */
       var scrollAwayPaddingBottom: Int = 0,
       /** Get the Fabric state of last scroll position */
-      val lastStateUpdateScroll: Point = Point(-1, -1),
+      val lastStateUpdateScroll: Point = Point(UNSET_SCROLL_POSITION, UNSET_SCROLL_POSITION),
       /** Get true if the previous animation was canceled */
       var isCanceled: Boolean = false,
       /** Get true if previous animation was finished */

packages/react-native/ReactAndroid/src/test/java/com/facebook/react/views/scroll/ReactScrollViewHelperStateTest.kt

@@ -0,0 +1,119 @@
+/*
+ * 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.scroll
+
+import android.annotation.SuppressLint
+import android.util.DisplayMetrics
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReactTestHelper.createTestReactApplicationContext
+import com.facebook.react.bridge.ReadableNativeMap
+import com.facebook.react.internal.featureflags.ReactNativeFeatureFlagsForTests
+import com.facebook.react.uimanager.DisplayMetricsHolder
+import com.facebook.react.uimanager.StateWrapper
+import com.facebook.react.uimanager.ThemedReactContext
+import com.facebook.testutils.shadows.ShadowNativeLoader
+import com.facebook.testutils.shadows.ShadowNativeMap
+import com.facebook.testutils.shadows.ShadowReadableNativeMap
+import com.facebook.testutils.shadows.ShadowSoLoader
+import com.facebook.testutils.shadows.ShadowWritableNativeMap
+import org.junit.After
+import org.junit.Before
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.mockito.kotlin.any
+import org.mockito.kotlin.doReturn
+import org.mockito.kotlin.mock
+import org.mockito.kotlin.never
+import org.mockito.kotlin.times
+import org.mockito.kotlin.verify
+import org.robolectric.RobolectricTestRunner
+import org.robolectric.annotation.Config
+
+/** Verifies when a ScrollView sends its scroll offset to the Fabric state. */
+@SuppressLint("DeprecatedClass", "DeprecatedMethod")
+@RunWith(RobolectricTestRunner::class)
+@Config(
+    shadows =
+        [
+            ShadowNativeLoader::class,
+            ShadowSoLoader::class,
+            ShadowNativeMap::class,
+            ShadowReadableNativeMap::class,
+            ShadowWritableNativeMap::class,
+        ],
+)
+class ReactScrollViewHelperStateTest {
+
+  private lateinit var view: ReactScrollView
+
+  @Before
+  fun setup() {
+    ReactNativeFeatureFlagsForTests.setUp()
+    val context: ReactApplicationContext = createTestReactApplicationContext()
+    DisplayMetricsHolder.setScreenDisplayMetrics(DisplayMetrics().apply { density = 1f })
+    view =
+        ReactScrollViewManager().createViewInstance(ThemedReactContext(context, context, null, -1))
+  }
+
+  @After
+  fun teardown() {
+    DisplayMetricsHolder.setScreenDisplayMetrics(null)
+  }
+
+  private fun stateWrapperWithOffset(x: Double, y: Double): StateWrapper {
+    val stateData =
+        mock<ReadableNativeMap> {
+          on { getDouble("contentOffsetLeft") } doReturn x
+          on { getDouble("contentOffsetTop") } doReturn y
+        }
+    return mock { on { this.stateData } doReturn stateData }
+  }
+
+  @Test
+  fun testFirstUpdateMatchingTheStateIsNotSent() {
+    val stateWrapper = stateWrapperWithOffset(0.0, 0.0)
+    view.stateWrapper = stateWrapper
+
+    ReactScrollViewHelper.updateFabricScrollState(view, 0, 0)
+
+    verify(stateWrapper, never()).updateState(any())
+  }
+
+  @Test
+  fun testFirstUpdateDifferingFromTheStateIsSent() {
+    val stateWrapper = stateWrapperWithOffset(0.0, 500.0)
+    view.stateWrapper = stateWrapper
+
+    ReactScrollViewHelper.updateFabricScrollState(view, 0, 0)
+
+    verify(stateWrapper, times(1)).updateState(any())
+  }
+
+  @Test
+  fun testFirstUpdateIsSentWithoutStateData() {
+    val stateWrapper = mock<StateWrapper> { on { stateData } doReturn null }
+    view.stateWrapper = stateWrapper
+
+    ReactScrollViewHelper.updateFabricScrollState(view, 0, 0)
+
+    verify(stateWrapper, times(1)).updateState(any())
+  }
+
+  @Test
+  fun testLaterUpdatesAreSentOncePerOffset() {
+    val stateWrapper = stateWrapperWithOffset(0.0, 0.0)
+    view.stateWrapper = stateWrapper
+
+    ReactScrollViewHelper.updateFabricScrollState(view, 0, 0)
+    ReactScrollViewHelper.updateFabricScrollState(view, 0, 100)
+    ReactScrollViewHelper.updateFabricScrollState(view, 0, 100)
+
+    verify(stateWrapper, times(1)).updateState(any())
+    verify(stateWrapper, times(1)).stateData
+  }
+}