Add bundleId (follow-up to #27844 and #27855)

React/CxxBridge/RCTCxxBridge.mm

@@ -384,7 +384,7 @@ - (void)start
   dispatch_group_notify(prepareBridge, dispatch_get_global_queue(QOS_CLASS_USER_INTERACTIVE, 0), ^{
     RCTCxxBridge *strongSelf = weakSelf;
     if (sourceCode && strongSelf.loading) {
-      [strongSelf executeSourceCode:sourceCode sync:NO];
+      [strongSelf executeSourceCode:sourceCode bundleId:0 sync:NO];
     }
   });
   RCT_PROFILE_END_EVENT(RCTProfileTagAlways, @"");
@@ -880,7 +880,7 @@ - (void)registerModuleForFrameUpdates:(id<RCTBridgeModule>)module
   [_displayLink registerModuleForFrameUpdates:module withModuleData:moduleData];
 }
 
-- (void)executeSourceCode:(NSData *)sourceCode sync:(BOOL)sync
+- (void)executeSourceCode:(NSData *)sourceCode bundleId:(int)bundleId sync:(BOOL)sync
 {
   // This will get called from whatever thread was actually executing JS.
   dispatch_block_t completion = ^{
@@ -905,10 +905,10 @@ - (void)executeSourceCode:(NSData *)sourceCode sync:(BOOL)sync
   };
 
   if (sync) {
-    [self executeApplicationScriptSync:sourceCode url:self.bundleURL];
+    [self executeApplicationScriptSync:sourceCode url:self.bundleURL bundleId:bundleId];
     completion();
   } else {
-    [self enqueueApplicationScript:sourceCode url:self.bundleURL onComplete:completion];
+    [self enqueueApplicationScript:sourceCode url:self.bundleURL bundleId:bundleId onComplete:completion];
   }
 
   if (self.devSettings.isHotLoadingAvailable) {
@@ -1292,11 +1292,12 @@ - (void)_immediatelyCallTimer:(NSNumber *)timer
 
 - (void)enqueueApplicationScript:(NSData *)script
                              url:(NSURL *)url
+                             bundleId:(uint32_t)bundleId
                       onComplete:(dispatch_block_t)onComplete
 {
   RCT_PROFILE_BEGIN_EVENT(RCTProfileTagAlways, @"-[RCTCxxBridge enqueueApplicationScript]", nil);
 
-  [self executeApplicationScript:script url:url async:YES];
+  [self executeApplicationScript:script url:url bundleId:bundleId async:YES];
 
   RCT_PROFILE_END_EVENT(RCTProfileTagAlways, @"");
 
@@ -1307,13 +1308,14 @@ - (void)enqueueApplicationScript:(NSData *)script
   }
 }
 
-- (void)executeApplicationScriptSync:(NSData *)script url:(NSURL *)url
+- (void)executeApplicationScriptSync:(NSData *)script url:(NSURL *)url bundleId:(uint32_t)bundleId
 {
-  [self executeApplicationScript:script url:url async:NO];
+  [self executeApplicationScript:script url:url bundleId:bundleId async:NO];
 }
 
 - (void)executeApplicationScript:(NSData *)script
                              url:(NSURL *)url
+                             bundleId:(uint32_t)bundleId
                            async:(BOOL)async
 {
   [self _tryAndHandleError:^{
@@ -1328,15 +1330,14 @@ - (void)executeApplicationScript:(NSData *)script
       [self->_performanceLogger markStopForTag:RCTPLRAMBundleLoad];
       [self->_performanceLogger setValue:scriptStr->size() forTag:RCTPLRAMStartupCodeSize];
       if (self->_reactInstance) {
-        auto registry = RAMBundleRegistry::multipleBundlesRegistry(std::move(ramBundle), JSIndexedRAMBundle::buildFactory());
-        self->_reactInstance->loadRAMBundle(std::move(registry), std::move(scriptStr),
-                                            sourceUrlStr.UTF8String, !async);
+        self->_reactInstance->loadRAMBundle(std::move(ramBundle), std::move(scriptStr),
+                                            sourceUrlStr.UTF8String, bundleId, !async);
       }
     } else if (self->_reactInstance) {
       self->_reactInstance->loadScriptFromString(std::make_unique<NSDataBigString>(script),
                                                  sourceUrlStr.UTF8String, !async);
     } else {
-      std::string methodName = async ? "loadApplicationScript" : "loadApplicationScriptSync";
+      std::string methodName = async ? "loadBundle" : "loadBundleSync";
       throw std::logic_error("Attempt to call " + methodName + ": on uninitialized bridge");
     }
   }];
@@ -1345,7 +1346,7 @@ - (void)executeApplicationScript:(NSData *)script
 - (void)registerSegmentWithId:(NSUInteger)segmentId path:(NSString *)path
 {
   if (_reactInstance) {
-    _reactInstance->registerBundle(static_cast<uint32_t>(segmentId), path.UTF8String);
+    /* _reactInstance->registerBundle(static_cast<uint32_t>(segmentId), path.UTF8String); */
   }
 }
 

React/CxxBridge/RCTObjcExecutor.mm

@@ -74,7 +74,11 @@
       std::make_unique<JSBigStdString>(folly::toJson(config)));
   }
 
-  void loadApplicationScript(
+  void initializeRuntime() {
+    // We do nothing here since initialization is done in the constructor
+  }
+
+  void loadBundle(
       std::unique_ptr<const JSBigString> script,
       std::string sourceURL) override {
     RCTProfileBeginFlowEvent();
@@ -97,7 +101,7 @@ void setBundleRegistry(std::unique_ptr<RAMBundleRegistry>) override {
     RCTAssert(NO, @"RAM bundles are not supported in RCTObjcExecutor");
   }
 
-  void registerBundle(uint32_t __unused bundleId, const std::string __unused &bundlePath) override {
+  void registerBundle(uint32_t __unused bundleId, std::unique_ptr<JSModulesUnbundle> __unused) override {
     RCTAssert(NO, @"RAM bundles are not supported in RCTObjcExecutor");
   }
 

ReactAndroid/src/main/java/com/facebook/react/bridge/CatalystInstanceImpl.java

@@ -230,26 +230,26 @@ public void registerSegment(int segmentId, String path) {
 
   @Override
   public void loadScriptFromAssets(
-      AssetManager assetManager, String assetURL, boolean loadSynchronously) {
+      AssetManager assetManager, String assetURL, int bundleId, boolean loadSynchronously) {
     mSourceURL = assetURL;
-    jniLoadScriptFromAssets(assetManager, assetURL, loadSynchronously);
+    jniLoadScriptFromAssets(assetManager, assetURL, bundleId, loadSynchronously);
   }
 
   @Override
-  public void loadScriptFromFile(String fileName, String sourceURL, boolean loadSynchronously) {
+  public void loadScriptFromFile(String fileName, String sourceURL, int bundleId, boolean loadSynchronously) {
     mSourceURL = sourceURL;
-    jniLoadScriptFromFile(fileName, sourceURL, loadSynchronously);
+    jniLoadScriptFromFile(fileName, sourceURL, bundleId, loadSynchronously);
   }
 
   private native void jniSetSourceURL(String sourceURL);
 
   private native void jniRegisterSegment(int segmentId, String path);
 
   private native void jniLoadScriptFromAssets(
-      AssetManager assetManager, String assetURL, boolean loadSynchronously);
+      AssetManager assetManager, String assetURL, int bundleId, boolean loadSynchronously);
 
   private native void jniLoadScriptFromFile(
-      String fileName, String sourceURL, boolean loadSynchronously);
+      String fileName, String sourceURL, int bundleId, boolean loadSynchronously);
 
   @Override
   public void runJSBundle() {

ReactAndroid/src/main/java/com/facebook/react/bridge/JSBundleLoader.java

@@ -26,7 +26,7 @@ public static JSBundleLoader createAssetLoader(
     return new JSBundleLoader() {
       @Override
       public String loadScript(JSBundleLoaderDelegate delegate) {
-        delegate.loadScriptFromAssets(context.getAssets(), assetUrl, loadSynchronously);
+        delegate.loadScriptFromAssets(context.getAssets(), assetUrl, 0, loadSynchronously);
         return assetUrl;
       }
     };
@@ -45,7 +45,7 @@ public static JSBundleLoader createFileLoader(
     return new JSBundleLoader() {
       @Override
       public String loadScript(JSBundleLoaderDelegate delegate) {
-        delegate.loadScriptFromFile(fileName, assetUrl, loadSynchronously);
+        delegate.loadScriptFromFile(fileName, assetUrl, 0, loadSynchronously);
         return fileName;
       }
     };
@@ -64,7 +64,7 @@ public static JSBundleLoader createCachedBundleFromNetworkLoader(
       @Override
       public String loadScript(JSBundleLoaderDelegate delegate) {
         try {
-          delegate.loadScriptFromFile(cachedFileLocation, sourceURL, false);
+          delegate.loadScriptFromFile(cachedFileLocation, sourceURL, 0, false);
           return sourceURL;
         } catch (Exception e) {
           throw DebugServerException.makeGeneric(sourceURL, e.getMessage(), e);

ReactAndroid/src/main/java/com/facebook/react/bridge/JSBundleLoaderDelegate.java

@@ -19,19 +19,21 @@ public interface JSBundleLoaderDelegate {
    *
    * @param assetManager
    * @param assetURL
+   * @param bundleId
    * @param loadSynchronously
    */
-  void loadScriptFromAssets(AssetManager assetManager, String assetURL, boolean loadSynchronously);
+  void loadScriptFromAssets(AssetManager assetManager, String assetURL, int bundleId, boolean loadSynchronously);
 
   /**
    * Load a JS bundle from the filesystem. See {@link JSBundleLoader#createFileLoader(String)} and
    * {@link JSBundleLoader#createCachedBundleFromNetworkLoader(String, String)}
    *
    * @param fileName
    * @param sourceURL
+   * @param bundleId
    * @param loadSynchronously
    */
-  void loadScriptFromFile(String fileName, String sourceURL, boolean loadSynchronously);
+  void loadScriptFromFile(String fileName, String sourceURL, int bundleId, boolean loadSynchronously);
 
   /**
    * This API is used in situations where the JS bundle is being executed not on the device, but on

ReactAndroid/src/main/java/com/facebook/react/bridge/JavaJSExecutor.java

@@ -38,7 +38,7 @@ public ProxyExecutorException(Throwable cause) {
    * @param sourceURL url or file location from which script content was loaded
    */
   @DoNotStrip
-  void loadApplicationScript(String sourceURL) throws ProxyExecutorException;
+  void loadBundle(String sourceURL) throws ProxyExecutorException;
 
   /**
    * Execute javascript method within js context

ReactAndroid/src/main/java/com/facebook/react/bridge/ReactMarkerConstants.java

@@ -59,8 +59,8 @@ public enum ReactMarkerConstants {
   UNPACKING_JS_BUNDLE_LOADER_CHECK_END,
   UNPACKING_JS_BUNDLE_LOADER_EXTRACTED,
   UNPACKING_JS_BUNDLE_LOADER_BLOCKED,
-  loadApplicationScript_startStringConvert,
-  loadApplicationScript_endStringConvert,
+  loadBundle_startStringConvert,
+  loadBundle_endStringConvert,
   PRE_SETUP_REACT_CONTEXT_START,
   PRE_SETUP_REACT_CONTEXT_END,
   PRE_RUN_JS_BUNDLE_START,

ReactAndroid/src/main/java/com/facebook/react/devsupport/JSDebuggerWebSocketClient.java

@@ -81,7 +81,7 @@ public void prepareJSRuntime(JSDebuggerCallback callback) {
     }
   }
 
-  public void loadApplicationScript(
+  public void loadBundle(
       String sourceURL, HashMap<String, String> injectedObjects, JSDebuggerCallback callback) {
     int requestID = mRequestID.getAndIncrement();
     mCallbacks.put(requestID, callback);

ReactAndroid/src/main/java/com/facebook/react/devsupport/WebsocketJavaScriptExecutor.java

@@ -153,10 +153,10 @@ public void close() {
   }
 
   @Override
-  public void loadApplicationScript(String sourceURL) throws JavaJSExecutor.ProxyExecutorException {
+  public void loadBundle(String sourceURL) throws JavaJSExecutor.ProxyExecutorException {
     JSExecutorCallbackFuture callback = new JSExecutorCallbackFuture();
     Assertions.assertNotNull(mWebSocketClient)
-        .loadApplicationScript(sourceURL, mInjectedObjects, callback);
+        .loadBundle(sourceURL, mInjectedObjects, callback);
     try {
       callback.get();
     } catch (Throwable cause) {
@@ -178,7 +178,7 @@ public void loadApplicationScript(String sourceURL) throws JavaJSExecutor.ProxyE
 
   @Override
   public void setGlobalVariable(String propertyName, String jsonEncodedValue) {
-    // Store and use in the next loadApplicationScript() call.
+    // Store and use in the next loadBundle() call.
     mInjectedObjects.put(propertyName, jsonEncodedValue);
   }
 }

ReactAndroid/src/main/jni/react/jni/CatalystInstanceImpl.cpp

@@ -208,6 +208,7 @@ void CatalystInstanceImpl::jniRegisterSegment(
 void CatalystInstanceImpl::jniLoadScriptFromAssets(
     jni::alias_ref<JAssetManager::javaobject> assetManager,
     const std::string &assetURL,
+    int bundleId,
     bool loadSynchronously) {
   const int kAssetsLength = 9; // strlen("assets://");
   auto sourceURL = assetURL.substr(kAssetsLength);
@@ -216,12 +217,11 @@ void CatalystInstanceImpl::jniLoadScriptFromAssets(
   auto script = loadScriptFromAssets(manager, sourceURL);
   if (JniJSModulesUnbundle::isUnbundle(manager, sourceURL)) {
     auto bundle = JniJSModulesUnbundle::fromEntryFile(manager, sourceURL);
-    auto registry = RAMBundleRegistry::singleBundleRegistry(std::move(bundle));
     instance_->loadRAMBundle(
-        std::move(registry), std::move(script), sourceURL, loadSynchronously);
+        std::move(bundle), std::move(script), sourceURL, (uint32_t)bundleId, loadSynchronously);
     return;
   } else if (Instance::isIndexedRAMBundle(&script)) {
-    instance_->loadRAMBundleFromString(std::move(script), sourceURL);
+    instance_->loadRAMBundleFromString(std::move(script), sourceURL, (uint32_t)bundleId);
   } else {
     instance_->loadScriptFromString(
         std::move(script), sourceURL, loadSynchronously);
@@ -231,9 +231,10 @@ void CatalystInstanceImpl::jniLoadScriptFromAssets(
 void CatalystInstanceImpl::jniLoadScriptFromFile(
     const std::string &fileName,
     const std::string &sourceURL,
+    int bundleId,
     bool loadSynchronously) {
   if (Instance::isIndexedRAMBundle(fileName.c_str())) {
-    instance_->loadRAMBundleFromFile(fileName, sourceURL, loadSynchronously);
+    instance_->loadRAMBundleFromFile(fileName, sourceURL, (uint32_t)bundleId, loadSynchronously);
   } else {
     std::unique_ptr<const JSBigFileString> script;
     RecoverableError::runRethrowingAsRecoverable<std::system_error>(

ReactAndroid/src/main/jni/react/jni/CatalystInstanceImpl.h

@@ -77,15 +77,14 @@ class CatalystInstanceImpl : public jni::HybridClass<CatalystInstanceImpl> {
    *
    */
   void jniRegisterSegment(int segmentId, const std::string &path);
-
-  void jniLoadScriptFromAssets(
-      jni::alias_ref<JAssetManager::javaobject> assetManager,
-      const std::string &assetURL,
-      bool loadSynchronously);
-  void jniLoadScriptFromFile(
-      const std::string &fileName,
-      const std::string &sourceURL,
-      bool loadSynchronously);
+  void jniLoadScriptFromAssets(jni::alias_ref<JAssetManager::javaobject> assetManager,
+                               const std::string& assetURL,
+                               int bundleId,
+                               bool loadSynchronously);
+  void jniLoadScriptFromFile(const std::string& fileName,
+                             const std::string& sourceURL,
+                             int bundleId,
+                             bool loadSynchronously);
   void jniCallJSFunction(
       std::string module,
       std::string method,

ReactAndroid/src/main/jni/react/jni/JReactMarker.cpp

@@ -49,10 +49,10 @@ void JReactMarker::logPerfMarker(
       JReactMarker::logMarker("CREATE_REACT_CONTEXT_END");
       break;
     case ReactMarker::JS_BUNDLE_STRING_CONVERT_START:
-      JReactMarker::logMarker("loadApplicationScript_startStringConvert");
+      JReactMarker::logMarker("loadBundle_startStringConvert");
       break;
     case ReactMarker::JS_BUNDLE_STRING_CONVERT_STOP:
-      JReactMarker::logMarker("loadApplicationScript_endStringConvert");
+      JReactMarker::logMarker("loadBundle_endStringConvert");
       break;
     case ReactMarker::NATIVE_MODULE_SETUP_START:
       JReactMarker::logMarker("NATIVE_MODULE_SETUP_START", tag);

ReactAndroid/src/main/jni/react/jni/ProxyExecutor.cpp

@@ -53,9 +53,7 @@ ProxyExecutor::~ProxyExecutor() {
   m_executor.reset();
 }
 
-void ProxyExecutor::loadApplicationScript(
-    std::unique_ptr<const JSBigString>,
-    std::string sourceURL) {
+void ProxyExecutor::initializeRuntime() {
   folly::dynamic nativeModuleConfig = folly::dynamic::array;
 
   {
@@ -76,14 +74,19 @@ void ProxyExecutor::loadApplicationScript(
         "__fbBatchedBridgeConfig",
         std::make_unique<JSBigStdString>(folly::toJson(config)));
   }
+}
+
+void ProxyExecutor::loadBundle(
+    std::unique_ptr<const JSBigString>,
+    std::string sourceURL) {
 
-  static auto loadApplicationScript =
+  static auto loadBundle =
       jni::findClassStatic(EXECUTOR_BASECLASS)
-          ->getMethod<void(jstring)>("loadApplicationScript");
+          ->getMethod<void(jstring)>("loadBundle");
 
   // The proxy ignores the script data passed in.
 
-  loadApplicationScript(m_executor.get(), jni::make_jstring(sourceURL).get());
+  loadBundle(m_executor.get(), jni::make_jstring(sourceURL).get());
   // We can get pending calls here to native but the queue will be drained when
   // we launch the application.
 }
@@ -96,7 +99,7 @@ void ProxyExecutor::setBundleRegistry(std::unique_ptr<RAMBundleRegistry>) {
 
 void ProxyExecutor::registerBundle(
     uint32_t bundleId,
-    const std::string &bundlePath) {
+    std::unique_ptr<JSModulesUnbundle> bundle) {
   jni::throwNewJavaException(
       "java/lang/UnsupportedOperationException",
       "Loading application RAM bundles is not supported for proxy executors");

ReactAndroid/src/main/jni/react/jni/ProxyExecutor.h

@@ -37,12 +37,13 @@ class ProxyExecutor : public JSExecutor {
       jni::global_ref<jobject> &&executorInstance,
       std::shared_ptr<ExecutorDelegate> delegate);
   virtual ~ProxyExecutor() override;
-  virtual void loadApplicationScript(
+  virtual void initializeRuntime() override;
+  virtual void loadBundle(
       std::unique_ptr<const JSBigString> script,
       std::string sourceURL) override;
   virtual void setBundleRegistry(
       std::unique_ptr<RAMBundleRegistry> bundle) override;
-  virtual void registerBundle(uint32_t bundleId, const std::string &bundlePath)
+  virtual void registerBundle(uint32_t bundleId, std::unique_ptr<JSModulesUnbundle> bundle)
       override;
   virtual void callFunction(
       const std::string &moduleId,

ReactAndroid/src/test/java/com/facebook/react/devsupport/JSDebuggerWebSocketClientTest.java

@@ -40,7 +40,7 @@ public void test_prepareJSRuntime_ShouldSendCorrectMessage() throws Exception {
   }
 
   @Test
-  public void test_loadApplicationScript_ShouldSendCorrectMessage() throws Exception {
+  public void test_loadBundle_ShouldSendCorrectMessage() throws Exception {
     final JSDebuggerWebSocketClient.JSDebuggerCallback cb =
         PowerMockito.mock(JSDebuggerWebSocketClient.JSDebuggerCallback.class);
 
@@ -49,7 +49,7 @@ public void test_loadApplicationScript_ShouldSendCorrectMessage() throws Excepti
     injectedObjects.put("key1", "value1");
     injectedObjects.put("key2", "value2");
 
-    client.loadApplicationScript("http://localhost:8080/index.js", injectedObjects, cb);
+    client.loadBundle("http://localhost:8080/index.js", injectedObjects, cb);
     PowerMockito.verifyPrivate(client)
         .invoke(
             "sendMessage",