@amazon-devices/react-native-worklets 1.0.0-rn-83

package/Common/cpp/worklets/Tools/SingleInstanceChecker.h

@@ -0,0 +1,82 @@
+#pragma once
+
+#ifndef NDEBUG
+
+#include <react/debug/react_native_assert.h>
+
+#include <cxxabi.h>
+
+#include <atomic>
+#include <cassert>
+#include <iostream>
+#include <string>
+
+#ifdef ANDROID
+#include <android/log.h>
+#endif // ANDROID
+
+// amzn_mod - use KPLog for logging on Kepler
+#ifdef KEPLER
+#include <KeplerScript/logger/KPLog.h>
+#endif // KEPLER
+
+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, "Worklets", "%s", message.c_str());
+// amzn_mod - add logging on Kepler
+#elif defined(KEPLER)
+      volta::react::KPLog.warn("[Worklets] {}", message);
+#else
+      std::cerr << "[Worklets] " << message << std::endl;
+#endif
+
+#ifdef IS_REANIMATED_EXAMPLE_APP
+      react_native_assert(false && "SingleInstanceChecker failed");
+#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,
+      "[Worklets] 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/Common/cpp/worklets/Tools/ThreadSafeQueue.h

@@ -0,0 +1,49 @@
+#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/Common/cpp/worklets/Tools/UIScheduler.cpp

@@ -0,0 +1,19 @@
+#include <worklets/Tools/UIScheduler.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/Common/cpp/worklets/Tools/UIScheduler.h

@@ -0,0 +1,26 @@
+#pragma once
+
+// amznmod_react - export symbols for reanimated
+#include <keplerui-083/keplerscript-export.h>
+
+#include <worklets/Tools/ThreadSafeQueue.h>
+
+#include <ReactCommon/CallInvoker.h>
+
+#include <atomic>
+
+namespace worklets {
+
+// amznmod_react - export symbols for reanimated
+class KEPLERSCRIPT_EXPORT 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/Common/cpp/worklets/Tools/VersionUtils.cpp

@@ -0,0 +1,75 @@
+#include <worklets/Tools/VersionUtils.h>
+
+#include <iostream>
+#include <regex>
+
+using namespace facebook;
+
+namespace worklets {
+
+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+");
+    std::smatch major1;
+    std::smatch major2;
+    std::regex_search(version1, major1, majorPattern);
+    std::regex_search(version2, major2, majorPattern);
+    if (major1 != major2) {
+      return false;
+    }
+    auto minorPattern = std::regex("\\.\\d+\\.");
+    std::smatch minor1;
+    std::smatch minor2;
+    std::regex_search(version1, minor1, minorPattern);
+    std::regex_search(version2, minor2, minorPattern);
+    if (minor1 != minor2) {
+      return false;
+    }
+    return true;
+  } else {
+    return version1 == version2;
+  }
+}
+
+void checkJSVersion(
+    jsi::Runtime &runtime,
+    jsi::Value &jsVersionValue,
+    const std::shared_ptr<worklets::JSLogger> &jsLogger,
+    const std::string &cppVersion,
+    const std::string &libraryName,
+    const std::string &docsBaseUrl) {
+  const auto libraryPrefix = std::string("[" + libraryName + "] ");
+
+  if (jsVersionValue.isUndefined()) {
+    jsLogger->warnOnJS(
+        std::string(
+            libraryPrefix +
+            "C++ side failed to resolve JavaScript code "
+            "version\n") +
+        "See " + docsBaseUrl +
+        "/guides/"
+        "troubleshooting#c-side-failed-to-resolve-javascript-code-version` for "
+        "more details.");
+    return;
+  }
+
+  const auto jsVersion = jsVersionValue.asString(runtime).utf8(runtime);
+
+  if (!matchVersion(cppVersion, jsVersion)) {
+    jsLogger->warnOnJS(
+        std::string(
+            libraryPrefix +
+            "Mismatch between C++ code version and "
+            "JavaScript code version (") +
+        cppVersion + " vs. " + jsVersion + " respectively).\n" + "See " +
+        docsBaseUrl +
+        "/guides/"
+        "troubleshooting#mismatch-between-c-code-version-and-javascript-code-"
+        "version` for more details.");
+    return;
+  }
+}
+
+}; // namespace worklets

package/Common/cpp/worklets/Tools/VersionUtils.h

@@ -0,0 +1,28 @@
+#pragma once
+
+// amznmod_react - export symbols for reanimated
+#include <keplerui-083/keplerscript-export.h>
+
+#include <worklets/Tools/JSLogger.h>
+
+#include <jsi/jsi.h>
+#include <memory>
+#include <regex>
+#include <string>
+
+using namespace facebook;
+
+namespace worklets {
+
+bool matchVersion(const std::string &version1, const std::string &version2);
+
+// amznmod_react - export symbols for reanimated
+void KEPLERSCRIPT_EXPORT checkJSVersion(
+    jsi::Runtime &runtime,
+    jsi::Value &jsVersionValue,
+    const std::shared_ptr<worklets::JSLogger> &jsLogger,
+    const std::string &cppVersion,
+    const std::string &libraryName,
+    const std::string &docsBaseUrl);
+
+}; // namespace worklets

package/Common/cpp/worklets/Tools/WorkletEventHandler.cpp

@@ -0,0 +1,29 @@
+#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/Common/cpp/worklets/Tools/WorkletEventHandler.h

@@ -0,0 +1,41 @@
+#pragma once
+
+#include <worklets/SharedItems/Serializable.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<SerializableWorklet> handlerFunction_;
+
+ public:
+  WorkletEventHandler(
+      const uint64_t handlerId,
+      const std::string &eventName,
+      const uint64_t emitterReactTag,
+      const std::shared_ptr<SerializableWorklet> &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/Common/cpp/worklets/Tools/WorkletsJSIUtils.cpp

@@ -0,0 +1,46 @@
+#include <worklets/Tools/WorkletsJSIUtils.h>
+
+#include <react/debug/react_native_assert.h>
+
+// amznmod_react - fix compilation errors
+#include <iterator>
+#include <memory>
+#include <sstream>
+#include <vector>
+
+using namespace facebook;
+
+namespace worklets::jsi_utils {
+
+jsi::Array convertStringToArray(
+    jsi::Runtime &rt,
+    const std::string &value,
+    const unsigned int expectedSize) {
+  std::vector<float> transformMatrixList;
+  std::istringstream stringStream(value);
+  std::copy(
+      std::istream_iterator<float>(stringStream),
+      std::istream_iterator<float>(),
+      std::back_inserter(transformMatrixList));
+  react_native_assert(
+      transformMatrixList.size() == expectedSize &&
+      "Transform matrix list size is different than expected");
+  jsi::Array matrix(rt, expectedSize);
+  for (unsigned int i = 0; i < expectedSize; i++) {
+    matrix.setValueAtIndex(rt, i, transformMatrixList[i]);
+  }
+  return matrix;
+}
+
+jsi::Object optimizedFromHostObject(
+    jsi::Runtime &rt,
+    std::shared_ptr<jsi::HostObject> &&hostObject) {
+  auto optimizedObject = jsi::Object(rt);
+  for (const auto &propertyName : hostObject->getPropertyNames(rt)) {
+    optimizedObject.setProperty(
+        rt, propertyName, hostObject->get(rt, propertyName));
+  }
+  return optimizedObject;
+}
+
+} // namespace worklets::jsi_utils

package/Common/cpp/worklets/Tools/WorkletsJSIUtils.h

@@ -0,0 +1,208 @@
+#pragma once
+
+#include <jsi/jsi.h>
+#include <react/debug/react_native_assert.h>
+#include <memory>
+#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("[Worklets] 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) {
+  react_native_assert(
+      sizeof...(Args) == count &&
+      "Argument list has different length than expected");
+  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) {
+  react_native_assert(
+      sizeof...(Args) == count &&
+      "Argument list has different length than expected");
+  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);
+
+jsi::Object optimizedFromHostObject(
+    jsi::Runtime &rt,
+    std::shared_ptr<jsi::HostObject> &&hostObject);
+
+} // namespace worklets::jsi_utils