/*
* Copyright 2013 Canonical Ltd.
* Copyright 2022 UBports Foundation.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License as published by
* the Free Software Foundation; version 3.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with this program. If not, see .
*
* Author: Thomas Voß
* Marius Gripsgard
*/
#include "core_geo_position_info_source.h"
#include
#include
#include
#include
#include "instance.h"
#include
#include
#include
#include
#include
namespace cll = com::lomiri::location;
namespace cllss = com::lomiri::location::service::session;
struct core::GeoPositionInfoSource::Private
{
// If an application requests an individual position update with a
// timeout value of 0, we bump the timeout to the default value of
// 10 seconds.
static const unsigned int default_timeout_in_ms = 10 * 1000;
// Processes the incoming position update and translates it to Qt world.
void handlePositionUpdate(const cll::Update& position);
// Processes the incoming heading update and translates it to Qt world.
void handleHeadingUpdate(const cll::Update& heading);
// Processes the incoming velocity update and translates it to Qt world.
void handleVelocityUpdate(const cll::Update& velocity);
void createLocationServiceSession();
void destroyLocationServiceSession();
// Creates a new instance and attempts to connect to the background service.
// Stores errors in the error member.
Private(core::GeoPositionInfoSource* parent);
~Private();
core::GeoPositionInfoSource* parent;
cllss::Interface::Ptr session;
std::shared_ptr instance;
QMutex lastKnownPositionGuard;
QGeoPositionInfo lastKnownPosition;
QTimer timer;
QGeoPositionInfoSource::Error error;
};
core::GeoPositionInfoSource::GeoPositionInfoSource(QObject *parent)
: QGeoPositionInfoSource(parent),
m_applicationActive(true),
m_lastReqTimeout(-1),
m_state(State::stopped),
d(new Private(this))
{
d->timer.setSingleShot(true);
QObject::connect(&d->timer, SIGNAL(timeout()), this, SLOT(timeout()), Qt::DirectConnection);
// Whenever we receive an update, we stop the timeout timer immediately.
QObject::connect(this, SIGNAL(positionUpdated(const QGeoPositionInfo&)), &d->timer, SLOT(stop()));
QObject::connect(qApp, SIGNAL(applicationStateChanged(Qt::ApplicationState)), this, SLOT(applicationStateChanged()));
qRegisterMetaType("Qt::ApplicationState");
}
void core::GeoPositionInfoSource::applicationStateChanged()
{
Qt::ApplicationState state = qApp->applicationState();
if (state == Qt::ApplicationInactive) {
if (m_applicationActive) {
int state = m_state;
stopUpdates();
m_applicationActive = false;
if (state == State::one_shot) {
// Save current time out
if (d->timer.isActive()) {
m_lastReqTimeout = d->timer.interval();
d->timer.stop();
}
}
else if (state == State::running) {
// Stop continuous updates and suspend
m_state = State::suspended;
}
}
}
else if (state == Qt::ApplicationActive) {
if (!m_applicationActive) {
m_applicationActive = true;
// Only restart updates if active before suspending
if (m_lastReqTimeout > -1) {
requestUpdate(m_lastReqTimeout);
m_lastReqTimeout = -1;
}
else if (m_state == State::suspended) {
// Restart continuous updates
startUpdates();
}
}
}
}
core::GeoPositionInfoSource::~GeoPositionInfoSource()
{
}
void core::GeoPositionInfoSource::setUpdateInterval(int msec)
{
// We emit our current error state whenever a caller tries to interact
// with the source although we are in error state.
if (error() != QGeoPositionInfoSource::NoError)
{
#if (QT_VERSION >= QT_VERSION_CHECK(6, 0, 0))
Q_EMIT(QGeoPositionInfoSource::errorOccurred(d->error));
#else
Q_EMIT(QGeoPositionInfoSource::error(d->error));
#endif
return;
}
(void) msec;
}
void core::GeoPositionInfoSource::setPreferredPositioningMethods(PositioningMethods methods)
{
// We emit our current error state whenever a caller tries to interact
// with the source although we are in error state.
if (error() != QGeoPositionInfoSource::NoError)
{
#if (QT_VERSION >= QT_VERSION_CHECK(6, 0, 0))
Q_EMIT(QGeoPositionInfoSource::errorOccurred(d->error));
#else
Q_EMIT(QGeoPositionInfoSource::error(d->error));
#endif
return;
}
QGeoPositionInfoSource::setPreferredPositioningMethods(methods);
}
QGeoPositionInfo core::GeoPositionInfoSource::lastKnownPosition(bool fromSatellitePositioningMethodsOnly) const
{
// We emit our current error state whenever a caller tries to interact
// with the source although we are in error state.
if (error() != QGeoPositionInfoSource::NoError)
return QGeoPositionInfo();
Q_UNUSED(fromSatellitePositioningMethodsOnly);
QMutexLocker lock(&d->lastKnownPositionGuard);
return QGeoPositionInfo(d->lastKnownPosition);
}
QGeoPositionInfoSource::PositioningMethods core::GeoPositionInfoSource::supportedPositioningMethods() const
{
// We emit our current error state whenever a caller tries to interact
// with the source although we are in error state.
if (error() != QGeoPositionInfoSource::NoError)
{
return QGeoPositionInfoSource::NoPositioningMethods;
}
return AllPositioningMethods;
}
void core::GeoPositionInfoSource::startUpdates()
{
if (d->session == nullptr) {
d->createLocationServiceSession();
}
// We emit our current error state whenever a caller tries to interact
// with the source although we are in error state.
if (error() != QGeoPositionInfoSource::NoError)
{
#if (QT_VERSION >= QT_VERSION_CHECK(6, 0, 0))
Q_EMIT(QGeoPositionInfoSource::errorOccurred(d->error));
#else
Q_EMIT(QGeoPositionInfoSource::error(d->error));
#endif
return;
}
d->session->updates().position_status.set(
cllss::Interface::Updates::Status::enabled);
d->session->updates().heading_status.set(
cllss::Interface::Updates::Status::enabled);
d->session->updates().velocity_status.set(
cllss::Interface::Updates::Status::enabled);
if (m_state != State::one_shot)
m_state = State::running;
}
int core::GeoPositionInfoSource::minimumUpdateInterval() const {
// We emit our current error state whenever a caller tries to interact
// with the source although we are in error state.
if (error() != QGeoPositionInfoSource::NoError)
{
return -1;
}
return 500;
}
void core::GeoPositionInfoSource::stopUpdates()
{
if (error() != QGeoPositionInfoSource::NoError || !d->session)
{
// Don't emit an error from stopUpdates(). Applications usually call
// stop() in response to an error, thus emitting one here could lead
// to an infinite call cycle (and maybe stack overflow).
return;
}
d->session->updates().position_status.set(
cllss::Interface::Updates::Status::disabled);
d->session->updates().heading_status.set(
cllss::Interface::Updates::Status::disabled);
d->session->updates().velocity_status.set(
cllss::Interface::Updates::Status::disabled);
m_state = State::stopped;
}
void core::GeoPositionInfoSource::requestUpdate(int timeout)
{
// We emit our current error state whenever a caller tries to interact
// with the source although we are in error state.
if (error() != QGeoPositionInfoSource::NoError)
{
#if (QT_VERSION >= QT_VERSION_CHECK(6, 0, 0))
Q_EMIT(QGeoPositionInfoSource::errorOccurred(d->error));
#else
Q_EMIT(QGeoPositionInfoSource::error(d->error));
#endif
return;
}
if (d->timer.isActive())
{
return;
}
// Bump the timeout if caller indicates "choose default value".
if (timeout <= 0)
timeout = Private::default_timeout_in_ms;
startUpdates();
d->timer.start(timeout);
}
void core::GeoPositionInfoSource::timeout()
{
// Update timeout reached, clean up
stopUpdates();
#if (QT_VERSION >= QT_VERSION_CHECK(6, 0, 0))
Q_EMIT(QGeoPositionInfoSource::errorOccurred(QGeoPositionInfoSource::UpdateTimeoutError));
#else
Q_EMIT updateTimeout();
#endif
}
QGeoPositionInfoSource::Error core::GeoPositionInfoSource::error() const
{
return d->error;
}
// Processes the incoming position update and translates it to Qt world.
void core::GeoPositionInfoSource::Private::handlePositionUpdate(const cll::Update& position)
{
QGeoCoordinate coord(
position.value.latitude.value.value(),
position.value.longitude.value.value(),
position.value.altitude ? position.value.altitude->value.value() : 0);
QMutexLocker lock(&lastKnownPositionGuard);
lastKnownPosition.setCoordinate(coord);
if (position.value.accuracy.horizontal)
{
double accuracy = position.value.accuracy.horizontal->value();
if (!std::isnan(accuracy))
lastKnownPosition.setAttribute(QGeoPositionInfo::HorizontalAccuracy, accuracy);
}
if (position.value.accuracy.vertical)
{
double accuracy = position.value.accuracy.vertical->value();
if (!std::isnan(accuracy))
lastKnownPosition.setAttribute(QGeoPositionInfo::VerticalAccuracy, accuracy);
}
lastKnownPosition.setTimestamp(
QDateTime::fromMSecsSinceEpoch(
std::chrono::duration_cast(position.when.time_since_epoch()).count()));
QGeoPositionInfo info{lastKnownPosition};
QMetaObject::invokeMethod(
parent,
"positionUpdated",
Qt::QueuedConnection,
Q_ARG(QGeoPositionInfo, info));
if (timer.isActive())
timer.stop();
if (parent->m_state == State::one_shot)
parent->stopUpdates();
}
// Processes the incoming heading update and translates it to Qt world.
void core::GeoPositionInfoSource::Private::handleHeadingUpdate(const cll::Update& heading)
{
QMutexLocker lock(&lastKnownPositionGuard);
lastKnownPosition.setAttribute(
QGeoPositionInfo::Direction,
heading.value.value());
lastKnownPosition.setTimestamp(
QDateTime::fromMSecsSinceEpoch(
std::chrono::duration_cast(heading.when.time_since_epoch()).count()));
QGeoPositionInfo info{lastKnownPosition};
QMetaObject::invokeMethod(
parent,
"positionUpdated",
Qt::QueuedConnection,
Q_ARG(QGeoPositionInfo, info));
}
// Processes the incoming velocity update and translates it to Qt world.
void core::GeoPositionInfoSource::Private::handleVelocityUpdate(const cll::Update& velocity)
{
QMutexLocker lock(&lastKnownPositionGuard);
lastKnownPosition.setAttribute(
QGeoPositionInfo::GroundSpeed,
velocity.value.value());
lastKnownPosition.setTimestamp(
QDateTime::fromMSecsSinceEpoch(
std::chrono::duration_cast(velocity.when.time_since_epoch()).count()));
QGeoPositionInfo info{lastKnownPosition};
QMetaObject::invokeMethod(
parent,
"positionUpdated",
Qt::QueuedConnection,
Q_ARG(QGeoPositionInfo, info));
}
void core::GeoPositionInfoSource::Private::createLocationServiceSession()
{
instance = std::make_shared();
try {
session = instance->getService()->create_session_for_criteria(cll::Criteria{});
error = QGeoPositionInfoSource::NoError;
} catch(...)
{
error = QGeoPositionInfoSource::AccessError;
return;
}
session->updates().position.changed().connect(
[this](const cll::Update& new_position)
{
try
{
this->handlePositionUpdate(new_position);
} catch(...)
{
// We silently ignore the issue and keep going.
}
});
session->updates().heading.changed().connect(
[this](const cll::Update& new_heading)
{
try
{
this->handleHeadingUpdate(new_heading);
} catch(...)
{
// We silently ignore the issue and keep going.
}
});
session->updates().velocity.changed().connect(
[this](const cll::Update& new_velocity)
{
try
{
this->handleVelocityUpdate(new_velocity);
} catch(...)
{
// We silently ignore the issue and keep going.
}
});
}
void core::GeoPositionInfoSource::Private::destroyLocationServiceSession()
{
if (session)
session = nullptr;
}
// Creates a new instance and attempts to connect to the background service.
// Stores errors in the error member.
core::GeoPositionInfoSource::Private::Private(core::GeoPositionInfoSource* parent)
: parent(parent),
session(nullptr),
error(QGeoPositionInfoSource::NoError)
{
qRegisterMetaType("QGeoPositionInfo");
}
core::GeoPositionInfoSource::Private::~Private()
{
destroyLocationServiceSession();
}