react-native-tvos 0.69.6-1 → 0.69.6-3

package/React/Base/RCTVersion.m

@@ -24,7 +24,7 @@ NSDictionary* RCTGetReactNativeVersion(void)
                   RCTVersionMajor: @(0),
                   RCTVersionMinor: @(69),
                   RCTVersionPatch: @(6),
-                  RCTVersionPrerelease: @"1",
+                  RCTVersionPrerelease: @"3",
                   };
   });
   return __rnVersion;

package/React/Fabric/Mounting/ComponentViews/View/RCTViewComponentView.mm

@@ -52,6 +52,7 @@ using namespace facebook::react;
   UIView *_nextFocusLeft;
   UIView *_nextFocusRight;
   UIView *_nextFocusActiveTarget;
+  BOOL _autoFocus;
 }
 
 @synthesize removeClippedSubviews = _removeClippedSubviews;
@@ -131,7 +132,7 @@ using namespace facebook::react;
   return (RCTRootComponentView *)rootview;
 }
 
-- (void)addFocusDestinations:(NSArray*)destinations {
+- (void)addFocusGuide {
   if (self.focusGuide == nil) {
     self.focusGuide = [UIFocusGuide new];
     [self addLayoutGuide:self.focusGuide];
@@ -141,7 +142,17 @@ using namespace facebook::react;
     [self.focusGuide.widthAnchor constraintEqualToAnchor:self.widthAnchor].active = YES;
     [self.focusGuide.heightAnchor constraintEqualToAnchor:self.heightAnchor].active = YES;
   }
+}
 
+- (void)removeFocusGuide {
+  if (self.focusGuide != nil) {
+    [self removeLayoutGuide:self.focusGuide];
+    self.focusGuide = nil;
+  }
+}
+
+- (void)addFocusDestinations:(NSArray*)destinations {
+  [self addFocusGuide];
   self.focusGuide.preferredFocusEnvironments = destinations;
 }
 
@@ -416,6 +427,17 @@ using namespace facebook::react;
     if (context.previouslyFocusedView == context.nextFocusedView) {
       return;
     }
+  
+    if (_autoFocus && self.focusGuide != nil && context.previouslyFocusedItem != nil) {
+      // Whenever focus leaves the container, `nextFocusedView` is the destination, the item outside the container.
+      // So, `previouslyFocusedItem` is always the last focused child of `TVFocusGuide`.
+      // We should update `preferredFocusEnvironments` in this case to make sure `FocusGuide` remembers
+      // the last focused element and redirects the focus to it whenever focus comes back.
+      // We also add `self` as the second option in case `previouslyFocusedItem` becomes unreachable (e.g gets detached).
+      // `self` helps redirecting focus to the first focusable element in that case.
+      self.focusGuide.preferredFocusEnvironments = @[context.previouslyFocusedItem, self];
+    }
+
     if (context.nextFocusedView == self && self.isUserInteractionEnabled ) {
       [self becomeFirstResponder];
       [self enableDirectionalFocusGuides];
@@ -825,6 +847,16 @@ using namespace facebook::react;
       _nextFocusRight = nil;
     }
   }
+  
+  // `autoFocus`
+  if (oldViewProps.autoFocus != newViewProps.autoFocus) {
+    _autoFocus = newViewProps.autoFocus;
+    if (_autoFocus == true) {
+      [self addFocusGuide];
+    } else {
+      [self removeFocusGuide];
+    }
+  }
 #endif
 
 
@@ -910,10 +942,22 @@ using namespace facebook::react;
   if ([_propKeysManagedByAnimated_DO_NOT_USE_THIS_IS_BROKEN containsObject:@"opacity"]) {
     self.layer.opacity = (float)props.opacity;
   }
-    
+  
+  // We reset the `preferredFocusEnvironments` in case of recycling to prevent bugs.
+  // Resetting it also introduces a bug but it prevents much worse ones.
+  // The destination `focusEnvironment` reference could be recycled and used in another place so we might
+  // be holding a reference and redirecting the focus to the wrong view.
+  // To make sure that's not the case, we reset the destination to `self` which will
+  // redirect the focus to the first focusable child.
   if (self.focusGuide != nil) {
-    [self removeLayoutGuide:self.focusGuide];
-    self.focusGuide = nil;
+    self.focusGuide.preferredFocusEnvironments = @[self];
+  }
+    
+  // If `autoFocus` is enabled, addition/removal process of `UIFocusGuide` is managed
+  // inside `updateProps` method. Removing `UIFocusGuide` here for that case would cause
+  // weird bugs and state loss.
+  if (!_autoFocus) {
+    [self removeFocusGuide];
   }
 
   _propKeysManagedByAnimated_DO_NOT_USE_THIS_IS_BROKEN = nil;

package/React/Views/RCTTVView.h

@@ -42,6 +42,11 @@
 @property (nonatomic, strong) UIFocusGuide * focusGuideLeft;
 @property (nonatomic, strong) UIFocusGuide * focusGuideRight;
 
+/**
+ * Auto focus
+ */
+@property (nonatomic, assign) BOOL autoFocus;
+
 - (instancetype)initWithBridge:(RCTBridge *)bridge;
 
 /**

package/React/Views/RCTTVView.m

@@ -261,6 +261,17 @@ RCT_NOT_IMPLEMENTED(-(instancetype)initWithCoder : unused)
   if (context.previouslyFocusedView == context.nextFocusedView) {
     return;
   }
+    
+  if (_autoFocus && self.focusGuide != nil && context.previouslyFocusedItem != nil) {
+    // Whenever focus leaves the container, `nextFocusedView` is the destination, the item outside the container.
+    // So, `previouslyFocusedItem` is always the last focused child of `TVFocusGuide`.
+    // We should update `preferredFocusEnvironments` in this case to make sure `FocusGuide` remembers
+    // the last focused element and redirects the focus to it whenever focus comes back.
+    // We also add `self` as the second option in case `previouslyFocusedItem` becomes unreachable (e.g gets detached).
+    // `self` helps redirecting focus to the first focusable element in that case.
+    self.focusGuide.preferredFocusEnvironments = @[context.previouslyFocusedItem, self];
+  }
+    
   if (context.nextFocusedView == self && self.isTVSelectable ) {
     [self becomeFirstResponder];
     [self enableDirectionalFocusGuides];
@@ -432,6 +443,14 @@ RCT_NOT_IMPLEMENTED(-(instancetype)initWithCoder : unused)
   [self setPreferredFocus:hasTVPreferredFocus];
 }
 
+- (void)setAutoFocus:(BOOL)autoFocus
+{
+    if (_autoFocus != autoFocus) {
+        _autoFocus = autoFocus;
+        [self addFocusGuide:@[self]];
+    }
+}
+
 - (void)addFocusGuide:(NSArray*)destinations {
   if (self.focusGuide == nil) {
     self.focusGuide = [UIFocusGuide new];

package/React/Views/RCTViewManager.m

@@ -137,6 +137,7 @@ RCT_EXPORT_VIEW_PROPERTY(nextFocusUp, NSNumber)
 RCT_EXPORT_VIEW_PROPERTY(nextFocusDown, NSNumber)
 RCT_EXPORT_VIEW_PROPERTY(nextFocusLeft, NSNumber)
 RCT_EXPORT_VIEW_PROPERTY(nextFocusRight, NSNumber)
+RCT_EXPORT_VIEW_PROPERTY(autoFocus, BOOL)
 #endif
 
 // Accessibility related properties

package/ReactAndroid/gradle.properties

@@ -1,4 +1,4 @@
-VERSION_NAME=0.69.6-1
+VERSION_NAME=0.69.6-3
 GROUP=com.facebook.react
 
 POM_NAME=ReactNative

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

@@ -21,8 +21,13 @@ import java.util.List;
 /* package */ class EventAnimationDriver implements RCTEventEmitter {
   private List<String> mEventPath;
   /* package */ ValueAnimatedNode mValueNode;
+  /* package */ String mEventName;
+  /* package */ int mViewTag;
 
-  public EventAnimationDriver(List<String> eventPath, ValueAnimatedNode valueNode) {
+  public EventAnimationDriver(
+      String eventName, int viewTag, List<String> eventPath, ValueAnimatedNode valueNode) {
+    mEventName = eventName;
+    mViewTag = viewTag;
     mEventPath = eventPath;
     mValueNode = valueNode;
   }

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

@@ -113,7 +113,7 @@ public class NativeAnimatedModule extends NativeAnimatedModuleSpec
 
     @AnyThread
     boolean isEmpty() {
-      return mQueue.isEmpty();
+      return mQueue.isEmpty() && mPeekedOperation != null;
     }
 
     void setSynchronizedAccess(boolean isSynchronizedAccess) {
@@ -393,8 +393,8 @@ public class NativeAnimatedModule extends NativeAnimatedModuleSpec
 
   /**
    * Given a viewTag, detect if we're running in Fabric or non-Fabric and attach an event listener
-   * to the correct UIManager, if necessary. This is expected to only be called from the JS thread,
-   * and not concurrently.
+   * to the correct UIManager, if necessary. This is expected to only be called from the native
+   * module thread, and not concurrently.
    *
    * @param viewTag
    */
@@ -417,8 +417,7 @@ public class NativeAnimatedModule extends NativeAnimatedModuleSpec
     }
 
     // Subscribe to UIManager (Fabric or non-Fabric) lifecycle events if we haven't yet
-    if ((mInitializedForFabric && mUIManagerType == UIManagerType.FABRIC)
-        || (mInitializedForNonFabric && mUIManagerType == UIManagerType.DEFAULT)) {
+    if (mUIManagerType == UIManagerType.FABRIC ? mInitializedForFabric : mInitializedForNonFabric) {
       return;
     }
 

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/modules/core/ReactAndroidHWInputDeviceHelper.java

@@ -63,6 +63,18 @@ public class ReactAndroidHWInputDeviceHelper {
           .put(KeyEvent.KEYCODE_CHANNEL_UP, "channelUp")
           .build();
 
+  private static final Map<Integer, String> KEY_EVENTS_LONG_PRESS_ACTIONS =
+      MapBuilder.<Integer, String>builder()
+          .put(KeyEvent.KEYCODE_DPAD_CENTER, "longSelect")
+          .put(KeyEvent.KEYCODE_ENTER, "longSelect")
+          .put(KeyEvent.KEYCODE_NUMPAD_ENTER, "longSelect")
+          .put(KeyEvent.KEYCODE_BUTTON_SELECT, "longSelect")
+          .put(KeyEvent.KEYCODE_DPAD_UP, "longUp")
+          .put(KeyEvent.KEYCODE_DPAD_RIGHT, "longRight")
+          .put(KeyEvent.KEYCODE_DPAD_DOWN, "longDown")
+          .put(KeyEvent.KEYCODE_DPAD_LEFT, "longLeft")
+          .build();
+
   /**
    * We keep a reference to the last focused view id so that we can send it as a target for key
    * events and be able to send a blur event when focus changes.
@@ -81,21 +93,33 @@ public class ReactAndroidHWInputDeviceHelper {
       eventKeyCode == KeyEvent.KEYCODE_ENTER;
   }
 
+  /** Only the up/right/down/left arrows. The dpad center button is not included */
+  private boolean isDPadEvent(int eventKeyCode) {
+    return eventKeyCode == KeyEvent.KEYCODE_DPAD_UP ||
+      eventKeyCode == KeyEvent.KEYCODE_DPAD_RIGHT ||
+      eventKeyCode == KeyEvent.KEYCODE_DPAD_DOWN ||
+      eventKeyCode == KeyEvent.KEYCODE_DPAD_LEFT;
+  }
+
   /** 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();
     int eventKeyAction = ev.getAction();
     long time = SystemClock.uptimeMillis();
+    boolean isSelectOrDPadEvent = isDPadEvent(eventKeyCode) || isSelectEvent(eventKeyCode);
 
     // Simple implementation of long press detection
     if ((eventKeyAction == KeyEvent.ACTION_DOWN)
-      && isSelectEvent(eventKeyCode) && mLastKeyDownTime == 0) {
+      && isSelectOrDPadEvent && mLastKeyDownTime == 0) {
       mLastKeyDownTime = time;
     }
+
     if (shouldDispatchEvent(eventKeyCode, eventKeyAction)) {
       long delta = time - mLastKeyDownTime;
-      if (isSelectEvent(eventKeyCode) && (delta > mPressedDelta)) {
-        dispatchEvent("longSelect", mLastFocusedViewId, eventKeyAction, context);
+      boolean isLongPress = delta > mPressedDelta;
+
+      if(isLongPress && isSelectOrDPadEvent){
+        dispatchEvent(KEY_EVENTS_LONG_PRESS_ACTIONS.get(eventKeyCode), mLastFocusedViewId, eventKeyAction, context);
       } else {
         dispatchEvent(KEY_EVENTS_ACTIONS.get(eventKeyCode), mLastFocusedViewId, eventKeyAction, context);
       }

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

@@ -18,5 +18,5 @@ public class ReactNativeVersion {
       "major", 0,
       "minor", 69,
       "patch", 6,
-      "prerelease", "1");
+      "prerelease", "3");
 }

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);
+  }
 }