react-native-tvos 0.76.1-0 → 0.76.1-1

package/Libraries/Pressability/Pressability.js

@@ -157,7 +157,8 @@ export type EventHandlers = $ReadOnly<{|
   onResponderTerminate: (event: PressEvent) => void,
   onResponderTerminationRequest: () => boolean,
   onStartShouldSetResponder: () => boolean,
-  onTVEvent: (event: any) => void,
+  onPressIn: (event: any) => void,
+  onPressOut: (event: any) => void,
 |}>;
 
 type TouchState =
@@ -397,6 +398,7 @@ export default class Pressability {
   |}>;
   _touchActivateTime: ?number;
   _touchState: TouchState = 'NOT_RESPONDER';
+  _longPressSent: boolean = false;
 
   constructor(config: PressabilityConfig) {
     this.configure(config);
@@ -436,35 +438,50 @@ export default class Pressability {
   }
 
   _createEventHandlers(): EventHandlers {
-    const tvEventHandlers = {
-      onTVEvent: (evt: any): void => {
-        if (this._config.disabled !== false) {
-          // $FlowFixMe[prop-missing]
-          if (evt?.eventType === 'focus') {
-            const {onFocus} = this._config;
-            onFocus && onFocus(evt);
-            // $FlowFixMe[prop-missing]
-          } else if (evt.eventType === 'blur') {
-            const {onBlur} = this._config;
-            onBlur && onBlur(evt);
-          } else if (evt.eventType === 'select') {
-            const {onPress, onPressIn, onPressOut} = this._config;
-            // $FlowFixMe[incompatible-exact]
-            onPressIn && onPressIn(evt);
-            onPress && onPress(evt);
-            setTimeout(() => {
-              onPressOut && onPressOut(evt);
-            }, this._config.minPressDuration ?? DEFAULT_MIN_PRESS_DURATION);
-          } else if (evt.eventType === 'longSelect') {
-            const {onLongPress, onPressIn, onPressOut} = this._config;
-            onLongPress && onLongPress(evt);
-            evt?.eventKeyAction === 0
-              ? onPressIn && onPressIn(evt)
-              : onPressOut && onPressOut(evt);
+    const tvPressEventHandlers = {
+      onPressIn: (evt: any): void => {
+        if (this._config.disabled === false) {
+          return;
+        }
+
+        this._longPressSent = false;
+
+        const {onPressIn, onLongPress} = this._config;
+        onPressIn && onPressIn(evt);
+
+        const delayPressIn = normalizeDelay(this._config.delayPressIn);
+        const delayLongPress = normalizeDelay(
+          this._config.delayLongPress,
+          10,
+          DEFAULT_LONG_PRESS_DELAY_MS - delayPressIn,
+        );
+        this._longPressDelayTimeout = setTimeout(() => {
+          onLongPress && onLongPress(evt);
+          this._longPressSent = true;
+        }, delayLongPress + delayPressIn);
+      },
+      onPressOut: (evt: any): void => {
+        if (this._config.disabled === false) {
+          return;
+        }
+        this._cancelLongPressDelayTimeout();
+        const {onPress, onLongPress, onPressOut, android_disableSound} =
+          this._config;
+        onPressOut && onPressOut(evt);
+
+        if (onPress != null) {
+          const isPressCanceledByLongPress =
+            onLongPress != null && this._longPressSent;
+          if (!isPressCanceledByLongPress) {
+            if (Platform.OS === 'android' && android_disableSound !== true) {
+              SoundManager.playTouchSound();
+            }
+            onPress(evt);
           }
         }
       },
     };
+
     const focusEventHandlers = {
       onBlur: (event: BlurEvent): void => {
         const {onBlur} = this._config;
@@ -645,7 +662,7 @@ export default class Pressability {
         };
       }
       return {
-        ...tvEventHandlers,
+        ...tvPressEventHandlers,
         ...focusEventHandlers,
         ...responderEventHandlers,
         ...hoverPointerEvents,
@@ -698,7 +715,7 @@ export default class Pressability {
               },
             };
       return {
-        ...tvEventHandlers,
+        ...tvPressEventHandlers,
         ...focusEventHandlers,
         ...responderEventHandlers,
         ...mouseEventHandlers,

package/Libraries/Types/CoreEventTypes.d.ts

@@ -246,6 +246,15 @@ export interface GestureResponderEvent
 
 export interface MouseEvent extends NativeSyntheticEvent<NativeMouseEvent> {}
 
+export interface NativeFocusEvent {}
+export interface FocusEvent extends NativeSyntheticEvent<NativeFocusEvent> {}
+
+export interface NativeBlurEvent {}
+export interface BlurEvent extends NativeSyntheticEvent<NativeBlurEvent> {}
+
+export interface NativePressEvent {}
+export interface PressEvent extends NativeSyntheticEvent<NativePressEvent> {}
+
 export interface TargetedEvent {
   target: number;
 }
@@ -265,6 +274,18 @@ export interface PointerEvents {
   onPointerUpCapture?: ((event: PointerEvent) => void) | undefined;
 }
 
+export interface PressEvents {
+  onPressIn?: ((event: PressEvent) => void) | undefined;
+  onPressOut?: ((event: PressEvent) => void) | undefined;
+}
+
+export interface FocusEvents {
+  onFocus?: ((event: FocusEvent) => void) | undefined;
+  onFocusCapture?: ((event: FocusEvent) => void) | undefined;
+  onBlur?: ((event: BlurEvent) => void) | undefined;
+  onBlurCapture?: ((event: BlurEvent) => void) | undefined;
+}
+
 export interface TVRemoteEvent {
   tag?: number | undefined;
   target?: number | undefined;

package/Libraries/Types/CoreEventTypes.js

@@ -282,6 +282,12 @@ export type FocusEvent = SyntheticEvent<
   |}>,
 >;
 
+export type RemotePressEvent = SyntheticEvent<
+  $ReadOnly<{|
+    target: number,
+  |}>,
+>;
+
 export type MouseEvent = SyntheticEvent<
   $ReadOnly<{|
     clientX: number,

package/React/Base/RCTVersion.m

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

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

@@ -63,8 +63,7 @@ const CGFloat BACKGROUND_COLOR_ZPOSITION = -1024.0f;
   BOOL _removeClippedSubviews;
   NSMutableArray<UIView *> *_reactSubviews;
   BOOL _motionEffectsAdded;
-  UITapGestureRecognizer *_selectRecognizer;
-  UILongPressGestureRecognizer * _longSelectRecognizer;
+  UILongPressGestureRecognizer * _pressRecognizer;
   NSSet<NSString *> *_Nullable _propKeysManagedByAnimated_DO_NOT_USE_THIS_IS_BROKEN;
   UIView *_containerView;
   BOOL _useCustomContainerView;
@@ -278,7 +277,7 @@ const CGFloat BACKGROUND_COLOR_ZPOSITION = -1024.0f;
     [[NSNotificationCenter defaultCenter] postNavigationPressEventWithType:RCTTVRemoteEventLongSelect keyAction:recognizer.eventKeyAction tag:@(self.tag) target:@(self.tag)];
 }
 
-- (void)handleSelect:(UIGestureRecognizer *)r
+- (void)animatePress
 {
   if (_tvParallaxProperties.enabled == YES) {
     float magnification = _tvParallaxProperties.magnification;
@@ -302,18 +301,26 @@ const CGFloat BACKGROUND_COLOR_ZPOSITION = -1024.0f;
         self.transform = CGAffineTransformMakeScale(magnification, magnification);
       }
                        completion:^(__unused BOOL finished2) {
-        [self sendSelectNotification:r];
       }];
     }];
 
-  } else {
-    [self sendSelectNotification:r];
   }
 }
 
-- (void)handleLongSelect:(UIGestureRecognizer *)r
+- (void)handlePress:(UIGestureRecognizer *)r
 {
-    [self sendLongSelectNotification:r];
+  switch (r.state) {
+      case UIGestureRecognizerStateBegan:
+      _eventEmitter->onPressIn();
+          break;
+      case UIGestureRecognizerStateEnded:
+      case UIGestureRecognizerStateCancelled:
+      [self animatePress];
+      _eventEmitter->onPressOut();
+          break;
+      default:
+          break;
+  }
 }
 
 - (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,24 +1040,15 @@ 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];
+      UILongPressGestureRecognizer *pressRecognizer = [[UILongPressGestureRecognizer alloc] initWithTarget:self action:@selector(handlePress:)];
+      pressRecognizer.allowedPressTypes = @[ @(UIPressTypeSelect) ];
+      pressRecognizer.minimumPressDuration = 0;
+      
+      [self addGestureRecognizer:pressRecognizer];
+      _pressRecognizer = pressRecognizer;
     } else {
-      if (_selectRecognizer) {
-        [self removeGestureRecognizer:_selectRecognizer];
-      }
-      if (_longSelectRecognizer) {
-        [self removeGestureRecognizer:_longSelectRecognizer];
+      if (_pressRecognizer) {
+        [self removeGestureRecognizer:_pressRecognizer];
       }
     }
   }
@@ -1077,6 +1079,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 +1092,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 +1105,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 +1118,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

@@ -52,6 +52,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;
 
 /**

package/React/Views/RCTTVView.m

@@ -22,8 +22,7 @@
 
 @implementation RCTTVView {
   __weak RCTBridge *_bridge;
-  UITapGestureRecognizer *_selectRecognizer;
-  UILongPressGestureRecognizer * _longSelectRecognizer;
+  UILongPressGestureRecognizer * _pressRecognizer;
   BOOL motionEffectsAdded;
   NSArray* focusDestinations;
   id<UIFocusItem> previouslyFocusedItem;
@@ -77,29 +76,21 @@ 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];
+    UILongPressGestureRecognizer *pressRecognizer = [[UILongPressGestureRecognizer alloc] initWithTarget:self action:@selector(handlePress:)];
+    pressRecognizer.allowedPressTypes = @[ @(UIPressTypeSelect) ];
+    pressRecognizer.minimumPressDuration = 0;
+
+    _pressRecognizer = pressRecognizer;
+
+    [self addGestureRecognizer:_pressRecognizer];
   } else {
-    if (_selectRecognizer) {
-      [self removeGestureRecognizer:_selectRecognizer];
-    }
-    if (_longSelectRecognizer) {
-      [self removeGestureRecognizer:_longSelectRecognizer];
+    if (_pressRecognizer) {
+      [self removeGestureRecognizer:_pressRecognizer];
     }
   }
 }
 
-- (void)handleSelect:(UIGestureRecognizer *)r
+- (void)animatePress
 {
   if ([self.tvParallaxProperties[@"enabled"] boolValue] == YES) {
     float magnification = [self.tvParallaxProperties[@"magnification"] floatValue];
@@ -123,18 +114,25 @@ RCT_NOT_IMPLEMENTED(-(instancetype)initWithCoder : unused)
         self.transform = CGAffineTransformMakeScale(magnification, magnification);
       }
                        completion:^(__unused BOOL finished2) {
-        [self sendSelectNotification:r];
       }];
     }];
-    
-  } else {
-    [self sendSelectNotification:r];
   }
 }
 
-- (void)handleLongSelect:(UIGestureRecognizer *)r
+- (void)handlePress:(UIGestureRecognizer *)r
 {
-    [self sendLongSelectNotification:r];
+  switch (r.state) {
+      case UIGestureRecognizerStateBegan:
+      if (self.onPressIn) self.onPressIn(nil);
+          break;
+      case UIGestureRecognizerStateEnded:
+      case UIGestureRecognizerStateCancelled:
+      [self animatePress];
+      if (self.onPressOut) self.onPressOut(nil);
+          break;
+      default:
+          break;
+  }
 }
 
 - (BOOL)isTVFocusGuide
@@ -323,6 +321,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 +329,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];
@@ -458,23 +458,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) {
+    [[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) {
+    [[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/ReactAndroid/gradle.properties

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

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

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

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"
+  }
+}

package/ReactAndroid/src/main/java/com/facebook/react/uimanager/events/PressOutEvent.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 PressOutEvent(surfaceId: Int, viewId: Int) :
+  Event<PressOutEvent>(surfaceId, viewId) {
+
+  override fun getEventName(): String = EVENT_NAME
+
+  override fun getEventData(): WritableMap = Arguments.createMap()
+
+  private companion object {
+    private const val EVENT_NAME: String = "topPressOut"
+  }
+}