qdeclarativegeoroutemodel.cpp

Go to the documentation of this file.

// Copyright (C) 2022 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 "qdeclarativegeoroutemodel_p.h"
#include "error_messages_p.h"
 
#include <QtCore/QCoreApplication>
#include <QtQml/QQmlEngine>
#include <QtQml/qqmlinfo.h>
#include <QtLocation/QGeoRoutingManager>
#include <QtPositioning/QGeoRectangle>
 
QT_BEGIN_NAMESPACE
 
QDeclarativeGeoRouteModel::QDeclarativeGeoRouteModel(QObject *parent)
    : QAbstractListModel(parent)
{
}
 
int QDeclarativeGeoRouteModel::count() const
{
    return routes_.count();
}
 
void QDeclarativeGeoRouteModel::reset()
{
    if (!routes_.isEmpty()) {
        beginResetModel();
        routes_.clear();
        emit countChanged();
        emit routesChanged();
        endResetModel();
    }
 
    emit abortRequested();
    setError(NoError, QString());
    setStatus(QDeclarativeGeoRouteModel::Null);
}
 
void QDeclarativeGeoRouteModel::cancel()
{
    emit abortRequested();
    setError(NoError, QString());
    setStatus(routes_.isEmpty() ? Null : Ready);
}
 
QGeoRoute QDeclarativeGeoRouteModel::get(int index)
{
    if (index < 0 || index >= routes_.count()) {
        qmlWarning(this) << QStringLiteral("Index '%1' out of range").arg(index);
        return QGeoRoute();
    }
    return routes_.at(index);
}
 
void QDeclarativeGeoRouteModel::componentComplete()
{
    complete_ = true;
    if (autoUpdate_) {
        update();
    }
}
 
int QDeclarativeGeoRouteModel::rowCount(const QModelIndex &parent) const
{
    Q_UNUSED(parent);
    return routes_.count();
}
 
QVariant QDeclarativeGeoRouteModel::data(const QModelIndex &index, int role) const
{
    if (!index.isValid()) {
        qmlWarning(this) << QStringLiteral("Error in indexing route model's data (invalid index).");
        return QVariant();
    }
 
    if (index.row() >= routes_.count()) {
        qmlWarning(this) << QStringLiteral("Fatal error in indexing route model's data (index overflow).");
        return QVariant();
    }
 
    if (role == RouteRole)
        return QVariant::fromValue(routes_.at(index.row()));
    return QVariant();
}
 
QHash<int, QByteArray> QDeclarativeGeoRouteModel::roleNames() const
{
    QHash<int, QByteArray> roleNames = QAbstractListModel::roleNames();
    roleNames.insert(RouteRole, "routeData");
    return roleNames;
}
 
void QDeclarativeGeoRouteModel::setPlugin(QDeclarativeGeoServiceProvider *plugin)
{
    if (plugin_ == plugin)
        return;
 
    reset(); // reset the model
 
    if (plugin_) {
        disconnect(plugin_, &QDeclarativeGeoServiceProvider::localesChanged,
                   this, &QDeclarativeGeoRouteModel::measurementSystemChanged);
    }
    if (plugin) {
        connect(plugin, &QDeclarativeGeoServiceProvider::localesChanged,
                this, &QDeclarativeGeoRouteModel::measurementSystemChanged);
    }
 
    plugin_ = plugin;
 
    if (complete_)
        emit pluginChanged();
 
    if (!plugin)
        return;
 
    if (plugin_->isAttached()) {
        pluginReady();
    } else {
        connect(plugin_, &QDeclarativeGeoServiceProvider::attached,
                this, &QDeclarativeGeoRouteModel::pluginReady);
    }
}
 
void QDeclarativeGeoRouteModel::pluginReady()
{
    QGeoServiceProvider *serviceProvider = plugin_->sharedGeoServiceProvider();
    QGeoRoutingManager *routingManager = serviceProvider->routingManager();
 
    if (serviceProvider->routingError() != QGeoServiceProvider::NoError) {
        QDeclarativeGeoRouteModel::RouteError newError = UnknownError;
        switch (serviceProvider->routingError()) {
        case QGeoServiceProvider::NotSupportedError:
            newError = EngineNotSetError; break;
        case QGeoServiceProvider::UnknownParameterError:
            newError = UnknownParameterError; break;
        case QGeoServiceProvider::MissingRequiredParameterError:
            newError = MissingRequiredParameterError; break;
        case QGeoServiceProvider::ConnectionError:
            newError = CommunicationError; break;
        default:
            break;
        }
 
        setError(newError, serviceProvider->routingErrorString());
        return;
    }
 
    if (!routingManager) {
        setError(EngineNotSetError, tr("Plugin does not support routing."));
        return;
    }
 
    connect(routingManager, &QGeoRoutingManager::finished,
            this, &QDeclarativeGeoRouteModel::routingFinished);
    connect(routingManager, &QGeoRoutingManager::errorOccurred,
            this, &QDeclarativeGeoRouteModel::routingError);
}
 
void QDeclarativeGeoRouteModel::queryDetailsChanged()
{
    if (autoUpdate_ && complete_)
        update();
}
 
QDeclarativeGeoServiceProvider *QDeclarativeGeoRouteModel::plugin() const
{
    return plugin_;
}
 
void QDeclarativeGeoRouteModel::setQuery(QDeclarativeGeoRouteQuery *query)
{
    if (!query || query == routeQuery_)
        return;
    if (routeQuery_)
        routeQuery_->disconnect(this);
    routeQuery_ = query;
    connect(query, &QDeclarativeGeoRouteQuery::queryDetailsChanged,
            this, &QDeclarativeGeoRouteModel::queryDetailsChanged);
    if (complete_) {
        emit queryChanged();
        if (autoUpdate_)
            update();
    }
}
 
QDeclarativeGeoRouteQuery *QDeclarativeGeoRouteModel::query() const
{
    return routeQuery_;
}
 
void QDeclarativeGeoRouteModel::setAutoUpdate(bool autoUpdate)
{
    if (autoUpdate_ == autoUpdate)
        return;
    autoUpdate_ = autoUpdate;
    if (complete_)
        emit autoUpdateChanged();
}
 
bool QDeclarativeGeoRouteModel::autoUpdate() const
{
    return autoUpdate_;
}
 
void QDeclarativeGeoRouteModel::setMeasurementSystem(QLocale::MeasurementSystem ms)
{
    if (!plugin_)
        return;
 
    QGeoServiceProvider *serviceProvider = plugin_->sharedGeoServiceProvider();
    if (!serviceProvider)
        return;
 
    QGeoRoutingManager *routingManager = serviceProvider->routingManager();
    if (!routingManager)
        return;
 
    if (routingManager->measurementSystem() == ms)
        return;
 
    routingManager->setMeasurementSystem(ms);
    emit measurementSystemChanged();
}
 
QLocale::MeasurementSystem QDeclarativeGeoRouteModel::measurementSystem() const
{
    if (!plugin_)
        return QLocale().measurementSystem();
 
    QGeoServiceProvider *serviceProvider = plugin_->sharedGeoServiceProvider();
    if (!serviceProvider) {
        if (plugin_->locales().isEmpty())
            return QLocale().measurementSystem();
 
        return QLocale(plugin_->locales().first()).measurementSystem();
    }
 
    QGeoRoutingManager *routingManager = serviceProvider->routingManager();
    if (!routingManager) {
        if (plugin_->locales().isEmpty())
            return QLocale().measurementSystem();
 
        return QLocale(plugin_->locales().first()).measurementSystem();
    }
 
    return routingManager->measurementSystem();
}
 
void QDeclarativeGeoRouteModel::setStatus(QDeclarativeGeoRouteModel::Status status)
{
    if (status_ == status)
        return;
 
    status_ = status;
 
    if (complete_)
        emit statusChanged();
}
 
QDeclarativeGeoRouteModel::Status QDeclarativeGeoRouteModel::status() const
{
    return status_;
}
 
QString QDeclarativeGeoRouteModel::errorString() const
{
    return errorString_;
}
 
QDeclarativeGeoRouteModel::RouteError QDeclarativeGeoRouteModel::error() const
{
    return error_;
}
 
void QDeclarativeGeoRouteModel::setError(RouteError error, const QString& errorString)
{
    if (error_ == error && errorString_ == errorString)
        return;
    error_ = error;
    errorString_ = errorString;
    emit errorChanged();
}
 
void QDeclarativeGeoRouteModel::update()
{
    if (!complete_)
        return;
 
    if (!plugin_) {
        setError(EngineNotSetError, tr("Cannot route, plugin not set."));
        return;
    }
 
    QGeoServiceProvider *serviceProvider = plugin_->sharedGeoServiceProvider();
    if (!serviceProvider)
        return;
 
    QGeoRoutingManager *routingManager = serviceProvider->routingManager();
    if (!routingManager) {
        setError(EngineNotSetError, tr("Cannot route, route manager not set."));
        return;
    }
    if (!routeQuery_) {
        setError(ParseError, tr("Cannot route, valid query not set."));
        return;
    }
    emit abortRequested(); // Clear previous requests
    QGeoRouteRequest request = routeQuery_->routeRequest();
    if (request.waypoints().count() < 2) {
        setError(ParseError,tr("Not enough waypoints for routing."));
        return;
    }
 
    setError(NoError, QString());
 
    QGeoRouteReply *reply = routingManager->calculateRoute(request);
    setStatus(QDeclarativeGeoRouteModel::Loading);
    if (!reply->isFinished()) {
        connect(this, &QDeclarativeGeoRouteModel::abortRequested, reply, &QGeoRouteReply::abort);
    } else {
        if (reply->error() == QGeoRouteReply::NoError) {
            routingFinished(reply);
        } else {
            routingError(reply, reply->error(), reply->errorString());
        }
    }
}
 
void QDeclarativeGeoRouteModel::routingFinished(QGeoRouteReply *reply)
{
    if (!reply)
        return;
    reply->deleteLater();
    if (reply->error() != QGeoRouteReply::NoError)
        return;
 
    beginResetModel();
    const int oldCount = routes_.count();
    routes_ = reply->routes();
    endResetModel();
 
    setError(NoError, QString());
    setStatus(QDeclarativeGeoRouteModel::Ready);
 
    if (oldCount != 0 || routes_.count() != 0)
        emit routesChanged();
    if (oldCount != routes_.count())
        emit countChanged();
}
 
void QDeclarativeGeoRouteModel::routingError(QGeoRouteReply *reply,
                                               QGeoRouteReply::Error error,
                                               const QString &errorString)
{
    if (!reply)
        return;
    reply->deleteLater();
    setError(static_cast<QDeclarativeGeoRouteModel::RouteError>(error), errorString);
    setStatus(QDeclarativeGeoRouteModel::Error);
}
 
 
QDeclarativeGeoRouteQuery::QDeclarativeGeoRouteQuery(QObject *parent)
    : QObject(parent)
{
}
 
QDeclarativeGeoRouteQuery::QDeclarativeGeoRouteQuery(const QGeoRouteRequest &request, QObject *parent)
    : QObject(parent), request_(request)
{
    // Extra params assumed to be already set in the request.
    // Init waypoints
    m_waypoints = request_.waypoints();
}
 
QDeclarativeGeoRouteQuery::~QDeclarativeGeoRouteQuery()
{
}
 
void QDeclarativeGeoRouteQuery::componentComplete()
{
    complete_ = true;
}
 
QList<int> QDeclarativeGeoRouteQuery::featureTypes() const
{
    QList<int> list;
 
    const auto featureTypes = request_.featureTypes();
    for (const auto &featureType : featureTypes)
        list.append(static_cast<int>(featureType));
    return list;
}
 
int QDeclarativeGeoRouteQuery::numberAlternativeRoutes() const
{
    return request_.numberAlternativeRoutes();
}
 
void QDeclarativeGeoRouteQuery::setNumberAlternativeRoutes(int numberAlternativeRoutes)
{
    if (numberAlternativeRoutes == request_.numberAlternativeRoutes())
        return;
 
    request_.setNumberAlternativeRoutes(numberAlternativeRoutes);
 
    if (complete_) {
        emit numberAlternativeRoutesChanged();
        emit queryDetailsChanged();
    }
}
 
QList<QGeoCoordinate> QDeclarativeGeoRouteQuery::waypoints() const
{
    return m_waypoints;
}
 
void QDeclarativeGeoRouteQuery::setWaypoints(const QList<QGeoCoordinate> &value)
{
    if (m_waypoints == value)
        return;
 
    m_waypoints = value;
    waypointChanged();
}
 
QList<QGeoRectangle> QDeclarativeGeoRouteQuery::excludedAreas() const
{
    return request_.excludeAreas();
}
 
void QDeclarativeGeoRouteQuery::setExcludedAreas(const QList<QGeoRectangle> &value)
{
    if (request_.excludeAreas() == value)
        return;
 
    request_.setExcludeAreas(value);
 
    if (complete_) {
        emit excludedAreasChanged();
        emit queryDetailsChanged();
    }
}
 
void QDeclarativeGeoRouteQuery::addExcludedArea(const QGeoRectangle &area)
{
    if (!area.isValid())
        return;
 
    QList<QGeoRectangle> excludedAreas = request_.excludeAreas();
 
    if (excludedAreas.contains(area))
        return;
 
    excludedAreas.append(area);
 
    request_.setExcludeAreas(excludedAreas);
 
    if (complete_) {
        emit excludedAreasChanged();
        emit queryDetailsChanged();
    }
}
 
void QDeclarativeGeoRouteQuery::removeExcludedArea(const QGeoRectangle &area)
{
    if (!area.isValid())
        return;
 
    QList<QGeoRectangle> excludedAreas = request_.excludeAreas();
 
    int index = excludedAreas.lastIndexOf(area);
    if (index == -1) {
        qmlWarning(this) << QStringLiteral("Cannot remove nonexistent area.");
        return;
    }
    excludedAreas.removeAt(index);
    request_.setExcludeAreas(excludedAreas);
 
    if (complete_) {
        emit excludedAreasChanged();
        emit queryDetailsChanged();
    }
}
 
void QDeclarativeGeoRouteQuery::clearExcludedAreas()
{
    if (request_.excludeAreas().isEmpty())
        return;
 
    request_.setExcludeAreas(QList<QGeoRectangle>());
 
    if (complete_) {
        emit excludedAreasChanged();
        emit queryDetailsChanged();
    }
}
 
void QDeclarativeGeoRouteQuery::addWaypoint(const QGeoCoordinate &waypoint)
{
    if (!waypoint.isValid()) {
        qmlWarning(this) << QStringLiteral("Invalid coordinate as waypoint");
        return;
    }
 
    m_waypoints << waypoint;
    waypointChanged();
}
 
void QDeclarativeGeoRouteQuery::removeWaypoint(const QGeoCoordinate &waypoint)
{
    if (!waypoint.isValid()) {
        qmlWarning(this) << QStringLiteral("Invalid coordinate as waypoint");
        return;
    }
 
    if (qsizetype idx = m_waypoints.lastIndexOf(waypoint); idx >= 0) {
        m_waypoints.remove(idx);
        waypointChanged();
    } else {
        qmlWarning(this) << QStringLiteral("Cannot remove nonexistent waypoint.");
    }
}
 
void QDeclarativeGeoRouteQuery::clearWaypoints()
{
    if (m_waypoints.isEmpty())
        return;
 
    m_waypoints.clear();
    waypointChanged();
}
 
void QDeclarativeGeoRouteQuery::setFeatureWeight(FeatureType featureType, FeatureWeight featureWeight)
{
    if (featureType == NoFeature && !request_.featureTypes().isEmpty()) {
        resetFeatureWeights();
        return;
    }
 
    // Check if the weight changes, as we need to signal it
    FeatureWeight originalWeight = static_cast<FeatureWeight>(request_.featureWeight(static_cast<QGeoRouteRequest::FeatureType>(featureType)));
    if (featureWeight == originalWeight)
        return;
 
    request_.setFeatureWeight(static_cast<QGeoRouteRequest::FeatureType>(featureType),
                              static_cast<QGeoRouteRequest::FeatureWeight>(featureWeight));
    if (complete_ && ((originalWeight == NeutralFeatureWeight) || (featureWeight == NeutralFeatureWeight))) {
        // featureTypes should now give a different list, because the original and new weight
        // were not same, and other one was neutral weight
        emit featureTypesChanged();
        emit queryDetailsChanged();
    }
}
 
void QDeclarativeGeoRouteQuery::resetFeatureWeights()
{
    // reset all feature types.
    const auto featureTypes = request_.featureTypes();
    for (const auto &featureType : featureTypes)
        request_.setFeatureWeight(featureType, QGeoRouteRequest::NeutralFeatureWeight);
    if (complete_) {
        emit featureTypesChanged();
        emit queryDetailsChanged();
    }
}
 
int QDeclarativeGeoRouteQuery::featureWeight(FeatureType featureType)
{
    return request_.featureWeight(static_cast<QGeoRouteRequest::FeatureType>(featureType));
}
 
void QDeclarativeGeoRouteQuery::setTravelModes(QDeclarativeGeoRouteQuery::TravelModes travelModes)
{
    QGeoRouteRequest::TravelModes reqTravelModes;
 
    if (travelModes & QDeclarativeGeoRouteQuery::CarTravel)
        reqTravelModes |= QGeoRouteRequest::CarTravel;
    if (travelModes & QDeclarativeGeoRouteQuery::PedestrianTravel)
        reqTravelModes |= QGeoRouteRequest::PedestrianTravel;
    if (travelModes & QDeclarativeGeoRouteQuery::BicycleTravel)
        reqTravelModes |= QGeoRouteRequest::BicycleTravel;
    if (travelModes & QDeclarativeGeoRouteQuery::PublicTransitTravel)
        reqTravelModes |= QGeoRouteRequest::PublicTransitTravel;
    if (travelModes & QDeclarativeGeoRouteQuery::TruckTravel)
        reqTravelModes |= QGeoRouteRequest::TruckTravel;
 
    if (reqTravelModes == request_.travelModes())
        return;
 
    request_.setTravelModes(reqTravelModes);
 
    if (complete_) {
        emit travelModesChanged();
        emit queryDetailsChanged();
    }
}
 
 
void QDeclarativeGeoRouteQuery::setSegmentDetail(SegmentDetail segmentDetail)
{
    if (static_cast<QGeoRouteRequest::SegmentDetail>(segmentDetail) == request_.segmentDetail())
        return;
    request_.setSegmentDetail(static_cast<QGeoRouteRequest::SegmentDetail>(segmentDetail));
    if (complete_) {
        emit segmentDetailChanged();
        emit queryDetailsChanged();
    }
}
 
QDeclarativeGeoRouteQuery::SegmentDetail QDeclarativeGeoRouteQuery::segmentDetail() const
{
    return static_cast<QDeclarativeGeoRouteQuery::SegmentDetail>(request_.segmentDetail());
}
 
void QDeclarativeGeoRouteQuery::setManeuverDetail(ManeuverDetail maneuverDetail)
{
    if (static_cast<QGeoRouteRequest::ManeuverDetail>(maneuverDetail) == request_.maneuverDetail())
        return;
    request_.setManeuverDetail(static_cast<QGeoRouteRequest::ManeuverDetail>(maneuverDetail));
    if (complete_) {
        emit maneuverDetailChanged();
        emit queryDetailsChanged();
    }
}
 
QDeclarativeGeoRouteQuery::ManeuverDetail QDeclarativeGeoRouteQuery::maneuverDetail() const
{
    return static_cast<QDeclarativeGeoRouteQuery::ManeuverDetail>(request_.maneuverDetail());
}
 
QDeclarativeGeoRouteQuery::TravelModes QDeclarativeGeoRouteQuery::travelModes() const
{
    QGeoRouteRequest::TravelModes reqTravelModes = request_.travelModes();
    QDeclarativeGeoRouteQuery::TravelModes travelModes;
 
    if (reqTravelModes & QGeoRouteRequest::CarTravel)
        travelModes |= QDeclarativeGeoRouteQuery::CarTravel;
    if (reqTravelModes & QGeoRouteRequest::PedestrianTravel)
        travelModes |= QDeclarativeGeoRouteQuery::PedestrianTravel;
    if (reqTravelModes & QGeoRouteRequest::BicycleTravel)
        travelModes |= QDeclarativeGeoRouteQuery::BicycleTravel;
    if (reqTravelModes & QGeoRouteRequest::PublicTransitTravel)
        travelModes |= QDeclarativeGeoRouteQuery::PublicTransitTravel;
    if (reqTravelModes & QGeoRouteRequest::TruckTravel)
        travelModes |= QDeclarativeGeoRouteQuery::TruckTravel;
 
    return travelModes;
}
 
QDeclarativeGeoRouteQuery::RouteOptimizations QDeclarativeGeoRouteQuery::routeOptimizations() const
{
    QGeoRouteRequest::RouteOptimizations reqOptimizations = request_.routeOptimization();
    QDeclarativeGeoRouteQuery::RouteOptimizations optimization;
 
    if (reqOptimizations & QGeoRouteRequest::ShortestRoute)
        optimization |= QDeclarativeGeoRouteQuery::ShortestRoute;
    if (reqOptimizations & QGeoRouteRequest::FastestRoute)
        optimization |= QDeclarativeGeoRouteQuery::FastestRoute;
    if (reqOptimizations & QGeoRouteRequest::MostEconomicRoute)
        optimization |= QDeclarativeGeoRouteQuery::MostEconomicRoute;
    if (reqOptimizations & QGeoRouteRequest::MostScenicRoute)
        optimization |= QDeclarativeGeoRouteQuery::MostScenicRoute;
 
    return optimization;
}
 
void QDeclarativeGeoRouteQuery::setDepartureTime(const QDateTime &departureTime)
{
    if (departureTime == request_.departureTime())
        return;
 
    request_.setDepartureTime(departureTime);
    if (complete_) {
        emit departureTimeChanged();
        emit queryDetailsChanged();
    }
}
 
QDateTime QDeclarativeGeoRouteQuery::departureTime() const
{
    return request_.departureTime();
}
 
void QDeclarativeGeoRouteQuery::setRouteOptimizations(QDeclarativeGeoRouteQuery::RouteOptimizations optimization)
{
    QGeoRouteRequest::RouteOptimizations reqOptimizations;
 
    if (optimization & QDeclarativeGeoRouteQuery::ShortestRoute)
        reqOptimizations |= QGeoRouteRequest::ShortestRoute;
    if (optimization & QDeclarativeGeoRouteQuery::FastestRoute)
        reqOptimizations |= QGeoRouteRequest::FastestRoute;
    if (optimization & QDeclarativeGeoRouteQuery::MostEconomicRoute)
        reqOptimizations |= QGeoRouteRequest::MostEconomicRoute;
    if (optimization & QDeclarativeGeoRouteQuery::MostScenicRoute)
        reqOptimizations |= QGeoRouteRequest::MostScenicRoute;
 
    if (reqOptimizations == request_.routeOptimization())
        return;
 
    request_.setRouteOptimization(reqOptimizations);
 
    if (complete_) {
        emit routeOptimizationsChanged();
        emit queryDetailsChanged();
    }
}
 
QGeoRouteRequest QDeclarativeGeoRouteQuery::routeRequest() const
{
    if (m_waypointsChanged) {
        m_waypointsChanged = false;
        // Update waypoints and metadata into request
        request_.setWaypoints(m_waypoints);
    }
    return request_;
}
 
void QDeclarativeGeoRouteQuery::excludedAreaCoordinateChanged()
{
    if (!m_excludedAreaCoordinateChanged) {
        m_excludedAreaCoordinateChanged = true;
        QMetaObject::invokeMethod(this, "doCoordinateChanged", Qt::QueuedConnection);
    }
}
 
void QDeclarativeGeoRouteQuery::waypointChanged()
{
    m_waypointsChanged = true;
    if (complete_) {
        emit waypointsChanged();
        emit queryDetailsChanged();
    }
}
 
void QDeclarativeGeoRouteQuery::doCoordinateChanged()
{
    m_excludedAreaCoordinateChanged = false;
    if (complete_)
        emit queryDetailsChanged();
}
 
QT_END_NAMESPACE