@onekeyfe/react-native-background-thread 3.0.20 → 3.0.22

package/ios/BackgroundRunnerReactNativeDelegate.mm

@@ -95,6 +95,49 @@ static NSURL *resolveMainBundleResourceURL(NSString *resourceName)
                                  withExtension:extension.length > 0 ? extension : nil];
 }
 
+/// Reflectively query BundleUpdateStore for an OTA-installed bundle path.
+/// Mirrors the cross-framework reflection pattern used by SplitBundleLoader
+/// (we can't import the Swift module directly because its umbrella header
+/// pulls in C++/Nitro headers that break the Clang dependency scanner).
+/// Returns nil when the selector is absent (older bundle-update package) or
+/// when no OTA is currently active.
+static NSString *resolveOtaBundlePath(NSString *selectorName)
+{
+  Class cls = NSClassFromString(@"ReactNativeBundleUpdate.BundleUpdateStore");
+  if (!cls) return nil;
+  SEL sel = NSSelectorFromString(selectorName);
+  if (![cls respondsToSelector:sel]) return nil;
+  NSMethodSignature *sig = [cls methodSignatureForSelector:sel];
+  if (!sig || strcmp(sig.methodReturnType, @encode(id)) != 0) return nil;
+  NSInvocation *inv = [NSInvocation invocationWithMethodSignature:sig];
+  inv.target = cls;
+  inv.selector = sel;
+  [inv invoke];
+  __unsafe_unretained id raw = nil;
+  [inv getReturnValue:&raw];
+  if (![raw isKindOfClass:[NSString class]]) return nil;
+  NSString *result = (NSString *)raw;
+  if (result.length == 0) return nil;
+  if ([result hasPrefix:@"file://"]) {
+    result = [[NSURL URLWithString:result] path];
+  }
+  if (![[NSFileManager defaultManager] fileExistsAtPath:result]) return nil;
+  return result;
+}
+
+/// True when an OTA-installed main bundle is currently active. Used to
+/// prevent falling back to IPA built-in common/background bundles when the
+/// foreground main runtime has already loaded an OTA main: a mixed
+/// OTA-main + IPA-built-in pair would moduleId-mismatch and crash on first
+/// require(). Without this guard, package skew (split-bundle-loader/
+/// background-thread upgraded but bundle-update still on a version that
+/// doesn't expose currentBundleCommonJSBundle) would silently reintroduce
+/// the very crash this patch was added to fix.
+static BOOL isOtaMainBundleActive(void)
+{
+  return resolveOtaBundlePath(@"currentBundleMainJSBundle") != nil;
+}
+
 static NSURL *resolveBundleSourceURL(NSString *jsBundleSourceNS)
 {
   if (jsBundleSourceNS.length == 0) {
@@ -120,6 +163,21 @@ static NSURL *resolveBundleSourceURL(NSString *jsBundleSourceNS)
   RCTInstance *_rctInstance;
   std::string _origin;
   std::string _jsBundleSource;
+  // YES when `bundleURL` observed an active OTA main bundle on its most
+  // recent invocation, regardless of whether OTA common actually resolved.
+  // Captures the invariant "this delegate is locked to OTA territory; IPA
+  // built-in fallbacks for the matching common/background bundle are
+  // unsafe", covering both:
+  //   1. OTA common was resolved (loaded). IPA built-in background would
+  //      moduleId-mismatch the OTA common.
+  //   2. OTA common was unresolvable but OTA main was active (`bundleURL`
+  //      returned nil). hostDidStart shouldn't fire in this case under
+  //      normal RCTHost lifecycle, but if it ever does, we must not let
+  //      `resolveBackgroundEntryBundlePath` happily fall back to IPA bg.
+  // `resolveBackgroundEntryBundlePath` and `hostDidStart` consult the flag
+  // to distinguish those fatal cases from the legitimate "this build was
+  // never split" case (no OTA, no background bundled — warn and continue).
+  BOOL _otaActiveAtBundleResolve;
 }
 
 - (void)cleanupResources;
@@ -136,6 +194,7 @@ static NSURL *resolveBundleSourceURL(NSString *jsBundleSourceNS)
   if (self = [super init]) {
     _hasOnMessageHandler = NO;
     _hasOnErrorHandler = NO;
+    _otaActiveAtBundleResolve = NO;
     self.dependencyProvider = [[RCTAppDependencyProvider alloc] init];
   }
   return self;
@@ -170,6 +229,10 @@ static NSURL *resolveBundleSourceURL(NSString *jsBundleSourceNS)
 
 - (NSURL *)bundleURL
 {
+  // Reset on every call so a re-entry (e.g. host restart) can't carry over
+  // a stale OTA assertion from a previous load.
+  _otaActiveAtBundleResolve = NO;
+
   // 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()) {
@@ -183,16 +246,64 @@ static NSURL *resolveBundleSourceURL(NSString *jsBundleSourceNS)
   }
 
   // Default: load common bundle (shared polyfills + modules).
-  // The background entry bundle is loaded later in hostDidStart:.
-  NSURL *commonURL = resolveMainBundleResourceURL(@"common.jsbundle");
+  // Prefer OTA-installed common.bundle so a three-bundle OTA update is
+  // actually picked up by the background runtime; fall back to the IPA
+  // built-in common.bundle when no OTA is active. Without this, OTA
+  // would push a new common.bundle to disk but the background runtime
+  // would keep loading the stale built-in copy and crash on
+  // moduleId mismatch with the OTA-loaded background.bundle.
+  NSString *otaCommonPath = resolveOtaBundlePath(@"currentBundleCommonJSBundle");
+  if (otaCommonPath) {
+    [BTLogger info:[NSString stringWithFormat:@"BackgroundRuntime: using OTA common bundle at %@", otaCommonPath]];
+    // OTA common resolved implies OTA main is active; the matching OTA
+    // background MUST be used (IPA bg would moduleId-mismatch).
+    _otaActiveAtBundleResolve = YES;
+    return [NSURL fileURLWithPath:otaCommonPath];
+  }
+
+  // Mixed-state guard: if OTA main is loaded but OTA common is unresolvable,
+  // refusing the IPA fallback is safer than crashing on moduleId mismatch.
+  // Returning nil aborts the background runtime; the foreground main runtime
+  // would have crashed anyway, so this just makes the failure mode loud.
+  if (isOtaMainBundleActive()) {
+    // Set the flag here too so the invariant ("OTA was active when bundleURL
+    // ran") holds regardless of whether OTA common resolved. Under normal
+    // RCTHost lifecycle hostDidStart won't run after we return nil, but if
+    // it ever does (host retry, lifecycle bug, future refactor), the flag
+    // ensures the same fatal-abort branch is taken.
+    _otaActiveAtBundleResolve = YES;
+    [BTLogger error:@"BackgroundRuntime: OTA main is active but OTA common bundle is unresolvable — refusing IPA fallback to avoid moduleId mismatch crash"];
+    return nil;
+  }
+
+  NSURL *commonURL = resolveMainBundleResourceURL(@"common.bundle");
   if (commonURL) {
     return commonURL;
   }
-  return [[NSBundle mainBundle] URLForResource:@"common" withExtension:@"jsbundle"];
+  return [[NSBundle mainBundle] URLForResource:@"common" withExtension:@"bundle"];
 }
 
 - (NSString *)resolveBackgroundEntryBundlePath
 {
+  // Prefer OTA-installed background.bundle; fall back to IPA built-in.
+  NSString *otaBackgroundPath = resolveOtaBundlePath(@"currentBundleBackgroundJSBundle");
+  if (otaBackgroundPath) {
+    [BTLogger info:[NSString stringWithFormat:@"BackgroundRuntime: using OTA background bundle at %@", otaBackgroundPath]];
+    return otaBackgroundPath;
+  }
+
+  // Mixed-state guard: bundleURL set _otaActiveAtBundleResolve when it
+  // observed an active OTA main on its most recent invocation (whether or
+  // not OTA common itself resolved). The IPA built-in background.bundle was
+  // built against the IPA common.bundle, so its moduleIds won't line up
+  // with whatever OTA bundle the foreground runtime is using — IPA fallback
+  // would crash on first require(). Return nil; hostDidStart consults the
+  // same flag and aborts loudly instead of continuing with a broken runtime.
+  if (_otaActiveAtBundleResolve) {
+    [BTLogger error:@"BackgroundRuntime: OTA main is active but OTA background is unresolvable — refusing IPA fallback to avoid moduleId mismatch crash"];
+    return nil;
+  }
+
   NSURL *url = resolveMainBundleResourceURL(@"background.bundle");
   return url.path;
 }
@@ -228,6 +339,22 @@ static NSURL *resolveBundleSourceURL(NSString *jsBundleSourceNS)
       bgBundleSourceURL = bgBundlePath.lastPathComponent ?: @"background.bundle";
       [BTLogger info:[NSString stringWithFormat:@"Background entry bundle loaded from %@ (%lu bytes)",
                       bgBundlePath, (unsigned long)bgBundleData.length]];
+    } else if (_otaActiveAtBundleResolve) {
+      // Fatal: bundleURL committed to OTA territory (loaded OTA common, or
+      // detected OTA main and refused IPA fallback) but the matching OTA
+      // background couldn't be resolved. Setting up SharedStore / SharedRPC
+      // and calling __setupBackgroundRPCHandler against a runtime with no
+      // entry bundle would leave RPC silently broken; falling back to IPA
+      // bg would moduleId-mismatch and crash. Abort loudly.
+      //
+      // Clear _rctInstance before returning so registerSegmentWithId (and
+      // any other downstream method that gates on `_rctInstance != nil`)
+      // doesn't operate on a half-initialized runtime where SharedStore /
+      // SharedRPC / error handler / __setupBackgroundRPCHandler were all
+      // skipped.
+      [BTLogger error:@"BackgroundRuntime: aborting hostDidStart — OTA bundle is loaded but OTA background bundle is unresolvable"];
+      _rctInstance = nil;
+      return;
     } else {
       [BTLogger warn:@"Background entry bundle not found, __setupBackgroundRPCHandler may not be defined"];
     }

package/ios/BackgroundThreadManager.mm

@@ -109,7 +109,7 @@ static NSString *const MODULE_DEBUG_URL = @"http://localhost:8082/apps/mobile/ba
 
         // Only set jsBundleSource for debug HTTP URLs or explicit OTA overrides.
         // Leaving the default release name ("background.bundle") unset lets the
-        // delegate fall back to split-bundle mode (common.jsbundle + entry).
+        // delegate fall back to split-bundle mode (common.bundle + entry).
         if (![entryURL isEqualToString:@"background.bundle"]) {
             [self.reactNativeFactoryDelegate setJsBundleSource:std::string([entryURL UTF8String])];
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@onekeyfe/react-native-background-thread",
-  "version": "3.0.20",
+  "version": "3.0.22",
   "description": "react-native-background-thread",
   "main": "./lib/module/index.js",
   "types": "./lib/typescript/src/index.d.ts",
@@ -84,6 +84,7 @@
     "typescript": "^5.9.2"
   },
   "peerDependencies": {
+    "@onekeyfe/react-native-bundle-update": ">=3.0.22",
     "react": "*",
     "react-native": "*"
   },