Revision control
+ // Copyright (C) 2025 The Qt Company Ltd.
+ // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
+
+ #include <QtCore/private/qcore_ohos_p.h>
+ #include <QtCore/private/qohoslogger_p.h>
+ #include <ohossensorsmanager.h>
+ #include <ohossensorutils.h>
+ #include <algorithm>
+ #include <chrono>
+ #include <optional>
+
+ namespace {
+
+ std::optional<std::vector<float>> tryGetSensorEventData(::Sensor_Event *sensorEvent)
+ {
+ float *data = nullptr;
+ std::uint32_t len = 0;
+ std::int32_t getDataResult = ::OH_SensorEvent_GetData(sensorEvent, &data, &len);
+ if (getDataResult != ::SENSOR_SUCCESS) {
+ qOhosPrintfError("%s: OH_SensorEvent_GetData failed, code=%d", Q_FUNC_INFO, getDataResult);
+ return std::nullopt;
+ }
+ if (data == nullptr) {
+ qOhosPrintfError("%s: data pointer is null", Q_FUNC_INFO);
+ return std::nullopt;
+ }
+ return std::vector<float>(data, data + len);
+ }
+
+ std::shared_ptr<std::vector<::Sensor_Info *>> tryCreateInfos(std::uint32_t count)
+ {
+ ::Sensor_Info **sensors = ::OH_Sensor_CreateInfos(count);
+ if (sensors == nullptr) {
+ qOhosPrintfError("%s: cannot create sensor infos objects", Q_FUNC_INFO);
+ return nullptr;
+ }
+
+ auto sensorsWrapper = std::shared_ptr<void>(
+ sensors,
+ [sensors, count](auto *) {
+ std::uint32_t destroyInfosResult = ::OH_Sensor_DestroyInfos(sensors, count);
+ if (destroyInfosResult != ::SENSOR_SUCCESS) {
+ qOhosPrintfError(
+ "%s: cannot destroy sensor infos, error: %d", Q_FUNC_INFO, destroyInfosResult);
+ }
+ }
+ );
+
+ return QtOhos::makeSharedPtrWithAttachedExtraData(
+ std::make_shared<std::vector<::Sensor_Info *>>(sensors, sensors + count),
+ sensorsWrapper);
+ }
+
+ std::shared_ptr<std::vector<::Sensor_Info *>> tryGetAvailableSensorsInfo()
+ {
+ std::uint32_t sensorsCount = 0;
+ std::uint32_t getSensorsCountResult = ::OH_Sensor_GetInfos(nullptr, &sensorsCount);
+ if (getSensorsCountResult != ::SENSOR_SUCCESS) {
+ qOhosPrintfError(
+ "%s: cannot get sensors count, error: %d", Q_FUNC_INFO, getSensorsCountResult);
+ return nullptr;
+ }
+
+ auto sensors = tryCreateInfos(sensorsCount);
+ if (!sensors) {
+ return nullptr;
+ }
+
+ std::uint32_t getInfosResult = ::OH_Sensor_GetInfos(sensors->data(), &sensorsCount);
+ if (getInfosResult != ::SENSOR_SUCCESS) {
+ qOhosPrintfError(
+ "%s: cannot get sensors infos, error: %d", Q_FUNC_INFO, getInfosResult);
+ return nullptr;
+ }
+
+ return sensors;
+ }
+
+ }
+
+ OhosSensorsManager::OhosSensorsManager()
+ {
+ QOhosJsThreadGateway::runAndWait(
+ [&](QOhosJsState &) {
+ m_jsScopeData = QtOhos::makeProxyWithJsThreadDeleter(std::make_shared<JsScopeData>());
+
+ m_jsScopeData->availableSensorsInfo = tryGetAvailableSensorsInfo();
+
+ m_jsScopeData->subscriber = tryCreateSensorResource<::Sensor_Subscriber>(
+ ::OH_Sensor_CreateSubscriber, ::OH_Sensor_DestroySubscriber);
+ if (!m_jsScopeData->subscriber) {
+ qOhosReportFatalErrorAndAbort("%s: Failed to create sensor subscriber.", Q_FUNC_INFO);
+ }
+
+ std::int32_t setCallbackRetVal = ::OH_SensorSubscriber_SetCallback(
+ m_jsScopeData->subscriber.get(), OhosSensorsManager::sensorEventCallbackHandler);
+ if (setCallbackRetVal != ::SENSOR_SUCCESS) {
+ qOhosReportFatalErrorAndAbort(
+ "%s: OH_SensorSubscriber_SetCallback fail with error code: %d",
+ Q_FUNC_INFO, setCallbackRetVal);
+ }
+ });
+ }
+
+ OhosSensorsManager *OhosSensorsManager::instance()
+ {
+ static OhosSensorsManager sensorManager;
+ return &sensorManager;
+ }
+
+ std::vector<::Sensor_Type> OhosSensorsManager::getAvailableSensorsTypes()
+ {
+ return QOhosJsThreadGateway::eval(
+ [&](QOhosJsState &) {
+ std::vector<::Sensor_Type> result;
+
+ auto sensorsInfo = m_jsScopeData->availableSensorsInfo;
+ if (sensorsInfo) {
+ for (auto *sensorInfo : *sensorsInfo) {
+ auto sensorType = tryGetSensorInfoField<::Sensor_Type>(sensorInfo, ::OH_SensorInfo_GetType);
+ if (sensorType.has_value()) {
+ result.push_back(sensorType.value());
+ }
+ }
+ }
+
+ return result;
+ });
+ }
+
+ std::optional<OhosSensorCapabilities> OhosSensorsManager::tryGetSensorCapabilities(QSensor *sensor)
+ {
+ auto ohosSensorType = tryMapQtToOhosSensorType(sensor->type());
+ if (!ohosSensorType.has_value()) {
+ qOhosPrintfError(
+ "%s: Cannot map Qt sensor type: %s, to OHOS Sensor_Type",
+ Q_FUNC_INFO, sensor->type().toStdString().c_str());
+ return std::nullopt;
+ }
+
+ return QOhosJsThreadGateway::eval(
+ [&](QOhosJsState &) -> std::optional<OhosSensorCapabilities> {
+ auto availableSensorsInfo = m_jsScopeData->availableSensorsInfo;
+ if (!availableSensorsInfo) {
+ return std::nullopt;
+ }
+
+ auto sensorInfo = std::find_if(
+ availableSensorsInfo->begin(),
+ availableSensorsInfo->end(),
+ [&](auto *info) {
+ return tryGetSensorInfoField<::Sensor_Type>(info, ::OH_SensorInfo_GetType) == ohosSensorType;
+ });
+
+ if (sensorInfo == availableSensorsInfo->end()) {
+ qOhosPrintfError(
+ "%s: Cannot find a sensor info for a sensor of type: %d",
+ Q_FUNC_INFO, ohosSensorType.value());
+ return std::nullopt;
+ }
+
+ auto resolution = tryGetSensorInfoField<float>(*sensorInfo, ::OH_SensorInfo_GetResolution);
+ if (!resolution.has_value()) {
+ qOhosPrintfError(
+ "%s: Cannot get resolution for a sensor of type: %d", Q_FUNC_INFO, ohosSensorType.value());
+ return std::nullopt;
+ }
+
+ auto minSamplingIntervalInNs = tryGetSensorInfoField<std::int64_t>(
+ *sensorInfo, ::OH_SensorInfo_GetMinSamplingInterval);
+ if (!minSamplingIntervalInNs.has_value()) {
+ qOhosPrintfError(
+ "%s: Cannot get minimal sampling interval for a sensor of type: %d",
+ Q_FUNC_INFO, ohosSensorType.value());
+ return std::nullopt;
+ }
+
+ auto maxSamplingIntervalInNs = tryGetSensorInfoField<std::int64_t>(
+ *sensorInfo, ::OH_SensorInfo_GetMaxSamplingInterval);
+ if (!maxSamplingIntervalInNs.has_value()) {
+ qOhosPrintfError(
+ "%s: Cannot get maximal sampling interval for a sensor of type: %d",
+ Q_FUNC_INFO, ohosSensorType.value());
+ return std::nullopt;
+ }
+
+ auto samplingIntervalToDataRate =
+ [](std::int64_t intervalInNs) -> int {
+ return intervalInNs != 0
+ ? 1e9 / intervalInNs
+ : 0;
+ };
+
+ return OhosSensorCapabilities{
+ resolution.value(),
+ samplingIntervalToDataRate(maxSamplingIntervalInNs.value()),
+ samplingIntervalToDataRate(minSamplingIntervalInNs.value())
+ };
+ });
+ }
+
+ void OhosSensorsManager::subscribeSensor(QSensor *sensor, QOhosConsumer<const OhosSensorData &> sensorDataConsumer)
+ {
+ auto subscribedSensor = m_subscribedSensors.find(sensor);
+ if (subscribedSensor != m_subscribedSensors.end()) {
+ qOhosPrintfError(
+ "%s: Sensor %s already subscribed.",
+ Q_FUNC_INFO, sensor->type().toStdString().c_str());
+ return;
+ }
+
+ auto ohosSensorType = tryMapQtToOhosSensorType(sensor->type());
+ if (!ohosSensorType.has_value()) {
+ qOhosPrintfError(
+ "%s: Cannot map Qt sensor type: %s, to OHOS Sensor_Type",
+ Q_FUNC_INFO, sensor->type().toStdString().c_str());
+ return;
+ }
+
+ auto sensorSubscriptionHandle = QOhosJsThreadGateway::eval(
+ [&](QOhosJsState &) -> std::shared_ptr<void> {
+ auto sensorSubId = tryCreateSensorResource<::Sensor_SubscriptionId>(
+ ::OH_Sensor_CreateSubscriptionId, ::OH_Sensor_DestroySubscriptionId);
+ if (!sensorSubId) {
+ qOhosPrintfError("%s: OH_Sensor_CreateSubscriptionId return nullptr", Q_FUNC_INFO);
+ return nullptr;
+ }
+
+ std::int32_t idRetVal = ::OH_SensorSubscriptionId_SetType(sensorSubId.get(), ohosSensorType.value());
+ if (idRetVal != ::SENSOR_SUCCESS) {
+ qOhosPrintfError("%s: OH_Sensor_CreateSubscriptionId fail with error code: %d",
+ Q_FUNC_INFO, idRetVal);
+ return nullptr;
+ }
+
+ auto sensorSubAttr = tryCreateSensorResource<::Sensor_SubscriptionAttribute>(
+ ::OH_Sensor_CreateSubscriptionAttribute, ::OH_Sensor_DestroySubscriptionAttribute);
+ if (!sensorSubAttr) {
+ qOhosPrintfError("%s: OH_Sensor_CreateSubscriptionAttribute returned nullptr", Q_FUNC_INFO);
+ return nullptr;
+ }
+
+ auto sensorSamplePeriod = std::chrono::duration<double>(1.0 / sensor->dataRate());
+ std::int32_t sensorSubAttrRetVal = ::OH_SensorSubscriptionAttribute_SetSamplingInterval(
+ sensorSubAttr.get(),
+ std::chrono::duration_cast<std::chrono::nanoseconds>(sensorSamplePeriod).count());
+ if (sensorSubAttrRetVal != ::SENSOR_SUCCESS) {
+ qOhosPrintfError(
+ "%s: OH_SensorSubscriptionAttribute_SetSamplingInterval fail with error code: %d",
+ Q_FUNC_INFO, sensorSubAttrRetVal);
+ return nullptr;
+ }
+
+ std::int32_t subscribeRetVal = ::OH_Sensor_Subscribe(
+ sensorSubId.get(), sensorSubAttr.get(), m_jsScopeData->subscriber.get());
+ if (subscribeRetVal != ::SENSOR_SUCCESS) {
+ qOhosPrintfError("%s: OH_Sensor_Subscribe fail with error code: %d",
+ Q_FUNC_INFO, subscribeRetVal);
+ return nullptr;
+ }
+
+ auto sensorSubscriptionHandle = std::shared_ptr<void>(
+ sensorSubId.get(),
+ [sensorSubId = std::move(sensorSubId),
+ weakSubscriber = std::weak_ptr<::Sensor_Subscriber>(m_jsScopeData->subscriber)](void *) mutable {
+ auto subscriber = weakSubscriber.lock();
+ if (subscriber) {
+ std::int32_t unsubRetVal = ::OH_Sensor_Unsubscribe(sensorSubId.get(), subscriber.get());
+ if (unsubRetVal != ::SENSOR_SUCCESS) {
+ qOhosPrintfError(
+ "%s: OH_Sensor_Unsubscribe fail with error code: %d",
+ Q_FUNC_INFO, unsubRetVal);
+ }
+ }
+ sensorSubId.reset();
+ });
+
+ return QtOhos::makeProxyWithJsThreadDeleter(std::move(sensorSubscriptionHandle));
+ });
+
+ if (sensorSubscriptionHandle) {
+ m_subscribedSensors.emplace(sensor, SensorSubscriptionHandle{sensorSubscriptionHandle, sensorDataConsumer});
+ }
+ }
+
+ void OhosSensorsManager::unsubscribeSensor(QSensor *sensor)
+ {
+ auto subscribedSensor = m_subscribedSensors.find(sensor);
+ if (subscribedSensor == m_subscribedSensors.end()) {
+ qOhosPrintfError(
+ "%s: Sensor %s not subscribed. Cannot unsubscribe.",
+ Q_FUNC_INFO, sensor->type().toStdString().c_str());
+ return;
+ }
+
+ m_subscribedSensors.erase(subscribedSensor);
+ }
+
+ void OhosSensorsManager::sensorEventCallbackHandler(::Sensor_Event *event)
+ {
+ if (event == nullptr) {
+ qOhosPrintfInfo("%s: sensor event is null", Q_FUNC_INFO);
+ return;
+ }
+
+ auto sensorType = tryGetSensorEventField<::Sensor_Type>(event, ::OH_SensorEvent_GetType);
+ if (!sensorType.has_value()) {
+ qOhosPrintfError("%s: Cannot obtain sensor type from event.", Q_FUNC_INFO);
+ return;
+ }
+
+ auto timestamp = tryGetSensorEventField<std::int64_t>(event, ::OH_SensorEvent_GetTimestamp);
+ if (!timestamp.has_value()) {
+ qOhosPrintfError("%s: Cannot obtain timestamp from event.", Q_FUNC_INFO);
+ return;
+ }
+
+ auto accuracy = tryGetSensorEventField<::Sensor_Accuracy>(event, ::OH_SensorEvent_GetAccuracy);
+ if (!accuracy.has_value()) {
+ qOhosPrintfError("%s: Cannot obtain sensor accuracy from event.", Q_FUNC_INFO);
+ return;
+ }
+
+ auto data = tryGetSensorEventData(event);
+ if (!data.has_value()) {
+ qOhosPrintfError("%s: Cannot obtain sensor data from event.", Q_FUNC_INFO);
+ return;
+ }
+
+ OhosSensorData sensorData{timestamp.value(), accuracy.value(), data.value()};
+
+ QtOhos::invokeInQtThread(
+ [sensorType, sensorData]() {
+ auto sensorDataConsumer =
+ OhosSensorsManager::instance()->tryGetSensorConsumerForGivenOhosSensorType(sensorType.value());
+ if (sensorDataConsumer != nullptr) {
+ sensorDataConsumer(sensorData);
+ }
+ });
+ }
+
+ QOhosConsumer<const OhosSensorData &>
+ OhosSensorsManager::tryGetSensorConsumerForGivenOhosSensorType(::Sensor_Type ohosSensorType)
+ {
+ auto sensor = std::find_if(
+ m_subscribedSensors.begin(),
+ m_subscribedSensors.end(),
+ [&](const auto &kv) {
+ return kv.first->identifier() == QByteArray::number(ohosSensorType);
+ });
+
+ if (sensor == m_subscribedSensors.end()) {
+ qOhosPrintfError(
+ "%s: Sensor with identifier %d is not subscribed.",
+ Q_FUNC_INFO, ohosSensorType);
+ return nullptr;
+ }
+
+ return sensor->second.sensorDataConsumer;
+ }