qplacemanagerengineohosmapkit.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 <QtCore/qjsondocument.h>
#include <QtCore/qjsonobject.h>
#include <QtCore/qregularexpression.h>
#include <QtCore/qstringlist.h>
#include <QtLocation/private/unsupportedreplies_p.h>
#include <QtLocation/qplacecategory.h>
#include <QtNetwork/qnetworkaccessmanager.h>
#include <qplacemanagerengineohosmapkit.h>
#include <qplacesearchreplyohosmapkit.h>
#include <qplacesearchsuggestionreplyohosmapkit.h>
#include <qohosmapkitcommon.h>
#include <qpoicategoryohosmapkit.h>
 
QT_BEGIN_NAMESPACE
 
namespace {
 
const QString placeSearchApiUrlBase =
    QLatin1String("https://siteapi.cloud.huawei.com/mapApi/v1/siteService/");
const auto searchByTextApiUrl = QUrl(placeSearchApiUrlBase + QLatin1String("searchByText"));
const auto autoCompleteApiUrl = QUrl(placeSearchApiUrlBase + QLatin1String("queryAutoComplete"));
 
class QPlaceManagerEngineOhosMapKit : public QPlaceManagerEngine
{
public:
    QPlaceManagerEngineOhosMapKit(
        const QVariantMap &parameters, QGeoServiceProvider::Error *error, QString *errorString);
 
    QPlaceSearchReply *search(const QPlaceSearchRequest &) override;
    QPlaceSearchSuggestionReply *searchSuggestions(const QPlaceSearchRequest &request) override;
 
    QPlaceReply *initializeCategories() override;
    QString parentCategoryId(const QString &categoryId) const override;
    QStringList childCategoryIds(const QString &categoryId) const override;
    QPlaceCategory category(const QString &categoryId) const override;
    QList<QPlaceCategory> childCategories(const QString &parentId) const override;
 
private:
    void onReplyFinished();
    void onReplyError(QPlaceReply::Error errorCode, const QString &errorString);
 
    QNetworkAccessManager m_networkManager;
    QString m_userAgent;
    QString m_authenticationKey;
};
 
class DummyPlaceReply : public QPlaceReply
{
public:
    DummyPlaceReply(QObject *parent);
 
    void finish();
};
 
DummyPlaceReply::DummyPlaceReply(QObject *parent)
    : QPlaceReply(parent)
{}
 
void DummyPlaceReply::finish()
{
    setFinished(true);
    Q_EMIT finished();
}
 
QJsonObject createPlaceSearchRequestBody(const QPlaceSearchRequest &request)
{
    QJsonObject placeSearchRequestBody;
 
    placeSearchRequestBody.insert(QStringLiteral("query"), request.searchTerm());
 
    auto searchArea = request.searchArea();
    if (searchArea.isValid() && !searchArea.isEmpty()) {
        constexpr int restApiMinRadiusInMeters = 1;
        constexpr int restApiMaxRadiusInMeters = 50000;
        auto radius = qBound(
            restApiMinRadiusInMeters,
            qRound(searchArea.center().distanceTo(searchArea.boundingGeoRectangle().topLeft())),
            restApiMaxRadiusInMeters);
 
        placeSearchRequestBody.insert(
            QStringLiteral("location"),
            OhosMapKit::CoordinateJson::tryConvertFromQGeoCoordinate(searchArea.center()));
        placeSearchRequestBody.insert(QStringLiteral("radius"), radius);
    }
 
    placeSearchRequestBody.insert(QStringLiteral("language"), OhosMapKit::getLanguageCode());
 
    return placeSearchRequestBody;
}
 
QString convertCategoryIdToCategoryName(const QString &categoryId)
{
    auto base = categoryId;
    if (!base.startsWith("ADMINISTRATIVE_AREA"))
        base.remove(QRegularExpression(R"((_LEVEL_\d+)$)"));
 
    auto parts = base.split(QLatin1Char('_'), Qt::SkipEmptyParts);
    for (int i = 0; i < parts.size(); ++i) {
        parts[i] = parts[i].toLower();
        if (i == 0 && !parts[i].isEmpty())
            parts[i][0] = parts[i][0].toUpper();
    }
    return parts.join(QLatin1Char(' '));
}
 
 
QPlaceManagerEngineOhosMapKit::QPlaceManagerEngineOhosMapKit(
    const QVariantMap &parameters, QGeoServiceProvider::Error *error, QString *errorString)
    : QPlaceManagerEngine(parameters)
    , m_userAgent(OhosMapKit::getUserAgentParameterOrDefault(parameters))
    , m_authenticationKey(OhosMapKit::getAuthenticationKeyParameterOrEmpty(parameters))
{
    if (error != nullptr)
        *error = QGeoServiceProvider::NoError;
 
    if (errorString != nullptr)
        errorString->clear();
}
 
QPlaceSearchReply *QPlaceManagerEngineOhosMapKit::search(const QPlaceSearchRequest &request)
{
    if (request.categories().size() > 1) {
        return new QPlaceSearchReplyUnsupported(
            QPlaceReply::UnsupportedError,
            tr("OHOS Map Kit allows search of only one category type."),
            this);
    }
 
    auto placeSearchRequestBody = createPlaceSearchRequestBody(request);
 
    constexpr auto restApiMinNumOfResultsPerPage = 1;
    constexpr auto restApiMaxNumOfResultsPerPage = 20;
    if (request.limit() > 0) {
        placeSearchRequestBody.insert(
            QStringLiteral("pageSize"),
            qBound(restApiMinNumOfResultsPerPage, request.limit(), restApiMaxNumOfResultsPerPage));
    }
 
    if (!request.categories().isEmpty())
        placeSearchRequestBody.insert(QStringLiteral("hwPoiType"), request.categories().first().categoryId());
 
    auto *reply = makeQPlaceSearchReplyOhosMapKit(
        request,
        m_networkManager.post(
            OhosMapKit::createOhosMapKitNetworkRequestWithJsonBody(
                searchByTextApiPath, m_userAgent, m_authenticationKey),
            QJsonDocument(placeSearchRequestBody).toJson(QJsonDocument::Compact)),
        this);
 
    connect(
        reply, &QPlaceSearchReply::finished,
        this, &QPlaceManagerEngineOhosMapKit::onReplyFinished);
    connect(
        reply,
        &QPlaceSearchReply::errorOccurred,
        this,
        &QPlaceManagerEngineOhosMapKit::onReplyError);
 
    return reply;
}
 
QPlaceSearchSuggestionReply *QPlaceManagerEngineOhosMapKit::searchSuggestions(
    const QPlaceSearchRequest &request)
{
    auto *reply = makeQPlaceSearchSuggestionReplyOhosMapKit(
        m_networkManager.post(
            OhosMapKit::createOhosMapKitNetworkRequestWithJsonBody(
                autoCompleteApiPath, m_userAgent, m_authenticationKey),
            QJsonDocument(createPlaceSearchRequestBody(request)).toJson(QJsonDocument::Compact)),
        this);
 
    connect(
        reply, &QPlaceSearchSuggestionReply::finished,
        this, &QPlaceManagerEngineOhosMapKit::onReplyFinished);
    connect(
        reply,
        &QPlaceSearchSuggestionReply::errorOccurred,
        this,
        &QPlaceManagerEngineOhosMapKit::onReplyError);
 
    return reply;
}
 
QPlaceReply *QPlaceManagerEngineOhosMapKit::initializeCategories()
{
    auto *reply = new DummyPlaceReply(this);
    connect(reply, &QPlaceReply::finished, this, &QPlaceManagerEngineOhosMapKit::onReplyFinished);
    QMetaObject::invokeMethod(reply, &DummyPlaceReply::finish, Qt::QueuedConnection);
 
    return reply;
}
 
QString QPlaceManagerEngineOhosMapKit::parentCategoryId(const QString &categoryId) const
{
    return QPoiCategoryOhosMapKit::tryGetParentCategoryIdOrEmpty(categoryId);
}
 
QStringList QPlaceManagerEngineOhosMapKit::childCategoryIds(const QString &categoryId) const
{
    return QPoiCategoryOhosMapKit::tryGetChildCategoryIdsOrEmpty(categoryId);
}
 
QPlaceCategory QPlaceManagerEngineOhosMapKit::category(const QString &categoryId) const
{
    QPlaceCategory placeCategory;
    placeCategory.setCategoryId(categoryId);
    placeCategory.setName(convertCategoryIdToCategoryName(categoryId));
    return placeCategory;
}
 
QList<QPlaceCategory> QPlaceManagerEngineOhosMapKit::childCategories(const QString &parentId) const
{
    auto categoryIds = childCategoryIds(parentId);
 
    QList<QPlaceCategory> childCategories;
    for (const auto &categoryId : categoryIds)
        childCategories.push_back(category(categoryId));
 
    return childCategories;
}
 
void QPlaceManagerEngineOhosMapKit::onReplyFinished()
{
    auto *reply = qobject_cast<QPlaceReply *>(sender());
    if (reply != nullptr)
        Q_EMIT finished(reply);
}
 
void QPlaceManagerEngineOhosMapKit::onReplyError(
    QPlaceReply::Error errorCode, const QString &errorString)
{
    auto *reply = qobject_cast<QPlaceReply *>(sender());
    if (reply != nullptr)
        Q_EMIT errorOccurred(reply, errorCode, errorString);
}
 
}
 
QPlaceManagerEngine *makeQPlaceManagerEngineOhosMapKit(
    const QVariantMap &parameters, QGeoServiceProvider::Error *error, QString *errorString)
{
    return new QPlaceManagerEngineOhosMapKit(parameters, error, errorString);
}
 
QT_END_NAMESPACE