react-native-tvos 0.76.5-0 → 0.77.0-0

package/ReactAndroid/src/main/java/com/facebook/react/views/progressbar/ReactProgressBarViewManager.kt

@@ -34,7 +34,7 @@ import java.util.WeakHashMap
  * a new one with the style given.
  */
 @ReactModule(name = ReactProgressBarViewManager.REACT_CLASS)
-public class ReactProgressBarViewManager :
+internal class ReactProgressBarViewManager :
     BaseViewManager<ProgressBarContainerView, ProgressBarShadowNode>(),
     AndroidProgressBarManagerInterface<ProgressBarContainerView> {
   private val measuredStyles = WeakHashMap<Int, Pair<Int, Int>>()
@@ -42,60 +42,60 @@ public class ReactProgressBarViewManager :
   private val delegate: ViewManagerDelegate<ProgressBarContainerView> =
       AndroidProgressBarManagerDelegate(this)
 
-  public override fun getName(): String = REACT_CLASS
+  override fun getName(): String = REACT_CLASS
 
-  protected override fun createViewInstance(context: ThemedReactContext): ProgressBarContainerView {
+  override fun createViewInstance(context: ThemedReactContext): ProgressBarContainerView {
     return ProgressBarContainerView(context)
   }
 
   @ReactProp(name = PROP_STYLE)
-  public override fun setStyleAttr(view: ProgressBarContainerView, styleName: String?) {
+  override fun setStyleAttr(view: ProgressBarContainerView, styleName: String?) {
     view.setStyle(styleName)
   }
 
   @ReactProp(name = ViewProps.COLOR, customType = "Color")
-  public override fun setColor(view: ProgressBarContainerView, color: Int?) {
+  override fun setColor(view: ProgressBarContainerView, color: Int?) {
     view.color = color
   }
 
   @ReactProp(name = PROP_INDETERMINATE)
-  public override fun setIndeterminate(view: ProgressBarContainerView, indeterminate: Boolean) {
+  override fun setIndeterminate(view: ProgressBarContainerView, indeterminate: Boolean) {
     view.indeterminate = indeterminate
   }
 
   @ReactProp(name = PROP_PROGRESS)
-  public override fun setProgress(view: ProgressBarContainerView, progress: Double) {
+  override fun setProgress(view: ProgressBarContainerView, progress: Double) {
     view.progress = progress
   }
 
   @ReactProp(name = PROP_ANIMATING)
-  public override fun setAnimating(view: ProgressBarContainerView, animating: Boolean) {
+  override fun setAnimating(view: ProgressBarContainerView, animating: Boolean) {
     view.animating = animating
   }
 
-  public override fun setTestID(view: ProgressBarContainerView, value: String?) {
+  override fun setTestID(view: ProgressBarContainerView, value: String?) {
     super.setTestId(view, value)
   }
 
   @ReactProp(name = PROP_ATTR)
-  public override fun setTypeAttr(view: ProgressBarContainerView, value: String?): Unit = Unit
+  override fun setTypeAttr(view: ProgressBarContainerView, value: String?): Unit = Unit
 
-  public override fun createShadowNodeInstance(): ProgressBarShadowNode = ProgressBarShadowNode()
+  override fun createShadowNodeInstance(): ProgressBarShadowNode = ProgressBarShadowNode()
 
-  public override fun getShadowNodeClass(): Class<ProgressBarShadowNode> =
+  override fun getShadowNodeClass(): Class<ProgressBarShadowNode> =
       ProgressBarShadowNode::class.java
 
-  public override fun updateExtraData(root: ProgressBarContainerView, extraData: Any) {
+  override fun updateExtraData(root: ProgressBarContainerView, extraData: Any) {
     // do nothing
   }
 
-  protected override fun onAfterUpdateTransaction(view: ProgressBarContainerView) {
+  override fun onAfterUpdateTransaction(view: ProgressBarContainerView) {
     view.apply()
   }
 
-  protected override fun getDelegate(): ViewManagerDelegate<ProgressBarContainerView> = delegate
+  override fun getDelegate(): ViewManagerDelegate<ProgressBarContainerView> = delegate
 
-  public override fun measure(
+  override fun measure(
       context: Context,
       localData: ReadableMap,
       props: ReadableMap,
@@ -119,15 +119,15 @@ public class ReactProgressBarViewManager :
         toDIPFromPixel(value.first.toFloat()), toDIPFromPixel(value.second.toFloat()))
   }
 
-  public companion object {
-    public const val REACT_CLASS: String = "AndroidProgressBar"
+  companion object {
+    const val REACT_CLASS: String = "AndroidProgressBar"
 
-    internal const val PROP_STYLE: String = "styleAttr"
-    internal const val PROP_ATTR: String = "typeAttr"
-    internal const val PROP_INDETERMINATE: String = "indeterminate"
-    internal const val PROP_PROGRESS: String = "progress"
-    internal const val PROP_ANIMATING: String = "animating"
-    internal const val DEFAULT_STYLE: String = "Normal"
+    const val PROP_STYLE: String = "styleAttr"
+    const val PROP_ATTR: String = "typeAttr"
+    const val PROP_INDETERMINATE: String = "indeterminate"
+    const val PROP_PROGRESS: String = "progress"
+    const val PROP_ANIMATING: String = "animating"
+    const val DEFAULT_STYLE: String = "Normal"
 
     private val progressBarCtorLock = Any()
 
@@ -136,7 +136,7 @@ public class ReactProgressBarViewManager :
      * ProgressBar constructor that may cause crashes when two ProgressBars are constructed at the
      * same time on two different threads. This static ctor wrapper protects against that.
      */
-    public fun createProgressBar(context: Context?, style: Int): ProgressBar {
+    fun createProgressBar(context: Context?, style: Int): ProgressBar {
       synchronized(progressBarCtorLock) {
         return ProgressBar(context, null, style)
       }

package/ReactAndroid/src/main/java/com/facebook/react/views/safeareaview/ReactSafeAreaView.kt

@@ -20,7 +20,7 @@ import com.facebook.react.uimanager.StateWrapper
 import com.facebook.react.uimanager.ThemedReactContext
 import com.facebook.react.uimanager.UIManagerModule
 
-public class ReactSafeAreaView(public val reactContext: ThemedReactContext) :
+internal class ReactSafeAreaView(public val reactContext: ThemedReactContext) :
     ViewGroup(reactContext) {
   internal var stateWrapper: StateWrapper? = null
 

package/ReactAndroid/src/main/java/com/facebook/react/views/safeareaview/ReactSafeAreaViewManager.kt

@@ -19,7 +19,7 @@ import com.facebook.react.viewmanagers.SafeAreaViewManagerInterface
 
 /** View manager for [ReactSafeAreaView] components. */
 @ReactModule(name = ReactSafeAreaViewManager.REACT_CLASS)
-public class ReactSafeAreaViewManager() :
+internal class ReactSafeAreaViewManager() :
     ViewGroupManager<ReactSafeAreaView>(), SafeAreaViewManagerInterface<ReactSafeAreaView> {
 
   private val delegate: ViewManagerDelegate<ReactSafeAreaView> = SafeAreaViewManagerDelegate(this)
@@ -45,7 +45,7 @@ public class ReactSafeAreaViewManager() :
     return null
   }
 
-  public companion object {
-    public const val REACT_CLASS: String = "RCTSafeAreaView"
+  internal companion object {
+    const val REACT_CLASS: String = "RCTSafeAreaView"
   }
 }

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

@@ -0,0 +1,46 @@
+/*
+ * 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.content.Context
+import com.facebook.react.modules.i18nmanager.I18nUtil
+import com.facebook.react.views.view.ReactViewGroup
+
+/**
+ * Used by legacy/Paper renderer to perform offsetting of scroll content when the app-wide layout
+ * direction is RTL. Contextually set layout direction is not respected by legacy renderer.
+ */
+internal class ReactHorizontalScrollContainerLegacyView(context: Context) :
+    ReactViewGroup(context) {
+  private val isRTL: Boolean = I18nUtil.instance.isRTL(context)
+
+  override fun setRemoveClippedSubviews(removeClippedSubviews: Boolean) {
+    // removeClippedSubviews logic may read metrics before the offsetting we do in onLayout() and is
+    // such unsafe
+    if (isRTL) {
+      super.setRemoveClippedSubviews(false)
+      return
+    }
+
+    super.setRemoveClippedSubviews(removeClippedSubviews)
+  }
+
+  protected override fun onLayout(changed: Boolean, left: Int, top: Int, right: Int, bottom: Int) {
+    if (isRTL) {
+      // When the layout direction is RTL, we expect Yoga to give us a layout
+      // that extends off the screen to the left so we re-center it with left=0
+      val newLeft = 0
+      val width = right - left
+      val newRight = newLeft + width
+      setLeft(newLeft)
+      setTop(top)
+      setRight(newRight)
+      setBottom(bottom)
+    }
+  }
+}

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

@@ -8,21 +8,41 @@
 package com.facebook.react.views.scroll
 
 import com.facebook.react.module.annotations.ReactModule
+import com.facebook.react.uimanager.ReactStylesDiffMap
+import com.facebook.react.uimanager.StateWrapper
 import com.facebook.react.uimanager.ThemedReactContext
-import com.facebook.react.views.view.ReactClippingViewManager
+import com.facebook.react.uimanager.common.UIManagerType
+import com.facebook.react.uimanager.common.ViewUtil
+import com.facebook.react.views.view.ReactViewGroup
+import com.facebook.react.views.view.ReactViewManager
 
 /** View manager for {@link ReactHorizontalScrollContainerView} components. */
 @ReactModule(name = ReactHorizontalScrollContainerViewManager.REACT_CLASS)
-public class ReactHorizontalScrollContainerViewManager :
-    ReactClippingViewManager<ReactHorizontalScrollContainerView>() {
-
+public class ReactHorizontalScrollContainerViewManager : ReactViewManager() {
   override public fun getName(): String = REACT_CLASS
 
-  override public fun createViewInstance(
-      context: ThemedReactContext
-  ): ReactHorizontalScrollContainerView = ReactHorizontalScrollContainerView(context)
+  protected override fun createViewInstance(
+      reactTag: Int,
+      context: ThemedReactContext,
+      initialProps: ReactStylesDiffMap?,
+      stateWrapper: StateWrapper?
+  ): ReactViewGroup {
+    check(uiManagerType == null)
+    uiManagerType = ViewUtil.getUIManagerType(reactTag)
+    val view = super.createViewInstance(reactTag, context, initialProps, stateWrapper)
+    uiManagerType = null
+    return view
+  }
+
+  public override fun createViewInstance(context: ThemedReactContext): ReactViewGroup {
+    return when (checkNotNull(uiManagerType)) {
+      UIManagerType.FABRIC -> ReactViewGroup(context)
+      else -> ReactHorizontalScrollContainerLegacyView(context)
+    }
+  }
 
   public companion object {
     public const val REACT_CLASS: String = "AndroidHorizontalScrollContentView"
+    private @UIManagerType var uiManagerType: Int? = null
   }
 }

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

@@ -37,8 +37,6 @@ import com.facebook.react.animated.NativeAnimatedModule;
 import com.facebook.react.bridge.ReactContext;
 import com.facebook.react.common.ReactConstants;
 import com.facebook.react.common.build.ReactBuildConfig;
-import com.facebook.react.internal.featureflags.ReactNativeFeatureFlags;
-import com.facebook.react.modules.i18nmanager.I18nUtil;
 import com.facebook.react.uimanager.BackgroundStyleApplicator;
 import com.facebook.react.uimanager.LengthPercentage;
 import com.facebook.react.uimanager.LengthPercentageType;
@@ -49,7 +47,6 @@ import com.facebook.react.uimanager.ReactClippingViewGroup;
 import com.facebook.react.uimanager.ReactClippingViewGroupHelper;
 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;
@@ -61,7 +58,7 @@ import com.facebook.react.views.scroll.ReactScrollViewHelper.HasScrollState;
 import com.facebook.react.views.scroll.ReactScrollViewHelper.HasSmoothScroll;
 import com.facebook.react.views.scroll.ReactScrollViewHelper.HasStateWrapper;
 import com.facebook.react.views.scroll.ReactScrollViewHelper.ReactScrollViewScrollState;
-import com.facebook.react.views.view.ReactViewBackgroundManager;
+import com.facebook.systrace.Systrace;
 import java.lang.reflect.Field;
 import java.util.ArrayList;
 import java.util.List;
@@ -104,8 +101,6 @@ public class ReactHorizontalScrollView extends HorizontalScrollView
   private @Nullable Runnable mPostTouchRunnable;
   private boolean mRemoveClippedSubviews;
   private boolean mScrollEnabled = true;
-  private boolean mPreventReentry = false;
-  private boolean mEnableSyncOnScroll = false;
   private boolean mSendMomentumEvents;
   private @Nullable FpsListener mFpsListener = null;
   private @Nullable String mScrollPerfTag;
@@ -117,7 +112,6 @@ public class ReactHorizontalScrollView extends HorizontalScrollView
   private boolean mSnapToStart = true;
   private boolean mSnapToEnd = true;
   private int mSnapToAlignment = SNAP_ALIGNMENT_DISABLED;
-  private ReactViewBackgroundManager mReactBackgroundManager;
   private boolean mPagedArrowScrolling = false;
   private int pendingContentOffsetX = UNSET_CONTENT_OFFSET;
   private int pendingContentOffsetY = UNSET_CONTENT_OFFSET;
@@ -138,23 +132,15 @@ public class ReactHorizontalScrollView extends HorizontalScrollView
 
   public ReactHorizontalScrollView(Context context, @Nullable FpsListener fpsListener) {
     super(context);
-    mReactBackgroundManager = new ReactViewBackgroundManager(this);
     mFpsListener = fpsListener;
 
     ViewCompat.setAccessibilityDelegate(this, new ReactScrollViewAccessibilityDelegate());
 
     mScroller = getOverScrollerFromParent();
-    mReactScrollViewScrollState =
-        new ReactScrollViewScrollState(
-            // TODO: The ScrollView content may be laid out in a different direction than the
-            // instance if the `direction` style is set on the ScrollView or above it.
-            I18nUtil.getInstance().isRTL(context)
-                ? ViewCompat.LAYOUT_DIRECTION_RTL
-                : ViewCompat.LAYOUT_DIRECTION_LTR);
+    mReactScrollViewScrollState = new ReactScrollViewScrollState();
 
     setOnHierarchyChangeListener(this);
     setClipChildren(false);
-    mReactBackgroundManager.setOverflow(ViewProps.SCROLL);
   }
 
   public boolean getScrollEnabled() {
@@ -166,6 +152,14 @@ public class ReactHorizontalScrollView extends HorizontalScrollView
     return mScrollEnabled && super.canScrollHorizontally(direction);
   }
 
+  @Override
+  protected int computeScrollDeltaToGetChildRectOnScreen(Rect rect) {
+    if (mScrollEnabled) {
+      return 0;
+    }
+    return super.computeScrollDeltaToGetChildRectOnScreen(rect);
+  }
+
   @Nullable
   private OverScroller getOverScrollerFromParent() {
     OverScroller scroller;
@@ -235,10 +229,6 @@ public class ReactHorizontalScrollView extends HorizontalScrollView
     mScrollEnabled = scrollEnabled;
   }
 
-  public void setEnableSyncOnScroll(boolean enableSyncOnScroll) {
-    mEnableSyncOnScroll = enableSyncOnScroll;
-  }
-
   public void setPagingEnabled(boolean pagingEnabled) {
     mPagingEnabled = pagingEnabled;
   }
@@ -289,7 +279,6 @@ public class ReactHorizontalScrollView extends HorizontalScrollView
       mOverflow = parsedOverflow == null ? Overflow.SCROLL : parsedOverflow;
     }
 
-    mReactBackgroundManager.setOverflow(overflow == null ? ViewProps.SCROLL : overflow);
     invalidate();
   }
 
@@ -333,12 +322,8 @@ public class ReactHorizontalScrollView extends HorizontalScrollView
 
   @Override
   public void onDraw(Canvas canvas) {
-    if (ReactNativeFeatureFlags.enableBackgroundStyleApplicator()) {
-      if (mOverflow != Overflow.VISIBLE) {
-        BackgroundStyleApplicator.clipToPaddingBox(this, canvas);
-      }
-    } else {
-      mReactBackgroundManager.maybeClipToPaddingBox(canvas);
+    if (mOverflow != Overflow.VISIBLE) {
+      BackgroundStyleApplicator.clipToPaddingBox(this, canvas);
     }
     super.onDraw(canvas);
   }
@@ -457,14 +442,6 @@ public class ReactHorizontalScrollView extends HorizontalScrollView
     return computeScrollDeltaToGetChildRectOnScreen(mTempRect);
   }
 
-  @Override
-  protected int computeScrollDeltaToGetChildRectOnScreen(Rect rect) {
-    if (!mScrollEnabled) {
-      return 0;
-    }
-    return super.computeScrollDeltaToGetChildRectOnScreen(rect);
-  }
-
   /** Returns whether the given descendent is scrolled fully in view */
   private boolean isScrolledInView(View descendent) {
     return getScrollDelta(descendent) == 0;
@@ -498,24 +475,24 @@ public class ReactHorizontalScrollView extends HorizontalScrollView
       FLog.i(TAG, "onScrollChanged[%d] x %d y %d oldx %d oldy %d", getId(), x, y, oldX, oldY);
     }
 
-    super.onScrollChanged(x, y, oldX, oldY);
+    Systrace.beginSection(
+        Systrace.TRACE_TAG_REACT_JAVA_BRIDGE, "ReactHorizontalScrollView.onScrollChanged");
+    try {
+      super.onScrollChanged(x, y, oldX, oldY);
 
-    mActivelyScrolling = true;
+      mActivelyScrolling = true;
 
-    if (mOnScrollDispatchHelper.onScrollChanged(x, y)) {
-      if (mRemoveClippedSubviews) {
-        updateClippingRect();
-      }
-      if (mPreventReentry) {
-        return;
+      if (mOnScrollDispatchHelper.onScrollChanged(x, y)) {
+        if (mRemoveClippedSubviews) {
+          updateClippingRect();
+        }
+        ReactScrollViewHelper.updateStateOnScrollChanged(
+            this,
+            mOnScrollDispatchHelper.getXFlingVelocity(),
+            mOnScrollDispatchHelper.getYFlingVelocity());
       }
-      mPreventReentry = true;
-      ReactScrollViewHelper.updateStateOnScrollChanged(
-          this,
-          mOnScrollDispatchHelper.getXFlingVelocity(),
-          mOnScrollDispatchHelper.getYFlingVelocity(),
-          mEnableSyncOnScroll);
-      mPreventReentry = false;
+    } finally {
+      Systrace.endSection(Systrace.TRACE_TAG_REACT_JAVA_BRIDGE);
     }
   }
 
@@ -791,12 +768,18 @@ public class ReactHorizontalScrollView extends HorizontalScrollView
       return;
     }
 
-    Assertions.assertNotNull(mClippingRect);
+    Systrace.beginSection(
+        Systrace.TRACE_TAG_REACT_JAVA_BRIDGE, "ReactHorizontalScrollView.updateClippingRect");
+    try {
+      Assertions.assertNotNull(mClippingRect);
 
-    ReactClippingViewGroupHelper.calculateClippingRect(this, mClippingRect);
-    View contentView = getContentView();
-    if (contentView instanceof ReactClippingViewGroup) {
-      ((ReactClippingViewGroup) contentView).updateClippingRect();
+      ReactClippingViewGroupHelper.calculateClippingRect(this, mClippingRect);
+      View contentView = getContentView();
+      if (contentView instanceof ReactClippingViewGroup) {
+        ((ReactClippingViewGroup) contentView).updateClippingRect();
+      }
+    } finally {
+      Systrace.endSection(Systrace.TRACE_TAG_REACT_JAVA_BRIDGE);
     }
   }
 
@@ -1105,13 +1088,9 @@ public class ReactHorizontalScrollView extends HorizontalScrollView
     int firstOffset = 0;
     int lastOffset = maximumOffset;
     int width = getWidth() - ViewCompat.getPaddingStart(this) - ViewCompat.getPaddingEnd(this);
-    int layoutDirection =
-        ReactNativeFeatureFlags.setAndroidLayoutDirection()
-            ? getLayoutDirection()
-            : mReactScrollViewScrollState.getLayoutDirection();
 
     // offsets are from the right edge in RTL layouts
-    if (layoutDirection == LAYOUT_DIRECTION_RTL) {
+    if (getLayoutDirection() == LAYOUT_DIRECTION_RTL) {
       targetOffset = maximumOffset - targetOffset;
       velocityX = -velocityX;
     }
@@ -1201,7 +1180,7 @@ public class ReactHorizontalScrollView extends HorizontalScrollView
     // if scrolling after the last snap offset and snapping to the
     // end of the list is disabled, then we allow free scrolling
     int currentOffset = getScrollX();
-    if (layoutDirection == LAYOUT_DIRECTION_RTL) {
+    if (getLayoutDirection() == LAYOUT_DIRECTION_RTL) {
       currentOffset = maximumOffset - currentOffset;
     }
     if (!mSnapToEnd && targetOffset >= lastOffset) {
@@ -1241,7 +1220,7 @@ public class ReactHorizontalScrollView extends HorizontalScrollView
     // Make sure the new offset isn't out of bounds
     targetOffset = Math.min(Math.max(0, targetOffset), maximumOffset);
 
-    if (layoutDirection == LAYOUT_DIRECTION_RTL) {
+    if (getLayoutDirection() == LAYOUT_DIRECTION_RTL) {
       targetOffset = maximumOffset - targetOffset;
       velocityX = -velocityX;
     }
@@ -1325,28 +1304,16 @@ public class ReactHorizontalScrollView extends HorizontalScrollView
 
   @Override
   public void setBackgroundColor(int color) {
-    if (ReactNativeFeatureFlags.enableBackgroundStyleApplicator()) {
-      BackgroundStyleApplicator.setBackgroundColor(this, color);
-    } else {
-      mReactBackgroundManager.setBackgroundColor(color);
-    }
+    BackgroundStyleApplicator.setBackgroundColor(this, color);
   }
 
   public void setBorderWidth(int position, float width) {
-    if (ReactNativeFeatureFlags.enableBackgroundStyleApplicator()) {
-      BackgroundStyleApplicator.setBorderWidth(
-          this, LogicalEdge.values()[position], PixelUtil.toDIPFromPixel(width));
-    } else {
-      mReactBackgroundManager.setBorderWidth(position, width);
-    }
+    BackgroundStyleApplicator.setBorderWidth(
+        this, LogicalEdge.values()[position], PixelUtil.toDIPFromPixel(width));
   }
 
   public void setBorderColor(int position, @Nullable Integer color) {
-    if (ReactNativeFeatureFlags.enableBackgroundStyleApplicator()) {
-      BackgroundStyleApplicator.setBorderColor(this, LogicalEdge.values()[position], color);
-    } else {
-      mReactBackgroundManager.setBorderColor(position, color);
-    }
+    BackgroundStyleApplicator.setBorderColor(this, LogicalEdge.values()[position], color);
   }
 
   public void setBorderRadius(float borderRadius) {
@@ -1354,26 +1321,18 @@ public class ReactHorizontalScrollView extends HorizontalScrollView
   }
 
   public void setBorderRadius(float borderRadius, int 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);
-    }
+    @Nullable
+    LengthPercentage radius =
+        Float.isNaN(borderRadius)
+            ? null
+            : new LengthPercentage(
+                PixelUtil.toDIPFromPixel(borderRadius), LengthPercentageType.POINT);
+    BackgroundStyleApplicator.setBorderRadius(this, BorderRadiusProp.values()[position], radius);
   }
 
   public void setBorderStyle(@Nullable String style) {
-    if (ReactNativeFeatureFlags.enableBackgroundStyleApplicator()) {
-      BackgroundStyleApplicator.setBorderStyle(
-          this, style == null ? null : BorderStyle.fromString(style));
-    } else {
-      mReactBackgroundManager.setBorderStyle(style);
-    }
+    BackgroundStyleApplicator.setBorderStyle(
+        this, style == null ? null : BorderStyle.fromString(style));
   }
 
   /**
@@ -1460,15 +1419,12 @@ public class ReactHorizontalScrollView extends HorizontalScrollView
     // does not shift layout. If `maintainVisibleContentPosition` is enabled, we try to adjust
     // position so that the viewport keeps the same insets to previously visible views. TODO: MVCP
     // does not work in RTL.
-    int layoutDirection =
-        ReactNativeFeatureFlags.setAndroidLayoutDirection()
-            ? v.getLayoutDirection()
-            : mReactScrollViewScrollState.getLayoutDirection();
-    if (layoutDirection == LAYOUT_DIRECTION_RTL) {
+    if (v.getLayoutDirection() == LAYOUT_DIRECTION_RTL) {
       adjustPositionForContentChangeRTL(left, right, oldLeft, oldRight);
     } else if (mMaintainVisibleContentPositionHelper != null) {
       mMaintainVisibleContentPositionHelper.updateScrollPosition();
     }
+    ReactScrollViewHelper.emitLayoutChangeEvent(this);
   }
 
   /**