Introduce executeOnUIRuntimeSync and use it to replace Sync Data Holder

Common/cpp/NativeModules/NativeReanimatedModule.cpp

@@ -58,7 +58,8 @@ NativeReanimatedModule::NativeReanimatedModule(
           rnRuntime,
           jsQueue,
           jsScheduler_,
-          "Reanimated UI runtime")),
+          "Reanimated UI runtime",
+          WorkletRuntimeType::WithLocking)),
       eventHandlerRegistry_(std::make_unique<EventHandlerRegistry>()),
       requestRender_(platformDepMethodsHolder.requestRender),
       onRenderCallback_([this](const double timestampMs) {
@@ -165,12 +166,31 @@ void NativeReanimatedModule::scheduleOnUI(
   });
 }
 
+jsi::Value NativeReanimatedModule::executeOnUIRuntimeSync(
+    jsi::Runtime &rt,
+    const jsi::Value &worklet) {
+  auto shareableWorklet = extractShareableOrThrow<ShareableWorklet>(
+      rt,
+      worklet,
+      "[Reanimated] Only worklets can be executed synchronously on UI runtime.");
+  auto lock = uiWorkletRuntime_->lock();
+  jsi::Runtime &uiRuntime = uiWorkletRuntime_->getJSIRuntime();
+  auto result = uiWorkletRuntime_->runGuarded(shareableWorklet);
+  auto shareableResult = extractShareableOrThrow(uiRuntime, result);
+  lock.unlock();
+  return shareableResult->getJSValue(rt);
+}
+
 jsi::Value NativeReanimatedModule::createWorkletRuntime(
     jsi::Runtime &rt,
     const jsi::Value &name,
     const jsi::Value &initializer) {
   auto workletRuntime = std::make_shared<WorkletRuntime>(
-      rt, jsQueue_, jsScheduler_, name.asString(rt).utf8(rt));
+      rt,
+      jsQueue_,
+      jsScheduler_,
+      name.asString(rt).utf8(rt),
+      WorkletRuntimeType::WithoutLocking);
   workletRuntime->installValueUnpacker(valueUnpackerCode_);
   auto initializerShareable = extractShareableOrThrow<ShareableWorklet>(
       rt, initializer, "[Reanimated] Initializer must be a worklet.");
@@ -186,27 +206,6 @@ jsi::Value NativeReanimatedModule::scheduleOnRuntime(
   return jsi::Value::undefined();
 }
 
-jsi::Value NativeReanimatedModule::makeSynchronizedDataHolder(
-    jsi::Runtime &rt,
-    const jsi::Value &initialShareable) {
-  auto dataHolder =
-      std::make_shared<ShareableSynchronizedDataHolder>(rt, initialShareable);
-  return dataHolder->getJSValue(rt);
-}
-
-void NativeReanimatedModule::updateDataSynchronously(
-    jsi::Runtime &rt,
-    const jsi::Value &synchronizedDataHolderRef,
-    const jsi::Value &newData) {
-  reanimated::updateDataSynchronously(rt, synchronizedDataHolderRef, newData);
-}
-
-jsi::Value NativeReanimatedModule::getDataSynchronously(
-    jsi::Runtime &rt,
-    const jsi::Value &synchronizedDataHolderRef) {
-  return reanimated::getDataSynchronously(rt, synchronizedDataHolderRef);
-}
-
 jsi::Value NativeReanimatedModule::makeShareableClone(
     jsi::Runtime &rt,
     const jsi::Value &value,

Common/cpp/NativeModules/NativeReanimatedModule.h

@@ -49,18 +49,9 @@ class NativeReanimatedModule : public NativeReanimatedModuleSpec {
       const jsi::Value &value,
       const jsi::Value &shouldRetainRemote) 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 executeOnUIRuntimeSync(jsi::Runtime &rt, const jsi::Value &worklet)
+      override;
 
   jsi::Value createWorkletRuntime(
       jsi::Runtime &rt,

Common/cpp/NativeModules/NativeReanimatedModuleSpec.cpp

@@ -27,36 +27,25 @@ static jsi::Value SPEC_PREFIX(makeShareableClone)(
       ->makeShareableClone(rt, std::move(args[0]), std::move(args[1]));
 }
 
-// Sync methods
+// scheduler
 
-static jsi::Value SPEC_PREFIX(makeSynchronizedDataHolder)(
+static jsi::Value SPEC_PREFIX(scheduleOnUI)(
     jsi::Runtime &rt,
     TurboModule &turboModule,
     const jsi::Value *args,
     size_t) {
-  return static_cast<NativeReanimatedModuleSpec *>(&turboModule)
-      ->makeSynchronizedDataHolder(rt, std::move(args[0]));
+  static_cast<NativeReanimatedModuleSpec *>(&turboModule)
+      ->scheduleOnUI(rt, std::move(args[0]));
+  return jsi::Value::undefined();
 }
 
-static jsi::Value SPEC_PREFIX(getDataSynchronously)(
+static jsi::Value SPEC_PREFIX(executeOnUIRuntimeSync)(
     jsi::Runtime &rt,
     TurboModule &turboModule,
     const jsi::Value *args,
     size_t) {
   return static_cast<NativeReanimatedModuleSpec *>(&turboModule)
-      ->getDataSynchronously(rt, std::move(args[0]));
-}
-
-// scheduler
-
-static jsi::Value SPEC_PREFIX(scheduleOnUI)(
-    jsi::Runtime &rt,
-    TurboModule &turboModule,
-    const jsi::Value *args,
-    size_t) {
-  static_cast<NativeReanimatedModuleSpec *>(&turboModule)
-      ->scheduleOnUI(rt, std::move(args[0]));
-  return jsi::Value::undefined();
+      ->executeOnUIRuntimeSync(rt, std::move(args[0]));
 }
 
 static jsi::Value SPEC_PREFIX(createWorkletRuntime)(
@@ -204,12 +193,9 @@ NativeReanimatedModuleSpec::NativeReanimatedModuleSpec(
   methodMap_["makeShareableClone"] =
       MethodMetadata{2, SPEC_PREFIX(makeShareableClone)};
 
-  methodMap_["makeSynchronizedDataHolder"] =
-      MethodMetadata{1, SPEC_PREFIX(makeSynchronizedDataHolder)};
-  methodMap_["getDataSynchronously"] =
-      MethodMetadata{1, SPEC_PREFIX(getDataSynchronously)};
-
   methodMap_["scheduleOnUI"] = MethodMetadata{1, SPEC_PREFIX(scheduleOnUI)};
+  methodMap_["executeOnUIRuntimeSync"] =
+      MethodMetadata{1, SPEC_PREFIX(executeOnUIRuntimeSync)};
   methodMap_["createWorkletRuntime"] =
       MethodMetadata{2, SPEC_PREFIX(createWorkletRuntime)};
   methodMap_["scheduleOnRuntime"] =

Common/cpp/NativeModules/NativeReanimatedModuleSpec.h

@@ -32,16 +32,11 @@ class JSI_EXPORT NativeReanimatedModuleSpec : public TurboModule {
       const jsi::Value &value,
       const jsi::Value &shouldRetainRemote) = 0;
 
-  // Synchronized data objects
-  virtual jsi::Value makeSynchronizedDataHolder(
-      jsi::Runtime &rt,
-      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;
+  virtual jsi::Value executeOnUIRuntimeSync(
+      jsi::Runtime &rt,
+      const jsi::Value &worklet) = 0;
 
   // Worklet runtime
   virtual jsi::Value createWorkletRuntime(

Common/cpp/ReanimatedRuntime/WorkletRuntime.cpp

@@ -4,19 +4,73 @@
 #include "WorkletRuntimeCollector.h"
 #include "WorkletRuntimeDecorator.h"
 
+#include <jsi/decorator.h>
+
 namespace reanimated {
 
+struct AroundLock {
+  std::recursive_mutex *mutex;
+  void before() {
+    mutex->lock();
+  }
+  void after() {
+    mutex->unlock();
+  }
+};
+
+class LockableRuntime : public jsi::WithRuntimeDecorator<AroundLock> {
+ private:
+  AroundLock aroundLock_;
+  std::shared_ptr<jsi::Runtime> runtime_;
+
+ public:
+  explicit LockableRuntime(
+      std::shared_ptr<jsi::Runtime> &&runtime,
+      std::recursive_mutex *runtimeMutex)
+      : jsi::WithRuntimeDecorator<AroundLock>(*runtime, aroundLock_),
+        runtime_(std::move(runtime)) {
+    aroundLock_.mutex = runtimeMutex;
+  }
+};
+
+static std::shared_ptr<jsi::Runtime> makeRuntime(
+    jsi::Runtime &runtime,
+    const std::shared_ptr<MessageQueueThread> &jsQueue,
+    const std::string &name,
+    bool supportLocking,
+    std::recursive_mutex *runtimeMutex) {
+  if (supportLocking) {
+    return std::make_shared<LockableRuntime>(
+        ReanimatedRuntime::make(runtime, jsQueue, name), runtimeMutex);
+  } else {
+    return ReanimatedRuntime::make(runtime, jsQueue, name);
+  }
+}
+
 WorkletRuntime::WorkletRuntime(
     jsi::Runtime &rnRuntime,
     const std::shared_ptr<MessageQueueThread> &jsQueue,
     const std::shared_ptr<JSScheduler> &jsScheduler,
-    const std::string &name)
-    : runtime_(ReanimatedRuntime::make(rnRuntime, jsQueue, name)), name_(name) {
+    const std::string &name,
+    WorkletRuntimeType type)
+    : runtime_(makeRuntime(
+          rnRuntime,
+          jsQueue,
+          name,
+          WorkletRuntimeType::WithLocking,
+          &runtimeMutex_)),
+      name_(name),
+      supportsLocking_(type == WorkletRuntimeType::WithLocking) {
   jsi::Runtime &rt = *runtime_;
   WorkletRuntimeCollector::install(rt);
   WorkletRuntimeDecorator::decorate(rt, name, jsScheduler);
 }
 
+std::unique_lock<std::recursive_mutex> WorkletRuntime::lock() {
+  assert(supportsLocking_ && "Runtime doesn't support locking");
+  return std::unique_lock<std::recursive_mutex>(runtimeMutex_);
+}
+
 void WorkletRuntime::installValueUnpacker(
     const std::string &valueUnpackerCode) {
   jsi::Runtime &rt = *runtime_;

Common/cpp/ReanimatedRuntime/WorkletRuntime.h

@@ -18,27 +18,32 @@ using namespace react;
 
 namespace reanimated {
 
+enum WorkletRuntimeType { WithLocking, WithoutLocking };
+
 class WorkletRuntime : public jsi::HostObject,
                        public std::enable_shared_from_this<WorkletRuntime> {
  public:
   explicit WorkletRuntime(
       jsi::Runtime &rnRuntime,
       const std::shared_ptr<MessageQueueThread> &jsQueue,
       const std::shared_ptr<JSScheduler> &jsScheduler,
-      const std::string &name);
+      const std::string &name,
+      WorkletRuntimeType type);
 
   void installValueUnpacker(const std::string &valueUnpackerCode);
 
   jsi::Runtime &getJSIRuntime() const {
     return *runtime_;
   }
 
+  std::unique_lock<std::recursive_mutex> lock();
+
   template <typename... Args>
-  inline void runGuarded(
+  inline jsi::Value runGuarded(
       const std::shared_ptr<ShareableWorklet> &shareableWorklet,
       Args &&...args) const {
     jsi::Runtime &rt = *runtime_;
-    runOnRuntimeGuarded(
+    return runOnRuntimeGuarded(
         rt, shareableWorklet->getJSValue(rt), std::forward<Args>(args)...);
   }
 
@@ -63,6 +68,8 @@ class WorkletRuntime : public jsi::HostObject,
   const std::shared_ptr<jsi::Runtime> runtime_;
   const std::string name_;
   std::shared_ptr<AsyncQueue> queue_;
+  std::recursive_mutex runtimeMutex_;
+  bool supportsLocking_;
 };
 
 // This function needs to be non-inline to avoid problems with dynamic_cast on

Common/cpp/ReanimatedRuntime/WorkletRuntimeDecorator.cpp

@@ -126,23 +126,6 @@ void WorkletRuntimeDecorator::decorate(
             rt, workletRuntimeValue, shareableWorkletValue);
       });
 
-  jsi_utils::installJsiFunction(
-      rt,
-      "_updateDataSynchronously",
-      [](jsi::Runtime &rt,
-         const jsi::Value &synchronizedDataHolderRef,
-         const jsi::Value &newData) {
-        return reanimated::updateDataSynchronously(
-            rt, synchronizedDataHolderRef, newData);
-      });
-
-  jsi_utils::installJsiFunction(
-      rt,
-      "_getDataSynchronously",
-      [](jsi::Runtime &rt, const jsi::Value &synchronizedDataHolderRef) {
-        return reanimated::getDataSynchronously(rt, synchronizedDataHolderRef);
-      });
-
   jsi::Object performance(rt);
   performance.setProperty(
       rt,

Common/cpp/SharedItems/Shareables.cpp

@@ -110,23 +110,6 @@ jsi::Value makeShareableClone(
   return ShareableJSRef::newHostObject(rt, shareable);
 }
 
-void updateDataSynchronously(
-    jsi::Runtime &rt,
-    const jsi::Value &synchronizedDataHolderRef,
-    const jsi::Value &newData) {
-  auto dataHolder = extractShareableOrThrow<ShareableSynchronizedDataHolder>(
-      rt, synchronizedDataHolderRef);
-  dataHolder->set(rt, newData);
-}
-
-jsi::Value getDataSynchronously(
-    jsi::Runtime &rt,
-    const jsi::Value &synchronizedDataHolderRef) {
-  auto dataHolder = extractShareableOrThrow<ShareableSynchronizedDataHolder>(
-      rt, synchronizedDataHolderRef);
-  return dataHolder->get(rt);
-}
-
 std::shared_ptr<Shareable> extractShareableOrThrow(
     jsi::Runtime &rt,
     const jsi::Value &maybeShareableValue,
@@ -273,42 +256,6 @@ jsi::Value ShareableHandle::toJSValue(jsi::Runtime &rt) {
   return jsi::Value(rt, *remoteValue_);
 }
 
-jsi::Value ShareableSynchronizedDataHolder::get(jsi::Runtime &rt) {
-  std::unique_lock<std::mutex> read_lock(dataAccessMutex_);
-  if (&rt == primaryRuntime_) {
-    if (primaryValue_ != nullptr) {
-      return jsi::Value(rt, *primaryValue_);
-    }
-    auto value = data_->getJSValue(rt);
-    primaryValue_ = std::make_unique<jsi::Value>(rt, value);
-    return value;
-  }
-  if (secondaryValue_ == nullptr) {
-    auto value = data_->getJSValue(rt);
-    secondaryValue_ = std::make_unique<jsi::Value>(rt, value);
-    secondaryRuntime_ = &rt;
-    return value;
-  }
-  if (&rt == secondaryRuntime_) {
-    return jsi::Value(rt, *secondaryValue_);
-  }
-  throw std::runtime_error(
-      "[Reanimated] ShareableSynchronizedDataHolder supports only RN or UI runtime");
-}
-
-void ShareableSynchronizedDataHolder::set(
-    jsi::Runtime &rt,
-    const jsi::Value &data) {
-  std::unique_lock<std::mutex> write_lock(dataAccessMutex_);
-  data_ = extractShareableOrThrow(rt, data);
-  primaryValue_.reset();
-  secondaryValue_.reset();
-}
-
-jsi::Value ShareableSynchronizedDataHolder::toJSValue(jsi::Runtime &rt) {
-  return ShareableJSRef::newHostObject(rt, shared_from_this());
-}
-
 jsi::Value ShareableString::toJSValue(jsi::Runtime &rt) {
   return jsi::String::createFromUtf8(rt, data_);
 }