@react-native-ohos/react-native-sensors 7.2.2-rc.2

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2017 Daniel Schmidt
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,13 @@
+# @react-native-ohos/react-native-sensors
+
+This project is based on [react-native-sensors](https://github.com/react-native-sensors/react-native-sensors/tree/v7.2.1-rc.2)
+
+## Documentation
+
+- [中文](https://gitee.com/react-native-oh-library/usage-docs/blob/master/zh-cn/react-native-sensors.md)
+
+- [English](https://gitee.com/react-native-oh-library/usage-docs/blob/master/en/react-native-sensors.md)
+
+## License
+
+This project is licensed under [The MIT License (MIT)](https://github.com/react-native-sensors/react-native-sensors/blob/master/LICENSE), Please enjoy and participate 

package/harmony/sensors/Index.ets

@@ -0,0 +1,16 @@
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd.
+ * Licensed under the MIT License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     https://github.com/react-native-sensors/react-native-sensors/blob/master/LICENSE
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+ 
+export * from './ts'

package/harmony/sensors/build-profile.json5

@@ -0,0 +1,12 @@
+{
+  "apiType": "stageMode",
+  "buildOption": {
+  },
+  "buildOptionSet": [
+  ],
+  "targets": [
+    {
+      "name": "default"
+    }
+  ]
+}

package/harmony/sensors/hvigorfile.ts

@@ -0,0 +1,6 @@
+import { harTasks } from '@ohos/hvigor-ohos-plugin';
+
+export default {
+    system: harTasks,  /* Built-in plugin of Hvigor. It cannot be modified. */
+    plugins:[]         /* Custom plugin to extend the functionality of Hvigor. */
+}

package/harmony/sensors/oh-package.json5

@@ -0,0 +1,11 @@
+{
+  name: "@react-native-ohos/react-native-sensors",
+  version: "7.2.2-rc.2",
+  description: "Please describe the basic information.",
+  main: "Index.ets",
+  author: "",
+  license: "MIT License",
+  dependencies: {
+    "@rnoh/react-native-openharmony": "^0.72.38"
+  },
+}

package/harmony/sensors/src/main/cpp/CMakeLists.txt

@@ -0,0 +1,9 @@
+cmake_minimum_required(VERSION 3.13)
+set(CMAKE_VERBOSE_MAKEFILE on)
+
+set(rnoh_sensors_generated_dir "${CMAKE_CURRENT_SOURCE_DIR}/generated")
+file(GLOB_RECURSE rnoh_sensors_generated_SRC "${rnoh_sensors_generated_dir}/**/*.cpp")
+file(GLOB rnoh_sensors_SRC CONFIGURE_DEPENDS *.cpp)
+add_library(rnoh_sensors SHARED ${rnoh_sensors_SRC} ${rnoh_sensors_generated_SRC})
+target_include_directories(rnoh_sensors PUBLIC ${CMAKE_CURRENT_SOURCE_DIR} ${rnoh_sensors_generated_dir})
+target_link_libraries(rnoh_sensors PUBLIC rnoh)

package/harmony/sensors/src/main/cpp/SensorsPackage.h

@@ -0,0 +1,25 @@
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd.
+ * Licensed under the MIT License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     https://github.com/react-native-sensors/react-native-sensors/blob/master/LICENSE
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include "generated/RNOH/generated/BaseReactNativeSensorsPackage.h"
+
+namespace rnoh {
+class SensorsPackage : public BaseReactNativeSensorsPackage {
+    using Super = BaseReactNativeSensorsPackage;
+    using Super::Super;
+};
+} // namespace rnoh

package/harmony/sensors/src/main/cpp/generated/RNOH/generated/BaseReactNativeSensorsPackage.h

@@ -0,0 +1,30 @@
+/**
+ * This code was generated by "react-native codegen-lib-harmony"
+ */
+
+#pragma once
+
+#include "RNOH/Package.h"
+#include "RNOH/ArkTSTurboModule.h"
+#include "./turbo_modules/RTNSensors.h"
+
+namespace rnoh {
+    class BaseReactNativeSensorsPackageTurboModuleFactoryDelegate : public TurboModuleFactoryDelegate {
+    public:
+        SharedTurboModule createTurboModule(Context ctx, const std::string &name) const override  {
+            if (name == "RTNSensors") {
+                return std::make_shared<RTNSensors>(ctx, name);
+            }
+            return nullptr;
+        };
+    };
+
+    class BaseReactNativeSensorsPackage : public Package  {
+    public:
+          BaseReactNativeSensorsPackage(Package::Context ctx) : Package(ctx) {
+          };
+          std::unique_ptr<TurboModuleFactoryDelegate> createTurboModuleFactoryDelegate() override {
+          return std::make_unique<BaseReactNativeSensorsPackageTurboModuleFactoryDelegate>();
+        }
+    };
+} // namespace rnoh

package/harmony/sensors/src/main/cpp/generated/RNOH/generated/turbo_modules/RTNSensors.cpp

@@ -0,0 +1,25 @@
+/**
+ * This code was generated by "react-native codegen-lib-harmony"
+ */
+
+#include "RTNSensors.h"
+
+namespace rnoh {
+using namespace facebook;
+
+RTNSensors::RTNSensors(const ArkTSTurboModule::Context ctx, const std::string name) : ArkTSTurboModule(ctx, name) {
+    methodMap_ = {
+        ARK_METHOD_METADATA(accelerometer, 0),
+        ARK_METHOD_METADATA(gyroscope, 0),
+        ARK_METHOD_METADATA(magnetometer, 0),
+        ARK_METHOD_METADATA(barometer, 0),
+        ARK_METHOD_METADATA(orientation, 0),
+        ARK_METHOD_METADATA(gravity, 0),
+        ARK_METHOD_METADATA(off, 1),
+        ARK_METHOD_METADATA(setUpdateInterval, 2),
+        ARK_ASYNC_METHOD_METADATA(isAvailable, 1),
+        ARK_METHOD_METADATA(setLogLevel, 2),
+    };
+}
+
+} // namespace rnoh

package/harmony/sensors/src/main/cpp/generated/RNOH/generated/turbo_modules/RTNSensors.h

@@ -0,0 +1,20 @@
+/**
+ * This code was generated by "react-native codegen-lib-harmony"
+ */
+
+#ifndef SENSORMODULE_H
+#define SENSORMODULE_H
+
+#pragma once
+
+#include "RNOH/ArkTSTurboModule.h"
+
+namespace rnoh {
+
+class JSI_EXPORT RTNSensors : public ArkTSTurboModule {
+  public:
+    RTNSensors(const ArkTSTurboModule::Context ctx, const std::string name);
+};
+
+} // namespace rnoh
+#endif

package/harmony/sensors/src/main/ets/RTNSensorsTurboModule.ts

@@ -0,0 +1,276 @@
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd.
+ * Licensed under the MIT License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     https://github.com/react-native-sensors/react-native-sensors/blob/master/LICENSE
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { TurboModule, RNOHLogger, TurboModuleContext } from "@rnoh/react-native-openharmony/ts";
+import sensor from "@ohos.sensor";
+import BusinessError from "@ohos.base";
+
+import { RTNSensors } from "./generated/turboModules/RTNSensors";
+
+export class RTNSensorsTurboModule extends TurboModule implements RTNSensors.Spec {
+  private logger: RNOHLogger;
+  private sensorsInterval = new Map<string, number>([
+    ["accelerometer", 0],
+    ["gyroscope", 0],
+    ["magnetometer", 0],
+    ["barometer", 0],
+    ["orientation", 0],
+    ["gravity", 0],
+  ])
+  private sensorsLogLevel = new Map<string, number>([
+    ["accelerometer", 0],
+    ["gyroscope", 0],
+    ["magnetometer", 0],
+    ["barometer", 0],
+    ["orientation", 0],
+    ["gravity", 0],
+  ])
+  private sensorsId = new Map<string, sensor.SensorId>([
+    ["accelerometer", sensor.SensorId.ACCELEROMETER],
+    ["gyroscope", sensor.SensorId.GYROSCOPE],
+    ["magnetometer", sensor.SensorId.MAGNETIC_FIELD],
+    ["barometer", sensor.SensorId.BAROMETER],
+    ["orientation", sensor.SensorId.ORIENTATION],
+    ["gravity", sensor.SensorId.GRAVITY],
+  ])
+  
+  constructor(ctx: TurboModuleContext) {
+    super(ctx);
+    this.logger = ctx.logger.clone("Sensors");
+  }
+  accelerometer(interval: number): void {
+    try {
+       interval = this.sensorsInterval.get('accelerometer')!;
+      const logLevel: number = this.sensorsLogLevel.get("accelerometer")!;
+      sensor.on(sensor.SensorId.ACCELEROMETER, (data: sensor.AccelerometerResponse) => {
+        if (logLevel > 0) {
+          this.logger.clone('accelerometer').info(`accelerometer onCreate ${interval}`)
+        }
+        if (logLevel > 1) {
+          this.logger.clone('accelerometer').info(`accelerometer onCreate ${JSON.stringify({
+            x: data?.x,
+            y: data?.y,
+            z: data?.z,
+            timestamp: data?.timestamp
+          })}`)
+        }
+        this.ctx.rnInstance.emitDeviceEvent('accelerometerClick', {
+          x: data?.x,
+          y: data?.y,
+          z: data?.z,
+          timestamp: data?.timestamp
+        });
+      }, { interval: interval });
+    } catch (error) {
+      let e: BusinessError.BusinessError = error as BusinessError.BusinessError;
+      this.logger.clone('accelerometer').error(`Failed to invoke on. Code: ${e.code}, message: ${e.message}`);
+    }
+  }
+
+  gyroscope(interval: number): void {
+    try {
+       interval = this.sensorsInterval.get('gyroscope')!;
+      const logLevel: number = this.sensorsLogLevel.get("gyroscope")!;
+      sensor.on(sensor.SensorId.GYROSCOPE, (data: sensor.GyroscopeResponse) => {
+        if (logLevel > 0) {
+          this.logger.clone('gyroscope').info(`gyroscope onCreate ${interval}`)
+        }
+        if (logLevel > 1) {
+          this.logger.clone('gyroscope').info(`gyroscope onCreate ${JSON.stringify({
+            x: data?.x,
+            y: data?.y,
+            z: data?.z,
+            timestamp: data?.timestamp
+          })}`)
+        }
+        this.ctx.rnInstance.emitDeviceEvent('gyroscopeClick', {
+          x: data?.x,
+          y: data?.y,
+          z: data?.z,
+          timestamp: data?.timestamp
+        });
+      }, { interval: interval });
+    } catch (error) {
+      let e: BusinessError.BusinessError = error as BusinessError.BusinessError;
+      this.logger.clone('gyroscope').error(`Failed to invoke on. Code: ${e.code}, message: ${e.message}`);
+    }
+  }
+
+  magnetometer(interval: number): void {
+    try {
+       interval = this.sensorsInterval.get('magnetometer')!;
+      const logLevel: number = this.sensorsLogLevel.get("magnetometer")!;
+      sensor.on(sensor.SensorId.MAGNETIC_FIELD, (data: sensor.MagneticFieldResponse) => {
+        if (logLevel > 0) {
+          this.logger.clone('magnetometer').info(`magnetometer onCreate ${interval}`)
+        }
+        if (logLevel > 1) {
+          this.logger.clone('magnetometer').info(`magnetometer onCreate ${JSON.stringify({
+            x: data?.x,
+            y: data?.y,
+            z: data?.z,
+            timestamp: data?.timestamp
+          })}`)
+        }
+        this.ctx.rnInstance.emitDeviceEvent('magnetometerClick', {
+          x: data?.x,
+          y: data?.y,
+          z: data?.z,
+          timestamp: data?.timestamp
+        });
+      }, { interval: interval });
+    } catch (error) {
+      let e: BusinessError.BusinessError = error as BusinessError.BusinessError;
+      this.logger.clone('magnetometer').error(`Failed to invoke on. Code: ${e.code}, message: ${e.message}`);
+    }
+  }
+
+  barometer(interval: number): void {
+    try {
+       interval = this.sensorsInterval.get('barometer')!;
+      const logLevel: number = this.sensorsLogLevel.get("barometer")!;
+      sensor.on(sensor.SensorId.BAROMETER, (data: sensor.BarometerResponse) => {
+        if (logLevel > 0) {
+          this.logger.clone('barometer').info(`barometer onCreate ${interval}`)
+        }
+        if (logLevel > 1) {
+          this.logger.clone('barometer').info(`barometer onCreate ${JSON.stringify({
+            pressure: data?.pressure
+          })}`)
+        }
+        this.ctx.rnInstance.emitDeviceEvent('barometerClick', {
+          pressure: data?.pressure
+        });
+      }, { interval: interval });
+    } catch (error) {
+      let e: BusinessError.BusinessError = error as BusinessError.BusinessError;
+      this.logger.clone('barometer').error(`Failed to invoke on. Code: ${e.code}, message: ${e.message}`);
+    }
+  }
+
+  orientation(interval: number): void {
+    try {
+       interval = this.sensorsInterval.get('orientation')!;
+      const logLevel: number = this.sensorsLogLevel.get("orientation")!;
+      sensor.on(sensor.SensorId.ORIENTATION, (data: sensor.OrientationResponse) => {
+        if (logLevel > 0) {
+          this.logger.clone('orientation').info(`orientation onCreate ${interval}`)
+        }
+        if (logLevel > 1) {
+          this.logger.clone('orientation').info(`orientation onCreate ${JSON.stringify({
+            x: data?.beta,
+            y: data?.gamma,
+            z: data?.alpha,
+            timestamp: data?.timestamp
+          })}`)
+        }
+        this.ctx.rnInstance.emitDeviceEvent('orientationClick', {
+          x: data?.beta,
+          y: data?.gamma,
+          z: data?.alpha,
+          timestamp: data?.timestamp
+        });
+      }, { interval: interval });
+    } catch (error) {
+      let e: BusinessError.BusinessError = error as BusinessError.BusinessError;
+      this.logger.clone('orientation').error(`Failed to invoke on. Code: ${e.code}, message: ${e.message}`);
+    }
+  }
+
+  gravity(interval: number): void {
+    try {
+       interval = this.sensorsInterval.get('gravity')!;
+      const logLevel: number = this.sensorsLogLevel.get("gravity")!;
+      sensor.on(sensor.SensorId.GRAVITY, (data: sensor.GravityResponse) => {
+        if (logLevel > 0) {
+          this.logger.clone('gravity').info(`gravity onCreate ${interval}`)
+        }
+        if (logLevel > 1) {
+          this.logger.clone('gravity').info(`gravity onCreate ${JSON.stringify({
+            x: data?.x,
+            y: data?.y,
+            z: data?.z,
+            timestamp: data?.timestamp
+          })}`)
+        }
+        this.ctx.rnInstance.emitDeviceEvent('gravityClick', {
+          x: data?.x,
+          y: data?.y,
+          z: data?.z,
+          timestamp: data?.timestamp
+        });
+      }, { interval: interval });
+    } catch (error) {
+      let e: BusinessError.BusinessError = error as BusinessError.BusinessError;
+      this.logger.clone('gravity').error(`Failed to invoke on. Code: ${e.code}, message: ${e.message}`);
+    }
+  }
+
+  off(sensorType: string): void {
+    try {
+      switch (sensorType) {
+        case 'accelerometer':
+          sensor.off(sensor.SensorId.ACCELEROMETER);
+          break;
+        case 'gyroscope':
+          sensor.off(sensor.SensorId.GYROSCOPE);
+          break;
+        case 'magnetometer':
+          sensor.off(sensor.SensorId.MAGNETIC_FIELD);
+          break;
+        case 'barometer':
+          sensor.off(sensor.SensorId.BAROMETER);
+          break;
+        case 'orientation':
+          sensor.off(sensor.SensorId.ORIENTATION);
+          break;
+        case 'gravity':
+          sensor.off(sensor.SensorId.GRAVITY);
+          break;
+        default:
+      }
+    } catch (error) {
+      let e: BusinessError.BusinessError = error as BusinessError.BusinessError;
+      this.logger.clone(`${sensorType} off}`).error(`Failed to invoke on. Code: ${e.code}, message: ${e.message}`);
+    }
+  }
+
+  setUpdateInterval(sensorType: string, updateInterval: number): void {
+    updateInterval = updateInterval * 1000000;
+    this.sensorsInterval.set(
+      sensorType,
+      updateInterval
+    )
+  }
+
+  async isAvailable(sensorType: string): Promise<boolean> {
+    try {
+      const sensorsTypeId: sensor.SensorId = this.sensorsId.get(sensorType);
+      const sensorsTypeDetails: sensor.Sensor = await sensor.getSingleSensor(sensorsTypeId);
+      return new Promise((resolve) => resolve(!!sensorsTypeDetails?.sensorId))
+    } catch (error) {
+      let e: BusinessError.BusinessError = error as BusinessError.BusinessError;
+      this.logger.clone(`${sensorType} isAvailable}`).error(`Failed to invoke on. Code: ${e.code}, message: ${e.message}`);
+      return new Promise((resolve) => resolve(false))
+    }
+  }
+
+  setLogLevel(sensorType: string, logLevel: number): void {
+    this.sensorsLogLevel.set(
+      sensorType,
+      logLevel
+    )
+  }
+}

package/harmony/sensors/src/main/ets/SensorsPackage.ts

@@ -0,0 +1,37 @@
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd.
+ * Licensed under the MIT License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     https://github.com/react-native-sensors/react-native-sensors/blob/master/LICENSE
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { RNPackage, TurboModulesFactory } from '@rnoh/react-native-openharmony/ts';
+import type { TurboModule, TurboModuleContext } from '@rnoh/react-native-openharmony/ts';
+import { RTNSensorsTurboModule } from './RTNSensorsTurboModule';
+
+class SensorsModulesFactory extends TurboModulesFactory {
+  createTurboModule(name: string): TurboModule | null {
+    if (name === 'RTNSensors') {
+      return new RTNSensorsTurboModule(this.ctx)
+    }
+    return null;
+  }
+
+  hasTurboModule(name: string): boolean {
+    return name === 'RTNSensors';
+  }
+}
+
+export class SensorsPackage extends RNPackage {
+  createTurboModulesFactory(ctx: TurboModuleContext): TurboModulesFactory {
+    return new SensorsModulesFactory(ctx);
+  }
+}

package/harmony/sensors/src/main/ets/generated/components/ts.ts

@@ -0,0 +1,5 @@
+
+/**
+ */
+
+export {}

package/harmony/sensors/src/main/ets/generated/index.ets

@@ -0,0 +1,5 @@
+/**
+ * This code was generated by "react-native codegen-lib-harmony"
+ */
+
+export * from "./ts"

package/harmony/sensors/src/main/ets/generated/ts.ts

@@ -0,0 +1,6 @@
+/**
+ * This code was generated by "react-native codegen-lib-harmony"
+ */
+
+export * as RNC from "./components/ts"
+export * as TM from "./turboModules/ts"

package/harmony/sensors/src/main/ets/generated/turboModules/RTNSensors.ts

@@ -0,0 +1,30 @@
+/**
+ * This code was generated by "react-native codegen-lib-harmony"
+ */
+
+export namespace RTNSensors {
+  export const NAME = 'RTNSensors' as const
+
+  export interface Spec {
+    accelerometer(interval: number): void;
+
+    gyroscope(interval: number): void;
+
+    magnetometer(interval: number): void;
+
+    barometer(interval: number): void;
+
+    orientation(interval: number): void;
+
+    gravity(interval: number): void;
+
+    off(sensorType: string): void;
+
+    setUpdateInterval(sensorType: string, updateInterval: number): void;
+
+    isAvailable(sensorType: string): Promise<boolean>;
+
+    setLogLevel(sensorType: string, logLevel: number): void;
+
+  }
+}

package/harmony/sensors/src/main/ets/generated/turboModules/ts.ts

@@ -0,0 +1,5 @@
+/**
+ * This code was generated by "react-native codegen-lib-harmony"
+ */
+
+export * from "./RTNSensors"

package/harmony/sensors/src/main/module.json5

@@ -0,0 +1,9 @@
+{
+  "module": {
+    "name": "sensors",
+    "type": "har",
+    "deviceTypes": [
+      "default",
+    ]
+  }
+}

package/harmony/sensors/src/main/resources/base/element/string.json

@@ -0,0 +1,8 @@
+{
+  "string": [
+    {
+      "name": "page_show",
+      "value": "page from package"
+    }
+  ]
+}

package/harmony/sensors/src/main/resources/en_US/element/string.json

@@ -0,0 +1,8 @@
+{
+  "string": [
+    {
+      "name": "page_show",
+      "value": "page from package"
+    }
+  ]
+}

package/harmony/sensors/src/main/resources/zh_CN/element/string.json

@@ -0,0 +1,8 @@
+{
+  "string": [
+    {
+      "name": "page_show",
+      "value": "page from package"
+    }
+  ]
+}

package/harmony/sensors/ts.ts

@@ -0,0 +1,17 @@
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd.
+ * Licensed under the MIT License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     https://github.com/react-native-sensors/react-native-sensors/blob/master/LICENSE
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+export * from './src/main/ets/RTNSensorsTurboModule'
+export * from './src/main/ets/SensorsPackage'

package/index.d.ts

@@ -0,0 +1,69 @@
+declare module "react-native-sensors" {
+  import { Observable } from "rxjs";
+
+  type Sensors = {
+    accelerometer: "accelerometer";
+    gyroscope: "gyroscope";
+    magnetometer: "magnetometer";
+    barometer: "barometer";
+    orientation: "orientation";
+    gravity: "gravity";
+  };
+
+  export const SensorTypes: Sensors;
+
+  export const setUpdateIntervalForType: (
+    type: keyof Sensors,
+    updateInterval: number
+  ) => void;
+
+  export const setLogLevelForType: (
+    type: keyof Sensors,
+    logLevel: 0 | 1 | 2
+  ) => void;
+
+  export interface SensorData {
+    x: number;
+    y: number;
+    z: number;
+    timestamp: number;
+  }
+
+  export interface BarometerData {
+    pressure: number;
+    timestamp: number;
+  }
+
+  export interface OrientationData {
+    qx: number;
+    qy: number;
+    qz: number;
+    qw: number;
+    pitch: number;
+    roll: number;
+    yaw: number;
+    timestamp: number;
+  }
+
+  type SensorsBase = {
+    accelerometer: Observable<SensorData>;
+    gyroscope: Observable<SensorData>;
+    magnetometer: Observable<SensorData>;
+    barometer: Observable<BarometerData>;
+    orientation: Observable<OrientationData>;
+    gravity: Observable<SensorData>;
+  };
+
+  export const {
+    accelerometer,
+    gyroscope,
+    magnetometer,
+    barometer,
+    orientation,
+    gravity,
+  }: SensorsBase;
+
+  const sensors: SensorsBase;
+
+  export default sensors;
+}

package/index.js

@@ -0,0 +1,14 @@
+import sensors from "./src/sensors";
+export { setUpdateInterval as setUpdateIntervalForType, setLogLevelForType } from "./src/rnsensors";
+
+export const SensorTypes = {
+  accelerometer: "accelerometer",
+  gyroscope: "gyroscope",
+  magnetometer: "magnetometer",
+  barometer: "barometer",
+  orientation: "orientation",
+  gravity: "gravity"
+};
+
+export const { accelerometer, gyroscope, magnetometer, barometer, orientation, gravity } = sensors;
+export default sensors;

package/package.json

@@ -0,0 +1,88 @@
+{
+  "name": "@react-native-ohos/react-native-sensors",
+  "version": "7.2.2-rc.2",
+  "description": "A developer friendly approach for sensors in react-native",
+  "scripts": {
+    "contributor:add": "all-contributors add",
+    "postcontributor:add": "npm run contributor:generate",
+    "contributor:generate": "all-contributors generate",
+    "postcontributor:generate": "npm run format",
+    "format": "prettier --write ./src/*",
+    "test": "prettier --check ./src/*",
+    "semantic-release": "semantic-release",
+    "codegen-lib": "react-native codegen-lib-harmony --no-safety-check --npm-package-name react-native-sensors --cpp-output-path ./harmony/sensors/src/main/cpp/generated --ets-output-path ./harmony/sensors/src/main/ets/generated --turbo-modules-spec-paths ./src/NativeSensors.ts",
+    "travis-deploy-once": "travis-deploy-once"
+  },
+  "main": "index.js",
+  "types": "index.d.ts",
+  "repository": "git@github.com:react-native-sensors/react-native-sensors.git",
+  "homepage": "https://github.com/react-native-sensors/react-native-sensors",
+  "keywords": [
+    "react-native",
+    "harmony"
+  ],
+  "author": {
+    "name": "Daniel Schmidt",
+    "email": "danielmschmidt92@gmail.com",
+    "url": "http://danielmschmidt.de"
+  },
+  "husky": {
+    "hooks": {
+      "pre-commit": "pretty-quick --staged"
+    }
+  },
+  "jest": {
+    "timers": "fake",
+    "projects": [
+      {
+        "displayName": "Unit",
+        "testEnvironment": "node",
+        "testPathIgnorePatterns": [
+          "tests/*"
+        ],
+        "timers": "fake"
+      }
+    ]
+  },
+  "babel": {
+    "presets": [
+      "react-native"
+    ]
+  },
+  "license": "MIT",
+  "dependencies": {
+    "rxjs": ">= 6"
+  },
+  "devDependencies": {
+    "all-contributors-cli": "6.1.2",
+    "babel-core": "6.26.3",
+    "babel-jest": "24.1.0",
+    "babel-preset-react-native": "4.0.0",
+    "husky": "4.2.3",
+    "jest": "24.1.0",
+    "metro-config": "^0.67.0",
+    "prettier": "2.2.1",
+    "pretty-quick": "3.1.0",
+    "react": "^17.0.2",
+    "react-native": "^0.68.0",
+    "regenerator-runtime": "0.13.1",
+    "rxjs-marbles": "5.0.0",
+    "semantic-release": "17.3.9",
+    "react-native-harmony-cli": "npm:@react-native-oh/react-native-harmony-cli@^0.0.27",
+    "travis-deploy-once": "5.0.11"
+  },
+  "harmony": {
+    "alias": "react-native-sensors"
+  },
+  "files": [
+    "src",
+    "harmony",
+    "LICENSE",
+    "README.md",
+    "index.*"
+  ],
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org/",
+     "access": "public"
+  }
+}

package/src/NativeSensors.ts

@@ -0,0 +1,31 @@
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd.
+ * Licensed under the MIT License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     https://github.com/react-native-sensors/react-native-sensors/blob/master/LICENSE
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import type { TurboModule } from "react-native/Libraries/TurboModule/RCTExport";
+import { TurboModuleRegistry } from "react-native";
+
+export interface Spec extends TurboModule {
+  accelerometer(interval?: number): void;
+  gyroscope(interval?: number): void;
+  magnetometer(interval?: number): void;
+  barometer(interval?: number): void;
+  orientation(interval?: number): void;
+  gravity(interval?: number): void;
+  off(sensorType: string): void;
+  setUpdateInterval(sensorType: string, updateInterval: number): void;
+  isAvailable(sensorType: string): Promise<boolean>;
+  setLogLevel(sensorType: string, logLevel: number): void;
+}
+export default TurboModuleRegistry.get<Spec>("RTNSensors") as Spec | null;

package/src/rnsensors.js

@@ -0,0 +1,49 @@
+import RTNSensors from "./NativeSensors";
+// Cache the availability of sensors
+const availableSensors = {};
+
+export function start(type) {
+  switch (type) {
+    case 'accelerometer':
+      RTNSensors.accelerometer();
+      break;
+    case 'gyroscope':
+      RTNSensors.gyroscope();
+      break;
+    case 'magnetometer':
+      RTNSensors.magnetometer();
+      break;
+    case 'barometer':
+      RTNSensors.barometer();
+      break;
+    case 'orientation':
+      RTNSensors.orientation();
+      break;
+    case 'gravity':
+      RTNSensors.gravity();
+      break;
+    default:
+  }
+}
+
+export function isAvailable(type) {
+  if (availableSensors[type]) {
+    return availableSensors[type];
+  }
+  const promise = RTNSensors.isAvailable(type);
+  availableSensors[type] = promise;
+
+  return promise;
+}
+
+export function stop(type) {
+  RTNSensors.off(type);
+}
+
+export function setUpdateInterval(type, updateInterval) {
+  RTNSensors.setUpdateInterval(type, updateInterval);
+}
+
+export function setLogLevelForType(type, level) {
+  RTNSensors.setLogLevel(type, level);
+}

package/src/sensors.js

@@ -0,0 +1,76 @@
+import { DeviceEventEmitter } from "react-native";
+import { Observable } from "rxjs";
+import { publish, refCount } from "rxjs/operators";
+import * as RNSensors from "./rnsensors";
+
+const listenerKeys = new Map([
+  ["accelerometer", "Accelerometer"],
+  ["gyroscope", "Gyroscope"],
+  ["magnetometer", "Magnetometer"],
+  ["barometer", "Barometer"],
+  ["orientation", "Orientation"],
+  ["gravity", "gravityClick"],
+]);
+
+const eventEmitterSubscription = new Map([
+  ["accelerometer", null],
+  ["gyroscope", null],
+  ["magnetometer", null],
+  ["barometer", null],
+  ["orientation", null],
+  ["gravity", null],
+]);
+
+function createSensorObservable(sensorType) {
+  return Observable.create(function subscribe(observer) {
+    this.isSensorAvailable = false;
+    this.unsubscribeCallback = () => {
+      if (!this.isSensorAvailable) return;
+      if (eventEmitterSubscription.get(sensorType))
+        eventEmitterSubscription.get(sensorType).remove();
+      RNSensors.stop(sensorType);
+      RNSensors.setUpdateInterval(sensorType, 0);
+      RNSensors.setLogLevelForType(sensorType, 0);
+    };
+    RNSensors.isAvailable(sensorType).then((res) => {
+      this.isSensorAvailable = true;
+      if (!res) {
+        observer.error(`Sensors${sensorType} is not available`);
+        return;
+      } else {
+        RNSensors.start(sensorType);
+        eventEmitterSubscription.set(
+          sensorType,
+          DeviceEventEmitter.addListener(
+            listenerKeys.get(sensorType),
+            (date) => {
+              observer.next(date);
+            }
+          )
+        );
+      }
+    });
+    return this.unsubscribeCallback;
+  }).pipe(makeSingleton());
+}
+
+// As we only have one sensor we need to share it between the different consumers
+function makeSingleton() {
+  return (source) => source.pipe(publish(), refCount());
+}
+
+const accelerometer = createSensorObservable("accelerometer");
+const gyroscope = createSensorObservable("gyroscope");
+const magnetometer = createSensorObservable("magnetometer");
+const barometer = createSensorObservable("barometer");
+const orientation = createSensorObservable("orientation");
+const gravity = createSensorObservable("gravity");
+
+export default {
+  gyroscope,
+  accelerometer,
+  magnetometer,
+  barometer,
+  orientation,
+  gravity,
+};