From 8dddef8528362cf10f55032626d11e2d35b9a69d Mon Sep 17 00:00:00 2001 From: wanghao Date: Mon, 9 Oct 2023 14:43:46 +0800 Subject: [PATCH 1/5] =?UTF-8?q?[add]=20=E6=B7=BB=E5=8A=A0qtsensors?= =?UTF-8?q?=E6=A8=A1=E5=9D=97=E8=A1=A5=E4=B8=81?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- patch/qtsensor.patch | 1339 ++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 1339 insertions(+) create mode 100644 patch/qtsensor.patch diff --git a/patch/qtsensor.patch b/patch/qtsensor.patch new file mode 100644 index 0000000000..27f1499543 --- /dev/null +++ b/patch/qtsensor.patch @@ -0,0 +1,1339 @@ +diff --git a/src/openharmony/native/QtSensors.ts b/src/openharmony/native/QtSensors.ts +new file mode 100644 +index 00000000..8c7ad9a0 +--- /dev/null ++++ b/src/openharmony/native/QtSensors.ts +@@ -0,0 +1,132 @@ ++import sensor from '@ohos.sensor'; ++import qtsensorsplugin from 'libplugins_sensors_qtsensors_openharmony.so'; ++ ++export class QtSensors { ++ private pointerId = 0; ++ ++ public constructor(id) { ++ this.pointerId = id; ++ } ++ ++ /* Hz转ns,周期为1 */ ++ private hertz2ns(rate: Number) { ++ /* f=1/T （其中f是指赫兹,T是指以秒为单位的时间）*/ ++ let ns = (1 / Number(rate)) * 1000000000; ++ return ns; ++ } ++ ++ /* ns转Hz,周期为1 */ ++ private ns2hertz(ns: Number) { ++ /* f=1/T （其中f是指赫兹,T是指以秒为单位的时间）*/ ++ let hz = 1 / (Number(ns) / 1000000000); ++ return hz; ++ } ++ ++ createSensor(name, p) { ++ let server = new QtSensors(p); ++ Reflect.defineProperty(globalThis, name, { value: server }); ++ return true; ++ } ++ ++ destroySensor(name: string) { ++ Reflect.deleteProperty(globalThis, name); ++ this.pointerId = 0; ++ return true; ++ } ++ ++ /* 获取所有传感器类型Id */ ++ async sensorIds() { ++ let s: Array = new Array(); ++ try { ++ let sr = await sensor.getSensorList(); ++ for (let data of sr) { ++ s.push(String(data.sensorId)); ++ } ++ } catch (e) { ++ console.error(`Failed to get sensorList. Code: ${e.code}, message: ${e.message}`); ++ } ++ return s; ++ } ++ ++ stop(type: sensor.SensorId) { ++ try { ++ sensor.off(Number(type)); ++ } catch (error) { ++ console.error(`Failed to invoke off. Code: ${error.code}, message: ${error.message}`); ++ } ++ } ++ ++ /* 开始订阅传感器数据 */ ++ async start(type: sensor.SensorId, rate: Number) { ++ try { ++ this.stop(type); ++ let ns = this.hertz2ns(rate); ++ let max = await this.maxSamplePeriod(type); ++ let min = await this.minSamplePeriod(type); ++ let iv = Math.max(Math.min(max, ns), min); ++ ++ sensor.on(Number(type), (data) => { ++ qtsensorsplugin.DataAcception(this.pointerId, JSON.stringify(data)); ++ }, { interval: iv }); ++ } catch (error) { ++ console.error(`Failed to invoke on. Code: ${error.code}, message: ${error.message}`); ++ } ++ } ++ ++ /* 获取指定传感器信息 */ ++ async description(type: sensor.SensorId) { ++ try { ++ let info = await sensor.getSingleSensor(type); ++ let des = JSON.stringify(info); ++ console.info('Succeeded in getting sensor: ' + des); ++ return des; ++ } catch (e) { ++ console.error(`Failed to get singleSensor . Code: ${e.code}, message: ${e.message}`); ++ } ++ } ++ ++ async sensorName(type: sensor.SensorId) { ++ let s = await sensor.getSingleSensor(type); ++ return s.sensorName; ++ } ++ ++ async vendorName(type: sensor.SensorId) { ++ let s = await sensor.getSingleSensor(type); ++ return s.vendorName; ++ } ++ ++ async firmwareVersion(type: sensor.SensorId) { ++ let s = await sensor.getSingleSensor(type); ++ return s.firmwareVersion; ++ } ++ ++ async hardwareVersion(type: sensor.SensorId) { ++ let s = await sensor.getSingleSensor(type); ++ return s.hardwareVersion; ++ } ++ ++ async maxRange(type: sensor.SensorId) { ++ let s = await sensor.getSingleSensor(type); ++ return s.maxRange; ++ } ++ ++ async minSamplePeriod(type: sensor.SensorId) { ++ let s = await sensor.getSingleSensor(type); ++ return this.ns2hertz(s.minSamplePeriod); ++ } ++ ++ async maxSamplePeriod(type: sensor.SensorId) { ++ let s = await sensor.getSingleSensor(type); ++ return this.ns2hertz(s.minSamplePeriod); ++ } ++ ++ async precision(type: sensor.SensorId) { ++ let s = await sensor.getSingleSensor(type); ++ return s.precision; ++ } ++ ++ async power(type: sensor.SensorId) { ++ let s = await sensor.getSingleSensor(type); ++ return s.minSamplePeriod; ++ } ++} +\ No newline at end of file +diff --git a/src/openharmony/openharmony.pro b/src/openharmony/openharmony.pro +new file mode 100644 +index 00000000..6f56bfea +--- /dev/null ++++ b/src/openharmony/openharmony.pro +@@ -0,0 +1,11 @@ ++TEMPLATE = aux ++ ++CONFIG -= qt ++ ++templates.files += $$files($$PWD/native/*.ts, true) ++templates.path = $$[QT_INSTALL_PREFIX]/openharmony/qtsensors ++templates.base = $$PWD ++ ++INSTALLS += templates ++ ++OTHER_FILES += $$templates.files +diff --git a/src/plugins/sensors/openharmony/main.cpp b/src/plugins/sensors/openharmony/main.cpp +new file mode 100644 +index 00000000..c14f6520 +--- /dev/null ++++ b/src/plugins/sensors/openharmony/main.cpp +@@ -0,0 +1,222 @@ ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++ ++#include "sensormanager.h" ++#include "sensorbackend.h" ++#include ++#include "openharmonylight.h" ++#include "openharmonyrotation.h" ++#include "openharmonyhumidity.h" ++#include "openharmonypressure.h" ++#include "openharmonyproximity.h" ++#include "openharmonygyroscope.h" ++#include "openharmonytemperature.h" ++#include "openharmonymagnetometer.h" ++#include "openharmonyaccelerometer.h" ++#include "QtCore/qopenharmonydefines.h" ++#include "QtCore/qopenharmonyjsenvironment.h" ++ ++ ++static napi_value DataAcception(napi_env env, napi_callback_info info) ++{ ++ size_t argc = 2; ++ napi_value args[2] = { Q_NULLPTR }; ++ napi_get_cb_info(env, info, &argc, args , nullptr, nullptr); ++ ++ if (argc != 2) { ++ napi_throw_type_error(env, NULL, "Wrong number of arguments in DataAcception"); ++ return nullptr; ++ } ++ int64_t value0 = qJs::getInt64(args[0]); ++ SensorBackendBase *backend = reinterpret_cast(value0); ++ if (backend == nullptr) ++ return Q_NULLPTR; ++ ++ ++ SensorBackendBase *sensor = reinterpret_cast(value0); ++ if (Q_NULLPTR == sensor) ++ return Q_NULLPTR; ++ ++ QByteArray data = qJs::getString(args[1]).toLocal8Bit(); ++ if (data.isEmpty()) ++ return Q_NULLPTR; ++ ++ QJsonParseError err; ++ const QJsonDocument &doc = QJsonDocument::fromJson(data, &err); ++ if (QJsonParseError::NoError != err.error) ++ return Q_NULLPTR; ++ ++ ++ //sensor->dataReceived(doc.object()); ++ QMetaObject::invokeMethod(sensor, "dataReceived", ++ Qt::QueuedConnection, ++ Q_ARG(QJsonObject, doc.object())); ++ return Q_NULLPTR; ++} ++ ++namespace { ++const char OPenHarmonyCompassId[] = "openharmony.synthetic.compass"; ++} ++ ++class OPenHarmonySensorPlugin : public QObject, public QSensorPluginInterface, ++ public QSensorBackendFactory ++{ ++ Q_OBJECT ++ Q_PLUGIN_METADATA(IID "com.qt-project.Qt.QSensorPluginInterface/1.0" FILE "plugin.json") ++ Q_INTERFACES(QSensorPluginInterface) ++ ++public: ++ void registerSensors() override ++ { ++ bool accelerometer = false; ++ bool magnetometer = false; ++ const QList &ids = SensorManager::instance()->sensorIds(); ++ for (int sensor : qAsConst(ids)) { ++ switch (sensor) { ++ case E_BAROMETER: ++ QSensorManager::registerBackend(QPressureSensor::type, QByteArray::number(sensor), this); ++ break; ++ case E_ACCELEROMETER: ++ m_accelerationModes |= OPenHarmonyAccelerometer::Accelerometer; ++ QSensorManager::registerBackend(QAccelerometer::type, QByteArray::number(sensor), this); ++ accelerometer = true; ++ break; ++ case E_LINEAR_ACCELEROMETER: ++ m_accelerationModes |= OPenHarmonyAccelerometer::LinearAcceleration; ++ //QSensorManager::registerBackend(QAccelerometer::type, QByteArray::number(sensor), this); ++ break; ++ case E_GRAVITY: ++ m_accelerationModes |= OPenHarmonyAccelerometer::Gravity; ++ //QSensorManager::registerBackend(QAccelerometer::type, QByteArray::number(sensor), this); ++ break; ++ case E_HUMIDITY: ++ QSensorManager::registerBackend(QHumiditySensor::type, QByteArray::number(sensor), this); ++ break; ++ case E_PROXIMITY: ++ QSensorManager::registerBackend(QProximitySensor::type, QByteArray::number(sensor), this); ++ break; ++ case E_GYROSCOPE: ++ QSensorManager::registerBackend(QGyroscope::type, QByteArray::number(sensor), this); ++ break; ++ case E_ORIENTATION: ++ /*FIXME 通过加速度传感器实现? */ ++ //QSensorManager::registerBackend(QOrientationSensor::type, QByteArray::number(sensor), this); ++ break; ++ case E_ROTATION_VECTOR: ++ QSensorManager::registerBackend(QRotationSensor::type, QByteArray::number(sensor), this); ++ break; ++ case E_AMBIENT_LIGHT: ++ QSensorManager::registerBackend(QAmbientLightSensor::type, QByteArray::number(sensor), this); ++ break; ++ case E_MAGNETIC_FIELD: ++ QSensorManager::registerBackend(QMagnetometer::type, QByteArray::number(sensor), this); ++ magnetometer = true; ++ break; ++ case E_AMBIENT_TEMPERATURE: ++ QSensorManager::registerBackend(QAmbientTemperatureSensor::type, QByteArray::number(sensor), this); ++ break; ++ default: ++ break; ++ } ++ } ++#if 0 ++ /* NOTE 现在的js回调机制不支持 ++ * 罗盘通过加速度和磁场传感器组合实现 ++ */ ++ if (accelerometer && magnetometer) ++ QSensorManager::registerBackend(QCompass::type, OPenHarmonyCompassId, this); ++#endif ++ } ++ ++ QSensorBackend *createBackend(QSensor *sensor) override ++ { ++ /* TODO QCompass */ ++ int id = sensor->identifier().toInt(); ++ switch (id) { ++ case E_BAROMETER: ++ return new OPenHarmonyPressure(id, sensor); ++ case E_ACCELEROMETER: ++ return new OPenHarmonyAccelerometer(m_accelerationModes, sensor); ++ case E_GYROSCOPE: ++ return new OPenHarmonyGyroscope(id, sensor); ++ case E_PROXIMITY: ++ return new OPenHarmonyProximity(id, sensor); ++ case E_AMBIENT_LIGHT: ++ return new OPenHarmonyLight(id, sensor); ++ case E_MAGNETIC_FIELD: ++ return new OPenHarmonyMagnetometer(id, sensor); ++ case E_HUMIDITY: ++ return new OPenHarmonyHumidity(id, sensor); ++ case E_ROTATION_VECTOR: ++ return new OPenHarmonyRotation(id, sensor); ++ case E_AMBIENT_TEMPERATURE: ++ return new OPenHarmonyTemperature(id, sensor); ++ default: ++ break; ++ } ++ return Q_NULLPTR; ++ } ++ ++private: ++ int m_accelerationModes = 0; ++}; ++ ++/* ++ * function for module exports ++ */ ++EXTERN_C_START ++static napi_value Init(napi_env env, napi_value exports) ++{ ++ static bool inited = false; ++ if (!inited) { ++ ++ LOGI("init sensors module"); ++ napi_property_descriptor desc[] ={ ++ DECLARE_NAPI_FUNCTION("DataAcception", DataAcception), ++ }; ++ NAPI_CALL(env, napi_define_properties(env, exports, sizeof(desc) / sizeof(desc[0]), desc)); ++ inited = true; ++ } ++ return exports; ++} ++EXTERN_C_END ++ ++/* ++ * Napi Module define ++ */ ++static napi_module openharmonyQtSensorsModule = { ++ .nm_version = 1, ++ .nm_flags = 0, ++ .nm_filename = nullptr, ++ .nm_register_func = Init, ++ .nm_modname = "openharmony_qt_sensors", ++ .nm_priv = ((void*)0), ++ .reserved = { 0 }, ++}; ++/* ++ * Module register function ++ */ ++extern "C" __attribute__((constructor)) void RegisterModule(void) ++{ ++ napi_module_register(&openharmonyQtSensorsModule); ++} ++ ++#include "main.moc" +diff --git a/src/plugins/sensors/openharmony/openharmony.pro b/src/plugins/sensors/openharmony/openharmony.pro +new file mode 100644 +index 00000000..390e904c +--- /dev/null ++++ b/src/plugins/sensors/openharmony/openharmony.pro +@@ -0,0 +1,36 @@ ++TARGET = qtsensors_openharmony ++QT = core sensors ++ ++OTHER_FILES = plugin.json ++ ++SOURCES += \ ++ main.cpp \ ++ openharmonyaccelerometer.cpp \ ++ openharmonygyroscope.cpp \ ++ openharmonyhumidity.cpp \ ++ openharmonylight.cpp \ ++ openharmonymagnetometer.cpp \ ++ openharmonypressure.cpp \ ++ openharmonyproximity.cpp \ ++ openharmonyrotation.cpp \ ++ openharmonytemperature.cpp \ ++ sensormanager.cpp ++ ++ ++PLUGIN_TYPE = sensors ++PLUGIN_CLASS_NAME = OPenHarmonySensorPlugin ++load(qt_plugin) ++ ++HEADERS += \ ++ openharmonyaccelerometer.h \ ++ openharmonygyroscope.h \ ++ openharmonyhumidity.h \ ++ openharmonylight.h \ ++ openharmonymagnetometer.h \ ++ openharmonypressure.h \ ++ openharmonyproximity.h \ ++ openharmonyrotation.h \ ++ openharmonytemperature.h \ ++ sensorbackend.h \ ++ sensormanager.h ++ +diff --git a/src/plugins/sensors/openharmony/openharmonyaccelerometer.cpp b/src/plugins/sensors/openharmony/openharmonyaccelerometer.cpp +new file mode 100644 +index 00000000..84ad1e53 +--- /dev/null ++++ b/src/plugins/sensors/openharmony/openharmonyaccelerometer.cpp +@@ -0,0 +1,71 @@ ++#include ++#include ++#include ++ ++#include "openharmonyaccelerometer.h" ++ ++OPenHarmonyAccelerometer::OPenHarmonyAccelerometer(int accelerationModes, QSensor *sensor, QObject *parent) ++ : SensorBackend(E_ACCELEROMETER, sensor, parent) ++ , m_accelerationModes(accelerationModes) ++{ ++ auto accelerometer = qobject_cast(sensor); ++ if (accelerometer) { ++ connect(accelerometer, &QAccelerometer::accelerationModeChanged, ++ this, &OPenHarmonyAccelerometer::applyAccelerationMode); ++ applyAccelerationMode(accelerometer->accelerationMode()); ++ } ++} ++ ++bool OPenHarmonyAccelerometer::isFeatureSupported(QSensor::Feature feature) const ++{ ++ return (feature == QSensor::AccelerationMode) ? m_accelerationModes == AllModes : SensorBackend::isFeatureSupported(feature); ++} ++ ++void OPenHarmonyAccelerometer::dataReceived(const QJsonObject &json) ++{ ++ double x = json.value("x").toDouble(); ++ double y = json.value("y").toDouble(); ++ double z = json.value("z").toDouble(); ++ ++ if (sensor()->skipDuplicates() && qFuzzyCompare(m_reader.x(), x) && ++ qFuzzyCompare(m_reader.y(), y) && ++ qFuzzyCompare(m_reader.z(), z)) { ++ return; ++ } ++ ++ double timestamp = json.value("timestamp").toDouble(); ++ m_reader.setTimestamp(quint64(timestamp)); ++ m_reader.setX(x); ++ m_reader.setY(y); ++ m_reader.setZ(z); ++ ++ newReadingAvailable(); ++} ++ ++void OPenHarmonyAccelerometer::applyAccelerationMode(QAccelerometer::AccelerationMode accelerationMode) ++{ ++ switch (accelerationMode) { ++ case QAccelerometer::Gravity: ++ if (!(m_accelerationModes & Gravity)) { ++ qWarning() << "Gravity sensor missing"; ++ return; ++ } ++ setSensorType(E_GRAVITY); ++ break; ++ case QAccelerometer::User: ++ if (!(m_accelerationModes & LinearAcceleration)) { ++ qWarning() << "Linear acceleration sensor missing"; ++ return; ++ } ++ setSensorType(E_LINEAR_ACCELEROMETER); ++ break; ++ case QAccelerometer::Combined: ++ if (!(m_accelerationModes & Accelerometer)) { ++ qWarning() << "Accelerometer sensor missing"; ++ return; ++ } ++ setSensorType(E_ACCELEROMETER); ++ break; ++ } ++} ++ +diff --git a/src/plugins/sensors/openharmony/openharmonyaccelerometer.h b/src/plugins/sensors/openharmony/openharmonyaccelerometer.h +new file mode 100644 +index 00000000..a610d25b +--- /dev/null ++++ b/src/plugins/sensors/openharmony/openharmonyaccelerometer.h +@@ -0,0 +1,32 @@ ++#ifndef OPENHARMONYACCELEROMETER_H ++#define OPENHARMONYACCELEROMETER_H ++ ++#include ++ ++#include "sensorbackend.h" ++ ++class OPenHarmonyAccelerometer : public SensorBackend ++{ ++ Q_OBJECT ++ ++public: ++ enum AccelerationModes { ++ Accelerometer = 1, ++ Gravity = 2, ++ LinearAcceleration = 4, ++ AllModes = (Accelerometer | Gravity | LinearAcceleration) ++ }; ++ OPenHarmonyAccelerometer(int accelerationModes, QSensor *sensor, QObject *parent = nullptr); ++ bool isFeatureSupported(QSensor::Feature feature) const override; ++ ++protected Q_SLOTS: ++ void dataReceived(const QJsonObject &json) override; ++ ++private: ++ void applyAccelerationMode(QAccelerometer::AccelerationMode accelerationMode); ++ ++private: ++ int m_accelerationModes; ++}; ++ ++#endif // OPENHARMONYACCELEROMETER_H +diff --git a/src/plugins/sensors/openharmony/openharmonygyroscope.cpp b/src/plugins/sensors/openharmony/openharmonygyroscope.cpp +new file mode 100644 +index 00000000..349b7e2f +--- /dev/null ++++ b/src/plugins/sensors/openharmony/openharmonygyroscope.cpp +@@ -0,0 +1,33 @@ ++#include ++#include ++#include ++ ++#include "openharmonygyroscope.h" ++ ++OPenHarmonyGyroscope::OPenHarmonyGyroscope(int type, QSensor *sensor, QObject *parent) ++: SensorBackend(type, sensor, parent) ++{ ++ ++} ++ ++void OPenHarmonyGyroscope::dataReceived(const QJsonObject &json) ++{ ++ double x = qRadiansToDegrees(json.value("x").toDouble()); ++ double y = qRadiansToDegrees(json.value("y").toDouble()); ++ double z = qRadiansToDegrees(json.value("z").toDouble()); ++ double timestamp = json.value("timestamp").toDouble(); ++ ++ if (sensor()->skipDuplicates() && qFuzzyCompare(m_reader.x(), x) && ++ qFuzzyCompare(m_reader.y(), y) && ++ qFuzzyCompare(m_reader.z(), z)) { ++ return; ++ } ++ ++ m_reader.setTimestamp(quint64(timestamp)); ++ m_reader.setX(x); ++ m_reader.setY(y); ++ m_reader.setZ(z); ++ ++ newReadingAvailable(); ++} ++ +diff --git a/src/plugins/sensors/openharmony/openharmonygyroscope.h b/src/plugins/sensors/openharmony/openharmonygyroscope.h +new file mode 100644 +index 00000000..ff3e6d2a +--- /dev/null ++++ b/src/plugins/sensors/openharmony/openharmonygyroscope.h +@@ -0,0 +1,18 @@ ++#ifndef OPENHARMONYGYROSCOPE_H ++#define OPENHARMONYGYROSCOPE_H ++ ++#include ++ ++#include "sensorbackend.h" ++ ++class OPenHarmonyGyroscope : public SensorBackend ++{ ++ Q_OBJECT ++public: ++ OPenHarmonyGyroscope(int type, QSensor *sensor, QObject *parent = nullptr); ++ ++protected Q_SLOTS: ++ void dataReceived(const QJsonObject &json) override; ++}; ++ ++#endif // OPENHARMONYGYROSCOPE_H +diff --git a/src/plugins/sensors/openharmony/openharmonyhumidity.cpp b/src/plugins/sensors/openharmony/openharmonyhumidity.cpp +new file mode 100644 +index 00000000..e17df8cf +--- /dev/null ++++ b/src/plugins/sensors/openharmony/openharmonyhumidity.cpp +@@ -0,0 +1,25 @@ ++#include ++#include ++ ++#include "openharmonyhumidity.h" ++ ++OPenHarmonyHumidity::OPenHarmonyHumidity(int type, QSensor *sensor, QObject *parent) ++ : SensorBackend(type, sensor, parent) ++{ ++ ++} ++ ++void OPenHarmonyHumidity::dataReceived(const QJsonObject &json) ++{ ++ qreal humidity = json.value("humidity").toDouble(); ++ ++ if (sensor()->skipDuplicates() && qFuzzyCompare(humidity, m_reader.relativeHumidity())) ++ return; ++ ++ double timestamp = json.value("timestamp").toDouble(); ++ m_reader.setTimestamp(quint64(timestamp)); ++ m_reader.setAbsoluteHumidity(0.f); ++ m_reader.setRelativeHumidity(humidity); ++ newReadingAvailable(); ++} ++ +diff --git a/src/plugins/sensors/openharmony/openharmonyhumidity.h b/src/plugins/sensors/openharmony/openharmonyhumidity.h +new file mode 100644 +index 00000000..adbf4c9b +--- /dev/null ++++ b/src/plugins/sensors/openharmony/openharmonyhumidity.h +@@ -0,0 +1,18 @@ ++#ifndef OPENHARMONYHUMIDITY_H ++#define OPENHARMONYHUMIDITY_H ++ ++#include ++ ++#include "sensorbackend.h" ++ ++class OPenHarmonyHumidity : public SensorBackend ++{ ++ Q_OBJECT ++public: ++ OPenHarmonyHumidity(int type, QSensor *sensor, QObject *parent = nullptr); ++ ++protected Q_SLOTS: ++ void dataReceived(const QJsonObject &json) override; ++}; ++ ++#endif // OPENHARMONYHUMIDITY_H +diff --git a/src/plugins/sensors/openharmony/openharmonylight.cpp b/src/plugins/sensors/openharmony/openharmonylight.cpp +new file mode 100644 +index 00000000..7274df7c +--- /dev/null ++++ b/src/plugins/sensors/openharmony/openharmonylight.cpp +@@ -0,0 +1,23 @@ ++#include ++#include ++ ++#include "openharmonylight.h" ++ ++OPenHarmonyLight::OPenHarmonyLight(int type, QSensor *sensor, QObject *parent) ++ : SensorBackend(type, sensor, parent) ++{ ++ ++} ++ ++void OPenHarmonyLight::dataReceived(const QJsonObject &json) ++{ ++ double intensity = json.value("intensity").toDouble(); ++ ++ if (sensor()->skipDuplicates() && qFuzzyCompare(m_reader.lux(), intensity)) ++ return; ++ ++ double timestamp = json.value("timestamp").toDouble(); ++ m_reader.setTimestamp(quint64(timestamp)); ++ m_reader.setLux(qreal(intensity)); ++ newReadingAvailable(); ++} +diff --git a/src/plugins/sensors/openharmony/openharmonylight.h b/src/plugins/sensors/openharmony/openharmonylight.h +new file mode 100644 +index 00000000..f8039a92 +--- /dev/null ++++ b/src/plugins/sensors/openharmony/openharmonylight.h +@@ -0,0 +1,18 @@ ++#ifndef OPENHARMONYLIGHT_H ++#define OPENHARMONYLIGHT_H ++ ++#include ++ ++#include "sensorbackend.h" ++ ++class OPenHarmonyLight : public SensorBackend ++{ ++ Q_OBJECT ++public: ++ OPenHarmonyLight(int type, QSensor *sensor, QObject *parent = nullptr); ++ ++protected Q_SLOTS: ++ void dataReceived(const QJsonObject &json) override; ++}; ++ ++#endif // OPENHARMONYLIGHT_H +diff --git a/src/plugins/sensors/openharmony/openharmonymagnetometer.cpp b/src/plugins/sensors/openharmony/openharmonymagnetometer.cpp +new file mode 100644 +index 00000000..34e34b21 +--- /dev/null ++++ b/src/plugins/sensors/openharmony/openharmonymagnetometer.cpp +@@ -0,0 +1,32 @@ ++#include ++#include ++#include "openharmonymagnetometer.h" ++ ++OPenHarmonyMagnetometer::OPenHarmonyMagnetometer(int type, QSensor *sensor, QObject *parent) ++ : SensorBackend(type, sensor, parent) ++{ ++ ++} ++ ++void OPenHarmonyMagnetometer::dataReceived(const QJsonObject &json) ++{ ++ double x = json.value("x").toDouble(); ++ double y = json.value("y").toDouble(); ++ double z = json.value("z").toDouble(); ++ ++ if (sensor()->skipDuplicates() && qFuzzyCompare(m_accuracy, m_reader.calibrationLevel()) && ++ qFuzzyCompare(x, m_reader.x()) && ++ qFuzzyCompare(y, m_reader.y()) && ++ qFuzzyCompare(z, m_reader.z())) { ++ return; ++ } ++ ++ m_reader.setCalibrationLevel(m_accuracy); ++ double timestamp = json.value("timestamp").toDouble(); ++ m_reader.setTimestamp(quint64(timestamp)); ++ m_reader.setX(x); ++ m_reader.setY(y); ++ m_reader.setZ(z); ++ newReadingAvailable(); ++} ++ +diff --git a/src/plugins/sensors/openharmony/openharmonymagnetometer.h b/src/plugins/sensors/openharmony/openharmonymagnetometer.h +new file mode 100644 +index 00000000..c3662243 +--- /dev/null ++++ b/src/plugins/sensors/openharmony/openharmonymagnetometer.h +@@ -0,0 +1,18 @@ ++#ifndef OPENHARMONYMAGNETOMETER_H ++#define OPENHARMONYMAGNETOMETER_H ++ ++#include ++ ++#include "sensorbackend.h" ++ ++class OPenHarmonyMagnetometer : public SensorBackend ++{ ++ Q_OBJECT ++public: ++ OPenHarmonyMagnetometer(int type, QSensor *sensor, QObject *parent = nullptr); ++ ++protected Q_SLOTS: ++ void dataReceived(const QJsonObject &json) override; ++}; ++ ++#endif // OPENHARMONYMAGNETOMETER_H +diff --git a/src/plugins/sensors/openharmony/openharmonypressure.cpp b/src/plugins/sensors/openharmony/openharmonypressure.cpp +new file mode 100644 +index 00000000..c7d5d3d3 +--- /dev/null ++++ b/src/plugins/sensors/openharmony/openharmonypressure.cpp +@@ -0,0 +1,22 @@ ++#include ++#include ++ ++#include "openharmonypressure.h" ++ ++OPenHarmonyPressure::OPenHarmonyPressure(int type, QSensor *sensor, QObject *parent) ++ : SensorBackend(type, sensor, parent) ++{ ++ ++} ++ ++void OPenHarmonyPressure::dataReceived(const QJsonObject &json) ++{ ++ auto pressurePa = json.value("pressure").toDouble(); ++ if (sensor()->skipDuplicates() && qFuzzyCompare(pressurePa, m_reader.pressure())) ++ return; ++ ++ double timestamp = json.value("timestamp").toDouble(); ++ m_reader.setTimestamp(quint64(timestamp)); ++ m_reader.setPressure(pressurePa); ++ newReadingAvailable(); ++} +diff --git a/src/plugins/sensors/openharmony/openharmonypressure.h b/src/plugins/sensors/openharmony/openharmonypressure.h +new file mode 100644 +index 00000000..8c2db8aa +--- /dev/null ++++ b/src/plugins/sensors/openharmony/openharmonypressure.h +@@ -0,0 +1,18 @@ ++#ifndef OPENHARMONYPRESSURE_H ++#define OPENHARMONYPRESSURE_H ++ ++#include ++ ++#include "sensorbackend.h" ++ ++class OPenHarmonyPressure : public SensorBackend ++{ ++ Q_OBJECT ++public: ++ OPenHarmonyPressure(int type, QSensor *sensor, QObject *parent = nullptr); ++ ++protected Q_SLOTS: ++ void dataReceived(const QJsonObject &json) override; ++}; ++ ++#endif // OPENHARMONYPRESSURE_H +diff --git a/src/plugins/sensors/openharmony/openharmonyproximity.cpp b/src/plugins/sensors/openharmony/openharmonyproximity.cpp +new file mode 100644 +index 00000000..e96a0b24 +--- /dev/null ++++ b/src/plugins/sensors/openharmony/openharmonyproximity.cpp +@@ -0,0 +1,28 @@ ++#include ++#include ++ ++#include "openharmonyproximity.h" ++ ++OPenHarmonyProximity::OPenHarmonyProximity(int type, QSensor *sensor, QObject *parent) ++ : SensorBackend(type, sensor, parent) ++{ ++ m_maximumRange = m_jsSensor->maxRange(m_type); ++ ++ // if we can't get the range, we arbitrarily define anything closer than 10 cm as "close" ++ if (m_maximumRange <= 0) ++ m_maximumRange = 10.0; ++} ++ ++void OPenHarmonyProximity::dataReceived(const QJsonObject &json) ++{ ++ qreal distance = json.value("distance").toDouble(); ++ bool close = distance < m_maximumRange; ++ if (sensor()->skipDuplicates() && close == m_reader.close()) ++ return; ++ ++ double timestamp = json.value("timestamp").toDouble(); ++ m_reader.setTimestamp(quint64(timestamp)); ++ m_reader.setClose(close); ++ newReadingAvailable(); ++} ++ +diff --git a/src/plugins/sensors/openharmony/openharmonyproximity.h b/src/plugins/sensors/openharmony/openharmonyproximity.h +new file mode 100644 +index 00000000..f1ef02f2 +--- /dev/null ++++ b/src/plugins/sensors/openharmony/openharmonyproximity.h +@@ -0,0 +1,21 @@ ++#ifndef OPENHARMONYPROXIMITY_H ++#define OPENHARMONYPROXIMITY_H ++ ++#include ++ ++#include "sensorbackend.h" ++ ++class OPenHarmonyProximity : public SensorBackend ++{ ++ Q_OBJECT ++public: ++ OPenHarmonyProximity(int type, QSensor *sensor, QObject *parent = nullptr); ++ ++protected Q_SLOTS: ++ void dataReceived(const QJsonObject &json) override; ++ ++private: ++ qreal m_maximumRange; ++}; ++ ++#endif // OPENHARMONYPROXIMITY_H +diff --git a/src/plugins/sensors/openharmony/openharmonyrotation.cpp b/src/plugins/sensors/openharmony/openharmonyrotation.cpp +new file mode 100644 +index 00000000..a4d70e6f +--- /dev/null ++++ b/src/plugins/sensors/openharmony/openharmonyrotation.cpp +@@ -0,0 +1,29 @@ ++#include ++#include ++#include ++ ++#include "openharmonyrotation.h" ++ ++OPenHarmonyRotation::OPenHarmonyRotation(int type, QSensor *sensor, QObject *parent) ++ : SensorBackend(type, sensor, parent) ++{ ++ ++} ++ ++void OPenHarmonyRotation::dataReceived(const QJsonObject &json) ++{ ++ qreal rz = -qRadiansToDegrees(json.value("x").toDouble()); //corresponds to x ++ qreal rx = -qRadiansToDegrees(json.value("y").toDouble()); //corresponds to y ++ qreal ry = qRadiansToDegrees(json.value("z").toDouble()); //corresponds to z ++ if (sensor()->skipDuplicates() && qFuzzyCompare(m_reader.x(), rx) && ++ qFuzzyCompare(m_reader.y(), ry) && ++ qFuzzyCompare(m_reader.z(), rz)) { ++ return; ++ } ++ ++ double timestamp = json.value("timestamp").toDouble(); ++ m_reader.setTimestamp(quint64(timestamp)); ++ m_reader.setFromEuler(rx, ry, rz); ++ newReadingAvailable(); ++} ++ +diff --git a/src/plugins/sensors/openharmony/openharmonyrotation.h b/src/plugins/sensors/openharmony/openharmonyrotation.h +new file mode 100644 +index 00000000..03243797 +--- /dev/null ++++ b/src/plugins/sensors/openharmony/openharmonyrotation.h +@@ -0,0 +1,18 @@ ++#ifndef OPENHARMONYROTATION_H ++#define OPENHARMONYROTATION_H ++ ++#include ++ ++#include "sensorbackend.h" ++ ++class OPenHarmonyRotation : public SensorBackend ++{ ++ Q_OBJECT ++public: ++ OPenHarmonyRotation(int type, QSensor *sensor, QObject *parent = nullptr); ++ ++protected Q_SLOTS: ++ void dataReceived(const QJsonObject &json) override; ++}; ++ ++#endif // OPENHARMONYROTATION_H +diff --git a/src/plugins/sensors/openharmony/openharmonytemperature.cpp b/src/plugins/sensors/openharmony/openharmonytemperature.cpp +new file mode 100644 +index 00000000..a3865b03 +--- /dev/null ++++ b/src/plugins/sensors/openharmony/openharmonytemperature.cpp +@@ -0,0 +1,23 @@ ++#include ++#include ++ ++#include "openharmonytemperature.h" ++ ++OPenHarmonyTemperature::OPenHarmonyTemperature(int type, QSensor *sensor, QObject *parent) ++ : SensorBackend(type, sensor, parent) ++{ ++ ++} ++ ++void OPenHarmonyTemperature::dataReceived(const QJsonObject &json) ++{ ++ qreal temperature = json.value("temperature").toDouble(); ++ if (sensor()->skipDuplicates() && qFuzzyCompare(m_reader.temperature(), temperature)) ++ return; ++ ++ double timestamp = json.value("timestamp").toDouble(); ++ m_reader.setTimestamp(quint64(timestamp)); ++ m_reader.setTemperature(temperature); // in degree Celsius ++ newReadingAvailable(); ++} ++ +diff --git a/src/plugins/sensors/openharmony/openharmonytemperature.h b/src/plugins/sensors/openharmony/openharmonytemperature.h +new file mode 100644 +index 00000000..cc881f20 +--- /dev/null ++++ b/src/plugins/sensors/openharmony/openharmonytemperature.h +@@ -0,0 +1,18 @@ ++#ifndef OPENHARMONYTEMPERATURE_H ++#define OPENHARMONYTEMPERATURE_H ++ ++#include ++ ++#include "sensorbackend.h" ++ ++class OPenHarmonyTemperature : public SensorBackend ++{ ++ Q_OBJECT ++public: ++ OPenHarmonyTemperature(int type, QSensor *sensor, QObject *parent = nullptr); ++ ++protected Q_SLOTS: ++ void dataReceived(const QJsonObject &json) override; ++}; ++ ++#endif // OPENHARMONYTEMPERATURE_H +diff --git a/src/plugins/sensors/openharmony/plugin.json b/src/plugins/sensors/openharmony/plugin.json +new file mode 100644 +index 00000000..ff40b670 +--- /dev/null ++++ b/src/plugins/sensors/openharmony/plugin.json +@@ -0,0 +1 @@ ++{ "Keys": [ "openharmony" ] } +diff --git a/src/plugins/sensors/openharmony/sensorbackend.h b/src/plugins/sensors/openharmony/sensorbackend.h +new file mode 100644 +index 00000000..aa0907df +--- /dev/null ++++ b/src/plugins/sensors/openharmony/sensorbackend.h +@@ -0,0 +1,91 @@ ++#ifndef SENSORBACKEND_H ++#define SENSORBACKEND_H ++ ++#include ++#include ++ ++#include "sensormanager.h" ++ ++class SensorBackendBase : public QSensorBackend ++{ ++public: ++ SensorBackendBase(QSensor *sensor, QObject *parent = nullptr) ++ : QSensorBackend(sensor, parent) ++ , m_jsSensor(Q_NULLPTR) ++ { ++ QString tempUuid = QUuid::createUuid().toString(); ++ tempUuid.chop(1); //remove trailing '}' ++ tempUuid.remove(0,1); //remove first '{' ++ ++ m_jsSensor = SensorManager::instance()->createJsSensor(tempUuid, this); ++ } ++ ++public Q_SLOTS: ++ virtual void dataReceived(const QJsonObject &json) = 0; ++ ++protected: ++ QSharedPointer m_jsSensor; ++}; ++ ++template ++class SensorBackend : public SensorBackendBase ++{ ++public: ++ explicit SensorBackend(int type, QSensor *sensor, QObject *parent = nullptr) : m_type(0) ++ , SensorBackendBase{ sensor, parent } ++ { ++ setReading(&m_reader); ++ setSensorType(type); ++ m_accuracy = m_jsSensor->precision(type); ++ addDataRate(m_jsSensor->minSamplePeriod(type), ++ m_jsSensor->maxSamplePeriod(type)); ++ addOutputRange(0, m_jsSensor->maxRange(type), m_accuracy); ++ } ++ ++ ~SensorBackend() override ++ { ++ stop(); ++ } ++ ++ void setSensorType(int type) ++ { ++ m_type = type; ++ bool started = m_started; ++ if (started) ++ stop(); ++ ++ setDescription(m_jsSensor->description(type)); ++ if (started) ++ start(); ++ } ++ ++ virtual void start() override ++ { ++ m_jsSensor->start(m_type, sensor()->dataRate()); ++ m_started = true; ++ } ++ ++ virtual void stop() override ++ { ++ m_jsSensor->stop(m_type); ++ m_started = false; ++ } ++ ++ bool isFeatureSupported(QSensor::Feature feature) const override ++ { ++ switch (feature) { ++ case QSensor::SkipDuplicates: ++ return true; ++ default: ++ return false; ++ } ++ } ++ ++protected: ++ T m_reader; ++ int m_type; ++ qreal m_accuracy = 0.0f; ++ bool m_started = false; ++}; ++ ++#endif // SENSORBACKEND_H +diff --git a/src/plugins/sensors/openharmony/sensormanager.cpp b/src/plugins/sensors/openharmony/sensormanager.cpp +new file mode 100644 +index 00000000..d34294f4 +--- /dev/null ++++ b/src/plugins/sensors/openharmony/sensormanager.cpp +@@ -0,0 +1,121 @@ ++#include "sensormanager.h" ++#include "QtCore/qopenharmonyjsobject.h" ++#include "QtCore/qopenharmonyjsenvironment.h" ++#include "QtCore/qopenharmonyjsobjectloader.h" ++ ++JsSensor::JsSensor(const QString &uuid) : m_uuid(uuid) ++ , m_jsSensor(Q_NULLPTR) ++{ ++ ++} ++ ++JsSensor::~JsSensor() ++{ ++ if (m_jsSensor) ++ m_jsSensor->call("destroySensor", m_uuid); ++} ++ ++qreal JsSensor::power(int id) const ++{ ++ qreal p = m_jsSensor->call("power", id); ++ return p; ++} ++ ++QString JsSensor::name(int id) const ++{ ++ QString n = m_jsSensor->call("sensorName", id); ++ return n; ++} ++ ++qreal JsSensor::maxRange(int id) const ++{ ++ qreal r = m_jsSensor->call("maxRange", id); ++ return r; ++} ++ ++qreal JsSensor::precision(int id) const ++{ ++ qreal accuracy = m_jsSensor->call("precision", id); ++ return accuracy; ++} ++ ++QString JsSensor::vendorName(int id) const ++{ ++ QString n = m_jsSensor->call("vendorName", id); ++ return n; ++} ++ ++QString JsSensor::description(int id) const ++{ ++ QString des = m_jsSensor->call("description", id); ++ return des; ++} ++ ++qreal JsSensor::minSamplePeriod(int id) const ++{ ++ qreal p = m_jsSensor->call("minSamplePeriod", id); ++ return p; ++} ++ ++qreal JsSensor::maxSamplePeriod(int id) const ++{ ++ qreal p = m_jsSensor->call("maxSamplePeriod", id); ++ return p; ++} ++ ++QString JsSensor::firmwareVersion(int id) const ++{ ++ QString v = m_jsSensor->call("firmwareVersion", id); ++ return v; ++} ++ ++void JsSensor::stop(int id) ++{ ++ m_jsSensor->call("stop", id); ++} ++ ++void JsSensor::start(int id, int rate) ++{ ++ m_jsSensor->call("start", id, rate); ++} ++ ++QString JsSensor::hardwareVersion(int id) const ++{ ++ QString hv = m_jsSensor->call("hardwareVersion", id); ++ return hv; ++} ++ ++SensorManager::SensorManager() { ++ m_sensors = qJsObjectLoader->create("qtsensors"); ++} ++ ++QList SensorManager::sensorIds() const ++{ ++ QStringList ids = m_sensors->call("sensorIds"); ++ QList ns; ++ ns.reserve(ids.size()); ++ for (const auto &id : qAsConst(ids)) { ++ ns.append(id.toInt()); ++ } ++ return ns; ++} ++ ++QSharedPointer &SensorManager::instance() ++{ ++ static QSharedPointer s{ new SensorManager() }; ++ return s; ++} ++ ++QSharedPointer SensorManager::createJsSensor(const QString &uuid, SensorBackendBase *backend) ++{ ++ JsSensor *s = new JsSensor(uuid); ++ m_sensors->call("createSensor", uuid, QVariant(qlonglong(backend))); ++ s->m_jsSensor.reset(new QOpenHarmonyJsObject(uuid)); ++ return QSharedPointer(s); ++} ++ ++void SensorManager::defineProperties(size_t property_count, const napi_property_descriptor *properties) ++{ ++ m_sensors->defineProperties(property_count, properties); ++} ++ +diff --git a/src/plugins/sensors/openharmony/sensormanager.h b/src/plugins/sensors/openharmony/sensormanager.h +new file mode 100644 +index 00000000..157baa3c +--- /dev/null ++++ b/src/plugins/sensors/openharmony/sensormanager.h +@@ -0,0 +1,69 @@ ++#ifndef SENSORMANAGER_H ++#define SENSORMANAGER_H ++ ++#include ++#include ++ ++/* NOTE 鸿蒙和Qt传感器匹配的项 ++ * Qt对前端传感器模块进行了封装 ++ * 鸿蒙提供的传感器模块接口不是 ++ * 完全匹配,需要转换 ++ */ ++enum { ++ E_GRAVITY = 257, /* 重力传感器<--->QAccelerometer */ ++ E_HUMIDITY = 13, /* 湿度传感器<--->QHumiditySensor */ ++ E_BAROMETER = 8, /* 气压传感器<--->QPressureSensor */ ++ E_GYROSCOPE = 2, /* 陀螺仪传感器<--->QGyroscope */ ++ E_PROXIMITY = 12, /* 接近光传感器<--->QDistanceSensor */ ++ E_ORIENTATION = 256, /* 方向传感器<--->QOrientationSensor */ ++ E_ACCELEROMETER = 1, /* 加速度传感器<--->QAccelerometer */ ++ E_AMBIENT_LIGHT = 5, /* 环境光传感器<--->QAmbientLightSensor */ ++ E_MAGNETIC_FIELD = 6, /* 磁场传感器<--->QMagnetometer */ ++ E_ROTATION_VECTOR = 259, /* 旋转矢量传感器<--->QRotationSensor */ ++ E_AMBIENT_TEMPERATURE = 260, /* 环境温度传感器<--->QAmbientTemperatureSensor */ ++ E_LINEAR_ACCELEROMETER = 258, /* 线性加速度传感器<--->QAccelerometer */ ++}; ++ ++class SensorBackendBase; ++class QOpenHarmonyJsObject; ++ ++class JsSensor ++{ ++ QString m_uuid; ++ QSharedPointer m_jsSensor; ++ ++ friend class SensorManager; ++public: ++ JsSensor(const QString &uuid); ++ ~JsSensor(); ++ ++ qreal power(int id) const; ++ QString name(int id) const; ++ qreal maxRange(int id) const; ++ qreal precision(int id) const; ++ QString vendorName(int id) const; ++ QString description(int id) const; ++ qreal minSamplePeriod(int id) const; ++ qreal maxSamplePeriod(int id) const; ++ QString firmwareVersion(int id) const; ++ QString hardwareVersion(int id) const; ++ ++ void stop(int id); ++ void start(int id, int rate); ++}; ++ ++class SensorManager ++{ ++ SensorManager(); ++ ++public: ++ QList sensorIds() const; ++ static QSharedPointer &instance(); ++ QSharedPointer createJsSensor(const QString &uuid, SensorBackendBase *backend); ++ void defineProperties(size_t property_count, const napi_property_descriptor* properties); ++ ++private: ++ QSharedPointer m_sensors; ++}; ++ ++#endif // SENSORMANAGER_H +diff --git a/src/plugins/sensors/sensors.pro b/src/plugins/sensors/sensors.pro +index 7fce2071..8037ffc4 100644 +--- a/src/plugins/sensors/sensors.pro ++++ b/src/plugins/sensors/sensors.pro +@@ -5,6 +5,10 @@ android { + isEmpty(SENSORS_PLUGINS): SENSORS_PLUGINS = android generic + } + ++openharmony { ++ isEmpty(SENSORS_PLUGINS): SENSORS_PLUGINS = openharmony generic ++} ++ + qtConfig(sensorfw) { + isEmpty(SENSORS_PLUGINS): SENSORS_PLUGINS = sensorfw generic + } +@@ -39,6 +43,7 @@ isEmpty(SENSORS_PLUGINS)|contains(SENSORS_PLUGINS, simulator):qtHaveModule(simul + isEmpty(SENSORS_PLUGINS)|contains(SENSORS_PLUGINS, linux):linux:SUBDIRS += linux + isEmpty(SENSORS_PLUGINS)|contains(SENSORS_PLUGINS, iio-sensor-proxy):linux:qtHaveModule(dbus):SUBDIRS += iio-sensor-proxy + isEmpty(SENSORS_PLUGINS)|contains(SENSORS_PLUGINS, android):android:SUBDIRS += android ++isEmpty(SENSORS_PLUGINS)|contains(SENSORS_PLUGINS, openharmony):openharmony:SUBDIRS += openharmony + isEmpty(SENSORS_PLUGINS)|contains(SENSORS_PLUGINS, sensorfw):sensorfw:SUBDIRS += sensorfw + isEmpty(SENSORS_PLUGINS)|contains(SENSORS_PLUGINS, sensortag):linux:SUBDIRS += sensortag + isEmpty(SENSORS_PLUGINS)|contains(SENSORS_PLUGINS, ios):darwin:SUBDIRS += ios +diff --git a/src/src.pro b/src/src.pro +index b3aa7ba0..df12cad0 100644 +--- a/src/src.pro ++++ b/src/src.pro +@@ -16,3 +16,6 @@ plugins.subdir = plugins + plugins.target = sub-plugins + plugins.depends = sensors + ++SUBDIRS += openharmony ++openharmony.subdir = openharmony ++openharmony.target = sub-openharmony -- Gitee From d1eac49a87bd320a604882418c3e04e7a5200573 Mon Sep 17 00:00:00 2001 From: wanghao Date: Mon, 9 Oct 2023 14:45:50 +0800 Subject: [PATCH 2/5] =?UTF-8?q?[del]=20=E5=88=A0=E9=99=A4qtsensors.path?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- patch/qtsensor.patch | 1339 ------------------------------------------ 1 file changed, 1339 deletions(-) delete mode 100644 patch/qtsensor.patch diff --git a/patch/qtsensor.patch b/patch/qtsensor.patch deleted file mode 100644 index 27f1499543..0000000000 --- a/patch/qtsensor.patch +++ /dev/null @@ -1,1339 +0,0 @@ -diff --git a/src/openharmony/native/QtSensors.ts b/src/openharmony/native/QtSensors.ts -new file mode 100644 -index 00000000..8c7ad9a0 ---- /dev/null -+++ b/src/openharmony/native/QtSensors.ts -@@ -0,0 +1,132 @@ -+import sensor from '@ohos.sensor'; -+import qtsensorsplugin from 'libplugins_sensors_qtsensors_openharmony.so'; -+ -+export class QtSensors { -+ private pointerId = 0; -+ -+ public constructor(id) { -+ this.pointerId = id; -+ } -+ -+ /* Hz转ns,周期为1 */ -+ private hertz2ns(rate: Number) { -+ /* f=1/T （其中f是指赫兹,T是指以秒为单位的时间）*/ -+ let ns = (1 / Number(rate)) * 1000000000; -+ return ns; -+ } -+ -+ /* ns转Hz,周期为1 */ -+ private ns2hertz(ns: Number) { -+ /* f=1/T （其中f是指赫兹,T是指以秒为单位的时间）*/ -+ let hz = 1 / (Number(ns) / 1000000000); -+ return hz; -+ } -+ -+ createSensor(name, p) { -+ let server = new QtSensors(p); -+ Reflect.defineProperty(globalThis, name, { value: server }); -+ return true; -+ } -+ -+ destroySensor(name: string) { -+ Reflect.deleteProperty(globalThis, name); -+ this.pointerId = 0; -+ return true; -+ } -+ -+ /* 获取所有传感器类型Id */ -+ async sensorIds() { -+ let s: Array = new Array(); -+ try { -+ let sr = await sensor.getSensorList(); -+ for (let data of sr) { -+ s.push(String(data.sensorId)); -+ } -+ } catch (e) { -+ console.error(`Failed to get sensorList. Code: ${e.code}, message: ${e.message}`); -+ } -+ return s; -+ } -+ -+ stop(type: sensor.SensorId) { -+ try { -+ sensor.off(Number(type)); -+ } catch (error) { -+ console.error(`Failed to invoke off. Code: ${error.code}, message: ${error.message}`); -+ } -+ } -+ -+ /* 开始订阅传感器数据 */ -+ async start(type: sensor.SensorId, rate: Number) { -+ try { -+ this.stop(type); -+ let ns = this.hertz2ns(rate); -+ let max = await this.maxSamplePeriod(type); -+ let min = await this.minSamplePeriod(type); -+ let iv = Math.max(Math.min(max, ns), min); -+ -+ sensor.on(Number(type), (data) => { -+ qtsensorsplugin.DataAcception(this.pointerId, JSON.stringify(data)); -+ }, { interval: iv }); -+ } catch (error) { -+ console.error(`Failed to invoke on. Code: ${error.code}, message: ${error.message}`); -+ } -+ } -+ -+ /* 获取指定传感器信息 */ -+ async description(type: sensor.SensorId) { -+ try { -+ let info = await sensor.getSingleSensor(type); -+ let des = JSON.stringify(info); -+ console.info('Succeeded in getting sensor: ' + des); -+ return des; -+ } catch (e) { -+ console.error(`Failed to get singleSensor . Code: ${e.code}, message: ${e.message}`); -+ } -+ } -+ -+ async sensorName(type: sensor.SensorId) { -+ let s = await sensor.getSingleSensor(type); -+ return s.sensorName; -+ } -+ -+ async vendorName(type: sensor.SensorId) { -+ let s = await sensor.getSingleSensor(type); -+ return s.vendorName; -+ } -+ -+ async firmwareVersion(type: sensor.SensorId) { -+ let s = await sensor.getSingleSensor(type); -+ return s.firmwareVersion; -+ } -+ -+ async hardwareVersion(type: sensor.SensorId) { -+ let s = await sensor.getSingleSensor(type); -+ return s.hardwareVersion; -+ } -+ -+ async maxRange(type: sensor.SensorId) { -+ let s = await sensor.getSingleSensor(type); -+ return s.maxRange; -+ } -+ -+ async minSamplePeriod(type: sensor.SensorId) { -+ let s = await sensor.getSingleSensor(type); -+ return this.ns2hertz(s.minSamplePeriod); -+ } -+ -+ async maxSamplePeriod(type: sensor.SensorId) { -+ let s = await sensor.getSingleSensor(type); -+ return this.ns2hertz(s.minSamplePeriod); -+ } -+ -+ async precision(type: sensor.SensorId) { -+ let s = await sensor.getSingleSensor(type); -+ return s.precision; -+ } -+ -+ async power(type: sensor.SensorId) { -+ let s = await sensor.getSingleSensor(type); -+ return s.minSamplePeriod; -+ } -+} -\ No newline at end of file -diff --git a/src/openharmony/openharmony.pro b/src/openharmony/openharmony.pro -new file mode 100644 -index 00000000..6f56bfea ---- /dev/null -+++ b/src/openharmony/openharmony.pro -@@ -0,0 +1,11 @@ -+TEMPLATE = aux -+ -+CONFIG -= qt -+ -+templates.files += $$files($$PWD/native/*.ts, true) -+templates.path = $$[QT_INSTALL_PREFIX]/openharmony/qtsensors -+templates.base = $$PWD -+ -+INSTALLS += templates -+ -+OTHER_FILES += $$templates.files -diff --git a/src/plugins/sensors/openharmony/main.cpp b/src/plugins/sensors/openharmony/main.cpp -new file mode 100644 -index 00000000..c14f6520 ---- /dev/null -+++ b/src/plugins/sensors/openharmony/main.cpp -@@ -0,0 +1,222 @@ -+#include -+#include -+#include -+#include -+#include -+#include -+#include -+#include -+#include -+#include -+#include -+#include -+#include -+#include -+#include -+#include -+#include -+#include -+#include -+#include -+ -+#include "sensormanager.h" -+#include "sensorbackend.h" -+#include -+#include "openharmonylight.h" -+#include "openharmonyrotation.h" -+#include "openharmonyhumidity.h" -+#include "openharmonypressure.h" -+#include "openharmonyproximity.h" -+#include "openharmonygyroscope.h" -+#include "openharmonytemperature.h" -+#include "openharmonymagnetometer.h" -+#include "openharmonyaccelerometer.h" -+#include "QtCore/qopenharmonydefines.h" -+#include "QtCore/qopenharmonyjsenvironment.h" -+ -+ -+static napi_value DataAcception(napi_env env, napi_callback_info info) -+{ -+ size_t argc = 2; -+ napi_value args[2] = { Q_NULLPTR }; -+ napi_get_cb_info(env, info, &argc, args , nullptr, nullptr); -+ -+ if (argc != 2) { -+ napi_throw_type_error(env, NULL, "Wrong number of arguments in DataAcception"); -+ return nullptr; -+ } -+ int64_t value0 = qJs::getInt64(args[0]); -+ SensorBackendBase *backend = reinterpret_cast(value0); -+ if (backend == nullptr) -+ return Q_NULLPTR; -+ -+ -+ SensorBackendBase *sensor = reinterpret_cast(value0); -+ if (Q_NULLPTR == sensor) -+ return Q_NULLPTR; -+ -+ QByteArray data = qJs::getString(args[1]).toLocal8Bit(); -+ if (data.isEmpty()) -+ return Q_NULLPTR; -+ -+ QJsonParseError err; -+ const QJsonDocument &doc = QJsonDocument::fromJson(data, &err); -+ if (QJsonParseError::NoError != err.error) -+ return Q_NULLPTR; -+ -+ -+ //sensor->dataReceived(doc.object()); -+ QMetaObject::invokeMethod(sensor, "dataReceived", -+ Qt::QueuedConnection, -+ Q_ARG(QJsonObject, doc.object())); -+ return Q_NULLPTR; -+} -+ -+namespace { -+const char OPenHarmonyCompassId[] = "openharmony.synthetic.compass"; -+} -+ -+class OPenHarmonySensorPlugin : public QObject, public QSensorPluginInterface, -+ public QSensorBackendFactory -+{ -+ Q_OBJECT -+ Q_PLUGIN_METADATA(IID "com.qt-project.Qt.QSensorPluginInterface/1.0" FILE "plugin.json") -+ Q_INTERFACES(QSensorPluginInterface) -+ -+public: -+ void registerSensors() override -+ { -+ bool accelerometer = false; -+ bool magnetometer = false; -+ const QList &ids = SensorManager::instance()->sensorIds(); -+ for (int sensor : qAsConst(ids)) { -+ switch (sensor) { -+ case E_BAROMETER: -+ QSensorManager::registerBackend(QPressureSensor::type, QByteArray::number(sensor), this); -+ break; -+ case E_ACCELEROMETER: -+ m_accelerationModes |= OPenHarmonyAccelerometer::Accelerometer; -+ QSensorManager::registerBackend(QAccelerometer::type, QByteArray::number(sensor), this); -+ accelerometer = true; -+ break; -+ case E_LINEAR_ACCELEROMETER: -+ m_accelerationModes |= OPenHarmonyAccelerometer::LinearAcceleration; -+ //QSensorManager::registerBackend(QAccelerometer::type, QByteArray::number(sensor), this); -+ break; -+ case E_GRAVITY: -+ m_accelerationModes |= OPenHarmonyAccelerometer::Gravity; -+ //QSensorManager::registerBackend(QAccelerometer::type, QByteArray::number(sensor), this); -+ break; -+ case E_HUMIDITY: -+ QSensorManager::registerBackend(QHumiditySensor::type, QByteArray::number(sensor), this); -+ break; -+ case E_PROXIMITY: -+ QSensorManager::registerBackend(QProximitySensor::type, QByteArray::number(sensor), this); -+ break; -+ case E_GYROSCOPE: -+ QSensorManager::registerBackend(QGyroscope::type, QByteArray::number(sensor), this); -+ break; -+ case E_ORIENTATION: -+ /*FIXME 通过加速度传感器实现? */ -+ //QSensorManager::registerBackend(QOrientationSensor::type, QByteArray::number(sensor), this); -+ break; -+ case E_ROTATION_VECTOR: -+ QSensorManager::registerBackend(QRotationSensor::type, QByteArray::number(sensor), this); -+ break; -+ case E_AMBIENT_LIGHT: -+ QSensorManager::registerBackend(QAmbientLightSensor::type, QByteArray::number(sensor), this); -+ break; -+ case E_MAGNETIC_FIELD: -+ QSensorManager::registerBackend(QMagnetometer::type, QByteArray::number(sensor), this); -+ magnetometer = true; -+ break; -+ case E_AMBIENT_TEMPERATURE: -+ QSensorManager::registerBackend(QAmbientTemperatureSensor::type, QByteArray::number(sensor), this); -+ break; -+ default: -+ break; -+ } -+ } -+#if 0 -+ /* NOTE 现在的js回调机制不支持 -+ * 罗盘通过加速度和磁场传感器组合实现 -+ */ -+ if (accelerometer && magnetometer) -+ QSensorManager::registerBackend(QCompass::type, OPenHarmonyCompassId, this); -+#endif -+ } -+ -+ QSensorBackend *createBackend(QSensor *sensor) override -+ { -+ /* TODO QCompass */ -+ int id = sensor->identifier().toInt(); -+ switch (id) { -+ case E_BAROMETER: -+ return new OPenHarmonyPressure(id, sensor); -+ case E_ACCELEROMETER: -+ return new OPenHarmonyAccelerometer(m_accelerationModes, sensor); -+ case E_GYROSCOPE: -+ return new OPenHarmonyGyroscope(id, sensor); -+ case E_PROXIMITY: -+ return new OPenHarmonyProximity(id, sensor); -+ case E_AMBIENT_LIGHT: -+ return new OPenHarmonyLight(id, sensor); -+ case E_MAGNETIC_FIELD: -+ return new OPenHarmonyMagnetometer(id, sensor); -+ case E_HUMIDITY: -+ return new OPenHarmonyHumidity(id, sensor); -+ case E_ROTATION_VECTOR: -+ return new OPenHarmonyRotation(id, sensor); -+ case E_AMBIENT_TEMPERATURE: -+ return new OPenHarmonyTemperature(id, sensor); -+ default: -+ break; -+ } -+ return Q_NULLPTR; -+ } -+ -+private: -+ int m_accelerationModes = 0; -+}; -+ -+/* -+ * function for module exports -+ */ -+EXTERN_C_START -+static napi_value Init(napi_env env, napi_value exports) -+{ -+ static bool inited = false; -+ if (!inited) { -+ -+ LOGI("init sensors module"); -+ napi_property_descriptor desc[] ={ -+ DECLARE_NAPI_FUNCTION("DataAcception", DataAcception), -+ }; -+ NAPI_CALL(env, napi_define_properties(env, exports, sizeof(desc) / sizeof(desc[0]), desc)); -+ inited = true; -+ } -+ return exports; -+} -+EXTERN_C_END -+ -+/* -+ * Napi Module define -+ */ -+static napi_module openharmonyQtSensorsModule = { -+ .nm_version = 1, -+ .nm_flags = 0, -+ .nm_filename = nullptr, -+ .nm_register_func = Init, -+ .nm_modname = "openharmony_qt_sensors", -+ .nm_priv = ((void*)0), -+ .reserved = { 0 }, -+}; -+/* -+ * Module register function -+ */ -+extern "C" __attribute__((constructor)) void RegisterModule(void) -+{ -+ napi_module_register(&openharmonyQtSensorsModule); -+} -+ -+#include "main.moc" -diff --git a/src/plugins/sensors/openharmony/openharmony.pro b/src/plugins/sensors/openharmony/openharmony.pro -new file mode 100644 -index 00000000..390e904c ---- /dev/null -+++ b/src/plugins/sensors/openharmony/openharmony.pro -@@ -0,0 +1,36 @@ -+TARGET = qtsensors_openharmony -+QT = core sensors -+ -+OTHER_FILES = plugin.json -+ -+SOURCES += \ -+ main.cpp \ -+ openharmonyaccelerometer.cpp \ -+ openharmonygyroscope.cpp \ -+ openharmonyhumidity.cpp \ -+ openharmonylight.cpp \ -+ openharmonymagnetometer.cpp \ -+ openharmonypressure.cpp \ -+ openharmonyproximity.cpp \ -+ openharmonyrotation.cpp \ -+ openharmonytemperature.cpp \ -+ sensormanager.cpp -+ -+ -+PLUGIN_TYPE = sensors -+PLUGIN_CLASS_NAME = OPenHarmonySensorPlugin -+load(qt_plugin) -+ -+HEADERS += \ -+ openharmonyaccelerometer.h \ -+ openharmonygyroscope.h \ -+ openharmonyhumidity.h \ -+ openharmonylight.h \ -+ openharmonymagnetometer.h \ -+ openharmonypressure.h \ -+ openharmonyproximity.h \ -+ openharmonyrotation.h \ -+ openharmonytemperature.h \ -+ sensorbackend.h \ -+ sensormanager.h -+ -diff --git a/src/plugins/sensors/openharmony/openharmonyaccelerometer.cpp b/src/plugins/sensors/openharmony/openharmonyaccelerometer.cpp -new file mode 100644 -index 00000000..84ad1e53 ---- /dev/null -+++ b/src/plugins/sensors/openharmony/openharmonyaccelerometer.cpp -@@ -0,0 +1,71 @@ -+#include -+#include -+#include -+ -+#include "openharmonyaccelerometer.h" -+ -+OPenHarmonyAccelerometer::OPenHarmonyAccelerometer(int accelerationModes, QSensor *sensor, QObject *parent) -+ : SensorBackend(E_ACCELEROMETER, sensor, parent) -+ , m_accelerationModes(accelerationModes) -+{ -+ auto accelerometer = qobject_cast(sensor); -+ if (accelerometer) { -+ connect(accelerometer, &QAccelerometer::accelerationModeChanged, -+ this, &OPenHarmonyAccelerometer::applyAccelerationMode); -+ applyAccelerationMode(accelerometer->accelerationMode()); -+ } -+} -+ -+bool OPenHarmonyAccelerometer::isFeatureSupported(QSensor::Feature feature) const -+{ -+ return (feature == QSensor::AccelerationMode) ? m_accelerationModes == AllModes : SensorBackend::isFeatureSupported(feature); -+} -+ -+void OPenHarmonyAccelerometer::dataReceived(const QJsonObject &json) -+{ -+ double x = json.value("x").toDouble(); -+ double y = json.value("y").toDouble(); -+ double z = json.value("z").toDouble(); -+ -+ if (sensor()->skipDuplicates() && qFuzzyCompare(m_reader.x(), x) && -+ qFuzzyCompare(m_reader.y(), y) && -+ qFuzzyCompare(m_reader.z(), z)) { -+ return; -+ } -+ -+ double timestamp = json.value("timestamp").toDouble(); -+ m_reader.setTimestamp(quint64(timestamp)); -+ m_reader.setX(x); -+ m_reader.setY(y); -+ m_reader.setZ(z); -+ -+ newReadingAvailable(); -+} -+ -+void OPenHarmonyAccelerometer::applyAccelerationMode(QAccelerometer::AccelerationMode accelerationMode) -+{ -+ switch (accelerationMode) { -+ case QAccelerometer::Gravity: -+ if (!(m_accelerationModes & Gravity)) { -+ qWarning() << "Gravity sensor missing"; -+ return; -+ } -+ setSensorType(E_GRAVITY); -+ break; -+ case QAccelerometer::User: -+ if (!(m_accelerationModes & LinearAcceleration)) { -+ qWarning() << "Linear acceleration sensor missing"; -+ return; -+ } -+ setSensorType(E_LINEAR_ACCELEROMETER); -+ break; -+ case QAccelerometer::Combined: -+ if (!(m_accelerationModes & Accelerometer)) { -+ qWarning() << "Accelerometer sensor missing"; -+ return; -+ } -+ setSensorType(E_ACCELEROMETER); -+ break; -+ } -+} -+ -diff --git a/src/plugins/sensors/openharmony/openharmonyaccelerometer.h b/src/plugins/sensors/openharmony/openharmonyaccelerometer.h -new file mode 100644 -index 00000000..a610d25b ---- /dev/null -+++ b/src/plugins/sensors/openharmony/openharmonyaccelerometer.h -@@ -0,0 +1,32 @@ -+#ifndef OPENHARMONYACCELEROMETER_H -+#define OPENHARMONYACCELEROMETER_H -+ -+#include -+ -+#include "sensorbackend.h" -+ -+class OPenHarmonyAccelerometer : public SensorBackend -+{ -+ Q_OBJECT -+ -+public: -+ enum AccelerationModes { -+ Accelerometer = 1, -+ Gravity = 2, -+ LinearAcceleration = 4, -+ AllModes = (Accelerometer | Gravity | LinearAcceleration) -+ }; -+ OPenHarmonyAccelerometer(int accelerationModes, QSensor *sensor, QObject *parent = nullptr); -+ bool isFeatureSupported(QSensor::Feature feature) const override; -+ -+protected Q_SLOTS: -+ void dataReceived(const QJsonObject &json) override; -+ -+private: -+ void applyAccelerationMode(QAccelerometer::AccelerationMode accelerationMode); -+ -+private: -+ int m_accelerationModes; -+}; -+ -+#endif // OPENHARMONYACCELEROMETER_H -diff --git a/src/plugins/sensors/openharmony/openharmonygyroscope.cpp b/src/plugins/sensors/openharmony/openharmonygyroscope.cpp -new file mode 100644 -index 00000000..349b7e2f ---- /dev/null -+++ b/src/plugins/sensors/openharmony/openharmonygyroscope.cpp -@@ -0,0 +1,33 @@ -+#include -+#include -+#include -+ -+#include "openharmonygyroscope.h" -+ -+OPenHarmonyGyroscope::OPenHarmonyGyroscope(int type, QSensor *sensor, QObject *parent) -+: SensorBackend(type, sensor, parent) -+{ -+ -+} -+ -+void OPenHarmonyGyroscope::dataReceived(const QJsonObject &json) -+{ -+ double x = qRadiansToDegrees(json.value("x").toDouble()); -+ double y = qRadiansToDegrees(json.value("y").toDouble()); -+ double z = qRadiansToDegrees(json.value("z").toDouble()); -+ double timestamp = json.value("timestamp").toDouble(); -+ -+ if (sensor()->skipDuplicates() && qFuzzyCompare(m_reader.x(), x) && -+ qFuzzyCompare(m_reader.y(), y) && -+ qFuzzyCompare(m_reader.z(), z)) { -+ return; -+ } -+ -+ m_reader.setTimestamp(quint64(timestamp)); -+ m_reader.setX(x); -+ m_reader.setY(y); -+ m_reader.setZ(z); -+ -+ newReadingAvailable(); -+} -+ -diff --git a/src/plugins/sensors/openharmony/openharmonygyroscope.h b/src/plugins/sensors/openharmony/openharmonygyroscope.h -new file mode 100644 -index 00000000..ff3e6d2a ---- /dev/null -+++ b/src/plugins/sensors/openharmony/openharmonygyroscope.h -@@ -0,0 +1,18 @@ -+#ifndef OPENHARMONYGYROSCOPE_H -+#define OPENHARMONYGYROSCOPE_H -+ -+#include -+ -+#include "sensorbackend.h" -+ -+class OPenHarmonyGyroscope : public SensorBackend -+{ -+ Q_OBJECT -+public: -+ OPenHarmonyGyroscope(int type, QSensor *sensor, QObject *parent = nullptr); -+ -+protected Q_SLOTS: -+ void dataReceived(const QJsonObject &json) override; -+}; -+ -+#endif // OPENHARMONYGYROSCOPE_H -diff --git a/src/plugins/sensors/openharmony/openharmonyhumidity.cpp b/src/plugins/sensors/openharmony/openharmonyhumidity.cpp -new file mode 100644 -index 00000000..e17df8cf ---- /dev/null -+++ b/src/plugins/sensors/openharmony/openharmonyhumidity.cpp -@@ -0,0 +1,25 @@ -+#include -+#include -+ -+#include "openharmonyhumidity.h" -+ -+OPenHarmonyHumidity::OPenHarmonyHumidity(int type, QSensor *sensor, QObject *parent) -+ : SensorBackend(type, sensor, parent) -+{ -+ -+} -+ -+void OPenHarmonyHumidity::dataReceived(const QJsonObject &json) -+{ -+ qreal humidity = json.value("humidity").toDouble(); -+ -+ if (sensor()->skipDuplicates() && qFuzzyCompare(humidity, m_reader.relativeHumidity())) -+ return; -+ -+ double timestamp = json.value("timestamp").toDouble(); -+ m_reader.setTimestamp(quint64(timestamp)); -+ m_reader.setAbsoluteHumidity(0.f); -+ m_reader.setRelativeHumidity(humidity); -+ newReadingAvailable(); -+} -+ -diff --git a/src/plugins/sensors/openharmony/openharmonyhumidity.h b/src/plugins/sensors/openharmony/openharmonyhumidity.h -new file mode 100644 -index 00000000..adbf4c9b ---- /dev/null -+++ b/src/plugins/sensors/openharmony/openharmonyhumidity.h -@@ -0,0 +1,18 @@ -+#ifndef OPENHARMONYHUMIDITY_H -+#define OPENHARMONYHUMIDITY_H -+ -+#include -+ -+#include "sensorbackend.h" -+ -+class OPenHarmonyHumidity : public SensorBackend -+{ -+ Q_OBJECT -+public: -+ OPenHarmonyHumidity(int type, QSensor *sensor, QObject *parent = nullptr); -+ -+protected Q_SLOTS: -+ void dataReceived(const QJsonObject &json) override; -+}; -+ -+#endif // OPENHARMONYHUMIDITY_H -diff --git a/src/plugins/sensors/openharmony/openharmonylight.cpp b/src/plugins/sensors/openharmony/openharmonylight.cpp -new file mode 100644 -index 00000000..7274df7c ---- /dev/null -+++ b/src/plugins/sensors/openharmony/openharmonylight.cpp -@@ -0,0 +1,23 @@ -+#include -+#include -+ -+#include "openharmonylight.h" -+ -+OPenHarmonyLight::OPenHarmonyLight(int type, QSensor *sensor, QObject *parent) -+ : SensorBackend(type, sensor, parent) -+{ -+ -+} -+ -+void OPenHarmonyLight::dataReceived(const QJsonObject &json) -+{ -+ double intensity = json.value("intensity").toDouble(); -+ -+ if (sensor()->skipDuplicates() && qFuzzyCompare(m_reader.lux(), intensity)) -+ return; -+ -+ double timestamp = json.value("timestamp").toDouble(); -+ m_reader.setTimestamp(quint64(timestamp)); -+ m_reader.setLux(qreal(intensity)); -+ newReadingAvailable(); -+} -diff --git a/src/plugins/sensors/openharmony/openharmonylight.h b/src/plugins/sensors/openharmony/openharmonylight.h -new file mode 100644 -index 00000000..f8039a92 ---- /dev/null -+++ b/src/plugins/sensors/openharmony/openharmonylight.h -@@ -0,0 +1,18 @@ -+#ifndef OPENHARMONYLIGHT_H -+#define OPENHARMONYLIGHT_H -+ -+#include -+ -+#include "sensorbackend.h" -+ -+class OPenHarmonyLight : public SensorBackend -+{ -+ Q_OBJECT -+public: -+ OPenHarmonyLight(int type, QSensor *sensor, QObject *parent = nullptr); -+ -+protected Q_SLOTS: -+ void dataReceived(const QJsonObject &json) override; -+}; -+ -+#endif // OPENHARMONYLIGHT_H -diff --git a/src/plugins/sensors/openharmony/openharmonymagnetometer.cpp b/src/plugins/sensors/openharmony/openharmonymagnetometer.cpp -new file mode 100644 -index 00000000..34e34b21 ---- /dev/null -+++ b/src/plugins/sensors/openharmony/openharmonymagnetometer.cpp -@@ -0,0 +1,32 @@ -+#include -+#include -+#include "openharmonymagnetometer.h" -+ -+OPenHarmonyMagnetometer::OPenHarmonyMagnetometer(int type, QSensor *sensor, QObject *parent) -+ : SensorBackend(type, sensor, parent) -+{ -+ -+} -+ -+void OPenHarmonyMagnetometer::dataReceived(const QJsonObject &json) -+{ -+ double x = json.value("x").toDouble(); -+ double y = json.value("y").toDouble(); -+ double z = json.value("z").toDouble(); -+ -+ if (sensor()->skipDuplicates() && qFuzzyCompare(m_accuracy, m_reader.calibrationLevel()) && -+ qFuzzyCompare(x, m_reader.x()) && -+ qFuzzyCompare(y, m_reader.y()) && -+ qFuzzyCompare(z, m_reader.z())) { -+ return; -+ } -+ -+ m_reader.setCalibrationLevel(m_accuracy); -+ double timestamp = json.value("timestamp").toDouble(); -+ m_reader.setTimestamp(quint64(timestamp)); -+ m_reader.setX(x); -+ m_reader.setY(y); -+ m_reader.setZ(z); -+ newReadingAvailable(); -+} -+ -diff --git a/src/plugins/sensors/openharmony/openharmonymagnetometer.h b/src/plugins/sensors/openharmony/openharmonymagnetometer.h -new file mode 100644 -index 00000000..c3662243 ---- /dev/null -+++ b/src/plugins/sensors/openharmony/openharmonymagnetometer.h -@@ -0,0 +1,18 @@ -+#ifndef OPENHARMONYMAGNETOMETER_H -+#define OPENHARMONYMAGNETOMETER_H -+ -+#include -+ -+#include "sensorbackend.h" -+ -+class OPenHarmonyMagnetometer : public SensorBackend -+{ -+ Q_OBJECT -+public: -+ OPenHarmonyMagnetometer(int type, QSensor *sensor, QObject *parent = nullptr); -+ -+protected Q_SLOTS: -+ void dataReceived(const QJsonObject &json) override; -+}; -+ -+#endif // OPENHARMONYMAGNETOMETER_H -diff --git a/src/plugins/sensors/openharmony/openharmonypressure.cpp b/src/plugins/sensors/openharmony/openharmonypressure.cpp -new file mode 100644 -index 00000000..c7d5d3d3 ---- /dev/null -+++ b/src/plugins/sensors/openharmony/openharmonypressure.cpp -@@ -0,0 +1,22 @@ -+#include -+#include -+ -+#include "openharmonypressure.h" -+ -+OPenHarmonyPressure::OPenHarmonyPressure(int type, QSensor *sensor, QObject *parent) -+ : SensorBackend(type, sensor, parent) -+{ -+ -+} -+ -+void OPenHarmonyPressure::dataReceived(const QJsonObject &json) -+{ -+ auto pressurePa = json.value("pressure").toDouble(); -+ if (sensor()->skipDuplicates() && qFuzzyCompare(pressurePa, m_reader.pressure())) -+ return; -+ -+ double timestamp = json.value("timestamp").toDouble(); -+ m_reader.setTimestamp(quint64(timestamp)); -+ m_reader.setPressure(pressurePa); -+ newReadingAvailable(); -+} -diff --git a/src/plugins/sensors/openharmony/openharmonypressure.h b/src/plugins/sensors/openharmony/openharmonypressure.h -new file mode 100644 -index 00000000..8c2db8aa ---- /dev/null -+++ b/src/plugins/sensors/openharmony/openharmonypressure.h -@@ -0,0 +1,18 @@ -+#ifndef OPENHARMONYPRESSURE_H -+#define OPENHARMONYPRESSURE_H -+ -+#include -+ -+#include "sensorbackend.h" -+ -+class OPenHarmonyPressure : public SensorBackend -+{ -+ Q_OBJECT -+public: -+ OPenHarmonyPressure(int type, QSensor *sensor, QObject *parent = nullptr); -+ -+protected Q_SLOTS: -+ void dataReceived(const QJsonObject &json) override; -+}; -+ -+#endif // OPENHARMONYPRESSURE_H -diff --git a/src/plugins/sensors/openharmony/openharmonyproximity.cpp b/src/plugins/sensors/openharmony/openharmonyproximity.cpp -new file mode 100644 -index 00000000..e96a0b24 ---- /dev/null -+++ b/src/plugins/sensors/openharmony/openharmonyproximity.cpp -@@ -0,0 +1,28 @@ -+#include -+#include -+ -+#include "openharmonyproximity.h" -+ -+OPenHarmonyProximity::OPenHarmonyProximity(int type, QSensor *sensor, QObject *parent) -+ : SensorBackend(type, sensor, parent) -+{ -+ m_maximumRange = m_jsSensor->maxRange(m_type); -+ -+ // if we can't get the range, we arbitrarily define anything closer than 10 cm as "close" -+ if (m_maximumRange <= 0) -+ m_maximumRange = 10.0; -+} -+ -+void OPenHarmonyProximity::dataReceived(const QJsonObject &json) -+{ -+ qreal distance = json.value("distance").toDouble(); -+ bool close = distance < m_maximumRange; -+ if (sensor()->skipDuplicates() && close == m_reader.close()) -+ return; -+ -+ double timestamp = json.value("timestamp").toDouble(); -+ m_reader.setTimestamp(quint64(timestamp)); -+ m_reader.setClose(close); -+ newReadingAvailable(); -+} -+ -diff --git a/src/plugins/sensors/openharmony/openharmonyproximity.h b/src/plugins/sensors/openharmony/openharmonyproximity.h -new file mode 100644 -index 00000000..f1ef02f2 ---- /dev/null -+++ b/src/plugins/sensors/openharmony/openharmonyproximity.h -@@ -0,0 +1,21 @@ -+#ifndef OPENHARMONYPROXIMITY_H -+#define OPENHARMONYPROXIMITY_H -+ -+#include -+ -+#include "sensorbackend.h" -+ -+class OPenHarmonyProximity : public SensorBackend -+{ -+ Q_OBJECT -+public: -+ OPenHarmonyProximity(int type, QSensor *sensor, QObject *parent = nullptr); -+ -+protected Q_SLOTS: -+ void dataReceived(const QJsonObject &json) override; -+ -+private: -+ qreal m_maximumRange; -+}; -+ -+#endif // OPENHARMONYPROXIMITY_H -diff --git a/src/plugins/sensors/openharmony/openharmonyrotation.cpp b/src/plugins/sensors/openharmony/openharmonyrotation.cpp -new file mode 100644 -index 00000000..a4d70e6f ---- /dev/null -+++ b/src/plugins/sensors/openharmony/openharmonyrotation.cpp -@@ -0,0 +1,29 @@ -+#include -+#include -+#include -+ -+#include "openharmonyrotation.h" -+ -+OPenHarmonyRotation::OPenHarmonyRotation(int type, QSensor *sensor, QObject *parent) -+ : SensorBackend(type, sensor, parent) -+{ -+ -+} -+ -+void OPenHarmonyRotation::dataReceived(const QJsonObject &json) -+{ -+ qreal rz = -qRadiansToDegrees(json.value("x").toDouble()); //corresponds to x -+ qreal rx = -qRadiansToDegrees(json.value("y").toDouble()); //corresponds to y -+ qreal ry = qRadiansToDegrees(json.value("z").toDouble()); //corresponds to z -+ if (sensor()->skipDuplicates() && qFuzzyCompare(m_reader.x(), rx) && -+ qFuzzyCompare(m_reader.y(), ry) && -+ qFuzzyCompare(m_reader.z(), rz)) { -+ return; -+ } -+ -+ double timestamp = json.value("timestamp").toDouble(); -+ m_reader.setTimestamp(quint64(timestamp)); -+ m_reader.setFromEuler(rx, ry, rz); -+ newReadingAvailable(); -+} -+ -diff --git a/src/plugins/sensors/openharmony/openharmonyrotation.h b/src/plugins/sensors/openharmony/openharmonyrotation.h -new file mode 100644 -index 00000000..03243797 ---- /dev/null -+++ b/src/plugins/sensors/openharmony/openharmonyrotation.h -@@ -0,0 +1,18 @@ -+#ifndef OPENHARMONYROTATION_H -+#define OPENHARMONYROTATION_H -+ -+#include -+ -+#include "sensorbackend.h" -+ -+class OPenHarmonyRotation : public SensorBackend -+{ -+ Q_OBJECT -+public: -+ OPenHarmonyRotation(int type, QSensor *sensor, QObject *parent = nullptr); -+ -+protected Q_SLOTS: -+ void dataReceived(const QJsonObject &json) override; -+}; -+ -+#endif // OPENHARMONYROTATION_H -diff --git a/src/plugins/sensors/openharmony/openharmonytemperature.cpp b/src/plugins/sensors/openharmony/openharmonytemperature.cpp -new file mode 100644 -index 00000000..a3865b03 ---- /dev/null -+++ b/src/plugins/sensors/openharmony/openharmonytemperature.cpp -@@ -0,0 +1,23 @@ -+#include -+#include -+ -+#include "openharmonytemperature.h" -+ -+OPenHarmonyTemperature::OPenHarmonyTemperature(int type, QSensor *sensor, QObject *parent) -+ : SensorBackend(type, sensor, parent) -+{ -+ -+} -+ -+void OPenHarmonyTemperature::dataReceived(const QJsonObject &json) -+{ -+ qreal temperature = json.value("temperature").toDouble(); -+ if (sensor()->skipDuplicates() && qFuzzyCompare(m_reader.temperature(), temperature)) -+ return; -+ -+ double timestamp = json.value("timestamp").toDouble(); -+ m_reader.setTimestamp(quint64(timestamp)); -+ m_reader.setTemperature(temperature); // in degree Celsius -+ newReadingAvailable(); -+} -+ -diff --git a/src/plugins/sensors/openharmony/openharmonytemperature.h b/src/plugins/sensors/openharmony/openharmonytemperature.h -new file mode 100644 -index 00000000..cc881f20 ---- /dev/null -+++ b/src/plugins/sensors/openharmony/openharmonytemperature.h -@@ -0,0 +1,18 @@ -+#ifndef OPENHARMONYTEMPERATURE_H -+#define OPENHARMONYTEMPERATURE_H -+ -+#include -+ -+#include "sensorbackend.h" -+ -+class OPenHarmonyTemperature : public SensorBackend -+{ -+ Q_OBJECT -+public: -+ OPenHarmonyTemperature(int type, QSensor *sensor, QObject *parent = nullptr); -+ -+protected Q_SLOTS: -+ void dataReceived(const QJsonObject &json) override; -+}; -+ -+#endif // OPENHARMONYTEMPERATURE_H -diff --git a/src/plugins/sensors/openharmony/plugin.json b/src/plugins/sensors/openharmony/plugin.json -new file mode 100644 -index 00000000..ff40b670 ---- /dev/null -+++ b/src/plugins/sensors/openharmony/plugin.json -@@ -0,0 +1 @@ -+{ "Keys": [ "openharmony" ] } -diff --git a/src/plugins/sensors/openharmony/sensorbackend.h b/src/plugins/sensors/openharmony/sensorbackend.h -new file mode 100644 -index 00000000..aa0907df ---- /dev/null -+++ b/src/plugins/sensors/openharmony/sensorbackend.h -@@ -0,0 +1,91 @@ -+#ifndef SENSORBACKEND_H -+#define SENSORBACKEND_H -+ -+#include -+#include -+ -+#include "sensormanager.h" -+ -+class SensorBackendBase : public QSensorBackend -+{ -+public: -+ SensorBackendBase(QSensor *sensor, QObject *parent = nullptr) -+ : QSensorBackend(sensor, parent) -+ , m_jsSensor(Q_NULLPTR) -+ { -+ QString tempUuid = QUuid::createUuid().toString(); -+ tempUuid.chop(1); //remove trailing '}' -+ tempUuid.remove(0,1); //remove first '{' -+ -+ m_jsSensor = SensorManager::instance()->createJsSensor(tempUuid, this); -+ } -+ -+public Q_SLOTS: -+ virtual void dataReceived(const QJsonObject &json) = 0; -+ -+protected: -+ QSharedPointer m_jsSensor; -+}; -+ -+template -+class SensorBackend : public SensorBackendBase -+{ -+public: -+ explicit SensorBackend(int type, QSensor *sensor, QObject *parent = nullptr) : m_type(0) -+ , SensorBackendBase{ sensor, parent } -+ { -+ setReading(&m_reader); -+ setSensorType(type); -+ m_accuracy = m_jsSensor->precision(type); -+ addDataRate(m_jsSensor->minSamplePeriod(type), -+ m_jsSensor->maxSamplePeriod(type)); -+ addOutputRange(0, m_jsSensor->maxRange(type), m_accuracy); -+ } -+ -+ ~SensorBackend() override -+ { -+ stop(); -+ } -+ -+ void setSensorType(int type) -+ { -+ m_type = type; -+ bool started = m_started; -+ if (started) -+ stop(); -+ -+ setDescription(m_jsSensor->description(type)); -+ if (started) -+ start(); -+ } -+ -+ virtual void start() override -+ { -+ m_jsSensor->start(m_type, sensor()->dataRate()); -+ m_started = true; -+ } -+ -+ virtual void stop() override -+ { -+ m_jsSensor->stop(m_type); -+ m_started = false; -+ } -+ -+ bool isFeatureSupported(QSensor::Feature feature) const override -+ { -+ switch (feature) { -+ case QSensor::SkipDuplicates: -+ return true; -+ default: -+ return false; -+ } -+ } -+ -+protected: -+ T m_reader; -+ int m_type; -+ qreal m_accuracy = 0.0f; -+ bool m_started = false; -+}; -+ -+#endif // SENSORBACKEND_H -diff --git a/src/plugins/sensors/openharmony/sensormanager.cpp b/src/plugins/sensors/openharmony/sensormanager.cpp -new file mode 100644 -index 00000000..d34294f4 ---- /dev/null -+++ b/src/plugins/sensors/openharmony/sensormanager.cpp -@@ -0,0 +1,121 @@ -+#include "sensormanager.h" -+#include "QtCore/qopenharmonyjsobject.h" -+#include "QtCore/qopenharmonyjsenvironment.h" -+#include "QtCore/qopenharmonyjsobjectloader.h" -+ -+JsSensor::JsSensor(const QString &uuid) : m_uuid(uuid) -+ , m_jsSensor(Q_NULLPTR) -+{ -+ -+} -+ -+JsSensor::~JsSensor() -+{ -+ if (m_jsSensor) -+ m_jsSensor->call("destroySensor", m_uuid); -+} -+ -+qreal JsSensor::power(int id) const -+{ -+ qreal p = m_jsSensor->call("power", id); -+ return p; -+} -+ -+QString JsSensor::name(int id) const -+{ -+ QString n = m_jsSensor->call("sensorName", id); -+ return n; -+} -+ -+qreal JsSensor::maxRange(int id) const -+{ -+ qreal r = m_jsSensor->call("maxRange", id); -+ return r; -+} -+ -+qreal JsSensor::precision(int id) const -+{ -+ qreal accuracy = m_jsSensor->call("precision", id); -+ return accuracy; -+} -+ -+QString JsSensor::vendorName(int id) const -+{ -+ QString n = m_jsSensor->call("vendorName", id); -+ return n; -+} -+ -+QString JsSensor::description(int id) const -+{ -+ QString des = m_jsSensor->call("description", id); -+ return des; -+} -+ -+qreal JsSensor::minSamplePeriod(int id) const -+{ -+ qreal p = m_jsSensor->call("minSamplePeriod", id); -+ return p; -+} -+ -+qreal JsSensor::maxSamplePeriod(int id) const -+{ -+ qreal p = m_jsSensor->call("maxSamplePeriod", id); -+ return p; -+} -+ -+QString JsSensor::firmwareVersion(int id) const -+{ -+ QString v = m_jsSensor->call("firmwareVersion", id); -+ return v; -+} -+ -+void JsSensor::stop(int id) -+{ -+ m_jsSensor->call("stop", id); -+} -+ -+void JsSensor::start(int id, int rate) -+{ -+ m_jsSensor->call("start", id, rate); -+} -+ -+QString JsSensor::hardwareVersion(int id) const -+{ -+ QString hv = m_jsSensor->call("hardwareVersion", id); -+ return hv; -+} -+ -+SensorManager::SensorManager() { -+ m_sensors = qJsObjectLoader->create("qtsensors"); -+} -+ -+QList SensorManager::sensorIds() const -+{ -+ QStringList ids = m_sensors->call("sensorIds"); -+ QList ns; -+ ns.reserve(ids.size()); -+ for (const auto &id : qAsConst(ids)) { -+ ns.append(id.toInt()); -+ } -+ return ns; -+} -+ -+QSharedPointer &SensorManager::instance() -+{ -+ static QSharedPointer s{ new SensorManager() }; -+ return s; -+} -+ -+QSharedPointer SensorManager::createJsSensor(const QString &uuid, SensorBackendBase *backend) -+{ -+ JsSensor *s = new JsSensor(uuid); -+ m_sensors->call("createSensor", uuid, QVariant(qlonglong(backend))); -+ s->m_jsSensor.reset(new QOpenHarmonyJsObject(uuid)); -+ return QSharedPointer(s); -+} -+ -+void SensorManager::defineProperties(size_t property_count, const napi_property_descriptor *properties) -+{ -+ m_sensors->defineProperties(property_count, properties); -+} -+ -diff --git a/src/plugins/sensors/openharmony/sensormanager.h b/src/plugins/sensors/openharmony/sensormanager.h -new file mode 100644 -index 00000000..157baa3c ---- /dev/null -+++ b/src/plugins/sensors/openharmony/sensormanager.h -@@ -0,0 +1,69 @@ -+#ifndef SENSORMANAGER_H -+#define SENSORMANAGER_H -+ -+#include -+#include -+ -+/* NOTE 鸿蒙和Qt传感器匹配的项 -+ * Qt对前端传感器模块进行了封装 -+ * 鸿蒙提供的传感器模块接口不是 -+ * 完全匹配,需要转换 -+ */ -+enum { -+ E_GRAVITY = 257, /* 重力传感器<--->QAccelerometer */ -+ E_HUMIDITY = 13, /* 湿度传感器<--->QHumiditySensor */ -+ E_BAROMETER = 8, /* 气压传感器<--->QPressureSensor */ -+ E_GYROSCOPE = 2, /* 陀螺仪传感器<--->QGyroscope */ -+ E_PROXIMITY = 12, /* 接近光传感器<--->QDistanceSensor */ -+ E_ORIENTATION = 256, /* 方向传感器<--->QOrientationSensor */ -+ E_ACCELEROMETER = 1, /* 加速度传感器<--->QAccelerometer */ -+ E_AMBIENT_LIGHT = 5, /* 环境光传感器<--->QAmbientLightSensor */ -+ E_MAGNETIC_FIELD = 6, /* 磁场传感器<--->QMagnetometer */ -+ E_ROTATION_VECTOR = 259, /* 旋转矢量传感器<--->QRotationSensor */ -+ E_AMBIENT_TEMPERATURE = 260, /* 环境温度传感器<--->QAmbientTemperatureSensor */ -+ E_LINEAR_ACCELEROMETER = 258, /* 线性加速度传感器<--->QAccelerometer */ -+}; -+ -+class SensorBackendBase; -+class QOpenHarmonyJsObject; -+ -+class JsSensor -+{ -+ QString m_uuid; -+ QSharedPointer m_jsSensor; -+ -+ friend class SensorManager; -+public: -+ JsSensor(const QString &uuid); -+ ~JsSensor(); -+ -+ qreal power(int id) const; -+ QString name(int id) const; -+ qreal maxRange(int id) const; -+ qreal precision(int id) const; -+ QString vendorName(int id) const; -+ QString description(int id) const; -+ qreal minSamplePeriod(int id) const; -+ qreal maxSamplePeriod(int id) const; -+ QString firmwareVersion(int id) const; -+ QString hardwareVersion(int id) const; -+ -+ void stop(int id); -+ void start(int id, int rate); -+}; -+ -+class SensorManager -+{ -+ SensorManager(); -+ -+public: -+ QList sensorIds() const; -+ static QSharedPointer &instance(); -+ QSharedPointer createJsSensor(const QString &uuid, SensorBackendBase *backend); -+ void defineProperties(size_t property_count, const napi_property_descriptor* properties); -+ -+private: -+ QSharedPointer m_sensors; -+}; -+ -+#endif // SENSORMANAGER_H -diff --git a/src/plugins/sensors/sensors.pro b/src/plugins/sensors/sensors.pro -index 7fce2071..8037ffc4 100644 ---- a/src/plugins/sensors/sensors.pro -+++ b/src/plugins/sensors/sensors.pro -@@ -5,6 +5,10 @@ android { - isEmpty(SENSORS_PLUGINS): SENSORS_PLUGINS = android generic - } - -+openharmony { -+ isEmpty(SENSORS_PLUGINS): SENSORS_PLUGINS = openharmony generic -+} -+ - qtConfig(sensorfw) { - isEmpty(SENSORS_PLUGINS): SENSORS_PLUGINS = sensorfw generic - } -@@ -39,6 +43,7 @@ isEmpty(SENSORS_PLUGINS)|contains(SENSORS_PLUGINS, simulator):qtHaveModule(simul - isEmpty(SENSORS_PLUGINS)|contains(SENSORS_PLUGINS, linux):linux:SUBDIRS += linux - isEmpty(SENSORS_PLUGINS)|contains(SENSORS_PLUGINS, iio-sensor-proxy):linux:qtHaveModule(dbus):SUBDIRS += iio-sensor-proxy - isEmpty(SENSORS_PLUGINS)|contains(SENSORS_PLUGINS, android):android:SUBDIRS += android -+isEmpty(SENSORS_PLUGINS)|contains(SENSORS_PLUGINS, openharmony):openharmony:SUBDIRS += openharmony - isEmpty(SENSORS_PLUGINS)|contains(SENSORS_PLUGINS, sensorfw):sensorfw:SUBDIRS += sensorfw - isEmpty(SENSORS_PLUGINS)|contains(SENSORS_PLUGINS, sensortag):linux:SUBDIRS += sensortag - isEmpty(SENSORS_PLUGINS)|contains(SENSORS_PLUGINS, ios):darwin:SUBDIRS += ios -diff --git a/src/src.pro b/src/src.pro -index b3aa7ba0..df12cad0 100644 ---- a/src/src.pro -+++ b/src/src.pro -@@ -16,3 +16,6 @@ plugins.subdir = plugins - plugins.target = sub-plugins - plugins.depends = sensors - -+SUBDIRS += openharmony -+openharmony.subdir = openharmony -+openharmony.target = sub-openharmony -- Gitee From b83d63025d41707389e2e1d699bad9952e304868 Mon Sep 17 00:00:00 2001 From: wanghao Date: Mon, 9 Oct 2023 14:47:08 +0800 Subject: [PATCH 3/5] =?UTF-8?q?[add]=20=E6=B7=BB=E5=8A=A0qtsensors?= =?UTF-8?q?=E8=A1=A5=E4=B8=81?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: wanghao --- patch/qtsensor.patch | 1339 ++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 1339 insertions(+) create mode 100644 patch/qtsensor.patch diff --git a/patch/qtsensor.patch b/patch/qtsensor.patch new file mode 100644 index 0000000000..27f1499543 --- /dev/null +++ b/patch/qtsensor.patch @@ -0,0 +1,1339 @@ +diff --git a/src/openharmony/native/QtSensors.ts b/src/openharmony/native/QtSensors.ts +new file mode 100644 +index 00000000..8c7ad9a0 +--- /dev/null ++++ b/src/openharmony/native/QtSensors.ts +@@ -0,0 +1,132 @@ ++import sensor from '@ohos.sensor'; ++import qtsensorsplugin from 'libplugins_sensors_qtsensors_openharmony.so'; ++ ++export class QtSensors { ++ private pointerId = 0; ++ ++ public constructor(id) { ++ this.pointerId = id; ++ } ++ ++ /* Hz转ns,周期为1 */ ++ private hertz2ns(rate: Number) { ++ /* f=1/T （其中f是指赫兹,T是指以秒为单位的时间）*/ ++ let ns = (1 / Number(rate)) * 1000000000; ++ return ns; ++ } ++ ++ /* ns转Hz,周期为1 */ ++ private ns2hertz(ns: Number) { ++ /* f=1/T （其中f是指赫兹,T是指以秒为单位的时间）*/ ++ let hz = 1 / (Number(ns) / 1000000000); ++ return hz; ++ } ++ ++ createSensor(name, p) { ++ let server = new QtSensors(p); ++ Reflect.defineProperty(globalThis, name, { value: server }); ++ return true; ++ } ++ ++ destroySensor(name: string) { ++ Reflect.deleteProperty(globalThis, name); ++ this.pointerId = 0; ++ return true; ++ } ++ ++ /* 获取所有传感器类型Id */ ++ async sensorIds() { ++ let s: Array = new Array(); ++ try { ++ let sr = await sensor.getSensorList(); ++ for (let data of sr) { ++ s.push(String(data.sensorId)); ++ } ++ } catch (e) { ++ console.error(`Failed to get sensorList. Code: ${e.code}, message: ${e.message}`); ++ } ++ return s; ++ } ++ ++ stop(type: sensor.SensorId) { ++ try { ++ sensor.off(Number(type)); ++ } catch (error) { ++ console.error(`Failed to invoke off. Code: ${error.code}, message: ${error.message}`); ++ } ++ } ++ ++ /* 开始订阅传感器数据 */ ++ async start(type: sensor.SensorId, rate: Number) { ++ try { ++ this.stop(type); ++ let ns = this.hertz2ns(rate); ++ let max = await this.maxSamplePeriod(type); ++ let min = await this.minSamplePeriod(type); ++ let iv = Math.max(Math.min(max, ns), min); ++ ++ sensor.on(Number(type), (data) => { ++ qtsensorsplugin.DataAcception(this.pointerId, JSON.stringify(data)); ++ }, { interval: iv }); ++ } catch (error) { ++ console.error(`Failed to invoke on. Code: ${error.code}, message: ${error.message}`); ++ } ++ } ++ ++ /* 获取指定传感器信息 */ ++ async description(type: sensor.SensorId) { ++ try { ++ let info = await sensor.getSingleSensor(type); ++ let des = JSON.stringify(info); ++ console.info('Succeeded in getting sensor: ' + des); ++ return des; ++ } catch (e) { ++ console.error(`Failed to get singleSensor . Code: ${e.code}, message: ${e.message}`); ++ } ++ } ++ ++ async sensorName(type: sensor.SensorId) { ++ let s = await sensor.getSingleSensor(type); ++ return s.sensorName; ++ } ++ ++ async vendorName(type: sensor.SensorId) { ++ let s = await sensor.getSingleSensor(type); ++ return s.vendorName; ++ } ++ ++ async firmwareVersion(type: sensor.SensorId) { ++ let s = await sensor.getSingleSensor(type); ++ return s.firmwareVersion; ++ } ++ ++ async hardwareVersion(type: sensor.SensorId) { ++ let s = await sensor.getSingleSensor(type); ++ return s.hardwareVersion; ++ } ++ ++ async maxRange(type: sensor.SensorId) { ++ let s = await sensor.getSingleSensor(type); ++ return s.maxRange; ++ } ++ ++ async minSamplePeriod(type: sensor.SensorId) { ++ let s = await sensor.getSingleSensor(type); ++ return this.ns2hertz(s.minSamplePeriod); ++ } ++ ++ async maxSamplePeriod(type: sensor.SensorId) { ++ let s = await sensor.getSingleSensor(type); ++ return this.ns2hertz(s.minSamplePeriod); ++ } ++ ++ async precision(type: sensor.SensorId) { ++ let s = await sensor.getSingleSensor(type); ++ return s.precision; ++ } ++ ++ async power(type: sensor.SensorId) { ++ let s = await sensor.getSingleSensor(type); ++ return s.minSamplePeriod; ++ } ++} +\ No newline at end of file +diff --git a/src/openharmony/openharmony.pro b/src/openharmony/openharmony.pro +new file mode 100644 +index 00000000..6f56bfea +--- /dev/null ++++ b/src/openharmony/openharmony.pro +@@ -0,0 +1,11 @@ ++TEMPLATE = aux ++ ++CONFIG -= qt ++ ++templates.files += $$files($$PWD/native/*.ts, true) ++templates.path = $$[QT_INSTALL_PREFIX]/openharmony/qtsensors ++templates.base = $$PWD ++ ++INSTALLS += templates ++ ++OTHER_FILES += $$templates.files +diff --git a/src/plugins/sensors/openharmony/main.cpp b/src/plugins/sensors/openharmony/main.cpp +new file mode 100644 +index 00000000..c14f6520 +--- /dev/null ++++ b/src/plugins/sensors/openharmony/main.cpp +@@ -0,0 +1,222 @@ ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++ ++#include "sensormanager.h" ++#include "sensorbackend.h" ++#include ++#include "openharmonylight.h" ++#include "openharmonyrotation.h" ++#include "openharmonyhumidity.h" ++#include "openharmonypressure.h" ++#include "openharmonyproximity.h" ++#include "openharmonygyroscope.h" ++#include "openharmonytemperature.h" ++#include "openharmonymagnetometer.h" ++#include "openharmonyaccelerometer.h" ++#include "QtCore/qopenharmonydefines.h" ++#include "QtCore/qopenharmonyjsenvironment.h" ++ ++ ++static napi_value DataAcception(napi_env env, napi_callback_info info) ++{ ++ size_t argc = 2; ++ napi_value args[2] = { Q_NULLPTR }; ++ napi_get_cb_info(env, info, &argc, args , nullptr, nullptr); ++ ++ if (argc != 2) { ++ napi_throw_type_error(env, NULL, "Wrong number of arguments in DataAcception"); ++ return nullptr; ++ } ++ int64_t value0 = qJs::getInt64(args[0]); ++ SensorBackendBase *backend = reinterpret_cast(value0); ++ if (backend == nullptr) ++ return Q_NULLPTR; ++ ++ ++ SensorBackendBase *sensor = reinterpret_cast(value0); ++ if (Q_NULLPTR == sensor) ++ return Q_NULLPTR; ++ ++ QByteArray data = qJs::getString(args[1]).toLocal8Bit(); ++ if (data.isEmpty()) ++ return Q_NULLPTR; ++ ++ QJsonParseError err; ++ const QJsonDocument &doc = QJsonDocument::fromJson(data, &err); ++ if (QJsonParseError::NoError != err.error) ++ return Q_NULLPTR; ++ ++ ++ //sensor->dataReceived(doc.object()); ++ QMetaObject::invokeMethod(sensor, "dataReceived", ++ Qt::QueuedConnection, ++ Q_ARG(QJsonObject, doc.object())); ++ return Q_NULLPTR; ++} ++ ++namespace { ++const char OPenHarmonyCompassId[] = "openharmony.synthetic.compass"; ++} ++ ++class OPenHarmonySensorPlugin : public QObject, public QSensorPluginInterface, ++ public QSensorBackendFactory ++{ ++ Q_OBJECT ++ Q_PLUGIN_METADATA(IID "com.qt-project.Qt.QSensorPluginInterface/1.0" FILE "plugin.json") ++ Q_INTERFACES(QSensorPluginInterface) ++ ++public: ++ void registerSensors() override ++ { ++ bool accelerometer = false; ++ bool magnetometer = false; ++ const QList &ids = SensorManager::instance()->sensorIds(); ++ for (int sensor : qAsConst(ids)) { ++ switch (sensor) { ++ case E_BAROMETER: ++ QSensorManager::registerBackend(QPressureSensor::type, QByteArray::number(sensor), this); ++ break; ++ case E_ACCELEROMETER: ++ m_accelerationModes |= OPenHarmonyAccelerometer::Accelerometer; ++ QSensorManager::registerBackend(QAccelerometer::type, QByteArray::number(sensor), this); ++ accelerometer = true; ++ break; ++ case E_LINEAR_ACCELEROMETER: ++ m_accelerationModes |= OPenHarmonyAccelerometer::LinearAcceleration; ++ //QSensorManager::registerBackend(QAccelerometer::type, QByteArray::number(sensor), this); ++ break; ++ case E_GRAVITY: ++ m_accelerationModes |= OPenHarmonyAccelerometer::Gravity; ++ //QSensorManager::registerBackend(QAccelerometer::type, QByteArray::number(sensor), this); ++ break; ++ case E_HUMIDITY: ++ QSensorManager::registerBackend(QHumiditySensor::type, QByteArray::number(sensor), this); ++ break; ++ case E_PROXIMITY: ++ QSensorManager::registerBackend(QProximitySensor::type, QByteArray::number(sensor), this); ++ break; ++ case E_GYROSCOPE: ++ QSensorManager::registerBackend(QGyroscope::type, QByteArray::number(sensor), this); ++ break; ++ case E_ORIENTATION: ++ /*FIXME 通过加速度传感器实现? */ ++ //QSensorManager::registerBackend(QOrientationSensor::type, QByteArray::number(sensor), this); ++ break; ++ case E_ROTATION_VECTOR: ++ QSensorManager::registerBackend(QRotationSensor::type, QByteArray::number(sensor), this); ++ break; ++ case E_AMBIENT_LIGHT: ++ QSensorManager::registerBackend(QAmbientLightSensor::type, QByteArray::number(sensor), this); ++ break; ++ case E_MAGNETIC_FIELD: ++ QSensorManager::registerBackend(QMagnetometer::type, QByteArray::number(sensor), this); ++ magnetometer = true; ++ break; ++ case E_AMBIENT_TEMPERATURE: ++ QSensorManager::registerBackend(QAmbientTemperatureSensor::type, QByteArray::number(sensor), this); ++ break; ++ default: ++ break; ++ } ++ } ++#if 0 ++ /* NOTE 现在的js回调机制不支持 ++ * 罗盘通过加速度和磁场传感器组合实现 ++ */ ++ if (accelerometer && magnetometer) ++ QSensorManager::registerBackend(QCompass::type, OPenHarmonyCompassId, this); ++#endif ++ } ++ ++ QSensorBackend *createBackend(QSensor *sensor) override ++ { ++ /* TODO QCompass */ ++ int id = sensor->identifier().toInt(); ++ switch (id) { ++ case E_BAROMETER: ++ return new OPenHarmonyPressure(id, sensor); ++ case E_ACCELEROMETER: ++ return new OPenHarmonyAccelerometer(m_accelerationModes, sensor); ++ case E_GYROSCOPE: ++ return new OPenHarmonyGyroscope(id, sensor); ++ case E_PROXIMITY: ++ return new OPenHarmonyProximity(id, sensor); ++ case E_AMBIENT_LIGHT: ++ return new OPenHarmonyLight(id, sensor); ++ case E_MAGNETIC_FIELD: ++ return new OPenHarmonyMagnetometer(id, sensor); ++ case E_HUMIDITY: ++ return new OPenHarmonyHumidity(id, sensor); ++ case E_ROTATION_VECTOR: ++ return new OPenHarmonyRotation(id, sensor); ++ case E_AMBIENT_TEMPERATURE: ++ return new OPenHarmonyTemperature(id, sensor); ++ default: ++ break; ++ } ++ return Q_NULLPTR; ++ } ++ ++private: ++ int m_accelerationModes = 0; ++}; ++ ++/* ++ * function for module exports ++ */ ++EXTERN_C_START ++static napi_value Init(napi_env env, napi_value exports) ++{ ++ static bool inited = false; ++ if (!inited) { ++ ++ LOGI("init sensors module"); ++ napi_property_descriptor desc[] ={ ++ DECLARE_NAPI_FUNCTION("DataAcception", DataAcception), ++ }; ++ NAPI_CALL(env, napi_define_properties(env, exports, sizeof(desc) / sizeof(desc[0]), desc)); ++ inited = true; ++ } ++ return exports; ++} ++EXTERN_C_END ++ ++/* ++ * Napi Module define ++ */ ++static napi_module openharmonyQtSensorsModule = { ++ .nm_version = 1, ++ .nm_flags = 0, ++ .nm_filename = nullptr, ++ .nm_register_func = Init, ++ .nm_modname = "openharmony_qt_sensors", ++ .nm_priv = ((void*)0), ++ .reserved = { 0 }, ++}; ++/* ++ * Module register function ++ */ ++extern "C" __attribute__((constructor)) void RegisterModule(void) ++{ ++ napi_module_register(&openharmonyQtSensorsModule); ++} ++ ++#include "main.moc" +diff --git a/src/plugins/sensors/openharmony/openharmony.pro b/src/plugins/sensors/openharmony/openharmony.pro +new file mode 100644 +index 00000000..390e904c +--- /dev/null ++++ b/src/plugins/sensors/openharmony/openharmony.pro +@@ -0,0 +1,36 @@ ++TARGET = qtsensors_openharmony ++QT = core sensors ++ ++OTHER_FILES = plugin.json ++ ++SOURCES += \ ++ main.cpp \ ++ openharmonyaccelerometer.cpp \ ++ openharmonygyroscope.cpp \ ++ openharmonyhumidity.cpp \ ++ openharmonylight.cpp \ ++ openharmonymagnetometer.cpp \ ++ openharmonypressure.cpp \ ++ openharmonyproximity.cpp \ ++ openharmonyrotation.cpp \ ++ openharmonytemperature.cpp \ ++ sensormanager.cpp ++ ++ ++PLUGIN_TYPE = sensors ++PLUGIN_CLASS_NAME = OPenHarmonySensorPlugin ++load(qt_plugin) ++ ++HEADERS += \ ++ openharmonyaccelerometer.h \ ++ openharmonygyroscope.h \ ++ openharmonyhumidity.h \ ++ openharmonylight.h \ ++ openharmonymagnetometer.h \ ++ openharmonypressure.h \ ++ openharmonyproximity.h \ ++ openharmonyrotation.h \ ++ openharmonytemperature.h \ ++ sensorbackend.h \ ++ sensormanager.h ++ +diff --git a/src/plugins/sensors/openharmony/openharmonyaccelerometer.cpp b/src/plugins/sensors/openharmony/openharmonyaccelerometer.cpp +new file mode 100644 +index 00000000..84ad1e53 +--- /dev/null ++++ b/src/plugins/sensors/openharmony/openharmonyaccelerometer.cpp +@@ -0,0 +1,71 @@ ++#include ++#include ++#include ++ ++#include "openharmonyaccelerometer.h" ++ ++OPenHarmonyAccelerometer::OPenHarmonyAccelerometer(int accelerationModes, QSensor *sensor, QObject *parent) ++ : SensorBackend(E_ACCELEROMETER, sensor, parent) ++ , m_accelerationModes(accelerationModes) ++{ ++ auto accelerometer = qobject_cast(sensor); ++ if (accelerometer) { ++ connect(accelerometer, &QAccelerometer::accelerationModeChanged, ++ this, &OPenHarmonyAccelerometer::applyAccelerationMode); ++ applyAccelerationMode(accelerometer->accelerationMode()); ++ } ++} ++ ++bool OPenHarmonyAccelerometer::isFeatureSupported(QSensor::Feature feature) const ++{ ++ return (feature == QSensor::AccelerationMode) ? m_accelerationModes == AllModes : SensorBackend::isFeatureSupported(feature); ++} ++ ++void OPenHarmonyAccelerometer::dataReceived(const QJsonObject &json) ++{ ++ double x = json.value("x").toDouble(); ++ double y = json.value("y").toDouble(); ++ double z = json.value("z").toDouble(); ++ ++ if (sensor()->skipDuplicates() && qFuzzyCompare(m_reader.x(), x) && ++ qFuzzyCompare(m_reader.y(), y) && ++ qFuzzyCompare(m_reader.z(), z)) { ++ return; ++ } ++ ++ double timestamp = json.value("timestamp").toDouble(); ++ m_reader.setTimestamp(quint64(timestamp)); ++ m_reader.setX(x); ++ m_reader.setY(y); ++ m_reader.setZ(z); ++ ++ newReadingAvailable(); ++} ++ ++void OPenHarmonyAccelerometer::applyAccelerationMode(QAccelerometer::AccelerationMode accelerationMode) ++{ ++ switch (accelerationMode) { ++ case QAccelerometer::Gravity: ++ if (!(m_accelerationModes & Gravity)) { ++ qWarning() << "Gravity sensor missing"; ++ return; ++ } ++ setSensorType(E_GRAVITY); ++ break; ++ case QAccelerometer::User: ++ if (!(m_accelerationModes & LinearAcceleration)) { ++ qWarning() << "Linear acceleration sensor missing"; ++ return; ++ } ++ setSensorType(E_LINEAR_ACCELEROMETER); ++ break; ++ case QAccelerometer::Combined: ++ if (!(m_accelerationModes & Accelerometer)) { ++ qWarning() << "Accelerometer sensor missing"; ++ return; ++ } ++ setSensorType(E_ACCELEROMETER); ++ break; ++ } ++} ++ +diff --git a/src/plugins/sensors/openharmony/openharmonyaccelerometer.h b/src/plugins/sensors/openharmony/openharmonyaccelerometer.h +new file mode 100644 +index 00000000..a610d25b +--- /dev/null ++++ b/src/plugins/sensors/openharmony/openharmonyaccelerometer.h +@@ -0,0 +1,32 @@ ++#ifndef OPENHARMONYACCELEROMETER_H ++#define OPENHARMONYACCELEROMETER_H ++ ++#include ++ ++#include "sensorbackend.h" ++ ++class OPenHarmonyAccelerometer : public SensorBackend ++{ ++ Q_OBJECT ++ ++public: ++ enum AccelerationModes { ++ Accelerometer = 1, ++ Gravity = 2, ++ LinearAcceleration = 4, ++ AllModes = (Accelerometer | Gravity | LinearAcceleration) ++ }; ++ OPenHarmonyAccelerometer(int accelerationModes, QSensor *sensor, QObject *parent = nullptr); ++ bool isFeatureSupported(QSensor::Feature feature) const override; ++ ++protected Q_SLOTS: ++ void dataReceived(const QJsonObject &json) override; ++ ++private: ++ void applyAccelerationMode(QAccelerometer::AccelerationMode accelerationMode); ++ ++private: ++ int m_accelerationModes; ++}; ++ ++#endif // OPENHARMONYACCELEROMETER_H +diff --git a/src/plugins/sensors/openharmony/openharmonygyroscope.cpp b/src/plugins/sensors/openharmony/openharmonygyroscope.cpp +new file mode 100644 +index 00000000..349b7e2f +--- /dev/null ++++ b/src/plugins/sensors/openharmony/openharmonygyroscope.cpp +@@ -0,0 +1,33 @@ ++#include ++#include ++#include ++ ++#include "openharmonygyroscope.h" ++ ++OPenHarmonyGyroscope::OPenHarmonyGyroscope(int type, QSensor *sensor, QObject *parent) ++: SensorBackend(type, sensor, parent) ++{ ++ ++} ++ ++void OPenHarmonyGyroscope::dataReceived(const QJsonObject &json) ++{ ++ double x = qRadiansToDegrees(json.value("x").toDouble()); ++ double y = qRadiansToDegrees(json.value("y").toDouble()); ++ double z = qRadiansToDegrees(json.value("z").toDouble()); ++ double timestamp = json.value("timestamp").toDouble(); ++ ++ if (sensor()->skipDuplicates() && qFuzzyCompare(m_reader.x(), x) && ++ qFuzzyCompare(m_reader.y(), y) && ++ qFuzzyCompare(m_reader.z(), z)) { ++ return; ++ } ++ ++ m_reader.setTimestamp(quint64(timestamp)); ++ m_reader.setX(x); ++ m_reader.setY(y); ++ m_reader.setZ(z); ++ ++ newReadingAvailable(); ++} ++ +diff --git a/src/plugins/sensors/openharmony/openharmonygyroscope.h b/src/plugins/sensors/openharmony/openharmonygyroscope.h +new file mode 100644 +index 00000000..ff3e6d2a +--- /dev/null ++++ b/src/plugins/sensors/openharmony/openharmonygyroscope.h +@@ -0,0 +1,18 @@ ++#ifndef OPENHARMONYGYROSCOPE_H ++#define OPENHARMONYGYROSCOPE_H ++ ++#include ++ ++#include "sensorbackend.h" ++ ++class OPenHarmonyGyroscope : public SensorBackend ++{ ++ Q_OBJECT ++public: ++ OPenHarmonyGyroscope(int type, QSensor *sensor, QObject *parent = nullptr); ++ ++protected Q_SLOTS: ++ void dataReceived(const QJsonObject &json) override; ++}; ++ ++#endif // OPENHARMONYGYROSCOPE_H +diff --git a/src/plugins/sensors/openharmony/openharmonyhumidity.cpp b/src/plugins/sensors/openharmony/openharmonyhumidity.cpp +new file mode 100644 +index 00000000..e17df8cf +--- /dev/null ++++ b/src/plugins/sensors/openharmony/openharmonyhumidity.cpp +@@ -0,0 +1,25 @@ ++#include ++#include ++ ++#include "openharmonyhumidity.h" ++ ++OPenHarmonyHumidity::OPenHarmonyHumidity(int type, QSensor *sensor, QObject *parent) ++ : SensorBackend(type, sensor, parent) ++{ ++ ++} ++ ++void OPenHarmonyHumidity::dataReceived(const QJsonObject &json) ++{ ++ qreal humidity = json.value("humidity").toDouble(); ++ ++ if (sensor()->skipDuplicates() && qFuzzyCompare(humidity, m_reader.relativeHumidity())) ++ return; ++ ++ double timestamp = json.value("timestamp").toDouble(); ++ m_reader.setTimestamp(quint64(timestamp)); ++ m_reader.setAbsoluteHumidity(0.f); ++ m_reader.setRelativeHumidity(humidity); ++ newReadingAvailable(); ++} ++ +diff --git a/src/plugins/sensors/openharmony/openharmonyhumidity.h b/src/plugins/sensors/openharmony/openharmonyhumidity.h +new file mode 100644 +index 00000000..adbf4c9b +--- /dev/null ++++ b/src/plugins/sensors/openharmony/openharmonyhumidity.h +@@ -0,0 +1,18 @@ ++#ifndef OPENHARMONYHUMIDITY_H ++#define OPENHARMONYHUMIDITY_H ++ ++#include ++ ++#include "sensorbackend.h" ++ ++class OPenHarmonyHumidity : public SensorBackend ++{ ++ Q_OBJECT ++public: ++ OPenHarmonyHumidity(int type, QSensor *sensor, QObject *parent = nullptr); ++ ++protected Q_SLOTS: ++ void dataReceived(const QJsonObject &json) override; ++}; ++ ++#endif // OPENHARMONYHUMIDITY_H +diff --git a/src/plugins/sensors/openharmony/openharmonylight.cpp b/src/plugins/sensors/openharmony/openharmonylight.cpp +new file mode 100644 +index 00000000..7274df7c +--- /dev/null ++++ b/src/plugins/sensors/openharmony/openharmonylight.cpp +@@ -0,0 +1,23 @@ ++#include ++#include ++ ++#include "openharmonylight.h" ++ ++OPenHarmonyLight::OPenHarmonyLight(int type, QSensor *sensor, QObject *parent) ++ : SensorBackend(type, sensor, parent) ++{ ++ ++} ++ ++void OPenHarmonyLight::dataReceived(const QJsonObject &json) ++{ ++ double intensity = json.value("intensity").toDouble(); ++ ++ if (sensor()->skipDuplicates() && qFuzzyCompare(m_reader.lux(), intensity)) ++ return; ++ ++ double timestamp = json.value("timestamp").toDouble(); ++ m_reader.setTimestamp(quint64(timestamp)); ++ m_reader.setLux(qreal(intensity)); ++ newReadingAvailable(); ++} +diff --git a/src/plugins/sensors/openharmony/openharmonylight.h b/src/plugins/sensors/openharmony/openharmonylight.h +new file mode 100644 +index 00000000..f8039a92 +--- /dev/null ++++ b/src/plugins/sensors/openharmony/openharmonylight.h +@@ -0,0 +1,18 @@ ++#ifndef OPENHARMONYLIGHT_H ++#define OPENHARMONYLIGHT_H ++ ++#include ++ ++#include "sensorbackend.h" ++ ++class OPenHarmonyLight : public SensorBackend ++{ ++ Q_OBJECT ++public: ++ OPenHarmonyLight(int type, QSensor *sensor, QObject *parent = nullptr); ++ ++protected Q_SLOTS: ++ void dataReceived(const QJsonObject &json) override; ++}; ++ ++#endif // OPENHARMONYLIGHT_H +diff --git a/src/plugins/sensors/openharmony/openharmonymagnetometer.cpp b/src/plugins/sensors/openharmony/openharmonymagnetometer.cpp +new file mode 100644 +index 00000000..34e34b21 +--- /dev/null ++++ b/src/plugins/sensors/openharmony/openharmonymagnetometer.cpp +@@ -0,0 +1,32 @@ ++#include ++#include ++#include "openharmonymagnetometer.h" ++ ++OPenHarmonyMagnetometer::OPenHarmonyMagnetometer(int type, QSensor *sensor, QObject *parent) ++ : SensorBackend(type, sensor, parent) ++{ ++ ++} ++ ++void OPenHarmonyMagnetometer::dataReceived(const QJsonObject &json) ++{ ++ double x = json.value("x").toDouble(); ++ double y = json.value("y").toDouble(); ++ double z = json.value("z").toDouble(); ++ ++ if (sensor()->skipDuplicates() && qFuzzyCompare(m_accuracy, m_reader.calibrationLevel()) && ++ qFuzzyCompare(x, m_reader.x()) && ++ qFuzzyCompare(y, m_reader.y()) && ++ qFuzzyCompare(z, m_reader.z())) { ++ return; ++ } ++ ++ m_reader.setCalibrationLevel(m_accuracy); ++ double timestamp = json.value("timestamp").toDouble(); ++ m_reader.setTimestamp(quint64(timestamp)); ++ m_reader.setX(x); ++ m_reader.setY(y); ++ m_reader.setZ(z); ++ newReadingAvailable(); ++} ++ +diff --git a/src/plugins/sensors/openharmony/openharmonymagnetometer.h b/src/plugins/sensors/openharmony/openharmonymagnetometer.h +new file mode 100644 +index 00000000..c3662243 +--- /dev/null ++++ b/src/plugins/sensors/openharmony/openharmonymagnetometer.h +@@ -0,0 +1,18 @@ ++#ifndef OPENHARMONYMAGNETOMETER_H ++#define OPENHARMONYMAGNETOMETER_H ++ ++#include ++ ++#include "sensorbackend.h" ++ ++class OPenHarmonyMagnetometer : public SensorBackend ++{ ++ Q_OBJECT ++public: ++ OPenHarmonyMagnetometer(int type, QSensor *sensor, QObject *parent = nullptr); ++ ++protected Q_SLOTS: ++ void dataReceived(const QJsonObject &json) override; ++}; ++ ++#endif // OPENHARMONYMAGNETOMETER_H +diff --git a/src/plugins/sensors/openharmony/openharmonypressure.cpp b/src/plugins/sensors/openharmony/openharmonypressure.cpp +new file mode 100644 +index 00000000..c7d5d3d3 +--- /dev/null ++++ b/src/plugins/sensors/openharmony/openharmonypressure.cpp +@@ -0,0 +1,22 @@ ++#include ++#include ++ ++#include "openharmonypressure.h" ++ ++OPenHarmonyPressure::OPenHarmonyPressure(int type, QSensor *sensor, QObject *parent) ++ : SensorBackend(type, sensor, parent) ++{ ++ ++} ++ ++void OPenHarmonyPressure::dataReceived(const QJsonObject &json) ++{ ++ auto pressurePa = json.value("pressure").toDouble(); ++ if (sensor()->skipDuplicates() && qFuzzyCompare(pressurePa, m_reader.pressure())) ++ return; ++ ++ double timestamp = json.value("timestamp").toDouble(); ++ m_reader.setTimestamp(quint64(timestamp)); ++ m_reader.setPressure(pressurePa); ++ newReadingAvailable(); ++} +diff --git a/src/plugins/sensors/openharmony/openharmonypressure.h b/src/plugins/sensors/openharmony/openharmonypressure.h +new file mode 100644 +index 00000000..8c2db8aa +--- /dev/null ++++ b/src/plugins/sensors/openharmony/openharmonypressure.h +@@ -0,0 +1,18 @@ ++#ifndef OPENHARMONYPRESSURE_H ++#define OPENHARMONYPRESSURE_H ++ ++#include ++ ++#include "sensorbackend.h" ++ ++class OPenHarmonyPressure : public SensorBackend ++{ ++ Q_OBJECT ++public: ++ OPenHarmonyPressure(int type, QSensor *sensor, QObject *parent = nullptr); ++ ++protected Q_SLOTS: ++ void dataReceived(const QJsonObject &json) override; ++}; ++ ++#endif // OPENHARMONYPRESSURE_H +diff --git a/src/plugins/sensors/openharmony/openharmonyproximity.cpp b/src/plugins/sensors/openharmony/openharmonyproximity.cpp +new file mode 100644 +index 00000000..e96a0b24 +--- /dev/null ++++ b/src/plugins/sensors/openharmony/openharmonyproximity.cpp +@@ -0,0 +1,28 @@ ++#include ++#include ++ ++#include "openharmonyproximity.h" ++ ++OPenHarmonyProximity::OPenHarmonyProximity(int type, QSensor *sensor, QObject *parent) ++ : SensorBackend(type, sensor, parent) ++{ ++ m_maximumRange = m_jsSensor->maxRange(m_type); ++ ++ // if we can't get the range, we arbitrarily define anything closer than 10 cm as "close" ++ if (m_maximumRange <= 0) ++ m_maximumRange = 10.0; ++} ++ ++void OPenHarmonyProximity::dataReceived(const QJsonObject &json) ++{ ++ qreal distance = json.value("distance").toDouble(); ++ bool close = distance < m_maximumRange; ++ if (sensor()->skipDuplicates() && close == m_reader.close()) ++ return; ++ ++ double timestamp = json.value("timestamp").toDouble(); ++ m_reader.setTimestamp(quint64(timestamp)); ++ m_reader.setClose(close); ++ newReadingAvailable(); ++} ++ +diff --git a/src/plugins/sensors/openharmony/openharmonyproximity.h b/src/plugins/sensors/openharmony/openharmonyproximity.h +new file mode 100644 +index 00000000..f1ef02f2 +--- /dev/null ++++ b/src/plugins/sensors/openharmony/openharmonyproximity.h +@@ -0,0 +1,21 @@ ++#ifndef OPENHARMONYPROXIMITY_H ++#define OPENHARMONYPROXIMITY_H ++ ++#include ++ ++#include "sensorbackend.h" ++ ++class OPenHarmonyProximity : public SensorBackend ++{ ++ Q_OBJECT ++public: ++ OPenHarmonyProximity(int type, QSensor *sensor, QObject *parent = nullptr); ++ ++protected Q_SLOTS: ++ void dataReceived(const QJsonObject &json) override; ++ ++private: ++ qreal m_maximumRange; ++}; ++ ++#endif // OPENHARMONYPROXIMITY_H +diff --git a/src/plugins/sensors/openharmony/openharmonyrotation.cpp b/src/plugins/sensors/openharmony/openharmonyrotation.cpp +new file mode 100644 +index 00000000..a4d70e6f +--- /dev/null ++++ b/src/plugins/sensors/openharmony/openharmonyrotation.cpp +@@ -0,0 +1,29 @@ ++#include ++#include ++#include ++ ++#include "openharmonyrotation.h" ++ ++OPenHarmonyRotation::OPenHarmonyRotation(int type, QSensor *sensor, QObject *parent) ++ : SensorBackend(type, sensor, parent) ++{ ++ ++} ++ ++void OPenHarmonyRotation::dataReceived(const QJsonObject &json) ++{ ++ qreal rz = -qRadiansToDegrees(json.value("x").toDouble()); //corresponds to x ++ qreal rx = -qRadiansToDegrees(json.value("y").toDouble()); //corresponds to y ++ qreal ry = qRadiansToDegrees(json.value("z").toDouble()); //corresponds to z ++ if (sensor()->skipDuplicates() && qFuzzyCompare(m_reader.x(), rx) && ++ qFuzzyCompare(m_reader.y(), ry) && ++ qFuzzyCompare(m_reader.z(), rz)) { ++ return; ++ } ++ ++ double timestamp = json.value("timestamp").toDouble(); ++ m_reader.setTimestamp(quint64(timestamp)); ++ m_reader.setFromEuler(rx, ry, rz); ++ newReadingAvailable(); ++} ++ +diff --git a/src/plugins/sensors/openharmony/openharmonyrotation.h b/src/plugins/sensors/openharmony/openharmonyrotation.h +new file mode 100644 +index 00000000..03243797 +--- /dev/null ++++ b/src/plugins/sensors/openharmony/openharmonyrotation.h +@@ -0,0 +1,18 @@ ++#ifndef OPENHARMONYROTATION_H ++#define OPENHARMONYROTATION_H ++ ++#include ++ ++#include "sensorbackend.h" ++ ++class OPenHarmonyRotation : public SensorBackend ++{ ++ Q_OBJECT ++public: ++ OPenHarmonyRotation(int type, QSensor *sensor, QObject *parent = nullptr); ++ ++protected Q_SLOTS: ++ void dataReceived(const QJsonObject &json) override; ++}; ++ ++#endif // OPENHARMONYROTATION_H +diff --git a/src/plugins/sensors/openharmony/openharmonytemperature.cpp b/src/plugins/sensors/openharmony/openharmonytemperature.cpp +new file mode 100644 +index 00000000..a3865b03 +--- /dev/null ++++ b/src/plugins/sensors/openharmony/openharmonytemperature.cpp +@@ -0,0 +1,23 @@ ++#include ++#include ++ ++#include "openharmonytemperature.h" ++ ++OPenHarmonyTemperature::OPenHarmonyTemperature(int type, QSensor *sensor, QObject *parent) ++ : SensorBackend(type, sensor, parent) ++{ ++ ++} ++ ++void OPenHarmonyTemperature::dataReceived(const QJsonObject &json) ++{ ++ qreal temperature = json.value("temperature").toDouble(); ++ if (sensor()->skipDuplicates() && qFuzzyCompare(m_reader.temperature(), temperature)) ++ return; ++ ++ double timestamp = json.value("timestamp").toDouble(); ++ m_reader.setTimestamp(quint64(timestamp)); ++ m_reader.setTemperature(temperature); // in degree Celsius ++ newReadingAvailable(); ++} ++ +diff --git a/src/plugins/sensors/openharmony/openharmonytemperature.h b/src/plugins/sensors/openharmony/openharmonytemperature.h +new file mode 100644 +index 00000000..cc881f20 +--- /dev/null ++++ b/src/plugins/sensors/openharmony/openharmonytemperature.h +@@ -0,0 +1,18 @@ ++#ifndef OPENHARMONYTEMPERATURE_H ++#define OPENHARMONYTEMPERATURE_H ++ ++#include ++ ++#include "sensorbackend.h" ++ ++class OPenHarmonyTemperature : public SensorBackend ++{ ++ Q_OBJECT ++public: ++ OPenHarmonyTemperature(int type, QSensor *sensor, QObject *parent = nullptr); ++ ++protected Q_SLOTS: ++ void dataReceived(const QJsonObject &json) override; ++}; ++ ++#endif // OPENHARMONYTEMPERATURE_H +diff --git a/src/plugins/sensors/openharmony/plugin.json b/src/plugins/sensors/openharmony/plugin.json +new file mode 100644 +index 00000000..ff40b670 +--- /dev/null ++++ b/src/plugins/sensors/openharmony/plugin.json +@@ -0,0 +1 @@ ++{ "Keys": [ "openharmony" ] } +diff --git a/src/plugins/sensors/openharmony/sensorbackend.h b/src/plugins/sensors/openharmony/sensorbackend.h +new file mode 100644 +index 00000000..aa0907df +--- /dev/null ++++ b/src/plugins/sensors/openharmony/sensorbackend.h +@@ -0,0 +1,91 @@ ++#ifndef SENSORBACKEND_H ++#define SENSORBACKEND_H ++ ++#include ++#include ++ ++#include "sensormanager.h" ++ ++class SensorBackendBase : public QSensorBackend ++{ ++public: ++ SensorBackendBase(QSensor *sensor, QObject *parent = nullptr) ++ : QSensorBackend(sensor, parent) ++ , m_jsSensor(Q_NULLPTR) ++ { ++ QString tempUuid = QUuid::createUuid().toString(); ++ tempUuid.chop(1); //remove trailing '}' ++ tempUuid.remove(0,1); //remove first '{' ++ ++ m_jsSensor = SensorManager::instance()->createJsSensor(tempUuid, this); ++ } ++ ++public Q_SLOTS: ++ virtual void dataReceived(const QJsonObject &json) = 0; ++ ++protected: ++ QSharedPointer m_jsSensor; ++}; ++ ++template ++class SensorBackend : public SensorBackendBase ++{ ++public: ++ explicit SensorBackend(int type, QSensor *sensor, QObject *parent = nullptr) : m_type(0) ++ , SensorBackendBase{ sensor, parent } ++ { ++ setReading(&m_reader); ++ setSensorType(type); ++ m_accuracy = m_jsSensor->precision(type); ++ addDataRate(m_jsSensor->minSamplePeriod(type), ++ m_jsSensor->maxSamplePeriod(type)); ++ addOutputRange(0, m_jsSensor->maxRange(type), m_accuracy); ++ } ++ ++ ~SensorBackend() override ++ { ++ stop(); ++ } ++ ++ void setSensorType(int type) ++ { ++ m_type = type; ++ bool started = m_started; ++ if (started) ++ stop(); ++ ++ setDescription(m_jsSensor->description(type)); ++ if (started) ++ start(); ++ } ++ ++ virtual void start() override ++ { ++ m_jsSensor->start(m_type, sensor()->dataRate()); ++ m_started = true; ++ } ++ ++ virtual void stop() override ++ { ++ m_jsSensor->stop(m_type); ++ m_started = false; ++ } ++ ++ bool isFeatureSupported(QSensor::Feature feature) const override ++ { ++ switch (feature) { ++ case QSensor::SkipDuplicates: ++ return true; ++ default: ++ return false; ++ } ++ } ++ ++protected: ++ T m_reader; ++ int m_type; ++ qreal m_accuracy = 0.0f; ++ bool m_started = false; ++}; ++ ++#endif // SENSORBACKEND_H +diff --git a/src/plugins/sensors/openharmony/sensormanager.cpp b/src/plugins/sensors/openharmony/sensormanager.cpp +new file mode 100644 +index 00000000..d34294f4 +--- /dev/null ++++ b/src/plugins/sensors/openharmony/sensormanager.cpp +@@ -0,0 +1,121 @@ ++#include "sensormanager.h" ++#include "QtCore/qopenharmonyjsobject.h" ++#include "QtCore/qopenharmonyjsenvironment.h" ++#include "QtCore/qopenharmonyjsobjectloader.h" ++ ++JsSensor::JsSensor(const QString &uuid) : m_uuid(uuid) ++ , m_jsSensor(Q_NULLPTR) ++{ ++ ++} ++ ++JsSensor::~JsSensor() ++{ ++ if (m_jsSensor) ++ m_jsSensor->call("destroySensor", m_uuid); ++} ++ ++qreal JsSensor::power(int id) const ++{ ++ qreal p = m_jsSensor->call("power", id); ++ return p; ++} ++ ++QString JsSensor::name(int id) const ++{ ++ QString n = m_jsSensor->call("sensorName", id); ++ return n; ++} ++ ++qreal JsSensor::maxRange(int id) const ++{ ++ qreal r = m_jsSensor->call("maxRange", id); ++ return r; ++} ++ ++qreal JsSensor::precision(int id) const ++{ ++ qreal accuracy = m_jsSensor->call("precision", id); ++ return accuracy; ++} ++ ++QString JsSensor::vendorName(int id) const ++{ ++ QString n = m_jsSensor->call("vendorName", id); ++ return n; ++} ++ ++QString JsSensor::description(int id) const ++{ ++ QString des = m_jsSensor->call("description", id); ++ return des; ++} ++ ++qreal JsSensor::minSamplePeriod(int id) const ++{ ++ qreal p = m_jsSensor->call("minSamplePeriod", id); ++ return p; ++} ++ ++qreal JsSensor::maxSamplePeriod(int id) const ++{ ++ qreal p = m_jsSensor->call("maxSamplePeriod", id); ++ return p; ++} ++ ++QString JsSensor::firmwareVersion(int id) const ++{ ++ QString v = m_jsSensor->call("firmwareVersion", id); ++ return v; ++} ++ ++void JsSensor::stop(int id) ++{ ++ m_jsSensor->call("stop", id); ++} ++ ++void JsSensor::start(int id, int rate) ++{ ++ m_jsSensor->call("start", id, rate); ++} ++ ++QString JsSensor::hardwareVersion(int id) const ++{ ++ QString hv = m_jsSensor->call("hardwareVersion", id); ++ return hv; ++} ++ ++SensorManager::SensorManager() { ++ m_sensors = qJsObjectLoader->create("qtsensors"); ++} ++ ++QList SensorManager::sensorIds() const ++{ ++ QStringList ids = m_sensors->call("sensorIds"); ++ QList ns; ++ ns.reserve(ids.size()); ++ for (const auto &id : qAsConst(ids)) { ++ ns.append(id.toInt()); ++ } ++ return ns; ++} ++ ++QSharedPointer &SensorManager::instance() ++{ ++ static QSharedPointer s{ new SensorManager() }; ++ return s; ++} ++ ++QSharedPointer SensorManager::createJsSensor(const QString &uuid, SensorBackendBase *backend) ++{ ++ JsSensor *s = new JsSensor(uuid); ++ m_sensors->call("createSensor", uuid, QVariant(qlonglong(backend))); ++ s->m_jsSensor.reset(new QOpenHarmonyJsObject(uuid)); ++ return QSharedPointer(s); ++} ++ ++void SensorManager::defineProperties(size_t property_count, const napi_property_descriptor *properties) ++{ ++ m_sensors->defineProperties(property_count, properties); ++} ++ +diff --git a/src/plugins/sensors/openharmony/sensormanager.h b/src/plugins/sensors/openharmony/sensormanager.h +new file mode 100644 +index 00000000..157baa3c +--- /dev/null ++++ b/src/plugins/sensors/openharmony/sensormanager.h +@@ -0,0 +1,69 @@ ++#ifndef SENSORMANAGER_H ++#define SENSORMANAGER_H ++ ++#include ++#include ++ ++/* NOTE 鸿蒙和Qt传感器匹配的项 ++ * Qt对前端传感器模块进行了封装 ++ * 鸿蒙提供的传感器模块接口不是 ++ * 完全匹配,需要转换 ++ */ ++enum { ++ E_GRAVITY = 257, /* 重力传感器<--->QAccelerometer */ ++ E_HUMIDITY = 13, /* 湿度传感器<--->QHumiditySensor */ ++ E_BAROMETER = 8, /* 气压传感器<--->QPressureSensor */ ++ E_GYROSCOPE = 2, /* 陀螺仪传感器<--->QGyroscope */ ++ E_PROXIMITY = 12, /* 接近光传感器<--->QDistanceSensor */ ++ E_ORIENTATION = 256, /* 方向传感器<--->QOrientationSensor */ ++ E_ACCELEROMETER = 1, /* 加速度传感器<--->QAccelerometer */ ++ E_AMBIENT_LIGHT = 5, /* 环境光传感器<--->QAmbientLightSensor */ ++ E_MAGNETIC_FIELD = 6, /* 磁场传感器<--->QMagnetometer */ ++ E_ROTATION_VECTOR = 259, /* 旋转矢量传感器<--->QRotationSensor */ ++ E_AMBIENT_TEMPERATURE = 260, /* 环境温度传感器<--->QAmbientTemperatureSensor */ ++ E_LINEAR_ACCELEROMETER = 258, /* 线性加速度传感器<--->QAccelerometer */ ++}; ++ ++class SensorBackendBase; ++class QOpenHarmonyJsObject; ++ ++class JsSensor ++{ ++ QString m_uuid; ++ QSharedPointer m_jsSensor; ++ ++ friend class SensorManager; ++public: ++ JsSensor(const QString &uuid); ++ ~JsSensor(); ++ ++ qreal power(int id) const; ++ QString name(int id) const; ++ qreal maxRange(int id) const; ++ qreal precision(int id) const; ++ QString vendorName(int id) const; ++ QString description(int id) const; ++ qreal minSamplePeriod(int id) const; ++ qreal maxSamplePeriod(int id) const; ++ QString firmwareVersion(int id) const; ++ QString hardwareVersion(int id) const; ++ ++ void stop(int id); ++ void start(int id, int rate); ++}; ++ ++class SensorManager ++{ ++ SensorManager(); ++ ++public: ++ QList sensorIds() const; ++ static QSharedPointer &instance(); ++ QSharedPointer createJsSensor(const QString &uuid, SensorBackendBase *backend); ++ void defineProperties(size_t property_count, const napi_property_descriptor* properties); ++ ++private: ++ QSharedPointer m_sensors; ++}; ++ ++#endif // SENSORMANAGER_H +diff --git a/src/plugins/sensors/sensors.pro b/src/plugins/sensors/sensors.pro +index 7fce2071..8037ffc4 100644 +--- a/src/plugins/sensors/sensors.pro ++++ b/src/plugins/sensors/sensors.pro +@@ -5,6 +5,10 @@ android { + isEmpty(SENSORS_PLUGINS): SENSORS_PLUGINS = android generic + } + ++openharmony { ++ isEmpty(SENSORS_PLUGINS): SENSORS_PLUGINS = openharmony generic ++} ++ + qtConfig(sensorfw) { + isEmpty(SENSORS_PLUGINS): SENSORS_PLUGINS = sensorfw generic + } +@@ -39,6 +43,7 @@ isEmpty(SENSORS_PLUGINS)|contains(SENSORS_PLUGINS, simulator):qtHaveModule(simul + isEmpty(SENSORS_PLUGINS)|contains(SENSORS_PLUGINS, linux):linux:SUBDIRS += linux + isEmpty(SENSORS_PLUGINS)|contains(SENSORS_PLUGINS, iio-sensor-proxy):linux:qtHaveModule(dbus):SUBDIRS += iio-sensor-proxy + isEmpty(SENSORS_PLUGINS)|contains(SENSORS_PLUGINS, android):android:SUBDIRS += android ++isEmpty(SENSORS_PLUGINS)|contains(SENSORS_PLUGINS, openharmony):openharmony:SUBDIRS += openharmony + isEmpty(SENSORS_PLUGINS)|contains(SENSORS_PLUGINS, sensorfw):sensorfw:SUBDIRS += sensorfw + isEmpty(SENSORS_PLUGINS)|contains(SENSORS_PLUGINS, sensortag):linux:SUBDIRS += sensortag + isEmpty(SENSORS_PLUGINS)|contains(SENSORS_PLUGINS, ios):darwin:SUBDIRS += ios +diff --git a/src/src.pro b/src/src.pro +index b3aa7ba0..df12cad0 100644 +--- a/src/src.pro ++++ b/src/src.pro +@@ -16,3 +16,6 @@ plugins.subdir = plugins + plugins.target = sub-plugins + plugins.depends = sensors + ++SUBDIRS += openharmony ++openharmony.subdir = openharmony ++openharmony.target = sub-openharmony -- Gitee From 7987eb2dd54fbe68c22df46d545b8a9cf5f4927a Mon Sep 17 00:00:00 2001 From: wanghao Date: Mon, 9 Oct 2023 14:58:42 +0800 Subject: [PATCH 4/5] =?UTF-8?q?[mod]=20=E7=AD=BE=E7=BD=B2=E9=97=AE?= =?UTF-8?q?=E9=A2=98?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: wanghao --- patch/qtsensor.patch | 1339 ------------------------------------------ 1 file changed, 1339 deletions(-) delete mode 100644 patch/qtsensor.patch diff --git a/patch/qtsensor.patch b/patch/qtsensor.patch deleted file mode 100644 index 27f1499543..0000000000 --- a/patch/qtsensor.patch +++ /dev/null @@ -1,1339 +0,0 @@ -diff --git a/src/openharmony/native/QtSensors.ts b/src/openharmony/native/QtSensors.ts -new file mode 100644 -index 00000000..8c7ad9a0 ---- /dev/null -+++ b/src/openharmony/native/QtSensors.ts -@@ -0,0 +1,132 @@ -+import sensor from '@ohos.sensor'; -+import qtsensorsplugin from 'libplugins_sensors_qtsensors_openharmony.so'; -+ -+export class QtSensors { -+ private pointerId = 0; -+ -+ public constructor(id) { -+ this.pointerId = id; -+ } -+ -+ /* Hz转ns,周期为1 */ -+ private hertz2ns(rate: Number) { -+ /* f=1/T （其中f是指赫兹,T是指以秒为单位的时间）*/ -+ let ns = (1 / Number(rate)) * 1000000000; -+ return ns; -+ } -+ -+ /* ns转Hz,周期为1 */ -+ private ns2hertz(ns: Number) { -+ /* f=1/T （其中f是指赫兹,T是指以秒为单位的时间）*/ -+ let hz = 1 / (Number(ns) / 1000000000); -+ return hz; -+ } -+ -+ createSensor(name, p) { -+ let server = new QtSensors(p); -+ Reflect.defineProperty(globalThis, name, { value: server }); -+ return true; -+ } -+ -+ destroySensor(name: string) { -+ Reflect.deleteProperty(globalThis, name); -+ this.pointerId = 0; -+ return true; -+ } -+ -+ /* 获取所有传感器类型Id */ -+ async sensorIds() { -+ let s: Array = new Array(); -+ try { -+ let sr = await sensor.getSensorList(); -+ for (let data of sr) { -+ s.push(String(data.sensorId)); -+ } -+ } catch (e) { -+ console.error(`Failed to get sensorList. Code: ${e.code}, message: ${e.message}`); -+ } -+ return s; -+ } -+ -+ stop(type: sensor.SensorId) { -+ try { -+ sensor.off(Number(type)); -+ } catch (error) { -+ console.error(`Failed to invoke off. Code: ${error.code}, message: ${error.message}`); -+ } -+ } -+ -+ /* 开始订阅传感器数据 */ -+ async start(type: sensor.SensorId, rate: Number) { -+ try { -+ this.stop(type); -+ let ns = this.hertz2ns(rate); -+ let max = await this.maxSamplePeriod(type); -+ let min = await this.minSamplePeriod(type); -+ let iv = Math.max(Math.min(max, ns), min); -+ -+ sensor.on(Number(type), (data) => { -+ qtsensorsplugin.DataAcception(this.pointerId, JSON.stringify(data)); -+ }, { interval: iv }); -+ } catch (error) { -+ console.error(`Failed to invoke on. Code: ${error.code}, message: ${error.message}`); -+ } -+ } -+ -+ /* 获取指定传感器信息 */ -+ async description(type: sensor.SensorId) { -+ try { -+ let info = await sensor.getSingleSensor(type); -+ let des = JSON.stringify(info); -+ console.info('Succeeded in getting sensor: ' + des); -+ return des; -+ } catch (e) { -+ console.error(`Failed to get singleSensor . Code: ${e.code}, message: ${e.message}`); -+ } -+ } -+ -+ async sensorName(type: sensor.SensorId) { -+ let s = await sensor.getSingleSensor(type); -+ return s.sensorName; -+ } -+ -+ async vendorName(type: sensor.SensorId) { -+ let s = await sensor.getSingleSensor(type); -+ return s.vendorName; -+ } -+ -+ async firmwareVersion(type: sensor.SensorId) { -+ let s = await sensor.getSingleSensor(type); -+ return s.firmwareVersion; -+ } -+ -+ async hardwareVersion(type: sensor.SensorId) { -+ let s = await sensor.getSingleSensor(type); -+ return s.hardwareVersion; -+ } -+ -+ async maxRange(type: sensor.SensorId) { -+ let s = await sensor.getSingleSensor(type); -+ return s.maxRange; -+ } -+ -+ async minSamplePeriod(type: sensor.SensorId) { -+ let s = await sensor.getSingleSensor(type); -+ return this.ns2hertz(s.minSamplePeriod); -+ } -+ -+ async maxSamplePeriod(type: sensor.SensorId) { -+ let s = await sensor.getSingleSensor(type); -+ return this.ns2hertz(s.minSamplePeriod); -+ } -+ -+ async precision(type: sensor.SensorId) { -+ let s = await sensor.getSingleSensor(type); -+ return s.precision; -+ } -+ -+ async power(type: sensor.SensorId) { -+ let s = await sensor.getSingleSensor(type); -+ return s.minSamplePeriod; -+ } -+} -\ No newline at end of file -diff --git a/src/openharmony/openharmony.pro b/src/openharmony/openharmony.pro -new file mode 100644 -index 00000000..6f56bfea ---- /dev/null -+++ b/src/openharmony/openharmony.pro -@@ -0,0 +1,11 @@ -+TEMPLATE = aux -+ -+CONFIG -= qt -+ -+templates.files += $$files($$PWD/native/*.ts, true) -+templates.path = $$[QT_INSTALL_PREFIX]/openharmony/qtsensors -+templates.base = $$PWD -+ -+INSTALLS += templates -+ -+OTHER_FILES += $$templates.files -diff --git a/src/plugins/sensors/openharmony/main.cpp b/src/plugins/sensors/openharmony/main.cpp -new file mode 100644 -index 00000000..c14f6520 ---- /dev/null -+++ b/src/plugins/sensors/openharmony/main.cpp -@@ -0,0 +1,222 @@ -+#include -+#include -+#include -+#include -+#include -+#include -+#include -+#include -+#include -+#include -+#include -+#include -+#include -+#include -+#include -+#include -+#include -+#include -+#include -+#include -+ -+#include "sensormanager.h" -+#include "sensorbackend.h" -+#include -+#include "openharmonylight.h" -+#include "openharmonyrotation.h" -+#include "openharmonyhumidity.h" -+#include "openharmonypressure.h" -+#include "openharmonyproximity.h" -+#include "openharmonygyroscope.h" -+#include "openharmonytemperature.h" -+#include "openharmonymagnetometer.h" -+#include "openharmonyaccelerometer.h" -+#include "QtCore/qopenharmonydefines.h" -+#include "QtCore/qopenharmonyjsenvironment.h" -+ -+ -+static napi_value DataAcception(napi_env env, napi_callback_info info) -+{ -+ size_t argc = 2; -+ napi_value args[2] = { Q_NULLPTR }; -+ napi_get_cb_info(env, info, &argc, args , nullptr, nullptr); -+ -+ if (argc != 2) { -+ napi_throw_type_error(env, NULL, "Wrong number of arguments in DataAcception"); -+ return nullptr; -+ } -+ int64_t value0 = qJs::getInt64(args[0]); -+ SensorBackendBase *backend = reinterpret_cast(value0); -+ if (backend == nullptr) -+ return Q_NULLPTR; -+ -+ -+ SensorBackendBase *sensor = reinterpret_cast(value0); -+ if (Q_NULLPTR == sensor) -+ return Q_NULLPTR; -+ -+ QByteArray data = qJs::getString(args[1]).toLocal8Bit(); -+ if (data.isEmpty()) -+ return Q_NULLPTR; -+ -+ QJsonParseError err; -+ const QJsonDocument &doc = QJsonDocument::fromJson(data, &err); -+ if (QJsonParseError::NoError != err.error) -+ return Q_NULLPTR; -+ -+ -+ //sensor->dataReceived(doc.object()); -+ QMetaObject::invokeMethod(sensor, "dataReceived", -+ Qt::QueuedConnection, -+ Q_ARG(QJsonObject, doc.object())); -+ return Q_NULLPTR; -+} -+ -+namespace { -+const char OPenHarmonyCompassId[] = "openharmony.synthetic.compass"; -+} -+ -+class OPenHarmonySensorPlugin : public QObject, public QSensorPluginInterface, -+ public QSensorBackendFactory -+{ -+ Q_OBJECT -+ Q_PLUGIN_METADATA(IID "com.qt-project.Qt.QSensorPluginInterface/1.0" FILE "plugin.json") -+ Q_INTERFACES(QSensorPluginInterface) -+ -+public: -+ void registerSensors() override -+ { -+ bool accelerometer = false; -+ bool magnetometer = false; -+ const QList &ids = SensorManager::instance()->sensorIds(); -+ for (int sensor : qAsConst(ids)) { -+ switch (sensor) { -+ case E_BAROMETER: -+ QSensorManager::registerBackend(QPressureSensor::type, QByteArray::number(sensor), this); -+ break; -+ case E_ACCELEROMETER: -+ m_accelerationModes |= OPenHarmonyAccelerometer::Accelerometer; -+ QSensorManager::registerBackend(QAccelerometer::type, QByteArray::number(sensor), this); -+ accelerometer = true; -+ break; -+ case E_LINEAR_ACCELEROMETER: -+ m_accelerationModes |= OPenHarmonyAccelerometer::LinearAcceleration; -+ //QSensorManager::registerBackend(QAccelerometer::type, QByteArray::number(sensor), this); -+ break; -+ case E_GRAVITY: -+ m_accelerationModes |= OPenHarmonyAccelerometer::Gravity; -+ //QSensorManager::registerBackend(QAccelerometer::type, QByteArray::number(sensor), this); -+ break; -+ case E_HUMIDITY: -+ QSensorManager::registerBackend(QHumiditySensor::type, QByteArray::number(sensor), this); -+ break; -+ case E_PROXIMITY: -+ QSensorManager::registerBackend(QProximitySensor::type, QByteArray::number(sensor), this); -+ break; -+ case E_GYROSCOPE: -+ QSensorManager::registerBackend(QGyroscope::type, QByteArray::number(sensor), this); -+ break; -+ case E_ORIENTATION: -+ /*FIXME 通过加速度传感器实现? */ -+ //QSensorManager::registerBackend(QOrientationSensor::type, QByteArray::number(sensor), this); -+ break; -+ case E_ROTATION_VECTOR: -+ QSensorManager::registerBackend(QRotationSensor::type, QByteArray::number(sensor), this); -+ break; -+ case E_AMBIENT_LIGHT: -+ QSensorManager::registerBackend(QAmbientLightSensor::type, QByteArray::number(sensor), this); -+ break; -+ case E_MAGNETIC_FIELD: -+ QSensorManager::registerBackend(QMagnetometer::type, QByteArray::number(sensor), this); -+ magnetometer = true; -+ break; -+ case E_AMBIENT_TEMPERATURE: -+ QSensorManager::registerBackend(QAmbientTemperatureSensor::type, QByteArray::number(sensor), this); -+ break; -+ default: -+ break; -+ } -+ } -+#if 0 -+ /* NOTE 现在的js回调机制不支持 -+ * 罗盘通过加速度和磁场传感器组合实现 -+ */ -+ if (accelerometer && magnetometer) -+ QSensorManager::registerBackend(QCompass::type, OPenHarmonyCompassId, this); -+#endif -+ } -+ -+ QSensorBackend *createBackend(QSensor *sensor) override -+ { -+ /* TODO QCompass */ -+ int id = sensor->identifier().toInt(); -+ switch (id) { -+ case E_BAROMETER: -+ return new OPenHarmonyPressure(id, sensor); -+ case E_ACCELEROMETER: -+ return new OPenHarmonyAccelerometer(m_accelerationModes, sensor); -+ case E_GYROSCOPE: -+ return new OPenHarmonyGyroscope(id, sensor); -+ case E_PROXIMITY: -+ return new OPenHarmonyProximity(id, sensor); -+ case E_AMBIENT_LIGHT: -+ return new OPenHarmonyLight(id, sensor); -+ case E_MAGNETIC_FIELD: -+ return new OPenHarmonyMagnetometer(id, sensor); -+ case E_HUMIDITY: -+ return new OPenHarmonyHumidity(id, sensor); -+ case E_ROTATION_VECTOR: -+ return new OPenHarmonyRotation(id, sensor); -+ case E_AMBIENT_TEMPERATURE: -+ return new OPenHarmonyTemperature(id, sensor); -+ default: -+ break; -+ } -+ return Q_NULLPTR; -+ } -+ -+private: -+ int m_accelerationModes = 0; -+}; -+ -+/* -+ * function for module exports -+ */ -+EXTERN_C_START -+static napi_value Init(napi_env env, napi_value exports) -+{ -+ static bool inited = false; -+ if (!inited) { -+ -+ LOGI("init sensors module"); -+ napi_property_descriptor desc[] ={ -+ DECLARE_NAPI_FUNCTION("DataAcception", DataAcception), -+ }; -+ NAPI_CALL(env, napi_define_properties(env, exports, sizeof(desc) / sizeof(desc[0]), desc)); -+ inited = true; -+ } -+ return exports; -+} -+EXTERN_C_END -+ -+/* -+ * Napi Module define -+ */ -+static napi_module openharmonyQtSensorsModule = { -+ .nm_version = 1, -+ .nm_flags = 0, -+ .nm_filename = nullptr, -+ .nm_register_func = Init, -+ .nm_modname = "openharmony_qt_sensors", -+ .nm_priv = ((void*)0), -+ .reserved = { 0 }, -+}; -+/* -+ * Module register function -+ */ -+extern "C" __attribute__((constructor)) void RegisterModule(void) -+{ -+ napi_module_register(&openharmonyQtSensorsModule); -+} -+ -+#include "main.moc" -diff --git a/src/plugins/sensors/openharmony/openharmony.pro b/src/plugins/sensors/openharmony/openharmony.pro -new file mode 100644 -index 00000000..390e904c ---- /dev/null -+++ b/src/plugins/sensors/openharmony/openharmony.pro -@@ -0,0 +1,36 @@ -+TARGET = qtsensors_openharmony -+QT = core sensors -+ -+OTHER_FILES = plugin.json -+ -+SOURCES += \ -+ main.cpp \ -+ openharmonyaccelerometer.cpp \ -+ openharmonygyroscope.cpp \ -+ openharmonyhumidity.cpp \ -+ openharmonylight.cpp \ -+ openharmonymagnetometer.cpp \ -+ openharmonypressure.cpp \ -+ openharmonyproximity.cpp \ -+ openharmonyrotation.cpp \ -+ openharmonytemperature.cpp \ -+ sensormanager.cpp -+ -+ -+PLUGIN_TYPE = sensors -+PLUGIN_CLASS_NAME = OPenHarmonySensorPlugin -+load(qt_plugin) -+ -+HEADERS += \ -+ openharmonyaccelerometer.h \ -+ openharmonygyroscope.h \ -+ openharmonyhumidity.h \ -+ openharmonylight.h \ -+ openharmonymagnetometer.h \ -+ openharmonypressure.h \ -+ openharmonyproximity.h \ -+ openharmonyrotation.h \ -+ openharmonytemperature.h \ -+ sensorbackend.h \ -+ sensormanager.h -+ -diff --git a/src/plugins/sensors/openharmony/openharmonyaccelerometer.cpp b/src/plugins/sensors/openharmony/openharmonyaccelerometer.cpp -new file mode 100644 -index 00000000..84ad1e53 ---- /dev/null -+++ b/src/plugins/sensors/openharmony/openharmonyaccelerometer.cpp -@@ -0,0 +1,71 @@ -+#include -+#include -+#include -+ -+#include "openharmonyaccelerometer.h" -+ -+OPenHarmonyAccelerometer::OPenHarmonyAccelerometer(int accelerationModes, QSensor *sensor, QObject *parent) -+ : SensorBackend(E_ACCELEROMETER, sensor, parent) -+ , m_accelerationModes(accelerationModes) -+{ -+ auto accelerometer = qobject_cast(sensor); -+ if (accelerometer) { -+ connect(accelerometer, &QAccelerometer::accelerationModeChanged, -+ this, &OPenHarmonyAccelerometer::applyAccelerationMode); -+ applyAccelerationMode(accelerometer->accelerationMode()); -+ } -+} -+ -+bool OPenHarmonyAccelerometer::isFeatureSupported(QSensor::Feature feature) const -+{ -+ return (feature == QSensor::AccelerationMode) ? m_accelerationModes == AllModes : SensorBackend::isFeatureSupported(feature); -+} -+ -+void OPenHarmonyAccelerometer::dataReceived(const QJsonObject &json) -+{ -+ double x = json.value("x").toDouble(); -+ double y = json.value("y").toDouble(); -+ double z = json.value("z").toDouble(); -+ -+ if (sensor()->skipDuplicates() && qFuzzyCompare(m_reader.x(), x) && -+ qFuzzyCompare(m_reader.y(), y) && -+ qFuzzyCompare(m_reader.z(), z)) { -+ return; -+ } -+ -+ double timestamp = json.value("timestamp").toDouble(); -+ m_reader.setTimestamp(quint64(timestamp)); -+ m_reader.setX(x); -+ m_reader.setY(y); -+ m_reader.setZ(z); -+ -+ newReadingAvailable(); -+} -+ -+void OPenHarmonyAccelerometer::applyAccelerationMode(QAccelerometer::AccelerationMode accelerationMode) -+{ -+ switch (accelerationMode) { -+ case QAccelerometer::Gravity: -+ if (!(m_accelerationModes & Gravity)) { -+ qWarning() << "Gravity sensor missing"; -+ return; -+ } -+ setSensorType(E_GRAVITY); -+ break; -+ case QAccelerometer::User: -+ if (!(m_accelerationModes & LinearAcceleration)) { -+ qWarning() << "Linear acceleration sensor missing"; -+ return; -+ } -+ setSensorType(E_LINEAR_ACCELEROMETER); -+ break; -+ case QAccelerometer::Combined: -+ if (!(m_accelerationModes & Accelerometer)) { -+ qWarning() << "Accelerometer sensor missing"; -+ return; -+ } -+ setSensorType(E_ACCELEROMETER); -+ break; -+ } -+} -+ -diff --git a/src/plugins/sensors/openharmony/openharmonyaccelerometer.h b/src/plugins/sensors/openharmony/openharmonyaccelerometer.h -new file mode 100644 -index 00000000..a610d25b ---- /dev/null -+++ b/src/plugins/sensors/openharmony/openharmonyaccelerometer.h -@@ -0,0 +1,32 @@ -+#ifndef OPENHARMONYACCELEROMETER_H -+#define OPENHARMONYACCELEROMETER_H -+ -+#include -+ -+#include "sensorbackend.h" -+ -+class OPenHarmonyAccelerometer : public SensorBackend -+{ -+ Q_OBJECT -+ -+public: -+ enum AccelerationModes { -+ Accelerometer = 1, -+ Gravity = 2, -+ LinearAcceleration = 4, -+ AllModes = (Accelerometer | Gravity | LinearAcceleration) -+ }; -+ OPenHarmonyAccelerometer(int accelerationModes, QSensor *sensor, QObject *parent = nullptr); -+ bool isFeatureSupported(QSensor::Feature feature) const override; -+ -+protected Q_SLOTS: -+ void dataReceived(const QJsonObject &json) override; -+ -+private: -+ void applyAccelerationMode(QAccelerometer::AccelerationMode accelerationMode); -+ -+private: -+ int m_accelerationModes; -+}; -+ -+#endif // OPENHARMONYACCELEROMETER_H -diff --git a/src/plugins/sensors/openharmony/openharmonygyroscope.cpp b/src/plugins/sensors/openharmony/openharmonygyroscope.cpp -new file mode 100644 -index 00000000..349b7e2f ---- /dev/null -+++ b/src/plugins/sensors/openharmony/openharmonygyroscope.cpp -@@ -0,0 +1,33 @@ -+#include -+#include -+#include -+ -+#include "openharmonygyroscope.h" -+ -+OPenHarmonyGyroscope::OPenHarmonyGyroscope(int type, QSensor *sensor, QObject *parent) -+: SensorBackend(type, sensor, parent) -+{ -+ -+} -+ -+void OPenHarmonyGyroscope::dataReceived(const QJsonObject &json) -+{ -+ double x = qRadiansToDegrees(json.value("x").toDouble()); -+ double y = qRadiansToDegrees(json.value("y").toDouble()); -+ double z = qRadiansToDegrees(json.value("z").toDouble()); -+ double timestamp = json.value("timestamp").toDouble(); -+ -+ if (sensor()->skipDuplicates() && qFuzzyCompare(m_reader.x(), x) && -+ qFuzzyCompare(m_reader.y(), y) && -+ qFuzzyCompare(m_reader.z(), z)) { -+ return; -+ } -+ -+ m_reader.setTimestamp(quint64(timestamp)); -+ m_reader.setX(x); -+ m_reader.setY(y); -+ m_reader.setZ(z); -+ -+ newReadingAvailable(); -+} -+ -diff --git a/src/plugins/sensors/openharmony/openharmonygyroscope.h b/src/plugins/sensors/openharmony/openharmonygyroscope.h -new file mode 100644 -index 00000000..ff3e6d2a ---- /dev/null -+++ b/src/plugins/sensors/openharmony/openharmonygyroscope.h -@@ -0,0 +1,18 @@ -+#ifndef OPENHARMONYGYROSCOPE_H -+#define OPENHARMONYGYROSCOPE_H -+ -+#include -+ -+#include "sensorbackend.h" -+ -+class OPenHarmonyGyroscope : public SensorBackend -+{ -+ Q_OBJECT -+public: -+ OPenHarmonyGyroscope(int type, QSensor *sensor, QObject *parent = nullptr); -+ -+protected Q_SLOTS: -+ void dataReceived(const QJsonObject &json) override; -+}; -+ -+#endif // OPENHARMONYGYROSCOPE_H -diff --git a/src/plugins/sensors/openharmony/openharmonyhumidity.cpp b/src/plugins/sensors/openharmony/openharmonyhumidity.cpp -new file mode 100644 -index 00000000..e17df8cf ---- /dev/null -+++ b/src/plugins/sensors/openharmony/openharmonyhumidity.cpp -@@ -0,0 +1,25 @@ -+#include -+#include -+ -+#include "openharmonyhumidity.h" -+ -+OPenHarmonyHumidity::OPenHarmonyHumidity(int type, QSensor *sensor, QObject *parent) -+ : SensorBackend(type, sensor, parent) -+{ -+ -+} -+ -+void OPenHarmonyHumidity::dataReceived(const QJsonObject &json) -+{ -+ qreal humidity = json.value("humidity").toDouble(); -+ -+ if (sensor()->skipDuplicates() && qFuzzyCompare(humidity, m_reader.relativeHumidity())) -+ return; -+ -+ double timestamp = json.value("timestamp").toDouble(); -+ m_reader.setTimestamp(quint64(timestamp)); -+ m_reader.setAbsoluteHumidity(0.f); -+ m_reader.setRelativeHumidity(humidity); -+ newReadingAvailable(); -+} -+ -diff --git a/src/plugins/sensors/openharmony/openharmonyhumidity.h b/src/plugins/sensors/openharmony/openharmonyhumidity.h -new file mode 100644 -index 00000000..adbf4c9b ---- /dev/null -+++ b/src/plugins/sensors/openharmony/openharmonyhumidity.h -@@ -0,0 +1,18 @@ -+#ifndef OPENHARMONYHUMIDITY_H -+#define OPENHARMONYHUMIDITY_H -+ -+#include -+ -+#include "sensorbackend.h" -+ -+class OPenHarmonyHumidity : public SensorBackend -+{ -+ Q_OBJECT -+public: -+ OPenHarmonyHumidity(int type, QSensor *sensor, QObject *parent = nullptr); -+ -+protected Q_SLOTS: -+ void dataReceived(const QJsonObject &json) override; -+}; -+ -+#endif // OPENHARMONYHUMIDITY_H -diff --git a/src/plugins/sensors/openharmony/openharmonylight.cpp b/src/plugins/sensors/openharmony/openharmonylight.cpp -new file mode 100644 -index 00000000..7274df7c ---- /dev/null -+++ b/src/plugins/sensors/openharmony/openharmonylight.cpp -@@ -0,0 +1,23 @@ -+#include -+#include -+ -+#include "openharmonylight.h" -+ -+OPenHarmonyLight::OPenHarmonyLight(int type, QSensor *sensor, QObject *parent) -+ : SensorBackend(type, sensor, parent) -+{ -+ -+} -+ -+void OPenHarmonyLight::dataReceived(const QJsonObject &json) -+{ -+ double intensity = json.value("intensity").toDouble(); -+ -+ if (sensor()->skipDuplicates() && qFuzzyCompare(m_reader.lux(), intensity)) -+ return; -+ -+ double timestamp = json.value("timestamp").toDouble(); -+ m_reader.setTimestamp(quint64(timestamp)); -+ m_reader.setLux(qreal(intensity)); -+ newReadingAvailable(); -+} -diff --git a/src/plugins/sensors/openharmony/openharmonylight.h b/src/plugins/sensors/openharmony/openharmonylight.h -new file mode 100644 -index 00000000..f8039a92 ---- /dev/null -+++ b/src/plugins/sensors/openharmony/openharmonylight.h -@@ -0,0 +1,18 @@ -+#ifndef OPENHARMONYLIGHT_H -+#define OPENHARMONYLIGHT_H -+ -+#include -+ -+#include "sensorbackend.h" -+ -+class OPenHarmonyLight : public SensorBackend -+{ -+ Q_OBJECT -+public: -+ OPenHarmonyLight(int type, QSensor *sensor, QObject *parent = nullptr); -+ -+protected Q_SLOTS: -+ void dataReceived(const QJsonObject &json) override; -+}; -+ -+#endif // OPENHARMONYLIGHT_H -diff --git a/src/plugins/sensors/openharmony/openharmonymagnetometer.cpp b/src/plugins/sensors/openharmony/openharmonymagnetometer.cpp -new file mode 100644 -index 00000000..34e34b21 ---- /dev/null -+++ b/src/plugins/sensors/openharmony/openharmonymagnetometer.cpp -@@ -0,0 +1,32 @@ -+#include -+#include -+#include "openharmonymagnetometer.h" -+ -+OPenHarmonyMagnetometer::OPenHarmonyMagnetometer(int type, QSensor *sensor, QObject *parent) -+ : SensorBackend(type, sensor, parent) -+{ -+ -+} -+ -+void OPenHarmonyMagnetometer::dataReceived(const QJsonObject &json) -+{ -+ double x = json.value("x").toDouble(); -+ double y = json.value("y").toDouble(); -+ double z = json.value("z").toDouble(); -+ -+ if (sensor()->skipDuplicates() && qFuzzyCompare(m_accuracy, m_reader.calibrationLevel()) && -+ qFuzzyCompare(x, m_reader.x()) && -+ qFuzzyCompare(y, m_reader.y()) && -+ qFuzzyCompare(z, m_reader.z())) { -+ return; -+ } -+ -+ m_reader.setCalibrationLevel(m_accuracy); -+ double timestamp = json.value("timestamp").toDouble(); -+ m_reader.setTimestamp(quint64(timestamp)); -+ m_reader.setX(x); -+ m_reader.setY(y); -+ m_reader.setZ(z); -+ newReadingAvailable(); -+} -+ -diff --git a/src/plugins/sensors/openharmony/openharmonymagnetometer.h b/src/plugins/sensors/openharmony/openharmonymagnetometer.h -new file mode 100644 -index 00000000..c3662243 ---- /dev/null -+++ b/src/plugins/sensors/openharmony/openharmonymagnetometer.h -@@ -0,0 +1,18 @@ -+#ifndef OPENHARMONYMAGNETOMETER_H -+#define OPENHARMONYMAGNETOMETER_H -+ -+#include -+ -+#include "sensorbackend.h" -+ -+class OPenHarmonyMagnetometer : public SensorBackend -+{ -+ Q_OBJECT -+public: -+ OPenHarmonyMagnetometer(int type, QSensor *sensor, QObject *parent = nullptr); -+ -+protected Q_SLOTS: -+ void dataReceived(const QJsonObject &json) override; -+}; -+ -+#endif // OPENHARMONYMAGNETOMETER_H -diff --git a/src/plugins/sensors/openharmony/openharmonypressure.cpp b/src/plugins/sensors/openharmony/openharmonypressure.cpp -new file mode 100644 -index 00000000..c7d5d3d3 ---- /dev/null -+++ b/src/plugins/sensors/openharmony/openharmonypressure.cpp -@@ -0,0 +1,22 @@ -+#include -+#include -+ -+#include "openharmonypressure.h" -+ -+OPenHarmonyPressure::OPenHarmonyPressure(int type, QSensor *sensor, QObject *parent) -+ : SensorBackend(type, sensor, parent) -+{ -+ -+} -+ -+void OPenHarmonyPressure::dataReceived(const QJsonObject &json) -+{ -+ auto pressurePa = json.value("pressure").toDouble(); -+ if (sensor()->skipDuplicates() && qFuzzyCompare(pressurePa, m_reader.pressure())) -+ return; -+ -+ double timestamp = json.value("timestamp").toDouble(); -+ m_reader.setTimestamp(quint64(timestamp)); -+ m_reader.setPressure(pressurePa); -+ newReadingAvailable(); -+} -diff --git a/src/plugins/sensors/openharmony/openharmonypressure.h b/src/plugins/sensors/openharmony/openharmonypressure.h -new file mode 100644 -index 00000000..8c2db8aa ---- /dev/null -+++ b/src/plugins/sensors/openharmony/openharmonypressure.h -@@ -0,0 +1,18 @@ -+#ifndef OPENHARMONYPRESSURE_H -+#define OPENHARMONYPRESSURE_H -+ -+#include -+ -+#include "sensorbackend.h" -+ -+class OPenHarmonyPressure : public SensorBackend -+{ -+ Q_OBJECT -+public: -+ OPenHarmonyPressure(int type, QSensor *sensor, QObject *parent = nullptr); -+ -+protected Q_SLOTS: -+ void dataReceived(const QJsonObject &json) override; -+}; -+ -+#endif // OPENHARMONYPRESSURE_H -diff --git a/src/plugins/sensors/openharmony/openharmonyproximity.cpp b/src/plugins/sensors/openharmony/openharmonyproximity.cpp -new file mode 100644 -index 00000000..e96a0b24 ---- /dev/null -+++ b/src/plugins/sensors/openharmony/openharmonyproximity.cpp -@@ -0,0 +1,28 @@ -+#include -+#include -+ -+#include "openharmonyproximity.h" -+ -+OPenHarmonyProximity::OPenHarmonyProximity(int type, QSensor *sensor, QObject *parent) -+ : SensorBackend(type, sensor, parent) -+{ -+ m_maximumRange = m_jsSensor->maxRange(m_type); -+ -+ // if we can't get the range, we arbitrarily define anything closer than 10 cm as "close" -+ if (m_maximumRange <= 0) -+ m_maximumRange = 10.0; -+} -+ -+void OPenHarmonyProximity::dataReceived(const QJsonObject &json) -+{ -+ qreal distance = json.value("distance").toDouble(); -+ bool close = distance < m_maximumRange; -+ if (sensor()->skipDuplicates() && close == m_reader.close()) -+ return; -+ -+ double timestamp = json.value("timestamp").toDouble(); -+ m_reader.setTimestamp(quint64(timestamp)); -+ m_reader.setClose(close); -+ newReadingAvailable(); -+} -+ -diff --git a/src/plugins/sensors/openharmony/openharmonyproximity.h b/src/plugins/sensors/openharmony/openharmonyproximity.h -new file mode 100644 -index 00000000..f1ef02f2 ---- /dev/null -+++ b/src/plugins/sensors/openharmony/openharmonyproximity.h -@@ -0,0 +1,21 @@ -+#ifndef OPENHARMONYPROXIMITY_H -+#define OPENHARMONYPROXIMITY_H -+ -+#include -+ -+#include "sensorbackend.h" -+ -+class OPenHarmonyProximity : public SensorBackend -+{ -+ Q_OBJECT -+public: -+ OPenHarmonyProximity(int type, QSensor *sensor, QObject *parent = nullptr); -+ -+protected Q_SLOTS: -+ void dataReceived(const QJsonObject &json) override; -+ -+private: -+ qreal m_maximumRange; -+}; -+ -+#endif // OPENHARMONYPROXIMITY_H -diff --git a/src/plugins/sensors/openharmony/openharmonyrotation.cpp b/src/plugins/sensors/openharmony/openharmonyrotation.cpp -new file mode 100644 -index 00000000..a4d70e6f ---- /dev/null -+++ b/src/plugins/sensors/openharmony/openharmonyrotation.cpp -@@ -0,0 +1,29 @@ -+#include -+#include -+#include -+ -+#include "openharmonyrotation.h" -+ -+OPenHarmonyRotation::OPenHarmonyRotation(int type, QSensor *sensor, QObject *parent) -+ : SensorBackend(type, sensor, parent) -+{ -+ -+} -+ -+void OPenHarmonyRotation::dataReceived(const QJsonObject &json) -+{ -+ qreal rz = -qRadiansToDegrees(json.value("x").toDouble()); //corresponds to x -+ qreal rx = -qRadiansToDegrees(json.value("y").toDouble()); //corresponds to y -+ qreal ry = qRadiansToDegrees(json.value("z").toDouble()); //corresponds to z -+ if (sensor()->skipDuplicates() && qFuzzyCompare(m_reader.x(), rx) && -+ qFuzzyCompare(m_reader.y(), ry) && -+ qFuzzyCompare(m_reader.z(), rz)) { -+ return; -+ } -+ -+ double timestamp = json.value("timestamp").toDouble(); -+ m_reader.setTimestamp(quint64(timestamp)); -+ m_reader.setFromEuler(rx, ry, rz); -+ newReadingAvailable(); -+} -+ -diff --git a/src/plugins/sensors/openharmony/openharmonyrotation.h b/src/plugins/sensors/openharmony/openharmonyrotation.h -new file mode 100644 -index 00000000..03243797 ---- /dev/null -+++ b/src/plugins/sensors/openharmony/openharmonyrotation.h -@@ -0,0 +1,18 @@ -+#ifndef OPENHARMONYROTATION_H -+#define OPENHARMONYROTATION_H -+ -+#include -+ -+#include "sensorbackend.h" -+ -+class OPenHarmonyRotation : public SensorBackend -+{ -+ Q_OBJECT -+public: -+ OPenHarmonyRotation(int type, QSensor *sensor, QObject *parent = nullptr); -+ -+protected Q_SLOTS: -+ void dataReceived(const QJsonObject &json) override; -+}; -+ -+#endif // OPENHARMONYROTATION_H -diff --git a/src/plugins/sensors/openharmony/openharmonytemperature.cpp b/src/plugins/sensors/openharmony/openharmonytemperature.cpp -new file mode 100644 -index 00000000..a3865b03 ---- /dev/null -+++ b/src/plugins/sensors/openharmony/openharmonytemperature.cpp -@@ -0,0 +1,23 @@ -+#include -+#include -+ -+#include "openharmonytemperature.h" -+ -+OPenHarmonyTemperature::OPenHarmonyTemperature(int type, QSensor *sensor, QObject *parent) -+ : SensorBackend(type, sensor, parent) -+{ -+ -+} -+ -+void OPenHarmonyTemperature::dataReceived(const QJsonObject &json) -+{ -+ qreal temperature = json.value("temperature").toDouble(); -+ if (sensor()->skipDuplicates() && qFuzzyCompare(m_reader.temperature(), temperature)) -+ return; -+ -+ double timestamp = json.value("timestamp").toDouble(); -+ m_reader.setTimestamp(quint64(timestamp)); -+ m_reader.setTemperature(temperature); // in degree Celsius -+ newReadingAvailable(); -+} -+ -diff --git a/src/plugins/sensors/openharmony/openharmonytemperature.h b/src/plugins/sensors/openharmony/openharmonytemperature.h -new file mode 100644 -index 00000000..cc881f20 ---- /dev/null -+++ b/src/plugins/sensors/openharmony/openharmonytemperature.h -@@ -0,0 +1,18 @@ -+#ifndef OPENHARMONYTEMPERATURE_H -+#define OPENHARMONYTEMPERATURE_H -+ -+#include -+ -+#include "sensorbackend.h" -+ -+class OPenHarmonyTemperature : public SensorBackend -+{ -+ Q_OBJECT -+public: -+ OPenHarmonyTemperature(int type, QSensor *sensor, QObject *parent = nullptr); -+ -+protected Q_SLOTS: -+ void dataReceived(const QJsonObject &json) override; -+}; -+ -+#endif // OPENHARMONYTEMPERATURE_H -diff --git a/src/plugins/sensors/openharmony/plugin.json b/src/plugins/sensors/openharmony/plugin.json -new file mode 100644 -index 00000000..ff40b670 ---- /dev/null -+++ b/src/plugins/sensors/openharmony/plugin.json -@@ -0,0 +1 @@ -+{ "Keys": [ "openharmony" ] } -diff --git a/src/plugins/sensors/openharmony/sensorbackend.h b/src/plugins/sensors/openharmony/sensorbackend.h -new file mode 100644 -index 00000000..aa0907df ---- /dev/null -+++ b/src/plugins/sensors/openharmony/sensorbackend.h -@@ -0,0 +1,91 @@ -+#ifndef SENSORBACKEND_H -+#define SENSORBACKEND_H -+ -+#include -+#include -+ -+#include "sensormanager.h" -+ -+class SensorBackendBase : public QSensorBackend -+{ -+public: -+ SensorBackendBase(QSensor *sensor, QObject *parent = nullptr) -+ : QSensorBackend(sensor, parent) -+ , m_jsSensor(Q_NULLPTR) -+ { -+ QString tempUuid = QUuid::createUuid().toString(); -+ tempUuid.chop(1); //remove trailing '}' -+ tempUuid.remove(0,1); //remove first '{' -+ -+ m_jsSensor = SensorManager::instance()->createJsSensor(tempUuid, this); -+ } -+ -+public Q_SLOTS: -+ virtual void dataReceived(const QJsonObject &json) = 0; -+ -+protected: -+ QSharedPointer m_jsSensor; -+}; -+ -+template -+class SensorBackend : public SensorBackendBase -+{ -+public: -+ explicit SensorBackend(int type, QSensor *sensor, QObject *parent = nullptr) : m_type(0) -+ , SensorBackendBase{ sensor, parent } -+ { -+ setReading(&m_reader); -+ setSensorType(type); -+ m_accuracy = m_jsSensor->precision(type); -+ addDataRate(m_jsSensor->minSamplePeriod(type), -+ m_jsSensor->maxSamplePeriod(type)); -+ addOutputRange(0, m_jsSensor->maxRange(type), m_accuracy); -+ } -+ -+ ~SensorBackend() override -+ { -+ stop(); -+ } -+ -+ void setSensorType(int type) -+ { -+ m_type = type; -+ bool started = m_started; -+ if (started) -+ stop(); -+ -+ setDescription(m_jsSensor->description(type)); -+ if (started) -+ start(); -+ } -+ -+ virtual void start() override -+ { -+ m_jsSensor->start(m_type, sensor()->dataRate()); -+ m_started = true; -+ } -+ -+ virtual void stop() override -+ { -+ m_jsSensor->stop(m_type); -+ m_started = false; -+ } -+ -+ bool isFeatureSupported(QSensor::Feature feature) const override -+ { -+ switch (feature) { -+ case QSensor::SkipDuplicates: -+ return true; -+ default: -+ return false; -+ } -+ } -+ -+protected: -+ T m_reader; -+ int m_type; -+ qreal m_accuracy = 0.0f; -+ bool m_started = false; -+}; -+ -+#endif // SENSORBACKEND_H -diff --git a/src/plugins/sensors/openharmony/sensormanager.cpp b/src/plugins/sensors/openharmony/sensormanager.cpp -new file mode 100644 -index 00000000..d34294f4 ---- /dev/null -+++ b/src/plugins/sensors/openharmony/sensormanager.cpp -@@ -0,0 +1,121 @@ -+#include "sensormanager.h" -+#include "QtCore/qopenharmonyjsobject.h" -+#include "QtCore/qopenharmonyjsenvironment.h" -+#include "QtCore/qopenharmonyjsobjectloader.h" -+ -+JsSensor::JsSensor(const QString &uuid) : m_uuid(uuid) -+ , m_jsSensor(Q_NULLPTR) -+{ -+ -+} -+ -+JsSensor::~JsSensor() -+{ -+ if (m_jsSensor) -+ m_jsSensor->call("destroySensor", m_uuid); -+} -+ -+qreal JsSensor::power(int id) const -+{ -+ qreal p = m_jsSensor->call("power", id); -+ return p; -+} -+ -+QString JsSensor::name(int id) const -+{ -+ QString n = m_jsSensor->call("sensorName", id); -+ return n; -+} -+ -+qreal JsSensor::maxRange(int id) const -+{ -+ qreal r = m_jsSensor->call("maxRange", id); -+ return r; -+} -+ -+qreal JsSensor::precision(int id) const -+{ -+ qreal accuracy = m_jsSensor->call("precision", id); -+ return accuracy; -+} -+ -+QString JsSensor::vendorName(int id) const -+{ -+ QString n = m_jsSensor->call("vendorName", id); -+ return n; -+} -+ -+QString JsSensor::description(int id) const -+{ -+ QString des = m_jsSensor->call("description", id); -+ return des; -+} -+ -+qreal JsSensor::minSamplePeriod(int id) const -+{ -+ qreal p = m_jsSensor->call("minSamplePeriod", id); -+ return p; -+} -+ -+qreal JsSensor::maxSamplePeriod(int id) const -+{ -+ qreal p = m_jsSensor->call("maxSamplePeriod", id); -+ return p; -+} -+ -+QString JsSensor::firmwareVersion(int id) const -+{ -+ QString v = m_jsSensor->call("firmwareVersion", id); -+ return v; -+} -+ -+void JsSensor::stop(int id) -+{ -+ m_jsSensor->call("stop", id); -+} -+ -+void JsSensor::start(int id, int rate) -+{ -+ m_jsSensor->call("start", id, rate); -+} -+ -+QString JsSensor::hardwareVersion(int id) const -+{ -+ QString hv = m_jsSensor->call("hardwareVersion", id); -+ return hv; -+} -+ -+SensorManager::SensorManager() { -+ m_sensors = qJsObjectLoader->create("qtsensors"); -+} -+ -+QList SensorManager::sensorIds() const -+{ -+ QStringList ids = m_sensors->call("sensorIds"); -+ QList ns; -+ ns.reserve(ids.size()); -+ for (const auto &id : qAsConst(ids)) { -+ ns.append(id.toInt()); -+ } -+ return ns; -+} -+ -+QSharedPointer &SensorManager::instance() -+{ -+ static QSharedPointer s{ new SensorManager() }; -+ return s; -+} -+ -+QSharedPointer SensorManager::createJsSensor(const QString &uuid, SensorBackendBase *backend) -+{ -+ JsSensor *s = new JsSensor(uuid); -+ m_sensors->call("createSensor", uuid, QVariant(qlonglong(backend))); -+ s->m_jsSensor.reset(new QOpenHarmonyJsObject(uuid)); -+ return QSharedPointer(s); -+} -+ -+void SensorManager::defineProperties(size_t property_count, const napi_property_descriptor *properties) -+{ -+ m_sensors->defineProperties(property_count, properties); -+} -+ -diff --git a/src/plugins/sensors/openharmony/sensormanager.h b/src/plugins/sensors/openharmony/sensormanager.h -new file mode 100644 -index 00000000..157baa3c ---- /dev/null -+++ b/src/plugins/sensors/openharmony/sensormanager.h -@@ -0,0 +1,69 @@ -+#ifndef SENSORMANAGER_H -+#define SENSORMANAGER_H -+ -+#include -+#include -+ -+/* NOTE 鸿蒙和Qt传感器匹配的项 -+ * Qt对前端传感器模块进行了封装 -+ * 鸿蒙提供的传感器模块接口不是 -+ * 完全匹配,需要转换 -+ */ -+enum { -+ E_GRAVITY = 257, /* 重力传感器<--->QAccelerometer */ -+ E_HUMIDITY = 13, /* 湿度传感器<--->QHumiditySensor */ -+ E_BAROMETER = 8, /* 气压传感器<--->QPressureSensor */ -+ E_GYROSCOPE = 2, /* 陀螺仪传感器<--->QGyroscope */ -+ E_PROXIMITY = 12, /* 接近光传感器<--->QDistanceSensor */ -+ E_ORIENTATION = 256, /* 方向传感器<--->QOrientationSensor */ -+ E_ACCELEROMETER = 1, /* 加速度传感器<--->QAccelerometer */ -+ E_AMBIENT_LIGHT = 5, /* 环境光传感器<--->QAmbientLightSensor */ -+ E_MAGNETIC_FIELD = 6, /* 磁场传感器<--->QMagnetometer */ -+ E_ROTATION_VECTOR = 259, /* 旋转矢量传感器<--->QRotationSensor */ -+ E_AMBIENT_TEMPERATURE = 260, /* 环境温度传感器<--->QAmbientTemperatureSensor */ -+ E_LINEAR_ACCELEROMETER = 258, /* 线性加速度传感器<--->QAccelerometer */ -+}; -+ -+class SensorBackendBase; -+class QOpenHarmonyJsObject; -+ -+class JsSensor -+{ -+ QString m_uuid; -+ QSharedPointer m_jsSensor; -+ -+ friend class SensorManager; -+public: -+ JsSensor(const QString &uuid); -+ ~JsSensor(); -+ -+ qreal power(int id) const; -+ QString name(int id) const; -+ qreal maxRange(int id) const; -+ qreal precision(int id) const; -+ QString vendorName(int id) const; -+ QString description(int id) const; -+ qreal minSamplePeriod(int id) const; -+ qreal maxSamplePeriod(int id) const; -+ QString firmwareVersion(int id) const; -+ QString hardwareVersion(int id) const; -+ -+ void stop(int id); -+ void start(int id, int rate); -+}; -+ -+class SensorManager -+{ -+ SensorManager(); -+ -+public: -+ QList sensorIds() const; -+ static QSharedPointer &instance(); -+ QSharedPointer createJsSensor(const QString &uuid, SensorBackendBase *backend); -+ void defineProperties(size_t property_count, const napi_property_descriptor* properties); -+ -+private: -+ QSharedPointer m_sensors; -+}; -+ -+#endif // SENSORMANAGER_H -diff --git a/src/plugins/sensors/sensors.pro b/src/plugins/sensors/sensors.pro -index 7fce2071..8037ffc4 100644 ---- a/src/plugins/sensors/sensors.pro -+++ b/src/plugins/sensors/sensors.pro -@@ -5,6 +5,10 @@ android { - isEmpty(SENSORS_PLUGINS): SENSORS_PLUGINS = android generic - } - -+openharmony { -+ isEmpty(SENSORS_PLUGINS): SENSORS_PLUGINS = openharmony generic -+} -+ - qtConfig(sensorfw) { - isEmpty(SENSORS_PLUGINS): SENSORS_PLUGINS = sensorfw generic - } -@@ -39,6 +43,7 @@ isEmpty(SENSORS_PLUGINS)|contains(SENSORS_PLUGINS, simulator):qtHaveModule(simul - isEmpty(SENSORS_PLUGINS)|contains(SENSORS_PLUGINS, linux):linux:SUBDIRS += linux - isEmpty(SENSORS_PLUGINS)|contains(SENSORS_PLUGINS, iio-sensor-proxy):linux:qtHaveModule(dbus):SUBDIRS += iio-sensor-proxy - isEmpty(SENSORS_PLUGINS)|contains(SENSORS_PLUGINS, android):android:SUBDIRS += android -+isEmpty(SENSORS_PLUGINS)|contains(SENSORS_PLUGINS, openharmony):openharmony:SUBDIRS += openharmony - isEmpty(SENSORS_PLUGINS)|contains(SENSORS_PLUGINS, sensorfw):sensorfw:SUBDIRS += sensorfw - isEmpty(SENSORS_PLUGINS)|contains(SENSORS_PLUGINS, sensortag):linux:SUBDIRS += sensortag - isEmpty(SENSORS_PLUGINS)|contains(SENSORS_PLUGINS, ios):darwin:SUBDIRS += ios -diff --git a/src/src.pro b/src/src.pro -index b3aa7ba0..df12cad0 100644 ---- a/src/src.pro -+++ b/src/src.pro -@@ -16,3 +16,6 @@ plugins.subdir = plugins - plugins.target = sub-plugins - plugins.depends = sensors - -+SUBDIRS += openharmony -+openharmony.subdir = openharmony -+openharmony.target = sub-openharmony -- Gitee From 1084594de04970bb2381b32764d29f78b0a3b4d4 Mon Sep 17 00:00:00 2001 From: wanghao Date: Mon, 9 Oct 2023 14:59:06 +0800 Subject: [PATCH 5/5] =?UTF-8?q?[mod]=20=E9=82=AE=E7=AE=B1=E7=AD=BE?= =?UTF-8?q?=E7=BD=B2=E9=97=AE=E9=A2=98=E9=87=8D=E6=96=B0=E6=8F=90=E4=BA=A4?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: wanghao --- patch/qtsensor.patch | 1339 ++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 1339 insertions(+) create mode 100644 patch/qtsensor.patch diff --git a/patch/qtsensor.patch b/patch/qtsensor.patch new file mode 100644 index 0000000000..27f1499543 --- /dev/null +++ b/patch/qtsensor.patch @@ -0,0 +1,1339 @@ +diff --git a/src/openharmony/native/QtSensors.ts b/src/openharmony/native/QtSensors.ts +new file mode 100644 +index 00000000..8c7ad9a0 +--- /dev/null ++++ b/src/openharmony/native/QtSensors.ts +@@ -0,0 +1,132 @@ ++import sensor from '@ohos.sensor'; ++import qtsensorsplugin from 'libplugins_sensors_qtsensors_openharmony.so'; ++ ++export class QtSensors { ++ private pointerId = 0; ++ ++ public constructor(id) { ++ this.pointerId = id; ++ } ++ ++ /* Hz转ns,周期为1 */ ++ private hertz2ns(rate: Number) { ++ /* f=1/T （其中f是指赫兹,T是指以秒为单位的时间）*/ ++ let ns = (1 / Number(rate)) * 1000000000; ++ return ns; ++ } ++ ++ /* ns转Hz,周期为1 */ ++ private ns2hertz(ns: Number) { ++ /* f=1/T （其中f是指赫兹,T是指以秒为单位的时间）*/ ++ let hz = 1 / (Number(ns) / 1000000000); ++ return hz; ++ } ++ ++ createSensor(name, p) { ++ let server = new QtSensors(p); ++ Reflect.defineProperty(globalThis, name, { value: server }); ++ return true; ++ } ++ ++ destroySensor(name: string) { ++ Reflect.deleteProperty(globalThis, name); ++ this.pointerId = 0; ++ return true; ++ } ++ ++ /* 获取所有传感器类型Id */ ++ async sensorIds() { ++ let s: Array = new Array(); ++ try { ++ let sr = await sensor.getSensorList(); ++ for (let data of sr) { ++ s.push(String(data.sensorId)); ++ } ++ } catch (e) { ++ console.error(`Failed to get sensorList. Code: ${e.code}, message: ${e.message}`); ++ } ++ return s; ++ } ++ ++ stop(type: sensor.SensorId) { ++ try { ++ sensor.off(Number(type)); ++ } catch (error) { ++ console.error(`Failed to invoke off. Code: ${error.code}, message: ${error.message}`); ++ } ++ } ++ ++ /* 开始订阅传感器数据 */ ++ async start(type: sensor.SensorId, rate: Number) { ++ try { ++ this.stop(type); ++ let ns = this.hertz2ns(rate); ++ let max = await this.maxSamplePeriod(type); ++ let min = await this.minSamplePeriod(type); ++ let iv = Math.max(Math.min(max, ns), min); ++ ++ sensor.on(Number(type), (data) => { ++ qtsensorsplugin.DataAcception(this.pointerId, JSON.stringify(data)); ++ }, { interval: iv }); ++ } catch (error) { ++ console.error(`Failed to invoke on. Code: ${error.code}, message: ${error.message}`); ++ } ++ } ++ ++ /* 获取指定传感器信息 */ ++ async description(type: sensor.SensorId) { ++ try { ++ let info = await sensor.getSingleSensor(type); ++ let des = JSON.stringify(info); ++ console.info('Succeeded in getting sensor: ' + des); ++ return des; ++ } catch (e) { ++ console.error(`Failed to get singleSensor . Code: ${e.code}, message: ${e.message}`); ++ } ++ } ++ ++ async sensorName(type: sensor.SensorId) { ++ let s = await sensor.getSingleSensor(type); ++ return s.sensorName; ++ } ++ ++ async vendorName(type: sensor.SensorId) { ++ let s = await sensor.getSingleSensor(type); ++ return s.vendorName; ++ } ++ ++ async firmwareVersion(type: sensor.SensorId) { ++ let s = await sensor.getSingleSensor(type); ++ return s.firmwareVersion; ++ } ++ ++ async hardwareVersion(type: sensor.SensorId) { ++ let s = await sensor.getSingleSensor(type); ++ return s.hardwareVersion; ++ } ++ ++ async maxRange(type: sensor.SensorId) { ++ let s = await sensor.getSingleSensor(type); ++ return s.maxRange; ++ } ++ ++ async minSamplePeriod(type: sensor.SensorId) { ++ let s = await sensor.getSingleSensor(type); ++ return this.ns2hertz(s.minSamplePeriod); ++ } ++ ++ async maxSamplePeriod(type: sensor.SensorId) { ++ let s = await sensor.getSingleSensor(type); ++ return this.ns2hertz(s.minSamplePeriod); ++ } ++ ++ async precision(type: sensor.SensorId) { ++ let s = await sensor.getSingleSensor(type); ++ return s.precision; ++ } ++ ++ async power(type: sensor.SensorId) { ++ let s = await sensor.getSingleSensor(type); ++ return s.minSamplePeriod; ++ } ++} +\ No newline at end of file +diff --git a/src/openharmony/openharmony.pro b/src/openharmony/openharmony.pro +new file mode 100644 +index 00000000..6f56bfea +--- /dev/null ++++ b/src/openharmony/openharmony.pro +@@ -0,0 +1,11 @@ ++TEMPLATE = aux ++ ++CONFIG -= qt ++ ++templates.files += $$files($$PWD/native/*.ts, true) ++templates.path = $$[QT_INSTALL_PREFIX]/openharmony/qtsensors ++templates.base = $$PWD ++ ++INSTALLS += templates ++ ++OTHER_FILES += $$templates.files +diff --git a/src/plugins/sensors/openharmony/main.cpp b/src/plugins/sensors/openharmony/main.cpp +new file mode 100644 +index 00000000..c14f6520 +--- /dev/null ++++ b/src/plugins/sensors/openharmony/main.cpp +@@ -0,0 +1,222 @@ ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++ ++#include "sensormanager.h" ++#include "sensorbackend.h" ++#include ++#include "openharmonylight.h" ++#include "openharmonyrotation.h" ++#include "openharmonyhumidity.h" ++#include "openharmonypressure.h" ++#include "openharmonyproximity.h" ++#include "openharmonygyroscope.h" ++#include "openharmonytemperature.h" ++#include "openharmonymagnetometer.h" ++#include "openharmonyaccelerometer.h" ++#include "QtCore/qopenharmonydefines.h" ++#include "QtCore/qopenharmonyjsenvironment.h" ++ ++ ++static napi_value DataAcception(napi_env env, napi_callback_info info) ++{ ++ size_t argc = 2; ++ napi_value args[2] = { Q_NULLPTR }; ++ napi_get_cb_info(env, info, &argc, args , nullptr, nullptr); ++ ++ if (argc != 2) { ++ napi_throw_type_error(env, NULL, "Wrong number of arguments in DataAcception"); ++ return nullptr; ++ } ++ int64_t value0 = qJs::getInt64(args[0]); ++ SensorBackendBase *backend = reinterpret_cast(value0); ++ if (backend == nullptr) ++ return Q_NULLPTR; ++ ++ ++ SensorBackendBase *sensor = reinterpret_cast(value0); ++ if (Q_NULLPTR == sensor) ++ return Q_NULLPTR; ++ ++ QByteArray data = qJs::getString(args[1]).toLocal8Bit(); ++ if (data.isEmpty()) ++ return Q_NULLPTR; ++ ++ QJsonParseError err; ++ const QJsonDocument &doc = QJsonDocument::fromJson(data, &err); ++ if (QJsonParseError::NoError != err.error) ++ return Q_NULLPTR; ++ ++ ++ //sensor->dataReceived(doc.object()); ++ QMetaObject::invokeMethod(sensor, "dataReceived", ++ Qt::QueuedConnection, ++ Q_ARG(QJsonObject, doc.object())); ++ return Q_NULLPTR; ++} ++ ++namespace { ++const char OPenHarmonyCompassId[] = "openharmony.synthetic.compass"; ++} ++ ++class OPenHarmonySensorPlugin : public QObject, public QSensorPluginInterface, ++ public QSensorBackendFactory ++{ ++ Q_OBJECT ++ Q_PLUGIN_METADATA(IID "com.qt-project.Qt.QSensorPluginInterface/1.0" FILE "plugin.json") ++ Q_INTERFACES(QSensorPluginInterface) ++ ++public: ++ void registerSensors() override ++ { ++ bool accelerometer = false; ++ bool magnetometer = false; ++ const QList &ids = SensorManager::instance()->sensorIds(); ++ for (int sensor : qAsConst(ids)) { ++ switch (sensor) { ++ case E_BAROMETER: ++ QSensorManager::registerBackend(QPressureSensor::type, QByteArray::number(sensor), this); ++ break; ++ case E_ACCELEROMETER: ++ m_accelerationModes |= OPenHarmonyAccelerometer::Accelerometer; ++ QSensorManager::registerBackend(QAccelerometer::type, QByteArray::number(sensor), this); ++ accelerometer = true; ++ break; ++ case E_LINEAR_ACCELEROMETER: ++ m_accelerationModes |= OPenHarmonyAccelerometer::LinearAcceleration; ++ //QSensorManager::registerBackend(QAccelerometer::type, QByteArray::number(sensor), this); ++ break; ++ case E_GRAVITY: ++ m_accelerationModes |= OPenHarmonyAccelerometer::Gravity; ++ //QSensorManager::registerBackend(QAccelerometer::type, QByteArray::number(sensor), this); ++ break; ++ case E_HUMIDITY: ++ QSensorManager::registerBackend(QHumiditySensor::type, QByteArray::number(sensor), this); ++ break; ++ case E_PROXIMITY: ++ QSensorManager::registerBackend(QProximitySensor::type, QByteArray::number(sensor), this); ++ break; ++ case E_GYROSCOPE: ++ QSensorManager::registerBackend(QGyroscope::type, QByteArray::number(sensor), this); ++ break; ++ case E_ORIENTATION: ++ /*FIXME 通过加速度传感器实现? */ ++ //QSensorManager::registerBackend(QOrientationSensor::type, QByteArray::number(sensor), this); ++ break; ++ case E_ROTATION_VECTOR: ++ QSensorManager::registerBackend(QRotationSensor::type, QByteArray::number(sensor), this); ++ break; ++ case E_AMBIENT_LIGHT: ++ QSensorManager::registerBackend(QAmbientLightSensor::type, QByteArray::number(sensor), this); ++ break; ++ case E_MAGNETIC_FIELD: ++ QSensorManager::registerBackend(QMagnetometer::type, QByteArray::number(sensor), this); ++ magnetometer = true; ++ break; ++ case E_AMBIENT_TEMPERATURE: ++ QSensorManager::registerBackend(QAmbientTemperatureSensor::type, QByteArray::number(sensor), this); ++ break; ++ default: ++ break; ++ } ++ } ++#if 0 ++ /* NOTE 现在的js回调机制不支持 ++ * 罗盘通过加速度和磁场传感器组合实现 ++ */ ++ if (accelerometer && magnetometer) ++ QSensorManager::registerBackend(QCompass::type, OPenHarmonyCompassId, this); ++#endif ++ } ++ ++ QSensorBackend *createBackend(QSensor *sensor) override ++ { ++ /* TODO QCompass */ ++ int id = sensor->identifier().toInt(); ++ switch (id) { ++ case E_BAROMETER: ++ return new OPenHarmonyPressure(id, sensor); ++ case E_ACCELEROMETER: ++ return new OPenHarmonyAccelerometer(m_accelerationModes, sensor); ++ case E_GYROSCOPE: ++ return new OPenHarmonyGyroscope(id, sensor); ++ case E_PROXIMITY: ++ return new OPenHarmonyProximity(id, sensor); ++ case E_AMBIENT_LIGHT: ++ return new OPenHarmonyLight(id, sensor); ++ case E_MAGNETIC_FIELD: ++ return new OPenHarmonyMagnetometer(id, sensor); ++ case E_HUMIDITY: ++ return new OPenHarmonyHumidity(id, sensor); ++ case E_ROTATION_VECTOR: ++ return new OPenHarmonyRotation(id, sensor); ++ case E_AMBIENT_TEMPERATURE: ++ return new OPenHarmonyTemperature(id, sensor); ++ default: ++ break; ++ } ++ return Q_NULLPTR; ++ } ++ ++private: ++ int m_accelerationModes = 0; ++}; ++ ++/* ++ * function for module exports ++ */ ++EXTERN_C_START ++static napi_value Init(napi_env env, napi_value exports) ++{ ++ static bool inited = false; ++ if (!inited) { ++ ++ LOGI("init sensors module"); ++ napi_property_descriptor desc[] ={ ++ DECLARE_NAPI_FUNCTION("DataAcception", DataAcception), ++ }; ++ NAPI_CALL(env, napi_define_properties(env, exports, sizeof(desc) / sizeof(desc[0]), desc)); ++ inited = true; ++ } ++ return exports; ++} ++EXTERN_C_END ++ ++/* ++ * Napi Module define ++ */ ++static napi_module openharmonyQtSensorsModule = { ++ .nm_version = 1, ++ .nm_flags = 0, ++ .nm_filename = nullptr, ++ .nm_register_func = Init, ++ .nm_modname = "openharmony_qt_sensors", ++ .nm_priv = ((void*)0), ++ .reserved = { 0 }, ++}; ++/* ++ * Module register function ++ */ ++extern "C" __attribute__((constructor)) void RegisterModule(void) ++{ ++ napi_module_register(&openharmonyQtSensorsModule); ++} ++ ++#include "main.moc" +diff --git a/src/plugins/sensors/openharmony/openharmony.pro b/src/plugins/sensors/openharmony/openharmony.pro +new file mode 100644 +index 00000000..390e904c +--- /dev/null ++++ b/src/plugins/sensors/openharmony/openharmony.pro +@@ -0,0 +1,36 @@ ++TARGET = qtsensors_openharmony ++QT = core sensors ++ ++OTHER_FILES = plugin.json ++ ++SOURCES += \ ++ main.cpp \ ++ openharmonyaccelerometer.cpp \ ++ openharmonygyroscope.cpp \ ++ openharmonyhumidity.cpp \ ++ openharmonylight.cpp \ ++ openharmonymagnetometer.cpp \ ++ openharmonypressure.cpp \ ++ openharmonyproximity.cpp \ ++ openharmonyrotation.cpp \ ++ openharmonytemperature.cpp \ ++ sensormanager.cpp ++ ++ ++PLUGIN_TYPE = sensors ++PLUGIN_CLASS_NAME = OPenHarmonySensorPlugin ++load(qt_plugin) ++ ++HEADERS += \ ++ openharmonyaccelerometer.h \ ++ openharmonygyroscope.h \ ++ openharmonyhumidity.h \ ++ openharmonylight.h \ ++ openharmonymagnetometer.h \ ++ openharmonypressure.h \ ++ openharmonyproximity.h \ ++ openharmonyrotation.h \ ++ openharmonytemperature.h \ ++ sensorbackend.h \ ++ sensormanager.h ++ +diff --git a/src/plugins/sensors/openharmony/openharmonyaccelerometer.cpp b/src/plugins/sensors/openharmony/openharmonyaccelerometer.cpp +new file mode 100644 +index 00000000..84ad1e53 +--- /dev/null ++++ b/src/plugins/sensors/openharmony/openharmonyaccelerometer.cpp +@@ -0,0 +1,71 @@ ++#include ++#include ++#include ++ ++#include "openharmonyaccelerometer.h" ++ ++OPenHarmonyAccelerometer::OPenHarmonyAccelerometer(int accelerationModes, QSensor *sensor, QObject *parent) ++ : SensorBackend(E_ACCELEROMETER, sensor, parent) ++ , m_accelerationModes(accelerationModes) ++{ ++ auto accelerometer = qobject_cast(sensor); ++ if (accelerometer) { ++ connect(accelerometer, &QAccelerometer::accelerationModeChanged, ++ this, &OPenHarmonyAccelerometer::applyAccelerationMode); ++ applyAccelerationMode(accelerometer->accelerationMode()); ++ } ++} ++ ++bool OPenHarmonyAccelerometer::isFeatureSupported(QSensor::Feature feature) const ++{ ++ return (feature == QSensor::AccelerationMode) ? m_accelerationModes == AllModes : SensorBackend::isFeatureSupported(feature); ++} ++ ++void OPenHarmonyAccelerometer::dataReceived(const QJsonObject &json) ++{ ++ double x = json.value("x").toDouble(); ++ double y = json.value("y").toDouble(); ++ double z = json.value("z").toDouble(); ++ ++ if (sensor()->skipDuplicates() && qFuzzyCompare(m_reader.x(), x) && ++ qFuzzyCompare(m_reader.y(), y) && ++ qFuzzyCompare(m_reader.z(), z)) { ++ return; ++ } ++ ++ double timestamp = json.value("timestamp").toDouble(); ++ m_reader.setTimestamp(quint64(timestamp)); ++ m_reader.setX(x); ++ m_reader.setY(y); ++ m_reader.setZ(z); ++ ++ newReadingAvailable(); ++} ++ ++void OPenHarmonyAccelerometer::applyAccelerationMode(QAccelerometer::AccelerationMode accelerationMode) ++{ ++ switch (accelerationMode) { ++ case QAccelerometer::Gravity: ++ if (!(m_accelerationModes & Gravity)) { ++ qWarning() << "Gravity sensor missing"; ++ return; ++ } ++ setSensorType(E_GRAVITY); ++ break; ++ case QAccelerometer::User: ++ if (!(m_accelerationModes & LinearAcceleration)) { ++ qWarning() << "Linear acceleration sensor missing"; ++ return; ++ } ++ setSensorType(E_LINEAR_ACCELEROMETER); ++ break; ++ case QAccelerometer::Combined: ++ if (!(m_accelerationModes & Accelerometer)) { ++ qWarning() << "Accelerometer sensor missing"; ++ return; ++ } ++ setSensorType(E_ACCELEROMETER); ++ break; ++ } ++} ++ +diff --git a/src/plugins/sensors/openharmony/openharmonyaccelerometer.h b/src/plugins/sensors/openharmony/openharmonyaccelerometer.h +new file mode 100644 +index 00000000..a610d25b +--- /dev/null ++++ b/src/plugins/sensors/openharmony/openharmonyaccelerometer.h +@@ -0,0 +1,32 @@ ++#ifndef OPENHARMONYACCELEROMETER_H ++#define OPENHARMONYACCELEROMETER_H ++ ++#include ++ ++#include "sensorbackend.h" ++ ++class OPenHarmonyAccelerometer : public SensorBackend ++{ ++ Q_OBJECT ++ ++public: ++ enum AccelerationModes { ++ Accelerometer = 1, ++ Gravity = 2, ++ LinearAcceleration = 4, ++ AllModes = (Accelerometer | Gravity | LinearAcceleration) ++ }; ++ OPenHarmonyAccelerometer(int accelerationModes, QSensor *sensor, QObject *parent = nullptr); ++ bool isFeatureSupported(QSensor::Feature feature) const override; ++ ++protected Q_SLOTS: ++ void dataReceived(const QJsonObject &json) override; ++ ++private: ++ void applyAccelerationMode(QAccelerometer::AccelerationMode accelerationMode); ++ ++private: ++ int m_accelerationModes; ++}; ++ ++#endif // OPENHARMONYACCELEROMETER_H +diff --git a/src/plugins/sensors/openharmony/openharmonygyroscope.cpp b/src/plugins/sensors/openharmony/openharmonygyroscope.cpp +new file mode 100644 +index 00000000..349b7e2f +--- /dev/null ++++ b/src/plugins/sensors/openharmony/openharmonygyroscope.cpp +@@ -0,0 +1,33 @@ ++#include ++#include ++#include ++ ++#include "openharmonygyroscope.h" ++ ++OPenHarmonyGyroscope::OPenHarmonyGyroscope(int type, QSensor *sensor, QObject *parent) ++: SensorBackend(type, sensor, parent) ++{ ++ ++} ++ ++void OPenHarmonyGyroscope::dataReceived(const QJsonObject &json) ++{ ++ double x = qRadiansToDegrees(json.value("x").toDouble()); ++ double y = qRadiansToDegrees(json.value("y").toDouble()); ++ double z = qRadiansToDegrees(json.value("z").toDouble()); ++ double timestamp = json.value("timestamp").toDouble(); ++ ++ if (sensor()->skipDuplicates() && qFuzzyCompare(m_reader.x(), x) && ++ qFuzzyCompare(m_reader.y(), y) && ++ qFuzzyCompare(m_reader.z(), z)) { ++ return; ++ } ++ ++ m_reader.setTimestamp(quint64(timestamp)); ++ m_reader.setX(x); ++ m_reader.setY(y); ++ m_reader.setZ(z); ++ ++ newReadingAvailable(); ++} ++ +diff --git a/src/plugins/sensors/openharmony/openharmonygyroscope.h b/src/plugins/sensors/openharmony/openharmonygyroscope.h +new file mode 100644 +index 00000000..ff3e6d2a +--- /dev/null ++++ b/src/plugins/sensors/openharmony/openharmonygyroscope.h +@@ -0,0 +1,18 @@ ++#ifndef OPENHARMONYGYROSCOPE_H ++#define OPENHARMONYGYROSCOPE_H ++ ++#include ++ ++#include "sensorbackend.h" ++ ++class OPenHarmonyGyroscope : public SensorBackend ++{ ++ Q_OBJECT ++public: ++ OPenHarmonyGyroscope(int type, QSensor *sensor, QObject *parent = nullptr); ++ ++protected Q_SLOTS: ++ void dataReceived(const QJsonObject &json) override; ++}; ++ ++#endif // OPENHARMONYGYROSCOPE_H +diff --git a/src/plugins/sensors/openharmony/openharmonyhumidity.cpp b/src/plugins/sensors/openharmony/openharmonyhumidity.cpp +new file mode 100644 +index 00000000..e17df8cf +--- /dev/null ++++ b/src/plugins/sensors/openharmony/openharmonyhumidity.cpp +@@ -0,0 +1,25 @@ ++#include ++#include ++ ++#include "openharmonyhumidity.h" ++ ++OPenHarmonyHumidity::OPenHarmonyHumidity(int type, QSensor *sensor, QObject *parent) ++ : SensorBackend(type, sensor, parent) ++{ ++ ++} ++ ++void OPenHarmonyHumidity::dataReceived(const QJsonObject &json) ++{ ++ qreal humidity = json.value("humidity").toDouble(); ++ ++ if (sensor()->skipDuplicates() && qFuzzyCompare(humidity, m_reader.relativeHumidity())) ++ return; ++ ++ double timestamp = json.value("timestamp").toDouble(); ++ m_reader.setTimestamp(quint64(timestamp)); ++ m_reader.setAbsoluteHumidity(0.f); ++ m_reader.setRelativeHumidity(humidity); ++ newReadingAvailable(); ++} ++ +diff --git a/src/plugins/sensors/openharmony/openharmonyhumidity.h b/src/plugins/sensors/openharmony/openharmonyhumidity.h +new file mode 100644 +index 00000000..adbf4c9b +--- /dev/null ++++ b/src/plugins/sensors/openharmony/openharmonyhumidity.h +@@ -0,0 +1,18 @@ ++#ifndef OPENHARMONYHUMIDITY_H ++#define OPENHARMONYHUMIDITY_H ++ ++#include ++ ++#include "sensorbackend.h" ++ ++class OPenHarmonyHumidity : public SensorBackend ++{ ++ Q_OBJECT ++public: ++ OPenHarmonyHumidity(int type, QSensor *sensor, QObject *parent = nullptr); ++ ++protected Q_SLOTS: ++ void dataReceived(const QJsonObject &json) override; ++}; ++ ++#endif // OPENHARMONYHUMIDITY_H +diff --git a/src/plugins/sensors/openharmony/openharmonylight.cpp b/src/plugins/sensors/openharmony/openharmonylight.cpp +new file mode 100644 +index 00000000..7274df7c +--- /dev/null ++++ b/src/plugins/sensors/openharmony/openharmonylight.cpp +@@ -0,0 +1,23 @@ ++#include ++#include ++ ++#include "openharmonylight.h" ++ ++OPenHarmonyLight::OPenHarmonyLight(int type, QSensor *sensor, QObject *parent) ++ : SensorBackend(type, sensor, parent) ++{ ++ ++} ++ ++void OPenHarmonyLight::dataReceived(const QJsonObject &json) ++{ ++ double intensity = json.value("intensity").toDouble(); ++ ++ if (sensor()->skipDuplicates() && qFuzzyCompare(m_reader.lux(), intensity)) ++ return; ++ ++ double timestamp = json.value("timestamp").toDouble(); ++ m_reader.setTimestamp(quint64(timestamp)); ++ m_reader.setLux(qreal(intensity)); ++ newReadingAvailable(); ++} +diff --git a/src/plugins/sensors/openharmony/openharmonylight.h b/src/plugins/sensors/openharmony/openharmonylight.h +new file mode 100644 +index 00000000..f8039a92 +--- /dev/null ++++ b/src/plugins/sensors/openharmony/openharmonylight.h +@@ -0,0 +1,18 @@ ++#ifndef OPENHARMONYLIGHT_H ++#define OPENHARMONYLIGHT_H ++ ++#include ++ ++#include "sensorbackend.h" ++ ++class OPenHarmonyLight : public SensorBackend ++{ ++ Q_OBJECT ++public: ++ OPenHarmonyLight(int type, QSensor *sensor, QObject *parent = nullptr); ++ ++protected Q_SLOTS: ++ void dataReceived(const QJsonObject &json) override; ++}; ++ ++#endif // OPENHARMONYLIGHT_H +diff --git a/src/plugins/sensors/openharmony/openharmonymagnetometer.cpp b/src/plugins/sensors/openharmony/openharmonymagnetometer.cpp +new file mode 100644 +index 00000000..34e34b21 +--- /dev/null ++++ b/src/plugins/sensors/openharmony/openharmonymagnetometer.cpp +@@ -0,0 +1,32 @@ ++#include ++#include ++#include "openharmonymagnetometer.h" ++ ++OPenHarmonyMagnetometer::OPenHarmonyMagnetometer(int type, QSensor *sensor, QObject *parent) ++ : SensorBackend(type, sensor, parent) ++{ ++ ++} ++ ++void OPenHarmonyMagnetometer::dataReceived(const QJsonObject &json) ++{ ++ double x = json.value("x").toDouble(); ++ double y = json.value("y").toDouble(); ++ double z = json.value("z").toDouble(); ++ ++ if (sensor()->skipDuplicates() && qFuzzyCompare(m_accuracy, m_reader.calibrationLevel()) && ++ qFuzzyCompare(x, m_reader.x()) && ++ qFuzzyCompare(y, m_reader.y()) && ++ qFuzzyCompare(z, m_reader.z())) { ++ return; ++ } ++ ++ m_reader.setCalibrationLevel(m_accuracy); ++ double timestamp = json.value("timestamp").toDouble(); ++ m_reader.setTimestamp(quint64(timestamp)); ++ m_reader.setX(x); ++ m_reader.setY(y); ++ m_reader.setZ(z); ++ newReadingAvailable(); ++} ++ +diff --git a/src/plugins/sensors/openharmony/openharmonymagnetometer.h b/src/plugins/sensors/openharmony/openharmonymagnetometer.h +new file mode 100644 +index 00000000..c3662243 +--- /dev/null ++++ b/src/plugins/sensors/openharmony/openharmonymagnetometer.h +@@ -0,0 +1,18 @@ ++#ifndef OPENHARMONYMAGNETOMETER_H ++#define OPENHARMONYMAGNETOMETER_H ++ ++#include ++ ++#include "sensorbackend.h" ++ ++class OPenHarmonyMagnetometer : public SensorBackend ++{ ++ Q_OBJECT ++public: ++ OPenHarmonyMagnetometer(int type, QSensor *sensor, QObject *parent = nullptr); ++ ++protected Q_SLOTS: ++ void dataReceived(const QJsonObject &json) override; ++}; ++ ++#endif // OPENHARMONYMAGNETOMETER_H +diff --git a/src/plugins/sensors/openharmony/openharmonypressure.cpp b/src/plugins/sensors/openharmony/openharmonypressure.cpp +new file mode 100644 +index 00000000..c7d5d3d3 +--- /dev/null ++++ b/src/plugins/sensors/openharmony/openharmonypressure.cpp +@@ -0,0 +1,22 @@ ++#include ++#include ++ ++#include "openharmonypressure.h" ++ ++OPenHarmonyPressure::OPenHarmonyPressure(int type, QSensor *sensor, QObject *parent) ++ : SensorBackend(type, sensor, parent) ++{ ++ ++} ++ ++void OPenHarmonyPressure::dataReceived(const QJsonObject &json) ++{ ++ auto pressurePa = json.value("pressure").toDouble(); ++ if (sensor()->skipDuplicates() && qFuzzyCompare(pressurePa, m_reader.pressure())) ++ return; ++ ++ double timestamp = json.value("timestamp").toDouble(); ++ m_reader.setTimestamp(quint64(timestamp)); ++ m_reader.setPressure(pressurePa); ++ newReadingAvailable(); ++} +diff --git a/src/plugins/sensors/openharmony/openharmonypressure.h b/src/plugins/sensors/openharmony/openharmonypressure.h +new file mode 100644 +index 00000000..8c2db8aa +--- /dev/null ++++ b/src/plugins/sensors/openharmony/openharmonypressure.h +@@ -0,0 +1,18 @@ ++#ifndef OPENHARMONYPRESSURE_H ++#define OPENHARMONYPRESSURE_H ++ ++#include ++ ++#include "sensorbackend.h" ++ ++class OPenHarmonyPressure : public SensorBackend ++{ ++ Q_OBJECT ++public: ++ OPenHarmonyPressure(int type, QSensor *sensor, QObject *parent = nullptr); ++ ++protected Q_SLOTS: ++ void dataReceived(const QJsonObject &json) override; ++}; ++ ++#endif // OPENHARMONYPRESSURE_H +diff --git a/src/plugins/sensors/openharmony/openharmonyproximity.cpp b/src/plugins/sensors/openharmony/openharmonyproximity.cpp +new file mode 100644 +index 00000000..e96a0b24 +--- /dev/null ++++ b/src/plugins/sensors/openharmony/openharmonyproximity.cpp +@@ -0,0 +1,28 @@ ++#include ++#include ++ ++#include "openharmonyproximity.h" ++ ++OPenHarmonyProximity::OPenHarmonyProximity(int type, QSensor *sensor, QObject *parent) ++ : SensorBackend(type, sensor, parent) ++{ ++ m_maximumRange = m_jsSensor->maxRange(m_type); ++ ++ // if we can't get the range, we arbitrarily define anything closer than 10 cm as "close" ++ if (m_maximumRange <= 0) ++ m_maximumRange = 10.0; ++} ++ ++void OPenHarmonyProximity::dataReceived(const QJsonObject &json) ++{ ++ qreal distance = json.value("distance").toDouble(); ++ bool close = distance < m_maximumRange; ++ if (sensor()->skipDuplicates() && close == m_reader.close()) ++ return; ++ ++ double timestamp = json.value("timestamp").toDouble(); ++ m_reader.setTimestamp(quint64(timestamp)); ++ m_reader.setClose(close); ++ newReadingAvailable(); ++} ++ +diff --git a/src/plugins/sensors/openharmony/openharmonyproximity.h b/src/plugins/sensors/openharmony/openharmonyproximity.h +new file mode 100644 +index 00000000..f1ef02f2 +--- /dev/null ++++ b/src/plugins/sensors/openharmony/openharmonyproximity.h +@@ -0,0 +1,21 @@ ++#ifndef OPENHARMONYPROXIMITY_H ++#define OPENHARMONYPROXIMITY_H ++ ++#include ++ ++#include "sensorbackend.h" ++ ++class OPenHarmonyProximity : public SensorBackend ++{ ++ Q_OBJECT ++public: ++ OPenHarmonyProximity(int type, QSensor *sensor, QObject *parent = nullptr); ++ ++protected Q_SLOTS: ++ void dataReceived(const QJsonObject &json) override; ++ ++private: ++ qreal m_maximumRange; ++}; ++ ++#endif // OPENHARMONYPROXIMITY_H +diff --git a/src/plugins/sensors/openharmony/openharmonyrotation.cpp b/src/plugins/sensors/openharmony/openharmonyrotation.cpp +new file mode 100644 +index 00000000..a4d70e6f +--- /dev/null ++++ b/src/plugins/sensors/openharmony/openharmonyrotation.cpp +@@ -0,0 +1,29 @@ ++#include ++#include ++#include ++ ++#include "openharmonyrotation.h" ++ ++OPenHarmonyRotation::OPenHarmonyRotation(int type, QSensor *sensor, QObject *parent) ++ : SensorBackend(type, sensor, parent) ++{ ++ ++} ++ ++void OPenHarmonyRotation::dataReceived(const QJsonObject &json) ++{ ++ qreal rz = -qRadiansToDegrees(json.value("x").toDouble()); //corresponds to x ++ qreal rx = -qRadiansToDegrees(json.value("y").toDouble()); //corresponds to y ++ qreal ry = qRadiansToDegrees(json.value("z").toDouble()); //corresponds to z ++ if (sensor()->skipDuplicates() && qFuzzyCompare(m_reader.x(), rx) && ++ qFuzzyCompare(m_reader.y(), ry) && ++ qFuzzyCompare(m_reader.z(), rz)) { ++ return; ++ } ++ ++ double timestamp = json.value("timestamp").toDouble(); ++ m_reader.setTimestamp(quint64(timestamp)); ++ m_reader.setFromEuler(rx, ry, rz); ++ newReadingAvailable(); ++} ++ +diff --git a/src/plugins/sensors/openharmony/openharmonyrotation.h b/src/plugins/sensors/openharmony/openharmonyrotation.h +new file mode 100644 +index 00000000..03243797 +--- /dev/null ++++ b/src/plugins/sensors/openharmony/openharmonyrotation.h +@@ -0,0 +1,18 @@ ++#ifndef OPENHARMONYROTATION_H ++#define OPENHARMONYROTATION_H ++ ++#include ++ ++#include "sensorbackend.h" ++ ++class OPenHarmonyRotation : public SensorBackend ++{ ++ Q_OBJECT ++public: ++ OPenHarmonyRotation(int type, QSensor *sensor, QObject *parent = nullptr); ++ ++protected Q_SLOTS: ++ void dataReceived(const QJsonObject &json) override; ++}; ++ ++#endif // OPENHARMONYROTATION_H +diff --git a/src/plugins/sensors/openharmony/openharmonytemperature.cpp b/src/plugins/sensors/openharmony/openharmonytemperature.cpp +new file mode 100644 +index 00000000..a3865b03 +--- /dev/null ++++ b/src/plugins/sensors/openharmony/openharmonytemperature.cpp +@@ -0,0 +1,23 @@ ++#include ++#include ++ ++#include "openharmonytemperature.h" ++ ++OPenHarmonyTemperature::OPenHarmonyTemperature(int type, QSensor *sensor, QObject *parent) ++ : SensorBackend(type, sensor, parent) ++{ ++ ++} ++ ++void OPenHarmonyTemperature::dataReceived(const QJsonObject &json) ++{ ++ qreal temperature = json.value("temperature").toDouble(); ++ if (sensor()->skipDuplicates() && qFuzzyCompare(m_reader.temperature(), temperature)) ++ return; ++ ++ double timestamp = json.value("timestamp").toDouble(); ++ m_reader.setTimestamp(quint64(timestamp)); ++ m_reader.setTemperature(temperature); // in degree Celsius ++ newReadingAvailable(); ++} ++ +diff --git a/src/plugins/sensors/openharmony/openharmonytemperature.h b/src/plugins/sensors/openharmony/openharmonytemperature.h +new file mode 100644 +index 00000000..cc881f20 +--- /dev/null ++++ b/src/plugins/sensors/openharmony/openharmonytemperature.h +@@ -0,0 +1,18 @@ ++#ifndef OPENHARMONYTEMPERATURE_H ++#define OPENHARMONYTEMPERATURE_H ++ ++#include ++ ++#include "sensorbackend.h" ++ ++class OPenHarmonyTemperature : public SensorBackend ++{ ++ Q_OBJECT ++public: ++ OPenHarmonyTemperature(int type, QSensor *sensor, QObject *parent = nullptr); ++ ++protected Q_SLOTS: ++ void dataReceived(const QJsonObject &json) override; ++}; ++ ++#endif // OPENHARMONYTEMPERATURE_H +diff --git a/src/plugins/sensors/openharmony/plugin.json b/src/plugins/sensors/openharmony/plugin.json +new file mode 100644 +index 00000000..ff40b670 +--- /dev/null ++++ b/src/plugins/sensors/openharmony/plugin.json +@@ -0,0 +1 @@ ++{ "Keys": [ "openharmony" ] } +diff --git a/src/plugins/sensors/openharmony/sensorbackend.h b/src/plugins/sensors/openharmony/sensorbackend.h +new file mode 100644 +index 00000000..aa0907df +--- /dev/null ++++ b/src/plugins/sensors/openharmony/sensorbackend.h +@@ -0,0 +1,91 @@ ++#ifndef SENSORBACKEND_H ++#define SENSORBACKEND_H ++ ++#include ++#include ++ ++#include "sensormanager.h" ++ ++class SensorBackendBase : public QSensorBackend ++{ ++public: ++ SensorBackendBase(QSensor *sensor, QObject *parent = nullptr) ++ : QSensorBackend(sensor, parent) ++ , m_jsSensor(Q_NULLPTR) ++ { ++ QString tempUuid = QUuid::createUuid().toString(); ++ tempUuid.chop(1); //remove trailing '}' ++ tempUuid.remove(0,1); //remove first '{' ++ ++ m_jsSensor = SensorManager::instance()->createJsSensor(tempUuid, this); ++ } ++ ++public Q_SLOTS: ++ virtual void dataReceived(const QJsonObject &json) = 0; ++ ++protected: ++ QSharedPointer m_jsSensor; ++}; ++ ++template ++class SensorBackend : public SensorBackendBase ++{ ++public: ++ explicit SensorBackend(int type, QSensor *sensor, QObject *parent = nullptr) : m_type(0) ++ , SensorBackendBase{ sensor, parent } ++ { ++ setReading(&m_reader); ++ setSensorType(type); ++ m_accuracy = m_jsSensor->precision(type); ++ addDataRate(m_jsSensor->minSamplePeriod(type), ++ m_jsSensor->maxSamplePeriod(type)); ++ addOutputRange(0, m_jsSensor->maxRange(type), m_accuracy); ++ } ++ ++ ~SensorBackend() override ++ { ++ stop(); ++ } ++ ++ void setSensorType(int type) ++ { ++ m_type = type; ++ bool started = m_started; ++ if (started) ++ stop(); ++ ++ setDescription(m_jsSensor->description(type)); ++ if (started) ++ start(); ++ } ++ ++ virtual void start() override ++ { ++ m_jsSensor->start(m_type, sensor()->dataRate()); ++ m_started = true; ++ } ++ ++ virtual void stop() override ++ { ++ m_jsSensor->stop(m_type); ++ m_started = false; ++ } ++ ++ bool isFeatureSupported(QSensor::Feature feature) const override ++ { ++ switch (feature) { ++ case QSensor::SkipDuplicates: ++ return true; ++ default: ++ return false; ++ } ++ } ++ ++protected: ++ T m_reader; ++ int m_type; ++ qreal m_accuracy = 0.0f; ++ bool m_started = false; ++}; ++ ++#endif // SENSORBACKEND_H +diff --git a/src/plugins/sensors/openharmony/sensormanager.cpp b/src/plugins/sensors/openharmony/sensormanager.cpp +new file mode 100644 +index 00000000..d34294f4 +--- /dev/null ++++ b/src/plugins/sensors/openharmony/sensormanager.cpp +@@ -0,0 +1,121 @@ ++#include "sensormanager.h" ++#include "QtCore/qopenharmonyjsobject.h" ++#include "QtCore/qopenharmonyjsenvironment.h" ++#include "QtCore/qopenharmonyjsobjectloader.h" ++ ++JsSensor::JsSensor(const QString &uuid) : m_uuid(uuid) ++ , m_jsSensor(Q_NULLPTR) ++{ ++ ++} ++ ++JsSensor::~JsSensor() ++{ ++ if (m_jsSensor) ++ m_jsSensor->call("destroySensor", m_uuid); ++} ++ ++qreal JsSensor::power(int id) const ++{ ++ qreal p = m_jsSensor->call("power", id); ++ return p; ++} ++ ++QString JsSensor::name(int id) const ++{ ++ QString n = m_jsSensor->call("sensorName", id); ++ return n; ++} ++ ++qreal JsSensor::maxRange(int id) const ++{ ++ qreal r = m_jsSensor->call("maxRange", id); ++ return r; ++} ++ ++qreal JsSensor::precision(int id) const ++{ ++ qreal accuracy = m_jsSensor->call("precision", id); ++ return accuracy; ++} ++ ++QString JsSensor::vendorName(int id) const ++{ ++ QString n = m_jsSensor->call("vendorName", id); ++ return n; ++} ++ ++QString JsSensor::description(int id) const ++{ ++ QString des = m_jsSensor->call("description", id); ++ return des; ++} ++ ++qreal JsSensor::minSamplePeriod(int id) const ++{ ++ qreal p = m_jsSensor->call("minSamplePeriod", id); ++ return p; ++} ++ ++qreal JsSensor::maxSamplePeriod(int id) const ++{ ++ qreal p = m_jsSensor->call("maxSamplePeriod", id); ++ return p; ++} ++ ++QString JsSensor::firmwareVersion(int id) const ++{ ++ QString v = m_jsSensor->call("firmwareVersion", id); ++ return v; ++} ++ ++void JsSensor::stop(int id) ++{ ++ m_jsSensor->call("stop", id); ++} ++ ++void JsSensor::start(int id, int rate) ++{ ++ m_jsSensor->call("start", id, rate); ++} ++ ++QString JsSensor::hardwareVersion(int id) const ++{ ++ QString hv = m_jsSensor->call("hardwareVersion", id); ++ return hv; ++} ++ ++SensorManager::SensorManager() { ++ m_sensors = qJsObjectLoader->create("qtsensors"); ++} ++ ++QList SensorManager::sensorIds() const ++{ ++ QStringList ids = m_sensors->call("sensorIds"); ++ QList ns; ++ ns.reserve(ids.size()); ++ for (const auto &id : qAsConst(ids)) { ++ ns.append(id.toInt()); ++ } ++ return ns; ++} ++ ++QSharedPointer &SensorManager::instance() ++{ ++ static QSharedPointer s{ new SensorManager() }; ++ return s; ++} ++ ++QSharedPointer SensorManager::createJsSensor(const QString &uuid, SensorBackendBase *backend) ++{ ++ JsSensor *s = new JsSensor(uuid); ++ m_sensors->call("createSensor", uuid, QVariant(qlonglong(backend))); ++ s->m_jsSensor.reset(new QOpenHarmonyJsObject(uuid)); ++ return QSharedPointer(s); ++} ++ ++void SensorManager::defineProperties(size_t property_count, const napi_property_descriptor *properties) ++{ ++ m_sensors->defineProperties(property_count, properties); ++} ++ +diff --git a/src/plugins/sensors/openharmony/sensormanager.h b/src/plugins/sensors/openharmony/sensormanager.h +new file mode 100644 +index 00000000..157baa3c +--- /dev/null ++++ b/src/plugins/sensors/openharmony/sensormanager.h +@@ -0,0 +1,69 @@ ++#ifndef SENSORMANAGER_H ++#define SENSORMANAGER_H ++ ++#include ++#include ++ ++/* NOTE 鸿蒙和Qt传感器匹配的项 ++ * Qt对前端传感器模块进行了封装 ++ * 鸿蒙提供的传感器模块接口不是 ++ * 完全匹配,需要转换 ++ */ ++enum { ++ E_GRAVITY = 257, /* 重力传感器<--->QAccelerometer */ ++ E_HUMIDITY = 13, /* 湿度传感器<--->QHumiditySensor */ ++ E_BAROMETER = 8, /* 气压传感器<--->QPressureSensor */ ++ E_GYROSCOPE = 2, /* 陀螺仪传感器<--->QGyroscope */ ++ E_PROXIMITY = 12, /* 接近光传感器<--->QDistanceSensor */ ++ E_ORIENTATION = 256, /* 方向传感器<--->QOrientationSensor */ ++ E_ACCELEROMETER = 1, /* 加速度传感器<--->QAccelerometer */ ++ E_AMBIENT_LIGHT = 5, /* 环境光传感器<--->QAmbientLightSensor */ ++ E_MAGNETIC_FIELD = 6, /* 磁场传感器<--->QMagnetometer */ ++ E_ROTATION_VECTOR = 259, /* 旋转矢量传感器<--->QRotationSensor */ ++ E_AMBIENT_TEMPERATURE = 260, /* 环境温度传感器<--->QAmbientTemperatureSensor */ ++ E_LINEAR_ACCELEROMETER = 258, /* 线性加速度传感器<--->QAccelerometer */ ++}; ++ ++class SensorBackendBase; ++class QOpenHarmonyJsObject; ++ ++class JsSensor ++{ ++ QString m_uuid; ++ QSharedPointer m_jsSensor; ++ ++ friend class SensorManager; ++public: ++ JsSensor(const QString &uuid); ++ ~JsSensor(); ++ ++ qreal power(int id) const; ++ QString name(int id) const; ++ qreal maxRange(int id) const; ++ qreal precision(int id) const; ++ QString vendorName(int id) const; ++ QString description(int id) const; ++ qreal minSamplePeriod(int id) const; ++ qreal maxSamplePeriod(int id) const; ++ QString firmwareVersion(int id) const; ++ QString hardwareVersion(int id) const; ++ ++ void stop(int id); ++ void start(int id, int rate); ++}; ++ ++class SensorManager ++{ ++ SensorManager(); ++ ++public: ++ QList sensorIds() const; ++ static QSharedPointer &instance(); ++ QSharedPointer createJsSensor(const QString &uuid, SensorBackendBase *backend); ++ void defineProperties(size_t property_count, const napi_property_descriptor* properties); ++ ++private: ++ QSharedPointer m_sensors; ++}; ++ ++#endif // SENSORMANAGER_H +diff --git a/src/plugins/sensors/sensors.pro b/src/plugins/sensors/sensors.pro +index 7fce2071..8037ffc4 100644 +--- a/src/plugins/sensors/sensors.pro ++++ b/src/plugins/sensors/sensors.pro +@@ -5,6 +5,10 @@ android { + isEmpty(SENSORS_PLUGINS): SENSORS_PLUGINS = android generic + } + ++openharmony { ++ isEmpty(SENSORS_PLUGINS): SENSORS_PLUGINS = openharmony generic ++} ++ + qtConfig(sensorfw) { + isEmpty(SENSORS_PLUGINS): SENSORS_PLUGINS = sensorfw generic + } +@@ -39,6 +43,7 @@ isEmpty(SENSORS_PLUGINS)|contains(SENSORS_PLUGINS, simulator):qtHaveModule(simul + isEmpty(SENSORS_PLUGINS)|contains(SENSORS_PLUGINS, linux):linux:SUBDIRS += linux + isEmpty(SENSORS_PLUGINS)|contains(SENSORS_PLUGINS, iio-sensor-proxy):linux:qtHaveModule(dbus):SUBDIRS += iio-sensor-proxy + isEmpty(SENSORS_PLUGINS)|contains(SENSORS_PLUGINS, android):android:SUBDIRS += android ++isEmpty(SENSORS_PLUGINS)|contains(SENSORS_PLUGINS, openharmony):openharmony:SUBDIRS += openharmony + isEmpty(SENSORS_PLUGINS)|contains(SENSORS_PLUGINS, sensorfw):sensorfw:SUBDIRS += sensorfw + isEmpty(SENSORS_PLUGINS)|contains(SENSORS_PLUGINS, sensortag):linux:SUBDIRS += sensortag + isEmpty(SENSORS_PLUGINS)|contains(SENSORS_PLUGINS, ios):darwin:SUBDIRS += ios +diff --git a/src/src.pro b/src/src.pro +index b3aa7ba0..df12cad0 100644 +--- a/src/src.pro ++++ b/src/src.pro +@@ -16,3 +16,6 @@ plugins.subdir = plugins + plugins.target = sub-plugins + plugins.depends = sensors + ++SUBDIRS += openharmony ++openharmony.subdir = openharmony ++openharmony.target = sub-openharmony -- Gitee