react-native-tvos 0.79.2-0 → 0.80.0-0

package/ReactAndroid/src/main/java/com/facebook/react/views/textinput/ReactTextInputSelectionEvent.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.textinput
+
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.WritableMap
+import com.facebook.react.uimanager.common.ViewUtil
+import com.facebook.react.uimanager.events.Event
+
+/** Event emitted by EditText native view when the text selection changes. */
+internal class ReactTextInputSelectionEvent(
+    surfaceId: Int,
+    viewId: Int,
+    private val selectionStart: Int,
+    private val selectionEnd: Int
+) : Event<ReactTextInputSelectionEvent>(surfaceId, viewId) {
+  @Deprecated(
+      "Use the constructor with surfaceId instead",
+      ReplaceWith("ReactTextInputSelectionEvent(surfaceId, viewId, selectionStart, selectionEnd)"))
+  constructor(
+      viewId: Int,
+      selectionStart: Int,
+      selectionEnd: Int
+  ) : this(ViewUtil.NO_SURFACE_ID, viewId, selectionStart, selectionEnd)
+
+  override fun getEventName(): String = EVENT_NAME
+
+  override fun getEventData(): WritableMap {
+    val selectionData =
+        Arguments.createMap().apply {
+          putInt("end", selectionEnd)
+          putInt("start", selectionStart)
+        }
+
+    return Arguments.createMap().apply { putMap("selection", selectionData) }
+  }
+
+  companion object {
+    private const val EVENT_NAME = "topSelectionChange"
+  }
+}

package/ReactAndroid/src/main/java/com/facebook/react/views/textinput/ReactTextInputShadowNode.kt

@@ -0,0 +1,210 @@
+/*
+ * 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.textinput
+
+import android.annotation.SuppressLint
+import android.text.Layout
+import android.util.TypedValue
+import android.view.ViewGroup
+import android.widget.EditText
+import androidx.appcompat.view.ContextThemeWrapper
+import androidx.core.view.ViewCompat
+import com.facebook.common.logging.FLog
+import com.facebook.infer.annotation.Assertions
+import com.facebook.react.R
+import com.facebook.react.common.ReactConstants
+import com.facebook.react.common.annotations.LegacyArchitectureShadowNodeWithCxxImpl
+import com.facebook.react.common.annotations.internal.LegacyArchitecture
+import com.facebook.react.uimanager.Spacing
+import com.facebook.react.uimanager.ThemedReactContext
+import com.facebook.react.uimanager.UIViewOperationQueue
+import com.facebook.react.uimanager.annotations.ReactProp
+import com.facebook.react.views.text.ReactBaseTextShadowNode
+import com.facebook.react.views.text.ReactTextUpdate
+import com.facebook.react.views.text.ReactTextViewManagerCallback
+import com.facebook.react.views.view.MeasureUtil.getMeasureSpec
+import com.facebook.yoga.YogaMeasureFunction
+import com.facebook.yoga.YogaMeasureMode
+import com.facebook.yoga.YogaMeasureOutput
+import com.facebook.yoga.YogaNode
+
+@LegacyArchitecture
+@LegacyArchitectureShadowNodeWithCxxImpl
+internal class ReactTextInputShadowNode
+@JvmOverloads
+constructor(reactTextViewManagerCallback: ReactTextViewManagerCallback? = null) :
+    ReactBaseTextShadowNode(reactTextViewManagerCallback), YogaMeasureFunction {
+  private var mostRecentEventCount = ReactConstants.UNSET
+  private var internalEditText: EditText? = null
+  private var localData: ReactTextInputLocalData? = null
+
+  // Represents the `text` property only, not possible nested content.
+  @set:ReactProp(name = PROP_TEXT)
+  var text: String? = null
+    set(value) {
+      field = value
+      markUpdated()
+    }
+
+  @set:ReactProp(name = PROP_PLACEHOLDER)
+  var placeholder: String? = null
+    set(value) {
+      field = value
+      markUpdated()
+    }
+
+  init {
+    mTextBreakStrategy = Layout.BREAK_STRATEGY_HIGH_QUALITY
+    setMeasureFunction(this)
+  }
+
+  @Suppress("DEPRECATION")
+  override fun setThemedContext(themedContext: ThemedReactContext) {
+    super.setThemedContext(themedContext)
+
+    // [EditText] has by default a border at the bottom of its view
+    // called "underline". To have a native look and feel of the TextEdit
+    // we have to preserve it at least by default.
+    // The border (underline) has its padding set by the background image
+    // provided by the system (which vary a lot among versions and vendors
+    // of Android), and it cannot be changed.
+    // So, we have to enforce it as a default padding.
+    // TODO #7120264: Cache this stuff better.
+    val editText = createInternalEditText()
+    setDefaultPadding(Spacing.START, ViewCompat.getPaddingStart(editText).toFloat())
+    setDefaultPadding(Spacing.TOP, editText.paddingTop.toFloat())
+    setDefaultPadding(Spacing.END, ViewCompat.getPaddingEnd(editText).toFloat())
+    setDefaultPadding(Spacing.BOTTOM, editText.paddingBottom.toFloat())
+
+    internalEditText = editText
+
+    // We must measure the EditText without paddings, so we have to reset them.
+    internalEditText?.setPadding(0, 0, 0, 0)
+
+    // This is needed to fix an android bug since 4.4.3 which will throw an NPE in measure,
+    // setting the layoutParams fixes it: https://code.google.com/p/android/issues/detail?id=75877
+    internalEditText?.layoutParams =
+        ViewGroup.LayoutParams(
+            ViewGroup.LayoutParams.WRAP_CONTENT, ViewGroup.LayoutParams.WRAP_CONTENT)
+  }
+
+  override fun measure(
+      node: YogaNode,
+      width: Float,
+      widthMode: YogaMeasureMode,
+      height: Float,
+      heightMode: YogaMeasureMode
+  ): Long {
+    // measure() should never be called before setThemedContext()
+    val editText = checkNotNull(internalEditText)
+
+    if (localData != null) {
+      localData?.apply(editText)
+    } else {
+      editText.setTextSize(TypedValue.COMPLEX_UNIT_PX, mTextAttributes.effectiveFontSize.toFloat())
+
+      if (mNumberOfLines != ReactConstants.UNSET) {
+        editText.setLines(mNumberOfLines)
+      }
+
+      @SuppressLint("WrongConstant")
+      if (editText.breakStrategy != mTextBreakStrategy) {
+        editText.breakStrategy = mTextBreakStrategy
+      }
+    }
+
+    // make sure the placeholder content is also being measured
+    editText.hint = placeholder
+    editText.measure(getMeasureSpec(width, widthMode), getMeasureSpec(height, heightMode))
+
+    return YogaMeasureOutput.make(editText.measuredWidth, editText.measuredHeight)
+  }
+
+  override fun isVirtualAnchor(): Boolean = true
+
+  override fun isYogaLeafNode(): Boolean = true
+
+  override fun setLocalData(data: Any) {
+    Assertions.assertCondition(data is ReactTextInputLocalData)
+    localData = data as ReactTextInputLocalData
+
+    // Telling to Yoga that the node should be remeasured on next layout pass.
+    dirty()
+
+    // Note: We should NOT mark the node updated (by calling {@code markUpdated}) here
+    // because the state remains the same.
+  }
+
+  @ReactProp(name = "mostRecentEventCount")
+  public fun setMostRecentEventCount(mostRecentEventCount: Int) {
+    this.mostRecentEventCount = mostRecentEventCount
+  }
+
+  override fun setTextBreakStrategy(textBreakStrategy: String?) {
+    when (textBreakStrategy) {
+      null,
+      "simple" -> mTextBreakStrategy = Layout.BREAK_STRATEGY_SIMPLE
+      "highQuality" -> mTextBreakStrategy = Layout.BREAK_STRATEGY_HIGH_QUALITY
+      "balanced" -> mTextBreakStrategy = Layout.BREAK_STRATEGY_BALANCED
+      else -> {
+        FLog.w(ReactConstants.TAG, "Invalid textBreakStrategy: $textBreakStrategy")
+        mTextBreakStrategy = Layout.BREAK_STRATEGY_SIMPLE
+      }
+    }
+  }
+
+  override fun onCollectExtraUpdates(uiViewOperationQueue: UIViewOperationQueue) {
+    super.onCollectExtraUpdates(uiViewOperationQueue)
+
+    if (mostRecentEventCount != ReactConstants.UNSET) {
+      val reactTextUpdate =
+          ReactTextUpdate(
+              spannedFromShadowNode(
+                  this,
+                  text, /* supportsInlineViews: */
+                  false, /* nativeViewHierarchyOptimizer: */
+                  null // only needed to support inline views
+                  ),
+              mostRecentEventCount,
+              mContainsImages,
+              getPadding(Spacing.LEFT),
+              getPadding(Spacing.TOP),
+              getPadding(Spacing.RIGHT),
+              getPadding(Spacing.BOTTOM),
+              mTextAlign,
+              mTextBreakStrategy,
+              mJustificationMode)
+      uiViewOperationQueue.enqueueUpdateExtraData(reactTag, reactTextUpdate)
+    }
+  }
+
+  override fun setPadding(spacingType: Int, padding: Float) {
+    super.setPadding(spacingType, padding)
+    markUpdated()
+  }
+
+  /**
+   * May be overridden by subclasses that would like to provide their own instance of the internal
+   * `EditText` this class uses to determine the expected size of the view.
+   */
+  private fun createInternalEditText(): EditText {
+    // By setting a style which has a background drawable, this EditText will have a different
+    // background drawable instance from that on the UI Thread, which maybe has a default background
+    // drawable instance.
+    // Otherwise, DrawableContainer is not a thread safe class, and it caused the npe in #29452.
+    val context =
+        ContextThemeWrapper(themedContext, R.style.Theme_ReactNative_TextInput_DefaultBackground)
+    return EditText(context)
+  }
+
+  companion object {
+    const val PROP_TEXT: String = "text"
+
+    const val PROP_PLACEHOLDER: String = "placeholder"
+  }
+}

package/ReactAndroid/src/main/java/com/facebook/react/views/textinput/ReactTextInputSubmitEditingEvent.kt

@@ -0,0 +1,40 @@
+/*
+ * 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.textinput
+
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.WritableMap
+import com.facebook.react.uimanager.common.ViewUtil
+import com.facebook.react.uimanager.events.Event
+
+/** Event emitted by EditText native view when the user submits the text. */
+internal class ReactTextInputSubmitEditingEvent(
+    surfaceId: Int,
+    viewId: Int,
+    private val text: String
+) : Event<ReactTextInputSubmitEditingEvent>(surfaceId, viewId) {
+  @Deprecated(
+      "Use the constructor with surfaceId instead",
+      ReplaceWith("ReactTextInputSubmitEditingEvent(surfaceId, viewId, text)"))
+  constructor(viewId: Int, text: String) : this(ViewUtil.NO_SURFACE_ID, viewId, text)
+
+  override fun getEventName(): String = EVENT_NAME
+
+  override fun getEventData(): WritableMap {
+    return Arguments.createMap().apply {
+      putInt("target", viewTag)
+      putString("text", text)
+    }
+  }
+
+  override fun canCoalesce(): Boolean = false
+
+  companion object {
+    private const val EVENT_NAME = "topSubmitEditing"
+  }
+}

package/ReactAndroid/src/main/java/com/facebook/react/views/textinput/ReactTextInputTextWatcher.kt

@@ -0,0 +1,66 @@
+/*
+ * 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.textinput
+
+import android.text.Editable
+import android.text.TextWatcher
+import com.facebook.react.bridge.ReactContext
+import com.facebook.react.bridge.WritableMap
+import com.facebook.react.bridge.WritableNativeMap
+import com.facebook.react.uimanager.UIManagerHelper
+import com.facebook.react.uimanager.events.EventDispatcher
+
+internal class ReactTextInputTextWatcher(
+    reactContext: ReactContext,
+    private val editText: ReactEditText
+) : TextWatcher {
+  private val eventDispatcher: EventDispatcher? =
+      UIManagerHelper.getEventDispatcherForReactTag(reactContext, editText.id)
+  private val surfaceId = UIManagerHelper.getSurfaceId(reactContext)
+  private var previousText: String? = null
+
+  override fun beforeTextChanged(s: CharSequence, start: Int, count: Int, after: Int) {
+    // Incoming charSequence gets mutated before onTextChanged() is invoked
+    previousText = s.toString()
+  }
+
+  override fun onTextChanged(s: CharSequence, start: Int, before: Int, count: Int) {
+    if (editText.disableTextDiffing) {
+      return
+    }
+
+    // Rearranging the text (i.e. changing between singleline and multiline attributes) can
+    // also trigger onTextChanged, call the event in JS only when the text actually changed
+    if (count == 0 && before == 0) {
+      return
+    }
+
+    val newText = s.toString().substring(start, start + count)
+    val oldText = checkNotNull(previousText).substring(start, start + before)
+    // Don't send same text changes
+    if (count == before && newText == oldText) {
+      return
+    }
+
+    val stateWrapper = editText.stateWrapper
+
+    if (stateWrapper != null) {
+      val newStateData: WritableMap = WritableNativeMap()
+      newStateData.putInt("mostRecentEventCount", editText.incrementAndGetEventCounter())
+      newStateData.putInt("opaqueCacheId", editText.id)
+      stateWrapper.updateState(newStateData)
+    }
+
+    // The event that contains the event counter and updates it must be sent first.
+    eventDispatcher?.dispatchEvent(
+        ReactTextChangedEvent(
+            surfaceId, editText.id, s.toString(), editText.incrementAndGetEventCounter()))
+  }
+
+  override fun afterTextChanged(s: Editable) = Unit
+}

package/ReactAndroid/src/main/java/com/facebook/react/views/textinput/ReactTextScrollWatcher.kt

@@ -0,0 +1,49 @@
+/*
+ * 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.textinput
+
+import com.facebook.react.uimanager.UIManagerHelper
+import com.facebook.react.uimanager.events.EventDispatcher
+import com.facebook.react.views.scroll.ScrollEvent.Companion.obtain
+import com.facebook.react.views.scroll.ScrollEventType
+
+internal class ReactTextScrollWatcher(private val editText: ReactEditText) : ScrollWatcher {
+  private val eventDispatcher: EventDispatcher?
+  private val surfaceId: Int
+  private var previousHorizontal = 0
+  private var previousVert = 0
+
+  init {
+    val reactContext = UIManagerHelper.getReactContext(editText)
+    eventDispatcher = UIManagerHelper.getEventDispatcherForReactTag(reactContext, editText.id)
+    surfaceId = UIManagerHelper.getSurfaceId(reactContext)
+  }
+
+  override fun onScrollChanged(horiz: Int, vert: Int, oldHoriz: Int, oldVert: Int) {
+    if (previousHorizontal != horiz || previousVert != vert) {
+      val event =
+          obtain(
+              surfaceId,
+              editText.id,
+              ScrollEventType.SCROLL,
+              horiz.toFloat(),
+              vert.toFloat(),
+              0f, // can't get x velocity
+              0f, // can't get y velocity
+              0, // can't get content width
+              0, // can't get content height
+              editText.width,
+              editText.height)
+
+      eventDispatcher?.dispatchEvent(event)
+
+      previousHorizontal = horiz
+      previousVert = vert
+    }
+  }
+}

package/ReactAndroid/src/main/java/com/facebook/react/views/textinput/ReactTextSelectionWatcher.kt

@@ -0,0 +1,45 @@
+/*
+ * 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.textinput
+
+import com.facebook.react.uimanager.UIManagerHelper
+import com.facebook.react.uimanager.events.EventDispatcher
+import kotlin.math.max
+import kotlin.math.min
+
+internal class ReactTextSelectionWatcher(private val editText: ReactEditText) : SelectionWatcher {
+  private val eventDispatcher: EventDispatcher?
+  private val surfaceId: Int
+  private var previousSelectionStart = 0
+  private var previousSelectionEnd = 0
+
+  init {
+    val reactContext = UIManagerHelper.getReactContext(editText)
+    eventDispatcher = UIManagerHelper.getEventDispatcherForReactTag(reactContext, editText.id)
+    surfaceId = UIManagerHelper.getSurfaceId(reactContext)
+  }
+
+  override fun onSelectionChanged(start: Int, end: Int) {
+    // Android will call us back for both the SELECTION_START span and SELECTION_END span in text
+    // To prevent double calling back into js we cache the result of the previous call and only
+    // forward it on if we have new values
+
+    // Apparently Android might call this with an end value that is less than the start value
+    // Lets normalize them. See https://github.com/facebook/react-native/issues/18579
+    val realStart = min(start.toDouble(), end.toDouble()).toInt()
+    val realEnd = max(start.toDouble(), end.toDouble()).toInt()
+
+    if (previousSelectionStart != realStart || previousSelectionEnd != realEnd) {
+      eventDispatcher?.dispatchEvent(
+          ReactTextInputSelectionEvent(surfaceId, editText.id, realStart, realEnd))
+
+      previousSelectionStart = realStart
+      previousSelectionEnd = realEnd
+    }
+  }
+}

package/ReactAndroid/src/main/java/com/facebook/react/views/unimplementedview/ReactUnimplementedView.kt

@@ -12,26 +12,29 @@ import android.graphics.Color
 import android.view.Gravity
 import android.widget.LinearLayout
 import androidx.appcompat.widget.AppCompatTextView
+import com.facebook.react.common.build.ReactBuildConfig
 
 internal class ReactUnimplementedView(context: Context) : LinearLayout(context) {
 
-  private val textView: AppCompatTextView
+  private val textView: AppCompatTextView = AppCompatTextView(context)
 
   init {
-    textView = AppCompatTextView(context)
-    textView.layoutParams =
-        LinearLayout.LayoutParams(
-            LinearLayout.LayoutParams.WRAP_CONTENT, LinearLayout.LayoutParams.MATCH_PARENT)
+    textView.layoutParams = LayoutParams(LayoutParams.WRAP_CONTENT, LayoutParams.MATCH_PARENT)
     textView.setGravity(Gravity.CENTER)
     textView.setTextColor(Color.WHITE)
+    textView.text = ""
 
-    setBackgroundColor(0x55ff0000)
-    setGravity(Gravity.CENTER_HORIZONTAL)
-    setOrientation(LinearLayout.VERTICAL)
+    if (ReactBuildConfig.DEBUG) {
+      setBackgroundColor(0x55ff0000)
+    }
+    gravity = Gravity.CENTER_HORIZONTAL
+    orientation = VERTICAL
     addView(textView)
   }
 
   internal fun setName(name: String) {
-    textView.setText("'$name' is not Fabric compatible yet.")
+    if (ReactBuildConfig.DEBUG) {
+      textView.text = "'$name' is not registered."
+    }
   }
 }

package/ReactAndroid/src/main/java/com/facebook/react/views/unimplementedview/ReactUnimplementedViewManager.kt

@@ -15,7 +15,10 @@ import com.facebook.react.uimanager.annotations.ReactProp
 import com.facebook.react.viewmanagers.UnimplementedNativeViewManagerDelegate
 import com.facebook.react.viewmanagers.UnimplementedNativeViewManagerInterface
 
-/** ViewManager for [ReactUnimplementedView] to represent a component that is not yet supported. */
+/**
+ * ViewManager that renders [ReactUnimplementedView] to represent a component that is not properly
+ * implemented or registered.
+ */
 @ReactModule(name = ReactUnimplementedViewManager.REACT_CLASS)
 internal class ReactUnimplementedViewManager :
     ViewGroupManager<ReactUnimplementedView>(),
@@ -32,9 +35,8 @@ internal class ReactUnimplementedViewManager :
   override fun getName(): String = REACT_CLASS
 
   @ReactProp(name = "name")
-  override fun setName(view: ReactUnimplementedView, name: String?): Unit {
-    view.setName(name ?: "<null component name>")
-  }
+  override fun setName(view: ReactUnimplementedView, name: String?): Unit =
+      view.setName(name ?: "<null component name>")
 
   internal companion object {
     const val REACT_CLASS: String = "UnimplementedNativeView"

package/ReactAndroid/src/main/java/com/facebook/react/views/view/MeasureUtil.kt

@@ -10,10 +10,10 @@ package com.facebook.react.views.view
 import android.view.View
 import com.facebook.yoga.YogaMeasureMode
 
-public object MeasureUtil {
+internal object MeasureUtil {
 
   @JvmStatic
-  public fun getMeasureSpec(size: Float, mode: YogaMeasureMode): Int =
+  fun getMeasureSpec(size: Float, mode: YogaMeasureMode): Int =
       when (mode) {
         YogaMeasureMode.EXACTLY ->
             View.MeasureSpec.makeMeasureSpec(size.toInt(), View.MeasureSpec.EXACTLY)

package/ReactAndroid/src/main/java/com/facebook/react/views/view/ReactViewGroup.java

@@ -229,6 +229,12 @@ public class ReactViewGroup extends ViewGroup
     // Remove any children
     removeAllViews();
 
+    // If the view is still attached to a parent, we need to remove it from the parent
+    // before we can recycle it.
+    if (getParent() != null) {
+      ((ViewGroup) getParent()).removeView(this);
+    }
+
     // Reset background, borders
     updateBackgroundDrawable(null);
 
@@ -254,13 +260,13 @@ public class ReactViewGroup extends ViewGroup
 
   @Override
   protected void onLayout(boolean changed, int left, int top, int right, int bottom) {
-    // No-op since UIManagerModule handles actually laying out children.
+    // No-op since UIManager handles actually laying out children.
   }
 
   @Override
   @SuppressLint("MissingSuperCall")
   public void requestLayout() {
-    // No-op, terminate `requestLayout` here, UIManagerModule handles laying out children and
+    // No-op, terminate `requestLayout` here, UIManager handles laying out children and
     // `layout` is called on all RN-managed views by `NativeViewHierarchyManager`
   }
 
@@ -438,6 +444,11 @@ public class ReactViewGroup extends ViewGroup
 
   @Override
   public void updateClippingRect() {
+    updateClippingRect(null);
+  }
+
+  @Override
+  public void updateClippingRect(@Nullable Set<Integer> excludedViewsSet) {
     if (!mRemoveClippedSubviews) {
       return;
     }
@@ -446,7 +457,7 @@ public class ReactViewGroup extends ViewGroup
     Assertions.assertNotNull(mAllChildren);
 
     ReactClippingViewGroupHelper.calculateClippingRect(this, mClippingRect);
-    updateClippingToRect(mClippingRect);
+    updateClippingToRect(mClippingRect, excludedViewsSet);
   }
 
   @Override
@@ -470,12 +481,16 @@ public class ReactViewGroup extends ViewGroup
   }
 
   private void updateClippingToRect(Rect clippingRect) {
+    updateClippingToRect(clippingRect, null);
+  }
+
+  private void updateClippingToRect(Rect clippingRect, @Nullable Set<Integer> excludedViewsSet) {
     Assertions.assertNotNull(mAllChildren);
     mInSubviewClippingLoop = true;
     int clippedSoFar = 0;
     for (int i = 0; i < mAllChildrenCount; i++) {
       try {
-        updateSubviewClipStatus(clippingRect, i, clippedSoFar);
+        updateSubviewClipStatus(clippingRect, i, clippedSoFar, excludedViewsSet);
       } catch (IndexOutOfBoundsException e) {
         int realClippedSoFar = 0;
         Set<View> uniqueViews = new HashSet<>();
@@ -509,6 +524,11 @@ public class ReactViewGroup extends ViewGroup
   }
 
   private void updateSubviewClipStatus(Rect clippingRect, int idx, int clippedSoFar) {
+    updateSubviewClipStatus(clippingRect, idx, clippedSoFar, null);
+  }
+
+  private void updateSubviewClipStatus(
+      Rect clippingRect, int idx, int clippedSoFar, @Nullable Set<Integer> excludedViewsSet) {
     UiThreadUtil.assertOnUiThread();
 
     View child = Assertions.assertNotNull(mAllChildren)[idx];
@@ -524,14 +544,23 @@ public class ReactViewGroup extends ViewGroup
     // it won't be size and located properly.
     Animation animation = child.getAnimation();
     boolean isAnimating = animation != null && !animation.hasEnded();
-    if (!intersects && !isViewClipped(child, idx) && !isAnimating) {
+    boolean shouldSkipView = excludedViewsSet != null && excludedViewsSet.contains(child.getId());
+    if (excludedViewsSet != null) {
+      needUpdateClippingRecursive = true;
+    }
+    // We don't want to clip a view that is currently focused at that might break focus navigation
+    if (!intersects
+        && !isViewClipped(child, idx)
+        && !isAnimating
+        && child != getFocusedChild()
+        && !shouldSkipView) {
       setViewClipped(child, true);
       recoverFocus(child);
       // We can try saving on invalidate call here as the view that we remove is out of visible area
       // therefore invalidation is not necessary.
       removeViewInLayout(child);
       needUpdateClippingRecursive = true;
-    } else if (intersects && isViewClipped(child, idx)) {
+    } else if ((shouldSkipView || intersects) && isViewClipped(child, idx)) {
       int adjustedIdx = idx - clippedSoFar;
       Assertions.assertCondition(adjustedIdx >= 0);
       setViewClipped(child, false);
@@ -546,7 +575,7 @@ public class ReactViewGroup extends ViewGroup
       if (child instanceof ReactClippingViewGroup) {
         ReactClippingViewGroup clippingChild = (ReactClippingViewGroup) child;
         if (clippingChild.getRemoveClippedSubviews()) {
-          clippingChild.updateClippingRect();
+          clippingChild.updateClippingRect(excludedViewsSet);
         }
       }
     }
@@ -710,9 +739,6 @@ public class ReactViewGroup extends ViewGroup
     UiThreadUtil.assertOnUiThread();
     checkViewClippingTag(child, Boolean.TRUE);
     if (!customDrawOrderDisabled()) {
-      if (indexOfChild(child) == -1) {
-        return;
-      }
       getDrawingOrderHelper().handleRemoveView(child);
       setChildrenDrawingOrderEnabled(getDrawingOrderHelper().shouldEnableCustomDrawingOrder());
     } else {
@@ -838,7 +864,7 @@ public class ReactViewGroup extends ViewGroup
             public void run() {
               if (!child.isShown()) {
                 ReactSoftExceptionLogger.logSoftException(
-                    TAG,
+                    ReactSoftExceptionLogger.Categories.CLIPPING_PROHIBITED_VIEW,
                     new ReactNoCrashSoftException(
                         "Child view has been added to Parent view in which it is clipped and not"
                             + " visible. This is not legal for this particular child view. Child: ["