QObject factory in Qt Plugin(non-creator)

Question

I am starting to be very nervous with my problem, I will try to desribe my need, hope that somebody understands. Imagine that I have project which generates one executable and some plugins( runtime loaded library ). That executable is some kind of daemon/service which looks for ist suitable plugins at the start. So these plugins should provide some abstract communication layer. I have looked at the Qt Doc and found QPluginLoader class which should provide interface loading from .so, but the interface cannot have signal/slot, must be pure virtual. So I was thinking about somethink which will return QObject based objects...

!!! Please dont get scared, its just 2 interfaces and 2 implementations :)

My Project layout and contents:

./Daemon/Interfaces/PluginInterface.h

#include <QObject>
#include "PluginInterface.h"
class PluginInterface {
public:
    virtual ~PluginInterface() = 0;
    virtual ProtocolInterface* getInterface() = 0;
    virtual int getPluginId() const = 0;
};

Q_DECLARE_INTERFACE( PluginInterface, "com.porta.protocol.PluginInterface/1.0")

./Daemon/Interfaces/ProtocolInterface.h

#include <QObject>
#include "turnstile.h"
class ProtocolInterface : public QObject {
    Q_OBJECT
public:
    ProtocolInterface( QObject *parent = 0 ) : QObject( parent ) {}
    virtual QWidget* getConfigureGUI() = 0;
    virtual void init() = 0;
    virtual void start() = 0;
signals:
    void someSignal();
};

./Daemon/ProtocolHander.cpp(&h) <- just plugin loading and some logic

./Daemon.pro

QT       += core gui
TARGET = porta_daemon
CONFIG   += console
CONFIG   -= app_bundle
TEMPLATE = app

SOURCES += main.cpp \
protocolhandler.cpp

HEADERS += protocolhandler.h \
Interfaces/protocolinterface.h \
Interfaces/protocolloader.h \
    Interfaces/turnstile.h

./Plugins/Dummy/DummyPluginInterface.h

#include "protocolloader.h"
#include <QObject>
class DummyPluginInterface : public QObject, PluginInterface {
    Q_OBJECT
    Q_INTERFACES(PluginInterface)
public:
    ProtocolInterface* getInterface();
    int getPluginId() const;
};

./Plugins/Dummy/DummyPluginInterface.cpp

#include "DummyPluginInterface.h"
#include "DummyProtocolInterface.h"

ProtocolInterface *DummyPluginInterface::getInterface() {
    return new DummyProtocolInterface();
}

int DummyPluginInterface::getPluginId() const {
    return 1;
}

Q_EXPORT_PLUGIN2(dummyplugin, DummyPluginInterface)

./Plugins/Dummy/DummyProtocolInterface.h

#include "protocolinterface.h"
#include <QObject>

class DummyProtocolInterface : public ProtocolInterface {
public:
    void init();
    QWidget* getConfigureGUI();
    void start();
    int getPluginId() { return 1; }
};

./Plugins/Dummy/DummyProtocolInterface.cpp

#include "DummyProtocolInterface.h"

QWidget* DummyProtocolInterface::getConfigureGUI() {
    return 0;
}

void DummyProtocolInterface::start() {
}

void DummyProtocolInterface::init() {
    emit someSignal(); /// !!! this is important for me
}

./Plugins/Dummy/Dummy.pro

TEMPLATE        = lib
CONFIG         += plugin
QT             += network
INCLUDEPATH += ../../Daemon/Interfaces/
HEADERS        += ****
SOURCES        += ****
TARGET          = *****
DESTDIR         = *****

My promblem is that I am getting linking errors or runtime unresolved symbols( mostly somethink from QObject ) or my signals cannot by connected... ProtocolHandler should be the one, who connects signals/slots..

Can anybody tell me how to make this approach right? Qt examples are not covering such think..

THANK YOU!

Adam

Answer 1

So adding ProtocolInterface.h into HEADERS += section of Plugin.pro file SOLVED THE PROBLEM :)