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

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

@@ -0,0 +1,88 @@
+
+#pragma once
+
+#include <cxxreact/MessageQueueThread.h>
+#include <react/renderer/uimanager/UIManagerBinding.h>
+#include <react/renderer/uimanager/primitives.h>
+
+#include <worklets/SharedItems/Serializable.h>
+#include <worklets/Tools/Defs.h>
+#include <worklets/WorkletRuntime/RuntimeManager.h>
+#include <worklets/WorkletRuntime/UIRuntimeDecorator.h>
+
+#ifdef __ANDROID__
+#include <fbjni/fbjni.h>
+#endif // __ANDROID__
+
+#include <jsi/jsi.h>
+
+#include <memory>
+#include <string>
+#include <vector>
+
+using namespace facebook;
+
+namespace worklets {
+
+class WorkletRuntime;
+
+class JSIWorkletsModuleProxy : public jsi::HostObject {
+ public:
+  explicit JSIWorkletsModuleProxy(
+      const bool isDevBundle,
+      const std::shared_ptr<const BigStringBuffer> &script,
+      const std::string &sourceUrl,
+      const std::shared_ptr<MessageQueueThread> &jsQueue,
+      const std::shared_ptr<JSScheduler> &jsScheduler,
+      const std::shared_ptr<UIScheduler> &uiScheduler,
+      const std::shared_ptr<RuntimeManager> &runtimeManager,
+      const std::weak_ptr<WorkletRuntime> &uiWorkletRuntime);
+
+  JSIWorkletsModuleProxy(const JSIWorkletsModuleProxy &other);
+
+  ~JSIWorkletsModuleProxy() override;
+
+  std::vector<jsi::PropNameID> getPropertyNames(jsi::Runtime &rt) override;
+
+  jsi::Value get(jsi::Runtime &rt, const jsi::PropNameID &propName) override;
+
+  [[nodiscard]] std::shared_ptr<MessageQueueThread> getJSQueue() const {
+    return jsQueue_;
+  }
+
+  [[nodiscard]] std::shared_ptr<JSScheduler> getJSScheduler() const {
+    return jsScheduler_;
+  }
+
+  [[nodiscard]] std::shared_ptr<UIScheduler> getUIScheduler() const {
+    return uiScheduler_;
+  }
+
+  [[nodiscard]] bool isDevBundle() const {
+    return isDevBundle_;
+  }
+
+  [[nodiscard]] std::shared_ptr<const BigStringBuffer> getScript() const {
+    return script_;
+  }
+
+  [[nodiscard]] std::string getSourceUrl() const {
+    return sourceUrl_;
+  }
+
+  [[nodiscard]] std::shared_ptr<RuntimeManager> getRuntimeManager() const {
+    return runtimeManager_;
+  }
+
+ private:
+  const bool isDevBundle_;
+  const std::shared_ptr<const BigStringBuffer> script_;
+  const std::string sourceUrl_;
+  const std::shared_ptr<MessageQueueThread> jsQueue_;
+  const std::shared_ptr<JSScheduler> jsScheduler_;
+  const std::shared_ptr<UIScheduler> uiScheduler_;
+  const std::shared_ptr<RuntimeManager> runtimeManager_;
+  const std::weak_ptr<WorkletRuntime> uiWorkletRuntime_;
+};
+
+} // namespace worklets

package/Common/cpp/worklets/NativeModules/WorkletsModuleProxy.cpp

@@ -0,0 +1,89 @@
+#include <react/renderer/uimanager/UIManagerBinding.h>
+#include <react/renderer/uimanager/primitives.h>
+
+#include <worklets/NativeModules/WorkletsModuleProxy.h>
+#include <worklets/RunLoop/AsyncQueueImpl.h>
+#include <worklets/SharedItems/Serializable.h>
+#include <worklets/Tools/Defs.h>
+#include <worklets/WorkletRuntime/UIRuntimeDecorator.h>
+
+#ifdef __ANDROID__
+#include <fbjni/fbjni.h>
+#endif // __ANDROID__
+
+#include <memory>
+#include <utility>
+
+using namespace facebook;
+
+namespace worklets {
+
+auto isDevBundleFromRNRuntime(jsi::Runtime &rnRuntime) -> bool;
+
+WorkletsModuleProxy::WorkletsModuleProxy(
+    jsi::Runtime &rnRuntime,
+    const std::shared_ptr<MessageQueueThread> &jsQueue,
+    const std::shared_ptr<CallInvoker> &jsCallInvoker,
+    const std::shared_ptr<UIScheduler> &uiScheduler,
+    std::function<bool()> &&isJavaScriptThread,
+    std::function<void(std::function<void(const double)>)>
+        &&forwardedRequestAnimationFrame,
+    const std::shared_ptr<const BigStringBuffer> &script,
+    const std::string &sourceUrl)
+    : isDevBundle_(isDevBundleFromRNRuntime(rnRuntime)),
+      jsQueue_(jsQueue),
+      jsScheduler_(std::make_shared<JSScheduler>(
+          rnRuntime,
+          jsCallInvoker,
+          std::move(isJavaScriptThread))),
+      uiScheduler_(uiScheduler),
+      jsLogger_(std::make_shared<JSLogger>(jsScheduler_)),
+      script_(script),
+      sourceUrl_(sourceUrl),
+      runtimeManager_(std::make_shared<RuntimeManager>()),
+      uiWorkletRuntime_(runtimeManager_->createUninitializedUIRuntime(
+          jsQueue_,
+          std::make_shared<AsyncQueueUI>(uiScheduler_))) {
+  /**
+   * We call additional `init` method here because
+   * JSIWorkletsModuleProxy needs a weak_ptr to the UI Runtime.
+   */
+  uiWorkletRuntime_->init(createJSIWorkletsModuleProxy());
+
+  animationFrameBatchinator_ = std::make_shared<AnimationFrameBatchinator>(
+      uiWorkletRuntime_->getJSIRuntime(),
+      std::move(forwardedRequestAnimationFrame));
+
+  UIRuntimeDecorator::decorate(
+      uiWorkletRuntime_->getJSIRuntime(),
+      animationFrameBatchinator_->getJsiRequestAnimationFrame());
+}
+
+std::shared_ptr<JSIWorkletsModuleProxy>
+WorkletsModuleProxy::createJSIWorkletsModuleProxy() const {
+  assert(
+      uiWorkletRuntime_ &&
+      "UI Worklet Runtime must be initialized before creating JSI proxy.");
+  return std::make_shared<JSIWorkletsModuleProxy>(
+      isDevBundle_,
+      script_,
+      sourceUrl_,
+      jsQueue_,
+      jsScheduler_,
+      uiScheduler_,
+      runtimeManager_,
+      uiWorkletRuntime_);
+}
+
+WorkletsModuleProxy::~WorkletsModuleProxy() {
+  animationFrameBatchinator_.reset();
+  jsQueue_->quitSynchronous();
+  uiWorkletRuntime_.reset();
+}
+
+auto isDevBundleFromRNRuntime(jsi::Runtime &rnRuntime) -> bool {
+  const auto rtDev = rnRuntime.global().getProperty(rnRuntime, "__DEV__");
+  return rtDev.isBool() && rtDev.asBool();
+}
+
+} // namespace worklets

package/Common/cpp/worklets/NativeModules/WorkletsModuleProxy.h

@@ -0,0 +1,80 @@
+#pragma once
+
+#include <cxxreact/MessageQueueThread.h>
+#include <jsi/jsi.h>
+#include <jsireact/JSIExecutor.h>
+#include <worklets/AnimationFrameQueue/AnimationFrameBatchinator.h>
+#include <worklets/NativeModules/JSIWorkletsModuleProxy.h>
+#include <worklets/Tools/JSLogger.h>
+#include <worklets/Tools/JSScheduler.h>
+#include <worklets/Tools/SingleInstanceChecker.h>
+#include <worklets/Tools/UIScheduler.h>
+#include <worklets/WorkletRuntime/RuntimeManager.h>
+#include <worklets/WorkletRuntime/WorkletRuntime.h>
+
+#include <memory>
+#include <string>
+
+namespace worklets {
+
+class WorkletsModuleProxy
+    : public std::enable_shared_from_this<WorkletsModuleProxy> {
+ public:
+  explicit WorkletsModuleProxy(
+      jsi::Runtime &rnRuntime,
+      const std::shared_ptr<MessageQueueThread> &jsQueue,
+      const std::shared_ptr<CallInvoker> &jsCallInvoker,
+      const std::shared_ptr<UIScheduler> &uiScheduler,
+      std::function<bool()> &&isJavaScriptQueue,
+      std::function<void(std::function<void(const double)>)>
+          &&forwardedRequestAnimationFrame,
+      const std::shared_ptr<const BigStringBuffer> &script,
+      const std::string &sourceUrl);
+
+  ~WorkletsModuleProxy();
+
+  [[nodiscard]] inline std::shared_ptr<MessageQueueThread> getJSQueue() const {
+    return jsQueue_;
+  }
+
+  [[nodiscard]] inline std::shared_ptr<JSScheduler> getJSScheduler() const {
+    return jsScheduler_;
+  }
+
+  [[nodiscard]] inline std::shared_ptr<UIScheduler> getUIScheduler() const {
+    return uiScheduler_;
+  }
+
+  [[nodiscard]] inline std::shared_ptr<JSLogger> getJSLogger() const {
+    return jsLogger_;
+  }
+
+  [[nodiscard]] inline std::shared_ptr<WorkletRuntime> getUIWorkletRuntime()
+      const {
+    return uiWorkletRuntime_;
+  }
+
+  [[nodiscard]] std::shared_ptr<JSIWorkletsModuleProxy>
+  createJSIWorkletsModuleProxy() const;
+
+  [[nodiscard]] inline bool isDevBundle() const {
+    return isDevBundle_;
+  }
+
+ private:
+  const bool isDevBundle_;
+  const std::shared_ptr<MessageQueueThread> jsQueue_;
+  const std::shared_ptr<JSScheduler> jsScheduler_;
+  const std::shared_ptr<UIScheduler> uiScheduler_;
+  const std::shared_ptr<JSLogger> jsLogger_;
+  const std::shared_ptr<const BigStringBuffer> script_;
+  const std::string sourceUrl_;
+  const std::shared_ptr<RuntimeManager> runtimeManager_;
+  std::shared_ptr<WorkletRuntime> uiWorkletRuntime_;
+  std::shared_ptr<AnimationFrameBatchinator> animationFrameBatchinator_;
+#ifndef NDEBUG
+  SingleInstanceChecker<WorkletsModuleProxy> singleInstanceChecker_;
+#endif // NDEBUG
+};
+
+} // namespace worklets

package/Common/cpp/worklets/Public/AsyncQueue.h

@@ -0,0 +1,14 @@
+#pragma once
+
+#include <jsi/jsi.h>
+
+namespace worklets {
+
+class AsyncQueue : public facebook::jsi::NativeState {
+ public:
+  virtual ~AsyncQueue() = default;
+
+  virtual void push(std::function<void()> &&job) = 0;
+};
+
+} // namespace worklets

package/Common/cpp/worklets/Registries/EventHandlerRegistry.cpp

@@ -0,0 +1,94 @@
+#include <worklets/Registries/EventHandlerRegistry.h>
+#include <worklets/Tools/WorkletEventHandler.h>
+
+#include <utility>
+#include <vector>
+
+namespace worklets {
+
+void EventHandlerRegistry::registerEventHandler(
+    const std::shared_ptr<WorkletEventHandler> &eventHandler) {
+  const std::lock_guard<std::mutex> lock(instanceMutex);
+  const auto &eventName = eventHandler->getEventName();
+  auto handlerId = eventHandler->getHandlerId();
+
+  if (eventHandler->shouldIgnoreEmitterReactTag()) {
+    eventMappingsWithoutTag[eventName][handlerId] = eventHandler;
+  } else {
+    const auto emitterReactTag = eventHandler->getEmitterReactTag();
+    const auto eventHash = std::make_pair(emitterReactTag, eventName);
+    eventMappingsWithTag[eventHash][handlerId] = eventHandler;
+  }
+  eventHandlers[handlerId] = eventHandler;
+}
+
+void EventHandlerRegistry::unregisterEventHandler(const uint64_t id) {
+  const std::lock_guard<std::mutex> lock(instanceMutex);
+  auto handlerIt = eventHandlers.find(id);
+  if (handlerIt != eventHandlers.end()) {
+    const auto &eventHandler = handlerIt->second;
+    const auto &eventName = eventHandler->getEventName();
+
+    if (eventHandler->shouldIgnoreEmitterReactTag()) {
+      const auto eventMappingIt = eventMappingsWithoutTag.find(eventName);
+      auto &handlersMap = eventMappingIt->second;
+      handlersMap.erase(id);
+      if (handlersMap.empty()) {
+        eventMappingsWithoutTag.erase(eventMappingIt);
+      }
+    } else {
+      const auto emitterReactTag = eventHandler->getEmitterReactTag();
+      const auto eventHash = std::make_pair(emitterReactTag, eventName);
+      const auto eventMappingIt = eventMappingsWithTag.find(eventHash);
+      auto &handlersMap = eventMappingIt->second;
+      handlersMap.erase(id);
+      if (handlersMap.empty()) {
+        eventMappingsWithTag.erase(eventMappingIt);
+      }
+    }
+    eventHandlers.erase(handlerIt);
+  }
+}
+
+void EventHandlerRegistry::processEvent(
+    const std::shared_ptr<WorkletRuntime> &uiWorkletRuntime,
+    const double eventTimestamp,
+    const std::string &eventName,
+    const int emitterReactTag,
+    const jsi::Value &eventPayload) {
+  std::vector<std::shared_ptr<WorkletEventHandler>> handlersForEvent;
+  {
+    const std::lock_guard<std::mutex> lock(instanceMutex);
+    auto handlersIt = eventMappingsWithoutTag.find(eventName);
+    if (handlersIt != eventMappingsWithoutTag.end()) {
+      for (auto handler : handlersIt->second) {
+        handlersForEvent.push_back(handler.second);
+      }
+    }
+    const auto eventHash = std::make_pair(emitterReactTag, eventName);
+    auto handlersWithTagIt = eventMappingsWithTag.find(eventHash);
+    if (handlersWithTagIt != eventMappingsWithTag.end()) {
+      for (auto handler : handlersWithTagIt->second) {
+        handlersForEvent.push_back(handler.second);
+      }
+    }
+  }
+
+  jsi::Runtime &rt = uiWorkletRuntime->getJSIRuntime();
+  eventPayload.asObject(rt).setProperty(
+      rt, "eventName", jsi::String::createFromUtf8(rt, eventName));
+  for (auto handler : handlersForEvent) {
+    handler->process(uiWorkletRuntime, eventTimestamp, eventPayload);
+  }
+}
+
+bool EventHandlerRegistry::isAnyHandlerWaitingForEvent(
+    const std::string &eventName,
+    const int emitterReactTag) {
+  const std::lock_guard<std::mutex> lock(instanceMutex);
+  const auto eventHash = std::make_pair(emitterReactTag, eventName);
+  auto it = eventMappingsWithTag.find(eventHash);
+  return it != eventMappingsWithTag.end() && !it->second.empty();
+}
+
+} // namespace worklets

package/Common/cpp/worklets/Registries/EventHandlerRegistry.h

@@ -0,0 +1,51 @@
+#pragma once
+
+#include <keplerui-083/keplerscript-export.h>
+
+#include <worklets/WorkletRuntime/WorkletRuntime.h>
+
+#include <jsi/jsi.h>
+
+#include <map>
+#include <memory>
+#include <mutex>
+#include <string>
+#include <unordered_map>
+#include <utility>
+
+using namespace facebook;
+
+namespace worklets {
+
+class WorkletEventHandler;
+
+class KEPLERSCRIPT_EXPORT EventHandlerRegistry {
+  std::map<
+      std::pair<int, std::string>,
+      std::unordered_map<uint64_t, std::shared_ptr<WorkletEventHandler>>>
+      eventMappingsWithTag;
+  std::map<
+      std::string,
+      std::unordered_map<uint64_t, std::shared_ptr<WorkletEventHandler>>>
+      eventMappingsWithoutTag;
+  std::map<uint64_t, std::shared_ptr<WorkletEventHandler>> eventHandlers;
+  std::mutex instanceMutex;
+
+ public:
+  void registerEventHandler(
+      const std::shared_ptr<WorkletEventHandler> &eventHandler);
+  void unregisterEventHandler(const uint64_t id);
+
+  void processEvent(
+      const std::shared_ptr<WorkletRuntime> &uiWorkletRuntime,
+      const double eventTimestamp,
+      const std::string &eventName,
+      const int emitterReactTag,
+      const jsi::Value &eventPayload);
+
+  bool isAnyHandlerWaitingForEvent(
+      const std::string &eventName,
+      const int emitterReactTag);
+};
+
+} // namespace worklets

package/Common/cpp/worklets/Registries/WorkletRuntimeRegistry.cpp

@@ -0,0 +1,8 @@
+#include <worklets/Registries/WorkletRuntimeRegistry.h>
+
+namespace worklets {
+
+std::set<jsi::Runtime *> WorkletRuntimeRegistry::registry_{};
+std::mutex WorkletRuntimeRegistry::mutex_{};
+
+} // namespace worklets

package/Common/cpp/worklets/Registries/WorkletRuntimeRegistry.h

@@ -0,0 +1,40 @@
+#pragma once
+
+#include <jsi/jsi.h>
+#include <react/debug/react_native_assert.h>
+
+#include <mutex>
+#include <set>
+
+using namespace facebook;
+
+namespace worklets {
+
+class WorkletRuntimeRegistry {
+ private:
+  static std::set<jsi::Runtime *> registry_;
+  static std::mutex mutex_; // Protects `registry_`.
+
+  WorkletRuntimeRegistry() {} // private ctor
+
+  static void registerRuntime(jsi::Runtime &runtime) {
+    std::lock_guard<std::mutex> lock(mutex_);
+    registry_.insert(&runtime);
+  }
+
+  static void unregisterRuntime(jsi::Runtime &runtime) {
+    std::lock_guard<std::mutex> lock(mutex_);
+    registry_.erase(&runtime);
+  }
+
+  friend class WorkletRuntimeCollector;
+
+ public:
+  static bool isRuntimeAlive(jsi::Runtime *runtime) {
+    react_native_assert(runtime != nullptr && "runtime is nullptr");
+    std::lock_guard<std::mutex> lock(mutex_);
+    return registry_.find(runtime) != registry_.end();
+  }
+};
+
+} // namespace worklets

package/Common/cpp/worklets/Resources/SynchronizableUnpacker.cpp

@@ -0,0 +1,49 @@
+// This file was generated with
+// `packages/react-native-worklets/scripts/export-unpackers.js`.
+// Please do not modify it directly.
+
+#include <worklets/Resources/Unpackers.h>
+
+namespace worklets {
+
+const char SynchronizableUnpackerCode[] =
+    R"DELIMITER__((function () {
+  var serializer = !globalThis._WORKLET || globalThis._WORKLETS_BUNDLE_MODE ? function (value, _) {
+    return (0, _serializable.createSerializable)(value);
+  } : globalThis._createSerializable;
+  function synchronizableUnpacker(synchronizableRef) {
+    var synchronizable = synchronizableRef;
+    var proxy = globalThis.__workletsModuleProxy;
+    synchronizable.__synchronizableRef = true;
+    synchronizable.getDirty = function () {
+      return proxy.synchronizableGetDirty(synchronizable);
+    };
+    synchronizable.getBlocking = function () {
+      return proxy.synchronizableGetBlocking(synchronizable);
+    };
+    synchronizable.setBlocking = function (valueOrFunction) {
+      var newValue;
+      if (typeof valueOrFunction === 'function') {
+        var func = valueOrFunction;
+        synchronizable.lock();
+        var prev = synchronizable.getBlocking();
+        newValue = func(prev);
+        proxy.synchronizableSetBlocking(synchronizable, serializer(newValue, undefined));
+        synchronizable.unlock();
+      } else {
+        var value = valueOrFunction;
+        newValue = value;
+        proxy.synchronizableSetBlocking(synchronizable, serializer(newValue, undefined));
+      }
+    };
+    synchronizable.lock = function () {
+      proxy.synchronizableLock(synchronizable);
+    };
+    synchronizable.unlock = function () {
+      proxy.synchronizableUnlock(synchronizable);
+    };
+    return synchronizable;
+  }
+  globalThis.__synchronizableUnpacker = synchronizableUnpacker;
+})();)DELIMITER__";
+} // namespace worklets

package/Common/cpp/worklets/Resources/Unpackers.h

@@ -0,0 +1,6 @@
+#pragma once
+
+namespace worklets {
+extern const char ValueUnpackerCode[];
+extern const char SynchronizableUnpackerCode[];
+} // namespace worklets

package/Common/cpp/worklets/Resources/ValueUnpacker.cpp

@@ -0,0 +1,53 @@
+// This file was generated with
+// `packages/react-native-worklets/scripts/export-unpackers.js`.
+// Please do not modify it directly.
+
+#include <worklets/Resources/Unpackers.h>
+
+namespace worklets {
+
+const char ValueUnpackerCode[] =
+    R"DELIMITER__((function () {
+  var workletsCache = new Map();
+  var handleCache = new WeakMap();
+  function valueUnpacker(objectToUnpack, category, remoteFunctionName) {
+    'use strict';
+
+    var workletHash = objectToUnpack.__workletHash;
+    if (workletHash !== undefined) {
+      var workletFun = workletsCache.get(workletHash);
+      if (workletFun === undefined) {
+        var initData = objectToUnpack.__initData;
+        if (globalThis.evalWithSourceMap) {
+          workletFun = globalThis.evalWithSourceMap('(' + initData.code + '\n)', initData.location, initData.sourceMap);
+        } else if (globalThis.evalWithSourceUrl) {
+          workletFun = globalThis.evalWithSourceUrl('(' + initData.code + '\n)', "worklet_".concat(workletHash));
+        } else {
+          workletFun = eval('(' + initData.code + '\n)');
+        }
+        workletsCache.set(workletHash, workletFun);
+      }
+      var functionInstance = workletFun.bind(objectToUnpack);
+      objectToUnpack._recur = functionInstance;
+      return functionInstance;
+    } else if (objectToUnpack.__init !== undefined) {
+      var value = handleCache.get(objectToUnpack);
+      if (value === undefined) {
+        value = objectToUnpack.__init();
+        handleCache.set(objectToUnpack, value);
+      }
+      return value;
+    } else if (category === 'RemoteFunction') {
+      var fun = function fun() {
+        var label = remoteFunctionName ? "function `".concat(remoteFunctionName, "`") : 'anonymous function';
+        throw new Error("[Worklets] Tried to synchronously call a non-worklet ".concat(label, " on the UI thread.\nSee https://docs.swmansion.com/react-native-reanimated/docs/guides/troubleshooting#tried-to-synchronously-call-a-non-worklet-function-on-the-ui-thread for more details."));
+      };
+      fun.__remoteFunction = objectToUnpack;
+      return fun;
+    } else {
+      throw new Error("[Worklets] Data type in category \"".concat(category, "\" not recognized by value unpacker: \"").concat(globalThis._toString(objectToUnpack), "\"."));
+    }
+  }
+  globalThis.__valueUnpacker = valueUnpacker;
+})();)DELIMITER__";
+} // namespace worklets

package/Common/cpp/worklets/RunLoop/AsyncQueueImpl.cpp

@@ -0,0 +1,62 @@
+#include <worklets/RunLoop/AsyncQueueImpl.h>
+
+#include <thread>
+#include <utility>
+
+namespace worklets {
+
+AsyncQueueImpl::AsyncQueueImpl(std::string name)
+    : state_(std::make_shared<AsyncQueueState>()) {
+  auto thread = std::thread([name, state = state_] {
+// amzn_mod - include check for VOLTA_DARWIN
+#if __APPLE__ || defined(VOLTA_DARWIN)
+    pthread_setname_np(name.c_str());
+#endif // __APPLE__ || VOLTA_DARWIN
+    while (state->running) {
+      std::unique_lock<std::mutex> lock(state->mutex);
+      state->cv.wait(
+          lock, [state] { return !state->queue.empty() || !state->running; });
+      if (!state->running) {
+        return;
+      }
+      if (state->queue.empty()) {
+        continue;
+      }
+      auto job = std::move(state->queue.front());
+      state->queue.pop();
+      lock.unlock();
+      job();
+    }
+  });
+// amzn_mod - exclude VOLTA_DARWIN
+#if defined(ANDROID) && not defined(VOLTA_DARWIN)
+  pthread_setname_np(thread.native_handle(), name.c_str());
+#endif // ANDROID && !VOLTA_DARWIN
+  thread.detach();
+}
+
+AsyncQueueImpl::~AsyncQueueImpl() {
+  {
+    std::unique_lock<std::mutex> lock(state_->mutex);
+    state_->running = false;
+    state_->queue = {};
+  }
+  state_->cv.notify_all();
+}
+
+void AsyncQueueImpl::push(std::function<void()> &&job) {
+  {
+    std::unique_lock<std::mutex> lock(state_->mutex);
+    state_->queue.emplace(job);
+  }
+  state_->cv.notify_one();
+}
+
+AsyncQueueUI::AsyncQueueUI(const std::shared_ptr<UIScheduler> &uiScheduler)
+    : uiScheduler_(uiScheduler) {}
+
+void AsyncQueueUI::push(std::function<void()> &&job) {
+  uiScheduler_->scheduleOnUI(std::move(job));
+}
+
+} // namespace worklets

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

@@ -0,0 +1,46 @@
+#pragma once
+
+#include <jsi/jsi.h>
+#include <worklets/Public/AsyncQueue.h>
+#include <worklets/Tools/UIScheduler.h>
+
+#include <atomic>
+#include <condition_variable>
+#include <memory>
+#include <queue>
+#include <string>
+
+namespace worklets {
+
+struct AsyncQueueState {
+  std::atomic_bool running{true};
+  std::mutex mutex;
+  std::condition_variable cv;
+  std::queue<std::function<void()>> queue;
+};
+
+class AsyncQueueImpl : public AsyncQueue {
+ public:
+  explicit AsyncQueueImpl(std::string name);
+
+  ~AsyncQueueImpl() override;
+
+  void push(std::function<void()> &&job) override;
+
+ private:
+  const std::shared_ptr<AsyncQueueState> state_;
+};
+
+class AsyncQueueUI : public AsyncQueue {
+ public:
+  explicit AsyncQueueUI(const std::shared_ptr<UIScheduler> &uiScheduler);
+
+  ~AsyncQueueUI() override = default;
+
+  void push(std::function<void()> &&job) override;
+
+ private:
+  std::shared_ptr<UIScheduler> uiScheduler_;
+};
+
+} // namespace worklets