summaryrefslogtreecommitdiffstats
path: root/core/gpslocation.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'core/gpslocation.cpp')
-rw-r--r--core/gpslocation.cpp606
1 files changed, 606 insertions, 0 deletions
diff --git a/core/gpslocation.cpp b/core/gpslocation.cpp
new file mode 100644
index 000000000..8595cc45d
--- /dev/null
+++ b/core/gpslocation.cpp
@@ -0,0 +1,606 @@
+#include "core/gpslocation.h"
+#include "qt-models/gpslistmodel.h"
+#include "core/pref.h"
+#include "core/dive.h"
+#include "core/helpers.h"
+#include <time.h>
+#include <unistd.h>
+#include <QDebug>
+#include <QVariant>
+#include <QUrlQuery>
+#include <QApplication>
+#include <QTimer>
+#include <QJsonDocument>
+#include <QJsonObject>
+#include <QJsonArray>
+
+#define GPS_FIX_ADD_URL "http://api.subsurface-divelog.org/api/dive/add/"
+#define GPS_FIX_DELETE_URL "http://api.subsurface-divelog.org/api/dive/delete/"
+#define GPS_FIX_DOWNLOAD_URL "http://api.subsurface-divelog.org/api/dive/get/"
+#define GET_WEBSERVICE_UID_URL "https://cloud.subsurface-divelog.org/webuserid/"
+
+GpsLocation *GpsLocation::m_Instance = NULL;
+
+GpsLocation::GpsLocation(void (*showMsgCB)(const char *), QObject *parent) : QObject(parent)
+{
+ Q_ASSERT_X(m_Instance == NULL, "GpsLocation", "GpsLocation recreated");
+ m_Instance = this;
+ m_GpsSource = 0;
+ waitingForPosition = false;
+ showMessageCB = showMsgCB;
+ // create a QSettings object that's separate from the main application settings
+ geoSettings = new QSettings(QSettings::NativeFormat, QSettings::UserScope,
+ QString("org.subsurfacedivelog"), QString("subsurfacelocation"), this);
+#ifdef SUBSURFACE_MOBILE
+ if (hasLocationsSource())
+ status(QString("Found GPS with positioning methods %1").arg(QString::number(m_GpsSource->supportedPositioningMethods(), 16)));
+#endif
+ userAgent = getUserAgent();
+ loadFromStorage();
+}
+
+GpsLocation *GpsLocation::instance()
+{
+ Q_ASSERT(m_Instance != NULL);
+
+ return m_Instance;
+}
+
+GpsLocation::~GpsLocation()
+{
+ m_Instance = NULL;
+}
+
+QGeoPositionInfoSource *GpsLocation::getGpsSource()
+{
+ if (!m_GpsSource) {
+ m_GpsSource = QGeoPositionInfoSource::createDefaultSource(this);
+ if (m_GpsSource != 0) {
+#ifndef SUBSURFACE_MOBILE
+ if (verbose)
+#endif
+ status(QString("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()));
+ m_GpsSource->setUpdateInterval(5 * 60 * 1000); // 5 minutes so the device doesn't drain the battery
+ } else {
+#ifdef SUBSURFACE_MOBILE
+ status("don't have GPS source");
+#endif
+ }
+ }
+ return m_GpsSource;
+}
+
+bool GpsLocation::hasLocationsSource()
+{
+ QGeoPositionInfoSource *gpsSource = getGpsSource();
+ return gpsSource != 0 && (gpsSource->supportedPositioningMethods() & QGeoPositionInfoSource::SatellitePositioningMethods);
+}
+
+void GpsLocation::serviceEnable(bool toggle)
+{
+ QGeoPositionInfoSource *gpsSource = getGpsSource();
+ if (!gpsSource) {
+ if (toggle)
+ status("Can't start location service, no location source available");
+ return;
+ }
+ if (toggle) {
+ gpsSource->startUpdates();
+ status(QString("Starting Subsurface GPS service with update interval %1").arg(gpsSource->updateInterval()));
+ } else {
+ gpsSource->stopUpdates();
+ status("Stopping Subsurface GPS service");
+ }
+}
+
+QString GpsLocation::currentPosition()
+{
+ if (!hasLocationsSource())
+ return tr("Unknown GPS location");
+ if (m_trackers.count() && m_trackers.lastKey() + 300 >= QDateTime::currentMSecsSinceEpoch() / 1000) {
+ // we can simply use the last position that we tracked
+ gpsTracker gt = m_trackers.last();
+ QString gpsString = printGPSCoords(gt.latitude.udeg, gt.longitude.udeg);
+ qDebug() << "returning last position" << gpsString;
+ return gpsString;
+ }
+ 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 QString("waiting for the next gps location");
+}
+
+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.latitude.udeg / 1000000.0);
+ lastCoord.setLongitude(gt.longitude.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("received new position %1 after delta %2 threshold %3");
+ status(qPrintable(msg.arg(pos.coordinate().toString()).arg(delta).arg(prefs.time_threshold)));
+ waitingForPosition = false;
+ gpsTracker gt;
+ gt.when = pos.timestamp().toTime_t();
+ gt.when += gettimezoneoffset(gt.when);
+ gt.latitude.udeg = rint(pos.coordinate().latitude() * 1000000);
+ gt.longitude.udeg = rint(pos.coordinate().longitude() * 1000000);
+ addFixToStorage(gt);
+ }
+}
+
+void GpsLocation::updateTimeout()
+{
+ status("request to get new position timed out");
+}
+
+void GpsLocation::status(QString msg)
+{
+ qDebug() << msg;
+ if (showMessageCB)
+ (*showMessageCB)(qPrintable(msg));
+}
+
+QString GpsLocation::getUserid(QString user, QString passwd)
+{
+ qDebug() << "called getUserid";
+ QEventLoop loop;
+ QTimer timer;
+ timer.setSingleShot(true);
+
+ QNetworkAccessManager *manager = new QNetworkAccessManager(qApp);
+ QUrl url(GET_WEBSERVICE_UID_URL);
+ QString data;
+ data = user + " " + passwd;
+ QNetworkRequest request;
+ request.setUrl(url);
+ request.setRawHeader("User-Agent", getUserAgent().toUtf8());
+ request.setRawHeader("Accept", "text/html");
+ request.setRawHeader("Content-type", "application/x-www-form-urlencoded");
+ reply = manager->post(request, data.toUtf8());
+ connect(&timer, &QTimer::timeout, &loop, &QEventLoop::quit);
+ connect(reply, &QNetworkReply::finished, &loop, &QEventLoop::quit);
+ connect(reply, SIGNAL(error(QNetworkReply::NetworkError)),
+ this, SLOT(getUseridError(QNetworkReply::NetworkError)));
+ timer.start(10000);
+ loop.exec();
+ if (timer.isActive()) {
+ timer.stop();
+ if (reply->error() == QNetworkReply::NoError) {
+ QString result = reply->readAll();
+ status(QString("received ") + result);
+ result.remove("WebserviceID:");
+ reply->deleteLater();
+ return result;
+ }
+ } else {
+ status("Getting Web service ID timed out");
+ }
+ reply->deleteLater();
+ return QString();
+}
+
+int GpsLocation::getGpsNum() const
+{
+ return m_trackers.count();
+}
+
+static void copy_gps_location(struct gpsTracker &gps, struct dive *d)
+{
+ struct dive_site *ds = get_dive_site_by_uuid(d->dive_site_uuid);
+ if (!ds) {
+ d->dive_site_uuid = create_dive_site(qPrintable(gps.name), gps.when);
+ ds = get_dive_site_by_uuid(d->dive_site_uuid);
+ }
+ ds->latitude = gps.latitude;
+ ds->longitude = gps.longitude;
+}
+
+#define SAME_GROUP 6 * 3600 /* six hours */
+bool GpsLocation::applyLocations()
+{
+ int i;
+ bool changed = false;
+ int last = 0;
+ int cnt = m_trackers.count();
+ if (cnt == 0)
+ return false;
+
+ // 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(d->when + d->duration.seconds);
+ /*
+ * 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";
+ copy_gps_location(gpsTable[j], d);
+ changed = true;
+ last = 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);
+ /* first let's test if this one is during the dive */
+ if (time_during_dive_with_offset(d, gpsTable[j+1].when, 0)) {
+ if (verbose)
+ qDebug() << "which is during the dive, pick that one";
+ copy_gps_location(gpsTable[j+1], d);
+ changed = true;
+ last = j + 1;
+ break;
+ }
+ /* 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 > d->when + d->duration.seconds) {
+ if (verbose)
+ qDebug() << "which is even later after the end of the dive, so pick the previous one";
+ copy_gps_location(gpsTable[j], d);
+ changed = true;
+ last = j;
+ break;
+ } else {
+ /* ok, gpsFix is before, nextgpsFix is after */
+ if (d->when - gpsTable[j].when <= gpsTable[j+1].when - (d->when + d->duration.seconds)) {
+ if (verbose)
+ qDebug() << "pick the one before as it's closer to the start";
+ copy_gps_location(gpsTable[j], d);
+ changed = true;
+ last = j;
+ break;
+ } else {
+ if (verbose)
+ qDebug() << "pick the one after as it's closer to the start";
+ copy_gps_location(gpsTable[j+1], d);
+ changed = true;
+ last = 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";
+ copy_gps_location(gpsTable[j], d);
+ changed = true;
+ last = 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 >= d->when + d->duration.seconds + SAME_GROUP) {
+ last = j;
+ break;
+ }
+ }
+
+ }
+ }
+ if (changed)
+ mark_divelist_changed(true);
+ return changed;
+}
+
+QMap<qint64, gpsTracker> GpsLocation::currentGPSInfo() const
+{
+ return m_trackers;
+}
+
+void GpsLocation::loadFromStorage()
+{
+ int nr = geoSettings->value(QString("count")).toInt();
+ for (int i = 0; i < nr; i++) {
+ struct gpsTracker gt;
+ gt.when = geoSettings->value(QString("gpsFix%1_time").arg(i)).toLongLong();
+ gt.latitude.udeg = geoSettings->value(QString("gpsFix%1_lat").arg(i)).toInt();
+ gt.longitude.udeg = geoSettings->value(QString("gpsFix%1_lon").arg(i)).toInt();
+ gt.name = geoSettings->value(QString("gpsFix%1_name").arg(i)).toString();
+ gt.idx = i;
+ m_trackers.insert(gt.when, gt);
+ }
+}
+
+void GpsLocation::replaceFixToStorage(gpsTracker &gt)
+{
+ if (!m_trackers.keys().contains(gt.when)) {
+ addFixToStorage(gt);
+ return;
+ }
+ gpsTracker replacedTracker = m_trackers.value(gt.when);
+ geoSettings->setValue(QString("gpsFix%1_time").arg(replacedTracker.idx), gt.when);
+ geoSettings->setValue(QString("gpsFix%1_lat").arg(replacedTracker.idx), gt.latitude.udeg);
+ geoSettings->setValue(QString("gpsFix%1_lon").arg(replacedTracker.idx), gt.longitude.udeg);
+ geoSettings->setValue(QString("gpsFix%1_name").arg(replacedTracker.idx), gt.name);
+ replacedTracker.latitude = gt.latitude;
+ replacedTracker.longitude = gt.longitude;
+ replacedTracker.name = gt.name;
+}
+
+void GpsLocation::addFixToStorage(gpsTracker &gt)
+{
+ int nr = m_trackers.count();
+ geoSettings->setValue("count", nr + 1);
+ geoSettings->setValue(QString("gpsFix%1_time").arg(nr), gt.when);
+ geoSettings->setValue(QString("gpsFix%1_lat").arg(nr), gt.latitude.udeg);
+ geoSettings->setValue(QString("gpsFix%1_lon").arg(nr), gt.longitude.udeg);
+ geoSettings->setValue(QString("gpsFix%1_name").arg(nr), gt.name);
+ gt.idx = nr;
+ geoSettings->sync();
+ m_trackers.insert(gt.when, gt);
+}
+
+void GpsLocation::deleteFixFromStorage(gpsTracker &gt)
+{
+ 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(QString("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(QString("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(QString("gpsFix%1_time").arg(movedTracker.idx), when);
+ geoSettings->setValue(QString("gpsFix%1_lat").arg(movedTracker.idx), movedTracker.latitude.udeg);
+ geoSettings->setValue(QString("gpsFix%1_lon").arg(movedTracker.idx), movedTracker.longitude.udeg);
+ geoSettings->setValue(QString("gpsFix%1_name").arg(movedTracker.idx), movedTracker.name);
+ geoSettings->remove(QString("gpsFix%1_lat").arg(cnt - 1));
+ geoSettings->remove(QString("gpsFix%1_lon").arg(cnt - 1));
+ geoSettings->remove(QString("gpsFix%1_time").arg(cnt - 1));
+ geoSettings->remove(QString("gpsFix%1_name").arg(cnt - 1));
+ }
+ geoSettings->setValue("count", cnt - 1);
+ geoSettings->sync();
+ m_trackers.remove(gt.when);
+}
+
+void GpsLocation::deleteGpsFix(qint64 when)
+{
+ struct gpsTracker defaultTracker;
+ defaultTracker.when = 0;
+ struct gpsTracker deletedTracker = m_trackers.value(when, defaultTracker);
+ if (deletedTracker.when != when) {
+ qDebug() << "can't find tracker for timestamp" << when;
+ return;
+ }
+ deleteFixFromStorage(deletedTracker);
+ m_deletedTrackers.append(deletedTracker);
+}
+
+void GpsLocation::clearGpsData()
+{
+ m_trackers.clear();
+ geoSettings->clear();
+ geoSettings->sync();
+}
+
+void GpsLocation::postError(QNetworkReply::NetworkError error)
+{
+ Q_UNUSED(error);
+ status(QString("error when sending a GPS fix: %1").arg(reply->errorString()));
+}
+
+void GpsLocation::getUseridError(QNetworkReply::NetworkError error)
+{
+ Q_UNUSED(error);
+ status(QString("error when retrieving Subsurface webservice user id: %1").arg(reply->errorString()));
+}
+
+void GpsLocation::deleteFixesFromServer()
+{
+ QEventLoop loop;
+ QTimer timer;
+ timer.setSingleShot(true);
+
+ QNetworkAccessManager *manager = new QNetworkAccessManager(qApp);
+ QUrl url(GPS_FIX_DELETE_URL);
+ QList<qint64> keys = m_trackers.keys();
+ while (!m_deletedTrackers.isEmpty()) {
+ gpsTracker gt = m_deletedTrackers.takeFirst();
+ QDateTime dt;
+ QUrlQuery data;
+ dt.setTime_t(gt.when - gettimezoneoffset(gt.when));
+ data.addQueryItem("login", prefs.userid);
+ data.addQueryItem("dive_date", dt.toString("yyyy-MM-dd"));
+ data.addQueryItem("dive_time", dt.toString("hh:mm"));
+ status(data.toString(QUrl::FullyEncoded).toUtf8());
+ QNetworkRequest request;
+ request.setUrl(url);
+ request.setRawHeader("User-Agent", getUserAgent().toUtf8());
+ request.setRawHeader("Accept", "text/json");
+ request.setRawHeader("Content-type", "application/x-www-form-urlencoded");
+ reply = manager->post(request, data.toString(QUrl::FullyEncoded).toUtf8());
+ connect(&timer, &QTimer::timeout, &loop, &QEventLoop::quit);
+ connect(reply, &QNetworkReply::finished, &loop, &QEventLoop::quit);
+ connect(reply, SIGNAL(error(QNetworkReply::NetworkError)),
+ this, SLOT(postError(QNetworkReply::NetworkError)));
+ timer.start(10000);
+ loop.exec();
+ if (timer.isActive()) {
+ timer.stop();
+ if (reply->error() != QNetworkReply::NoError) {
+ QString response = reply->readAll();
+ status(QString("Server response:") + reply->readAll());
+ }
+ } else {
+ status("Deleting on the server timed out - try again later");
+ m_deletedTrackers.prepend(gt);
+ break;
+ }
+ reply->deleteLater();
+ status(QString("completed deleting gps fix %1 - response: ").arg(gt.idx) + reply->readAll());
+ }
+}
+
+void GpsLocation::uploadToServer()
+{
+ // we want to do this one at a time (the server prefers that)
+ QEventLoop loop;
+ QTimer timer;
+ timer.setSingleShot(true);
+
+ QNetworkAccessManager *manager = new QNetworkAccessManager(qApp);
+ QUrl url(GPS_FIX_ADD_URL);
+ Q_FOREACH(qint64 key, m_trackers.keys()) {
+ struct gpsTracker gt = m_trackers.value(key);
+ QDateTime dt;
+ QUrlQuery data;
+ dt.setTime_t(gt.when - gettimezoneoffset(gt.when));
+ data.addQueryItem("login", prefs.userid);
+ data.addQueryItem("dive_date", dt.toString("yyyy-MM-dd"));
+ data.addQueryItem("dive_time", dt.toString("hh:mm"));
+ data.addQueryItem("dive_latitude", QString::number(gt.latitude.udeg / 1000000.0, 'f', 9));
+ data.addQueryItem("dive_longitude", QString::number(gt.longitude.udeg / 1000000.0, 'f', 9));
+ if (gt.name.isEmpty())
+ gt.name = "Auto-created dive";
+ data.addQueryItem("dive_name", gt.name);
+ status(data.toString(QUrl::FullyEncoded).toUtf8());
+ QNetworkRequest request;
+ request.setUrl(url);
+ request.setRawHeader("User-Agent", getUserAgent().toUtf8());
+ request.setRawHeader("Accept", "text/json");
+ request.setRawHeader("Content-type", "application/x-www-form-urlencoded");
+ reply = manager->post(request, data.toString(QUrl::FullyEncoded).toUtf8());
+ connect(&timer, &QTimer::timeout, &loop, &QEventLoop::quit);
+ connect(reply, &QNetworkReply::finished, &loop, &QEventLoop::quit);
+ // somehoe I cannot get this to work with the new connect syntax:
+ // connect(reply, &QNetworkReply::error, this, &GpsLocation::postError);
+ connect(reply, SIGNAL(error(QNetworkReply::NetworkError)),
+ this, SLOT(postError(QNetworkReply::NetworkError)));
+ timer.start(10000);
+ loop.exec();
+ if (timer.isActive()) {
+ timer.stop();
+ if (reply->error() != QNetworkReply::NoError) {
+ QString response = reply->readAll();
+ if (!response.contains("Duplicate entry")) {
+ status(QString("Server response:") + reply->readAll());
+ break;
+ }
+ }
+ } else {
+ status("Uploading to server timed out");
+ break;
+ }
+ reply->deleteLater();
+ status(QString("completed sending gps fix %1 - response: ").arg(gt.idx) + reply->readAll());
+ }
+ // and now remove the ones that were locally deleted
+ deleteFixesFromServer();
+}
+
+void GpsLocation::downloadFromServer()
+{
+ QEventLoop loop;
+ QTimer timer;
+ timer.setSingleShot(true);
+ QNetworkAccessManager *manager = new QNetworkAccessManager(qApp);
+ QUrl url(QString(GPS_FIX_DOWNLOAD_URL "?login=%1").arg(prefs.userid));
+ QNetworkRequest request;
+ request.setUrl(url);
+ request.setRawHeader("User-Agent", getUserAgent().toUtf8());
+ request.setRawHeader("Accept", "text/json");
+ request.setRawHeader("Content-type", "text/html");
+ qDebug() << "downloadFromServer accessing" << url;
+ reply = manager->get(request);
+ connect(&timer, &QTimer::timeout, &loop, &QEventLoop::quit);
+ connect(reply, &QNetworkReply::finished, &loop, &QEventLoop::quit);
+ connect(reply, SIGNAL(error(QNetworkReply::NetworkError)),
+ this, SLOT(getUseridError(QNetworkReply::NetworkError)));
+ timer.start(10000);
+ loop.exec();
+ if (timer.isActive()) {
+ timer.stop();
+ if (!reply->error()) {
+ QString response = reply->readAll();
+ QJsonDocument json = QJsonDocument::fromJson(response.toLocal8Bit());
+ QJsonObject object = json.object();
+ if (object.value("download").toString() != "ok") {
+ qDebug() << "problems downloading GPS fixes";
+ return;
+ }
+ qDebug() << "already have" << m_trackers.count() << "GPS fixes";
+ QJsonArray downloadedFixes = object.value("dives").toArray();
+ qDebug() << downloadedFixes.count() << "GPS fixes downloaded";
+ for (int i = 0; i < downloadedFixes.count(); i++) {
+ QJsonObject fix = downloadedFixes[i].toObject();
+ QString date = fix.value("date").toString();
+ QString time = fix.value("time").toString();
+ QString name = fix.value("name").toString();
+ QString latitude = fix.value("latitude").toString();
+ QString longitude = fix.value("longitude").toString();
+ QDateTime timestamp = QDateTime::fromString(date + " " + time, "yyyy-M-d hh:m:s");
+
+ struct gpsTracker gt;
+ gt.when = timestamp.toMSecsSinceEpoch() / 1000 + gettimezoneoffset(timestamp.toMSecsSinceEpoch() / 1000);
+ gt.latitude.udeg = latitude.toDouble() * 1000000;
+ gt.longitude.udeg = longitude.toDouble() * 1000000;
+ gt.name = name;
+ // add this GPS fix to the QMap and the settings (remove existing fix at the same timestamp first)
+ if (m_trackers.keys().contains(gt.when)) {
+ qDebug() << "already have a fix at time stamp" << gt.when;
+ replaceFixToStorage(gt);
+ } else {
+ addFixToStorage(gt);
+ }
+ }
+ } else {
+ qDebug() << "network error" << reply->error() << reply->errorString() << reply->readAll();
+ }
+ } else {
+ qDebug() << "download timed out";
+ status("Download from server timed out");
+ }
+ reply->deleteLater();
+}
generated by cgit v1.2.3-70-g09d2 (git 2.47.0) at 2024-12-29 01:38:13 +0000