react-native 0.71.3 → 0.72.0-rc.0

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

@@ -79,6 +79,7 @@ public abstract class BaseViewManager<T extends View, C extends LayoutShadowNode
     view.setTag(R.id.accessibility_state, null);
     view.setTag(R.id.accessibility_actions, null);
     view.setTag(R.id.accessibility_value, null);
+    view.setTag(R.id.accessibility_state_expanded, null);
 
     // This indirectly calls (and resets):
     // setTranslationX
@@ -114,7 +115,7 @@ public abstract class BaseViewManager<T extends View, C extends LayoutShadowNode
     view.setNextFocusRightId(View.NO_ID);
     view.setNextFocusUpId(View.NO_ID);
 
-    // This is possibly subject to change and overrideable per-platform, but these
+    // This is possibly subject to change and overridable per-platform, but these
     // are the default view flags in View.java:
     // https://android.googlesource.com/platform/frameworks/base/+/a175a5b/core/java/android/view/View.java#2712
     // `mViewFlags = SOUND_EFFECTS_ENABLED | HAPTIC_FEEDBACK_ENABLED | LAYOUT_DIRECTION_INHERIT`
@@ -270,6 +271,9 @@ public abstract class BaseViewManager<T extends View, C extends LayoutShadowNode
     if (accessibilityState == null) {
       return;
     }
+    if (accessibilityState.hasKey("expanded")) {
+      view.setTag(R.id.accessibility_state_expanded, accessibilityState.getBoolean("expanded"));
+    }
     if (accessibilityState.hasKey("selected")) {
       boolean prevSelected = view.isSelected();
       boolean nextSelected = accessibilityState.getBoolean("selected");
@@ -335,13 +339,6 @@ public abstract class BaseViewManager<T extends View, C extends LayoutShadowNode
             && value.getType() == ReadableType.Boolean
             && value.asBoolean()) {
           contentDescription.add(view.getContext().getString(R.string.state_busy_description));
-        } else if (state.equals(STATE_EXPANDED) && value.getType() == ReadableType.Boolean) {
-          contentDescription.add(
-              view.getContext()
-                  .getString(
-                      value.asBoolean()
-                          ? R.string.state_expanded_description
-                          : R.string.state_collapsed_description));
         }
       }
     }
@@ -369,12 +366,13 @@ public abstract class BaseViewManager<T extends View, C extends LayoutShadowNode
   @ReactProp(name = ViewProps.ACCESSIBILITY_VALUE)
   public void setAccessibilityValue(T view, ReadableMap accessibilityValue) {
     if (accessibilityValue == null) {
-      return;
-    }
-
-    view.setTag(R.id.accessibility_value, accessibilityValue);
-    if (accessibilityValue.hasKey("text")) {
-      updateViewContentDescription(view);
+      view.setTag(R.id.accessibility_value, null);
+      view.setContentDescription(null);
+    } else {
+      view.setTag(R.id.accessibility_value, accessibilityValue);
+      if (accessibilityValue.hasKey("text")) {
+        updateViewContentDescription(view);
+      }
     }
   }
 

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

@@ -0,0 +1,26 @@
+/*
+ * 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.uimanager;
+
+import android.view.View;
+
+/** Interface providing children management API for view managers of classes extending ViewGroup. */
+public interface IViewGroupManager<T extends View> extends IViewManagerWithChildren {
+
+  /** Adds a child view into the parent at the index specified as a parameter */
+  void addView(T parent, View child, int index);
+
+  /** @return child of the parent view at the index specified as a parameter. */
+  View getChildAt(T parent, int index);
+
+  /** Removes View from the parent View at the index specified as a parameter. */
+  void removeViewAt(T parent, int index);
+
+  /** Return the amount of children contained by the view specified as a parameter. */
+  int getChildCount(T parent);
+}

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

@@ -16,5 +16,5 @@ public interface IViewManagerWithChildren {
    * of automatically laying out children without going through the ViewGroup's onLayout method. In
    * that case, onLayout for this View type must *not* call layout on its children.
    */
-  public boolean needsCustomLayoutForChildren();
+  boolean needsCustomLayoutForChildren();
 }

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

@@ -22,8 +22,10 @@ import com.facebook.react.uimanager.events.PointerEventHelper.EVENT;
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.HashMap;
+import java.util.HashSet;
 import java.util.List;
 import java.util.Map;
+import java.util.Set;
 
 /**
  * JSPointerDispatcher handles dispatching pointer events to JS from RootViews. If you implement
@@ -38,6 +40,7 @@ public class JSPointerDispatcher {
 
   private Map<Integer, List<ViewTarget>> mLastHitPathByPointerId;
   private Map<Integer, float[]> mLastEventCoordinatesByPointerId;
+  private Set<Integer> mHoveringPointerIds = new HashSet<>();
 
   private int mChildHandlingNativeGesture = -1;
   private int mPrimaryPointerId = UNSET_POINTER_ID;
@@ -75,10 +78,9 @@ public class JSPointerDispatcher {
       MotionEvent motionEvent,
       EventDispatcher eventDispatcher) {
 
-    List<ViewTarget> activeHitPath =
-        eventState.getHitPathByPointerId().get(eventState.getActivePointerId());
+    int activePointerId = eventState.getActivePointerId();
+    List<ViewTarget> activeHitPath = eventState.getHitPathByPointerId().get(activePointerId);
 
-    boolean supportsHover = PointerEventHelper.supportsHover(motionEvent);
     boolean listeningForUp =
         isAnyoneListeningForBubblingEvent(activeHitPath, EVENT.UP, EVENT.UP_CAPTURE);
     if (listeningForUp) {
@@ -87,6 +89,8 @@ public class JSPointerDispatcher {
               PointerEventHelper.POINTER_UP, activeTargetTag, eventState, motionEvent));
     }
 
+    boolean supportsHover = mHoveringPointerIds.contains(activePointerId);
+
     if (!supportsHover) {
       boolean listeningForOut =
           isAnyoneListeningForBubblingEvent(activeHitPath, EVENT.OUT, EVENT.OUT_CAPTURE);
@@ -111,6 +115,7 @@ public class JSPointerDispatcher {
     if (motionEvent.getActionMasked() == MotionEvent.ACTION_UP) {
       mPrimaryPointerId = UNSET_POINTER_ID;
     }
+    mHoveringPointerIds.remove(activePointerId);
   }
 
   private void incrementCoalescingKey() {
@@ -131,7 +136,7 @@ public class JSPointerDispatcher {
         eventState.getHitPathByPointerId().get(eventState.getActivePointerId());
 
     incrementCoalescingKey();
-    boolean supportsHover = PointerEventHelper.supportsHover(motionEvent);
+    boolean supportsHover = mHoveringPointerIds.contains(eventState.getActivePointerId());
     if (!supportsHover) {
       // Indirect OVER event dispatches before ENTER
       boolean listeningForOver =
@@ -164,9 +169,7 @@ public class JSPointerDispatcher {
     }
   }
 
-  private PointerEventState createEventState(MotionEvent motionEvent) {
-    int activeIndex = motionEvent.getActionIndex();
-
+  private PointerEventState createEventState(int activePointerId, MotionEvent motionEvent) {
     Map<Integer, float[]> offsetByPointerId = new HashMap<Integer, float[]>();
     Map<Integer, List<ViewTarget>> hitPathByPointerId = new HashMap<Integer, List<ViewTarget>>();
     Map<Integer, float[]> eventCoordinatesByPointerId = new HashMap<Integer, float[]>();
@@ -183,7 +186,6 @@ public class JSPointerDispatcher {
       eventCoordinatesByPointerId.put(pointerId, eventCoordinates);
     }
 
-    int activePointerId = motionEvent.getPointerId(activeIndex);
     int surfaceId = UIManagerHelper.getSurfaceId(mRootViewGroup);
 
     return new PointerEventState(
@@ -193,31 +195,64 @@ public class JSPointerDispatcher {
         surfaceId,
         offsetByPointerId,
         hitPathByPointerId,
-        eventCoordinatesByPointerId);
+        eventCoordinatesByPointerId,
+        mHoveringPointerIds); // Creates a copy of hovering pointer ids, as they may be updated
   }
 
-  public void handleMotionEvent(MotionEvent motionEvent, EventDispatcher eventDispatcher) {
+  public void handleMotionEvent(
+      MotionEvent motionEvent, EventDispatcher eventDispatcher, boolean isCapture) {
     // Don't fire any pointer events if child view is handling native gesture
     if (mChildHandlingNativeGesture != -1) {
       return;
     }
 
     int action = motionEvent.getActionMasked();
+    int activePointerId = motionEvent.getPointerId(motionEvent.getActionIndex());
     if (action == MotionEvent.ACTION_DOWN) {
       mPrimaryPointerId = motionEvent.getPointerId(0);
+    } else if (action == MotionEvent.ACTION_HOVER_MOVE) {
+      mHoveringPointerIds.add(activePointerId);
     }
 
-    PointerEventState eventState = createEventState(motionEvent);
-    List<ViewTarget> activeHitPath =
-        eventState.getHitPathByPointerId().get(eventState.getActivePointerId());
-
-    if (activeHitPath == null || activeHitPath.isEmpty()) {
-      return;
+    PointerEventState eventState = createEventState(activePointerId, motionEvent);
+
+    // We've empirically determined that when we get a ACTION_HOVER_EXIT from the root view on the
+    // `onInterceptHoverEvent`, this means we've exited the root view.
+    // This logic may be wrong but reasoning about the dispatch sequence for HOVER_ENTER/HOVER_EXIT
+    // doesn't follow the capture/bubbling sequence like other MotionEvents. See:
+    // https://developer.android.com/reference/android/view/MotionEvent#ACTION_HOVER_ENTER
+    // https://suragch.medium.com/how-touch-events-are-delivered-in-android-eee3b607b038
+    boolean isExitFromRoot =
+        isCapture && motionEvent.getActionMasked() == MotionEvent.ACTION_HOVER_EXIT;
+
+    // Calculate the targetTag, with special handling for when we exit the root view. In that case,
+    // we use the root viewId of the last event
+    int activeTargetTag;
+
+    List<ViewTarget> activeHitPath;
+    if (isExitFromRoot) {
+      List<ViewTarget> lastHitPath =
+          mLastHitPathByPointerId != null
+              ? mLastHitPathByPointerId.get(eventState.getActivePointerId())
+              : null;
+      if (lastHitPath == null || lastHitPath.isEmpty()) {
+        return;
+      }
+      activeTargetTag = lastHitPath.get(lastHitPath.size() - 1).getViewId();
+
+      // Explicitly make the hit path for this cursor empty
+      activeHitPath = new ArrayList<>();
+      eventState.getHitPathByPointerId().put(activePointerId, activeHitPath);
+    } else {
+      activeHitPath = eventState.getHitPathByPointerId().get(activePointerId);
+      if (activeHitPath == null || activeHitPath.isEmpty()) {
+        return;
+      }
+      activeTargetTag = activeHitPath.get(0).getViewId();
     }
 
-    TouchTargetHelper.ViewTarget activeViewTarget = activeHitPath.get(0);
-    int activeTargetTag = activeViewTarget.getViewId();
-
+    // Dispatch pointer events from the MotionEvents. When we want to ignore an event, we need to
+    // exit early so we don't record anything about this MotionEvent.
     switch (action) {
       case MotionEvent.ACTION_DOWN:
       case MotionEvent.ACTION_POINTER_DOWN:
@@ -225,22 +260,21 @@ public class JSPointerDispatcher {
         break;
       case MotionEvent.ACTION_HOVER_MOVE:
         // TODO(luwe) - converge this with ACTION_MOVE
-        // HOVER_MOVE may occur before DOWN. Add its downTime as a coalescing key
+        // If we don't move enough, ignore this event.
+        float[] eventCoordinates = eventState.getEventCoordinatesByPointerId().get(activePointerId);
+        float[] lastEventCoordinates =
+            mLastEventCoordinatesByPointerId != null
+                    && mLastEventCoordinatesByPointerId.containsKey(activePointerId)
+                ? mLastEventCoordinatesByPointerId.get(activePointerId)
+                : new float[] {0, 0};
+        if (!qualifiedMove(eventCoordinates, lastEventCoordinates)) {
+          return;
+        }
+
         onMove(activeTargetTag, eventState, motionEvent, eventDispatcher);
         break;
       case MotionEvent.ACTION_MOVE:
-        // TODO(luwe) - converge this with ACTION_HOVER_MOVE
-        boolean listeningForMove =
-            isAnyoneListeningForBubblingEvent(activeHitPath, EVENT.MOVE, EVENT.MOVE_CAPTURE);
-        if (listeningForMove) {
-          eventDispatcher.dispatchEvent(
-              PointerEvent.obtain(
-                  PointerEventHelper.POINTER_MOVE,
-                  activeTargetTag,
-                  eventState,
-                  motionEvent,
-                  getCoalescingKey()));
-        }
+        onMove(activeTargetTag, eventState, motionEvent, eventDispatcher);
         break;
       case MotionEvent.ACTION_UP:
       case MotionEvent.ACTION_POINTER_UP:
@@ -250,16 +284,32 @@ public class JSPointerDispatcher {
       case MotionEvent.ACTION_CANCEL:
         dispatchCancelEvent(eventState, motionEvent, eventDispatcher);
         break;
+      case MotionEvent.ACTION_HOVER_ENTER:
+        // Ignore these events as enters will be calculated from HOVER_MOVE
+        return;
+      case MotionEvent.ACTION_HOVER_EXIT:
+        // For root exits, we need to update our stored eventState to reflect this exit because we
+        // won't receive future HOVER_MOVE events when cursor is outside root view
+        if (isExitFromRoot) {
+          // We've set the hit path for this pointer to be empty to calculate all exits
+          onMove(activeTargetTag, eventState, motionEvent, eventDispatcher);
+        }
+        break;
       default:
         FLog.w(
             ReactConstants.TAG,
-            "Warning : Motion Event was ignored. Action=" + action + " Target=" + activeTargetTag);
+            "Motion Event was ignored. Action=" + action + " Target=" + activeTargetTag);
         return;
     }
 
+    // Caching the event state so we have a new "last"
     mLastHitPathByPointerId = eventState.getHitPathByPointerId();
     mLastEventCoordinatesByPointerId = eventState.getEventCoordinatesByPointerId();
     mLastButtonState = motionEvent.getButtonState();
+
+    // Clean up any stale pointerIds
+    Set<Integer> allPointerIds = mLastEventCoordinatesByPointerId.keySet();
+    mHoveringPointerIds.retainAll(allPointerIds);
   }
 
   private static boolean isAnyoneListeningForBubblingEvent(
@@ -321,7 +371,11 @@ public class JSPointerDispatcher {
     }
   }
 
-  // called on hover_move motion events only
+  private boolean qualifiedMove(float[] eventCoordinates, float[] lastEventCoordinates) {
+    return (Math.abs(lastEventCoordinates[0] - eventCoordinates[0]) > ONMOVE_EPSILON
+        || Math.abs(lastEventCoordinates[1] - eventCoordinates[1]) > ONMOVE_EPSILON);
+  }
+
   private void onMove(
       int targetTag,
       PointerEventState eventState,
@@ -329,7 +383,6 @@ public class JSPointerDispatcher {
       EventDispatcher eventDispatcher) {
 
     int activePointerId = eventState.getActivePointerId();
-    float[] eventCoordinates = eventState.getEventCoordinatesByPointerId().get(activePointerId);
     List<ViewTarget> activeHitPath = eventState.getHitPathByPointerId().get(activePointerId);
 
     List<ViewTarget> lastHitPath =
@@ -337,21 +390,6 @@ public class JSPointerDispatcher {
             ? mLastHitPathByPointerId.get(activePointerId)
             : new ArrayList<ViewTarget>();
 
-    float[] lastEventCoordinates =
-        mLastEventCoordinatesByPointerId != null
-                && mLastEventCoordinatesByPointerId.containsKey(activePointerId)
-            ? mLastEventCoordinatesByPointerId.get(activePointerId)
-            : new float[] {0, 0};
-
-    boolean qualifiedMove =
-        (Math.abs(lastEventCoordinates[0] - eventCoordinates[0]) > ONMOVE_EPSILON
-            || Math.abs(lastEventCoordinates[1] - eventCoordinates[1]) > ONMOVE_EPSILON);
-
-    // Early exit if active pointer has not moved enough
-    if (!qualifiedMove) {
-      return;
-    }
-
     // hitState is list ordered from inner child -> parent tag
     // Traverse hitState back-to-front to find the first divergence with lastHitPath
     // FIXME: this may generate incorrect events when view collapsing changes the hierarchy
@@ -460,7 +498,9 @@ public class JSPointerDispatcher {
         mChildHandlingNativeGesture == -1,
         "Expected to not have already sent a cancel for this gesture");
 
-    PointerEventState eventState = createEventState(motionEvent);
+    int activeIndex = motionEvent.getActionIndex();
+    int activePointerId = motionEvent.getPointerId(activeIndex);
+    PointerEventState eventState = createEventState(activePointerId, motionEvent);
     dispatchCancelEvent(eventState, motionEvent, eventDispatcher);
   }
 
@@ -473,8 +513,8 @@ public class JSPointerDispatcher {
         mChildHandlingNativeGesture == -1,
         "Expected to not have already sent a cancel for this gesture");
 
-    List<ViewTarget> activeHitPath =
-        eventState.getHitPathByPointerId().get(eventState.getActivePointerId());
+    int activePointerId = eventState.getActivePointerId();
+    List<ViewTarget> activeHitPath = eventState.getHitPathByPointerId().get(activePointerId);
 
     if (!activeHitPath.isEmpty()) {
       boolean listeningForCancel =
@@ -501,6 +541,8 @@ public class JSPointerDispatcher {
           eventDispatcher);
 
       incrementCoalescingKey();
+      mHoveringPointerIds.remove(mPrimaryPointerId);
+      mHoveringPointerIds.remove(activePointerId);
       mPrimaryPointerId = UNSET_POINTER_ID;
     }
   }

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

@@ -8,9 +8,10 @@
 package com.facebook.react.uimanager;
 
 import androidx.annotation.Nullable;
+import com.facebook.common.logging.FLog;
 import com.facebook.react.bridge.Dynamic;
-import com.facebook.react.bridge.JSApplicationIllegalArgumentException;
 import com.facebook.react.bridge.ReadableType;
+import com.facebook.react.common.ReactConstants;
 import com.facebook.react.modules.i18nmanager.I18nUtil;
 import com.facebook.react.uimanager.annotations.ReactProp;
 import com.facebook.react.uimanager.annotations.ReactPropGroup;
@@ -60,11 +61,16 @@ public class LayoutShadowNode extends ReactShadowNodeImpl {
           unit = YogaUnit.PERCENT;
           value = Float.parseFloat(s.substring(0, s.length() - 1));
         } else {
-          throw new IllegalArgumentException("Unknown value: " + s);
+          FLog.w(ReactConstants.TAG, "Unknown value: " + s);
+          unit = YogaUnit.UNDEFINED;
+          value = YogaConstants.UNDEFINED;
         }
-      } else {
+      } else if (dynamic.getType() == ReadableType.Number) {
         unit = YogaUnit.POINT;
         value = PixelUtil.toPixelFromDIP(dynamic.asDouble());
+      } else {
+        unit = YogaUnit.UNDEFINED;
+        value = YogaConstants.UNDEFINED;
       }
     }
   }
@@ -318,8 +324,9 @@ public class LayoutShadowNode extends ReactShadowNodeImpl {
         }
       default:
         {
-          throw new JSApplicationIllegalArgumentException(
-              "invalid value for flexDirection: " + flexDirection);
+          FLog.w(ReactConstants.TAG, "invalid value for flexDirection: " + flexDirection);
+          setFlexDirection(YogaFlexDirection.COLUMN);
+          break;
         }
     }
   }
@@ -353,8 +360,9 @@ public class LayoutShadowNode extends ReactShadowNodeImpl {
         }
       default:
         {
-          throw new JSApplicationIllegalArgumentException(
-              "invalid value for flexWrap: " + flexWrap);
+          FLog.w(ReactConstants.TAG, "invalid value for flexWrap: " + flexWrap);
+          setFlexWrap(YogaWrap.NO_WRAP);
+          break;
         }
     }
   }
@@ -413,8 +421,9 @@ public class LayoutShadowNode extends ReactShadowNodeImpl {
         }
       default:
         {
-          throw new JSApplicationIllegalArgumentException(
-              "invalid value for alignSelf: " + alignSelf);
+          FLog.w(ReactConstants.TAG, "invalid value for alignSelf: " + alignSelf);
+          setAlignSelf(YogaAlign.AUTO);
+          return;
         }
     }
   }
@@ -473,8 +482,9 @@ public class LayoutShadowNode extends ReactShadowNodeImpl {
         }
       default:
         {
-          throw new JSApplicationIllegalArgumentException(
-              "invalid value for alignItems: " + alignItems);
+          FLog.w(ReactConstants.TAG, "invalid value for alignItems: " + alignItems);
+          setAlignItems(YogaAlign.STRETCH);
+          return;
         }
     }
   }
@@ -533,8 +543,9 @@ public class LayoutShadowNode extends ReactShadowNodeImpl {
         }
       default:
         {
-          throw new JSApplicationIllegalArgumentException(
-              "invalid value for alignContent: " + alignContent);
+          FLog.w(ReactConstants.TAG, "invalid value for alignContent: " + alignContent);
+          setAlignContent(YogaAlign.FLEX_START);
+          return;
         }
     }
   }
@@ -583,8 +594,9 @@ public class LayoutShadowNode extends ReactShadowNodeImpl {
         }
       default:
         {
-          throw new JSApplicationIllegalArgumentException(
-              "invalid value for justifyContent: " + justifyContent);
+          FLog.w(ReactConstants.TAG, "invalid value for justifyContent: " + justifyContent);
+          setJustifyContent(YogaJustify.FLEX_START);
+          break;
         }
     }
   }
@@ -617,8 +629,9 @@ public class LayoutShadowNode extends ReactShadowNodeImpl {
         }
       default:
         {
-          throw new JSApplicationIllegalArgumentException(
-              "invalid value for overflow: " + overflow);
+          FLog.w(ReactConstants.TAG, "invalid value for overflow: " + overflow);
+          setOverflow(YogaOverflow.VISIBLE);
+          break;
         }
     }
   }
@@ -647,7 +660,9 @@ public class LayoutShadowNode extends ReactShadowNodeImpl {
         }
       default:
         {
-          throw new JSApplicationIllegalArgumentException("invalid value for display: " + display);
+          FLog.w(ReactConstants.TAG, "invalid value for display: " + display);
+          setDisplay(YogaDisplay.FLEX);
+          break;
         }
     }
   }
@@ -820,8 +835,9 @@ public class LayoutShadowNode extends ReactShadowNodeImpl {
         }
       default:
         {
-          throw new JSApplicationIllegalArgumentException(
-              "invalid value for position: " + position);
+          FLog.w(ReactConstants.TAG, "invalid value for position: " + position);
+          setPositionType(YogaPositionType.RELATIVE);
+          break;
         }
     }
   }

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

@@ -373,7 +373,7 @@ public class NativeViewHierarchyManager {
 
   /**
    * @param tag react tag of the node we want to manage
-   * @param indicesToRemove ordered (asc) list of indicies at which view should be removed
+   * @param indicesToRemove ordered (asc) list of indices at which view should be removed
    * @param viewsToAdd ordered (asc based on mIndex property) list of tag-index pairs that represent
    *     a view which should be added at the specified index
    * @param tagsToDelete list of tags corresponding to views that should be removed
@@ -666,6 +666,15 @@ public class NativeViewHierarchyManager {
     mRootTags.delete(rootViewTag);
   }
 
+  /**
+   * Return root view num
+   *
+   * @return The num of root view
+   */
+  public synchronized int getRootViewNum() {
+    return mRootTags.size();
+  }
+
   /**
    * Returns true on success, false on failure. If successful, after calling, output buffer will be
    * {x, y, width, height}.