LinkConfiguration.h

Go to the documentation of this file.

#pragma once
 
#include <QtCore/QDeadlineTimer>
#include <QtCore/QElapsedTimer>
#include <QtCore/QSettings>
#include <QtCore/QString>
#include <QtQmlIntegration/QtQmlIntegration>
 
class LinkInterface;
 
class LinkConfiguration : public QObject
{
    Q_OBJECT
    QML_ELEMENT
    QML_UNCREATABLE("")
    Q_MOC_INCLUDE("LinkInterface.h")
 
    Q_PROPERTY(QString          name            READ name           WRITE setName           NOTIFY nameChanged)
    Q_PROPERTY(LinkInterface    *link           READ link                                   NOTIFY linkChanged)
    Q_PROPERTY(bool             linkActive      READ linkActive                             NOTIFY linkActiveChanged)
    Q_PROPERTY(LinkType         linkType        READ type                                   CONSTANT)
    Q_PROPERTY(bool             dynamic         READ isDynamic      WRITE setDynamic        NOTIFY dynamicChanged)
    Q_PROPERTY(bool             autoConnect     READ isAutoConnect  WRITE setAutoConnect    NOTIFY autoConnectChanged)
    Q_PROPERTY(QString          settingsURL     READ settingsURL                            CONSTANT)
    Q_PROPERTY(QString          settingsTitle   READ settingsTitle                          CONSTANT)
    Q_PROPERTY(bool             highLatency     READ isHighLatency  WRITE setHighLatency    NOTIFY highLatencyChanged)
 
public:
    LinkConfiguration(const QString &name, QObject *parent = nullptr);
    LinkConfiguration(const LinkConfiguration *copy, QObject *parent = nullptr);
    virtual ~LinkConfiguration();
 
    QString name() const { return _name; }
    void setName(const QString &name);
 
    LinkInterface *link() const { return _link.lock().get(); }
    void setLink(const std::shared_ptr<LinkInterface> link);
 
    bool linkActive() const { return (link() != nullptr) || (_autoConnect && _autoConnectStarted && !_suppressAutoReconnect); }
 
    bool isDynamic() const { return _dynamic; }
 
    void setDynamic(bool dynamic = true);
 
    bool isForwarding() const { return _forwarding; }
 
    void setForwarding(bool forwarding = true) { _forwarding = forwarding; };
 
    bool isAutoConnect() const { return _autoConnect; }
 
    virtual void setAutoConnect(bool autoc = true);
 
    bool suppressAutoReconnect() const { return _suppressAutoReconnect; }
    void setSuppressAutoReconnect(bool suppress) {
        if (_suppressAutoReconnect != suppress) { _suppressAutoReconnect = suppress; emit linkActiveChanged(); }
    }
 
    bool autoConnectStarted() const { return _autoConnectStarted; }
    void setAutoConnectStarted(bool started) {
        if (_autoConnectStarted != started) { _autoConnectStarted = started; emit linkActiveChanged(); }
    }
 
    bool reconnectReady() const { return _nextReconnect.hasExpired(); }
    void noteReconnectAttempt() {
        const int exp = qMin(_reconnectAttempts, 16);
        _reconnectAttempts = qMin(_reconnectAttempts + 1, 17);
        _nextReconnect = QDeadlineTimer(qMin(_reconnectBaseMs << exp, _reconnectMaxMs));
    }
    void resetReconnectBackoff() { _reconnectAttempts = 0; _nextReconnect = QDeadlineTimer(); }
    void noteConnected() { _connectedTimer.start(); }
    void noteDisconnected() {
        if (_connectedTimer.isValid() && (_connectedTimer.elapsed() >= _reconnectStableMs)) {
            resetReconnectBackoff();
        }
        _connectedTimer.invalidate();
    }
 
    bool isHighLatency() const { return _highLatency; }
 
    void setHighLatency(bool hl = false);
 
    virtual void copyFrom(const LinkConfiguration *source);
 
    enum LinkType {
#ifndef QGC_NO_SERIAL_LINK
        TypeSerial,     
#endif
        TypeUdp,        
        TypeTcp,        
        TypeBluetooth,  
#ifdef QT_DEBUG
        TypeMock,       
#endif
        TypeLogReplay,
        TypeLast        // Last type value (type >= TypeLast == invalid)
    };
    Q_ENUM(LinkType)
 
    
    virtual LinkType type() const = 0;
 
    virtual void loadSettings(QSettings &settings, const QString &root) = 0;
 
    virtual void saveSettings(QSettings &settings, const QString &root) const = 0;
 
    virtual QString settingsURL() const = 0;
 
    virtual QString settingsTitle() const = 0;
 
    static LinkConfiguration *createSettings(int type, const QString &name);
 
    static LinkConfiguration *duplicateSettings(const LinkConfiguration *source);
 
    static QString settingsRoot() { return QStringLiteral("LinkConfigurations"); }
 
signals:
    void nameChanged(const QString &name);
    void linkChanged();
    void linkActiveChanged();
    void dynamicChanged();
    void autoConnectChanged();
    void highLatencyChanged();
 
protected:
    std::weak_ptr<LinkInterface> _link; 
 
private:
    QString _name;
    bool _dynamic = false;     
    bool _forwarding = false;  
    bool _autoConnect = false; 
    bool _highLatency = false;
    bool _suppressAutoReconnect = false; 
    bool _autoConnectStarted = false;    
    int _reconnectAttempts = 0;          
    QDeadlineTimer _nextReconnect;       
    QElapsedTimer _connectedTimer;       
 
    static constexpr int _reconnectBaseMs = 1000;
    static constexpr int _reconnectMaxMs = 5000;
    static constexpr int _reconnectStableMs = 2000; 
};
 
typedef std::shared_ptr<LinkConfiguration> SharedLinkConfigurationPtr;
typedef std::weak_ptr<LinkConfiguration> WeakLinkConfigurationPtr;