qdeclarativepositionsource.cpp

Go to the documentation of this file.

// Copyright (C) 2021 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 "qdeclarativepositionsource_p.h"
#include "qdeclarativeposition_p.h"
 
#include <QtCore/QCoreApplication>
#include <QtQml/qqmlinfo.h>
#include <QtQml/qqml.h>
#include <qdeclarativepluginparameter_p.h>
#include <QFile>
#include <QtNetwork/QTcpSocket>
#include <QTimer>
 
QT_BEGIN_NAMESPACE
 
 
QDeclarativePositionSource::QDeclarativePositionSource()
    : m_singleUpdate(0), m_regularUpdates(0), m_componentComplete(0),
      m_parametersInitialized(0), m_startRequested(0), m_defaultSourceUsed(0)
{
    m_position.setValueBypassingBindings(new QDeclarativePosition(this));
}
 
QDeclarativePositionSource::~QDeclarativePositionSource()
{
    delete m_positionSource;
}
 
 
QString QDeclarativePositionSource::name() const
{
    return m_sourceName;
}
 
void QDeclarativePositionSource::setName(const QString &newName)
{
    m_sourceName.removeBindingUnlessInWrapper();
    if (m_positionSource && m_positionSource->sourceName() == newName)
        return;
 
    if (newName.isEmpty() && m_defaultSourceUsed)
        return; // previously attached to a default source, now requesting the same.
 
    const QString previousName = name();
 
    if (!m_componentComplete || !m_parametersInitialized) {
        if (previousName != newName) {
            m_sourceName.setValueBypassingBindings(newName);
            m_sourceName.notify();
        }
        return;
    }
 
    // tryAttach() will update the m_sourceName correctly
    tryAttach(newName, false);
}
 
QBindable<QString> QDeclarativePositionSource::bindableName()
{
    return QBindable<QString>(&m_sourceName);
}
 
QBindable<QDeclarativePosition *> QDeclarativePositionSource::bindablePosition() const
{
    return QBindable<QDeclarativePosition *>(&m_position);
}
 
void QDeclarativePositionSource::tryAttach(const QString &newName, bool useFallback)
{
    const QString previousName = name();
    const bool sourceExisted = (m_positionSource != nullptr);
 
    int previousUpdateInterval = updateInterval();
    PositioningMethods previousPositioningMethods = supportedPositioningMethods();
    PositioningMethods previousPreferredPositioningMethods = preferredPositioningMethods();
 
    m_defaultSourceUsed = false;
 
    if (newName.isEmpty()) {
        setSource(QGeoPositionInfoSource::createDefaultSource(parameterMap(), this));
        m_defaultSourceUsed = true;
    } else {
        setSource(QGeoPositionInfoSource::createSource(newName, parameterMap(), this));
        if (!m_positionSource && useFallback) {
            setSource(QGeoPositionInfoSource::createDefaultSource(parameterMap(), this));
            m_defaultSourceUsed = true;
        }
    }
 
    if (m_positionSource) {
        m_sourceName.setValueBypassingBindings(m_positionSource->sourceName());
 
        connect(m_positionSource, SIGNAL(positionUpdated(QGeoPositionInfo)),
                this, SLOT(positionUpdateReceived(QGeoPositionInfo)));
        connect(m_positionSource, SIGNAL(errorOccurred(QGeoPositionInfoSource::Error)),
                this, SLOT(sourceErrorReceived(QGeoPositionInfoSource::Error)));
 
        m_positionSource->setUpdateInterval(m_updateInterval);
        m_positionSource->setPreferredPositioningMethods(
            static_cast<QGeoPositionInfoSource::PositioningMethods>(int(m_preferredPositioningMethods)));
 
        if (m_startRequested) {
            const QGeoPositionInfo &lastKnown = m_positionSource->lastKnownPosition();
            if (lastKnown.isValid())
                setPosition(lastKnown);
        }
    } else {
        m_sourceName.setValueBypassingBindings(newName);
        m_defaultSourceUsed = false;
        if (m_active) {
            // We do not want to break the binding here, because we just want to
            // give the user an opportunity to select another plugin and keep
            // working.
            m_active.setValueBypassingBindings(false);
            m_active.notify();
        }
    }
 
    if (previousUpdateInterval != updateInterval())
        emit updateIntervalChanged();
 
    if (previousPreferredPositioningMethods != preferredPositioningMethods())
        emit preferredPositioningMethodsChanged();
 
    if (previousPositioningMethods != supportedPositioningMethods())
        notifySupportedPositioningMethodsChanged();
 
    const bool sourceCurrentlyExists = (m_positionSource != nullptr);
    if (sourceExisted != sourceCurrentlyExists) {
        m_isValid.notify();
        emit validityChanged();
    }
 
    if (m_active) { // implies m_positionSource
        // If m_active is true, then the previous position source existed!
        Q_ASSERT(sourceExisted);
        // New source is set. It should be inactive by default.
        // But we do not want to break the binding.
        m_active.setValueBypassingBindings(false);
        m_active.notify();
    } else if (m_startRequested) {
        m_startRequested = false;
        executeStart();
    }
 
    if (previousName != m_sourceName)
        m_sourceName.notify();
}
 
bool QDeclarativePositionSource::isValid() const
{
    return m_isValid.value();
}
 
QBindable<bool> QDeclarativePositionSource::bindableIsValid() const
{
    return QBindable<bool>(&m_isValid);
}
 
bool QDeclarativePositionSource::isValidActualComputation() const
{
    return m_positionSource != nullptr;
}
 
void QDeclarativePositionSource::onParameterInitialized()
{
    m_parametersInitialized = true;
    for (QDeclarativePluginParameter *p: std::as_const(m_parameters)) {
        if (!p->isInitialized()) {
            m_parametersInitialized = false;
            break;
        }
    }
 
    // If here, componentComplete has been called.
    if (m_parametersInitialized)
        tryAttach(m_sourceName.value());
}
 
void QDeclarativePositionSource::notifySupportedPositioningMethodsChanged()
{
    m_supportedPositioningMethods.notify();
    emit supportedPositioningMethodsChanged();
}
 
void QDeclarativePositionSource::setPosition(const QGeoPositionInfo &pi)
{
    m_position.value()->setPosition(pi);
    m_position.notify();
    emit positionChanged();
}
 
void QDeclarativePositionSource::setSource(QGeoPositionInfoSource *source)
{
    if (m_positionSource)
        delete m_positionSource;
 
    if (!source) {
        m_positionSource = nullptr;
    } else {
        m_positionSource = source;
        connect(m_positionSource, &QGeoPositionInfoSource::supportedPositioningMethodsChanged,
                this, &QDeclarativePositionSource::notifySupportedPositioningMethodsChanged);
    }
}
 
bool QDeclarativePositionSource::parametersReady()
{
    for (const QDeclarativePluginParameter *p: std::as_const(m_parameters)) {
        if (!p->isInitialized())
            return false;
    }
    return true;
}
 
QVariantMap QDeclarativePositionSource::parameterMap() const
{
    QVariantMap map;
 
    for (const auto *parameter : m_parameters)
        map.insert(parameter->name(), parameter->value());
 
    return map;
}
 
void QDeclarativePositionSource::setUpdateInterval(int updateInterval)
{
    if (m_positionSource) {
        int previousUpdateInterval = m_positionSource->updateInterval();
 
        m_updateInterval = updateInterval;
 
        if (previousUpdateInterval != updateInterval) {
            m_positionSource->setUpdateInterval(updateInterval);
            if (previousUpdateInterval != m_positionSource->updateInterval())
                emit updateIntervalChanged();
        }
    } else {
        if (m_updateInterval != updateInterval) {
            m_updateInterval = updateInterval;
            emit updateIntervalChanged();
        }
    }
}
 
int QDeclarativePositionSource::updateInterval() const
{
    if (!m_positionSource)
        return m_updateInterval;
 
    return m_positionSource->updateInterval();
}
 
QDeclarativePositionSource::PositioningMethods
QDeclarativePositionSource::supportedPositioningMethods() const
{
    return m_supportedPositioningMethods.value();
}
 
QDeclarativePositionSource::PositioningMethods
QDeclarativePositionSource::supportedMethodsActualComputation() const
{
    if (m_positionSource) {
        return static_cast<QDeclarativePositionSource::PositioningMethods>(
            int(m_positionSource->supportedPositioningMethods()));
    }
    return QDeclarativePositionSource::NoPositioningMethods;
}
 
QBindable<QDeclarativePositionSource::PositioningMethods>
QDeclarativePositionSource::bindableSupportedPositioningMethods() const
{
    return QBindable<PositioningMethods>(&m_supportedPositioningMethods);
}
 
void QDeclarativePositionSource::setPreferredPositioningMethods(PositioningMethods methods)
{
    if (m_positionSource) {
        PositioningMethods previousPreferredPositioningMethods = preferredPositioningMethods();
 
        m_preferredPositioningMethods = methods;
 
        if (previousPreferredPositioningMethods != methods) {
            m_positionSource->setPreferredPositioningMethods(
                static_cast<QGeoPositionInfoSource::PositioningMethods>(int(methods)));
            if (previousPreferredPositioningMethods != m_positionSource->preferredPositioningMethods())
                emit preferredPositioningMethodsChanged();
        }
    } else {
        if (m_preferredPositioningMethods != methods) {
            m_preferredPositioningMethods = methods;
            emit preferredPositioningMethodsChanged();
        }
    }
}
 
QDeclarativePositionSource::PositioningMethods QDeclarativePositionSource::preferredPositioningMethods() const
{
    if (m_positionSource) {
        return static_cast<QDeclarativePositionSource::PositioningMethods>(
            int(m_positionSource->preferredPositioningMethods()));
    }
    return m_preferredPositioningMethods;
}
 
void QDeclarativePositionSource::start()
{
    if (m_positionSource) {
        m_active.removeBindingUnlessInWrapper();
        executeStart();
    }
}
 
void QDeclarativePositionSource::update(int timeout)
{
    if (m_positionSource) {
        m_singleUpdate = true;
        if (!m_active) {
            // Questionable: we do not want this method to break the binding.
            // Mostly because it can be called while the updates are already
            // running.
            m_active.setValueBypassingBindings(true);
            m_active.notify();
        }
        // Use default timeout value. Set active before calling the
        // update request because on some platforms there may
        // be results immediately.
        m_positionSource->requestUpdate(timeout);
    }
}
 
void QDeclarativePositionSource::stop()
{
    if (m_positionSource) {
        m_positionSource->stopUpdates();
        m_regularUpdates = false;
        // Try to break the binding even if we do not actually need to update
        // the active state. The m_active can be updated later, when the
        // single update request finishes.
        m_active.removeBindingUnlessInWrapper();
        if (m_active && !m_singleUpdate) {
            m_active.setValueBypassingBindings(false);
            m_active.notify();
        }
    }
}
 
void QDeclarativePositionSource::setActive(bool active)
{
    // We need to remove binding, if this method is called explicitly.
    // Other changes to m_active are done inside start() and stop() methods.
    m_active.removeBindingUnlessInWrapper();
    if (active == m_active)
        return;
 
    if (active) {
        // If the component is not completed yet, we need to defer the
        // actual executeStart() call until everything is set up.
        if (m_componentComplete && m_parametersInitialized)
            executeStart();
        else
            m_startRequested = true;
    } else {
        stop();
    }
}
 
bool QDeclarativePositionSource::isActive() const
{
    return m_active;
}
 
QDeclarativePosition *QDeclarativePositionSource::position()
{
    return m_position.value();
}
 
void QDeclarativePositionSource::positionUpdateReceived(const QGeoPositionInfo &update)
{
    setPosition(update);
 
    if (m_singleUpdate && m_active) {
        // we need to reset m_singleUpdate because we got one
        m_singleUpdate = false;
        if (!m_regularUpdates) {
            // but we change the active state only if the regular updates are
            // also stopped
            m_active.setValueBypassingBindings(false);
            m_active.notify();
        }
    }
}
 
 
QDeclarativePositionSource::SourceError QDeclarativePositionSource::sourceError() const
{
    return m_sourceError;
}
 
QBindable<QDeclarativePositionSource::SourceError>
QDeclarativePositionSource::bindableSourceError() const
{
    return QBindable<QDeclarativePositionSource::SourceError>(&m_sourceError);
}
 
QGeoPositionInfoSource *QDeclarativePositionSource::positionSource() const
{
    return m_positionSource;
}
 
QQmlListProperty<QDeclarativePluginParameter> QDeclarativePositionSource::parameters()
{
    return QQmlListProperty<QDeclarativePluginParameter>(this,
            0,
            parameter_append,
            parameter_count,
            parameter_at,
            parameter_clear);
}
 
void QDeclarativePositionSource::parameter_append(QQmlListProperty<QDeclarativePluginParameter> *prop, QDeclarativePluginParameter *parameter)
{
    QDeclarativePositionSource *p = static_cast<QDeclarativePositionSource *>(prop->object);
    p->m_parameters.append(parameter);
}
 
qsizetype QDeclarativePositionSource::parameter_count(QQmlListProperty<QDeclarativePluginParameter> *prop)
{
    return static_cast<QDeclarativePositionSource *>(prop->object)->m_parameters.size();
}
 
QDeclarativePluginParameter *QDeclarativePositionSource::parameter_at(QQmlListProperty<QDeclarativePluginParameter> *prop, qsizetype index)
{
    return static_cast<QDeclarativePositionSource *>(prop->object)->m_parameters[index];
}
 
void QDeclarativePositionSource::parameter_clear(QQmlListProperty<QDeclarativePluginParameter> *prop)
{
    QDeclarativePositionSource *p = static_cast<QDeclarativePositionSource *>(prop->object);
    p->m_parameters.clear();
}
 
void QDeclarativePositionSource::executeStart()
{
    if (m_positionSource) {
        m_positionSource->startUpdates();
 
        // If this method is called directly from start(), the binding is
        // already broken there (for the consistency with stop()).
        // If this method is called by a timer, started in setActive(), we do
        // not need to break the binding, because it was already done (if
        // needed).
 
        m_regularUpdates = true;
        if (!m_active) {
            m_active.setValueBypassingBindings(true);
            m_active.notify();
        }
    }
}
 
void QDeclarativePositionSource::componentComplete()
{
    m_componentComplete = true;
    m_parametersInitialized = true;
    for (QDeclarativePluginParameter *p: std::as_const(m_parameters)) {
        if (!p->isInitialized()) {
            m_parametersInitialized = false;
            connect(p, &QDeclarativePluginParameter::initialized,
                    this, &QDeclarativePositionSource::onParameterInitialized,
                    Qt::SingleShotConnection);
        }
    }
 
    if (m_parametersInitialized)
        tryAttach(m_sourceName.value());
}
 
bool QDeclarativePositionSource::setBackendProperty(const QString &name, const QVariant &value)
{
    if (m_positionSource)
        return m_positionSource->setBackendProperty(name, value);
    return false;
}
 
QVariant QDeclarativePositionSource::backendProperty(const QString &name) const
{
    if (m_positionSource)
        return m_positionSource->backendProperty(name);
    return QVariant();
}
 
QBindable<bool> QDeclarativePositionSource::bindableActive()
{
    return QBindable<bool>(&m_active);
}
 
void QDeclarativePositionSource::sourceErrorReceived(const QGeoPositionInfoSource::Error error)
{
    if (error == QGeoPositionInfoSource::AccessError)
        m_sourceError.setValueBypassingBindings(QDeclarativePositionSource::AccessError);
    else if (error == QGeoPositionInfoSource::ClosedError)
        m_sourceError.setValueBypassingBindings(QDeclarativePositionSource::ClosedError);
    else if (error == QGeoPositionInfoSource::UpdateTimeoutError)
        m_sourceError.setValueBypassingBindings(QDeclarativePositionSource::UpdateTimeoutError);
    else if (error == QGeoPositionInfoSource::NoError)
        return; //nothing to do
    else
        m_sourceError.setValueBypassingBindings(QDeclarativePositionSource::UnknownSourceError);
 
    m_sourceError.notify();
    emit sourceErrorChanged();
 
    // if an error occurred during single update, the update is stopped, so we
    // need to change the active state.
    if (m_active && m_singleUpdate) {
        m_singleUpdate = false;
        if (!m_regularUpdates) {
            m_active.setValueBypassingBindings(false);
            m_active.notify();
        }
    }
}
 
QT_END_NAMESPACE
 
#include "moc_qdeclarativepositionsource_p.cpp"