@bm-fe/react-native-multi-bundle 1.0.0-beta.1 → 1.0.0-beta.2

package/INTEGRATION.md

@@ -55,93 +55,70 @@ npx react-native start
 
 ## Native 模块集成
 
-### Android
+### Android（自动链接，无需手动配置）
 
-#### 1. 复制 Native 模块文件
+#### 自动链接工作原理
 
-将以下文件从 `templates/native/android/` 复制到你的 Android 项目：
+安装包后，React Native CLI 会自动：
+1. 读取包中的 `react-native.config.js` 配置
+2. 将 `ModuleLoaderPackage` 添加到 `PackageList` 中
+3. 在构建时自动集成原生模块
 
-- `ModuleLoaderModule.kt` → `android/app/src/main/java/com/yourpackage/ModuleLoaderModule.kt`
-- `ModuleLoaderPackage.kt` → `android/app/src/main/java/com/yourpackage/ModuleLoaderPackage.kt`
+#### 验证自动链接
 
-**重要**：修改文件中的包名 `com.yourpackage` 为你的实际包名。
+安装包后，可以通过以下命令验证自动链接是否生效：
 
-#### 2. 注册 ModuleLoaderPackage
+```bash
+npx react-native config
+```
 
-根据你使用的 React Native 架构版本，选择对应的方式：
+在输出中应该能看到 `@bm-fe/react-native-multi-bundle` 的配置信息。
 
-##### 方式一：新架构（React Native 0.82+，使用 ReactHost）
+#### 确保 assets 目录存在
 
-如果你的 `MainApplication.kt` 使用 `ReactHost`（新架构），在 `PackageList` 中添加：
+确保 `android/app/src/main/assets/` 目录存在，bundle 文件将放在这里：
 
-```kotlin
-package com.yourpackage
+```bash
+mkdir -p android/app/src/main/assets/modules
+```
 
-import android.app.Application
-import com.yourpackage.ModuleLoaderPackage
-import com.facebook.react.PackageList
-import com.facebook.react.ReactApplication
-import com.facebook.react.ReactHost
-import com.facebook.react.ReactNativeApplicationEntryPoint.loadReactNative
-import com.facebook.react.defaults.DefaultReactHost.getDefaultReactHost
+#### 手动集成（可选，仅在自动链接不工作时使用）
 
-class MainApplication : Application(), ReactApplication {
-  override val reactHost: ReactHost by lazy {
-    getDefaultReactHost(
-      context = applicationContext,
-      packageList =
-        PackageList(this).packages.apply {
-          // Packages that cannot be autolinked yet can be added manually here
-          add(ModuleLoaderPackage())
-        },
-    )
-  }
+如果自动链接不工作（极少数情况），可以手动集成：
 
-  override fun onCreate() {
-    super.onCreate()
-    loadReactNative(this)
-  }
-}
-```
+<details>
+<summary>点击展开手动集成步骤</summary>
 
-##### 方式二：旧架构（使用 ReactNativeHost）
+##### 1. 复制 Native 模块文件
 
-如果你的 `MainApplication.kt` 使用 `ReactNativeHost`（旧架构），在 `getPackages()` 方法中添加：
+将以下文件从 `node_modules/@bm-fe/react-native-multi-bundle/templates/native/android/` 复制到你的 Android 项目：
 
-```kotlin
-package com.yourpackage
+- `ModuleLoaderModule.kt` → `android/app/src/main/java/com/yourpackage/ModuleLoaderModule.kt`
+- `ModuleLoaderPackage.kt` → `android/app/src/main/java/com/yourpackage/ModuleLoaderPackage.kt`
 
-import android.app.Application
+**重要**：修改文件中的包名 `com.yourpackage` 为你的实际包名。
+
+##### 2. 注册 ModuleLoaderPackage
+
+在 `MainApplication.kt` 中添加：
+
+```kotlin
 import com.yourpackage.ModuleLoaderPackage
-import com.facebook.react.ReactApplication
-import com.facebook.react.ReactPackage
-import com.facebook.react.PackageList
-import com.facebook.react.ReactNativeHost
-import com.facebook.react.defaults.DefaultReactNativeHost
 
 class MainApplication : Application(), ReactApplication {
-  override val reactNativeHost: ReactNativeHost =
-      object : DefaultReactNativeHost(this) {
-          override fun getPackages(): List<ReactPackage> =
-              PackageList(this).packages.apply {
-                // Packages that cannot be autolinked yet can be added manually here
-                add(ModuleLoaderPackage())
-              }
-
-          override fun getJSMainModuleName(): String = "index"
-          override fun getUseDeveloperSupport(): Boolean = BuildConfig.DEBUG
-          // ... 其他配置
-      }
-
-  // ... 其他代码
+  override val reactHost: ReactHost by lazy {
+    getDefaultReactHost(
+      context = applicationContext,
+      packageList = PackageList(this).packages.apply {
+        add(ModuleLoaderPackage())  // 手动添加
+      },
+    )
+  }
+  // ...
 }
 ```
 
-**注意**：React Native 0.82+ 默认使用新架构（ReactHost），推荐使用方式一。
-
-#### 3. 确保 assets 目录存在
-
-确保 `android/app/src/main/assets/` 目录存在，bundle 文件将放在这里。
+</details>
 
 ### iOS
 

package/android/moduleloader/build.gradle

@@ -0,0 +1,93 @@
+def isNewArchitectureEnabled() {
+  return rootProject.hasProperty("newArchEnabled") && rootProject.getProperty("newArchEnabled") == "true"
+}
+
+apply plugin: "com.android.library"
+apply plugin: "org.jetbrains.kotlin.android"
+
+if (isNewArchitectureEnabled()) {
+  apply plugin: "com.facebook.react"
+}
+
+def getExtOrDefault(name) {
+  return rootProject.ext.has(name) ? rootProject.ext.get(name) : project.properties["ModuleLoader_" + name]
+}
+
+def getExtOrIntegerDefault(name) {
+  return rootProject.ext.has(name) ? rootProject.ext.get(name) : (project.properties["ModuleLoader_" + name]).toInteger()
+}
+
+def supportsNamespace() {
+  def parsed = com.android.Version.ANDROID_GRADLE_PLUGIN_VERSION.tokenize('.')
+  def major = parsed[0].toInteger()
+  def minor = parsed[1].toInteger()
+
+  // Namespace support was added in 7.3.0
+  return (major == 7 && minor >= 3) || major >= 8
+}
+
+android {
+  if (supportsNamespace()) {
+    namespace "com.bitmart.exchange.module.loader"
+
+    sourceSets {
+      main {
+        manifest.srcFile "src/main/AndroidManifestNew.xml"
+      }
+    }
+  }
+
+  compileSdkVersion getExtOrIntegerDefault("compileSdkVersion")
+
+  defaultConfig {
+    minSdkVersion getExtOrIntegerDefault("minSdkVersion")
+    targetSdkVersion getExtOrIntegerDefault("targetSdkVersion")
+    buildConfigField "boolean", "IS_NEW_ARCHITECTURE_ENABLED", isNewArchitectureEnabled().toString()
+  }
+
+  buildFeatures {
+    buildConfig true
+  }
+
+  buildTypes {
+    release {
+      minifyEnabled false
+    }
+  }
+
+  lintOptions {
+    disable "GradleCompatible"
+  }
+
+  compileOptions {
+    sourceCompatibility JavaVersion.VERSION_17
+    targetCompatibility JavaVersion.VERSION_17
+  }
+
+  kotlinOptions {
+    jvmTarget = "17"
+  }
+}
+
+repositories {
+  mavenCentral()
+  google()
+}
+
+def isInDevelopment = project.hasProperty('ModuleLoader_development') && project.property('ModuleLoader_development') == "true"
+
+dependencies {
+  if (isInDevelopment) {
+    implementation("com.facebook.react:react-android:0.71.+")
+  } else {
+    // For < 0.71, this will be from the local maven repo
+    // For > 0.71, this will be replaced by `com.facebook.react:react-android:$version` by react gradle plugin
+    //noinspection GradleDynamicVersion
+    implementation "com.facebook.react:react-native:+"
+  }
+  
+  // Kotlin Coroutines
+  implementation("org.jetbrains.kotlinx:kotlinx-coroutines-core:1.7.3")
+  implementation("org.jetbrains.kotlinx:kotlinx-coroutines-android:1.7.3")
+}
+

package/android/moduleloader/src/main/AndroidManifest.xml

@@ -0,0 +1,4 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+    package="com.bitmart.exchange.module.loader">
+</manifest>
+

package/android/moduleloader/src/main/AndroidManifestNew.xml

@@ -0,0 +1,3 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+</manifest>
+

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

@@ -0,0 +1,449 @@
+package com.bitmart.exchange.module.loader
+
+import android.util.Log
+import com.facebook.react.bridge.Promise
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReactContextBaseJavaModule
+import com.facebook.react.bridge.ReactMethod
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.JSBundleLoader
+import com.facebook.react.module.annotations.ReactModule
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.SupervisorJob
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.withContext
+import java.io.BufferedReader
+import java.io.File
+import java.io.FileOutputStream
+import java.io.FileReader
+import java.io.IOException
+import java.io.InputStream
+import java.io.InputStreamReader
+
+/**
+ * 简单的 Bundle 加载模块
+ * 用于在同一个 JS 运行时中动态加载子 bundle
+ * 
+ * 新架构下通过反射获取 ReactInstance，然后调用 loadJSBundle 方法
+ * 注意：ReactInstance 是 internal 类，必须完全通过反射操作
+ */
+@ReactModule(name = ModuleLoaderModule.NAME)
+class ModuleLoaderModule(private val reactContext: ReactApplicationContext) : ReactContextBaseJavaModule(reactContext) {
+
+    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")
+                reactInstanceClass = Class.forName("com.facebook.react.runtime.ReactInstance")
+            } catch (e: ClassNotFoundException) {
+                Log.w(TAG, "New architecture classes not found, will use old architecture")
+            }
+        }
+    }
+
+    // 记录已加载的 bundle，避免重复加载
+    private val loadedBundles = mutableSetOf<String>()
+
+    // 协程作用域，用于异步操作
+    private val moduleScope = CoroutineScope(SupervisorJob() + Dispatchers.Main)
+
+    override fun getName(): String = NAME
+
+    /**
+     * 加载子 bundle
+     * 
+     * @param bundleId 模块 ID（如 "home", "details", "settings"）
+     * @param bundlePath bundle 文件路径（如 "modules/home.bundle"）
+     * @param promise 加载结果回调
+     */
+    @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)
+            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
+            }
+
+            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)
+            }
+
+        } catch (e: Exception) {
+            Log.e(TAG, "Failed to load bundle: $bundleId", e)
+            val result = Arguments.createMap().apply {
+                putBoolean("success", false)
+                putString("errorMessage", e.message ?: "Unknown error")
+            }
+            promise.resolve(result)
+        }
+    }
+
+    /**
+     * 新架构方案：完全通过反射获取 ReactInstance 并加载 bundle
+     */
+    private fun loadBundleViaReflection(
+        reactHost: Any,
+        bundleLoader: JSBundleLoader,
+        bundleId: String,
+        promise: Promise
+    ) {
+        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 {
+                    putBoolean("success", false)
+                    putString("errorMessage", "ReactInstance not available")
+                }
+                promise.resolve(result)
+                return
+            }
+
+            // 通过反射调用 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)
+            val result = Arguments.createMap().apply {
+                putBoolean("success", false)
+                putString("errorMessage", e.message ?: "Unknown error")
+            }
+            promise.resolve(result)
+        }
+    }
+
+    /**
+     * 检查 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 ====================
+
+    /**
+     * 获取当前 bundle manifest 文件路径
+     * 优先从 assets-base 目录获取，如果不存在则返回 null
+     */
+    @ReactMethod
+    fun getCurrentBundleManifest(promise: Promise) {
+        try {
+
+            // 确保 CodePush 目录已初始化
+            ensureCodePushDirectoryInitialized()
+
+            // 从 assets-base 目录获取 manifest
+            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
+            }
+
+            // 如果都不存在，返回 null
+            promise.resolve(null)
+        } catch (e: Exception) {
+            Log.e(TAG, "Failed to get current bundle manifest: ${e.message}")
+            promise.reject("MANIFEST_ERROR", "Failed to get manifest path", e)
+        }
+    }
+
+    /**
+     * 获取当前 bundle manifest 文件内容
+     * 使用协程在 IO 线程读取文件内容
+     */
+    @ReactMethod
+    fun getCurrentBundleManifestContent(promise: Promise) {
+        moduleScope.launch {
+            try {
+                val manifestContent = withContext(Dispatchers.IO) {
+                    // 确保 CodePush 目录已初始化
+                    ensureCodePushDirectoryInitialized()
+
+                    // 从 assets-base 目录读取 manifest
+                    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) {
+                            Log.d(TAG, "✓ Read bundle manifest from assets-base directory")
+                            return@withContext content
+                        }
+                    }
+
+                    // 如果都不存在，返回 null
+                    null
+                }
+                promise.resolve(manifestContent)
+            } catch (e: Exception) {
+                Log.e(TAG, "Failed to get bundle manifest content: ${e.message}")
+                promise.reject("MANIFEST_CONTENT_ERROR", "Failed to read manifest content", e)
+            }
+        }
+    }
+
+    /**
+     * 确保 CodePush 目录已从 assets 初始化
+     */
+    private fun ensureCodePushDirectoryInitialized() {
+        try {
+            val codePushDir = "${reactContext.filesDir.absolutePath}/CodePush"
+            val assetsBaseDir = "$codePushDir/assets-base"
+
+            // 检查 assets-base 目录是否有 bundle-manifest.json 和 modules
+            val manifestFile = File("$assetsBaseDir/bundle-manifest.json")
+            val modulesDir = File("$assetsBaseDir/modules")
+
+            // 如果任一不存在，从 assets 复制
+            if (!manifestFile.exists() || !modulesDir.exists()) {
+                Log.d(TAG, "Initializing CodePush directory from assets...")
+                copyAssetsToCodePushDirectory(codePushDir)
+            }
+        } catch (e: Exception) {
+            Log.e(TAG, "Failed to initialize CodePush directory: ${e.message}")
+        }
+    }
+
+    /**
+     * 从 assets 复制 bundle-manifest.json 和 modules 目录到 CodePush 目录
+     */
+    private fun copyAssetsToCodePushDirectory(codePushDir: String) {
+        try {
+            // 创建 assets-base 目录
+            val defaultPackageDir = "$codePushDir/assets-base"
+            val defaultPackageDirFile = File(defaultPackageDir)
+            if (!defaultPackageDirFile.exists()) {
+                defaultPackageDirFile.mkdirs()
+            }
+
+            // 1. 复制 bundle-manifest.json
+            try {
+                val manifestAssetPath = "bundle-manifest.json"
+                val manifestInput = reactContext.assets.open(manifestAssetPath)
+                val manifestOutput = File("$defaultPackageDir/bundle-manifest.json")
+                copyInputStreamToFile(manifestInput, manifestOutput)
+                Log.d(TAG, "✓ Copied bundle-manifest.json to CodePush directory")
+            } catch (e: IOException) {
+                Log.w(TAG, "Warning: Could not copy bundle-manifest.json: ${e.message}")
+            }
+
+            // 2. 复制 modules 目录
+            try {
+                val modulesAssetPath = "modules"
+                val modulesOutputDir = File("$defaultPackageDir/modules")
+                if (!modulesOutputDir.exists()) {
+                    modulesOutputDir.mkdirs()
+                }
+
+                copyAssetFolder(modulesAssetPath, modulesOutputDir.absolutePath)
+                Log.d(TAG, "✓ Copied modules directory to CodePush directory")
+            } catch (e: IOException) {
+                Log.w(TAG, "Warning: Could not copy modules directory: ${e.message}")
+            }
+
+        } catch (e: Exception) {
+            Log.e(TAG, "Failed to copy assets to CodePush directory: ${e.message}")
+        }
+    }
+
+    /**
+     * 递归复制 asset 文件夹
+     */
+    @Throws(IOException::class)
+    private fun copyAssetFolder(assetPath: String, targetPath: String) {
+        val assets = reactContext.assets.list(assetPath)
+        if (assets.isNullOrEmpty()) {
+            // 这是一个文件，不是目录
+            val input = reactContext.assets.open(assetPath)
+            val output = File(targetPath)
+            copyInputStreamToFile(input, output)
+        } else {
+            // 这是一个目录
+            val dir = File(targetPath)
+            if (!dir.exists()) {
+                dir.mkdirs()
+            }
+
+            for (asset in assets) {
+                val subAssetPath = "$assetPath/$asset"
+                val subTargetPath = "$targetPath/$asset"
+                copyAssetFolder(subAssetPath, subTargetPath)
+            }
+        }
+    }
+
+    /**
+     * 将 InputStream 复制到文件
+     */
+    @Throws(IOException::class)
+    private fun copyInputStreamToFile(input: InputStream, output: File) {
+        var outputStream: FileOutputStream? = null
+        try {
+            outputStream = FileOutputStream(output)
+            val buffer = ByteArray(4096)
+            var bytesRead: Int
+            while (input.read(buffer).also { bytesRead = it } != -1) {
+                outputStream.write(buffer, 0, bytesRead)
+            }
+        } finally {
+            try {
+                input.close()
+            } catch (e: IOException) {
+                // Ignore
+            }
+            try {
+                outputStream?.close()
+            } catch (e: IOException) {
+                // Ignore
+            }
+        }
+    }
+
+    /**
+     * 读取文件内容
+     */
+    private fun readFileContent(file: File): String? {
+        var reader: BufferedReader? = null
+        return try {
+            reader = BufferedReader(FileReader(file))
+            val content = StringBuilder()
+            var line: String?
+            while (reader.readLine().also { line = it } != null) {
+                content.append(line).append("\n")
+            }
+            content.toString()
+        } catch (e: IOException) {
+            Log.e(TAG, "Failed to read file: ${file.absolutePath} - ${e.message}")
+            null
+        } finally {
+            try {
+                reader?.close()
+            } catch (e: IOException) {
+                // Ignore
+            }
+        }
+    }
+}
+
+

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

@@ -0,0 +1,24 @@
+package com.bitmart.exchange.module.loader
+
+import com.facebook.react.ReactPackage
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.uimanager.ViewManager
+
+/**
+ * ModuleLoader ReactPackage
+ * 注册 ModuleLoaderModule 到 React Native
+ */
+class ModuleLoaderPackage : ReactPackage {
+    @Suppress("DEPRECATION")
+    override fun createNativeModules(reactContext: ReactApplicationContext): List<NativeModule> {
+        return listOf(ModuleLoaderModule(reactContext))
+    }
+
+    @Suppress("DEPRECATION")
+    override fun createViewManagers(reactContext: ReactApplicationContext): List<ViewManager<*, *>> {
+        return emptyList()
+    }
+}
+
+

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bm-fe/react-native-multi-bundle",
-  "version": "1.0.0-beta.1",
+  "version": "1.0.0-beta.2",
   "description": "React Native 多 Bundle 系统 - 支持模块按需加载和独立更新",
   "main": "src/index.ts",
   "types": "src/index.ts",
@@ -20,6 +20,8 @@
     "src",
     "scripts",
     "templates",
+    "android/moduleloader",
+    "react-native.config.js",
     "README.md",
     "INTEGRATION.md",
     "LICENSE"
@@ -35,9 +37,11 @@
     "version:minor": "standard-version --release-as minor",
     "version:major": "standard-version --release-as major",
     "version:beta": "npm version prerelease --preid=beta --no-git-tag-version --no-scripts",
+    "prepublishOnly": "rm -rf android/moduleloader/build",
     "publish:beta": "npm publish --tag beta",
     "release:beta": "npm run version:beta && npm run publish:beta",
-    "release": "npm run version && npm publish"
+    "release": "npm run version && npm publish",
+    "android": "react-native run-android"
   },
   "peerDependencies": {
     "react": ">=18.0.0",
@@ -46,6 +50,8 @@
   "dependencies": {
     "@react-navigation/native": "^7.1.21",
     "@react-navigation/native-stack": "^7.6.4",
+    "react": "19.1.1",
+    "react-native": "0.82.1",
     "react-native-fs": "^2.20.0",
     "react-native-safe-area-context": "^5.6.2",
     "react-native-screens": "^4.18.0"
@@ -59,6 +65,7 @@
     "@react-native-community/cli-platform-ios": "20.0.2",
     "@react-native/babel-preset": "0.82.1",
     "@react-native/eslint-config": "0.82.1",
+    "@react-native/gradle-plugin": "0.82.1",
     "@react-native/metro-config": "0.82.1",
     "@react-native/typescript-config": "0.82.1",
     "@rnx-kit/babel-preset-metro-react-native": "^3.0.0",
@@ -73,6 +80,7 @@
     "patch-package": "^8.0.1",
     "postinstall-postinstall": "^2.1.0",
     "prettier": "3.6.2",
+    "react-native": "^0.82.1",
     "react-test-renderer": "^19.1.1",
     "standard-version": "^9.5.0",
     "typescript": "5.9.3"

package/react-native.config.js

@@ -0,0 +1,23 @@
+/**
+ * React Native 配置文件
+ * 用于配置原生模块的自动链接
+ * 
+ * 当此包被安装到其他 RN 项目时，React Native CLI 会自动读取此配置
+ * 并将 ModuleLoaderPackage 自动注册到 PackageList 中
+ */
+
+module.exports = {
+  // 配置原生模块自动链接
+  dependency: {
+    platforms: {
+      android: {
+        sourceDir: './android/moduleloader',
+        packageImportPath: 'import com.bitmart.exchange.module.loader.ModuleLoaderPackage;',
+        packageInstance: 'new ModuleLoaderPackage()',
+        buildTypes: ['debug', 'release'],
+      },
+      ios: null, // iOS 暂未实现
+    },
+  },
+};
+

package/src/multi-bundle/LocalBundleManager.ts

@@ -61,9 +61,31 @@ function convertNativeManifestToBundleManifest(nativeManifest: any): BundleManif
  */
 async function getCurrentBundleManifest(): Promise<BundleManifest> {
   // 生产环境：从 Native 模块获取 manifest
-  if (!__DEV__) {
-    try {
-      const nativeManifest = await NativeModules.CodePush.getCurrentBundleManifestContent();
+//   if (!__DEV__) {
+//     try {
+//       const nativeManifest = await NativeModules.ModuleLoader.getCurrentBundleManifestContent();
+//       if (nativeManifest) {
+//         return convertNativeManifestToBundleManifest(nativeManifest);
+//       } else {
+//         // Native 模块返回 null 或 undefined
+//         throw new Error(
+//           '[LocalBundleManager] Native module returned null manifest. ' +
+//           'Please ensure bundle-manifest.json exists in the app bundle.'
+//         );
+//       }
+//     } catch (error) {
+//       console.error(
+//         `[LocalBundleManager] Failed to get manifest from Native: ${error}`
+//       );
+//       // 生产环境无法获取 manifest 时抛出异常
+//       throw new Error(
+//         `[LocalBundleManager] Failed to get manifest from Native module: ${error}`
+//       );
+//     }
+//   }
+      console.log("ReactNativeJS","nativeManifest getCurrentBundleManifestContent")
+      const nativeManifest = await NativeModules.ModuleLoader.getCurrentBundleManifestContent();
+      console.log("ReactNativeJS","nativeManifest "+nativeManifest)
       if (nativeManifest) {
         return convertNativeManifestToBundleManifest(nativeManifest);
       } else {
@@ -73,16 +95,6 @@ async function getCurrentBundleManifest(): Promise<BundleManifest> {
           'Please ensure bundle-manifest.json exists in the app bundle.'
         );
       }
-    } catch (error) {
-      console.error(
-        `[LocalBundleManager] Failed to get manifest from Native: ${error}`
-      );
-      // 生产环境无法获取 manifest 时抛出异常
-      throw new Error(
-        `[LocalBundleManager] Failed to get manifest from Native module: ${error}`
-      );
-    }
-  }
 
   // 开发环境：从开发服务器获取 manifest
   const config = getGlobalConfig();

package/src/multi-bundle/README.md

@@ -341,3 +341,4 @@ function preloadModule(moduleId: string): Promise<void>
 - [使用指南](../docs/使用指南.md)
 - [多 Bundle 架构设计](../docs/React%20Native%20多%20bundle%20技术方案.md)
 
+