react-native-tvos 0.78.0-0rc4 → 0.79.0-0

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

@@ -0,0 +1,335 @@
+/*
+ * 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.text
+
+import android.graphics.Paint
+import android.graphics.Rect
+import android.os.Bundle
+import android.text.Spannable
+import android.text.Spanned
+import android.text.style.AbsoluteSizeSpan
+import android.text.style.ClickableSpan
+import android.view.View
+import android.widget.TextView
+import androidx.core.view.ViewCompat
+import androidx.core.view.accessibility.AccessibilityNodeInfoCompat
+import androidx.core.view.accessibility.AccessibilityNodeProviderCompat
+import com.facebook.react.R
+import com.facebook.react.uimanager.ReactAccessibilityDelegate
+import com.facebook.react.views.text.internal.span.ReactClickableSpan
+import kotlin.math.ceil
+
+internal class ReactTextViewAccessibilityDelegate : ReactAccessibilityDelegate {
+  public constructor(
+      view: View,
+      originalFocus: Boolean,
+      originalImportantForAccessibility: Int
+  ) : super(view, originalFocus, originalImportantForAccessibility) {
+    accessibilityLinks = hostView.getTag(R.id.accessibility_links) as AccessibilityLinks?
+  }
+
+  private var accessibilityLinks: AccessibilityLinks? = null
+
+  public companion object {
+    public fun setDelegate(
+        view: View,
+        originalFocus: Boolean,
+        originalImportantForAccessibility: Int
+    ) {
+      // if a view already has an accessibility delegate, replacing it could cause
+      // problems,so leave it alone.
+      if (!ViewCompat.hasAccessibilityDelegate(view) &&
+          (view.getTag(R.id.accessibility_role) != null ||
+              view.getTag(R.id.accessibility_state) != null ||
+              view.getTag(R.id.accessibility_actions) != null ||
+              view.getTag(R.id.react_test_id) != null ||
+              view.getTag(R.id.accessibility_collection_item) != null ||
+              view.getTag(R.id.accessibility_links) != null ||
+              view.getTag(R.id.role) != null)) {
+        ViewCompat.setAccessibilityDelegate(
+            view,
+            ReactTextViewAccessibilityDelegate(
+                view, originalFocus, originalImportantForAccessibility))
+      }
+    }
+
+    public fun resetDelegate(
+        view: View,
+        originalFocus: Boolean,
+        originalImportantForAccessibility: Int
+    ) {
+      ViewCompat.setAccessibilityDelegate(
+          view,
+          ReactTextViewAccessibilityDelegate(
+              view, originalFocus, originalImportantForAccessibility))
+    }
+  }
+
+  override fun onVirtualViewKeyboardFocusChanged(virtualViewId: Int, hasFocus: Boolean) {
+    if (accessibilityLinks == null) {
+      return
+    }
+
+    val link = accessibilityLinks?.getLinkById(virtualViewId) ?: return
+
+    val span = getFirstSpan(link.start, link.end, ClickableSpan::class.java)
+    if (span == null || span !is ReactClickableSpan || hostView !is ReactTextView) {
+      return
+    }
+
+    // TODO: When we refactor ReactTextView, implement this using
+    // https://developer.android.com/reference/android/text/Layout
+    span.isKeyboardFocused = hasFocus
+    span.focusBgColor = (hostView as TextView).highlightColor
+    hostView.invalidate()
+  }
+
+  override fun onPerformActionForVirtualView(
+      virtualViewId: Int,
+      action: Int,
+      arguments: Bundle?
+  ): Boolean {
+    if (accessibilityLinks == null) {
+      return false
+    }
+
+    val link = accessibilityLinks?.getLinkById(virtualViewId) ?: return false
+
+    val span = getFirstSpan(link.start, link.end, ClickableSpan::class.java)
+    if (span == null || span !is ReactClickableSpan) {
+      return false
+    }
+
+    if (action == AccessibilityNodeInfoCompat.ACTION_CLICK) {
+      span.onClick(hostView)
+      return true
+    }
+
+    return false
+  }
+
+  override fun getVisibleVirtualViews(virtualViewIds: MutableList<Int?>) {
+    val accessibilityLinks = accessibilityLinks ?: return
+
+    for (i in 0 until accessibilityLinks.size()) {
+      virtualViewIds.add(i)
+    }
+  }
+
+  override fun getVirtualViewAt(x: Float, y: Float): Int {
+    val accessibilityLinks = accessibilityLinks ?: return INVALID_ID
+    if (accessibilityLinks.size() == 0 || hostView !is TextView) {
+      return INVALID_ID
+    }
+
+    var x = x
+    var y = y
+
+    val textView = hostView as TextView
+    if (textView.text !is Spanned) {
+      return INVALID_ID
+    }
+
+    val layout = textView.layout ?: return INVALID_ID
+
+    x -= textView.totalPaddingLeft.toFloat()
+    y -= textView.totalPaddingTop.toFloat()
+    x += textView.scrollX.toFloat()
+    y += textView.scrollY.toFloat()
+
+    val line = layout.getLineForVertical(y.toInt())
+    val charOffset = layout.getOffsetForHorizontal(line, x)
+
+    val clickableSpan =
+        getFirstSpan(charOffset, charOffset, ClickableSpan::class.java) ?: return INVALID_ID
+
+    val spanned = textView.text as Spanned
+    val start = spanned.getSpanStart(clickableSpan)
+    val end = spanned.getSpanEnd(clickableSpan)
+
+    val link: AccessibilityLinks.AccessibleLink? = accessibilityLinks.getLinkBySpanPos(start, end)
+    return link?.id ?: INVALID_ID
+  }
+
+  protected fun <T> getFirstSpan(start: Int, end: Int, classType: Class<T>?): T? {
+    if (hostView !is TextView || (hostView as TextView).text !is Spanned) {
+      return null
+    }
+
+    val spanned = (hostView as TextView).text as Spanned
+    val spans = spanned.getSpans(start, end, classType)
+    return if (spans.isNotEmpty()) spans[0] else null
+  }
+
+  @Suppress("DEPRECATION")
+  override fun onPopulateNodeForVirtualView(virtualViewId: Int, node: AccessibilityNodeInfoCompat) {
+    // If we get an invalid virtualViewId for some reason (which is known to happen in API 19 and
+    // below), return an "empty" node to prevent from crashing. This will never be presented to
+    // the user, as Talkback filters out nodes with no content to announce.
+    val accessibilityLinks = accessibilityLinks
+    if (accessibilityLinks == null) {
+      node.contentDescription = ""
+      node.setBoundsInParent(Rect(0, 0, 1, 1))
+      return
+    }
+
+    val accessibleTextSpan: AccessibilityLinks.AccessibleLink? =
+        accessibilityLinks.getLinkById(virtualViewId)
+    if (accessibleTextSpan == null) {
+      node.contentDescription = ""
+      node.setBoundsInParent(Rect(0, 0, 1, 1))
+      return
+    }
+
+    // NOTE: The span may not actually have visible bounds within its parent,
+    // due to line limits, etc.
+    val bounds = getBoundsInParent(accessibleTextSpan)
+    if (bounds == null) {
+      node.contentDescription = ""
+      node.setBoundsInParent(Rect(0, 0, 1, 1))
+      return
+    }
+
+    node.contentDescription = accessibleTextSpan.description
+    node.addAction(AccessibilityNodeInfoCompat.ACTION_CLICK)
+    node.setBoundsInParent(bounds)
+    node.roleDescription = hostView.resources.getString(R.string.link_description)
+    node.className = AccessibilityRole.getValue(AccessibilityRole.BUTTON)
+  }
+
+  private fun getBoundsInParent(accessibleLink: AccessibilityLinks.AccessibleLink): Rect? {
+    // This view is not a text view, so return the entire views bounds.
+    if (hostView !is TextView) {
+      return Rect(0, 0, hostView.width, hostView.height)
+    }
+
+    val textView = hostView as TextView
+    val textViewLayout = textView.layout ?: return Rect(0, 0, textView.width, textView.height)
+
+    val startOffset = accessibleLink.start
+    val endOffset = accessibleLink.end
+
+    // Ensure the link hasn't been ellipsized away; in such cases,
+    // getPrimaryHorizontal will crash (and the link isn't rendered anyway).
+    val startOffsetLineNumber = textViewLayout.getLineForOffset(startOffset)
+    val lineEndOffset = textViewLayout.getLineEnd(startOffsetLineNumber)
+    if (startOffset > lineEndOffset) {
+      return null
+    }
+
+    val rootRect = Rect()
+
+    val startXCoordinates = textViewLayout.getPrimaryHorizontal(startOffset).toDouble()
+
+    val paint = Paint()
+    val sizeSpan =
+        getFirstSpan(accessibleLink.start, accessibleLink.end, AbsoluteSizeSpan::class.java)
+    val textSize = sizeSpan?.size?.toFloat() ?: textView.textSize
+    paint.textSize = textSize
+    val textWidth = ceil(paint.measureText(accessibleLink.description).toDouble()).toInt()
+
+    val endOffsetLineNumber = textViewLayout.getLineForOffset(endOffset)
+    val isMultiline = startOffsetLineNumber != endOffsetLineNumber
+    textViewLayout.getLineBounds(startOffsetLineNumber, rootRect)
+
+    val verticalOffset = textView.scrollY + textView.totalPaddingTop
+    rootRect.top += verticalOffset
+    rootRect.bottom += verticalOffset
+    rootRect.left =
+        (rootRect.left + (startXCoordinates + textView.totalPaddingLeft - textView.scrollX)).toInt()
+
+    // The bounds for multi-line strings should *only* include the first line. This is because for
+    // API 25 and below, Talkback's click is triggered at the center point of these bounds, and if
+    // that center point is outside the spannable, it will click on something else. There is no
+    // harm in not outlining the wrapped part of the string, as the text for the whole string will
+    // be read regardless of the bounding box.
+    if (isMultiline) {
+      return Rect(rootRect.left, rootRect.top, rootRect.right, rootRect.bottom)
+    }
+
+    return Rect(rootRect.left, rootRect.top, rootRect.left + textWidth, rootRect.bottom)
+  }
+
+  override fun getAccessibilityNodeProvider(host: View): AccessibilityNodeProviderCompat? {
+    // Only set a NodeProvider if we have virtual views, otherwise just return null here so that
+    // we fall back to the View class's default behavior. If we don't do this, then Views with
+    // no virtual children will fall back to using ExploreByTouchHelper's onPopulateNodeForHost
+    // method to populate their AccessibilityNodeInfo, which defaults to doing nothing, so no
+    // AccessibilityNodeInfo will be created. Alternatively, we could override
+    // onPopulateNodeForHost instead, and have it create an AccessibilityNodeInfo for the host
+    // but this is what the default View class does by itself, so we may as well defer to it.
+    if (accessibilityLinks != null) {
+      return superGetAccessibilityNodeProvider(host)
+    }
+
+    return null
+  }
+
+  public class AccessibilityLinks(spans: Array<ClickableSpan?>, text: Spannable) {
+    private val links: List<AccessibleLink>
+
+    init {
+      val accessibleLinks = mutableListOf<AccessibleLink>()
+      for (i in spans.indices) {
+        val span = spans[i]
+        val start = text.getSpanStart(span)
+        val end = text.getSpanEnd(span)
+        // zero length spans, and out of range spans should not be included.
+        if (start == end || start < 0 || end < 0 || start > text.length || end > text.length) {
+          continue
+        }
+
+        val link = AccessibleLink()
+        link.description = text.subSequence(start, end).toString()
+        link.start = start
+        link.end = end
+
+        // ID is the reverse of what is expected, since the ClickableSpans are returned in reverse
+        // order due to being added in reverse order. If we don't do this, focus will move to the
+        // last link first and move backwards.
+        //
+        // If this approach becomes unreliable, we should instead look at their start position and
+        // order them manually.
+        link.id = spans.size - 1 - i
+        accessibleLinks.add(link)
+      }
+      links = accessibleLinks
+    }
+
+    public fun getLinkById(id: Int): AccessibleLink? {
+      for (link in links) {
+        if (link.id == id) {
+          return link
+        }
+      }
+
+      return null
+    }
+
+    public fun getLinkBySpanPos(start: Int, end: Int): AccessibleLink? {
+      for (link in links) {
+        if (link.start == start && link.end == end) {
+          return link
+        }
+      }
+
+      return null
+    }
+
+    public fun size(): Int {
+      return links.size
+    }
+
+    public class AccessibleLink {
+      public var description: String? = null
+      public var start: Int = 0
+      public var end: Int = 0
+      public var id: Int = 0
+    }
+  }
+}

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

@@ -18,9 +18,9 @@ import com.facebook.react.common.MapBuilder;
 import com.facebook.react.common.annotations.VisibleForTesting;
 import com.facebook.react.common.mapbuffer.MapBuffer;
 import com.facebook.react.internal.SystraceSection;
+import com.facebook.react.internal.featureflags.ReactNativeFeatureFlags;
 import com.facebook.react.module.annotations.ReactModule;
 import com.facebook.react.uimanager.IViewManagerWithChildren;
-import com.facebook.react.uimanager.ReactAccessibilityDelegate;
 import com.facebook.react.uimanager.ReactStylesDiffMap;
 import com.facebook.react.uimanager.StateWrapper;
 import com.facebook.react.uimanager.ThemedReactContext;
@@ -58,7 +58,9 @@ public class ReactTextViewManager
 
   public ReactTextViewManager(@Nullable ReactTextViewManagerCallback reactTextViewManagerCallback) {
     mReactTextViewManagerCallback = reactTextViewManagerCallback;
-    setupViewRecycling();
+    if (ReactNativeFeatureFlags.enableViewRecyclingForText()) {
+      setupViewRecycling();
+    }
   }
 
   @Override
@@ -80,6 +82,12 @@ public class ReactTextViewManager
     return REACT_CLASS;
   }
 
+  @Override
+  protected void updateViewAccessibility(@NonNull ReactTextView view) {
+    ReactTextViewAccessibilityDelegate.Companion.setDelegate(
+        view, view.isFocusable(), view.getImportantForAccessibility());
+  }
+
   @Override
   public ReactTextView createViewInstance(ThemedReactContext context) {
     return new ReactTextView(context);
@@ -99,14 +107,13 @@ public class ReactTextViewManager
       // delegate so that these can be picked up by the accessibility system.
       ReactClickableSpan[] clickableSpans =
           spannable.getSpans(0, update.getText().length(), ReactClickableSpan.class);
-
-      if (clickableSpans.length > 0) {
-        view.setTag(
-            R.id.accessibility_links,
-            new ReactAccessibilityDelegate.AccessibilityLinks(clickableSpans, spannable));
-        ReactAccessibilityDelegate.resetDelegate(
-            view, view.isFocusable(), view.getImportantForAccessibility());
-      }
+      view.setTag(
+          R.id.accessibility_links,
+          clickableSpans.length > 0
+              ? new ReactTextViewAccessibilityDelegate.AccessibilityLinks(clickableSpans, spannable)
+              : null);
+      ReactTextViewAccessibilityDelegate.Companion.resetDelegate(
+          view, view.isFocusable(), view.getImportantForAccessibility());
     }
   }
 

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

@@ -19,20 +19,20 @@ import com.facebook.react.uimanager.ThemedReactContext
 @ReactModule(name = ReactVirtualTextViewManager.REACT_CLASS)
 internal class ReactVirtualTextViewManager : BaseViewManager<View, ReactVirtualTextShadowNode>() {
 
-  public override fun getName(): String = REACT_CLASS
+  override fun getName(): String = REACT_CLASS
 
-  protected override fun createViewInstance(context: ThemedReactContext): View {
+  override fun createViewInstance(context: ThemedReactContext): View {
     throw IllegalStateException("Attempt to create a native view for RCTVirtualText")
   }
 
-  public override fun updateExtraData(view: View, extraData: Any): Unit {}
+  override fun updateExtraData(view: View, extraData: Any): Unit = Unit
 
-  public override fun getShadowNodeClass(): Class<ReactVirtualTextShadowNode> =
+  override fun getShadowNodeClass(): Class<ReactVirtualTextShadowNode> =
       ReactVirtualTextShadowNode::class.java
 
   override fun createShadowNodeInstance(): ReactVirtualTextShadowNode = ReactVirtualTextShadowNode()
 
   internal companion object {
-    public const val REACT_CLASS: String = "RCTVirtualText"
+    const val REACT_CLASS: String = "RCTVirtualText"
   }
 }

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

@@ -11,9 +11,11 @@ import android.content.Context;
 import android.content.res.Resources;
 import android.net.Uri;
 import androidx.annotation.Nullable;
+import androidx.core.util.Preconditions;
 import com.facebook.common.logging.FLog;
 import com.facebook.common.util.UriUtil;
 import com.facebook.drawee.controller.AbstractDraweeControllerBuilder;
+import com.facebook.infer.annotation.Nullsafe;
 import com.facebook.react.bridge.Dynamic;
 import com.facebook.react.bridge.ReadableArray;
 import com.facebook.react.bridge.ReadableMap;
@@ -27,10 +29,11 @@ import com.facebook.yoga.YogaConstants;
 import java.util.Locale;
 
 /** Shadow node that represents an inline image. Loading is done using Fresco. */
+@Nullsafe(Nullsafe.Mode.LOCAL)
 class FrescoBasedReactTextInlineImageShadowNode extends ReactTextInlineImageShadowNode {
 
   private @Nullable Uri mUri;
-  private ReadableMap mHeaders;
+  private @Nullable ReadableMap mHeaders;
   private final AbstractDraweeControllerBuilder mDraweeControllerBuilder;
   private final @Nullable Object mCallerContext;
   private float mWidth = YogaConstants.UNDEFINED;
@@ -46,8 +49,10 @@ class FrescoBasedReactTextInlineImageShadowNode extends ReactTextInlineImageShad
 
   @ReactProp(name = "src")
   public void setSource(@Nullable ReadableArray sources) {
-    final String source =
-        (sources == null || sources.size() == 0) ? null : sources.getMap(0).getString("uri");
+    final @Nullable String source =
+        (sources == null || sources.size() == 0 || sources.getType(0) != ReadableType.Map)
+            ? null
+            : Preconditions.checkNotNull(sources.getMap(0)).getString("uri");
     Uri uri = null;
     if (source != null) {
       try {
@@ -70,7 +75,7 @@ class FrescoBasedReactTextInlineImageShadowNode extends ReactTextInlineImageShad
   }
 
   @ReactProp(name = "headers")
-  public void setHeaders(ReadableMap headers) {
+  public void setHeaders(@Nullable ReadableMap headers) {
     mHeaders = headers;
   }
 
@@ -109,7 +114,7 @@ class FrescoBasedReactTextInlineImageShadowNode extends ReactTextInlineImageShad
     return mUri;
   }
 
-  public ReadableMap getHeaders() {
+  public @Nullable ReadableMap getHeaders() {
     return mHeaders;
   }
 

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

@@ -15,14 +15,15 @@ import android.graphics.drawable.Drawable;
 import android.net.Uri;
 import android.widget.TextView;
 import androidx.annotation.Nullable;
+import androidx.core.util.Preconditions;
 import com.facebook.drawee.controller.AbstractDraweeControllerBuilder;
-import com.facebook.drawee.drawable.ScalingUtils;
 import com.facebook.drawee.generic.GenericDraweeHierarchy;
 import com.facebook.drawee.generic.GenericDraweeHierarchyBuilder;
 import com.facebook.drawee.interfaces.DraweeController;
 import com.facebook.drawee.view.DraweeHolder;
 import com.facebook.imagepipeline.request.ImageRequest;
 import com.facebook.imagepipeline.request.ImageRequestBuilder;
+import com.facebook.infer.annotation.Nullsafe;
 import com.facebook.react.bridge.ReadableMap;
 import com.facebook.react.modules.fresco.ReactNetworkImageRequest;
 import com.facebook.react.uimanager.PixelUtil;
@@ -40,6 +41,7 @@ import com.facebook.react.views.text.internal.span.TextInlineImageSpan;
  * <p>Note: It borrows code from DynamicDrawableSpan and if that code updates how it computes size
  * or draws, we need to update this as well.
  */
+@Nullsafe(Nullsafe.Mode.LOCAL)
 class FrescoBasedReactTextInlineImageSpan extends TextInlineImageSpan {
 
   private @Nullable Drawable mDrawable;
@@ -51,8 +53,8 @@ class FrescoBasedReactTextInlineImageSpan extends TextInlineImageSpan {
   private int mTintColor;
   private Uri mUri;
   private int mWidth;
-  private ReadableMap mHeaders;
-  private String mResizeMode;
+  private @Nullable ReadableMap mHeaders;
+  private @Nullable String mResizeMode;
 
   private @Nullable TextView mTextView;
 
@@ -62,10 +64,10 @@ class FrescoBasedReactTextInlineImageSpan extends TextInlineImageSpan {
       int width,
       int tintColor,
       @Nullable Uri uri,
-      ReadableMap headers,
+      @Nullable ReadableMap headers,
       AbstractDraweeControllerBuilder draweeControllerBuilder,
       @Nullable Object callerContext,
-      String resizeMode) {
+      @Nullable String resizeMode) {
     mDraweeHolder = new DraweeHolder(GenericDraweeHierarchyBuilder.newInstance(resources).build());
     mDraweeControllerBuilder = draweeControllerBuilder;
     mCallerContext = callerContext;
@@ -116,7 +118,8 @@ class FrescoBasedReactTextInlineImageSpan extends TextInlineImageSpan {
     return mWidth;
   }
 
-  public void setTextView(TextView textView) {
+  @Override
+  public void setTextView(@Nullable TextView textView) {
     mTextView = textView;
   }
 
@@ -135,18 +138,20 @@ class FrescoBasedReactTextInlineImageSpan extends TextInlineImageSpan {
       ImageRequestBuilder imageRequestBuilder = ImageRequestBuilder.newBuilderWithSource(mUri);
       ImageRequest imageRequest =
           ReactNetworkImageRequest.fromBuilderWithHeaders(imageRequestBuilder, mHeaders);
-      mDraweeHolder.getHierarchy().setActualImageScaleType(getResizeMode(mResizeMode));
-      DraweeController draweeController =
-          mDraweeControllerBuilder
-              .reset()
-              .setOldController(mDraweeHolder.getController())
-              .setCallerContext(mCallerContext)
-              .setImageRequest(imageRequest)
-              .build();
+      mDraweeHolder
+          .getHierarchy()
+          .setActualImageScaleType(ImageResizeMode.toScaleType(mResizeMode));
+      mDraweeControllerBuilder.reset();
+      mDraweeControllerBuilder.setOldController(mDraweeHolder.getController());
+      if (mCallerContext != null) {
+        mDraweeControllerBuilder.setCallerContext(mCallerContext);
+      }
+      mDraweeControllerBuilder.setImageRequest(imageRequest);
+      DraweeController draweeController = mDraweeControllerBuilder.build();
       mDraweeHolder.setController(draweeController);
       mDraweeControllerBuilder.reset();
 
-      mDrawable = mDraweeHolder.getTopLevelDrawable();
+      mDrawable = Preconditions.checkNotNull(mDraweeHolder.getTopLevelDrawable());
       mDrawable.setBounds(0, 0, mWidth, mHeight);
       if (mTintColor != 0) {
         mDrawable.setColorFilter(mTintColor, PorterDuff.Mode.SRC_IN);
@@ -168,10 +173,6 @@ class FrescoBasedReactTextInlineImageSpan extends TextInlineImageSpan {
     canvas.restore();
   }
 
-  private ScalingUtils.ScaleType getResizeMode(String resizeMode) {
-    return ImageResizeMode.toScaleType(resizeMode);
-  }
-
   @Override
   public int getWidth() {
     return mWidth;

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

@@ -31,7 +31,7 @@ constructor(
 
   override fun getName(): String = REACT_CLASS
 
-  public override fun createViewInstance(context: ThemedReactContext): View {
+  override fun createViewInstance(context: ThemedReactContext): View {
     throw IllegalStateException("RCTTextInlineImage doesn't map into a native view")
   }
 
@@ -44,7 +44,7 @@ constructor(
 
   override fun updateExtraData(root: View, extraData: Any) = Unit
 
-  public companion object {
-    public const val REACT_CLASS: String = "RCTTextInlineImage"
+  companion object {
+    const val REACT_CLASS: String = "RCTTextInlineImage"
   }
 }

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

@@ -0,0 +1,21 @@
+/*
+ * 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.text.internal
+
+import com.facebook.react.uimanager.LayoutShadowNode
+import com.facebook.react.views.text.internal.span.TextInlineImageSpan
+import com.facebook.yoga.YogaNode
+
+/** Base class for [YogaNode]s that represent inline images. */
+internal abstract class ReactTextInlineImageShadowNode : LayoutShadowNode() {
+  /**
+   * Build a [TextInlineImageSpan] from this node. This will be added to the TextView in place of
+   * this node.
+   */
+  abstract fun buildInlineImageSpan(): TextInlineImageSpan
+}

package/ReactAndroid/src/main/java/com/facebook/react/views/text/internal/span/ReactClickableSpan.kt

@@ -7,6 +7,7 @@
 
 package com.facebook.react.views.text.internal.span
 
+import android.graphics.Color
 import android.text.TextPaint
 import android.text.style.ClickableSpan
 import android.view.View
@@ -35,6 +36,9 @@ import com.facebook.react.views.view.ViewGroupClickEvent
  * menu).
  */
 public class ReactClickableSpan(public val reactTag: Int) : ClickableSpan(), ReactSpan {
+  public var isKeyboardFocused: Boolean = false
+  public var focusBgColor: Int = Color.TRANSPARENT
+
   public override fun onClick(view: View) {
     val context = view.context as ReactContext
     val eventDispatcher = UIManagerHelper.getEventDispatcherForReactTag(context, reactTag)
@@ -43,7 +47,10 @@ public class ReactClickableSpan(public val reactTag: Int) : ClickableSpan(), Rea
   }
 
   public override fun updateDrawState(ds: TextPaint) {
-    // no-op to make sure we don't change the link color or add an underline by default, as the
+    // no super call so we don't change the link color or add an underline by default, as the
     // superclass does.
+    if (isKeyboardFocused) {
+      ds.bgColor = focusBgColor
+    }
   }
 }

package/ReactAndroid/src/main/java/com/facebook/react/views/textinput/{ContentSizeWatcher.java → ContentSizeWatcher.kt}

@@ -5,8 +5,8 @@
  * LICENSE file in the root directory of this source tree.
  */
 
-package com.facebook.react.views.textinput;
+package com.facebook.react.views.textinput
 
 public interface ContentSizeWatcher {
-  void onLayout();
+  public fun onLayout(): Unit
 }