feat: bundle registry improvements, clean and refactor

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

@@ -13,14 +13,13 @@
 #include <cxxreact/CxxNativeModule.h>
 #include <cxxreact/Instance.h>
 #include <cxxreact/IndexedRAMBundle.h>
+#include <cxxreact/BasicBundle.h>
 #include <cxxreact/JSBigString.h>
-#include <cxxreact/JSBundleType.h>
 #include <cxxreact/JSDeltaBundleClient.h>
-#include <cxxreact/JSIndexedRAMBundle.h>
 #include <cxxreact/MethodCall.h>
 #include <cxxreact/ModuleRegistry.h>
 #include <cxxreact/RecoverableError.h>
-#include <cxxreact/RAMBundleRegistry.h>
+// #include <cxxreact/RAMBundleRegistry.h>
 #include <fb/log.h>
 #include <fb/fbjni/ByteBuffer.h>
 #include <folly/dynamic.h>
@@ -31,8 +30,8 @@
 #include "CxxModuleWrapper.h"
 #include "JavaScriptExecutorHolder.h"
 #include "JNativeRunnable.h"
-#include "JniJSModulesUnbundle.h"
 #include "NativeArray.h"
+#include "FileRAMBundle.h"
 
 using namespace facebook::jni;
 
@@ -178,7 +177,7 @@ void CatalystInstanceImpl::jniSetSourceURL(const std::string& sourceURL) {
 }
 
 void CatalystInstanceImpl::jniRegisterSegment(int segmentId, const std::string& path) {
-  // TODO: remove
+  // TODO: remove or figure out how to port it
 }
 
 void CatalystInstanceImpl::jniLoadScriptFromAssets(
@@ -190,25 +189,19 @@ void CatalystInstanceImpl::jniLoadScriptFromAssets(
 
   auto manager = extractAssetManager(assetManager);
   auto script = loadScriptFromAssets(manager, sourceURL);
-  // TODO: refactor + add checks
-  std::unique_ptr<IndexedRAMBundle> bundle =
-    std::make_unique<IndexedRAMBundle>(std::move(script), assetURL, sourceURL);
-  instance_->loadBundle(std::move(bundle), loadSynchronously);
 
-  // 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);
-  //   return;
-  // } else if (Instance::isIndexedRAMBundle(&script)) {
-  //   instance_->loadRAMBundleFromString(std::move(script), sourceURL);
-  // } else {
-  //   instance_->loadScriptFromString(std::move(script), sourceURL, loadSynchronously);
-  // }
+  std::unique_ptr<Bundle> bundle;
+  if (FileRAMBundle::isFileRAMBundle(manager, sourceURL.c_str())) {
+    // TODO: create File RAM Bundle
+  } else if (IndexedRAMBundle::isIndexedRAMBundle(script.get())) {
+    bundle = std::make_unique<IndexedRAMBundle>(std::move(script),
+                                                sourceURL,
+                                                sourceURL);
+  } else {
+    bundle = std::make_unique<BasicBundle>(std::move(script), sourceURL);
+  }
+
+  instance_->loadBundle(std::move(bundle), loadSynchronously);
 }
 
 void CatalystInstanceImpl::jniLoadScriptFromFile(const std::string& fileName,

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

@@ -20,24 +20,23 @@ namespace react {
 using asset_ptr =
     std::unique_ptr<AAsset, std::function<decltype(AAsset_close)>>;
 
-static std::string jsModulesDir(const std::string& entryFile) {
-  std::string dir = dirname(entryFile.c_str());
+static std::string jsModulesDir(const char* entryFile) {
+  std::string dir = dirname(entryFile);
 
   // android's asset manager does not work with paths that start with a dot
   return dir == "." ? "js-modules/" : dir + "/js-modules/";
 }
 
 static asset_ptr openAsset(
     AAssetManager* manager,
-    const std::string& fileName,
+    const char* fileName,
     int mode = AASSET_MODE_STREAMING) {
   return asset_ptr(
-      AAssetManager_open(manager, fileName.c_str(), mode), AAsset_close);
+      AAssetManager_open(manager, fileName, mode), AAsset_close);
 }
 
-bool FileRAMBundle::isFileRAMBundle(
-    AAssetManager* assetManager,
-    const std::string& assetName) {
+bool FileRAMBundle::isFileRAMBundle(AAssetManager* assetManager,
+                                    const char* assetName) {
   if (!assetManager) {
     return false;
   }
@@ -61,8 +60,12 @@ FileRAMBundle::FileRAMBundle(
       moduleDirectory_(moduleDirectory),
       startupScript_(std::move(startupScript)) {}
 
-std::shared_ptr<const JSBigString> FileRAMBundle::getStartupScript() const {
-  return startupScript_;
+std::unique_ptr<const JSBigString> FileRAMBundle::getStartupScript() const {
+  // It might be used multiple times, so we don't want to move it, but instead copy it.
+  std::unique_ptr<JSBigBufferString> script =
+    std::make_unique<JSBigBufferString>(startupScript_->size());
+  std::memcpy(script->data(), startupScript_->c_str(), startupScript_->size());
+  return std::move(script);
 }
 
 std::string FileRAMBundle::getSourcePath() const {
@@ -85,7 +88,7 @@ FileRAMBundle::Module FileRAMBundle::getModule(uint32_t moduleId) const {
   auto sourceUrl = folly::to<std::string>(moduleId, ".js");
 
   auto fileName = moduleDirectory_ + sourceUrl;
-  auto asset = openAsset(assetManager_, fileName, AASSET_MODE_BUFFER);
+  auto asset = openAsset(assetManager_, fileName.c_str(), AASSET_MODE_BUFFER);
 
   const char* buffer = nullptr;
   if (asset != nullptr) {

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

@@ -13,27 +13,25 @@ class FileRAMBundle : public RAMBundle {
    * This implementation reads modules as single file from the assets of an apk.
    */
  public:
+  static bool isFileRAMBundle(AAssetManager* assetManager, const char* assetName);
+
   FileRAMBundle() = default;
   FileRAMBundle(
       AAssetManager* assetManager,
       const std::string& moduleDirectory,
       std::unique_ptr<JSBigString> startupScript);
   ~FileRAMBundle() {}
 
-  static bool isFileRAMBundle(
-      AAssetManager* assetManager,
-      const std::string& assetName);
-
   std::string getSourcePath() const override;
   std::string getSourceURL() const override;
-  std::shared_ptr<const JSBigString> getStartupScript() const override;
+  std::unique_ptr<const JSBigString> getStartupScript() const override;
   Module getModule(uint32_t moduleId) const override;
   BundleType getBundleType() const override;
 
  private:
   AAssetManager* assetManager_ = nullptr;
   std::string moduleDirectory_;
-  std::shared_ptr<JSBigString> startupScript_;
+  std::unique_ptr<JSBigString> startupScript_;
 };
 
 } // namespace react

ReactCommon/cxxreact/BasicBundle.cpp

@@ -16,8 +16,12 @@ std::string BasicBundle::getSourceURL() const {
   return sourceURL_;
 }
 
-std::shared_ptr<const JSBigString> BasicBundle::getScript() {
-  return script_;
+std::unique_ptr<const JSBigString> BasicBundle::getScript() const {
+  // It might be used multiple times, so we don't want to move it, but instead copy it.
+  std::unique_ptr<JSBigBufferString> script =
+    std::make_unique<JSBigBufferString>(script_->size());
+  std::memcpy(script->data(), script_->c_str(), script_->size());
+  return std::move(script);
 }
 
 } // react

ReactCommon/cxxreact/BasicBundle.h

@@ -12,11 +12,11 @@ class BasicBundle : public Bundle {
     BasicBundle(std::unique_ptr<const JSBigString> script, std::string sourceURL);
 
     std::string getSourceURL() const override;
-    std::shared_ptr<const JSBigString> getScript();
+    std::unique_ptr<const JSBigString> getScript() const;
     BundleType getBundleType() const override;
   private:
     std::string sourceURL_;
-    std::shared_ptr<const JSBigString> script_;
+    std::unique_ptr<const JSBigString> script_;
 };
 
 } // react

ReactCommon/cxxreact/Bundle.cpp

@@ -0,0 +1,39 @@
+#include "Bundle.h"
+#include <folly/Bits.h>
+
+namespace facebook {
+namespace react {
+
+static uint32_t constexpr RAMBundleMagicNumber = 0xFB0BD1E5;
+static uint32_t constexpr BCBundleMagicNumber  = 0x6D657300;
+
+BundleType Bundle::parseTypeFromHeader(const BundleHeader& header) {
+  switch (folly::Endian::little(header.magic)) {
+  case RAMBundleMagicNumber:
+    return BundleType::IndexedRAMBundle;
+  case BCBundleMagicNumber:
+    return BundleType::BCBundle;
+  default:
+    return BundleType::BasicBundle;
+  }
+}
+
+const char* Bundle::stringForBundleType(const BundleType& type) {
+  switch (type) {
+    case BundleType::BasicBundle:
+      return "BundleType";
+    case BundleType::IndexedRAMBundle:
+      return "Indexed RAM Bundle";
+    case BundleType::FileRAMBundle:
+      return "File RAM Bundle";
+    case BundleType::BCBundle:
+      return "BC Bundle";
+    case BundleType::DeltaBundle:
+      return "Delta Bundle";
+    default:
+      return "";
+  }
+}
+
+}  // namespace react
+}  // namespace facebook