react-native-tvos 0.78.0-0rc4 → 0.79.0-0rc2

package/ReactCommon/react/nativemodule/core/platform/ios/ReactCommon/RCTTurboModule.h

@@ -32,7 +32,11 @@ using EventEmitterCallback = std::function<void(const std::string &, id)>;
 namespace TurboModuleConvertUtils {
 jsi::Value convertObjCObjectToJSIValue(jsi::Runtime &runtime, id value);
 id convertJSIValueToObjCObject(jsi::Runtime &runtime, const jsi::Value &value, std::shared_ptr<CallInvoker> jsInvoker);
-id convertJSIValueToObjCObject(jsi::Runtime &runtime, const jsi::Value &value, std::shared_ptr<CallInvoker> jsInvoker, BOOL useNSNull);
+id convertJSIValueToObjCObject(
+    jsi::Runtime &runtime,
+    const jsi::Value &value,
+    std::shared_ptr<CallInvoker> jsInvoker,
+    BOOL useNSNull);
 } // namespace TurboModuleConvertUtils
 
 template <>
@@ -172,9 +176,25 @@ class JSI_EXPORT ObjCTurboModule : public TurboModule {
 }
 @end
 
-@protocol RCTTurboModule <NSObject>
+/**
+ * Factory object that can create a Turbomodule. It could be either a C++ TM or any TurboModule.
+ * This needs to be an Objective-C class so we can instantiate it at runtime.
+ */
+@protocol RCTModuleProvider <NSObject>
+
+/**
+ * Create an instance of a TurboModule with the JS Invoker.
+ */
 - (std::shared_ptr<facebook::react::TurboModule>)getTurboModule:
     (const facebook::react::ObjCTurboModule::InitParams &)params;
+@end
+
+/**
+ * Protocol that objects can inherit to conform to be treated as turbomodules.
+ * It inherits from RCTTurboModuleProvider, meaning that a TurboModule can create itself
+ */
+@protocol RCTTurboModule <RCTModuleProvider>
+
 @optional
 - (void)setEventEmitterCallback:(EventEmitterCallbackWrapper *)eventEmitterCallbackWrapper;
 @end

package/ReactCommon/react/nativemodule/core/platform/ios/ReactCommon/RCTTurboModule.mm

@@ -111,8 +111,11 @@ static NSString *convertJSIStringToNSString(jsi::Runtime &runtime, const jsi::St
   return [NSString stringWithUTF8String:value.utf8(runtime).c_str()];
 }
 
-static NSArray *
-convertJSIArrayToNSArray(jsi::Runtime &runtime, const jsi::Array &value, std::shared_ptr<CallInvoker> jsInvoker, BOOL useNSNull)
+static NSArray *convertJSIArrayToNSArray(
+    jsi::Runtime &runtime,
+    const jsi::Array &value,
+    std::shared_ptr<CallInvoker> jsInvoker,
+    BOOL useNSNull)
 {
   size_t size = value.size(runtime);
   NSMutableArray *result = [NSMutableArray new];
@@ -124,8 +127,11 @@ convertJSIArrayToNSArray(jsi::Runtime &runtime, const jsi::Array &value, std::sh
   return [result copy];
 }
 
-static NSDictionary *
-convertJSIObjectToNSDictionary(jsi::Runtime &runtime, const jsi::Object &value, std::shared_ptr<CallInvoker> jsInvoker, BOOL useNSNull)
+static NSDictionary *convertJSIObjectToNSDictionary(
+    jsi::Runtime &runtime,
+    const jsi::Object &value,
+    std::shared_ptr<CallInvoker> jsInvoker,
+    BOOL useNSNull)
 {
   jsi::Array propertyNames = value.getPropertyNames(runtime);
   size_t size = propertyNames.size(runtime);
@@ -159,7 +165,16 @@ convertJSIFunctionToCallback(jsi::Runtime &rt, jsi::Function &&function, std::sh
   };
 }
 
-id convertJSIValueToObjCObject(jsi::Runtime &runtime, const jsi::Value &value, std::shared_ptr<CallInvoker> jsInvoker, BOOL useNSNull)
+id convertJSIValueToObjCObject(jsi::Runtime &runtime, const jsi::Value &value, std::shared_ptr<CallInvoker> jsInvoker)
+{
+  return convertJSIValueToObjCObject(runtime, value, jsInvoker, NO);
+}
+
+id convertJSIValueToObjCObject(
+    jsi::Runtime &runtime,
+    const jsi::Value &value,
+    std::shared_ptr<CallInvoker> jsInvoker,
+    BOOL useNSNull)
 {
   if (value.isUndefined() || (value.isNull() && !useNSNull)) {
     return nil;
@@ -190,11 +205,6 @@ id convertJSIValueToObjCObject(jsi::Runtime &runtime, const jsi::Value &value, s
   throw std::runtime_error("Unsupported jsi::Value kind");
 }
 
-id convertJSIValueToObjCObject(jsi::Runtime &runtime, const jsi::Value &value, std::shared_ptr<CallInvoker> jsInvoker)
-{
-  return convertJSIValueToObjCObject(runtime, value, jsInvoker, NO);
-}
-
 static jsi::Value createJSRuntimeError(jsi::Runtime &runtime, const std::string &message)
 {
   return runtime.global().getPropertyAsFunction(runtime, "Error").call(runtime, message);
@@ -582,12 +592,15 @@ void ObjCTurboModule::setInvocationArg(
     double v = arg.getNumber();
 
     /**
-     * JS type checking ensures the Objective C argument here is either a double or NSNumber*.
+     * JS type checking ensures the Objective C argument here is either a double or NSNumber* or NSInteger.
      */
     if (objCArgType == @encode(id)) {
       id objCArg = [NSNumber numberWithDouble:v];
       [inv setArgument:(void *)&objCArg atIndex:i + 2];
       [retainedObjectsForInvocation addObject:objCArg];
+    } else if (objCArgType == @encode(NSInteger)) {
+      NSInteger integer = v;
+      [inv setArgument:&integer atIndex:i + 2];
     } else {
       [inv setArgument:(void *)&v atIndex:i + 2];
     }

package/ReactCommon/react/nativemodule/core/platform/ios/ReactCommon/RCTTurboModuleManager.h

@@ -34,6 +34,13 @@
 
 @optional
 
+/**
+ * This method is used to retrieve a factory object that can create a `facebook::react::TurboModule`,
+ * The class implementing `RCTTurboModuleProvider` must be an Objective-C class so that we can
+ * initialize it dynamically with Codegen.
+ */
+- (id<RCTModuleProvider>)getModuleProvider:(const char *)name;
+
 /**
  * Create an instance of a TurboModule without relying on any ObjC++ module instance.
  */

package/ReactCommon/react/nativemodule/core/platform/ios/ReactCommon/RCTTurboModuleManager.mm

@@ -29,9 +29,11 @@
 #import <React/RCTUtils.h>
 #import <ReactCommon/CxxTurboModuleUtils.h>
 #import <ReactCommon/RCTTurboModuleWithJSIBindings.h>
+#import <ReactCommon/RuntimeExecutor.h>
 #import <ReactCommon/TurboCxxModule.h>
 #import <ReactCommon/TurboModulePerfLogger.h>
 #import <ReactCommon/TurboModuleUtils.h>
+#import <react/featureflags/ReactNativeFeatureFlags.h>
 
 using namespace facebook;
 using namespace facebook::react;
@@ -338,8 +340,7 @@ typedef struct {
   /**
    * Step 2: Look for platform-specific modules.
    */
-  id<RCTBridgeModule> module =
-      !RCTTurboModuleInteropEnabled() || [self _isTurboModule:moduleName] ? [self _provideObjCModule:moduleName] : nil;
+  id<RCTModuleProvider> module = [self _moduleProviderForName:moduleName];
 
   TurboModulePerfLogger::moduleJSRequireEndingStart(moduleName);
 
@@ -349,31 +350,28 @@ typedef struct {
     return nullptr;
   }
 
-  Class moduleClass = [module class];
-
+  std::shared_ptr<NativeMethodCallInvoker> nativeMethodCallInvoker = nullptr;
   dispatch_queue_t methodQueue = (dispatch_queue_t)objc_getAssociatedObject(module, &kAssociatedMethodQueueKey);
-  if (methodQueue == nil) {
-    RCTLogError(@"TurboModule \"%@\" was not associated with a method queue.", moduleClass);
-  }
-
-  /**
-   * Step 2c: Create and native CallInvoker from the TurboModule's method queue.
-   */
-  std::shared_ptr<NativeMethodCallInvoker> nativeMethodCallInvoker =
-      std::make_shared<ModuleNativeMethodCallInvoker>(methodQueue);
+  if (methodQueue) {
+    /**
+     * Step 2c: Create and native CallInvoker from the TurboModule's method queue.
+     */
+    nativeMethodCallInvoker = std::make_shared<ModuleNativeMethodCallInvoker>(methodQueue);
 
-  /**
-   * Have RCTCxxBridge decorate native CallInvoker, so that it's aware of TurboModule async method calls.
-   * This helps the bridge fire onBatchComplete as readily as it should.
-   */
-  if ([_bridge respondsToSelector:@selector(decorateNativeMethodCallInvoker:)]) {
-    nativeMethodCallInvoker = [_bridge decorateNativeMethodCallInvoker:nativeMethodCallInvoker];
+    /**
+     * Have RCTCxxBridge decorate native CallInvoker, so that it's aware of TurboModule async method calls.
+     * This helps the bridge fire onBatchComplete as readily as it should.
+     */
+    if ([_bridge respondsToSelector:@selector(decorateNativeMethodCallInvoker:)]) {
+      nativeMethodCallInvoker = [_bridge decorateNativeMethodCallInvoker:nativeMethodCallInvoker];
+    }
   }
 
   /**
    * Step 2d: If the moduleClass is a legacy CxxModule, return a TurboCxxModule instance that
    * wraps CxxModule.
    */
+  Class moduleClass = [module class];
   if ([moduleClass isSubclassOfClass:RCTCxxModule.class]) {
     // Use TurboCxxModule compat class to wrap the CxxModule instance.
     // This is only for migration convenience, despite less performant.
@@ -391,7 +389,7 @@ typedef struct {
   if ([module respondsToSelector:@selector(getTurboModule:)]) {
     ObjCTurboModule::InitParams params = {
         .moduleName = moduleName,
-        .instance = module,
+        .instance = (id<RCTBridgeModule>)module,
         .jsInvoker = _jsInvoker,
         .nativeMethodCallInvoker = nativeMethodCallInvoker,
         .isSyncModule = methodQueue == RCTJSThread,
@@ -428,7 +426,8 @@ typedef struct {
   TurboModulePerfLogger::moduleJSRequireBeginningEnd(moduleName);
 
   // Create platform-specific native module object
-  id<RCTBridgeModule> module = [self _isLegacyModule:moduleName] ? [self _provideObjCModule:moduleName] : nil;
+  id<RCTBridgeModule> module =
+      [self _isLegacyModule:moduleName] ? [self _provideObjCModule:moduleName moduleProvider:nil] : nil;
 
   TurboModulePerfLogger::moduleJSRequireEndingStart(moduleName);
 
@@ -473,6 +472,8 @@ typedef struct {
   return turboModule;
 }
 
+#pragma mark - Private Methods
+
 - (BOOL)_isTurboModule:(const char *)moduleName
 {
   Class moduleClass = [self _getModuleClassFromName:moduleName];
@@ -490,6 +491,30 @@ typedef struct {
   return moduleClass != nil && (!isTurboModuleClass(moduleClass) || [moduleClass isSubclassOfClass:RCTCxxModule.class]);
 }
 
+- (id<RCTModuleProvider>)_moduleProviderForName:(const char *)moduleName
+{
+  id<RCTModuleProvider> moduleProvider = nil;
+  if ([_delegate respondsToSelector:@selector(getModuleProvider:)]) {
+    moduleProvider = [_delegate getModuleProvider:moduleName];
+  }
+
+  if (RCTTurboModuleInteropEnabled() && ![self _isTurboModule:moduleName] && !moduleProvider) {
+    return nil;
+  }
+
+  if (moduleProvider) {
+    if ([moduleProvider conformsToProtocol:@protocol(RCTTurboModule)]) {
+      // moduleProvider is also a TM, we need to initialize objectiveC properties, like the dispatch queue
+      return (id<RCTModuleProvider>)[self _provideObjCModule:moduleName moduleProvider:moduleProvider];
+    }
+    // module is Cxx module
+    return moduleProvider;
+  }
+
+  // No module provider, the Module is registered without Codegen
+  return (id<RCTModuleProvider>)[self _provideObjCModule:moduleName moduleProvider:nil];
+}
+
 - (ModuleHolder *)_getOrCreateModuleHolder:(const char *)moduleName
 {
   std::lock_guard<std::mutex> guard(_moduleHoldersMutex);
@@ -499,7 +524,6 @@ typedef struct {
 
   return &_moduleHolders[moduleName];
 }
-
 /**
  * Given a name for a NativeModule, return an ObjC object which is the instance
  * of that NativeModule ObjC class. If no NativeModule exist with the provided name,
@@ -508,7 +532,7 @@ typedef struct {
  * Note: All NativeModule instances are cached, which means they're all long-lived
  * (for now).
  */
-- (id<RCTBridgeModule>)_provideObjCModule:(const char *)moduleName
+- (id<RCTBridgeModule>)_provideObjCModule:(const char *)moduleName moduleProvider:(id<RCTModuleProvider>)moduleProvider
 {
   if (strncmp("RCT", moduleName, 3) == 0) {
     moduleName = [[[NSString stringWithUTF8String:moduleName] substringFromIndex:3] UTF8String];
@@ -521,7 +545,10 @@ typedef struct {
   }
 
   TurboModulePerfLogger::moduleCreateStart(moduleName, moduleHolder->getModuleId());
-  id<RCTBridgeModule> module = [self _provideObjCModule:moduleName moduleHolder:moduleHolder shouldPerfLog:YES];
+  id<RCTBridgeModule> module = [self _provideObjCModule:moduleName
+                                           moduleHolder:moduleHolder
+                                          shouldPerfLog:YES
+                                         moduleProvider:moduleProvider];
 
   if (module) {
     TurboModulePerfLogger::moduleCreateEnd(moduleName, moduleHolder->getModuleId());
@@ -535,6 +562,7 @@ typedef struct {
 - (id<RCTBridgeModule>)_provideObjCModule:(const char *)moduleName
                              moduleHolder:(ModuleHolder *)moduleHolder
                             shouldPerfLog:(BOOL)shouldPerfLog
+                           moduleProvider:(id<RCTModuleProvider>)moduleProvider
 {
   bool shouldCreateModule = false;
 
@@ -558,7 +586,7 @@ typedef struct {
     /**
      * Step 2a: Resolve platform-specific class.
      */
-    Class moduleClass = [self _getModuleClassFromName:moduleName];
+    Class moduleClass = moduleProvider ? [moduleProvider class] : [self _getModuleClassFromName:moduleName];
 
     __block id<RCTBridgeModule> module = nil;
 
@@ -574,7 +602,30 @@ typedef struct {
       };
 
       if ([self _requiresMainQueueSetup:moduleClass]) {
-        RCTUnsafeExecuteOnMainQueueSync(work);
+        if (ReactNativeFeatureFlags::throwExceptionInsteadOfDeadlockOnTurboModuleSetupDuringSyncRenderIOS()) {
+          static int32_t modulesSettingUpOnMainQueueCount = 0;
+          std::unique_lock<std::mutex> lock{facebook::react::getMainThreadMutex(), std::defer_lock};
+
+          // This function can be recursive. If it's called recursively, we need to skip the lock.
+          // We can't use a recursive mutex instead because the lock is needed on multiple threads.
+          if (modulesSettingUpOnMainQueueCount == 0) {
+            if (!lock.try_lock()) {
+              NSString *reason = [NSString
+                  stringWithFormat:
+                      @"TurboModule %@ which requires main queue setup is initializing during sync rendering. This would have caused a deadlock. Please fix this by avoiding main queue setup or eager initializing this TurboModule.",
+                      NSStringFromClass(moduleClass)];
+              NSException *exception = [NSException exceptionWithName:@"UnsafeTurboModuleException"
+                                                               reason:reason
+                                                             userInfo:nil];
+              @throw exception;
+            }
+          }
+          modulesSettingUpOnMainQueueCount++;
+          RCTUnsafeExecuteOnMainQueueSync(work);
+          modulesSettingUpOnMainQueueCount--;
+        } else {
+          RCTUnsafeExecuteOnMainQueueSync(work);
+        }
       } else {
         work();
       }
@@ -586,7 +637,6 @@ typedef struct {
       moduleHolder->setModule(module);
       moduleHolder->endCreatingModule();
     }
-
     moduleHolder->cv().notify_all();
 
     return module;
@@ -797,7 +847,9 @@ typedef struct {
   }
 
   Class moduleClass = nil;
-  {
+  if (ReactNativeFeatureFlags::removeTurboModuleManagerDelegateMutex()) {
+    moduleClass = [_delegate getModuleClassFromName:moduleName];
+  } else {
     std::lock_guard<std::mutex> delegateGuard(_turboModuleManagerDelegateMutex);
     moduleClass = [_delegate getModuleClassFromName:moduleName];
   }
@@ -836,7 +888,9 @@ typedef struct {
   }
 
   id<RCTBridgeModule> module = nil;
-  {
+  if (ReactNativeFeatureFlags::removeTurboModuleManagerDelegateMutex()) {
+    module = (id<RCTBridgeModule>)[_delegate getModuleInstanceFromClass:moduleClass];
+  } else {
     std::lock_guard<std::mutex> delegateGuard(_turboModuleManagerDelegateMutex);
     module = (id<RCTBridgeModule>)[_delegate getModuleInstanceFromClass:moduleClass];
   }
@@ -969,7 +1023,7 @@ typedef struct {
     return nil;
   }
 
-  id<RCTBridgeModule> module = [self _provideObjCModule:moduleName];
+  id<RCTBridgeModule> module = [self _provideObjCModule:moduleName moduleProvider:nil];
 
   if (warnOnLookupFailure && !module) {
     RCTLogError(@"Unable to find module for %@", [NSString stringWithUTF8String:moduleName]);
@@ -1035,7 +1089,8 @@ typedef struct {
      */
     id<RCTBridgeModule> module = [self _provideObjCModule:moduleName.c_str()
                                              moduleHolder:moduleHolder
-                                            shouldPerfLog:NO];
+                                            shouldPerfLog:NO
+                                           moduleProvider:nil];
 
     if ([module respondsToSelector:@selector(invalidate)]) {
       dispatch_queue_t methodQueue = (dispatch_queue_t)objc_getAssociatedObject(module, &kAssociatedMethodQueueKey);

package/ReactCommon/react/nativemodule/defaults/DefaultTurboModules.cpp

@@ -11,7 +11,7 @@
 #include <react/nativemodule/idlecallbacks/NativeIdleCallbacks.h>
 #include <react/nativemodule/microtasks/NativeMicrotasks.h>
 
-#ifdef HERMES_ENABLE_DEBUGGER
+#ifdef REACT_NATIVE_DEBUGGER_ENABLED_DEVONLY
 #include <react/nativemodule/devtoolsruntimesettings/DevToolsRuntimeSettingsModule.h>
 #endif
 
@@ -36,7 +36,7 @@ namespace facebook::react {
     return std::make_shared<NativeDOM>(jsInvoker);
   }
 
-#ifdef HERMES_ENABLE_DEBUGGER
+#ifdef REACT_NATIVE_DEBUGGER_ENABLED_DEVONLY
   if (name == DevToolsRuntimeSettingsModule::kModuleName) {
     return std::make_shared<DevToolsRuntimeSettingsModule>(jsInvoker);
   }

package/ReactCommon/react/nativemodule/defaults/React-defaultsnativemodule.podspec

@@ -53,11 +53,7 @@ Pod::Spec.new do |s|
   s.dependency "RCT-Folly"
   s.dependency "React-jsi"
   s.dependency "React-jsiexecutor"
-  if ENV["USE_HERMES"] == nil || ENV["USE_HERMES"] == "1"
-    s.dependency "hermes-engine"
-  else
-    s.dependency "React-jsc"
-  end
+  depend_on_js_engine(s)
 
   s.dependency "React-domnativemodule"
   s.dependency "React-featureflagsnativemodule"

package/ReactCommon/react/nativemodule/dom/CMakeLists.txt

@@ -27,6 +27,6 @@ target_link_libraries(react_nativemodule_dom
         rrc_root
         react_codegen_rncore
         react_cxxreact
-        react_render_dom
-        react_render_uimanager
+        react_renderer_dom
+        react_renderer_uimanager
 )