@bm-fe/react-native-multi-bundle 1.0.0-beta.3 → 1.0.0-beta.5

package/INTEGRATION.md

@@ -120,25 +120,90 @@ class MainApplication : Application(), ReactApplication {
 
 </details>
 
-### iOS
+### iOS（自动链接，无需手动配置）
 
-#### 1. 复制 Native 模块文件
+#### 自动链接工作原理
+
+安装包后，React Native CLI 和 CocoaPods 会自动：
+1. 读取包中的 `react-native-multi-bundle.podspec`
+2. 将 `ModuleLoader` 原生模块添加到项目中
+3. 在构建时自动集成
+
+#### 安装依赖
+
+安装 npm 包后，运行 pod install：
+
+```bash
+cd ios && pod install
+```
+
+#### 验证自动链接
+
+安装包后，可以通过以下命令验证自动链接是否生效：
+
+```bash
+npx react-native config
+```
+
+在输出中应该能看到 `@bm-fe/react-native-multi-bundle` 的 iOS 配置信息。
+
+#### 准备 Bundles 目录
+
+确保 iOS 项目中有 `Bundles` 目录用于存放 bundle 文件：
+
+1. 在 Xcode 中，右键点击项目 → New Group，创建 `Bundles` 目录
+2. 或者在终端中创建：
+   ```bash
+   mkdir -p ios/YourProject/Bundles/modules
+   ```
 
-将以下文件从 `templates/native/ios/` 添加到你的 iOS 项目：
+3. **重要**：确保 `Bundles` 目录已添加到 Xcode 项目的 Resources 中：
+   - 在 Xcode 中，右键点击 `Bundles` 目录 → Add Files to "YourProject"
+   - 确保 "Create folder references" 已选中（蓝色文件夹图标）
+   - 这样 bundle 文件才会被打包到 app 中
+
+#### Bundle 文件结构
+
+构建完成后，iOS bundle 文件应放置在：
+
+```
+ios/YourProject/Bundles/
+├── bundle-manifest.json
+├── main.jsbundle
+└── modules/
+    ├── home.jsbundle
+    ├── details.jsbundle
+    └── settings.jsbundle
+```
+
+#### 手动集成（可选，仅在自动链接不工作时使用）
+
+<details>
+<summary>点击展开手动集成步骤</summary>
+
+##### 1. 复制 Native 模块文件
+
+将以下文件从 `node_modules/@bm-fe/react-native-multi-bundle/ios/ModuleLoader/` 复制到你的 iOS 项目：
 
 - `ModuleLoaderModule.h`
-- `ModuleLoaderModule.m`
+- `ModuleLoaderModule.mm`
 
 在 Xcode 中：
 1. 右键点击项目 → Add Files to "YourProject"
 2. 选择这两个文件
 3. 确保 "Copy items if needed" 已勾选
 
-#### 2. 注册模块
+##### 2. 验证编译
 
 iOS 端的模块会自动注册（通过 `RCT_EXPORT_MODULE`），无需额外配置。
 
-**注意**：iOS 端的 bundle 加载实现可能需要根据你的具体需求调整。当前模板提供了基础框架。
+重新构建项目：
+
+```bash
+npx react-native run-ios
+```
+
+</details>
 
 ## 初始化多 Bundle 系统
 

package/android/moduleloader/src/main/java/com/bitmart/exchange/module/loader/ModuleLoaderModule.kt

@@ -23,8 +23,7 @@ import java.io.InputStreamReader
 
 /**
  * 简单的 Bundle 加载模块
- * 用于在同一个 JS 运行时中动态加载子 bundle
- * 
+ *
  * 新架构下通过反射获取 ReactInstance，然后调用 loadJSBundle 方法
  * 注意：ReactInstance 是 internal 类，必须完全通过反射操作
  */
@@ -34,11 +33,11 @@ class ModuleLoaderModule(private val reactContext: ReactApplicationContext) : Re
     companion object {
         const val NAME = "ModuleLoader"
         private const val TAG = "ModuleLoaderModule"
-        
+
         // 缓存反射获取的类和方法，避免重复反射
         private var reactHostImplClass: Class<*>? = null
         private var reactInstanceClass: Class<*>? = null
-        
+
         init {
             try {
                 reactHostImplClass = Class.forName("com.facebook.react.runtime.ReactHostImpl")
@@ -49,9 +48,6 @@ class ModuleLoaderModule(private val reactContext: ReactApplicationContext) : Re
         }
     }
 
-    // 记录已加载的 bundle，避免重复加载
-    private val loadedBundles = mutableSetOf<String>()
-
     // 协程作用域，用于异步操作
     private val moduleScope = CoroutineScope(SupervisorJob() + Dispatchers.Main)
 
@@ -59,71 +55,77 @@ class ModuleLoaderModule(private val reactContext: ReactApplicationContext) : Re
 
     /**
      * 加载子 bundle
-     * 
-     * @param bundleId 模块 ID（如 "home", "details", "settings"）
-     * @param bundlePath bundle 文件路径（如 "modules/home.bundle"）
-     * @param promise 加载结果回调
+     *
+     * 加载策略（按优先级）：
+     * 1. 旧架构：CatalystInstance（当前 RN 0.79.5）
+     * 2. 新架构：ReactHostImpl（完全 Bridgeless）
      */
     @ReactMethod
     fun loadBusinessBundle(bundleId: String, bundlePath: String, promise: Promise) {
         Log.d(TAG, "loadBusinessBundle: bundleId=$bundleId, bundlePath=$bundlePath")
 
-        // 已经加载过的 bundle，直接返回成功
-        if (loadedBundles.contains(bundleId)) {
-            Log.d(TAG, "Bundle already loaded: $bundleId")
-            val result = Arguments.createMap().apply {
-                putBoolean("success", true)
-            }
-            promise.resolve(result)
+        // 1️⃣ 优先：旧架构 CatalystInstance
+        if (tryLoadWithCatalystInstance(bundleId, bundlePath, promise)) {
             return
         }
 
-        try {
-            // 获取 ReactApplication
-            val application = reactContext.applicationContext as? android.app.Application
-            val reactApplication = application as? com.facebook.react.ReactApplication
-            
-            if (reactApplication == null) {
-                Log.e(TAG, "Application is not a ReactApplication")
-                val result = Arguments.createMap().apply {
-                    putBoolean("success", false)
-                    putString("errorMessage", "Application is not a ReactApplication")
-                }
-                promise.resolve(result)
-                return
-            }
+        // 2️⃣ 其次：新架构 ReactHostImpl
+        if (tryLoadWithReactHost(bundleId, bundlePath, promise)) {
+            return
+        }
 
-            val reactHost = reactApplication.reactHost
-            
-            // 构建 assets 路径
-            val assetUrl = "assets://$bundlePath"
-            Log.d(TAG, "Loading bundle from: $assetUrl")
-
-            // 创建 JSBundleLoader
-            val bundleLoader = JSBundleLoader.createAssetLoader(
-                reactContext,
-                assetUrl,
-                false  // 异步加载
-            )
-
-            // 检查是否是新架构（ReactHostImpl）
-            val hostImplClass = reactHostImplClass
-            if (reactHost != null && hostImplClass != null && hostImplClass.isInstance(reactHost)) {
-                loadBundleViaReflection(reactHost, bundleLoader, bundleId, promise)
-            } else {
-                // 旧架构回退方案：使用 CatalystInstance
-                Log.d(TAG, "Falling back to CatalystInstance (old architecture)")
-                loadBundleWithCatalystInstance(bundleId, bundlePath, promise)
-            }
+        // 都失败
+        Log.e(TAG, "No suitable runtime found")
+        promise.resolve(Arguments.createMap().apply {
+            putBoolean("success", false)
+            putString("errorMessage", "No CatalystInstance or ReactHostImpl available")
+        })
+    }
+
+    /**
+     * 尝试使用旧架构 CatalystInstance 加载
+     * @return true 如果成功处理（包括成功加载或失败），false 如果 CatalystInstance 不可用
+     */
+    @Suppress("DEPRECATION")
+    private fun tryLoadWithCatalystInstance(bundleId: String, bundlePath: String, promise: Promise): Boolean {
+        val catalystInstance = reactContext.catalystInstance ?: return false
 
+        Log.d(TAG, "Using CatalystInstance (same JS Runtime guaranteed)")
+        try {
+            val assetPath = "assets://$bundlePath"
+            catalystInstance.loadScriptFromAssets(reactContext.assets, assetPath, false)
+            Log.d(TAG, "Bundle loaded successfully: $bundleId")
+            promise.resolve(Arguments.createMap().apply { putBoolean("success", true) })
         } catch (e: Exception) {
             Log.e(TAG, "Failed to load bundle: $bundleId", e)
-            val result = Arguments.createMap().apply {
+            promise.resolve(Arguments.createMap().apply {
                 putBoolean("success", false)
                 putString("errorMessage", e.message ?: "Unknown error")
-            }
-            promise.resolve(result)
+            })
+        }
+        return true
+    }
+
+    /**
+     * 尝试使用新架构 ReactHostImpl 加载
+     * @return true 如果成功处理，false 如果 ReactHostImpl 不可用
+     */
+    private fun tryLoadWithReactHost(bundleId: String, bundlePath: String, promise: Promise): Boolean {
+        val application = reactContext.applicationContext as? android.app.Application
+        val reactApplication = application as? com.facebook.react.ReactApplication ?: return false
+
+        val reactHost = reactApplication.reactHost
+        val hostImplClass = reactHostImplClass
+
+        if (reactHost == null || hostImplClass == null || !hostImplClass.isInstance(reactHost)) {
+            return false
         }
+
+        Log.d(TAG, "Using ReactHostImpl (new architecture)")
+        val assetUrl = "assets://$bundlePath"
+        val bundleLoader = JSBundleLoader.createAssetLoader(reactContext, assetUrl, false)
+        loadBundleViaReflection(reactHost, bundleLoader, bundleId, promise)
+        return true
     }
 
     /**
@@ -138,12 +140,12 @@ class ModuleLoaderModule(private val reactContext: ReactApplicationContext) : Re
         try {
             val hostImplClass = reactHostImplClass ?: throw Exception("ReactHostImpl class not found")
             val instanceClass = reactInstanceClass ?: throw Exception("ReactInstance class not found")
-            
+
             // 通过反射获取 private 的 reactInstance 字段
             val reactInstanceField = hostImplClass.getDeclaredField("reactInstance")
             reactInstanceField.isAccessible = true
             val reactInstance = reactInstanceField.get(reactHost)
-            
+
             if (reactInstance == null) {
                 Log.e(TAG, "ReactInstance is null")
                 val result = Arguments.createMap().apply {
@@ -157,59 +159,16 @@ class ModuleLoaderModule(private val reactContext: ReactApplicationContext) : Re
             // 通过反射调用 ReactInstance.loadJSBundle 方法
             val loadJSBundleMethod = instanceClass.getMethod("loadJSBundle", JSBundleLoader::class.java)
             loadJSBundleMethod.invoke(reactInstance, bundleLoader)
-            
-            // 标记为已加载
-            loadedBundles.add(bundleId)
+
             Log.d(TAG, "Bundle loaded successfully via ReactInstance: $bundleId")
 
             val result = Arguments.createMap().apply {
                 putBoolean("success", true)
             }
             promise.resolve(result)
-            
-        } catch (e: Exception) {
-            Log.e(TAG, "Failed to load bundle via ReactInstance: $bundleId", e)
-            val result = Arguments.createMap().apply {
-                putBoolean("success", false)
-                putString("errorMessage", e.message ?: "Unknown error")
-            }
-            promise.resolve(result)
-        }
-    }
-
-    /**
-     * 旧架构回退方案：使用 CatalystInstance 加载 bundle
-     */
-    @Suppress("DEPRECATION")
-    private fun loadBundleWithCatalystInstance(bundleId: String, bundlePath: String, promise: Promise) {
-        try {
-            val catalystInstance = reactContext.catalystInstance
-            if (catalystInstance == null) {
-                Log.e(TAG, "CatalystInstance is null")
-                val result = Arguments.createMap().apply {
-                    putBoolean("success", false)
-                    putString("errorMessage", "CatalystInstance not available")
-                }
-                promise.resolve(result)
-                return
-            }
-
-            val assetPath = "assets://$bundlePath"
-            catalystInstance.loadScriptFromAssets(
-                reactContext.assets,
-                assetPath,
-                false
-            )
 
-            loadedBundles.add(bundleId)
-            Log.d(TAG, "Bundle loaded successfully via CatalystInstance: $bundleId")
-
-            val result = Arguments.createMap().apply {
-                putBoolean("success", true)
-            }
-            promise.resolve(result)
         } catch (e: Exception) {
-            Log.e(TAG, "Failed to load bundle via CatalystInstance: $bundleId", e)
+            Log.e(TAG, "Failed to load bundle via ReactInstance: $bundleId", e)
             val result = Arguments.createMap().apply {
                 putBoolean("success", false)
                 putString("errorMessage", e.message ?: "Unknown error")
@@ -218,24 +177,6 @@ class ModuleLoaderModule(private val reactContext: ReactApplicationContext) : Re
         }
     }
 
-    /**
-     * 检查 bundle 是否已加载
-     */
-    @ReactMethod
-    fun isBundleLoaded(bundleId: String, promise: Promise) {
-        promise.resolve(loadedBundles.contains(bundleId))
-    }
-
-    /**
-     * 获取已加载的 bundle 列表
-     */
-    @ReactMethod
-    fun getLoadedBundles(promise: Promise) {
-        val array = Arguments.createArray()
-        loadedBundles.forEach { array.pushString(it) }
-        promise.resolve(array)
-    }
-
     // ==================== Bundle Manifest Support ====================
 
     /**
@@ -253,7 +194,7 @@ class ModuleLoaderModule(private val reactContext: ReactApplicationContext) : Re
             val codePushDir = "${reactContext.filesDir.absolutePath}/CodePush"
             val assetsBaseManifestPath = "$codePushDir/assets-base/bundle-manifest.json"
             val assetsBaseManifestFile = File(assetsBaseManifestPath)
-            
+
             if (assetsBaseManifestFile.exists()) {
                 promise.resolve(assetsBaseManifestPath)
                 return
@@ -283,7 +224,7 @@ class ModuleLoaderModule(private val reactContext: ReactApplicationContext) : Re
                     val codePushDir = "${reactContext.filesDir.absolutePath}/CodePush"
                     val assetsBaseManifestPath = "$codePushDir/assets-base/bundle-manifest.json"
                     val assetsBaseManifestFile = File(assetsBaseManifestPath)
-                    
+
                     if (assetsBaseManifestFile.exists()) {
                         val content = readFileContent(assetsBaseManifestFile)
                         if (content != null) {
@@ -445,5 +386,3 @@ class ModuleLoaderModule(private val reactContext: ReactApplicationContext) : Re
         }
     }
 }
-
-

package/ios/ModuleLoader/ModuleLoaderModule.h

@@ -0,0 +1,12 @@
+#import <React/RCTBridgeModule.h>
+
+/**
+ * ModuleLoader - iOS 原生模块
+ * 用于在同一个 JS 运行时中动态加载子 bundle
+ * 
+ * 新架构下通过 RCTHost 加载 bundle
+ */
+@interface ModuleLoaderModule : NSObject <RCTBridgeModule>
+
+@end
+