@react-native-ohos/react-native-reanimated 3.18.1-rc.1

package/harmony/reanimated/src/main/cpp/Common/cpp/reanimated/RuntimeDecorators/UIRuntimeDecorator.cpp

@@ -0,0 +1,70 @@
+#include <reanimated/RuntimeDecorators/UIRuntimeDecorator.h>
+#include <worklets/Tools/ReanimatedJSIUtils.h>
+
+namespace reanimated {
+
+using namespace worklets;
+
+void UIRuntimeDecorator::decorate(
+    jsi::Runtime &uiRuntime,
+#ifdef RCT_NEW_ARCH_ENABLED
+// nothing
+#else
+    const ScrollToFunction scrollTo,
+#endif
+    const ObtainPropFunction obtainPropFunction,
+    const UpdatePropsFunction updateProps,
+    const MeasureFunction measure,
+    const DispatchCommandFunction dispatchCommand,
+    const RequestAnimationFrameFunction requestAnimationFrame,
+    const GetAnimationTimestampFunction getAnimationTimestamp,
+    const SetGestureStateFunction setGestureState,
+    const ProgressLayoutAnimationFunction progressLayoutAnimation,
+    const EndLayoutAnimationFunction endLayoutAnimation,
+    const MaybeFlushUIUpdatesQueueFunction maybeFlushUIUpdatesQueue) {
+  uiRuntime.global().setProperty(uiRuntime, "_UI", true);
+
+#ifdef RCT_NEW_ARCH_ENABLED
+  jsi_utils::installJsiFunction(uiRuntime, "_updatePropsFabric", updateProps);
+  jsi_utils::installJsiFunction(
+      uiRuntime, "_dispatchCommandFabric", dispatchCommand);
+  jsi_utils::installJsiFunction(uiRuntime, "_measureFabric", measure);
+#else
+  jsi_utils::installJsiFunction(uiRuntime, "_updatePropsPaper", updateProps);
+  jsi_utils::installJsiFunction(
+      uiRuntime, "_dispatchCommandPaper", dispatchCommand);
+  jsi_utils::installJsiFunction(uiRuntime, "_scrollToPaper", scrollTo);
+  jsi_utils::installJsiFunction(
+      uiRuntime,
+      "_measurePaper",
+      [measure](jsi::Runtime &rt, int viewTag) -> jsi::Value {
+        auto result = measure(viewTag);
+        jsi::Object resultObject(rt);
+        for (const auto &item : result) {
+          resultObject.setProperty(rt, item.first.c_str(), item.second);
+        }
+        return resultObject;
+      });
+  jsi_utils::installJsiFunction(
+      uiRuntime, "_obtainPropPaper", obtainPropFunction);
+#endif // RCT_NEW_ARCH_ENABLED
+
+  jsi_utils::installJsiFunction(
+      uiRuntime, "requestAnimationFrame", requestAnimationFrame);
+  jsi_utils::installJsiFunction(
+      uiRuntime, "_getAnimationTimestamp", getAnimationTimestamp);
+
+  jsi_utils::installJsiFunction(
+      uiRuntime, "_notifyAboutProgress", progressLayoutAnimation);
+  jsi_utils::installJsiFunction(
+      uiRuntime, "_notifyAboutEnd", endLayoutAnimation);
+
+  jsi_utils::installJsiFunction(uiRuntime, "_setGestureState", setGestureState);
+  jsi_utils::installJsiFunction(
+      uiRuntime, "_maybeFlushUIUpdatesQueue", maybeFlushUIUpdatesQueue);
+
+  jsi_utils::installJsiFunction(
+      uiRuntime, "_obtainPropFabric", obtainPropFunction);
+}
+
+} // namespace reanimated

package/harmony/reanimated/src/main/cpp/Common/cpp/reanimated/RuntimeDecorators/UIRuntimeDecorator.h

@@ -0,0 +1,35 @@
+#pragma once
+
+#include <jsi/jsi.h>
+
+#include <reanimated/Tools/PlatformDepMethodsHolder.h>
+
+using namespace facebook;
+
+namespace reanimated {
+
+using RequestAnimationFrameFunction =
+    std::function<void(jsi::Runtime &, const jsi::Value &)>;
+
+class UIRuntimeDecorator {
+ public:
+  static void decorate(
+      jsi::Runtime &uiRuntime,
+#ifdef RCT_NEW_ARCH_ENABLED
+// nothing
+#else
+      const ScrollToFunction scrollTo,
+#endif
+      const ObtainPropFunction obtainPropFunction,
+      const UpdatePropsFunction updateProps,
+      const MeasureFunction measure,
+      const DispatchCommandFunction dispatchCommand,
+      const RequestAnimationFrameFunction requestAnimationFrame,
+      const GetAnimationTimestampFunction getAnimationTimestamp,
+      const SetGestureStateFunction setGestureState,
+      const ProgressLayoutAnimationFunction progressLayoutAnimation,
+      const EndLayoutAnimationFunction endLayoutAnimation,
+      const MaybeFlushUIUpdatesQueueFunction maybeFlushUIUpdatesQueue);
+};
+
+} // namespace reanimated

package/harmony/reanimated/src/main/cpp/Common/cpp/reanimated/Tools/CollectionUtils.h

@@ -0,0 +1,14 @@
+#pragma once
+
+#include <algorithm>
+
+namespace reanimated {
+namespace collection {
+
+template <class CollectionType, class ValueType>
+inline bool contains(const CollectionType &collection, const ValueType &value) {
+  return collection.find(value) != collection.end();
+}
+
+} // namespace collection
+} // namespace reanimated

package/harmony/reanimated/src/main/cpp/Common/cpp/reanimated/Tools/FeaturesConfig.cpp

@@ -0,0 +1,5 @@
+#include <reanimated/Tools/FeaturesConfig.h>
+
+namespace reanimated {
+bool FeaturesConfig::_isLayoutAnimationEnabled = false;
+}

package/harmony/reanimated/src/main/cpp/Common/cpp/reanimated/Tools/FeaturesConfig.h

@@ -0,0 +1,19 @@
+#pragma once
+#include <string>
+
+namespace reanimated {
+
+class FeaturesConfig {
+ public:
+  static inline bool isLayoutAnimationEnabled() {
+    return _isLayoutAnimationEnabled;
+  }
+  static inline void setLayoutAnimationEnabled(bool isLayoutAnimationEnabled) {
+    _isLayoutAnimationEnabled = isLayoutAnimationEnabled;
+  }
+
+ private:
+  static bool _isLayoutAnimationEnabled;
+};
+
+} // namespace reanimated

package/harmony/reanimated/src/main/cpp/Common/cpp/reanimated/Tools/PlatformDepMethodsHolder.h

@@ -0,0 +1,98 @@
+#pragma once
+
+#include <jsi/jsi.h>
+
+#ifdef RCT_NEW_ARCH_ENABLED
+#include <react/renderer/core/ReactPrimitives.h>
+#endif
+
+#include <string>
+#include <utility>
+#include <vector>
+
+using namespace facebook;
+
+#ifdef RCT_NEW_ARCH_ENABLED
+using namespace react;
+#endif
+
+namespace reanimated {
+
+#ifdef RCT_NEW_ARCH_ENABLED
+
+using UpdatePropsFunction =
+    std::function<void(jsi::Runtime &rt, const jsi::Value &operations)>;
+using ObtainPropFunction = std::function<jsi::Value(
+    jsi::Runtime &rt,
+    const jsi::Value &shadowNodeWrapper,
+    const jsi::Value &propName)>;
+using DispatchCommandFunction = std::function<void(
+    jsi::Runtime &rt,
+    const jsi::Value &shadowNodeValue,
+    const jsi::Value &commandNameValue,
+    const jsi::Value &argsValue)>;
+using MeasureFunction = std::function<
+    jsi::Value(jsi::Runtime &rt, const jsi::Value &shadowNodeValue)>;
+
+#else
+
+using UpdatePropsFunction =
+    std::function<void(jsi::Runtime &rt, const jsi::Value &operations)>;
+using ScrollToFunction = std::function<void(int, double, double, bool)>;
+using DispatchCommandFunction = std::function<void(
+    jsi::Runtime &rt,
+    const int viewTag,
+    const jsi::Value &commandNameValue,
+    const jsi::Value &argsValue)>;
+using MeasureFunction =
+    std::function<std::vector<std::pair<std::string, double>>(int)>;
+using ObtainPropFunction =
+    std::function<jsi::Value(jsi::Runtime &, const int, const jsi::Value &)>;
+
+#endif // RCT_NEW_ARCH_ENABLED
+
+using RequestRenderFunction =
+    std::function<void(std::function<void(const double)>)>;
+using GetAnimationTimestampFunction = std::function<double(void)>;
+
+using ProgressLayoutAnimationFunction =
+    std::function<void(jsi::Runtime &, int, jsi::Object, bool)>;
+using EndLayoutAnimationFunction = std::function<void(int, bool)>;
+
+using RegisterSensorFunction =
+    std::function<int(int, int, int, std::function<void(double[], int)>)>;
+using UnregisterSensorFunction = std::function<void(int)>;
+using SetGestureStateFunction = std::function<void(int, int)>;
+using ConfigurePropsFunction = std::function<void(
+    jsi::Runtime &rt,
+    const jsi::Value &uiProps,
+    const jsi::Value &nativeProps)>;
+using KeyboardEventSubscribeFunction =
+    std::function<int(std::function<void(int, int)>, bool, bool)>;
+using KeyboardEventUnsubscribeFunction = std::function<void(int)>;
+using MaybeFlushUIUpdatesQueueFunction = std::function<void()>;
+
+struct PlatformDepMethodsHolder {
+  RequestRenderFunction requestRender;
+#ifdef RCT_NEW_ARCH_ENABLED
+  // nothing
+#else
+  UpdatePropsFunction updatePropsFunction;
+  ScrollToFunction scrollToFunction;
+  DispatchCommandFunction dispatchCommandFunction;
+  MeasureFunction measureFunction;
+  ConfigurePropsFunction configurePropsFunction;
+  ObtainPropFunction obtainPropFunction;
+#endif
+  GetAnimationTimestampFunction getAnimationTimestamp;
+  ProgressLayoutAnimationFunction progressLayoutAnimation;
+  EndLayoutAnimationFunction endLayoutAnimation;
+  RegisterSensorFunction registerSensor;
+  UnregisterSensorFunction unregisterSensor;
+  SetGestureStateFunction setGestureStateFunction;
+  KeyboardEventSubscribeFunction subscribeForKeyboardEvents;
+  KeyboardEventUnsubscribeFunction unsubscribeFromKeyboardEvents;
+  MaybeFlushUIUpdatesQueueFunction maybeFlushUIUpdatesQueueFunction;
+};
+
+} // namespace reanimated

package/harmony/reanimated/src/main/cpp/Common/cpp/reanimated/Tools/ReanimatedSystraceSection.h

@@ -0,0 +1,135 @@
+#pragma once
+#include <string>
+#include <vector>
+
+#ifdef REANIMATED_PROFILING
+
+#if defined(__APPLE__)
+#include <os/trace_base.h>
+
+#if OS_LOG_TARGET_HAS_10_15_FEATURES
+#include <os/log.h>
+#include <os/signpost.h>
+#include <sstream>
+#endif // OS_LOG_TARGET_HAS_10_15_FEATURES
+
+#elif defined(ANDROID)
+
+#include <android/trace.h>
+
+#endif // defined(ANDROID)
+
+#endif // REANIMATED_PROFILING
+
+namespace reanimated {
+
+#if defined(ANDROID) && defined(REANIMATED_PROFILING)
+
+struct ReanimatedSystraceSection {
+ public:
+  template <typename... ConvertsToStringPiece>
+  explicit ReanimatedSystraceSection(
+      const char *name,
+      ConvertsToStringPiece &&...args) {
+    ATrace_beginSection(name);
+  }
+
+  ~ReanimatedSystraceSection() {
+    ATrace_endSection();
+  }
+};
+
+// The apple part is copied from React Native
+// from
+// https://github.com/facebook/react-native/blob/5697d923a05119314b4cfcd556cb243986637764/packages/react-native/ReactCommon/cxxreact/SystraceSection.h
+#elif defined(__APPLE__) && OS_LOG_TARGET_HAS_10_15_FEATURES && \
+    defined(REANIMATED_PROFILING)
+
+template <typename T, typename = void>
+struct renderer {
+  static std::string render(const T &t) {
+    std::ostringstream oss;
+    oss << t;
+    return oss.str();
+  }
+};
+
+template <typename T>
+static auto render(const T &t)
+    -> decltype(renderer<T>::render(std::declval<const T &>())) {
+  return renderer<T>::render(t);
+}
+
+inline os_log_t instrumentsLogHandle = nullptr;
+
+static inline os_log_t getOrCreateInstrumentsLogHandle() {
+  if (!instrumentsLogHandle) {
+    instrumentsLogHandle = os_log_create(
+        "dev.reanimated.instruments", OS_LOG_CATEGORY_POINTS_OF_INTEREST);
+  }
+  return instrumentsLogHandle;
+}
+
+struct ReanimatedSystraceSection {
+ public:
+  template <typename... ConvertsToStringPiece>
+  explicit ReanimatedSystraceSection(
+      const char *name,
+      ConvertsToStringPiece &&...args) {
+    os_log_t instrumentsLogHandle =
+        reanimated::getOrCreateInstrumentsLogHandle();
+
+    // If the log isn't enabled, we don't want the performance overhead of the
+    // rest of the code below.
+    if (!os_signpost_enabled(instrumentsLogHandle)) {
+      return;
+    }
+
+    name_ = name;
+
+    const auto argsVector =
+        std::vector<std::string>{reanimated::render(args)...};
+    std::string argsString = "";
+    for (size_t i = 0; i < argsVector.size(); i += 2) {
+      argsString += argsVector[i] + "=" + argsVector[i + 1] + ";";
+    }
+
+    signpostID_ = os_signpost_id_make_with_pointer(instrumentsLogHandle, this);
+
+    os_signpost_interval_begin(
+        instrumentsLogHandle,
+        signpostID_,
+        "Reanimated",
+        "%s begin: %s",
+        name,
+        argsString.c_str());
+  }
+
+  ~ReanimatedSystraceSection() {
+    os_signpost_interval_end(
+        reanimated::instrumentsLogHandle,
+        signpostID_,
+        "Reanimated",
+        "%s end",
+        name_.data());
+  }
+
+ private:
+  os_signpost_id_t signpostID_ = OS_SIGNPOST_ID_INVALID;
+  std::string_view name_;
+};
+
+#else
+
+struct ReanimatedSystraceSection {
+ public:
+  template <typename... ConvertsToStringPiece>
+  explicit ReanimatedSystraceSection(
+      const char *name,
+      ConvertsToStringPiece &&...args) {}
+};
+
+#endif // defined(__APPLE__) && OS_LOG_TARGET_HAS_10_15_FEATURES &&
+       // defined(REANIMATED_PROFILING)
+
+} // namespace reanimated

package/harmony/reanimated/src/main/cpp/Common/cpp/worklets/NativeModules/WorkletsModuleProxy.cpp

@@ -0,0 +1,47 @@
+#include <string>
+
+#ifdef RCT_NEW_ARCH_ENABLED
+#include <react/renderer/uimanager/UIManagerBinding.h>
+#include <react/renderer/uimanager/primitives.h>
+#endif // RCT_NEW_ARCH_ENABLED
+
+#include <worklets/NativeModules/WorkletsModuleProxy.h>
+#include <worklets/SharedItems/Shareables.h>
+#include <worklets/Tools/Defs.h>
+
+#ifdef __ANDROID__
+#include <fbjni/fbjni.h>
+#endif // __ANDROID__
+
+#include <jsi/jsi.h>
+
+using namespace facebook;
+
+namespace worklets {
+
+WorkletsModuleProxy::WorkletsModuleProxy(
+    const std::string &valueUnpackerCode,
+    const std::shared_ptr<MessageQueueThread> &jsQueue,
+    const std::shared_ptr<CallInvoker> &jsCallInvoker,
+    const std::shared_ptr<JSScheduler> &jsScheduler,
+    const std::shared_ptr<UIScheduler> &uiScheduler)
+    : WorkletsModuleProxySpec(jsCallInvoker),
+      valueUnpackerCode_(valueUnpackerCode),
+      jsQueue_(jsQueue),
+      jsScheduler_(jsScheduler),
+      uiScheduler_(uiScheduler) {}
+
+WorkletsModuleProxy::~WorkletsModuleProxy() {}
+
+jsi::Value WorkletsModuleProxy::makeShareableClone(
+    jsi::Runtime &rt,
+    const jsi::Value &value,
+    const jsi::Value &shouldRetainRemote,
+    const jsi::Value &nativeStateSource) {
+  // TODO: It might be a good idea to rename one of these methods to avoid
+  // confusion.
+  return worklets::makeShareableClone(
+      rt, value, shouldRetainRemote, nativeStateSource);
+}
+
+} // namespace worklets

package/harmony/reanimated/src/main/cpp/Common/cpp/worklets/NativeModules/WorkletsModuleProxy.h

@@ -0,0 +1,59 @@
+#pragma once
+
+#include <cxxreact/MessageQueueThread.h>
+#include <worklets/NativeModules/WorkletsModuleProxySpec.h>
+#include <worklets/Tools/JSScheduler.h>
+#include <worklets/Tools/SingleInstanceChecker.h>
+#include <worklets/Tools/UIScheduler.h>
+#include <worklets/WorkletRuntime/WorkletRuntime.h>
+#include <memory>
+#include <string>
+
+namespace worklets {
+
+class WorkletsModuleProxy
+    : public WorkletsModuleProxySpec,
+      public std::enable_shared_from_this<WorkletsModuleProxy> {
+ public:
+  explicit WorkletsModuleProxy(
+      const std::string &valueUnpackerCode,
+      const std::shared_ptr<MessageQueueThread> &jsQueue,
+      const std::shared_ptr<CallInvoker> &jsCallInvoker,
+      const std::shared_ptr<JSScheduler> &jsScheduler,
+      const std::shared_ptr<UIScheduler> &uiScheduler);
+
+  ~WorkletsModuleProxy();
+
+  jsi::Value makeShareableClone(
+      jsi::Runtime &rt,
+      const jsi::Value &value,
+      const jsi::Value &shouldRetainRemote,
+      const jsi::Value &nativeStateSource) override;
+
+  [[nodiscard]] inline std::string getValueUnpackerCode() const {
+    return valueUnpackerCode_;
+  }
+
+  [[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_;
+  }
+
+ private:
+  const std::string valueUnpackerCode_;
+  const std::shared_ptr<MessageQueueThread> jsQueue_;
+  const std::shared_ptr<JSScheduler> jsScheduler_;
+  const std::shared_ptr<UIScheduler> uiScheduler_;
+#ifndef NDEBUG
+  SingleInstanceChecker<WorkletsModuleProxy> singleInstanceChecker_;
+#endif // NDEBUG
+};
+
+} // namespace worklets

package/harmony/reanimated/src/main/cpp/Common/cpp/worklets/NativeModules/WorkletsModuleProxySpec.cpp

@@ -0,0 +1,27 @@
+#include <worklets/NativeModules/WorkletsModuleProxySpec.h>
+
+#include <utility>
+
+#define WORKLETS_SPEC_PREFIX(FN_NAME) \
+  __hostFunction_WorkletsModuleProxySpec_##FN_NAME
+
+namespace worklets {
+
+static jsi::Value WORKLETS_SPEC_PREFIX(makeShareableClone)(
+    jsi::Runtime &rt,
+    TurboModule &turboModule,
+    const jsi::Value *args,
+    size_t) {
+  return static_cast<WorkletsModuleProxySpec *>(&turboModule)
+      ->makeShareableClone(
+          rt, std::move(args[0]), std::move(args[1]), std::move(args[2]));
+}
+
+WorkletsModuleProxySpec::WorkletsModuleProxySpec(
+    const std::shared_ptr<CallInvoker> jsInvoker)
+    : TurboModule("NativeWorklets", jsInvoker) {
+  methodMap_["makeShareableClone"] =
+      MethodMetadata{2, WORKLETS_SPEC_PREFIX(makeShareableClone)};
+}
+
+} // namespace worklets

package/harmony/reanimated/src/main/cpp/Common/cpp/worklets/NativeModules/WorkletsModuleProxySpec.h

@@ -0,0 +1,25 @@
+#pragma once
+
+#include <ReactCommon/CallInvoker.h>
+#include <ReactCommon/TurboModule.h>
+#include <memory>
+
+using namespace facebook;
+using namespace react;
+
+namespace worklets {
+
+class JSI_EXPORT WorkletsModuleProxySpec : public TurboModule {
+ protected:
+  explicit WorkletsModuleProxySpec(
+      const std::shared_ptr<CallInvoker> jsInvoker);
+
+ public:
+  virtual jsi::Value makeShareableClone(
+      jsi::Runtime &rt,
+      const jsi::Value &value,
+      const jsi::Value &shouldRetainRemote,
+      const jsi::Value &nativeStateSource) = 0;
+};
+
+} // namespace worklets

package/harmony/reanimated/src/main/cpp/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/harmony/reanimated/src/main/cpp/Common/cpp/worklets/Registries/EventHandlerRegistry.h

@@ -0,0 +1,49 @@
+#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