react-native-tvos 0.73.7-1 → 0.74.0-0

package/React/Base/RCTKeyCommands.m

@@ -173,13 +173,24 @@ RCT_NOT_IMPLEMENTED(-(instancetype)init)
 
 - (void)RCT_handleKeyCommand:(NSString *)input flags:(UIKeyModifierFlags)modifierFlags
 {
+  // In Bridgeless mode we might incur in some concurrency issues
+  // where the React Native instance is invalidated while iterating on the
+  // list of available commands.
+  // That will cleanup the set while iterating, which is a not allowed mutation.
+  // To work around that, we store the commands that we need to execute in a separate
+  // array, local to this function call, so we don't incur in concurrency issues
+  NSMutableArray<RCTKeyCommand *> *commandsToExecute = [NSMutableArray new];
   for (RCTKeyCommand *command in [RCTKeyCommands sharedInstance].commands) {
     if ([command matchesInput:input flags:modifierFlags]) {
       if (command.block) {
-        command.block(nil);
+        [commandsToExecute addObject:command];
       }
     }
   }
+
+  for (RCTKeyCommand *command in commandsToExecute) {
+    command.block(nil);
+  }
 }
 
 + (instancetype)sharedInstance

package/React/Base/RCTModuleData.mm

@@ -77,20 +77,6 @@ int32_t getUniqueId()
         !_instance && [_moduleClass instanceMethodForSelector:@selector(init)] != objectInitMethod;
 
     _requiresMainQueueSetup = _hasConstantsToExport || hasCustomInit;
-    if (_requiresMainQueueSetup) {
-      const char *methodName = "";
-      if (_hasConstantsToExport) {
-        methodName = "constantsToExport";
-      } else if (hasCustomInit) {
-        methodName = "init";
-      }
-      RCTLogWarn(
-          @"Module %@ requires main queue setup since it overrides `%s` but doesn't implement "
-           "`requiresMainQueueSetup`. In a future release React Native will default to initializing all native modules "
-           "on a background thread unless explicitly opted-out of.",
-          _moduleClass,
-          methodName);
-    }
   }
 }
 

package/React/Base/RCTRuntimeExecutorModule.h

@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+@class RCTRuntimeExecutor;
+
+/**
+ * Have your module conform to this protocol to access the RuntimeExecutor.
+ * Only available in the bridgeless runtime.
+ */
+@protocol RCTRuntimeExecutorModule <NSObject>
+
+@property (nonatomic, nullable, readwrite) RCTRuntimeExecutor *runtimeExecutor;
+
+@end

package/React/Base/RCTUtils.h

@@ -16,6 +16,10 @@
 
 NS_ASSUME_NONNULL_BEGIN
 
+// Whether the New Architecture is enabled or not
+RCT_EXTERN BOOL RCTIsNewArchEnabled(void);
+RCT_EXTERN void RCTSetNewArchEnabled(BOOL enabled);
+
 // JSON serialization/deserialization
 RCT_EXTERN NSString *__nullable RCTJSONStringify(id __nullable jsonObject, NSError **error);
 RCT_EXTERN id __nullable RCTJSONParse(NSString *__nullable jsonString, NSError **error);
@@ -95,6 +99,11 @@ RCT_EXTERN UIWindow *__nullable RCTKeyWindow(void);
 // e.g. to present a modal view controller or alert over it
 RCT_EXTERN UIViewController *__nullable RCTPresentedViewController(void);
 
+// Retrieve current window UIStatusBarManager
+#if !TARGET_OS_TV
+RCT_EXTERN UIStatusBarManager *__nullable RCTUIStatusBarManager(void) API_AVAILABLE(ios(13));
+#endif
+
 // Does this device support force touch (aka 3D Touch)?
 RCT_EXTERN BOOL RCTForceTouchAvailable(void);
 

package/React/Base/RCTUtils.m

@@ -33,6 +33,20 @@ NSString *__nullable RCTHomePathForURL(NSURL *__nullable URL);
 // Determines if a given image URL refers to a image in Home directory (~)
 BOOL RCTIsHomeAssetURL(NSURL *__nullable imageURL);
 
+// Whether the New Architecture is enabled or not
+static BOOL _newArchEnabled = false;
+BOOL RCTIsNewArchEnabled(void)
+{
+  return _newArchEnabled;
+}
+void RCTSetNewArchEnabled(BOOL enabled)
+{
+  static dispatch_once_t onceToken;
+  dispatch_once(&onceToken, ^{
+    _newArchEnabled = enabled;
+  });
+}
+
 static NSString *__nullable _RCTJSONStringifyNoRetry(id __nullable jsonObject, NSError **error)
 {
   if (!jsonObject) {
@@ -302,14 +316,14 @@ static CGFloat screenScale;
 void RCTComputeScreenScale(void)
 {
   dispatch_once(&onceTokenScreenScale, ^{
-    screenScale = [UIScreen mainScreen].scale;
+    screenScale = [UITraitCollection currentTraitCollection].displayScale;
   });
 }
 
 CGFloat RCTScreenScale(void)
 {
   RCTUnsafeExecuteOnMainQueueOnceSync(&onceTokenScreenScale, ^{
-    screenScale = [UIScreen mainScreen].scale;
+    screenScale = [UITraitCollection currentTraitCollection].displayScale;
   });
 
   return screenScale;
@@ -548,15 +562,30 @@ UIWindow *__nullable RCTKeyWindow(void)
     return nil;
   }
 
-  // TODO: replace with a more robust solution
-  for (UIWindow *window in RCTSharedApplication().windows) {
-    if (window.keyWindow) {
-      return window;
+  for (UIScene *scene in RCTSharedApplication().connectedScenes) {
+    if (scene.activationState != UISceneActivationStateForegroundActive ||
+        ![scene isKindOfClass:[UIWindowScene class]]) {
+      continue;
+    }
+    UIWindowScene *windowScene = (UIWindowScene *)scene;
+
+    for (UIWindow *window in windowScene.windows) {
+      if (window.isKeyWindow) {
+        return window;
+      }
     }
   }
+
   return nil;
 }
 
+#if !TARGET_OS_TV
+UIStatusBarManager *__nullable RCTUIStatusBarManager(void)
+{
+  return RCTKeyWindow().windowScene.statusBarManager;
+}
+#endif
+
 UIViewController *__nullable RCTPresentedViewController(void)
 {
   if ([RCTUtilsUIOverride hasPresentedViewController]) {
@@ -578,12 +607,10 @@ BOOL RCTForceTouchAvailable(void)
   static BOOL forceSupported;
   static dispatch_once_t onceToken;
   dispatch_once(&onceToken, ^{
-    forceSupported =
-        [UITraitCollection class] && [UITraitCollection instancesRespondToSelector:@selector(forceTouchCapability)];
+    forceSupported = [UITraitCollection currentTraitCollection].forceTouchCapability == UIForceTouchCapabilityAvailable;
   });
 
-  return forceSupported &&
-      (RCTKeyWindow() ?: [UIView new]).traitCollection.forceTouchCapability == UIForceTouchCapabilityAvailable;
+  return forceSupported;
 }
 
 NSError *RCTErrorWithMessage(NSString *message)

package/React/Base/RCTVersion.m

@@ -1,10 +1,10 @@
 /**
- * @generated by scripts/set-rn-version.js
- *
  * Copyright (c) Meta Platforms, Inc. and affiliates.
  *
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
+ *
+ * @generated by scripts/releases/set-rn-version.js
  */
 
 #import "RCTVersion.h"
@@ -22,9 +22,9 @@ NSDictionary* RCTGetReactNativeVersion(void)
   dispatch_once(&onceToken, ^(void){
     __rnVersion = @{
                   RCTVersionMajor: @(0),
-                  RCTVersionMinor: @(73),
-                  RCTVersionPatch: @(7),
-                  RCTVersionPrerelease: @"1",
+                  RCTVersionMinor: @(74),
+                  RCTVersionPatch: @(0),
+                  RCTVersionPrerelease: @"0",
                   };
   });
   return __rnVersion;

package/React/Base/Surface/SurfaceHostingView/RCTSurfaceHostingProxyRootView.h

@@ -12,6 +12,10 @@
 
 #import "RCTSurfaceHostingView.h"
 
+#if TARGET_OS_TV
+#import <React/RCTTVRemoteHandler.h>
+#endif
+
 NS_ASSUME_NONNULL_BEGIN
 
 /**
@@ -38,6 +42,11 @@ NS_ASSUME_NONNULL_BEGIN
 @property (nonatomic, assign) NSTimeInterval loadingViewFadeDelay;
 @property (nonatomic, assign) NSTimeInterval loadingViewFadeDuration;
 @property (nonatomic, assign) CGSize minimumSize;
+#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
 
 - (instancetype)initWithSurface:(id<RCTSurfaceProtocol>)surface NS_DESIGNATED_INITIALIZER;
 

package/React/Base/Surface/SurfaceHostingView/RCTSurfaceHostingProxyRootView.mm

@@ -63,6 +63,27 @@ static RCTRootViewSizeFlexibility convertToRootViewSizeFlexibility(RCTSurfaceSiz
 RCT_NOT_IMPLEMENTED(-(instancetype)initWithFrame : (CGRect)frame)
 RCT_NOT_IMPLEMENTED(-(instancetype)initWithCoder : (NSCoder *)aDecoder)
 
+#if TARGET_OS_TV
+- (void)dealloc
+{
+  self.tvRemoteHandler = nil;
+}
+
+- (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];
+  }
+  return [super preferredFocusEnvironments];
+}
+#endif
+
+
 #pragma mark proxy methods to RCTSurfaceHostingView
 
 - (NSString *)moduleName
@@ -126,6 +147,10 @@ RCT_NOT_IMPLEMENTED(-(instancetype)initWithCoder : (NSCoder *)aDecoder)
   if (RCTSurfaceStageIsRunning(stage)) {
     [_bridge.performanceLogger markStopForTag:RCTPLTTI];
     dispatch_async(dispatch_get_main_queue(), ^{
+#if TARGET_OS_TV
+     self.tvRemoteHandler = [[RCTTVRemoteHandler alloc] initWithView:[self contentView]];
+#endif
+
       [[NSNotificationCenter defaultCenter] postNotificationName:RCTContentDidAppearNotification object:self];
     });
   }

package/React/Base/Surface/SurfaceHostingView/RCTSurfaceHostingView.h

@@ -56,6 +56,13 @@ NS_ASSUME_NONNULL_BEGIN
  */
 @property (nonatomic, copy, nullable) RCTSurfaceHostingViewActivityIndicatorViewFactory activityIndicatorViewFactory;
 
+/**
+ * When set to `YES`, the activity indicator is not automatically hidden when the Surface stage changes.
+ * In this scenario, users should invoke `hideActivityIndicator` to remove it.
+ *
+ * @param disabled: if `YES`, the auto-hide is disabled. Otherwise the loading view will be hidden automatically
+ */
+- (void)disableActivityIndicatorAutoHide:(BOOL)disabled;
 @end
 
 NS_ASSUME_NONNULL_END

package/React/Base/Surface/SurfaceHostingView/RCTSurfaceHostingView.mm

@@ -24,6 +24,7 @@
   UIView *_Nullable _activityIndicatorView;
   UIView *_Nullable _surfaceView;
   RCTSurfaceStage _stage;
+  BOOL _autoHideDisabled;
 }
 
 RCT_NOT_IMPLEMENTED(-(instancetype)init)
@@ -36,6 +37,7 @@ RCT_NOT_IMPLEMENTED(-(nullable instancetype)initWithCoder : (NSCoder *)coder)
   if (self = [super initWithFrame:CGRectZero]) {
     _surface = surface;
     _sizeMeasureMode = sizeMeasureMode;
+    _autoHideDisabled = NO;
 
     _surface.delegate = self;
     _stage = surface.stage;
@@ -124,6 +126,10 @@ RCT_NOT_IMPLEMENTED(-(nullable instancetype)initWithCoder : (NSCoder *)coder)
   _sizeMeasureMode = sizeMeasureMode;
   [self _invalidateLayout];
 }
+- (void)disableActivityIndicatorAutoHide:(BOOL)disabled
+{
+  _autoHideDisabled = disabled;
+}
 
 #pragma mark - isActivityIndicatorViewVisible
 
@@ -162,7 +168,16 @@ RCT_NOT_IMPLEMENTED(-(nullable instancetype)initWithCoder : (NSCoder *)coder)
     _surfaceView = _surface.view;
     _surfaceView.frame = self.bounds;
     _surfaceView.autoresizingMask = UIViewAutoresizingFlexibleWidth | UIViewAutoresizingFlexibleHeight;
-    [self addSubview:_surfaceView];
+    if (_activityIndicatorView && _autoHideDisabled) {
+      // The activity indicator is still showing and the surface is set to
+      // prevent the auto hide. This means that the application will take care of
+      // hiding it when it's ready.
+      // Let's add the surfaceView below the activity indicator so it's ready once
+      // the activity indicator is hidden.
+      [self insertSubview:_surfaceView belowSubview:_activityIndicatorView];
+    } else {
+      [self addSubview:_surfaceView];
+    }
   } else {
     [_surfaceView removeFromSuperview];
     _surfaceView = nil;
@@ -204,7 +219,7 @@ RCT_NOT_IMPLEMENTED(-(nullable instancetype)initWithCoder : (NSCoder *)coder)
 - (void)_updateViews
 {
   self.isSurfaceViewVisible = RCTSurfaceStageIsRunning(_stage);
-  self.isActivityIndicatorViewVisible = RCTSurfaceStageIsPreparing(_stage);
+  self.isActivityIndicatorViewVisible = _autoHideDisabled || RCTSurfaceStageIsPreparing(_stage);
 }
 
 - (void)didMoveToWindow