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 "qohosgeopositioninfosource.h"
++ #include "qohospositioncommon.h"
++ #include "qohospositioningenums.h"
++ #include <QtCore/private/qcore_ohos_p.h>
++ #include <QtCore/private/qohoscommon_p.h>
++ #include <QtCore/private/qohosjstools_p.h>
++ #include <QtCore/private/qohoslogger_p.h>
++ #include <QtCore/qtimer.h>
++ #include <algorithm>
++ #include <cmath>
++ #include <cstdlib>
++ #include <functional>
++ #include <memory>
++ #include <optional>
++ #include <utility>
++
++ QT_BEGIN_NAMESPACE
++
++ namespace {
++
++ using UserActivityScenario = QtOhosPositioning::enums::ohos::geoLocationManager::UserActivityScenario;
++ using LocationError = QtOhosPositioning::enums::ohos::geoLocationManager::LocationError;
++
++ constexpr int coldStartMarginMs = 2 * 60 * 1000;
++ constexpr int continuousUpdateTimerIntervalMs = 30 * 1000;
++
++ const char *toStaticString(UserActivityScenario scenario)
++ {
++ switch (scenario) {
++ case UserActivityScenario::NAVIGATION:
++ return "NAVIGATION";
++ case UserActivityScenario::SPORT:
++ return "SPORT";
++ case UserActivityScenario::TRANSPORT:
++ return "TRANSPORT";
++ case UserActivityScenario::DAILY_LIFE_SERVICE:
++ return "DAILY_LIFE_SERVICE";
++ }
++
++ qOhosReportFatalErrorAndAbort(
++ "%s received invalid UserActivityScenario: %d", Q_FUNC_INFO, scenario);
++ }
++
++ const char *toStaticString(LocationError locationError)
++ {
++ switch (locationError) {
++ case LocationError::LOCATING_FAILED_DEFAULT:
++ return "LOCATING_FAILED_DEFAULT";
++ case LocationError::LOCATING_FAILED_LOCATION_PERMISSION_DENIED:
++ return "LOCATING_FAILED_LOCATION_PERMISSION_DENIED";
++ case LocationError::LOCATING_FAILED_BACKGROUND_PERMISSION_DENIED:
++ return "LOCATING_FAILED_BACKGROUND_PERMISSION_DENIED";
++ case LocationError::LOCATING_FAILED_LOCATION_SWITCH_OFF:
++ return "LOCATING_FAILED_LOCATION_SWITCH_OFF";
++ case LocationError::LOCATING_FAILED_INTERNET_ACCESS_FAILURE:
++ return "LOCATING_FAILED_INTERNET_ACCESS_FAILURE";
++ }
++
++ qOhosReportFatalErrorAndAbort(
++ "%s received invalid LocationError: %d", Q_FUNC_INFO, locationError);
++ }
++
++ std::optional<UserActivityScenario> tryMapPositioningMethodsToUserActivityScenario(
++ QGeoPositionInfoSource::PositioningMethods positioningMethods)
++ {
++ qOhosPrintfDebug("%s: %d", Q_FUNC_INFO, static_cast<int>(positioningMethods));
++
++ if (positioningMethods.testFlag(QGeoPositionInfoSource::SatellitePositioningMethods))
++ return UserActivityScenario::NAVIGATION;
++
++ if (positioningMethods.testFlag(QGeoPositionInfoSource::NonSatellitePositioningMethods))
++ return UserActivityScenario::DAILY_LIFE_SERVICE;
++
++ return std::nullopt;
++ }
++
++ QGeoPositionInfo convertLocationObjectToPositionInfo(const QNapi::Object &locationObject)
++ {
++ auto dateTime = QDateTime::fromMSecsSinceEpoch(
++ locationObject.get<QNapi::Number>("timeStamp").Int64Value());
++ QGeoCoordinate coordinate(
++ locationObject.get<QNapi::Number>("latitude"),
++ locationObject.get<QNapi::Number>("longitude"),
++ locationObject.get<QNapi::Number>("altitude"));
++
++ QGeoPositionInfo positionInfo(coordinate, dateTime);
++
++ positionInfo.setAttribute(
++ QGeoPositionInfo::Direction, locationObject.get<QNapi::Number>("direction"));
++ positionInfo.setAttribute(
++ QGeoPositionInfo::HorizontalAccuracy, locationObject.get<QNapi::Number>("accuracy"));
++ positionInfo.setAttribute(
++ QGeoPositionInfo::VerticalAccuracy, locationObject.get<QNapi::Number>("altitudeAccuracy"));
++ // NOTE: QGeoPositionInfo distinguishes GroundSpeed and VerticalSpeed, while OHOS provides only
++ // Location_BasicInfo::speed. Here, we assume, that since Location_BasicInfo::accuracy relates
++ // to HorizontalAccuracy, the Location_BasicInfo::speed relates to GroundSpeed (although, there
++ // is no information about that anywhere in the documentation).
++ positionInfo.setAttribute(
++ QGeoPositionInfo::GroundSpeed, locationObject.get<QNapi::Number>("speed"));
++
++ return positionInfo;
++ }
++
++ std::shared_ptr<void> registerLocationChangeUpdateHandler(
++ QObject *contextObject, long intervalSec,
++ UserActivityScenario userActivityScenario,
++ QOhosConsumer<const QGeoPositionInfo &> positionInfoUpdateConsumer)
++ {
++ auto sharedPositionInfoUpdateConsumer = QtOhos::moveToSharedPtr(std::move(positionInfoUpdateConsumer));
++
++ auto weakPositionInfoUpdateConsumer = QtOhos::makeWeakPtr(sharedPositionInfoUpdateConsumer);
++ auto contextObjectRef = QtOhos::makeQThreadSafeRef(contextObject);
++
++ auto registrationHandle = QOhosJsThreadGateway::eval(
++ [&](QOhosJsState &jsState) {
++ qOhosPrintfWarning("%s Interval in Seconds: %li", Q_FUNC_INFO, intervalSec);
++ auto continuousLocationRequest = QNapi::makeObject(
++ jsState.env(),
++ {
++ {"interval", intervalSec},
++ {"locationScenario", jsState.mapOhosEnumToJs(userActivityScenario)},
++ });
++
++ qOhosPrintfDebug(
++ "%s registering callback with scenario: %s",
++ Q_FUNC_INFO, toStaticString(userActivityScenario));
++
++ return QtOhos::makeProxyWithJsThreadDeleter(
++ registerQOhosOnOffMethodsBasedEventHandler(
++ getGeoLocationManagerObject(jsState), "locationChange",
++ [contextObjectRef, weakPositionInfoUpdateConsumer](const QOhosCallbackInfo &cbInfo) {
++ auto location = cbInfo.getFirstArg<QNapi::Object>(Q_FUNC_INFO);
++ auto positionInfo = convertLocationObjectToPositionInfo(location);
++
++ contextObjectRef.visitInQtThreadIfAlive(
++ [weakPositionInfoUpdateConsumer, positionInfo](auto &) {
++ auto sharedPositionInfoUpdateConsumer = weakPositionInfoUpdateConsumer.lock();
++ if (sharedPositionInfoUpdateConsumer)
++ (*sharedPositionInfoUpdateConsumer)(positionInfo);
++ });
++ },
++ {
++ .optEventSourceAliveCheckFunc = {},
++ .extraOnArg = std::make_optional<QNapi::ValueWrapper>(continuousLocationRequest),
++ .extraOffArg = {},
++ .optOnCallExceptionHandler = {},
++ }));
++ });
++
++ return QtOhos::moveToSharedPtr(
++ std::make_pair(sharedPositionInfoUpdateConsumer, registrationHandle));
++ }
++
++ std::shared_ptr<void> makeContinuousPositionInfoUpdateProducer(
++ QObject *contextObject, int intervalMs, QGeoPositionInfoSource::PositioningMethods positioningMethods,
++ QOhosConsumer<const QGeoPositionInfo &, QGeoPositionInfoSource::PositioningMethods> positionInfoUpdateConsumer)
++ {
++ auto userActivityScenario =
++ tryMapPositioningMethodsToUserActivityScenario(positioningMethods)
++ .value_or(UserActivityScenario::DAILY_LIFE_SERVICE);
++ auto intervalSec = std::lround(static_cast<double>(intervalMs) / 1000.0);
++
++ return registerLocationChangeUpdateHandler(
++ contextObject, intervalSec, userActivityScenario,
++ [positionInfoUpdateConsumer = std::move(positionInfoUpdateConsumer), positioningMethods](const QGeoPositionInfo &positionInfo) {
++ positionInfoUpdateConsumer(positionInfo, positioningMethods);
++ });
++ }
++
++ std::shared_ptr<void> makeSinglePositionInfoUpdateProducer(
++ QObject *contextObject, int timeoutMs, QGeoPositionInfoSource::PositioningMethods positioningMethods,
++ QOhosConsumer<std::optional<QGeoPositionInfo>, QGeoPositionInfoSource::PositioningMethods> positionInfoUpdateConsumer)
++ {
++ qOhosDebug(QtForOhos) << Q_FUNC_INFO << contextObject << timeoutMs;
++
++ struct Context
++ {
++ QOhosConsumer<std::optional<QGeoPositionInfo>, QGeoPositionInfoSource::PositioningMethods> positionInfoUpdateConsumer;
++ QtOhos::QThreadSafeRef<QObject> contextObjectRef;
++ };
++
++ auto sharedContext = QtOhos::moveToSharedPtr(Context{
++ .positionInfoUpdateConsumer = std::move(positionInfoUpdateConsumer),
++ .contextObjectRef = QtOhos::makeQThreadSafeRef(contextObject)
++ });
++
++ auto weakContext = QtOhos::makeWeakPtr(sharedContext);
++ auto sharedPositionInfoUpdateProxy = QtOhos::moveToSharedPtr(
++ [weakContext, positioningMethods](std::optional<QGeoPositionInfo> optPositionInfo) {
++ auto sharedContext = weakContext.lock();
++ if (sharedContext) {
++ sharedContext->contextObjectRef.visitInQtThreadIfAlive(
++ [weakContext, optPositionInfo, positioningMethods](auto &) {
++ auto sharedContext = weakContext.lock();
++ if (sharedContext)
++ sharedContext->positionInfoUpdateConsumer(optPositionInfo, positioningMethods);
++ });
++ }
++ });
++
++ QOhosJsThreadGateway::runAndWait(
++ [&](QOhosJsState &jsState) {
++ auto userActivityScenario =
++ tryMapPositioningMethodsToUserActivityScenario(positioningMethods)
++ .value_or(UserActivityScenario::DAILY_LIFE_SERVICE);
++ auto currentLocationRequest = QNapi::makeObject(
++ jsState.env(),
++ {
++ {"scenario", jsState.mapOhosEnumToJs(userActivityScenario)},
++ {"timeoutMs", timeoutMs},
++ });
++
++ getGeoLocationManagerObject(jsState)
++ .evalToPromiseOrRejectOnThrow("getCurrentLocation(*)", {currentLocationRequest})
++ .onThen([sharedPositionInfoUpdateProxy](const QOhosCallbackInfo &cbInfo) {
++ auto location = cbInfo.getFirstArg<QNapi::Object>("getCurrentLocation");
++ (*sharedPositionInfoUpdateProxy)(convertLocationObjectToPositionInfo(location));
++ })
++ .onCatch([sharedPositionInfoUpdateProxy](const QOhosCallbackInfo &cbInfo) {
++ QtOhos::logJsCallbackError(cbInfo, "getCurrentLocation() failed");
++ (*sharedPositionInfoUpdateProxy)(std::nullopt);
++ });
++ });
++
++ return sharedContext;
++ }
++
++ std::shared_ptr<void> registerLocationErrorHandler(
++ QObject *contextObject, QOhosConsumer<LocationError> errorConsumer)
++ {
++ qOhosDebug(QtForOhos) << Q_FUNC_INFO << contextObject;
++
++ auto sharedErrorConsumer = QtOhos::moveToSharedPtr(std::move(errorConsumer));
++
++ auto contextObjectRef = QtOhos::makeQThreadSafeRef(contextObject);
++ auto weakErrorConsumer = QtOhos::makeWeakPtr(sharedErrorConsumer);
++
++ auto registrationHandle = QOhosJsThreadGateway::eval(
++ [&](QOhosJsState &jsState) {
++ return QtOhos::makeProxyWithJsThreadDeleter(
++ registerQOhosOnOffMethodsBasedEventHandler(
++ getGeoLocationManagerObject(jsState), "locationError",
++ [contextObjectRef, weakErrorConsumer](const QOhosCallbackInfo &cbInfo) {
++ auto jsLocationError = cbInfo.getFirstArg<QNapi::Number>(Q_FUNC_INFO);
++ auto locationError = cbInfo.jsState().mapOhosEnumFromJs<LocationError>(jsLocationError);
++ contextObjectRef.visitInQtThreadIfAlive(
++ [weakErrorConsumer, locationError](auto &) {
++ auto sharedErrorConsumer = weakErrorConsumer.lock();
++ if (sharedErrorConsumer)
++ (*sharedErrorConsumer)(locationError);
++ });
++ }));
++ });
++
++ return QtOhos::makeSharedPtrWithAttachedExtraData(registrationHandle, sharedErrorConsumer);
++ }
++
++ QGeoPositionInfoSource::Error convertLocationErrorToQtError(LocationError error)
++ {
++ switch (error) {
++ case LocationError::LOCATING_FAILED_DEFAULT:
++ return QGeoPositionInfoSource::UnknownSourceError;
++ case LocationError::LOCATING_FAILED_LOCATION_SWITCH_OFF:
++ return QGeoPositionInfoSource::ClosedError;
++ case LocationError::LOCATING_FAILED_LOCATION_PERMISSION_DENIED:
++ case LocationError::LOCATING_FAILED_BACKGROUND_PERMISSION_DENIED:
++ case LocationError::LOCATING_FAILED_INTERNET_ACCESS_FAILURE:
++ return QGeoPositionInfoSource::AccessError;
++ }
++
++ qOhosPrintfWarning("%s received unknown error: %d", Q_FUNC_INFO, static_cast<int>(error));
++ return QGeoPositionInfoSource::UnknownSourceError;
++ }
++
++ class QOhosGeoPositionInfoSource : public QGeoPositionInfoSource
++ {
++ public:
++ static QOhosGeoPositionInfoSource *tryMakeInstance(QObject *parent);
++
++ ~QOhosGeoPositionInfoSource() override;
++
++ void setUpdateInterval(int msec) override;
++ QGeoPositionInfo lastKnownPosition(bool fromSatellitePositioningMethodsOnly) const override;
++ PositioningMethods supportedPositioningMethods() const override;
++ void setPreferredPositioningMethods(PositioningMethods methods) override;
++ int minimumUpdateInterval() const override;
++ Error error() const override;
++
++ public:
++ void startUpdates() override;
++ void stopUpdates() override;
++
++ void requestUpdate(int timeout) override;
++
++ protected:
++ QOhosGeoPositionInfoSource(QObject *parent);
++
++ private:
++ void setErrorHelper(QGeoPositionInfoSource::Error error);
++ void continuousUpdateTimeout();
++
++ void updatePositionInfo(const QGeoPositionInfo &positionInfo, PositioningMethods positioningMethods);
++
++ QGeoPositionInfoSource::Error m_error = QGeoPositionInfoSource::NoError;
++ QGeoPositionInfo m_lastUpdatedPositionInfo;
++ QGeoPositionInfo m_lastUpdatedPositionInfoFromSatelliteSource;
++
++ std::shared_ptr<void> m_locationErrorHandle;
++
++ std::shared_ptr<void> m_continuousLocationUpdatesHandle;
++ QTimer m_continuousUpdateTimeoutTimer;
++ qint64 m_lastUpdateTime = 0;
++ bool m_continuousUpdateTimeoutErrorRaised = false;
++
++ std::shared_ptr<void> m_singlePositionUpdateHandle;
++ std::unique_ptr<QTimer> m_singleUpdateTimeoutTimer;
++ };
++
++ QOhosGeoPositionInfoSource *QOhosGeoPositionInfoSource::tryMakeInstance(QObject *parent)
++ {
++ if (!checkLocationOrApproximatelyLocationPermissionGranted()) {
++ qOhosDebug(QtForOhos)
++ << Q_FUNC_INFO
++ << "Location permission isn't granted. Can't create QOhosGeoPositionInfoSource";
++ return nullptr;
++ }
++
++ return new QOhosGeoPositionInfoSource(parent);
++ }
++
++ QOhosGeoPositionInfoSource::QOhosGeoPositionInfoSource(QObject *parent)
++ : QGeoPositionInfoSource(parent)
++ {
++ qOhosDebug(QtForOhos) << Q_FUNC_INFO << parent;
++
++ m_locationErrorHandle = registerLocationErrorHandler(
++ this,
++ [this](LocationError error) {
++ qOhosWarning(QtForOhos)
++ << Q_FUNC_INFO << "Received error from callback:" << toStaticString(error);
++ setErrorHelper(convertLocationErrorToQtError(error));
++ });
++
++ m_continuousUpdateTimeoutTimer.setSingleShot(false);
++ m_continuousUpdateTimeoutTimer.setInterval(continuousUpdateTimerIntervalMs);
++ QObject::connect(&m_continuousUpdateTimeoutTimer, &QTimer::timeout,
++ this, [this]() { continuousUpdateTimeout(); });
++ }
++
++ QOhosGeoPositionInfoSource::~QOhosGeoPositionInfoSource() = default;
++
++ void QOhosGeoPositionInfoSource::setUpdateInterval(int msec)
++ {
++ qOhosDebug(QtForOhos) << Q_FUNC_INFO << msec;
++
++ QGeoPositionInfoSource::setUpdateInterval(msec);
++
++ if (m_continuousLocationUpdatesHandle) {
++ stopUpdates();
++ startUpdates();
++ }
++ }
++
++ QGeoPositionInfo QOhosGeoPositionInfoSource::lastKnownPosition(bool fromSatellitePositioningMethodsOnly) const
++ {
++ qOhosDebug(QtForOhos) << Q_FUNC_INFO << fromSatellitePositioningMethodsOnly;
++
++ return fromSatellitePositioningMethodsOnly
++ ? m_lastUpdatedPositionInfoFromSatelliteSource
++ : m_lastUpdatedPositionInfo;
++ }
++
++ QGeoPositionInfoSource::PositioningMethods QOhosGeoPositionInfoSource::supportedPositioningMethods() const
++ {
++ qOhosDebug(QtForOhos) << Q_FUNC_INFO;
++
++ return QGeoPositionInfoSource::AllPositioningMethods;
++ }
++
++ void QOhosGeoPositionInfoSource::setPreferredPositioningMethods(PositioningMethods methods)
++ {
++ qOhosDebug(QtForOhos) << Q_FUNC_INFO << methods;
++
++ QGeoPositionInfoSource::setPreferredPositioningMethods(methods);
++ }
++
++ int QOhosGeoPositionInfoSource::minimumUpdateInterval() const
++ {
++ qOhosDebug(QtForOhos) << Q_FUNC_INFO;
++
++ return 1000;
++ }
++
++ QGeoPositionInfoSource::Error QOhosGeoPositionInfoSource::error() const
++ {
++ qOhosDebug(QtForOhos) << Q_FUNC_INFO;
++
++ return m_error;
++ }
++
++ void QOhosGeoPositionInfoSource::startUpdates()
++ {
++ qOhosDebug(QtForOhos) << Q_FUNC_INFO;
++
++ if (m_continuousLocationUpdatesHandle) {
++ qOhosDebug(QtForOhos) << Q_FUNC_INFO << "Continuous updates already running. Ignoring";
++ return;
++ }
++
++ auto intervalMs = std::max(updateInterval(), minimumUpdateInterval());
++
++ m_lastUpdateTime = QDateTime::currentMSecsSinceEpoch();
++ m_continuousUpdateTimeoutErrorRaised = false;
++
++ m_continuousLocationUpdatesHandle =
++ makeContinuousPositionInfoUpdateProducer(
++ this, intervalMs,
++ preferredPositioningMethods(),
++ [this](const QGeoPositionInfo &positionInfo, PositioningMethods positioningMethods) {
++ updatePositionInfo(positionInfo, positioningMethods);
++ });
++
++ m_continuousUpdateTimeoutTimer.start();
++
++ setErrorHelper(QGeoPositionInfoSource::NoError);
++ }
++
++ void QOhosGeoPositionInfoSource::continuousUpdateTimeout()
++ {
++ if (!m_continuousUpdateTimeoutErrorRaised) {
++ const auto now = QDateTime::currentMSecsSinceEpoch();
++ if ((now - m_lastUpdateTime) > (updateInterval() + coldStartMarginMs)) {
++ m_continuousUpdateTimeoutErrorRaised = true;
++ setErrorHelper(QGeoPositionInfoSource::UpdateTimeoutError);
++ }
++ }
++ }
++
++ void QOhosGeoPositionInfoSource::stopUpdates()
++ {
++ qOhosDebug(QtForOhos) << Q_FUNC_INFO;
++
++ m_continuousLocationUpdatesHandle.reset();
++ m_continuousUpdateTimeoutTimer.stop();
++ }
++
++ void QOhosGeoPositionInfoSource::requestUpdate(int timeoutMs)
++ {
++ qOhosDebug(QtForOhos) << Q_FUNC_INFO << timeoutMs;
++
++ if (m_singlePositionUpdateHandle) {
++ qOhosDebug(QtForOhos) << Q_FUNC_INFO << "Update already in progress. Ignoring this one";
++ return;
++ }
++
++ if (timeoutMs != 0 && timeoutMs < minimumUpdateInterval()) {
++ setErrorHelper(QGeoPositionInfoSource::UpdateTimeoutError);
++ return;
++ }
++
++ auto timeout = timeoutMs != 0 ? timeoutMs : coldStartMarginMs;
++
++ m_singlePositionUpdateHandle = makeSinglePositionInfoUpdateProducer(
++ this,
++ updateInterval() >= minimumUpdateInterval() ? updateInterval() : minimumUpdateInterval(),
++ preferredPositioningMethods(),
++ [this](std::optional<QGeoPositionInfo> optPositionInfo, PositioningMethods positioningMethods) {
++ m_singlePositionUpdateHandle.reset();
++ m_singleUpdateTimeoutTimer.reset();
++ if (optPositionInfo.has_value())
++ updatePositionInfo(optPositionInfo.value(), positioningMethods);
++ else
++ setErrorHelper(QGeoPositionInfoSource::UpdateTimeoutError);
++ });
++ if (!m_singlePositionUpdateHandle) {
++ qOhosWarning(QtForOhos) << Q_FUNC_INFO << "Failed to make single position info update producer";
++ setErrorHelper(QGeoPositionInfoSource::UnknownSourceError);
++ return;
++ }
++
++ m_singleUpdateTimeoutTimer =
++ makeSingleShotUpdateTimeoutTimer(timeout, [this]() {
++ m_singlePositionUpdateHandle.reset();
++ setErrorHelper(QGeoPositionInfoSource::UpdateTimeoutError);
++ });
++
++ setErrorHelper(QGeoPositionInfoSource::NoError);
++ }
++
++ void QOhosGeoPositionInfoSource::setErrorHelper(QGeoPositionInfoSource::Error newError)
++ {
++ qOhosDebug(QtForOhos) << Q_FUNC_INFO << newError;
++
++ if (m_error == newError)
++ return;
++
++ m_error = newError;
++
++ if (newError != QGeoPositionInfoSource::NoError)
++ Q_EMIT QGeoPositionInfoSource::errorOccurred(m_error);
++ }
++
++ void QOhosGeoPositionInfoSource::updatePositionInfo(
++ const QGeoPositionInfo &positionInfo, PositioningMethods positioningMethods)
++ {
++ qOhosDebug(QtForOhos) << Q_FUNC_INFO << positionInfo;
++
++ m_lastUpdateTime = QDateTime::currentMSecsSinceEpoch();
++ m_continuousUpdateTimeoutErrorRaised = false;
++ setErrorHelper(QGeoPositionInfoSource::NoError);
++
++ if (positioningMethods.testFlag(PositioningMethod::SatellitePositioningMethods))
++ m_lastUpdatedPositionInfoFromSatelliteSource = positionInfo;
++ m_lastUpdatedPositionInfo = positionInfo;
++ Q_EMIT positionUpdated(m_lastUpdatedPositionInfo);
++ }
++
++ }
++
++ QGeoPositionInfoSource *tryMakeQOhosGeoPositionInfoSource(QObject *parent)
++ {
++ return QOhosGeoPositionInfoSource::tryMakeInstance(parent);
++ }
++
++ QT_END_NAMESPACE