react-native-tvos 0.68.2-6 → 0.69.5-0

package/React/Views/RCTBorderDrawing.m

@@ -172,13 +172,15 @@ static CGPathRef RCTPathCreateOuterOutline(BOOL drawToEdge, CGRect rect, RCTCorn
   return RCTPathCreateWithRoundedRect(rect, RCTGetCornerInsets(cornerRadii, UIEdgeInsetsZero), NULL);
 }
 
-static CGContextRef
-RCTUIGraphicsBeginImageContext(CGSize size, CGColorRef backgroundColor, BOOL hasCornerRadii, BOOL drawToEdge)
+static UIGraphicsImageRenderer *
+RCTUIGraphicsImageRenderer(CGSize size, CGColorRef backgroundColor, BOOL hasCornerRadii, BOOL drawToEdge)
 {
   const CGFloat alpha = CGColorGetAlpha(backgroundColor);
   const BOOL opaque = (drawToEdge || !hasCornerRadii) && alpha == 1.0;
-  UIGraphicsBeginImageContextWithOptions(size, opaque, 0.0);
-  return UIGraphicsGetCurrentContext();
+  UIGraphicsImageRendererFormat *const rendererFormat = [UIGraphicsImageRendererFormat defaultFormat];
+  rendererFormat.opaque = opaque;
+  UIGraphicsImageRenderer *const renderer = [[UIGraphicsImageRenderer alloc] initWithSize:size format:rendererFormat];
+  return renderer;
 }
 
 static UIImage *RCTGetSolidBorderImage(
@@ -229,164 +231,166 @@ static UIImage *RCTGetSolidBorderImage(
     edgeInsets.top + 1 + edgeInsets.bottom
   } : viewSize;
 
-  CGContextRef ctx = RCTUIGraphicsBeginImageContext(size, backgroundColor, hasCornerRadii, drawToEdge);
-  const CGRect rect = {.size = size};
-  CGPathRef path = RCTPathCreateOuterOutline(drawToEdge, rect, cornerRadii);
-
-  if (backgroundColor) {
-    CGContextSetFillColorWithColor(ctx, backgroundColor);
-    CGContextAddPath(ctx, path);
-    CGContextFillPath(ctx);
-  }
-
-  CGContextAddPath(ctx, path);
-  CGPathRelease(path);
-
-  CGPathRef insetPath = RCTPathCreateWithRoundedRect(UIEdgeInsetsInsetRect(rect, borderInsets), cornerInsets, NULL);
-
-  CGContextAddPath(ctx, insetPath);
-  CGContextEOClip(ctx);
-
-  BOOL hasEqualColors = RCTBorderColorsAreEqual(borderColors);
-  if ((drawToEdge || !hasCornerRadii) && hasEqualColors) {
-    CGContextSetFillColorWithColor(ctx, borderColors.left);
-    CGContextAddRect(ctx, rect);
-    CGContextAddPath(ctx, insetPath);
-    CGContextEOFillPath(ctx);
-
-  } else {
-    CGPoint topLeft = (CGPoint){borderInsets.left, borderInsets.top};
-    if (cornerInsets.topLeft.width > 0 && cornerInsets.topLeft.height > 0) {
-      CGPoint points[2];
-      RCTEllipseGetIntersectionsWithLine(
-          (CGRect){topLeft, {2 * cornerInsets.topLeft.width, 2 * cornerInsets.topLeft.height}},
-          CGPointZero,
-          topLeft,
-          points);
-      if (!isnan(points[1].x) && !isnan(points[1].y)) {
-        topLeft = points[1];
-      }
+  UIGraphicsImageRenderer *const imageRenderer =
+      RCTUIGraphicsImageRenderer(size, backgroundColor, hasCornerRadii, drawToEdge);
+  UIImage *image = [imageRenderer imageWithActions:^(UIGraphicsImageRendererContext *_Nonnull rendererContext) {
+    const CGContextRef context = rendererContext.CGContext;
+    const CGRect rect = {.size = size};
+    CGPathRef path = RCTPathCreateOuterOutline(drawToEdge, rect, cornerRadii);
+
+    if (backgroundColor) {
+      CGContextSetFillColorWithColor(context, backgroundColor);
+      CGContextAddPath(context, path);
+      CGContextFillPath(context);
     }
 
-    CGPoint bottomLeft = (CGPoint){borderInsets.left, size.height - borderInsets.bottom};
-    if (cornerInsets.bottomLeft.width > 0 && cornerInsets.bottomLeft.height > 0) {
-      CGPoint points[2];
-      RCTEllipseGetIntersectionsWithLine(
-          (CGRect){
-              {bottomLeft.x, bottomLeft.y - 2 * cornerInsets.bottomLeft.height},
-              {2 * cornerInsets.bottomLeft.width, 2 * cornerInsets.bottomLeft.height}},
-          (CGPoint){0, size.height},
-          bottomLeft,
-          points);
-      if (!isnan(points[1].x) && !isnan(points[1].y)) {
-        bottomLeft = points[1];
+    CGContextAddPath(context, path);
+    CGPathRelease(path);
+
+    CGPathRef insetPath = RCTPathCreateWithRoundedRect(UIEdgeInsetsInsetRect(rect, borderInsets), cornerInsets, NULL);
+
+    CGContextAddPath(context, insetPath);
+    CGContextEOClip(context);
+
+    BOOL hasEqualColors = RCTBorderColorsAreEqual(borderColors);
+    if ((drawToEdge || !hasCornerRadii) && hasEqualColors) {
+      CGContextSetFillColorWithColor(context, borderColors.left);
+      CGContextAddRect(context, rect);
+      CGContextAddPath(context, insetPath);
+      CGContextEOFillPath(context);
+
+    } else {
+      CGPoint topLeft = (CGPoint){borderInsets.left, borderInsets.top};
+      if (cornerInsets.topLeft.width > 0 && cornerInsets.topLeft.height > 0) {
+        CGPoint points[2];
+        RCTEllipseGetIntersectionsWithLine(
+            (CGRect){topLeft, {2 * cornerInsets.topLeft.width, 2 * cornerInsets.topLeft.height}},
+            CGPointZero,
+            topLeft,
+            points);
+        if (!isnan(points[1].x) && !isnan(points[1].y)) {
+          topLeft = points[1];
+        }
       }
-    }
 
-    CGPoint topRight = (CGPoint){size.width - borderInsets.right, borderInsets.top};
-    if (cornerInsets.topRight.width > 0 && cornerInsets.topRight.height > 0) {
-      CGPoint points[2];
-      RCTEllipseGetIntersectionsWithLine(
-          (CGRect){
-              {topRight.x - 2 * cornerInsets.topRight.width, topRight.y},
-              {2 * cornerInsets.topRight.width, 2 * cornerInsets.topRight.height}},
-          (CGPoint){size.width, 0},
-          topRight,
-          points);
-      if (!isnan(points[0].x) && !isnan(points[0].y)) {
-        topRight = points[0];
+      CGPoint bottomLeft = (CGPoint){borderInsets.left, size.height - borderInsets.bottom};
+      if (cornerInsets.bottomLeft.width > 0 && cornerInsets.bottomLeft.height > 0) {
+        CGPoint points[2];
+        RCTEllipseGetIntersectionsWithLine(
+            (CGRect){
+                {bottomLeft.x, bottomLeft.y - 2 * cornerInsets.bottomLeft.height},
+                {2 * cornerInsets.bottomLeft.width, 2 * cornerInsets.bottomLeft.height}},
+            (CGPoint){0, size.height},
+            bottomLeft,
+            points);
+        if (!isnan(points[1].x) && !isnan(points[1].y)) {
+          bottomLeft = points[1];
+        }
       }
-    }
 
-    CGPoint bottomRight = (CGPoint){size.width - borderInsets.right, size.height - borderInsets.bottom};
-    if (cornerInsets.bottomRight.width > 0 && cornerInsets.bottomRight.height > 0) {
-      CGPoint points[2];
-      RCTEllipseGetIntersectionsWithLine(
-          (CGRect){
-              {bottomRight.x - 2 * cornerInsets.bottomRight.width, bottomRight.y - 2 * cornerInsets.bottomRight.height},
-              {2 * cornerInsets.bottomRight.width, 2 * cornerInsets.bottomRight.height}},
-          (CGPoint){size.width, size.height},
-          bottomRight,
-          points);
-      if (!isnan(points[0].x) && !isnan(points[0].y)) {
-        bottomRight = points[0];
+      CGPoint topRight = (CGPoint){size.width - borderInsets.right, borderInsets.top};
+      if (cornerInsets.topRight.width > 0 && cornerInsets.topRight.height > 0) {
+        CGPoint points[2];
+        RCTEllipseGetIntersectionsWithLine(
+            (CGRect){
+                {topRight.x - 2 * cornerInsets.topRight.width, topRight.y},
+                {2 * cornerInsets.topRight.width, 2 * cornerInsets.topRight.height}},
+            (CGPoint){size.width, 0},
+            topRight,
+            points);
+        if (!isnan(points[0].x) && !isnan(points[0].y)) {
+          topRight = points[0];
+        }
       }
-    }
 
-    CGColorRef currentColor = NULL;
+      CGPoint bottomRight = (CGPoint){size.width - borderInsets.right, size.height - borderInsets.bottom};
+      if (cornerInsets.bottomRight.width > 0 && cornerInsets.bottomRight.height > 0) {
+        CGPoint points[2];
+        RCTEllipseGetIntersectionsWithLine(
+            (CGRect){
+                {bottomRight.x - 2 * cornerInsets.bottomRight.width,
+                 bottomRight.y - 2 * cornerInsets.bottomRight.height},
+                {2 * cornerInsets.bottomRight.width, 2 * cornerInsets.bottomRight.height}},
+            (CGPoint){size.width, size.height},
+            bottomRight,
+            points);
+        if (!isnan(points[0].x) && !isnan(points[0].y)) {
+          bottomRight = points[0];
+        }
+      }
 
-    // RIGHT
-    if (borderInsets.right > 0) {
-      const CGPoint points[] = {
-          (CGPoint){size.width, 0},
-          topRight,
-          bottomRight,
-          (CGPoint){size.width, size.height},
-      };
+      CGColorRef currentColor = NULL;
 
-      currentColor = borderColors.right;
-      CGContextAddLines(ctx, points, sizeof(points) / sizeof(*points));
-    }
+      // RIGHT
+      if (borderInsets.right > 0) {
+        const CGPoint points[] = {
+            (CGPoint){size.width, 0},
+            topRight,
+            bottomRight,
+            (CGPoint){size.width, size.height},
+        };
 
-    // BOTTOM
-    if (borderInsets.bottom > 0) {
-      const CGPoint points[] = {
-          (CGPoint){0, size.height},
-          bottomLeft,
-          bottomRight,
-          (CGPoint){size.width, size.height},
-      };
-
-      if (!CGColorEqualToColor(currentColor, borderColors.bottom)) {
-        CGContextSetFillColorWithColor(ctx, currentColor);
-        CGContextFillPath(ctx);
-        currentColor = borderColors.bottom;
+        currentColor = borderColors.right;
+        CGContextAddLines(context, points, sizeof(points) / sizeof(*points));
       }
-      CGContextAddLines(ctx, points, sizeof(points) / sizeof(*points));
-    }
 
-    // LEFT
-    if (borderInsets.left > 0) {
-      const CGPoint points[] = {
-          CGPointZero,
-          topLeft,
-          bottomLeft,
-          (CGPoint){0, size.height},
-      };
-
-      if (!CGColorEqualToColor(currentColor, borderColors.left)) {
-        CGContextSetFillColorWithColor(ctx, currentColor);
-        CGContextFillPath(ctx);
-        currentColor = borderColors.left;
+      // BOTTOM
+      if (borderInsets.bottom > 0) {
+        const CGPoint points[] = {
+            (CGPoint){0, size.height},
+            bottomLeft,
+            bottomRight,
+            (CGPoint){size.width, size.height},
+        };
+
+        if (!CGColorEqualToColor(currentColor, borderColors.bottom)) {
+          CGContextSetFillColorWithColor(context, currentColor);
+          CGContextFillPath(context);
+          currentColor = borderColors.bottom;
+        }
+        CGContextAddLines(context, points, sizeof(points) / sizeof(*points));
       }
-      CGContextAddLines(ctx, points, sizeof(points) / sizeof(*points));
-    }
 
-    // TOP
-    if (borderInsets.top > 0) {
-      const CGPoint points[] = {
-          CGPointZero,
-          topLeft,
-          topRight,
-          (CGPoint){size.width, 0},
-      };
-
-      if (!CGColorEqualToColor(currentColor, borderColors.top)) {
-        CGContextSetFillColorWithColor(ctx, currentColor);
-        CGContextFillPath(ctx);
-        currentColor = borderColors.top;
+      // LEFT
+      if (borderInsets.left > 0) {
+        const CGPoint points[] = {
+            CGPointZero,
+            topLeft,
+            bottomLeft,
+            (CGPoint){0, size.height},
+        };
+
+        if (!CGColorEqualToColor(currentColor, borderColors.left)) {
+          CGContextSetFillColorWithColor(context, currentColor);
+          CGContextFillPath(context);
+          currentColor = borderColors.left;
+        }
+        CGContextAddLines(context, points, sizeof(points) / sizeof(*points));
       }
-      CGContextAddLines(ctx, points, sizeof(points) / sizeof(*points));
-    }
 
-    CGContextSetFillColorWithColor(ctx, currentColor);
-    CGContextFillPath(ctx);
-  }
+      // TOP
+      if (borderInsets.top > 0) {
+        const CGPoint points[] = {
+            CGPointZero,
+            topLeft,
+            topRight,
+            (CGPoint){size.width, 0},
+        };
+
+        if (!CGColorEqualToColor(currentColor, borderColors.top)) {
+          CGContextSetFillColorWithColor(context, currentColor);
+          CGContextFillPath(context);
+          currentColor = borderColors.top;
+        }
+        CGContextAddLines(context, points, sizeof(points) / sizeof(*points));
+      }
 
-  CGPathRelease(insetPath);
+      CGContextSetFillColorWithColor(context, currentColor);
+      CGContextFillPath(context);
+    }
 
-  UIImage *image = UIGraphicsGetImageFromCurrentImageContext();
-  UIGraphicsEndImageContext();
+    CGPathRelease(insetPath);
+  }];
 
   if (makeStretchable) {
     image = [image resizableImageWithCapInsets:edgeInsets];
@@ -477,42 +481,41 @@ static UIImage *RCTGetDashedOrDottedBorderImage(
   }
 
   const BOOL hasCornerRadii = RCTCornerRadiiAreAboveThreshold(cornerRadii);
-  CGContextRef ctx = RCTUIGraphicsBeginImageContext(viewSize, backgroundColor, hasCornerRadii, drawToEdge);
-  const CGRect rect = {.size = viewSize};
-
-  if (backgroundColor) {
-    CGPathRef outerPath = RCTPathCreateOuterOutline(drawToEdge, rect, cornerRadii);
-    CGContextAddPath(ctx, outerPath);
-    CGPathRelease(outerPath);
-
-    CGContextSetFillColorWithColor(ctx, backgroundColor);
-    CGContextFillPath(ctx);
-  }
-
-  // Stroking means that the width is divided in half and grows in both directions
-  // perpendicular to the path, that's why we inset by half the width, so that it
-  // reaches the edge of the rect.
-  CGRect pathRect = CGRectInset(rect, lineWidth / 2.0, lineWidth / 2.0);
-  CGPathRef path = RCTPathCreateWithRoundedRect(pathRect, RCTGetCornerInsets(cornerRadii, UIEdgeInsetsZero), NULL);
-
-  CGFloat dashLengths[2];
-  dashLengths[0] = dashLengths[1] = (borderStyle == RCTBorderStyleDashed ? 3 : 1) * lineWidth;
+  UIGraphicsImageRenderer *const imageRenderer =
+      RCTUIGraphicsImageRenderer(viewSize, backgroundColor, hasCornerRadii, drawToEdge);
+  return [imageRenderer imageWithActions:^(UIGraphicsImageRendererContext *_Nonnull rendererContext) {
+    const CGContextRef context = rendererContext.CGContext;
+    const CGRect rect = {.size = viewSize};
+
+    if (backgroundColor) {
+      CGPathRef outerPath = RCTPathCreateOuterOutline(drawToEdge, rect, cornerRadii);
+      CGContextAddPath(context, outerPath);
+      CGPathRelease(outerPath);
+
+      CGContextSetFillColorWithColor(context, backgroundColor);
+      CGContextFillPath(context);
+    }
 
-  CGContextSetLineWidth(ctx, lineWidth);
-  CGContextSetLineDash(ctx, 0, dashLengths, sizeof(dashLengths) / sizeof(*dashLengths));
+    // Stroking means that the width is divided in half and grows in both directions
+    // perpendicular to the path, that's why we inset by half the width, so that it
+    // reaches the edge of the rect.
+    CGRect pathRect = CGRectInset(rect, lineWidth / 2.0, lineWidth / 2.0);
+    CGPathRef path = RCTPathCreateWithRoundedRect(pathRect, RCTGetCornerInsets(cornerRadii, UIEdgeInsetsZero), NULL);
 
-  CGContextSetStrokeColorWithColor(ctx, [UIColor yellowColor].CGColor);
+    CGFloat dashLengths[2];
+    dashLengths[0] = dashLengths[1] = (borderStyle == RCTBorderStyleDashed ? 3 : 1) * lineWidth;
 
-  CGContextAddPath(ctx, path);
-  CGContextSetStrokeColorWithColor(ctx, borderColors.top);
-  CGContextStrokePath(ctx);
+    CGContextSetLineWidth(context, lineWidth);
+    CGContextSetLineDash(context, 0, dashLengths, sizeof(dashLengths) / sizeof(*dashLengths));
 
-  CGPathRelease(path);
+    CGContextSetStrokeColorWithColor(context, [UIColor yellowColor].CGColor);
 
-  UIImage *image = UIGraphicsGetImageFromCurrentImageContext();
-  UIGraphicsEndImageContext();
+    CGContextAddPath(context, path);
+    CGContextSetStrokeColorWithColor(context, borderColors.top);
+    CGContextStrokePath(context);
 
-  return image;
+    CGPathRelease(path);
+  }];
 }
 
 UIImage *RCTGetBorderImage(

package/React/Views/RCTComponent.h

@@ -15,6 +15,7 @@
  */
 typedef void (^RCTDirectEventBlock)(NSDictionary *body);
 typedef void (^RCTBubblingEventBlock)(NSDictionary *body);
+typedef void (^RCTCapturingEventBlock)(NSDictionary *body);
 
 /**
  * Logical node in a tree of application components. Both `ShadowView` and

package/React/Views/RCTComponentData.m

@@ -262,7 +262,8 @@ static RCTPropBlock createNSInvocationSetter(NSMethodSignature *typeSignature, S
     // Build setter block
     void (^setterBlock)(id target, id json) = nil;
     if (type == NSSelectorFromString(@"RCTBubblingEventBlock:") ||
-        type == NSSelectorFromString(@"RCTDirectEventBlock:")) {
+        type == NSSelectorFromString(@"RCTDirectEventBlock:") ||
+        type == NSSelectorFromString(@"RCTCapturingEventBlock:")) {
       // Special case for event handlers
       setterBlock =
           createEventSetter(name, setter, self.eventInterceptor, _bridge ? _bridge.eventDispatcher : _eventDispatcher);
@@ -388,6 +389,7 @@ static RCTPropBlock createNSInvocationSetter(NSMethodSignature *typeSignature, S
 - (NSDictionary<NSString *, id> *)viewConfig
 {
   NSMutableArray<NSString *> *bubblingEvents = [NSMutableArray new];
+  NSMutableArray<NSString *> *capturingEvents = [NSMutableArray new];
   NSMutableArray<NSString *> *directEvents = [NSMutableArray new];
 
 #pragma clang diagnostic push
@@ -431,6 +433,13 @@ static RCTPropBlock createNSInvocationSetter(NSMethodSignature *typeSignature, S
     if ([type isEqualToString:@"RCTBubblingEventBlock"]) {
       [bubblingEvents addObject:RCTNormalizeInputEventName(name)];
 
+      // TODO(109509380): Remove this gating
+      if (!RCTViewConfigEventValidAttributesDisabled()) {
+        propTypes[name] = @"BOOL";
+      }
+    } else if ([type isEqualToString:@"RCTCapturingEventBlock"]) {
+      [capturingEvents addObject:RCTNormalizeInputEventName(name)];
+
       // TODO(109509380): Remove this gating
       if (!RCTViewConfigEventValidAttributesDisabled()) {
         propTypes[name] = @"BOOL";
@@ -466,6 +475,7 @@ static RCTPropBlock createNSInvocationSetter(NSMethodSignature *typeSignature, S
     @"propTypes" : propTypes,
     @"directEvents" : directEvents,
     @"bubblingEvents" : bubblingEvents,
+    @"capturingEvents" : capturingEvents,
     @"baseModuleName" : superClass == [NSObject class] ? (id)kCFNull : moduleNameForClass(superClass),
   };
 }

package/React/Views/RCTDatePickerManager.m

@@ -6,8 +6,6 @@
  */
 
 #import "RCTDatePickerManager.h"
-
-#import <React/RCTUIManager.h>
 #import "RCTBridge.h"
 #import "RCTDatePicker.h"
 #import "UIView+React.h"
@@ -44,6 +42,8 @@ RCT_ENUM_CONVERTER(
 
 @implementation RCTDatePickerManager
 
+@synthesize viewRegistry_DEPRECATED = _viewRegistry_DEPRECATED;
+
 RCT_EXPORT_MODULE()
 
 - (UIView *)view
@@ -62,16 +62,15 @@ RCT_REMAP_VIEW_PROPERTY(timeZoneOffsetInMinutes, timeZone, NSTimeZone)
 
 RCT_EXPORT_METHOD(setNativeDate : (nonnull NSNumber *)viewTag toDate : (NSDate *)date)
 {
-  [self.bridge.uiManager addUIBlock:^(RCTUIManager *uiManager, NSDictionary<NSNumber *, UIView *> *viewRegistry) {
-    UIView *view = viewRegistry[viewTag];
-
+  [_viewRegistry_DEPRECATED addUIBlock:^(RCTViewRegistry *viewRegistry) {
+    UIView *view = [viewRegistry viewForReactTag:viewTag];
     if ([view isKindOfClass:[RCTDatePicker class]]) {
       [(RCTDatePicker *)view setDate:date];
     } else {
       // This component is used in Fabric through LegacyInteropLayer.
       // `RCTDatePicker` view is subview of `RCTLegacyViewManagerInteropComponentView`.
       // `viewTag` passed as parameter to this method is tag of the `RCTLegacyViewManagerInteropComponentView`.
-      UIView *subview = [uiManager viewForReactTag:viewTag].subviews.firstObject;
+      UIView *subview = view.subviews.firstObject;
       if ([subview isKindOfClass:[RCTDatePicker class]]) {
         [(RCTDatePicker *)subview setDate:date];
       } else {

package/React/Views/RCTModalHostView.h

@@ -39,7 +39,7 @@
 @property (nonatomic, copy) RCTDirectEventBlock onOrientationChange;
 
 // Fabric only
-@property (nonatomic, copy) RCTBubblingEventBlock onDismiss;
+@property (nonatomic, copy) RCTDirectEventBlock onDismiss;
 #if TARGET_OS_TV
 @property (nonatomic, copy) RCTDirectEventBlock onRequestClose;
 @property (nonatomic, strong) RCTTVRemoteHandler *tvRemoteHandler;
@@ -47,6 +47,9 @@
 
 - (instancetype)initWithBridge:(RCTBridge *)bridge NS_DESIGNATED_INITIALIZER;
 
+- (void)enableEventHandlers;
+- (void)disableEventHandlers;
+
 @end
 
 @protocol RCTModalHostViewInteractor <NSObject>

package/React/Views/RCTModalHostView.m

@@ -45,12 +45,12 @@ RCT_NOT_IMPLEMENTED(-(instancetype)initWithCoder : coder)
     UIView *containerView = [UIView new];
     containerView.autoresizingMask = UIViewAutoresizingFlexibleHeight | UIViewAutoresizingFlexibleWidth;
     _modalViewController.view = containerView;
+    _modalViewController.modalHostView = self;
     _touchHandler = [[RCTTouchHandler alloc] initWithBridge:bridge];
 #if TARGET_OS_TV
     _menuButtonGestureRecognizer = [[UITapGestureRecognizer alloc] initWithTarget:self
                                                                            action:@selector(menuButtonPressed:)];
     _menuButtonGestureRecognizer.allowedPressTypes = @[ @(UIPressTypeMenu) ];
-    self.tvRemoteHandler = [[RCTTVRemoteHandler alloc] initWithView:self];
 #endif
     _isPresented = NO;
 
@@ -74,21 +74,15 @@ RCT_NOT_IMPLEMENTED(-(instancetype)initWithCoder : coder)
   if (_onRequestClose) {
     _onRequestClose(nil);
   }
+  if (_onDismiss) {
+    _onDismiss(nil);
+  }
 }
 #endif
 
 - (void)setOnRequestClose:(RCTDirectEventBlock)onRequestClose
 {
   _onRequestClose = onRequestClose;
-#if TARGET_OS_TV
-  if (_reactSubview) {
-    if (_onRequestClose && _menuButtonGestureRecognizer) {
-      [_reactSubview addGestureRecognizer:_menuButtonGestureRecognizer];
-    } else {
-      [_reactSubview removeGestureRecognizer:_menuButtonGestureRecognizer];
-    }
-  }
-#endif
 }
 
 - (void)notifyForBoundsChange:(CGRect)newBounds
@@ -99,11 +93,18 @@ RCT_NOT_IMPLEMENTED(-(instancetype)initWithCoder : coder)
   }
 }
 
-- (void)presentationControllerDidAttemptToDismiss:(UIPresentationController *)controller
+- (void)enableEventHandlers
 {
-  if (_onRequestClose != nil) {
-    _onRequestClose(nil);
-  }
+  self.tvRemoteHandler = [[RCTTVRemoteHandler alloc] initWithView:_modalViewController.view];
+  [self.tvRemoteHandler disableTVMenuKey];
+
+  [_modalViewController.view addGestureRecognizer:_menuButtonGestureRecognizer];
+}
+
+- (void)disableEventHandlers
+{
+  self.tvRemoteHandler = nil;
+  [_modalViewController.view removeGestureRecognizer:_menuButtonGestureRecognizer];
 }
 
 - (void)notifyForOrientationChange
@@ -133,12 +134,6 @@ RCT_NOT_IMPLEMENTED(-(instancetype)initWithCoder : coder)
   RCTAssert(_reactSubview == nil, @"Modal view can only have one subview");
   [super insertReactSubview:subview atIndex:atIndex];
   [_touchHandler attachToView:subview];
-#if TARGET_OS_TV
-  if (_onRequestClose) {
-    [subview addGestureRecognizer:_menuButtonGestureRecognizer];
-  }
-#endif
-
   [_modalViewController.view insertSubview:subview atIndex:0];
   _reactSubview = subview;
 }
@@ -149,11 +144,6 @@ RCT_NOT_IMPLEMENTED(-(instancetype)initWithCoder : coder)
   // Superclass (category) removes the `subview` from actual `superview`.
   [super removeReactSubview:subview];
   [_touchHandler detachFromView:subview];
-#if TARGET_OS_TV
-  if (_menuButtonGestureRecognizer) {
-    [subview removeGestureRecognizer:_menuButtonGestureRecognizer];
-  }
-#endif
   _reactSubview = nil;
 }
 

package/React/Views/RCTModalHostViewController.h

@@ -6,11 +6,14 @@
  */
 
 #import <UIKit/UIKit.h>
+#import "RCTModalHostView.h"
 
 @interface RCTModalHostViewController : UIViewController
 
 @property (nonatomic, copy) void (^boundsDidChangeBlock)(CGRect newBounds);
 
+@property (nonatomic, weak) RCTModalHostView *modalHostView;
+
 #if !TARGET_OS_TV
 @property (nonatomic, assign) UIInterfaceOrientationMask supportedInterfaceOrientations;
 #endif

package/React/Views/RCTModalHostViewController.m

@@ -39,6 +39,32 @@
   return self;
 }
 
+- (void)viewDidAppear:(BOOL)animated
+{
+#if TARGET_OS_TV
+  [self.modalHostView enableEventHandlers];
+#endif
+}
+
+- (void)viewWillDisappear:(BOOL)animated
+{
+#if TARGET_OS_TV
+  [self.modalHostView disableEventHandlers];
+  if (self.modalHostView.onRequestClose) {
+    self.modalHostView.onRequestClose(nil);
+  }
+#endif
+}
+
+- (void)viewDidDisappear:(BOOL)animated
+{
+#if TARGET_OS_TV
+  if (self.modalHostView.onDismiss) {
+    self.modalHostView.onDismiss(nil);
+  }
+#endif
+}
+
 - (void)viewDidLayoutSubviews
 {
   [super viewDidLayoutSubviews];

package/React/Views/RCTShadowView.h

@@ -8,6 +8,8 @@
 #import <UIKit/UIKit.h>
 
 #import <React/RCTComponent.h>
+// Keeps RCTConvert.h here before yoga for clang module to generate correct header imports.
+#import <React/RCTConvert.h>
 #import <React/RCTLayout.h>
 #import <React/RCTRootView.h>
 #import <yoga/Yoga.h>

package/React/Views/RCTTVView.m

@@ -145,7 +145,7 @@ RCT_NOT_IMPLEMENTED(-(instancetype)initWithCoder : unused)
   // When root view available, set this view as focused
   RCTRootView *rootview = [self rootView];
   int counter = 30;
-  while (rootview == nil || counter > 0) {
+  while (rootview == nil && counter > 0) {
     [[NSRunLoop currentRunLoop] runUntilDate:[NSDate dateWithTimeIntervalSinceNow:0.016]];
     counter = counter - 1;
     rootview = [self rootView];