react-native-tvos 0.85.3-0 → 0.86.0-0rc3

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

@@ -101,6 +101,7 @@ public class ReactScrollView extends ScrollView
   private final VelocityHelper mVelocityHelper = new VelocityHelper();
   private final Rect mTempRect = new Rect();
   private final ValueAnimator DEFAULT_FLING_ANIMATOR = ObjectAnimator.ofInt(this, "scrollY", 0, 0);
+  private final @Nullable FpsListener mFpsListener;
 
   private Rect mOverflowInset;
   private @Nullable VirtualViewContainerState mVirtualViewContainerState;
@@ -113,7 +114,6 @@ public class ReactScrollView extends ScrollView
   private boolean mRemoveClippedSubviews;
   private boolean mScrollEnabled;
   private boolean mSendMomentumEvents;
-  private @Nullable FpsListener mFpsListener;
   private @Nullable String mScrollPerfTag;
   private @Nullable Drawable mEndBackground;
   private int mEndFillColor;
@@ -298,6 +298,7 @@ public class ReactScrollView extends ScrollView
     mScrollEnabled = scrollEnabled;
   }
 
+  @Override
   public boolean getScrollEnabled() {
     return mScrollEnabled;
   }
@@ -519,29 +520,39 @@ public class ReactScrollView extends ScrollView
   }
 
   /**
-   * Attempts to scroll-snap to the focused child based on snapToAlignment/scrollSnapAlign.
-   * Returns true if snap scrolling was performed, false otherwise.
+   * Attempts to scroll-snap to the focused child based on snapToAlignment/scrollSnapAlign
+   * or scrollSnapOffset. Returns true if snap scrolling was performed, false otherwise.
    */
   private boolean tryScrollSnapToChild(View focused) {
     if (mSnapToAlignment != SNAP_ALIGNMENT_ITEM) {
       return false;
     }
 
-    kotlin.Pair<View, String> result = ReactScrollViewHelper.findScrollSnapAlign(focused, this);
+    kotlin.Triple<View, String, Integer> result =
+        ReactScrollViewHelper.findScrollSnap(focused, this);
     if (result == null) {
       return false;
     }
 
     View snapTarget = result.getFirst();
     String alignment = result.getSecond();
+    Integer snapOffset = result.getThird();
 
     Rect rect = new Rect();
     snapTarget.getDrawingRect(rect);
     offsetDescendantRectToMyCoords(snapTarget, rect);
 
-    int viewportHeight = getHeight() - getPaddingTop() - getPaddingBottom();
     int maxScrollY = getMaxScrollY();
 
+    if (snapOffset != null) {
+      int targetOffset = ReactScrollViewHelper.computeScrollSnapTargetForOffset(
+          rect.top, snapOffset, mSnapInterval, maxScrollY);
+      reactSmoothScrollTo(getScrollX(), targetOffset);
+      return true;
+    }
+
+    int viewportHeight = getHeight() - getPaddingTop() - getPaddingBottom();
+
     Integer targetOffset = ReactScrollViewHelper.computeScrollSnapOffset(
         rect.top, rect.bottom, viewportHeight, alignment, mSnapInterval, mSnapToItemPadding, maxScrollY);
     if (targetOffset == null) {
@@ -783,6 +794,7 @@ public class ReactScrollView extends ScrollView
       float vScroll = ev.getAxisValue(MotionEvent.AXIS_VSCROLL);
       if (vScroll != 0) {
         // Perform the scroll
+        enableFpsListener();
         boolean result = super.dispatchGenericMotionEvent(ev);
         // Schedule snap alignment to run after scrolling stops
         if (result
@@ -793,6 +805,7 @@ public class ReactScrollView extends ScrollView
           // Cancel any pending post-touch runnable and reschedule
           if (mPostTouchRunnable != null) {
             removeCallbacks(mPostTouchRunnable);
+            mPostTouchRunnable = null;
           }
           mPostTouchRunnable =
               new Runnable() {
@@ -806,9 +819,12 @@ public class ReactScrollView extends ScrollView
                     velocityY = 0;
                   }
                   flingAndSnap(velocityY);
+                  handlePostTouchScrolling(0, velocityY);
                 }
               };
           postOnAnimationDelayed(mPostTouchRunnable, ReactScrollViewHelper.MOMENTUM_DELAY);
+        } else {
+          handlePostTouchScrolling(0, 0);
         }
         return result;
       }
@@ -871,14 +887,6 @@ public class ReactScrollView extends ScrollView
     }
   }
 
-  @Override
-  public boolean getClipToPadding() {
-    if (ReactNativeFeatureFlags.syncAndroidClipToPaddingWithOverflow()) {
-      return mOverflow != Overflow.VISIBLE;
-    }
-    return super.getClipToPadding();
-  }
-
   @Override
   public void getClippingRect(Rect outClippingRect) {
     outClippingRect.set(Assertions.assertNotNull(mClippingRect));
@@ -972,6 +980,7 @@ public class ReactScrollView extends ScrollView
   }
 
   @Nullable
+  @Override
   public StateWrapper getStateWrapper() {
     return mStateWrapper;
   }
@@ -1437,6 +1446,7 @@ public class ReactScrollView extends ScrollView
    * <p>`smoothScrollTo` changes `contentOffset` and we need to keep `contentOffset` in sync between
    * scroll view and state. Calling raw `smoothScrollTo` doesn't update state.
    */
+  @Override
   public void reactSmoothScrollTo(int x, int y) {
     if (mScrollAnimationEnabled || !UiModeUtils.isTVDevice(getContext())) {
       ReactScrollViewHelper.smoothScrollTo(this, x, y);
@@ -1551,10 +1561,6 @@ public class ReactScrollView extends ScrollView
       return;
     }
 
-    if (mMaintainVisibleContentPositionHelper != null) {
-      mMaintainVisibleContentPositionHelper.updateScrollPosition();
-    }
-
     if (isShown() && isContentReady()) {
       int currentScrollY = getScrollY();
       int maxScrollY = getMaxScrollY();
@@ -1612,11 +1618,12 @@ public class ReactScrollView extends ScrollView
    * and that you are **not** overriding the ScrollView content view to pass in a `translateY`
    * style. `translateY` must never be set from ReactJS while using this feature!
    */
-  public void setScrollAwayTopPaddingEnabledUnstable(int topPadding) {
-    setScrollAwayTopPaddingEnabledUnstable(topPadding, true);
+  public void setScrollAwayPaddingEnabledUnstable(int topPadding, int bottomPadding) {
+    setScrollAwayPaddingEnabledUnstable(topPadding, bottomPadding, true);
   }
 
-  public void setScrollAwayTopPaddingEnabledUnstable(int topPadding, boolean updateState) {
+  public void setScrollAwayPaddingEnabledUnstable(
+      int topPadding, int bottomPadding, boolean updateState) {
     int count = getChildCount();
 
     Assertions.assertCondition(
@@ -1633,17 +1640,18 @@ public class ReactScrollView extends ScrollView
       // Add the topPadding value as the bottom padding for the ScrollView.
       // Otherwise, we'll push down the contents of the scroll view down too
       // far off screen.
-      setPadding(0, 0, 0, topPadding);
+      setPadding(0, 0, 0, topPadding + bottomPadding);
     }
 
     if (updateState) {
-      updateScrollAwayState(topPadding);
+      updateScrollAwayState(topPadding, bottomPadding);
     }
     setRemoveClippedSubviews(mRemoveClippedSubviews);
   }
 
-  private void updateScrollAwayState(int scrollAwayPaddingTop) {
+  private void updateScrollAwayState(int scrollAwayPaddingTop, int scrollAwayPaddingBottom) {
     getReactScrollViewScrollState().setScrollAwayPaddingTop(scrollAwayPaddingTop);
+    getReactScrollViewScrollState().setScrollAwayPaddingBottom(scrollAwayPaddingBottom);
     ReactScrollViewHelper.forceUpdateState(this);
   }
 
@@ -1652,7 +1660,8 @@ public class ReactScrollView extends ScrollView
     mReactScrollViewScrollState = scrollState;
     if (ReactNativeFeatureFlags.enableViewCulling()
         || ReactNativeFeatureFlags.useTraitHiddenOnAndroid()) {
-      setScrollAwayTopPaddingEnabledUnstable(scrollState.getScrollAwayPaddingTop(), false);
+      setScrollAwayPaddingEnabledUnstable(
+          scrollState.getScrollAwayPaddingTop(), scrollState.getScrollAwayPaddingBottom(), false);
 
       Point scrollPosition = scrollState.getLastStateUpdateScroll();
       scrollTo(scrollPosition.x, scrollPosition.y);

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

@@ -31,7 +31,6 @@ import com.facebook.react.uimanager.ReactClippingViewGroup
 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 com.facebook.react.views.view.ReactViewGroup
 import java.lang.ref.WeakReference
 import java.util.concurrent.CopyOnWriteArrayList
@@ -46,6 +45,7 @@ public object ReactScrollViewHelper {
   private const val CONTENT_OFFSET_LEFT = "contentOffsetLeft"
   private const val CONTENT_OFFSET_TOP = "contentOffsetTop"
   private const val SCROLL_AWAY_PADDING_TOP = "scrollAwayPaddingTop"
+  private const val SCROLL_AWAY_PADDING_BOTTOM = "scrollAwayPaddingBottom"
 
   public const val MOMENTUM_DELAY: Long = 20
   public const val OVER_SCROLL_ALWAYS: String = "always"
@@ -351,9 +351,6 @@ public object ReactScrollViewHelper {
           scrollY,
       )
     }
-    if (ViewUtil.getUIManagerType(scrollView.id) == UIManagerType.LEGACY) {
-      return
-    }
     // NOTE: if the state wrapper is null, we shouldn't even update
     // the scroll state because there is a chance of going out of sync!
     if (scrollView.stateWrapper == null) {
@@ -377,6 +374,7 @@ public object ReactScrollViewHelper {
       where T : HasScrollState?, T : HasStateWrapper?, T : ViewGroup {
     val scrollState = scrollView.reactScrollViewScrollState
     val scrollAwayPaddingTop = scrollState.scrollAwayPaddingTop
+    val scrollAwayPaddingBottom = scrollState.scrollAwayPaddingBottom
     val scrollPos = scrollState.lastStateUpdateScroll
     val scrollX = scrollPos.x
     val scrollY = scrollPos.y
@@ -398,6 +396,10 @@ public object ReactScrollViewHelper {
           SCROLL_AWAY_PADDING_TOP,
           toDIPFromPixel(scrollAwayPaddingTop.toFloat()).toDouble(),
       )
+      newStateData.putDouble(
+          SCROLL_AWAY_PADDING_BOTTOM,
+          toDIPFromPixel(scrollAwayPaddingBottom.toFloat()).toDouble(),
+      )
       stateWrapper.updateState(newStateData)
     }
   }
@@ -418,9 +420,14 @@ public object ReactScrollViewHelper {
     val scrollX = toPixelFromDIP(stateData.getDouble(CONTENT_OFFSET_LEFT)).toInt()
     val scrollY = toPixelFromDIP(stateData.getDouble(CONTENT_OFFSET_TOP)).toInt()
     val scrollAwayPaddingTop = toPixelFromDIP(stateData.getDouble(SCROLL_AWAY_PADDING_TOP)).toInt()
+    val scrollAwayPaddingBottom =
+        toPixelFromDIP(stateData.getDouble(SCROLL_AWAY_PADDING_BOTTOM)).toInt()
 
     val scrollState =
-        scrollView.reactScrollViewScrollState.copy(scrollAwayPaddingTop = scrollAwayPaddingTop)
+        scrollView.reactScrollViewScrollState.copy(
+            scrollAwayPaddingTop = scrollAwayPaddingTop,
+            scrollAwayPaddingBottom = scrollAwayPaddingBottom,
+        )
     scrollState.setLastStateUpdateScroll(scrollX, scrollY)
     scrollView.reactScrollViewScrollState = scrollState
   }
@@ -569,27 +576,67 @@ public object ReactScrollViewHelper {
 
   /**
    * Walks up the view hierarchy from the focused view to find a ReactViewGroup with
-   * scrollSnapAlign set. Returns a Pair of (snapTarget, alignment) or null if not found.
+   * either scrollSnapAlign or scrollSnapOffset set. Returns a Triple of (snapTarget,
+   * alignment, offsetPx) or null if neither marker was found. Exactly one of
+   * alignment/offsetPx is non-null on return.
+   *
+   * Walk is inner→outer, latest marker wins. On a single view declaring both,
+   * scrollSnapOffset wins as the more specific config.
    *
    * Shared by [ReactScrollView] and [ReactHorizontalScrollView].
    */
   @JvmStatic
-  public fun findScrollSnapAlign(focused: View, scrollView: ViewGroup): Pair<View, String>? {
+  public fun findScrollSnap(focused: View, scrollView: ViewGroup): Triple<View, String?, Int?>? {
     var view: View? = focused
     var snapTarget: View? = null
     var alignment: String? = null
+    var offset: Int? = null
     while (view != null && view !== scrollView) {
       if (view is ReactViewGroup) {
-        val snap = view.scrollSnapAlign
-        if (snap != null) {
-          alignment = snap
+        val o = view.scrollSnapOffset
+        val a = view.scrollSnapAlign
+        if (o != null) {
+          offset = o
+          alignment = null
+          snapTarget = view
+        } else if (a != null) {
+          alignment = a
+          offset = null
           snapTarget = view
         }
       }
       val parent = view.parent
       view = if (parent is View) parent else null
     }
-    return if (alignment != null && snapTarget != null) Pair(snapTarget, alignment) else null
+    return if (snapTarget != null && (alignment != null || offset != null))
+        Triple(snapTarget, alignment, offset) else null
+  }
+
+  /**
+   * Computes the target scroll offset for the per-item scrollSnapOffset path:
+   * land the snap target's leading edge at `snapOffset` pixels from the viewport origin.
+   *
+   * Returns the clamped target offset.
+   *
+   * Shared by [ReactScrollView] and [ReactHorizontalScrollView].
+   *
+   * @param focusedStart the start coordinate of the snap target in scroll view coordinates
+   * @param snapOffset the per-item pixel offset from the viewport origin
+   * @param snapInterval the snap interval (0 if not set)
+   * @param maxScrollOffset the maximum scroll offset for clamping
+   */
+  @JvmStatic
+  public fun computeScrollSnapTargetForOffset(
+      focusedStart: Int,
+      snapOffset: Int,
+      snapInterval: Int,
+      maxScrollOffset: Int,
+  ): Int {
+    var targetOffset = focusedStart - snapOffset
+    if (snapInterval > 0) {
+      targetOffset = (Math.floor(targetOffset.toDouble() / snapInterval) * snapInterval).toInt()
+    }
+    return Math.max(0, Math.min(targetOffset, maxScrollOffset))
   }
 
   /**
@@ -691,6 +738,8 @@ public object ReactScrollViewHelper {
       val finalAnimatedPositionScroll: Point = Point(),
       /** Get the padding on the top for nav bar */
       var scrollAwayPaddingTop: Int = 0,
+      /** 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),
       /** Get true if the previous animation was canceled */

package/ReactAndroid/src/main/java/com/facebook/react/views/text/FontMetricsUtil.kt

@@ -7,10 +7,10 @@
 
 package com.facebook.react.views.text
 
-import android.content.Context
 import android.graphics.Rect
 import android.text.Layout
 import android.text.TextPaint
+import android.util.DisplayMetrics
 import com.facebook.react.bridge.Arguments
 import com.facebook.react.bridge.WritableArray
 import com.facebook.react.bridge.buildReadableMap
@@ -22,8 +22,7 @@ internal object FontMetricsUtil {
   private const val AMPLIFICATION_FACTOR = 100f
 
   @JvmStatic
-  fun getFontMetrics(text: CharSequence, layout: Layout, context: Context): WritableArray {
-    val dm = context.resources.displayMetrics
+  fun getFontMetrics(text: CharSequence, layout: Layout, dm: DisplayMetrics): WritableArray {
     val lines = Arguments.createArray()
 
     // To calculate xHeight and capHeight we have to render an "x" and "T" and manually measure

package/ReactAndroid/src/main/java/com/facebook/react/views/text/ReactTextView.java

@@ -26,37 +26,29 @@ import android.view.View;
 import android.view.ViewGroup;
 import androidx.annotation.Nullable;
 import androidx.appcompat.widget.AppCompatTextView;
-import androidx.appcompat.widget.TintContextWrapper;
 import androidx.core.view.AccessibilityDelegateCompat;
 import androidx.core.view.ViewCompat;
 import androidx.customview.widget.ExploreByTouchHelper;
 import com.facebook.react.views.common.UiModeUtils;
 import com.facebook.common.logging.FLog;
-import com.facebook.infer.annotation.Assertions;
 import com.facebook.infer.annotation.Nullsafe;
 import com.facebook.react.bridge.Arguments;
-import com.facebook.react.bridge.ReactContext;
 import com.facebook.react.bridge.WritableMap;
 import com.facebook.react.common.ReactConstants;
 import com.facebook.react.common.annotations.UnstableReactNativeAPI;
-import com.facebook.react.common.build.ReactBuildConfig;
 import com.facebook.react.internal.SystraceSection;
 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.ReactCompoundView;
-import com.facebook.react.uimanager.UIManagerModule;
 import com.facebook.react.uimanager.ViewDefaults;
-import com.facebook.react.uimanager.common.UIManagerType;
-import com.facebook.react.uimanager.common.ViewUtil;
 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.text.internal.span.ReactFragmentIndexSpan;
 import com.facebook.react.views.text.internal.span.ReactTagSpan;
-import com.facebook.react.views.text.internal.span.TextInlineViewPlaceholderSpan;
 import com.facebook.yoga.YogaMeasureMode;
 
 @Nullsafe(Nullsafe.Mode.LOCAL)
@@ -206,164 +198,14 @@ public class ReactTextView extends AppCompatTextView implements ReactCompoundVie
     return json;
   }
 
-  private ReactContext getReactContext() {
-    Context context = getContext();
-    return (context instanceof TintContextWrapper)
-        ? (ReactContext) ((TintContextWrapper) context).getBaseContext()
-        : (ReactContext) context;
-  }
-
   @Override
   protected void onLayout(
       boolean changed, int textViewLeft, int textViewTop, int textViewRight, int textViewBottom) {
     // TODO T62882314: Delete this method when Fabric is fully released in OSS
-    int reactTag = getId();
-    if (!(getText() instanceof Spanned)
-        || ViewUtil.getUIManagerType(reactTag) == UIManagerType.FABRIC
-        || ReactBuildConfig.UNSTABLE_ENABLE_MINIFY_LEGACY_ARCHITECTURE) {
-      /**
-       * In general, {@link #setText} is called via {@link ReactTextViewManager#updateExtraData}
-       * before we are laid out. This ordering is a requirement because we utilize the data from
-       * setText in onLayout.
-       *
-       * <p>However, it's possible for us to get an extra layout before we've received our setText
-       * call. If this happens before the initial setText call, then getText() will have its default
-       * value which isn't a Spanned and we need to bail out. That's fine because we'll get a
-       * setText followed by a layout later.
-       *
-       * <p>The cause for the extra early layout is that an ancestor gets transitioned from a
-       * layout-only node to a non layout-only node.
-       */
-      return;
-    }
-
-    ReactContext reactContext = getReactContext();
-    UIManagerModule uiManager =
-        Assertions.assertNotNull(reactContext.getNativeModule(UIManagerModule.class));
-
-    Spanned text = (Spanned) getText();
-    Layout layout = getLayout();
-    if (layout == null) {
-      // Text layout is calculated during pre-draw phase, so in some cases it can be empty during
-      // layout phase, which usually happens before drawing.
-      // The text layout is created by private {@link assumeLayout} method, which we can try to
-      // invoke directly through reflection or indirectly through some methods that compute it
-      // (e.g. {@link getExtendedPaddingTop}).
-      // It is safer, however, to just early return here, as next measure/layout passes are way more
-      // likely to have the text layout computed.
-      return;
-    }
-
-    TextInlineViewPlaceholderSpan[] placeholders =
-        text.getSpans(0, text.length(), TextInlineViewPlaceholderSpan.class);
-    int textViewWidth = textViewRight - textViewLeft;
-    int textViewHeight = textViewBottom - textViewTop;
-
-    for (TextInlineViewPlaceholderSpan placeholder : placeholders) {
-      View child = uiManager.resolveView(placeholder.getReactTag());
-
-      if (child == null) {
-        continue;
-      }
-
-      int start = text.getSpanStart(placeholder);
-      int line = layout.getLineForOffset(start);
-      boolean isLineTruncated = layout.getEllipsisCount(line) > 0;
-
-      if ( // This truncation check works well on recent versions of Android (tested on 5.1.1 and
-      // 6.0.1) but not on Android 4.4.4. The reason is that getEllipsisCount is buggy on
-      // Android 4.4.4. Specifically, it incorrectly returns 0 if an inline view is the first
-      // thing to be truncated.
-      (isLineTruncated && start >= layout.getLineStart(line) + layout.getEllipsisStart(line))
-          ||
-
-          // This truncation check works well on Android 4.4.4 but not on others (e.g. 6.0.1).
-          // On Android 4.4.4, getLineEnd returns the first truncated character whereas on 6.0.1,
-          // it appears to return the position after the last character on the line even if that
-          // character is truncated.
-          line >= mNumberOfLines
-          || start >= layout.getLineEnd(line)) {
-        // On some versions of Android (e.g. 4.4.4, 5.1.1), getPrimaryHorizontal can infinite
-        // loop when called on a character that appears after the ellipsis. Avoid this bug by
-        // special casing the character truncation case.
-        child.setVisibility(View.GONE);
-      } else {
-        int width = placeholder.getWidth();
-        int height = placeholder.getHeight();
-
-        // Calculate if the direction of the placeholder character is Right-To-Left.
-        boolean isRtlChar = layout.isRtlCharAt(start);
-
-        boolean isRtlParagraph = layout.getParagraphDirection(line) == Layout.DIR_RIGHT_TO_LEFT;
-
-        int placeholderHorizontalPosition;
-        // There's a bug on Samsung devices where calling getPrimaryHorizontal on
-        // the last offset in the layout will result in an endless loop. Work around
-        // this bug by avoiding getPrimaryHorizontal in that case.
-        if (start == text.length() - 1) {
-          boolean endsWithNewLine =
-              text.length() > 0 && text.charAt(layout.getLineEnd(line) - 1) == '\n';
-          float lineWidth = endsWithNewLine ? layout.getLineMax(line) : layout.getLineWidth(line);
-          placeholderHorizontalPosition =
-              isRtlParagraph
-                  // Equivalent to `layout.getLineLeft(line)` but `getLineLeft` returns incorrect
-                  // values when the paragraph is RTL and `setSingleLine(true)`.
-                  ? textViewWidth - (int) lineWidth
-                  : (int) layout.getLineRight(line) - width;
-        } else {
-          // The direction of the paragraph may not be exactly the direction the string is heading
-          // in at the
-          // position of the placeholder. So, if the direction of the character is the same as the
-          // paragraph
-          // use primary, secondary otherwise.
-          boolean characterAndParagraphDirectionMatch = isRtlParagraph == isRtlChar;
-
-          placeholderHorizontalPosition =
-              characterAndParagraphDirectionMatch
-                  ? (int) layout.getPrimaryHorizontal(start)
-                  : (int) layout.getSecondaryHorizontal(start);
-
-          if (isRtlParagraph) {
-            // Adjust `placeholderHorizontalPosition` to work around an Android bug.
-            // The bug is when the paragraph is RTL and `setSingleLine(true)`, some layout
-            // methods such as `getPrimaryHorizontal`, `getSecondaryHorizontal`, and
-            // `getLineRight` return incorrect values. Their return values seem to be off
-            // by the same number of pixels so subtracting these values cancels out the error.
-            //
-            // The result is equivalent to bugless versions of
-            // `getPrimaryHorizontal`/`getSecondaryHorizontal`.
-            placeholderHorizontalPosition =
-                textViewWidth - ((int) layout.getLineRight(line) - placeholderHorizontalPosition);
-          }
-
-          if (isRtlChar) {
-            placeholderHorizontalPosition -= width;
-          }
-        }
-
-        int leftRelativeToTextView =
-            isRtlChar
-                ? placeholderHorizontalPosition + getTotalPaddingRight()
-                : placeholderHorizontalPosition + getTotalPaddingLeft();
-
-        int left = textViewLeft + leftRelativeToTextView;
-
-        // Vertically align the inline view to the baseline of the line of text.
-        int topRelativeToTextView = getTotalPaddingTop() + layout.getLineBaseline(line) - height;
-        int top = textViewTop + topRelativeToTextView;
-
-        boolean isFullyClipped =
-            textViewWidth <= leftRelativeToTextView || textViewHeight <= topRelativeToTextView;
-        int layoutVisibility = isFullyClipped ? View.GONE : View.VISIBLE;
-        int layoutLeft = left;
-        int layoutTop = top;
-        int layoutRight = left + width;
-        int layoutBottom = top + height;
-
-        child.setVisibility(layoutVisibility);
-        child.layout(layoutLeft, layoutTop, layoutRight, layoutBottom);
-      }
-    }
+    // In Fabric, setText is called via ReactTextViewManager#updateExtraData
+    // before we are laid out. This ordering is a requirement because we utilize the data from
+    // setText in onLayout. The early return here is safe because the text layout is handled
+    // correctly in Fabric.
   }
 
   @Override
@@ -604,6 +446,7 @@ public class ReactTextView extends AppCompatTextView implements ReactCompoundVie
     mShouldAdjustSpannableFontSize = true;
   }
 
+  @Override
   public void setLetterSpacing(float letterSpacing) {
     if (Float.isNaN(letterSpacing)) {
       return;

package/ReactAndroid/src/main/java/com/facebook/react/views/text/ReactTextViewManager.kt

@@ -157,7 +157,7 @@ public constructor(
         state.getMapBuffer(TX_STATE_KEY_PARAGRAPH_ATTRIBUTES.toInt())
     val spanned: Spannable =
         TextLayoutManager.getOrCreateSpannableForText(
-            view.context,
+            view.context.assets,
             attributedString,
             reactTextViewManagerCallback,
         )