react-native-tvos 0.76.3-0 → 0.77.0-0rc1

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

@@ -19,7 +19,6 @@ import com.facebook.react.bridge.ReactContext
 import com.facebook.react.bridge.WritableMap
 import com.facebook.react.bridge.WritableNativeMap
 import com.facebook.react.common.ReactConstants
-import com.facebook.react.internal.featureflags.ReactNativeFeatureFlags
 import com.facebook.react.uimanager.PixelUtil.toDIPFromPixel
 import com.facebook.react.uimanager.StateWrapper
 import com.facebook.react.uimanager.UIManagerHelper
@@ -30,8 +29,9 @@ import java.util.concurrent.CopyOnWriteArrayList
 
 /** Helper class that deals with emitting Scroll Events. */
 public object ReactScrollViewHelper {
-  private val TAG = ReactHorizontalScrollView::class.java.simpleName
+  private val TAG = ReactScrollView::class.java.simpleName
   private val DEBUG_MODE = false // ReactBuildConfig.DEBUG
+
   private const val CONTENT_OFFSET_LEFT = "contentOffsetLeft"
   private const val CONTENT_OFFSET_TOP = "contentOffsetTop"
   private const val SCROLL_AWAY_PADDING_TOP = "scrollAwayPaddingTop"
@@ -47,6 +47,7 @@ public object ReactScrollViewHelper {
 
   // Support global native listeners for scroll events
   private val scrollListeners = CopyOnWriteArrayList<WeakReference<ScrollListener>>()
+  private val layoutChangeListeners = CopyOnWriteArrayList<WeakReference<LayoutChangeListener>>()
 
   // If all else fails, this is the hardcoded value in OverScroller.java, in AOSP.
   // The default is defined here (as of this diff):
@@ -102,7 +103,6 @@ public object ReactScrollViewHelper {
       scrollEventType: ScrollEventType,
       xVelocity: Float,
       yVelocity: Float,
-      experimental_isSynchronous: Boolean = false,
   ) where T : HasScrollEventThrottle?, T : ViewGroup {
     val now = System.currentTimeMillis()
     // Throttle the scroll event if scrollEventThrottle is set to be equal or more than 17 ms.
@@ -137,8 +137,7 @@ public object ReactScrollViewHelper {
               contentView.width,
               contentView.height,
               scrollView.width,
-              scrollView.height,
-              experimental_isSynchronous))
+              scrollView.height))
       scrollView.lastScrollDispatchTime = now
     }
   }
@@ -151,6 +150,13 @@ public object ReactScrollViewHelper {
     }
   }
 
+  @JvmStatic
+  public fun emitLayoutChangeEvent(scrollView: ViewGroup) {
+    for (listener in layoutChangeListeners) {
+      listener.get()?.onLayoutChange(scrollView)
+    }
+  }
+
   @JvmStatic
   public fun parseOverScrollMode(jsOverScrollMode: String?): Int {
     return if (jsOverScrollMode == null || jsOverScrollMode == AUTO) {
@@ -214,6 +220,16 @@ public object ReactScrollViewHelper {
     scrollListeners.remove(WeakReference(listener))
   }
 
+  @JvmStatic
+  public fun addLayoutChangeListener(listener: LayoutChangeListener) {
+    layoutChangeListeners.add(WeakReference(listener))
+  }
+
+  @JvmStatic
+  public fun removeLayoutChangeListener(listener: LayoutChangeListener) {
+    layoutChangeListeners.remove(WeakReference(listener))
+  }
+
   /**
    * Scroll the given view to the location (x, y), with provided initial velocity. This method works
    * by calculate the "would be" initial velocity with internal friction to move to the point (x,
@@ -246,9 +262,6 @@ public object ReactScrollViewHelper {
     if (scrollY != y) {
       scrollView.startFlingAnimator(scrollY, y)
     }
-    if (ReactNativeFeatureFlags.fixIncorrectScrollViewStateUpdateOnAndroid()) {
-      updateFabricScrollState<T>(scrollView, x, y)
-    }
   }
 
   /** Get current position or position after current animation finishes, if any. */
@@ -318,25 +331,9 @@ public object ReactScrollViewHelper {
     val scrollPos = scrollState.lastStateUpdateScroll
     val scrollX = scrollPos.x
     val scrollY = scrollPos.y
-    val layoutDirection = scrollState.layoutDirection
-    val fabricScrollX =
-        if (layoutDirection == View.LAYOUT_DIRECTION_RTL) {
-          // getScrollX returns offset from left even when layout direction is RTL.
-          // The following line calculates offset from right.
-          val child = scrollView.getChildAt(0)
-          val contentWidth = child?.width ?: 0
-          -(contentWidth - scrollX - scrollView.width)
-        } else {
-          scrollX
-        }
     if (DEBUG_MODE) {
       FLog.i(
-          TAG,
-          "updateFabricScrollState[%d] scrollX %d scrollY %d fabricScrollX %d",
-          scrollView.id,
-          scrollX,
-          scrollY,
-          fabricScrollX)
+          TAG, "updateFabricScrollState[%d] scrollX %d scrollY %d", scrollView.id, scrollX, scrollY)
     }
     val stateWrapper = scrollView.stateWrapper
     if (stateWrapper != null) {
@@ -359,29 +356,13 @@ public object ReactScrollViewHelper {
   T : HasScrollEventThrottle?,
   T : HasScrollState?,
   T : HasStateWrapper?,
-  T : ViewGroup {
-    updateStateOnScrollChanged(scrollView, xVelocity, yVelocity, false)
-  }
-
-  @JvmStatic
-  public fun <T> updateStateOnScrollChanged(
-      scrollView: T,
-      xVelocity: Float,
-      yVelocity: Float,
-      experimental_synchronous: Boolean,
-  ) 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
     // the error as much as possible.
     updateFabricScrollState(scrollView, scrollView.scrollX, scrollView.scrollY)
-    emitScrollEvent(
-        scrollView, ScrollEventType.SCROLL, xVelocity, yVelocity, experimental_synchronous)
+    emitScrollEvent(scrollView, xVelocity, yVelocity)
   }
 
   public fun <T> registerFlingAnimator(scrollView: T) where
@@ -412,6 +393,31 @@ public object ReactScrollViewHelper {
             })
   }
 
+  @JvmStatic
+  public fun <T> dispatchMomentumEndOnAnimationEnd(scrollView: T) where
+  T : HasFlingAnimator?,
+  T : HasScrollEventThrottle?,
+  T : ViewGroup {
+    scrollView
+        .getFlingAnimator()
+        .addListener(
+            object : Animator.AnimatorListener {
+              override fun onAnimationStart(animator: Animator) = Unit
+
+              override fun onAnimationEnd(animator: Animator) {
+                emitScrollMomentumEndEvent(scrollView)
+                animator.removeListener(this)
+              }
+
+              override fun onAnimationCancel(animator: Animator) {
+                emitScrollMomentumEndEvent(scrollView)
+                animator.removeListener(this)
+              }
+
+              override fun onAnimationRepeat(animator: Animator) = Unit
+            })
+  }
+
   @JvmStatic
   public fun <T> predictFinalScrollPosition(
       scrollView: T,
@@ -459,6 +465,10 @@ public object ReactScrollViewHelper {
     public fun onLayout(scrollView: ViewGroup?)
   }
 
+  public interface LayoutChangeListener {
+    public fun onLayoutChange(scrollView: ViewGroup)
+  }
+
   public interface HasStateWrapper {
     public val stateWrapper: StateWrapper?
   }
@@ -481,13 +491,7 @@ public object ReactScrollViewHelper {
     }
   }
 
-  public class ReactScrollViewScrollState(
-      /**
-       * Get the layout direction. Can be either scrollView.LAYOUT_DIRECTION_RTL (1) or
-       * scrollView.LAYOUT_DIRECTION_LTR (0). If the value is -1, it means unknown layout.
-       */
-      public val layoutDirection: Int
-  ) {
+  public class ReactScrollViewScrollState() {
 
     /** Get the position after current animation is finished */
     public val finalAnimatedPositionScroll: Point = Point()

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

@@ -9,7 +9,6 @@ package com.facebook.react.views.scroll;
 
 import android.graphics.Color;
 import android.view.View;
-import androidx.annotation.ColorInt;
 import androidx.annotation.Nullable;
 import androidx.core.view.ViewCompat;
 import com.facebook.infer.annotation.Nullsafe;
@@ -17,7 +16,6 @@ import com.facebook.react.bridge.ReadableArray;
 import com.facebook.react.bridge.ReadableMap;
 import com.facebook.react.bridge.RetryableMountingLayerException;
 import com.facebook.react.common.MapBuilder;
-import com.facebook.react.internal.featureflags.ReactNativeFeatureFlags;
 import com.facebook.react.module.annotations.ReactModule;
 import com.facebook.react.uimanager.BackgroundStyleApplicator;
 import com.facebook.react.uimanager.LengthPercentage;
@@ -169,11 +167,6 @@ public class ReactScrollViewManager extends ViewGroupManager<ReactScrollView>
     view.setScrollPerfTag(scrollPerfTag);
   }
 
-  @ReactProp(name = "enableSyncOnScroll")
-  public void setEnableSyncOnScroll(ReactScrollView view, boolean value) {
-    view.setEnableSyncOnScroll(value);
-  }
-
   @ReactProp(name = "pagingEnabled")
   public void setPagingEnabled(ReactScrollView view, boolean pagingEnabled) {
     view.setPagingEnabled(pagingEnabled);
@@ -245,36 +238,20 @@ public class ReactScrollViewManager extends ViewGroupManager<ReactScrollView>
       },
       defaultFloat = Float.NaN)
   public void setBorderRadius(ReactScrollView view, int index, float borderRadius) {
-    if (ReactNativeFeatureFlags.enableBackgroundStyleApplicator()) {
-      @Nullable
-      LengthPercentage radius =
-          Float.isNaN(borderRadius)
-              ? null
-              : new LengthPercentage(borderRadius, LengthPercentageType.POINT);
-      BackgroundStyleApplicator.setBorderRadius(view, BorderRadiusProp.values()[index], radius);
-    } else {
-      if (!Float.isNaN(borderRadius)) {
-        borderRadius = PixelUtil.toPixelFromDIP(borderRadius);
-      }
-
-      if (index == 0) {
-        view.setBorderRadius(borderRadius);
-      } else {
-        view.setBorderRadius(borderRadius, index - 1);
-      }
-    }
+    @Nullable
+    LengthPercentage radius =
+        Float.isNaN(borderRadius)
+            ? null
+            : new LengthPercentage(borderRadius, LengthPercentageType.POINT);
+    BackgroundStyleApplicator.setBorderRadius(view, BorderRadiusProp.values()[index], radius);
   }
 
   @ReactProp(name = "borderStyle")
   public void setBorderStyle(ReactScrollView view, @Nullable String borderStyle) {
-    if (ReactNativeFeatureFlags.enableBackgroundStyleApplicator()) {
-      @Nullable
-      BorderStyle parsedBorderStyle =
-          borderStyle == null ? null : BorderStyle.fromString(borderStyle);
-      BackgroundStyleApplicator.setBorderStyle(view, parsedBorderStyle);
-    } else {
-      view.setBorderStyle(borderStyle);
-    }
+    @Nullable
+    BorderStyle parsedBorderStyle =
+        borderStyle == null ? null : BorderStyle.fromString(borderStyle);
+    BackgroundStyleApplicator.setBorderStyle(view, parsedBorderStyle);
   }
 
   @ReactPropGroup(
@@ -287,15 +264,7 @@ public class ReactScrollViewManager extends ViewGroupManager<ReactScrollView>
       },
       defaultFloat = Float.NaN)
   public void setBorderWidth(ReactScrollView view, int index, float width) {
-    if (ReactNativeFeatureFlags.enableBackgroundStyleApplicator()) {
-      BackgroundStyleApplicator.setBorderWidth(view, LogicalEdge.values()[index], width);
-    } else {
-      if (!Float.isNaN(width)) {
-        width = PixelUtil.toPixelFromDIP(width);
-      }
-
-      view.setBorderWidth(SPACING_TYPES[index], width);
-    }
+    BackgroundStyleApplicator.setBorderWidth(view, LogicalEdge.values()[index], width);
   }
 
   @ReactPropGroup(
@@ -308,11 +277,7 @@ public class ReactScrollViewManager extends ViewGroupManager<ReactScrollView>
       },
       customType = "Color")
   public void setBorderColor(ReactScrollView view, int index, @Nullable Integer color) {
-    if (ReactNativeFeatureFlags.enableBackgroundStyleApplicator()) {
-      BackgroundStyleApplicator.setBorderColor(view, LogicalEdge.ALL, color);
-    } else {
-      view.setBorderColor(SPACING_TYPES[index], color);
-    }
+    BackgroundStyleApplicator.setBorderColor(view, LogicalEdge.ALL, color);
   }
 
   @ReactProp(name = "overflow")
@@ -372,22 +337,6 @@ public class ReactScrollViewManager extends ViewGroupManager<ReactScrollView>
     }
   }
 
-  @ReactProp(name = ViewProps.BOX_SHADOW, customType = "BoxShadow")
-  public void setBoxShadow(ReactScrollView view, @Nullable ReadableArray shadows) {
-    if (ReactNativeFeatureFlags.enableBackgroundStyleApplicator()) {
-      BackgroundStyleApplicator.setBoxShadow(view, shadows);
-    }
-  }
-
-  @Override
-  public void setBackgroundColor(ReactScrollView view, @ColorInt int backgroundColor) {
-    if (ReactNativeFeatureFlags.enableBackgroundStyleApplicator()) {
-      BackgroundStyleApplicator.setBackgroundColor(view, backgroundColor);
-    } else {
-      super.setBackgroundColor(view, backgroundColor);
-    }
-  }
-
   @Override
   public @Nullable Object updateState(
       ReactScrollView view, ReactStylesDiffMap props, StateWrapper stateWrapper) {

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

@@ -7,6 +7,7 @@
 
 package com.facebook.react.views.scroll
 
+import android.os.SystemClock
 import androidx.core.util.Pools.SynchronizedPool
 import com.facebook.infer.annotation.Assertions
 import com.facebook.react.bridge.Arguments
@@ -27,7 +28,7 @@ public class ScrollEvent private constructor() : Event<ScrollEvent>() {
   private var scrollViewWidth = 0
   private var scrollViewHeight = 0
   private var scrollEventType: ScrollEventType? = null
-  private var experimental_isSynchronous = false
+  private var timestamp: Long = 0
 
   override fun onDispose() {
     try {
@@ -51,7 +52,6 @@ public class ScrollEvent private constructor() : Event<ScrollEvent>() {
       contentHeight: Int,
       scrollViewWidth: Int,
       scrollViewHeight: Int,
-      experimental_isSynchronous: Boolean,
   ) {
     super.init(surfaceId, viewTag)
     this.scrollEventType = scrollEventType
@@ -63,7 +63,7 @@ public class ScrollEvent private constructor() : Event<ScrollEvent>() {
     this.contentHeight = contentHeight
     this.scrollViewWidth = scrollViewWidth
     this.scrollViewHeight = scrollViewHeight
-    this.experimental_isSynchronous = experimental_isSynchronous
+    this.timestamp = SystemClock.uptimeMillis()
   }
 
   override fun getEventName(): String =
@@ -71,10 +71,6 @@ public class ScrollEvent private constructor() : Event<ScrollEvent>() {
 
   override fun canCoalesce(): Boolean = scrollEventType == ScrollEventType.SCROLL
 
-  override fun experimental_isSynchronous(): Boolean {
-    return experimental_isSynchronous
-  }
-
   override fun getEventData(): WritableMap {
     val contentInset = Arguments.createMap()
     contentInset.putDouble("top", 0.0)
@@ -100,6 +96,7 @@ public class ScrollEvent private constructor() : Event<ScrollEvent>() {
     event.putMap("layoutMeasurement", layoutMeasurement)
     event.putMap("velocity", velocity)
     event.putInt("target", viewTag)
+    event.putDouble("timestamp", timestamp.toDouble())
     event.putBoolean("responderIgnoreScroll", true)
     return event
   }
@@ -121,7 +118,6 @@ public class ScrollEvent private constructor() : Event<ScrollEvent>() {
         contentHeight: Int,
         scrollViewWidth: Int,
         scrollViewHeight: Int,
-        experimental_isSynchronous: Boolean,
     ): ScrollEvent =
         (EVENTS_POOL.acquire() ?: ScrollEvent()).apply {
           init(
@@ -135,8 +131,7 @@ public class ScrollEvent private constructor() : Event<ScrollEvent>() {
               contentWidth,
               contentHeight,
               scrollViewWidth,
-              scrollViewHeight,
-              experimental_isSynchronous)
+              scrollViewHeight)
         }
 
     @Deprecated(
@@ -168,7 +163,6 @@ public class ScrollEvent private constructor() : Event<ScrollEvent>() {
             contentHeight,
             scrollViewWidth,
             scrollViewHeight,
-            false,
         )
   }
 }

package/ReactAndroid/src/main/java/com/facebook/react/views/swiperefresh/ReactSwipeRefreshLayout.kt

@@ -0,0 +1,131 @@
+/*
+ * 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.swiperefresh
+
+import android.view.MotionEvent
+import android.view.ViewConfiguration
+import androidx.swiperefreshlayout.widget.SwipeRefreshLayout
+import com.facebook.react.bridge.ReactContext
+import com.facebook.react.uimanager.PixelUtil
+import com.facebook.react.uimanager.events.NativeGestureUtil
+
+/** Basic extension of [SwipeRefreshLayout] with ReactNative-specific functionality. */
+public class ReactSwipeRefreshLayout(reactContext: ReactContext) :
+    SwipeRefreshLayout(reactContext) {
+
+  private var didLayout: Boolean = false
+  private var refreshing: Boolean = false
+  private var progressViewOffset: Float = 0f
+  private val touchSlop: Int = ViewConfiguration.get(reactContext).scaledTouchSlop
+  private var prevTouchX: Float = 0f
+  private var intercepted: Boolean = false
+  private var nativeGestureStarted: Boolean = false
+
+  public override fun setRefreshing(refreshing: Boolean) {
+    this.refreshing = refreshing
+
+    // `setRefreshing` must be called after the initial layout otherwise it
+    // doesn't work when mounting the component with `refreshing = true`.
+    // Known Android issue: https://code.google.com/p/android/issues/detail?id=77712
+    if (didLayout) {
+      super.setRefreshing(refreshing)
+    }
+  }
+
+  public fun setProgressViewOffset(offset: Float) {
+    progressViewOffset = offset
+
+    // The view must be measured before calling `getProgressCircleDiameter` so
+    // don't do it before the initial layout.
+    if (didLayout) {
+      val diameter = progressCircleDiameter
+      val start = Math.round(PixelUtil.toPixelFromDIP(offset)) - diameter
+      val end = Math.round(PixelUtil.toPixelFromDIP(offset + DEFAULT_CIRCLE_TARGET)) - diameter
+      setProgressViewOffset(false, start, end)
+    }
+  }
+
+  public override fun onLayout(changed: Boolean, left: Int, top: Int, right: Int, bottom: Int) {
+    super.onLayout(changed, left, top, right, bottom)
+
+    if (!didLayout) {
+      didLayout = true
+
+      // Update values that must be set after initial layout.
+      setProgressViewOffset(progressViewOffset)
+      setRefreshing(refreshing)
+    }
+  }
+
+  public override fun canChildScrollUp(): Boolean {
+    val firstChild = getChildAt(0)
+    return firstChild?.canScrollVertically(-1) ?: super.canChildScrollUp()
+  }
+
+  /**
+   * [SwipeRefreshLayout] overrides [ViewGroup.requestDisallowInterceptTouchEvent] and swallows it.
+   * This means that any component underneath SwipeRefreshLayout will now interact incorrectly with
+   * Views that are above SwipeRefreshLayout. We fix that by transmitting the call to this View's
+   * parents.
+   */
+  public override fun requestDisallowInterceptTouchEvent(disallowIntercept: Boolean) {
+    parent?.requestDisallowInterceptTouchEvent(disallowIntercept)
+  }
+
+  public override fun onInterceptTouchEvent(ev: MotionEvent): Boolean {
+    if (shouldInterceptTouchEvent(ev) && super.onInterceptTouchEvent(ev)) {
+      NativeGestureUtil.notifyNativeGestureStarted(this, ev)
+      nativeGestureStarted = true
+
+      // If the pull-to-refresh gesture is interrupted by a parent with its own
+      // onInterceptTouchEvent then the refresh indicator gets stuck on-screen
+      // so we ask the parent to not intercept this touch event after it started
+      parent?.requestDisallowInterceptTouchEvent(true)
+
+      return true
+    }
+    return false
+  }
+
+  public override fun onTouchEvent(ev: MotionEvent): Boolean {
+    if (ev.actionMasked == MotionEvent.ACTION_UP && nativeGestureStarted) {
+      NativeGestureUtil.notifyNativeGestureEnded(this, ev)
+      nativeGestureStarted = false
+    }
+    return super.onTouchEvent(ev)
+  }
+
+  /**
+   * [SwipeRefreshLayout] completely bypasses ViewGroup's "disallowIntercept" by overriding
+   * [ViewGroup.onInterceptTouchEvent] and never calling super.onInterceptTouchEvent(). This means
+   * that horizontal scrolls will always be intercepted, even though they shouldn't, so we have to
+   * check for that manually here.
+   */
+  private fun shouldInterceptTouchEvent(ev: MotionEvent): Boolean {
+    when (ev.action) {
+      MotionEvent.ACTION_DOWN -> {
+        prevTouchX = ev.x
+        intercepted = false
+      }
+      MotionEvent.ACTION_MOVE -> {
+        val eventX = ev.x
+        val xDiff = Math.abs(eventX - prevTouchX)
+
+        if (intercepted || xDiff > touchSlop) {
+          intercepted = true
+          return false
+        }
+      }
+    }
+    return true
+  }
+
+  private companion object {
+    private const val DEFAULT_CIRCLE_TARGET = 64f
+  }
+}

package/ReactAndroid/src/main/java/com/facebook/react/views/swiperefresh/RefreshEvent.kt

@@ -15,9 +15,9 @@ import com.facebook.react.uimanager.events.Event
 internal class RefreshEvent : Event<RefreshEvent> {
 
   @Deprecated("Use constructor with surfaceId", ReplaceWith("RefreshEvent(surfaceId, viewTag)"))
-  protected constructor(viewTag: Int) : this(ViewUtil.NO_SURFACE_ID, viewTag)
+  constructor(viewTag: Int) : this(ViewUtil.NO_SURFACE_ID, viewTag)
 
-  protected constructor(surfaceId: Int, viewTag: Int) : super(surfaceId, viewTag)
+  constructor(surfaceId: Int, viewTag: Int) : super(surfaceId, viewTag)
 
   override public fun getEventName(): String {
     return "topRefresh"