react-native-tvos 0.76.1-0 → 0.76.2-0

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

@@ -63,8 +63,6 @@ const CGFloat BACKGROUND_COLOR_ZPOSITION = -1024.0f;
   BOOL _removeClippedSubviews;
   NSMutableArray<UIView *> *_reactSubviews;
   BOOL _motionEffectsAdded;
-  UITapGestureRecognizer *_selectRecognizer;
-  UILongPressGestureRecognizer * _longSelectRecognizer;
   NSSet<NSString *> *_Nullable _propKeysManagedByAnimated_DO_NOT_USE_THIS_IS_BROKEN;
   UIView *_containerView;
   BOOL _useCustomContainerView;
@@ -268,52 +266,61 @@ const CGFloat BACKGROUND_COLOR_ZPOSITION = -1024.0f;
     [[NSNotificationCenter defaultCenter] postNavigationBlurEventWithTag:@(self.tag) target:@(self.tag)];
 }
 
-- (void)sendSelectNotification:(UIGestureRecognizer *)recognizer
+- (void)sendSelectNotification
 {
-    [[NSNotificationCenter defaultCenter] postNavigationPressEventWithType:RCTTVRemoteEventSelect keyAction:RCTTVRemoteEventKeyActionUp tag:@(self.tag) target:@(self.tag)];
+  [[NSNotificationCenter defaultCenter] postNavigationPressEventWithType:RCTTVRemoteEventSelect keyAction:RCTTVRemoteEventKeyActionUp tag:@(self.tag) target:@(self.tag)];
 }
 
-- (void)sendLongSelectNotification:(UIGestureRecognizer *)recognizer
+- (void)sendLongSelectBeganNotification
 {
-    [[NSNotificationCenter defaultCenter] postNavigationPressEventWithType:RCTTVRemoteEventLongSelect keyAction:recognizer.eventKeyAction tag:@(self.tag) target:@(self.tag)];
+    [[NSNotificationCenter defaultCenter] postNavigationPressEventWithType:RCTTVRemoteEventLongSelect keyAction:RCTTVRemoteEventKeyActionDown tag:@(self.tag) target:@(self.tag)];
 }
 
-- (void)handleSelect:(UIGestureRecognizer *)r
+- (void)sendLongSelectEndedNotification
+{
+    [[NSNotificationCenter defaultCenter] postNavigationPressEventWithType:RCTTVRemoteEventLongSelect keyAction:RCTTVRemoteEventKeyActionUp tag:@(self.tag) target:@(self.tag)];
+}
+
+- (void)animatePressIn
 {
   if (_tvParallaxProperties.enabled == YES) {
-    float magnification = _tvParallaxProperties.magnification;
     float pressMagnification = _tvParallaxProperties.pressMagnification;
 
     // Duration of press animation
     float pressDuration = _tvParallaxProperties.pressDuration;
 
-    // Delay of press animation
-    float pressDelay = _tvParallaxProperties.pressDelay;
-
-    [[NSRunLoop currentRunLoop] runUntilDate:[NSDate dateWithTimeIntervalSinceNow:pressDelay]];
-
     [UIView animateWithDuration:(pressDuration/2)
                      animations:^{
       self.transform = CGAffineTransformMakeScale(pressMagnification, pressMagnification);
     }
-                     completion:^(__unused BOOL finished1){
-      [UIView animateWithDuration:(pressDuration/2)
-                       animations:^{
-        self.transform = CGAffineTransformMakeScale(magnification, magnification);
-      }
-                       completion:^(__unused BOOL finished2) {
-        [self sendSelectNotification:r];
-      }];
-    }];
+                     completion:^(__unused BOOL finished){}];
+  }
+}
 
-  } else {
-    [self sendSelectNotification:r];
+- (void) animatePressOut
+{
+  if (_tvParallaxProperties.enabled == YES) {
+    float magnification = _tvParallaxProperties.magnification;
+
+    // Duration of press animation
+    float pressDuration = _tvParallaxProperties.pressDuration;
+
+    [UIView animateWithDuration:(pressDuration/2)
+                     animations:^{
+      self.transform = CGAffineTransformMakeScale(magnification, magnification);
+    }
+                     completion:^(__unused BOOL finished){}];
   }
 }
 
-- (void)handleLongSelect:(UIGestureRecognizer *)r
+- (void)emitPressInEvent
+{
+  _eventEmitter->onPressIn();
+}
+
+- (void)emitPressOutEvent
 {
-    [self sendLongSelectNotification:r];
+  _eventEmitter->onPressOut();
 }
 
 - (void)addParallaxMotionEffects
@@ -576,6 +583,8 @@ const CGFloat BACKGROUND_COLOR_ZPOSITION = -1024.0f;
     }
 
     if (context.nextFocusedView == self && self.isUserInteractionEnabled && ![self isTVFocusGuide]) {
+      if(_eventEmitter) _eventEmitter->onFocus();
+
       [self becomeFirstResponder];
       [self enableDirectionalFocusGuides];
       [coordinator addCoordinatedAnimations:^(void){
@@ -583,6 +592,8 @@ const CGFloat BACKGROUND_COLOR_ZPOSITION = -1024.0f;
           [self sendFocusNotification:context];
       } completion:^(void){}];
     } else {
+      if (_eventEmitter) _eventEmitter->onBlur();
+
       [self disableDirectionalFocusGuides];
       [coordinator addCoordinatedAnimations:^(void){
           [self removeParallaxMotionEffects];
@@ -1029,25 +1040,9 @@ const CGFloat BACKGROUND_COLOR_ZPOSITION = -1024.0f;
   // `isTVSelectable`
   if (oldViewProps.isTVSelectable != newViewProps.isTVSelectable) {
     if (newViewProps.isTVSelectable && ![self isTVFocusGuide]) {
-      UITapGestureRecognizer *recognizer = [[UITapGestureRecognizer alloc] initWithTarget:self
-                                                                                   action:@selector(handleSelect:)];
-      recognizer.allowedPressTypes = @[ @(UIPressTypeSelect) ];
-      _selectRecognizer = recognizer;
-
-      UILongPressGestureRecognizer *longRecognizer = [[UILongPressGestureRecognizer alloc] initWithTarget:self action:@selector(handleLongSelect:)];
-      recognizer.allowedPressTypes = @[ @(UIPressTypeSelect) ];
-      [self addGestureRecognizer:longRecognizer];
-      _longSelectRecognizer = longRecognizer;
-
-      [self addGestureRecognizer:_selectRecognizer];
-      [self addGestureRecognizer:_longSelectRecognizer];
+      self.tvRemoteSelectHandler = [[RCTTVRemoteSelectHandler alloc]initWithView:self];
     } else {
-      if (_selectRecognizer) {
-        [self removeGestureRecognizer:_selectRecognizer];
-      }
-      if (_longSelectRecognizer) {
-        [self removeGestureRecognizer:_longSelectRecognizer];
-      }
+      self.tvRemoteSelectHandler = nil;
     }
   }
   // `tvParallaxProperties
@@ -1077,6 +1072,9 @@ const CGFloat BACKGROUND_COLOR_ZPOSITION = -1024.0f;
       _nextFocusUp = [rootView viewWithTag:newViewProps.nextFocusUp.value()];
       [self enableDirectionalFocusGuides];
     } else {
+      if (self.focusGuideUp != nil) {
+        [[self containingRootView] removeLayoutGuide:self.focusGuideUp];
+      }
       _nextFocusUp = nil;
     }
   }
@@ -1087,6 +1085,9 @@ const CGFloat BACKGROUND_COLOR_ZPOSITION = -1024.0f;
       _nextFocusDown = [rootView viewWithTag:newViewProps.nextFocusDown.value()];
       [self enableDirectionalFocusGuides];
     } else {
+      if (self.focusGuideDown != nil) {
+        [[self containingRootView] removeLayoutGuide:self.focusGuideDown];
+      }
       _nextFocusDown = nil;
     }
   }
@@ -1097,6 +1098,9 @@ const CGFloat BACKGROUND_COLOR_ZPOSITION = -1024.0f;
       _nextFocusLeft = [rootView viewWithTag:newViewProps.nextFocusLeft.value()];
       [self enableDirectionalFocusGuides];
     } else {
+      if (self.focusGuideLeft != nil) {
+        [[self containingRootView] removeLayoutGuide:self.focusGuideLeft];
+      }
       _nextFocusLeft = nil;
     }
   }
@@ -1107,6 +1111,9 @@ const CGFloat BACKGROUND_COLOR_ZPOSITION = -1024.0f;
       _nextFocusRight = [rootView viewWithTag:newViewProps.nextFocusRight.value()];
       [self enableDirectionalFocusGuides];
     } else {
+      if (self.focusGuideRight != nil) {
+        [[self containingRootView] removeLayoutGuide:self.focusGuideRight];
+      }
       _nextFocusRight = nil;
     }
   }

package/React/Views/RCTTVView.h

@@ -10,9 +10,10 @@
 
 #import <React/RCTView.h>
 #import <React/RCTBridge.h>
+#import <React/RCTTVRemoteSelectHandler.h>
 
 //  A RCTView with additional properties and methods for user interaction using the Apple TV focus engine.
-@interface RCTTVView : RCTView
+@interface RCTTVView : RCTView <RCTTVRemoteSelectHandlerDelegate>
 
 /**
  * TV event handlers
@@ -29,6 +30,10 @@
  */
 @property (nonatomic, assign) BOOL hasTVPreferredFocus;
 
+/**
+  * Select and longSelect event handler
+ */
+@property (nonatomic, strong) RCTTVRemoteSelectHandler *tvRemoteSelectHandler;
 /**
  * Focus direction tags
  */
@@ -52,6 +57,19 @@
 @property (nonatomic, assign) BOOL trapFocusLeft;
 @property (nonatomic, assign) BOOL trapFocusRight;
 
+
+/**
+ * Focus
+ */
+@property (nonatomic, copy) RCTBubblingEventBlock onFocus;
+@property (nonatomic, copy) RCTBubblingEventBlock onBlur;
+
+/**
+ * TV Press Handlers
+ */
+@property (nonatomic, copy) RCTDirectEventBlock onPressIn;
+@property (nonatomic, copy) RCTDirectEventBlock onPressOut;
+
 - (instancetype)initWithBridge:(RCTBridge *)bridge;
 
 /**
@@ -64,11 +82,6 @@
  */
 - (void)sendBlurNotification:(UIFocusUpdateContext *)context;
 
-/**
- * Send Select Notification to listeners
- */
-- (void)sendSelectNotification:(UIGestureRecognizer *)recognizer;
-
 /**
  * Adds Parallax Motion Effects if tvParallaxProperty is enabled
  */

package/React/Views/RCTTVView.m

@@ -22,8 +22,6 @@
 
 @implementation RCTTVView {
   __weak RCTBridge *_bridge;
-  UITapGestureRecognizer *_selectRecognizer;
-  UILongPressGestureRecognizer * _longSelectRecognizer;
   BOOL motionEffectsAdded;
   NSArray* focusDestinations;
   id<UIFocusItem> previouslyFocusedItem;
@@ -77,64 +75,47 @@ RCT_NOT_IMPLEMENTED(-(instancetype)initWithCoder : unused)
 {
   self->_isTVSelectable = isTVSelectable;
   if (isTVSelectable && ![self isTVFocusGuide]) {
-    UITapGestureRecognizer *recognizer = [[UITapGestureRecognizer alloc] initWithTarget:self
-                                                                                 action:@selector(handleSelect:)];
-    recognizer.allowedPressTypes = @[ @(UIPressTypeSelect) ];
-    _selectRecognizer = recognizer;
-
-    UILongPressGestureRecognizer *longRecognizer = [[UILongPressGestureRecognizer alloc] initWithTarget:self action:@selector(handleLongSelect:)];
-    recognizer.allowedPressTypes = @[ @(UIPressTypeSelect) ];
-    [self addGestureRecognizer:longRecognizer];
-    _longSelectRecognizer = longRecognizer;
-
-    [self addGestureRecognizer:_selectRecognizer];
-    [self addGestureRecognizer:_longSelectRecognizer];
+    self.tvRemoteSelectHandler = [[RCTTVRemoteSelectHandler alloc] initWithView:self];
   } else {
-    if (_selectRecognizer) {
-      [self removeGestureRecognizer:_selectRecognizer];
-    }
-    if (_longSelectRecognizer) {
-      [self removeGestureRecognizer:_longSelectRecognizer];
-    }
+    self.tvRemoteSelectHandler = nil;
   }
 }
 
-- (void)handleSelect:(UIGestureRecognizer *)r
+- (void)animatePressIn
 {
   if ([self.tvParallaxProperties[@"enabled"] boolValue] == YES) {
-    float magnification = [self.tvParallaxProperties[@"magnification"] floatValue];
     float pressMagnification = [self.tvParallaxProperties[@"pressMagnification"] floatValue];
-    
-    // Duration of press animation
     float pressDuration = [self.tvParallaxProperties[@"pressDuration"] floatValue];
-    
-    // Delay of press animation
-    float pressDelay = [self.tvParallaxProperties[@"pressDelay"] floatValue];
-    
-    [[NSRunLoop currentRunLoop] runUntilDate:[NSDate dateWithTimeIntervalSinceNow:pressDelay]];
-    
     [UIView animateWithDuration:(pressDuration/2)
                      animations:^{
       self.transform = CGAffineTransformMakeScale(pressMagnification, pressMagnification);
     }
-                     completion:^(__unused BOOL finished1){
-      [UIView animateWithDuration:(pressDuration/2)
-                       animations:^{
-        self.transform = CGAffineTransformMakeScale(magnification, magnification);
-      }
-                       completion:^(__unused BOOL finished2) {
-        [self sendSelectNotification:r];
-      }];
-    }];
-    
-  } else {
-    [self sendSelectNotification:r];
+                     completion:^(__unused BOOL finished){}];
   }
 }
 
-- (void)handleLongSelect:(UIGestureRecognizer *)r
+- (void) animatePressOut
+{
+  if ([self.tvParallaxProperties[@"enabled"] boolValue] == YES) {
+    float magnification = [self.tvParallaxProperties[@"magnification"] floatValue];
+    float pressDuration = [self.tvParallaxProperties[@"pressDuration"] floatValue];
+
+    [UIView animateWithDuration:(pressDuration/2)
+                     animations:^{
+      self.transform = CGAffineTransformMakeScale(magnification, magnification);
+    }
+                     completion:^(__unused BOOL finished){}];
+  }
+}
+
+- (void)emitPressInEvent
+{
+  if (self.onPressIn) self.onPressIn(nil);
+}
+
+- (void)emitPressOutEvent
 {
-    [self sendLongSelectNotification:r];
+  if (self.onPressOut) self.onPressOut(nil);
 }
 
 - (BOOL)isTVFocusGuide
@@ -323,6 +304,7 @@ RCT_NOT_IMPLEMENTED(-(instancetype)initWithCoder : unused)
   }
     
   if (context.nextFocusedView == self && ![self isTVFocusGuide] && self.isTVSelectable ) {
+    if (self.onFocus) self.onFocus(nil);
     [self becomeFirstResponder];
     [self enableDirectionalFocusGuides];
     [coordinator addCoordinatedAnimations:^(void){
@@ -330,6 +312,7 @@ RCT_NOT_IMPLEMENTED(-(instancetype)initWithCoder : unused)
       [self sendFocusNotification:context];
     } completion:^(void){}];
   } else {
+    if (self.onBlur) self.onBlur(nil);
     [self disableDirectionalFocusGuides];
     [coordinator addCoordinatedAnimations:^(void){
       [self sendBlurNotification:context];
@@ -441,14 +424,19 @@ RCT_NOT_IMPLEMENTED(-(instancetype)initWithCoder : unused)
     [[NSNotificationCenter defaultCenter] postNavigationBlurEventWithTag:self.reactTag target:self.reactTag];
 }
 
-- (void)sendSelectNotification:(UIGestureRecognizer *)recognizer
+- (void)sendSelectNotification
 {
     [[NSNotificationCenter defaultCenter] postNavigationPressEventWithType:RCTTVRemoteEventSelect keyAction:RCTTVRemoteEventKeyActionUp tag:self.reactTag target:self.reactTag];
 }
 
-- (void)sendLongSelectNotification:(UIGestureRecognizer *)recognizer
+- (void)sendLongSelectBeganNotification
 {
-    [[NSNotificationCenter defaultCenter] postNavigationPressEventWithType:RCTTVRemoteEventLongSelect keyAction:recognizer.eventKeyAction tag:self.reactTag target:self.reactTag];
+    [[NSNotificationCenter defaultCenter] postNavigationPressEventWithType:RCTTVRemoteEventLongSelect keyAction:RCTTVRemoteEventKeyActionDown tag:self.reactTag target:self.reactTag];
+}
+
+- (void)sendLongSelectEndedNotification
+{
+    [[NSNotificationCenter defaultCenter] postNavigationPressEventWithType:RCTTVRemoteEventLongSelect keyAction:RCTTVRemoteEventKeyActionUp tag:self.reactTag target:self.reactTag];
 }
 
 - (RCTTVView *)getViewById:(NSNumber *)viewId {
@@ -458,23 +446,43 @@ RCT_NOT_IMPLEMENTED(-(instancetype)initWithCoder : unused)
 }
 
 - (void)setNextFocusUp:(NSNumber *)nextFocusUp {
-  self->_nextFocusUp = [self getViewById: nextFocusUp];
-  [self enableDirectionalFocusGuides];
+  if (self.focusGuideUp != nil && nextFocusUp == nil) {
+    [[self rootView] removeLayoutGuide:self.focusGuideUp];
+    self.focusGuideUp = nil;
+  } else {
+    self->_nextFocusUp = [self getViewById: nextFocusUp];
+    [self enableDirectionalFocusGuides];
+  }
 }
 
 - (void)setNextFocusDown:(NSNumber *)nextFocusDown {
-  self->_nextFocusDown = [self getViewById: nextFocusDown];
-  [self enableDirectionalFocusGuides];
+  if (self.focusGuideDown != nil && nextFocusDown == nil) {
+    [[self rootView] removeLayoutGuide:self.focusGuideDown];
+    self.focusGuideDown = nil;
+  } else {
+    self->_nextFocusDown = [self getViewById: nextFocusDown];
+    [self enableDirectionalFocusGuides];
+  }
 }
 
 - (void)setNextFocusLeft:(NSNumber *)nextFocusLeft {
-  self->_nextFocusLeft = [self getViewById: nextFocusLeft];
-  [self enableDirectionalFocusGuides];
+  if (self.focusGuideLeft != nil && nextFocusLeft == nil) {
+    [[self rootView] removeLayoutGuide:self.focusGuideLeft];
+    self.focusGuideLeft = nil;
+  } else {
+    self->_nextFocusLeft = [self getViewById: nextFocusLeft];
+    [self enableDirectionalFocusGuides];
+  }
 }
 
 - (void)setNextFocusRight:(NSNumber *)nextFocusRight {
-  self->_nextFocusRight = [self getViewById: nextFocusRight];
-  [self enableDirectionalFocusGuides];
+  if (self.focusGuideRight != nil && nextFocusRight == nil) {
+    [[self rootView] removeLayoutGuide:self.focusGuideRight];
+    self.focusGuideRight = nil;
+  } else {
+    self->_nextFocusRight = [self getViewById: nextFocusRight];
+    [self enableDirectionalFocusGuides];
+  }
 }
 
 - (void)setPreferredFocus:(BOOL)hasTVPreferredFocus

package/React/Views/RCTViewManager.m

@@ -197,6 +197,10 @@ RCT_EXPORT_VIEW_PROPERTY(trapFocusUp, BOOL)
 RCT_EXPORT_VIEW_PROPERTY(trapFocusDown, BOOL)
 RCT_EXPORT_VIEW_PROPERTY(trapFocusLeft, BOOL)
 RCT_EXPORT_VIEW_PROPERTY(trapFocusRight, BOOL)
+RCT_EXPORT_VIEW_PROPERTY(onFocus, RCTBubblingEventBlock)
+RCT_EXPORT_VIEW_PROPERTY(onBlur, RCTBubblingEventBlock)
+RCT_EXPORT_VIEW_PROPERTY(onPressIn, RCTDirectEventBlock)
+RCT_EXPORT_VIEW_PROPERTY(onPressOut, RCTDirectEventBlock)
 #endif
 
 // Accessibility related properties

package/React/Views/ScrollView/RCTScrollView.m

@@ -23,6 +23,7 @@
 #if TARGET_OS_TV
 #import "RCTTVRemoteHandler.h"
 #import "RCTTVNavigationEventNotification.h"
+#import "React/RCTI18nUtil.h"
 #endif
 
 #if !TARGET_OS_TV
@@ -1086,21 +1087,24 @@ RCT_SCROLL_EVENT_HANDLER(scrollViewDidScrollToTop, onScrollToTop)
 
 - (BOOL)shouldUpdateFocusInContext:(UIFocusUpdateContext *)context
 {
-    // Keep focus inside the scroll view till the end of the content
+    // Determine if the layout is Right-to-Left
+    BOOL isRTL = [[RCTI18nUtil sharedInstance] isRTL];
+    // Adjust for horizontal scrolling with RTL support
     if ([self isHorizontal:self.scrollView]) {
-        if ((context.focusHeading == UIFocusHeadingLeft && self.scrollView.contentOffset.x > 0)
-            || (context.focusHeading == UIFocusHeadingRight && self.scrollView.contentOffset.x < self.scrollView.contentSize.width - self.scrollView.visibleSize.width)
-        ) {
+        BOOL isNavigatingToEnd = (isRTL ? context.focusHeading == UIFocusHeadingLeft : context.focusHeading == UIFocusHeadingRight);
+        BOOL isNavigatingToStart = (isRTL ? context.focusHeading == UIFocusHeadingRight : context.focusHeading == UIFocusHeadingLeft);
+
+        if ((isNavigatingToEnd && self.scrollView.contentOffset.x < self.scrollView.contentSize.width - self.scrollView.visibleSize.width) ||
+            (isNavigatingToStart && self.scrollView.contentOffset.x > 0)) {
             return [UIFocusSystem environment:self containsEnvironment:context.nextFocusedItem];
         }
     } else {
-        if ((context.focusHeading == UIFocusHeadingUp && self.scrollView.contentOffset.y > 0)
-            || (context.focusHeading == UIFocusHeadingDown && self.scrollView.contentOffset.y < self.scrollView.contentSize.height - self.scrollView.visibleSize.height)
-        ) {
+        // Handle vertical scrolling as before
+        if ((context.focusHeading == UIFocusHeadingUp && self.scrollView.contentOffset.y > 0) ||
+            (context.focusHeading == UIFocusHeadingDown && self.scrollView.contentOffset.y < self.scrollView.contentSize.height - self.scrollView.visibleSize.height)) {
             return [UIFocusSystem environment:self containsEnvironment:context.nextFocusedItem];
         }
     }
-
     return [super shouldUpdateFocusInContext:context];
 }
 

package/ReactAndroid/api/ReactAndroid.api

@@ -3306,7 +3306,6 @@ public final class com/facebook/react/modules/core/TimingModule : com/facebook/f
 	public fun createTimer (DDDZ)V
 	public fun deleteTimer (D)V
 	public fun emitTimeDriftWarning (Ljava/lang/String;)V
-	public fun initialize ()V
 	public fun invalidate ()V
 	public fun setSendIdleEvents (Z)V
 }

package/ReactAndroid/cmake-utils/ReactNative-application.cmake

@@ -36,7 +36,7 @@ if(CMAKE_HOST_WIN32)
 endif()
 
 file(GLOB input_SRC CONFIGURE_DEPENDS
-        *.cpp
+        ${REACT_ANDROID_DIR}/cmake-utils/default-app-setup/*.cpp
         ${BUILD_DIR}/generated/autolinking/src/main/jni/*.cpp)
 
 add_library(${CMAKE_PROJECT_NAME} SHARED ${input_SRC})

package/ReactAndroid/gradle.properties

@@ -1,4 +1,4 @@
-VERSION_NAME=0.76.1-0
+VERSION_NAME=0.76.2-0
 react.internal.publishingGroup=io.github.react-native-tvos
 
 android.useAndroidX=true

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

@@ -65,6 +65,7 @@ public open class JavaTimerManager(
 
   init {
     reactApplicationContext.addLifecycleEventListener(this)
+    HeadlessJsTaskContext.getInstance(reactApplicationContext).addTaskEventListener(this)
   }
 
   override fun onHostPause() {
@@ -103,6 +104,7 @@ public open class JavaTimerManager(
   }
 
   public open fun onInstanceDestroy() {
+    HeadlessJsTaskContext.getInstance(reactApplicationContext).removeTaskEventListener(this)
     reactApplicationContext.removeLifecycleEventListener(this)
     clearFrameCallback()
     clearChoreographerIdleCallback()

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

@@ -12,7 +12,6 @@ import com.facebook.react.bridge.ReactApplicationContext
 import com.facebook.react.bridge.WritableArray
 import com.facebook.react.common.annotations.VisibleForTesting
 import com.facebook.react.devsupport.interfaces.DevSupportManager
-import com.facebook.react.jstasks.HeadlessJsTaskContext
 import com.facebook.react.module.annotations.ReactModule
 
 /** Native module for JS timer execution. Timers fire on frame boundaries. */
@@ -24,11 +23,6 @@ public class TimingModule(
   private val javaTimerManager: JavaTimerManager =
       JavaTimerManager(reactContext, this, ReactChoreographer.getInstance(), devSupportManager)
 
-  override fun initialize() {
-    HeadlessJsTaskContext.getInstance(getReactApplicationContext())
-        .addTaskEventListener(javaTimerManager)
-  }
-
   override fun createTimer(
       callbackIDDouble: Double,
       durationDouble: Double,
@@ -68,8 +62,6 @@ public class TimingModule(
   }
 
   override fun invalidate() {
-    val headlessJsTaskContext = HeadlessJsTaskContext.getInstance(getReactApplicationContext())
-    headlessJsTaskContext.removeTaskEventListener(javaTimerManager)
     javaTimerManager.onInstanceDestroy()
   }
 

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", 76,
-      "patch", 1,
+      "patch", 2,
       "prerelease", "0");
 }

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

@@ -736,6 +736,16 @@ public abstract class BaseViewManager<T extends View, C extends LayoutShadowNode
                 MapBuilder.of(
                     "phasedRegistrationNames",
                     MapBuilder.of("bubbled", "onClick", "captured", "onClickCapture")))
+            .put(
+              "topFocus",
+              MapBuilder.of(
+                "phasedRegistrationNames",
+                MapBuilder.of("bubbled", "onFocus", "captured", "onFocusCapture")))
+            .put(
+              "topBlur",
+              MapBuilder.of(
+                "phasedRegistrationNames",
+                MapBuilder.of("bubbled", "onBlur", "captured", "onBlurCapture")))
             .build());
     return eventTypeConstants;
   }
@@ -751,6 +761,12 @@ public abstract class BaseViewManager<T extends View, C extends LayoutShadowNode
             .put(
                 "topAccessibilityAction",
                 MapBuilder.of("registrationName", "onAccessibilityAction"))
+          .put(
+            "topPressIn",
+            MapBuilder.of("registrationName", "onPressIn"))
+          .put(
+            "topPressOut",
+            MapBuilder.of("registrationName", "onPressOut"))
             .build());
     return eventTypeConstants;
   }

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

@@ -568,6 +568,26 @@ public class ReactAccessibilityDelegate extends ExploreByTouchHelper {
     if (action == AccessibilityNodeInfoCompat.ACTION_EXPAND) {
       host.setTag(R.id.accessibility_state_expanded, true);
     }
+    if (action == AccessibilityNodeInfoCompat.ACTION_CLICK) {
+      final WritableMap payload = Arguments.createMap();
+      final int reactTag = host.getId();
+      payload.putString("eventType", "select");
+      payload.putInt("eventKeyAction", 1);
+      payload.putInt("tag", reactTag);
+      payload.putInt("target", reactTag);
+      ReactContext reactContext = (ReactContext) host.getContext();
+      reactContext.emitDeviceEvent("onHWKeyEvent", payload);
+    }
+    if (action == AccessibilityNodeInfoCompat.ACTION_LONG_CLICK) {
+      final WritableMap payload = Arguments.createMap();
+      final int reactTag = host.getId();
+      payload.putString("eventType", "longSelect");
+      payload.putInt("eventKeyAction", 1);
+      payload.putInt("tag", reactTag);
+      payload.putInt("target", reactTag);
+      ReactContext reactContext = (ReactContext) host.getContext();
+      reactContext.emitDeviceEvent("onHWKeyEvent", payload);
+    }
     if (mAccessibilityActionsMap.containsKey(action)) {
       final WritableMap event = Arguments.createMap();
       event.putString("actionName", mAccessibilityActionsMap.get(action));

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

@@ -0,0 +1,16 @@
+package com.facebook.react.uimanager.events
+
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.WritableMap
+
+public class BlurEvent(surfaceId: Int, viewId: Int) :
+  Event<BlurEvent>(surfaceId, viewId) {
+
+  override fun getEventName(): String = EVENT_NAME
+
+  override fun getEventData(): WritableMap = Arguments.createMap()
+
+  private companion object {
+    private const val EVENT_NAME: String = "topBlur"
+  }
+}

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

@@ -0,0 +1,16 @@
+package com.facebook.react.uimanager.events
+
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.WritableMap
+
+public class FocusEvent(surfaceId: Int, viewId: Int) :
+  Event<FocusEvent>(surfaceId, viewId) {
+
+  override fun getEventName(): String = EVENT_NAME
+
+  override fun getEventData(): WritableMap = Arguments.createMap()
+
+  private companion object {
+    private const val EVENT_NAME: String = "topFocus"
+  }
+}

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

@@ -0,0 +1,16 @@
+package com.facebook.react.uimanager.events
+
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.WritableMap
+
+public class PressInEvent(surfaceId: Int, viewId: Int) :
+  Event<PressInEvent>(surfaceId, viewId) {
+
+  override fun getEventName(): String = EVENT_NAME
+
+  override fun getEventData(): WritableMap = Arguments.createMap()
+
+  private companion object {
+    private const val EVENT_NAME: String = "topPressIn"
+  }
+}