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

package/Libraries/NativeAnimation/RCTNativeAnimatedTurboModule.mm

@@ -26,9 +26,6 @@ typedef void (^AnimatedOperation)(RCTNativeAnimatedNodesManager *nodesManager);
   NSMutableArray<AnimatedOperation> *_operations;
   // Operations called before views have been updated.
   NSMutableArray<AnimatedOperation> *_preOperations;
-  NSMutableDictionary<NSNumber *, NSNumber *> *_animIdIsManagedByFabric;
-  // A set of nodeIDs managed by Fabric.
-  NSMutableSet<NSNumber *> *_nodeIDsManagedByFabric;
 }
 
 RCT_EXPORT_MODULE();
@@ -43,8 +40,6 @@ RCT_EXPORT_MODULE();
   if (self = [super init]) {
     _operations = [NSMutableArray new];
     _preOperations = [NSMutableArray new];
-    _animIdIsManagedByFabric = [NSMutableDictionary new];
-    _nodeIDsManagedByFabric = [NSMutableSet new];
   }
   return self;
 }
@@ -113,9 +108,6 @@ RCT_EXPORT_METHOD(updateAnimatedNodeConfig:(double)tag
 RCT_EXPORT_METHOD(connectAnimatedNodes:(double)parentTag
                   childTag:(double)childTag)
 {
-  if ([_nodeIDsManagedByFabric containsObject:@(childTag)]) {
-    [_nodeIDsManagedByFabric addObject:@(parentTag)];
-  }
   [self addOperationBlock:^(RCTNativeAnimatedNodesManager *nodesManager) {
     [nodesManager connectAnimatedNodes:[NSNumber numberWithDouble:parentTag] childTag:[NSNumber numberWithDouble:childTag]];
   }];
@@ -138,11 +130,7 @@ RCT_EXPORT_METHOD(startAnimatingNode:(double)animationId
     [nodesManager startAnimatingNode:[NSNumber numberWithDouble:animationId] nodeTag:[NSNumber numberWithDouble:nodeTag] config:config endCallback:callBack];
   }];
 
-  BOOL isNodeManagedByFabric = [_nodeIDsManagedByFabric containsObject:@(nodeTag)];
-  if (isNodeManagedByFabric) {
-    self->_animIdIsManagedByFabric[[NSNumber numberWithDouble:animationId]] = @YES;
-    [self flushOperationQueues];
-  }
+  [self flushOperationQueues];
 }
 
 RCT_EXPORT_METHOD(stopAnimation:(double)animationId)
@@ -150,9 +138,7 @@ RCT_EXPORT_METHOD(stopAnimation:(double)animationId)
   [self addOperationBlock:^(RCTNativeAnimatedNodesManager *nodesManager) {
     [nodesManager stopAnimation:[NSNumber numberWithDouble:animationId]];
   }];
-  if ([_animIdIsManagedByFabric[[NSNumber numberWithDouble:animationId]] boolValue]) {
-    [self flushOperationQueues];
-  }
+  [self flushOperationQueues];
 }
 
 RCT_EXPORT_METHOD(setAnimatedNodeValue:(double)nodeTag
@@ -192,9 +178,6 @@ RCT_EXPORT_METHOD(extractAnimatedNodeOffset:(double)nodeTag)
 RCT_EXPORT_METHOD(connectAnimatedNodeToView:(double)nodeTag
                   viewTag:(double)viewTag)
 {
-  if (RCTUIManagerTypeForTagIsFabric(@(viewTag))) {
-    [_nodeIDsManagedByFabric addObject:@(nodeTag)];
-  }
   [self addOperationBlock:^(RCTNativeAnimatedNodesManager *nodesManager) {
     // viewName is not used when node is managed by Fabric, and nodes are always managed by Fabric in Bridgeless.
     [nodesManager connectAnimatedNodeToView:[NSNumber numberWithDouble:nodeTag] viewTag:[NSNumber numberWithDouble:viewTag] viewName:nil];
@@ -291,7 +274,6 @@ RCT_EXPORT_METHOD(getValue:(double)nodeTag saveValueCallback:(RCTResponseSenderB
   _preOperations = [NSMutableArray new];
   _operations = [NSMutableArray new];
 
-
   RCTExecuteOnMainQueue(^{
     for (AnimatedOperation operation in preOperations) {
       operation(self->_nodesManager);

package/Libraries/StyleSheet/StyleSheetTypes.js

@@ -16,6 +16,7 @@ import type {NativeColorValue} from './PlatformColorValueTypes';
 
 export type ____ColorValue_Internal = null | string | number | NativeColorValue;
 
+export type ColorValue = ____ColorValue_Internal;
 export type ColorArrayValue = null | $ReadOnlyArray<____ColorValue_Internal>;
 export type PointValue = {
   x: number,

package/Libraries/Types/CoreEventTypes.js

@@ -164,3 +164,12 @@ export type MouseEvent = SyntheticEvent<
     timestamp: number,
   |}>,
 >;
+
+export type TVRemoteEvent = 
+  $ReadOnly<{|
+    eventType: string,
+    eventKeyAction?: string,
+    // $FlowFixMe[unclear-type]
+    body?: any,
+  |}>;
+

package/README.md

@@ -206,7 +206,9 @@ class Game2048 extends React.Component {
 
 | Prop | Value | Description | 
 |---|---|---|
-| destinations | any[] | Array of `Component`s to register as destinations of the FocusGuideView |
+| destinations | any[]? | Array of `Component`s to register as destinations of the FocusGuideView |
+| autoFocus | boolean? | If true, `TVFocusGuide` will automatically manage focus for you. It will redirect the focus to the first focusable child on the first visit. It also remembers the last focused child and redirects the focus to it on the subsequent visits. `destinations` prop takes precedence over this prop when used together. |
+| trapFocus* (Up, Down, Left, Right) | Prevents focus escaping from the container for the given directions. |
 
 - _Next Focus Direction_: the props `nextFocus*` on `View` should work as expected on iOS too (previously android only). One caveat is that if there is no focusable in the `nextFocusable*` direction next to the starting view, iOS doesn't check if we want to override the destination. 
 

package/React/Base/RCTRootView.m

@@ -167,6 +167,12 @@ RCT_NOT_IMPLEMENTED(-(instancetype)initWithCoder : (NSCoder *)aDecoder)
 #if TARGET_OS_TV
 - (NSArray<id<UIFocusEnvironment>> *)preferredFocusEnvironments
 {
+  if (self.reactPreferredFocusEnvironments != nil) {
+    NSArray<id<UIFocusEnvironment>> *tempReactPreferredFocusEnvironments = self.reactPreferredFocusEnvironments;
+    self.reactPreferredFocusEnvironments = nil;
+    return tempReactPreferredFocusEnvironments;
+  }
+
   if (self.reactPreferredFocusedView && self.reactPreferredFocusedView.window != nil) {
     return @[self.reactPreferredFocusedView];
   }

package/React/Base/RCTRootViewInternal.h

@@ -27,6 +27,7 @@
 #if TARGET_OS_TV
 @property (nonatomic, strong) RCTTVRemoteHandler *tvRemoteHandler;
 @property (nonatomic, weak) UIView *reactPreferredFocusedView;
+@property (nonatomic, copy, nullable) NSArray<id<UIFocusEnvironment>> *reactPreferredFocusEnvironments;
 #endif
 
 - (void)contentViewInvalidated;

package/React/Base/RCTVersion.m

@@ -23,8 +23,8 @@ NSDictionary* RCTGetReactNativeVersion(void)
     __rnVersion = @{
                   RCTVersionMajor: @(0),
                   RCTVersionMinor: @(69),
-                  RCTVersionPatch: @(6),
-                  RCTVersionPrerelease: @"2",
+                  RCTVersionPatch: @(8),
+                  RCTVersionPrerelease: @"0",
                   };
   });
   return __rnVersion;

package/React/Fabric/Mounting/ComponentViews/Root/RCTRootComponentView.h

@@ -23,6 +23,7 @@ NS_ASSUME_NONNULL_BEGIN
 #if TARGET_OS_TV
 @property (nonatomic, strong, nullable) RCTTVRemoteHandler *tvRemoteHandler;
 @property (nonatomic, weak, nullable) UIView *reactPreferredFocusedView;
+@property (nonatomic, copy, nullable) NSArray<id<UIFocusEnvironment>> *reactPreferredFocusEnvironments;
 #endif
 
 @end

package/React/Fabric/Mounting/ComponentViews/Root/RCTRootComponentView.mm

@@ -35,6 +35,12 @@ using namespace facebook::react;
 }
 
 - (NSArray<id<UIFocusEnvironment>> *)preferredFocusEnvironments {
+  if (self.reactPreferredFocusEnvironments != nil) {
+    NSArray<id<UIFocusEnvironment>> *tempReactPreferredFocusEnvironments = self.reactPreferredFocusEnvironments;
+    self.reactPreferredFocusEnvironments = nil;
+    return tempReactPreferredFocusEnvironments;
+  }
+
   if (self.reactPreferredFocusedView && self.reactPreferredFocusedView.window != nil) {
     return @[self.reactPreferredFocusedView];
   }

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

@@ -52,6 +52,13 @@ using namespace facebook::react;
   UIView *_nextFocusLeft;
   UIView *_nextFocusRight;
   UIView *_nextFocusActiveTarget;
+  BOOL _autoFocus;
+  BOOL _trapFocusUp;
+  BOOL _trapFocusDown;
+  BOOL _trapFocusLeft;
+  BOOL _trapFocusRight;
+  NSArray* _focusDestinations;
+  id<UIFocusItem> _previouslyFocusedItem;
 }
 
 @synthesize removeClippedSubviews = _removeClippedSubviews;
@@ -131,7 +138,7 @@ using namespace facebook::react;
   return (RCTRootComponentView *)rootview;
 }
 
-- (void)addFocusDestinations:(NSArray*)destinations {
+- (void)addFocusGuide:(NSArray*)destinations {
   if (self.focusGuide == nil) {
     self.focusGuide = [UIFocusGuide new];
     [self addLayoutGuide:self.focusGuide];
@@ -141,10 +148,49 @@ using namespace facebook::react;
     [self.focusGuide.widthAnchor constraintEqualToAnchor:self.widthAnchor].active = YES;
     [self.focusGuide.heightAnchor constraintEqualToAnchor:self.heightAnchor].active = YES;
   }
-
+  
   self.focusGuide.preferredFocusEnvironments = destinations;
 }
 
+- (void)removeFocusGuide {
+  if (self.focusGuide != nil) {
+    _focusDestinations = nil;
+    _previouslyFocusedItem = nil;
+
+    [self removeLayoutGuide:self.focusGuide];
+    self.focusGuide = nil;
+  }
+}
+
+/// Responsible of determining what focusGuide's next state should be based on the active properties of the component.
+- (void)handleFocusGuide
+{
+  // `destinations` should always be favored against `autoFocus` feature, if provided.
+  if (_focusDestinations != nil) {
+    [self addFocusGuide:_focusDestinations];
+  } else if (_autoFocus && _previouslyFocusedItem != nil) {
+    // 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 addFocusGuide:@[_previouslyFocusedItem, self]];
+  } else if (_autoFocus) {
+    [self addFocusGuide:@[self]];
+  } else {
+    // Then there's no need to have `focusGuide`, remove it to prevent potential bugs.
+    [self removeFocusGuide];
+  }
+}
+
+- (void)setFocusDestinations:(NSArray*)destinations
+{
+  if(destinations.count == 0) {
+    _focusDestinations = nil;
+  } else {
+    _focusDestinations = destinations;
+  }
+
+  [self handleFocusGuide];
+}
+
 - (void)sendFocusNotification:(__unused UIFocusUpdateContext *)context
 {
     [self sendNotificationWithEventType:@"focus"];
@@ -411,11 +457,38 @@ using namespace facebook::react;
   }
 }
 
+- (BOOL)shouldUpdateFocusInContext:(UIFocusUpdateContext *)context
+{
+  // This is  the `trapFocus*` logic that prevents the focus updates if
+  // focus should be trapped and `nextFocusedItem` is not a child FocusEnv.
+  if ((_trapFocusUp && context.focusHeading == UIFocusHeadingUp)
+     || (_trapFocusDown && context.focusHeading == UIFocusHeadingDown)
+     || (_trapFocusLeft && context.focusHeading == UIFocusHeadingLeft)
+     || (_trapFocusRight && context.focusHeading == UIFocusHeadingRight)) {
+    
+    // Checks if `nextFocusedItem` is a child `FocusEnvironment`.
+    // If not, it returns false thus it keeps the focus inside.
+    return [UIFocusSystem environment:self containsEnvironment:context.nextFocusedItem];
+  }
+
+  return [super shouldUpdateFocusInContext:context];
+}
+
 - (void)didUpdateFocusInContext:(UIFocusUpdateContext *)context withAnimationCoordinator:(UIFocusAnimationCoordinator *)coordinator
 {
     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.
+      _previouslyFocusedItem = context.previouslyFocusedItem;
+      [self handleFocusGuide];
+    }
+
     if (context.nextFocusedView == self && self.isUserInteractionEnabled ) {
       [self becomeFirstResponder];
       [self enableDirectionalFocusGuides];
@@ -459,9 +532,31 @@ using namespace facebook::react;
         [destinations addObject:view];
       }
     }
-    [self addFocusDestinations:destinations];
+    [self setFocusDestinations:destinations];
     return;
 #endif
+  } else if ([commandName isEqualToString:@"requestTVFocus"]) {
+#if TARGET_OS_TV
+    if ([args count] != 0) {
+      RCTLogError(
+          @"%@ command %@ received %d arguments, expected %d.", @"View", commandName, (int)[args count], 0);
+      return;
+    }
+
+    RCTRootComponentView *rootview = [self containingRootView];
+    if (rootview == nil) return;
+
+    if (self.focusGuide != nil) {
+      rootview.reactPreferredFocusEnvironments = self.focusGuide.preferredFocusEnvironments;
+    } else {
+      rootview.reactPreferredFocusEnvironments = @[self];
+    }
+
+    [rootview setNeedsFocusUpdate];
+    [rootview updateFocusIfNeeded];
+    
+#endif
+    return;
   }
 #if RCT_DEBUG
   RCTLogError(@"%@ received command %@, which is not a supported command.", @"View", commandName);
@@ -825,6 +920,17 @@ using namespace facebook::react;
       _nextFocusRight = nil;
     }
   }
+  
+  // `autoFocus`
+  if (oldViewProps.autoFocus != newViewProps.autoFocus) {
+    _autoFocus = newViewProps.autoFocus;
+    [self handleFocusGuide];
+  }
+
+  _trapFocusUp = newViewProps.trapFocusUp;
+  _trapFocusDown = newViewProps.trapFocusDown;
+  _trapFocusLeft = newViewProps.trapFocusLeft;
+  _trapFocusRight = newViewProps.trapFocusRight;
 #endif
 
 
@@ -910,11 +1016,8 @@ using namespace facebook::react;
   if ([_propKeysManagedByAnimated_DO_NOT_USE_THIS_IS_BROKEN containsObject:@"opacity"]) {
     self.layer.opacity = (float)props.opacity;
   }
-    
-  if (self.focusGuide != nil) {
-    [self removeLayoutGuide:self.focusGuide];
-    self.focusGuide = nil;
-  }
+  
+  [self removeFocusGuide];
 
   _propKeysManagedByAnimated_DO_NOT_USE_THIS_IS_BROKEN = nil;
   _eventEmitter.reset();

package/React/Views/RCTTVView.h

@@ -42,6 +42,16 @@
 @property (nonatomic, strong) UIFocusGuide * focusGuideLeft;
 @property (nonatomic, strong) UIFocusGuide * focusGuideRight;
 
+/**
+ * Auto focus
+ */
+@property (nonatomic, assign) BOOL autoFocus;
+
+@property (nonatomic, assign) BOOL trapFocusUp;
+@property (nonatomic, assign) BOOL trapFocusDown;
+@property (nonatomic, assign) BOOL trapFocusLeft;
+@property (nonatomic, assign) BOOL trapFocusRight;
+
 - (instancetype)initWithBridge:(RCTBridge *)bridge;
 
 /**
@@ -70,7 +80,9 @@
 - (void)removeParallaxMotionEffects;
 
 
-- (void)addFocusGuide:(NSArray*)destinations;
+- (void)setFocusDestinations:(NSArray*)destinations;
+
+- (void)requestTVFocus;
 
 @property (nonatomic, strong) UIFocusGuide * focusGuide;
 

package/React/Views/RCTTVView.m

@@ -23,6 +23,9 @@
   __weak RCTBridge *_bridge;
   UITapGestureRecognizer *_selectRecognizer;
   BOOL motionEffectsAdded;
+  NSArray* focusDestinations;
+  id<UIFocusItem> previouslyFocusedItem;
+  
 }
 
 - (instancetype)initWithBridge:(RCTBridge *)bridge {
@@ -255,12 +258,39 @@ RCT_NOT_IMPLEMENTED(-(instancetype)initWithCoder : unused)
   motionEffectsAdded = NO;
 }
 
+- (BOOL)shouldUpdateFocusInContext:(UIFocusUpdateContext *)context
+{
+  // This is  the `trapFocus*` logic that prevents the focus updates if
+  // focus should be trapped and `nextFocusedItem` is not a child FocusEnv.
+  if ((_trapFocusUp && context.focusHeading == UIFocusHeadingUp)
+     || (_trapFocusDown && context.focusHeading == UIFocusHeadingDown)
+     || (_trapFocusLeft && context.focusHeading == UIFocusHeadingLeft)
+     || (_trapFocusRight && context.focusHeading == UIFocusHeadingRight)) {
+
+    // Checks if `nextFocusedItem` is a child `FocusEnvironment`.
+    // If not, it returns false thus it keeps the focus inside.
+    return [UIFocusSystem environment:self containsEnvironment:context.nextFocusedItem];
+  }
+
+  return [super shouldUpdateFocusInContext:context];
+}
+
 - (void)didUpdateFocusInContext:(UIFocusUpdateContext *)context
        withAnimationCoordinator:(UIFocusAnimationCoordinator *)coordinator
 {
   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.
+    previouslyFocusedItem = context.previouslyFocusedItem;
+    [self handleFocusGuide];
+  }
+    
   if (context.nextFocusedView == self && self.isTVSelectable ) {
     [self becomeFirstResponder];
     [self enableDirectionalFocusGuides];
@@ -432,6 +462,14 @@ RCT_NOT_IMPLEMENTED(-(instancetype)initWithCoder : unused)
   [self setPreferredFocus:hasTVPreferredFocus];
 }
 
+- (void)setAutoFocus:(BOOL)autoFocus
+{
+  if (_autoFocus != autoFocus) {
+    _autoFocus = autoFocus;
+    [self handleFocusGuide];
+  }
+}
+
 - (void)addFocusGuide:(NSArray*)destinations {
   if (self.focusGuide == nil) {
     self.focusGuide = [UIFocusGuide new];
@@ -446,4 +484,57 @@ RCT_NOT_IMPLEMENTED(-(instancetype)initWithCoder : unused)
   self.focusGuide.preferredFocusEnvironments = destinations;
 }
 
+- (void)removeFocusGuide {
+	if (self.focusGuide != nil) {
+    focusDestinations = nil;
+    previouslyFocusedItem = nil;
+
+    [self removeLayoutGuide:self.focusGuide];
+    self.focusGuide = nil;
+	}
+}
+
+/// Responsible of determining what focusGuide's next state should be based on the active properties of the component.
+- (void)handleFocusGuide
+{
+  // `destinations` should always be favored against `autoFocus` feature, if provided.
+  if (focusDestinations != nil) {
+    [self addFocusGuide:focusDestinations];
+  } else if (_autoFocus && previouslyFocusedItem != nil) {
+    // 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 addFocusGuide:@[previouslyFocusedItem, self]];
+  } else if (_autoFocus) {
+    [self addFocusGuide:@[self]];
+  } else {
+    // Then there's no need to have `focusGuide`, remove it to prevent potential bugs.
+    [self removeFocusGuide];
+  }
+}
+
+- (void)setFocusDestinations:(NSArray*)destinations
+{
+  if(destinations.count == 0) {
+    focusDestinations = nil;
+  } else {
+    focusDestinations = destinations;
+  }
+
+  [self handleFocusGuide];
+}
+
+- (void)requestTVFocus
+{
+  RCTRootView *rootview = [self rootView];
+  if (rootview == nil) return;
+
+  if (self.focusGuide != nil) {
+    rootview.reactPreferredFocusEnvironments = self.focusGuide.preferredFocusEnvironments;
+  } else {
+    rootview.reactPreferredFocusEnvironments = @[self];
+  }
+
+  [rootview setNeedsFocusUpdate];
+  [rootview updateFocusIfNeeded];
+}
 @end

package/React/Views/RCTViewManager.m

@@ -137,6 +137,11 @@ 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)
+RCT_EXPORT_VIEW_PROPERTY(trapFocusUp, BOOL)
+RCT_EXPORT_VIEW_PROPERTY(trapFocusDown, BOOL)
+RCT_EXPORT_VIEW_PROPERTY(trapFocusLeft, BOOL)
+RCT_EXPORT_VIEW_PROPERTY(trapFocusRight, BOOL)
 #endif
 
 // Accessibility related properties
@@ -451,9 +456,17 @@ RCT_EXPORT_METHOD(setDestinations : (nonnull NSNumber *)viewTag reactTags : (NSA
         [destinations addObject:destination];
       }
     }
-    [view addFocusGuide:destinations];
+    [view setFocusDestinations:destinations];
   }];  
 }
+
+RCT_EXPORT_METHOD(requestTVFocus : (nonnull NSNumber *)viewTag)
+{
+  [self.bridge.uiManager addUIBlock:^(RCTUIManager *uiManager, NSDictionary<NSNumber *, UIView *> *viewRegistry) {
+    RCTTVView *view = (RCTTVView *)viewRegistry[viewTag];
+    [view requestTVFocus];
+  }];
+}
 #endif
 
 // The events below define the properties that are not used by native directly, but required in the view config for new

package/ReactAndroid/gradle.properties

@@ -1,4 +1,4 @@
-VERSION_NAME=0.69.6-2
+VERSION_NAME=0.69.8-0
 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;
     }