iOS RN启动中管理Native Module详解

// 1. 全局注册中心, RN 用 RCTModuleClasses 来持有全局注册的 native module
static NSMutableArray<Class> *RCTModuleClasses;
static dispatch_queue_t RCTModuleClassesSyncQueue;
// 2. sync 读 - 全局 RCTModuleClasses
NSArray<Class> *RCTGetModuleClasses(void) {
    __block NSArray<Class> *result;
    dispatch_sync(RCTModuleClassesSyncQueue, ^{
        result = [RCTModuleClasses copy];
    });
    return result;
}
// 3. barrier async 写
void RCTRegisterModule(Class moduleClass) {
    static dispatch_once_t onceToken;
    dispatch_once(&onceToken, ^{
        RCTModuleClasses = [NSMutableArray new];
        RCTModuleClassesSyncQueue = dispatch_queue_create("com.facebook.React.ModuleClassesSyncQueue", DISPATCH_QUEUE_CONCURRENT); // sync 读, barrier_async 写
    });
    dispatch_barrier_async(RCTModuleClassesSyncQueue, ^{
        [RCTModuleClasses addObject:moduleClass];
    });
}

@protocol RCTBridgeModule <NSObject>

#define RCT_EXPORT_MODULE(js_name)          \
  RCT_EXTERN void RCTRegisterModule(Class); \
  +(NSString *)moduleName                   \
  {                                         \
    return @ #js_name;                      \
  }                                         \
  +(void)load                               \
  {                                         \
    RCTRegisterModule(self);                \
  }
...
@end

//(void)[self _initializeModules:RCTGetModuleClasses() withDispatchGroup:prepareBridge lazilyDiscovered:NO];
- (NSArray<RCTModuleData *> *)_initializeModules:(NSArray<Class> *)modules
                               withDispatchGroup:(dispatch_group_t)dispatchGroup
                                lazilyDiscovered:(BOOL)lazilyDiscovered {
    /// 1. modules Class => 包装成中间管理类 RCTModuleData
    /// 2. 然后将 RCTModuleData 对象放到 bridge 的几个特定容器中管理
    NSArray<RCTModuleData *> *moduleDataById = [self _registerModulesForClasses:modules lazilyDiscovered:lazilyDiscovered];
    if (lazilyDiscovered) {
        ...
    } else { 
        // 初始化时候, 会走这里
        /// 3. 处理 moduleData.hasInstance 的场景, 在 bridge._moduleSetupComplete 之前, module强制进行instance实例化, 并管理在 moduleData 中
        for (RCTModuleData *moduleData in _moduleDataByID) {
            if (moduleData.hasInstance && (!moduleData.requiresMainQueueSetup || RCTIsMainQueue())) {
                (void)[moduleData instance];
            }
        }
        /// 4. 标记 bridge 中的 module 完成 setup 工作
        _moduleSetupComplete = YES;
        /// 5. 对 bridge 中的 module 异步 preapre
        [self _prepareModulesWithDispatchGroup:dispatchGroup];
    }
    /// 6. 返回所有的 moduleData 数组
    return moduleDataById;
}

- (instancetype)initWithModuleClass:(Class)moduleClass
                     moduleProvider:(RCTBridgeModuleProvider)moduleProvider
                             bridge:(RCTBridge *)bridge
                     moduleRegistry:(RCTModuleRegistry *)moduleRegistry
            viewRegistry_DEPRECATED:(RCTViewRegistry *)viewRegistry_DEPRECATED
                      bundleManager:(RCTBundleManager *)bundleManager
                  callableJSModules:(RCTCallableJSModules *)callableJSModules
{
  if (self = [super init]) {
    _bridge = bridge;
    _moduleClass = moduleClass;
    _moduleProvider = [moduleProvider copy];
    _moduleRegistry = moduleRegistry;
    _viewRegistry_DEPRECATED = viewRegistry_DEPRECATED;
    _bundleManager = bundleManager;
    _callableJSModules = callableJSModules;
    [self setUp];
  }
  return self;
}
- (void)setUp {
    // 1. instance 是否实现 -batchDidComplete 方法
    _implementsBatchDidComplete = [_moduleClass instancesRespondToSelector:@selector(batchDidComplete)];
    // 2. instance 是否实现 -batchDidComplete 方法
    _implementsPartialBatchDidFlush = [_moduleClass instancesRespondToSelector:@selector(partialBatchDidFlush)];
    // 3. instance 是否是用常量需要暴露出去
    _hasConstantsToExport = [_moduleClass instancesRespondToSelector:@selector(constantsToExport)];
    // 4. module 是否强制在 main queue 中 setup
    const BOOL implementsRequireMainQueueSetup = [_moduleClass respondsToSelector:@selector(requiresMainQueueSetup)];
    if (implementsRequireMainQueueSetup) {
        _requiresMainQueueSetup = [_moduleClass requiresMainQueueSetup];
    } else {
        ...
        // 5. 没实现 requires 时,
        //  - 是否有自定义 -init 初始化方法
        //  - _hasConstantsToExport || hasCustomInit 时, 需要main queue setup
        const BOOL hasCustomInit = !_instance && [_moduleClass instanceMethodForSelector:@selector(init)] != objectInitMethod;
        _requiresMainQueueSetup = _hasConstantsToExport || hasCustomInit;
    }
}

/// RCTCxxBridge 处理所有的 RCTModuleData, 对它们调用 `moduleData instance` 方法的过程
- (void)_prepareModulesWithDispatchGroup:(dispatch_group_t)dispatchGroup {
    // 1. 根据是否有 dispatchGroup 决定后续进行 `module instance` 是否异步进行
    BOOL initializeImmediately = NO;
    if (dispatchGroup == NULL) {
        RCTAssertMainQueue();
        initializeImmediately = YES;
    }
    // 2. _moduleDataByID 中缓存着所有的`module class`构造的`RCTModuleData`, 遍历它们, 构造一个 block, 根据 initializeImmediately 参数, 决定是否立即执行
    for (RCTModuleData *moduleData in _moduleDataByID) {
        // 3. 注意, 强制 moduleData.requiresMainQueueSetup, 也就是`module instance`强制在main queue 进行`setup`
        if (moduleData.requiresMainQueueSetup) {
            // 4. `module instance setup` 的过程, 直接主动调用 [moduleData instance], 并强制触发 `[moduleData gatherConstants]`, 收集 instance 要暴露给 JS 的常量Dictionary
            dispatch_block_t block = ^{
                if (self.valid && ![moduleData.moduleClass isSubclassOfClass:[RCTCxxModule class]]) {
                    (void)[moduleData instance];
                    if (!RCTIsMainQueueExecutionOfConstantsToExportDisabled()) {
                        [moduleData gatherConstants];
                    }
                }
            };
            if (initializeImmediately && RCTIsMainQueue()) {
                block();
            } else {
                if (dispatchGroup) {
                    dispatch_group_async(dispatchGroup, dispatch_get_main_queue(), block);
                }
            }
            // 5. RCTCxxBridge 中 记录所有在  main queue 中 进行 `module instance` 的module个数
            _modulesInitializedOnMainQueue++;
        }
    }
}

- (id<RCTBridgeModule>)instance {
    ...
    // 1. _setupComplete 标记 module instance 是否 setup 完成
    if(!_setupComplete) {
        [self setUpInstanceAndBridge:requestId];
    }
    ...
    return _instance;
}
- (void)setUpInstanceAndBridge:(int32_t)requestId {
    NSString *moduleName = [self name];
    // 注意: 使用 instanceLock 保护 _instance 成员
    {
        std::unique_lock<std::mutex> lock(_instanceLock);
        // 1. 判断 moduleData._setupComplete 是否完成 setup
        BOOL shouldSetup = !_setupComplete && _bridge.valid;
        // 2. 如果 moduleData._instance 没实例化, 使用 _moduleProvider() 实例化
        // - 如果实例化失败, 也需要标记 _setupComplete = true
        if (shouldSetup) {
            if (!_instance) {
                // 使用 moduleProvider() 调用实例化
                _instance = _moduleProvider ? _moduleProvider() : nil;
                if (!_instance) {
                    _setupComplete = YES;
                }
            }
        }
        // 3. 将常见属性(bridge, moduleRegistry...)注入到 module instnace 中!
        if (shouldSetup) {
            [self setBridgeForInstance];
            [self setModuleRegistryForInstance];
            [self setViewRegistryForInstance];
            [self setBundleManagerForInstance];
            [self setCallableJSModulesForInstance];
        }
        // 4. 初始化 module instance 的 methodQueue
        [self setUpMethodQueue];
        // 5. 调用 module instance 中的 initialize 方法, 如果实现了的话
        if (shouldSetup) {
            [self _initializeModule];
        }
    } // instanceLock 释放
    // 6. 什么时候通知全局 module instance 完成!!!
    if (_bridge.moduleSetupComplete) {
        // 6.1 大部分 module instance 是在 moduleSetupComplete = ture 执行, 会主动通知全局
        [self finishSetupForInstance];
    } else {  
        // 6.2 少部分在 moduleSetupComplete = false 执行, 标记 _requiresMainQueueSetup = NO, 这样 module instance 实际只setup 一半, lazy instance 使用时, `_bridge.moduleSetupComplete` 一定为 true, 再进行通知, 调用 `finishSetupForInstance`方法
        _requiresMainQueueSetup = NO;
    }
}
- (void)setUpMethodQueue {
    if (_instance && !_methodQueue && _bridge.valid) {
        // 1. instance 是否主动指定 methodQueue, moduleData持有
        BOOL implementsMethodQueue = [_instance respondsToSelector:@selector(methodQueue)];
        if (implementsMethodQueue && _bridge.valid) {
            _methodQueue = _instance.methodQueue;
        }
        // 2. instance 没有指定, 创建 子线程, 作为 methodQueue
        if (!_methodQueue && _bridge.valid) {
            _queueName = [NSString stringWithFORMat:@"com.facebook.react.%@Queue", self.name];
            _methodQueue = dispatch_queue_create(_queueName.UTF8String, DISPATCH_QUEUE_SERIAL);
            // 3. 如果`module instance` 主动实现 methodQueue, 使用KVC设置给`module instance` methodQueue!!!
            if (implementsMethodQueue) {
                @try {
                    [(id)_instance setValue:_methodQueue forKey:@"methodQueue"];
                } @catch (NSException *exception) {
                    RCTLogError();
                }
            }
      }
}
// 如果 `module instance` 实现 `RCTBridgeModule`协议的`-initialize`方法, 主动调用, 并标记`_isInitialized`执行过
- (void)_initializeModule {
    if (!_isInitialized && [_instance respondsToSelector:@selector(initialize)]) {
        _isInitialized = YES;
        [(id<RCTInitializing>)_instance initialize];
    }
}
// 如果执行这个方法, 通知bridge + 全局: 这个 module `setupComplete`!!!
- (void)finishSetupForInstance {
    if (!_setupComplete && _instance) {
        _setupComplete = YES;
        [_bridge registerModuleForFrameUpdates:_instance withModuleData:self];
        [[NSNotificationCenter defaultCenter] postNotificationName:RCTDidInitializeModuleNotification object:_bridge userInfo:@{@"module" : _instance, @"bridge" : RCTNullIfNil(_bridge.parentBridge)}];
    }
}