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

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

@@ -1,266 +1,266 @@
-// 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 <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: {
-        double sendData[] = {
-            data[0],
-            data[1],
-            data[2],
-        };
-        sensorInstance->runSensor(sendData);
-        return;
-    }
-    case SENSOR_TYPE_GYROSCOPE: {
-        double sendData[] = {
-            data[0],
-            data[1],
-            data[2],
-        };
-        sensorInstance->runSensor(sendData);
-        return;
-    }
-    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],
-        };
-        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
-        };
-        sensorInstance->runSensor(sendData);
-        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) {
-    if (value && setter_ && runOnTheMainThread_) {
-        runOnTheMainThread_([weakSelf = weak_from_this(), value]() {
-            auto self = weakSelf.lock();
-            if (!self) {
-                return;
-            }
-            self->setter_(value, 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(); }
+// 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 <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: {
+        double sendData[] = {
+            data[0],
+            data[1],
+            data[2],
+        };
+        sensorInstance->runSensor(sendData);
+        return;
+    }
+    case SENSOR_TYPE_GYROSCOPE: {
+        double sendData[] = {
+            data[0],
+            data[1],
+            data[2],
+        };
+        sensorInstance->runSensor(sendData);
+        return;
+    }
+    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],
+        };
+        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
+        };
+        sensorInstance->runSensor(sendData);
+        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) {
+    if (value && setter_ && runOnTheMainThread_) {
+        runOnTheMainThread_([weakSelf = weak_from_this(), value]() {
+            auto self = weakSelf.lock();
+            if (!self) {
+                return;
+            }
+            self->setter_(value, 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

@@ -1,36 +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);
-    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
+// 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);
+    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

@@ -1,36 +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);
-    }
-}
+// 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);
+    }
+}
 }