qdeclarativegeoserviceprovider.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 "qdeclarativegeoserviceprovider_p.h"
#include <QtQml/QQmlInfo>
#include <QtQml/QQmlEngine>
#include <QLocale>
 
QT_BEGIN_NAMESPACE
 
 
QDeclarativeGeoServiceProvider::QDeclarativeGeoServiceProvider(QObject *parent)
:   QObject(parent), required_(new QDeclarativeGeoServiceProviderRequirements)
{
    locales_.append(QLocale().name());
}
 
QDeclarativeGeoServiceProvider::~QDeclarativeGeoServiceProvider()
{
}
 
 
 
void QDeclarativeGeoServiceProvider::setName(const QString &name)
{
    if (name_ == name)
        return;
 
    name_ = name;
 
    if (complete_)
        tryAttach();
 
    emit nameChanged(name_);
}
 
bool QDeclarativeGeoServiceProvider::parametersReady() {
    for (const QDeclarativePluginParameter *p: std::as_const(parameters_)) {
        if (!p->isInitialized())
            return false;
    }
    return true;
}
 
void QDeclarativeGeoServiceProvider::tryAttach()
{
    if (!parametersReady())
        return;
 
    sharedProvider_.reset();
 
    if (name_.isEmpty())
        return;
 
    sharedProvider_.reset(new QGeoServiceProvider(name_, parameterMap()));
    sharedProvider_->setQmlEngine(qmlEngine(this));
    sharedProvider_->setLocale(QLocale(locales_.at(0)));
    sharedProvider_->setAllowExperimental(experimental_);
 
    emit attached();
}
 
QString QDeclarativeGeoServiceProvider::name() const
{
    return name_;
}
 
 
QStringList QDeclarativeGeoServiceProvider::availableServiceProviders()
{
    return QGeoServiceProvider::availableServiceProviders();
}
 
void QDeclarativeGeoServiceProvider::componentComplete()
{
    complete_ = true;
 
    for (QDeclarativePluginParameter *p: std::as_const(parameters_)) {
        if (!p->isInitialized()) {
            connect(p, &QDeclarativePluginParameter::initialized,
                    this, &QDeclarativeGeoServiceProvider::tryAttach);
        }
    }
 
    if (!name_.isEmpty()) {
        tryAttach();
    } else if (!prefer_.isEmpty()
            || required_->mappingRequirements() != NoMappingFeatures
            || required_->routingRequirements() != NoRoutingFeatures
            || required_->geocodingRequirements() != NoGeocodingFeatures
            || required_->placesRequirements() != NoPlacesFeatures
            || required_->navigationRequirements() != NoNavigationFeatures) {
 
        QStringList providers = QGeoServiceProvider::availableServiceProviders();
 
        /* first check any preferred plugins */
        for (const QString &name : std::as_const(prefer_)) {
            if (providers.contains(name)) {
                // so we don't try it again later
                providers.removeAll(name);
 
                QGeoServiceProvider sp(name, parameterMap(), experimental_);
                if (required_->matches(&sp)) {
                    setName(name);
                    return;
                }
            }
        }
 
        /* then try the rest */
        for (const QString &name : std::as_const(providers)) {
            QGeoServiceProvider sp(name, parameterMap(), experimental_);
            if (required_->matches(&sp)) {
                setName(name);
                return;
            }
        }
 
        qmlWarning(this) << "Could not find a plugin with the required features to attach to";
    }
}
 
bool QDeclarativeGeoServiceProvider::supportsGeocoding(const GeocodingFeatures &feature) const
{
    QGeoServiceProvider *sp = sharedGeoServiceProvider();
    QGeoServiceProvider::GeocodingFeatures f =
            static_cast<QGeoServiceProvider::GeocodingFeature>(int(feature));
    if (f == QGeoServiceProvider::AnyGeocodingFeatures)
        return (sp && (sp->geocodingFeatures() != QGeoServiceProvider::NoGeocodingFeatures));
    else
        return (sp && (sp->geocodingFeatures() & f) == f);
}
 
bool QDeclarativeGeoServiceProvider::supportsMapping(const MappingFeatures &feature) const
{
    QGeoServiceProvider *sp = sharedGeoServiceProvider();
    QGeoServiceProvider::MappingFeatures f =
            static_cast<QGeoServiceProvider::MappingFeature>(int(feature));
    if (f == QGeoServiceProvider::AnyMappingFeatures)
        return (sp && (sp->mappingFeatures() != QGeoServiceProvider::NoMappingFeatures));
    else
        return (sp && (sp->mappingFeatures() & f) == f);
}
 
bool QDeclarativeGeoServiceProvider::supportsRouting(const RoutingFeatures &feature) const
{
    QGeoServiceProvider *sp = sharedGeoServiceProvider();
    QGeoServiceProvider::RoutingFeatures f =
            static_cast<QGeoServiceProvider::RoutingFeature>(int(feature));
    if (f == QGeoServiceProvider::AnyRoutingFeatures)
        return (sp && (sp->routingFeatures() != QGeoServiceProvider::NoRoutingFeatures));
    else
        return (sp && (sp->routingFeatures() & f) == f);
}
 
bool QDeclarativeGeoServiceProvider::supportsPlaces(const PlacesFeatures &feature) const
{
    QGeoServiceProvider *sp = sharedGeoServiceProvider();
    QGeoServiceProvider::PlacesFeatures f =
            static_cast<QGeoServiceProvider::PlacesFeature>(int(feature));
    if (f == QGeoServiceProvider::AnyPlacesFeatures)
        return (sp && (sp->placesFeatures() != QGeoServiceProvider::NoPlacesFeatures));
    else
        return (sp && (sp->placesFeatures() & f) == f);
}
 
bool QDeclarativeGeoServiceProvider::supportsNavigation(const QDeclarativeGeoServiceProvider::NavigationFeature &feature) const
{
    QGeoServiceProvider *sp = sharedGeoServiceProvider();
    QGeoServiceProvider::NavigationFeatures f =
            static_cast<QGeoServiceProvider::NavigationFeature>(int(feature));
    if (f == QGeoServiceProvider::AnyNavigationFeatures)
        return (sp && (sp->navigationFeatures() != QGeoServiceProvider::NoNavigationFeatures));
    else
        return (sp && (sp->navigationFeatures() & f) == f);
}
 
QDeclarativeGeoServiceProviderRequirements *QDeclarativeGeoServiceProvider::requirements() const
{
    return required_.get();
}
 
void QDeclarativeGeoServiceProvider::setRequirements(QDeclarativeGeoServiceProviderRequirements *req)
{
    if (!name().isEmpty() || !req)
        return;
 
    if (required_ && *required_ == *req)
        return;
 
    required_.reset(req);
    QQmlEngine::setObjectOwnership(req, QQmlEngine::CppOwnership); // To prevent the engine from making this object disappear
}
 
QStringList QDeclarativeGeoServiceProvider::preferred() const
{
    return prefer_;
}
 
void QDeclarativeGeoServiceProvider::setPreferred(const QStringList &val)
{
    prefer_ = val;
    emit preferredChanged(prefer_);
}
 
bool QDeclarativeGeoServiceProvider::isAttached() const
{
    return (sharedProvider_ != 0);
}
 
bool QDeclarativeGeoServiceProvider::allowExperimental() const
{
    return experimental_;
}
 
void QDeclarativeGeoServiceProvider::setAllowExperimental(bool allow)
{
    if (experimental_ == allow)
        return;
 
    experimental_ = allow;
    if (sharedProvider_)
        sharedProvider_->setAllowExperimental(allow);
 
    emit allowExperimentalChanged(allow);
}
 
QGeoServiceProvider *QDeclarativeGeoServiceProvider::sharedGeoServiceProvider() const
{
    return sharedProvider_.get();
}
 
QStringList QDeclarativeGeoServiceProvider::locales() const
{
    return locales_;
}
 
void QDeclarativeGeoServiceProvider::setLocales(const QStringList &locales)
{
    if (locales_ == locales)
        return;
 
    locales_ = locales;
 
    if (locales_.isEmpty())
        locales_.append(QLocale().name());
 
    if (sharedProvider_)
        sharedProvider_->setLocale(QLocale(locales_.at(0)));
 
    emit localesChanged();
}
 
QQmlListProperty<QDeclarativePluginParameter> QDeclarativeGeoServiceProvider::parameters()
{
    return QQmlListProperty<QDeclarativePluginParameter>(this,
            0,
            parameter_append,
            parameter_count,
            parameter_at,
            parameter_clear);
}
 
void QDeclarativeGeoServiceProvider::parameter_append(QQmlListProperty<QDeclarativePluginParameter> *prop, QDeclarativePluginParameter *parameter)
{
    QDeclarativeGeoServiceProvider *p = static_cast<QDeclarativeGeoServiceProvider *>(prop->object);
    p->parameters_.append(parameter);
    if (p->sharedProvider_)
        p->sharedProvider_->setParameters(p->parameterMap());
}
 
qsizetype QDeclarativeGeoServiceProvider::parameter_count(QQmlListProperty<QDeclarativePluginParameter> *prop)
{
    return static_cast<QDeclarativeGeoServiceProvider *>(prop->object)->parameters_.count();
}
 
QDeclarativePluginParameter *QDeclarativeGeoServiceProvider::parameter_at(QQmlListProperty<QDeclarativePluginParameter> *prop, qsizetype index)
{
    return static_cast<QDeclarativeGeoServiceProvider *>(prop->object)->parameters_[index];
}
 
void QDeclarativeGeoServiceProvider::parameter_clear(QQmlListProperty<QDeclarativePluginParameter> *prop)
{
    QDeclarativeGeoServiceProvider *p = static_cast<QDeclarativeGeoServiceProvider *>(prop->object);
    p->parameters_.clear();
    if (p->sharedProvider_)
        p->sharedProvider_->setParameters(p->parameterMap());
}
 
QVariantMap QDeclarativeGeoServiceProvider::parameterMap() const
{
    QVariantMap map;
 
    for (const auto *parameter : parameters_)
        map.insert(parameter->name(), parameter->value());
 
    return map;
}
 
/*******************************************************************************
*******************************************************************************/
 
QDeclarativeGeoServiceProviderRequirements::QDeclarativeGeoServiceProviderRequirements(QObject *parent)
    : QObject(parent)
{
}
 
QDeclarativeGeoServiceProviderRequirements::~QDeclarativeGeoServiceProviderRequirements()
{
}
 
QDeclarativeGeoServiceProvider::MappingFeatures QDeclarativeGeoServiceProviderRequirements::mappingRequirements() const
{
    return mapping_;
}
 
void QDeclarativeGeoServiceProviderRequirements::setMappingRequirements(const QDeclarativeGeoServiceProvider::MappingFeatures &features)
{
    if (mapping_ == features)
        return;
 
    mapping_ = features;
    emit mappingRequirementsChanged(mapping_);
    emit requirementsChanged();
}
 
QDeclarativeGeoServiceProvider::RoutingFeatures QDeclarativeGeoServiceProviderRequirements::routingRequirements() const
{
    return routing_;
}
 
void QDeclarativeGeoServiceProviderRequirements::setRoutingRequirements(const QDeclarativeGeoServiceProvider::RoutingFeatures &features)
{
    if (routing_ == features)
        return;
 
    routing_ = features;
    emit routingRequirementsChanged(routing_);
    emit requirementsChanged();
}
 
QDeclarativeGeoServiceProvider::GeocodingFeatures QDeclarativeGeoServiceProviderRequirements::geocodingRequirements() const
{
    return geocoding_;
}
 
void QDeclarativeGeoServiceProviderRequirements::setGeocodingRequirements(const QDeclarativeGeoServiceProvider::GeocodingFeatures &features)
{
    if (geocoding_ == features)
        return;
 
    geocoding_ = features;
    emit geocodingRequirementsChanged(geocoding_);
    emit requirementsChanged();
}
 
QDeclarativeGeoServiceProvider::PlacesFeatures QDeclarativeGeoServiceProviderRequirements::placesRequirements() const
{
    return places_;
}
 
void QDeclarativeGeoServiceProviderRequirements::setPlacesRequirements(const QDeclarativeGeoServiceProvider::PlacesFeatures &features)
{
    if (places_ == features)
        return;
 
    places_ = features;
    emit placesRequirementsChanged(places_);
    emit requirementsChanged();
}
 
QDeclarativeGeoServiceProvider::NavigationFeatures QDeclarativeGeoServiceProviderRequirements::navigationRequirements() const
{
    return navigation_;
}
 
void QDeclarativeGeoServiceProviderRequirements::setNavigationRequirements(const QDeclarativeGeoServiceProvider::NavigationFeatures &features)
{
    if (navigation_ == features)
        return;
 
    navigation_ = features;
    emit navigationRequirementsChanged(navigation_);
    emit requirementsChanged();
}
 
bool QDeclarativeGeoServiceProviderRequirements::matches(const QGeoServiceProvider *provider) const
{
    QGeoServiceProvider::MappingFeatures mapping =
            static_cast<QGeoServiceProvider::MappingFeatures>(int(mapping_));
 
    // extra curlies here to avoid "dangling" else, which could belong to either if
    // same goes for all the rest of these blocks
    if (mapping == QGeoServiceProvider::AnyMappingFeatures) {
        if (provider->mappingFeatures() == QGeoServiceProvider::NoMappingFeatures)
            return false;
    } else {
        if ((provider->mappingFeatures() & mapping) != mapping)
            return false;
    }
 
    QGeoServiceProvider::RoutingFeatures routing =
            static_cast<QGeoServiceProvider::RoutingFeatures>(int(routing_));
 
    if (routing == QGeoServiceProvider::AnyRoutingFeatures) {
        if (provider->routingFeatures() == QGeoServiceProvider::NoRoutingFeatures)
            return false;
    } else {
        if ((provider->routingFeatures() & routing) != routing)
            return false;
    }
 
    QGeoServiceProvider::GeocodingFeatures geocoding =
            static_cast<QGeoServiceProvider::GeocodingFeatures>(int(geocoding_));
 
    if (geocoding == QGeoServiceProvider::AnyGeocodingFeatures) {
        if (provider->geocodingFeatures() == QGeoServiceProvider::NoGeocodingFeatures)
            return false;
    } else {
        if ((provider->geocodingFeatures() & geocoding) != geocoding)
            return false;
    }
 
    QGeoServiceProvider::PlacesFeatures places =
            static_cast<QGeoServiceProvider::PlacesFeatures>(int(places_));
 
    if (places == QGeoServiceProvider::AnyPlacesFeatures) {
        if (provider->placesFeatures() == QGeoServiceProvider::NoPlacesFeatures)
            return false;
    } else {
        if ((provider->placesFeatures() & places) != places)
            return false;
    }
 
    QGeoServiceProvider::NavigationFeatures navigation =
            static_cast<QGeoServiceProvider::NavigationFeatures>(int(navigation_));
 
    if (navigation == QGeoServiceProvider::AnyNavigationFeatures) {
        if (provider->navigationFeatures() == QGeoServiceProvider::NoNavigationFeatures)
            return false;
    } else {
        if ((provider->navigationFeatures() & navigation) != navigation)
            return false;
    }
 
    return true;
}
 
bool QDeclarativeGeoServiceProviderRequirements::operator == (const QDeclarativeGeoServiceProviderRequirements &rhs) const
{
    return (mapping_ == rhs.mapping_ && routing_ == rhs.routing_
            && geocoding_ == rhs.geocoding_ && places_ == rhs.places_
            && navigation_ == rhs.navigation_);
}
 
/*******************************************************************************
*******************************************************************************/
 
 
/*******************************************************************************
 *  Implementation now in positioningquick
*******************************************************************************/
 
QT_END_NAMESPACE