@depup/react-native-worklets 0.11.4-depup.0 → 0.12.1-depup.0

package/Common/cpp/worklets/AnimationFrameQueue/AnimationFrameBatchinator.cpp

@@ -45,9 +45,12 @@ void AnimationFrameBatchinator::flush() {
     strongThis->flushRequested_ = false;
 
     auto &uiWorkletRuntime = strongThis->uiWorkletRuntime_;
-    for (const auto &callback : callbacks) {
-      uiWorkletRuntime->runSync(*callback, timestampMs);
-    }
+    uiWorkletRuntime->runSync([&](jsi::Runtime &rt) {
+      for (const auto &callback : callbacks) {
+        uiWorkletRuntime->runSync(*callback, timestampMs);
+      }
+      jsi_utils::triggerWeakRefCleanup(uiWorkletRuntime->getJSIRuntime());
+    });
   });
 }
 

package/Common/cpp/worklets/Compat/StableApi.cpp

@@ -22,6 +22,10 @@ void scheduleOnUI(const std::shared_ptr<UIScheduler> &uiScheduler, const std::fu
   uiScheduler->scheduleOnUI(job);
 }
 
+bool isOnUIThread(const std::shared_ptr<UIScheduler> &uiScheduler) {
+  return uiScheduler->isOnUIThread();
+}
+
 facebook::jsi::Runtime &getJSIRuntimeFromWorkletRuntime(const std::shared_ptr<WorkletRuntime> &workletRuntime) {
   return workletRuntime->getJSIRuntime();
 }

package/Common/cpp/worklets/Compat/StableApi.h

@@ -5,7 +5,7 @@
  * It can be used by libraries to verify they use a compatible version
  * of `react-native-worklets` installed when integrating in C++.
  */
-#define WORKLETS_STABLE_API_VERSION "0.9.0"
+#define WORKLETS_STABLE_API_VERSION "0.12.1"
 
 #include <cstdint>
 #include <functional>
@@ -83,6 +83,8 @@ extern std::weak_ptr<WorkletRuntime> getWeakRuntimeFromJSIRuntime(facebook::jsi:
 
 extern void scheduleOnUI(const std::shared_ptr<UIScheduler> &uiScheduler, const std::function<void()> &job);
 
+extern bool isOnUIThread(const std::shared_ptr<UIScheduler> &uiScheduler);
+
 extern std::string JSIValueToStdString(facebook::jsi::Runtime &rt, const facebook::jsi::Value &value);
 
 extern std::shared_ptr<Serializable>

package/Common/cpp/worklets/NativeModules/JSIWorkletsModuleProxy.cpp

@@ -71,37 +71,11 @@ inline void scheduleOnUI(
   if (!uiWorkletRuntime) {
     return;
   }
-  uiWorkletRuntime->schedule([worklets = std::move(worklets),
 #ifndef NDEBUG
-                              scheduleStacks = std::move(scheduleStacks),
-#endif // NDEBUG
-                              weakUIWorkletRuntime]() {
-    // This callback can outlive the WorkletsModuleProxy object during the
-    // invalidation of React Native. This happens when WorkletsModuleProxy
-    // destructor is called on the JS thread and the UI thread is
-    // executing callbacks from the `scheduleOnUI` queue. Therefore, we
-    // need to make sure it's still alive before we try to access it.
-    auto uiWorkletRuntime = weakUIWorkletRuntime.lock();
-    if (!uiWorkletRuntime) {
-      return;
-    }
-
-    // JSI's scope defined here allows for JSI-objects to be cleared up
-    // after each runtime loop. Within these loops we typically create
-    // some temporary JSI objects and hence it allows for such objects to
-    // be garbage collected much sooner.
-    const auto scope = jsi::Scope(uiWorkletRuntime->getJSIRuntime());
-
-    for (size_t i = 0; i < worklets.size(); i++) {
-#ifndef NDEBUG
-      uiWorkletRuntime->runSyncWithStack(worklets[i], scheduleStacks[i]);
+  uiWorkletRuntime->scheduleWithStack(std::move(worklets), std::move(scheduleStacks));
 #else
-      uiWorkletRuntime->runSync(worklets[i]);
+  uiWorkletRuntime->schedule(std::move(worklets));
 #endif // NDEBUG
-    }
-
-    uiWorkletRuntime->callMicrotasks();
-  });
 }
 
 #ifndef NDEBUG
@@ -113,7 +87,8 @@ inline jsi::Value runOnUISync(
   if (auto uiWorkletRuntime = weakUIWorkletRuntime.lock()) {
     auto serializableWorklet = extractSerializableOrThrow<SerializableWorklet>(
         rt, worklet, "[Worklets] Only worklets can be executed on UI runtime.");
-    auto serializedResult = uiWorkletRuntime->runSyncSerializedWithStack(serializableWorklet, scheduleStack);
+    auto serializedResult =
+        uiWorkletRuntime->runSyncWithStack<std::shared_ptr<Serializable>>(serializableWorklet, scheduleStack);
     return serializedResult->toJSValue(rt);
   }
   return jsi::Value::undefined();
@@ -140,7 +115,8 @@ jsi::Value runOnRuntimeSync(
   auto workletRuntime = workletRuntimeValue.getObject(rt).getHostObject<WorkletRuntime>(rt);
   auto worklet = extractSerializableOrThrow<SerializableWorklet>(
       rt, serializableWorkletValue, "[Worklets] Only worklets can be executed on a worklet runtime.");
-  return workletRuntime->runSyncSerializedWithStack(worklet, scheduleStack)->toJSValue(rt);
+  auto serializedResult = workletRuntime->runSyncWithStack<std::shared_ptr<Serializable>>(worklet, scheduleStack);
+  return serializedResult->toJSValue(rt);
 }
 #else
 jsi::Value
@@ -148,7 +124,8 @@ runOnRuntimeSync(jsi::Runtime &rt, const jsi::Value &workletRuntimeValue, const
   auto workletRuntime = workletRuntimeValue.getObject(rt).getHostObject<WorkletRuntime>(rt);
   auto worklet = extractSerializableOrThrow<SerializableWorklet>(
       rt, serializableWorkletValue, "[Worklets] Only worklets can be executed on a worklet runtime.");
-  return workletRuntime->runSyncSerialized(worklet)->toJSValue(rt);
+  auto serializedResult = workletRuntime->runSyncSerialized(worklet);
+  return serializedResult->toJSValue(rt);
 }
 #endif // NDEBUG
 
@@ -159,9 +136,10 @@ inline jsi::Value createWorkletRuntime(
     const std::string &name,
     std::shared_ptr<SerializableWorklet> &initializer,
     const std::shared_ptr<AsyncQueue> &queue,
-    bool enableEventLoop) {
+    bool enableEventLoop,
+    bool enableLocking) {
   const auto workletRuntime =
-      runtimeManager->createWorkletRuntime(sourceProxy, name, initializer, queue, enableEventLoop);
+      runtimeManager->createWorkletRuntime(sourceProxy, name, initializer, queue, enableEventLoop, enableLocking);
   return jsi::Object::createFromHostObject(originRuntime, workletRuntime);
 }
 
@@ -202,7 +180,9 @@ inline void registerCustomSerializable(
   runtimeManager->withRegistrationPaused([&] {
     memoryManager->registerCustomSerializable(data);
     for (const auto &runtime : runtimeManager->getAllRuntimes()) {
-      memoryManager->loadCustomSerializable(runtime, data);
+      if (runtime->isLockingEnabled()) {
+        memoryManager->loadCustomSerializable(runtime, data);
+      }
     }
   });
 }
@@ -505,21 +485,23 @@ jsi::Object JSIWorkletsModuleProxy::toOptimizedObject(jsi::Runtime &rt) const {
         if (at<2>(args).isString()) {
           scheduleStack = at<2>(args).asString(rt).utf8(rt);
         }
-        return workletRuntime->runSyncSerializedWithStack(serializableWorklet, scheduleStack)->toJSValue(rt);
+        auto serializedResult =
+            workletRuntime->runSyncWithStack<std::shared_ptr<Serializable>>(serializableWorklet, scheduleStack);
 #else
-        return workletRuntime->runSyncSerialized(serializableWorklet)->toJSValue(rt);
+        auto serializedResult = workletRuntime->runSyncSerialized(serializableWorklet);
 #endif // NDEBUG
+        return serializedResult->toJSValue(rt);
       });
 
-  jsi_utils::addMethod<5>(
+  jsi_utils::addMethod<6>(
       rt,
       obj,
       "createWorkletRuntime",
-      [sourceProxy = shared_from_this()](jsi::Runtime &rt, const jsi::Value &, const jsi::Value(&args)[5]) {
-        const auto name = at<0>(args).asString(rt).utf8(rt);
+      [sourceProxy = shared_from_this()](jsi::Runtime &rt, const jsi::Value &, const jsi::Value(&args)[6]) {
+        const auto name = at<0>(args).getString(rt).utf8(rt);
         auto serializableInitializer = extractSerializableOrThrow<SerializableWorklet>(
             rt, at<1>(args), "[Worklets] Initializer must be a worklet.");
-        const auto useDefaultQueue = at<2>(args).asBool();
+        const auto useDefaultQueue = at<2>(args).getBool();
 
         std::shared_ptr<AsyncQueue> asyncQueue;
         if (useDefaultQueue) {
@@ -528,11 +510,12 @@ jsi::Object JSIWorkletsModuleProxy::toOptimizedObject(jsi::Runtime &rt) const {
           asyncQueue = extractAsyncQueue(rt, at<3>(args));
         }
 
-        const auto enableEventLoop = at<4>(args).asBool();
+        const auto enableEventLoop = at<4>(args).getBool();
+        const auto enableLocking = at<5>(args).getBool();
         const auto runtimeManager = sourceProxy->getRuntimeManager();
 
         return createWorkletRuntime(
-            rt, runtimeManager, sourceProxy, name, serializableInitializer, asyncQueue, enableEventLoop);
+            rt, runtimeManager, sourceProxy, name, serializableInitializer, asyncQueue, enableEventLoop, enableLocking);
       });
 
   jsi_utils::addMethod<3>(
@@ -566,7 +549,7 @@ jsi::Object JSIWorkletsModuleProxy::toOptimizedObject(jsi::Runtime &rt) const {
         if (at<2>(args).isString()) {
           scheduleStack = at<2>(args).asString(rt).utf8(rt);
         }
-        workletRuntime->schedule(worklet, scheduleStack);
+        workletRuntime->scheduleWithStack(worklet, scheduleStack);
 #else
         workletRuntime->schedule(worklet);
 #endif // NDEBUG

package/Common/cpp/worklets/RunLoop/EventLoop.cpp

@@ -1,4 +1,5 @@
 #include <worklets/RunLoop/EventLoop.h>
+#include <worklets/Tools/WorkletsJSIUtils.h>
 
 #include <memory>
 #include <string>
@@ -11,8 +12,13 @@ namespace worklets {
 EventLoop::EventLoop(
     const std::string &name,
     const std::shared_ptr<jsi::Runtime> &runtime,
-    const std::shared_ptr<AsyncQueue> &queue)
-    : runtime_(runtime), queue_(queue), timeoutsQueueState_(std::make_shared<TimeoutsQueueState>()), name_(name) {}
+    const std::shared_ptr<AsyncQueue> &queue,
+    const std::shared_ptr<std::recursive_mutex> &runtimeMutex)
+    : runtime_(runtime),
+      queue_(queue),
+      runtimeMutex_(runtimeMutex),
+      timeoutsQueueState_(std::make_shared<TimeoutsQueueState>()),
+      name_(name) {}
 
 EventLoop::~EventLoop() {
   {
@@ -76,11 +82,14 @@ void EventLoop::run() {
 }
 
 void EventLoop::pushTask(std::function<void(jsi::Runtime &rt)> &&job) {
-  queue_->push([weakRuntime = std::weak_ptr<jsi::Runtime>{runtime_}, job = std::move(job)] {
-    if (auto runtime = weakRuntime.lock()) {
-      job(*runtime);
-    }
-  });
+  queue_->push(
+      [weakRuntime = std::weak_ptr<jsi::Runtime>{runtime_}, runtimeMutex = runtimeMutex_, job = std::move(job)] {
+        if (auto runtime = weakRuntime.lock()) {
+          std::unique_lock lock(*runtimeMutex);
+          job(*runtime);
+          jsi_utils::drainMicrotasks(*runtime);
+        }
+      });
 }
 
 void EventLoop::pushTimeout(std::function<void(jsi::Runtime &rt)> &&job, int64_t delay) {

package/Common/cpp/worklets/RunLoop/EventLoop.h

@@ -6,7 +6,7 @@
 #include <atomic>
 #include <condition_variable>
 #include <memory>
-#include <queue>
+#include <mutex>
 #include <string>
 #include <vector>
 
@@ -34,7 +34,8 @@ class EventLoop : public std::enable_shared_from_this<EventLoop> {
   EventLoop(
       const std::string &name,
       const std::shared_ptr<jsi::Runtime> &runtime,
-      const std::shared_ptr<AsyncQueue> &queue);
+      const std::shared_ptr<AsyncQueue> &queue,
+      const std::shared_ptr<std::recursive_mutex> &runtimeMutex);
   ~EventLoop();
   void run();
   void pushTask(std::function<void(jsi::Runtime &rt)> &&job);
@@ -43,6 +44,7 @@ class EventLoop : public std::enable_shared_from_this<EventLoop> {
  private:
   const std::shared_ptr<jsi::Runtime> runtime_;
   const std::shared_ptr<AsyncQueue> queue_;
+  const std::shared_ptr<std::recursive_mutex> runtimeMutex_;
   const std::shared_ptr<TimeoutsQueueState> timeoutsQueueState_;
   const std::string name_;
 

package/Common/cpp/worklets/SharedItems/MemoryManager.cpp

@@ -7,7 +7,7 @@
 namespace worklets {
 void MemoryManager::loadAllCustomSerializables(const std::shared_ptr<WorkletRuntime> &runtime) {
   std::lock_guard lock(customSerializationDataMutex_);
-  runtime->executeSync([&](jsi::Runtime &rt) -> jsi::Value {
+  runtime->runSync([&](jsi::Runtime &rt) -> jsi::Value {
     const auto registry = getCustomSerializationRegistry(rt);
     for (const auto &data : customSerializationData_) {
       loadCustomSerializable(rt, registry, data);
@@ -20,7 +20,7 @@ void MemoryManager::loadCustomSerializable(
     const std::shared_ptr<WorkletRuntime> &runtime,
     const SerializationData &data) {
   std::lock_guard lock(customSerializationDataMutex_);
-  runtime->executeSync([this, data](jsi::Runtime &rt) -> jsi::Value {
+  runtime->runSync([this, data](jsi::Runtime &rt) -> jsi::Value {
     const auto registry = getCustomSerializationRegistry(rt);
     loadCustomSerializable(rt, registry, data);
     return jsi::Value::undefined();

package/Common/cpp/worklets/SharedItems/Serializable.h

@@ -6,6 +6,7 @@
 #include <worklets/Tools/JSScheduler.h>
 #include <worklets/WorkletRuntime/RuntimeData.h>
 
+#include <atomic>
 #include <memory>
 #include <mutex>
 #include <optional>
@@ -46,8 +47,9 @@ template <typename BaseClass>
 class RetainingSerializable : virtual public BaseClass {
  private:
   jsi::Runtime *primaryRuntime_;
-  jsi::Runtime *secondaryRuntime_;
   std::unique_ptr<jsi::Value> secondaryValue_;
+  std::atomic<jsi::Runtime *> secondaryRuntime_{nullptr};
+  std::mutex secondaryCacheMutex_;
 
  public:
   template <typename... Args>
@@ -56,28 +58,24 @@ class RetainingSerializable : virtual public BaseClass {
 
   jsi::Value toJSValue(jsi::Runtime &rt) override {
     if (&rt == primaryRuntime_) {
-      // 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);
     }
-    if (secondaryValue_ == nullptr) {
-      auto value = BaseClass::toJSValue(rt);
-      secondaryValue_ = std::make_unique<jsi::Value>(rt, value);
-      secondaryRuntime_ = &rt;
-      return value;
-    }
-    if (&rt == secondaryRuntime_) {
+    if (secondaryRuntime_.load(std::memory_order_acquire) == &rt) {
       return jsi::Value(rt, *secondaryValue_);
     }
-    return BaseClass::toJSValue(rt);
+    auto value = BaseClass::toJSValue(rt);
+    {
+      std::lock_guard<std::mutex> lock(secondaryCacheMutex_);
+      if (secondaryRuntime_.load(std::memory_order_relaxed) == nullptr) {
+        secondaryValue_ = std::make_unique<jsi::Value>(rt, value);
+        secondaryRuntime_.store(&rt, std::memory_order_release);
+      }
+    }
+    return value;
   }
 
   ~RetainingSerializable() override {
-    cleanupRuntimeAware(secondaryRuntime_, secondaryValue_);
+    cleanupRuntimeAware(secondaryRuntime_.load(std::memory_order_relaxed), secondaryValue_);
   }
 };
 

package/Common/cpp/worklets/Tools/UIScheduler.cpp

@@ -1,9 +1,12 @@
 #include <worklets/Tools/UIScheduler.h>
 
+#include <optional>
 #include <utility>
 
 namespace worklets {
 
+static thread_local std::optional<bool> tls_isOnUIThread;
+
 void UIScheduler::scheduleOnUI(std::function<void()> job) {
   uiJobs_.push(std::move(job));
 }
@@ -16,4 +19,11 @@ void UIScheduler::triggerUI() {
   }
 }
 
+bool UIScheduler::isOnUIThread() const {
+  if (!tls_isOnUIThread.has_value()) {
+    tls_isOnUIThread = queryIsOnUIThread();
+  }
+  return *tls_isOnUIThread;
+}
+
 } // namespace worklets

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

@@ -12,9 +12,12 @@ class UIScheduler {
  public:
   virtual void scheduleOnUI(std::function<void()> job);
   virtual void triggerUI();
+  bool isOnUIThread() const;
   virtual ~UIScheduler() = default;
 
  protected:
+  virtual bool queryIsOnUIThread() const = 0;
+
   std::atomic<bool> scheduledOnUI_{false};
   ThreadSafeQueue<std::function<void()>> uiJobs_;
 };

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

@@ -11,6 +11,29 @@ using namespace facebook;
 
 namespace worklets::jsi_utils {
 
+/**
+ * Drains Hermes microtasks - we don't use these, but Hermes WeakRefs are
+ * cleaned during Hermes microtask checkpoint.
+ */
+inline void triggerWeakRefCleanup(jsi::Runtime &rt) {
+  rt.drainMicrotasks();
+}
+
+/**
+ * Drains both Worklets and Hermes microtasks.
+ */
+inline void drainMicrotasks(jsi::Runtime &rt) {
+  auto callMicrotasks = rt.global().getProperty(rt, "__callMicrotasks");
+  if (callMicrotasks.isObject()) {
+    auto callMicrotasksObject = callMicrotasks.getObject(rt);
+    if (callMicrotasksObject.isFunction(rt)) {
+      callMicrotasksObject.getFunction(rt).call(rt);
+    }
+  }
+
+  triggerWeakRefCleanup(rt);
+}
+
 // `get` functions take a pointer to `jsi::Value` and
 // call an appropriate method to cast to the native type
 template <typename T>

package/Common/cpp/worklets/WorkletRuntime/RuntimeManager.cpp

@@ -55,11 +55,12 @@ std::shared_ptr<WorkletRuntime> RuntimeManager::createWorkletRuntime(
     const std::string &name,
     const std::shared_ptr<SerializableWorklet> &initializer,
     const std::shared_ptr<AsyncQueue> &queue,
-    bool enableEventLoop) {
+    bool enableEventLoop,
+    bool enableLocking) {
   const auto runtimeId = getNextRuntimeId();
 
-  const auto workletRuntime =
-      std::make_shared<WorkletRuntime>(runtimeId, RuntimeData::RuntimeKind::Worker, name, queue, enableEventLoop);
+  const auto workletRuntime = std::make_shared<WorkletRuntime>(
+      runtimeId, RuntimeData::RuntimeKind::Worker, name, queue, enableEventLoop, enableLocking);
   const auto targetProxy = JSIWorkletsModuleProxy::createForNewRuntime(sourceProxy, runtimeId);
 
   workletRuntime->init(targetProxy);
@@ -84,7 +85,9 @@ void RuntimeManager::propagateModuleUpdate(const std::string &code, const std::s
   moduleUpdates_.push_back(ModuleUpdate{.sourceUrl = sourceUrl, .code = code});
 
   for (const auto &runtime : getAllRuntimes()) {
-    evaluateModuleUpdate(runtime, code, sourceUrl);
+    if (runtime->isLockingEnabled()) {
+      evaluateModuleUpdate(runtime, code, sourceUrl);
+    }
   }
 }
 

package/Common/cpp/worklets/WorkletRuntime/RuntimeManager.h

@@ -35,7 +35,8 @@ class RuntimeManager {
       const std::string &name,
       const std::shared_ptr<SerializableWorklet> &initializer = nullptr,
       const std::shared_ptr<AsyncQueue> &queue = nullptr,
-      bool enableEventLoop = true);
+      bool enableEventLoop = true,
+      bool enableLocking = true);
 
   std::shared_ptr<WorkletRuntime> createUninitializedUIRuntime(const std::shared_ptr<AsyncQueue> &uiAsyncQueue);