@depup/react-native-worklets 0.11.3-depup.0

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

@@ -0,0 +1,126 @@
+#pragma once
+
+#include <jsi/jsi.h>
+#include <worklets/SharedItems/MemoryManager.h>
+#include <worklets/SharedItems/Serializable.h>
+#include <worklets/SharedItems/UnpackerLoader.h>
+#include <worklets/Tools/RNRuntimeStatus.h>
+#include <worklets/Tools/ScriptBuffer.h>
+#include <worklets/WorkletRuntime/BundleModeConfig.h>
+#include <worklets/WorkletRuntime/RuntimeBindings.h>
+#include <worklets/WorkletRuntime/RuntimeData.h>
+#include <worklets/WorkletRuntime/RuntimeManager.h>
+
+#include <memory>
+#include <string>
+
+using namespace facebook;
+
+namespace worklets {
+
+class WorkletRuntime;
+
+class JSIWorkletsModuleProxy : public std::enable_shared_from_this<JSIWorkletsModuleProxy> {
+ public:
+  explicit JSIWorkletsModuleProxy(
+      const bool isDevBundle,
+      const std::shared_ptr<JSScheduler> &jsScheduler,
+      const std::shared_ptr<UIScheduler> &uiScheduler,
+      const std::shared_ptr<MemoryManager> &memoryManager,
+      const std::shared_ptr<RuntimeManager> &runtimeManager,
+      const std::weak_ptr<WorkletRuntime> &uiWorkletRuntime,
+      const std::shared_ptr<RuntimeBindings> &runtimeBindings,
+      const BundleModeConfig &bundleModeConfig,
+      const std::shared_ptr<UnpackerLoader> &unpackerLoader,
+      const std::shared_ptr<RNRuntimeStatus> &rnRuntimeStatus,
+      RuntimeData::RuntimeId hostRuntimeId)
+      : isDevBundle_(isDevBundle),
+        bundleModeConfig_(bundleModeConfig),
+        jsScheduler_(jsScheduler),
+        uiScheduler_(uiScheduler),
+        memoryManager_(memoryManager),
+        runtimeManager_(runtimeManager),
+        uiWorkletRuntime_(uiWorkletRuntime),
+        runtimeBindings_(runtimeBindings),
+        unpackerLoader_(unpackerLoader),
+        rnRuntimeStatus_(rnRuntimeStatus),
+        hostRuntimeId_(hostRuntimeId) {}
+
+  static std::shared_ptr<JSIWorkletsModuleProxy> createForNewRuntime(
+      const std::shared_ptr<const JSIWorkletsModuleProxy> &sourceProxy,
+      RuntimeData::RuntimeId hostRuntimeId) {
+    return std::make_shared<JSIWorkletsModuleProxy>(
+        sourceProxy->isDevBundle_,
+        sourceProxy->jsScheduler_,
+        sourceProxy->uiScheduler_,
+        sourceProxy->memoryManager_,
+        sourceProxy->runtimeManager_,
+        sourceProxy->uiWorkletRuntime_,
+        sourceProxy->runtimeBindings_,
+        sourceProxy->bundleModeConfig_,
+        sourceProxy->unpackerLoader_,
+        sourceProxy->rnRuntimeStatus_,
+        hostRuntimeId);
+  }
+
+  /** No copy constructor to prevent making JSIWorkletsModuleProxy with wrong hostRuntimeId. */
+  JSIWorkletsModuleProxy(const JSIWorkletsModuleProxy &other) = delete;
+
+  [[nodiscard]]
+  jsi::Object toOptimizedObject(jsi::Runtime &rt) const;
+
+  [[nodiscard]] std::shared_ptr<JSScheduler> getJSScheduler() const {
+    return jsScheduler_;
+  }
+
+  [[nodiscard]] std::shared_ptr<UIScheduler> getUIScheduler() const {
+    return uiScheduler_;
+  }
+
+  [[nodiscard]] bool isBundleModeEnabled() const {
+    return bundleModeConfig_.enabled;
+  }
+
+  [[nodiscard]] bool isDevBundle() const {
+    return isDevBundle_;
+  }
+
+  [[nodiscard]] std::shared_ptr<const ScriptBuffer> getScript() const {
+    return bundleModeConfig_.script;
+  }
+
+  [[nodiscard]] std::string getSourceUrl() const {
+    return bundleModeConfig_.sourceURL;
+  }
+
+  [[nodiscard]] std::shared_ptr<MemoryManager> getMemoryManager() const {
+    return memoryManager_;
+  }
+
+  [[nodiscard]] std::shared_ptr<RuntimeManager> getRuntimeManager() const {
+    return runtimeManager_;
+  }
+
+  [[nodiscard]] std::shared_ptr<RuntimeBindings> getRuntimeBindings() const {
+    return runtimeBindings_;
+  }
+
+  [[nodiscard]] std::shared_ptr<UnpackerLoader> getUnpackerLoader() const {
+    return unpackerLoader_;
+  }
+
+ private:
+  const bool isDevBundle_;
+  const BundleModeConfig bundleModeConfig_;
+  const std::shared_ptr<JSScheduler> jsScheduler_;
+  const std::shared_ptr<UIScheduler> uiScheduler_;
+  const std::shared_ptr<MemoryManager> memoryManager_;
+  const std::shared_ptr<RuntimeManager> runtimeManager_;
+  const std::weak_ptr<WorkletRuntime> uiWorkletRuntime_;
+  const std::shared_ptr<RuntimeBindings> runtimeBindings_;
+  const std::shared_ptr<UnpackerLoader> unpackerLoader_;
+  const std::shared_ptr<RNRuntimeStatus> rnRuntimeStatus_;
+  const RuntimeData::RuntimeId hostRuntimeId_;
+};
+
+} // namespace worklets

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

@@ -0,0 +1,81 @@
+#include <worklets/NativeModules/JSIWorkletsModuleProxy.h>
+#include <worklets/NativeModules/WorkletsModuleProxy.h>
+#include <worklets/RunLoop/AsyncQueueImpl.h>
+#include <worklets/WorkletRuntime/RNRuntimeWorkletDecorator.h>
+#include <worklets/WorkletRuntime/RuntimeBindings.h>
+#include <worklets/WorkletRuntime/RuntimeData.h>
+#include <worklets/WorkletRuntime/UIRuntimeDecorator.h>
+
+#include <memory>
+#include <utility>
+
+using namespace facebook;
+
+namespace worklets {
+
+bool isDevBundleFromRNRuntime(jsi::Runtime &rnRuntime) {
+  const auto rtDev = rnRuntime.global().getProperty(rnRuntime, "__DEV__");
+  return rtDev.isBool() && rtDev.asBool();
+}
+
+/**
+ * This method is required outside of Bundle Mode to make sure we start creating
+ * Worklet Runtimes only after unpackers code was loaded from the RN Runtime.
+ *
+ * In Bundle Mode unpackers are installed during bundle evaluation instead.
+ */
+void WorkletsModuleProxy::start() {
+  /**
+   * We call additional `init` method here because
+   * JSIWorkletsModuleProxy needs a weak_ptr to the UI Runtime.
+   */
+  const auto uiRuntimeProxy = JSIWorkletsModuleProxy::createForNewRuntime(rnRuntimeProxy_, RuntimeData::uiRuntimeId);
+  uiWorkletRuntime_->init(uiRuntimeProxy);
+
+  animationFrameBatchinator_ =
+      std::make_shared<AnimationFrameBatchinator>(uiWorkletRuntime_, runtimeBindings_->requestAnimationFrame);
+
+  UIRuntimeDecorator::decorate(
+      uiWorkletRuntime_->getJSIRuntime(), animationFrameBatchinator_->getJsiRequestAnimationFrame());
+}
+
+WorkletsModuleProxy::WorkletsModuleProxy(
+    jsi::Runtime &rnRuntime,
+    const std::shared_ptr<CallInvoker> &jsCallInvoker,
+    const std::shared_ptr<UIScheduler> &uiScheduler,
+    std::function<bool()> &&isJavaScriptThread,
+    const std::shared_ptr<RuntimeBindings> &runtimeBindings,
+    const BundleModeConfig &bundleModeConfig,
+    const std::shared_ptr<RNRuntimeStatus> &rnRuntimeStatus)
+    : isDevBundle_(isDevBundleFromRNRuntime(rnRuntime)),
+      jsScheduler_(std::make_shared<JSScheduler>(rnRuntime, jsCallInvoker, std::move(isJavaScriptThread))),
+      uiScheduler_(uiScheduler),
+      jsLogger_(std::make_shared<JSLogger>(jsScheduler_)),
+      runtimeBindings_(runtimeBindings),
+      bundleModeConfig_(bundleModeConfig),
+      memoryManager_(std::make_shared<MemoryManager>()),
+      runtimeManager_(std::make_shared<RuntimeManager>()),
+      unpackerLoader_(std::make_shared<UnpackerLoader>()),
+      rnRuntimeStatus_(rnRuntimeStatus),
+      uiWorkletRuntime_(runtimeManager_->createUninitializedUIRuntime(std::make_shared<AsyncQueueUI>(uiScheduler_))),
+      rnRuntimeProxy_(std::make_shared<JSIWorkletsModuleProxy>(
+          isDevBundle_,
+          jsScheduler_,
+          uiScheduler_,
+          memoryManager_,
+          runtimeManager_,
+          uiWorkletRuntime_,
+          runtimeBindings_,
+          bundleModeConfig_,
+          unpackerLoader_,
+          rnRuntimeStatus_,
+          RuntimeData::rnRuntimeId)) {
+  RNRuntimeWorkletDecorator::decorate(rnRuntime, rnRuntimeProxy_->toOptimizedObject(rnRuntime), jsLogger_);
+}
+
+WorkletsModuleProxy::~WorkletsModuleProxy() {
+  animationFrameBatchinator_.reset();
+  uiWorkletRuntime_.reset();
+}
+
+} // namespace worklets

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

@@ -0,0 +1,76 @@
+#pragma once
+
+#include <jsi/jsi.h>
+#include <worklets/AnimationFrameQueue/AnimationFrameBatchinator.h>
+#include <worklets/NativeModules/JSIWorkletsModuleProxy.h>
+#include <worklets/SharedItems/MemoryManager.h>
+#include <worklets/SharedItems/UnpackerLoader.h>
+#include <worklets/Tools/JSLogger.h>
+#include <worklets/Tools/JSScheduler.h>
+#include <worklets/Tools/RNRuntimeStatus.h>
+#include <worklets/Tools/ScriptBuffer.h>
+#include <worklets/Tools/SingleInstanceChecker.h>
+#include <worklets/Tools/UIScheduler.h>
+#include <worklets/WorkletRuntime/BundleModeConfig.h>
+#include <worklets/WorkletRuntime/RuntimeManager.h>
+#include <worklets/WorkletRuntime/WorkletRuntime.h>
+
+#include <memory>
+
+namespace worklets {
+
+class WorkletsModuleProxy : public std::enable_shared_from_this<WorkletsModuleProxy> {
+ public:
+  void start();
+
+  explicit WorkletsModuleProxy(
+      jsi::Runtime &rnRuntime,
+      const std::shared_ptr<CallInvoker> &jsCallInvoker,
+      const std::shared_ptr<UIScheduler> &uiScheduler,
+      std::function<bool()> &&isJavaScriptQueue,
+      const std::shared_ptr<RuntimeBindings> &runtimeBindings,
+      const BundleModeConfig &bundleModeConfig,
+      const std::shared_ptr<RNRuntimeStatus> &rnRuntimeStatus);
+
+  ~WorkletsModuleProxy();
+
+  [[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]] inline bool isDevBundle() const {
+    return isDevBundle_;
+  }
+
+ private:
+  const bool isDevBundle_;
+  const std::shared_ptr<JSScheduler> jsScheduler_;
+  const std::shared_ptr<UIScheduler> uiScheduler_;
+  const std::shared_ptr<JSLogger> jsLogger_;
+  const std::shared_ptr<RuntimeBindings> runtimeBindings_;
+  const BundleModeConfig bundleModeConfig_;
+  const std::shared_ptr<MemoryManager> memoryManager_;
+  const std::shared_ptr<RuntimeManager> runtimeManager_;
+  const std::shared_ptr<UnpackerLoader> unpackerLoader_;
+  const std::shared_ptr<RNRuntimeStatus> rnRuntimeStatus_;
+  std::shared_ptr<WorkletRuntime> uiWorkletRuntime_;
+  const std::shared_ptr<JSIWorkletsModuleProxy> rnRuntimeProxy_;
+  std::shared_ptr<AnimationFrameBatchinator> animationFrameBatchinator_;
+#ifndef NDEBUG
+  SingleInstanceChecker<WorkletsModuleProxy> singleInstanceChecker_;
+#endif // NDEBUG
+};
+
+} // namespace worklets

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

@@ -0,0 +1,95 @@
+// EventHandlerRegistry was fully moved to Reanimated.
+// This file is kept only for backwards compatibility with older versions of Reanimated.
+
+#include <worklets/Registries/EventHandlerRegistry.h>
+#include <worklets/Tools/WorkletEventHandler.h>
+
+#include <memory>
+#include <string>
+#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 (const 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 (const 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 (const 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,44 @@
+// EventHandlerRegistry was fully moved to Reanimated.
+// This file is kept only for backwards compatibility with older versions of Reanimated.
+
+#pragma once
+
+#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 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,10 @@
+#include <worklets/Registries/WorkletRuntimeRegistry.h>
+
+#include <set>
+
+namespace worklets {
+
+std::set<jsi::Runtime *> WorkletRuntimeRegistry::registry_{};
+std::shared_mutex WorkletRuntimeRegistry::mutex_{};
+
+} // namespace worklets

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

@@ -0,0 +1,43 @@
+#pragma once
+
+#include <jsi/jsi.h>
+#include <react/debug/react_native_assert.h>
+
+#include <set>
+#include <shared_mutex>
+#include <utility>
+
+using namespace facebook;
+
+namespace worklets {
+
+class WorkletRuntimeRegistry {
+ private:
+  static std::set<jsi::Runtime *> registry_;
+  static std::shared_mutex mutex_;
+
+  WorkletRuntimeRegistry() {}
+
+  static void registerRuntime(jsi::Runtime &runtime) {
+    std::lock_guard<std::shared_mutex> lock(mutex_);
+    registry_.insert(&runtime);
+  }
+
+  static void unregisterRuntime(jsi::Runtime &runtime) {
+    std::lock_guard<std::shared_mutex> lock(mutex_);
+    registry_.erase(&runtime);
+  }
+
+  friend class WorkletRuntimeCollector;
+
+ public:
+  template <typename TFn>
+  static void runWhileLocked(jsi::Runtime *runtime, TFn &&fn) {
+    react_native_assert(runtime != nullptr && "runtime is nullptr");
+    std::shared_lock<std::shared_mutex> lock(mutex_);
+    const bool isAlive = registry_.find(runtime) != registry_.end();
+    std::forward<TFn>(fn)(isAlive);
+  }
+};
+
+} // namespace worklets

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

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

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

@@ -0,0 +1,69 @@
+#include <worklets/RunLoop/AsyncQueueImpl.h>
+
+#ifdef ANDROID
+#include <fbjni/fbjni.h>
+#endif // ANDROID
+
+#include <memory>
+#include <string>
+#include <thread>
+#include <utility>
+
+namespace worklets {
+
+using namespace facebook;
+
+void AsyncQueueImpl::runLoop(const std::shared_ptr<AsyncQueueState> &state) {
+  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();
+  }
+}
+
+AsyncQueueImpl::AsyncQueueImpl(const std::string &name) : state_(std::make_shared<AsyncQueueState>()) {
+  auto thread = std::thread([name, state = state_] {
+#ifdef ANDROID
+    pthread_setname_np(pthread_self(), name.c_str());
+    jni::ThreadScope::WithClassLoader([state]() { AsyncQueueImpl::runLoop(state); });
+#else
+    pthread_setname_np(name.c_str());
+    AsyncQueueImpl::runLoop(state);
+#endif // ANDROID
+  });
+  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,48 @@
+#pragma once
+
+#include <jsi/jsi.h>
+#include <worklets/RunLoop/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(const std::string &name);
+
+  ~AsyncQueueImpl() override;
+
+  void push(std::function<void()> &&job) override;
+
+ private:
+  static void runLoop(const std::shared_ptr<AsyncQueueState> &state);
+
+  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