NTRIPManager.h

Go to the documentation of this file.

#pragma once
 
#include <chrono>
#include <functional>
#include <memory>
 
#include <QtCore/QObject>
#include <QtCore/QPointer>
#include <QtCore/QString>
#include <QtCore/QVector>
#include <QtPositioning/QGeoCoordinate>
#include <QtQmlIntegration/QtQmlIntegration>
 
#include "ExponentialBackoff.h"
#include "NTRIPConfiguration.h"
#include "NTRIPConnectionStats.h"
#include "NTRIPGgaReporter.h"
#include "NTRIPSourceTableController.h"
#include "NTRIPTransport.h"
#include "ScheduledTask.h"
 
class GPSCorrectionManager;
class GPSCorrectionSourceHandle;
class QGCNetworkAvailabilityMonitor;
class RuntimeScheduler;
 
struct NTRIPRTCMFilterConfig
{
    QString whitelist;
    bool operator==(const NTRIPRTCMFilterConfig&) const = default;
 
    [[nodiscard]] QVector<int> messageIds() const;
};
 
struct NTRIPManagerDependencies
{
    GPSCorrectionManager* corrections = nullptr;
    QGCNetworkAvailabilityMonitor* network = nullptr;
};
 
class NTRIPManager : public QObject
{
    Q_OBJECT
    QML_ELEMENT
    QML_UNCREATABLE("Provided by the GPS manager")
    Q_MOC_INCLUDE("NTRIPConnectionStats.h")
    Q_PROPERTY(ConnectionStatus connectionStatus READ connectionStatus NOTIFY connectionStatusChanged FINAL)
    Q_PROPERTY(QString statusMessage READ statusMessage NOTIFY statusMessageChanged FINAL)
    Q_PROPERTY(QString connectionStatusText READ connectionStatusText NOTIFY connectionStatusChanged FINAL)
    Q_PROPERTY(QString securityWarning READ securityWarning NOTIFY securityWarningChanged FINAL)
    Q_PROPERTY(QString ggaSource READ ggaSource NOTIFY ggaSourceChanged FINAL)
    Q_PROPERTY(NTRIPSourceTableController* sourceTableController READ sourceTableController CONSTANT FINAL)
    Q_PROPERTY(NTRIPConnectionStats* connectionStats READ connectionStats CONSTANT FINAL)
 
    friend class NTRIPManagerTest;
 
public:
    enum class ConnectionStatus
    {
        Disconnected = 0,
        Connecting = 1,
        Connected = 2,
        Reconnecting = 3,
        Error = 4
    };
    Q_ENUM(ConnectionStatus)
 
    
    enum class Event
    {
        StartRequested,       
        StopRequested,        
        ConfigInvalid,        
        TransportConnected,   
        TransportError,       
        TransportFatalError,  
        ReconnectDue,         
        ReconnectGaveUp,      
        HotReconfigure,       
    };
    Q_ENUM(Event)
 
    
    struct Configuration
    {
        bool enabled = false;
        NTRIPConnectionConfig connection;
        NTRIPRTCMFilterConfig filter;
        NTRIPGgaReporter::Configuration gga;
        bool operator==(const Configuration&) const = default;
    };
 
    using Dependencies = NTRIPManagerDependencies;
 
    explicit NTRIPManager(QObject* parent = nullptr, RuntimeScheduler* scheduler = nullptr,
                          const Dependencies& dependencies = {});
    ~NTRIPManager() override;
 
    void init();
    void setConfiguration(const Configuration& configuration);
 
    const Configuration& configuration() const { return _configuration; }
 
    ConnectionStatus connectionStatus() const { return _connectionStatus; }
 
    QString connectionStatusText() const;
 
    QString statusMessage() const { return _statusMessage; }
 
    QString securityWarning() const;
 
    QString ggaSource() const { return _ggaReporter.currentSource(); }
 
    NTRIPSourceTableController* sourceTableController() { return &_sourceTableController; }
 
    NTRIPConnectionStats* connectionStats() { return &_stats; }
 
    Q_INVOKABLE void fetchMountpoints(const QGeoCoordinate& sortCoordinate = QGeoCoordinate());
 
    using TransportFactory = std::function<NTRIPTransport*(const Configuration& configuration, QObject* parent)>;
 
    void setTransportFactory(TransportFactory factory) { _transportFactory = std::move(factory); }
 
    void setGgaPositionProvider(NTRIPGgaReporter::PositionSource source, NTRIPGgaReporter::PositionProvider provider);
 
    Q_INVOKABLE void retryNTRIP();
    void shutdown();
 
signals:
    void connectionStatusChanged();
    void statusMessageChanged();
    void securityWarningChanged();
    void ggaSourceChanged();
    void enableRequested();
    void certificatePinChanged(const QString& pin);
 
private:
    struct Notified
    {
        ConnectionStatus status = ConnectionStatus::Disconnected;
        QString message;
        QString securityWarning;
    };
 
    void _publish();
    void _start();
    void _stop();
 
    bool _dispatch(Event ev, const QString& detail = {}, std::chrono::milliseconds retryAfter = {});
 
    void _enterState(ConnectionStatus to, const QString& detail, std::chrono::milliseconds retryAfter = {});
 
    void _onEnterState(ConnectionStatus to, std::chrono::milliseconds retryAfter);
 
    static QString _defaultMessageFor(ConnectionStatus state);
 
    void _openSession();
    void _stopStreaming();
 
    // The single-shot reconnect timer fires ReconnectDue; a failure after the attempt ceiling fires ReconnectGaveUp.
    static constexpr int MAX_RECONNECT_ATTEMPTS = 100;
 
    void _scheduleReconnect(std::chrono::milliseconds retryAfter = {});
 
    void _cancelReconnect();
 
    bool _shouldWaitForNetwork() const;
    bool _casterIsLoopback() const;
    void _waitForNetwork();
 
    bool _reconnectExhausted() const { return _reconnectBackoff.attempts() >= MAX_RECONNECT_ATTEMPTS; }
 
    void _onTransportConnected();
    void _onTransportError(const NTRIPFailure& failure);
    void _onCertificatePinned(const QString& pin);
    void _setPinnedCertificate(const QString& pin);
    void _onCorrectionFrame(const RTCMDecodedFrame& frame);
    void _applyConfiguration();
 
    bool _isEnabled() const { return _configuration.enabled; }
 
    RuntimeScheduler* const _scheduler;
    ScheduledTask _settingsDebounceTask;
    ScheduledTask _reconnectTask;
    NTRIPGgaReporter _ggaReporter;
    NTRIPConnectionStats _stats;
 
    ConnectionStatus _connectionStatus = ConnectionStatus::Disconnected;
    QString _statusMessage;
    Notified _notified;
 
    TransportFactory _transportFactory;
    QPointer<NTRIPTransport> _transport;
    std::unique_ptr<GPSCorrectionSourceHandle> _correctionSource;
 
    const QPointer<GPSCorrectionManager> _correctionManager;
    const QPointer<QGCNetworkAvailabilityMonitor> _networkMonitor;
 
    // Latest supplied configuration, and the one the current transport uses.
    Configuration _configuration;
    Configuration _running;
 
    NTRIPSourceTableController _sourceTableController;
 
    static constexpr std::chrono::milliseconds SETTINGS_DEBOUNCE{250};
    ExponentialBackoff _reconnectBackoff{std::chrono::seconds(1), 2, std::chrono::seconds(30),
                                         NTRIPFailure::MAX_RETRY_AFTER};
    QString _lastFailureDetail;  
    bool _waitingForNetwork = false;
    bool _initialized = false;
    bool _shutdown = false;
};