react-native-reanimated 3.0.0-rc.9 → 3.0.1

package/Common/cpp/Registries/EventHandlerRegistry.cpp

@@ -10,7 +10,7 @@ void EventHandlerRegistry::registerEventHandler(
   eventHandlers[eventHandler->id] = eventHandler;
 }
 
-void EventHandlerRegistry::unregisterEventHandler(unsigned long id) {
+void EventHandlerRegistry::unregisterEventHandler(uint64_t id) {
   const std::lock_guard<std::mutex> lock(instanceMutex);
   auto handlerIt = eventHandlers.find(id);
   if (handlerIt != eventHandlers.end()) {
@@ -24,13 +24,9 @@ void EventHandlerRegistry::unregisterEventHandler(unsigned long id) {
 
 void EventHandlerRegistry::processEvent(
     jsi::Runtime &rt,
-    std::string eventName,
-#ifdef RCT_NEW_ARCH_ENABLED
-    jsi::Value &eventPayload
-#else
-    std::string eventPayload
-#endif
-    /**/) {
+    double eventTimestamp,
+    const std::string &eventName,
+    const jsi::Value &eventPayload) {
   std::vector<std::shared_ptr<WorkletEventHandler>> handlersForEvent;
   {
     const std::lock_guard<std::mutex> lock(instanceMutex);
@@ -41,38 +37,16 @@ void EventHandlerRegistry::processEvent(
       }
     }
   }
-#ifdef RCT_NEW_ARCH_ENABLED
-  eventPayload.asObject(rt).setProperty(
-      rt, "eventName", jsi::String::createFromUtf8(rt, eventName));
-  for (auto handler : handlersForEvent) {
-    handler->process(rt, eventPayload);
-  }
-#else
-  // We receive here a JS Map with JSON as a value of NativeMap key
-  // { NativeMap: { "jsonProp": "json value" } }
-  // So we need to extract only JSON part
-  std::string delimimter = "NativeMap:";
-  auto positionToSplit = eventPayload.find(delimimter) + delimimter.size();
-  auto lastBracketCharactedPosition = eventPayload.size() - positionToSplit - 1;
-  auto eventJSON =
-      eventPayload.substr(positionToSplit, lastBracketCharactedPosition);
 
-  if (eventJSON.compare(std::string("null")) == 0) {
-    return;
-  }
-
-  auto eventObject = jsi::Value::createFromJsonUtf8(
-      rt, reinterpret_cast<uint8_t *>(&eventJSON[0]), eventJSON.size());
-
-  eventObject.asObject(rt).setProperty(
+  eventPayload.asObject(rt).setProperty(
       rt, "eventName", jsi::String::createFromUtf8(rt, eventName));
   for (auto handler : handlersForEvent) {
-    handler->process(rt, eventObject);
+    handler->process(eventTimestamp, eventPayload);
   }
-#endif
 }
 
-bool EventHandlerRegistry::isAnyHandlerWaitingForEvent(std::string eventName) {
+bool EventHandlerRegistry::isAnyHandlerWaitingForEvent(
+    const std::string &eventName) {
   const std::lock_guard<std::mutex> lock(instanceMutex);
   auto it = eventMappings.find(eventName);
   return (it != eventMappings.end()) && (!(it->second).empty());

package/Common/cpp/Registries/EventHandlerRegistry.h

@@ -18,28 +18,22 @@ class WorkletEventHandler;
 class EventHandlerRegistry {
   std::map<
       std::string,
-      std::unordered_map<unsigned long, std::shared_ptr<WorkletEventHandler>>>
+      std::unordered_map<uint64_t, std::shared_ptr<WorkletEventHandler>>>
       eventMappings;
-  std::map<unsigned long, std::shared_ptr<WorkletEventHandler>> eventHandlers;
+  std::map<uint64_t, std::shared_ptr<WorkletEventHandler>> eventHandlers;
   std::mutex instanceMutex;
 
  public:
   void registerEventHandler(std::shared_ptr<WorkletEventHandler> eventHandler);
-  void unregisterEventHandler(unsigned long id);
+  void unregisterEventHandler(uint64_t id);
 
-#ifdef RCT_NEW_ARCH_ENABLED
   void processEvent(
       jsi::Runtime &rt,
-      std::string eventName,
-      jsi::Value &eventPayload);
-#else
-  void processEvent(
-      jsi::Runtime &rt,
-      std::string eventName,
-      std::string eventPayload);
-#endif
+      double eventTimestamp,
+      const std::string &eventName,
+      const jsi::Value &eventPayload);
 
-  bool isAnyHandlerWaitingForEvent(std::string eventName);
+  bool isAnyHandlerWaitingForEvent(const std::string &eventName);
 };
 
 } // namespace reanimated

package/Common/cpp/SharedItems/Shareables.cpp

@@ -11,10 +11,12 @@ CoreFunction::CoreFunction(
   jsi::Runtime &rt = *runtimeHelper->rnRuntime();
   auto workletObject = workletValue.asObject(rt);
   rnFunction_ = std::make_unique<jsi::Function>(workletObject.asFunction(rt));
-  functionBody_ =
-      workletObject.getProperty(rt, "asString").asString(rt).utf8(rt);
+  functionBody_ = workletObject.getPropertyAsObject(rt, "__initData")
+                      .getProperty(rt, "code")
+                      .asString(rt)
+                      .utf8(rt);
   location_ = "worklet_" +
-      std::to_string(static_cast<unsigned long long>(
+      std::to_string(static_cast<uint64_t>(
           workletObject.getProperty(rt, "__workletHash").getNumber()));
 }
 
@@ -59,61 +61,8 @@ std::shared_ptr<Shareable> extractShareableOrThrow(
 
 Shareable::~Shareable() {}
 
-#if HAS_JS_WEAK_OBJECTS
-
-jsi::Value RetainingShareable::getJSValue(jsi::Runtime &rt) {
-  jsi::Value value;
-  if (runtimeHelper_->isRNRuntime(rt)) {
-    // TODO: it is suboptimal to generate new object every time getJS is called
-    // on host runtime – the objects we are generating already exists and we
-    // should possibly just grab a hold of such object and use it here instead
-    // of creating a new JS representation. As far as I understand the only
-    // case where it can be realistically called this way is when a shared
-    // value is created and then accessed on the same runtime
-    return toJSValue(rt);
-  } else if (remoteValue_ == nullptr) {
-    value = toJSValue(rt);
-    remoteValue_ = std::make_unique<jsi::WeakObject>(rt, value.asObject(rt));
-  } else {
-    value = remoteValue_->lock(rt);
-    if (value.isUndefined()) {
-      value = toJSValue(rt);
-      remoteValue_ = std::make_unique<jsi::WeakObject>(rt, value.asObject(rt));
-    }
-  }
-  return value;
-}
-
-RetainingShareable::~RetainingShareable() {
-  if (runtimeHelper_->uiRuntimeDestroyed) {
-    // The below use of unique_ptr.release prevents the smart pointer from
-    // calling the destructor of the kept object. This effectively results in
-    // leaking some memory. We do this on purpose, as sometimes we would keep
-    // references to JSI objects past the lifetime of its runtime (e.g., shared
-    // values references from the RN VM holds reference to JSI objects on the
-    // UI runtime). When the UI runtime is terminated, the orphaned JSI objects
-    // would crash the app when their destructors are called, because they
-    // call into a memory that's managed by the terminated runtime. We accept
-    // the tradeoff of leaking memory here, as it has a limited impact. This
-    // scenario can only occur when the React instance is torn down which
-    // happens in development mode during app reloads, or in production when the
-    // app is being shut down gracefully by the system. An alternative solution
-    // would require us to keep track of all JSI values that are in use which
-    // would require additional data structure and compute spent on bookkeeping
-    // that only for the sake of destroying the values in time before the
-    // runtime is terminated. Note that the underlying memory that jsi::Value
-    // refers to is managed by the VM and gets freed along with the runtime.
-    remoteValue_.release();
-  }
-}
-
-#endif // HAS_JS_WEAK_OBJECTS
-
-ShareableArray::ShareableArray(
-    const std::shared_ptr<JSRuntimeHelper> &runtimeHelper,
-    jsi::Runtime &rt,
-    const jsi::Array &array)
-    : RetainingShareable(runtimeHelper, rt, ArrayType) {
+ShareableArray::ShareableArray(jsi::Runtime &rt, const jsi::Array &array)
+    : Shareable(ArrayType) {
   auto size = array.size(rt);
   data_.reserve(size);
   for (size_t i = 0; i < size; i++) {
@@ -121,11 +70,8 @@ ShareableArray::ShareableArray(
   }
 }
 
-ShareableObject::ShareableObject(
-    const std::shared_ptr<JSRuntimeHelper> &runtimeHelper,
-    jsi::Runtime &rt,
-    const jsi::Object &object)
-    : RetainingShareable(runtimeHelper, rt, ObjectType) {
+ShareableObject::ShareableObject(jsi::Runtime &rt, const jsi::Object &object)
+    : Shareable(ObjectType) {
   auto propertyNames = object.getPropertyNames(rt);
   auto size = propertyNames.size(rt);
   data_.reserve(size);

package/Common/cpp/SharedItems/Shareables.h

@@ -6,16 +6,10 @@
 #include <utility>
 #include <vector>
 
-#ifdef RCT_NEW_ARCH_ENABLED
-#include <react/renderer/uimanager/primitives.h>
-#endif
-
 #include "ReanimatedRuntime.h"
 #include "RuntimeManager.h"
 #include "Scheduler.h"
 
-#define HAS_JS_WEAK_OBJECTS (JS_RUNTIME_HERMES || JS_RUNTIME_V8)
-
 using namespace facebook;
 
 namespace reanimated {
@@ -57,7 +51,7 @@ class JSRuntimeHelper {
       const std::shared_ptr<Scheduler> &scheduler)
       : rnRuntime_(rnRuntime), uiRuntime_(uiRuntime), scheduler_(scheduler) {}
 
-  volatile bool uiRuntimeDestroyed;
+  volatile bool uiRuntimeDestroyed = false;
   std::unique_ptr<CoreFunction> callGuard;
   std::unique_ptr<CoreFunction> valueUnpacker;
 
@@ -121,9 +115,7 @@ class Shareable {
     RemoteFunctionType,
     HandleType,
     SynchronizedDataHolder,
-#ifdef RCT_NEW_ARCH_ENABLED
-    ShadowNode,
-#endif
+    HostObjectType,
   };
 
   explicit Shareable(ValueType valueType) : valueType_(valueType) {}
@@ -141,34 +133,57 @@ class Shareable {
   ValueType valueType_;
 };
 
-class RetainingShareable : public Shareable {
- protected:
-  std::shared_ptr<JSRuntimeHelper> runtimeHelper_;
-
-#if HAS_JS_WEAK_OBJECTS
-
+template <typename BaseClass>
+class RetainingShareable : virtual public BaseClass {
  private:
-  std::unique_ptr<jsi::WeakObject> remoteValue_;
-
- public:
-  jsi::Value getJSValue(jsi::Runtime &rt) final;
-
-  RetainingShareable(
-      const std::shared_ptr<JSRuntimeHelper> &runtimeHelper,
-      jsi::Runtime &rt,
-      ValueType valueType)
-      : Shareable(valueType), runtimeHelper_(runtimeHelper) {}
-
-  ~RetainingShareable();
-#else
+  std::shared_ptr<JSRuntimeHelper> runtimeHelper_;
+  std::unique_ptr<jsi::Value> remoteValue_;
 
  public:
+  template <typename... Args>
   RetainingShareable(
       const std::shared_ptr<JSRuntimeHelper> &runtimeHelper,
-      jsi::Runtime &rt,
-      ValueType valueType)
-      : Shareable(valueType), runtimeHelper_(runtimeHelper) {}
-#endif
+      Args &&...args)
+      : BaseClass(std::forward<Args>(args)...), runtimeHelper_(runtimeHelper) {}
+  jsi::Value getJSValue(jsi::Runtime &rt) {
+    if (runtimeHelper_->isRNRuntime(rt)) {
+      // TODO: it is suboptimal to generate new object every time getJS is
+      // called on host runtime – the objects we are generating already exists
+      // and we should possibly just grab a hold of such object and use it here
+      // instead of creating a new JS representation. As far as I understand the
+      // only case where it can be realistically called this way is when a
+      // shared value is created and then accessed on the same runtime
+      return BaseClass::toJSValue(rt);
+    } else if (remoteValue_ == nullptr) {
+      auto value = BaseClass::toJSValue(rt);
+      remoteValue_ = std::make_unique<jsi::Value>(rt, value);
+      return value;
+    }
+    return jsi::Value(rt, *remoteValue_);
+  }
+  ~RetainingShareable() {
+    if (runtimeHelper_->uiRuntimeDestroyed) {
+      // The below use of unique_ptr.release prevents the smart pointer from
+      // calling the destructor of the kept object. This effectively results in
+      // leaking some memory. We do this on purpose, as sometimes we would keep
+      // references to JSI objects past the lifetime of its runtime (e.g.,
+      // shared values references from the RN VM holds reference to JSI objects
+      // on the UI runtime). When the UI runtime is terminated, the orphaned JSI
+      // objects would crash the app when their destructors are called, because
+      // they call into a memory that's managed by the terminated runtime. We
+      // accept the tradeoff of leaking memory here, as it has a limited impact.
+      // This scenario can only occur when the React instance is torn down which
+      // happens in development mode during app reloads, or in production when
+      // the app is being shut down gracefully by the system. An alternative
+      // solution would require us to keep track of all JSI values that are in
+      // use which would require additional data structure and compute spent on
+      // bookkeeping that only for the sake of destroying the values in time
+      // before the runtime is terminated. Note that the underlying memory that
+      // jsi::Value refers to is managed by the VM and gets freed along with the
+      // runtime.
+      remoteValue_.release();
+    }
+  }
 };
 
 class ShareableJSRef : public jsi::HostObject {
@@ -210,12 +225,9 @@ std::shared_ptr<T> extractShareableOrThrow(
   return res;
 }
 
-class ShareableArray : public RetainingShareable {
+class ShareableArray : public Shareable {
  public:
-  ShareableArray(
-      const std::shared_ptr<JSRuntimeHelper> &runtimeHelper,
-      jsi::Runtime &rt,
-      const jsi::Array &array);
+  ShareableArray(jsi::Runtime &rt, const jsi::Array &array);
 
   jsi::Value toJSValue(jsi::Runtime &rt) override {
     auto size = data_.size();
@@ -230,12 +242,9 @@ class ShareableArray : public RetainingShareable {
   std::vector<std::shared_ptr<Shareable>> data_;
 };
 
-class ShareableObject : public RetainingShareable {
+class ShareableObject : public Shareable {
  public:
-  ShareableObject(
-      const std::shared_ptr<JSRuntimeHelper> &runtimeHelper,
-      jsi::Runtime &rt,
-      const jsi::Object &object);
+  ShareableObject(jsi::Runtime &rt, const jsi::Object &object);
   jsi::Value toJSValue(jsi::Runtime &rt) override {
     auto obj = jsi::Object(rt);
     for (size_t i = 0, size = data_.size(); i < size; i++) {
@@ -249,34 +258,31 @@ class ShareableObject : public RetainingShareable {
   std::vector<std::pair<std::string, std::shared_ptr<Shareable>>> data_;
 };
 
-#ifdef RCT_NEW_ARCH_ENABLED
-class ShareableShadowNodeWrapper : public Shareable {
- private:
-  react::ShadowNode::Shared shadowNode_;
-
+class ShareableHostObject : public Shareable {
  public:
-  ShareableShadowNodeWrapper(
+  ShareableHostObject(
       const std::shared_ptr<JSRuntimeHelper> &runtimeHelper,
       jsi::Runtime &rt,
-      const jsi::Object &wrapperObject)
-      : Shareable(ShadowNode) {
-    shadowNode_ =
-        wrapperObject.getHostObject<ShadowNodeWrapper>(rt)->shadowNode;
-  }
+      const std::shared_ptr<jsi::HostObject> &hostObject)
+      : Shareable(HostObjectType), hostObject_(hostObject) {}
   jsi::Value toJSValue(jsi::Runtime &rt) override {
-    return jsi::Object::createFromHostObject(
-        rt, std::make_shared<ShadowNodeWrapper>(shadowNode_));
+    return jsi::Object::createFromHostObject(rt, hostObject_);
   }
+
+ protected:
+  std::shared_ptr<jsi::HostObject> hostObject_;
 };
-#endif
 
 class ShareableWorklet : public ShareableObject {
+ private:
+  std::shared_ptr<JSRuntimeHelper> runtimeHelper_;
+
  public:
   ShareableWorklet(
       const std::shared_ptr<JSRuntimeHelper> &runtimeHelper,
       jsi::Runtime &rt,
       const jsi::Object &worklet)
-      : ShareableObject(runtimeHelper, rt, worklet) {
+      : ShareableObject(rt, worklet), runtimeHelper_(runtimeHelper) {
     valueType_ = WorkletType;
   }
   jsi::Value toJSValue(jsi::Runtime &rt) override {
@@ -286,18 +292,20 @@ class ShareableWorklet : public ShareableObject {
 };
 
 class ShareableRemoteFunction
-    : public RetainingShareable,
+    : public Shareable,
       public std::enable_shared_from_this<ShareableRemoteFunction> {
  private:
   jsi::Function function_;
+  std::shared_ptr<JSRuntimeHelper> runtimeHelper_;
 
  public:
   ShareableRemoteFunction(
       const std::shared_ptr<JSRuntimeHelper> &runtimeHelper,
       jsi::Runtime &rt,
       jsi::Function &&function)
-      : RetainingShareable(runtimeHelper, rt, RemoteFunctionType),
-        function_(std::move(function)) {}
+      : Shareable(RemoteFunctionType),
+        function_(std::move(function)),
+        runtimeHelper_(runtimeHelper) {}
   jsi::Value toJSValue(jsi::Runtime &rt) override {
     if (runtimeHelper_->isUIRuntime(rt)) {
 #ifdef DEBUG
@@ -326,8 +334,7 @@ class ShareableHandle : public Shareable {
       jsi::Runtime &rt,
       const jsi::Object &initializerObject)
       : Shareable(HandleType), runtimeHelper_(runtimeHelper) {
-    initializer_ =
-        std::make_unique<ShareableObject>(runtimeHelper, rt, initializerObject);
+    initializer_ = std::make_unique<ShareableObject>(rt, initializerObject);
   }
   ~ShareableHandle() {
     if (runtimeHelper_->uiRuntimeDestroyed) {
@@ -372,7 +379,7 @@ class ShareableSynchronizedDataHolder
   std::shared_ptr<Shareable> data_;
   std::shared_ptr<jsi::Value> uiValue_;
   std::shared_ptr<jsi::Value> rnValue_;
-  std::mutex dataAccessLock_;
+  std::mutex dataAccessMutex_; // Protects `data_`.
 
  public:
   ShareableSynchronizedDataHolder(
@@ -384,7 +391,7 @@ class ShareableSynchronizedDataHolder
         data_(extractShareableOrThrow(rt, initialValue)) {}
 
   jsi::Value get(jsi::Runtime &rt) {
-    std::unique_lock<std::mutex> read_lock(dataAccessLock_);
+    std::unique_lock<std::mutex> read_lock(dataAccessMutex_);
     if (runtimeHelper_->isUIRuntime(rt)) {
       if (uiValue_ == nullptr) {
         auto value = data_->getJSValue(rt);
@@ -405,7 +412,7 @@ class ShareableSynchronizedDataHolder
   }
 
   void set(jsi::Runtime &rt, const jsi::Value &data) {
-    std::unique_lock<std::mutex> write_lock(dataAccessLock_);
+    std::unique_lock<std::mutex> write_lock(dataAccessMutex_);
     data_ = extractShareableOrThrow(rt, data);
     uiValue_.reset();
     rnValue_.reset();
@@ -418,16 +425,14 @@ class ShareableSynchronizedDataHolder
 
 class ShareableString : public Shareable {
  public:
-  ShareableString(jsi::Runtime &rt, const jsi::String &string)
-      : Shareable(StringType) {
-    data = string.utf8(rt);
-  }
+  explicit ShareableString(const std::string &string)
+      : Shareable(StringType), data_(string) {}
   jsi::Value toJSValue(jsi::Runtime &rt) override {
-    return jsi::String::createFromUtf8(rt, data);
+    return jsi::String::createFromUtf8(rt, data_);
   }
 
  protected:
-  std::string data;
+  std::string data_;
 };
 
 class ShareableScalar : public Shareable {

package/Common/cpp/Tools/CollectionUtils.h

@@ -0,0 +1,14 @@
+#pragma once
+
+#include <algorithm>
+
+namespace reanimated {
+namespace collection {
+
+template <class CollectionType, class ValueType>
+inline bool contains(CollectionType &collection, const ValueType &value) {
+  return collection.find(value) != collection.end();
+}
+
+} // namespace collection
+} // namespace reanimated

package/Common/cpp/Tools/JsiUtils.cpp

@@ -0,0 +1,26 @@
+#include "JsiUtils.h"
+#include <vector>
+
+using namespace facebook;
+
+namespace reanimated::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));
+  assert(transformMatrixList.size() == expectedSize);
+  jsi::Array matrix(rt, expectedSize);
+  for (int i = 0; i < expectedSize; i++) {
+    matrix.setValueAtIndex(rt, i, transformMatrixList[i]);
+  }
+  return matrix;
+}
+
+} // namespace reanimated::jsi_utils