Upgraded Nokia Route API from 6.2 to 7.2

Since the 7.2 API supports many more lanugages(23 compared to 4) and is the
only version that supports China it was necessary to upgrade the nokia route
plugin to 7.2.

The major change is that 7.2 does not support multiple mode parameters which
6.2 did. Now if the user selects multiple route optimizations multiple
requests will be made, one for each optimization. Nokia has also reduced
the amount of different route modes, only fastest and shortest are supported
now.

In the response part noting has changed, so no parsing fixes were necessary.

Task-number: QTBUG-24808

Change-Id: I256079f9a1e91e11c961849c95b95b712021ace0
Reviewed-by: Alex Blasche <alexander.blasche@digia.com>

4 files changed, 139 insertions, 104 deletions

diff --git a/src/plugins/geoservices/nokia/qgeoroutereply_nokia.cpp b/src/plugins/geoservices/nokia/qgeoroutereply_nokia.cpp
index 663410ad..2245b208 100644
--- a/src/plugins/geoservices/nokia/qgeoroutereply_nokia.cpp
+++ b/src/plugins/geoservices/nokia/qgeoroutereply_nokia.cpp
@@ -53,42 +53,47 @@
 
 QT_BEGIN_NAMESPACE
 
-QGeoRouteReplyNokia::QGeoRouteReplyNokia(const QGeoRouteRequest &request, QNetworkReply *reply, QObject *parent)
+QGeoRouteReplyNokia::QGeoRouteReplyNokia(const QGeoRouteRequest &request, const QList<QNetworkReply*> &replies, QObject *parent)
         : QGeoRouteReply(request, parent),
-        m_reply(reply)
+        m_replies(replies)
 {
-    connect(m_reply,
-            SIGNAL(finished()),
-            this,
-            SLOT(networkFinished()));
-
-    connect(m_reply,
-            SIGNAL(error(QNetworkReply::NetworkError)),
-            this,
-            SLOT(networkError(QNetworkReply::NetworkError)));
+    foreach (QNetworkReply *reply, m_replies) {
+        connect(reply,
+                SIGNAL(finished()),
+                this,
+                SLOT(networkFinished()));
+
+        connect(reply,
+                SIGNAL(error(QNetworkReply::NetworkError)),
+                this,
+                SLOT(networkError(QNetworkReply::NetworkError)));
+    }
 }
 
 QGeoRouteReplyNokia::~QGeoRouteReplyNokia()
 {
+    abort();
 }
 
 void QGeoRouteReplyNokia::abort()
 {
-    if (!m_reply)
+    if (m_replies.isEmpty())
         return;
 
-    m_reply->abort();
-
-    m_reply->deleteLater();
-    m_reply = 0;
+    foreach (QNetworkReply *reply, m_replies) {
+        reply->abort();
+        reply->deleteLater();
+    }
+    m_replies.clear();
 }
 
 void QGeoRouteReplyNokia::networkFinished()
 {
-    if (!m_reply)
+    QNetworkReply *reply = qobject_cast<QNetworkReply *>(sender());
+    if (!reply)
         return;
 
-    if (m_reply->error() != QNetworkReply::NoError) {
+    if (reply->error() != QNetworkReply::NoError) {
         // Removed because this is already done in networkError, which previously caused _two_ errors to be raised for every error.
         //setError(QGeoRouteReply::CommunicationError, m_reply->errorString());
         //m_reply->deleteLater();
@@ -97,42 +102,44 @@ void QGeoRouteReplyNokia::networkFinished()
     }
 
     QGeoRouteXmlParser parser(request());
-
-    if (parser.parse(m_reply)) {
-        setRoutes(parser.results());
-        setFinished(true);
+    if (parser.parse(reply)) {
+        addRoutes(parser.results());
+        reply->deleteLater();
+        m_replies.removeOne(reply);
+        if (m_replies.isEmpty())
+            setFinished(true);
     } else {
         // add a qWarning with the actual parser.errorString()
         setError(QGeoRouteReply::ParseError, "The response from the service was not in a recognisable format.");
+        abort();
     }
-
-    m_reply->deleteLater();
-    m_reply = 0;
 }
 
 void QGeoRouteReplyNokia::networkError(QNetworkReply::NetworkError error)
 {
     Q_UNUSED(error)
 
-    if (!m_reply)
+    QNetworkReply *reply = qobject_cast<QNetworkReply *>(sender());
+    if (!reply)
         return;
 
     bool resolvedError = false;
-
     if (QNetworkReply::UnknownContentError == error) {
         QGeoRouteXmlParser parser(request());
-        if (parser.parse(m_reply)) {
-            setRoutes(parser.results());
-            setFinished(true);
+        if (parser.parse(reply)) {
+            addRoutes(parser.results());
+            reply->deleteLater();
+            m_replies.removeOne(reply);
             resolvedError = true;
+            if (m_replies.isEmpty())
+                setFinished(true);
         }
     }
 
-    if (!resolvedError)
-        setError(QGeoRouteReply::CommunicationError, m_reply->errorString());
-
-    m_reply->deleteLater();
-    m_reply = 0;
+    if (!resolvedError) {
+        setError(QGeoRouteReply::CommunicationError, reply->errorString());
+        abort();
+    }
 }
 
 QT_END_NAMESPACE
diff --git a/src/plugins/geoservices/nokia/qgeoroutereply_nokia.h b/src/plugins/geoservices/nokia/qgeoroutereply_nokia.h
index b8cb2db3..911e1920 100644
--- a/src/plugins/geoservices/nokia/qgeoroutereply_nokia.h
+++ b/src/plugins/geoservices/nokia/qgeoroutereply_nokia.h
@@ -58,7 +58,7 @@ class QGeoRouteReplyNokia : public QGeoRouteReply
 {
     Q_OBJECT
 public:
-    QGeoRouteReplyNokia(const QGeoRouteRequest &request, QNetworkReply *reply, QObject *parent = 0);
+    QGeoRouteReplyNokia(const QGeoRouteRequest &request, const QList<QNetworkReply*> &replies, QObject *parent = 0);
     ~QGeoRouteReplyNokia();
 
     void abort();
@@ -68,7 +68,7 @@ private Q_SLOTS:
     void networkError(QNetworkReply::NetworkError error);
 
 private:
-    QNetworkReply *m_reply;
+    QList<QNetworkReply*> m_replies;
 };
 
 QT_END_NAMESPACE
diff --git a/src/plugins/geoservices/nokia/qgeoroutingmanagerengine_nokia.cpp b/src/plugins/geoservices/nokia/qgeoroutingmanagerengine_nokia.cpp
index 5ea99027..9bd60155 100644
--- a/src/plugins/geoservices/nokia/qgeoroutingmanagerengine_nokia.cpp
+++ b/src/plugins/geoservices/nokia/qgeoroutingmanagerengine_nokia.cpp
@@ -81,6 +81,7 @@ QGeoRoutingManagerEngineNokia::QGeoRoutingManagerEngineNokia(
     featureTypes |= QGeoRouteRequest::FerryFeature;
     featureTypes |= QGeoRouteRequest::TunnelFeature;
     featureTypes |= QGeoRouteRequest::DirtRoadFeature;
+    featureTypes |= QGeoRouteRequest::ParksFeature;
     setSupportedFeatureTypes(featureTypes);
 
     QGeoRouteRequest::FeatureWeights featureWeights;
@@ -96,14 +97,13 @@ QGeoRoutingManagerEngineNokia::QGeoRoutingManagerEngineNokia(
     QGeoRouteRequest::RouteOptimizations optimizations;
     optimizations |= QGeoRouteRequest::ShortestRoute;
     optimizations |= QGeoRouteRequest::FastestRoute;
-    optimizations |= QGeoRouteRequest::MostEconomicRoute;
-    optimizations |= QGeoRouteRequest::MostScenicRoute;
     setSupportedRouteOptimizations(optimizations);
 
     QGeoRouteRequest::TravelModes travelModes;
     travelModes |= QGeoRouteRequest::CarTravel;
     travelModes |= QGeoRouteRequest::PedestrianTravel;
     travelModes |= QGeoRouteRequest::PublicTransitTravel;
+    travelModes |= QGeoRouteRequest::BicycleTravel;
     setSupportedTravelModes(travelModes);
 
     QGeoRouteRequest::SegmentDetails segmentDetails;
@@ -121,16 +121,19 @@ QGeoRoutingManagerEngineNokia::~QGeoRoutingManagerEngineNokia() {}
 
 QGeoRouteReply *QGeoRoutingManagerEngineNokia::calculateRoute(const QGeoRouteRequest &request)
 {
-    QString reqString = calculateRouteRequestString(request);
+    const QStringList reqStrings = calculateRouteRequestString(request);
 
-    if (reqString.isEmpty()) {
+    if (reqStrings.isEmpty()) {
         QGeoRouteReply *reply = new QGeoRouteReply(QGeoRouteReply::UnsupportedOptionError, "The given route request options are not supported by this service provider.", this);
         emit error(reply, reply->error(), reply->errorString());
         return reply;
     }
 
-    QNetworkReply *networkReply = m_networkManager->get(QNetworkRequest(QUrl(reqString)));
-    QGeoRouteReplyNokia *reply = new QGeoRouteReplyNokia(request, networkReply, this);
+    QList<QNetworkReply*> replies;
+    foreach (const QString &reqString, reqStrings)
+        replies.append(m_networkManager->get(QNetworkRequest(QUrl(reqString))));
+
+    QGeoRouteReplyNokia *reply = new QGeoRouteReplyNokia(request, replies, this);
 
     connect(reply,
             SIGNAL(finished()),
@@ -147,18 +150,21 @@ QGeoRouteReply *QGeoRoutingManagerEngineNokia::calculateRoute(const QGeoRouteReq
 
 QGeoRouteReply *QGeoRoutingManagerEngineNokia::updateRoute(const QGeoRoute &route, const QGeoCoordinate &position)
 {
-    QString reqString = updateRouteRequestString(route, position);
+    const QStringList reqStrings = updateRouteRequestString(route, position);
 
-    if (reqString.isEmpty()) {
+    if (reqStrings.isEmpty()) {
         QGeoRouteReply *reply = new QGeoRouteReply(QGeoRouteReply::UnsupportedOptionError, "The given route request options are not supported by this service provider.", this);
         emit error(reply, reply->error(), reply->errorString());
         return reply;
     }
 
-    QNetworkReply *networkReply = m_networkManager->get(QNetworkRequest(QUrl(reqString)));
+    QList<QNetworkReply*> replies;
+    foreach (const QString &reqString, reqStrings)
+        replies.append(m_networkManager->get(QNetworkRequest(QUrl(reqString))));
+
     QGeoRouteRequest updateRequest(route.request());
     updateRequest.setTravelModes(route.travelMode());
-    QGeoRouteReplyNokia *reply = new QGeoRouteReplyNokia(updateRequest, networkReply, this);
+    QGeoRouteReplyNokia *reply = new QGeoRouteReplyNokia(updateRequest, replies, this);
 
     connect(reply,
             SIGNAL(finished()),
@@ -217,87 +223,100 @@ bool QGeoRoutingManagerEngineNokia::checkEngineSupport(const QGeoRouteRequest &r
     return true;
 }
 
-QString QGeoRoutingManagerEngineNokia::calculateRouteRequestString(const QGeoRouteRequest &request)
+QStringList QGeoRoutingManagerEngineNokia::calculateRouteRequestString(const QGeoRouteRequest &request)
 {
     bool supported = checkEngineSupport(request, request.travelModes());
 
     if (!supported)
-        return QString();
+        return QStringList();
+    QStringList requests;
 
-    QString requestString = QStringLiteral("http://");
-    requestString += m_uriProvider->getCurrentHost();
-    requestString += QStringLiteral("/routing/6.2/calculateroute.xml");
+    QString baseRequest = QStringLiteral("http://");
+    baseRequest += m_uriProvider->getCurrentHost();
+    baseRequest += QStringLiteral("/routing/7.2/calculateroute.xml");
 
-    requestString += QStringLiteral("?alternatives=");
-    requestString += QString::number(request.numberAlternativeRoutes());
+    baseRequest += QStringLiteral("?alternatives=");
+    baseRequest += QString::number(request.numberAlternativeRoutes());
 
     if (!m_appId.isEmpty() && !m_token.isEmpty()) {
-        requestString += QStringLiteral("&app_id=");
-        requestString += m_appId;
-        requestString += QStringLiteral("&token=");
-        requestString += m_token;
+        baseRequest += QStringLiteral("&app_id=");
+        baseRequest += m_appId;
+        baseRequest += QStringLiteral("&token=");
+        baseRequest += m_token;
     }
 
     int numWaypoints = request.waypoints().size();
     if (numWaypoints < 2)
-        return QString();
+        return QStringList();
 
     for (int i = 0;i < numWaypoints;++i) {
-        requestString += QStringLiteral("&waypoint");
-        requestString += QString::number(i);
-        requestString += QStringLiteral("=geo!");
-        requestString += trimDouble(request.waypoints().at(i).latitude());
-        requestString += ",";
-        requestString += trimDouble(request.waypoints().at(i).longitude());
+        baseRequest += QStringLiteral("&waypoint");
+        baseRequest += QString::number(i);
+        baseRequest += QStringLiteral("=geo!");
+        baseRequest += trimDouble(request.waypoints().at(i).latitude());
+        baseRequest += ",";
+        baseRequest += trimDouble(request.waypoints().at(i).longitude());
     }
 
-    requestString += modesRequestString(request, request.travelModes());
-    requestString += routeRequestString(request);
+    QGeoRouteRequest::RouteOptimizations optimization = request.routeOptimization();
 
-    return requestString;
+    QStringList types;
+    if (optimization.testFlag(QGeoRouteRequest::ShortestRoute))
+        types.append("shortest");
+    if (optimization.testFlag(QGeoRouteRequest::FastestRoute))
+        types.append("fastest");
+
+    foreach (const QString &optimization, types) {
+        QString requestString = baseRequest;
+        requestString += modesRequestString(request, request.travelModes(), optimization);
+        requestString += routeRequestString(request);
+        requests << requestString;
+    }
+
+    return requests;
 }
 
-QString QGeoRoutingManagerEngineNokia::updateRouteRequestString(const QGeoRoute &route, const QGeoCoordinate &position)
+QStringList QGeoRoutingManagerEngineNokia::updateRouteRequestString(const QGeoRoute &route, const QGeoCoordinate &position)
 {
     if (!checkEngineSupport(route.request(), route.travelMode()))
-        return "";
+        return QStringList();
+    QStringList requests;
+
+    QString baseRequest = "http://";
+    baseRequest += m_uriProvider->getCurrentHost();
+    baseRequest += "/routing/7.2/getroute.xml";
 
-    QString requestString = "http://";
-    requestString += m_uriProvider->getCurrentHost();
-    requestString += "/routing/6.2/getroute.xml";
+    baseRequest += "?routeid=";
+    baseRequest += route.routeId();
 
-    requestString += "?routeid=";
-    requestString += route.routeId();
+    baseRequest += "&pos=";
+    baseRequest += QString::number(position.latitude());
+    baseRequest += ",";
+    baseRequest += QString::number(position.longitude());
 
-    requestString += "&pos=";
-    requestString += QString::number(position.latitude());
-    requestString += ",";
-    requestString += QString::number(position.longitude());
+    QGeoRouteRequest::RouteOptimizations optimization = route.request().routeOptimization();
 
-    requestString += modesRequestString(route.request(), route.travelMode());
+    QStringList types;
+    if (optimization.testFlag(QGeoRouteRequest::ShortestRoute))
+        types.append("shortest");
+    if (optimization.testFlag(QGeoRouteRequest::FastestRoute))
+        types.append("fastest");
 
-    requestString += routeRequestString(route.request());
+    foreach (const QString &optimization, types) {
+        QString requestString = baseRequest;
+        requestString += modesRequestString(route.request(), route.travelMode(), optimization);
+        requestString += routeRequestString(route.request());
+        requests << requestString;
+    }
 
-    return requestString;
+    return requests;
 }
 
 QString QGeoRoutingManagerEngineNokia::modesRequestString(const QGeoRouteRequest &request,
-        QGeoRouteRequest::TravelModes travelModes) const
+        QGeoRouteRequest::TravelModes travelModes, const QString &optimization) const
 {
     QString requestString;
 
-    QGeoRouteRequest::RouteOptimizations optimization = request.routeOptimization();
-
-    QStringList types;
-    if (optimization.testFlag(QGeoRouteRequest::ShortestRoute))
-        types.append("shortest");
-    if (optimization.testFlag(QGeoRouteRequest::FastestRoute))
-        types.append("fastestNow");
-    if (optimization.testFlag(QGeoRouteRequest::MostEconomicRoute))
-        types.append("economic");
-    if (optimization.testFlag(QGeoRouteRequest::MostScenicRoute))
-        types.append("scenic");
-
     QStringList modes;
     if (travelModes.testFlag(QGeoRouteRequest::CarTravel))
         modes.append("car");
@@ -358,12 +377,10 @@ QString QGeoRoutingManagerEngineNokia::modesRequestString(const QGeoRouteRequest
         }
     }
 
-    for (int i = 0;i < types.count();++i) {
-        requestString += "&mode" + QString::number(i) + "=";
-        requestString += types[i] + ";" + modes.join(",");
-        if (featureStrings.count())
-            requestString += ";" + featureStrings.join(",");
-    }
+    requestString += "&mode=";
+    requestString += optimization + ";" + modes.join(",");
+    if (featureStrings.count())
+        requestString += ";" + featureStrings.join(",");
     return requestString;
 }
 
@@ -426,9 +443,19 @@ QString QGeoRoutingManagerEngineNokia::routeRequestString(const QGeoRouteRequest
     requestString += "&instructionformat=text";
 
     const QLocale loc(locale());
+
+    requestString += "&metricSystem=";
+    if (QLocale::MetricSystem == loc.measurementSystem())
+        requestString  += "metric";
+    else
+        requestString += "imperial";
+
     if (QLocale::C != loc.language() && QLocale::AnyLanguage != loc.language()) {
         requestString += "&language=";
         requestString += loc.name();
+        //If the first language isn't supported, english will be selected automatically
+        if (QLocale::English != loc.language())
+            requestString += ",en_US";
     }
 
     return requestString;
diff --git a/src/plugins/geoservices/nokia/qgeoroutingmanagerengine_nokia.h b/src/plugins/geoservices/nokia/qgeoroutingmanagerengine_nokia.h
index 34da6200..42a3c939 100644
--- a/src/plugins/geoservices/nokia/qgeoroutingmanagerengine_nokia.h
+++ b/src/plugins/geoservices/nokia/qgeoroutingmanagerengine_nokia.h
@@ -77,13 +77,14 @@ private Q_SLOTS:
     void routeError(QGeoRouteReply::Error error, const QString &errorString);
 
 private:
-    QString calculateRouteRequestString(const QGeoRouteRequest &request);
-    QString updateRouteRequestString(const QGeoRoute &route, const QGeoCoordinate &position);
+    QStringList calculateRouteRequestString(const QGeoRouteRequest &request);
+    QStringList updateRouteRequestString(const QGeoRoute &route, const QGeoCoordinate &position);
     QString routeRequestString(const QGeoRouteRequest &request) const;
     bool checkEngineSupport(const QGeoRouteRequest &request,
                             QGeoRouteRequest::TravelModes travelModes) const;
     QString modesRequestString(const QGeoRouteRequest &request,
-                               QGeoRouteRequest::TravelModes travelModes) const;
+                               QGeoRouteRequest::TravelModes travelModes,
+                               const QString &optimization) const;
     static QString trimDouble(double degree, int decimalDigits = 10);
 
     QGeoNetworkAccessManager *m_networkManager;