mirror of
https://github.com/subsurface/subsurface.git
synced 2024-12-05 00:21:29 +00:00
f63485b444
Move this function from maintab.cpp to qthelper.cpp. Since the functionality was used in numerous places, use the helper function there as well. This removes a number of inconsistencies. For example, sometime setTimeSpec(Qt::UTC) was called, even though the QDateTime object was already created with that time spec. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
418 lines
14 KiB
C++
418 lines
14 KiB
C++
// SPDX-License-Identifier: GPL-2.0
|
|
#include "core/gpslocation.h"
|
|
#include "core/divesite.h"
|
|
#include "core/dive.h"
|
|
#include "qt-models/gpslistmodel.h"
|
|
#include "core/pref.h"
|
|
#include "core/qthelper.h"
|
|
#include "core/errorhelper.h"
|
|
#include "core/settings/qPrefLocationService.h"
|
|
#include <time.h>
|
|
#include <unistd.h>
|
|
#include <QDebug>
|
|
#include <QVariant>
|
|
#include <QUrlQuery>
|
|
#include <QApplication>
|
|
#include <QTimer>
|
|
|
|
GpsLocation *GpsLocation::m_Instance = NULL;
|
|
|
|
GpsLocation::GpsLocation(void (*showMsgCB)(const char *), QObject *parent) :
|
|
QObject(parent),
|
|
m_GpsSource(0),
|
|
waitingForPosition(false),
|
|
haveSource(UNKNOWN)
|
|
{
|
|
Q_ASSERT_X(m_Instance == NULL, "GpsLocation", "GpsLocation recreated");
|
|
m_Instance = this;
|
|
showMessageCB = showMsgCB;
|
|
// create a QSettings object that's separate from the main application settings
|
|
geoSettings = new QSettings(QSettings::NativeFormat, QSettings::UserScope,
|
|
QStringLiteral("org.subsurfacedivelog"), QStringLiteral("subsurfacelocation"), this);
|
|
userAgent = getUserAgent();
|
|
(void)getGpsSource();
|
|
loadFromStorage();
|
|
|
|
// register changes in time threshold
|
|
connect(qPrefLocationService::instance(), SIGNAL(time_thresholdChanged(int)), this, SLOT(setGpsTimeThreshold(int)));
|
|
}
|
|
|
|
GpsLocation *GpsLocation::instance()
|
|
{
|
|
Q_ASSERT(m_Instance != NULL);
|
|
|
|
return m_Instance;
|
|
}
|
|
|
|
bool GpsLocation::hasInstance()
|
|
{
|
|
return m_Instance != NULL;
|
|
}
|
|
|
|
GpsLocation::~GpsLocation()
|
|
{
|
|
m_Instance = NULL;
|
|
}
|
|
|
|
void GpsLocation::setGpsTimeThreshold(int seconds)
|
|
{
|
|
if (m_GpsSource) {
|
|
m_GpsSource->setUpdateInterval(seconds * 1000);
|
|
status(QStringLiteral("Set GPS service update interval to %1 s").arg(m_GpsSource->updateInterval() / 1000));
|
|
}
|
|
}
|
|
|
|
QGeoPositionInfoSource *GpsLocation::getGpsSource()
|
|
{
|
|
if (haveSource == NOGPS)
|
|
return 0;
|
|
|
|
if (!m_GpsSource) {
|
|
m_GpsSource = QGeoPositionInfoSource::createDefaultSource(this);
|
|
if (m_GpsSource != 0) {
|
|
#if defined(Q_OS_IOS)
|
|
// at least Qt 5.6.0 isn't doing things right on iOS - it MUST check for permission before
|
|
// accessing the position source
|
|
// I have a hacked version of Qt 5.6.0 that I will build the iOS binaries with for now;
|
|
// this test below righ after creating the source checks if the location service is disabled
|
|
// and set's an error right when the position source is created to indicate this
|
|
if (m_GpsSource->error() == QGeoPositionInfoSource::AccessError) {
|
|
haveSource = NOGPS;
|
|
emit haveSourceChanged();
|
|
m_GpsSource = NULL;
|
|
return NULL;
|
|
}
|
|
#endif
|
|
haveSource = (m_GpsSource->supportedPositioningMethods() & QGeoPositionInfoSource::SatellitePositioningMethods) ? HAVEGPS : NOGPS;
|
|
emit haveSourceChanged();
|
|
#ifndef SUBSURFACE_MOBILE
|
|
if (verbose)
|
|
#endif
|
|
status(QStringLiteral("Created position source %1").arg(m_GpsSource->sourceName()));
|
|
connect(m_GpsSource, SIGNAL(positionUpdated(QGeoPositionInfo)), this, SLOT(newPosition(QGeoPositionInfo)));
|
|
connect(m_GpsSource, SIGNAL(updateTimeout()), this, SLOT(updateTimeout()));
|
|
connect(m_GpsSource, SIGNAL(error(QGeoPositionInfoSource::Error)), this, SLOT(positionSourceError(QGeoPositionInfoSource::Error)));
|
|
setGpsTimeThreshold(prefs.time_threshold);
|
|
} else {
|
|
#ifdef SUBSURFACE_MOBILE
|
|
status("don't have GPS source");
|
|
#endif
|
|
haveSource = NOGPS;
|
|
emit haveSourceChanged();
|
|
}
|
|
}
|
|
return m_GpsSource;
|
|
}
|
|
|
|
bool GpsLocation::hasLocationsSource()
|
|
{
|
|
(void)getGpsSource();
|
|
return haveSource == HAVEGPS;
|
|
}
|
|
|
|
void GpsLocation::serviceEnable(bool toggle)
|
|
{
|
|
QGeoPositionInfoSource *gpsSource = getGpsSource();
|
|
if (haveSource != HAVEGPS) {
|
|
if (toggle)
|
|
status("Can't start location service, no location source available");
|
|
return;
|
|
}
|
|
if (toggle) {
|
|
gpsSource->startUpdates();
|
|
status(QStringLiteral("Starting Subsurface GPS service with update interval %1").arg(gpsSource->updateInterval()));
|
|
} else {
|
|
gpsSource->stopUpdates();
|
|
status("Stopping Subsurface GPS service");
|
|
}
|
|
}
|
|
|
|
QString GpsLocation::currentPosition()
|
|
{
|
|
qDebug() << "current position requested";
|
|
if (!hasLocationsSource())
|
|
return tr("Unknown GPS location (no GPS source)");
|
|
if (m_trackers.count()) {
|
|
QDateTime lastFixTime = timestampToDateTime(m_trackers.lastKey() - gettimezoneoffset(m_trackers.lastKey()));
|
|
QDateTime now = QDateTime::currentDateTime();
|
|
int delta = lastFixTime.secsTo(now);
|
|
qDebug() << "lastFixTime" << lastFixTime.toString() << "now" << now.toString() << "delta" << delta;
|
|
if (delta < 300) {
|
|
// we can simply use the last position that we tracked
|
|
gpsTracker gt = m_trackers.last();
|
|
QString gpsString = printGPSCoords(>.location);
|
|
qDebug() << "returning last position" << gpsString;
|
|
return gpsString;
|
|
} else {
|
|
qDebug() << "last position saved was too old" << lastFixTime.toString();
|
|
}
|
|
}
|
|
qDebug() << "requesting new GPS position";
|
|
m_GpsSource->requestUpdate();
|
|
// ok, we need to get the current position and somehow in the callback update the location in the QML UI
|
|
// punting right now
|
|
waitingForPosition = true;
|
|
return GPS_CURRENT_POS;
|
|
}
|
|
|
|
void GpsLocation::newPosition(QGeoPositionInfo pos)
|
|
{
|
|
int64_t lastTime = 0;
|
|
QGeoCoordinate lastCoord;
|
|
int nr = m_trackers.count();
|
|
if (nr) {
|
|
gpsTracker gt = m_trackers.last();
|
|
lastCoord.setLatitude(gt.location.lat.udeg / 1000000.0);
|
|
lastCoord.setLongitude(gt.location.lon.udeg / 1000000.0);
|
|
lastTime = gt.when;
|
|
}
|
|
// if we are waiting for a position update or
|
|
// if we have no record stored or if at least the configured minimum
|
|
// time has passed or we moved at least the configured minimum distance
|
|
int64_t delta = (int64_t)pos.timestamp().toTime_t() + gettimezoneoffset() - lastTime;
|
|
if (!nr || waitingForPosition || delta > prefs.time_threshold ||
|
|
lastCoord.distanceTo(pos.coordinate()) > prefs.distance_threshold) {
|
|
QString msg = QStringLiteral("received new position %1 after delta %2 threshold %3 (now %4 last %5)");
|
|
status(qPrintable(msg.arg(pos.coordinate().toString()).arg(delta).arg(prefs.time_threshold).arg(pos.timestamp().toString()).arg(timestampToDateTime(lastTime).toString())));
|
|
waitingForPosition = false;
|
|
acquiredPosition();
|
|
gpsTracker gt;
|
|
gt.when = pos.timestamp().toTime_t();
|
|
gt.when += gettimezoneoffset(gt.when);
|
|
gt.location = create_location(pos.coordinate().latitude(), pos.coordinate().longitude());
|
|
addFixToStorage(gt);
|
|
gpsTracker gtNew = m_trackers.last();
|
|
qDebug() << "newest fix is now at" << timestampToDateTime(gtNew.when - gettimezoneoffset(gtNew.when)).toString();
|
|
}
|
|
}
|
|
|
|
void GpsLocation::updateTimeout()
|
|
{
|
|
status("request to get new position timed out");
|
|
}
|
|
|
|
void GpsLocation::positionSourceError(QGeoPositionInfoSource::Error)
|
|
{
|
|
status("error receiving a GPS location");
|
|
haveSource = NOGPS;
|
|
emit haveSourceChanged();
|
|
}
|
|
|
|
void GpsLocation::status(QString msg)
|
|
{
|
|
if (showMessageCB)
|
|
(*showMessageCB)(qPrintable(msg));
|
|
else
|
|
qDebug() << msg;
|
|
}
|
|
|
|
int GpsLocation::getGpsNum() const
|
|
{
|
|
return m_trackers.count();
|
|
}
|
|
|
|
#define SAME_GROUP 6 * 3600 /* six hours */
|
|
#define ADD_LOCATION(_dive, _gpsfix, _mark) \
|
|
{ \
|
|
fixes.push_back( { _dive, _gpsfix.location, _gpsfix.name } ); \
|
|
last = _mark; \
|
|
}
|
|
|
|
std::vector<DiveAndLocation> GpsLocation::getLocations()
|
|
{
|
|
int i;
|
|
int last = 0;
|
|
int cnt = m_trackers.count();
|
|
std::vector<DiveAndLocation> fixes;
|
|
if (cnt == 0)
|
|
return fixes;
|
|
|
|
// create a table with the GPS information
|
|
QList<struct gpsTracker> gpsTable = m_trackers.values();
|
|
|
|
// now walk the dive table and see if we can fill in missing gps data
|
|
struct dive *d;
|
|
for_each_dive(i, d) {
|
|
if (dive_has_gps_location(d))
|
|
continue;
|
|
for (int j = last; j < cnt; j++) {
|
|
if (time_during_dive_with_offset(d, gpsTable[j].when, SAME_GROUP)) {
|
|
if (verbose)
|
|
qDebug() << "processing gpsFix @" << get_dive_date_string(gpsTable[j].when) <<
|
|
"which is withing six hours of dive from" <<
|
|
get_dive_date_string(d->when) << "until" <<
|
|
get_dive_date_string(dive_endtime(d));
|
|
/*
|
|
* If position is fixed during dive. This is the good one.
|
|
* Asign and mark position, and end gps_location loop
|
|
*/
|
|
if (time_during_dive_with_offset(d, gpsTable[j].when, 0)) {
|
|
if (verbose)
|
|
qDebug() << "gpsFix is during the dive, pick that one";
|
|
ADD_LOCATION(d, gpsTable[j], j);
|
|
break;
|
|
} else {
|
|
/*
|
|
* If it is not, check if there are more position fixes in SAME_GROUP range
|
|
*/
|
|
if (j + 1 < cnt && time_during_dive_with_offset(d, gpsTable[j+1].when, SAME_GROUP)) {
|
|
if (verbose)
|
|
qDebug() << "look at the next gps fix @" << get_dive_date_string(gpsTable[j+1].when);
|
|
/* we know the gps fixes are sorted; if they are both before the dive, ignore the first,
|
|
* if theay are both after the dive, take the first,
|
|
* if the first is before and the second is after, take the closer one */
|
|
if (gpsTable[j+1].when < d->when) {
|
|
if (verbose)
|
|
qDebug() << "which is closer to the start of the dive, do continue with that";
|
|
continue;
|
|
} else if (gpsTable[j].when > dive_endtime(d)) {
|
|
if (verbose)
|
|
qDebug() << "which is even later after the end of the dive, so pick the previous one";
|
|
ADD_LOCATION(d, gpsTable[j], j);
|
|
break;
|
|
} else {
|
|
/* ok, gpsFix is before, nextgpsFix is after */
|
|
if (d->when - gpsTable[j].when <= gpsTable[j+1].when - dive_endtime(d)) {
|
|
if (verbose)
|
|
qDebug() << "pick the one before as it's closer to the start";
|
|
ADD_LOCATION(d, gpsTable[j], j);
|
|
break;
|
|
} else {
|
|
if (verbose)
|
|
qDebug() << "pick the one after as it's closer to the start";
|
|
ADD_LOCATION(d, gpsTable[j + 1], j + 1);
|
|
break;
|
|
}
|
|
}
|
|
/*
|
|
* If no more positions in range, the actual is the one. Asign, mark and end loop.
|
|
*/
|
|
} else {
|
|
if (verbose)
|
|
qDebug() << "which seems to be the best one for this dive, so pick it";
|
|
ADD_LOCATION(d, gpsTable[j], j);
|
|
break;
|
|
}
|
|
}
|
|
} else {
|
|
/* If position is out of SAME_GROUP range and in the future, mark position for
|
|
* next dive iteration and end the gps_location loop
|
|
*/
|
|
if (gpsTable[j].when >= dive_endtime(d) + SAME_GROUP) {
|
|
last = j;
|
|
break;
|
|
}
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
return fixes;
|
|
}
|
|
|
|
QMap<qint64, gpsTracker> GpsLocation::currentGPSInfo() const
|
|
{
|
|
return m_trackers;
|
|
}
|
|
|
|
void GpsLocation::loadFromStorage()
|
|
{
|
|
int nr = geoSettings->value(QStringLiteral("count")).toInt();
|
|
for (int i = 0; i < nr; i++) {
|
|
struct gpsTracker gt;
|
|
gt.when = geoSettings->value(QStringLiteral("gpsFix%1_time").arg(i)).toLongLong();
|
|
gt.location.lat.udeg = geoSettings->value(QStringLiteral("gpsFix%1_lat").arg(i)).toInt();
|
|
gt.location.lon.udeg = geoSettings->value(QStringLiteral("gpsFix%1_lon").arg(i)).toInt();
|
|
gt.name = geoSettings->value(QStringLiteral("gpsFix%1_name").arg(i)).toString();
|
|
gt.idx = i;
|
|
m_trackers.insert(gt.when, gt);
|
|
}
|
|
}
|
|
|
|
void GpsLocation::replaceFixToStorage(gpsTracker >)
|
|
{
|
|
if (!m_trackers.keys().contains(gt.when)) {
|
|
addFixToStorage(gt);
|
|
return;
|
|
}
|
|
gpsTracker replacedTracker = m_trackers.value(gt.when);
|
|
geoSettings->setValue(QStringLiteral("gpsFix%1_time").arg(replacedTracker.idx), gt.when);
|
|
geoSettings->setValue(QStringLiteral("gpsFix%1_lat").arg(replacedTracker.idx), gt.location.lat.udeg);
|
|
geoSettings->setValue(QStringLiteral("gpsFix%1_lon").arg(replacedTracker.idx), gt.location.lon.udeg);
|
|
geoSettings->setValue(QStringLiteral("gpsFix%1_name").arg(replacedTracker.idx), gt.name);
|
|
replacedTracker.location = gt.location;
|
|
replacedTracker.name = gt.name;
|
|
}
|
|
|
|
void GpsLocation::addFixToStorage(gpsTracker >)
|
|
{
|
|
int nr = m_trackers.count();
|
|
geoSettings->setValue("count", nr + 1);
|
|
geoSettings->setValue(QStringLiteral("gpsFix%1_time").arg(nr), gt.when);
|
|
geoSettings->setValue(QStringLiteral("gpsFix%1_lat").arg(nr), gt.location.lat.udeg);
|
|
geoSettings->setValue(QStringLiteral("gpsFix%1_lon").arg(nr), gt.location.lon.udeg);
|
|
geoSettings->setValue(QStringLiteral("gpsFix%1_name").arg(nr), gt.name);
|
|
gt.idx = nr;
|
|
geoSettings->sync();
|
|
m_trackers.insert(gt.when, gt);
|
|
}
|
|
|
|
void GpsLocation::deleteFixFromStorage(gpsTracker >)
|
|
{
|
|
qint64 when = gt.when;
|
|
int cnt = m_trackers.count();
|
|
if (cnt == 0 || !m_trackers.keys().contains(when)) {
|
|
qDebug() << "no gps fix with timestamp" << when;
|
|
return;
|
|
}
|
|
if (geoSettings->value(QStringLiteral("gpsFix%1_time").arg(gt.idx)).toLongLong() != when) {
|
|
qDebug() << "uh oh - index for tracker has gotten out of sync...";
|
|
return;
|
|
}
|
|
if (cnt > 1) {
|
|
// now we move the last tracker into that spot (so our settings stay consecutive)
|
|
// and delete the last settings entry
|
|
when = geoSettings->value(QStringLiteral("gpsFix%1_time").arg(cnt - 1)).toLongLong();
|
|
struct gpsTracker movedTracker = m_trackers.value(when);
|
|
movedTracker.idx = gt.idx;
|
|
m_trackers.remove(movedTracker.when);
|
|
m_trackers.insert(movedTracker.when, movedTracker);
|
|
geoSettings->setValue(QStringLiteral("gpsFix%1_time").arg(movedTracker.idx), when);
|
|
geoSettings->setValue(QStringLiteral("gpsFix%1_lat").arg(movedTracker.idx), movedTracker.location.lat.udeg);
|
|
geoSettings->setValue(QStringLiteral("gpsFix%1_lon").arg(movedTracker.idx), movedTracker.location.lon.udeg);
|
|
geoSettings->setValue(QStringLiteral("gpsFix%1_name").arg(movedTracker.idx), movedTracker.name);
|
|
geoSettings->remove(QStringLiteral("gpsFix%1_lat").arg(cnt - 1));
|
|
geoSettings->remove(QStringLiteral("gpsFix%1_lon").arg(cnt - 1));
|
|
geoSettings->remove(QStringLiteral("gpsFix%1_time").arg(cnt - 1));
|
|
geoSettings->remove(QStringLiteral("gpsFix%1_name").arg(cnt - 1));
|
|
}
|
|
geoSettings->setValue("count", cnt - 1);
|
|
geoSettings->sync();
|
|
m_trackers.remove(gt.when);
|
|
}
|
|
|
|
void GpsLocation::deleteGpsFix(qint64 when)
|
|
{
|
|
auto it = m_trackers.find(when);
|
|
if (it == m_trackers.end()) {
|
|
qWarning() << "GpsLocation::deleteGpsFix(): can't find tracker for timestamp " << when;
|
|
return;
|
|
}
|
|
struct gpsTracker deletedTracker = *it;
|
|
deleteFixFromStorage(deletedTracker);
|
|
m_deletedTrackers.append(deletedTracker);
|
|
}
|
|
|
|
#ifdef SUBSURFACE_MOBILE
|
|
void GpsLocation::clearGpsData()
|
|
{
|
|
m_trackers.clear();
|
|
geoSettings->clear();
|
|
geoSettings->sync();
|
|
}
|
|
#endif
|
|
|
|
void GpsLocation::postError(QNetworkReply::NetworkError)
|
|
{
|
|
status(QStringLiteral("error when sending a GPS fix: %1").arg(reply->errorString()));
|
|
}
|