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

package/harmony/reanimated/src/main/cpp/Common/cpp/worklets/WorkletRuntime/WorkletRuntime.h

@@ -0,0 +1,90 @@
+#pragma once
+
+#include <cxxreact/MessageQueueThread.h>
+#include <jsi/jsi.h>
+
+#include <worklets/SharedItems/Shareables.h>
+#include <worklets/Tools/AsyncQueue.h>
+#include <worklets/Tools/JSScheduler.h>
+
+#include <memory>
+#include <string>
+#include <utility>
+#include <vector>
+
+using namespace facebook;
+using namespace react;
+
+namespace worklets {
+
+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 bool supportsLocking,
+      const std::string &valueUnpackerCode);
+
+  jsi::Runtime &getJSIRuntime() const {
+    return *runtime_;
+  }
+
+  template <typename... Args>
+  inline jsi::Value runGuarded(
+      const std::shared_ptr<ShareableWorklet> &shareableWorklet,
+      Args &&...args) const {
+    jsi::Runtime &rt = *runtime_;
+    return runOnRuntimeGuarded(
+        rt, shareableWorklet->toJSValue(rt), std::forward<Args>(args)...);
+  }
+
+  void runAsyncGuarded(
+      const std::shared_ptr<ShareableWorklet> &shareableWorklet) {
+    if (queue_ == nullptr) {
+      queue_ = std::make_shared<AsyncQueue>(name_);
+    }
+    queue_->push([=, weakThis = weak_from_this()] {
+      auto strongThis = weakThis.lock();
+      if (!strongThis) {
+        return;
+      }
+
+      strongThis->runGuarded(shareableWorklet);
+    });
+  }
+
+  jsi::Value executeSync(jsi::Runtime &rt, const jsi::Value &worklet) const;
+
+  std::string toString() const {
+    return "[WorkletRuntime \"" + name_ + "\"]";
+  }
+
+  jsi::Value get(jsi::Runtime &rt, const jsi::PropNameID &propName) override;
+
+  std::vector<jsi::PropNameID> getPropertyNames(jsi::Runtime &rt) override;
+
+ private:
+  const std::shared_ptr<std::recursive_mutex> runtimeMutex_;
+  const std::shared_ptr<jsi::Runtime> runtime_;
+#ifndef NDEBUG
+  const bool supportsLocking_;
+#endif
+  const std::string name_;
+  std::shared_ptr<AsyncQueue> queue_;
+};
+
+// This function needs to be non-inline to avoid problems with dynamic_cast on
+// Android
+std::shared_ptr<WorkletRuntime> extractWorkletRuntime(
+    jsi::Runtime &rt,
+    const jsi::Value &value);
+
+void scheduleOnRuntime(
+    jsi::Runtime &rt,
+    const jsi::Value &workletRuntimeValue,
+    const jsi::Value &shareableWorkletValue);
+
+} // namespace worklets

package/harmony/reanimated/src/main/cpp/Common/cpp/worklets/WorkletRuntime/WorkletRuntimeCollector.h

@@ -0,0 +1,36 @@
+#pragma once
+
+#include <worklets/Registries/WorkletRuntimeRegistry.h>
+
+#include <jsi/jsi.h>
+
+#include <memory>
+
+namespace worklets {
+
+class WorkletRuntimeCollector : public jsi::HostObject {
+  // When worklet runtime is created, we inject an instance of this class as a
+  // `jsi::HostObject` into the global object. When worklet runtime is
+  // terminated, the object is garbage-collected, which runs the C++ destructor.
+  // In the destructor, we unregister the worklet runtime from the registry.
+
+ public:
+  explicit WorkletRuntimeCollector(jsi::Runtime &runtime) : runtime_(runtime) {
+    WorkletRuntimeRegistry::registerRuntime(runtime_);
+  }
+
+  ~WorkletRuntimeCollector() {
+    WorkletRuntimeRegistry::unregisterRuntime(runtime_);
+  }
+
+  static void install(jsi::Runtime &rt) {
+    auto collector = std::make_shared<WorkletRuntimeCollector>(rt);
+    auto object = jsi::Object::createFromHostObject(rt, collector);
+    rt.global().setProperty(rt, "__workletRuntimeCollector", object);
+  }
+
+ private:
+  jsi::Runtime &runtime_;
+};
+
+} // namespace worklets

package/harmony/reanimated/src/main/cpp/Common/cpp/worklets/WorkletRuntime/WorkletRuntimeDecorator.cpp

@@ -0,0 +1,182 @@
+#include <worklets/SharedItems/Shareables.h>
+#include <worklets/Tools/JSISerializer.h>
+#include <worklets/Tools/PlatformLogger.h>
+#include <worklets/Tools/ReanimatedJSIUtils.h>
+#include <worklets/WorkletRuntime/WorkletRuntime.h>
+#include <worklets/WorkletRuntime/WorkletRuntimeDecorator.h>
+
+#include <vector>
+
+namespace worklets {
+
+static inline double performanceNow() {
+  // copied from JSExecutor.cpp
+  auto time = std::chrono::steady_clock::now();
+  auto duration = std::chrono::duration_cast<std::chrono::nanoseconds>(
+                      time.time_since_epoch())
+                      .count();
+
+  constexpr double NANOSECONDS_IN_MILLISECOND = 1000000.0;
+  return duration / NANOSECONDS_IN_MILLISECOND;
+}
+
+static inline std::vector<jsi::Value> parseArgs(
+    jsi::Runtime &rt,
+    std::shared_ptr<ShareableArray> shareableArgs) {
+  if (shareableArgs == nullptr) {
+    return {};
+  }
+
+  auto argsArray = shareableArgs->toJSValue(rt).asObject(rt).asArray(rt);
+  auto argsSize = argsArray.size(rt);
+  std::vector<jsi::Value> result(argsSize);
+  for (size_t i = 0; i < argsSize; i++) {
+    result[i] = argsArray.getValueAtIndex(rt, i);
+  }
+  return result;
+}
+
+void WorkletRuntimeDecorator::decorate(
+    jsi::Runtime &rt,
+    const std::string &name,
+    const std::shared_ptr<JSScheduler> &jsScheduler) {
+  // resolves "ReferenceError: Property 'global' doesn't exist at ..."
+  rt.global().setProperty(rt, "global", rt.global());
+
+  rt.global().setProperty(rt, "_WORKLET", true);
+
+  rt.global().setProperty(rt, "_LABEL", jsi::String::createFromAscii(rt, name));
+
+#ifdef RCT_NEW_ARCH_ENABLED
+  constexpr auto isFabric = true;
+#else
+  constexpr auto isFabric = false;
+#endif // RCT_NEW_ARCH_ENABLED
+  rt.global().setProperty(rt, "_IS_FABRIC", isFabric);
+
+#ifndef NDEBUG
+  auto evalWithSourceUrl = [](jsi::Runtime &rt,
+                              const jsi::Value &thisValue,
+                              const jsi::Value *args,
+                              size_t count) -> jsi::Value {
+    auto code = std::make_shared<const jsi::StringBuffer>(
+        args[0].asString(rt).utf8(rt));
+    std::string url;
+    if (count > 1 && args[1].isString()) {
+      url = args[1].asString(rt).utf8(rt);
+    }
+    return rt.evaluateJavaScript(code, url);
+  };
+  rt.global().setProperty(
+      rt,
+      "evalWithSourceUrl",
+      jsi::Function::createFromHostFunction(
+          rt,
+          jsi::PropNameID::forAscii(rt, "evalWithSourceUrl"),
+          1,
+          evalWithSourceUrl));
+#endif // NDEBUG
+
+  jsi_utils::installJsiFunction(
+      rt, "_log", [](jsi::Runtime &rt, const jsi::Value &value) {
+        PlatformLogger::log(stringifyJSIValue(rt, value));
+      });
+
+  jsi_utils::installJsiFunction(
+      rt, "_toString", [](jsi::Runtime &rt, const jsi::Value &value) {
+        return jsi::String::createFromUtf8(rt, stringifyJSIValue(rt, value));
+      });
+
+  jsi_utils::installJsiFunction(
+      rt,
+      "_makeShareableClone",
+      [](jsi::Runtime &rt,
+         const jsi::Value &value,
+         const jsi::Value &nativeStateSource) {
+        auto shouldRetainRemote = jsi::Value::undefined();
+        return makeShareableClone(
+            rt, value, shouldRetainRemote, nativeStateSource);
+      });
+
+  jsi_utils::installJsiFunction(
+      rt,
+      "_scheduleRemoteFunctionOnJS",
+      [jsScheduler](
+          jsi::Runtime &rt,
+          const jsi::Value &funValue,
+          const jsi::Value &argsValue) {
+        auto shareableRemoteFun = extractShareableOrThrow<
+            ShareableRemoteFunction>(
+            rt,
+            funValue,
+            "[Reanimated] Incompatible object passed to scheduleOnJS. It is only allowed to schedule worklets or functions defined on the React Native JS runtime this way.");
+
+        auto shareableArgs = argsValue.isUndefined()
+            ? nullptr
+            : extractShareableOrThrow<ShareableArray>(
+                  rt, argsValue, "[Reanimated] Args must be an array.");
+
+        jsScheduler->scheduleOnJS([=](jsi::Runtime &rt) {
+          auto fun =
+              shareableRemoteFun->toJSValue(rt).asObject(rt).asFunction(rt);
+          if (shareableArgs == nullptr) {
+            // fast path for remote function w/o arguments
+            fun.call(rt);
+          } else {
+            auto args = parseArgs(rt, shareableArgs);
+            fun.call(
+                rt, const_cast<const jsi::Value *>(args.data()), args.size());
+          }
+        });
+      });
+
+  jsi_utils::installJsiFunction(
+      rt,
+      "_scheduleHostFunctionOnJS",
+      [jsScheduler](
+          jsi::Runtime &rt,
+          const jsi::Value &hostFunValue,
+          const jsi::Value &argsValue) {
+        auto hostFun =
+            hostFunValue.asObject(rt).asFunction(rt).getHostFunction(rt);
+
+        auto shareableArgs = argsValue.isUndefined()
+            ? nullptr
+            : extractShareableOrThrow<ShareableArray>(
+                  rt, argsValue, "[Reanimated] Args must be an array.");
+
+        jsScheduler->scheduleOnJS([=](jsi::Runtime &rt) {
+          auto args = parseArgs(rt, shareableArgs);
+          hostFun(
+              rt,
+              jsi::Value::undefined(),
+              const_cast<const jsi::Value *>(args.data()),
+              args.size());
+        });
+      });
+
+  jsi_utils::installJsiFunction(
+      rt,
+      "_scheduleOnRuntime",
+      [](jsi::Runtime &rt,
+         const jsi::Value &workletRuntimeValue,
+         const jsi::Value &shareableWorkletValue) {
+        scheduleOnRuntime(rt, workletRuntimeValue, shareableWorkletValue);
+      });
+
+  jsi::Object performance(rt);
+  performance.setProperty(
+      rt,
+      "now",
+      jsi::Function::createFromHostFunction(
+          rt,
+          jsi::PropNameID::forAscii(rt, "now"),
+          0,
+          [](jsi::Runtime &runtime,
+             const jsi::Value &,
+             const jsi::Value *args,
+             size_t count) { return jsi::Value(performanceNow()); }));
+  rt.global().setProperty(rt, "performance", performance);
+}
+
+} // namespace worklets

package/harmony/reanimated/src/main/cpp/Common/cpp/worklets/WorkletRuntime/WorkletRuntimeDecorator.h

@@ -0,0 +1,22 @@
+#pragma once
+
+#include <worklets/Tools/JSScheduler.h>
+
+#include <jsi/jsi.h>
+
+#include <memory>
+#include <string>
+
+using namespace facebook;
+
+namespace worklets {
+
+class WorkletRuntimeDecorator {
+ public:
+  static void decorate(
+      jsi::Runtime &rt,
+      const std::string &name,
+      const std::shared_ptr<JSScheduler> &jsScheduler);
+};
+
+} // namespace worklets

package/harmony/reanimated/src/main/cpp/ReanimatedLogger.cpp

@@ -0,0 +1,33 @@
+// Copyright (c) 2025 Huawei Device Co., Ltd. All rights reserved
+// Use of this source code is governed by a MIT license that can be
+// found in the LICENSE file.
+
+#include <PlatformLogger.h>
+#include "glog/logging.h"
+
+namespace worklets {
+void PlatformLogger::log(const char *str)
+{
+    LOG(INFO) << str;
+}
+
+void PlatformLogger::log(const std::string &str)
+{
+    log(str.c_str());
+}
+
+void PlatformLogger::log(const double d)
+{
+    LOG(INFO) << d;
+}
+
+void PlatformLogger::log(const int i)
+{
+    LOG(INFO) << i;
+}
+
+void PlatformLogger::log(const bool b)
+{
+    LOG(INFO) << b;
+}
+} // namespace worklets

package/harmony/reanimated/src/main/cpp/ReanimatedModule.cpp

@@ -0,0 +1,222 @@
+// Copyright (c) 2025 Huawei Device Co., Ltd. All rights reserved
+// Use of this source code is governed by a MIT license that can be
+// found in the LICENSE file.
+
+#include "RNOH/ArkTSTurboModule.h"
+#include "RNOH/RNInstance.h"
+#include "ReanimatedModule.h"
+#include "ReanimatedUIScheduler.h"
+#include "PlatformDepMethodsHolder.h"
+#include "WorkletRuntimeCollector.h"
+#include "RNRuntimeDecorator.h"
+#include "TransformParser.h"
+#include "RNOH/RNInstanceCAPI.h"
+#include "WorkletsModule.h"
+
+using namespace facebook;
+using namespace reanimated;
+using namespace worklets;
+namespace rnoh {
+static double getMillisSinceEpoch()
+{
+    auto now = std::chrono::high_resolution_clock::now();
+    auto frameTime = std::chrono::duration_cast<std::chrono::milliseconds>(now.time_since_epoch());
+    return frameTime.count();
+}
+
+jsi::Value installTurboModule(facebook::jsi::Runtime &rt, react::TurboModule &turboModule,
+    const facebook::jsi::Value *args, size_t count)
+{
+    auto self = static_cast<ReanimatedModule *>(&turboModule);
+    self->installTurboModule(rt);
+    return facebook::jsi::Value(true);
+}
+
+ReanimatedModule::ReanimatedModule(const ArkTSTurboModule::Context ctx, const std::string name)
+    : ArkTSTurboModule(ctx, name)
+{
+    methodMap_ = { { "installTurboModule", { 0, rnoh::installTurboModule } } };
+}
+
+ReanimatedModule::~ReanimatedModule()
+{
+    LOG(INFO) << "ReanimatedModule::~ReanimatedModule";
+    if (eventListener) {
+        m_ctx.scheduler->removeEventListener(eventListener);
+    }
+    if (keyboardEventDataUpdater_) {
+        keyboardEventDataUpdater_ = nullptr;
+    }
+}
+
+void ReanimatedModule::installTurboModule(facebook::jsi::Runtime &rt)
+{
+    auto nodesManager = std::make_shared<ReanimatedNodesManager>(
+        [weakExecutor = std::weak_ptr(m_ctx.taskExecutor)](TaskExecutor::Task &&task) {
+            if (auto taskExecutor = weakExecutor.lock()) {
+                taskExecutor->runTask(TaskThread::MAIN, std::move(task));
+            }
+        });
+
+    auto maybeFlushUIUpdatesQueueFunction = [nodesManager]() { nodesManager->maybeFlushUIUpdatesQueue(); };
+    auto requestRender = [weakSelf = weak_from_this(), nodesManager](std::function<void(double)> onRender) {
+        auto self = weakSelf.lock();
+        if (!self) {
+            return;
+        }
+
+        nodesManager->postOnAnimation(
+            [weakReanimatedModule = self->weakNativeReanimatedModule_, onRender = std::move(onRender)](auto frameTime) {
+                if (auto reanimatedModule = weakReanimatedModule.lock()) {
+                    onRender(frameTime);
+                }
+            });
+    };
+
+    auto progressLayoutAnimation = [=](jsi::Runtime &rt, int tag, const jsi::Object &newStyle,
+        bool isSharedTransition) {
+        // noop
+    };
+
+    auto endLayoutAnimation = [=](int tag, bool removeView) {
+        // noop
+    };
+
+    auto getAnimationTimestamp = getMillisSinceEpoch;
+
+    auto registerSensorFunction = [](int sensorType, int interval, int iosReferenceFrame,
+        std::function<void(double[], int)> setter) -> int {
+        // TODO
+        return -1;
+    };
+    auto unregisterSensorFunction = [](int sensorId) {
+        // TODO
+    };
+    auto subscribeForKeyboardEventsFunction =
+        [weakSelf = weak_from_this()](std::function<void(int keyboardState, int height)> keyboardEventDataUpdater,
+        bool isStatusBarTranslucent, bool isNavigationBarTranslucent) {
+            auto self = weakSelf.lock();
+            if (!self) {
+                return 0;
+            }
+            self->keyboardEventDataUpdater_ = std::move(keyboardEventDataUpdater);
+            auto weakExecutor = std::weak_ptr(self->m_ctx.taskExecutor);
+            if (auto taskExecutor = weakExecutor.lock()) {
+                taskExecutor->runTask(TaskThread::MAIN, [ctx = self->m_ctx, isStatusBarTranslucent]() {
+                    ArkJS arkJs(ctx.env);
+                    // arkJs.createBoolean(isStatusBarTranslucent);
+                    auto napiTurboModuleObject = arkJs.getObject(ctx.arkTSTurboModuleInstanceRef);
+                    napiTurboModuleObject.call("subscribeKeyBordListeners", {});
+                });
+            }
+            return 0;
+        };
+    auto unsubscribeFromKeyboardEventsFunction = [weakSelf = weak_from_this()](int listenerId) {
+        auto self = weakSelf.lock();
+        if (!self) {
+            return 0;
+        }
+        auto weakExecutor = std::weak_ptr(self->m_ctx.taskExecutor);
+        if (auto taskExecutor = weakExecutor.lock()) {
+            taskExecutor->runTask(TaskThread::MAIN, [ctx = self->m_ctx]() {
+                ArkJS arkJs(ctx.env);
+                auto napiTurboModuleObject = arkJs.getObject(ctx.arkTSTurboModuleInstanceRef);
+                napiTurboModuleObject.call("unsubscribeKeyBordListeners", {});
+            });
+        }
+        return 0;
+    };
+    auto setGestureStateFunction = [weakSelf = weak_from_this()](int handlerTag, int newState) {
+        auto self = weakSelf.lock();
+        if (!self) {
+            return;
+        }
+        ArkJS arkJs(self->m_ctx.env);
+        auto napiTag = arkJs.createInt(handlerTag);
+        auto napiState = arkJs.createInt(newState);
+        auto napiTurboModuleObject = arkJs.getObject(self->m_ctx.arkTSTurboModuleInstanceRef);
+        napiTurboModuleObject.call("setGestureHandlerState", { napiTag, napiState });
+    };
+    PlatformDepMethodsHolder platformDepMethodsHolder = {
+        requestRender,
+        getAnimationTimestamp,
+        progressLayoutAnimation,
+        endLayoutAnimation,
+        registerSensorFunction,
+        unregisterSensorFunction,
+        setGestureStateFunction,
+        subscribeForKeyboardEventsFunction,
+        unsubscribeFromKeyboardEventsFunction,
+        maybeFlushUIUpdatesQueueFunction,
+    };
+    auto isReducedMotion = false;
+    auto isBridgeless = true;
+    auto workletsModule = [weakSelf = weak_from_this()]() -> std::shared_ptr<WorkletsModule> {
+        auto self = weakSelf.lock();
+        if (!self) {
+            return nullptr;
+        }
+        auto instance = self->m_ctx.instance.lock();
+        if (instance == nullptr) {
+            return nullptr;
+        }
+        return instance->getTurboModule<WorkletsModule>("WorkletsModule");
+    };
+    auto nativeReanimatedModule = std::make_shared<ReanimatedModuleProxy>(workletsModule()->getWorkletsModuleProxy(),
+        rt, jsInvoker_, platformDepMethodsHolder, isBridgeless, isReducedMotion);
+    weakNativeReanimatedModule_ = nativeReanimatedModule;
+    nativeReanimatedModule->init(platformDepMethodsHolder);
+    ReanimatedPerformOperations reanimatedPerformOperations = [weakNativeReanimatedModule =
+                                                                   weakNativeReanimatedModule_]() {
+        if (auto nativeReanimatedModule = weakNativeReanimatedModule.lock()) {
+            nativeReanimatedModule->performOperations();
+        }
+    };
+    nodesManager->registerPerformOperations(reanimatedPerformOperations);
+
+    WorkletRuntimeCollector::install(rt);
+
+    RNRuntimeDecorator::decorate(rt, nativeReanimatedModule);
+    injectDependencies(rt);
+
+    eventListener =
+        std::make_shared<facebook::react::EventListener>([weakNativeReanimatedModule = weakNativeReanimatedModule_,
+        weakTaskExecutor = std::weak_ptr{ m_ctx.taskExecutor }](facebook::react::RawEvent const & rawEvent) {
+            auto taskExecutor = weakTaskExecutor.lock();
+            auto nativeReanimatedModule = weakNativeReanimatedModule.lock();
+            if (!nativeReanimatedModule || !taskExecutor || !taskExecutor->isOnTaskThread(TaskThread::MAIN)) {
+                return false;
+            }
+
+            auto eventType = rawEvent.type;
+            auto frameTime = getMillisSinceEpoch();
+
+            // React Native prefixes event names with "top". If the event name starts with "on", the result is that the
+            // event on the native side is prefixed with "topOn", while the JS side expects the event name to be without
+            // the "on" prefix.
+            if (eventType.rfind("topOn", 0) == 0) {
+                auto eventCopy = rawEvent;
+                eventCopy.type = "on" + eventType.substr(5);
+                return nativeReanimatedModule->handleRawEvent(eventCopy, frameTime);
+            } else if (eventType.rfind("topLayout", 0) == 0) { // 针对onLayout事件，不阻断，采用系统处理
+                return false;
+            }
+            return nativeReanimatedModule->handleRawEvent(rawEvent, frameTime);
+        });
+    m_ctx.scheduler->addEventListener(eventListener);
+}
+void ReanimatedModule::injectDependencies(facebook::jsi::Runtime & /* rt */)
+{
+    const auto uiManager = m_ctx.scheduler->getUIManager();
+    if (auto nativeReanimatedModule = weakNativeReanimatedModule_.lock()) {
+        nativeReanimatedModule->initializeFabric(uiManager);
+    }
+}
+
+void ReanimatedModule::callKeyBord(double height, int status)
+{
+    if (keyboardEventDataUpdater_) {
+        keyboardEventDataUpdater_(status, height);
+    }
+}
+} // namespace rnoh

package/harmony/reanimated/src/main/cpp/ReanimatedModule.h

@@ -0,0 +1,24 @@
+// Copyright (c) 2025 Huawei Device Co., Ltd. All rights reserved
+// Use of this source code is governed by a MIT license that can be
+// found in the LICENSE file.
+
+#pragma once
+
+#include "RNOH/ArkTSTurboModule.h"
+#include "ReanimatedModuleProxy.h"
+#include "ReanimatedNodesManager.h"
+
+namespace rnoh {
+class JSI_EXPORT ReanimatedModule : public std::enable_shared_from_this<ReanimatedModule>, public ArkTSTurboModule {
+public:
+    ReanimatedModule(const ArkTSTurboModule::Context ctx, const std::string name);
+    ~ReanimatedModule() override;
+    void installTurboModule(facebook::jsi::Runtime &rt);
+    void callKeyBord(double height, int status);
+private:
+    std::weak_ptr<reanimated::ReanimatedModuleProxy> weakNativeReanimatedModule_;
+    void injectDependencies(facebook::jsi::Runtime &rt);
+    std::shared_ptr<facebook::react::EventListener> eventListener;
+    std::function<void(int keyboardState, int height)> keyboardEventDataUpdater_;
+};
+} // namespace rnoh

package/harmony/reanimated/src/main/cpp/ReanimatedNodesManager.cpp

@@ -0,0 +1,56 @@
+// Copyright (c) 2025 Huawei Device Co., Ltd. All rights reserved
+// Use of this source code is governed by a MIT license that can be
+// found in the LICENSE file.
+
+#include "ReanimatedNodesManager.h"
+
+constexpr int64_t NANO_TO_MILLIS = 1000000;
+
+namespace rnoh {
+static void vsyncHandleCallback(long long timestamp, void *data)
+{
+    auto self = static_cast<ReanimatedNodesManager *>(data);
+    self->onAnimationFrame(timestamp);
+}
+ReanimatedNodesManager::ReanimatedNodesManager(std::function<void(TaskExecutor::Task &&)> runOnTheMainThread)
+    : m_vsyncHandle("ReanimatedNodesManager"), runOnTheMainThread(std::move(runOnTheMainThread))
+{}
+
+void ReanimatedNodesManager::maybeFlushUIUpdatesQueue()
+{
+    performOperations();
+};
+
+void ReanimatedNodesManager::registerPerformOperations(ReanimatedPerformOperations reanimatedPerformOperations)
+{
+    performOperations = std::move(reanimatedPerformOperations);
+}
+
+void ReanimatedNodesManager::postOnAnimation(ReanimatedOnAnimationCallback callback)
+{
+    onAnimationCallbacks.push_back(std::move(callback));
+    m_vsyncHandle.requestFrame(vsyncHandleCallback, this);
+}
+
+void ReanimatedNodesManager::operationBatchDidComplete()
+{
+    performOperations();
+}
+
+void ReanimatedNodesManager::onAnimationFrame(int64_t timestamp)
+{
+    runOnTheMainThread([weakSelf = weak_from_this(), timestamp]() {
+        auto self = weakSelf.lock();
+        if (!self) {
+            return;
+        }
+        std::vector<ReanimatedOnAnimationCallback> callbacks;
+        std::swap(callbacks, self->onAnimationCallbacks);
+
+        for (auto &callback : callbacks) {
+            callback(timestamp / NANO_TO_MILLIS);
+        }
+        self->performOperations();
+    });
+}
+} // namespace rnoh