Connect the classes for C++ Module registration to TMManagerDelegate (facebook#49611)

Summary:
Pull Request resolved: facebook#49611

This Change connects the pod created previously to the `RCTTuboModuleManager` so that it can ask the delegate about the CxxTurboModuleProviders.

We had to introduce a `RCTFullTurboModuleManagerDelegate` that implements both the old `TurboModuleManagerDelegate` and the new Swift compatible one.

## Problem
As of today, it is not possible to create a pure C++ TM and to register it through a Swift AppDelegate

## Solution
We can create a pod that can be imported in a Swift AppDelegate and that offer some pure Objective-C classes.

These classes contains a provider that can be instantiated in Swift.

The TurboModule manager delegate will ask the AppDelegate about the presence of some provider that can instantiate a pure C++ turbomodule with a given name.

The provider has an empty interface, but the implementation contains a function that can actually instantiate the TM. The function is implemented in an Objective-C++ class that imports the pure C++ turbomodule and creates it.

The TMManager extends the provider through a category to attaach the signature of the function that is implemented by the provider.

The last diff in this stack contains an exaple on how to implement this.

## Changelog:
[iOS][Added] - Added the React-SwiftCompatibleNativeModules pod

Reviewed By: javache

Differential Revision: D70012142

fbshipit-source-id: db96c4cd3cdd1062b12f11131b7c6c51ecd74bc7

Author: cipolleschi

packages/react-native/Libraries/AppDelegate/RCTDefaultReactNativeFactoryDelegate.mm

@@ -90,6 +90,13 @@ - (void)hostDidStart:(RCTHost *)host
 {
 }
 
+- (nullable id<RCTModuleProvider>)getModuleProvider:(const char *)name
+{
+  //  NSString *providerName = [NSString stringWithCString:name encoding:NSUTF8StringEncoding];
+  //  return self.dependencyProvider ? self.dependencyProvider.moduleProviders[providerName] : nullptr;
+  return nil;
+}
+
 - (std::shared_ptr<facebook::react::TurboModule>)getTurboModule:(const std::string &)name
                                                       jsInvoker:(std::shared_ptr<facebook::react::CallInvoker>)jsInvoker
 {

packages/react-native/Libraries/AppDelegate/RCTReactNativeFactory.mm

@@ -170,6 +170,14 @@ - (Class)getModuleClassFromName:(const char *)name
 #endif
 }
 
+- (nullable id<RCTModuleProvider>)getModuleProvider:(const char *)name
+{
+  if ([_delegate respondsToSelector:@selector(getModuleProvider:)]) {
+    return [_delegate getModuleProvider:name];
+  }
+  return nil;
+}
+
 - (std::shared_ptr<facebook::react::TurboModule>)getTurboModule:(const std::string &)name
                                                       jsInvoker:(std::shared_ptr<facebook::react::CallInvoker>)jsInvoker
 {

packages/react-native/ReactCommon/react/nativemodule/core/platform/ios/ReactCommon/RCTTurboModule.h

@@ -176,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

packages/react-native/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.
  */

packages/react-native/ReactCommon/react/nativemodule/core/platform/ios/ReactCommon/RCTTurboModuleManager.mm

@@ -340,8 +340,7 @@ - (instancetype)initWithBridgeProxy:(RCTBridgeProxy *)bridgeProxy
   /**
    * 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);
 
@@ -351,31 +350,28 @@ - (instancetype)initWithBridgeProxy:(RCTBridgeProxy *)bridgeProxy
     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.
@@ -393,7 +389,7 @@ - (instancetype)initWithBridgeProxy:(RCTBridgeProxy *)bridgeProxy
   if ([module respondsToSelector:@selector(getTurboModule:)]) {
     ObjCTurboModule::InitParams params = {
         .moduleName = moduleName,
-        .instance = module,
+        .instance = (id<RCTBridgeModule>)module,
         .jsInvoker = _jsInvoker,
         .nativeMethodCallInvoker = nativeMethodCallInvoker,
         .isSyncModule = methodQueue == RCTJSThread,
@@ -430,7 +426,8 @@ - (instancetype)initWithBridgeProxy:(RCTBridgeProxy *)bridgeProxy
   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);
 
@@ -475,6 +472,8 @@ - (instancetype)initWithBridgeProxy:(RCTBridgeProxy *)bridgeProxy
   return turboModule;
 }
 
+#pragma mark - Private Methods
+
 - (BOOL)_isTurboModule:(const char *)moduleName
 {
   Class moduleClass = [self _getModuleClassFromName:moduleName];
@@ -492,6 +491,27 @@ - (BOOL)_isLegacyModuleClass:(Class)moduleClass
   return moduleClass != nil && (!isTurboModuleClass(moduleClass) || [moduleClass isSubclassOfClass:RCTCxxModule.class]);
 }
 
+- (id<RCTModuleProvider>)_moduleProviderForName:(const char *)moduleName
+{
+  id<RCTModuleProvider> moduleProvider = [_delegate getModuleProvider:moduleName];
+  BOOL isTurboModule = [self _isTurboModule:moduleName];
+  if (RCTTurboModuleEnabled() && !isTurboModule && !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);
@@ -501,7 +521,6 @@ - (ModuleHolder *)_getOrCreateModuleHolder:(const char *)moduleName
 
   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,
@@ -510,7 +529,7 @@ - (ModuleHolder *)_getOrCreateModuleHolder:(const char *)moduleName
  * 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];
@@ -523,7 +542,10 @@ - (ModuleHolder *)_getOrCreateModuleHolder:(const char *)moduleName
   }
 
   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());
@@ -537,6 +559,7 @@ - (ModuleHolder *)_getOrCreateModuleHolder:(const char *)moduleName
 - (id<RCTBridgeModule>)_provideObjCModule:(const char *)moduleName
                              moduleHolder:(ModuleHolder *)moduleHolder
                             shouldPerfLog:(BOOL)shouldPerfLog
+                           moduleProvider:(id<RCTModuleProvider>)moduleProvider
 {
   bool shouldCreateModule = false;
 
@@ -560,7 +583,7 @@ - (ModuleHolder *)_getOrCreateModuleHolder:(const char *)moduleName
     /**
      * Step 2a: Resolve platform-specific class.
      */
-    Class moduleClass = [self _getModuleClassFromName:moduleName];
+    Class moduleClass = moduleProvider ? [moduleProvider class] : [self _getModuleClassFromName:moduleName];
 
     __block id<RCTBridgeModule> module = nil;
 
@@ -611,7 +634,6 @@ - (ModuleHolder *)_getOrCreateModuleHolder:(const char *)moduleName
       moduleHolder->setModule(module);
       moduleHolder->endCreatingModule();
     }
-
     moduleHolder->cv().notify_all();
 
     return module;
@@ -998,7 +1020,7 @@ - (id)moduleForName:(const char *)moduleName warnOnLookupFailure:(BOOL)warnOnLoo
     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]);
@@ -1064,7 +1086,8 @@ - (void)_invalidateModules
      */
     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);

packages/react-native/ReactCommon/react/runtime/platform/ios/ReactCommon/RCTInstance.mm

@@ -235,6 +235,14 @@ - (Class)getModuleClassFromName:(const char *)name
   return @[];
 }
 
+- (nullable id<RCTModuleProvider>)getModuleProvider:(const char *)name
+{
+  if ([_appTMMDelegate respondsToSelector:@selector(getModuleProvider:)]) {
+    return [_appTMMDelegate getModuleProvider:name];
+  }
+  return nil;
+}
+
 #pragma mark - Private
 
 - (void)_start