LinkManager.h

Go to the documentation of this file.

#pragma once
 
#include <QtCore/QList>
#include <QtCore/QMutex>
#include <QtCore/QMutexLocker>
#include <QtCore/QStringList>
#include <QtQmlIntegration/QtQmlIntegration>
 
#include <limits>
 
#include "LinkConfiguration.h"
#include "LinkInterface.h"
#ifndef QGC_NO_SERIAL_LINK
    #include "QGCSerialPortInfo.h"
#endif
 
class AutoConnectSettings;
class LogReplayLink;
class MAVLinkProtocol;
class QmlObjectListModel;
class QTimer;
class SerialLink;
class UDPConfiguration;
class UdpIODevice;
 
class LinkManager : public QObject
{
    Q_OBJECT
    QML_ELEMENT
    QML_UNCREATABLE("")
    Q_MOC_INCLUDE("QmlObjectListModel.h")
    Q_MOC_INCLUDE("LogReplayLink.h")
    Q_PROPERTY(bool isBluetoothAvailable READ isBluetoothAvailable NOTIFY isBluetoothAvailableChanged)
    Q_PROPERTY(QmlObjectListModel *linkConfigurations READ _qmlLinkConfigurations CONSTANT)
    Q_PROPERTY(QStringList linkTypeStrings READ linkTypeStrings CONSTANT)
    Q_PROPERTY(bool mavlinkSupportForwardingEnabled READ mavlinkSupportForwardingEnabled NOTIFY mavlinkSupportForwardingEnabledChanged)
 
public:
    explicit LinkManager(QObject *parent = nullptr);
    ~LinkManager();
 
    static LinkManager *instance();
 
    void init();
 
    Q_INVOKABLE LinkConfiguration *createConfiguration(int type, const QString &name);
    Q_INVOKABLE LinkConfiguration *startConfigurationEditing(LinkConfiguration *config);
    Q_INVOKABLE void cancelConfigurationEditing(LinkConfiguration *config) const { delete config; }
    Q_INVOKABLE void endConfigurationEditing(LinkConfiguration *config, LinkConfiguration *editedConfig);
    Q_INVOKABLE void endCreateConfiguration(LinkConfiguration *config);
    Q_INVOKABLE void removeConfiguration(LinkConfiguration *config);
    Q_INVOKABLE void createConnectedLink(const LinkConfiguration *config);
    Q_INVOKABLE void createMavlinkForwardingSupportLink();
    Q_INVOKABLE void shutdown();
    Q_INVOKABLE LogReplayLink *startLogReplay(const QString &logFile);
 
    QList<SharedLinkInterfacePtr> links();
    QStringList linkTypeStrings() const;
    bool mavlinkSupportForwardingEnabled() const { return _mavlinkSupportForwardingEnabled; }
 
    void loadLinkConfigurationList();
    void saveLinkConfigurationList();
 
    void setConnectionsSuspended(const QString &reason) { _connectionsSuspended = true; _connectionsSuspendedReason = reason; }
 
    void setConnectionsAllowed() { _connectionsSuspended = false; }
 
    bool createConnectedLink(SharedLinkConfigurationPtr &config);
 
    SharedLinkInterfacePtr mavlinkForwardingLink();
 
    SharedLinkInterfacePtr mavlinkForwardingSupportLink();
 
    void disconnectAll();
 
    uint8_t allocateMavlinkChannel();
    void freeMavlinkChannel(uint8_t channel);
 
    SharedLinkInterfacePtr sharedLinkInterfacePointerForLink(const LinkInterface *link);
 
    bool containsLink(const LinkInterface *link);
 
    SharedLinkConfigurationPtr addConfiguration(LinkConfiguration *config);
 
    void startAutoConnectedLinks();
 
    static bool isBluetoothAvailable();
 
    static bool isLinkUSBDirect(const LinkInterface *link);
 
    static constexpr uint8_t invalidMavlinkChannel() { return std::numeric_limits<uint8_t>::max(); }
 
signals:
    void mavlinkSupportForwardingEnabledChanged();
    void isBluetoothAvailableChanged();
 
private slots:
    void _linkDisconnected();
    void _communicationError(const QString &title, const QString &error);
 
private:
    QmlObjectListModel *_qmlLinkConfigurations();
    bool _connectionsSuspendedMsg() const;
    void _updateAutoConnectLinks();
    void _removeConfiguration(const LinkConfiguration *config);
    void _addUDPAutoConnectLink();
    void _addMAVLinkForwardingLink();
    void _createDynamicForwardLink(const char *linkName, const QString &hostName);
 
    QTimer *_portListTimer = nullptr;
    QmlObjectListModel *_qmlConfigurations = nullptr;
    AutoConnectSettings *_autoConnectSettings = nullptr;
 
    bool _configUpdateSuspended = false;            
    bool _configurationsLoaded = false;             
    bool _connectionsSuspended = false;             
    bool _mavlinkSupportForwardingEnabled = false;
    uint32_t _mavlinkChannelsUsedBitMask = 1;
    QString _connectionsSuspendedReason;            
 
    QMutex _linksMutex;                             
    QList<SharedLinkInterfacePtr> _rgLinks;
    QList<SharedLinkConfigurationPtr> _rgLinkConfigs;
 
    static constexpr const char *_defaultUDPLinkName = "UDP Link (AutoConnect)";
    static constexpr const char *_mavlinkForwardingLinkName = "MAVLink Forwarding Link";
    static constexpr const char *_mavlinkForwardingSupportLinkName = "MAVLink Support Forwarding Link";
 
    static constexpr int _autoconnectUpdateTimerMSecs = 1000;
#ifdef Q_OS_WIN
    // Have to manually let the bootloader go by on Windows to get a working connect
    static constexpr int _autoconnectConnectDelayMSecs = 6000;
#else
    static constexpr int _autoconnectConnectDelayMSecs = 1000;
#endif
 
#ifndef QGC_NO_SERIAL_LINK
private:
    Q_PROPERTY(QStringList serialBaudRates   READ serialBaudRates   CONSTANT)
    Q_PROPERTY(QStringList serialPortStrings READ serialPortStrings NOTIFY commPortStringsChanged)
    Q_PROPERTY(QStringList serialPorts       READ serialPorts       NOTIFY commPortsChanged)
 
public:
    static QStringList serialBaudRates();
    QStringList serialPortStrings();
    QStringList serialPorts();
 
signals:
    void commPortStringsChanged();
    void commPortsChanged();
 
private:
    bool _isSerialPortConnected();
    void _updateSerialPorts();
    bool _allowAutoConnectToBoard(QGCSerialPortInfo::BoardType_t boardType) const;
    void _addSerialAutoConnectLink();
    bool _portAlreadyConnected(const QString &portName);
    void _filterCompositePorts(QList<QGCSerialPortInfo> &portList);
 
    QMap<QString, int> _autoconnectPortWaitList;   
    QList<SerialLink*> _activeLinkCheckList;       
    QStringList _commPortList;
    QStringList _commPortDisplayList;
    QString _autoConnectRTKPort;
    QString _nmeaDeviceName;
    uint32_t _nmeaBaud = 0;
    QSerialPort *_nmeaPort = nullptr;
#endif // QGC_NO_SERIAL_LINK
 
    // NMEA UDP is network-only; available regardless of QGC_NO_SERIAL_LINK.
    UdpIODevice *_nmeaSocket = nullptr;
};