qohosgeosatelliteinfosource.cpp

Go to the documentation of this file.

// 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 "qohosgeosatelliteinfosource.h"
#include "qohospositioncommon.h"
#include "qohosjsutils.h"
#include <QtCore/private/qcore_ohos_p.h>
#include <QtCore/private/qnapi_p.h>
#include <QtCore/private/qohoscommon_p.h>
#include <QtCore/private/qohoslogger_p.h>
#include <QtCore/qset.h>
#include <QtCore/qmath.h>
#include <QtPositioning/qgeosatelliteinfo.h>
#include <algorithm>
#include <chrono>
#include <memory>
#include <optional>
#include <utility>
#include <vector>
 
QT_BEGIN_NAMESPACE
 
namespace {
 
constexpr int updateAsOftenAsNecessaryInterval = 0;
 
enum class SatelliteConstellationCategory
{
    CONSTELLATION_CATEGORY_UNKNOWN,
    CONSTELLATION_CATEGORY_GPS,
    CONSTELLATION_CATEGORY_SBAS,
    CONSTELLATION_CATEGORY_GLONASS,
    CONSTELLATION_CATEGORY_QZSS,
    CONSTELLATION_CATEGORY_BEIDOU,
    CONSTELLATION_CATEGORY_GALILEO,
    CONSTELLATION_CATEGORY_IRNSS,
};
 
struct SatelliteInfo
{
    int id;
    double carrierToNoiseDensity;
    double altitude;
    double azimuth;
    std::optional<SatelliteConstellationCategory> optConstellationCategory;
    bool usedInFix;
};
 
std::optional<std::vector<SatelliteConstellationCategory>>
tryGetSatelliteConstelationCategoriesFromSatelliteStatusInfoObject(
    QOhosJsState &jsState, QNapi::Object satelliteStatusInfoObject)
{
    auto satelliteConstellationArray = QNapi::getOptionalPropOrEmpty<QNapi::Array>(
        satelliteStatusInfoObject, "satelliteConstellation");
 
    return !satelliteConstellationArray.IsEmpty()
        ? std::make_optional(
            QNapi::getArrayElements<std::vector<SatelliteConstellationCategory>, QNapi::Number>(
                satelliteConstellationArray,
                [&](auto satelliteConstellation) {
                    return jsState.mapOhosEnumFromJs<SatelliteConstellationCategory>(satelliteConstellation);
                }))
        : std::nullopt;
}
 
std::optional<std::vector<int>> tryGetSatelliteAdditionalInfosFromSatelliteStatusInfoObject(
    QOhosJsState &, QNapi::Object satelliteStatusInfoObject)
{
    auto satelliteAdditionalInfoArray = QNapi::getOptionalPropOrEmpty<QNapi::Array>(
        satelliteStatusInfoObject, "satelliteAdditionalInfo");
 
    return !satelliteAdditionalInfoArray.IsEmpty()
        ? std::make_optional(
            QNapi::getArrayElements<std::vector<int>, QNapi::Number>(satelliteAdditionalInfoArray))
        : std::nullopt;
}
 
bool isSatelliteUsedInFix(QOhosJsState &jsState, int satelliteAdditionalInfo)
{
    int satelliteUsedInValueFlag = jsState.eval<QNapi::Number>(
        "@ohos.geoLocationManager.SatelliteAdditionalInfo.SATELLITES_ADDITIONAL_INFO_USED_IN_FIX");
 
    return (satelliteAdditionalInfo & satelliteUsedInValueFlag) != 0;
}
 
std::vector<SatelliteInfo> convertJsSatelliteStatusInfoObjectToQGeoSatelliteInfos(
    QOhosJsState &jsState, QNapi::Object satelliteStatusInfoObject)
{
    int satellitesNumber = satelliteStatusInfoObject.get<QNapi::Number>("satellitesNumber");
    auto satelliteIds = QNapi::getArrayElements<std::vector<int>, QNapi::Number>(
        satelliteStatusInfoObject.get<QNapi::Array>("satelliteIds"));
    auto carrierToNoiseDensities = QNapi::getArrayElements<std::vector<double>, QNapi::Number>(
        satelliteStatusInfoObject.get<QNapi::Array>("carrierToNoiseDensitys"));
    auto altitudes = QNapi::getArrayElements<std::vector<double>, QNapi::Number>(
        satelliteStatusInfoObject.get<QNapi::Array>("altitudes"));
    auto azimuths = QNapi::getArrayElements<std::vector<double>, QNapi::Number>(
        satelliteStatusInfoObject.get<QNapi::Array>("azimuths"));
    auto satelliteConstellations = tryGetSatelliteConstelationCategoriesFromSatelliteStatusInfoObject(
        jsState, satelliteStatusInfoObject);
    auto satelliteAdditionalInfos = tryGetSatelliteAdditionalInfosFromSatelliteStatusInfoObject(
        jsState, satelliteStatusInfoObject);
 
    std::vector<SatelliteInfo> satelliteInfos;
    satelliteInfos.reserve(satellitesNumber);
 
    for (int i = 0; i < satellitesNumber; i++) {
        satelliteInfos.push_back(SatelliteInfo{
            .id = satelliteIds[i],
            .carrierToNoiseDensity = carrierToNoiseDensities[i],
            .altitude = altitudes[i],
            .azimuth = azimuths[i],
            .optConstellationCategory = satelliteConstellations.has_value()
                ? std::make_optional(satelliteConstellations.value()[i])
                : std::nullopt,
            .usedInFix = satelliteAdditionalInfos.has_value()
                ? isSatelliteUsedInFix(jsState, satelliteAdditionalInfos.value()[i])
                : false
        });
    }
 
    return satelliteInfos;
}
 
QGeoSatelliteInfo::SatelliteSystem convertSatelliteConstellationCategoryToQt(
    SatelliteConstellationCategory constellationCategory)
{
    switch (constellationCategory) {
    case SatelliteConstellationCategory::CONSTELLATION_CATEGORY_UNKNOWN:
        return QGeoSatelliteInfo::Undefined;
    case SatelliteConstellationCategory::CONSTELLATION_CATEGORY_GPS:
        return QGeoSatelliteInfo::GPS;
    case SatelliteConstellationCategory::CONSTELLATION_CATEGORY_GLONASS:
        return QGeoSatelliteInfo::GLONASS;
    case SatelliteConstellationCategory::CONSTELLATION_CATEGORY_SBAS:
        return QGeoSatelliteInfo::SBAS;
    case SatelliteConstellationCategory::CONSTELLATION_CATEGORY_QZSS:
        return QGeoSatelliteInfo::QZSS;
    case SatelliteConstellationCategory::CONSTELLATION_CATEGORY_BEIDOU:
        return QGeoSatelliteInfo::BEIDOU;
    case SatelliteConstellationCategory::CONSTELLATION_CATEGORY_GALILEO:
        return QGeoSatelliteInfo::GALILEO;
    case SatelliteConstellationCategory::CONSTELLATION_CATEGORY_IRNSS:
        return QGeoSatelliteInfo::IRNSS;
    }
 
    qOhosReportFatalErrorAndAbort(
        "%s Received an unknown SatelliteConstellationCategory: %d",
        Q_FUNC_INFO, constellationCategory);
}
 
std::shared_ptr<void> registerSatelliteStatusInfoProducerConsumer(
    QObject *contextObject, QOhosConsumer<std::vector<SatelliteInfo>> satelliteStatusInfoConsumer)
{
    qOhosDebug(QtForOhos) << Q_FUNC_INFO << contextObject;
 
    auto contextObjectRef = QtOhos::makeQThreadSafeRef(contextObject);
    auto sharedSatelliteStatusInfoConsumer =
        QtOhos::moveToSharedPtr(std::move(satelliteStatusInfoConsumer));
    auto weakSatelliteStatusInfoConsumer = QtOhos::makeWeakPtr(sharedSatelliteStatusInfoConsumer);
 
    auto registrationHandle = QOhosJsThreadGateway::eval(
        [&](QOhosJsState &jsState) {
            return QtOhos::registerOnOffMethodsBasedEventHandler(
                getGeoLocationManagerObject(jsState), "satelliteStatusChange",
                [contextObjectRef, weakSatelliteStatusInfoConsumer](const QOhosCallbackInfo &cbInfo) {
                    auto satelliteStatusInfo = cbInfo.getFirstArg<QNapi::Object>(Q_FUNC_INFO);
                    auto satelliteInfos = convertJsSatelliteStatusInfoObjectToQGeoSatelliteInfos(
                        cbInfo.jsState(), satelliteStatusInfo);
                    contextObjectRef.visitInQtThreadIfAlive(
                        [weakSatelliteStatusInfoConsumer, satelliteInfos](auto &) {
                            auto sharedSatelliteStatusInfoConsumer = weakSatelliteStatusInfoConsumer.lock();
                            if (sharedSatelliteStatusInfoConsumer)
                                (*sharedSatelliteStatusInfoConsumer)(satelliteInfos);
                        });
                });
        });
 
    return QtOhos::moveToSharedPtr(
        std::make_pair(registrationHandle, sharedSatelliteStatusInfoConsumer));
}
 
class QOhosGeoSatelliteInfoSource : public QGeoSatelliteInfoSource
{
public:
    QOhosGeoSatelliteInfoSource(QObject *parent);
    ~QOhosGeoSatelliteInfoSource() override;
 
    void setUpdateInterval(int msec) override;
    int minimumUpdateInterval() const override;
    Error error() const override;
 
public:
    void startUpdates() override;
    void stopUpdates() override;
 
    void requestUpdate(int timeout) override;
 
private:
    enum UpdateType
    {
        SingleUpdate,
        ContinuousUpdate,
    };
 
    void startUpdatesHelper();
    void setErrorHelper(Error error);
 
    void handleSatelliteStatusInfoUpdate(std::vector<SatelliteInfo> updatedSatelliteStatusInfo);
    void handleSingleUpdateFinished();
    void handleUpdateFinished();
 
    QSet<UpdateType> m_updateTypes;
    std::shared_ptr<void> m_updateSatelliteStatusInfoProducerHandle;
    std::unique_ptr<QGeoPositionInfoSource> m_positionInfoSource;
 
    std::unique_ptr<QTimer> m_singleUpdateTimeoutTimer;
 
    std::optional<QList<QGeoSatelliteInfo>> m_lastUpdatedSatellitesInView;
    std::optional<QList<QGeoSatelliteInfo>> m_lastUpdatedSatellitesInUse;
 
    QGeoSatelliteInfoSource::Error m_error = QGeoSatelliteInfoSource::NoError;
};
 
QOhosGeoSatelliteInfoSource::QOhosGeoSatelliteInfoSource(QObject *parent)
    : QGeoSatelliteInfoSource(parent)
{
    qOhosDebug(QtForOhos) << Q_FUNC_INFO;
}
 
QOhosGeoSatelliteInfoSource::~QOhosGeoSatelliteInfoSource() = default;
 
void QOhosGeoSatelliteInfoSource::setUpdateInterval(int msec)
{
    qOhosDebug(QtForOhos) << Q_FUNC_INFO << msec;
 
    if (msec != updateAsOftenAsNecessaryInterval)
        qOhosWarning(QtForOhos) << Q_FUNC_INFO << "Specific update intervals are not supported";
}
 
int QOhosGeoSatelliteInfoSource::minimumUpdateInterval() const
{
    qOhosDebug(QtForOhos) << Q_FUNC_INFO;
 
    return updateAsOftenAsNecessaryInterval;
}
 
QGeoSatelliteInfoSource::Error QOhosGeoSatelliteInfoSource::error() const
{
    qOhosDebug(QtForOhos) << Q_FUNC_INFO;
 
    return m_error;
}
 
void QOhosGeoSatelliteInfoSource::startUpdates()
{
    qOhosDebug(QtForOhos) << Q_FUNC_INFO;
 
    if (!checkLocationOrApproximatelyLocationPermissionGranted()) {
        qOhosWarning(QtForOhos) << Q_FUNC_INFO << "Location permission not granted. Can't start updates";
        setErrorHelper(QGeoSatelliteInfoSource::AccessError);
        return;
    }
 
    if (m_updateTypes.contains(UpdateType::ContinuousUpdate))
        return;
 
    m_updateTypes.insert(UpdateType::ContinuousUpdate);
 
    if (!m_updateSatelliteStatusInfoProducerHandle && !m_positionInfoSource)
        startUpdatesHelper();
}
 
void QOhosGeoSatelliteInfoSource::stopUpdates()
{
    qOhosDebug(QtForOhos) << Q_FUNC_INFO;
 
    m_updateTypes.remove(UpdateType::ContinuousUpdate);
 
    handleUpdateFinished();
}
 
void QOhosGeoSatelliteInfoSource::requestUpdate(int timeout)
{
    qOhosDebug(QtForOhos) << Q_FUNC_INFO << timeout;
 
    if (!checkLocationOrApproximatelyLocationPermissionGranted()) {
        qOhosWarning(QtForOhos) << Q_FUNC_INFO << "Location permission not granted. Can't request update";
        setErrorHelper(QGeoSatelliteInfoSource::AccessError);
        return;
    }
 
    if (m_updateTypes.contains(UpdateType::SingleUpdate))
        return;
 
    m_updateTypes.insert(UpdateType::SingleUpdate);
 
    if (!m_updateSatelliteStatusInfoProducerHandle && !m_positionInfoSource)
        startUpdatesHelper();
 
    m_singleUpdateTimeoutTimer = makeSingleShotUpdateTimeoutTimer(
        timeout, [this]() {
            if (m_lastUpdatedSatellitesInUse.has_value() && m_lastUpdatedSatellitesInView.has_value()) {
                Q_EMIT satellitesInUseUpdated(m_lastUpdatedSatellitesInUse.value());
                Q_EMIT satellitesInViewUpdated(m_lastUpdatedSatellitesInView.value());
            } else {
                Q_EMIT errorOccurred(QGeoSatelliteInfoSource::UpdateTimeoutError);
            }
 
            handleSingleUpdateFinished();
        });
}
 
void QOhosGeoSatelliteInfoSource::startUpdatesHelper()
{
    qOhosDebug(QtForOhos) << Q_FUNC_INFO;
 
    m_updateSatelliteStatusInfoProducerHandle =
        registerSatelliteStatusInfoProducerConsumer(
            this, [this](auto updatedSatelliteInfos) {
                handleSatelliteStatusInfoUpdate(updatedSatelliteInfos);
            });
 
    m_positionInfoSource = std::unique_ptr<QGeoPositionInfoSource>(tryMakeQOhosGeoPositionInfoSource());
    if (!m_positionInfoSource)
        qOhosReportFatalErrorAndAbort("%s positionInfoSource is invalid", Q_FUNC_INFO);
 
    m_positionInfoSource->setPreferredPositioningMethods(QGeoPositionInfoSource::SatellitePositioningMethods);
    m_positionInfoSource->startUpdates();
}
 
void QOhosGeoSatelliteInfoSource::setErrorHelper(Error error)
{
    qOhosWarning(QtForOhos) << Q_FUNC_INFO << error;
 
    if (m_error == error)
        return;
 
    m_error = error;
 
    if (error != QGeoSatelliteInfoSource::NoError)
        Q_EMIT QGeoSatelliteInfoSource::errorOccurred(m_error);
}
 
void QOhosGeoSatelliteInfoSource::handleSatelliteStatusInfoUpdate(
    std::vector<SatelliteInfo> updatedSatellites)
{
    qOhosDebug(QtForOhos) << Q_FUNC_INFO << "found" << updatedSatellites.size() << "satellites";
 
    QList<QGeoSatelliteInfo> satellitesInView;
    QList<QGeoSatelliteInfo> satellitesInUse;
 
    for (const auto &updatedSatellite : updatedSatellites) {
        if (qFuzzyIsNull(updatedSatellite.carrierToNoiseDensity))
            continue;
 
        QGeoSatelliteInfo satelliteInfo;
        satelliteInfo.setSatelliteIdentifier(updatedSatellite.id);
        satelliteInfo.setSatelliteSystem(
            updatedSatellite.optConstellationCategory.has_value()
                ? convertSatelliteConstellationCategoryToQt(updatedSatellite.optConstellationCategory.value())
                : QGeoSatelliteInfo::SatelliteSystem::Undefined);
        satelliteInfo.setSignalStrength(updatedSatellite.carrierToNoiseDensity);
        satelliteInfo.setAttribute(QGeoSatelliteInfo::Azimuth, updatedSatellite.azimuth);
        satelliteInfo.setAttribute(QGeoSatelliteInfo::Elevation, updatedSatellite.altitude);
 
        satellitesInView.append(satelliteInfo);
        if (updatedSatellite.usedInFix)
            satellitesInUse.append(satelliteInfo);
    }
 
    Q_EMIT satellitesInUseUpdated(satellitesInUse);
    Q_EMIT satellitesInViewUpdated(satellitesInView);
 
    m_lastUpdatedSatellitesInView = satellitesInView;
    m_lastUpdatedSatellitesInUse = satellitesInUse;
 
    if (m_updateTypes.contains(UpdateType::SingleUpdate))
        handleSingleUpdateFinished();
}
 
void QOhosGeoSatelliteInfoSource::handleSingleUpdateFinished()
{
    m_updateTypes.remove(UpdateType::SingleUpdate);
 
    m_singleUpdateTimeoutTimer.reset();
 
    handleUpdateFinished();
}
 
void QOhosGeoSatelliteInfoSource::handleUpdateFinished()
{
    if (m_updateTypes.empty()) {
        m_positionInfoSource.reset();
        m_updateSatelliteStatusInfoProducerHandle.reset();
        m_lastUpdatedSatellitesInView.reset();
        m_lastUpdatedSatellitesInUse.reset();
    }
}
 
}
 
QGeoSatelliteInfoSource *makeQOhosGeoSatelliteInfoSource(QObject *parent)
{
    return new QOhosGeoSatelliteInfoSource(parent);
}
 
namespace QtOhos {
 
template<>
struct OhosEnumMeta<SatelliteConstellationCategory>
{
    static constexpr const char *fullTypeName = "@ohos.geoLocationManager.SatelliteConstellationCategory";
    static constexpr std::array<std::pair<SatelliteConstellationCategory, const char *>, 8> enumeratorsNames = {{
        {SatelliteConstellationCategory::CONSTELLATION_CATEGORY_UNKNOWN, "CONSTELLATION_CATEGORY_UNKNOWN"},
        {SatelliteConstellationCategory::CONSTELLATION_CATEGORY_GPS, "CONSTELLATION_CATEGORY_GPS"},
        {SatelliteConstellationCategory::CONSTELLATION_CATEGORY_SBAS, "CONSTELLATION_CATEGORY_SBAS"},
        {SatelliteConstellationCategory::CONSTELLATION_CATEGORY_GLONASS, "CONSTELLATION_CATEGORY_GLONASS"},
        {SatelliteConstellationCategory::CONSTELLATION_CATEGORY_QZSS, "CONSTELLATION_CATEGORY_QZSS"},
        {SatelliteConstellationCategory::CONSTELLATION_CATEGORY_BEIDOU, "CONSTELLATION_CATEGORY_BEIDOU"},
        {SatelliteConstellationCategory::CONSTELLATION_CATEGORY_GALILEO, "CONSTELLATION_CATEGORY_GALILEO"},
        {SatelliteConstellationCategory::CONSTELLATION_CATEGORY_IRNSS, "CONSTELLATION_CATEGORY_IRNSS"},
    }};
};
 
}
 
QT_END_NAMESPACE