@onekeyfe/react-native-background-thread 1.1.51 → 1.1.53

package/android/src/main/java/com/backgroundthread/BackgroundThreadManager.kt

@@ -108,6 +108,108 @@ class BackgroundThreadManager private constructor() {
         return null
     }
 
+    /**
+     * Creates a JSBundleLoader that loads two bundles sequentially from Android assets:
+     * first the common bundle (polyfills + shared modules), then the
+     * entry-specific bundle (entry-only modules + require(entryId)).
+     */
+    private fun createSequentialAssetBundleLoader(
+        appContext: android.content.Context,
+        commonAssetName: String,
+        entryAssetName: String
+    ): JSBundleLoader {
+        return object : JSBundleLoader() {
+            override fun loadScript(delegate: com.facebook.react.bridge.JSBundleLoaderDelegate): String {
+                val totalStart = System.nanoTime()
+
+                // Step 1: Load common bundle (polyfills + shared modules)
+                val commonStart = System.nanoTime()
+                delegate.loadScriptFromAssets(appContext.assets, "assets://$commonAssetName", false)
+                val commonMs = (System.nanoTime() - commonStart) / 1_000_000.0
+                BTLogger.info("[SplitBundle] common bundle loaded from assets in ${String.format("%.1f", commonMs)}ms: $commonAssetName")
+
+                // Step 2: Load entry-specific bundle
+                val entryStart = System.nanoTime()
+                delegate.loadScriptFromAssets(appContext.assets, "assets://$entryAssetName", false)
+                val entryMs = (System.nanoTime() - entryStart) / 1_000_000.0
+                BTLogger.info("[SplitBundle] entry bundle loaded from assets in ${String.format("%.1f", entryMs)}ms: $entryAssetName")
+
+                val totalMs = (System.nanoTime() - totalStart) / 1_000_000.0
+                BTLogger.info("[SplitBundle] sequential asset load total: ${String.format("%.1f", totalMs)}ms (common=${String.format("%.1f", commonMs)}ms + entry=${String.format("%.1f", entryMs)}ms)")
+
+                return "assets://$entryAssetName"
+            }
+        }
+    }
+
+    /**
+     * Creates a JSBundleLoader that loads two bundles sequentially from local files:
+     * first the common bundle, then the entry-specific bundle.
+     */
+    private fun createSequentialFileBundleLoader(
+        commonPath: String,
+        entryPath: String,
+        entrySourceURL: String
+    ): JSBundleLoader {
+        return object : JSBundleLoader() {
+            override fun loadScript(delegate: com.facebook.react.bridge.JSBundleLoaderDelegate): String {
+                val totalStart = System.nanoTime()
+
+                // Step 1: Load common bundle (polyfills + shared modules)
+                val commonFile = File(commonPath)
+                if (!commonFile.exists()) {
+                    BTLogger.error("Common bundle file does not exist: $commonPath")
+                    throw RuntimeException("Common bundle file does not exist: $commonPath")
+                }
+                BTLogger.info("[SplitBundle] common bundle file: ${commonFile.length() / 1024}KB")
+                val commonStart = System.nanoTime()
+                delegate.loadScriptFromFile(commonFile.absolutePath, "common.bundle", false)
+                val commonMs = (System.nanoTime() - commonStart) / 1_000_000.0
+                BTLogger.info("[SplitBundle] common bundle loaded from file in ${String.format("%.1f", commonMs)}ms: $commonPath")
+
+                // Step 2: Load entry-specific bundle
+                val entryFile = File(entryPath)
+                if (!entryFile.exists()) {
+                    BTLogger.error("Entry bundle file does not exist: $entryPath")
+                    throw RuntimeException("Entry bundle file does not exist: $entryPath")
+                }
+                BTLogger.info("[SplitBundle] entry bundle file: ${entryFile.length() / 1024}KB")
+                val entryStart = System.nanoTime()
+                delegate.loadScriptFromFile(entryFile.absolutePath, entrySourceURL, false)
+                val entryMs = (System.nanoTime() - entryStart) / 1_000_000.0
+                BTLogger.info("[SplitBundle] entry bundle loaded from file in ${String.format("%.1f", entryMs)}ms: $entryPath")
+
+                val totalMs = (System.nanoTime() - totalStart) / 1_000_000.0
+                BTLogger.info("[SplitBundle] sequential file load total: ${String.format("%.1f", totalMs)}ms (common=${String.format("%.1f", commonMs)}ms + entry=${String.format("%.1f", entryMs)}ms)")
+
+                return entrySourceURL
+            }
+        }
+    }
+
+    /**
+     * Check if common.bundle exists in the Android assets directory.
+     */
+    private fun hasCommonBundleInAssets(appContext: android.content.Context): Boolean {
+        return try {
+            appContext.assets.open("common.bundle").close()
+            true
+        } catch (e: Exception) {
+            false
+        }
+    }
+
+    /**
+     * Resolve the common bundle path for OTA (file-based) loading.
+     * Looks for common.bundle in the same directory as the entry bundle.
+     */
+    private fun resolveCommonBundlePath(entryBundlePath: String): String? {
+        val entryFile = File(entryBundlePath)
+        val parentDir = entryFile.parentFile ?: return null
+        val commonFile = File(parentDir, "common.bundle")
+        return if (commonFile.exists()) commonFile.absolutePath else null
+    }
+
     private fun createDownloadedBundleLoader(appContext: android.content.Context, entryURL: String): JSBundleLoader {
         return object : JSBundleLoader() {
             override fun loadScript(delegate: com.facebook.react.bridge.JSBundleLoaderDelegate): String {
@@ -149,7 +251,8 @@ class BackgroundThreadManager private constructor() {
             BTLogger.warn("Background runner already started")
             return
         }
-        BTLogger.info("Starting background runner with entryURL: $entryURL")
+        val bgStartTime = System.nanoTime()
+        BTLogger.info("[SplitBundle] background runner starting with entryURL: $entryURL")
 
         val appContext = context.applicationContext
         val packages =
@@ -163,10 +266,43 @@ class BackgroundThreadManager private constructor() {
         val localBundlePath = resolveLocalBundlePath(entryURL)
         val bundleLoader =
             when {
+                // Debug mode: remote URL — use single bundle (Metro dev server)
                 isRemoteBundleUrl(entryURL) -> createDownloadedBundleLoader(appContext, entryURL)
-                localBundlePath != null -> createLocalFileBundleLoader(localBundlePath, entryURL)
-                entryURL.startsWith("assets://") -> JSBundleLoader.createAssetLoader(appContext, entryURL, true)
-                else -> JSBundleLoader.createAssetLoader(appContext, "assets://$entryURL", true)
+
+                // OTA / local file path — try sequential loading with common bundle
+                localBundlePath != null -> {
+                    val commonPath = resolveCommonBundlePath(localBundlePath)
+                    if (commonPath != null) {
+                        BTLogger.info("Using sequential file bundle loader: common=$commonPath, entry=$localBundlePath")
+                        createSequentialFileBundleLoader(commonPath, localBundlePath, entryURL)
+                    } else {
+                        BTLogger.info("No common bundle found for OTA path, using single bundle: $localBundlePath")
+                        createLocalFileBundleLoader(localBundlePath, entryURL)
+                    }
+                }
+
+                // Assets-based loading — try sequential loading with common.bundle in assets
+                entryURL.startsWith("assets://") -> {
+                    val entryAssetName = entryURL.removePrefix("assets://")
+                    if (hasCommonBundleInAssets(appContext)) {
+                        BTLogger.info("Using sequential asset bundle loader: common=common.bundle, entry=$entryAssetName")
+                        createSequentialAssetBundleLoader(appContext, "common.bundle", entryAssetName)
+                    } else {
+                        BTLogger.info("No common.bundle in assets, using single bundle: $entryURL")
+                        JSBundleLoader.createAssetLoader(appContext, entryURL, true)
+                    }
+                }
+
+                // Bare filename (e.g. "background.bundle") — treat as asset
+                else -> {
+                    if (hasCommonBundleInAssets(appContext)) {
+                        BTLogger.info("Using sequential asset bundle loader: common=common.bundle, entry=$entryURL")
+                        createSequentialAssetBundleLoader(appContext, "common.bundle", entryURL)
+                    } else {
+                        BTLogger.info("No common.bundle in assets, using single bundle: assets://$entryURL")
+                        JSBundleLoader.createAssetLoader(appContext, "assets://$entryURL", true)
+                    }
+                }
             }
 
         val delegate = DefaultReactHostDelegate(
@@ -191,7 +327,8 @@ class BackgroundThreadManager private constructor() {
 
         host.addReactInstanceEventListener(object : ReactInstanceEventListener {
             override fun onReactContextInitialized(context: ReactContext) {
-                BTLogger.info("Background ReactContext initialized")
+                val initMs = (System.nanoTime() - bgStartTime) / 1_000_000.0
+                BTLogger.info("[SplitBundle] background ReactContext initialized in ${String.format("%.1f", initMs)}ms")
                 context.runOnJSQueueThread {
                     try {
                         val ptr = context.javaScriptContextHolder?.get() ?: 0L

package/ios/BackgroundRunnerReactNativeDelegate.mm

@@ -170,6 +170,8 @@ static NSURL *resolveBundleSourceURL(NSString *jsBundleSourceNS)
 
 - (NSURL *)bundleURL
 {
+  // When _jsBundleSource is set (dev mode or explicit override), use it as-is.
+  // This is a single full bundle (not split), so DON'T use common+entry strategy.
   if (!_jsBundleSource.empty()) {
     NSString *jsBundleSourceNS = [NSString stringWithUTF8String:_jsBundleSource.c_str()];
     NSURL *resolvedURL = resolveBundleSourceURL(jsBundleSourceNS);
@@ -180,11 +182,19 @@ static NSURL *resolveBundleSourceURL(NSString *jsBundleSourceNS)
     [BTLogger warn:[NSString stringWithFormat:@"Unable to resolve custom jsBundleSource=%@", jsBundleSourceNS]];
   }
 
-  NSURL *defaultBundleURL = resolveMainBundleResourceURL(@"background.bundle");
-  if (defaultBundleURL) {
-    return defaultBundleURL;
+  // Default: load common bundle (shared polyfills + modules).
+  // The background entry bundle is loaded later in hostDidStart:.
+  NSURL *commonURL = resolveMainBundleResourceURL(@"common.jsbundle");
+  if (commonURL) {
+    return commonURL;
   }
-  return [[NSBundle mainBundle] URLForResource:@"background" withExtension:@"bundle"];
+  return [[NSBundle mainBundle] URLForResource:@"common" withExtension:@"jsbundle"];
+}
+
+- (NSString *)resolveBackgroundEntryBundlePath
+{
+  NSURL *url = resolveMainBundleResourceURL(@"background.bundle");
+  return url.path;
 }
 
 - (void)hostDidStart:(RCTHost *)host
@@ -203,6 +213,28 @@ static NSURL *resolveBundleSourceURL(NSString *jsBundleSourceNS)
     return;
   }
 
+  // When _jsBundleSource is set, the bundle loaded in bundleURL was already
+  // a full single bundle (dev mode / explicit override), so skip entry loading.
+  BOOL isSplitBundle = _jsBundleSource.empty();
+
+  // Read the background entry bundle data before entering the executor block
+  // (only needed in split-bundle mode).
+  NSData *bgBundleData = nil;
+  NSString *bgBundleSourceURL = nil;
+  if (isSplitBundle) {
+    NSString *bgBundlePath = [self resolveBackgroundEntryBundlePath];
+    if (bgBundlePath) {
+      bgBundleData = [NSData dataWithContentsOfFile:bgBundlePath];
+      bgBundleSourceURL = bgBundlePath.lastPathComponent ?: @"background.bundle";
+      [BTLogger info:[NSString stringWithFormat:@"Background entry bundle loaded from %@ (%lu bytes)",
+                      bgBundlePath, (unsigned long)bgBundleData.length]];
+    } else {
+      [BTLogger warn:@"Background entry bundle not found, __setupBackgroundRPCHandler may not be defined"];
+    }
+  }
+
+  CFAbsoluteTime bgStartTime = CFAbsoluteTimeGetCurrent();
+
   [_rctInstance callFunctionOnBufferedRuntimeExecutor:[=](jsi::Runtime &runtime) {
     [self setupErrorHandler:runtime];
 
@@ -218,6 +250,22 @@ static NSURL *resolveBundleSourceURL(NSString *jsBundleSourceNS)
     };
     SharedRPC::install(runtime, std::move(bgExecutor), "background");
     [BTLogger info:@"SharedStore and SharedRPC installed in background runtime"];
+
+    // In split-bundle mode, evaluate the background entry bundle now.
+    // This must happen BEFORE invokeOptionalGlobalFunction since the entry
+    // bundle defines __setupBackgroundRPCHandler.
+    if (isSplitBundle && bgBundleData && bgBundleData.length > 0) {
+      CFAbsoluteTime bgEvalStart = CFAbsoluteTimeGetCurrent();
+      auto buffer = std::make_shared<jsi::StringBuffer>(
+        std::string(static_cast<const char *>(bgBundleData.bytes), bgBundleData.length));
+      runtime.evaluateJavaScript(std::move(buffer), [bgBundleSourceURL UTF8String]);
+      double bgEvalMs = (CFAbsoluteTimeGetCurrent() - bgEvalStart) * 1000.0;
+      [BTLogger info:[NSString stringWithFormat:@"[SplitBundle] bg entry evaluated in %.1fms", bgEvalMs]];
+    }
+
+    double bgTotalMs = (CFAbsoluteTimeGetCurrent() - bgStartTime) * 1000.0;
+    [BTLogger info:[NSString stringWithFormat:@"[SplitBundle] bg hostDidStart total setup in %.1fms", bgTotalMs]];
+
     invokeOptionalGlobalFunction(runtime, "__setupBackgroundRPCHandler");
   }];
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@onekeyfe/react-native-background-thread",
-  "version": "1.1.51",
+  "version": "1.1.53",
   "description": "react-native-background-thread",
   "main": "./lib/module/index.js",
   "types": "./lib/typescript/src/index.d.ts",