qgeoroutereplyohosmapkit.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/qjsonarray.h>
#include <QtCore/qmetaobject.h>
#include <QtLocation/private/qgeorouteparser_p.h>
#include <QtLocation/private/qgeoroute_p.h>
#include <QtLocation/qgeoroutesegment.h>
#include <QtLocation/qgeomaneuver.h>
#include <qgeoroutereplyohosmapkit.h>
#include <qgeoroutingmanagerengineohosmapkit.h>
#include <qohosmapkitcommon.h>
 
QT_BEGIN_NAMESPACE
 
namespace {
 
QHash<QString, QGeoManeuver::InstructionDirection> actionsToDirectionsMap = {
    {"turn-slight-left", QGeoManeuver::DirectionLightLeft},
    {"turn-sharp-left", QGeoManeuver::DirectionHardLeft},
    {"uturn-left", QGeoManeuver::DirectionUTurnLeft},
    {"turn-left", QGeoManeuver::DirectionLeft},
    {"turn-slight-right", QGeoManeuver::DirectionLightRight},
    {"turn-sharp-right", QGeoManeuver::DirectionHardRight},
    {"uturn-right", QGeoManeuver::DirectionUTurnRight},
    {"turn-right", QGeoManeuver::DirectionRight},
    {"straight", QGeoManeuver::DirectionForward},
    {"ramp-left", QGeoManeuver::DirectionBearLeft},
    {"ramp-right", QGeoManeuver::DirectionBearRight},
    {"fork-left", QGeoManeuver::DirectionBearLeft},
    {"fork-right", QGeoManeuver::DirectionBearRight},
    {"roundabout-left", QGeoManeuver::DirectionLeft},
    {"roundabout-right", QGeoManeuver::DirectionRight},
};
 
QList<QGeoCoordinate> parsePolyline(const QJsonArray &polyArray)
{
    QList<QGeoCoordinate> coords;
 
    coords.reserve(polyArray.size());
    for (const auto &coordVal : polyArray)
        coords.append(OhosMapKit::CoordinateJson::tryConvertToQGeoCoordinate(coordVal.toObject()));
 
    return coords;
}
 
QGeoManeuver parseManeuver(const QJsonObject &stepObj)
{
    QGeoManeuver maneuver;
 
    maneuver.setInstructionText(stepObj.value("instruction").toString());
    maneuver.setPosition(
        OhosMapKit::CoordinateJson::tryConvertToQGeoCoordinate(stepObj.value("startLocation").toObject()));
    maneuver.setDistanceToNextInstruction(stepObj.value("distance").toDouble());
    maneuver.setTimeToNextInstruction(stepObj.value("duration").toDouble());
 
    auto action = stepObj.value("action").toString();
    maneuver.setDirection(actionsToDirectionsMap.value(action, QGeoManeuver::NoDirection));
 
    return maneuver;
}
 
QGeoRouteSegment parseStep(const QJsonObject &stepObj)
{
    QGeoRouteSegment segment;
 
    segment.setDistance(stepObj.value("distance").toDouble());
    segment.setTravelTime(stepObj.value("duration").toDouble());
    segment.setPath(parsePolyline(stepObj.value("polyline").toArray()));
    segment.setManeuver(parseManeuver(stepObj));
 
    return segment;
}
 
QGeoRoute parseRoute(const QJsonObject &routeObj)
{
    QGeoRoute route;
 
    route.setBounds(
        OhosMapKit::CoordinateBoundsJson::tryConvertToQGeoRectangle(routeObj.value("bounds").toObject()));
 
    double totalDistance = 0.0;
    double totalTimeSeconds = 0.0;
    QList<QGeoCoordinate> fullRoutePath;
    QList<QGeoRouteSegment> routeSegments;
 
    auto pathsArray = routeObj.value("paths").toArray();
    for (const auto &pathVal : pathsArray) {
        auto pathObj = pathVal.toObject();
        totalDistance += pathObj.value("distance").toDouble();
        totalTimeSeconds += pathObj.value("duration").toDouble();
 
        auto stepsArray = pathObj.value("steps").toArray();
        for (const auto &stepVal : stepsArray) {
            routeSegments.push_back(parseStep(stepVal.toObject()));
 
            auto segmentPath = routeSegments.last().path();
            if (!segmentPath.isEmpty()) {
                if (!fullRoutePath.isEmpty() && fullRoutePath.last() == segmentPath.first())
                    segmentPath.pop_front();
 
                fullRoutePath += segmentPath;
            }
        }
    }
 
    route.setDistance(totalDistance);
    route.setTravelTime(totalTimeSeconds);
    route.setPath(fullRoutePath);
    if (!routeSegments.isEmpty()) {
        auto currentRouteSegment = routeSegments.last();
        for (int i = routeSegments.size() - 2; i >= 0; --i) {
            auto tmpRouteSegment = routeSegments[i];
            tmpRouteSegment.setNextRouteSegment(currentRouteSegment);
            currentRouteSegment = tmpRouteSegment;
        }
        route.setFirstRouteSegment(currentRouteSegment);
    }
 
    return route;
}
 
QList<QGeoRoute> parseRouteResponse(const QJsonObject &responseBodyJsonObj)
{
    QList<QGeoRoute> routes;
 
    auto routesArray = responseBodyJsonObj.value("routes").toArray();
    for (const auto &routeVal : routesArray)
        routes.append(parseRoute(routeVal.toObject()));
 
    return routes;
}
 
class QGeoRouteReplyOhosMapKit : public QGeoRouteReply
{
public:
    QGeoRouteReplyOhosMapKit(
        QNetworkReply *reply, const QGeoRouteRequest &request, QObject *parent);
 
private:
    void networkReplyFinished();
    void networkReplyError(QNetworkReply::NetworkError error);
};
 
QGeoRouteReplyOhosMapKit::QGeoRouteReplyOhosMapKit(
    QNetworkReply *reply, const QGeoRouteRequest &request, QObject *parent)
    : QGeoRouteReply(request, parent)
{
    if (reply == nullptr) {
        setError(QGeoRouteReply::UnknownError, QStringLiteral("Null reply"));
        return;
    }
 
    connect(reply, &QNetworkReply::finished, this, &QGeoRouteReplyOhosMapKit::networkReplyFinished);
    connect(reply, &QNetworkReply::errorOccurred, this, &QGeoRouteReplyOhosMapKit::networkReplyError);
    connect(this, &QGeoRouteReply::aborted, reply, &QNetworkReply::abort);
    connect(this, &QObject::destroyed, reply, &QObject::deleteLater);
}
 
void QGeoRouteReplyOhosMapKit::networkReplyFinished()
{
    auto *reply = static_cast<QNetworkReply *>(sender());
    reply->deleteLater();
 
    if (reply->error() != QNetworkReply::NoError) {
        setError(
            QGeoRouteReply::UnknownError,
            tr("Network reply error: %1")
                .arg(QMetaEnum::fromType<QNetworkReply::NetworkError>().valueToKey(reply->error())));
        return;
    }
 
    auto responseBodyJsonDoc = QJsonDocument::fromJson(reply->readAll());
    if (!responseBodyJsonDoc.isObject()) {
        setError(QGeoRouteReply::ParseError, tr("Response parse error"));
        return;
    }
 
    setRoutes(parseRouteResponse(responseBodyJsonDoc.object()));
 
    setFinished(true);
}
 
void QGeoRouteReplyOhosMapKit::networkReplyError(QNetworkReply::NetworkError error)
{
    Q_UNUSED(error)
    auto *reply = static_cast<QNetworkReply *>(sender());
    reply->deleteLater();
    setError(QGeoRouteReply::CommunicationError, reply->errorString());
}
 
}
 
QGeoRouteReply *makeQGeoRouteReplyOhosMapKit(
    QNetworkReply *reply, const QGeoRouteRequest &request, QObject *parent)
{
    return new QGeoRouteReplyOhosMapKit(reply, request, parent);
}
 
QT_END_NAMESPACE