@onekeyfe/react-native-background-thread 1.1.47 → 1.1.48

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

@@ -1,5 +1,6 @@
 package com.backgroundthread
 
+import android.net.Uri
 import com.facebook.react.ReactPackage
 import com.facebook.proguard.annotations.DoNotStrip
 import com.facebook.react.ReactInstanceEventListener
@@ -14,6 +15,7 @@ import com.facebook.react.fabric.ComponentFactory
 import com.facebook.react.runtime.ReactHostImpl
 import com.facebook.react.runtime.hermes.HermesInstance
 import com.facebook.react.shell.MainReactPackage
+import java.io.File
 
 /**
  * Singleton manager for the background React Native runtime.
@@ -92,13 +94,61 @@ class BackgroundThreadManager private constructor() {
 
     // ── Background runner lifecycle ─────────────────────────────────────────
 
+    private fun isRemoteBundleUrl(entryURL: String): Boolean {
+        return entryURL.startsWith("http://") || entryURL.startsWith("https://")
+    }
+
+    private fun resolveLocalBundlePath(entryURL: String): String? {
+        if (entryURL.startsWith("file://")) {
+            return Uri.parse(entryURL).path
+        }
+        if (entryURL.startsWith("/")) {
+            return entryURL
+        }
+        return null
+    }
+
+    private fun createDownloadedBundleLoader(appContext: android.content.Context, entryURL: String): JSBundleLoader {
+        return object : JSBundleLoader() {
+            override fun loadScript(delegate: com.facebook.react.bridge.JSBundleLoaderDelegate): String {
+                val tempFile = File(appContext.cacheDir, "background.bundle")
+                try {
+                    java.net.URL(entryURL).openStream().use { input ->
+                        tempFile.outputStream().use { output ->
+                            input.copyTo(output)
+                        }
+                    }
+                    BTLogger.info("Background bundle downloaded to ${tempFile.absolutePath}")
+                } catch (e: Exception) {
+                    BTLogger.error("Failed to download background bundle: ${e.message}")
+                    throw RuntimeException("Failed to download background bundle from $entryURL", e)
+                }
+                delegate.loadScriptFromFile(tempFile.absolutePath, entryURL, false)
+                return entryURL
+            }
+        }
+    }
+
+    private fun createLocalFileBundleLoader(localPath: String, sourceURL: String): JSBundleLoader {
+        return object : JSBundleLoader() {
+            override fun loadScript(delegate: com.facebook.react.bridge.JSBundleLoaderDelegate): String {
+                val bundleFile = File(localPath)
+                if (!bundleFile.exists()) {
+                    BTLogger.error("Background bundle file does not exist: $localPath")
+                    throw RuntimeException("Background bundle file does not exist: $localPath")
+                }
+                delegate.loadScriptFromFile(bundleFile.absolutePath, sourceURL, false)
+                return sourceURL
+            }
+        }
+    }
+
     @OptIn(UnstableReactNativeAPI::class)
     fun startBackgroundRunnerWithEntryURL(context: ReactApplicationContext, entryURL: String) {
         if (isStarted) {
             BTLogger.warn("Background runner already started")
             return
         }
-        isStarted = true
         BTLogger.info("Starting background runner with entryURL: $entryURL")
 
         val appContext = context.applicationContext
@@ -106,34 +156,18 @@ class BackgroundThreadManager private constructor() {
             if (reactPackages.isNotEmpty()) {
                 reactPackages
             } else {
-                BTLogger.warn("No ReactPackages registered for background runtime; falling back to MainReactPackage only")
+                BTLogger.warn("No ReactPackages registered for background runtime; call setReactPackages(...) from host before start. Falling back to MainReactPackage only.")
                 listOf(MainReactPackage())
             }
 
-        val bundleLoader = if (entryURL.startsWith("http")) {
-            // Dev server: download bundle to temp file first, then load from file.
-            // loadScriptFromFile only accepts local file paths, not HTTP URLs.
-            object : JSBundleLoader() {
-                override fun loadScript(delegate: com.facebook.react.bridge.JSBundleLoaderDelegate): String {
-                    val tempFile = java.io.File(appContext.cacheDir, "background.bundle")
-                    try {
-                        java.net.URL(entryURL).openStream().use { input ->
-                            tempFile.outputStream().use { output ->
-                                input.copyTo(output)
-                            }
-                        }
-                        BTLogger.info("Background bundle downloaded to ${tempFile.absolutePath}")
-                    } catch (e: Exception) {
-                        BTLogger.error("Failed to download background bundle: ${e.message}")
-                        throw RuntimeException("Failed to download background bundle from $entryURL", e)
-                    }
-                    delegate.loadScriptFromFile(tempFile.absolutePath, entryURL, false)
-                    return entryURL
-                }
+        val localBundlePath = resolveLocalBundlePath(entryURL)
+        val bundleLoader =
+            when {
+                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)
             }
-        } else {
-            JSBundleLoader.createAssetLoader(appContext, "assets://$entryURL", true)
-        }
 
         val delegate = DefaultReactHostDelegate(
             jsMainModulePath = MODULE_NAME,
@@ -177,6 +211,7 @@ class BackgroundThreadManager private constructor() {
         })
 
         host.start()
+        isStarted = true
     }
 
     /**

package/ios/BackgroundRunnerReactNativeDelegate.mm

@@ -71,6 +71,51 @@ static void invokeOptionalGlobalFunction(jsi::Runtime &runtime, const char *name
   }
 }
 
+static NSURL *resolveMainBundleResourceURL(NSString *resourceName)
+{
+  if (resourceName.length == 0) {
+    return nil;
+  }
+
+  NSURL *directURL = [[NSBundle mainBundle] URLForResource:resourceName withExtension:nil];
+  if (directURL) {
+    return directURL;
+  }
+
+  NSString *normalizedName = [resourceName hasPrefix:@"/"]
+      ? resourceName.lastPathComponent
+      : resourceName;
+  NSString *extension = normalizedName.pathExtension;
+  NSString *baseName = normalizedName.stringByDeletingPathExtension;
+  if (baseName.length == 0) {
+    return nil;
+  }
+
+  return [[NSBundle mainBundle] URLForResource:baseName
+                                 withExtension:extension.length > 0 ? extension : nil];
+}
+
+static NSURL *resolveBundleSourceURL(NSString *jsBundleSourceNS)
+{
+  if (jsBundleSourceNS.length == 0) {
+    return nil;
+  }
+
+  NSURL *parsedURL = [NSURL URLWithString:jsBundleSourceNS];
+  if (parsedURL.scheme.length > 0) {
+    if (parsedURL.isFileURL && parsedURL.path.length > 0) {
+      return [NSURL fileURLWithPath:parsedURL.path];
+    }
+    return parsedURL;
+  }
+
+  if ([jsBundleSourceNS hasPrefix:@"/"]) {
+    return [NSURL fileURLWithPath:jsBundleSourceNS];
+  }
+
+  return resolveMainBundleResourceURL(jsBundleSourceNS);
+}
+
 @interface BackgroundReactNativeDelegate () {
   RCTInstance *_rctInstance;
   std::string _origin;
@@ -127,17 +172,19 @@ static void invokeOptionalGlobalFunction(jsi::Runtime &runtime, const char *name
 {
   if (!_jsBundleSource.empty()) {
     NSString *jsBundleSourceNS = [NSString stringWithUTF8String:_jsBundleSource.c_str()];
-    NSURL *url = [NSURL URLWithString:jsBundleSourceNS];
-    if (url && url.scheme) {
-      return url;
+    NSURL *resolvedURL = resolveBundleSourceURL(jsBundleSourceNS);
+    if (resolvedURL) {
+      return resolvedURL;
     }
 
-    if ([jsBundleSourceNS hasSuffix:@".jsbundle"]) {
-      return [[NSBundle mainBundle] URLForResource:jsBundleSourceNS withExtension:nil];
-    }
+    [BTLogger warn:[NSString stringWithFormat:@"Unable to resolve custom jsBundleSource=%@", jsBundleSourceNS]];
   }
 
-  return [[NSBundle mainBundle] URLForResource: @"background" withExtension: @"bundle"];
+  NSURL *defaultBundleURL = resolveMainBundleResourceURL(@"background.bundle");
+  if (defaultBundleURL) {
+    return defaultBundleURL;
+  }
+  return [[NSBundle mainBundle] URLForResource:@"background" withExtension:@"bundle"];
 }
 
 - (void)hostDidStart:(RCTHost *)host

package/ios/BackgroundThreadManager.mm

@@ -107,9 +107,7 @@ static NSString *const MODULE_DEBUG_URL = @"http://localhost:8082/apps/mobile/ba
         self.reactNativeFactoryDelegate = [[BackgroundReactNativeDelegate alloc] init];
         self.reactNativeFactory = [[RCTReactNativeFactory alloc] initWithDelegate:self.reactNativeFactoryDelegate];
 
-        #if DEBUG
-            [self.reactNativeFactoryDelegate setJsBundleSource:std::string([entryURL UTF8String])];
-        #endif
+        [self.reactNativeFactoryDelegate setJsBundleSource:std::string([entryURL UTF8String])];
 
         [self.reactNativeFactory.rootViewFactory viewWithModuleName:MODULE_NAME
                                                      initialProperties:initialProperties

package/package.json

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