@react-native-ohos/react-native-reanimated 3.18.2-rc.2 → 4.0.1

package/harmony/reanimated/src/main/cpp/Common/cpp/worklets/Tools/ReanimatedJSIUtils.h

@@ -1,199 +0,0 @@
-#pragma once
-
-#include <jsi/jsi.h>
-#include <sstream>
-#include <string>
-#include <tuple>
-#include <utility>
-
-using namespace facebook;
-
-namespace worklets::jsi_utils {
-
-// `get` functions take a pointer to `jsi::Value` and
-// call an appropriate method to cast to the native type
-template <typename T>
-inline T get(jsi::Runtime &rt, const jsi::Value *value);
-
-template <>
-inline double get<double>(jsi::Runtime &, const jsi::Value *value) {
-  return value->asNumber();
-}
-
-template <>
-inline int get<int>(jsi::Runtime &, const jsi::Value *value) {
-  return value->asNumber();
-}
-
-template <>
-inline bool get<bool>(jsi::Runtime &, const jsi::Value *value) {
-  if (!value->isBool()) {
-    throw jsi::JSINativeException("[Reanimated] Expected a boolean.");
-  }
-  return value->getBool();
-}
-
-template <>
-inline jsi::Object get<jsi::Object>(jsi::Runtime &rt, const jsi::Value *value) {
-  return value->asObject(rt);
-}
-
-template <>
-inline jsi::Value const &get<jsi::Value const &>(
-    jsi::Runtime &,
-    const jsi::Value *value) {
-  return *value;
-}
-
-// `convertArgs` functions take a variadic template parameter of target (C++)
-// argument types `Targs` and a `jsi::Value` array `args`, and converts `args`
-// to a tuple of typed C++ arguments to be passed to the native implementation.
-// This is accomplished by dispatching (at compile time) to the correct
-// implementation based on the first type of `Targs`, using SFINAE to select the
-// correct specialization, and concatenating with the result of recursion on the
-// rest of `Targs`
-
-// BEGIN implementations for `convertArgs` specializations.
-// specialization for empty `Targs` - returns an empty tuple
-template <typename... Args>
-inline std::enable_if_t<(sizeof...(Args) == 0), std::tuple<>> convertArgs(
-    jsi::Runtime &,
-    const jsi::Value *) {
-  return std::make_tuple();
-}
-
-// calls `get<First>` on the first argument to retrieve the native type,
-// then calls recursively on the rest of `args`
-// and returns the concatenation of results
-template <typename T, typename... Rest>
-inline std::tuple<T, Rest...> convertArgs(
-    jsi::Runtime &rt,
-    const jsi::Value *args) {
-  auto arg = std::tuple<T>(get<T>(rt, args));
-  auto rest = convertArgs<Rest...>(rt, std::next(args));
-  return std::tuple_cat(std::move(arg), std::move(rest));
-}
-// END implementations for `convertArgs` specializations.
-
-// returns a tuple with the result of casting `args` to appropriate
-// native C++ types needed to call `function`
-template <typename Ret, typename... Args>
-std::tuple<Args...> getArgsForFunction(
-    std::function<Ret(Args...)>,
-    jsi::Runtime &rt,
-    const jsi::Value *args,
-    const size_t count) {
-  assert(sizeof...(Args) == count);
-  return convertArgs<Args...>(rt, args);
-}
-
-// returns a tuple with the result of casting `args` to appropriate
-// native C++ types needed to call `function`,
-// passing `rt` as the first argument
-template <typename Ret, typename... Args>
-std::tuple<jsi::Runtime &, Args...> getArgsForFunction(
-    std::function<Ret(jsi::Runtime &, Args...)>,
-    jsi::Runtime &rt,
-    const jsi::Value *args,
-    const size_t count) {
-  assert(sizeof...(Args) == count);
-  return std::tuple_cat(std::tie(rt), convertArgs<Args...>(rt, args));
-}
-
-// calls `function` with `args`
-template <typename Ret, typename... Args>
-inline jsi::Value apply(
-    std::function<Ret(Args...)> function,
-    std::tuple<Args...> args) {
-  return std::apply(function, std::move(args));
-}
-
-// calls string-returning `function` with `args`,
-// and returns the string
-template <typename... Args>
-inline jsi::Value apply(
-    jsi::Runtime &rt,
-    std::function<std::string(Args...)> function,
-    std::tuple<Args...> args) {
-  return jsi::String::createFromUtf8(rt, std::apply(function, std::move(args)));
-}
-
-// calls void-returning `function` with `args`,
-// and returns `undefined`
-template <typename... Args>
-inline jsi::Value apply(
-    std::function<void(Args...)> function,
-    std::tuple<Args...> args) {
-  std::apply(function, std::move(args));
-  return jsi::Value::undefined();
-}
-
-// returns a function with JSI calling convention
-// from a native function `function`
-template <typename Fun>
-jsi::HostFunctionType createHostFunction(Fun function) {
-  return [function](
-             jsi::Runtime &rt,
-             const jsi::Value &,
-             const jsi::Value *args,
-             const size_t count) {
-    auto argz = getArgsForFunction(function, rt, args, count);
-    return apply(function, std::move(argz));
-  };
-}
-
-// returns a function with JSI calling convention
-// from a native function `function` returning a string
-template <typename... Args>
-jsi::HostFunctionType createHostFunction(
-    std::function<std::string(Args...)> function) {
-  return [function](
-             jsi::Runtime &rt,
-             const jsi::Value &,
-             const jsi::Value *args,
-             const size_t count) {
-    auto argz = getArgsForFunction(function, rt, args, count);
-    return apply(rt, function, std::move(argz));
-  };
-}
-
-// used to determine if `function<Ret(Args...)>`
-// takes `Runtime &` as its first argument
-template <typename... Args>
-struct takes_runtime {
-  static constexpr size_t value = 0;
-};
-
-// specialization for `function<Ret(Runtime &, Rest...)`
-template <typename... Rest>
-struct takes_runtime<jsi::Runtime &, Rest...> {
-  static constexpr size_t value = 1;
-};
-
-// creates a JSI compatible function from `function`
-// and installs it as a global function named `name`
-// in the `rt` JS runtime
-template <typename Ret, typename... Args>
-void installJsiFunction(
-    jsi::Runtime &rt,
-    std::string_view name,
-    std::function<Ret(Args...)> function) {
-  auto clb = createHostFunction(function);
-  auto argsCount = sizeof...(Args) - takes_runtime<Args...>::value;
-  jsi::Value jsiFunction = jsi::Function::createFromHostFunction(
-      rt, jsi::PropNameID::forAscii(rt, name.data()), argsCount, clb);
-  rt.global().setProperty(rt, name.data(), jsiFunction);
-}
-
-// this should take care of passing types convertible to `function`
-template <typename Fun>
-void installJsiFunction(jsi::Runtime &rt, std::string_view name, Fun function) {
-  installJsiFunction(rt, name, std::function(std::forward<Fun>(function)));
-}
-
-jsi::Array convertStringToArray(
-    jsi::Runtime &rt,
-    const std::string &value,
-    const unsigned int expectedSize);
-
-} // namespace worklets::jsi_utils

package/harmony/reanimated/src/main/cpp/Common/cpp/worklets/Tools/ReanimatedVersion.cpp

@@ -1,95 +0,0 @@
-#include <worklets/Tools/JSLogger.h>
-#include <worklets/Tools/ReanimatedVersion.h>
-
-#include <memory>
-#include <regex>
-#include <string>
-
-#ifdef REANIMATED_VERSION
-#define STRINGIZE(x) #x
-#define STRINGIZE2(x) STRINGIZE(x)
-#define REANIMATED_VERSION_STRING STRINGIZE2(REANIMATED_VERSION)
-#endif // REANIMATED_VERSION
-
-using namespace facebook;
-
-namespace worklets {
-
-std::string getReanimatedCppVersion() {
-  return std::string(REANIMATED_VERSION_STRING);
-}
-
-void injectReanimatedCppVersion(jsi::Runtime &rnRuntime) {
-  auto version = getReanimatedCppVersion();
-  rnRuntime.global().setProperty(
-      rnRuntime,
-      "_REANIMATED_VERSION_CPP",
-      jsi::String::createFromUtf8(rnRuntime, version));
-}
-
-#ifndef NDEBUG
-// This function is pretty much a copy of
-// `src/reanimated2/platform-specific/checkVersion.ts`.
-bool matchVersion(const std::string &version1, const std::string &version2) {
-  std::regex pattern("^\\d+\\.\\d+\\.\\d+$");
-  if (std::regex_match(version1, pattern) &&
-      std::regex_match(version2, pattern)) {
-    auto majorPattern = std::regex("^\\d+");
-    auto major1 = std::regex_search(version1, majorPattern);
-    auto major2 = std::regex_search(version2, majorPattern);
-    if (major1 != major2) {
-      return false;
-    }
-    auto minorPattern = std::regex("\\.\\d+\\.");
-    auto minor1 = std::regex_search(version1, minorPattern);
-    auto minor2 = std::regex_search(version2, minorPattern);
-    if (minor1 != minor2) {
-      return false;
-    }
-    return true;
-  } else {
-    return version1 == version2;
-  }
-}
-
-void checkJSVersion(
-    jsi::Runtime &rnRuntime,
-    const std::shared_ptr<JSLogger> &jsLogger) {
-  auto cppVersion = getReanimatedCppVersion();
-
-  auto maybeJSVersion =
-      rnRuntime.global().getProperty(rnRuntime, "_REANIMATED_VERSION_JS");
-  if (maybeJSVersion.isUndefined()) {
-    jsLogger->warnOnJS(
-        std::string(
-            "[Reanimated] C++ side failed to resolve JavaScript code version\n") +
-        "See `https://docs.swmansion.com/react-native-reanimated/docs/guides/troubleshooting#c-side-failed-to-resolve-javascript-code-version` for more details.");
-    return;
-  }
-
-  auto jsVersion = maybeJSVersion.asString(rnRuntime).utf8(rnRuntime);
-
-  if (!matchVersion(cppVersion, jsVersion)) {
-    jsLogger->warnOnJS(
-        std::string(
-            "[Reanimated] Mismatch between C++ code version and JavaScript code version (") +
-        cppVersion + " vs. " + jsVersion + " respectively).\n" +
-        "See `https://docs.swmansion.com/react-native-reanimated/docs/guides/troubleshooting#mismatch-between-c-code-version-and-javascript-code-version` for more details.");
-    return;
-  }
-}
-#else
-void checkJSVersion(
-    jsi::Runtime &rnRuntime,
-    const std::shared_ptr<worklets::JSLogger> &jsLogger) {
-  // In release builds we don't check the version, hence
-  // this function is a NOOP.
-}
-
-bool matchVersion(const std::string &version1, const std::string &version2) {
-  // Stub implementation for release builds.
-  return true;
-}
-#endif // NDEBUG
-
-}; // namespace worklets

package/harmony/reanimated/src/main/cpp/Common/cpp/worklets/Tools/SingleInstanceChecker.h

@@ -1,72 +0,0 @@
-#pragma once
-
-#ifndef NDEBUG
-
-#include <cxxabi.h>
-
-#include <atomic>
-#include <cassert>
-#include <iostream>
-#include <string>
-
-#ifdef ANDROID
-#include <android/log.h>
-#endif // ANDROID
-
-namespace worklets {
-
-// This is a class that counts how many instances of a different class there
-// are. It is meant only to be used with classes that should only have one
-// instance.
-
-template <class T>
-class SingleInstanceChecker {
- public:
-  SingleInstanceChecker();
-  ~SingleInstanceChecker();
-
- private:
-  void assertWithMessage(bool condition, std::string message) {
-    if (!condition) {
-#ifdef ANDROID
-      __android_log_print(
-          ANDROID_LOG_WARN, "Reanimated", "%s", message.c_str());
-#else
-      std::cerr << "[Reanimated] " << message << std::endl;
-#endif
-
-#ifdef IS_REANIMATED_EXAMPLE_APP
-      assert(false);
-#endif
-    }
-  }
-
-  // A static field will exist separately for every class template.
-  // This has to be inline for automatic initialization.
-  inline static std::atomic<int> instanceCount_;
-};
-
-template <class T>
-SingleInstanceChecker<T>::SingleInstanceChecker() {
-  int status = 0;
-  std::string className =
-      __cxxabiv1::__cxa_demangle(typeid(T).name(), nullptr, nullptr, &status);
-
-  // React Native can spawn up to two instances of a Native Module at the same
-  // time. This happens during a reload when a new instance of React Native is
-  // created while simultaneously the old one is torn down.
-  instanceCount_++;
-  assertWithMessage(
-      instanceCount_ <= 2,
-      "[Reanimated] More than two instances of " + className +
-          " present. This may indicate a memory leak due to a retain cycle.");
-}
-
-template <class T>
-SingleInstanceChecker<T>::~SingleInstanceChecker() {
-  instanceCount_--;
-}
-
-} // namespace worklets
-
-#endif // NDEBUG

package/harmony/reanimated/src/main/cpp/Common/cpp/worklets/Tools/ThreadSafeQueue.h

@@ -1,49 +0,0 @@
-#pragma once
-
-#include <condition_variable>
-#include <mutex>
-#include <queue>
-#include <utility>
-
-namespace worklets {
-
-//
-// Copyright (c) 2013 Juan Palacios juan.palacios.puyana@gmail.com
-// Subject to the BSD 2-Clause License
-// - see < https://opensource.org/license/bsd-2-clause/ >
-//
-template <typename T>
-class ThreadSafeQueue {
- public:
-  T pop() {
-    std::unique_lock<std::mutex> mlock(mutex_);
-    while (queue_.empty()) {
-      cond_.wait(mlock);
-    }
-    const auto item = queue_.front();
-    queue_.pop();
-    return item;
-  }
-
-  void push(T &&item) {
-    std::unique_lock<std::mutex> mlock(mutex_);
-    queue_.push(std::move(item));
-    mlock.unlock();
-    cond_.notify_one();
-  }
-
-  bool empty() const {
-    std::unique_lock<std::mutex> mlock(mutex_);
-    const auto res = queue_.empty();
-    mlock.unlock();
-    cond_.notify_one();
-    return res;
-  }
-
- private:
-  std::queue<T> queue_;
-  mutable std::mutex mutex_;
-  mutable std::condition_variable cond_;
-};
-
-} // namespace worklets

package/harmony/reanimated/src/main/cpp/Common/cpp/worklets/Tools/UIScheduler.cpp

@@ -1,20 +0,0 @@
-#include <worklets/Tools/UIScheduler.h>
-#include <worklets/WorkletRuntime/ReanimatedRuntime.h>
-
-#include <utility>
-
-namespace worklets {
-
-void UIScheduler::scheduleOnUI(std::function<void()> job) {
-  uiJobs_.push(std::move(job));
-}
-
-void UIScheduler::triggerUI() {
-  scheduledOnUI_ = false;
-  while (!uiJobs_.empty()) {
-    const auto job = uiJobs_.pop();
-    job();
-  }
-}
-
-} // namespace worklets

package/harmony/reanimated/src/main/cpp/Common/cpp/worklets/Tools/UIScheduler.h

@@ -1,22 +0,0 @@
-#pragma once
-
-#include <worklets/Tools/ThreadSafeQueue.h>
-
-#include <ReactCommon/CallInvoker.h>
-
-#include <atomic>
-
-namespace worklets {
-
-class UIScheduler {
- public:
-  virtual void scheduleOnUI(std::function<void()> job);
-  virtual void triggerUI();
-  virtual ~UIScheduler() = default;
-
- protected:
-  std::atomic<bool> scheduledOnUI_{false};
-  ThreadSafeQueue<std::function<void()>> uiJobs_;
-};
-
-} // namespace worklets

package/harmony/reanimated/src/main/cpp/Common/cpp/worklets/Tools/WorkletEventHandler.cpp

@@ -1,29 +0,0 @@
-#include <worklets/Tools/WorkletEventHandler.h>
-
-namespace worklets {
-
-void WorkletEventHandler::process(
-    const std::shared_ptr<WorkletRuntime> &workletRuntime,
-    const double eventTimestamp,
-    const jsi::Value &eventValue) const {
-  workletRuntime->runGuarded(
-      handlerFunction_, jsi::Value(eventTimestamp), eventValue);
-}
-
-uint64_t WorkletEventHandler::getHandlerId() const {
-  return handlerId_;
-}
-
-const std::string &WorkletEventHandler::getEventName() const {
-  return eventName_;
-}
-
-uint64_t WorkletEventHandler::getEmitterReactTag() const {
-  return emitterReactTag_;
-}
-
-bool WorkletEventHandler::shouldIgnoreEmitterReactTag() const {
-  return emitterReactTag_ == -1;
-}
-
-} // namespace worklets

package/harmony/reanimated/src/main/cpp/Common/cpp/worklets/Tools/WorkletEventHandler.h

@@ -1,41 +0,0 @@
-#pragma once
-
-#include <worklets/SharedItems/Shareables.h>
-#include <worklets/WorkletRuntime/WorkletRuntime.h>
-
-#include <jsi/jsi.h>
-
-#include <memory>
-#include <string>
-
-using namespace facebook;
-
-namespace worklets {
-
-class WorkletEventHandler {
-  const uint64_t handlerId_;
-  const uint64_t emitterReactTag_;
-  const std::string eventName_;
-  const std::shared_ptr<ShareableWorklet> handlerFunction_;
-
- public:
-  WorkletEventHandler(
-      const uint64_t handlerId,
-      const std::string &eventName,
-      const uint64_t emitterReactTag,
-      const std::shared_ptr<ShareableWorklet> &handlerFunction)
-      : handlerId_(handlerId),
-        emitterReactTag_(emitterReactTag),
-        eventName_(eventName),
-        handlerFunction_(handlerFunction) {}
-  void process(
-      const std::shared_ptr<WorkletRuntime> &workletRuntime,
-      double eventTimestamp,
-      const jsi::Value &eventValue) const;
-  uint64_t getHandlerId() const;
-  const std::string &getEventName() const;
-  uint64_t getEmitterReactTag() const;
-  bool shouldIgnoreEmitterReactTag() const;
-};
-
-} // namespace worklets

package/harmony/reanimated/src/main/cpp/Common/cpp/worklets/WorkletRuntime/RNRuntimeWorkletDecorator.cpp

@@ -1,16 +0,0 @@
-#include <worklets/WorkletRuntime/RNRuntimeWorkletDecorator.h>
-
-namespace worklets {
-
-void RNRuntimeWorkletDecorator::decorate(
-    jsi::Runtime &rnRuntime,
-    const std::shared_ptr<WorkletsModuleProxy> &workletsModuleProxy) {
-  rnRuntime.global().setProperty(rnRuntime, "_WORKLET", false);
-
-  rnRuntime.global().setProperty(
-      rnRuntime,
-      "__workletsModuleProxy",
-      jsi::Object::createFromHostObject(rnRuntime, workletsModuleProxy));
-}
-
-} // namespace worklets

package/harmony/reanimated/src/main/cpp/Common/cpp/worklets/WorkletRuntime/RNRuntimeWorkletDecorator.h

@@ -1,19 +0,0 @@
-#pragma once
-
-#include <jsi/jsi.h>
-#include <worklets/NativeModules/WorkletsModuleProxy.h>
-#include <memory>
-
-using namespace facebook;
-
-namespace worklets {
-
-class RNRuntimeWorkletDecorator {
-  // TODO: Rename to `RNRuntimeWorkletsDecorator` or something more suitable.
- public:
-  static void decorate(
-      jsi::Runtime &rnRuntime,
-      const std::shared_ptr<WorkletsModuleProxy> &workletsModuleProxy);
-};
-
-} // namespace worklets

package/harmony/reanimated/src/main/cpp/Common/cpp/worklets/WorkletRuntime/ReanimatedHermesRuntime.cpp

@@ -1,112 +0,0 @@
-#include <worklets/WorkletRuntime/ReanimatedHermesRuntime.h>
-
-// Only include this file in Hermes-enabled builds as some platforms (like tvOS)
-// don't support hermes and it causes the compilation to fail.
-#if JS_RUNTIME_HERMES
-
-#include <cxxreact/MessageQueueThread.h>
-#include <jsi/decorator.h>
-#include <jsi/jsi.h>
-
-#include <memory>
-#include <string>
-#include <utility>
-
-namespace worklets {
-
-using namespace facebook;
-using namespace react;
-#if HERMES_ENABLE_DEBUGGER
-using namespace facebook::hermes::inspector_modern;
-#endif // HERMES_ENABLE_DEBUGGER
-
-#if HERMES_ENABLE_DEBUGGER
-
-class HermesExecutorRuntimeAdapter : public RuntimeAdapter {
- public:
-  explicit HermesExecutorRuntimeAdapter(
-      facebook::hermes::HermesRuntime &hermesRuntime,
-      const std::shared_ptr<MessageQueueThread> &thread)
-      : hermesRuntime_(hermesRuntime), thread_(std::move(thread)) {}
-
-  virtual ~HermesExecutorRuntimeAdapter() {
-    // This is required by iOS, because there is an assertion in the destructor
-    // that the thread was indeed `quit` before
-    thread_->quitSynchronous();
-  }
-
-  facebook::hermes::HermesRuntime &getRuntime() override {
-    return hermesRuntime_;
-  }
-
-  // This is not empty in the original implementation, but we decided to tickle
-  // the runtime by running a small piece of code on every frame as using this
-  // required us to hold a refernce to the runtime inside this adapter which
-  // caused issues while reloading the app.
-  void tickleJs() override {}
-
- public:
-  facebook::hermes::HermesRuntime &hermesRuntime_;
-  std::shared_ptr<MessageQueueThread> thread_;
-};
-
-#endif // HERMES_ENABLE_DEBUGGER
-
-ReanimatedHermesRuntime::ReanimatedHermesRuntime(
-    std::unique_ptr<facebook::hermes::HermesRuntime> runtime,
-    const std::shared_ptr<MessageQueueThread> &jsQueue,
-    const std::string &name)
-    : jsi::WithRuntimeDecorator<ReanimatedReentrancyCheck>(
-          *runtime,
-          reentrancyCheck_),
-      runtime_(std::move(runtime)) {
-#if HERMES_ENABLE_DEBUGGER
-  auto adapter =
-      std::make_unique<HermesExecutorRuntimeAdapter>(*runtime_, jsQueue);
-  debugToken_ = chrome::enableDebugging(std::move(adapter), name);
-#else
-  // This is required by iOS, because there is an assertion in the destructor
-  // that the thread was indeed `quit` before
-  jsQueue->quitSynchronous();
-#endif // HERMES_ENABLE_DEBUGGER
-
-#ifndef NDEBUG
-  facebook::hermes::HermesRuntime *wrappedRuntime = runtime_.get();
-  jsi::Value evalWithSourceMap = jsi::Function::createFromHostFunction(
-      *runtime_,
-      jsi::PropNameID::forAscii(*runtime_, "evalWithSourceMap"),
-      3,
-      [wrappedRuntime](
-          jsi::Runtime &rt,
-          const jsi::Value &thisValue,
-          const jsi::Value *args,
-          size_t count) -> jsi::Value {
-        auto code = std::make_shared<const jsi::StringBuffer>(
-            args[0].asString(rt).utf8(rt));
-        std::string sourceURL;
-        if (count > 1 && args[1].isString()) {
-          sourceURL = args[1].asString(rt).utf8(rt);
-        }
-        std::shared_ptr<const jsi::Buffer> sourceMap;
-        if (count > 2 && args[2].isString()) {
-          sourceMap = std::make_shared<const jsi::StringBuffer>(
-              args[2].asString(rt).utf8(rt));
-        }
-        return wrappedRuntime->evaluateJavaScriptWithSourceMap(
-            code, sourceMap, sourceURL);
-      });
-  runtime_->global().setProperty(
-      *runtime_, "evalWithSourceMap", evalWithSourceMap);
-#endif // NDEBUG
-}
-
-ReanimatedHermesRuntime::~ReanimatedHermesRuntime() {
-#if HERMES_ENABLE_DEBUGGER
-  // We have to disable debugging before the runtime is destroyed.
-  chrome::disableDebugging(debugToken_);
-#endif // HERMES_ENABLE_DEBUGGER
-}
-
-} // namespace worklets
-
-#endif // JS_RUNTIME_HERMES