rawhidplugin.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 "rawhidplugin.h"
#include "rawhid.h"

#include <coreplugin/icore.h>
#include <QtCore/QtPlugin>
#include <QtCore/QMutexLocker>
#include <QDebug>

#include "rawhid_const.h"
#include "usbsignalfilter.h"

// **********************************************************************

RawHIDConnection::RawHIDConnection()
{
    RawHidHandle = NULL;
    enablePolling = true;

    m_usbMonitor = USBMonitor::instance();

    m_signalFilter = new USBSignalFilter(-1, -1, -1, USBMonitor::Running);
    connect(m_signalFilter, &USBSignalFilter::deviceDiscovered, this,
            &RawHIDConnection::onDeviceConnected);
    connect(m_signalFilter, &USBSignalFilter::deviceRemoved, this,
            &RawHIDConnection::onDeviceDisconnected);
}

RawHIDConnection::~RawHIDConnection()
{
    if (RawHidHandle)
        if (RawHidHandle->isOpen())
            RawHidHandle->close();

    delete m_signalFilter;
}

void RawHIDConnection::onDeviceConnected()
{
    emit availableDevChanged(this);
}

void RawHIDConnection::onDeviceDisconnected()
{
    RAW_HID_QXTLOG_DEBUG("onDeviceDisconnected()");
    if (enablePolling)
        emit availableDevChanged(this);
}

QList<Core::IDevice *> RawHIDConnection::availableDevices()
{
    QList<Core::IDevice *> devices;
    QList<USBPortInfo> portsList;

    // Loop for all vendorIDs known by the board manager
    Core::BoardManager *brdMgr = Core::ICore::instance()->boardManager();
    QList<int> brdVID = brdMgr->getKnownVendorIDs();
    foreach (int vendorID, brdVID) {
        RAW_HID_QXTLOG_DEBUG("[rawhidplugin] VendorID type known: ", vendorID);
        portsList = m_usbMonitor->availableDevices(vendorID, -1, -1, USBMonitor::Running);
        // We currently list devices by their serial number
        USBDevice *dev = new USBDevice();
        foreach (USBPortInfo prt, portsList) {
            dev->setName(prt.serialNumber);
            dev->setDisplayName(prt.product);
            dev->setVendorID(prt.vendorID);
            dev->setProductID(prt.productID);
            dev->setPath(prt.path);
            devices.append(dev);
        }
    }
    return devices;
}

QIODevice *RawHIDConnection::openDevice(Core::IDevice *deviceName)
{
    if (RawHidHandle)
        closeDevice(deviceName->getName());

    // We know this device is (should be?) a USB device:
    USBDevice *usbDev = dynamic_cast<USBDevice *>(deviceName);
    Q_ASSERT(usbDev);

    RawHidHandle = new RawHID(usbDev);
    return RawHidHandle;
}

void RawHIDConnection::closeDevice(const QString &deviceName)
{
    Q_UNUSED(deviceName);
    if (RawHidHandle) {
        RAW_HID_QXTLOG_DEBUG("Closing the device here");
        RawHidHandle->close();
        delete RawHidHandle;
        RawHidHandle = NULL;
    }
}

QString RawHIDConnection::connectionName()
{
    return QString("Raw HID USB");
}

QString RawHIDConnection::shortName()
{
    return QString("USB");
}

void RawHIDConnection::suspendPolling()
{
    enablePolling = false;
}

void RawHIDConnection::resumePolling()
{
    enablePolling = true;
}

// **********************************************************************

RawHIDPlugin::RawHIDPlugin()
{
    m_usbMonitor = NULL;
    hidConnection = NULL;
}

RawHIDPlugin::~RawHIDPlugin()
{
    if (m_usbMonitor)
        delete m_usbMonitor;
}

void RawHIDPlugin::extensionsInitialized()
{
    hidConnection = new RawHIDConnection();
    addAutoReleasedObject(hidConnection);
}

bool RawHIDPlugin::initialize(const QStringList &arguments, QString *errorString)
{
    Q_UNUSED(arguments);
    Q_UNUSED(errorString);

    // We have to create the USB Monitor here:
    m_usbMonitor = new USBMonitor(this);

    return true;
}