@react-native-ohos/react-native-reanimated 4.0.1 → 4.0.2

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

@@ -1,234 +1,247 @@
-// 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 "ReanimatedSensorContainer.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;
-    }
-    if (auto nativeReanimatedModule = weakNativeReanimatedModule_.lock()) {
-        nativeReanimatedModule->invalidate();
-    }
-}
-
-void ReanimatedModule::installTurboModule(facebook::jsi::Runtime &rt) {
-    if (!m_ctx.taskExecutor->isOnTaskThread(rnoh::TaskThread::JS)) {
-        DLOG(ERROR) << "react_worklets reanimated installTurboModule failed,because of current thread is not js;";
-        return;
-    }
-    
-    auto runMainThreadFuc = [weakExecutor = std::weak_ptr(m_ctx.taskExecutor)](TaskExecutor::Task &&task) {
-        if (auto taskExecutor = weakExecutor.lock()) {
-            taskExecutor->runTask(TaskThread::MAIN, std::move(task));
-        }
-    };
-    auto nodesManager = std::make_shared<ReanimatedNodesManager>(runMainThreadFuc);
-
-    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 getAnimationTimestamp = getMillisSinceEpoch;
-
-    auto synchronouslyUpdateUIPropsFunction = [weakInstance = m_ctx.instance](Tag tag, const folly::dynamic &dynamic) {
-        auto instance = weakInstance.lock();
-        auto instanceCapi = std::dynamic_pointer_cast<RNInstanceCAPI>(instance);
-        if (!instanceCapi) {
-            return;
-        }
-        auto componentInstance = instanceCapi->findComponentInstanceByTag(tag);
-        if (!componentInstance) {
-            return;
-        }
-
-        // We want to restore the ignored props after the update,
-        // because reanimated handles setting correct props on React renders on its own
-        auto ignoredProps = componentInstance->getIgnoredPropKeys();
-        instanceCapi->synchronouslyUpdateViewOnUIThread(tag, dynamic);
-        componentInstance->setIgnoredPropKeys(std::move(ignoredProps));
-    };
-    auto sensorContainer = std::make_shared<ReanimatedSensorContainer>();
-
-
-    auto registerSensorFunction = [sensorContainer,
-                                   runMainThreadFuc](int sensorType, int interval, int iosReferenceFrame,
-                                                     std::function<void(double[], int)> setter) -> int {
-        return sensorContainer->registerSensor(sensorType, interval, iosReferenceFrame, setter, runMainThreadFuc);
-    };
-    auto unregisterSensorFunction = [sensorContainer](int sensorId) { sensorContainer->unregisterSensor(sensorId); };
-    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,
-        synchronouslyUpdateUIPropsFunction,
-        getAnimationTimestamp,
-        registerSensorFunction,
-        unregisterSensorFunction,
-        setGestureStateFunction,
-        subscribeForKeyboardEventsFunction,
-        unsubscribeFromKeyboardEventsFunction,
-        maybeFlushUIUpdatesQueueFunction,
-    };
-    auto isReducedMotion = false; // ANIMATOR_DURATION_SCALE
-    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 reanimatedModuleProxy = std::make_shared<ReanimatedModuleProxy>(
-        workletsModule()->getWorkletsModuleProxy(), rt, jsInvoker_, platformDepMethodsHolder, isReducedMotion);
-    reanimatedModuleProxy->init(platformDepMethodsHolder);
-    weakNativeReanimatedModule_ = reanimatedModuleProxy;
-
-    ReanimatedPerformOperations reanimatedPerformOperations = [weakNativeReanimatedModule =
-                                                                   weakNativeReanimatedModule_]() {
-        if (auto nativeReanimatedModule = weakNativeReanimatedModule.lock()) {
-            nativeReanimatedModule->performOperations(false);
-        }
-    };
-    nodesManager->registerPerformOperations(reanimatedPerformOperations);
-
-    WorkletRuntimeCollector::install(rt);
-    auto &uiRuntime = workletsModule()->getWorkletsModuleProxy()->getUIWorkletRuntime()->getJSIRuntime();
-
-    RNRuntimeDecorator::decorate(rt, uiRuntime, reanimatedModuleProxy);
-    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);
-    }
-}
+// 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 "ReanimatedSensorContainer.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;
+    }
+    if (auto nativeReanimatedModule = weakNativeReanimatedModule_.lock()) {
+        nativeReanimatedModule->invalidate();
+    }
+}
+
+void ReanimatedModule::installTurboModule(facebook::jsi::Runtime &rt) {
+    if (!m_ctx.taskExecutor->isOnTaskThread(rnoh::TaskThread::JS)) {
+        DLOG(ERROR) << "react_worklets reanimated installTurboModule failed,because of current thread is not js;";
+        return;
+    }
+    
+    auto runMainThreadFuc = [weakExecutor = std::weak_ptr(m_ctx.taskExecutor)](TaskExecutor::Task &&task) {
+        if (auto taskExecutor = weakExecutor.lock()) {
+            taskExecutor->runTask(TaskThread::MAIN, std::move(task));
+        }
+    };
+    auto nodesManager = std::make_shared<ReanimatedNodesManager>(runMainThreadFuc);
+
+    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 getAnimationTimestamp = getMillisSinceEpoch;
+
+    auto synchronouslyUpdateUIPropsFunction = [weakInstance = m_ctx.instance](Tag tag, const folly::dynamic &dynamic) {
+        auto instance = weakInstance.lock();
+        auto instanceCapi = std::dynamic_pointer_cast<RNInstanceCAPI>(instance);
+        if (!instanceCapi) {
+            return;
+        }
+        auto componentInstance = instanceCapi->findComponentInstanceByTag(tag);
+        if (!componentInstance) {
+            return;
+        }
+
+        // We want to restore the ignored props after the update,
+        // because reanimated handles setting correct props on React renders on its own
+        auto ignoredProps = componentInstance->getIgnoredPropKeys();
+        instanceCapi->synchronouslyUpdateViewOnUIThread(tag, dynamic);
+        componentInstance->setIgnoredPropKeys(std::move(ignoredProps));
+    };
+    auto sensorContainer = std::make_shared<ReanimatedSensorContainer>();
+
+
+    auto registerSensorFunction = [sensorContainer,
+                                   runMainThreadFuc](int sensorType, int interval, int iosReferenceFrame,
+                                                     std::function<void(double[], int)> setter) -> int {
+        return sensorContainer->registerSensor(sensorType, interval, iosReferenceFrame, setter, runMainThreadFuc);
+    };
+    auto unregisterSensorFunction = [sensorContainer](int sensorId) { sensorContainer->unregisterSensor(sensorId); };
+    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,
+        synchronouslyUpdateUIPropsFunction,
+        getAnimationTimestamp,
+        registerSensorFunction,
+        unregisterSensorFunction,
+        setGestureStateFunction,
+        subscribeForKeyboardEventsFunction,
+        unsubscribeFromKeyboardEventsFunction,
+        maybeFlushUIUpdatesQueueFunction,
+    };
+    bool isReducedMotion = false; // ANIMATOR_DURATION_SCALE
+    m_ctx.taskExecutor->runSyncTask(TaskThread::MAIN,
+        [ctx = m_ctx, &isReducedMotion]() {
+            if (!ctx.arkTSTurboModuleInstanceRef) {
+                return;
+            }
+            ArkJS arkJs(ctx.env);
+            auto napiTurboModuleObject =
+                arkJs.getObject(ctx.arkTSTurboModuleInstanceRef);
+            auto napiResult =
+                napiTurboModuleObject.call("isReducedMotionEnabled", {});
+            isReducedMotion = arkJs.getBoolean(napiResult);
+        });
+    
+    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 reanimatedModuleProxy = std::make_shared<ReanimatedModuleProxy>(
+        workletsModule()->getWorkletsModuleProxy(), rt, jsInvoker_, platformDepMethodsHolder, isReducedMotion);
+    reanimatedModuleProxy->init(platformDepMethodsHolder);
+    weakNativeReanimatedModule_ = reanimatedModuleProxy;
+
+    ReanimatedPerformOperations reanimatedPerformOperations = [weakNativeReanimatedModule =
+                                                                   weakNativeReanimatedModule_]() {
+        if (auto nativeReanimatedModule = weakNativeReanimatedModule.lock()) {
+            nativeReanimatedModule->performOperations(false);
+        }
+    };
+    nodesManager->registerPerformOperations(reanimatedPerformOperations);
+
+    WorkletRuntimeCollector::install(rt);
+    auto &uiRuntime = workletsModule()->getWorkletsModuleProxy()->getUIWorkletRuntime()->getJSIRuntime();
+
+    RNRuntimeDecorator::decorate(rt, uiRuntime, reanimatedModuleProxy);
+    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

@@ -1,24 +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_;
-};
+// 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

@@ -1,57 +1,57 @@
-// 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)
-{
-    LOG(INFO)<<"react_work reanimated------>postOnAnimation";
-    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();
-    });
-}
+// 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)
+{
+    LOG(INFO)<<"react_work reanimated------>postOnAnimation";
+    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