qgeoserviceprovider.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 "qgeoserviceprovider.h"
#include "qgeoserviceprovider_p.h"
#include "qgeoserviceproviderfactory.h"
 
#include "qgeocodingmanager.h"
#include "qgeomappingmanager_p.h"
#include "qgeoroutingmanager.h"
#include "qplacemanager.h"
#include "qgeocodingmanagerengine.h"
#include "qgeomappingmanagerengine_p.h"
#include "qgeoroutingmanagerengine.h"
#include "qplacemanagerengine.h"
#include "qplacemanagerengine_p.h"
 
#include <QList>
#include <QString>
#include <QVariant>
#include <QCborArray>
 
#include <QDebug>
#include <QStringList>
#include <QCoreApplication>
#include <QObject>
#include <QMetaObject>
#include <QMetaEnum>
#include <QtCore/private/qfactoryloader_p.h>
 
QT_BEGIN_NAMESPACE
 
Q_GLOBAL_STATIC_WITH_ARGS(QFactoryLoader, loader,
        ("org.qt-project.qt.geoservice.serviceproviderfactory/6.0",
         QLatin1String("/geoservices")))
 
 
QStringList QGeoServiceProvider::availableServiceProviders()
{
    return QGeoServiceProviderPrivate::plugins().keys();
}
 
QGeoServiceProvider::QGeoServiceProvider(const QString &providerName,
                                         const QVariantMap &parameters,
                                         bool allowExperimental)
    : d_ptr(new QGeoServiceProviderPrivate())
{
    d_ptr->experimental = allowExperimental;
    d_ptr->parameterMap = parameters;
    // TODO Qt 6 Remove silent nokia rename
    if (providerName == QStringLiteral("nokia"))
        d_ptr->providerName = QStringLiteral("here");
    else
        d_ptr->providerName = providerName;
    d_ptr->loadMeta();
}
 
QGeoServiceProvider::~QGeoServiceProvider()
{
    delete d_ptr;
}
 
/* Template for the routingFeatures(), geocodingFeatures() etc methods.
 * Ideally, the enumName would be a template parameter, but strings
 * are not a valid const expr. :( */
template <class Flags>
Flags QGeoServiceProviderPrivate::features(const char *enumName) const
{
    const QMetaObject *mo = &QGeoServiceProvider::staticMetaObject;
    const QMetaEnum en = mo->enumerator(
                mo->indexOfEnumerator(enumName));
 
    /* We need the typename keyword here, or Flags::enum_type will be parsed
     * as a non-type and lead to an error */
    Flags ret = typename Flags::enum_type(0);
    if (this->metaData.contains(QStringLiteral("Features"))
            && this->metaData.value(QStringLiteral("Features")).isArray()) {
        const QCborArray features = this->metaData.value(QStringLiteral("Features")).toArray();
        for (const QCborValueConstRef v : features) {
            int val = en.keyToValue(v.toString().toLatin1().constData());
            if (v.isString() && val != -1) {
                ret |= typename Flags::enum_type(val);
            }
        }
    }
 
    return ret;
}
 
QGeoServiceProvider::RoutingFeatures QGeoServiceProvider::routingFeatures() const
{
    return d_ptr->features<RoutingFeatures>("RoutingFeatures");
}
 
QGeoServiceProvider::GeocodingFeatures QGeoServiceProvider::geocodingFeatures() const
{
    return d_ptr->features<GeocodingFeatures>("GeocodingFeatures");
}
 
QGeoServiceProvider::MappingFeatures QGeoServiceProvider::mappingFeatures() const
{
    return d_ptr->features<MappingFeatures>("MappingFeatures");
}
 
QGeoServiceProvider::PlacesFeatures QGeoServiceProvider::placesFeatures() const
{
    return d_ptr->features<PlacesFeatures>("PlacesFeatures");
}
 
QGeoServiceProvider::NavigationFeatures QGeoServiceProvider::navigationFeatures() const
{
    return d_ptr->features<NavigationFeatures>("NavigationFeatures");
}
 
/* Sadly, these are necessary to figure out which of the factory->createX
 * methods we need to call. Ideally it would be nice to find a way to embed
 * these into the manager() template. */
template <class Engine>
Engine *createEngine(QGeoServiceProviderPrivate *)
{
    return nullptr;
}
template <> QGeoCodingManagerEngine *createEngine<QGeoCodingManagerEngine>(QGeoServiceProviderPrivate *d_ptr)
{
    return d_ptr->factory->createGeocodingManagerEngine(d_ptr->cleanedParameterMap, &(d_ptr->geocodeError), &(d_ptr->geocodeErrorString));
}
template <> QGeoRoutingManagerEngine *createEngine<QGeoRoutingManagerEngine>(QGeoServiceProviderPrivate *d_ptr)
{
    return d_ptr->factory->createRoutingManagerEngine(d_ptr->cleanedParameterMap, &(d_ptr->routingError), &(d_ptr->routingErrorString));
}
template <> QGeoMappingManagerEngine *createEngine<QGeoMappingManagerEngine>(QGeoServiceProviderPrivate *d_ptr)
{
    return d_ptr->factory->createMappingManagerEngine(d_ptr->cleanedParameterMap, &(d_ptr->mappingError), &(d_ptr->mappingErrorString));
}
template <> QPlaceManagerEngine *createEngine<QPlaceManagerEngine>(QGeoServiceProviderPrivate *d_ptr)
{
    return d_ptr->factory->createPlaceManagerEngine(d_ptr->cleanedParameterMap, &(d_ptr->placeError), &(d_ptr->placeErrorString));
}
 
/* Template for generating the code for each of the geocodingManager(),
 * mappingManager() etc methods */
template <class Manager, class Engine>
Manager *QGeoServiceProviderPrivate::manager(QGeoServiceProvider::Error *_error,
                                             QString *_errorString)
{
    // make local references just so this method is easier to read
    QGeoServiceProvider::Error &error = *_error;
    QString &errorString = *_errorString;
    Manager *manager = nullptr;
 
    if (!factory) {
        filterParameterMap();
        loadPlugin(this->parameterMap);
    }
 
    if (!factory) {
        error = this->error;
        errorString = this->errorString;
        return nullptr;
    }
 
    if (!manager) {
        Engine *engine = createEngine<Engine>(this); // this sets the specific error variables directly,
                                                     // from now on the local error, errorString refs should be set.
 
        if (engine) {
            engine->setManagerName(
                        metaData.value(QStringLiteral("Provider")).toString());
            engine->setManagerVersion(
                        int(metaData.value(QStringLiteral("Version")).toDouble()));
            manager = new Manager(engine);
        } else if (error == QGeoServiceProvider::NoError) {
            error = QGeoServiceProvider::NotSupportedError;
            errorString = QLatin1String("The service provider does not support the %1 type.")
                                      .arg(QLatin1String(Manager::staticMetaObject.className()));
        }
 
        if (error != QGeoServiceProvider::NoError) {
            delete manager;
            manager = nullptr;
            this->error = error;
            this->errorString = errorString;
        }
 
        if (manager && localeSet)
            manager->setLocale(locale);
    }
 
    if (manager) {
        this->error = QGeoServiceProvider::NoError;
        this->errorString.clear();
    }
 
    return manager;
}
 
QGeoCodingManager *QGeoServiceProvider::geocodingManager() const
{
    if (!d_ptr->geocodingManager) {
        d_ptr->geocodingManager.reset(d_ptr->manager<QGeoCodingManager, QGeoCodingManagerEngine>(
               &(d_ptr->geocodeError), &(d_ptr->geocodeErrorString)));
        if (!d_ptr->geocodingManager)
            qDebug() << d_ptr->error << ", " << d_ptr->errorString;
    }
    return d_ptr->geocodingManager.get();
}
 
QGeoMappingManager *QGeoServiceProvider::mappingManager() const
{
    if (!d_ptr->mappingManager) {
        d_ptr->mappingManager.reset(d_ptr->manager<QGeoMappingManager, QGeoMappingManagerEngine>(
                &(d_ptr->mappingError), &(d_ptr->mappingErrorString)));
        if (!d_ptr->mappingManager)
            qDebug() << d_ptr->error << ", " << d_ptr->errorString;
    }
    return d_ptr->mappingManager.get();
}
 
QGeoRoutingManager *QGeoServiceProvider::routingManager() const
{
    if (!d_ptr->routingManager) {
        d_ptr->routingManager.reset(d_ptr->manager<QGeoRoutingManager, QGeoRoutingManagerEngine>(
                &(d_ptr->routingError), &(d_ptr->routingErrorString)));
        if (!d_ptr->routingManager)
            qDebug() << d_ptr->error << ", " << d_ptr->errorString;
    }
    return d_ptr->routingManager.get();
}
 
QPlaceManager *QGeoServiceProvider::placeManager() const
{
    if (!d_ptr->placeManager) {
        d_ptr->placeManager.reset(d_ptr->manager<QPlaceManager, QPlaceManagerEngine>(
                &(d_ptr->placeError), &(d_ptr->placeErrorString)));
        if (!d_ptr->placeManager)
            qDebug() << d_ptr->error << ", " << d_ptr->errorString;
    }
    return d_ptr->placeManager.get();
}
 
QGeoServiceProvider::Error QGeoServiceProvider::error() const
{
    return d_ptr->error;
}
 
QString QGeoServiceProvider::errorString() const
{
    return d_ptr->errorString;
}
 
QGeoServiceProvider::Error QGeoServiceProvider::mappingError() const
{
    return d_ptr->mappingError;
}
 
QString QGeoServiceProvider::mappingErrorString() const
{
    return d_ptr->mappingErrorString;
}
 
QGeoServiceProvider::Error QGeoServiceProvider::geocodingError() const
{
    return d_ptr->geocodeError;
}
 
QString QGeoServiceProvider::geocodingErrorString() const
{
    return d_ptr->geocodeErrorString;
}
 
QGeoServiceProvider::Error QGeoServiceProvider::routingError() const
{
    return d_ptr->routingError;
}
 
QString QGeoServiceProvider::routingErrorString() const
{
    return d_ptr->routingErrorString;
}
 
QGeoServiceProvider::Error QGeoServiceProvider::placesError() const
{
    return d_ptr->placeError;
}
 
QString QGeoServiceProvider::placesErrorString() const
{
    return d_ptr->placeErrorString;
}
 
QGeoServiceProvider::Error QGeoServiceProvider::navigationError() const
{
    return d_ptr->navigationError;
}
 
QString QGeoServiceProvider::navigationErrorString() const
{
    return d_ptr->navigationErrorString;
}
 
void QGeoServiceProvider::setAllowExperimental(bool allow)
{
    d_ptr->experimental = allow;
    d_ptr->unload();
    d_ptr->loadMeta();
}
 
void QGeoServiceProvider::setQmlEngine(QQmlEngine *engine)
{
    d_ptr->qmlEngine = engine;
}
 
void QGeoServiceProvider::setParameters(const QVariantMap &parameters)
{
    d_ptr->parameterMap = parameters;
    d_ptr->unload();
    d_ptr->loadMeta();
}
 
void QGeoServiceProvider::setLocale(const QLocale &locale)
{
    d_ptr->locale = locale;
    d_ptr->localeSet = true;
 
    if (d_ptr->geocodingManager)
        d_ptr->geocodingManager->setLocale(locale);
    if (d_ptr->routingManager)
        d_ptr->routingManager->setLocale(locale);
    if (d_ptr->mappingManager)
        d_ptr->mappingManager->setLocale(locale);
    if (d_ptr->placeManager)
        d_ptr->placeManager->setLocale(locale);
}
 
/*******************************************************************************
*******************************************************************************/
 
QGeoServiceProviderPrivate::QGeoServiceProviderPrivate()
{
    metaData.insert(QStringLiteral("index"), -1);
}
 
QGeoServiceProviderPrivate::~QGeoServiceProviderPrivate()
{
}
 
void QGeoServiceProviderPrivate::unload()
{
    geocodingManager.reset();
    routingManager.reset();
    mappingManager.reset();
    placeManager.reset();
 
    factory = nullptr;
    error = QGeoServiceProvider::NoError;
    errorString = QLatin1String("");
    metaData = QCborMap();
    metaData.insert(QStringLiteral("index"), -1);
}
 
/* Filter out any parameter that doesn't match any plugin */
void QGeoServiceProviderPrivate::filterParameterMap()
{
    const auto availablePlugins = QGeoServiceProviderPrivate::plugins();
 
    cleanedParameterMap = parameterMap;
    for (auto it = availablePlugins.keyBegin(), end = availablePlugins.keyEnd(); it != end; ++it) {
        if (*it == providerName) // don't remove parameters for current provider
            continue;
 
        QVariantMap::iterator i = cleanedParameterMap.begin();
        while (i != cleanedParameterMap.end()) {
            // remove every parameter meant for other plugins
            if (i.key().startsWith(QString(*it + QLatin1Char('.'))))
                i = cleanedParameterMap.erase(i);
            else
                ++i;
        }
    }
}
 
void QGeoServiceProviderPrivate::loadMeta()
{
    factory = nullptr;
    metaData = QCborMap();
    metaData.insert(QStringLiteral("index"), -1);
    error = QGeoServiceProvider::NotSupportedError;
    errorString = QString(QLatin1String("The geoservices provider %1 is not supported.")).arg(providerName);
 
    const QList<QCborMap> candidates = QGeoServiceProviderPrivate::plugins().values(providerName);
 
    int versionFound = -1;
    int idx = -1;
 
    // figure out which version of the plugin we want
    // (always latest unless experimental)
    for (qsizetype i = 0; i < candidates.size(); ++i) {
        QCborMap meta = candidates[i];
        if (meta.contains(QStringLiteral("Version"))
                && meta.value(QStringLiteral("Version")).isInteger()
                && meta.contains(QStringLiteral("Experimental"))
                && meta.value(QStringLiteral("Experimental")).isBool()) {
            int ver = int(meta.value(QStringLiteral("Version")).toDouble());
            if (ver > versionFound && !(!experimental && meta.value(QStringLiteral("Experimental")).toBool())) {
                versionFound = ver;
                idx = i;
            }
        }
    }
 
    if (idx != -1) {
        error = QGeoServiceProvider::NoError;
        errorString = QStringLiteral("");
        metaData = candidates[idx];
    }
}
 
void QGeoServiceProviderPrivate::loadPlugin(const QVariantMap &parameters)
{
    Q_UNUSED(parameters);
 
    if (int(metaData.value(QStringLiteral("index")).toDouble()) < 0) {
        error = QGeoServiceProvider::NotSupportedError;
        errorString = QString(QLatin1String("The geoservices provider is not supported."));
        factory = nullptr;
        return;
    }
 
    error = QGeoServiceProvider::NoError;
    errorString = QLatin1String("");
 
    int idx = int(metaData.value(QStringLiteral("index")).toDouble());
 
    // load the actual plugin
    factory = qobject_cast<QGeoServiceProviderFactory *>(loader()->instance(idx));
    if (!factory) {
        error = QGeoServiceProvider::LoaderError;
        errorString = QLatin1String("loader()->instance(idx) failed to return an instance. Set the environment variable QT_DEBUG_PLUGINS to see more details.");
        return;
    }
    factory->setQmlEngine(qmlEngine);
}
 
QMultiHash<QString, QCborMap> QGeoServiceProviderPrivate::plugins(bool reload)
{
    static QMultiHash<QString, QCborMap> plugins;
    static bool alreadyDiscovered = false;
 
    if (reload == true)
        alreadyDiscovered = false;
 
    if (!alreadyDiscovered) {
        loadPluginMetadata(plugins);
        alreadyDiscovered = true;
    }
    return plugins;
}
 
void QGeoServiceProviderPrivate::loadPluginMetadata(QMultiHash<QString, QCborMap> &list)
{
    QFactoryLoader *l = loader();
    const QList<QPluginParsedMetaData> meta = l->metaData();
    for (qsizetype i = 0; i < meta.size(); ++i) {
        QCborMap obj = meta.at(i).value(QtPluginMetaDataKeys::MetaData).toMap();
        obj.insert(QStringLiteral("index"), i);
        list.insert(obj.value(QStringLiteral("Provider")).toString(), obj);
    }
}
 
 
QT_END_NAMESPACE