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/qohoslogger_p.h>
+ #include <QtCore/qjsonarray.h>
+ #include <QtCore/qjsondocument.h>
+ #include <QtCore/qjsonobject.h>
+ #include <QtCore/qurl.h>
+ #include <QtLocation/QGeoRouteReply>
+ #include <QtLocation/QGeoRouteRequest>
+ #include <QtNetwork/qnetworkaccessmanager.h>
+ #include <QtNetwork/qnetworkreply.h>
+ #include <QtNetwork/qnetworkrequest.h>
+ #include <QtPositioning/qgeocoordinate.h>
+ #include <bitset>
+ #include <qgeoroutereplyohosmapkit.h>
+ #include <qgeoroutingmanagerengineohosmapkit.h>
+ #include <qohosmapkitcommon.h>
+
+ QT_BEGIN_NAMESPACE
+
+ namespace {
+
+ const QString routingApiBasePath = QLatin1String("https://mapapi.cloud.huawei.com/mapApi/v1/routeService/");
+ const QHash<QGeoRouteRequest::TravelModes, QUrl> routingApiUrl =
+ {{{QGeoRouteRequest::PedestrianTravel}, QUrl(routingApiBasePath + QLatin1String("walking"))},
+ {{QGeoRouteRequest::BicycleTravel}, QUrl(routingApiBasePath + QLatin1String("bicycling"))},
+ {{QGeoRouteRequest::CarTravel}, QUrl(routingApiBasePath + QLatin1String("driving"))},
+ };
+
+ enum class RestApiRoutingPolicy {
+ Fast = 0,
+ AvoidToolRoads = 1 << 0,
+ AvoidHighways = 1 << 1,
+ ShortDistance = 1 << 2,
+ AvoidFerries = 1 << 3,
+ AvoidCongestedRoads = 1 << 4,
+ PrioritizeMainRoads = 1 << 5,
+ SelectRoutesIntelligently = 1 << 6,
+ PrioritizeHighways = 1 << 7,
+ TakeRoutesChangingTheLeast = 1 << 8,
+ };
+
+ bool isSingleTravelMode(QGeoRouteRequest::TravelModes modes)
+ {
+ auto modesBits = std::bitset<sizeof(unsigned)>(static_cast<unsigned>(modes));
+ return modesBits.count() == 1;
+ }
+
+ QJsonArray createRestApiAvoidArray(const QGeoRouteRequest &request)
+ {
+ QJsonArray restApiAvoidArray;
+
+ auto features = request.featureTypes();
+ auto travelModes = request.travelModes();
+
+ for (auto feature : features) {
+ if (travelModes != QGeoRouteRequest::CarTravel && feature != QGeoRouteRequest::FerryFeature)
+ continue;
+
+ auto featureWeight = request.featureWeight(feature);
+
+ switch (feature) {
+ case QGeoRouteRequest::TollFeature:
+ if (featureWeight == QGeoRouteRequest::AvoidFeatureWeight
+ || featureWeight == QGeoRouteRequest::DisallowFeatureWeight)
+ restApiAvoidArray.push_back(static_cast<int>(RestApiRoutingPolicy::AvoidToolRoads));
+ break;
+ case QGeoRouteRequest::HighwayFeature:
+ if (featureWeight == QGeoRouteRequest::AvoidFeatureWeight
+ || featureWeight == QGeoRouteRequest::DisallowFeatureWeight) {
+ restApiAvoidArray.push_back(static_cast<int>(RestApiRoutingPolicy::AvoidHighways));
+ } else if (featureWeight == QGeoRouteRequest::PreferFeatureWeight
+ || featureWeight == QGeoRouteRequest::RequireFeatureWeight) {
+ restApiAvoidArray.push_back(static_cast<int>(RestApiRoutingPolicy::PrioritizeHighways));
+ }
+ break;
+ case QGeoRouteRequest::FerryFeature:
+ if (featureWeight == QGeoRouteRequest::AvoidFeatureWeight
+ || featureWeight == QGeoRouteRequest::DisallowFeatureWeight)
+ restApiAvoidArray.push_back(static_cast<int>(RestApiRoutingPolicy::AvoidFerries));
+ break;
+ default:
+ break;
+ }
+ }
+
+ if (travelModes == QGeoRouteRequest::CarTravel) {
+ auto routeOptimizations = request.routeOptimization();
+ if (routeOptimizations.testFlag(QGeoRouteRequest::ShortestRoute))
+ restApiAvoidArray.push_back(static_cast<int>(RestApiRoutingPolicy::ShortDistance));
+ else if (routeOptimizations.testFlag(QGeoRouteRequest::FastestRoute))
+ restApiAvoidArray.push_back(static_cast<int>(RestApiRoutingPolicy::Fast));
+ }
+
+ return restApiAvoidArray;
+ }
+
+ QJsonArray createWaypointsJsonArray(const QList<QGeoCoordinate> &waypoints)
+ {
+ QJsonArray waypointsArray;
+
+ constexpr int minNumOfWaypointsToCreateRouteMidpoints = 3;
+ if (waypoints.size() < minNumOfWaypointsToCreateRouteMidpoints)
+ return waypointsArray;
+ constexpr int secondElementIndex = 1;
+ const int penultimateElementIndex = waypoints.size() - 2;
+ for (const auto &waypoint: waypoints.mid(secondElementIndex, penultimateElementIndex))
+ waypointsArray.push_back(OhosMapKit::CoordinateJson::tryConvertFromQGeoCoordinate(waypoint));
+
+ return waypointsArray;
+ }
+
+ QByteArray createRouteRequestBody(const QGeoRouteRequest &request)
+ {
+ constexpr int minNumOfWaypoints = 2;
+ constexpr int restApiWaypointsLimitation = 25;
+ auto waypoints = request.waypoints();
+ if (waypoints.size() < minNumOfWaypoints || waypoints.size() > restApiWaypointsLimitation) {
+ qOhosPrintfWarning(
+ "%s: Invalid number of waypoints: %d. Cannot create route request.",
+ Q_FUNC_INFO, int(waypoints.size()));
+ return {};
+ }
+
+ QJsonObject routeRequestBody;
+
+ routeRequestBody.insert(
+ QStringLiteral("origin"),
+ OhosMapKit::CoordinateJson::tryConvertFromQGeoCoordinate(waypoints.first()));
+ routeRequestBody.insert(
+ QStringLiteral("destination"),
+ OhosMapKit::CoordinateJson::tryConvertFromQGeoCoordinate(waypoints.last()));
+
+ auto restApiAvoidArray = createRestApiAvoidArray(request);
+ if (!restApiAvoidArray.isEmpty())
+ routeRequestBody.insert(QStringLiteral("avoid"), restApiAvoidArray);
+
+ if (request.travelModes() == QGeoRouteRequest::CarTravel) {
+ auto waypointsArray = createWaypointsJsonArray(waypoints);
+ if (!waypointsArray.empty())
+ routeRequestBody.insert(QStringLiteral("waypoints"), waypointsArray);
+ }
+
+ return QJsonDocument(routeRequestBody).toJson(QJsonDocument::Compact);
+ }
+
+ class QGeoRoutingManagerEngineOhosMapKit : public QGeoRoutingManagerEngine
+ {
+ public:
+ QGeoRoutingManagerEngineOhosMapKit(
+ const QVariantMap &parameters, QGeoServiceProvider::Error *error, QString *errorString);
+
+ QGeoRouteReply *calculateRoute(const QGeoRouteRequest &request) override;
+
+ private:
+ void onReplyFinished();
+ void onReplyError(QGeoRouteReply::Error errorCode, const QString &errorString);
+
+ QNetworkAccessManager m_networkManager;
+ QString m_userAgent;
+ QString m_authenticationKey;
+ };
+
+ QGeoRoutingManagerEngineOhosMapKit::QGeoRoutingManagerEngineOhosMapKit(
+ const QVariantMap &parameters, QGeoServiceProvider::Error *error, QString *errorString)
+ : QGeoRoutingManagerEngine(parameters)
+ , m_userAgent(OhosMapKit::getAuthenticationKeyParameterOrEmpty(parameters))
+ , m_authenticationKey(OhosMapKit::getAuthenticationKeyParameterOrEmpty(parameters))
+ {
+ if (error != nullptr)
+ *error = QGeoServiceProvider::NoError;
+
+ if (errorString != nullptr)
+ errorString->clear();
+ }
+
+ QGeoRouteReply *QGeoRoutingManagerEngineOhosMapKit::calculateRoute(const QGeoRouteRequest &request)
+ {
+ auto travelModes = request.travelModes();
+
+ if (!isSingleTravelMode(travelModes)) {
+ return new QGeoRouteReply(
+ QGeoRouteReply::UnsupportedOptionError,
+ tr("Selection of multiple travel modes is not supported by OHOS Map Kit plugin"));
+ }
+
+ if (!routingApiUrl.contains(travelModes)) {
+ return new QGeoRouteReply(
+ QGeoRouteReply::UnsupportedOptionError,
+ tr("Selected travel mode: %1 is not supported by OHOS Map Kit plugin")
+ .arg(travelModes.toInt()));
+ }
+
+ auto *reply = makeQGeoRouteReplyOhosMapKit(
+ m_networkManager.post(
+ OhosMapKit::createOhosMapKitNetworkRequestWithJsonBody(
+ routingApiUrl.value(travelModes), m_userAgent, m_authenticationKey),
+ createRouteRequestBody(request)),
+ request, this);
+
+ connect(
+ reply, &QGeoRouteReply::finished,
+ this, &QGeoRoutingManagerEngineOhosMapKit::onReplyFinished);
+ connect(
+ reply, &QGeoRouteReply::errorOccurred,
+ this, &QGeoRoutingManagerEngineOhosMapKit::onReplyError);
+
+ return reply;
+ }
+
+ void QGeoRoutingManagerEngineOhosMapKit::onReplyFinished()
+ {
+ auto *reply = qobject_cast<QGeoRouteReply *>(sender());
+ if (reply != nullptr)
+ Q_EMIT finished(reply);
+ }
+
+ void QGeoRoutingManagerEngineOhosMapKit::onReplyError(
+ QGeoRouteReply::Error errorCode, const QString &errorString)
+ {
+ auto *reply = qobject_cast<QGeoRouteReply *>(sender());
+ if (reply != nullptr)
+ Q_EMIT errorOccurred(reply, errorCode, errorString);
+ }
+
+ }
+
+ QGeoRoutingManagerEngine *makeQGeoRoutingManagerEngineOhosMapKit(
+ const QVariantMap &parameters, QGeoServiceProvider::Error *error, QString *errorString)
+ {
+ return new QGeoRoutingManagerEngineOhosMapKit(parameters, error, errorString);
+ }
+
+ QT_END_NAMESPACE