qgeopositioninfosource.cpp

Go to the documentation of this file.

// Copyright (C) 2016 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 <qgeopositioninfosource.h>
#include "qgeopositioninfosource_p.h"
#include "qgeopositioninfosourcefactory.h"
 
#include <QFile>
#include <QPluginLoader>
#include <QStringList>
#include <QCryptographicHash>
#include <QtCore/private/qfactoryloader_p.h>
#include <QtCore/private/qthread_p.h>
 
#include <algorithm>
 
QT_BEGIN_NAMESPACE
 
Q_GLOBAL_STATIC_WITH_ARGS(QFactoryLoader, loader,
        ("org.qt-project.qt.position.sourcefactory/6.0",
         QLatin1String("/position")))
 
 
QGeoPositionInfoSourcePrivate::~QGeoPositionInfoSourcePrivate()
{
 
}
 
QGeoPositionInfoSourceFactory *QGeoPositionInfoSourcePrivate::loadFactory(const QCborMap &meta)
{
    const int idx = static_cast<int>(meta.value(QStringLiteral("index")).toDouble());
    if (idx < 0)
        return nullptr;
    QObject *instance = loader()->instance(idx);
    if (!instance)
        return nullptr;
    return qobject_cast<QGeoPositionInfoSourceFactory *>(instance);
}
 
QMultiHash<QString, QCborMap> QGeoPositionInfoSourcePrivate::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;
}
 
static bool pluginComparator(const QCborMap &p1, const QCborMap &p2)
{
    const QString prio = QStringLiteral("Priority");
    if (p1.contains(prio) && !p2.contains(prio))
        return true;
    if (!p1.contains(prio) && p2.contains(prio))
        return false;
    if (p1.value(prio).isDouble() && !p2.value(prio).isDouble())
        return true;
    if (!p1.value(prio).isDouble() && p2.value(prio).isDouble())
        return false;
    return (p1.value(prio).toDouble() > p2.value(prio).toDouble());
}
 
QList<QCborMap> QGeoPositionInfoSourcePrivate::pluginsSorted()
{
    QList<QCborMap> list = plugins().values();
    std::stable_sort(list.begin(), list.end(), pluginComparator);
    return list;
}
 
void QGeoPositionInfoSourcePrivate::loadPluginMetadata(QMultiHash<QString, QCborMap> &plugins)
{
    QFactoryLoader *l = loader();
    QList<QPluginParsedMetaData> meta = l->metaData();
    for (qsizetype i = 0; i < meta.size(); ++i) {
        QCborMap obj = meta.at(i).value(QtPluginMetaDataKeys::MetaData).toMap();
        const QLatin1String testableKey("Testable");
        if (!obj.value(testableKey).toBool(true)) {
            static bool inTest = qEnvironmentVariableIsSet("QT_QTESTLIB_RUNNING");
            if (inTest)
                continue;
        }
        obj.insert(QLatin1String("index"), static_cast<qint64>(i));
        plugins.insert(obj.value(QStringLiteral("Provider")).toString(), obj);
    }
}
 
QGeoPositionInfoSource::QGeoPositionInfoSource(QObject *parent)
        : QObject(*new QGeoPositionInfoSourcePrivate, parent)
{
    qRegisterMetaType<QGeoPositionInfo>();
}
 
QGeoPositionInfoSource::~QGeoPositionInfoSource()
{
}
 
QString QGeoPositionInfoSource::sourceName() const
{
    Q_D(const QGeoPositionInfoSource);
    return d->sourceName;
}
 
bool QGeoPositionInfoSource::setBackendProperty(const QString &name, const QVariant &value)
{
    Q_UNUSED(name)
    Q_UNUSED(value)
    return false;
}
 
QVariant QGeoPositionInfoSource::backendProperty(const QString &name) const
{
    Q_UNUSED(name)
    return QVariant();
}
 
void QGeoPositionInfoSource::setUpdateInterval(int msec)
{
    Q_D(QGeoPositionInfoSource);
    d->interval = msec;
}
 
int QGeoPositionInfoSource::updateInterval() const
{
    Q_D(const QGeoPositionInfoSource);
    return d->interval.value();
}
 
QBindable<int> QGeoPositionInfoSource::bindableUpdateInterval()
{
    Q_D(QGeoPositionInfoSource);
    return QBindable<int>(&d->interval);
}
 
void QGeoPositionInfoSource::setPreferredPositioningMethods(PositioningMethods methods)
{
    Q_D(QGeoPositionInfoSource);
    d->methods.removeBindingUnlessInWrapper();
    // The supported positioning methods can change during the calls to this
    // method, so we can't have a simple check like:
    // if (currentMethods == methods) return;
    // Instead we need to save the current value and compare it afterwards
    const auto prevMethods = d->methods.value();
 
    if (supportedPositioningMethods() != QGeoPositionInfoSource::NoPositioningMethods) {
        d->methods.setValueBypassingBindings(methods & supportedPositioningMethods());
        if (d->methods.value() == 0) {
            d->methods.setValueBypassingBindings(supportedPositioningMethods());
        }
    } else { // avoid that turned of Location service blocks any changes to d->methods
        d->methods.setValueBypassingBindings(methods);
    }
    if (prevMethods != d->methods.value())
        d->methods.notify();
}
 
QGeoPositionInfoSource::PositioningMethods QGeoPositionInfoSource::preferredPositioningMethods() const
{
    Q_D(const QGeoPositionInfoSource);
    return d->methods.value();
}
 
QBindable<QGeoPositionInfoSource::PositioningMethods>
QGeoPositionInfoSource::bindablePreferredPositioningMethods()
{
    Q_D(QGeoPositionInfoSource);
    return QBindable<PositioningMethods>(&d->methods);
}
 
QGeoPositionInfoSource *QGeoPositionInfoSourcePrivate::createSourceReal(const QCborMap &meta, const QVariantMap &parameters, QObject *parent)
{
    QGeoPositionInfoSource *s = nullptr;
    auto factory = QGeoPositionInfoSourcePrivate::loadFactory(meta);
    if (factory)
        s = factory->positionInfoSource(parent, parameters);
    if (s)
        s->d_func()->sourceName = meta.value(QStringLiteral("Provider")).toString();
 
    return s;
}
 
QGeoPositionInfoSource *QGeoPositionInfoSource::createDefaultSource(QObject *parent)
{
    return createDefaultSource(QVariantMap(), parent);
}
 
QGeoPositionInfoSource *QGeoPositionInfoSource::createDefaultSource(const QVariantMap &parameters, QObject *parent)
{
    const QList<QCborMap> plugins = QGeoPositionInfoSourcePrivate::pluginsSorted();
    foreach (const QCborMap &obj, plugins) {
        if (obj.value(QStringLiteral("Position")).isBool()
                && obj.value(QStringLiteral("Position")).toBool()) {
            QGeoPositionInfoSource *source = QGeoPositionInfoSourcePrivate::createSourceReal(obj, parameters, parent);
            if (source)
                return source;
        }
    }
    return nullptr;
}
 
QGeoPositionInfoSource *QGeoPositionInfoSource::createSource(const QString &sourceName, QObject *parent)
{
    return createSource(sourceName, QVariantMap(), parent);
}
 
QGeoPositionInfoSource *QGeoPositionInfoSource::createSource(const QString &sourceName, const QVariantMap &parameters, QObject *parent)
{
    auto plugins = QGeoPositionInfoSourcePrivate::plugins();
    if (plugins.contains(sourceName))
        return QGeoPositionInfoSourcePrivate::createSourceReal(plugins.value(sourceName), parameters, parent);
    return nullptr;
}
 
QStringList QGeoPositionInfoSource::availableSources()
{
    QStringList plugins;
    const auto meta = QGeoPositionInfoSourcePrivate::plugins();
    for (auto it = meta.cbegin(), end = meta.cend(); it != end; ++it) {
        if (it.value().value(QStringLiteral("Position")).isBool()
                && it.value().value(QStringLiteral("Position")).toBool()) {
            plugins << it.key();
        }
    }
 
    return plugins;
}
 
QGeoPositionInfoSource::QGeoPositionInfoSource(QGeoPositionInfoSourcePrivate &dd, QObject *parent)
    : QObject(dd, parent)
{
    qRegisterMetaType<QGeoPositionInfo>();
    Q_D(QGeoPositionInfoSource);
    d->interval.setValueBypassingBindings(0);
    d->methods.setValueBypassingBindings(NoPositioningMethods);
}
 
QT_END_NAMESPACE
 
#include "moc_qgeopositioninfosource.cpp"