QObjet usine dans Qt Plugin (non-créateur)

Question

Je commence à être très nerveux avec mon problème, je vais essayer de décrire mon besoin, j'espère que quelqu'un comprend. Imaginez que j'ai un projet qui génère un exécutable et quelques plugins (bibliothèque chargée à l'exécution). Cet exécutable est une sorte de démon/service qui cherche des plugins appropriés au début. Ces plugins devraient donc fournir une couche de communication abstraite. J'ai regardé le Qt Doc et trouvé la classe QPluginLoader qui devrait fournir le chargement de l'interface à partir de .so, mais l'interface ne peut pas avoir de signal/slot, doit être pure virtuelle. Donc je pensais à quelque chose qui renverra des objets basés sur QObject ...

!!! S'il vous plaît Ne pas avoir peur, ses seulement 2 interfaces et 2 implémentations :)

Ma mise en page du projet et le contenu:

./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) < - juste le chargement des greffons et une certaine logique

./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   = ***** 

Mon promblem est que je reçois des erreurs ou exécution reliant des symboles non résolus (principalement quelque chose de QObject) ou mes signaux ne peuvent pas être connectés ... ProtocolHandler devrait être celui qui connecte les signaux/slots.

Quelqu'un peut-il me dire comment faire cette approche? Qt exemples ne couvrent pas une telle pensée ..

MERCI!

Adam

Answer 1

Ainsi ajoutant ProtocolInterface.h dans TÊTES + = section du fichier Plugin.pro résolvait le problème :)