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

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.0",
+  "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"
@@ -34,10 +36,12 @@
     "version:patch": "standard-version --release-as patch",
     "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",
+    "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/scripts/build-multi-bundle.js

@@ -13,17 +13,41 @@
  * - --env: 'development' | 'staging' | 'production' (默认: 'production')
  * 
  * 环境变量：
- * - PROJECT_ROOT: 项目根目录（可选，默认从脚本位置推断）
+ * - PROJECT_ROOT: 项目根目录（可选，默认从当前工作目录向上查找包含 multi-bundle.config.json 的目录）
  */
 
 const fs = require('fs');
 const path = require('path');
 const { execSync } = require('child_process');
 
-// 支持从任意项目目录运行
-// 如果作为 npm 包使用，PROJECT_ROOT 应该是调用脚本的项目根目录
-// 如果直接运行，PROJECT_ROOT 是脚本所在目录的父目录
-const PROJECT_ROOT = process.env.PROJECT_ROOT || path.join(__dirname, '..');
+/**
+ * 查找项目根目录
+ * 从当前工作目录向上查找，直到找到包含 multi-bundle.config.json 的目录
+ * 如果找不到，则使用当前工作目录（通常打包命令在项目根目录执行）
+ */
+function findProjectRoot() {
+  // 如果通过环境变量指定，直接使用
+  if (process.env.PROJECT_ROOT) {
+    return process.env.PROJECT_ROOT;
+  }
+  
+  // 从当前工作目录开始向上查找
+  let currentDir = process.cwd();
+  const root = path.parse(currentDir).root;
+  
+  while (currentDir !== root) {
+    const configFile = path.join(currentDir, 'multi-bundle.config.json');
+    if (fs.existsSync(configFile)) {
+      return currentDir;
+    }
+    currentDir = path.dirname(currentDir);
+  }
+  
+  // 如果找不到配置文件，使用当前工作目录（通常打包命令在项目根目录执行）
+  return process.cwd();
+}
+
+const PROJECT_ROOT = findProjectRoot();
 const CONFIG_FILE = path.join(PROJECT_ROOT, 'multi-bundle.config.json');
 const OUTPUT_DIR = path.join(PROJECT_ROOT, 'build/bundles');
 

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();