// 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>
/**
 * Place this macro in your class implementation to automatically register
 * your module with the bridge when it loads. The optional js_name argument
 * will be used as the JS module name. If omitted, the JS module name will
 * match the Objective-C class name.
 */
#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 數(shù)組
    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 是否實現(xiàn) -batchDidComplete 方法
    _implementsBatchDidComplete = [_moduleClass instancesRespondToSelector:@selector(batchDidComplete)];
    // 2. instance 是否實現(xiàn) -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. 沒實現(xiàn) requires 時,
        //  - 是否有自定義 -init 初始化方法
        //  - _hasConstantsToExport || hasCustomInit 時, 需要main queue setup
        const BOOL hasCustomInit = !_instance && [_moduleClass instanceMethodForSelector:@selector(init)] != objectInitMethod;
        _requiresMainQueueSetup = _hasConstantsToExport || hasCustomInit;
    }
}

/// RCTCxxBridge 處理所有的 RCTModuleData, 對它們調(diào)用 `moduleData instance` 方法的過程
- (void)_prepareModulesWithDispatchGroup:(dispatch_group_t)dispatchGroup {
    // 1. 根據(jù)是否有 dispatchGroup 決定后續(xù)進行 `module instance` 是否異步進行
    BOOL initializeImmediately = NO;
    if (dispatchGroup == NULL) {
        RCTAssertMainQueue();
        initializeImmediately = YES;
    }
    // 2. _moduleDataByID 中緩存著所有的`module class`構(gòu)造的`RCTModuleData`, 遍歷它們, 構(gòu)造一個 block, 根據(jù) initializeImmediately 參數(shù), 決定是否立即執(zhí)行
    for (RCTModuleData *moduleData in _moduleDataByID) {
        // 3. 注意, 強制 moduleData.requiresMainQueueSetup, 也就是`module instance`強制在main queue 進行`setup`
        if (moduleData.requiresMainQueueSetup) {
            // 4. `module instance setup` 的過程, 直接主動調(diào)用 [moduleData instance], 并強制觸發(fā) `[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個數(shù)
            _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() 調(diào)用實例化
                _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. 調(diào)用 module instance 中的 initialize 方法, 如果實現(xiàn)了的話
        if (shouldSetup) {
            [self _initializeModule];
        }
    } // instanceLock 釋放
    // 6. 什么時候通知全局 module instance 完成!!!
    if (_bridge.moduleSetupComplete) {
        // 6.1 大部分 module instance 是在 moduleSetupComplete = ture 執(zhí)行, 會主動通知全局
        [self finishSetupForInstance];
    } else {  
        // 6.2 少部分在 moduleSetupComplete = false 執(zhí)行, 標記 _requiresMainQueueSetup = NO, 這樣 module instance 實際只setup 一半, lazy instance 使用時, `_bridge.moduleSetupComplete` 一定為 true, 再進行通知, 調(diào)用 `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 沒有指定, 創(chuàng)建 子線程, 作為 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` 主動實現(xiàn) methodQueue, 使用KVC設置給`module instance` methodQueue!!!
            if (implementsMethodQueue) {
                @try {
                    [(id)_instance setValue:_methodQueue forKey:@"methodQueue"];
                } @catch (NSException *exception) {
                    RCTLogError();
                }
            }
      }
}
// 如果 `module instance` 實現(xiàn) `RCTBridgeModule`協(xié)議的`-initialize`方法, 主動調(diào)用, 并標記`_isInitialized`執(zhí)行過
- (void)_initializeModule {
    if (!_isInitialized && [_instance respondsToSelector:@selector(initialize)]) {
        _isInitialized = YES;
        [(id<RCTInitializing>)_instance initialize];
    }
}
// 如果執(zhí)行這個方法, 通知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)}];
    }
}