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

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
     }
 
     /**
@@ -207,6 +242,45 @@ class BackgroundThreadManager private constructor() {
         }
     }
 
+    // ── Segment Registration (Phase 2.5 spike) ─────────────────────────────
+
+    /**
+     * Register a HBC segment in the background runtime.
+     * Uses CatalystInstance.registerSegment() on the background ReactContext.
+     *
+     * @param segmentId The segment ID to register
+     * @param path Absolute file path to the .seg.hbc file
+     * @throws IllegalStateException if background runtime is not started
+     * @throws IllegalArgumentException if segment file does not exist
+     */
+    fun registerSegmentInBackground(segmentId: Int, path: String) {
+        if (!isStarted) {
+            throw IllegalStateException("Background runtime not started")
+        }
+
+        val file = File(path)
+        if (!file.exists()) {
+            throw IllegalArgumentException("Segment file not found: $path")
+        }
+
+        val context = bgReactHost?.currentReactContext
+            ?: throw IllegalStateException("Background ReactContext not available")
+
+        context.runOnJSQueueThread {
+            try {
+                if (context.hasCatalystInstance()) {
+                    context.catalystInstance.registerSegment(segmentId, path)
+                    BTLogger.info("Segment registered in background runtime: id=$segmentId, path=$path")
+                } else {
+                    BTLogger.error("Background CatalystInstance not available for segment registration")
+                }
+            } catch (e: Exception) {
+                BTLogger.error("Failed to register segment in background runtime: ${e.message}")
+                throw e
+            }
+        }
+    }
+
     // ── Lifecycle ───────────────────────────────────────────────────────────
 
     val isBackgroundStarted: Boolean get() = isStarted

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

@@ -1,5 +1,6 @@
 package com.backgroundthread
 
+import com.facebook.react.bridge.Promise
 import com.facebook.react.bridge.ReactApplicationContext
 import com.facebook.react.module.annotations.ReactModule
 
@@ -26,4 +27,14 @@ class BackgroundThreadModule(reactContext: ReactApplicationContext) :
     override fun startBackgroundRunnerWithEntryURL(entryURL: String) {
         BackgroundThreadManager.getInstance().startBackgroundRunnerWithEntryURL(reactApplicationContext, entryURL)
     }
+
+    override fun loadSegmentInBackground(segmentId: Double, path: String, promise: Promise) {
+        try {
+            BackgroundThreadManager.getInstance()
+                .registerSegmentInBackground(segmentId.toInt(), path)
+            promise.resolve(null)
+        } catch (e: Exception) {
+            promise.reject("BG_SEGMENT_LOAD_ERROR", e.message, e)
+        }
+    }
 }

package/ios/BackgroundRunnerReactNativeDelegate.h

@@ -31,6 +31,13 @@ NS_ASSUME_NONNULL_BEGIN
  */
 - (instancetype)init;
 
+/**
+ * Register a HBC segment in the background runtime (Phase 2.5 spike).
+ * Uses RCTInstance's registerSegmentWithId:path: API.
+ * Must be called after hostDidStart: has completed.
+ */
+- (BOOL)registerSegmentWithId:(NSNumber *)segmentId path:(NSString *)path;
+
 @end
 
 NS_ASSUME_NONNULL_END

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
@@ -175,6 +222,34 @@ static void invokeOptionalGlobalFunction(jsi::Runtime &runtime, const char *name
   }];
 }
 
+#pragma mark - Segment Registration (Phase 2.5 spike)
+
+- (BOOL)registerSegmentWithId:(NSNumber *)segmentId path:(NSString *)path
+{
+  if (!_rctInstance) {
+    [BTLogger error:@"Cannot register segment: background RCTInstance not available"];
+    return NO;
+  }
+
+  @try {
+    SEL sel = NSSelectorFromString(@"registerSegmentWithId:path:");
+    if ([_rctInstance respondsToSelector:sel]) {
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Warc-performSelector-leaks"
+      [_rctInstance performSelector:sel withObject:segmentId withObject:path];
+#pragma clang diagnostic pop
+      [BTLogger info:[NSString stringWithFormat:@"Segment registered in background runtime: id=%@, path=%@", segmentId, path]];
+      return YES;
+    } else {
+      [BTLogger error:@"RCTInstance does not respond to registerSegmentWithId:path:"];
+      return NO;
+    }
+  } @catch (NSException *exception) {
+    [BTLogger error:[NSString stringWithFormat:@"Failed to register segment: %@", exception.reason]];
+    return NO;
+  }
+}
+
 #pragma mark - RCTTurboModuleManagerDelegate
 
 - (id<RCTModuleProvider>)getModuleProvider:(const char *)name

package/ios/BackgroundThread.h

@@ -5,5 +5,9 @@
 - (void)startBackgroundRunner;
 - (void)startBackgroundRunnerWithEntryURL:(NSString *)entryURL;
 - (void)installSharedBridge;
+- (void)loadSegmentInBackground:(double)segmentId
+                           path:(NSString *)path
+                        resolve:(RCTPromiseResolveBlock)resolve
+                         reject:(RCTPromiseRejectBlock)reject;
 
 @end

package/ios/BackgroundThread.mm

@@ -29,6 +29,22 @@
     [BTLogger info:@"installSharedBridge called (no-op on iOS, installed from AppDelegate)"];
 }
 
+- (void)loadSegmentInBackground:(double)segmentId
+                           path:(NSString *)path
+                        resolve:(RCTPromiseResolveBlock)resolve
+                         reject:(RCTPromiseRejectBlock)reject {
+    BackgroundThreadManager *manager = [BackgroundThreadManager sharedInstance];
+    [manager registerSegmentInBackground:@((int)segmentId)
+                                    path:path
+                              completion:^(NSError * _Nullable error) {
+        if (error) {
+            reject(@"BG_SEGMENT_LOAD_ERROR", error.localizedDescription, error);
+        } else {
+            resolve(nil);
+        }
+    }];
+}
+
 + (NSString *)moduleName
 {
   return @"BackgroundThread";

package/ios/BackgroundThreadManager.h

@@ -26,6 +26,14 @@ NS_ASSUME_NONNULL_BEGIN
 /// Check if background runner is started
 @property (nonatomic, readonly) BOOL isStarted;
 
+/// Register a HBC segment in the background runtime (Phase 2.5 spike)
+/// @param segmentId The segment ID to register
+/// @param path Absolute file path to the .seg.hbc file
+/// @param completion Callback with nil error on success, or NSError on failure
+- (void)registerSegmentInBackground:(NSNumber *)segmentId
+                               path:(NSString *)path
+                         completion:(void (^)(NSError * _Nullable error))completion;
+
 @end
 
 NS_ASSUME_NONNULL_END

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
@@ -117,4 +115,40 @@ static NSString *const MODULE_DEBUG_URL = @"http://localhost:8082/apps/mobile/ba
     });
 }
 
+#pragma mark - Segment Registration (Phase 2.5 spike)
+
+- (void)registerSegmentInBackground:(NSNumber *)segmentId
+                               path:(NSString *)path
+                         completion:(void (^)(NSError * _Nullable error))completion
+{
+    if (!self.isStarted || !self.reactNativeFactoryDelegate) {
+        NSError *error = [NSError errorWithDomain:@"BackgroundThread"
+                                             code:1
+                                         userInfo:@{NSLocalizedDescriptionKey: @"Background runtime not started"}];
+        if (completion) completion(error);
+        return;
+    }
+
+    // Verify the file exists
+    if (![[NSFileManager defaultManager] fileExistsAtPath:path]) {
+        NSError *error = [NSError errorWithDomain:@"BackgroundThread"
+                                             code:2
+                                         userInfo:@{NSLocalizedDescriptionKey:
+                                                        [NSString stringWithFormat:@"Segment file not found: %@", path]}];
+        if (completion) completion(error);
+        return;
+    }
+
+    BOOL success = [self.reactNativeFactoryDelegate registerSegmentWithId:segmentId path:path];
+    if (success) {
+        if (completion) completion(nil);
+    } else {
+        NSError *error = [NSError errorWithDomain:@"BackgroundThread"
+                                             code:3
+                                         userInfo:@{NSLocalizedDescriptionKey:
+                                                        @"Failed to register segment in background runtime"}];
+        if (completion) completion(error);
+    }
+}
+
 @end

package/lib/module/NativeBackgroundThread.js.map

@@ -1 +1 @@
-{"version":3,"names":["TurboModuleRegistry","getEnforcing"],"sourceRoot":"../../src","sources":["NativeBackgroundThread.ts"],"mappings":";;AAAA,SAASA,mBAAmB,QAAQ,cAAc;AAQlD,eAAeA,mBAAmB,CAACC,YAAY,CAAO,kBAAkB,CAAC","ignoreList":[]}
+{"version":3,"names":["TurboModuleRegistry","getEnforcing"],"sourceRoot":"../../src","sources":["NativeBackgroundThread.ts"],"mappings":";;AAAA,SAASA,mBAAmB,QAAQ,cAAc;AAYlD,eAAeA,mBAAmB,CAACC,YAAY,CAAO,kBAAkB,CAAC","ignoreList":[]}

package/lib/typescript/src/NativeBackgroundThread.d.ts

@@ -2,6 +2,7 @@ import type { TurboModule } from 'react-native';
 export interface Spec extends TurboModule {
     startBackgroundRunnerWithEntryURL(entryURL: string): void;
     installSharedBridge(): void;
+    loadSegmentInBackground(segmentId: number, path: string): Promise<void>;
 }
 declare const _default: Spec;
 export default _default;

package/lib/typescript/src/NativeBackgroundThread.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"NativeBackgroundThread.d.ts","sourceRoot":"","sources":["../../../src/NativeBackgroundThread.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAChD,MAAM,WAAW,IAAK,SAAQ,WAAW;IACvC,iCAAiC,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;IAC1D,mBAAmB,IAAI,IAAI,CAAC;CAC7B;;AAED,wBAA0E"}
+{"version":3,"file":"NativeBackgroundThread.d.ts","sourceRoot":"","sources":["../../../src/NativeBackgroundThread.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAChD,MAAM,WAAW,IAAK,SAAQ,WAAW;IACvC,iCAAiC,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;IAC1D,mBAAmB,IAAI,IAAI,CAAC;IAC5B,uBAAuB,CACrB,SAAS,EAAE,MAAM,EACjB,IAAI,EAAE,MAAM,GACX,OAAO,CAAC,IAAI,CAAC,CAAC;CAClB;;AAED,wBAA0E"}

package/package.json

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

package/src/NativeBackgroundThread.ts

@@ -4,6 +4,10 @@ import type { TurboModule } from 'react-native';
 export interface Spec extends TurboModule {
   startBackgroundRunnerWithEntryURL(entryURL: string): void;
   installSharedBridge(): void;
+  loadSegmentInBackground(
+    segmentId: number,
+    path: string,
+  ): Promise<void>;
 }
 
 export default TurboModuleRegistry.getEnforcing<Spec>('BackgroundThread');