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/qjsonarray.h>
+ #include <QtCore/qjsondocument.h>
+ #include <QtCore/qjsonobject.h>
+ #include <QtCore/qmetaobject.h>
+ #include <QtLocation/qplace.h>
+ #include <QtLocation/qplaceattribute.h>
+ #include <QtLocation/qplacecategory.h>
+ #include <QtLocation/qplacecontactdetail.h>
+ #include <QtLocation/qplaceicon.h>
+ #include <QtLocation/qplaceratings.h>
+ #include <QtLocation/qplaceresult.h>
+ #include <QtLocation/qplacesearchrequest.h>
+ #include <QtLocation/qplacesearchresult.h>
+ #include <QtPositioning/qgeoaddress.h>
+ #include <QtPositioning/qgeolocation.h>
+ #include <qohosmapkitcommon.h>
+ #include <qplacesearchreplyohosmapkit.h>
+ #include <qplacemanagerengineohosmapkit.h>
+
+ QT_BEGIN_NAMESPACE
+
+ namespace {
+
+ class QPlaceSearchReplyOhosMapKit : public QPlaceSearchReply
+ {
+ public:
+ QPlaceSearchReplyOhosMapKit(
+ const QPlaceSearchRequest &request, QNetworkReply *reply, QPlaceManagerEngine *parent);
+
+ private:
+ void onReplyFinished();
+ void onNetworkError(QNetworkReply::NetworkError error);
+ };
+
+ void populatePlaceExtendedAttributes(const QJsonObject &poiJsonObj, QPlace &place)
+ {
+ const QJsonValue openingHours = poiJsonObj.value(QStringLiteral("openingHours"));
+ if (!openingHours.isUndefined() && !openingHours.isNull()) {
+ QPlaceAttribute attr;
+ attr.setLabel(QPlaceSearchReplyOhosMapKit::tr("Opening hours"));
+ attr.setText(openingHours.toVariant().toString());
+ place.setExtendedAttribute(QStringLiteral("openingHours"), attr);
+ }
+
+ const QJsonArray photos = poiJsonObj.value(QStringLiteral("photoUrls")).toArray();
+ if (!photos.isEmpty()) {
+ QPlaceAttribute attr;
+ attr.setLabel(QPlaceSearchReplyOhosMapKit::tr("Photo URLs"));
+ attr.setText(QString::fromUtf8(QJsonDocument(photos).toJson(QJsonDocument::Compact)));
+ place.setExtendedAttribute(QStringLiteral("photoUrls"), attr);
+ }
+ }
+
+ void populatePlaceFromPoiJson(const QJsonObject &poiJsonObj, QPlace &place)
+ {
+ auto phoneData = poiJsonObj.value(QStringLiteral("phone")).toVariant().toString();
+ if (!phoneData.isEmpty()) {
+ QPlaceContactDetail phoneDetail;
+ phoneDetail.setLabel(QPlaceSearchReplyOhosMapKit::tr("Phone"));
+ phoneDetail.setValue(phoneData);
+ place.appendContactDetail(QPlaceContactDetail::Phone, phoneDetail);
+ }
+
+ auto internationalPhoneData =
+ poiJsonObj.value(QStringLiteral("internationalPhone")).toVariant().toString();
+ if (!internationalPhoneData.isEmpty()) {
+ QPlaceContactDetail intlPhoneDetail;
+ intlPhoneDetail.setLabel(QPlaceSearchReplyOhosMapKit::tr("International phone"));
+ intlPhoneDetail.setValue(internationalPhoneData);
+ place.appendContactDetail(QPlaceContactDetail::Phone, intlPhoneDetail);
+ }
+
+ auto websiteUrl = poiJsonObj.value(QStringLiteral("websiteUrl")).toVariant().toString();
+ if (!websiteUrl.isEmpty()) {
+ QPlaceContactDetail websiteDetail;
+ websiteDetail.setLabel(QPlaceSearchReplyOhosMapKit::tr("Website"));
+ websiteDetail.setValue(internationalPhoneData);
+ place.appendContactDetail(QPlaceContactDetail::Website, websiteDetail);
+ }
+
+ auto rating = poiJsonObj.value(QStringLiteral("rating")).toDouble(0.0);
+ if (rating > 0.0) {
+ QPlaceRatings ratings;
+ ratings.setAverage(rating);
+ place.setRatings(ratings);
+ }
+
+ auto iconUrl = poiJsonObj.value(QStringLiteral("icon")).toVariant().toUrl();
+ if (!iconUrl.isEmpty()) {
+ QPlaceIcon icon;
+ icon.setParameters({{QPlaceIcon::SingleUrl, iconUrl}});
+ place.setIcon(icon);
+ }
+
+ auto hwPoi = poiJsonObj.value(QStringLiteral("hwPoiTypes")).toArray();
+ if (!hwPoi.isEmpty()) {
+ auto id = hwPoi.first().toVariant().toString();
+ if (!id.isEmpty()) {
+ QPlaceCategory c;
+ c.setCategoryId(id);
+ place.setCategory(c);
+ }
+ }
+
+ populatePlaceExtendedAttributes(poiJsonObj, place);
+ }
+
+ QPlaceResult siteJsonObjToPlaceResult(const QJsonObject &siteJsonObj)
+ {
+ QPlace place;
+
+ place.setName(siteJsonObj.value(QStringLiteral("name")).toVariant().toString());
+ place.setLocation(OhosMapKit::SiteJson::tryConvertToQGeoLocation(siteJsonObj));
+
+ const QJsonObject poiObj = siteJsonObj.value(QStringLiteral("poi")).toObject();
+ if (!poiObj.isEmpty())
+ populatePlaceFromPoiJson(poiObj, place);
+
+ QPlaceResult result;
+ result.setPlace(place);
+ result.setDistance(siteJsonObj.value(QStringLiteral("distance")).toVariant().toInt());
+ return result;
+ }
+
+ QList<QPlaceSearchResult> parsePlaceSearchResponse(const QJsonDocument &responseBodyJsonDoc)
+ {
+ QList<QPlaceSearchResult> results;
+
+ const QJsonObject responseBodyJsonObj = responseBodyJsonDoc.object();
+ if (responseBodyJsonObj.contains(QStringLiteral("sites"))) {
+ const QJsonArray sites = responseBodyJsonObj.value(QStringLiteral("sites")).toArray();
+ for (const QJsonValue &siteValue : sites) {
+ if (siteValue.isObject())
+ results.append(siteJsonObjToPlaceResult(siteValue.toObject()));
+ }
+ }
+
+ return results;
+ }
+
+ QPlaceSearchReplyOhosMapKit::QPlaceSearchReplyOhosMapKit(
+ const QPlaceSearchRequest &request, QNetworkReply *reply, QPlaceManagerEngine *parent)
+ : QPlaceSearchReply(parent)
+ {
+ Q_ASSERT(parent);
+ if (!reply) {
+ setError(QPlaceReply::UnknownError, QStringLiteral("Null reply"));
+ return;
+ }
+ setRequest(request);
+
+ connect(reply, &QNetworkReply::finished, this, &QPlaceSearchReplyOhosMapKit::onReplyFinished);
+ connect(reply, &QNetworkReply::errorOccurred, this, &QPlaceSearchReplyOhosMapKit::onNetworkError);
+
+ connect(this, &QPlaceReply::aborted, reply, &QNetworkReply::abort);
+ connect(this, &QObject::destroyed, reply, &QObject::deleteLater);
+ }
+
+ void QPlaceSearchReplyOhosMapKit::onReplyFinished()
+ {
+ auto *reply = static_cast<QNetworkReply *>(sender());
+ reply->deleteLater();
+
+ auto setErrorEmitAndFinish = [&](QPlaceReply::Error errorCode, const QString &errorString) {
+ setError(errorCode, errorString);
+ Q_EMIT errorOccurred(errorCode, errorString);
+
+ setFinished(true);
+ Q_EMIT finished();
+ };
+
+ if (reply->error() != QNetworkReply::NoError) {
+ setErrorEmitAndFinish(
+ QPlaceReply::CommunicationError,
+ tr("Network reply error: %1")
+ .arg(QMetaEnum::fromType<QNetworkReply::NetworkError>().valueToKey(reply->error())));
+ return;
+ }
+
+ const auto responseBodyJsonDoc = QJsonDocument::fromJson(reply->readAll());
+ if (!responseBodyJsonDoc.isObject()) {
+ setErrorEmitAndFinish(QPlaceReply::ParseError, tr("Response parse error"));
+ return;
+ }
+
+ auto results = parsePlaceSearchResponse(responseBodyJsonDoc);
+
+ if (request().relevanceHint() == QPlaceSearchRequest::DistanceHint) {
+ std::sort(
+ results.begin(), results.end(),
+ [](const auto &a, const auto &b) {
+ return
+ a.type() == QPlaceSearchResult::PlaceResult
+ && b.type() == QPlaceSearchResult::PlaceResult
+ && QPlaceResult(a).distance() < QPlaceResult(b).distance();
+ });
+ } else if (request().relevanceHint() == QPlaceSearchRequest::LexicalPlaceNameHint) {
+ std::sort(
+ results.begin(), results.end(),
+ [](const auto &a, const auto &b) {
+ return
+ a.type() == QPlaceSearchResult::PlaceResult
+ && b.type() == QPlaceSearchResult::PlaceResult
+ && QPlaceResult(a).place().name() < QPlaceResult(b).place().name();
+ });
+ }
+
+ setResults(results);
+
+ setFinished(true);
+ Q_EMIT finished();
+ }
+
+ void QPlaceSearchReplyOhosMapKit::onNetworkError(QNetworkReply::NetworkError error)
+ {
+ Q_UNUSED(error)
+ auto *reply = static_cast<QNetworkReply *>(sender());
+ reply->deleteLater();
+ setError(QPlaceReply::CommunicationError, reply->errorString());
+ }
+
+ }
+
+ QPlaceSearchReply *makeQPlaceSearchReplyOhosMapKit(
+ const QPlaceSearchRequest &request, QNetworkReply *reply, QPlaceManagerEngine *parent)
+ {
+ return new QPlaceSearchReplyOhosMapKit(request, reply, parent);
+ }
+
+ QT_END_NAMESPACE