NTRIPManager.h

Go to the documentation of this file.

#pragma once
 
#include <QtCore/QChronoTimer>
#include <QtCore/QLoggingCategory>
#include <QtCore/QObject>
#include <QtCore/QPointer>
#include <QtQmlIntegration/QtQmlIntegration>
#include <chrono>
 
#include "NTRIPConnectionStats.h"
#include "NTRIPGgaProvider.h"
#include "NTRIPSourceTableController.h"
#include "NTRIPTransport.h"
#include "NTRIPTransportConfig.h"
#include "UdpForwarder.h"
 
Q_DECLARE_LOGGING_CATEGORY(NTRIPManagerLog)
 
class NTRIPSettings;
class RTCMMavlink;
class RTCMUdpInput;
 
class NTRIPManager : public QObject
{
    Q_OBJECT
    friend class NTRIPManagerTest;
    QML_ELEMENT
    QML_UNCREATABLE("")
    Q_MOC_INCLUDE("NTRIPConnectionStats.h")
    Q_MOC_INCLUDE("NTRIPSourceTableController.h")
    Q_MOC_INCLUDE("RTCMMavlink.h")
    Q_PROPERTY(ConnectionStatus connectionStatus READ connectionStatus NOTIFY connectionStatusChanged)
    Q_PROPERTY(QString statusMessage READ statusMessage NOTIFY statusMessageChanged)
    Q_PROPERTY(QString securityWarning READ securityWarning NOTIFY securityWarningChanged)
    Q_PROPERTY(CasterStatus casterStatus READ casterStatus NOTIFY casterStatusChanged)
    Q_PROPERTY(QString ggaSource READ ggaSource NOTIFY ggaSourceChanged)
    Q_PROPERTY(NTRIPSourceTableController* sourceTableController READ sourceTableController CONSTANT)
    Q_PROPERTY(NTRIPConnectionStats* connectionStats READ connectionStats CONSTANT)
    // CONSTANT is safe: rtcmMavlink is established once in init() (or injected for
    // tests) before any QML binds, and is never reassigned thereafter.
    Q_PROPERTY(RTCMMavlink* rtcmMavlink READ rtcmMavlink CONSTANT)
 
public:
    enum class ConnectionStatus
    {
        Disconnected = 0,
        Connecting = 1,
        Connected = 2,
        Reconnecting = 3,
        Error = 4
    };
    Q_ENUM(ConnectionStatus)
 
    enum class CasterStatus
    {
        CasterConnected,
        CasterNoLocation,
        CasterError
    };
    Q_ENUM(CasterStatus)
 
    
    enum class Event
    {
        StartRequested,       
        StopRequested,        
        ConfigInvalid,        
        TransportConnected,   
        RTCMBeforeConnected,  
        TransportError,       
        TransportFatalError,  
        ReconnectDue,         
        ReconnectGaveUp,      
        HotReconfigure,       
    };
 
    explicit NTRIPManager(QObject* parent = nullptr);
    ~NTRIPManager() override;
 
    static NTRIPManager* instance();
 
    void init();
 
    ConnectionStatus connectionStatus() const { return _connectionStatus; }
 
    QString statusMessage() const { return _statusMessage; }
 
    QString securityWarning() const { return _securityWarning; }
 
    CasterStatus casterStatus() const { return _casterStatus; }
 
    QString ggaSource() const { return _ggaProvider.currentSource(); }
 
    NTRIPSourceTableController* sourceTableController() { return &_sourceTableController; }
 
    NTRIPConnectionStats* connectionStats() { return &_stats; }
 
    RTCMMavlink* rtcmMavlink() const;
 
    Q_INVOKABLE void fetchMountpoints();
 
    Q_INVOKABLE void selectMountpoint(const QString& mountpoint)
    {
        _sourceTableController.selectMountpoint(mountpoint);
    }
 
    void setTransportForTest(NTRIPTransport* transport) { _injectedTransport = transport; }
 
    void setRtcmMavlink(RTCMMavlink* mavlink);
 
    void startNTRIP();
    void stopNTRIP();
 
signals:
    void connectionStatusChanged();
    void statusMessageChanged();
    void securityWarningChanged();
    void casterStatusChanged(CasterStatus status);
    void ggaSourceChanged();
 
private:
    bool _dispatch(Event ev, const QString& detail = {});
 
    void _enterState(ConnectionStatus to, const QString& detail);
 
    void _onEnterState(ConnectionStatus from, ConnectionStatus to);
 
    static QString _defaultMessageFor(ConnectionStatus state);
 
    void _startTransport();
    void _teardownTransport();
 
    // Reconnect backoff (inlined; was NTRIPReconnectPolicy). The single-shot
    // timer fires reconnectRequested → ReconnectDue; exhausting the attempt
    // ceiling fires ReconnectGaveUp instead.
    static constexpr int kMinReconnectMs = 1000;
    static constexpr int kMaxReconnectMs = 30000;
    static constexpr int kMaxReconnectAttempts = 100;
 
    void _scheduleReconnect();
 
    void _cancelReconnect() { _reconnectTimer.stop(); }
 
    void _resetReconnectAttempts() { _reconnectAttempts = 0; }
 
    int _reconnectBackoffMs() const;
 
    bool _reconnectExhausted() const { return _reconnectAttempts >= kMaxReconnectAttempts; }
 
    void _applyUdpForwarderConfig(const NTRIPTransportConfig& config);
 
    void _onTransportError(NTRIPError code, const QString& detail);
    void _onPlaintextCredentialsWarning();
    void _setSecurityWarning(const QString& warning);
    void _rtcmDataReceived(const QByteArray& data, int messageId);
    void _onSettingChanged();
    bool _isEnabled() const;
 
    void _setupRtcmUdpInput();
 
    NTRIPGgaProvider _ggaProvider{this};
    NTRIPConnectionStats _stats{this};
    UdpForwarder _udpForwarder{this};
 
    ConnectionStatus _connectionStatus = ConnectionStatus::Disconnected;
    QString _statusMessage;
    QString _securityWarning;
    CasterStatus _casterStatus = CasterStatus::CasterError;
 
    QPointer<NTRIPTransport> _injectedTransport;
    QPointer<NTRIPTransport> _transport;
 
    QPointer<RTCMMavlink> _rtcmMavlink;
    RTCMUdpInput* _rtcmUdpInput = nullptr;
 
    NTRIPTransportConfig _runningConfig;
    NTRIPSettings* _settings = nullptr;
 
    NTRIPSourceTableController _sourceTableController{this};
 
    static constexpr std::chrono::milliseconds kSettingsDebounceMs{250};
    QChronoTimer _settingsDebounceTimer{this};
    QChronoTimer _reconnectTimer{this};
    int _reconnectAttempts = 0;
    bool _initialized = false;
};