react-native-tvos 0.75.3-0 → 0.76.0-0

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

@@ -35,8 +35,14 @@ import com.facebook.common.logging.FLog;
 import com.facebook.infer.annotation.Assertions;
 import com.facebook.infer.annotation.Nullsafe;
 import com.facebook.react.R;
+import com.facebook.react.animated.NativeAnimatedModule;
+import com.facebook.react.bridge.ReactContext;
 import com.facebook.react.bridge.ReadableMap;
 import com.facebook.react.common.ReactConstants;
+import com.facebook.react.internal.featureflags.ReactNativeFeatureFlags;
+import com.facebook.react.uimanager.BackgroundStyleApplicator;
+import com.facebook.react.uimanager.LengthPercentage;
+import com.facebook.react.uimanager.LengthPercentageType;
 import com.facebook.react.uimanager.MeasureSpecAssertions;
 import com.facebook.react.uimanager.PixelUtil;
 import com.facebook.react.uimanager.PointerEvents;
@@ -46,6 +52,10 @@ import com.facebook.react.uimanager.ReactOverflowViewWithInset;
 import com.facebook.react.uimanager.StateWrapper;
 import com.facebook.react.uimanager.ViewProps;
 import com.facebook.react.uimanager.events.NativeGestureUtil;
+import com.facebook.react.uimanager.style.BorderRadiusProp;
+import com.facebook.react.uimanager.style.BorderStyle;
+import com.facebook.react.uimanager.style.LogicalEdge;
+import com.facebook.react.uimanager.style.Overflow;
 import com.facebook.react.views.scroll.ReactScrollViewHelper.HasFlingAnimator;
 import com.facebook.react.views.scroll.ReactScrollViewHelper.HasScrollEventThrottle;
 import com.facebook.react.views.scroll.ReactScrollViewHelper.HasScrollState;
@@ -88,7 +98,7 @@ public class ReactScrollView extends ScrollView
 
   private boolean mActivelyScrolling;
   private @Nullable Rect mClippingRect;
-  private @Nullable String mOverflow = ViewProps.HIDDEN;
+  private Overflow mOverflow = Overflow.SCROLL;
   private boolean mDragging;
   private boolean mPagingEnabled = false;
   private @Nullable Runnable mPostTouchRunnable;
@@ -260,8 +270,15 @@ public class ReactScrollView extends ScrollView
   }
 
   public void setOverflow(@Nullable String overflow) {
-    mOverflow = overflow;
+    if (overflow == null) {
+      mOverflow = Overflow.SCROLL;
+    } else {
+      @Nullable Overflow parsedOverflow = Overflow.fromString(overflow);
+      mOverflow = parsedOverflow == null ? Overflow.SCROLL : parsedOverflow;
+    }
+
     mReactBackgroundManager.setOverflow(overflow == null ? ViewProps.SCROLL : overflow);
+    invalidate();
   }
 
   public void setMaintainVisibleContentPosition(
@@ -280,7 +297,16 @@ public class ReactScrollView extends ScrollView
 
   @Override
   public @Nullable String getOverflow() {
-    return mOverflow;
+    switch (mOverflow) {
+      case HIDDEN:
+        return "hidden";
+      case SCROLL:
+        return "scroll";
+      case VISIBLE:
+        return "visible";
+    }
+
+    return null;
   }
 
   @Override
@@ -654,7 +680,13 @@ public class ReactScrollView extends ScrollView
 
   @Override
   public void onDraw(Canvas canvas) {
-    mReactBackgroundManager.maybeClipToPaddingBox(canvas);
+    if (ReactNativeFeatureFlags.enableBackgroundStyleApplicator()) {
+      if (mOverflow != Overflow.VISIBLE) {
+        BackgroundStyleApplicator.clipToPaddingBox(this, canvas);
+      }
+    } else {
+      mReactBackgroundManager.maybeClipToPaddingBox(canvas);
+    }
     super.onDraw(canvas);
   }
 
@@ -709,6 +741,14 @@ public class ReactScrollView extends ScrollView
                 if (mSendMomentumEvents) {
                   ReactScrollViewHelper.emitScrollMomentumEndEvent(ReactScrollView.this);
                 }
+                ReactContext context = (ReactContext) getContext();
+                if (context != null) {
+                  NativeAnimatedModule nativeAnimated =
+                      context.getNativeModule(NativeAnimatedModule.class);
+                  if (nativeAnimated != null) {
+                    nativeAnimated.userDrivenScrollEnded(ReactScrollView.this.getId());
+                  }
+                }
                 disableFpsListener();
               } else {
                 if (mPagingEnabled && !mSnappingToPage) {
@@ -1217,27 +1257,55 @@ public class ReactScrollView extends ScrollView
 
   @Override
   public void setBackgroundColor(int color) {
-    mReactBackgroundManager.setBackgroundColor(color);
+    if (ReactNativeFeatureFlags.enableBackgroundStyleApplicator()) {
+      BackgroundStyleApplicator.setBackgroundColor(this, color);
+    } else {
+      mReactBackgroundManager.setBackgroundColor(color);
+    }
   }
 
   public void setBorderWidth(int position, float width) {
-    mReactBackgroundManager.setBorderWidth(position, width);
+    if (ReactNativeFeatureFlags.enableBackgroundStyleApplicator()) {
+      BackgroundStyleApplicator.setBorderWidth(
+          this, LogicalEdge.values()[position], PixelUtil.toDIPFromPixel(width));
+    } else {
+      mReactBackgroundManager.setBorderWidth(position, width);
+    }
   }
 
-  public void setBorderColor(int position, float color, float alpha) {
-    mReactBackgroundManager.setBorderColor(position, color, alpha);
+  public void setBorderColor(int position, @Nullable Integer color) {
+    if (ReactNativeFeatureFlags.enableBackgroundStyleApplicator()) {
+      BackgroundStyleApplicator.setBorderColor(this, LogicalEdge.values()[position], color);
+    } else {
+      mReactBackgroundManager.setBorderColor(position, color);
+    }
   }
 
   public void setBorderRadius(float borderRadius) {
-    mReactBackgroundManager.setBorderRadius(borderRadius);
+    setBorderRadius(borderRadius, BorderRadiusProp.BORDER_RADIUS.ordinal());
   }
 
   public void setBorderRadius(float borderRadius, int position) {
-    mReactBackgroundManager.setBorderRadius(borderRadius, position);
+    if (ReactNativeFeatureFlags.enableBackgroundStyleApplicator()) {
+      @Nullable
+      LengthPercentage radius =
+          Float.isNaN(borderRadius)
+              ? null
+              : new LengthPercentage(
+                  PixelUtil.toDIPFromPixel(borderRadius), LengthPercentageType.POINT);
+      BackgroundStyleApplicator.setBorderRadius(this, BorderRadiusProp.values()[position], radius);
+    } else {
+      mReactBackgroundManager.setBorderRadius(borderRadius, position);
+    }
   }
 
   public void setBorderStyle(@Nullable String style) {
-    mReactBackgroundManager.setBorderStyle(style);
+    if (ReactNativeFeatureFlags.enableBackgroundStyleApplicator()) {
+      BackgroundStyleApplicator.setBorderStyle(
+          this, style == null ? null : BorderStyle.fromString(style));
+    } else {
+      mReactBackgroundManager.setBorderStyle(style);
+    }
   }
 
   /**

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

@@ -14,19 +14,19 @@ import android.graphics.Point
 import android.view.View
 import android.view.ViewGroup
 import android.widget.OverScroller
-import androidx.core.view.ViewCompat
 import com.facebook.common.logging.FLog
 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
 import com.facebook.react.uimanager.common.UIManagerType
 import com.facebook.react.uimanager.common.ViewUtil
-import java.util.Collections
-import java.util.WeakHashMap
+import java.lang.ref.WeakReference
+import java.util.concurrent.CopyOnWriteArrayList
 
 /** Helper class that deals with emitting Scroll Events. */
 public object ReactScrollViewHelper {
@@ -46,7 +46,7 @@ public object ReactScrollViewHelper {
   public const val SNAP_ALIGNMENT_END: Int = 3
 
   // Support global native listeners for scroll events
-  private val scrollListeners = Collections.newSetFromMap(WeakHashMap<ScrollListener, Boolean>())
+  private val scrollListeners = CopyOnWriteArrayList<WeakReference<ScrollListener>>()
 
   // If all else fails, this is the hardcoded value in OverScroller.java, in AOSP.
   // The default is defined here (as of this diff):
@@ -114,7 +114,7 @@ public object ReactScrollViewHelper {
     }
     val contentView = scrollView.getChildAt(0) ?: return
     for (scrollListener in scrollListeners) {
-      scrollListener.onScroll(scrollView, scrollEventType, xVelocity, yVelocity)
+      scrollListener.get()?.onScroll(scrollView, scrollEventType, xVelocity, yVelocity)
     }
     val reactContext = scrollView.context as ReactContext
     val surfaceId = UIManagerHelper.getSurfaceId(reactContext)
@@ -147,7 +147,7 @@ public object ReactScrollViewHelper {
   @JvmStatic
   public fun emitLayoutEvent(scrollView: ViewGroup) {
     for (scrollListener in scrollListeners) {
-      scrollListener.onLayout(scrollView)
+      scrollListener.get()?.onLayout(scrollView)
     }
   }
 
@@ -205,17 +205,13 @@ public object ReactScrollViewHelper {
    * @param listener
    */
   @JvmStatic
-  public fun addScrollListener(listener: ScrollListener?) {
-    if (listener != null) {
-      scrollListeners.add(listener)
-    }
+  public fun addScrollListener(listener: ScrollListener) {
+    scrollListeners.add(WeakReference(listener))
   }
 
   @JvmStatic
-  public fun removeScrollListener(listener: ScrollListener?) {
-    if (listener != null) {
-      scrollListeners.remove(listener)
-    }
+  public fun removeScrollListener(listener: ScrollListener) {
+    scrollListeners.remove(WeakReference(listener))
   }
 
   /**
@@ -250,7 +246,9 @@ public object ReactScrollViewHelper {
     if (scrollY != y) {
       scrollView.startFlingAnimator(scrollY, y)
     }
-    updateFabricScrollState<T>(scrollView, x, y)
+    if (ReactNativeFeatureFlags.fixIncorrectScrollViewStateUpdateOnAndroid()) {
+      updateFabricScrollState<T>(scrollView, x, y)
+    }
   }
 
   /** Get current position or position after current animation finishes, if any. */
@@ -291,7 +289,6 @@ public object ReactScrollViewHelper {
    * 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 : HasFlingAnimator?,
   T : HasScrollState?,
   T : HasStateWrapper?,
   T : ViewGroup {
@@ -308,13 +305,11 @@ public object ReactScrollViewHelper {
       return
     }
     scrollState.setLastStateUpdateScroll(scrollX, scrollY)
-    forceUpdateState<T>(scrollView)
-    return
+    forceUpdateState(scrollView)
   }
 
   @JvmStatic
   public fun <T> forceUpdateState(scrollView: T) where
-  T : HasFlingAnimator?,
   T : HasScrollState?,
   T : HasStateWrapper?,
   T : ViewGroup {
@@ -323,9 +318,8 @@ public object ReactScrollViewHelper {
     val scrollPos = scrollState.lastStateUpdateScroll
     val scrollX = scrollPos.x
     val scrollY = scrollPos.y
-    val fabricScrollX: Int
     val layoutDirection = scrollState.layoutDirection
-    fabricScrollX =
+    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.
@@ -338,7 +332,7 @@ public object ReactScrollViewHelper {
     if (DEBUG_MODE) {
       FLog.i(
           TAG,
-          "updateFabricScrollState[%d] scrollX %d scrollY %d fabricScrollX",
+          "updateFabricScrollState[%d] scrollX %d scrollY %d fabricScrollX %d",
           scrollView.id,
           scrollX,
           scrollY,
@@ -385,7 +379,7 @@ public object ReactScrollViewHelper {
     // 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)
+    updateFabricScrollState(scrollView, scrollView.scrollX, scrollView.scrollY)
     emitScrollEvent(
         scrollView, ScrollEventType.SCROLL, xVelocity, yVelocity, experimental_synchronous)
   }
@@ -434,10 +428,7 @@ 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 -
-            ViewCompat.getPaddingStart(scrollView) -
-            ViewCompat.getPaddingEnd(scrollView))
+    val width = scrollView.width - scrollView.getPaddingStart() - scrollView.getPaddingEnd()
     val height = scrollView.height - scrollView.paddingBottom - scrollView.paddingTop
     val finalAnimatedPositionScroll = scrollState.finalAnimatedPositionScroll
     scroller.fling(
@@ -516,7 +507,7 @@ public object ReactScrollViewHelper {
         finalAnimatedPositionScrollX: Int,
         finalAnimatedPositionScrollY: Int
     ): ReactScrollViewScrollState {
-      finalAnimatedPositionScroll[finalAnimatedPositionScrollX] = finalAnimatedPositionScrollY
+      finalAnimatedPositionScroll.set(finalAnimatedPositionScrollX, finalAnimatedPositionScrollY)
       return this
     }
 
@@ -525,7 +516,7 @@ public object ReactScrollViewHelper {
         lastStateUpdateScrollX: Int,
         lastStateUpdateScrollY: Int
     ): ReactScrollViewScrollState {
-      lastStateUpdateScroll[lastStateUpdateScrollX] = lastStateUpdateScrollY
+      lastStateUpdateScroll.set(lastStateUpdateScrollX, lastStateUpdateScrollY)
       return this
     }
   }
@@ -550,15 +541,13 @@ public object ReactScrollViewHelper {
   }
 
   public interface HasScrollEventThrottle {
-    /** Get the scroll event throttle in ms. */
     /**
-     * Set the scroll event throttle in ms. This number is used to throttle the scroll events. The
+     * The scroll event throttle in ms. This number is used to throttle the scroll events. The
      * default value is zero, which means the scroll events are sent with no throttle.
      */
     public var scrollEventThrottle: Int
 
-    /** Get the scroll view dispatch time for throttling */
-    /** Set the scroll view's last dispatch time for throttling */
+    /** The scroll view's last dispatch time for throttling */
     public var lastScrollDispatchTime: Long
   }
 

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

@@ -9,6 +9,7 @@ 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;
@@ -16,7 +17,11 @@ 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;
+import com.facebook.react.uimanager.LengthPercentageType;
 import com.facebook.react.uimanager.PixelUtil;
 import com.facebook.react.uimanager.PointerEvents;
 import com.facebook.react.uimanager.ReactClippingViewGroupHelper;
@@ -28,7 +33,9 @@ import com.facebook.react.uimanager.ViewGroupManager;
 import com.facebook.react.uimanager.ViewProps;
 import com.facebook.react.uimanager.annotations.ReactProp;
 import com.facebook.react.uimanager.annotations.ReactPropGroup;
-import com.facebook.yoga.YogaConstants;
+import com.facebook.react.uimanager.style.BorderRadiusProp;
+import com.facebook.react.uimanager.style.BorderStyle;
+import com.facebook.react.uimanager.style.LogicalEdge;
 import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.List;
@@ -80,7 +87,7 @@ public class ReactScrollViewManager extends ViewGroupManager<ReactScrollView>
     view.setFocusable(value);
   }
 
-  @ReactProp(name = "showsVerticalScrollIndicator")
+  @ReactProp(name = "showsVerticalScrollIndicator", defaultBoolean = true)
   public void setShowsVerticalScrollIndicator(ReactScrollView view, boolean value) {
     view.setVerticalScrollBarEnabled(value);
   }
@@ -236,22 +243,38 @@ public class ReactScrollViewManager extends ViewGroupManager<ReactScrollView>
         ViewProps.BORDER_BOTTOM_RIGHT_RADIUS,
         ViewProps.BORDER_BOTTOM_LEFT_RADIUS
       },
-      defaultFloat = YogaConstants.UNDEFINED)
+      defaultFloat = Float.NaN)
   public void setBorderRadius(ReactScrollView view, int index, float borderRadius) {
-    if (!YogaConstants.isUndefined(borderRadius)) {
-      borderRadius = PixelUtil.toPixelFromDIP(borderRadius);
-    }
-
-    if (index == 0) {
-      view.setBorderRadius(borderRadius);
+    if (ReactNativeFeatureFlags.enableBackgroundStyleApplicator()) {
+      @Nullable
+      LengthPercentage radius =
+          Float.isNaN(borderRadius)
+              ? null
+              : new LengthPercentage(borderRadius, LengthPercentageType.POINT);
+      BackgroundStyleApplicator.setBorderRadius(view, BorderRadiusProp.values()[index], radius);
     } else {
-      view.setBorderRadius(borderRadius, index - 1);
+      if (!Float.isNaN(borderRadius)) {
+        borderRadius = PixelUtil.toPixelFromDIP(borderRadius);
+      }
+
+      if (index == 0) {
+        view.setBorderRadius(borderRadius);
+      } else {
+        view.setBorderRadius(borderRadius, index - 1);
+      }
     }
   }
 
   @ReactProp(name = "borderStyle")
   public void setBorderStyle(ReactScrollView view, @Nullable String borderStyle) {
-    view.setBorderStyle(borderStyle);
+    if (ReactNativeFeatureFlags.enableBackgroundStyleApplicator()) {
+      @Nullable
+      BorderStyle parsedBorderStyle =
+          borderStyle == null ? null : BorderStyle.fromString(borderStyle);
+      BackgroundStyleApplicator.setBorderStyle(view, parsedBorderStyle);
+    } else {
+      view.setBorderStyle(borderStyle);
+    }
   }
 
   @ReactPropGroup(
@@ -262,12 +285,17 @@ public class ReactScrollViewManager extends ViewGroupManager<ReactScrollView>
         ViewProps.BORDER_TOP_WIDTH,
         ViewProps.BORDER_BOTTOM_WIDTH,
       },
-      defaultFloat = YogaConstants.UNDEFINED)
+      defaultFloat = Float.NaN)
   public void setBorderWidth(ReactScrollView view, int index, float width) {
-    if (!YogaConstants.isUndefined(width)) {
-      width = PixelUtil.toPixelFromDIP(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);
     }
-    view.setBorderWidth(SPACING_TYPES[index], width);
   }
 
   @ReactPropGroup(
@@ -279,10 +307,12 @@ public class ReactScrollViewManager extends ViewGroupManager<ReactScrollView>
         "borderBottomColor"
       },
       customType = "Color")
-  public void setBorderColor(ReactScrollView view, int index, Integer color) {
-    float rgbComponent = color == null ? YogaConstants.UNDEFINED : (float) (color & 0x00FFFFFF);
-    float alphaComponent = color == null ? YogaConstants.UNDEFINED : (float) (color >>> 24);
-    view.setBorderColor(SPACING_TYPES[index], rgbComponent, alphaComponent);
+  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);
+    }
   }
 
   @ReactProp(name = "overflow")
@@ -342,6 +372,22 @@ 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/VelocityHelper.kt

@@ -0,0 +1,51 @@
+/*
+ * 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.view.MotionEvent
+import android.view.VelocityTracker
+
+/**
+ * This Class helps to calculate the velocity for all ScrollView. The x and y velocity will later on
+ * send to ReactScrollViewHelper for further use.
+ */
+internal class VelocityHelper {
+  private var velocityTracker: VelocityTracker? = null
+
+  /* Needs to call ACTION_UP/CANCEL to update the xVelocity/yVelocity */
+  public var xVelocity = 0f
+    private set
+
+  public var yVelocity = 0f
+    private set
+
+  /**
+   * Call from a ScrollView in onTouchEvent. Calculating the velocity for END_DRAG movement and send
+   * them back to react ScrollResponder.js
+   */
+  public fun calculateVelocity(ev: MotionEvent): Unit {
+    if (velocityTracker == null) {
+      velocityTracker = VelocityTracker.obtain()
+    }
+
+    velocityTracker?.let { tracker ->
+      tracker.addMovement(ev)
+      when (ev.action and MotionEvent.ACTION_MASK) {
+        MotionEvent.ACTION_UP,
+        MotionEvent.ACTION_CANCEL -> {
+          // Calculate velocity on END_DRAG
+          tracker.computeCurrentVelocity(1) // points/millisecond
+          xVelocity = tracker.xVelocity
+          yVelocity = tracker.yVelocity
+          tracker.recycle()
+          velocityTracker = null
+        }
+      }
+    }
+  }
+}

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

@@ -8,6 +8,7 @@
 package com.facebook.react.views.swiperefresh;
 
 import android.view.MotionEvent;
+import android.view.View;
 import android.view.ViewConfiguration;
 import androidx.swiperefreshlayout.widget.SwipeRefreshLayout;
 import com.facebook.infer.annotation.Nullsafe;
@@ -72,6 +73,16 @@ public class ReactSwipeRefreshLayout extends SwipeRefreshLayout {
     }
   }
 
+  @Override
+  public boolean canChildScrollUp() {
+    View firstChild = getChildAt(0);
+    if (firstChild != null) {
+      return firstChild.canScrollVertically(-1);
+    } else {
+      return super.canChildScrollUp();
+    }
+  }
+
   /**
    * {@link SwipeRefreshLayout} overrides {@link ViewGroup#requestDisallowInterceptTouchEvent} and
    * swallows it. This means that any component underneath SwipeRefreshLayout will now interact

package/ReactAndroid/src/main/java/com/facebook/react/views/switchview/ReactSwitch.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.switchview
+
+import android.content.Context
+import android.content.res.ColorStateList
+import android.graphics.PorterDuff
+import android.graphics.PorterDuffColorFilter
+import android.graphics.drawable.ColorDrawable
+import android.graphics.drawable.Drawable
+import android.graphics.drawable.RippleDrawable
+import androidx.appcompat.widget.SwitchCompat
+
+/**
+ * Switch that has its value controlled by JS. Whenever the value of the switch changes, we do not
+ * allow any other changes to that switch until JS sets a value explicitly. This stops the Switch
+ * from changing its value multiple times, when those changes have not been processed by JS first.
+ */
+internal class ReactSwitch(context: Context) : SwitchCompat(context) {
+
+  private var allowChange = true
+  private var trackColorForFalse: Int? = null
+  private var trackColorForTrue: Int? = null
+
+  override fun setChecked(checked: Boolean) {
+    if (allowChange && isChecked != checked) {
+      allowChange = false
+      super.setChecked(checked)
+      setTrackColor(checked)
+    } else {
+      // Even if mAllowChange is set to false or the checked value hasn't changed, we still must
+      // call the super method, since it will make sure the thumb is moved back to the correct edge.
+      // Without calling the super method, the thumb might stuck in the middle of the switch.
+      super.setChecked(isChecked)
+    }
+  }
+
+  override fun setBackgroundColor(color: Int) {
+    background =
+        RippleDrawable(createRippleDrawableColorStateList(color), ColorDrawable(color), null)
+  }
+
+  public fun setColor(drawable: Drawable, color: Int?): Unit {
+    if (color == null) {
+      drawable.clearColorFilter()
+    } else {
+      drawable.setColorFilter(PorterDuffColorFilter(color, PorterDuff.Mode.MULTIPLY))
+    }
+  }
+
+  public fun setTrackColor(color: Int?): Unit {
+    setColor(super.getTrackDrawable(), color)
+  }
+
+  public fun setThumbColor(color: Int?): Unit {
+    setColor(super.getThumbDrawable(), color)
+
+    // Set the ripple color if background is instance of RippleDrawable
+    if (color != null && super.getBackground() is RippleDrawable) {
+      val customColorState = createRippleDrawableColorStateList(color)
+      (super.getBackground() as RippleDrawable).setColor(customColorState)
+    }
+  }
+
+  public fun setOn(on: Boolean): Unit {
+    // If the switch has a different value than the value sent by JS, we must change it.
+    if (isChecked != on) {
+      super.setChecked(on)
+      setTrackColor(on)
+    }
+    allowChange = true
+  }
+
+  public fun setTrackColorForTrue(color: Int?): Unit {
+    if (color == trackColorForTrue) {
+      return
+    }
+    trackColorForTrue = color
+    if (isChecked) {
+      setTrackColor(trackColorForTrue)
+    }
+  }
+
+  public fun setTrackColorForFalse(color: Int?): Unit {
+    if (color == trackColorForFalse) {
+      return
+    }
+    trackColorForFalse = color
+    if (!isChecked) {
+      setTrackColor(trackColorForFalse)
+    }
+  }
+
+  private fun setTrackColor(checked: Boolean) {
+    if (trackColorForTrue != null || trackColorForFalse != null) {
+      // Update the track color to reflect the new value. We only want to do this if these
+      // props were actually set from JS; otherwise we'll just reset the color to the default.
+      val currentTrackColor = if (checked) trackColorForTrue else trackColorForFalse
+      setTrackColor(currentTrackColor)
+    }
+  }
+
+  private fun createRippleDrawableColorStateList(color: Int): ColorStateList =
+      ColorStateList(arrayOf(intArrayOf(android.R.attr.state_pressed)), intArrayOf(color))
+}