qdeclarativeposition.cpp

Go to the documentation of this file.

// Copyright (C) 2016 Jolla Ltd.
// 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 <QtCore/QtNumeric>
#include "qdeclarativeposition_p.h"
#include <QtQml/qqml.h>
#include <qnmeapositioninfosource.h>
#include <QFile>
 
QT_BEGIN_NAMESPACE
 
 
namespace
{
 
bool equalOrNaN(qreal a, qreal b)
{
    return a == b || (qIsNaN(a) && qIsNaN(b));
}
 
bool exclusiveNaN(qreal a, qreal b)
{
    return qIsNaN(a) != qIsNaN(b);
}
 
}
 
QDeclarativePosition::QDeclarativePosition(QObject *parent)
:   QObject(parent)
{
}
 
QDeclarativePosition::~QDeclarativePosition()
{
}
 
void QDeclarativePosition::setPosition(const QGeoPositionInfo &info)
{
    // timestamp
    const QDateTime pTimestamp = m_info.timestamp();
    const QDateTime timestamp = info.timestamp();
    const bool timestampChanged = pTimestamp != timestamp;
 
    // coordinate
    const QGeoCoordinate pCoordinate = m_info.coordinate();
    const QGeoCoordinate coordinate = info.coordinate();
    const bool coordinateChanged = pCoordinate != coordinate;
    const bool latitudeValidChanged = exclusiveNaN(pCoordinate.latitude(), coordinate.latitude());
    const bool longitudeValidChanged =
            exclusiveNaN(pCoordinate.longitude(), coordinate.longitude());
    const bool altitudeValidChanged = exclusiveNaN(pCoordinate.altitude(), coordinate.altitude());
 
    // direction
    const qreal pDirection = m_info.attribute(QGeoPositionInfo::Direction);
    const qreal direction = info.attribute(QGeoPositionInfo::Direction);
    const bool directionChanged = !equalOrNaN(pDirection, direction);
    const bool directionValidChanged = exclusiveNaN(pDirection, direction);
 
    // ground speed
    const qreal pSpeed = m_info.attribute(QGeoPositionInfo::GroundSpeed);
    const qreal speed = info.attribute(QGeoPositionInfo::GroundSpeed);
    const bool speedChanged = !equalOrNaN(pSpeed, speed);
    const bool speedValidChanged = exclusiveNaN(pSpeed, speed);
 
    // vertical speed
    const qreal pVerticalSpeed = m_info.attribute(QGeoPositionInfo::VerticalSpeed);
    const qreal verticalSpeed = info.attribute(QGeoPositionInfo::VerticalSpeed);
    const bool verticalSpeedChanged = !equalOrNaN(pVerticalSpeed, verticalSpeed);
    const bool verticalSpeedValidChanged = exclusiveNaN(pVerticalSpeed, verticalSpeed);
 
    // magnetic variation
    const qreal pMagneticVariation = m_info.attribute(QGeoPositionInfo::MagneticVariation);
    const qreal magneticVariation = info.attribute(QGeoPositionInfo::MagneticVariation);
    const bool magneticVariationChanged = !equalOrNaN(pMagneticVariation, magneticVariation);
    const bool magneticVariationValidChanged = exclusiveNaN(pMagneticVariation, magneticVariation);
 
    // horizontal accuracy
    const qreal pHorizontalAccuracy = m_info.attribute(QGeoPositionInfo::HorizontalAccuracy);
    const qreal horizontalAccuracy = info.attribute(QGeoPositionInfo::HorizontalAccuracy);
    const bool horizontalAccuracyChanged = !equalOrNaN(pHorizontalAccuracy, horizontalAccuracy);
    const bool horizontalAccuracyValidChanged =
            exclusiveNaN(pHorizontalAccuracy, horizontalAccuracy);
 
    // vertical accuracy
    const qreal pVerticalAccuracy = m_info.attribute(QGeoPositionInfo::VerticalAccuracy);
    const qreal verticalAccuracy = info.attribute(QGeoPositionInfo::VerticalAccuracy);
    const bool verticalAccuracyChanged = !equalOrNaN(pVerticalAccuracy, verticalAccuracy);
    const bool verticalAccuracyValidChanged = exclusiveNaN(pVerticalAccuracy, verticalAccuracy);
 
    // direction accuracy
    const qreal pDirectionAccuracy = m_info.attribute(QGeoPositionInfo::DirectionAccuracy);
    const qreal directionAccuracy = info.attribute(QGeoPositionInfo::DirectionAccuracy);
    const bool directionAccuracyChanged = !equalOrNaN(pDirectionAccuracy, directionAccuracy);
    const bool directionAccuracyValidChanged = exclusiveNaN(pDirectionAccuracy, directionAccuracy);
 
    m_info = info;
 
    if (timestampChanged)
        m_computedTimestamp.notify();
 
    if (coordinateChanged)
        m_computedCoordinate.notify();
    if (latitudeValidChanged)
        m_computedLatitudeValid.notify();
    if (longitudeValidChanged)
        m_computedLongitudeValid.notify();
    if (altitudeValidChanged)
        m_computedAltitudeValid.notify();
 
    if (directionChanged)
        m_computedDirection.notify();
    if (directionValidChanged)
        m_computedDirectionValid.notify();
 
    if (speedChanged)
        m_computedSpeed.notify();
    if (speedValidChanged)
        m_computedSpeedValid.notify();
 
    if (verticalSpeedChanged)
        m_computedVerticalSpeed.notify();
    if (verticalSpeedValidChanged)
        m_computedVerticalSpeedValid.notify();
 
    if (horizontalAccuracyChanged)
        m_computedHorizontalAccuracy.notify();
    if (horizontalAccuracyValidChanged)
        m_computedHorizontalAccuracyValid.notify();
 
    if (verticalAccuracyChanged)
        m_computedVerticalAccuracy.notify();
    if (verticalAccuracyValidChanged)
        m_computedVerticalAccuracyValid.notify();
 
    if (magneticVariationChanged)
        m_computedMagneticVariation.notify();
    if (magneticVariationValidChanged)
        m_computedMagneticVariationValid.notify();
 
    if (directionAccuracyChanged)
        m_computedDirectionAccuracy.notify();
    if (directionAccuracyValidChanged)
        m_computedDirectionAccuracyValid.notify();
}
 
const QGeoPositionInfo &QDeclarativePosition::position() const
{
    return m_info;
}
 
QBindable<bool> QDeclarativePosition::bindableLatitudeValid() const
{
    return QBindable<bool>(&m_computedLatitudeValid);
}
 
QBindable<bool> QDeclarativePosition::bindableLongitudeValid() const
{
    return QBindable<bool>(&m_computedLongitudeValid);
}
 
QBindable<bool> QDeclarativePosition::bindableAltitudeValid() const
{
    return QBindable<bool>(&m_computedAltitudeValid);
}
 
QBindable<QGeoCoordinate> QDeclarativePosition::bindableCoordinate() const
{
    return QBindable<QGeoCoordinate>(&m_computedCoordinate);
}
 
QBindable<QDateTime> QDeclarativePosition::bindableTimestamp() const
{
    return QBindable<QDateTime>(&m_computedTimestamp);
}
 
QBindable<double> QDeclarativePosition::bindableSpeed() const
{
    return QBindable<double>(&m_computedSpeed);
}
 
QBindable<bool> QDeclarativePosition::bindableSpeedValid() const
{
    return QBindable<bool>(&m_computedSpeedValid);
}
 
QBindable<qreal> QDeclarativePosition::bindableHorizontalAccuracy() const
{
    return QBindable<qreal>(&m_computedHorizontalAccuracy);
}
 
QBindable<qreal> QDeclarativePosition::binableVerticalAccuracy() const
{
    return QBindable<qreal>(&m_computedVerticalAccuracy);
}
 
QBindable<bool> QDeclarativePosition::bindableHorizontalAccuracyValid() const
{
    return QBindable<bool>(&m_computedHorizontalAccuracyValid);
}
 
QBindable<bool> QDeclarativePosition::bindableVerticalAccuracyValid() const
{
    return QBindable<bool>(&m_computedVerticalAccuracyValid);
}
 
QBindable<bool> QDeclarativePosition::bindableDirectionValid() const
{
    return QBindable<bool>(&m_computedDirectionValid);
}
 
QBindable<double> QDeclarativePosition::bindableDirection() const
{
    return QBindable<double>(&m_computedDirection);
}
 
QBindable<bool> QDeclarativePosition::bindableVerticalSpeedValid() const
{
    return QBindable<bool>(&m_computedVerticalSpeedValid);
}
 
QBindable<double> QDeclarativePosition::bindableVerticalSpeed() const
{
    return QBindable<double>(&m_computedVerticalSpeed);
}
 
QBindable<double> QDeclarativePosition::bindableMagneticVariation() const
{
    return QBindable<double>(&m_computedMagneticVariation);
}
 
QBindable<bool> QDeclarativePosition::bindableMagneticVariationValid() const
{
    return QBindable<bool>(&m_computedMagneticVariationValid);
}
 
QBindable<double> QDeclarativePosition::bindableDirectionAccuracy() const
{
    return QBindable<double>(&m_computedDirectionAccuracy);
}
 
QBindable<bool> QDeclarativePosition::bindableDirectionAccuracyValid() const
{
    return QBindable<bool>(&m_computedDirectionAccuracyValid);
}
 
QGeoCoordinate QDeclarativePosition::coordinate() const
{
    return m_computedCoordinate.value();
}
 
QGeoCoordinate QDeclarativePosition::coordinateActualCalculation() const
{
    return m_info.coordinate();
}
 
bool QDeclarativePosition::isLatitudeValid() const
{
    return m_computedLatitudeValid.value();
}
 
bool QDeclarativePosition::isLatitudeValidActualCalculation() const
{
    return !qIsNaN(m_info.coordinate().latitude());
}
 
bool QDeclarativePosition::isLongitudeValid() const
{
    return m_computedLongitudeValid.value();
}
 
bool QDeclarativePosition::isLongitudeValidActualCalculation() const
{
    return !qIsNaN(m_info.coordinate().longitude());
}
 
bool QDeclarativePosition::isSpeedValid() const
{
    return m_computedSpeedValid.value();
}
 
bool QDeclarativePosition::isSpeedValidActualCalculation() const
{
    return !qIsNaN(m_info.attribute(QGeoPositionInfo::GroundSpeed));
}
 
bool QDeclarativePosition::isAltitudeValid() const
{
    return m_computedAltitudeValid.value();
}
 
bool QDeclarativePosition::isAltitudeValidActualCalculation() const
{
    return !qIsNaN(m_info.coordinate().altitude());
}
 
double QDeclarativePosition::speed() const
{
    return m_computedSpeed.value();
}
 
double QDeclarativePosition::speedActualCalculation() const
{
    return m_info.attribute(QGeoPositionInfo::GroundSpeed);
}
 
qreal QDeclarativePosition::horizontalAccuracy() const
{
    return m_computedHorizontalAccuracy.value();
}
 
qreal QDeclarativePosition::horizontalAccuracyActualCalculation() const
{
    return m_info.attribute(QGeoPositionInfo::HorizontalAccuracy);
}
 
bool QDeclarativePosition::isHorizontalAccuracyValid() const
{
    return m_computedHorizontalAccuracyValid.value();
}
 
bool QDeclarativePosition::isHorizontalAccuracyValidActualCalculation() const
{
    return !qIsNaN(m_info.attribute(QGeoPositionInfo::HorizontalAccuracy));
}
 
qreal QDeclarativePosition::verticalAccuracy() const
{
    return m_computedVerticalAccuracy.value();
}
 
qreal QDeclarativePosition::verticalAccuracyActualCalculation() const
{
    return m_info.attribute(QGeoPositionInfo::VerticalAccuracy);
}
 
bool QDeclarativePosition::isVerticalAccuracyValid() const
{
    return m_computedVerticalAccuracyValid.value();
}
 
bool QDeclarativePosition::isVerticalAccuracyValidActualCalculation() const
{
    return !qIsNaN(m_info.attribute(QGeoPositionInfo::VerticalAccuracy));
}
 
QDateTime QDeclarativePosition::timestamp() const
{
    return m_computedTimestamp.value();
}
 
QDateTime QDeclarativePosition::timestampActualCalculation() const
{
    return m_info.timestamp();
}
 
bool QDeclarativePosition::isDirectionValid() const
{
    return m_computedDirectionValid.value();
}
 
bool QDeclarativePosition::isDirectionValidActualCalculation() const
{
    return !qIsNaN(m_info.attribute(QGeoPositionInfo::Direction));
}
 
double QDeclarativePosition::direction() const
{
    return m_computedDirection.value();
}
 
double QDeclarativePosition::directionActualCalculation() const
{
    return m_info.attribute(QGeoPositionInfo::Direction);
}
 
bool QDeclarativePosition::isVerticalSpeedValid() const
{
    return m_computedVerticalSpeedValid.value();
}
 
bool QDeclarativePosition::isVerticalSpeedValidActualCalculation() const
{
    return !qIsNaN(m_info.attribute(QGeoPositionInfo::VerticalSpeed));
}
 
double QDeclarativePosition::verticalSpeed() const
{
    return m_computedVerticalSpeed.value();
}
 
double QDeclarativePosition::verticalSpeedActualCalculation() const
{
    return m_info.attribute(QGeoPositionInfo::VerticalSpeed);
}
 
bool QDeclarativePosition::isMagneticVariationValid() const
{
    return m_computedMagneticVariationValid.value();
}
 
bool QDeclarativePosition::isMagneticVariationValidActualCalculation() const
{
    return !qIsNaN(m_info.attribute(QGeoPositionInfo::MagneticVariation));
}
 
double QDeclarativePosition::magneticVariation() const
{
    return m_computedMagneticVariation.value();
}
 
double QDeclarativePosition::magneticVariationActualCalculation() const
{
    return m_info.attribute(QGeoPositionInfo::MagneticVariation);
}
 
bool QDeclarativePosition::isDirectionAccuracyValid() const
{
    return m_computedDirectionAccuracyValid.value();
}
 
bool QDeclarativePosition::isDirectionAccuracyValidActualCalculation() const
{
    return !qIsNaN(m_info.attribute(QGeoPositionInfo::DirectionAccuracy));
}
 
double QDeclarativePosition::directionAccuracy() const
{
    return m_computedDirectionAccuracy.value();
}
 
double QDeclarativePosition::directionAccuracyActualCalculation() const
{
    return m_info.attribute(QGeoPositionInfo::DirectionAccuracy);
}
 
QT_END_NAMESPACE
 
#include "moc_qdeclarativeposition_p.cpp"