@react-native-ohos/react-native-reanimated 3.18.3-beta.2 → 3.18.4-beta.2

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

@@ -0,0 +1,248 @@
+// 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 "ReanimatedSensor.h"
+#include "glog/logging.h"
+#include <memory>
+#include <vector>
+#include <sensors/oh_sensor.h>
+#include <window_manager/oh_display_info.h>
+#include <window_manager/oh_display_manager.h>
+namespace rnoh {
+static std::unordered_map<Sensor_Type, ReanimatedSensor *> g_sensorSubscriberMap_;
+static std::mutex g_subscriberMapMutex_; // 保护映射表的互斥锁
+
+void SensorDataCallbackImpl(Sensor_Event *event) {
+    if (event == nullptr) {
+        return;
+    }
+    int64_t timestamp = -1;
+    // 获取传感器数据的时间戳。
+    int32_t ret = OH_SensorEvent_GetTimestamp(event, &timestamp);
+    if (ret != SENSOR_SUCCESS) {
+        return;
+    }
+    Sensor_Type sensorType;
+    // 获取传感器类型。
+    ret = OH_SensorEvent_GetType(event, &sensorType);
+    if (ret != SENSOR_SUCCESS) {
+        return;
+    }
+    Sensor_Accuracy accuracy = SENSOR_ACCURACY_UNRELIABLE;
+    // 获取传感器数据的精度。
+    ret = OH_SensorEvent_GetAccuracy(event, &accuracy);
+    if (ret != SENSOR_SUCCESS) {
+        return;
+    }
+    float *data = nullptr;
+    uint32_t length = 0;
+    // 获取传感器数据。
+    ret = OH_SensorEvent_GetData(event, &data, &length);
+    if (ret != SENSOR_SUCCESS || data == nullptr) {
+        return;
+    }
+
+    std::lock_guard<std::mutex> lock(g_subscriberMapMutex_);
+    auto it = g_sensorSubscriberMap_.find(sensorType);
+    if (it == g_sensorSubscriberMap_.end()) {
+        return;
+    }
+    ReanimatedSensor *sensorInstance = it->second;
+    if (sensorInstance == nullptr) {
+        return;
+    }
+
+    switch (sensorType) {
+    case SENSOR_TYPE_ACCELEROMETER:
+    case SENSOR_TYPE_GYROSCOPE:
+    case SENSOR_TYPE_GRAVITY:
+    case SENSOR_TYPE_MAGNETIC_FIELD: {
+        double sendData[] = {
+            data[0],
+            data[1],
+            data[2],
+        };
+        // 传入 count，由 runSensor 拷贝到堆，避免跨线程 use-after-free
+        sensorInstance->runSensor(sendData, 3);
+        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
+        };
+        sensorInstance->runSensor(sendData, 7);
+        return;
+    }
+    default:
+        return;
+    }
+}
+
+
+rnoh::ReanimatedSensor::ReanimatedSensor(int sensorType, int interval, int iosReferenceFrame,
+                                         std::function<void(double *, int)> setter,
+                                         std::function<void(TaskExecutor::Task &&)> runOnTheMainThread)
+    : iosReferenceFrame_(iosReferenceFrame), setter_(std::move(setter)),
+      runOnTheMainThread_(std::move(runOnTheMainThread)) {
+    if (interval == -1) {
+        uint32_t refreshRate = 0;
+        OH_NativeDisplayManager_GetDefaultDisplayRefreshRate(&refreshRate);
+        if (refreshRate > 0) {
+            interval_ = refreshRate * 1000000; // 120hz;
+        } else {
+            interval_ = 200000000;
+        }
+    } else {
+        // js unit is milliseconds
+        interval_ = interval * 1000000;
+    }
+    castSensorType(sensorType);
+}
+
+
+void rnoh::ReanimatedSensor::castSensorType(int sensorType) {
+    if (sensorType == 1) {
+        sensorType_ = SENSOR_TYPE_ACCELEROMETER;
+    } else if (sensorType == 2) {
+        sensorType_ = SENSOR_TYPE_GYROSCOPE;
+    } else if (sensorType == 3) {
+        sensorType_ = SENSOR_TYPE_GRAVITY;
+    } else if (sensorType == 4) {
+        sensorType_ = SENSOR_TYPE_MAGNETIC_FIELD;
+    } else if (sensorType == 5) {
+        sensorType_ = SENSOR_TYPE_ROTATION_VECTOR;
+    } else {
+        throw std::invalid_argument("[ReanimatedSensor] Unknown sensorType: " + sensorType);
+    }
+}
+
+bool rnoh::ReanimatedSensor::initialize() {
+    if (!isSupportSensor()) {
+        LOG(ERROR) << "[ReanimatedSensor] is not support, sensorType:" << sensorType_;
+        return false;
+    }
+    id_ = OH_Sensor_CreateSubscriptionId();
+    if (id_ == nullptr) {
+        LOG(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_;
+        return false;
+    }
+    auto attr = OH_Sensor_CreateSubscriptionAttribute();
+    if (attr == nullptr) {
+        LOG(ERROR) << "[ReanimatedSensor] create sensor attribute failed";
+        return false;
+    }
+
+    res = OH_SensorSubscriptionAttribute_SetSamplingInterval(attr, interval_);
+    if (res != SENSOR_SUCCESS) {
+        LOG(ERROR) << "[ReanimatedSensor] set sensor Interval failed, interval_:" << interval_;
+        return false;
+    }
+
+    subSensor_ = OH_Sensor_CreateSubscriber();
+
+    {
+        std::lock_guard<std::mutex> lock(g_subscriberMapMutex_);
+        g_sensorSubscriberMap_[sensorType_] = this;
+    }
+
+    int32_t ret = OH_SensorSubscriber_SetCallback(subSensor_, SensorDataCallbackImpl);
+    if (ret != SENSOR_SUCCESS) {
+        LOG(ERROR) << "[ReanimatedSensor] set sensor callback failed";
+        return false;
+    }
+    Sensor_Result sensorRes = OH_Sensor_Subscribe(id_, attr, subSensor_);
+    if (sensorRes != SENSOR_SUCCESS) {
+        LOG(ERROR) << "[ReanimatedSensor] on sensor subscribe failed";
+        return false;
+    }
+    return true;
+}
+
+
+bool rnoh::ReanimatedSensor::isSupportSensor() {
+    uint32_t count = 0;
+    int32_t ret = OH_Sensor_GetInfos(nullptr, &count);
+    bool isSupport = false;
+    if (count > 0) {
+        Sensor_Info **sensors = OH_Sensor_CreateInfos(count);
+        ret = OH_Sensor_GetInfos(sensors, &count);
+        for (uint32_t i = 0; i < count; ++i) {
+            Sensor_Info *sensorInfoTemp = sensors[i];
+            Sensor_Type sensorType;
+            ret = OH_SensorInfo_GetType(sensorInfoTemp, &sensorType);
+            if (sensorType == sensorType_) {
+                isSupport = true;
+                break;
+            }
+        }
+        ret = OH_Sensor_DestroyInfos(sensors, count);
+    }
+    return isSupport;
+}
+
+void rnoh::ReanimatedSensor::runSensor(double *value, size_t count) {
+    if (value && setter_ && runOnTheMainThread_ && count > 0) {
+        // 跨线程传递必须拷贝到堆：传感器回调运行在传感器线程，
+        // 而 setter_ 在主线程异步执行，栈上数据此时已释放（use-after-free）。
+        auto dataPtr = std::make_shared<std::vector<double>>(value, value + count);
+        runOnTheMainThread_([weakSelf = weak_from_this(), dataPtr]() {
+            auto self = weakSelf.lock();
+            if (!self) {
+                return;
+            }
+            self->setter_(dataPtr->data(), self->getInterfaceOrientation());
+        });
+    }
+}
+
+int rnoh::ReanimatedSensor::getInterfaceOrientation() {
+    NativeDisplayManager_Rotation rotation;
+    auto ret = OH_NativeDisplayManager_GetDefaultDisplayRotation(&rotation);
+    if (ret == DISPLAY_MANAGER_OK) {
+        switch (rotation) {
+        case DISPLAY_MANAGER_ROTATION_270:
+            return 270;
+        case DISPLAY_MANAGER_ROTATION_90:
+            return 90;
+        case DISPLAY_MANAGER_ROTATION_180:
+            return 180;
+        default:
+            return 0;
+        }
+    }
+    return 0;
+}
+
+
+void rnoh::ReanimatedSensor::cancel() { destroySensor(); }
+
+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_);
+            it->second->subSensor_ = nullptr;
+            it = g_sensorSubscriberMap_.erase(it);
+        } else {
+            ++it;
+        }
+    }
+}
+
+rnoh::ReanimatedSensor::~ReanimatedSensor() { destroySensor(); }
+}

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

@@ -0,0 +1,36 @@
+// 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.
+
+#ifndef HARMONY_REANIMATEDSENSOR_H
+#define HARMONY_REANIMATEDSENSOR_H
+#include <functional>
+#include <mutex>
+#include <sensors/oh_sensor_type.h>
+#include "RNOH/TaskExecutor/TaskExecutor.h"
+
+namespace rnoh {
+class ReanimatedSensor : public std::enable_shared_from_this<ReanimatedSensor> {
+public:
+    ReanimatedSensor(int sensorType, int interval, int iosReferenceFrame, std::function<void(double[], int)> setter,
+                     std::function<void(TaskExecutor::Task &&)> runOnTheMainThread);
+    ~ReanimatedSensor();
+    bool initialize();
+    void cancel();
+    void castSensorType(int sensorType);
+    void runSensor(double *value, size_t count);
+    std::function<void(double[], int)> setter_;
+    Sensor_Type sensorType_{SENSOR_TYPE_ACCELEROMETER};
+
+private:
+    void destroySensor();
+    bool isSupportSensor();
+    int getInterfaceOrientation();
+    int interval_{-1};
+    int iosReferenceFrame_{-1};
+    Sensor_Subscriber *subSensor_{nullptr};
+    Sensor_SubscriptionId *id_{nullptr};
+    std::function<void(TaskExecutor::Task &&)> runOnTheMainThread_;
+};
+} // namespace rnoh
+#endif // HARMONY_REANIMATEDSENSOR_H

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

@@ -0,0 +1,36 @@
+// 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 "ReanimatedSensorContainer.h"
+#include "glog/logging.h"
+namespace rnoh {
+
+rnoh::ReanimatedSensorContainer::ReanimatedSensorContainer() {}
+
+int rnoh::ReanimatedSensorContainer::registerSensor(int sensorType, int interval, int iosReferenceFrame,
+                                                    std::function<void(double *, int)> setter,
+                                                    std::function<void(TaskExecutor::Task &&)> runOnTheMainThread) {
+    auto sensor =
+        std::make_shared<ReanimatedSensor>(sensorType, interval, iosReferenceFrame, setter, runOnTheMainThread);
+    int sensorId = -1;
+    if (sensor->initialize()) {
+        sensorId = nextSensorId;
+        nextSensorId++;
+        sensorMap_[sensorId] = sensor;
+    }
+    return sensorId;
+}
+
+void rnoh::ReanimatedSensorContainer::unregisterSensor(int sensorId) {
+    auto it = sensorMap_.find(sensorId);
+    if (it == sensorMap_.end()) {
+        return;
+    }
+    auto sensor = it->second;
+    if (sensor != nullptr) {
+        sensor->cancel();
+        sensorMap_.erase(it);
+    }
+}
+}

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

@@ -0,0 +1,23 @@
+// 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.
+
+#ifndef HARMONY_REANIMATEDSENSORCONTAINER_H
+#define HARMONY_REANIMATEDSENSORCONTAINER_H
+#include "ReanimatedSensor.h"
+#include <functional>
+namespace rnoh {
+class ReanimatedSensorContainer {
+public:
+    ReanimatedSensorContainer();
+    ~ReanimatedSensorContainer() noexcept = default;
+    int registerSensor(int sensorType, int interval, int iosReferenceFrame, std::function<void(double[], int)> setter,
+                       std::function<void(TaskExecutor::Task &&)> runOnTheMainThread);
+    void unregisterSensor(int sensorId);
+
+private:
+    std::unordered_map<int, std::shared_ptr<ReanimatedSensor>> sensorMap_;
+    int nextSensorId{0};
+};
+} // namespace rnoh
+#endif // HARMONY_REANIMATEDSENSORCONTAINER_H

package/harmony/reanimated/src/main/cpp/patches/NativeModules/ReanimatedModuleProxy.cpp

@@ -27,6 +27,7 @@
 #endif // RCT_NEW_ARCH_ENABLED
 
 #include <functional>
+#include <glog/logging.h>
 #include <utility>
 
 #ifdef RCT_NEW_ARCH_ENABLED
@@ -228,6 +229,14 @@ void ReanimatedModuleProxy::init(
 }
 
 ReanimatedModuleProxy::~ReanimatedModuleProxy() {
+  LOG(WARNING) << "[RNOH_REA_TEARDOWN_V1] stage=proxy_dtor"
+               << " frame_callbacks=" << frameCallbacks_.size()
+#ifdef RCT_NEW_ARCH_ENABLED
+               << " pending_operations=" << operationsInBatch_.size()
+               << " props_registry=" << static_cast<bool>(propsRegistry_)
+               << " layout_proxy=" << static_cast<bool>(layoutAnimationsProxy_)
+#endif
+      ;
   // event handler registry and frame callbacks store some JSI values from UI
   // runtime, so they have to go away before we tear down the runtime
   eventHandlerRegistry_.reset();
@@ -256,8 +265,42 @@ ReanimatedModuleProxy::~ReanimatedModuleProxy() {
   }
   layoutAnimationsProxy_.reset();
 
+  // 主动触发 Hermes GC：在 uiWorkletRuntime_ 销毁前回收 Hermes 堆中持有
+  // ShadowNode::Shared（通过 NativeState / ShadowNodeWrapper）的 JSI 对象。
+  //
+  // 此处 commitHook_ / mountHook_ 仍未 reset，它们持有 uiManager_ 的
+  // shared_ptr，确保 GC 回收 ShadowNodeWrapper 触发 ~ShadowNodeFamily 时
+  // ComponentDescriptorRegistry 仍然有效。这样可避免 uiWorkletRuntime_.reset()
+  // → HadesGC::finalizeAll() 在上下文可能已失效后触发
+  // ~ShadowNodeFamily → ~InstanceHandle 崩溃（0730 复现变体根因）。
+  //
+  // UI runtime 为 LockableRuntime（supportsLocking=true），每个 JSI 操作
+  // 自动加锁 runtimeMutex_（recursive_mutex），从主线程调用 gc() 会阻塞
+  // 等待 UI 线程完成当前 worklet 后执行，不会死锁。
+#if JS_RUNTIME_HERMES
+  if (uiWorkletRuntime_) {
+    try {
+      auto &uiRuntime = uiWorkletRuntime_->getJSIRuntime();
+      auto gc = uiRuntime.global().getPropertyAsFunction(uiRuntime, "gc");
+      gc.call(uiRuntime);
+    } catch (const std::exception &) {
+      // gc() 调用失败不应阻止后续析构流程
+    } catch (...) {
+      // 忽略未知异常，保证析构不因 GC 失败而 terminate
+    }
+  }
+#endif // JS_RUNTIME_HERMES
+
+  // GC 之后再注销 hooks：确保 GC 回收 ShadowNodeWrapper 时
+  // UIManager（及 ComponentDescriptorRegistry）仍存活
+  commitHook_.reset();
+  mountHook_.reset();
+  LOG(WARNING) << "[RNOH_REA_TEARDOWN_V1] stage=fabric_hooks_removed";
+  uiManager_.reset();
 #endif // RCT_NEW_ARCH_ENABLED
+  LOG(WARNING) << "[RNOH_REA_TEARDOWN_V1] stage=ui_runtime_reset_begin";
   uiWorkletRuntime_.reset();
+  LOG(WARNING) << "[RNOH_REA_TEARDOWN_V1] stage=proxy_dtor_complete";
 }
 
 void ReanimatedModuleProxy::scheduleOnUI(
@@ -622,6 +665,7 @@ void ReanimatedModuleProxy::cleanupSensors() {
 void ReanimatedModuleProxy::markNodeAsRemovable(
     jsi::Runtime &rt,
     const jsi::Value &shadowNodeWrapper) {
+  auto lock = propsRegistry_->createLock();    
   auto shadowNode = shadowNodeFromValue(rt, shadowNodeWrapper);
   propsRegistry_->markNodeAsRemovable(shadowNode);
 }
@@ -629,6 +673,7 @@ void ReanimatedModuleProxy::markNodeAsRemovable(
 void ReanimatedModuleProxy::unmarkNodeAsRemovable(
     jsi::Runtime &rt,
     const jsi::Value &viewTag) {
+  auto lock = propsRegistry_->createLock();    
   propsRegistry_->unmarkNodeAsRemovable(viewTag.asNumber());
 }
 

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

@@ -5,6 +5,8 @@
 import { RNOHLogger, Tag, UITurboModule, UITurboModuleContext } from "@rnoh/react-native-openharmony/ts";
 import { Animator, AnimatorResult, window } from '@kit.ArkUI';
 import { KeyboardState } from "./AnimationManager";
+import deviceInfo from '@ohos.deviceInfo';
+import { accessibility } from '@kit.AccessibilityKit';
 
 export class ReanimatedModule extends UITurboModule {
   static NAME = "ReanimatedModule"
@@ -24,7 +26,13 @@ export class ReanimatedModule extends UITurboModule {
 
   public async subscribeKeyBordListeners(isStatusBarTranslucent: boolean, isNavigationBarTranslucent: boolean) {
     //ignore isStatusBarTranslucent  - those are Android only
-    const windowInstance = await window.getLastWindow(this.ctx.uiAbilityContext);
+    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
     );
@@ -91,7 +99,13 @@ export class ReanimatedModule extends UITurboModule {
   }
 
   public async unsubscribeKeyBordListeners() {
-    const windowInstance = await window.getLastWindow(this.ctx.uiAbilityContext);
+    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;
@@ -120,4 +134,15 @@ export class ReanimatedModule extends UITurboModule {
     }
     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;
+  }
 }

package/package.json

@@ -4,8 +4,8 @@
     "alias": "react-native-reanimated",
     "redirectInternalImports": true
   },
-  "version": "3.18.3-beta.2",
-  "description": "",
+  "version": "3.18.4-beta.2",
+  "description": "More powerful alternative to Animated library for React Native.",
   "main": "lib/index.js",
   "scripts": {
     "build": "tsc",
@@ -46,6 +46,20 @@
     "lib",
     "harmony",
     "src",
-    "./harmony.tar.gz"
-  ]
+    "./harmony.tar.gz",
+    "CHANGELOG.md",
+    "!build"
+  ],
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "homepage": "https://gitcode.com/CPF-RN/rntpc_react-native-reanimated",
+  "bugs": {
+    "url": "https://gitcode.com/CPF-RN/rntpc_react-native-reanimated/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://gitcode.com/CPF-RN/rntpc_react-native-reanimated.git"
+  }
 }