Source code
Revision control
Copy as Markdown
// 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 ¶meters, 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 ¶meters, 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 ¶meters, QGeoServiceProvider::Error *error, QString *errorString)
{
return new QGeoRoutingManagerEngineOhosMapKit(parameters, error, errorString);
}
QT_END_NAMESPACE