react-native-reanimated 3.0.0-rc.6 → 3.0.0-rc.8

package/Common/cpp/NativeModules/NativeReanimatedModule.h

@@ -13,7 +13,7 @@
 
 #include "AnimatedSensorModule.h"
 #include "ErrorHandler.h"
-#include "LayoutAnimationsProxy.h"
+#include "LayoutAnimationsManager.h"
 #include "NativeReanimatedModuleSpec.h"
 #include "PlatformDepMethodsHolder.h"
 #include "RuntimeDecorator.h"
@@ -25,46 +25,48 @@ namespace reanimated {
 
 using FrameCallback = std::function<void(double)>;
 
-class ShareableValue;
-class MutableValue;
-class MapperRegistry;
 class EventHandlerRegistry;
 
 class NativeReanimatedModule : public NativeReanimatedModuleSpec,
                                public RuntimeManager {
-  friend ShareableValue;
-  friend MutableValue;
-
  public:
   NativeReanimatedModule(
-      std::shared_ptr<CallInvoker> jsInvoker,
-      std::shared_ptr<Scheduler> scheduler,
-      std::shared_ptr<jsi::Runtime> rt,
-      std::shared_ptr<ErrorHandler> errorHandler,
+      const std::shared_ptr<CallInvoker> &jsInvoker,
+      const std::shared_ptr<Scheduler> &scheduler,
+      const std::shared_ptr<jsi::Runtime> &rt,
+      const std::shared_ptr<ErrorHandler> &errorHandler,
 #ifdef RCT_NEW_ARCH_ENABLED
   // nothing
 #else
       std::function<jsi::Value(jsi::Runtime &, const int, const jsi::String &)>
           propObtainer,
 #endif
-      std::shared_ptr<LayoutAnimationsProxy> layoutAnimationsProxy,
       PlatformDepMethodsHolder platformDepMethodsHolder);
 
-  void installCoreFunctions(jsi::Runtime &rt, const jsi::Value &valueSetter)
-      override;
+  ~NativeReanimatedModule();
 
-  jsi::Value makeShareable(jsi::Runtime &rt, const jsi::Value &value) override;
-  jsi::Value makeMutable(jsi::Runtime &rt, const jsi::Value &value) override;
-  jsi::Value makeRemote(jsi::Runtime &rt, const jsi::Value &value) override;
+  std::shared_ptr<JSRuntimeHelper> runtimeHelper;
 
-  jsi::Value startMapper(
+  void installCoreFunctions(
       jsi::Runtime &rt,
-      const jsi::Value &worklet,
-      const jsi::Value &inputs,
-      const jsi::Value &outputs,
-      const jsi::Value &updater,
-      const jsi::Value &viewDescriptors) override;
-  void stopMapper(jsi::Runtime &rt, const jsi::Value &mapperId) override;
+      const jsi::Value &workletMaker,
+      const jsi::Value &layoutAnimationStartFunction) override;
+
+  jsi::Value makeShareableClone(jsi::Runtime &rt, const jsi::Value &value)
+      override;
+
+  jsi::Value makeSynchronizedDataHolder(
+      jsi::Runtime &rt,
+      const jsi::Value &initialShareable) override;
+  jsi::Value getDataSynchronously(
+      jsi::Runtime &rt,
+      const jsi::Value &synchronizedDataHolderRef) override;
+  void updateDataSynchronously(
+      jsi::Runtime &rt,
+      const jsi::Value &synchronizedDataHolderRef,
+      const jsi::Value &newData);
+
+  void scheduleOnUI(jsi::Runtime &rt, const jsi::Value &worklet) override;
 
   jsi::Value registerEventHandler(
       jsi::Runtime &rt,
@@ -86,6 +88,11 @@ class NativeReanimatedModule : public NativeReanimatedModuleSpec,
       jsi::Runtime &rt,
       const jsi::Value &uiProps,
       const jsi::Value &nativeProps) override;
+  jsi::Value configureLayoutAnimation(
+      jsi::Runtime &rt,
+      const jsi::Value &viewTag,
+      const jsi::Value &type,
+      const jsi::Value &config) override;
 
   void onRender(double timestampMs);
 #ifdef RCT_NEW_ARCH_ENABLED
@@ -144,23 +151,17 @@ class NativeReanimatedModule : public NativeReanimatedModuleSpec,
       jsi::Runtime &rt,
       const jsi::Value &listenerId) override;
 
-  jsi::Value configureLayoutAnimation(
-      jsi::Runtime &rt,
-      const jsi::Value &viewTag,
-      const jsi::Value &type,
-      const jsi::Value &config,
-      const jsi::Value &viewSharedValue) override;
+  inline LayoutAnimationsManager &layoutAnimationsManager() {
+    return layoutAnimationsManager_;
+  }
 
  private:
 #ifdef RCT_NEW_ARCH_ENABLED
   bool isThereAnyLayoutProp(jsi::Runtime &rt, const jsi::Value &props);
 #endif // RCT_NEW_ARCH_ENABLED
 
-  std::shared_ptr<LayoutAnimationsProxy> layoutAnimationsProxy_;
-  std::shared_ptr<MapperRegistry> mapperRegistry;
-  std::shared_ptr<EventHandlerRegistry> eventHandlerRegistry;
+  std::unique_ptr<EventHandlerRegistry> eventHandlerRegistry;
   std::function<void(FrameCallback &, jsi::Runtime &)> requestRender;
-  std::shared_ptr<jsi::Value> dummyEvent;
   std::vector<FrameCallback> frameCallbacks;
   bool renderRequested = false;
   std::function<jsi::Value(jsi::Runtime &, const int, const jsi::String &)>
@@ -187,6 +188,7 @@ class NativeReanimatedModule : public NativeReanimatedModuleSpec,
 #endif
 
   std::unordered_set<std::string> nativePropNames_; // filled by configureProps
+  LayoutAnimationsManager layoutAnimationsManager_;
 
   KeyboardEventSubscribeFunction subscribeForKeyboardEventsFunction;
   KeyboardEventUnsubscribeFunction unsubscribeFromKeyboardEventsFunction;

package/Common/cpp/NativeModules/NativeReanimatedModuleSpec.cpp

@@ -12,61 +12,50 @@ static jsi::Value SPEC_PREFIX(installCoreFunctions)(
     const jsi::Value *args,
     size_t count) {
   static_cast<NativeReanimatedModuleSpec *>(&turboModule)
-      ->installCoreFunctions(rt, std::move(args[0]));
+      ->installCoreFunctions(rt, std::move(args[0]), std::move(args[1]));
   return jsi::Value::undefined();
 }
 
 // SharedValue
 
-static jsi::Value SPEC_PREFIX(makeShareable)(
+static jsi::Value SPEC_PREFIX(makeShareableClone)(
     jsi::Runtime &rt,
     TurboModule &turboModule,
     const jsi::Value *args,
     size_t count) {
   return static_cast<NativeReanimatedModuleSpec *>(&turboModule)
-      ->makeShareable(rt, std::move(args[0]));
+      ->makeShareableClone(rt, std::move(args[0]));
 }
 
-static jsi::Value SPEC_PREFIX(makeMutable)(
-    jsi::Runtime &rt,
-    TurboModule &turboModule,
-    const jsi::Value *args,
-    size_t count) {
-  return static_cast<NativeReanimatedModuleSpec *>(&turboModule)
-      ->makeMutable(rt, std::move(args[0]));
-}
+// Sync methods
 
-static jsi::Value SPEC_PREFIX(makeRemote)(
+static jsi::Value SPEC_PREFIX(makeSynchronizedDataHolder)(
     jsi::Runtime &rt,
     TurboModule &turboModule,
     const jsi::Value *args,
     size_t count) {
   return static_cast<NativeReanimatedModuleSpec *>(&turboModule)
-      ->makeRemote(rt, std::move(args[0]));
+      ->makeSynchronizedDataHolder(rt, std::move(args[0]));
 }
 
-static jsi::Value SPEC_PREFIX(startMapper)(
+static jsi::Value SPEC_PREFIX(getDataSynchronously)(
     jsi::Runtime &rt,
     TurboModule &turboModule,
     const jsi::Value *args,
     size_t count) {
   return static_cast<NativeReanimatedModuleSpec *>(&turboModule)
-      ->startMapper(
-          rt,
-          std::move(args[0]),
-          std::move(args[1]),
-          std::move(args[2]),
-          std::move(args[3]),
-          std::move(args[4]));
+      ->getDataSynchronously(rt, std::move(args[0]));
 }
 
-static jsi::Value SPEC_PREFIX(stopMapper)(
+// scheduler
+
+static jsi::Value SPEC_PREFIX(scheduleOnUI)(
     jsi::Runtime &rt,
     TurboModule &turboModule,
     const jsi::Value *args,
     size_t count) {
   static_cast<NativeReanimatedModuleSpec *>(&turboModule)
-      ->stopMapper(rt, std::move(args[0]));
+      ->scheduleOnUI(rt, std::move(args[0]));
   return jsi::Value::undefined();
 }
 
@@ -166,25 +155,24 @@ static jsi::Value SPEC_PREFIX(configureLayoutAnimation)(
     size_t count) {
   return static_cast<NativeReanimatedModuleSpec *>(&turboModule)
       ->configureLayoutAnimation(
-          rt,
-          std::move(args[0]),
-          std::move(args[1]),
-          std::move(args[2]),
-          std::move(args[3]));
+          rt, std::move(args[0]), std::move(args[1]), std::move(args[2]));
 }
 
 NativeReanimatedModuleSpec::NativeReanimatedModuleSpec(
     std::shared_ptr<CallInvoker> jsInvoker)
     : TurboModule("NativeReanimated", jsInvoker) {
   methodMap_["installCoreFunctions"] =
-      MethodMetadata{1, SPEC_PREFIX(installCoreFunctions)};
+      MethodMetadata{2, SPEC_PREFIX(installCoreFunctions)};
+
+  methodMap_["makeShareableClone"] =
+      MethodMetadata{1, SPEC_PREFIX(makeShareableClone)};
 
-  methodMap_["makeShareable"] = MethodMetadata{1, SPEC_PREFIX(makeShareable)};
-  methodMap_["makeMutable"] = MethodMetadata{1, SPEC_PREFIX(makeMutable)};
-  methodMap_["makeRemote"] = MethodMetadata{1, SPEC_PREFIX(makeRemote)};
+  methodMap_["makeSynchronizedDataHolder"] =
+      MethodMetadata{1, SPEC_PREFIX(makeSynchronizedDataHolder)};
+  methodMap_["getDataSynchronously"] =
+      MethodMetadata{1, SPEC_PREFIX(getDataSynchronously)};
 
-  methodMap_["startMapper"] = MethodMetadata{5, SPEC_PREFIX(startMapper)};
-  methodMap_["stopMapper"] = MethodMetadata{1, SPEC_PREFIX(stopMapper)};
+  methodMap_["scheduleOnUI"] = MethodMetadata{1, SPEC_PREFIX(scheduleOnUI)};
 
   methodMap_["registerEventHandler"] =
       MethodMetadata{2, SPEC_PREFIX(registerEventHandler)};

package/Common/cpp/NativeModules/NativeReanimatedModuleSpec.h

@@ -24,24 +24,24 @@ class JSI_EXPORT NativeReanimatedModuleSpec : public TurboModule {
  public:
   virtual void installCoreFunctions(
       jsi::Runtime &rt,
-      const jsi::Value &valueSetter) = 0;
+      const jsi::Value &valueUnpacker,
+      const jsi::Value &layoutAnimationStartFunction) = 0;
 
   // SharedValue
-  virtual jsi::Value makeShareable(
+  virtual jsi::Value makeShareableClone(
       jsi::Runtime &rt,
       const jsi::Value &value) = 0;
-  virtual jsi::Value makeMutable(jsi::Runtime &rt, const jsi::Value &value) = 0;
-  virtual jsi::Value makeRemote(jsi::Runtime &rt, const jsi::Value &value) = 0;
 
-  // mappers
-  virtual jsi::Value startMapper(
+  // Synchronized data objects
+  virtual jsi::Value makeSynchronizedDataHolder(
       jsi::Runtime &rt,
-      const jsi::Value &worklet,
-      const jsi::Value &inputs,
-      const jsi::Value &outputs,
-      const jsi::Value &updater,
-      const jsi::Value &viewDescriptors) = 0;
-  virtual void stopMapper(jsi::Runtime &rt, const jsi::Value &mapperId) = 0;
+      const jsi::Value &initialShareable) = 0;
+  virtual jsi::Value getDataSynchronously(
+      jsi::Runtime &rt,
+      const jsi::Value &synchronizedDataHolderRef) = 0;
+
+  // Scheduling
+  virtual void scheduleOnUI(jsi::Runtime &rt, const jsi::Value &worklet) = 0;
 
   // events
   virtual jsi::Value registerEventHandler(
@@ -91,8 +91,7 @@ class JSI_EXPORT NativeReanimatedModuleSpec : public TurboModule {
       jsi::Runtime &rt,
       const jsi::Value &viewTag,
       const jsi::Value &type,
-      const jsi::Value &config,
-      const jsi::Value &viewSharedValue) = 0;
+      const jsi::Value &config) = 0;
 };
 
 } // namespace reanimated

package/Common/cpp/SharedItems/RuntimeManager.h

@@ -3,11 +3,8 @@
 #include <jsi/jsi.h>
 #include <memory>
 #include "ErrorHandler.h"
-#include "JSIStoreValueUser.h"
 #include "RuntimeDecorator.h"
 #include "Scheduler.h"
-#include "ShareableValue.h"
-#include "WorkletsCache.h"
 
 namespace reanimated {
 
@@ -23,24 +20,10 @@ class RuntimeManager {
       std::shared_ptr<ErrorHandler> errorHandler,
       std::shared_ptr<Scheduler> scheduler,
       RuntimeType runtimeType = RuntimeType::Worklet)
-      : runtime(runtime),
-        errorHandler(errorHandler),
-        scheduler(scheduler),
-        workletsCache(std::make_unique<WorkletsCache>()),
-        storeUserData(std::make_shared<StaticStoreUser>()) {
+      : runtime(runtime), errorHandler(errorHandler), scheduler(scheduler) {
     RuntimeDecorator::registerRuntime(this->runtime.get(), runtimeType);
   }
 
-  virtual ~RuntimeManager() {
-    clearStore();
-  }
-
- public:
-  /**
-   Holds the jsi::Function worklet that is responsible for updating values in
-   JS. Can be null.
-   */
-  std::shared_ptr<ShareableValue> valueSetter;
   /**
    Holds the jsi::Runtime this RuntimeManager is managing.
    */
@@ -54,22 +37,6 @@ class RuntimeManager {
    React-JS Thread.
    */
   std::shared_ptr<Scheduler> scheduler;
-  /**
-   Holds a list of adapted Worklets which are cached to avoid unneccessary
-   recreation.
-   */
-  std::unique_ptr<WorkletsCache> workletsCache;
-  /**
-   Holds the JSI-Value Store where JSI::Values are cached on a
-   per-RuntimeManager basis.
-   */
-  std::shared_ptr<StaticStoreUser> storeUserData;
-
- private:
-  void clearStore() {
-    const std::lock_guard<std::recursive_mutex> lock(storeUserData->storeMutex);
-    storeUserData->store.clear();
-  }
 };
 
 } // namespace reanimated

package/Common/cpp/SharedItems/Shareables.cpp

@@ -0,0 +1,142 @@
+#include "Shareables.h"
+
+using namespace facebook;
+
+namespace reanimated {
+
+CoreFunction::CoreFunction(
+    JSRuntimeHelper *runtimeHelper,
+    const jsi::Value &workletValue)
+    : runtimeHelper_(runtimeHelper) {
+  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);
+  location_ = workletObject.getProperty(rt, "__location").asString(rt).utf8(rt);
+}
+
+std::unique_ptr<jsi::Function> &CoreFunction::getFunction(jsi::Runtime &rt) {
+  if (runtimeHelper_->isUIRuntime(rt)) {
+    if (uiFunction_ == nullptr) {
+      // maybe need to initialize UI Function
+      // the newline before closing paren is needed because the last line can be
+      // an inline comment (specifically this happens when we attach source maps
+      // at the end) in which case the paren won't be parsed
+      auto codeBuffer = std::make_shared<const jsi::StringBuffer>(
+          "(" + functionBody_ + "\n)");
+      uiFunction_ = std::make_unique<jsi::Function>(
+          rt.evaluateJavaScript(codeBuffer, location_)
+              .asObject(rt)
+              .asFunction(rt));
+    }
+    return uiFunction_;
+  } else {
+    // running on the main RN runtime
+    return rnFunction_;
+  }
+}
+
+std::shared_ptr<Shareable> extractShareableOrThrow(
+    jsi::Runtime &rt,
+    const jsi::Value &maybeShareableValue,
+    const char *errorMessage) {
+  if (maybeShareableValue.isObject()) {
+    auto object = maybeShareableValue.asObject(rt);
+    if (object.isHostObject<ShareableJSRef>(rt)) {
+      return object.getHostObject<ShareableJSRef>(rt)->value();
+    }
+  } else if (maybeShareableValue.isUndefined()) {
+    return Shareable::undefined();
+  }
+  throw std::runtime_error(
+      errorMessage != nullptr
+          ? errorMessage
+          : "expecting the object to be of type ShareableJSRef");
+}
+
+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) {
+  auto size = array.size(rt);
+  data_.reserve(size);
+  for (size_t i = 0; i < size; i++) {
+    data_.push_back(extractShareableOrThrow(rt, array.getValueAtIndex(rt, i)));
+  }
+}
+
+ShareableObject::ShareableObject(
+    const std::shared_ptr<JSRuntimeHelper> &runtimeHelper,
+    jsi::Runtime &rt,
+    const jsi::Object &object)
+    : RetainingShareable(runtimeHelper, rt, ObjectType) {
+  auto propertyNames = object.getPropertyNames(rt);
+  auto size = propertyNames.size(rt);
+  data_.reserve(size);
+  for (size_t i = 0; i < size; i++) {
+    auto key = propertyNames.getValueAtIndex(rt, i).asString(rt);
+    auto value = extractShareableOrThrow(rt, object.getProperty(rt, key));
+    data_.emplace_back(key.utf8(rt), value);
+  }
+}
+
+std::shared_ptr<Shareable> Shareable::undefined() {
+  static auto undefined = std::make_shared<ShareableScalar>();
+  return undefined;
+}
+
+} /* namespace reanimated */