| /**************************************************************************** |
| ** |
| ** Copyright (C) 2015 The Qt Company Ltd. |
| ** Contact: http://www.qt.io/licensing/ |
| ** |
| ** This file is part of the QtLocation module of the Qt Toolkit. |
| ** |
| ** $QT_BEGIN_LICENSE:LGPL3$ |
| ** Commercial License Usage |
| ** Licensees holding valid commercial Qt licenses may use this file in |
| ** accordance with the commercial license agreement provided with the |
| ** Software or, alternatively, in accordance with the terms contained in |
| ** a written agreement between you and The Qt Company. For licensing terms |
| ** and conditions see http://www.qt.io/terms-conditions. For further |
| ** information use the contact form at http://www.qt.io/contact-us. |
| ** |
| ** GNU Lesser General Public License Usage |
| ** Alternatively, this file may be used under the terms of the GNU Lesser |
| ** General Public License version 3 as published by the Free Software |
| ** Foundation and appearing in the file LICENSE.LGPLv3 included in the |
| ** packaging of this file. Please review the following information to |
| ** ensure the GNU Lesser General Public License version 3 requirements |
| ** will be met: https://www.gnu.org/licenses/lgpl.html. |
| ** |
| ** GNU General Public License Usage |
| ** Alternatively, this file may be used under the terms of the GNU |
| ** General Public License version 2.0 or later as published by the Free |
| ** Software Foundation and appearing in the file LICENSE.GPL included in |
| ** the packaging of this file. Please review the following information to |
| ** ensure the GNU General Public License version 2.0 requirements will be |
| ** met: http://www.gnu.org/licenses/gpl-2.0.html. |
| ** |
| ** $QT_END_LICENSE$ |
| ** |
| ****************************************************************************/ |
| |
| #include "qgeocodejsonparser.h" |
| |
| #include <QtPositioning/QGeoShape> |
| #include <QtPositioning/QGeoRectangle> |
| #include <QtPositioning/QGeoAddress> |
| #include <QtPositioning/QGeoCoordinate> |
| |
| #include <QtCore/QThreadPool> |
| #include <QtCore/QJsonObject> |
| #include <QtCore/QJsonArray> |
| #include <QtCore/QJsonParseError> |
| #include <QtCore/QVariantMap> |
| |
| #include <QtDebug> |
| |
| QT_BEGIN_NAMESPACE |
| |
| namespace { |
| |
| /* |
| Checks that the given Location object contains the information |
| we need and is not malformed in any way. We expect a Location |
| object of the following form: |
| |
| "Location": { |
| "Address": { |
| "AdditionalData": [ |
| { |
| "key": "CountryName", |
| "value": "Australia" |
| }, |
| { |
| "key": "StateName", |
| "value": "New South Wales" |
| } |
| ], |
| "City": "Sydney", |
| "Country": "AUS", |
| "District": "Casula", |
| "Label": "Casula, Sydney, NSW, Australia", |
| "PostalCode": "2170", |
| "State": "NSW" |
| }, |
| "DisplayPosition": { |
| "Latitude": -33.949509999999997, |
| "Longitude": 150.90386000000001 |
| }, |
| "LocationId": "NT_5UQ89lKoiI4DIYbOrIR0-D", |
| "LocationType": "area", |
| "MapReference": { |
| "CityId": "1469266800", |
| "CountryId": "1469256839", |
| "DistrictId": "1469267758", |
| "MapId": "NXAM16130", |
| "MapReleaseDate": "2016-10-05", |
| "MapVersion": "Q1/2016", |
| "ReferenceId": "868383156", |
| "SideOfStreet": "neither", |
| "StateId": "1469256831" |
| }, |
| "MapView": { |
| "BottomRight": { |
| "Latitude": -33.966839999999998, |
| "Longitude": 150.91875999999999 |
| }, |
| "TopLeft": { |
| "Latitude": -33.937440000000002, |
| "Longitude": 150.87457000000001 |
| } |
| } |
| } |
| |
| */ |
| bool checkLocation(const QJsonObject &loc, QString *errorString) |
| { |
| QJsonObject::const_iterator ait = loc.constFind(QLatin1String("Address")); |
| if (ait == loc.constEnd()) { |
| *errorString = QLatin1String("Expected Address element within Location object"); |
| return false; |
| } else if (!ait.value().isObject()) { |
| *errorString = QLatin1String("Expected Address object within Location object"); |
| return false; |
| } |
| |
| QJsonObject::const_iterator dpit = loc.constFind(QLatin1String("DisplayPosition")); |
| if (dpit == loc.constEnd()) { |
| *errorString = QLatin1String("Expected DisplayPosition element within Location object"); |
| return false; |
| } else if (!dpit.value().isObject()) { |
| *errorString = QLatin1String("Expected DisplayPosition object within Location object"); |
| return false; |
| } |
| QJsonObject displayPosition = dpit.value().toObject(); |
| QJsonObject::const_iterator latit = displayPosition.constFind(QLatin1String("Latitude")); |
| if (latit == displayPosition.constEnd()) { |
| *errorString = QLatin1String("Expected Latitude element within Location.DisplayPosition object"); |
| return false; |
| } else if (!latit.value().isDouble()) { |
| *errorString = QLatin1String("Expected Latitude double within Location.DisplayPosition object"); |
| return false; |
| } |
| QJsonObject::const_iterator lonit = displayPosition.constFind(QLatin1String("Longitude")); |
| if (lonit == displayPosition.constEnd()) { |
| *errorString = QLatin1String("Expected Longitude element within Location.DisplayPosition object"); |
| return false; |
| } else if (!lonit.value().isDouble()) { |
| *errorString = QLatin1String("Expected Longitude double within Location.DisplayPosition object"); |
| return false; |
| } |
| |
| QJsonObject::const_iterator mvit = loc.constFind(QLatin1String("MapView")); |
| if (mvit == loc.constEnd()) { |
| *errorString = QLatin1String("Expected MapView element within Location object"); |
| return false; |
| } else if (!mvit.value().isObject()) { |
| *errorString = QLatin1String("Expected MapView object within Location object"); |
| return false; |
| } |
| QJsonObject mapView = mvit.value().toObject(); |
| QJsonObject::const_iterator brit = mapView.constFind(QLatin1String("BottomRight")); |
| if (brit == mapView.constEnd()) { |
| *errorString = QLatin1String("Expected BottomRight element within Location.MapView object"); |
| return false; |
| } else if (!brit.value().isObject()) { |
| *errorString = QLatin1String("Expected BottomRight object within Location.MapView object"); |
| return false; |
| } |
| QJsonObject bottomRight = brit.value().toObject(); |
| QJsonObject::const_iterator brlatit = bottomRight.constFind(QLatin1String("Latitude")); |
| if (brlatit == bottomRight.constEnd()) { |
| *errorString = QLatin1String("Expected Latitude element within Location.MapView.BottomRight object"); |
| return false; |
| } else if (!brlatit.value().isDouble()) { |
| *errorString = QLatin1String("Expected Latitude double within Location.MapView.BottomRight object"); |
| return false; |
| } |
| QJsonObject::const_iterator brlonit = bottomRight.constFind(QLatin1String("Longitude")); |
| if (brlonit == bottomRight.constEnd()) { |
| *errorString = QLatin1String("Expected Longitude element within Location.MapView.BottomRight object"); |
| return false; |
| } else if (!brlonit.value().isDouble()) { |
| *errorString = QLatin1String("Expected Longitude double within Location.MapView.BottomRight object"); |
| return false; |
| } |
| QJsonObject::const_iterator tlit = mapView.constFind(QLatin1String("TopLeft")); |
| if (tlit == mapView.constEnd()) { |
| *errorString = QLatin1String("Expected TopLeft element within Location.MapView object"); |
| return false; |
| } else if (!tlit.value().isObject()) { |
| *errorString = QLatin1String("Expected TopLeft object within Location.MapView object"); |
| return false; |
| } |
| QJsonObject topLeft = tlit.value().toObject(); |
| QJsonObject::const_iterator tllatit = topLeft.constFind(QLatin1String("Latitude")); |
| if (tllatit == topLeft.constEnd()) { |
| *errorString = QLatin1String("Expected Latitude element within Location.MapView.TopLeft object"); |
| return false; |
| } else if (!tllatit.value().isDouble()) { |
| *errorString = QLatin1String("Expected Latitude double within Location.MapView.TopLeft object"); |
| return false; |
| } |
| QJsonObject::const_iterator tllonit = topLeft.constFind(QLatin1String("Longitude")); |
| if (tllonit == bottomRight.constEnd()) { |
| *errorString = QLatin1String("Expected Longitude element within Location.MapView.TopLeft object"); |
| return false; |
| } else if (!tllonit.value().isDouble()) { |
| *errorString = QLatin1String("Expected Longitude double within Location.MapView.TopLeft object"); |
| return false; |
| } |
| |
| return true; |
| } |
| |
| /* |
| Checks that the given document contains the required information |
| and is not malformed in any way. We expect a document like the |
| following: |
| |
| { |
| "Response": { |
| "MetaInfo": { |
| "Timestamp": "2016-10-18T08:42:04.369+0000" |
| }, |
| "View": [ |
| { |
| "ViewId": 0, |
| "_type": "SearchResultsViewType", |
| "Result": [ |
| { |
| "Direction": 72.099999999999994, |
| "Distance": -1885.2, |
| "Location": { |
| // OMITTED FOR BREVITY |
| }, |
| "MatchLevel": "district", |
| "MatchQuality": { |
| "City": 1, |
| "Country": 1, |
| "District": 1, |
| "PostalCode": 1, |
| "State": 1 |
| }, |
| "Relevance": 1 |
| } |
| ] |
| } |
| ] |
| } |
| } |
| */ |
| bool checkDocument(const QJsonDocument &doc, QString *errorString) |
| { |
| if (!doc.isObject()) { |
| *errorString = QLatin1String("Expected JSON document containing object"); |
| return false; |
| } |
| |
| QJsonObject rootObject = doc.object(); |
| QJsonObject::const_iterator it = rootObject.constFind(QLatin1String("Response")); |
| if (it == rootObject.constEnd()) { |
| *errorString = QLatin1String("Expected Response element within root object"); |
| return false; |
| } else if (!it.value().isObject()) { |
| *errorString = QLatin1String("Expected Response object within root object"); |
| return false; |
| } |
| |
| QJsonObject response = it.value().toObject(); |
| QJsonObject::const_iterator rit = response.constFind(QLatin1String("View")); |
| if (rit == response.constEnd()) { |
| *errorString = QLatin1String("Expected View element within Response object"); |
| return false; |
| } else if (!rit.value().isArray()) { |
| *errorString = QLatin1String("Expected View array within Response object"); |
| return false; |
| } |
| |
| QJsonArray view = rit.value().toArray(); |
| Q_FOREACH (const QJsonValue &viewElement, view) { |
| if (!viewElement.isObject()) { |
| *errorString = QLatin1String("Expected View array element to be object"); |
| return false; |
| } |
| |
| QJsonObject viewObject = viewElement.toObject(); |
| QJsonObject::const_iterator voit = viewObject.constFind(QLatin1String("Result")); |
| if (voit == viewObject.constEnd()) { |
| *errorString = QLatin1String("Expected Result element within View array object element"); |
| return false; |
| } else if (!voit.value().isArray()) { |
| *errorString = QLatin1String("Expected Result array within View array object element"); |
| return false; |
| } |
| |
| QJsonArray result = voit.value().toArray(); |
| Q_FOREACH (const QJsonValue &resultElement, result) { |
| if (!resultElement.isObject()) { |
| *errorString = QLatin1String("Expected Result array element to be object"); |
| return false; |
| } |
| |
| QJsonObject resultObject = resultElement.toObject(); |
| QJsonObject::const_iterator roit = resultObject.constFind("Location"); |
| if (roit == resultObject.constEnd()) { |
| *errorString = QLatin1String("Expected Location element in Result array element object"); |
| return false; |
| } else if (!roit.value().isObject()) { |
| *errorString = QLatin1String("Expected Location object in Result array element object"); |
| return false; |
| } |
| |
| QJsonObject location = roit.value().toObject(); |
| if (!checkLocation(location, errorString)) { |
| return false; |
| } |
| } |
| } |
| |
| return true; |
| } |
| |
| bool parseLocation(const QJsonObject &obj, const QGeoShape &bounds, QGeoLocation *loc) |
| { |
| QJsonObject displayPosition = obj.value("DisplayPosition").toObject(); |
| QGeoCoordinate coordinate = QGeoCoordinate(displayPosition.value("Latitude").toDouble(), displayPosition.value("Longitude").toDouble()); |
| if (bounds.isValid() && !bounds.contains(coordinate)) { |
| // manual bounds check failed, location can be omitted from results. |
| return false; |
| } |
| |
| QGeoAddress address; |
| QJsonObject addr = obj.value("Address").toObject(); |
| address.setCountryCode(addr.value("Country").toString()); |
| address.setState(addr.value("State").toString()); |
| address.setCounty(addr.value("County").toString()); |
| address.setCity(addr.value("City").toString()); |
| address.setDistrict(addr.value("District").toString()); |
| QString houseNumber = addr.value("HouseNumber").toString(); |
| QString street = addr.value("Street").toString(); |
| address.setStreet(houseNumber.isEmpty() ? street : QString("%1 %2").arg(houseNumber, street)); |
| address.setPostalCode(addr.value("PostalCode").toString()); |
| QString label = addr.value("Label").toString().trimmed(); |
| if (!label.isEmpty()) { |
| address.setText(label); |
| } |
| QJsonArray additionalData = addr.value("AdditionalData").toArray(); |
| Q_FOREACH (const QJsonValue &adv, additionalData) { |
| if (adv.isObject()) { |
| const QJsonObject &ado(adv.toObject()); |
| if (ado.value("key").toString() == QLatin1String("CountryName")) { |
| address.setCountry(ado.value("value").toString()); |
| } |
| } |
| } |
| |
| QGeoRectangle boundingBox; |
| QJsonObject mapView = obj.value("MapView").toObject(); |
| QJsonObject bottomRight = mapView.value("BottomRight").toObject(); |
| QJsonObject topLeft = mapView.value("TopLeft").toObject(); |
| boundingBox.setBottomRight(QGeoCoordinate(bottomRight.value("Latitude").toDouble(), bottomRight.value("Longitude").toDouble())); |
| boundingBox.setTopLeft(QGeoCoordinate(topLeft.value("Latitude").toDouble(), topLeft.value("Longitude").toDouble())); |
| |
| loc->setAddress(address); |
| loc->setCoordinate(coordinate); |
| loc->setBoundingBox(boundingBox); |
| |
| return true; |
| } |
| |
| void parseDocument(const QJsonDocument &doc, const QGeoShape &bounds, QList<QGeoLocation> *locs) |
| { |
| QJsonArray view = doc.object().value("Response").toObject().value("View").toArray(); |
| Q_FOREACH (const QJsonValue &viewElement, view) { |
| QJsonArray result = viewElement.toObject().value("Result").toArray(); |
| Q_FOREACH (const QJsonValue &resultElement, result) { |
| QGeoLocation location; |
| if (parseLocation(resultElement.toObject().value("Location").toObject(), bounds, &location)) { |
| locs->append(location); |
| } |
| } |
| } |
| } |
| |
| } // namespace |
| |
| void QGeoCodeJsonParser::setBounds(const QGeoShape &bounds) |
| { |
| m_bounds = bounds; |
| } |
| |
| void QGeoCodeJsonParser::parse(const QByteArray &data) |
| { |
| m_data = data; |
| QThreadPool::globalInstance()->start(this); |
| } |
| |
| void QGeoCodeJsonParser::run() |
| { |
| // parse the document. |
| QJsonParseError perror; |
| m_document = QJsonDocument::fromJson(m_data, &perror); |
| if (perror.error != QJsonParseError::NoError) { |
| m_errorString = perror.errorString(); |
| } else { |
| // ensure that the response is valid and contains the information we need. |
| if (checkDocument(m_document, &m_errorString)) { |
| // extract the location results from the response. |
| parseDocument(m_document, m_bounds, &m_results); |
| emit results(m_results); |
| return; |
| } |
| } |
| |
| emit error(m_errorString); |
| } |
| |
| QT_END_NAMESPACE |
