react-native-tvos 0.69.6-2 → 0.69.8-0

package/ReactAndroid/src/main/java/com/facebook/react/animated/NativeAnimatedNodesManager.java

@@ -30,11 +30,9 @@ import com.facebook.react.uimanager.events.EventDispatcher;
 import com.facebook.react.uimanager.events.EventDispatcherListener;
 import java.util.ArrayDeque;
 import java.util.ArrayList;
-import java.util.HashMap;
 import java.util.LinkedList;
 import java.util.List;
 import java.util.ListIterator;
-import java.util.Map;
 import java.util.Queue;
 
 /**
@@ -57,9 +55,9 @@ import java.util.Queue;
   private final SparseArray<AnimatedNode> mAnimatedNodes = new SparseArray<>();
   private final SparseArray<AnimationDriver> mActiveAnimations = new SparseArray<>();
   private final SparseArray<AnimatedNode> mUpdatedNodes = new SparseArray<>();
-  // Mapping of a view tag and an event name to a list of event animation drivers. 99% of the time
-  // there will be only one driver per mapping so all code code should be optimized around that.
-  private final Map<String, List<EventAnimationDriver>> mEventDrivers = new HashMap<>();
+  // List of event animation drivers for an event on view.
+  // There may be multiple drivers for the same event and view.
+  private final List<EventAnimationDriver> mEventDrivers = new ArrayList<>();
   private final ReactApplicationContext mReactApplicationContext;
   private int mAnimatedGraphBFSColor = 0;
   // Used to avoid allocating a new array on every frame in `runUpdates` and `onEventDispatch`.
@@ -76,36 +74,27 @@ import java.util.Queue;
 
   /**
    * Initialize event listeners for Fabric UIManager or non-Fabric UIManager, exactly once. Once
-   * Fabric is the only UIManager, this logic can be simplified. This is only called on the JS
-   * thread.
+   * Fabric is the only UIManager, this logic can be simplified. This is expected to only be called
+   * from the native module thread.
    *
    * @param uiManagerType
    */
-  @UiThread
   public void initializeEventListenerForUIManagerType(@UIManagerType final int uiManagerType) {
-    if ((uiManagerType == UIManagerType.FABRIC && mEventListenerInitializedForFabric)
-        || (uiManagerType == UIManagerType.DEFAULT && mEventListenerInitializedForNonFabric)) {
+    if (uiManagerType == UIManagerType.FABRIC
+        ? mEventListenerInitializedForFabric
+        : mEventListenerInitializedForNonFabric) {
       return;
     }
 
-    final NativeAnimatedNodesManager self = this;
-    mReactApplicationContext.runOnUiQueueThread(
-        new Runnable() {
-          @Override
-          public void run() {
-            UIManager uiManager =
-                UIManagerHelper.getUIManager(mReactApplicationContext, uiManagerType);
-            if (uiManager != null) {
-              uiManager.<EventDispatcher>getEventDispatcher().addListener(self);
-
-              if (uiManagerType == UIManagerType.FABRIC) {
-                mEventListenerInitializedForFabric = true;
-              } else {
-                mEventListenerInitializedForNonFabric = true;
-              }
-            }
-          }
-        });
+    UIManager uiManager = UIManagerHelper.getUIManager(mReactApplicationContext, uiManagerType);
+    if (uiManager != null) {
+      uiManager.<EventDispatcher>getEventDispatcher().addListener(this);
+      if (uiManagerType == UIManagerType.FABRIC) {
+        mEventListenerInitializedForFabric = true;
+      } else {
+        mEventListenerInitializedForNonFabric = true;
+      }
+    }
   }
 
   /*package*/ @Nullable
@@ -471,7 +460,8 @@ import java.util.Queue;
   }
 
   @UiThread
-  public void addAnimatedEventToView(int viewTag, String eventName, ReadableMap eventMapping) {
+  public void addAnimatedEventToView(
+      int viewTag, String eventHandlerName, ReadableMap eventMapping) {
     int nodeTag = eventMapping.getInt("animatedValueTag");
     AnimatedNode node = mAnimatedNodes.get(nodeTag);
     if (node == null) {
@@ -482,8 +472,8 @@ import java.util.Queue;
       throw new JSApplicationIllegalArgumentException(
           "addAnimatedEventToView: Animated node on view ["
               + viewTag
-              + "] connected to event ("
-              + eventName
+              + "] connected to event handler ("
+              + eventHandlerName
               + ") should be of type "
               + ValueAnimatedNode.class.getName());
     }
@@ -494,37 +484,31 @@ import java.util.Queue;
       pathList.add(path.getString(i));
     }
 
-    EventAnimationDriver event = new EventAnimationDriver(pathList, (ValueAnimatedNode) node);
-    String key = viewTag + eventName;
-    if (mEventDrivers.containsKey(key)) {
-      mEventDrivers.get(key).add(event);
-    } else {
-      List<EventAnimationDriver> drivers = new ArrayList<>(1);
-      drivers.add(event);
-      mEventDrivers.put(key, drivers);
-    }
+    String eventName = normalizeEventName(eventHandlerName);
+
+    EventAnimationDriver eventDriver =
+        new EventAnimationDriver(eventName, viewTag, pathList, (ValueAnimatedNode) node);
+    mEventDrivers.add(eventDriver);
   }
 
   @UiThread
-  public void removeAnimatedEventFromView(int viewTag, String eventName, int animatedValueTag) {
-    String key = viewTag + eventName;
-    if (mEventDrivers.containsKey(key)) {
-      List<EventAnimationDriver> driversForKey = mEventDrivers.get(key);
-      if (driversForKey.size() == 1) {
-        mEventDrivers.remove(viewTag + eventName);
-      } else {
-        ListIterator<EventAnimationDriver> it = driversForKey.listIterator();
-        while (it.hasNext()) {
-          if (it.next().mValueNode.mTag == animatedValueTag) {
-            it.remove();
-            break;
-          }
-        }
+  public void removeAnimatedEventFromView(
+      int viewTag, String eventHandlerName, int animatedValueTag) {
+
+    String eventName = normalizeEventName(eventHandlerName);
+
+    ListIterator<EventAnimationDriver> it = mEventDrivers.listIterator();
+    while (it.hasNext()) {
+      EventAnimationDriver driver = it.next();
+      if (eventName.equals(driver.mEventName)
+          && viewTag == driver.mViewTag
+          && animatedValueTag == driver.mValueNode.mTag) {
+        it.remove();
+        break;
       }
     }
   }
 
-  @UiThread
   @Override
   public void onEventDispatch(final Event event) {
     // Events can be dispatched from any thread so we have to make sure handleEvent is run from the
@@ -556,18 +540,19 @@ import java.util.Queue;
       if (uiManager == null) {
         return;
       }
-      String eventName = uiManager.resolveCustomDirectEventName(event.getEventName());
-      if (eventName == null) {
-        eventName = "";
-      }
 
-      List<EventAnimationDriver> driversForKey = mEventDrivers.get(event.getViewTag() + eventName);
-      if (driversForKey != null) {
-        for (EventAnimationDriver driver : driversForKey) {
+      boolean foundAtLeastOneDriver = false;
+      Event.EventAnimationDriverMatchSpec matchSpec = event.getEventAnimationDriverMatchSpec();
+      for (EventAnimationDriver driver : mEventDrivers) {
+        if (matchSpec.match(driver.mViewTag, driver.mEventName)) {
+          foundAtLeastOneDriver = true;
           stopAnimationsForNode(driver.mValueNode);
           event.dispatch(driver);
           mRunUpdateNodeList.add(driver.mValueNode);
         }
+      }
+
+      if (foundAtLeastOneDriver) {
         updateNodes(mRunUpdateNodeList);
         mRunUpdateNodeList.clear();
       }
@@ -782,4 +767,14 @@ import java.util.Queue;
       mWarnedAboutGraphTraversal = false;
     }
   }
+
+  private String normalizeEventName(String eventHandlerName) {
+    // Fabric UIManager also makes this assumption
+    String eventName = eventHandlerName;
+    if (eventHandlerName.startsWith("on")) {
+      eventName = "top" + eventHandlerName.substring(2);
+    }
+
+    return eventName;
+  }
 }

package/ReactAndroid/src/main/java/com/facebook/react/config/ReactFeatureFlags.java

@@ -105,7 +105,13 @@ public class ReactFeatureFlags {
   public static boolean enableDelayedViewStateDeletion = false;
 
   /**
-   * Send key down events as well as key up events
+   * Android TV: Send key down events as well as key up events. 
+   * Enabling this flag will result in two 'select' TVRemoteEventHandler events
+   * (one with key action 0 and one with key action 1) for each press of the center
+   * DPad button. (Similarly for arrow keys.)
+   * Note: If you enable this flag, long presses of the select or center button will
+   * result in an initial 'select' with eventKeyAction = 0 (ACTION_DOWN), before
+   * the expected 'longSelect' events are fired. (Similarly for arrow keys.)
    */
   public static boolean enableKeyDownEvents = false;
 

package/ReactAndroid/src/main/java/com/facebook/react/modules/core/ReactAndroidHWInputDeviceHelper.java

@@ -81,8 +81,14 @@ public class ReactAndroidHWInputDeviceHelper {
    */
   private int mLastFocusedViewId = View.NO_ID;
 
+  // Presses longer than this number of milliseconds are treated as long presses
+  // This seems to be roughly the time the emulator waits after the first key down event
+  // before sending a continuous stream of rapid key downs on a long press.
+  private long mLongPressedDelta = 300;
+
+  // These are used for long press detection
   private long mLastKeyDownTime = 0;
-  private long mPressedDelta = 1000;
+  private boolean longPressEventActive = false;
 
   public ReactAndroidHWInputDeviceHelper() {}
 
@@ -101,6 +107,12 @@ public class ReactAndroidHWInputDeviceHelper {
       eventKeyCode == KeyEvent.KEYCODE_DPAD_LEFT;
   }
 
+  // True if we are in the long press state and we are more than
+  // mLongPressedDelta milliseconds since the last long press event was fired
+  private boolean isLongPressEventTime(long time) {
+    return mLastKeyDownTime != 0 && time - mLastKeyDownTime > mLongPressedDelta;
+  }
+
   /** Called from {@link com.facebook.react.ReactRootView}. This is the main place the key events are handled. */
   public void handleKeyEvent(KeyEvent ev, ReactContext context) {
     int eventKeyCode = ev.getKeyCode();
@@ -108,30 +120,48 @@ public class ReactAndroidHWInputDeviceHelper {
     long time = SystemClock.uptimeMillis();
     boolean isSelectOrDPadEvent = isDPadEvent(eventKeyCode) || isSelectEvent(eventKeyCode);
 
-    // Simple implementation of long press detection
-    if ((eventKeyAction == KeyEvent.ACTION_DOWN)
-      && isSelectOrDPadEvent && mLastKeyDownTime == 0) {
-      mLastKeyDownTime = time;
+    // Simple implementation of long press detection for key down events
+    if ((eventKeyAction == KeyEvent.ACTION_DOWN) && isSelectOrDPadEvent) {
+      if (mLastKeyDownTime == 0) {
+        mLastKeyDownTime = time;
+      } else {
+        if (isLongPressEventTime(time)) {
+          // Activate long press state and don't reset until key up event arrives
+          longPressEventActive = true;
+        }
+      }
     }
 
-    if (shouldDispatchEvent(eventKeyCode, eventKeyAction)) {
-      long delta = time - mLastKeyDownTime;
-      boolean isLongPress = delta > mPressedDelta;
-
-      if(isLongPress && isSelectOrDPadEvent){
-        dispatchEvent(KEY_EVENTS_LONG_PRESS_ACTIONS.get(eventKeyCode), mLastFocusedViewId, eventKeyAction, context);
+    if (shouldDispatchEvent(eventKeyCode, eventKeyAction, time)) {
+      if(longPressEventActive) {
+        // If we are not sending key down events to JS, send the long press event as a key up to make sure it is received
+        dispatchEvent(
+          KEY_EVENTS_LONG_PRESS_ACTIONS.get(eventKeyCode),
+          mLastFocusedViewId,
+          ReactFeatureFlags.enableKeyDownEvents ? eventKeyAction : KeyEvent.ACTION_UP,
+          context
+        );
+        // Update the start time for detecting the next long press event
+        mLastKeyDownTime = time;
       } else {
         dispatchEvent(KEY_EVENTS_ACTIONS.get(eventKeyCode), mLastFocusedViewId, eventKeyAction, context);
       }
+    }
+
+    // If this is key up event, reset long press detector
+    if ((eventKeyAction == KeyEvent.ACTION_UP) && isSelectOrDPadEvent) {
       mLastKeyDownTime = 0;
+      longPressEventActive = false;
     }
+
   }
 
-  // Android TV: Only send key up actions, unless key down events are enabled
-  private boolean shouldDispatchEvent(int eventKeyCode, int eventKeyAction) {
+  // Android TV: Only send key up actions, unless key down events are enabled or we need to send a long press event
+  private boolean shouldDispatchEvent(int eventKeyCode, int eventKeyAction, long time) {
     return KEY_EVENTS_ACTIONS.containsKey(eventKeyCode) && (
       (eventKeyAction == KeyEvent.ACTION_UP) ||
-      (eventKeyAction == KeyEvent.ACTION_DOWN && ReactFeatureFlags.enableKeyDownEvents)
+      (eventKeyAction == KeyEvent.ACTION_DOWN && !longPressEventActive && ReactFeatureFlags.enableKeyDownEvents) ||
+      (eventKeyAction == KeyEvent.ACTION_DOWN && longPressEventActive && isLongPressEventTime(time))
     );
   }
 

package/ReactAndroid/src/main/java/com/facebook/react/modules/systeminfo/ReactNativeVersion.java

@@ -17,6 +17,6 @@ public class ReactNativeVersion {
   public static final Map<String, Object> VERSION = MapBuilder.<String, Object>of(
       "major", 0,
       "minor", 69,
-      "patch", 6,
-      "prerelease", "2");
+      "patch", 8,
+      "prerelease", "0");
 }

package/ReactAndroid/src/main/java/com/facebook/react/uimanager/events/Event.java

@@ -39,6 +39,7 @@ public abstract class Event<T extends Event> {
   private int mViewTag;
   private long mTimestampMs;
   private int mUniqueID = sUniqueID++;
+  private @Nullable EventAnimationDriverMatchSpec mEventAnimationDriverMatchSpec;
 
   protected Event() {}
 
@@ -156,6 +157,19 @@ public abstract class Event<T extends Event> {
   /** @return the name of this event as registered in JS */
   public abstract String getEventName();
 
+  public EventAnimationDriverMatchSpec getEventAnimationDriverMatchSpec() {
+    if (mEventAnimationDriverMatchSpec == null) {
+      mEventAnimationDriverMatchSpec =
+          new EventAnimationDriverMatchSpec() {
+            @Override
+            public boolean match(int viewTag, String eventName) {
+              return viewTag == getViewTag() && eventName.equals(getEventName());
+            };
+          };
+    }
+    return mEventAnimationDriverMatchSpec;
+  }
+
   /**
    * Dispatch this event to JS using the given event emitter. Compatible with old and new renderer.
    * Instead of using this or dispatchModern, it is recommended that you simply override
@@ -216,4 +230,8 @@ public abstract class Event<T extends Event> {
     }
     dispatch(rctEventEmitter);
   }
+
+  public interface EventAnimationDriverMatchSpec {
+    boolean match(int viewTag, String eventName);
+  }
 }

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

@@ -586,6 +586,10 @@ public class ReactEditText extends AppCompatEditText
         new SpannableStringBuilder(reactTextUpdate.getText());
 
     manageSpans(spannableStringBuilder, reactTextUpdate.mContainsMultipleFragments);
+
+    // Mitigation for https://github.com/facebook/react-native/issues/35936 (S318090)
+    stripAbsoluteSizeSpans(spannableStringBuilder);
+
     mContainsImages = reactTextUpdate.containsImages();
 
     // When we update text, we trigger onChangeText code that will
@@ -659,6 +663,27 @@ public class ReactEditText extends AppCompatEditText
     }
   }
 
+  private void stripAbsoluteSizeSpans(SpannableStringBuilder sb) {
+    // We have already set a font size on the EditText itself. We can safely remove sizing spans
+    // which are the same as the set font size, and not otherwise overlapped.
+    final int effectiveFontSize = mTextAttributes.getEffectiveFontSize();
+    ReactAbsoluteSizeSpan[] spans = sb.getSpans(0, sb.length(), ReactAbsoluteSizeSpan.class);
+
+    outerLoop:
+    for (ReactAbsoluteSizeSpan span : spans) {
+      ReactAbsoluteSizeSpan[] overlappingSpans =
+          sb.getSpans(sb.getSpanStart(span), sb.getSpanEnd(span), ReactAbsoluteSizeSpan.class);
+
+      for (ReactAbsoluteSizeSpan overlappingSpan : overlappingSpans) {
+        if (span.getSize() != effectiveFontSize) {
+          continue outerLoop;
+        }
+      }
+
+      sb.removeSpan(span);
+    }
+  }
+
   private static boolean sameTextForSpan(
       final Editable oldText,
       final SpannableStringBuilder newText,