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

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

@@ -0,0 +1,555 @@
+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 org.json.JSONObject
+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 加载模块
+ *
+ * 新架构下通过反射获取 ReactInstance，然后调用 loadJSBundle 方法
+ * 注意：ReactInstance 是 internal 类，必须完全通过反射操作
+ * 
+ * Bundle 加载优先级：
+ * 1. CodePush 目录（热更新后的 bundle）
+ * 2. Assets（APK 内置的 bundle）
+ */
+@ReactModule(name = ModuleLoaderModule.NAME)
+class ModuleLoaderModule(private val reactContext: ReactApplicationContext) : ReactContextBaseJavaModule(reactContext) {
+
+    companion object {
+        const val NAME = "ModuleLoader"
+        private const val TAG = "ModuleLoaderModule"
+        
+        // CodePush 相关常量
+        private const val CODE_PUSH_FOLDER_PREFIX = "CodePush"
+        private const val STATUS_FILE = "codepush.json"
+        private const val CURRENT_PACKAGE_KEY = "currentPackage"
+
+        // 缓存反射获取的类和方法，避免重复反射
+        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")
+            }
+        }
+    }
+
+    // 协程作用域，用于异步操作
+    private val moduleScope = CoroutineScope(SupervisorJob() + Dispatchers.Main)
+
+    override fun getName(): String = NAME
+
+    /**
+     * 加载子 bundle
+     *
+     * 加载策略（按优先级）：
+     * 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")
+
+        // 1️⃣ 优先：旧架构 CatalystInstance
+        if (tryLoadWithCatalystInstance(bundleId, bundlePath, promise)) {
+            return
+        }
+
+        // 2️⃣ 其次：新架构 ReactHostImpl
+        if (tryLoadWithReactHost(bundleId, bundlePath, promise)) {
+            return
+        }
+
+        // 都失败
+        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 {
+            // 1️⃣ 优先从 CodePush 目录加载
+            val codePushBundlePath = getCodePushBundlePath(bundlePath)
+            if (codePushBundlePath != null) {
+                Log.d(TAG, "Loading bundle from CodePush: $codePushBundlePath")
+                catalystInstance.loadScriptFromFile(codePushBundlePath, codePushBundlePath, false)
+                Log.d(TAG, "✓ Bundle loaded from CodePush: $bundleId")
+                promise.resolve(Arguments.createMap().apply { putBoolean("success", true) })
+                return true
+            }
+            
+            // 2️⃣ 回退到 assets 加载
+            val assetPath = "assets://$bundlePath"
+            Log.d(TAG, "Loading bundle from assets: $assetPath")
+            catalystInstance.loadScriptFromAssets(reactContext.assets, assetPath, false)
+            Log.d(TAG, "✓ Bundle loaded from assets: $bundleId")
+            promise.resolve(Arguments.createMap().apply { putBoolean("success", true) })
+        } catch (e: Exception) {
+            Log.e(TAG, "Failed to load bundle: $bundleId", e)
+            promise.resolve(Arguments.createMap().apply {
+                putBoolean("success", false)
+                putString("errorMessage", e.message ?: "Unknown error")
+            })
+        }
+        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)")
+        
+        // 1️⃣ 优先从 CodePush 目录加载
+        val codePushBundlePath = getCodePushBundlePath(bundlePath)
+        val bundleLoader = if (codePushBundlePath != null) {
+            Log.d(TAG, "Loading bundle from CodePush: $codePushBundlePath")
+            JSBundleLoader.createFileLoader(codePushBundlePath)
+        } else {
+            // 2️⃣ 回退到 assets 加载
+            val assetUrl = "assets://$bundlePath"
+            Log.d(TAG, "Loading bundle from assets: $assetUrl")
+            JSBundleLoader.createAssetLoader(reactContext, assetUrl, false)
+        }
+        
+        loadBundleViaReflection(reactHost, bundleLoader, bundleId, promise)
+        return true
+    }
+
+    /**
+     * 新架构方案：完全通过反射获取 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)
+
+            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)
+        }
+    }
+
+    // ==================== CodePush Bundle Path Resolution ====================
+
+    /**
+     * 获取 CodePush 基础目录
+     * 路径: <filesDir>/CodePush/
+     */
+    private fun getCodePushPath(): String {
+        return "${reactContext.filesDir.absolutePath}/$CODE_PUSH_FOLDER_PREFIX"
+    }
+
+    /**
+     * 获取当前 CodePush 包的 hash
+     * 从 <CodePushPath>/codepush.json 读取 currentPackage 字段
+     */
+    private fun getCurrentPackageHash(): String? {
+        return try {
+            val statusFilePath = "${getCodePushPath()}/$STATUS_FILE"
+            val statusFile = File(statusFilePath)
+            
+            if (!statusFile.exists()) {
+                Log.d(TAG, "CodePush status file not found: $statusFilePath")
+                return null
+            }
+            
+            val content = statusFile.readText()
+            val json = JSONObject(content)
+            val packageHash = json.optString(CURRENT_PACKAGE_KEY, null)
+            
+            if (packageHash.isNullOrEmpty()) {
+                Log.d(TAG, "No current package hash in CodePush status")
+                return null
+            }
+            
+            Log.d(TAG, "Current CodePush package hash: $packageHash")
+            packageHash
+        } catch (e: Exception) {
+            Log.e(TAG, "Error reading CodePush status: ${e.message}")
+            null
+        }
+    }
+
+    /**
+     * 获取 CodePush 包目录路径
+     * 路径: <CodePushPath>/<packageHash>/
+     */
+    private fun getPackageFolderPath(packageHash: String): String {
+        return "${getCodePushPath()}/$packageHash"
+    }
+
+    /**
+     * 从 CodePush 目录查找子 bundle 文件
+     * 
+     * 查找顺序：
+     * 1. <packageFolder>/modules/<bundleFileName>
+     * 2. <packageFolder>/<bundlePath>
+     * 3. <packageFolder>/<bundleFileName>
+     * 
+     * @param bundlePath 原始 bundle 路径，如 "modules/home.jsbundle"
+     * @return 完整的文件路径，如果不存在返回 null
+     */
+    private fun getCodePushBundlePath(bundlePath: String): String? {
+        val packageHash = getCurrentPackageHash() ?: return null
+        val packageFolder = getPackageFolderPath(packageHash)
+        
+        // 检查包目录是否存在
+        val packageDir = File(packageFolder)
+        if (!packageDir.exists()) {
+            Log.d(TAG, "CodePush package folder not found: $packageFolder")
+            return null
+        }
+        
+        // 提取文件名
+        val bundleFileName = File(bundlePath).name
+        
+        // 查找路径列表
+        val searchPaths = listOf(
+            // 1. <packageFolder>/modules/<bundleFileName>
+            "$packageFolder/modules/$bundleFileName",
+            // 2. <packageFolder>/<bundlePath> (完整相对路径)
+            "$packageFolder/$bundlePath",
+            // 3. <packageFolder>/<bundleFileName> (仅文件名)
+            "$packageFolder/$bundleFileName"
+        )
+        
+        for (path in searchPaths) {
+            val file = File(path)
+            if (file.exists() && file.isFile) {
+                Log.d(TAG, "Found bundle in CodePush: $path")
+                return path
+            }
+        }
+        
+        Log.d(TAG, "Bundle not found in CodePush package, searched: $searchPaths")
+        return null
+    }
+
+    // ==================== Bundle Manifest Support ====================
+
+    /**
+     * 获取当前 bundle manifest 文件路径
+     * 
+     * 查找优先级：
+     * 1. CodePush 当前包目录（热更新后的 manifest）
+     * 2. assets-base 目录（初始复制的 manifest）
+     */
+    @ReactMethod
+    fun getCurrentBundleManifest(promise: Promise) {
+        try {
+            // 1️⃣ 优先从 CodePush 当前包目录获取
+            val packageHash = getCurrentPackageHash()
+            if (packageHash != null) {
+                val packageFolder = getPackageFolderPath(packageHash)
+                val codePushManifestPath = "$packageFolder/bundle-manifest.json"
+                val codePushManifestFile = File(codePushManifestPath)
+                
+                if (codePushManifestFile.exists()) {
+                    Log.d(TAG, "Found manifest in CodePush package: $codePushManifestPath")
+                    promise.resolve(codePushManifestPath)
+                    return
+                }
+            }
+
+            // 2️⃣ 确保 assets-base 目录已初始化
+            ensureCodePushDirectoryInitialized()
+
+            // 从 assets-base 目录获取 manifest
+            val codePushDir = getCodePushPath()
+            val assetsBaseManifestPath = "$codePushDir/assets-base/bundle-manifest.json"
+            val assetsBaseManifestFile = File(assetsBaseManifestPath)
+
+            if (assetsBaseManifestFile.exists()) {
+                Log.d(TAG, "Found manifest in assets-base: $assetsBaseManifestPath")
+                promise.resolve(assetsBaseManifestPath)
+                return
+            }
+
+            // 如果都不存在，返回 null
+            Log.w(TAG, "Bundle manifest not found in any location")
+            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 文件内容
+     * 
+     * 查找优先级：
+     * 1. CodePush 当前包目录（热更新后的 manifest）
+     * 2. assets-base 目录（初始复制的 manifest）
+     */
+    @ReactMethod
+    fun getCurrentBundleManifestContent(promise: Promise) {
+        moduleScope.launch {
+            try {
+                val manifestContent = withContext(Dispatchers.IO) {
+                    // 1️⃣ 优先从 CodePush 当前包目录读取
+                    val packageHash = getCurrentPackageHash()
+                    if (packageHash != null) {
+                        val packageFolder = getPackageFolderPath(packageHash)
+                        val codePushManifestPath = "$packageFolder/bundle-manifest.json"
+                        val codePushManifestFile = File(codePushManifestPath)
+                        
+                        if (codePushManifestFile.exists()) {
+                            val content = readFileContent(codePushManifestFile)
+                            if (content != null) {
+                                Log.d(TAG, "✓ Read bundle manifest from CodePush package")
+                                return@withContext content
+                            }
+                        }
+                    }
+                    
+                    // 2️⃣ 确保 assets-base 目录已初始化
+                    ensureCodePushDirectoryInitialized()
+
+                    // 从 assets-base 目录读取 manifest
+                    val codePushDir = getCodePushPath()
+                    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
+                    Log.w(TAG, "Bundle manifest content not found in any location")
+                    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,25 @@
+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/ios/ModuleLoader/ModuleLoaderModule.h

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