plugininterface.h

Go to the documentation of this file.

#ifndef INCLUDE_PLUGININTERFACE_H
#define INCLUDE_PLUGININTERFACE_H

#include <QtPlugin>
#include <QString>

#include "export.h"

struct SDRBASE_API PluginDescriptor {
    // general plugin description
    const QString displayedName;
    const QString version;
    const QString copyright;
    const QString website;
    bool licenseIsGPL;
    const QString sourceCodeURL;
};

class PluginAPI;
class DeviceAPI;
class DeviceUISet;
class PluginInstanceGUI;
class QWidget;
class DeviceSampleSource;
class DeviceSampleSink;
class DeviceSampleMIMO;
class BasebandSampleSink;
class BasebandSampleSource;
class ChannelAPI;

class SDRBASE_API PluginInterface {
public:
    struct SamplingDevice
    {
        enum SamplingDeviceType
        {
            PhysicalDevice,
            BuiltInDevice
        };

        enum StreamType
        {
            StreamSingleRx, 
            StreamSingleTx, 
            StreamMIMO      
        };

        QString displayedName;    
        QString hardwareId;       
        QString id;               
        QString serial;           
        int sequence;             
        SamplingDeviceType type;  
        StreamType streamType;    
        int deviceNbItems;        
        int deviceItemIndex;      
        int claimed;              

        SamplingDevice(const QString& _displayedName,
                const QString& _hardwareId,
                const QString& _id,
                const QString& _serial,
                int _sequence,
                SamplingDeviceType _type,
                StreamType _streamType,
                int _deviceNbItems,
                int _deviceItemIndex) :
            displayedName(_displayedName),
            hardwareId(_hardwareId),
            id(_id),
            serial(_serial),
            sequence(_sequence),
            type(_type),
            streamType(_streamType),
            deviceNbItems(_deviceNbItems),
            deviceItemIndex(_deviceItemIndex),
            claimed(-1)
        { }
    };
    typedef QList<SamplingDevice> SamplingDevices;

    virtual ~PluginInterface() { }

    virtual const PluginDescriptor& getPluginDescriptor() const = 0;
    virtual void initPlugin(PluginAPI* pluginAPI) = 0;

    // channel Rx plugins

    virtual PluginInstanceGUI* createRxChannelGUI(
            DeviceUISet *deviceUISet,
            BasebandSampleSink *rxChannel)
    {
        (void) deviceUISet;
        (void) rxChannel;
        return nullptr;
    }

    virtual BasebandSampleSink* createRxChannelBS(
            DeviceAPI *deviceAPI)
    {
        (void) deviceAPI;
        return nullptr;
    }

    virtual ChannelAPI* createRxChannelCS(
            DeviceAPI *deviceAPI)
    {
        (void) deviceAPI;
        return nullptr;
    }

    // channel Tx plugins

    virtual PluginInstanceGUI* createTxChannelGUI(
            DeviceUISet *deviceUISet,
            BasebandSampleSource *txChannel)
    {
        (void) deviceUISet;
        (void) txChannel;
        return nullptr;
    }

    virtual BasebandSampleSource* createTxChannelBS(
            DeviceAPI *deviceAPI)
    {
        (void) deviceAPI;
        return nullptr;
    }

    virtual ChannelAPI* createTxChannelCS(
            DeviceAPI *deviceAPI)
    {
        (void) deviceAPI;
        return nullptr;
    }

    // device source plugins only

    virtual SamplingDevices enumSampleSources() { return SamplingDevices(); }

    virtual PluginInstanceGUI* createSampleSourcePluginInstanceGUI(
            const QString& sourceId,
            QWidget **widget,
            DeviceUISet *deviceUISet)
    {
        (void) sourceId;
        (void) widget;
        (void) deviceUISet;
        return nullptr;
    }

    virtual DeviceSampleSource* createSampleSourcePluginInstance( // creates the input "core"
            const QString& sourceId,
            DeviceAPI *deviceAPI)
    {
        (void) sourceId;
        (void) deviceAPI;
        return nullptr;
    }
    virtual void deleteSampleSourcePluginInstanceGUI(PluginInstanceGUI *ui);
    virtual void deleteSampleSourcePluginInstanceInput(DeviceSampleSource *source);

    // device sink plugins only

    virtual SamplingDevices enumSampleSinks() { return SamplingDevices(); }

    virtual PluginInstanceGUI* createSampleSinkPluginInstanceGUI(
            const QString& sinkId,
            QWidget **widget,
            DeviceUISet *deviceUISet)
    {
        (void) sinkId;
        (void) widget;
        (void) deviceUISet;
        return nullptr;
    }

    virtual DeviceSampleSink* createSampleSinkPluginInstance( // creates the output "core"
            const QString& sinkId,
            DeviceAPI *deviceAPI)
    {
        (void) sinkId;
        (void) deviceAPI;
        return nullptr;
    }

    virtual void deleteSampleSinkPluginInstanceGUI(PluginInstanceGUI *ui);
    virtual void deleteSampleSinkPluginInstanceOutput(DeviceSampleSink *sink);

    // device MIMO plugins only

    virtual SamplingDevices enumSampleMIMO() { return SamplingDevices(); }

    virtual PluginInstanceGUI* createSampleMIMOPluginInstanceGUI(
            const QString& mimoId,
            QWidget **widget,
            DeviceUISet *deviceUISet)
    {
        (void) mimoId;
        (void) widget;
        (void) deviceUISet;
        return nullptr;
    }

    virtual DeviceSampleMIMO* createSampleMIMOPluginInstance( // creates the MIMO "core"
            const QString& mimoId,
            DeviceAPI *deviceAPI)
    {
        (void) mimoId;
        (void) deviceAPI;
        return nullptr;
    }

    virtual void deleteSampleMIMOPluginInstanceGUI(PluginInstanceGUI *ui);
    virtual void deleteSampleMIMOPluginInstanceMIMO(DeviceSampleMIMO *mimo);

};

Q_DECLARE_INTERFACE(PluginInterface, "SDRangel.PluginInterface/0.1");

#endif // INCLUDE_PLUGININTERFACE_H