react-native 0.0.0-263478b91 → 0.0.0-268efb102

package/ReactAndroid/src/main/java/com/facebook/react/uimanager/DisplayMetricsHolder.java

@@ -13,9 +13,8 @@ import android.view.Display;
 import android.view.WindowManager;
 import androidx.annotation.Nullable;
 import com.facebook.infer.annotation.Assertions;
+import com.facebook.react.bridge.WritableMap;
 import com.facebook.react.bridge.WritableNativeMap;
-import java.util.HashMap;
-import java.util.Map;
 
 /**
  * Holds an instance of the current DisplayMetrics so we don't have to thread it through all the
@@ -81,40 +80,20 @@ public class DisplayMetricsHolder {
     return sScreenDisplayMetrics;
   }
 
-  public static Map<String, Map<String, Object>> getDisplayMetricsMap(double fontScale) {
+  public static WritableMap getDisplayMetricsWritableMap(double fontScale) {
     Assertions.assertCondition(
         sWindowDisplayMetrics != null && sScreenDisplayMetrics != null,
-        "DisplayMetricsHolder must be initialized with initDisplayMetricsIfNotInitialized or initDisplayMetrics");
-    final Map<String, Map<String, Object>> result = new HashMap<>();
-    result.put("windowPhysicalPixels", getPhysicalPixelsMap(sWindowDisplayMetrics, fontScale));
-    result.put("screenPhysicalPixels", getPhysicalPixelsMap(sScreenDisplayMetrics, fontScale));
-    return result;
-  }
-
-  public static WritableNativeMap getDisplayMetricsNativeMap(double fontScale) {
-    Assertions.assertCondition(
-        sWindowDisplayMetrics != null && sScreenDisplayMetrics != null,
-        "DisplayMetricsHolder must be initialized with initDisplayMetricsIfNotInitialized or initDisplayMetrics");
+        "DisplayMetricsHolder must be initialized with initDisplayMetricsIfNotInitialized or"
+            + " initDisplayMetrics");
     final WritableNativeMap result = new WritableNativeMap();
     result.putMap(
-        "windowPhysicalPixels", getPhysicalPixelsNativeMap(sWindowDisplayMetrics, fontScale));
+        "windowPhysicalPixels", getPhysicalPixelsWritableMap(sWindowDisplayMetrics, fontScale));
     result.putMap(
-        "screenPhysicalPixels", getPhysicalPixelsNativeMap(sScreenDisplayMetrics, fontScale));
-    return result;
-  }
-
-  private static Map<String, Object> getPhysicalPixelsMap(
-      DisplayMetrics displayMetrics, double fontScale) {
-    final Map<String, Object> result = new HashMap<>();
-    result.put("width", displayMetrics.widthPixels);
-    result.put("height", displayMetrics.heightPixels);
-    result.put("scale", displayMetrics.density);
-    result.put("fontScale", fontScale);
-    result.put("densityDpi", displayMetrics.densityDpi);
+        "screenPhysicalPixels", getPhysicalPixelsWritableMap(sScreenDisplayMetrics, fontScale));
     return result;
   }
 
-  private static WritableNativeMap getPhysicalPixelsNativeMap(
+  private static WritableMap getPhysicalPixelsWritableMap(
       DisplayMetrics displayMetrics, double fontScale) {
     final WritableNativeMap result = new WritableNativeMap();
     result.putInt("width", displayMetrics.widthPixels);

package/ReactAndroid/src/main/java/com/facebook/react/uimanager/JSTouchDispatcher.java

@@ -12,6 +12,7 @@ import android.view.ViewGroup;
 import com.facebook.common.logging.FLog;
 import com.facebook.infer.annotation.Assertions;
 import com.facebook.react.common.ReactConstants;
+import com.facebook.react.uimanager.common.UIManagerType;
 import com.facebook.react.uimanager.events.EventDispatcher;
 import com.facebook.react.uimanager.events.TouchEvent;
 import com.facebook.react.uimanager.events.TouchEventCoalescingKeyHelper;
@@ -50,14 +51,22 @@ public class JSTouchDispatcher {
     mTargetTag = -1;
   }
 
+  /**
+   * See Event.java. By contract, this surfaceId should be a valid SurfaceId in Fabric, and should
+   * ALWAYS return -1 in non-Fabric.
+   *
+   * @return
+   */
   private int getSurfaceId() {
-    if (mRootViewGroup instanceof ReactRoot) {
+    if (mRootViewGroup != null
+        && mRootViewGroup instanceof ReactRoot
+        && ((ReactRoot) mRootViewGroup).getUIManagerType() == UIManagerType.FABRIC) {
+      if (mRootViewGroup.getContext() instanceof ThemedReactContext) {
+        ThemedReactContext context = (ThemedReactContext) mRootViewGroup.getContext();
+        return context.getSurfaceId();
+      }
       return ((ReactRoot) mRootViewGroup).getRootViewTag();
     }
-    if (mRootViewGroup != null && mRootViewGroup.getContext() instanceof ThemedReactContext) {
-      ThemedReactContext context = (ThemedReactContext) mRootViewGroup.getContext();
-      return context.getSurfaceId();
-    }
     return -1;
   }
 

package/ReactAndroid/src/main/java/com/facebook/react/uimanager/NativeViewHierarchyOptimizer.java

@@ -13,7 +13,6 @@ import com.facebook.common.logging.FLog;
 import com.facebook.infer.annotation.Assertions;
 import com.facebook.react.bridge.ReadableArray;
 import com.facebook.react.bridge.ReadableMapKeySetIterator;
-import com.facebook.react.config.ReactFeatureFlags;
 
 /**
  * Class responsible for optimizing the native view hierarchy while still respecting the final UI
@@ -425,18 +424,16 @@ public class NativeViewHierarchyOptimizer {
     // Bit of a hack: we need to update the layout of this node's children now that it's no longer
     // layout-only, but we may still receive more layout updates at the end of this batch that we
     // don't want to ignore.
-    if (ReactFeatureFlags.enableTransitionLayoutOnlyViewCleanup) {
-      FLog.i(
-          TAG,
-          "Transitioning LayoutOnlyView - tag: "
-              + node.getReactTag()
-              + " - rootTag: "
-              + node.getRootTag()
-              + " - hasProps: "
-              + (props != null)
-              + " - tagsWithLayout.size: "
-              + mTagsWithLayoutVisited.size());
-    }
+    FLog.i(
+        TAG,
+        "Transitioning LayoutOnlyView - tag: "
+            + node.getReactTag()
+            + " - rootTag: "
+            + node.getRootTag()
+            + " - hasProps: "
+            + (props != null)
+            + " - tagsWithLayout.size: "
+            + mTagsWithLayoutVisited.size());
     Assertions.assertCondition(mTagsWithLayoutVisited.size() == 0);
     applyLayoutBase(node);
     for (int i = 0; i < node.getChildCount(); i++) {

package/ReactAndroid/src/main/java/com/facebook/react/uimanager/PixelUtil.java

@@ -24,11 +24,6 @@ public class PixelUtil {
     return toPixelFromDIP((float) value);
   }
 
-  /** Convert from PX to SP */
-  public static float toSPFromPixel(float value) {
-    return value / DisplayMetricsHolder.getScreenDisplayMetrics().scaledDensity;
-  }
-
   /** Convert from SP to PX */
   public static float toPixelFromSP(float value) {
     return toPixelFromSP(value, Float.NaN);
@@ -58,6 +53,6 @@ public class PixelUtil {
 
   /** @return {@link float} that represents the density of the display metrics for device screen. */
   public static float getDisplayMetricDensity() {
-    return DisplayMetricsHolder.getScreenDisplayMetrics().density;
+    return DisplayMetricsHolder.getWindowDisplayMetrics().density;
   }
 }

package/ReactAndroid/src/main/java/com/facebook/react/uimanager/ReactAccessibilityDelegate.java

@@ -26,7 +26,7 @@ import com.facebook.react.bridge.Arguments;
 import com.facebook.react.bridge.Dynamic;
 import com.facebook.react.bridge.ReactContext;
 import com.facebook.react.bridge.ReactNoCrashSoftException;
-import com.facebook.react.bridge.ReactSoftException;
+import com.facebook.react.bridge.ReactSoftExceptionLogger;
 import com.facebook.react.bridge.ReadableArray;
 import com.facebook.react.bridge.ReadableMap;
 import com.facebook.react.bridge.ReadableMapKeySetIterator;
@@ -107,6 +107,7 @@ public class ReactAccessibilityDelegate extends AccessibilityDelegateCompat {
     TAB,
     TABLIST,
     TIMER,
+    LIST,
     TOOLBAR;
 
     public static String getValue(AccessibilityRole role) {
@@ -135,6 +136,8 @@ public class ReactAccessibilityDelegate extends AccessibilityDelegateCompat {
           return "android.widget.SpinButton";
         case SWITCH:
           return "android.widget.Switch";
+        case LIST:
+          return "android.widget.AbsListView";
         case NONE:
         case LINK:
         case SUMMARY:
@@ -316,7 +319,7 @@ public class ReactAccessibilityDelegate extends AccessibilityDelegateCompat {
                   });
         }
       } else {
-        ReactSoftException.logSoftException(
+        ReactSoftExceptionLogger.logSoftException(
             TAG, new ReactNoCrashSoftException("Cannot get RCTEventEmitter, no CatalystInstance"));
       }
 
@@ -385,18 +388,14 @@ public class ReactAccessibilityDelegate extends AccessibilityDelegateCompat {
         spannable.setSpan(new URLSpan(""), 0, spannable.length(), 0);
         nodeInfo.setText(spannable);
       }
-    } else if (role.equals(AccessibilityRole.SEARCH)) {
-      nodeInfo.setRoleDescription(context.getString(R.string.search_description));
     } else if (role.equals(AccessibilityRole.IMAGE)) {
       nodeInfo.setRoleDescription(context.getString(R.string.image_description));
     } else if (role.equals(AccessibilityRole.IMAGEBUTTON)) {
       nodeInfo.setRoleDescription(context.getString(R.string.imagebutton_description));
       nodeInfo.setClickable(true);
     } else if (role.equals(AccessibilityRole.BUTTON)) {
-      nodeInfo.setRoleDescription(context.getString(R.string.button_description));
       nodeInfo.setClickable(true);
     } else if (role.equals(AccessibilityRole.TOGGLEBUTTON)) {
-      nodeInfo.setRoleDescription(context.getString(R.string.toggle_button_description));
       nodeInfo.setClickable(true);
       nodeInfo.setCheckable(true);
     } else if (role.equals(AccessibilityRole.SUMMARY)) {

package/ReactAndroid/src/main/java/com/facebook/react/uimanager/ReactClippingProhibitedView.java

@@ -0,0 +1,26 @@
+/*
+ * Copyright (c) Facebook, Inc. and its 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.uimanager;
+
+/**
+ * Some Views may not function if added directly to a ViewGroup that clips them. For example, TTRC
+ * markers may rely on `onDraw` functionality to work properly, and will break if they're clipped
+ * out of the View hierarchy for any resaon.
+ *
+ * <p>This situation can occur more often in Fabric with View Flattening. We may prevent this sort
+ * of View Flattening from occurring in the future, but the connection is not entirely certain.
+ *
+ * <p>This can occur either because ReactViewGroup clips them out, using the ordinarary subview
+ * clipping feature. It is also possible if a View is added directly to a ReactRootView below the
+ * fold of the screen.
+ *
+ * <p>Generally the solution is to prevent View flattening in JS by adding `collapsable=false` to a
+ * parent component of the clipped view, and/or move the View higher up in the hierarchy so it is
+ * always rendered within the first page of the screen.
+ */
+public interface ReactClippingProhibitedView {}

package/ReactAndroid/src/main/java/com/facebook/react/uimanager/ReactOverflowView.java

@@ -0,0 +1,25 @@
+/*
+ * Copyright (c) Facebook, Inc. and its 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.uimanager;
+
+import android.view.View;
+import androidx.annotation.Nullable;
+
+/**
+ * Interface that should be implemented by {@link View} subclasses that support {@code overflow}
+ * style. This allows the overflow information to be used by {@link TouchTargetHelper} to determine
+ * if a View is touchable.
+ */
+public interface ReactOverflowView {
+  /**
+   * Gets the overflow state of a view. If set, this should be one of {@link ViewProps#HIDDEN},
+   * {@link ViewProps#VISIBLE} or {@link ViewProps#SCROLL}.
+   */
+  @Nullable
+  String getOverflow();
+}

package/ReactAndroid/src/main/java/com/facebook/react/uimanager/TouchTargetHelper.java

@@ -17,6 +17,9 @@ import androidx.annotation.Nullable;
 import com.facebook.react.bridge.JSApplicationIllegalArgumentException;
 import com.facebook.react.bridge.UiThreadUtil;
 import com.facebook.react.touch.ReactHitSlopView;
+import java.util.ArrayList;
+import java.util.EnumSet;
+import java.util.List;
 
 /**
  * Class responsible for identifying which react view should handle a given {@link MotionEvent}. It
@@ -80,7 +83,7 @@ public class TouchTargetHelper {
     // Store eventCoords in array so that they are modified to be relative to the targetView found.
     viewCoords[0] = eventX;
     viewCoords[1] = eventY;
-    View nativeTargetView = findTouchTargetView(viewCoords, viewGroup);
+    View nativeTargetView = findTouchTargetViewWithPointerEvents(viewCoords, viewGroup, null);
     if (nativeTargetView != null) {
       View reactTargetView = findClosestReactAncestor(nativeTargetView);
       if (reactTargetView != null) {
@@ -93,6 +96,39 @@ public class TouchTargetHelper {
     return targetTag;
   }
 
+  /**
+   * Find touch event target view within the provided container given the coordinates provided via
+   * {@link MotionEvent}.
+   *
+   * @param eventX the X screen coordinate of the touch location
+   * @param eventY the Y screen coordinate of the touch location
+   * @param viewGroup the container view to traverse
+   * @param viewCoords an out parameter that will return the X,Y value in the target view
+   * @return If a target was found, returns a path through the view tree of all react tags that are
+   *     a container for the touch target, ordered from target to root (last element)
+   */
+  public static List<Integer> findTargetPathAndCoordinatesForTouch(
+      float eventX, float eventY, ViewGroup viewGroup, float[] viewCoords) {
+    UiThreadUtil.assertOnUiThread();
+
+    // Store eventCoords in array so that they are modified to be relative to the targetView found.
+    viewCoords[0] = eventX;
+    viewCoords[1] = eventY;
+
+    List<Integer> pathAccumulator = new ArrayList<>();
+    View targetView = findTouchTargetViewWithPointerEvents(viewCoords, viewGroup, pathAccumulator);
+
+    if (targetView != null) {
+      View reactTargetView = findClosestReactAncestor(targetView);
+      int targetTag = getTouchTargetForView(reactTargetView, viewCoords[0], viewCoords[1]);
+      if (targetTag != pathAccumulator.get(0)) {
+        pathAccumulator.add(0, targetTag);
+      }
+    }
+
+    return pathAccumulator;
+  }
+
   private static View findClosestReactAncestor(View view) {
     while (view != null && view.getId() <= 0) {
       view = (View) view.getParent();
@@ -100,6 +136,14 @@ public class TouchTargetHelper {
     return view;
   }
 
+  /** Types of allowed return values from {@link #findTouchTargetView}. */
+  private enum TouchTargetReturnType {
+    /** Allow returning the view passed in through the parameters. */
+    SELF,
+    /** Allow returning children of the view passed in through parameters. */
+    CHILD,
+  }
+
   /**
    * Returns the touch target View that is either viewGroup or one if its descendants. This is a
    * recursive DFS since view the entire tree must be parsed until the target is found. If the
@@ -111,43 +155,91 @@ public class TouchTargetHelper {
    * be relative to the current viewGroup. When the method returns, it will contain the eventCoords
    * relative to the targetView found.
    */
-  private static View findTouchTargetView(float[] eventCoords, ViewGroup viewGroup) {
-    int childrenCount = viewGroup.getChildCount();
-    // Consider z-index when determining the touch target.
-    ReactZIndexedViewGroup zIndexedViewGroup =
-        viewGroup instanceof ReactZIndexedViewGroup ? (ReactZIndexedViewGroup) viewGroup : null;
-    for (int i = childrenCount - 1; i >= 0; i--) {
-      int childIndex =
-          zIndexedViewGroup != null ? zIndexedViewGroup.getZIndexMappedChildIndex(i) : i;
-      View child = viewGroup.getChildAt(childIndex);
-      PointF childPoint = mTempPoint;
-      if (isTransformedTouchPointInView(
-          eventCoords[0], eventCoords[1], viewGroup, child, childPoint)) {
-        // If it is contained within the child View, the childPoint value will contain the view
-        // coordinates relative to the child
+  private static View findTouchTargetView(
+      float[] eventCoords,
+      View view,
+      EnumSet<TouchTargetReturnType> allowReturnTouchTargetTypes,
+      List<Integer> pathAccumulator) {
+    // We prefer returning a child, so we check for a child that can handle the touch first
+    if (allowReturnTouchTargetTypes.contains(TouchTargetReturnType.CHILD)
+        && view instanceof ViewGroup) {
+      ViewGroup viewGroup = (ViewGroup) view;
+      int childrenCount = viewGroup.getChildCount();
+      // Consider z-index when determining the touch target.
+      ReactZIndexedViewGroup zIndexedViewGroup =
+          viewGroup instanceof ReactZIndexedViewGroup ? (ReactZIndexedViewGroup) viewGroup : null;
+      for (int i = childrenCount - 1; i >= 0; i--) {
+        int childIndex =
+            zIndexedViewGroup != null ? zIndexedViewGroup.getZIndexMappedChildIndex(i) : i;
+        View child = viewGroup.getChildAt(childIndex);
+        PointF childPoint = mTempPoint;
+        getChildPoint(eventCoords[0], eventCoords[1], viewGroup, child, childPoint);
+        // The childPoint value will contain the view coordinates relative to the child.
         // We need to store the existing X,Y for the viewGroup away as it is possible this child
         // will not actually be the target and so we restore them if not
         float restoreX = eventCoords[0];
         float restoreY = eventCoords[1];
         eventCoords[0] = childPoint.x;
         eventCoords[1] = childPoint.y;
-        View targetView = findTouchTargetViewWithPointerEvents(eventCoords, child);
+        View targetView = findTouchTargetViewWithPointerEvents(eventCoords, child, pathAccumulator);
+
         if (targetView != null) {
-          return targetView;
+          // We don't allow touches on views that are outside the bounds of an `overflow: hidden`
+          // View
+          boolean inOverflowBounds = true;
+          if (viewGroup instanceof ReactOverflowView) {
+            @Nullable String overflow = ((ReactOverflowView) viewGroup).getOverflow();
+            if ((ViewProps.HIDDEN.equals(overflow) || ViewProps.SCROLL.equals(overflow))
+                && !isTouchPointInView(restoreX, restoreY, view)) {
+              inOverflowBounds = false;
+            }
+          }
+          if (inOverflowBounds) {
+            return targetView;
+          }
         }
         eventCoords[0] = restoreX;
         eventCoords[1] = restoreY;
       }
     }
-    return viewGroup;
+
+    // Check if parent can handle the touch after the children
+    if (allowReturnTouchTargetTypes.contains(TouchTargetReturnType.SELF)
+        && isTouchPointInView(eventCoords[0], eventCoords[1], view)) {
+      return view;
+    }
+
+    return null;
+  }
+
+  /**
+   * Checks whether a touch at {@code x} and {@code y} are within the bounds of the View. Both
+   * {@code x} and {@code y} must be relative to the top-left corner of the view.
+   */
+  private static boolean isTouchPointInView(float x, float y, View view) {
+    if (view instanceof ReactHitSlopView && ((ReactHitSlopView) view).getHitSlopRect() != null) {
+      Rect hitSlopRect = ((ReactHitSlopView) view).getHitSlopRect();
+      if ((x >= -hitSlopRect.left && x < (view.getWidth()) + hitSlopRect.right)
+          && (y >= -hitSlopRect.top && y < (view.getHeight()) + hitSlopRect.bottom)) {
+        return true;
+      }
+
+      return false;
+    } else {
+      if ((x >= 0 && x < (view.getWidth())) && (y >= 0 && y < (view.getHeight()))) {
+        return true;
+      }
+
+      return false;
+    }
   }
 
   /**
-   * Returns whether the touch point is within the child View It is transform aware and will invert
-   * the transform Matrix to find the true local points This code is taken from {@link
+   * Returns the coordinates of a touch in the child View. It is transform aware and will invert the
+   * transform Matrix to find the true local points This code is taken from {@link
    * ViewGroup#isTransformedTouchPointInView()}
    */
-  private static boolean isTransformedTouchPointInView(
+  private static void getChildPoint(
       float x, float y, ViewGroup parent, View child, PointF outLocalPoint) {
     float localX = x + parent.getScrollX() - child.getLeft();
     float localY = y + parent.getScrollY() - child.getTop();
@@ -162,26 +254,7 @@ public class TouchTargetHelper {
       localX = localXY[0];
       localY = localXY[1];
     }
-    if (child instanceof ReactHitSlopView && ((ReactHitSlopView) child).getHitSlopRect() != null) {
-      Rect hitSlopRect = ((ReactHitSlopView) child).getHitSlopRect();
-      if ((localX >= -hitSlopRect.left
-              && localX < (child.getRight() - child.getLeft()) + hitSlopRect.right)
-          && (localY >= -hitSlopRect.top
-              && localY < (child.getBottom() - child.getTop()) + hitSlopRect.bottom)) {
-        outLocalPoint.set(localX, localY);
-        return true;
-      }
-
-      return false;
-    } else {
-      if ((localX >= 0 && localX < (child.getRight() - child.getLeft()))
-          && (localY >= 0 && localY < (child.getBottom() - child.getTop()))) {
-        outLocalPoint.set(localX, localY);
-        return true;
-      }
-
-      return false;
-    }
+    outLocalPoint.set(localX, localY);
   }
 
   /**
@@ -189,7 +262,7 @@ public class TouchTargetHelper {
    * its descendants are the touch target.
    */
   private static @Nullable View findTouchTargetViewWithPointerEvents(
-      float eventCoords[], View view) {
+      float eventCoords[], View view, @Nullable List<Integer> pathAccumulator) {
     PointerEvents pointerEvents =
         view instanceof ReactPointerEventsView
             ? ((ReactPointerEventsView) view).getPointerEvents()
@@ -211,45 +284,68 @@ public class TouchTargetHelper {
       return null;
 
     } else if (pointerEvents == PointerEvents.BOX_ONLY) {
-      // This view is the target, its children don't matter
-      return view;
+      // This view may be the target, its children don't matter
+      View targetView =
+          findTouchTargetView(
+              eventCoords, view, EnumSet.of(TouchTargetReturnType.SELF), pathAccumulator);
+      if (targetView != null && pathAccumulator != null) {
+        pathAccumulator.add(view.getId());
+      }
+      return targetView;
 
     } else if (pointerEvents == PointerEvents.BOX_NONE) {
       // This view can't be the target, but its children might.
-      if (view instanceof ViewGroup) {
-        View targetView = findTouchTargetView(eventCoords, (ViewGroup) view);
-        if (targetView != view) {
-          return targetView;
+      View targetView =
+          findTouchTargetView(
+              eventCoords, view, EnumSet.of(TouchTargetReturnType.CHILD), pathAccumulator);
+      if (targetView != null) {
+        if (pathAccumulator != null) {
+          pathAccumulator.add(view.getId());
         }
+        return targetView;
+      }
 
-        // PointerEvents.BOX_NONE means that this react element cannot receive pointer events.
-        // However, there might be virtual children that can receive pointer events, in which case
-        // we still want to return this View and dispatch a pointer event to the virtual element.
-        // Note that this currently only applies to Nodes/FlatViewGroup as it's the only class that
-        // is both a ViewGroup and ReactCompoundView (ReactTextView is a ReactCompoundView but not a
-        // ViewGroup).
-        if (view instanceof ReactCompoundView) {
-          int reactTag =
-              ((ReactCompoundView) view).reactTagForTouch(eventCoords[0], eventCoords[1]);
-          if (reactTag != view.getId()) {
-            // make sure we exclude the View itself because of the PointerEvents.BOX_NONE
-            return view;
+      // PointerEvents.BOX_NONE means that this react element cannot receive pointer events.
+      // However, there might be virtual children that can receive pointer events, in which case
+      // we still want to return this View and dispatch a pointer event to the virtual element.
+      // Note that this currently only applies to Nodes/FlatViewGroup as it's the only class that
+      // is both a ViewGroup and ReactCompoundView (ReactTextView is a ReactCompoundView but not a
+      // ViewGroup).
+      if (view instanceof ReactCompoundView
+          && isTouchPointInView(eventCoords[0], eventCoords[1], view)) {
+        int reactTag = ((ReactCompoundView) view).reactTagForTouch(eventCoords[0], eventCoords[1]);
+        // make sure we exclude the View itself because of the PointerEvents.BOX_NONE
+        if (reactTag != view.getId()) {
+          if (pathAccumulator != null) {
+            pathAccumulator.add(view.getId());
           }
+          return view;
         }
       }
+
       return null;
 
     } else if (pointerEvents == PointerEvents.AUTO) {
       // Either this view or one of its children is the target
-      if (view instanceof ReactCompoundViewGroup) {
-        if (((ReactCompoundViewGroup) view).interceptsTouchEvent(eventCoords[0], eventCoords[1])) {
-          return view;
+      if (view instanceof ReactCompoundViewGroup
+          && isTouchPointInView(eventCoords[0], eventCoords[1], view)
+          && ((ReactCompoundViewGroup) view).interceptsTouchEvent(eventCoords[0], eventCoords[1])) {
+        if (pathAccumulator != null) {
+          pathAccumulator.add(view.getId());
         }
+        return view;
       }
-      if (view instanceof ViewGroup) {
-        return findTouchTargetView(eventCoords, (ViewGroup) view);
+
+      View result =
+          findTouchTargetView(
+              eventCoords,
+              view,
+              EnumSet.of(TouchTargetReturnType.SELF, TouchTargetReturnType.CHILD),
+              pathAccumulator);
+      if (result != null && pathAccumulator != null) {
+        pathAccumulator.add(view.getId());
       }
-      return view;
+      return result;
 
     } else {
       throw new JSApplicationIllegalArgumentException(

package/ReactAndroid/src/main/java/com/facebook/react/uimanager/UIImplementation.java

@@ -21,7 +21,6 @@ import com.facebook.react.bridge.ReadableMap;
 import com.facebook.react.bridge.UiThreadUtil;
 import com.facebook.react.bridge.WritableArray;
 import com.facebook.react.common.ReactConstants;
-import com.facebook.react.config.ReactFeatureFlags;
 import com.facebook.react.modules.i18nmanager.I18nUtil;
 import com.facebook.react.uimanager.debug.NotThreadSafeViewHierarchyUpdateDebugListener;
 import com.facebook.react.uimanager.events.EventDispatcher;
@@ -965,9 +964,7 @@ public class UIImplementation {
       }
     }
     cssNode.markUpdateSeen();
-    if (ReactFeatureFlags.enableTransitionLayoutOnlyViewCleanup) {
-      mNativeViewHierarchyOptimizer.onViewUpdatesCompleted(cssNode);
-    }
+    mNativeViewHierarchyOptimizer.onViewUpdatesCompleted(cssNode);
   }
 
   public void addUIBlock(UIBlock block) {