@react-native-ohos/react-native-reanimated 3.18.1-rc.6 → 4.0.0-rc.1

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

@@ -0,0 +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(); }
+}

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);
+    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/ReanimatedUIScheduler.h

@@ -4,17 +4,17 @@
 
 #pragma once
 #include <functional>
-#include <UIScheduler.h>
+//#include <UIScheduler.h>
 #include <memory>
 #include "RNOH/TaskExecutor/TaskExecutor.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

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

@@ -5,18 +5,22 @@
 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"
 
 export class ReanimatedModule extends UITurboModule {
   static NAME = "ReanimatedModule"
   private logger: RNOHLogger
   private keyBordHeight = 0;
 
-  constructor(ctx:  UITurboModuleContext) {
+  constructor(ctx: UITurboModuleContext) {
     super(ctx);
     this.logger = ctx.logger.clone("Reanimated");
   }
+
   public setViewProps(tag: Tag, props: Object) {
     this.ctx.descriptorRegistry.setAnimatedRawProps(tag, props);
+
   }
 
   public async subscribeKeyBordListeners() {
@@ -38,4 +42,11 @@ export class ReanimatedModule extends UITurboModule {
     windowInstance.off('keyboardHeightChange', (v) => {
     })
   }
+
+  public setGestureHandlerState(handlerTag: Tag, newState: number) {
+    const module = this.ctx.rnInstance.getTurboModule("RNGestureHandlerModule") as any;
+    if (module && module.setGestureHandlerState) {
+      module.setGestureHandlerState(handlerTag, newState);
+    }
+  }
 }

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

@@ -5,20 +5,17 @@
 import { RNPackage, UITurboModuleContext, TurboModulesFactory } from "@rnoh/react-native-openharmony/ts";
 import type { UITurboModule } from "@rnoh/react-native-openharmony/ts";
 import { ReanimatedModule } from './ReanimatedModule';
-import { WorkletsModule } from './WorkletsModule';
 
 class ReanimatedTurboModulesFactory extends TurboModulesFactory {
   createTurboModule(name: string): UITurboModule | null {
     if (name === ReanimatedModule.NAME) {
       return new ReanimatedModule(this.ctx);
-    } else if (name === WorkletsModule.NAME) {
-      return new WorkletsModule(this.ctx);
     }
     return null;
   }
 
   hasTurboModule(name: string): boolean {
-    return name === 'ReanimatedModule' || name === 'WorkletsModule';
+    return name === 'ReanimatedModule';
   }
 }
 

package/package.json

@@ -4,7 +4,7 @@
     "alias": "react-native-reanimated",
     "redirectInternalImports": true
   },
-  "version": "3.18.1-rc.6",
+  "version": "4.0.0-rc.1",
   "description": "",
   "main": "lib/index.js",
   "scripts": {
@@ -18,33 +18,51 @@
   "peerDependencies": {
     "react": "*",
     "react-native": "*",
-    "react-native-harmony": "*",
-    "react-native-reanimated": "3.18.0"
+    "react-native-reanimated": "4.2.1"
   },
   "author": "",
   "license": "ISC",
   "dependencies": {
-    "@types/node": "^20.11.4",
-    "react-native-reanimated": "3.18.0"
+	"@types/node": "^24.0.14",
+    "react-native-reanimated": "4.2.1"
   },
   "devDependencies": {
-    "@babel/cli": "^7.23.4",
-    "@babel/core": "^7.23.7",
-    "@babel/preset-env": "^7.23.8",
-    "@babel/preset-typescript": "^7.23.3",
-    "@babel/runtime": "^7.23.8",
-    "@types/invariant": "^2.2.35",
-    "@types/react": "^18.2.15",
-    "metro-react-native-babel-preset": "^0.77.0",
-    "react": "18.3.1",
-    "react-native": "0.77.1",
-    "react-native-builder-bob": "^0.21.3",
-    "typescript": "^5.1.6"
+    "@babel/core": "7.28.4",
+    "@babel/preset-env": "7.28.3",
+    "@react-native/babel-preset": "0.82.0",
+    "@react-native/eslint-config": "0.82.0",
+    "@react-native/metro-config": "0.82.0",
+    "@react-native/typescript-config": "0.82.0",
+    "@testing-library/jest-native": "5.4.3",
+    "@testing-library/react-hooks": "8.0.1",
+    "@testing-library/react-native": "13.3.3",
+    "@types/convert-source-map": "2.0.3",
+    "@types/jest": "30.0.0",
+    "@types/node": "24.0.14",
+    "@types/react": "19.2.2",
+    "@types/react-test-renderer": "19.1.0",
+    "@types/semver": "7.7.1",
+    "clang-format-node": "1.3.5",
+    "eslint": "9.37.0",
+    "jest": "30.2.0",
+    "knip": "5.61.3",
+    "madge": "8.0.0",
+    "prettier": "3.6.2",
+    "react": "19.1.1",
+    "react-dom": "19.1.1",
+    "react-native": "0.82.0",
+    "react-native-builder-bob": "0.40.13",
+    "react-native-web": "0.21.1",
+    "react-native-worklets": "0.7.1",
+    "react-test-renderer": "19.1.1",
+    "typescript": "5.8.3"
   },
   "files": [
     "lib",
     "harmony",
+	"scripts",
     "src",
-    "./harmony.tar.gz"
+    "./harmony.tar.gz",
+	"compatibility.json"
   ]
 }