@react-native-ohos/react-native-reanimated 4.0.2-beta.1 → 4.1.0-beta.1

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

@@ -1,9 +1,12 @@
-// Copyright (c) 2025 Huawei Device Co., Ltd. All rights reserved
+// Copyright (c) 2026 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 "ReanimatedSensor.h"
 #include "glog/logging.h"
+#include <algorithm>
+#include <cmath>
+#include <string>
 #include <sensors/oh_sensor.h>
 #include <window_manager/oh_display_info.h>
 #include <window_manager/oh_display_manager.h>
@@ -52,52 +55,54 @@ void SensorDataCallbackImpl(Sensor_Event *event) {
     }
 
     switch (sensorType) {
-    case SENSOR_TYPE_ACCELEROMETER: {
-        double sendData[] = {
-            data[0],
-            data[1],
-            data[2],
-        };
-        sensorInstance->runSensor(sendData);
-        return;
-    }
-    case SENSOR_TYPE_GYROSCOPE: {
-        double sendData[] = {
+    case SENSOR_TYPE_GYROSCOPE:
+    case SENSOR_TYPE_MAGNETIC_FIELD: {
+        std::array<double, 7> sendData = {
             data[0],
             data[1],
             data[2],
+            0,
+            0,
+            0,
+            0,
         };
         sensorInstance->runSensor(sendData);
         return;
     }
+    case SENSOR_TYPE_ACCELEROMETER:
+    case SENSOR_TYPE_LINEAR_ACCELERATION:
     case SENSOR_TYPE_GRAVITY: {
-        double sendData[] = {
-            data[0],
-            data[1],
-            data[2],
-        };
-        sensorInstance->runSensor(sendData);
-        return;
-    }
-    case SENSOR_TYPE_MAGNETIC_FIELD: {
-        double sendData[] = {
-            data[0],
-            data[1],
-            data[2],
+        std::array<double, 7> sendData = {
+            -data[0],
+            -data[1],
+            -data[2],
+            0,
+            0,
+            0,
+            0,
         };
         sensorInstance->runSensor(sendData);
         return;
     }
     case SENSOR_TYPE_ROTATION_VECTOR: {
-        double sendData[] = {
-            data[0], // x
-            data[1], // y
-            data[2], // z
-            data[3], // w
-            // ios
-            0, // yaw
-            0, // pitch
-            0  // roll
+        double qx = data[0], qy = data[1], qz = data[2];
+        double qw = (length >= 4)
+            ? data[3]
+            : std::sqrt(std::max(0.0, 1.0 - qx * qx - qy * qy - qz * qz));
+        double xx = qx * qx, yy = qy * qy, zz = qz * qz;
+        double xy = qx * qy, xz = qx * qz, yz = qy * qz;
+        double wx = qw * qx, wy = qw * qy, wz = qw * qz;
+        double azimuth = std::atan2(2 * (xy - wz), 1 - 2 * (xx + zz));
+        double pitch = std::asin(std::clamp(-2 * (yz + wx), -1.0, 1.0));
+        double roll = std::atan2(-2 * (xz - wy), 1 - 2 * (xx + yy));
+        std::array<double, 7> sendData = {
+            qx,       // qx
+            qz,       // qy槽位放qz，对齐iOS参考系（同Android ReanimatedSensorListener.kt）
+            -qy,      // qz槽位放-qy
+            qw,       // qw
+            -azimuth, // yaw
+            -pitch,   // pitch
+            roll      // roll
         };
         sensorInstance->runSensor(sendData);
         return;
@@ -117,9 +122,10 @@ rnoh::ReanimatedSensor::ReanimatedSensor(int sensorType, int interval, int iosRe
         uint32_t refreshRate = 0;
         OH_NativeDisplayManager_GetDefaultDisplayRefreshRate(&refreshRate);
         if (refreshRate > 0) {
-            interval_ = refreshRate * 1000000; // 120hz;
+            // 采样周期 = 1/刷新率，换算为纳秒（iOS侧为 1/maximumFramesPerSecond 秒）
+            interval_ = 1000000000 / refreshRate;
         } else {
-            interval_ = 200000000;
+            interval_ = 16666667; // 查询失败时按60Hz周期兜底
         }
     } else {
         // js unit is milliseconds
@@ -131,7 +137,7 @@ rnoh::ReanimatedSensor::ReanimatedSensor(int sensorType, int interval, int iosRe
 
 void rnoh::ReanimatedSensor::castSensorType(int sensorType) {
     if (sensorType == 1) {
-        sensorType_ = SENSOR_TYPE_ACCELEROMETER;
+        sensorType_ = SENSOR_TYPE_LINEAR_ACCELERATION;
     } else if (sensorType == 2) {
         sensorType_ = SENSOR_TYPE_GYROSCOPE;
     } else if (sensorType == 3) {
@@ -141,34 +147,44 @@ void rnoh::ReanimatedSensor::castSensorType(int sensorType) {
     } else if (sensorType == 5) {
         sensorType_ = SENSOR_TYPE_ROTATION_VECTOR;
     } else {
-        throw std::invalid_argument("[ReanimatedSensor] Unknown sensorType: " + sensorType);
+        throw std::invalid_argument("[ReanimatedSensor] Unknown sensorType: " + std::to_string(sensorType));
     }
 }
 
 bool rnoh::ReanimatedSensor::initialize() {
     if (!isSupportSensor()) {
-        LOG(ERROR) << "[ReanimatedSensor] is not support, sensorType:" << sensorType_;
-        return false;
+        if (sensorType_ == SENSOR_TYPE_LINEAR_ACCELERATION) {
+            DLOG(WARNING) << "[ReanimatedSensor] linear acceleration not supported, fallback to accelerometer";
+            sensorType_ = SENSOR_TYPE_ACCELEROMETER;
+        }
+        if (!isSupportSensor()) {
+            DLOG(ERROR) << "[ReanimatedSensor] is not support, sensorType:" << sensorType_;
+            return false;
+        }
     }
     id_ = OH_Sensor_CreateSubscriptionId();
     if (id_ == nullptr) {
-        LOG(ERROR) << "[ReanimatedSensor] create sensor id failed";
+        DLOG(ERROR) << "[ReanimatedSensor] create sensor id failed";
         return false;
     }
     int32_t res = OH_SensorSubscriptionId_SetType(id_, sensorType_);
     if (res != SENSOR_SUCCESS) {
-        LOG(ERROR) << "[ReanimatedSensor] set sensor type failed ,sensorType:" << sensorType_;
+        OH_Sensor_DestroySubscriptionId(id_);
+        id_ = nullptr;
+        DLOG(ERROR) << "[ReanimatedSensor] set sensor type failed ,sensorType:" << sensorType_;
         return false;
     }
-    auto attr = OH_Sensor_CreateSubscriptionAttribute();
-    if (attr == nullptr) {
-        LOG(ERROR) << "[ReanimatedSensor] create sensor attribute failed";
+    attr_ = OH_Sensor_CreateSubscriptionAttribute();
+    if (attr_ == nullptr) {
+        DLOG(ERROR) << "[ReanimatedSensor] create sensor attribute failed";
         return false;
     }
 
-    res = OH_SensorSubscriptionAttribute_SetSamplingInterval(attr, interval_);
+    res = OH_SensorSubscriptionAttribute_SetSamplingInterval(attr_, interval_);
     if (res != SENSOR_SUCCESS) {
-        LOG(ERROR) << "[ReanimatedSensor] set sensor Interval failed, interval_:" << interval_;
+        OH_Sensor_DestroySubscriptionAttribute(attr_);
+        attr_ = nullptr;
+        DLOG(ERROR) << "[ReanimatedSensor] set sensor Interval failed, interval_:" << interval_;
         return false;
     }
 
@@ -181,12 +197,16 @@ bool rnoh::ReanimatedSensor::initialize() {
 
     int32_t ret = OH_SensorSubscriber_SetCallback(subSensor_, SensorDataCallbackImpl);
     if (ret != SENSOR_SUCCESS) {
-        LOG(ERROR) << "[ReanimatedSensor] set sensor callback failed";
+        OH_Sensor_DestroySubscriptionAttribute(attr_);
+        attr_ = nullptr;
+        DLOG(ERROR) << "[ReanimatedSensor] set sensor callback failed";
         return false;
     }
-    Sensor_Result sensorRes = OH_Sensor_Subscribe(id_, attr, subSensor_);
+    Sensor_Result sensorRes = OH_Sensor_Subscribe(id_, attr_, subSensor_);
     if (sensorRes != SENSOR_SUCCESS) {
-        LOG(ERROR) << "[ReanimatedSensor] on sensor subscribe failed";
+        OH_Sensor_DestroySubscriptionAttribute(attr_);
+        attr_ = nullptr;
+        DLOG(ERROR) << "[ReanimatedSensor] on sensor subscribe failed";
         return false;
     }
     return true;
@@ -214,14 +234,14 @@ bool rnoh::ReanimatedSensor::isSupportSensor() {
     return isSupport;
 }
 
-void rnoh::ReanimatedSensor::runSensor(double *value) {
-    if (value && setter_ && runOnTheMainThread_) {
-        runOnTheMainThread_([weakSelf = weak_from_this(), value]() {
+void rnoh::ReanimatedSensor::runSensor(std::array<double, 7> value) {
+    if (setter_ && runOnTheMainThread_) {
+        runOnTheMainThread_([weakSelf = weak_from_this(), value = std::move(value)]() mutable {
             auto self = weakSelf.lock();
             if (!self) {
                 return;
             }
-            self->setter_(value, self->getInterfaceOrientation());
+            self->setter_(value.data(), self->getInterfaceOrientation());
         });
     }
 }
@@ -251,9 +271,20 @@ void rnoh::ReanimatedSensor::destroySensor() {
     std::lock_guard<std::mutex> lock(g_subscriberMapMutex_);
     for (auto it = g_sensorSubscriberMap_.begin(); it != g_sensorSubscriberMap_.end();) {
         if (it->second == this) {
-            OH_Sensor_Unsubscribe(it->second->id_, it->second->subSensor_);
-            OH_Sensor_DestroySubscriptionId(it->second->id_);
-            OH_Sensor_DestroySubscriber(it->second->subSensor_);
+            if (it->second->id_ && it->second->subSensor_) {
+                OH_Sensor_Unsubscribe(it->second->id_, it->second->subSensor_);
+            }
+            if (it->second->id_ ) {
+                OH_Sensor_DestroySubscriptionId(it->second->id_);
+            }
+            if (it->second->subSensor_) {
+                OH_Sensor_DestroySubscriber(it->second->subSensor_);
+            }
+            if (it->second->attr_) {
+                OH_Sensor_DestroySubscriptionAttribute(it->second->attr_);
+            }
+            it->second->id_ = nullptr;
+            it->second->attr_ = nullptr;
             it->second->subSensor_ = nullptr;
             it = g_sensorSubscriberMap_.erase(it);
         } else {

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

@@ -1,9 +1,10 @@
-// Copyright (c) 2025 Huawei Device Co., Ltd. All rights reserved
+// Copyright (c) 2026 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.
 
 #ifndef HARMONY_REANIMATEDSENSOR_H
 #define HARMONY_REANIMATEDSENSOR_H
+#include <array>
 #include <functional>
 #include <mutex>
 #include <sensors/oh_sensor_type.h>
@@ -18,7 +19,7 @@ public:
     bool initialize();
     void cancel();
     void castSensorType(int sensorType);
-    void runSensor(double *value);
+    void runSensor(std::array<double, 7> value);
     std::function<void(double[], int)> setter_;
     Sensor_Type sensorType_{SENSOR_TYPE_ACCELEROMETER};
 
@@ -30,6 +31,7 @@ private:
     int iosReferenceFrame_{-1};
     Sensor_Subscriber *subSensor_{nullptr};
     Sensor_SubscriptionId *id_{nullptr};
+    Sensor_SubscriptionAttribute *attr_{nullptr};
     std::function<void(TaskExecutor::Task &&)> runOnTheMainThread_;
 };
 } // namespace rnoh

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

@@ -1,4 +1,4 @@
-// Copyright (c) 2025 Huawei Device Co., Ltd. All rights reserved
+// Copyright (c) 2026 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.
 

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

@@ -1,4 +1,4 @@
-// Copyright (c) 2025 Huawei Device Co., Ltd. All rights reserved
+// Copyright (c) 2026 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.
 

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

@@ -1,4 +1,4 @@
-// Copyright (c) 2025 Huawei Device Co., Ltd. All rights reserved
+// Copyright (c) 2026 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.
 
@@ -13,11 +13,13 @@ void ReanimatedUIScheduler::scheduleOnUI(std::function<void()> job)
         job();
         return;
     }
-
-    m_taskExecutor->runTask(TaskThread::MAIN, [weakSelf = weak_from_this(), job = std::move(job)]() {
-        if (auto self = weakSelf.lock()) {
-            job();
-        }
-    });
+    UIScheduler::scheduleOnUI(job);
+    if (!scheduledOnUI_.exchange(true)) {
+        m_taskExecutor->runTask(TaskThread::MAIN, [weakSelf = weak_from_this()]() {
+            if (auto self = weakSelf.lock()) {
+                self->triggerUI();
+            }
+        });
+    }
 }
 } // namespace rnoh

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

@@ -1,20 +1,21 @@
-// Copyright (c) 2025 Huawei Device Co., Ltd. All rights reserved
+// Copyright (c) 2026 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 <functional>
-//#include <UIScheduler.h>
 #include <memory>
 #include "RNOH/TaskExecutor/TaskExecutor.h"
+#include "worklets/Tools/UIScheduler.h"
 
 namespace rnoh {
-class ReanimatedUIScheduler : public std::enable_shared_from_this<ReanimatedUIScheduler> { //, public worklets::UIScheduler
+class ReanimatedUIScheduler : public std::enable_shared_from_this<ReanimatedUIScheduler>,
+                              public worklets::UIScheduler {
 private:
     std::shared_ptr<TaskExecutor> m_taskExecutor;
 
 public:
     ReanimatedUIScheduler(std::shared_ptr<TaskExecutor> taskExecutor);
-    void scheduleOnUI(std::function<void()> job) ; //override
+    void scheduleOnUI(std::function<void()> job) override;
 };
-} // namespace rnoh
+} // namespace rnoh

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

@@ -1,4 +1,4 @@
-// Copyright (c) 2025 Huawei Device Co., Ltd. All rights reserved
+// Copyright (c) 2026 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.
 

package/harmony/reanimated/src/main/cpp/codegen/react/renderer/components/rnreanimated/EventEmitters.h

@@ -0,0 +1,19 @@
+#pragma once
+
+// Copyright (c) 2026 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 <react/renderer/components/view/ViewEventEmitter.h>
+
+namespace facebook {
+namespace react {
+
+class REASharedTransitionBoundaryEventEmitter final
+    : public ViewEventEmitter {
+ public:
+  using ViewEventEmitter::ViewEventEmitter;
+};
+
+} // namespace react
+} // namespace facebook

package/harmony/reanimated/src/main/cpp/codegen/react/renderer/components/rnreanimated/Props.h

@@ -0,0 +1,31 @@
+#pragma once
+
+// Copyright (c) 2026 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 <react/renderer/components/view/ViewProps.h>
+#include <react/renderer/core/PropsParserContext.h>
+#include <react/renderer/core/RawProps.h>
+#include <react/renderer/core/propsConversions.h>
+
+namespace facebook {
+namespace react {
+
+class REASharedTransitionBoundaryProps final : public ViewProps {
+ public:
+  REASharedTransitionBoundaryProps() = default;
+
+  REASharedTransitionBoundaryProps(
+      const PropsParserContext &context,
+      const REASharedTransitionBoundaryProps &sourceProps,
+      const RawProps &rawProps)
+      : ViewProps(context, sourceProps, rawProps) {
+    isActive = convertRawProp(context, rawProps, "isActive", sourceProps.isActive, false);
+  }
+
+  bool isActive{false};
+};
+
+} // namespace react
+} // namespace facebook

package/harmony/reanimated/src/main/ets/KeyboardState.ts

@@ -0,0 +1,11 @@
+// Copyright (c) 2026 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.
+
+export enum KeyboardState {
+  UNKNOWN = 0,
+  OPENING = 1,
+  OPEN = 2,
+  CLOSING = 3,
+  CLOSED = 4,
+}

package/harmony/reanimated/src/main/ets/ReanimatedModule.ts

@@ -1,17 +1,19 @@
-// Copyright (c) 2025 Huawei Device Co., Ltd. All rights reserved
+// Copyright (c) 2026 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.
 
 import { RNOHLogger, Tag, UITurboModule, UITurboModuleContext } from "@rnoh/react-native-openharmony/ts";
-import { window } from '@kit.ArkUI';
-import { AnimationManager } from './AnimationManager'
-import settings from '@ohos.settings';
-import { } from "@ohos.display"
+import { Animator, AnimatorResult, window } from '@kit.ArkUI';
+import { KeyboardState } from "./KeyboardState";
+import deviceInfo from '@ohos.deviceInfo';
+import { accessibility } from '@kit.AccessibilityKit';
 
 export class ReanimatedModule extends UITurboModule {
   static NAME = "ReanimatedModule"
   private logger: RNOHLogger
   private keyBordHeight = 0;
+  private currentAnimator: AnimatorResult | null = null;
+  private currentAnimatedHeight = 0;
 
   constructor(ctx: UITurboModuleContext) {
     super(ctx);
@@ -20,27 +22,99 @@ export class ReanimatedModule extends UITurboModule {
 
   public setViewProps(tag: Tag, props: Object) {
     this.ctx.descriptorRegistry.setAnimatedRawProps(tag, props);
-
   }
 
-  public async subscribeKeyBordListeners() {
-    const windowInstance = await window.getLastWindow(this.ctx.uiAbilityContext);
+  public async subscribeKeyBordListeners(isStatusBarTranslucent: boolean, isNavigationBarTranslucent: boolean) {
+    //ignore isStatusBarTranslucent  - those are Android only
+    let windowInstance: window.Window;
+    try {
+      windowInstance = await window.getLastWindow(this.ctx.uiAbilityContext);
+    } catch (e: ESObject) {
+      this.logger.error(`subscribeKeyBordListeners failed: ${e?.message ?? e}`);
+      return;
+    }
+    const navIndicatorArea = windowInstance.getWindowAvoidArea(
+      window.AvoidAreaType.TYPE_NAVIGATION_INDICATOR
+    );
+    const navIndicatorHeight = this.ctx.getUIContext().px2vp(
+      navIndicatorArea.bottomRect.height
+    );
+
+    const isEdgeToEdge = this.isEdgeToEdgeMode(windowInstance);
+    const effectiveNavBarTranslucent = isEdgeToEdge && isNavigationBarTranslucent;
+
     windowInstance.on('keyboardHeightChange', async (height) => {
-      let keyBordHeight = this.ctx.getUIContext().px2vp(height);
-      const animationManager = new AnimationManager();
-      animationManager.setUpdateCallback((value, status) => {
+      let rawKeyboardHeight = this.ctx.getUIContext().px2vp(height);
+      //If the immersive mode is not enabled, then the area around the bottom navigation bar that needs to be avoided needs to be removed.
+      //If the immersive mode is enabled, the returned value will be the height of the current keyboard.
+      let keyBordHeight = effectiveNavBarTranslucent
+        ? rawKeyboardHeight
+        : Math.max(0, rawKeyboardHeight - navIndicatorHeight);
+
+      //Unchanged height, skip handle
+      if (Math.abs(keyBordHeight - this.currentAnimatedHeight) < 0.01) {
+        return;
+      }
+
+      const isOpening = keyBordHeight > this.keyBordHeight;
+
+      if (this.currentAnimator) {
+        this.currentAnimator.onFrame = null;
+        this.currentAnimator.onFinish = null;
+        this.currentAnimator.cancel();
+        this.currentAnimator = null;
+      }
+
+      this.currentAnimator = Animator.create({
+        duration: isOpening ? 480 : 350,
+        delay: 0,
+        //simulate the keyboard pop-up and retraction animations in harmony
+        easing: isOpening ? "cubic-bezier(0.2, 0.0, 0.1, 1.0)"
+          : "cubic-bezier(0.0, 0.0, 0.1, 1.0)",
+        fill: "forwards",
+        direction: "normal",
+        iterations: 1,
+        begin: this.currentAnimatedHeight,
+        end: keyBordHeight
+      }
+      )
+      this.currentAnimator.onFrame = (progress: number) => {
+        this.currentAnimatedHeight = progress;
+        if (Math.abs(progress - keyBordHeight) < 0.01) { //The final instruction is sent by "onFinish".
+          return;
+        }
+        let status = keyBordHeight > this.keyBordHeight ? KeyboardState.OPENING : KeyboardState.CLOSING;
         this.ctx.rnInstance.postMessageToCpp("REANIMATED_KEY_BOARD_CHANGE",
-          { keyboardHeight: value, status: status.valueOf() });
-      });
-      animationManager.startAnimation(this.keyBordHeight, keyBordHeight, 200);
-      this.keyBordHeight = keyBordHeight;
+          { keyboardHeight: progress, status: status.valueOf() });
+      }
+      this.currentAnimator.onFinish = () => {
+        this.currentAnimatedHeight = keyBordHeight;
+        let status = keyBordHeight > this.keyBordHeight ? KeyboardState.OPEN : KeyboardState.CLOSED;
+        this.keyBordHeight = keyBordHeight;
+        this.ctx.rnInstance.postMessageToCpp("REANIMATED_KEY_BOARD_CHANGE",
+          { keyboardHeight: keyBordHeight, status: status.valueOf() });
+      }
+      this.currentAnimator.play();
     })
   }
 
   public async unsubscribeKeyBordListeners() {
-    const windowInstance = await window.getLastWindow(this.ctx.uiAbilityContext);
-    windowInstance.off('keyboardHeightChange', (v) => {
-    })
+    let windowInstance: window.Window;
+    try {
+      windowInstance = await window.getLastWindow(this.ctx.uiAbilityContext);
+    } catch (e: ESObject) {
+      this.logger.error(`unsubscribeKeyBordListeners failed: ${e?.message ?? e}`);
+      return;
+    }
+    windowInstance.off('keyboardHeightChange')
+    if (this.currentAnimator) {
+      this.currentAnimator.onFrame = null;
+      this.currentAnimator.onFinish = null;
+      this.currentAnimator.cancel();
+      this.currentAnimator = null;
+    }
+    this.keyBordHeight = 0;
+    this.currentAnimatedHeight = 0;
   }
 
   public setGestureHandlerState(handlerTag: Tag, newState: number) {
@@ -49,4 +123,30 @@ export class ReanimatedModule extends UITurboModule {
       module.setGestureHandlerState(handlerTag, newState);
     }
   }
-}
+
+  private isEdgeToEdgeMode(windowInstance: window.Window) {
+    let isLayoutFullScreen = false;
+    try {
+      const windowProperties = windowInstance.getWindowProperties();
+      isLayoutFullScreen = windowProperties.isLayoutFullScreen;
+    } catch (e: ESObject) {
+      isLayoutFullScreen = false;
+    }
+    return isLayoutFullScreen;
+  }
+
+  public isReducedMotionEnabled(): boolean {
+    try {
+      if (deviceInfo.sdkApiVersion >= 23) {
+        return (accessibility as ESObject).isAnimationReduceEnabledSync();
+      }
+    } catch (e) {
+      this.logger.warn(`isReducedMotionEnabled failed: ${JSON.stringify(e)}`);
+    }
+    return false;
+  }
+
+  __onDestroy__(): void {
+    this.unsubscribeKeyBordListeners();
+  }
+}

package/harmony/reanimated/src/main/ets/{ReanimatedPackage.ts → ReanimatedPackage.ets}

@@ -1,10 +1,11 @@
-// Copyright (c) 2025 Huawei Device Co., Ltd. All rights reserved
+// Copyright (c) 2026 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.
 
-import { RNPackage, UITurboModuleContext, TurboModulesFactory } from "@rnoh/react-native-openharmony/ts";
+import { UITurboModuleContext, TurboModulesFactory } from "@rnoh/react-native-openharmony/ts";
 import type { UITurboModule } from "@rnoh/react-native-openharmony/ts";
 import { ReanimatedModule } from './ReanimatedModule';
+import { RNOHPackage } from '@rnoh/react-native-openharmony'
 
 class ReanimatedTurboModulesFactory extends TurboModulesFactory {
   createTurboModule(name: string): UITurboModule | null {
@@ -19,7 +20,7 @@ class ReanimatedTurboModulesFactory extends TurboModulesFactory {
   }
 }
 
-export class ReanimatedPackage extends RNPackage {
+export class ReanimatedPackage extends RNOHPackage {
   createTurboModulesFactory(ctx: UITurboModuleContext): TurboModulesFactory {
     return new ReanimatedTurboModulesFactory(ctx);
   }