@callstack/react-native-brownfield 5.2.0 → 6.0.0

package/ios/BrownfieldPerformanceBridge.mm

@@ -0,0 +1,103 @@
+#import "BrownfieldPerformanceBridge.h"
+#import <React/RCTBridge.h>
+#import <React/RCTBridge+Private.h>
+#import <React/RCTBridgeModule.h>
+#import <React/RCTConstants.h>
+#import <objc/runtime.h>
+#include <atomic>
+
+// Accessed on main, like BrownfieldDisplaySession.
+static __weak RCTBridge *sPerformanceBridge;
+static __weak NSThread *sJavaScriptThread;
+static std::atomic<uint64_t> sGeneration{0};
+
+static void BrownfieldPerformanceReset(void)
+{
+  ++sGeneration;
+  sPerformanceBridge = nil;
+  sJavaScriptThread = nil;
+}
+
+@implementation BrownfieldPerformanceBridge
++ (BOOL)dispatchToJavaScript:(dispatch_block_t)block
+{
+  NSThread *thread = sJavaScriptThread;
+  if (thread && !thread.finished && !thread.cancelled) {
+    [self performSelector:@selector(runJavaScriptBlock:)
+                 onThread:thread
+               withObject:[block copy]
+            waitUntilDone:NO
+                    modes:@[NSRunLoopCommonModes]];
+    return YES;
+  }
+
+  RCTBridge *bridge = sPerformanceBridge;
+  // NSProxy's respondsToSelector: does not reliably describe RCTBridgeProxy.
+  if (!bridge || !class_getInstanceMethod(object_getClass(bridge), @selector(dispatchBlock:queue:))) {
+    return NO;
+  }
+  [bridge dispatchBlock:block queue:RCTJSThread];
+  return YES;
+}
+
++ (void)runJavaScriptBlock:(dispatch_block_t)block
+{
+  block();
+}
+@end
+
+// A separate iOS-only module leaves Android's generated module contract unchanged.
+@interface BrownfieldPerformance : NSObject <RCTBridgeModule>
+@end
+@implementation BrownfieldPerformance
+RCT_EXPORT_MODULE();
++ (BOOL)requiresMainQueueSetup { return NO; }
+RCT_EXPORT_METHOD(markFullyDisplayed:(NSString *)presentationID)
+{
+  dispatch_async(dispatch_get_main_queue(), ^{
+    [[NSNotificationCenter defaultCenter] postNotificationName:@"BrownfieldMarkFullyDisplayed"
+                                                      object:presentationID];
+  });
+}
+@end
+
+__attribute__((constructor)) static void BrownfieldPerformanceRegister(void)
+{
+  // Bridgeless RN (including 0.86) posts synchronously from loadScript's afterLoad
+  // callback on the JS thread. Observe without a queue so we capture that thread,
+  // whose run loop is maintained by RCTJSThreadManager. currentBridge is a stub
+  // when the legacy architecture is removed, and this notification has no payload.
+  [[NSNotificationCenter defaultCenter] addObserverForName:@"RCTInstanceDidLoadBundle"
+      object:nil queue:nil usingBlock:^(__unused NSNotification *notification) {
+    const auto generation = sGeneration.load();
+    NSThread *thread = NSThread.currentThread;
+    if (thread.isMainThread) {
+      return;
+    }
+    dispatch_async(dispatch_get_main_queue(), ^{
+      if (generation != sGeneration.load()) {
+        return;
+      }
+      sJavaScriptThread = thread;
+      sPerformanceBridge = nil;
+      [[NSNotificationCenter defaultCenter] postNotificationName:@"BrownfieldPerformanceBridgeReady" object:nil];
+    });
+  }];
+  [[NSNotificationCenter defaultCenter] addObserverForName:RCTJavaScriptDidLoadNotification
+      object:nil queue:NSOperationQueue.mainQueue usingBlock:^(NSNotification *notification) {
+    sPerformanceBridge = notification.userInfo[@"bridge"];
+    // Newer RN also sends this notification after the instance notification.
+    // Announcing readiness twice would cancel an already attached display session.
+    if (!sJavaScriptThread) {
+      [[NSNotificationCenter defaultCenter] postNotificationName:@"BrownfieldPerformanceBridgeReady" object:nil];
+    }
+  }];
+  [[NSNotificationCenter defaultCenter] addObserverForName:@"BrownfieldPerformanceStop"
+      object:nil queue:NSOperationQueue.mainQueue usingBlock:^(__unused NSNotification *notification) {
+    BrownfieldPerformanceReset();
+  }];
+  [[NSNotificationCenter defaultCenter] addObserverForName:RCTJavaScriptDidFailToLoadNotification
+      object:nil queue:NSOperationQueue.mainQueue usingBlock:^(__unused NSNotification *notification) {
+    BrownfieldPerformanceReset();
+  }];
+}

package/ios/Expo/ExpoHostRuntime.swift

@@ -15,6 +15,17 @@ final class ExpoHostRuntime {
   private var delegate = ExpoHostRuntimeDelegate()
   private var reactNativeFactory: RCTReactNativeFactory?
   private var expoDelegate: ExpoAppDelegate?
+  #if canImport(EXUpdates)
+  private let updatesStartup = ExpoUpdatesStartup()
+  #endif
+
+  func prepareReactNative(_ completion: @escaping () -> Void) {
+    #if canImport(EXUpdates)
+    updatesStartup.prepareReactNative(completion)
+    #else
+    completion()
+    #endif
+  }
 
   private func configureDevLoadingView(with bundleURL: URL? = nil) {
     #if DEBUG
@@ -37,7 +48,7 @@ final class ExpoHostRuntime {
    *
    * @param onBundleLoaded Optional callback invoked on the main thread after JS bundle is fully loaded.
    */
-  public func startReactNative(onBundleLoaded: (() -> Void)?) {
+  public func startReactNative(onBundleLoaded: ((JSBundleTimings) -> Void)?) {
     // The callback registration is outside of the guard below. An earlier `startReactNative` call
     // can already have made the factory, and the callback must still run.
     if let onBundleLoaded {
@@ -73,6 +84,9 @@ final class ExpoHostRuntime {
     reactNativeFactory = nil
     expoDelegate = nil
     preloadState.reset()
+    #if canImport(EXUpdates)
+    updatesStartup.cancelPendingRequests()
+    #endif
   }
 
   /**
@@ -164,11 +178,42 @@ final class ExpoHostRuntime {
     return ExpoAppDelegateSubscriberManager.application(application, willFinishLaunchingWithOptions: launchOptions)
   }
 
+  /// `onRootView` receives the React Native root view, or `nil` when React Native can't create
+  /// it. While Updates selects its launch asset, this happens after `view` returns a container.
   func view(
+    moduleName: String,
+    initialProps: [AnyHashable: Any]?,
+    launchOptions: [AnyHashable: Any]?,
+    onRootView: ((UIView?) -> Void)? = nil
+  ) -> UIView? {
+    // Return a container while Updates selects its launch asset. This also supports the
+    // public view API, which does not go through ReactNativeViewController.
+    let container = UIView()
+    var immediateView: UIView?
+    var preparing = true
+    prepareReactNative { [weak self, weak container] in
+      guard let self, preparing || container != nil else { return }
+      let root = self.createView(moduleName: moduleName, initialProps: initialProps,
+                                 launchOptions: launchOptions)
+      if preparing {
+        immediateView = root
+      } else if let container, let root {
+        root.frame = container.bounds
+        root.autoresizingMask = [.flexibleWidth, .flexibleHeight]
+        container.addSubview(root)
+      }
+      onRootView?(root)
+    }
+    preparing = false
+    return immediateView ?? container
+  }
+
+  private func createView(
     moduleName: String,
     initialProps: [AnyHashable: Any]?,
     launchOptions: [AnyHashable: Any]?
   ) -> UIView? {
+    startReactNative()
     let bundleURL = delegate.bundleURL()
     configureDevLoadingView(with: bundleURL)
 
@@ -201,8 +246,8 @@ extension ExpoHostRuntime: ReactHostPreloading {
 
   /**
    * expo-dev-launcher finds the Metro URL only after the user selects an app in the launcher. This
-   * is a Debug behavior. In Release the class is in the binary, but it does nothing. Thus this
-   * check is also only in Debug.
+   * is a Debug behavior. Packaged apps opting into an embedded bundle or an explicit URL
+   * can preload without the launcher. In Release the launcher does nothing.
    *
    * The check reads the class name, because this pod has no dependency on expo-dev-launcher.
    * `EXDevLauncherController` is the name in expo-dev-launcher 56 and 57. If a later version
@@ -213,7 +258,8 @@ extension ExpoHostRuntime: ReactHostPreloading {
    */
   func canPreloadReactNative() -> Bool {
     #if DEBUG
-    if NSClassFromString("EXDevLauncherController") != nil {
+    if !preferEmbeddedBundleInDebug && bundleURLOverride?() == nil,
+      NSClassFromString("EXDevLauncherController") != nil {
       return false
     }
     #endif
@@ -251,8 +297,8 @@ class ExpoHostRuntimeDelegate: ExpoReactNativeFactoryDelegate {
       }
 
       #if canImport(EXUpdates)
-      if !isDebug,
-        AppController.isInitialized(),
+      if AppController.isInitialized(),
+        AppController.sharedInstance.isActiveController,
         let launchAssetURL = AppController.sharedInstance.launchAssetUrl()
       {
         return launchAssetURL
@@ -286,20 +332,18 @@ class ExpoHostRuntimeDelegate: ExpoReactNativeFactoryDelegate {
    *
    * The override wins over every other step, thus an override makes the URL stable.
    *
-   * expo-updates selects the launch asset while `AppController` starts. `ReactNativeViewController`
-   * starts `AppController`. Before this operation is complete, `launchAssetUrl()` is nil, and
-   * `bundleURL()` gives the embedded bundle. A host from that time keeps the embedded bundle, and
-   * Expo never applies the update. Thus the URL is stable only after `launchAssetUrl()` has a
-   * value. The class can be in the binary while the app does not use it, thus this check reads the
-   * state and not the class.
+   * The shared runtime waits for Updates before preloading or creating views. Inactive
+   * controllers use the normal bundle resolver and do not need an Updates launch asset.
    */
   var isBundleURLStable: Bool {
     if bundleURLOverride?() != nil {
       return true
     }
 
-    #if canImport(EXUpdates) && !DEBUG
-    return AppController.isInitialized() && AppController.sharedInstance.launchAssetUrl() != nil
+    #if canImport(EXUpdates)
+    guard AppController.isInitialized() else { return false }
+    return !AppController.sharedInstance.isActiveController
+      || AppController.sharedInstance.launchAssetUrl() != nil
     #else
     return true
     #endif

package/ios/Expo/ExpoUpdatesStartup.swift

@@ -0,0 +1,49 @@
+#if canImport(EXUpdates)
+import Foundation
+internal import EXUpdates
+
+final class ExpoUpdatesStartup: NSObject {
+  private var updatesReady = false
+  private var updatesCallbacks: [() -> Void] = []
+
+  // Updates belongs to the application lifetime, not to a view or React Host session.
+  // Inactive controllers (including DevLauncherAppController) must never be started here.
+  func prepareReactNative(_ completion: @escaping () -> Void) {
+    if !Thread.isMainThread {
+      DispatchQueue.main.async { [weak self] in self?.prepareReactNative(completion) }
+      return
+    }
+    AppController.initializeWithoutStarting()
+    let controller = AppController.sharedInstance
+    guard controller.isActiveController else { completion(); return }
+    if updatesReady || controller.launchAssetUrl() != nil {
+      completion()
+      return
+    }
+    updatesCallbacks.append(completion)
+    controller.delegate = self
+    if !controller.isStarted {
+      controller.start()
+    }
+  }
+
+  func cancelPendingRequests() { updatesCallbacks.removeAll() }
+}
+#endif
+
+#if canImport(EXUpdates)
+extension ExpoUpdatesStartup: AppControllerDelegate {
+  func appController(_ appController: any AppControllerInterface, didStartWithSuccess success: Bool) {
+    DispatchQueue.main.async { [weak self] in
+      guard let self else { return }
+      self.updatesReady = true
+      if !success {
+        NSLog("%@", "Expo Updates failed to select a launch asset; using the bundle resolver fallback.")
+      }
+      let callbacks = self.updatesCallbacks
+      self.updatesCallbacks.removeAll()
+      callbacks.forEach { $0() }
+    }
+  }
+}
+#endif

package/ios/JSBundleLoadObserver.swift

@@ -1,33 +1,39 @@
 import Foundation
 
 /**
- * Watches the `RCTInstanceDidLoadBundle` notification, and calls the callback that waits for it.
+ * Watches the Brownfield timing-ready notification, and calls the callback that waits for it.
  *
- * React Native sends the notification from the JavaScript thread. This class always calls the
- * callback on the main thread, because the callback changes the user interface.
+ * The timing observer forwards React Native completion to the main thread after capturing
+ * timings. This class also delivers callbacks on the main thread for UI updates.
  *
  * The class starts to watch at the initialization, and not at the first callback. The class then
  * knows that React Native loaded the bundle, also if nobody waited for the notification.
  */
 final class JSBundleLoadObserver {
-  private var pendingCallback: (() -> Void)?
+  private var pendingCallback: ((JSBundleTimings) -> Void)?
   private var didLoadBundle = false
-  private var observerToken: NSObjectProtocol?
+  private var latestTimings: JSBundleTimings?
+  private var observerTokens: [NSObjectProtocol] = []
 
   init() {
-    observerToken = NotificationCenter.default.addObserver(
-      forName: NSNotification.Name("RCTInstanceDidLoadBundle"),
+    observerTokens.append(NotificationCenter.default.addObserver(
+      forName: .JSBundleTimingDidLoad,
       object: nil,
       queue: .main
     ) { [weak self] _ in
       self?.bundleDidLoad()
-    }
+    })
+    observerTokens.append(NotificationCenter.default.addObserver(
+      forName: NSNotification.Name("RCTJavaScriptDidFailToLoadNotification"),
+      object: nil,
+      queue: .main
+    ) { [weak self] _ in
+      self?.bundleDidFailToLoad()
+    })
   }
 
   deinit {
-    if let observerToken {
-      NotificationCenter.default.removeObserver(observerToken)
-    }
+    observerTokens.forEach(NotificationCenter.default.removeObserver)
   }
 
   /**
@@ -35,31 +41,37 @@ final class JSBundleLoadObserver {
    * React Native already loaded the bundle, the class calls the callback in the next turn of the
    * main run loop.
    *
-   * @param onBundleLoaded The class always calls this callback on the main thread.
+   * @param onBundleLoaded The class always calls this callback on the main thread, with the
+   *   timings of the session that loaded the bundle.
    */
-  func observe(onBundleLoaded: @escaping () -> Void) {
+  func observe(onBundleLoaded: @escaping (JSBundleTimings) -> Void) {
     onMainThread { [weak self] in
       self?.register(onBundleLoaded)
     }
   }
 
   /**
-   * Removes the callback that waits, and forgets the bundle of the earlier session. Call this
-   * method when you stop React Native. A callback of the earlier session must not run in the next
-   * session.
+   * Removes the callback that waits, forgets the bundle of the earlier session, and clears stored
+   * JS bundle timings. Call this method when you stop React Native. A callback of the earlier
+   * session must not run in the next session, and the next session must not reuse the last timings.
    */
   func reset() {
     onMainThread { [weak self] in
       self?.pendingCallback = nil
       self?.didLoadBundle = false
+      self?.latestTimings = nil
+      JSBundleTimingObserver.reset()
     }
   }
 
   // MARK: - Main thread only
 
-  private func register(_ onBundleLoaded: @escaping () -> Void) {
+  private func register(_ onBundleLoaded: @escaping (JSBundleTimings) -> Void) {
     guard !didLoadBundle else {
-      DispatchQueue.main.async(execute: onBundleLoaded)
+      let timings = latestTimings ?? Self.snapshotTimings()
+      DispatchQueue.main.async {
+        onBundleLoaded(timings)
+      }
       return
     }
 
@@ -68,11 +80,36 @@ final class JSBundleLoadObserver {
 
   private func bundleDidLoad() {
     didLoadBundle = true
+    latestTimings = Self.snapshotTimings()
 
     let callback = pendingCallback
     pendingCallback = nil
 
-    callback?()
+    if let callback, let timings = latestTimings {
+      callback(timings)
+    }
+  }
+
+  /**
+   * A failed load, for example a reload in development, replaces the bundle that loaded earlier.
+   * Forget it and its timings, so a new callback waits for the next load. A callback that waits
+   * keeps waiting: it belongs to this session, and runs when a reload succeeds.
+   */
+  private func bundleDidFailToLoad() {
+    didLoadBundle = false
+    latestTimings = nil
+  }
+
+  /**
+   * The timing observer posts our notification only after storing the snapshot. This avoids
+   * depending on NotificationCenter observer ordering, including for late registrations.
+   */
+  private static func snapshotTimings() -> JSBundleTimings {
+    JSBundleTimings(
+      jsBundleLoadTime: JSBundleTimingObserver.jsBundleLoadTime,
+      jsBundleEvaluationTime: JSBundleTimingObserver.jsBundleEvaluationTime,
+      timeline: JSBundleTimingObserver.timeline
+    )
   }
 
   private func onMainThread(_ work: @escaping () -> Void) {

package/ios/JSBundleTimingObserver.h

@@ -0,0 +1,26 @@
+#import <Foundation/Foundation.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+// Posted on main after the timing snapshot is ready.
+FOUNDATION_EXPORT NSNotificationName const JSBundleTimingDidLoadNotification;
+
+/**
+ * Captures JS bundle timings from `RCTPerformanceLogger` when React Native
+ * finishes (or fails) loading the bundle.
+ *
+ * The observer registers at binary load, before Swift host singletons run.
+ */
+@interface JSBundleTimingObserver : NSObject
+
+@property (class, nonatomic, readonly, nullable) NSNumber *jsBundleLoadTime;
+@property (class, nonatomic, readonly, nullable) NSNumber *jsBundleEvaluationTime;
+
+// Completed startup intervals, in monotonic milliseconds.
+@property (class, nonatomic, readonly) NSArray<NSDictionary<NSString *, id> *> *timeline;
+
++ (void)reset;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/JSBundleTimingObserver.m

@@ -0,0 +1,140 @@
+#import "JSBundleTimingObserver.h"
+
+#import <React/RCTBridge.h>
+#import <React/RCTConstants.h>
+#import <React/RCTPerformanceLogger.h>
+#import <React/RCTPLTag.h>
+#import <objc/runtime.h>
+
+static NSNumber *sJSBundleLoadTime;
+static NSNumber *sJSBundleEvaluationTime;
+static NSArray *sTimeline;
+
+static NSString *const kRCTInstanceDidLoadBundleNotification = @"RCTInstanceDidLoadBundle";
+
+NSNotificationName const JSBundleTimingDidLoadNotification = @"BrownfieldJSBundleTimingDidLoad";
+
+// Check the endpoints: a completed interval can round to zero milliseconds,
+// while an unfinished interval can produce a negative durationForTag: value.
+static NSNumber *JSBundleTimingNumberOrNil(NSArray<NSNumber *> *values, RCTPLTag tag)
+{
+  NSUInteger index = (NSUInteger)tag * 2;
+  if (values.count <= index + 1) {
+    return nil;
+  }
+  int64_t start = values[index].longLongValue;
+  int64_t stop = values[index + 1].longLongValue;
+  return start > 0 && stop >= start ? @(stop - start) : nil;
+}
+
+static void JSBundleTimingClearTagSnapshot(void)
+{
+  sJSBundleLoadTime = nil;
+  sJSBundleEvaluationTime = nil;
+  sTimeline = @[];
+}
+
+@implementation JSBundleTimingObserver
+
++ (NSNumber *)jsBundleLoadTime
+{
+  return sJSBundleLoadTime;
+}
+
++ (NSNumber *)jsBundleEvaluationTime
+{
+  return sJSBundleEvaluationTime;
+}
+
++ (NSArray *)timeline { return sTimeline ?: @[]; }
+
++ (void)reset
+{
+  if ([NSThread isMainThread]) {
+    JSBundleTimingClearTagSnapshot();
+  } else {
+    dispatch_async(dispatch_get_main_queue(), ^{
+      [self reset];
+    });
+  }
+}
+
++ (RCTPerformanceLogger *)performanceLoggerFromNotification:(NSNotification *)notification
+{
+  id bridge = notification.userInfo[@"bridge"];
+  RCTPerformanceLogger *logger = nil;
+
+  // RCTBridgeProxy inherits NSProxy's forwarding-based respondsToSelector:.
+  // It can report NO even for its synthesized performanceLogger getter. Inspect
+  // the actual class method table so we can safely call an implemented getter.
+  Class bridgeClass = object_getClass(bridge);
+  BOOL hasLoggerGetter = class_getInstanceMethod(bridgeClass, @selector(performanceLogger)) != NULL;
+  if (hasLoggerGetter) {
+    logger = [bridge performanceLogger];
+  }
+
+  return logger;
+}
+
++ (void)captureTimingsFromNotification:(NSNotification *)notification
+{
+  RCTPerformanceLogger *logger = [self performanceLoggerFromNotification:notification];
+  if (logger == nil) {
+    JSBundleTimingClearTagSnapshot();
+    return;
+  }
+
+  NSArray<NSNumber *> *values = [logger valuesForTags];
+  sJSBundleLoadTime = JSBundleTimingNumberOrNil(values, RCTPLScriptDownload);
+  sJSBundleEvaluationTime = JSBundleTimingNumberOrNil(values, RCTPLScriptExecution);
+  // These intervals can overlap. Preserve endpoints instead of adding durations.
+  RCTPLTag tags[] = {RCTPLScriptDownload, RCTPLScriptExecution};
+  NSArray *names = @[@"RCTPLScriptDownload", @"RCTPLScriptExecution"];
+  NSMutableArray *timeline = [NSMutableArray new];
+  for (NSUInteger i = 0; i < 2; i++) {
+    NSUInteger index = (NSUInteger)tags[i] * 2;
+    if (JSBundleTimingNumberOrNil(values, tags[i]) != nil) {
+      [timeline addObject:@{@"tag": names[i], @"startMs": values[index], @"stopMs": values[index + 1]}];
+    }
+  }
+  sTimeline = [timeline sortedArrayUsingDescriptors:@[[NSSortDescriptor sortDescriptorWithKey:@"startMs" ascending:YES]]];
+}
+
+@end
+
+__attribute__((constructor)) static void JSBundleTimingObserverRegister(void)
+{
+  NSNotificationCenter *center = [NSNotificationCenter defaultCenter];
+  NSOperationQueue *mainQueue = [NSOperationQueue mainQueue];
+
+  [center addObserverForName:RCTJavaScriptDidLoadNotification
+                      object:nil
+                       queue:mainQueue
+                  usingBlock:^(NSNotification *notification) {
+                    [JSBundleTimingObserver captureTimingsFromNotification:notification];
+                    [[NSNotificationCenter defaultCenter] postNotificationName:JSBundleTimingDidLoadNotification object:nil];
+                  }];
+
+  [center addObserverForName:kRCTInstanceDidLoadBundleNotification
+                      object:nil
+                       queue:mainQueue
+                  usingBlock:^(NSNotification *notification) {
+                    // RN versions that expose the instance logger on the bridge proxy
+                    // send RCTJavaScriptDidLoadNotification next, with that proxy.
+                    // currentBridge is a stub, and this earlier notification has no payload.
+                    Class proxyClass = NSClassFromString(@"RCTBridgeProxy");
+                    BOOL hasLoggerSetter = [proxyClass instancesRespondToSelector:NSSelectorFromString(@"setPerformanceLogger:")];
+                    if (hasLoggerSetter) {
+                      return;
+                    }
+                    [JSBundleTimingObserver captureTimingsFromNotification:notification];
+                    [[NSNotificationCenter defaultCenter] postNotificationName:JSBundleTimingDidLoadNotification object:nil];
+                  }];
+
+  [center addObserverForName:RCTJavaScriptDidFailToLoadNotification
+                      object:nil
+                       queue:mainQueue
+                  usingBlock:^(__unused NSNotification *notification) {
+                    [JSBundleTimingObserver reset];
+                  }];
+}

package/ios/ReactHostPreloading.swift

@@ -103,10 +103,14 @@ protocol ReactHostPreloading: AnyObject {
    */
   func canPreloadReactNative() -> Bool
 
+  func prepareReactNative(_ completion: @escaping () -> Void)
+
   func prepareDevLoadingView()
 }
 
 extension ReactHostPreloading {
+  func prepareReactNative(_ completion: @escaping () -> Void) { completion() }
+
   /**
    * The implementation of
    * `ReactNativeBrownfield.startReactNative(launchOptions:preloadBundle:onBundleLoaded:)`, which
@@ -115,7 +119,7 @@ extension ReactHostPreloading {
   func startReactNative(
     launchOptions: [AnyHashable: Any]?,
     preloadBundle: Bool,
-    onBundleLoaded: (() -> Void)?
+    onBundleLoaded: ((JSBundleTimings) -> Void)?
   ) {
     preloadState.storeLaunchOptions(launchOptions)
 
@@ -131,10 +135,10 @@ extension ReactHostPreloading {
     preloadState.requestPreload()
 
     if Thread.isMainThread {
-      createReactHost()
+      prepareReactNative { [weak self] in self?.createReactHost() }
     } else {
       DispatchQueue.main.async { [weak self] in
-        self?.createReactHost()
+        self?.prepareReactNative { [weak self] in self?.createReactHost() }
       }
     }
   }