react-native-windows 0.84.0-preview.9 → 0.85.0-preview.1

package/ReactCommon/TEMP_UntilReactCommonUpdate/cxxreact/CxxNativeModule.cpp

@@ -1,259 +0,0 @@
-/*
- * 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.
- */
-
-#include "CxxNativeModule.h"
-
-#ifndef RCT_REMOVE_LEGACY_ARCH
-
-#include "Instance.h"
-
-#include <folly/json.h>
-#include <glog/logging.h>
-#include <iterator>
-
-#include "JsArgumentHelpers.h"
-#include "MessageQueueThread.h"
-#include "TraceSection.h"
-
-#include <logger/react_native_log.h>
-
-using facebook::xplat::module::CxxModule;
-namespace facebook::react {
-
-std::function<void(folly::dynamic)> makeCallback(
-    std::weak_ptr<Instance> instance,
-    const folly::dynamic& callbackId) {
-  if (!callbackId.isNumber()) {
-    throw std::invalid_argument("Expected callback(s) as final argument");
-  }
-
-  auto id = callbackId.asInt();
-  return [winstance = std::move(instance), id](folly::dynamic args) {
-    if (auto instance = winstance.lock()) {
-      instance->callJSCallback(id, std::move(args));
-    }
-  };
-}
-
-namespace {
-
-/**
- * CxxModule::Callback accepts a vector<dynamic>, makeCallback returns
- * a callback that accepts a dynamic, adapt the second into the first.
- * TODO: Callback types should be made equal (preferably
- * function<void(dynamic)>) to avoid the extra copy and indirect call.
- */
-CxxModule::Callback convertCallback(
-    std::function<void(folly::dynamic)> callback) {
-  return [callback = std::move(callback)](std::vector<folly::dynamic> args) {
-    // after unpinning folly, can use folly::dynamic::array_range
-    folly::dynamic obj = folly::dynamic::array;
-    for (auto& arg : args) {
-      obj.push_back(std::move(arg));
-    }
-    callback(std::move(obj));
-  };
-}
-
-} // namespace
-
-bool CxxNativeModule::shouldWarnOnUse_ = false;
-
-void CxxNativeModule::setShouldWarnOnUse(bool value) {
-  shouldWarnOnUse_ = value;
-}
-
-void CxxNativeModule::emitWarnIfWarnOnUsage(
-    const std::string& method_name,
-    const std::string& module_name) {
-  if (shouldWarnOnUse_) {
-    std::string message = "Calling " + method_name +
-        " on Cxx NativeModule (name = \"" + module_name + "\").";
-    react_native_log_warn(message.c_str());
-  }
-}
-
-std::string CxxNativeModule::getName() {
-  return name_;
-}
-
-std::string CxxNativeModule::getSyncMethodName(unsigned int reactMethodId) {
-  if (reactMethodId >= methods_.size()) {
-    throw std::invalid_argument(
-        "methodId " + std::to_string(reactMethodId) + " out of range [0.." +
-        std::to_string(methods_.size()) + "]");
-  }
-  return methods_[reactMethodId].name;
-}
-
-std::vector<MethodDescriptor> CxxNativeModule::getMethods() {
-  lazyInit();
-
-  std::vector<MethodDescriptor> descs;
-  descs.reserve(methods_.size());
-  for (auto& method : methods_) {
-    descs.emplace_back(method.name, method.getType());
-  }
-  return descs;
-}
-
-folly::dynamic CxxNativeModule::getConstants() {
-  lazyInit();
-
-  if (!module_) {
-    return nullptr;
-  }
-
-  emitWarnIfWarnOnUsage("getConstants()", getName());
-
-  folly::dynamic constants = folly::dynamic::object();
-  for (auto& pair : module_->getConstants()) {
-    constants.insert(std::move(pair.first), std::move(pair.second));
-  }
-  return constants;
-}
-
-void CxxNativeModule::invoke(
-    unsigned int reactMethodId,
-    folly::dynamic&& params,
-    int callId) {
-  if (reactMethodId >= methods_.size()) {
-    throw std::invalid_argument(
-        "methodId " + std::to_string(reactMethodId) + " out of range [0.." +
-        std::to_string(methods_.size()) + "]");
-  }
-  if (!params.isArray()) {
-    throw std::invalid_argument(
-        std::string("Method parameters should be array, but are ") +
-        params.typeName());
-  }
-
-  CxxModule::Callback first;
-  CxxModule::Callback second;
-
-  const auto& method = methods_[reactMethodId];
-
-  if (!method.func) {
-    throw std::runtime_error(
-        "Method " + method.name + " is synchronous but invoked asynchronously");
-  }
-
-  emitWarnIfWarnOnUsage(method.name, getName());
-
-  if (params.size() < method.callbacks) {
-    throw std::invalid_argument(
-        "Expected " + std::to_string(method.callbacks) +
-        " callbacks, but only " + std::to_string(params.size()) +
-        " parameters provided");
-  }
-
-  if (method.callbacks == 1) {
-    first = convertCallback(makeCallback(instance_, params[params.size() - 1]));
-  } else if (method.callbacks == 2) {
-    first = convertCallback(makeCallback(instance_, params[params.size() - 2]));
-    second =
-        convertCallback(makeCallback(instance_, params[params.size() - 1]));
-  }
-
-  params.resize(params.size() - method.callbacks);
-
-  // I've got a few flawed options here.  I can let the C++ exception
-  // propagate, and the registry will log/convert them to java exceptions.
-  // This lets all the java and red box handling work ok, but the only info I
-  // can capture about the C++ exception is the what() string, not the stack.
-  // I can std::terminate() the app.  This causes the full, accurate C++
-  // stack trace to be added to logcat by debuggerd.  The java state is lost,
-  // but in practice, the java stack is always the same in this case since
-  // the javascript stack is not visible, and the crash is unfriendly to js
-  // developers, but crucial to C++ developers.  The what() value is also
-  // lost.  Finally, I can catch, log the java stack, then rethrow the C++
-  // exception.  In this case I get java and C++ stack data, but the C++
-  // stack is as of the rethrow, not the original throw, both the C++ and
-  // java stacks always look the same.
-  //
-  // I am going with option 2, since that seems like the most useful
-  // choice.  It would be nice to be able to get what() and the C++
-  // stack.  I'm told that will be possible in the future.  TODO
-  // mhorowitz #7128529: convert C++ exceptions to Java
-
-  const auto& moduleName = name_;
-  TraceSection s(
-      "CxxMethodCallQueue", "module", moduleName, "method", method.name);
-  messageQueueThread_->runOnQueue([method,
-                                   moduleName,
-                                   params = std::move(params),
-                                   first,
-                                   second,
-                                   callId]() {
-#ifdef WITH_FBSYSTRACE
-    if (callId != -1) {
-      //fbsystrace_end_async_flow(TRACE_TAG_REACT, "native", callId);
-      fbsystrace_end_async_flow(TRACE_TAG_REACT_CXX_BRIDGE, "native", callId); // [Windows] [issue #14819]
-    }
-#else
-    (void)(callId);
-#endif
-    TraceSection s(
-        "CxxMethodCallDispatch", "module", moduleName, "method", method.name);
-    try {
-      method.func(params, first, second);
-    } catch (const facebook::xplat::JsArgumentException&) {
-      throw;
-    } catch (std::exception& e) {
-      LOG(ERROR) << "std::exception. Method call " << method.name.c_str()
-                 << " failed: " << e.what();
-      std::terminate();
-    } catch (std::string& error) {
-      LOG(ERROR) << "std::string. Method call " << method.name.c_str()
-                 << " failed: " << error.c_str();
-      std::terminate();
-    } catch (...) {
-      LOG(ERROR) << "Method call " << method.name.c_str()
-                 << " failed. unknown error";
-      std::terminate();
-    }
-  });
-}
-
-MethodCallResult CxxNativeModule::callSerializableNativeHook(
-    unsigned int hookId,
-    folly::dynamic&& args) {
-  if (hookId >= methods_.size()) {
-    throw std::invalid_argument(
-        "methodId " + std::to_string(hookId) + " out of range [0.." +
-        std::to_string(methods_.size()) + "]");
-  }
-
-  const auto& method = methods_[hookId];
-
-  if (!method.syncFunc) {
-    throw std::runtime_error(
-        "Method " + method.name + " is asynchronous but invoked synchronously");
-  }
-
-  emitWarnIfWarnOnUsage(method.name, getName());
-
-  return method.syncFunc(std::move(args));
-}
-
-void CxxNativeModule::lazyInit() {
-  if (module_ || !provider_) {
-    return;
-  }
-
-  // TODO 17216751: providers should never return null modules
-  module_ = provider_();
-  provider_ = nullptr;
-  if (module_) {
-    module_->setInstance(instance_);
-    methods_ = module_->getMethods();
-  }
-}
-
-} // namespace facebook::react
-
-#endif // RCT_REMOVE_LEGACY_ARCH

package/ReactCommon/TEMP_UntilReactCommonUpdate/cxxreact/Instance.cpp

@@ -1,381 +0,0 @@
-/*
- * 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 "Instance.h"
-
-#ifndef RCT_REMOVE_LEGACY_ARCH
-
-#include "ErrorUtils.h"
-#include "JSBigString.h"
-#include "JSBundleType.h"
-#include "JSExecutor.h"
-#include "MessageQueueThread.h"
-#include "MethodCall.h"
-#include "NativeToJsBridge.h"
-#include "RAMBundleRegistry.h"
-#include "RecoverableError.h"
-#include "TraceSection.h"
-
-#include <cxxreact/JSIndexedRAMBundle.h>
-#include <folly/json.h>
-#include <react/debug/react_native_assert.h>
-
-#include <glog/logging.h>
-
-#include <condition_variable>
-#include <exception>
-#include <memory>
-#include <mutex>
-#include <string>
-
-namespace facebook::react {
-
-Instance::~Instance() {
-  if (nativeToJsBridge_) {
-    nativeToJsBridge_->destroy();
-  }
-}
-
-void Instance::unregisterFromInspector() {
-  if (inspectorTarget_ != nullptr) {
-    assert(runtimeInspectorTarget_);
-    inspectorTarget_->unregisterRuntime(*runtimeInspectorTarget_);
-    assert(parentInspectorTarget_);
-    parentInspectorTarget_->unregisterInstance(*inspectorTarget_);
-    parentInspectorTarget_ = nullptr;
-    inspectorTarget_ = nullptr;
-  }
-}
-
-void Instance::initializeBridge(
-    std::unique_ptr<InstanceCallback> callback,
-    std::shared_ptr<JSExecutorFactory> jsef,
-    std::shared_ptr<MessageQueueThread> jsQueue,
-    std::shared_ptr<ModuleRegistry> moduleRegistry,
-    jsinspector_modern::HostTarget* parentInspectorTarget) {
-  callback_ = std::move(callback);
-  moduleRegistry_ = std::move(moduleRegistry);
-  parentInspectorTarget_ = parentInspectorTarget;
-
-  jsQueue->runOnQueueSync([this, &jsef, jsQueue]() mutable {
-    nativeToJsBridge_ = std::make_shared<NativeToJsBridge>(
-        jsef.get(), moduleRegistry_, jsQueue, callback_);
-
-    // If a parent inspector HostTarget is provided, perform inspector
-    // initialization synchronously.
-    if (parentInspectorTarget_ != nullptr) {
-      auto inspectorExecutor = parentInspectorTarget_->executorFromThis();
-      std::mutex inspectorInitializedMutex;
-      std::condition_variable inspectorInitializedCv;
-      bool inspectorInitialized = false;
-
-      // Schedule work on the inspector thread. NOTE: We expect this callback
-      // to always execute, given the invariant that `initializeBridge` (this
-      // method) completes before `unregisterFromInspector` is called.
-      // - On iOS, instance creation and invalidation both run on the main
-      //   queue (`RCTCxxBridge::start,invalidate` use `RCTAssertMainQueue`).
-      // - On Android, `ReactContext` must be initialized with a constructed
-      //   `CatalystInstance` (in which `Instance::initializeBridge` has
-      //   completed) before `destroy` can be called.
-      inspectorExecutor([this,
-                         &inspectorInitialized,
-                         &inspectorInitializedMutex,
-                         &inspectorInitializedCv](
-                            jsinspector_modern::HostTarget& hostTarget) {
-        // NOTE: By passing *this, we strongly assume the Instance will still
-        // be alive by the time this executes.
-        // - On iOS, instance creation is done synchronously
-        //   (`RCTCxxBridge::_initializeBridgeLocked`).
-        // - On Android, we explicitly wait for instance creation before
-        //   destruction (`ReactInstanceManager::mReactContextLock`).
-        inspectorTarget_ = &hostTarget.registerInstance(*this);
-        RuntimeExecutor runtimeExecutorIfJsi = getRuntimeExecutor();
-        runtimeInspectorTarget_ = &inspectorTarget_->registerRuntime(
-            nativeToJsBridge_->getInspectorTargetDelegate(),
-            runtimeExecutorIfJsi ? runtimeExecutorIfJsi : [](auto) {});
-
-        // Signal that initialization is complete
-        {
-          std::lock_guard lock(inspectorInitializedMutex);
-          inspectorInitialized = true;
-        }
-        inspectorInitializedCv.notify_one();
-      });
-
-      // Wait for the initialization work to complete
-      {
-        std::unique_lock lock(inspectorInitializedMutex);
-        inspectorInitializedCv.wait(
-            lock, [&inspectorInitialized] { return inspectorInitialized; });
-      }
-    }
-
-    // Initialize the JavaScript runtime after we've initialized the inspector
-    nativeToJsBridge_->initializeRuntime();
-
-    // After NativeToJsBridge is created, the jsi::Runtime should exist. Also,
-    // the JS message queue thread exists. So, it's safe to schedule all queued
-    // up JS calls.
-    jsCallInvoker_->setNativeToJsBridgeAndFlushCalls(nativeToJsBridge_);
-
-    std::scoped_lock lock(m_syncMutex);
-    m_syncReady = true;
-    m_syncCV.notify_all();
-  });
-
-  CHECK(nativeToJsBridge_);
-}
-
-void Instance::loadBundle(
-    std::unique_ptr<RAMBundleRegistry> bundleRegistry,
-    std::unique_ptr<const JSBigString> startupScript,
-    std::string sourceURL) {
-  callback_->incrementPendingJSCalls();
-  TraceSection s("Instance::loadBundle", "sourceURL", sourceURL);
-  nativeToJsBridge_->loadBundle(
-      std::move(bundleRegistry),
-      std::move(startupScript),
-      std::move(sourceURL));
-}
-
-void Instance::loadBundleSync(
-    std::unique_ptr<RAMBundleRegistry> bundleRegistry,
-    std::unique_ptr<const JSBigString> startupScript,
-    std::string sourceURL) {
-  std::unique_lock<std::mutex> lock(m_syncMutex);
-  m_syncCV.wait(lock, [this] { return m_syncReady; });
-
-  TraceSection s("Instance::loadBundleSync", "sourceURL", sourceURL);
-  nativeToJsBridge_->loadBundleSync(
-      std::move(bundleRegistry),
-      std::move(startupScript),
-      std::move(sourceURL));
-}
-
-void Instance::setSourceURL(std::string sourceURL) {
-  callback_->incrementPendingJSCalls();
-  TraceSection s("Instance::setSourceURL", "sourceURL", sourceURL);
-
-  nativeToJsBridge_->loadBundle(nullptr, nullptr, std::move(sourceURL));
-}
-
-void Instance::loadScriptFromString(
-    std::unique_ptr<const JSBigString> string,
-    std::string sourceURL,
-    bool loadSynchronously) {
-  TraceSection s("Instance::loadScriptFromString", "sourceURL", sourceURL);
-  if (loadSynchronously) {
-    loadBundleSync(nullptr, std::move(string), std::move(sourceURL));
-  } else {
-    loadBundle(nullptr, std::move(string), std::move(sourceURL));
-  }
-}
-
-void Instance::loadRAMBundleFromString(
-    std::unique_ptr<const JSBigString> script,
-    const std::string& sourceURL) {
-  auto bundle = std::make_unique<JSIndexedRAMBundle>(std::move(script));
-  auto startupScript = bundle->getStartupCode();
-  auto registry = RAMBundleRegistry::singleBundleRegistry(std::move(bundle));
-  loadRAMBundle(std::move(registry), std::move(startupScript), sourceURL, true);
-}
-
-void Instance::loadRAMBundleFromFile(
-    const std::string& sourcePath,
-    const std::string& sourceURL,
-    bool loadSynchronously) {
-  auto bundle = std::make_unique<JSIndexedRAMBundle>(sourcePath.c_str());
-  auto startupScript = bundle->getStartupCode();
-  auto registry = RAMBundleRegistry::multipleBundlesRegistry(
-      std::move(bundle), JSIndexedRAMBundle::buildFactory());
-  loadRAMBundle(
-      std::move(registry),
-      std::move(startupScript),
-      sourceURL,
-      loadSynchronously);
-}
-
-void Instance::loadRAMBundle(
-    std::unique_ptr<RAMBundleRegistry> bundleRegistry,
-    std::unique_ptr<const JSBigString> startupScript,
-    std::string startupScriptSourceURL,
-    bool loadSynchronously) {
-  if (loadSynchronously) {
-    loadBundleSync(
-        std::move(bundleRegistry),
-        std::move(startupScript),
-        std::move(startupScriptSourceURL));
-  } else {
-    loadBundle(
-        std::move(bundleRegistry),
-        std::move(startupScript),
-        std::move(startupScriptSourceURL));
-  }
-}
-
-void Instance::setGlobalVariable(
-    std::string propName,
-    std::unique_ptr<const JSBigString> jsonValue) {
-  nativeToJsBridge_->setGlobalVariable(
-      std::move(propName), std::move(jsonValue));
-}
-
-void* Instance::getJavaScriptContext() {
-  return nativeToJsBridge_ ? nativeToJsBridge_->getJavaScriptContext()
-                           : nullptr;
-}
-
-bool Instance::isInspectable() {
-  return nativeToJsBridge_ ? nativeToJsBridge_->isInspectable() : false;
-}
-
-bool Instance::isBatchActive() {
-  return nativeToJsBridge_ ? nativeToJsBridge_->isBatchActive() : false;
-}
-
-void Instance::callJSFunction(
-    std::string&& module,
-    std::string&& method,
-    folly::dynamic&& params) {
-  callback_->incrementPendingJSCalls();
-  nativeToJsBridge_->callFunction(
-      std::move(module), std::move(method), std::move(params));
-}
-
-void Instance::callJSCallback(uint64_t callbackId, folly::dynamic&& params) {
-  TraceSection s("Instance::callJSCallback");
-  callback_->incrementPendingJSCalls();
-  nativeToJsBridge_->invokeCallback((double)callbackId, std::move(params));
-}
-
-void Instance::registerBundle(
-    uint32_t bundleId,
-    const std::string& bundlePath) {
-  nativeToJsBridge_->registerBundle(bundleId, bundlePath);
-}
-
-const ModuleRegistry& Instance::getModuleRegistry() const {
-  return *moduleRegistry_;
-}
-
-ModuleRegistry& Instance::getModuleRegistry() {
-  return *moduleRegistry_;
-}
-
-void Instance::handleMemoryPressure(int pressureLevel) {
-  if (nativeToJsBridge_) {
-    // This class resets `nativeToJsBridge_` only in the destructor,
-    // hence a race is not possible there.
-    nativeToJsBridge_->handleMemoryPressure(pressureLevel);
-  }
-}
-
-std::shared_ptr<CallInvoker> Instance::getJSCallInvoker() {
-  return std::static_pointer_cast<CallInvoker>(jsCallInvoker_);
-}
-
-RuntimeExecutor Instance::getRuntimeExecutor() {
-  // HACK: RuntimeExecutor is not compatible with non-JSIExecutor, we return
-  // a null callback, which the caller should handle.
-  if (getJavaScriptContext() == nullptr) {
-    return nullptr;
-  }
-
-  std::weak_ptr<NativeToJsBridge> weakNativeToJsBridge = nativeToJsBridge_;
-  return [weakNativeToJsBridge](
-             std::function<void(jsi::Runtime & runtime)>&& callback) {
-    if (auto strongNativeToJsBridge = weakNativeToJsBridge.lock()) {
-      strongNativeToJsBridge->runOnExecutorQueue(
-          [callback = std::move(callback)](JSExecutor* executor) {
-            // Assumes the underlying executor is a JSIExecutor
-            auto* runtime =
-                static_cast<jsi::Runtime*>(executor->getJavaScriptContext());
-            try {
-              react_native_assert(runtime != nullptr);
-              callback(*runtime);
-              executor->flush();
-            } catch (jsi::JSError& originalError) {
-              handleJSError(*runtime, originalError, true);
-            }
-          });
-    }
-  };
-}
-
-std::shared_ptr<NativeMethodCallInvoker>
-Instance::getDecoratedNativeMethodCallInvoker(
-    std::shared_ptr<NativeMethodCallInvoker> nativeMethodCallInvoker) {
-  return nativeToJsBridge_->getDecoratedNativeMethodCallInvoker(
-      nativeMethodCallInvoker);
-}
-
-void Instance::JSCallInvoker::setNativeToJsBridgeAndFlushCalls(
-    std::weak_ptr<NativeToJsBridge> nativeToJsBridge) {
-  std::scoped_lock guard(m_mutex);
-
-  m_shouldBuffer = false;
-  m_nativeToJsBridge = nativeToJsBridge;
-  while (!m_workBuffer.empty()) {
-    scheduleAsync(std::move(m_workBuffer.front()));
-    m_workBuffer.pop_front();
-  }
-}
-
-void Instance::JSCallInvoker::invokeSync(CallFunc&& /*work*/) {
-  // TODO: Replace JS Callinvoker with RuntimeExecutor.
-  throw std::runtime_error(
-      "Synchronous native -> JS calls are currently not supported.");
-}
-
-void Instance::JSCallInvoker::invokeAsync(CallFunc&& work) noexcept {
-  std::scoped_lock guard(m_mutex);
-
-  /**
-   * Why is is necessary to queue up async work?
-   *
-   * 1. TurboModuleManager must be created synchronously after the Instance,
-   *    before we load the source code. This is when the NativeModule system
-   *    is initialized. RCTDevLoadingView shows bundle download progress.
-   * 2. TurboModuleManager requires a JS CallInvoker.
-   * 3. The JS CallInvoker requires the NativeToJsBridge, which is created on
-   *    the JS thread in Instance::initializeBridge.
-   *
-   * Therefore, although we don't call invokeAsync before the JS bundle is
-   * executed, this buffering is implemented anyways to ensure that work
-   * isn't discarded.
-   */
-  if (m_shouldBuffer) {
-    m_workBuffer.push_back(std::move(work));
-    return;
-  }
-
-  scheduleAsync(std::move(work));
-}
-
-void Instance::JSCallInvoker::scheduleAsync(CallFunc&& work) noexcept {
-  if (auto strongNativeToJsBridge = m_nativeToJsBridge.lock()) {
-    strongNativeToJsBridge->runOnExecutorQueue(
-        [work = std::move(work)](JSExecutor* executor) {
-          auto* runtime = (jsi::Runtime*)executor->getJavaScriptContext();
-          work(*runtime);
-          executor->flush();
-        });
-  }
-}
-
-} // namespace facebook::react
-
-#endif // RCT_REMOVE_LEGACY_ARCH
-
-#if _MSC_VER
-#pragma warning(pop)
-#endif