@react-native-ohos/react-native-reanimated 3.18.2 → 3.18.3

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/WorkletsModule.cpp

@@ -1,61 +1,61 @@
-// 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 "ReanimatedUIScheduler.h"
-#include "WorkletsModule.h"
-#include "RNRuntimeWorkletDecorator.h"
-#include "PlatformLogger.h"
-
-using namespace facebook;
-namespace worklets {
-jsi::Value installTurboModule(facebook::jsi::Runtime &rt, react::TurboModule &turboModule,
-    const facebook::jsi::Value *args, size_t count)
-{
-    auto self = static_cast<WorkletsModule *>(&turboModule);
-    if (count < 1) {
-        LOG(ERROR) << "WorkletsModule: Missing required argument";
-        return facebook::jsi::Value(false);
-    }
-    if (!args[0].isString()) {
-        LOG(ERROR) << "WorkletsModule: First argument must be a string";
-        return facebook::jsi::Value(false);
-    }
-
-    std::string valueUnpackerCode = args[0].getString(rt).utf8(rt);
-    if (self == nullptr) { 
-        return facebook::jsi::Value::undefined();
-    }
-    self->installTurboModule(rt, valueUnpackerCode);
-    return facebook::jsi::Value(true);
-}
-
-WorkletsModule::WorkletsModule(const ArkTSTurboModule::Context ctx, const std::string name)
-    : ArkTSTurboModule(ctx, name)
-{
-    methodMap_ = { { "installTurboModule", { 0, worklets::installTurboModule } } };
-}
-
-WorkletsModule::~WorkletsModule()
-{
-    LOG(INFO) << "WorkletsModule::~WorkletsModule";
-}
-
-void WorkletsModule::installTurboModule(facebook::jsi::Runtime &runtime, std::string valueUnpackerCode)
-{
-    if (workletsModuleProxy_) {
-        LOG(WARNING) << "WorkletsModuleProxy already initialized";
-        return;
-    }
-
-    workletsModuleProxy_ = std::make_shared<WorkletsModuleProxy>(valueUnpackerCode, m_ctx.jsQueue, jsInvoker_,
-        std::make_shared<worklets::JSScheduler>(runtime, jsInvoker_),
-        std::make_shared<rnoh::ReanimatedUIScheduler>(m_ctx.taskExecutor));
-    RNRuntimeWorkletDecorator::decorate(runtime, workletsModuleProxy_);
-}
-std::shared_ptr<worklets::WorkletsModuleProxy> WorkletsModule::getWorkletsModuleProxy()
-{
-    return workletsModuleProxy_;
-}
+// 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 "ReanimatedUIScheduler.h"
+#include "WorkletsModule.h"
+#include "RNRuntimeWorkletDecorator.h"
+#include "PlatformLogger.h"
+
+using namespace facebook;
+namespace worklets {
+jsi::Value installTurboModule(facebook::jsi::Runtime &rt, react::TurboModule &turboModule,
+    const facebook::jsi::Value *args, size_t count)
+{
+    auto self = static_cast<WorkletsModule *>(&turboModule);
+    if (count < 1) {
+        LOG(ERROR) << "WorkletsModule: Missing required argument";
+        return facebook::jsi::Value(false);
+    }
+    if (!args[0].isString()) {
+        LOG(ERROR) << "WorkletsModule: First argument must be a string";
+        return facebook::jsi::Value(false);
+    }
+
+    std::string valueUnpackerCode = args[0].getString(rt).utf8(rt);
+    if (self == nullptr) { 
+        return facebook::jsi::Value::undefined();
+    }
+    self->installTurboModule(rt, valueUnpackerCode);
+    return facebook::jsi::Value(true);
+}
+
+WorkletsModule::WorkletsModule(const ArkTSTurboModule::Context ctx, const std::string name)
+    : ArkTSTurboModule(ctx, name)
+{
+    methodMap_ = { { "installTurboModule", { 0, worklets::installTurboModule } } };
+}
+
+WorkletsModule::~WorkletsModule()
+{
+    LOG(INFO) << "WorkletsModule::~WorkletsModule";
+}
+
+void WorkletsModule::installTurboModule(facebook::jsi::Runtime &runtime, std::string valueUnpackerCode)
+{
+    if (workletsModuleProxy_) {
+        LOG(WARNING) << "WorkletsModuleProxy already initialized";
+        return;
+    }
+
+    workletsModuleProxy_ = std::make_shared<WorkletsModuleProxy>(valueUnpackerCode, m_ctx.jsQueue, jsInvoker_,
+        std::make_shared<worklets::JSScheduler>(runtime, jsInvoker_),
+        std::make_shared<rnoh::ReanimatedUIScheduler>(m_ctx.taskExecutor));
+    RNRuntimeWorkletDecorator::decorate(runtime, workletsModuleProxy_);
+}
+std::shared_ptr<worklets::WorkletsModuleProxy> WorkletsModule::getWorkletsModuleProxy()
+{
+    return workletsModuleProxy_;
+}
 } // namespace worklets

package/harmony/reanimated/src/main/cpp/patches/AnimatedSensor/AnimatedSensorModule.cpp

@@ -1,89 +1,89 @@
-#include <reanimated/AnimatedSensor/AnimatedSensorModule.h>
-
-#include <utility>
-
-namespace reanimated {
-
-AnimatedSensorModule::AnimatedSensorModule(
-    const PlatformDepMethodsHolder &platformDepMethodsHolder)
-    : platformRegisterSensorFunction_(platformDepMethodsHolder.registerSensor),
-      platformUnregisterSensorFunction_(
-          platformDepMethodsHolder.unregisterSensor) {}
-
-AnimatedSensorModule::~AnimatedSensorModule() {
-  assert(sensorsIds_.empty());
-}
-
-jsi::Value AnimatedSensorModule::registerSensor(
-    jsi::Runtime &rt,
-    const std::shared_ptr<WorkletRuntime> &uiWorkletRuntime,
-    const jsi::Value &sensorTypeValue,
-    const jsi::Value &interval,
-    const jsi::Value &iosReferenceFrame,
-    const jsi::Value &sensorDataHandler) {
-  SensorType sensorType = static_cast<SensorType>(sensorTypeValue.asNumber());
-
-  auto shareableHandler = extractShareableOrThrow<ShareableWorklet>(
-      rt,
-      sensorDataHandler,
-      "[Reanimated] Sensor event handler must be a worklet.");
-
-  int sensorId = platformRegisterSensorFunction_(
-      sensorType,
-      interval.asNumber(),
-      iosReferenceFrame.asNumber(),
-      [sensorType,
-       shareableHandler,
-       weakUiWorkletRuntime = std::weak_ptr<WorkletRuntime>(uiWorkletRuntime)](
-          double newValues[], int orientationDegrees) {
-        auto uiWorkletRuntime = weakUiWorkletRuntime.lock();
-        if (uiWorkletRuntime == nullptr) {
-          return;
-        }
-
-        jsi::Runtime &uiRuntime = uiWorkletRuntime->getJSIRuntime();
-        jsi::Object value(uiRuntime);
-        if (sensorType == SensorType::ROTATION_VECTOR) {
-          // TODO: timestamp should be provided by the platform implementation
-          // such that the native side has a chance of providing a true event
-          // timestamp
-          value.setProperty(uiRuntime, "qx", newValues[0]);
-          value.setProperty(uiRuntime, "qy", newValues[1]);
-          value.setProperty(uiRuntime, "qz", newValues[2]);
-          value.setProperty(uiRuntime, "qw", newValues[3]);
-          value.setProperty(uiRuntime, "yaw", newValues[4]);
-          value.setProperty(uiRuntime, "pitch", newValues[5]);
-          value.setProperty(uiRuntime, "roll", newValues[6]);
-        } else {
-          value.setProperty(uiRuntime, "x", newValues[0]);
-          value.setProperty(uiRuntime, "y", newValues[1]);
-          value.setProperty(uiRuntime, "z", newValues[2]);
-        }
-        value.setProperty(
-            uiRuntime, "interfaceOrientation", orientationDegrees);
-
-        uiWorkletRuntime->runGuarded(shareableHandler, value);
-      });
-  if (sensorId != -1) {
-    sensorsIds_.insert(sensorId);
-  }
-  return jsi::Value(sensorId);
-}
-
-void AnimatedSensorModule::unregisterSensor(const jsi::Value &sensorId) {
-  // It is called during sensor hook unmounting
-  if (!sensorId.isNumber()) {
-    return;
-  }
-  sensorsIds_.erase(sensorId.getNumber());
-  platformUnregisterSensorFunction_(sensorId.asNumber());
-}
-
-void AnimatedSensorModule::unregisterAllSensors() {
-  for (auto sensorId : sensorsIds_) {
-    platformUnregisterSensorFunction_(sensorId);
-  }
-  sensorsIds_.clear();
-}
-
-} // namespace reanimated
+#include <reanimated/AnimatedSensor/AnimatedSensorModule.h>
+
+#include <utility>
+
+namespace reanimated {
+
+AnimatedSensorModule::AnimatedSensorModule(
+    const PlatformDepMethodsHolder &platformDepMethodsHolder)
+    : platformRegisterSensorFunction_(platformDepMethodsHolder.registerSensor),
+      platformUnregisterSensorFunction_(
+          platformDepMethodsHolder.unregisterSensor) {}
+
+AnimatedSensorModule::~AnimatedSensorModule() {
+  assert(sensorsIds_.empty());
+}
+
+jsi::Value AnimatedSensorModule::registerSensor(
+    jsi::Runtime &rt,
+    const std::shared_ptr<WorkletRuntime> &uiWorkletRuntime,
+    const jsi::Value &sensorTypeValue,
+    const jsi::Value &interval,
+    const jsi::Value &iosReferenceFrame,
+    const jsi::Value &sensorDataHandler) {
+  SensorType sensorType = static_cast<SensorType>(sensorTypeValue.asNumber());
+
+  auto shareableHandler = extractShareableOrThrow<ShareableWorklet>(
+      rt,
+      sensorDataHandler,
+      "[Reanimated] Sensor event handler must be a worklet.");
+
+  int sensorId = platformRegisterSensorFunction_(
+      sensorType,
+      interval.asNumber(),
+      iosReferenceFrame.asNumber(),
+      [sensorType,
+       shareableHandler,
+       weakUiWorkletRuntime = std::weak_ptr<WorkletRuntime>(uiWorkletRuntime)](
+          double newValues[], int orientationDegrees) {
+        auto uiWorkletRuntime = weakUiWorkletRuntime.lock();
+        if (uiWorkletRuntime == nullptr) {
+          return;
+        }
+
+        jsi::Runtime &uiRuntime = uiWorkletRuntime->getJSIRuntime();
+        jsi::Object value(uiRuntime);
+        if (sensorType == SensorType::ROTATION_VECTOR) {
+          // TODO: timestamp should be provided by the platform implementation
+          // such that the native side has a chance of providing a true event
+          // timestamp
+          value.setProperty(uiRuntime, "qx", newValues[0]);
+          value.setProperty(uiRuntime, "qy", newValues[1]);
+          value.setProperty(uiRuntime, "qz", newValues[2]);
+          value.setProperty(uiRuntime, "qw", newValues[3]);
+          value.setProperty(uiRuntime, "yaw", newValues[4]);
+          value.setProperty(uiRuntime, "pitch", newValues[5]);
+          value.setProperty(uiRuntime, "roll", newValues[6]);
+        } else {
+          value.setProperty(uiRuntime, "x", newValues[0]);
+          value.setProperty(uiRuntime, "y", newValues[1]);
+          value.setProperty(uiRuntime, "z", newValues[2]);
+        }
+        value.setProperty(
+            uiRuntime, "interfaceOrientation", orientationDegrees);
+
+        uiWorkletRuntime->runGuarded(shareableHandler, value);
+      });
+  if (sensorId != -1) {
+    sensorsIds_.insert(sensorId);
+  }
+  return jsi::Value(sensorId);
+}
+
+void AnimatedSensorModule::unregisterSensor(const jsi::Value &sensorId) {
+  // It is called during sensor hook unmounting
+  if (!sensorId.isNumber()) {
+    return;
+  }
+  sensorsIds_.erase(sensorId.getNumber());
+  platformUnregisterSensorFunction_(sensorId.asNumber());
+}
+
+void AnimatedSensorModule::unregisterAllSensors() {
+  for (auto sensorId : sensorsIds_) {
+    platformUnregisterSensorFunction_(sensorId);
+  }
+  sensorsIds_.clear();
+}
+
+} // namespace reanimated