diff --git a/app/CMakeLists.txt b/app/CMakeLists.txt index e474aa9b2..00c0041cc 100644 --- a/app/CMakeLists.txt +++ b/app/CMakeLists.txt @@ -32,8 +32,10 @@ set(MM_SRCS ios/iosutils.cpp position/providers/abstractpositionprovider.cpp position/providers/internalpositionprovider.cpp + position/providers/networkpositionprovider.cpp position/providers/positionprovidersmodel.cpp position/providers/simulatedpositionprovider.cpp + position/providers/nmeaparser.cpp position/tracking/abstracttrackingbackend.cpp position/tracking/internaltrackingbackend.cpp position/tracking/positiontrackinghighlight.cpp @@ -122,8 +124,10 @@ set(MM_HDRS ios/iosutils.h position/providers/abstractpositionprovider.h position/providers/internalpositionprovider.h + position/providers/networkpositionprovider.h position/providers/positionprovidersmodel.h position/providers/simulatedpositionprovider.h + position/providers/nmeaparser.h position/tracking/abstracttrackingbackend.h position/tracking/internaltrackingbackend.h position/tracking/positiontrackinghighlight.h diff --git a/app/appsettings.cpp b/app/appsettings.cpp index 58e340ec1..e781e108a 100644 --- a/app/appsettings.cpp +++ b/app/appsettings.cpp @@ -215,6 +215,7 @@ QVariantList AppSettings::savedPositionProviders() const QStringList provider; provider << settings.value( "providerName" ).toString(); provider << settings.value( "providerAddress" ).toString(); + provider << settings.value( "providerType" ).toString(); providers.push_back( provider ); } @@ -238,15 +239,16 @@ void AppSettings::savePositionProviders( const QVariantList &providers ) { QVariantList provider = providers[i].toList(); - if ( provider.length() < 2 ) + if ( provider.length() < 3 ) { CoreUtils::log( QStringLiteral( "AppSettings" ), QStringLiteral( "Tried to save provider without sufficient data" ) ); continue; } settings.setArrayIndex( i ); - settings.setValue( "providerName", providers[i].toList()[0] ); - settings.setValue( "providerAddress", providers[i].toList()[1] ); + settings.setValue( "providerName", provider[0] ); + settings.setValue( "providerAddress", provider[1] ); + settings.setValue( "providerType", provider[2] ); } settings.endArray(); } diff --git a/app/position/positionkit.cpp b/app/position/positionkit.cpp index 7ef76d3a7..51d8f207c 100644 --- a/app/position/positionkit.cpp +++ b/app/position/positionkit.cpp @@ -18,6 +18,7 @@ #include "position/providers/internalpositionprovider.h" #include "position/providers/simulatedpositionprovider.h" +#include "providers/networkpositionprovider.h" #ifdef ANDROID #include "position/providers/androidpositionprovider.h" #include @@ -122,13 +123,12 @@ AbstractPositionProvider *PositionKit::constructProvider( const QString &type, c { QString providerType( type ); - // currently the only external provider is bluetooth, so manually set internal provider for platforms that - // do not support reading bluetooth serial + // set internal provider for platforms that do not support reading bluetooth serial #ifndef HAVE_BLUETOOTH providerType = QStringLiteral( "internal" ); #endif - if ( providerType == QStringLiteral( "external" ) ) + if ( providerType == QStringLiteral( "external_bt" ) ) { #ifdef HAVE_BLUETOOTH AbstractPositionProvider *provider = new BluetoothPositionProvider( id, name, *mPositionTransformer ); @@ -136,39 +136,46 @@ AbstractPositionProvider *PositionKit::constructProvider( const QString &type, c return provider; #endif } - else // type == internal + + if ( providerType == QStringLiteral( "external_ip" ) ) { - if ( id == QStringLiteral( "simulated" ) ) - { - AbstractPositionProvider *provider = new SimulatedPositionProvider( *mPositionTransformer ); - QQmlEngine::setObjectOwnership( provider, QQmlEngine::CppOwnership ); - return provider; - } + AbstractPositionProvider *provider = new NetworkPositionProvider( id, name, *mPositionTransformer ); + QQmlEngine::setObjectOwnership( provider, QQmlEngine::CppOwnership ); + return provider; + } + + // type == internal + if ( id == QStringLiteral( "simulated" ) ) + { + AbstractPositionProvider *provider = new SimulatedPositionProvider( *mPositionTransformer ); + QQmlEngine::setObjectOwnership( provider, QQmlEngine::CppOwnership ); + return provider; + } #ifdef ANDROID - if ( id == QStringLiteral( "android_fused" ) || id == QStringLiteral( "android_gps" ) ) + if ( id == QStringLiteral( "android_fused" ) || id == QStringLiteral( "android_gps" ) ) + { + const bool fused = ( id == QStringLiteral( "android_fused" ) ); + if ( fused && !AndroidPositionProvider::isFusedAvailable() ) { - const bool fused = ( id == QStringLiteral( "android_fused" ) ); - if ( fused && !AndroidPositionProvider::isFusedAvailable() ) - { - // TODO: inform user + use AndroidPositionProvider::fusedErrorString() output? + // TODO: inform user + use AndroidPositionProvider::fusedErrorString() output? - // fallback to the default - at this point the Qt Positioning implementation - AbstractPositionProvider *provider = new InternalPositionProvider( *mPositionTransformer ); - QQmlEngine::setObjectOwnership( provider, QQmlEngine::CppOwnership ); - return provider; - } - __android_log_print( ANDROID_LOG_INFO, "CPP", "MAKE PROVIDER %d", fused ); - AbstractPositionProvider *provider = new AndroidPositionProvider( fused, *mPositionTransformer ); - QQmlEngine::setObjectOwnership( provider, QQmlEngine::CppOwnership ); - return provider; - } -#endif - else // id == devicegps - { + // fallback to the default - at this point the Qt Positioning implementation AbstractPositionProvider *provider = new InternalPositionProvider( *mPositionTransformer ); QQmlEngine::setObjectOwnership( provider, QQmlEngine::CppOwnership ); return provider; } + __android_log_print( ANDROID_LOG_INFO, "CPP", "MAKE PROVIDER %d", fused ); + AbstractPositionProvider *provider = new AndroidPositionProvider( fused, *mPositionTransformer ); + QQmlEngine::setObjectOwnership( provider, QQmlEngine::CppOwnership ); + return provider; + } +#endif + + // id == devicegps + { + AbstractPositionProvider *provider = new InternalPositionProvider( *mPositionTransformer ); + QQmlEngine::setObjectOwnership( provider, QQmlEngine::CppOwnership ); + return provider; } } @@ -201,8 +208,10 @@ AbstractPositionProvider *PositionKit::constructActiveProvider( AppSettings *app } else { - // find name of the active provider + // find name & type of the active provider QString providerName; + // Migration from single external provider to multiple currently, missing type == bluetooth provider + QString providerType = QStringLiteral( "external_bt" ); QVariantList providers = appsettings->savedPositionProviders(); for ( const auto &provider : providers ) @@ -217,10 +226,14 @@ AbstractPositionProvider *PositionKit::constructActiveProvider( AppSettings *app if ( providerData[1] == providerId ) { providerName = providerData[0].toString(); + if ( !providerData.at( 2 ).isNull() ) + { + providerType = providerData[2].toString(); + } } } - return constructProvider( QStringLiteral( "external" ), providerId, providerName ); + return constructProvider( providerType, providerId, providerName ); } } diff --git a/app/position/positiontransformer.cpp b/app/position/positiontransformer.cpp index 2c4dc9b90..60b7b9470 100644 --- a/app/position/positiontransformer.cpp +++ b/app/position/positiontransformer.cpp @@ -45,6 +45,11 @@ GeoPosition PositionTransformer::processBluetoothPosition( GeoPosition geoPositi return geoPosition; } +GeoPosition PositionTransformer::processNetworkPosition( const GeoPosition &geoPosition ) +{ + return processBluetoothPosition( geoPosition ); +} + GeoPosition PositionTransformer::processAndroidPosition( GeoPosition geoPosition ) { if ( geoPosition.elevation != std::numeric_limits::quiet_NaN() ) diff --git a/app/position/positiontransformer.h b/app/position/positiontransformer.h index fb9a62250..e77519263 100644 --- a/app/position/positiontransformer.h +++ b/app/position/positiontransformer.h @@ -49,6 +49,14 @@ class PositionTransformer : QObject */ GeoPosition processBluetoothPosition( GeoPosition geoPosition ); + /** + * Transform the elevation if the user sets custom vertical CRS. The elevation gets recalculated to ellipsoid elevation + * and then back to orthometric based on specified CRS. + * \note This method should be used only with NetworkPositionProvider to mitigate unnecessary transformations + * \return Copy of passed geoPosition with processed elevation and elevation separation. + */ + GeoPosition processNetworkPosition( const GeoPosition &geoPosition ); + /** * Transform the elevation from EPSG:4979 (WGS84 (EPSG:4326) + ellipsoidal height) to specified geoid model * (by default EPSG:9707 (WGS84 + EGM96)) diff --git a/app/position/providers/bluetoothpositionprovider.cpp b/app/position/providers/bluetoothpositionprovider.cpp index 167750d48..380c595fe 100644 --- a/app/position/providers/bluetoothpositionprovider.cpp +++ b/app/position/providers/bluetoothpositionprovider.cpp @@ -19,19 +19,8 @@ #include #endif -NmeaParser::NmeaParser() : QgsNmeaConnection( new QBluetoothSocket() ) -{ -} - -QgsGpsInformation NmeaParser::parseNmeaString( const QString &nmeaString ) -{ - mStringBuffer = nmeaString; - processStringBuffer(); - return mLastGPSInformation; -} - BluetoothPositionProvider::BluetoothPositionProvider( const QString &addr, const QString &name, PositionTransformer &positionTransformer, QObject *parent ) - : AbstractPositionProvider( addr, QStringLiteral( "external" ), name, positionTransformer, parent ) + : AbstractPositionProvider( addr, QStringLiteral( "external_bt" ), name, positionTransformer, parent ) , mTargetAddress( addr ) { mSocket = std::unique_ptr( new QBluetoothSocket( QBluetoothServiceInfo::RfcommProtocol ) ); @@ -214,6 +203,6 @@ void BluetoothPositionProvider::positionUpdateReceived() GeoPosition positionData = GeoPosition::fromQgsGpsInformation( data ); GeoPosition transformedPosition = mPositionTransformer->processBluetoothPosition( positionData ); - emit positionChanged( positionData ); + emit positionChanged( transformedPosition ); } } diff --git a/app/position/providers/bluetoothpositionprovider.h b/app/position/providers/bluetoothpositionprovider.h index 4670131da..8797c8ec1 100644 --- a/app/position/providers/bluetoothpositionprovider.h +++ b/app/position/providers/bluetoothpositionprovider.h @@ -10,29 +10,12 @@ #ifndef BLUETOOTHPOSITIONPROVIDER_H #define BLUETOOTHPOSITIONPROVIDER_H -#include "abstractpositionprovider.h" - -#include "qgsnmeaconnection.h" - #include #include #include -/** - * NmeaParser is a big hack how to reuse QGIS NmeaConnection function in order to (a) keep ownership of bluetooth - * socket, (b) do not have multiple unique_ptrs holding the same pointer and to avoid some possible crashes. - * - * Note: This way of reusing makes the parser highly dependent on QgsNmeaConnection class and any change inside the class - * can lead to misbehavior's. See implementation of QgsNmeaConnection and QgsGpsConnection for more details. - */ -class NmeaParser : public QgsNmeaConnection -{ - public: - NmeaParser(); - - // Takes nmea string and returns gps position - QgsGpsInformation parseNmeaString( const QString &nmeaString ); -}; +#include "abstractpositionprovider.h" +#include "nmeaparser.h" /** * BluetoothPositionProvider initiates connection to bluetooth device diff --git a/app/position/providers/networkpositionprovider.cpp b/app/position/providers/networkpositionprovider.cpp new file mode 100644 index 000000000..fbe533b65 --- /dev/null +++ b/app/position/providers/networkpositionprovider.cpp @@ -0,0 +1,208 @@ +/*************************************************************************** +* * + * This program is free software; you can redistribute it and/or modify * + * it under the terms of the GNU General Public License as published by * + * the Free Software Foundation; either version 2 of the License, or * + * (at your option) any later version. * + * * + ***************************************************************************/ + +#include "networkpositionprovider.h" + +#include +#include + +static int ONE_SECOND_MS = 1000; + +NetworkPositionProvider::NetworkPositionProvider( const QString &addr, const QString &name, PositionTransformer &positionTransformer, QObject *parent ) + : AbstractPositionProvider( addr, QStringLiteral( "external_ip" ), name, positionTransformer, parent ), + mSecondsLeftToReconnect( ReconnectDelay::ShortDelay / ONE_SECOND_MS ) +{ + const QStringList targetAddress = addr.split( ":" ); + mTargetAddress = targetAddress.at( 0 ); + mTargetPort = targetAddress.at( 1 ).toInt(); + + mTcpSocket = std::make_unique(); + mUdpSocket = std::make_unique(); + + connect( mTcpSocket.get(), &QTcpSocket::readyRead, this, &NetworkPositionProvider::positionUpdateReceived ); + connect( mUdpSocket.get(), &QUdpSocket::readyRead, this, &NetworkPositionProvider::positionUpdateReceived ); + + connect( mTcpSocket.get(), &QTcpSocket::stateChanged, this, &NetworkPositionProvider::socketStateChanged ); + connect( mUdpSocket.get(), &QUdpSocket::stateChanged, this, &NetworkPositionProvider::socketStateChanged ); + + mReconnectTimer.setSingleShot( false ); + mReconnectTimer.setInterval( ONE_SECOND_MS ); + connect( &mReconnectTimer, &QTimer::timeout, this, &NetworkPositionProvider::reconnectTimeout ); + mUdpReconnectTimer.setSingleShot( true ); + connect( &mUdpReconnectTimer, &QTimer::timeout, this, [this] + { + if ( mTcpSocket->state() != QAbstractSocket::ConnectedState ) + { + setState( tr( "No connection" ), State::NoConnection ); + startReconnectTimer(); + // let's also invalidate current position since we no longer have connection + emit positionChanged( GeoPosition() ); + } + } ); + + NetworkPositionProvider::startUpdates(); +} + +void NetworkPositionProvider::startUpdates() +{ + // TODO: QHostAddress doesn't support hostname lookup (QHostInfo does) + mTcpSocket->connectToHost( mTargetAddress, mTargetPort ); + mUdpSocket->bind( QHostAddress::LocalHost, mTargetPort ); + mUdpReconnectTimer.start( ReconnectDelay::ExtraLongDelay ); +} + +void NetworkPositionProvider::stopUpdates() +{ + if ( mTcpSocket->state() != QAbstractSocket::UnconnectedState && mTcpSocket->state() != QAbstractSocket::ClosingState ) + { + mTcpSocket->disconnectFromHost(); + } + if ( mUdpSocket->state() != QAbstractSocket::UnconnectedState && mUdpSocket->state() != QAbstractSocket::ClosingState ) + { + mUdpSocket->disconnectFromHost(); + } +} + +void NetworkPositionProvider::closeProvider() +{ + mTcpSocket->close(); + mUdpSocket->close(); +} + +void NetworkPositionProvider::positionUpdateReceived() +{ + QAbstractSocket *socket = dynamic_cast( sender() ); + const QString socketTypeToString = QMetaEnum::fromType().valueToKey( socket->socketType() ); + + // if udp is not connected to the host yet, connect + // this approach will let us use QIODevice functions for both sockets + if ( socket->socketType() == QAbstractSocket::UdpSocket && mUdpSocket->state() != QAbstractSocket::ConnectedState ) + { + mUdpReconnectTimer.stop(); + + // if by any chance we showed wrong message in the status like "no connection", fix it here + // we know the connection is working because we just received data from the device + setState( tr( "Connected" ), State::Connected ); + + QHostAddress peerAddress; + int peerPort; + // process the incoming data as it will break the signal emitting if unprocessed + while ( mUdpSocket->hasPendingDatagrams() ) + { + QNetworkDatagram datagram = mUdpSocket->receiveDatagram(); + peerAddress = datagram.senderAddress(); + peerPort = datagram.senderPort(); + const QByteArray rawNmeaData = datagram.data(); + const QString nmeaData( rawNmeaData ); + const QgsGpsInformation gpsInfo = mNmeaParser.parseNmeaString( nmeaData ); + GeoPosition transformedPosition = mPositionTransformer->processNetworkPosition( GeoPosition::fromQgsGpsInformation( gpsInfo ) ); + + emit positionChanged( transformedPosition ); + } + + // "connect" to peer if we are not already connecting + if ( mUdpSocket->state() != QAbstractSocket::ConnectedState && mUdpSocket->state() != QAbstractSocket::ConnectingState ) + { + mUdpSocket->connectToHost( peerAddress.toString(), peerPort ); + } + return; + } + + // stop the UDP silence timer, we just received data + // kills the timer when the app was minimized, and we were able to reconnect in the meantime + if ( socket->socketType() == QAbstractSocket::UdpSocket ) + { + mUdpReconnectTimer.stop(); + } + + // if by any chance we showed wrong message in the status like "no connection", fix it here + // we know the connection is working because we just received data from the device + setState( tr( "Connected" ), State::Connected ); + + const QByteArray rawNmeaData = socket->readAll(); + const QString nmeaData( rawNmeaData ); + const QgsGpsInformation gpsInfo = mNmeaParser.parseNmeaString( nmeaData ); + GeoPosition transformedPosition = mPositionTransformer->processNetworkPosition( GeoPosition::fromQgsGpsInformation( gpsInfo ) ); + + emit positionChanged( GeoPosition::fromQgsGpsInformation( gpsInfo ) ); +} + +void NetworkPositionProvider::socketStateChanged( const QAbstractSocket::SocketState state ) +{ + const QAbstractSocket *socket = dynamic_cast( sender() ); + + if ( state == QAbstractSocket::ConnectingState || state == QAbstractSocket::HostLookupState ) + { + setState( tr( "Connecting to %1" ).arg( mProviderName ), State::Connecting ); + } + // Only with TCP we can be sure in ConnectedState that we are connected, with UDP we wait until the first datagram arrives + else if ( state == QAbstractSocket::ConnectedState && socket->socketType() == QAbstractSocket::TcpSocket ) + { + setState( tr( "Connected" ), State::Connected ); + } + else if ( state == QAbstractSocket::UnconnectedState ) + { + const bool isUdpSocketListening = mUdpSocket->state() == QAbstractSocket::ConnectedState || mUdpSocket->state() == QAbstractSocket::BoundState || mUdpReconnectTimer.isActive(); + if ( socket->socketType() == QAbstractSocket::TcpSocket && !isUdpSocketListening && QApplication::applicationState() == Qt::ApplicationActive ) + { + setState( tr( "No connection" ), State::NoConnection ); + startReconnectTimer(); + // let's also invalidate current position since we no longer have connection + emit positionChanged( GeoPosition() ); + } + else if ( socket->socketType() == QAbstractSocket::UdpSocket && QApplication::applicationState() == Qt::ApplicationActive ) + { + setState( tr( "No connection" ), State::NoConnection ); + startReconnectTimer(); + // let's also invalidate current position since we no longer have connection + emit positionChanged( GeoPosition() ); + } + } + + const QString socketTypeToString = QMetaEnum::fromType().valueToKey( socket->socketType() ); + const QString stateToString = QMetaEnum::fromType().valueToKey( state ); +} + +void NetworkPositionProvider::reconnectTimeout() +{ + if ( mSecondsLeftToReconnect <= 1 ) + { + reconnect(); + } + else + { + mSecondsLeftToReconnect--; + setState( tr( "No connection, reconnecting in (%1)" ).arg( mSecondsLeftToReconnect ), State::WaitingToReconnect ); + mReconnectTimer.start(); + } +} + +void NetworkPositionProvider::reconnect() +{ + mReconnectTimer.stop(); + + setState( tr( "Reconnecting" ), State::Connecting ); + + stopUpdates(); + startUpdates(); +} + +void NetworkPositionProvider::startReconnectTimer() +{ + mSecondsLeftToReconnect = mReconnectDelay / ONE_SECOND_MS; + setState( tr( "No connection, reconnecting in (%1)" ).arg( mSecondsLeftToReconnect ), State::WaitingToReconnect ); + + mReconnectTimer.start(); + + // first time do reconnect in short time, then each other in long time + if ( mReconnectDelay == NetworkPositionProvider::ShortDelay ) + { + mReconnectDelay = NetworkPositionProvider::LongDelay; + } +} diff --git a/app/position/providers/networkpositionprovider.h b/app/position/providers/networkpositionprovider.h new file mode 100644 index 000000000..9d4bc080f --- /dev/null +++ b/app/position/providers/networkpositionprovider.h @@ -0,0 +1,68 @@ +/*************************************************************************** +* * + * This program is free software; you can redistribute it and/or modify * + * it under the terms of the GNU General Public License as published by * + * the Free Software Foundation; either version 2 of the License, or * + * (at your option) any later version. * + * * + ***************************************************************************/ + + +#ifndef NETWORKPOSITIONPROVIDER_H +#define NETWORKPOSITIONPROVIDER_H + +#include +#include +#include + +#include "abstractpositionprovider.h" +#include "nmeaparser.h" + + +class NetworkPositionProvider : public AbstractPositionProvider +{ + Q_OBJECT + + // signalizes in how many [ms] we will try to reconnect to GPS again + enum ReconnectDelay + { + ShortDelay = 3000, // 3 secs + LongDelay = 5000, // 5 secs + ExtraLongDelay = 10000 // 10 secs + }; + + public: + NetworkPositionProvider( const QString &addr, const QString &name, PositionTransformer &positionTransformer, QObject *parent = nullptr ); + + void startUpdates() override; + void stopUpdates() override; + void closeProvider() override; + + public slots: + // processes the received nmea data and emits new position + void positionUpdateReceived(); + // changes the provider state depending on the socket states + void socketStateChanged( QAbstractSocket::SocketState state ); + // checks if enough time passed since last reconnect and triggers it if necessary + void reconnectTimeout(); + + private: + // trigger the reconnection flow for both sockets + void reconnect(); + // start the reconnection timeout + void startReconnectTimer(); + + std::unique_ptr mTcpSocket; + std::unique_ptr mUdpSocket; + + int mReconnectDelay = ReconnectDelay::ShortDelay; // in how many [ms] we will try to reconnect again + int mSecondsLeftToReconnect; // how many seconds are left to reconnect. Reconnects if less than or equal to one + QTimer mReconnectTimer; // timer that times out each second and lowers the mSecondsLeftToReconnect by one + QTimer mUdpReconnectTimer; // timer that times out after ExtraLongDelay and triggers reconnect + + QString mTargetAddress; // IP address or hostname of the receiver + int mTargetPort; // active port of the receiver + + NmeaParser mNmeaParser; // parser to decode received NMEA strings +}; +#endif //NETWORKPOSITIONPROVIDER_H diff --git a/app/position/providers/nmeaparser.cpp b/app/position/providers/nmeaparser.cpp new file mode 100644 index 000000000..69a8f1015 --- /dev/null +++ b/app/position/providers/nmeaparser.cpp @@ -0,0 +1,23 @@ +/*************************************************************************** +* * + * This program is free software; you can redistribute it and/or modify * + * it under the terms of the GNU General Public License as published by * + * the Free Software Foundation; either version 2 of the License, or * + * (at your option) any later version. * + * * + ***************************************************************************/ + +#include "nmeaparser.h" + +#include + +NmeaParser::NmeaParser() : QgsNmeaConnection( new QBuffer() ) +{ +} + +QgsGpsInformation NmeaParser::parseNmeaString( const QString &nmeaString ) +{ + mStringBuffer = nmeaString; + processStringBuffer(); + return mLastGPSInformation; +} \ No newline at end of file diff --git a/app/position/providers/nmeaparser.h b/app/position/providers/nmeaparser.h new file mode 100644 index 000000000..fc47d7e82 --- /dev/null +++ b/app/position/providers/nmeaparser.h @@ -0,0 +1,32 @@ +/*************************************************************************** +* * + * This program is free software; you can redistribute it and/or modify * + * it under the terms of the GNU General Public License as published by * + * the Free Software Foundation; either version 2 of the License, or * + * (at your option) any later version. * + * * + ***************************************************************************/ + +#ifndef NMEAPARSER_H +#define NMEAPARSER_H + +#include + +/** + * NmeaParser is a big hack how to reuse QGIS NmeaConnection function in order to (a) keep ownership of bluetooth + * socket, (b) do not have multiple unique_ptrs holding the same pointer and to avoid some possible crashes. + * + * Note: This way of reusing makes the parser highly dependent on QgsNmeaConnection class and any change inside the class + * can lead to misbehavior's. See implementation of QgsNmeaConnection and QgsGpsConnection for more details. + */ +class NmeaParser : public QgsNmeaConnection +{ + public: + NmeaParser(); + +// Takes nmea string and returns gps position + QgsGpsInformation parseNmeaString( const QString &nmeaString ); +}; + + +#endif //NMEAPARSER_H \ No newline at end of file diff --git a/app/position/providers/positionprovidersmodel.cpp b/app/position/providers/positionprovidersmodel.cpp index e070e4576..c9a91b6ea 100644 --- a/app/position/providers/positionprovidersmodel.cpp +++ b/app/position/providers/positionprovidersmodel.cpp @@ -134,16 +134,17 @@ void PositionProvidersModel::removeProvider( const QString &providerId ) } } -void PositionProvidersModel::addProvider( const QString &name, const QString &providerId ) +void PositionProvidersModel::addProvider( const QString &name, const QString &providerId, const QString &providerType ) { if ( providerId.isEmpty() ) return; PositionProvider toAdd; + const QString deviceDesc = providerType == QStringLiteral( "external_bt" ) ? tr( " Bluetooth device" ) : tr( " Network device" ); toAdd.name = name; toAdd.providerId = providerId; - toAdd.description = providerId + " " + tr( " Bluetooth device" ); - toAdd.providerType = "external"; + toAdd.description = providerId + " " + deviceDesc; + toAdd.providerType = providerType; if ( mProviders.contains( toAdd ) ) return; @@ -196,10 +197,12 @@ void PositionProvidersModel::setAppSettings( AppSettings *as ) } PositionProvider provider; + const QString providerType = providerData[2].isNull() ? QStringLiteral( "external_bt" ) : QStringLiteral( "external_ip" ); + const QString deviceDesc = providerType == QStringLiteral( "external_bt" ) ? tr( " Bluetooth device" ) : tr( " Network device" ); provider.name = providerData[0].toString(); provider.providerId = providerData[1].toString(); - provider.description = provider.providerId + " " + tr( "Bluetooth device" ); - provider.providerType = "external"; + provider.description = provider.providerId + deviceDesc; + provider.providerType = providerType; mProviders.append( provider ); } @@ -218,8 +221,8 @@ QVariantList PositionProvidersModel::toVariantList() const if ( mProviders[i].providerType == QStringLiteral( "internal" ) ) continue; - QStringList a = { mProviders[i].name, mProviders[i].providerId }; - out.push_back( a ); + QStringList provider = { mProviders[i].name, mProviders[i].providerId, mProviders[i].providerType }; + out.push_back( provider ); } return out; diff --git a/app/position/providers/positionprovidersmodel.h b/app/position/providers/positionprovidersmodel.h index dc24171fe..a05589504 100644 --- a/app/position/providers/positionprovidersmodel.h +++ b/app/position/providers/positionprovidersmodel.h @@ -67,7 +67,7 @@ class PositionProvidersModel : public QAbstractListModel QVariant data( const QModelIndex &index, int role = Qt::DisplayRole ) const override; Q_INVOKABLE void removeProvider( const QString &providerId ); - Q_INVOKABLE void addProvider( const QString &providerName, const QString &providerId ); + Q_INVOKABLE void addProvider( const QString &providerName, const QString &providerId, const QString &providerType ); AppSettings *appSettings() const; void setAppSettings( AppSettings * ); diff --git a/app/qml/gps/MMGpsDataDrawer.qml b/app/qml/gps/MMGpsDataDrawer.qml index 8518f0770..ebbd7f4c4 100644 --- a/app/qml/gps/MMGpsDataDrawer.qml +++ b/app/qml/gps/MMGpsDataDrawer.qml @@ -73,7 +73,7 @@ MMComponents.MMDrawer { width: parent.width / 2 - visible: PositionKit.positionProvider && PositionKit.positionProvider.type() === "external" + visible: PositionKit.positionProvider && PositionKit.positionProvider.type().includes("external") title: qsTr( "Status" ) value: PositionKit.positionProvider ? PositionKit.positionProvider.stateMessage : "" @@ -214,7 +214,7 @@ MMComponents.MMDrawer { PositionKit.fix } - visible: PositionKit.positionProvider && PositionKit.positionProvider.type() === "external" + visible: PositionKit.positionProvider && PositionKit.positionProvider.type().includes("external") alignmentRight: Positioner.index % 2 === 1 } @@ -247,7 +247,7 @@ MMComponents.MMDrawer { __inputUtils.formatNumber( PositionKit.hdop, 2 ) } - visible: PositionKit.positionProvider && PositionKit.positionProvider.type() === "external" + visible: PositionKit.positionProvider && PositionKit.positionProvider.type().includes("external") alignmentRight: Positioner.index % 2 === 1 } @@ -264,7 +264,7 @@ MMComponents.MMDrawer { __inputUtils.formatNumber( PositionKit.vdop, 2 ) } - visible: PositionKit.positionProvider && PositionKit.positionProvider.type() === "external" + visible: PositionKit.positionProvider && PositionKit.positionProvider.type().includes("external") alignmentRight: Positioner.index % 2 === 1 } @@ -281,7 +281,7 @@ MMComponents.MMDrawer { __inputUtils.formatNumber( PositionKit.pdop, 2 ) } - visible: PositionKit.positionProvider && PositionKit.positionProvider.type() === "external" + visible: PositionKit.positionProvider && PositionKit.positionProvider.type().includes("external") alignmentRight: Positioner.index % 2 === 1 } diff --git a/app/qml/gps/MMPositionProviderPage.qml b/app/qml/gps/MMPositionProviderPage.qml index c98d9a0c8..89cd58ae4 100644 --- a/app/qml/gps/MMPositionProviderPage.qml +++ b/app/qml/gps/MMPositionProviderPage.qml @@ -8,6 +8,7 @@ ***************************************************************************/ import QtQuick +import QtQml.Models import QtQuick.Controls import QtQuick.Dialogs @@ -16,6 +17,7 @@ import MMInput import "../components" as MMComponents import "../dialogs" as MMDialogs +import "../inputs" as MMInputs MMComponents.MMPage { id: root @@ -94,7 +96,7 @@ MMComponents.MMPage { if ( ListView.section === "internal" ) { let ix = providersModel.index( index + 1, 0 ) let type = providersModel.data( ix, MM.PositionProvidersModel.ProviderType ) - if ( type === "external" ) return false + if ( type.includes("external") ) return false } return true @@ -135,7 +137,95 @@ MMComponents.MMPage { text: qsTr( "Connect new receiver" ) - onClicked: bluetoothDiscoveryLoader.active = true + onClicked: providerTypeDrawer.open() + } + + MMComponents.MMListDrawer { + id: providerTypeDrawer + + drawerHeader.title: qsTr("Pick the correct provider type") + drawerHeader.titleFont: __style.t2 + + list.model: ListModel { + ListElement { + name: qsTr( "Bluetooth provider" ) + type: "bluetooth" + } + ListElement { + name: qsTr( "Network provider" ) + type: "network" + } + } + + list.delegate: MMComponents.MMListDelegate { + required property string name + required property string type + + text: name + onClicked: { + providerTypeDrawer.close() + if (type === "bluetooth") { + bluetoothDiscoveryLoader.active = true + } + else if (type === "network"){ + networkProviderInfoDrawer.open() + } + } + } + } + + MMComponents.MMDrawerDialog { + id: networkProviderInfoDrawer + + title: qsTr("Network provider setup") + imageSource: __style.externalGpsGreenImage + description: qsTr( "To connect to the external device please specify the IP address and port below." ) + primaryButton.text: qsTr( "Confirm" ) + primaryButton.type: MMComponents.MMButton.Primary + + additionalContent: Column { + width: parent.width + spacing: __style.spacing20 + + MMInputs.MMTextInput { + id: aliasInput + + width: parent.width + textFieldBackground.color: __style.lightGreenColor + + title: qsTr("Device alias") + placeholderText: qsTr("Green device") + } + + MMInputs.MMTextInput { + id: ipAddressInput + + width: parent.width + textFieldBackground.color: __style.lightGreenColor + + title: qsTr("IP address") + placeholderText: qsTr("localhost") + } + + MMInputs.MMTextInput { + id: portInput + + width: parent.width + textFieldBackground.color: __style.lightGreenColor + + title: qsTr("Port") + placeholderText: qsTr("1234") + } + } + + onPrimaryButtonClicked: function() { + close() + + const deviceAddress = ipAddressInput.text + ":" + portInput.text + __positionKit.positionProvider = __positionKit.constructProvider( "external_ip", deviceAddress, aliasInput.text ) + + providersModel.addProvider( aliasInput.text, deviceAddress, "external_ip" ) + } } MMComponents.MMMessage { @@ -205,9 +295,9 @@ MMComponents.MMPage { MMAddPositionProviderDrawer { onInitiatedConnectionTo: function ( deviceAddress, deviceName ) { - PositionKit.positionProvider = PositionKit.constructProvider( "external", deviceAddress, deviceName ) + PositionKit.positionProvider = PositionKit.constructProvider( "external_bt", deviceAddress, deviceName ) - providersModel.addProvider( deviceName, deviceAddress ) + providersModel.addProvider( deviceName, deviceAddress, "external_bt" ) list.model.discovering = false close() @@ -239,7 +329,7 @@ MMComponents.MMPage { } function constructProvider( type, id, name ) { - if ( type === "external" ) { + if ( type === "external_bt" ) { // Is bluetooth turned on? if ( !__inputUtils.isBluetoothTurnedOn() ) { __inputUtils.turnBluetoothOn() @@ -253,7 +343,7 @@ MMComponents.MMPage { PositionKit.positionProvider = PositionKit.constructProvider( type, id, name ) - if ( type === "external" ) { + if ( type === "external_bt" ) { connectingDialogLoader.open() } } diff --git a/app/qml/map/MMMapController.qml b/app/qml/map/MMMapController.qml index ae892281d..a9d5f8be2 100644 --- a/app/qml/map/MMMapController.qml +++ b/app/qml/map/MMMapController.qml @@ -679,7 +679,7 @@ Item { visible: { if ( root.mapExtentOffset > 0 && root.state !== "stakeout" ) return false - if ( PositionKit.positionProvider && PositionKit.positionProvider.type() === "external" ) { + if ( PositionKit.positionProvider && PositionKit.positionProvider.type().includes("external") ) { // for external receivers we want to show gps panel and accuracy button // even when the GPS receiver is not sending position data return true @@ -699,7 +699,7 @@ Item { { return "" } - else if ( PositionKit.positionProvider.type() === "external" ) + else if ( PositionKit.positionProvider.type().includes("external") ) { if ( PositionKit.positionProvider.state === MM.PositionProvider.Connecting ) { diff --git a/app/test/testposition.cpp b/app/test/testposition.cpp index 2a4a8213f..94c7675e4 100644 --- a/app/test/testposition.cpp +++ b/app/test/testposition.cpp @@ -106,8 +106,8 @@ void TestPosition::testBluetoothProviderConnection() QCOMPARE( "testBluetoothProvider", pkProvider->name() ); QCOMPARE( "AA:AA:AA:AA:00:00", btProvider->id() ); QCOMPARE( "AA:AA:AA:AA:00:00", pkProvider->id() ); - QCOMPARE( "external", btProvider->type() ); - QCOMPARE( "external", pkProvider->type() ); + QCOMPARE( "external_bt", btProvider->type() ); + QCOMPARE( "external_bt", pkProvider->type() ); // // let's continue with BT instance, @@ -257,11 +257,11 @@ void TestPosition::testPositionProviderKeysInSettings() rawSettings.remove( AppSettings::POSITION_PROVIDERS_GROUP ); // make sure nothing is there from previous tests #ifdef HAVE_BLUETOOTH - positionKit->setPositionProvider( positionKit->constructProvider( "external", "AA:BB:CC:DD:EE:FF", "testProviderA" ) ); + positionKit->setPositionProvider( positionKit->constructProvider( "external_bt", "AA:BB:CC:DD:EE:FF", "testProviderA" ) ); QCOMPARE( positionKit->positionProvider()->id(), "AA:BB:CC:DD:EE:FF" ); QCOMPARE( positionKit->positionProvider()->name(), "testProviderA" ); - QCOMPARE( positionKit->positionProvider()->type(), "external" ); + QCOMPARE( positionKit->positionProvider()->type(), "external_bt" ); QCOMPARE( rawSettings.value( CoreUtils::QSETTINGS_APP_GROUP_NAME + "/activePositionProviderId" ).toString(), "AA:BB:CC:DD:EE:FF" ); #endif @@ -279,20 +279,28 @@ void TestPosition::testPositionProviderKeysInSettings() QCOMPARE( providersModel.data( providersModel.index( 1 ), PositionProvidersModel::ProviderId ), "simulated" ); providersModel.setAppSettings( &appSettings ); - providersModel.addProvider( "testProviderB", "AA:00:11:22:23:44" ); + providersModel.addProvider( "testProviderB", "AA:00:11:22:23:44", "external_bt" ); + providersModel.addProvider( "testProviderC", "localhost:9000", "external_ip" ); - // app settings should have one saved provider - testProviderB + // app settings should have two saved providers - testProviderB & testProviderC QVariantList providers = appSettings.savedPositionProviders(); - QCOMPARE( providers.count(), 1 ); // we have one (external) provider - QCOMPARE( providers.at( 0 ).toList().count(), 2 ); // the provider has two properties + QCOMPARE( providers.count(), 2 ); // we have two (external) providers + QCOMPARE( providers.at( 0 ).toList().count(), 3 ); // the provider has two properties QVariantList providerData = providers.at( 0 ).toList(); QCOMPARE( providerData.at( 0 ).toString(), "testProviderB" ); QCOMPARE( providerData.at( 1 ).toString(), "AA:00:11:22:23:44" ); + QCOMPARE( providerData.at( 2 ).toString(), "external_bt" ); + + providerData = providers.at( 1 ).toList(); + QCOMPARE( providerData.at( 0 ).toString(), "testProviderC" ); + QCOMPARE( providerData.at( 1 ).toString(), "localhost:9000" ); + QCOMPARE( providerData.at( 2 ).toString(), "external_ip" ); // remove that provider providersModel.removeProvider( "AA:00:11:22:23:44" ); + providersModel.removeProvider( "localhost:9000" ); providers = appSettings.savedPositionProviders(); @@ -778,6 +786,73 @@ void TestPosition::testPositionTransformerInternalDesktopPosition() QVERIFY( qgsDoubleNear( newPosition.elevation, 171.3 ) ); } +void TestPosition::testPositionTransformerNetworkPosition() +{ +// prepare position transformers + // WGS84 + ellipsoid + QgsCoordinateReferenceSystem ellipsoidHeightCrs = QgsCoordinateReferenceSystem::fromEpsgId( 4979 ); + // WGS84 + EGM96 + QgsCoordinateReferenceSystem geoidHeightCrs = QgsCoordinateReferenceSystem::fromEpsgId( 9707 ); + PositionTransformer passThroughTransformer( ellipsoidHeightCrs, geoidHeightCrs, true, QgsCoordinateTransformContext() ); + PositionTransformer positionTransformer( ellipsoidHeightCrs, geoidHeightCrs, false, QgsCoordinateTransformContext() ); + +#ifdef HAVE_BLUETOOTH + // mini file contains only minimal info like position and date + QString miniNmeaPositionFilePath = TestUtils::testDataDir() + "/position/nmea_petrzalka_mini.txt"; + QFile miniNmeaFile( miniNmeaPositionFilePath ); + miniNmeaFile.open( QFile::ReadOnly ); + + QVERIFY( miniNmeaFile.isOpen() ); + + NmeaParser parser; + QgsGpsInformation position = parser.parseNmeaString( miniNmeaFile.readAll() ); + GeoPosition geoPosition = GeoPosition::fromQgsGpsInformation( position ); + + QVERIFY( qgsDoubleNear( geoPosition.latitude, 48.10305 ) ); + QVERIFY( qgsDoubleNear( geoPosition.longitude, 17.1064 ) ); + QCOMPARE( geoPosition.elevation, 171.3 ); + QCOMPARE( geoPosition.elevation_diff, std::numeric_limits::quiet_NaN() ); +#else + GeoPosition geoPosition; + geoPosition.latitude = 48.10305; + geoPosition.longitude = 17.1064; + geoPosition.elevation = 171.3; +#endif + + // transform with pass through disabled and missing elevation separation + GeoPosition newPosition = positionTransformer.processNetworkPosition( geoPosition ); + + QVERIFY( qgsDoubleNear( newPosition.latitude, 48.10305 ) ); + QVERIFY( qgsDoubleNear( newPosition.longitude, 17.1064 ) ); + QCOMPARE( newPosition.elevation, 171.3 ); + QCOMPARE( newPosition.elevation_diff, std::numeric_limits::quiet_NaN() ); + + // transform with pass through enabled and missing elevation separation + newPosition = passThroughTransformer.processNetworkPosition( geoPosition ); + + QVERIFY( qgsDoubleNear( newPosition.latitude, 48.10305 ) ); + QVERIFY( qgsDoubleNear( newPosition.longitude, 17.1064 ) ); + QCOMPARE( newPosition.elevation, 171.3 ); + QCOMPARE( newPosition.elevation_diff, std::numeric_limits::quiet_NaN() ); + + // transform with pass through enabled and elevation separation + geoPosition.elevation_diff = 40; + newPosition = passThroughTransformer.processNetworkPosition( geoPosition ); + + QVERIFY( qgsDoubleNear( newPosition.latitude, 48.10305 ) ); + QVERIFY( qgsDoubleNear( newPosition.longitude, 17.1064 ) ); + QCOMPARE( newPosition.elevation, 171.3 ); + QCOMPARE( newPosition.elevation_diff, 40 ); + + // transform with pass through disabled and elevation separation + newPosition = positionTransformer.processNetworkPosition( geoPosition ); + + QVERIFY( qgsDoubleNear( newPosition.latitude, 48.10305 ) ); + QVERIFY( qgsDoubleNear( newPosition.longitude, 17.1064 ) ); + QVERIFY( qgsDoubleNear( newPosition.elevation, 167.53574931171875 ) ); + QVERIFY( qgsDoubleNear( newPosition.elevation_diff, 43.764250688281265 ) ); +} + void TestPosition::testPositionTransformerSimulatedPosition() { // prepare position transformers diff --git a/app/test/testposition.h b/app/test/testposition.h index 3636b89c3..40ffd45c6 100644 --- a/app/test/testposition.h +++ b/app/test/testposition.h @@ -44,6 +44,7 @@ class TestPosition: public QObject void testPositionTransformerInternalAndroidPosition(); void testPositionTransformerInternalIosPosition(); void testPositionTransformerInternalDesktopPosition(); + void testPositionTransformerNetworkPosition(); void testPositionTransformerSimulatedPosition(); private: diff --git a/app/test/testvariablesmanager.cpp b/app/test/testvariablesmanager.cpp index e7bda0498..cd191c431 100644 --- a/app/test/testvariablesmanager.cpp +++ b/app/test/testvariablesmanager.cpp @@ -84,7 +84,7 @@ void TestVariablesManager::testPositionVariables() evaluateExpression( QStringLiteral( "@position_gps_antenna_height" ), QStringLiteral( "0.000" ), &context ); evaluateExpression( QStringLiteral( "@position_provider_address" ), QStringLiteral( "AA:AA:FF:AA:00:10" ), &context ); evaluateExpression( QStringLiteral( "@position_provider_name" ), QStringLiteral( "testBluetoothProvider" ), &context ); - evaluateExpression( QStringLiteral( "@position_provider_type" ), QStringLiteral( "external" ), &context ); + evaluateExpression( QStringLiteral( "@position_provider_type" ), QStringLiteral( "external_bt" ), &context ); mAppSettings->setGpsAntennaHeight( 1.6784 ); pos.verticalSpeed = 1.345; diff --git a/gallery/positionkit.h b/gallery/positionkit.h index 059a3e737..bab5f6dfc 100644 --- a/gallery/positionkit.h +++ b/gallery/positionkit.h @@ -61,7 +61,7 @@ class PositionKit : public QObject private: QString pProviderName = "Gps Source is ok!"; - QString pProviderType = "external"; + QString pProviderType = "external_bt"; QString pProviderMessage = "Connected"; QString pStateMessage = "Message"; QString pLastRead = "17:19:08 CEST";