Revision control
++ // Copyright (C) 2017 Mapbox, Inc.
++ // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
++
++ #include "qplacemanagerenginemapbox.h"
++ #include "qplacesearchreplymapbox.h"
++ #include "qplacesearchsuggestionreplymapbox.h"
++ #include "qplacecategoriesreplymapbox.h"
++ #include "qmapboxcommon.h"
++
++ #include <QtCore/QUrlQuery>
++ #include <QtCore/QXmlStreamReader>
++ #include <QtCore/QRegularExpression>
++ #include <QtNetwork/QNetworkAccessManager>
++ #include <QtNetwork/QNetworkRequest>
++ #include <QtNetwork/QNetworkReply>
++ #include <QtPositioning/QGeoCircle>
++ #include <QtLocation/QPlaceCategory>
++ #include <QtLocation/QPlaceSearchRequest>
++ #include <QtLocation/private/unsupportedreplies_p.h>
++
++ #include <QtCore/QElapsedTimer>
++
++ namespace {
++
++ static const QStringList categories = QStringList()
++ << QStringLiteral("bakery")
++ << QStringLiteral("bank")
++ << QStringLiteral("bar")
++ << QStringLiteral("cafe")
++ << QStringLiteral("church")
++ << QStringLiteral("cinema")
++ << QStringLiteral("coffee")
++ << QStringLiteral("concert")
++ << QStringLiteral("fast food")
++ << QStringLiteral("finance")
++ << QStringLiteral("gallery")
++ << QStringLiteral("historic")
++ << QStringLiteral("hotel")
++ << QStringLiteral("landmark")
++ << QStringLiteral("museum")
++ << QStringLiteral("music")
++ << QStringLiteral("park")
++ << QStringLiteral("pizza")
++ << QStringLiteral("restaurant")
++ << QStringLiteral("retail")
++ << QStringLiteral("school")
++ << QStringLiteral("shop")
++ << QStringLiteral("tea")
++ << QStringLiteral("theater")
++ << QStringLiteral("university");
++
++ } // namespace
++
++ // Mapbox API does not provide support for paginated place queries. This
++ // implementation is a wrapper around its Geocoding service:
++ QPlaceManagerEngineMapbox::QPlaceManagerEngineMapbox(const QVariantMap ¶meters, QGeoServiceProvider::Error *error, QString *errorString)
++ : QPlaceManagerEngine(parameters), m_networkManager(new QNetworkAccessManager(this))
++ {
++ if (parameters.contains(QStringLiteral("mapbox.useragent")))
++ m_userAgent = parameters.value(QStringLiteral("mapbox.useragent")).toString().toLatin1();
++ else
++ m_userAgent = mapboxDefaultUserAgent;
++
++ m_accessToken = parameters.value(QStringLiteral("mapbox.access_token")).toString();
++
++ m_isEnterprise = parameters.value(QStringLiteral("mapbox.enterprise")).toBool();
++ m_urlPrefix = m_isEnterprise ? mapboxGeocodingEnterpriseApiPath : mapboxGeocodingApiPath;
++
++ *error = QGeoServiceProvider::NoError;
++ errorString->clear();
++ }
++
++ QPlaceManagerEngineMapbox::~QPlaceManagerEngineMapbox()
++ {
++ }
++
++ QPlaceSearchReply *QPlaceManagerEngineMapbox::search(const QPlaceSearchRequest &request)
++ {
++ return qobject_cast<QPlaceSearchReply *>(doSearch(request, PlaceSearchType::CompleteSearch));
++ }
++
++ QPlaceSearchSuggestionReply *QPlaceManagerEngineMapbox::searchSuggestions(const QPlaceSearchRequest &request)
++ {
++ return qobject_cast<QPlaceSearchSuggestionReply *>(doSearch(request, PlaceSearchType::SuggestionSearch));
++ }
++
++ QPlaceReply *QPlaceManagerEngineMapbox::doSearch(const QPlaceSearchRequest &request, PlaceSearchType searchType)
++ {
++ const QGeoShape searchArea = request.searchArea();
++ const QString searchTerm = request.searchTerm();
++ const QString recommendationId = request.recommendationId();
++ const QList<QPlaceCategory> placeCategories = request.categories();
++
++ bool invalidRequest = false;
++
++ // QLocation::DeviceVisibility is not allowed for non-enterprise accounts.
++ if (!m_isEnterprise)
++ invalidRequest |= request.visibilityScope().testFlag(QLocation::DeviceVisibility);
++
++ // Must provide either a search term, categories or recommendation.
++ invalidRequest |= searchTerm.isEmpty() && placeCategories.isEmpty() && recommendationId.isEmpty();
++
++ // Category search must not provide recommendation, and vice-versa.
++ invalidRequest |= searchTerm.isEmpty() && !placeCategories.isEmpty() && !recommendationId.isEmpty();
++
++ if (invalidRequest) {
++ QPlaceReply *reply;
++ if (searchType == PlaceSearchType::CompleteSearch)
++ reply = new QPlaceSearchReplyMapbox(request, 0, this);
++ else
++ reply = new QPlaceSearchSuggestionReplyMapbox(0, this);
++
++ connect(reply, &QPlaceReply::finished,
++ this, &QPlaceManagerEngineMapbox::onReplyFinished);
++ connect(reply, &QPlaceReply::errorOccurred,
++ this, &QPlaceManagerEngineMapbox::onReplyError);
++
++ QMetaObject::invokeMethod(reply, "setError", Qt::QueuedConnection,
++ Q_ARG(QPlaceReply::Error, QPlaceReply::BadArgumentError),
++ Q_ARG(QString, "Invalid request."));
++
++ return reply;
++ }
++
++ QString queryString;
++ if (!searchTerm.isEmpty()) {
++ queryString = searchTerm;
++ } else if (!recommendationId.isEmpty()) {
++ queryString = recommendationId;
++ } else {
++ QStringList similarIds;
++ for (const QPlaceCategory &placeCategory : placeCategories)
++ similarIds.append(placeCategory.categoryId());
++ queryString = similarIds.join(QLatin1Char(','));
++ }
++ queryString.append(QStringLiteral(".json"));
++
++ QUrl requestUrl(m_urlPrefix + queryString);
++
++ QUrlQuery queryItems;
++ queryItems.addQueryItem(QStringLiteral("access_token"), m_accessToken);
++
++ // XXX: Investigate situations where we need to filter by 'country'.
++
++ QStringList languageCodes;
++ for (const QLocale& locale: std::as_const(m_locales)) {
++ // Returns the language and country of this locale as a string of the
++ // form "language_country", where language is a lowercase, two-letter
++ // ISO 639 language code, and country is an uppercase, two- or
++ // three-letter ISO 3166 country code.
++
++ if (locale.language() == QLocale::C)
++ continue;
++
++ const QString languageCode = locale.name().section(QLatin1Char('_'), 0, 0);
++ if (!languageCodes.contains(languageCode))
++ languageCodes.append(languageCode);
++ }
++
++ if (!languageCodes.isEmpty())
++ queryItems.addQueryItem(QStringLiteral("language"), languageCodes.join(QLatin1Char(',')));
++
++ if (searchArea.type() != QGeoShape::UnknownType) {
++ const QGeoCoordinate center = searchArea.center();
++ queryItems.addQueryItem(QStringLiteral("proximity"),
++ QString::number(center.longitude()) + QLatin1Char(',') + QString::number(center.latitude()));
++ }
++
++ queryItems.addQueryItem(QStringLiteral("type"), QStringLiteral("poi"));
++
++ // XXX: Investigate situations where 'autocomplete' should be disabled.
++
++ QGeoRectangle boundingBox = searchArea.boundingGeoRectangle();
++ if (!boundingBox.isEmpty()) {
++ queryItems.addQueryItem(QStringLiteral("bbox"),
++ QString::number(boundingBox.topLeft().longitude()) + QLatin1Char(',') +
++ QString::number(boundingBox.bottomRight().latitude()) + QLatin1Char(',') +
++ QString::number(boundingBox.bottomRight().longitude()) + QLatin1Char(',') +
++ QString::number(boundingBox.topLeft().latitude()));
++ }
++
++ if (request.limit() > 0)
++ queryItems.addQueryItem(QStringLiteral("limit"), QString::number(request.limit()));
++
++ // XXX: Investigate searchContext() use cases.
++
++ requestUrl.setQuery(queryItems);
++
++ QNetworkRequest networkRequest(requestUrl);
++ networkRequest.setHeader(QNetworkRequest::UserAgentHeader, m_userAgent);
++
++ QNetworkReply *networkReply = m_networkManager->get(networkRequest);
++ QPlaceReply *reply;
++ if (searchType == PlaceSearchType::CompleteSearch)
++ reply = new QPlaceSearchReplyMapbox(request, networkReply, this);
++ else
++ reply = new QPlaceSearchSuggestionReplyMapbox(networkReply, this);
++
++ connect(reply, &QPlaceReply::finished,
++ this, &QPlaceManagerEngineMapbox::onReplyFinished);
++ connect(reply, &QPlaceReply::errorOccurred,
++ this, &QPlaceManagerEngineMapbox::onReplyError);
++
++ return reply;
++ }
++
++ QPlaceReply *QPlaceManagerEngineMapbox::initializeCategories()
++ {
++ if (m_categories.isEmpty()) {
++ for (const QString &categoryId : categories) {
++ QPlaceCategory category;
++ category.setName(QMapboxCommon::mapboxNameForCategory(categoryId));
++ category.setCategoryId(categoryId);
++ category.setVisibility(QLocation::PublicVisibility);
++ m_categories[categoryId] = category;
++ }
++ }
++
++ QPlaceCategoriesReplyMapbox *reply = new QPlaceCategoriesReplyMapbox(this);
++ connect(reply, &QPlaceReply::finished,
++ this, &QPlaceManagerEngineMapbox::onReplyFinished);
++ connect(reply, &QPlaceReply::errorOccurred,
++ this, &QPlaceManagerEngineMapbox::onReplyError);
++
++ // Queue a future finished() emission from the reply.
++ QMetaObject::invokeMethod(reply, "finish", Qt::QueuedConnection);
++
++ return reply;
++ }
++
++ QString QPlaceManagerEngineMapbox::parentCategoryId(const QString &categoryId) const
++ {
++ Q_UNUSED(categoryId);
++
++ // Only a single category level.
++ return QString();
++ }
++
++ QStringList QPlaceManagerEngineMapbox::childCategoryIds(const QString &categoryId) const
++ {
++ // Only a single category level.
++ if (categoryId.isEmpty())
++ return m_categories.keys();
++
++ return QStringList();
++ }
++
++ QPlaceCategory QPlaceManagerEngineMapbox::category(const QString &categoryId) const
++ {
++ return m_categories.value(categoryId);
++ }
++
++ QList<QPlaceCategory> QPlaceManagerEngineMapbox::childCategories(const QString &parentId) const
++ {
++ // Only a single category level.
++ if (parentId.isEmpty())
++ return m_categories.values();
++
++ return QList<QPlaceCategory>();
++ }
++
++ QList<QLocale> QPlaceManagerEngineMapbox::locales() const
++ {
++ return m_locales;
++ }
++
++ void QPlaceManagerEngineMapbox::setLocales(const QList<QLocale> &locales)
++ {
++ m_locales = locales;
++ }
++
++ void QPlaceManagerEngineMapbox::onReplyFinished()
++ {
++ QPlaceReply *reply = qobject_cast<QPlaceReply *>(sender());
++ if (reply)
++ emit finished(reply);
++ }
++
++ void QPlaceManagerEngineMapbox::onReplyError(QPlaceReply::Error errorCode, const QString &errorString)
++ {
++ QPlaceReply *reply = qobject_cast<QPlaceReply *>(sender());
++ if (reply)
++ emit errorOccurred(reply, errorCode, errorString);
++ }