react-native-windows 0.82.0 → 0.82.3

package/ReactCommon/TEMP_UntilReactCommonUpdate/jsiexecutor/jsireact/JSIExecutor.cpp

@@ -0,0 +1,622 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#if _MSC_VER
+#pragma warning(push)
+#pragma warning(disable : 4996) // deprecated APIs
+#endif
+#include "jsireact/JSIExecutor.h"
+
+#include <cxxreact/ErrorUtils.h>
+#include <cxxreact/JSBigString.h>
+#include <cxxreact/ModuleRegistry.h>
+#include <cxxreact/ReactMarker.h>
+#include <cxxreact/TraceSection.h>
+#include <folly/json.h>
+#include <glog/logging.h>
+#include <jsi/JSIDynamic.h>
+#include <jsi/instrumentation.h>
+#include <reactperflogger/BridgeNativeModulePerfLogger.h>
+
+#include <sstream>
+#include <stdexcept>
+
+using namespace facebook::jsi;
+
+namespace facebook::react {
+
+#ifndef RCT_FIT_RM_OLD_RUNTIME
+
+class JSIExecutor::NativeModuleProxy : public jsi::HostObject {
+ public:
+  NativeModuleProxy(std::shared_ptr<JSINativeModules> nativeModules)
+      : weakNativeModules_(nativeModules) {}
+
+  Value get(Runtime& rt, const PropNameID& name) override {
+    if (name.utf8(rt) == "name") {
+      return jsi::String::createFromAscii(rt, "NativeModules");
+    }
+
+    auto nativeModules = weakNativeModules_.lock();
+    if (!nativeModules) {
+      return nullptr;
+    }
+
+    return nativeModules->getModule(rt, name);
+  }
+
+  void set(Runtime&, const PropNameID&, const Value&) override {
+    throw std::runtime_error(
+        "Unable to put on NativeModules: Operation unsupported");
+  }
+
+ private:
+  std::weak_ptr<JSINativeModules> weakNativeModules_;
+};
+
+namespace {
+
+// basename_r isn't in all iOS SDKs, so use this simple version instead.
+std::string simpleBasename(const std::string& path) {
+  size_t pos = path.rfind('/');
+  return (pos != std::string::npos) ? path.substr(pos) : path;
+}
+
+} // namespace
+
+JSIExecutor::JSIExecutor(
+    std::shared_ptr<jsi::Runtime> runtime,
+    std::shared_ptr<ExecutorDelegate> delegate,
+    const JSIScopedTimeoutInvoker& scopedTimeoutInvoker,
+    RuntimeInstaller runtimeInstaller)
+    : runtime_(runtime),
+      delegate_(delegate),
+      nativeModules_(std::make_shared<JSINativeModules>(
+          delegate ? delegate->getModuleRegistry() : nullptr)),
+      moduleRegistry_(delegate ? delegate->getModuleRegistry() : nullptr),
+      scopedTimeoutInvoker_(scopedTimeoutInvoker),
+      runtimeInstaller_(runtimeInstaller) {
+  runtime_->global().setProperty(
+      *runtime, "__jsiExecutorDescription", runtime->description());
+}
+
+void JSIExecutor::initializeRuntime() {
+  TraceSection s("JSIExecutor::initializeRuntime");
+
+  bindNativePerformanceNow(*runtime_);
+
+  runtime_->global().setProperty(
+      *runtime_,
+      "nativeModuleProxy",
+      Object::createFromHostObject(
+          *runtime_, std::make_shared<NativeModuleProxy>(nativeModules_)));
+
+  runtime_->global().setProperty(
+      *runtime_,
+      "nativeFlushQueueImmediate",
+      Function::createFromHostFunction(
+          *runtime_,
+          PropNameID::forAscii(*runtime_, "nativeFlushQueueImmediate"),
+          1,
+          [this](
+              jsi::Runtime&,
+              const jsi::Value&,
+              const jsi::Value* args,
+              size_t count) {
+            if (count != 1) {
+              throw std::invalid_argument(
+                  "nativeFlushQueueImmediate arg count must be 1");
+            }
+            callNativeModules(args[0], false);
+            return Value::undefined();
+          }));
+
+  runtime_->global().setProperty(
+      *runtime_,
+      "nativeCallSyncHook",
+      Function::createFromHostFunction(
+          *runtime_,
+          PropNameID::forAscii(*runtime_, "nativeCallSyncHook"),
+          1,
+          [this](
+              jsi::Runtime&,
+              const jsi::Value&,
+              const jsi::Value* args,
+              size_t count) { return nativeCallSyncHook(args, count); }));
+
+  runtime_->global().setProperty(
+      *runtime_,
+      "globalEvalWithSourceUrl",
+      Function::createFromHostFunction(
+          *runtime_,
+          PropNameID::forAscii(*runtime_, "globalEvalWithSourceUrl"),
+          1,
+          [this](
+              jsi::Runtime&,
+              const jsi::Value&,
+              const jsi::Value* args,
+              size_t count) { return globalEvalWithSourceUrl(args, count); }));
+
+  if (runtimeInstaller_) {
+    runtimeInstaller_(*runtime_);
+  }
+  bool hasLogger = false;
+  {
+    std::shared_lock lock(ReactMarker::logTaggedMarkerImplMutex);
+    hasLogger = ReactMarker::logTaggedMarkerImpl != nullptr;
+  }
+  if (hasLogger) {
+    ReactMarker::logMarker(ReactMarker::CREATE_REACT_CONTEXT_STOP);
+  }
+}
+
+void JSIExecutor::loadBundle(
+    std::unique_ptr<const JSBigString> script,
+    std::string sourceURL) {
+  TraceSection s("JSIExecutor::loadBundle");
+  bool hasLogger = false;
+  {
+    std::shared_lock lock(ReactMarker::logTaggedMarkerImplMutex);
+    hasLogger = ReactMarker::logTaggedMarkerImpl != nullptr;
+  }
+  std::string scriptName = simpleBasename(sourceURL);
+  if (hasLogger) {
+    ReactMarker::logTaggedMarker(
+        ReactMarker::RUN_JS_BUNDLE_START, scriptName.c_str());
+  }
+  runtime_->evaluateJavaScript(
+      std::make_unique<BigStringBuffer>(std::move(script)), sourceURL);
+  flush();
+  if (hasLogger) {
+    ReactMarker::logTaggedMarker(
+        ReactMarker::RUN_JS_BUNDLE_STOP, scriptName.c_str());
+    ReactMarker::logMarker(ReactMarker::INIT_REACT_RUNTIME_STOP);
+    ReactMarker::logMarker(ReactMarker::APP_STARTUP_STOP);
+  }
+}
+
+void JSIExecutor::setBundleRegistry(std::unique_ptr<RAMBundleRegistry> r) {
+  if (!bundleRegistry_) {
+    runtime_->global().setProperty(
+        *runtime_,
+        "nativeRequire",
+        Function::createFromHostFunction(
+            *runtime_,
+            PropNameID::forAscii(*runtime_, "nativeRequire"),
+            2,
+            [this](
+                [[maybe_unused]] Runtime& rt,
+                const facebook::jsi::Value&,
+                const facebook::jsi::Value* args,
+                size_t count) { return nativeRequire(args, count); }));
+  }
+  bundleRegistry_ = std::move(r);
+}
+
+void JSIExecutor::registerBundle(
+    uint32_t bundleId,
+    const std::string& bundlePath) {
+  auto tag = std::to_string(bundleId);
+  ReactMarker::logTaggedMarker(
+      ReactMarker::REGISTER_JS_SEGMENT_START, tag.c_str());
+  if (bundleRegistry_) {
+    bundleRegistry_->registerBundle(bundleId, bundlePath);
+  } else {
+    auto script = JSBigFileString::fromPath(bundlePath);
+    if (script->size() == 0) {
+      throw std::invalid_argument(
+          "Empty bundle registered with ID " + tag + " from " + bundlePath);
+    }
+    runtime_->evaluateJavaScript(
+        std::make_unique<BigStringBuffer>(std::move(script)),
+        JSExecutor::getSyntheticBundlePath(bundleId, bundlePath));
+  }
+  ReactMarker::logTaggedMarker(
+      ReactMarker::REGISTER_JS_SEGMENT_STOP, tag.c_str());
+}
+
+void JSIExecutor::callFunction(
+    const std::string& moduleId,
+    const std::string& methodId,
+    const folly::dynamic& arguments) {
+  TraceSection s(
+      "JSIExecutor::callFunction", "moduleId", moduleId, "methodId", methodId);
+  if (!callFunctionReturnFlushedQueue_) {
+    bindBridge();
+  }
+
+  // Construct the error message producer in case this times out.
+  // This is executed on a background thread, so it must capture its parameters
+  // by value.
+  auto errorProducer = [=] {
+    std::stringstream ss;
+    ss << "moduleID: " << moduleId << " methodID: " << methodId;
+    return ss.str();
+  };
+
+  Value ret = Value::undefined();
+  try {
+    scopedTimeoutInvoker_(
+        [&] {
+          ret = callFunctionReturnFlushedQueue_->call(
+              *runtime_,
+              moduleId,
+              methodId,
+              valueFromDynamic(*runtime_, arguments));
+        },
+        std::move(errorProducer));
+  } catch (...) {
+    std::throw_with_nested(
+        std::runtime_error("Error calling " + moduleId + "." + methodId));
+  }
+
+  callNativeModules(ret, true);
+}
+
+void JSIExecutor::invokeCallback(
+    const double callbackId,
+    const folly::dynamic& arguments) {
+  TraceSection s("JSIExecutor::invokeCallback", "callbackId", callbackId);
+  if (!invokeCallbackAndReturnFlushedQueue_) {
+    bindBridge();
+  }
+  Value ret;
+  try {
+    ret = invokeCallbackAndReturnFlushedQueue_->call(
+        *runtime_, callbackId, valueFromDynamic(*runtime_, arguments));
+  } catch (...) {
+    std::throw_with_nested(std::runtime_error(
+        "Error invoking callback " + std::to_string(callbackId)));
+  }
+
+  callNativeModules(ret, true);
+}
+
+void JSIExecutor::setGlobalVariable(
+    std::string propName,
+    std::unique_ptr<const JSBigString> jsonValue) {
+  TraceSection s("JSIExecutor::setGlobalVariable", "propName", propName);
+  runtime_->global().setProperty(
+      *runtime_,
+      propName.c_str(),
+      Value::createFromJsonUtf8(
+          *runtime_,
+          reinterpret_cast<const uint8_t*>(jsonValue->c_str()),
+          jsonValue->size()));
+}
+
+std::string JSIExecutor::getDescription() {
+  return "JSI (" + runtime_->description() + ")";
+}
+
+void* JSIExecutor::getJavaScriptContext() {
+  return runtime_.get();
+}
+
+bool JSIExecutor::isInspectable() {
+  return runtime_->isInspectable();
+}
+
+void JSIExecutor::handleMemoryPressure(int pressureLevel) {
+  // The level is an enum value passed by the Android OS to an onTrimMemory
+  // event callback. Defined in ComponentCallbacks2.
+  enum AndroidMemoryPressure {
+    TRIM_MEMORY_BACKGROUND = 40,
+    TRIM_MEMORY_COMPLETE = 80,
+    TRIM_MEMORY_MODERATE = 60,
+    TRIM_MEMORY_RUNNING_CRITICAL = 15,
+    TRIM_MEMORY_RUNNING_LOW = 10,
+    TRIM_MEMORY_RUNNING_MODERATE = 5,
+    TRIM_MEMORY_UI_HIDDEN = 20,
+  };
+  const char* levelName;
+  switch (pressureLevel) {
+    case TRIM_MEMORY_BACKGROUND:
+      levelName = "TRIM_MEMORY_BACKGROUND";
+      break;
+    case TRIM_MEMORY_COMPLETE:
+      levelName = "TRIM_MEMORY_COMPLETE";
+      break;
+    case TRIM_MEMORY_MODERATE:
+      levelName = "TRIM_MEMORY_MODERATE";
+      break;
+    case TRIM_MEMORY_RUNNING_CRITICAL:
+      levelName = "TRIM_MEMORY_RUNNING_CRITICAL";
+      break;
+    case TRIM_MEMORY_RUNNING_LOW:
+      levelName = "TRIM_MEMORY_RUNNING_LOW";
+      break;
+    case TRIM_MEMORY_RUNNING_MODERATE:
+      levelName = "TRIM_MEMORY_RUNNING_MODERATE";
+      break;
+    case TRIM_MEMORY_UI_HIDDEN:
+      levelName = "TRIM_MEMORY_UI_HIDDEN";
+      break;
+    default:
+      levelName = "UNKNOWN";
+      break;
+  }
+
+  switch (pressureLevel) {
+    case TRIM_MEMORY_RUNNING_LOW:
+    case TRIM_MEMORY_RUNNING_MODERATE:
+    case TRIM_MEMORY_UI_HIDDEN:
+      // For non-severe memory trims, do nothing.
+      LOG(INFO) << "Memory warning (pressure level: " << levelName
+                << ") received by JS VM, ignoring because it's non-severe";
+      break;
+    case TRIM_MEMORY_BACKGROUND:
+    case TRIM_MEMORY_COMPLETE:
+    case TRIM_MEMORY_MODERATE:
+    case TRIM_MEMORY_RUNNING_CRITICAL:
+      // For now, pressureLevel is unused by collectGarbage.
+      // This may change in the future if the JS GC has different styles of
+      // collections.
+      LOG(INFO) << "Memory warning (pressure level: " << levelName
+                << ") received by JS VM, running a GC";
+      runtime_->instrumentation().collectGarbage(levelName);
+      break;
+    default:
+      // Use the raw number instead of the name here since the name is
+      // meaningless.
+      LOG(WARNING) << "Memory warning (pressure level: " << pressureLevel
+                   << ") received by JS VM, unrecognized pressure level";
+      break;
+  }
+}
+
+void JSIExecutor::bindBridge() {
+  std::call_once(bindFlag_, [this] {
+    TraceSection s("JSIExecutor::bindBridge (once)");
+    Value batchedBridgeValue =
+        runtime_->global().getProperty(*runtime_, "__fbBatchedBridge");
+    if (batchedBridgeValue.isUndefined() || !batchedBridgeValue.isObject()) {
+      throw JSINativeException(
+          "Could not get BatchedBridge, make sure your bundle is packaged correctly");
+    }
+
+    Object batchedBridge = batchedBridgeValue.asObject(*runtime_);
+    callFunctionReturnFlushedQueue_ = batchedBridge.getPropertyAsFunction(
+        *runtime_, "callFunctionReturnFlushedQueue");
+    invokeCallbackAndReturnFlushedQueue_ = batchedBridge.getPropertyAsFunction(
+        *runtime_, "invokeCallbackAndReturnFlushedQueue");
+    flushedQueue_ =
+        batchedBridge.getPropertyAsFunction(*runtime_, "flushedQueue");
+  });
+}
+
+void JSIExecutor::callNativeModules(const Value& queue, bool isEndOfBatch) {
+  TraceSection s("JSIExecutor::callNativeModules");
+  // If this fails, you need to pass a fully functional delegate with a
+  // module registry to the factory/ctor.
+  CHECK(delegate_) << "Attempting to use native modules without a delegate";
+#if 0 // maybe useful for debugging
+  std::string json = runtime_->global().getPropertyAsObject(*runtime_, "JSON")
+    .getPropertyAsFunction(*runtime_, "stringify").call(*runtime_, queue)
+    .getString(*runtime_).utf8(*runtime_);
+#endif
+  BridgeNativeModulePerfLogger::asyncMethodCallBatchPreprocessStart();
+
+  delegate_->callNativeModules(
+      *this, dynamicFromValue(*runtime_, queue), isEndOfBatch);
+}
+
+void JSIExecutor::flush() {
+  TraceSection s("JSIExecutor::flush");
+  if (flushedQueue_) {
+    Value ret = flushedQueue_->call(*runtime_);
+    callNativeModules(ret, true);
+    return;
+  }
+
+  // When a native module is called from JS, BatchedBridge.enqueueNativeCall()
+  // is invoked.  For that to work, require('BatchedBridge') has to be called,
+  // and when that happens, __fbBatchedBridge is set as a side effect.
+  Value batchedBridge =
+      runtime_->global().getProperty(*runtime_, "__fbBatchedBridge");
+  // So here, if __fbBatchedBridge doesn't exist, then we know no native calls
+  // have happened, and we were able to determine this without forcing
+  // BatchedBridge to be loaded as a side effect.
+  if (!batchedBridge.isUndefined()) {
+    // If calls were made, we bind to the JS bridge methods, and use them to
+    // get the pending queue of native calls.
+    bindBridge();
+    Value ret = flushedQueue_->call(*runtime_);
+    callNativeModules(ret, true);
+  } else if (delegate_) {
+    // If we have a delegate, we need to call it; we pass a null list to
+    // callNativeModules, since we know there are no native calls, without
+    // calling into JS again.  If no calls were made and there's no delegate,
+    // nothing happens, which is correct.
+    callNativeModules(nullptr, true);
+  }
+}
+
+Value JSIExecutor::nativeRequire(const Value* args, size_t count) {
+  if (count > 2 || count == 0) {
+    throw std::invalid_argument("Got wrong number of args");
+  }
+
+  auto moduleId = static_cast<uint32_t>(args[0].getNumber());
+  uint32_t bundleId =
+      count == 2 ? static_cast<uint32_t>(args[1].getNumber()) : 0;
+  auto module = bundleRegistry_->getModule(bundleId, moduleId);
+
+  runtime_->evaluateJavaScript(
+      std::make_unique<StringBuffer>(module.code), module.name);
+  return facebook::jsi::Value();
+}
+
+Value JSIExecutor::nativeCallSyncHook(const Value* args, size_t count) {
+  if (count != 3) {
+    throw std::invalid_argument("nativeCallSyncHook arg count must be 3");
+  }
+
+  if (!args[2].isObject() || !args[2].asObject(*runtime_).isArray(*runtime_)) {
+    throw std::invalid_argument("method parameters should be array");
+  }
+
+  unsigned int moduleId = static_cast<unsigned int>(args[0].getNumber());
+  unsigned int methodId = static_cast<unsigned int>(args[1].getNumber());
+  std::string moduleName;
+  std::string methodName;
+
+  if (moduleRegistry_) {
+    moduleName = moduleRegistry_->getModuleName(moduleId);
+    methodName = moduleRegistry_->getModuleSyncMethodName(moduleId, methodId);
+
+    BridgeNativeModulePerfLogger::syncMethodCallStart(
+        moduleName.c_str(), methodName.c_str());
+
+    BridgeNativeModulePerfLogger::syncMethodCallArgConversionStart(
+        moduleName.c_str(), methodName.c_str());
+  }
+
+  MethodCallResult result = delegate_->callSerializableNativeHook(
+      *this, moduleId, methodId, dynamicFromValue(*runtime_, args[2]));
+
+  /**
+   * Note:
+   * In RCTNativeModule, std::nullopt is returned from
+   * callSerializableNativeHook when executing a NativeModule method fails.
+   * Therefore, it's safe to not terminate the syncMethodCall when std::nullopt
+   * is returned.
+   *
+   * TODO: In JavaNativeModule, std::nullopt is returned when the synchronous
+   * NativeModule method has the void return type. Change this to return
+   * folly::dynamic(nullptr) instead, so that std::nullopt is reserved for
+   * exceptional scenarios.
+   *
+   * TODO: Investigate CxxModule infra to see if std::nullopt is used for
+   * returns in exceptional scenarios.
+   **/
+
+  if (!result.has_value()) {
+    return Value::undefined();
+  }
+
+  Value returnValue = valueFromDynamic(*runtime_, result.value());
+
+  if (moduleRegistry_) {
+    BridgeNativeModulePerfLogger::syncMethodCallReturnConversionEnd(
+        moduleName.c_str(), methodName.c_str());
+    BridgeNativeModulePerfLogger::syncMethodCallEnd(
+        moduleName.c_str(), methodName.c_str());
+  }
+
+  return returnValue;
+}
+
+Value JSIExecutor::globalEvalWithSourceUrl(const Value* args, size_t count) {
+  if (count != 1 && count != 2) {
+    throw std::invalid_argument(
+        "globalEvalWithSourceUrl arg count must be 1 or 2");
+  }
+
+  auto code = args[0].asString(*runtime_).utf8(*runtime_);
+  std::string url;
+  if (count > 1 && args[1].isString()) {
+    url = args[1].asString(*runtime_).utf8(*runtime_);
+  }
+
+  return runtime_->evaluateJavaScript(
+      std::make_unique<StringBuffer>(std::move(code)), url);
+}
+
+#else // RCT_FIT_RM_OLD_RUNTIME
+
+JSIExecutor::JSIExecutor(
+    std::shared_ptr<jsi::Runtime> runtime,
+    std::shared_ptr<ExecutorDelegate> delegate,
+    const JSIScopedTimeoutInvoker& scopedTimeoutInvoker,
+    RuntimeInstaller runtimeInstaller) {}
+
+void JSIExecutor::initializeRuntime() {}
+
+void JSIExecutor::loadBundle(
+    std::unique_ptr<const JSBigString> script,
+    std::string sourceURL) {}
+
+void JSIExecutor::registerBundle(
+    uint32_t bundleId,
+    const std::string& bundlePath) {}
+
+void JSIExecutor::callFunction(
+    const std::string& moduleId,
+    const std::string& methodId,
+    const folly::dynamic& arguments) {}
+
+void JSIExecutor::invokeCallback(
+    const double callbackId,
+    const folly::dynamic& arguments) {}
+
+void JSIExecutor::setGlobalVariable(
+    std::string propName,
+    std::unique_ptr<const JSBigString> jsonValue) {}
+
+std::string JSIExecutor::getDescription() {
+  return "null";
+}
+
+void* JSIExecutor::getJavaScriptContext() {
+  return nullptr;
+}
+
+bool JSIExecutor::isInspectable() {
+  return false;
+}
+
+void JSIExecutor::handleMemoryPressure(int pressureLevel) {}
+
+void JSIExecutor::flush() {}
+
+#endif // RCT_FIT_RM_OLD_RUNTIME
+
+void bindNativeLogger(Runtime& runtime, Logger logger) {
+  runtime.global().setProperty(
+      runtime,
+      "nativeLoggingHook",
+      Function::createFromHostFunction(
+          runtime,
+          PropNameID::forAscii(runtime, "nativeLoggingHook"),
+          2,
+          [logger = std::move(logger)](
+              jsi::Runtime& runtime,
+              const jsi::Value&,
+              const jsi::Value* args,
+              size_t count) {
+            if (count != 2) {
+              throw std::invalid_argument(
+                  "nativeLoggingHook takes 2 arguments");
+            }
+            logger(
+                args[0].asString(runtime).utf8(runtime),
+                static_cast<unsigned int>(args[1].asNumber()));
+            return Value::undefined();
+          }));
+}
+
+void bindNativePerformanceNow(Runtime& runtime) {
+  runtime.global().setProperty(
+      runtime,
+      "nativePerformanceNow",
+      Function::createFromHostFunction(
+          runtime,
+          PropNameID::forAscii(runtime, "nativePerformanceNow"),
+          0,
+          [](jsi::Runtime& runtime,
+             const jsi::Value&,
+             const jsi::Value* args,
+             size_t /*count*/) {
+            return HighResTimeStamp::now().toDOMHighResTimeStamp();
+          }));
+}
+
+} // namespace facebook::react
+#if _MSC_VER
+#pragma warning(pop)
+#endif