connectionmanager.cpp

Go to the documentation of this file.

/*
 * 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 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
 * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
 * for more details.
 *
 * You should have received a copy of the GNU General Public License along
 * with this program; if not, see <http://www.gnu.org/licenses/>
 */

#include "connectionmanager.h"
#include <coreplugin/icore.h>
#include <aggregation/aggregate.h>
#include <coreplugin/iconnection.h>
#include <coreplugin/idevice.h>
#include <extensionsystem/pluginmanager.h>
#include <QtSerialPort/QSerialPort>
#include <QtSerialPort/QSerialPortInfo>
#include <QDebug>
#include <QLabel>
#include <QHBoxLayout>
#include <QComboBox>
#include <QEventLoop>
#include <QMainWindow>
#include <alarmsmonitorwidget.h>

namespace Core {

ConnectionManager::ConnectionManager(Internal::MainWindow *mainWindow, QTabWidget *modeStack)
    : QWidget(mainWindow)
    , m_availableDevList(nullptr)
    , m_connectBtn(nullptr)
    , m_ioDev(NULL)
    , polling(true)
    , m_mainWindow(mainWindow)
{
    QHBoxLayout *layout = new QHBoxLayout;
    layout->setSpacing(5);
    layout->setContentsMargins(0, 0, 9, 0);

    m_monitorWidget = new TelemetryMonitorWidget(this);
    AlarmsMonitorWidget::getInstance().init(m_monitorWidget->getRenderer(),
                                            m_monitorWidget->getBackgroundItem());
    layout->addWidget(m_monitorWidget, Qt::AlignHCenter | Qt::AlignVCenter);

    layout->addWidget(new QLabel(tr("Connections:")));

    m_availableDevList = new QComboBox;
    m_availableDevList->setMinimumWidth(100);
    m_availableDevList->setMaximumWidth(150);
    m_availableDevList->setContextMenuPolicy(Qt::CustomContextMenu);
    layout->addWidget(m_availableDevList, Qt::AlignVCenter);

    m_connectBtn = new QPushButton(tr("Connect"));
    m_connectBtn->setEnabled(false);
    layout->addWidget(m_connectBtn, Qt::AlignVCenter);

    setLayout(layout);

    modeStack->setCornerWidget(this, Qt::TopRightCorner);

    QObject::connect(m_connectBtn, SIGNAL(clicked()), this, SLOT(onConnectClicked()));

    // setup our reconnect timers
    reconnect = new QTimer(this);
    reconnectCheck = new QTimer(this);
    connect(reconnect, SIGNAL(timeout()), this, SLOT(reconnectSlot()));
    connect(reconnectCheck, SIGNAL(timeout()), this, SLOT(reconnectCheckSlot()));
}

ConnectionManager::~ConnectionManager()
{
    disconnectDevice();
    suspendPolling();
    if (m_monitorWidget)
        delete m_monitorWidget;
}

void ConnectionManager::init()
{
    // register to the plugin manager so we can receive
    // new connection object from plugins
    QObject::connect(ExtensionSystem::PluginManager::instance(), SIGNAL(objectAdded(QObject *)),
                     this, SLOT(objectAdded(QObject *)));
    QObject::connect(ExtensionSystem::PluginManager::instance(),
                     SIGNAL(aboutToRemoveObject(QObject *)), this,
                     SLOT(aboutToRemoveObject(QObject *)));
}

void ConnectionManager::connectDeviceFailed(DevListItem &device)
{

    QString msg("<span style='color:red'>Failed</span> to connect device: ");
    if (device.device)
        msg.append(device.device->getDisplayName());
    else
        msg.append("Unknown");

#ifdef Q_OS_LINUX
    if (device.connection && device.connection->shortName() == "USB")
        msg.append("<br />Have you set udev rules?");
#endif

    QMessageBox msgFailedToConnect(dynamic_cast<QWidget *>(Core::ICore::instance()->mainWindow()));
    msgFailedToConnect.setText(msg);
    msgFailedToConnect.open();
}

bool ConnectionManager::connectDevice(DevListItem device)
{
    if (!device.connection) {
        return false;
    }

    QIODevice *io_dev = device.connection->openDevice(device.device);
    if (!io_dev) {
        return false;
    }

    io_dev->open(QIODevice::ReadWrite);

    // check if opening the device worked
    if (!io_dev->isOpen()) {
        return false;
    }

    // The device is connected make it the one selected on the dropbox
    for (int x = 0; x < m_availableDevList->count(); ++x) {
        if (device.getConName() == m_availableDevList->itemData(x, Qt::ToolTipRole).toString())
            m_availableDevList->setCurrentIndex(x);
    }
    // we appear to have connected to the device OK
    // remember the connection/device details
    m_connectionDevice = device;
    m_ioDev = io_dev;

    connect(m_connectionDevice.connection, SIGNAL(destroyed(QObject *)), this,
            SLOT(onConnectionDestroyed(QObject *)), Qt::QueuedConnection);

    // signal interested plugins that we connected to the device
    emit deviceConnected(io_dev);
    m_connectBtn->setText("Disconnect");
    m_availableDevList->setEnabled(false);

    // tell the monitorwidget we're conneced
    m_monitorWidget->connected();

    return true;
}

bool ConnectionManager::disconnectDevice()
{
    // tell the monitor widget we're disconnected
    m_monitorWidget->disconnect();

    if (!m_ioDev) {
        // apparently we are already disconnected: this can
        // happen if a plugin tries to force a disconnect whereas
        // we are not connected. Just return.
        return false;
    }

    // We are connected - disconnect from the device

    // stop our timers
    if (reconnect->isActive())
        reconnect->stop();
    if (reconnectCheck->isActive())
        reconnectCheck->stop();

    // signal interested plugins that user is disconnecting his device
    emit deviceAboutToDisconnect();

    try {
        if (m_connectionDevice.connection) {
            m_connectionDevice.connection->closeDevice(m_connectionDevice.getConName());
        }
    } catch (...) { // handle exception
        qDebug() << "Exception: m_connectionDevice.connection->closeDevice("
                 << m_connectionDevice.getConName() << ")";
    }

    m_connectionDevice.connection = NULL;
    m_ioDev = NULL;

    emit deviceDisconnected();
    m_connectBtn->setText("Connect");
    m_availableDevList->setEnabled(true);

    return true;
}

void ConnectionManager::objectAdded(QObject *obj)
{
    // Check if a plugin added a connection object to the pool
    IConnection *connection = Aggregation::query<IConnection>(obj);
    if (!connection)
        return;

    // register devices and populate CB
    devChanged(connection);

    // Keep track of the registration to be able to tell plugins
    // to do things
    m_connectionsList.append(connection);

    QObject::connect(connection, SIGNAL(availableDevChanged(IConnection *)), this,
                     SLOT(devChanged(IConnection *)));
}

void ConnectionManager::aboutToRemoveObject(QObject *obj)
{
    // Check if a plugin added a connection object to the pool
    IConnection *connection = Aggregation::query<IConnection>(obj);
    if (!connection)
        return;

    if (m_connectionDevice.connection
        && m_connectionDevice.connection
            == connection) { // we are currently using the one that is about to be removed
        disconnectDevice();
        m_connectionDevice.connection = NULL;
        m_ioDev = NULL;
    }

    if (m_connectionsList.contains(connection))
        m_connectionsList.removeAt(m_connectionsList.indexOf(connection));
}

void ConnectionManager::onConnectionDestroyed(QObject *obj)
{
    Q_UNUSED(obj)
    disconnectDevice();
}

void ConnectionManager::onConnectClicked()
{
    // Check if we have a ioDev already created:
    if (!m_ioDev) {
        // connecting to currently selected device
        DevListItem device = findDevice(
            m_availableDevList->itemData(m_availableDevList->currentIndex(), Qt::ToolTipRole)
                .toString());
        if (device.connection) {
            if (!connectDevice(device)) {
                connectDeviceFailed(device);
            }
        }
    } else { // disconnecting
        disconnectDevice();
    }
}

void ConnectionManager::telemetryConnected()
{
    qDebug() << "TelemetryMonitor: connected";

    if (reconnectCheck->isActive())
        reconnectCheck->stop();

    // tell the monitor we're connected
    m_monitorWidget->connected();
}

void ConnectionManager::telemetryDisconnected()
{
    qDebug() << "TelemetryMonitor: disconnected";

    if (m_ioDev) {
        if (m_connectionDevice.connection->reconnect()) // currently used with bluetooth only
        {
            if (!reconnect->isActive())
                reconnect->start(1000);
        }
    }
    // tell the monitor we're disconnected
    m_monitorWidget->disconnect();
}

void ConnectionManager::telemetryUpdated(double txRate, double rxRate)
{
    m_monitorWidget->updateTelemetry(txRate, rxRate);
}

void ConnectionManager::reconnectSlot()
{
    qDebug() << "reconnect";
    if (m_ioDev->isOpen())
        m_ioDev->close();

    if (m_ioDev->open(QIODevice::ReadWrite)) {
        qDebug() << "reconnect successfull";
        reconnect->stop();
        reconnectCheck->start(20000);
    } else
        qDebug() << "reconnect NOT successfull";
}

void ConnectionManager::reconnectCheckSlot()
{
    reconnectCheck->stop();
    reconnect->start(1000);
}

DevListItem ConnectionManager::findDevice(const QString &devName)
{
    foreach (DevListItem d, m_devList) {
        if (d.getConName() == devName)
            return d;
    }

    qDebug() << "findDevice: cannot find " << devName << " in device list";

    DevListItem d;
    d.connection = NULL;
    return d;
}

void ConnectionManager::suspendPolling()
{
    foreach (IConnection *cnx, m_connectionsList) {
        cnx->suspendPolling();
    }

    m_connectBtn->setEnabled(false);
    m_availableDevList->setEnabled(false);
    polling = false;
}

void ConnectionManager::resumePolling()
{
    foreach (IConnection *cnx, m_connectionsList) {
        cnx->resumePolling();
    }

    m_connectBtn->setEnabled(true);
    m_availableDevList->setEnabled(true);
    polling = true;
}

bool ConnectionManager::getAutoconnect()
{
    return m_mainWindow->generalSettings()->autoConnect();
}

void ConnectionManager::updateConnectionList(IConnection *connection)
{
    // Get the updated list of devices
    QList<IDevice *> availableDev = connection->availableDevices();

    // Go through the list of connections of that type.  If they are not in the
    // available device list then remove them.  If they are connected, then
    // disconnect them.
    for (QLinkedList<DevListItem>::iterator iter = m_devList.begin(); iter != m_devList.end();) {
        if (iter->connection != connection) {
            ++iter;
            continue;
        }

        // See if device exists in the updated availability list
        bool found = availableDev.contains(iter->device);
        if (!found) {
            // we are currently using the one we are about to erase
            if (m_connectionDevice.connection && m_connectionDevice.connection == connection
                && m_connectionDevice.device == iter->device) {
                disconnectDevice();
            }

            // We have to delete the IDevice in that DevListItem before getting rid
            // of the iter itself
            if (!iter->device.isNull())
                iter->device->deleteLater();

            iter = m_devList.erase(iter);
        } else
            ++iter;
    }

    // Add any back to list that don't exist
    foreach (IDevice *dev, availableDev) {
        bool found = m_devList.contains(DevListItem(connection, dev));
        if (!found) {
            registerDevice(connection, dev);
        }
    }
}

void ConnectionManager::registerDevice(IConnection *conn, IDevice *device)
{
    DevListItem d(conn, device);
    m_devList.append(d);
}

void ConnectionManager::devChanged(IConnection *connection)
{
    if (!ExtensionSystem::PluginManager::instance()->allPluginsLoaded()) {
        connectionBackup.append(connection);
        connect(ExtensionSystem::PluginManager::instance(), SIGNAL(pluginsLoadEnded()), this,
                SLOT(connectionsCallBack()), Qt::UniqueConnection);
        return;
    }
    // clear device list combobox
    m_availableDevList->clear();

    // remove registered devices of this IConnection from the list
    updateConnectionList(connection);

    updateConnectionDropdown();

    emit availableDevicesChanged(m_devList);

    // disable connection button if the liNameif (m_availableDevList->count() > 0)
    if (m_availableDevList->count() > 0)
        m_connectBtn->setEnabled(true);
    else
        m_connectBtn->setEnabled(false);
}

void ConnectionManager::updateConnectionDropdown()
{
    // add all the list again to the combobox
    foreach (DevListItem d, m_devList) {
        m_availableDevList->addItem(d.getConName());
        m_availableDevList->setItemData(m_availableDevList->count() - 1, d.getConName(),
                                        Qt::ToolTipRole);
        if (!m_ioDev && d.getConName().startsWith("USB")) {
            if (m_mainWindow->generalSettings()->autoConnect()
                || m_mainWindow->generalSettings()->autoSelect())
                m_availableDevList->setCurrentIndex(m_availableDevList->count() - 1);

            if (m_mainWindow->generalSettings()->autoConnect() && polling) {
                qDebug() << "Automatically opening device";
                connectDevice(d);
                qDebug() << "ConnectionManager::devChanged autoconnected USB device";
            }
        }
    }
    if (m_ioDev) // if a device is connected make it the one selected on the dropbox
    {
        for (int x = 0; x < m_availableDevList->count(); ++x) {
            if (m_connectionDevice.getConName()
                == m_availableDevList->itemData(x, Qt::ToolTipRole).toString())
                m_availableDevList->setCurrentIndex(x);
        }
    }
}

void Core::ConnectionManager::connectionsCallBack()
{
    foreach (IConnection *con, connectionBackup) {
        devChanged(con);
    }
    connectionBackup.clear();
    disconnect(ExtensionSystem::PluginManager::instance(), SIGNAL(pluginsLoadEnded()), this,
               SLOT(connectionsCallBack()));
}

} // namespace Core