Création de plugin avec Qt

Nicolas — Sun, 18 Feb 2007 23:11:00 +0100

Comment créer des plugins avec Qt ? et de manière multi-plateforme ?
Comment permettre à mes utilisateurs d'étendre eux-mêmes mon application ?

Ce tutoriel va nous détailler la création d'un système de plugins avec la bibliothèque Qt, et le chargement de ces plugins depuis notre application.

Version : Qt4 (supérieur ou égal à Qt 4.1)
Auteur : Nicolas Arnaud-Cormos (nikikko)
Test : Linux (Qt 4.1, 4.2)

Plugin, vous avez dit plugin ?

Qu'est-ce que c'est ?

Je n'ai pas réussit à faire mieux que Wikipedia pour la définition :

En informatique, un plugin ou plug-in, de l'anglais to plug in (brancher), parfois traduit en module externe, module enfichable, module d'extension, greffon ou plugiciel, est un logiciel tiers venant se greffer à un logiciel principal afin de lui apporter de nouvelles fonctionnalités. Le logiciel principal fixe un standard d'échange d'informations auquel ses modules se conforment. Le module n'est généralement pas conçu pour fonctionner seul mais avec un autre programme.

Comment ça marche ?

C'est relativement simple (en théorie ;)) :

Le logiciel principal défini une API standard : un ensemble de classes et de fonctions pouvant être utilisées/héritées par les plugins. C'est le lien, le langage commun entre le logiciel principal et les plugins.
Les plugins se basent sur cette API, et créent ainsi de nouvelles fonctionnalités pour le logiciel principal. Ils se présentent généralement sous forme de bibliothèques dynamiques (*.dll sous Windows ou *.so sous Linux). Pour pouvoir être chargés par le programme principal, ils doivent être copiés dans un répertoire spécifique.
Le logiciel principal, au démarrage, charge les plugins qu'il trouve, ajoutant ainsi de nouvelles fonctionnalités.

Avantages ?

Les avantages d'un système de plugins sont nombreux. En voici quelques uns :

l'utilisateur ou un intervenant externe peut étendre les fonctionnalités d'une application sans avoir son code source,
le logiciel est beaucoup plus modulaire : possibilité de faire des versions réduite, version complète...
la mise en place d'un système de plugin force à réfléchir un peu à l'architecture du logiciel, ce qui n'est pas un mal ;)

Les plugins avec Qt ? (pourquoi c'est pratique)

La mise en place d'un système de plugin est parfois assez lourde et nécessite par exemple de vérifier dans le programme principal si un plugin contient telle ou telle fonction. Je ne parle même pas d'un système multi-plateforme... heureusement, Qt est là.

Grâce à Qt, la réalisation d'un système de plugins multi-plateforme est relativement simple : la documentation Qt sur le système de plugins.

CalcOp

Pour illustrer la création de plugin, nous allons utiliser un exemple assez simple : un petit projet que j'ai nommé calcop, et qui permet à partir de 1, 2 ou 3 variables, d'effectuer une opération au choix de l'utilisateur (par exemple des additions, multiplications, remplacement de caractères dans une chaîne...).

Ça ne sert à rien, mais le principal c'est que l'exemple est très simple, il permet donc de se concentrer sur le code lié à la gestion de plugin. Le code source est livré avec deux plugins :

un plugin contenant des opérations mathématiques (addition, multiplication, division, soustraction, factoriel)
un plugin contenant des opérations sur les chaînes (inversion de sens et remplacement dans une chaîne)

Les sources du logiciel sont téléchargeables ici. Je vous conseille de les télécharger avant de vous lancer dans la lecture du tutoriel.

Le programme principal

Le programme principal est relativement simple. Je ne vais pas détailler tout le code, mais je vais me focaliser sur les parties nécessaires à la mise en place de plugins.

La première chose à faire, c'est de définir un ensemble d'interfaces à nos plugins : ce sont des classes avec seulement des fonctions virtuelles pures utilisées pour dialoguer entre l'application et les plugins. Il est possible bien entendu de définir plusieurs interfaces, pour différents types de plugin, mais dans notre cas nous n'en définissons qu'une seule, OperationInterface :

class OperationInterface
{
public:
    virtual ~OperationInterface() {}
    virtual QStringList operationList() = 0;
    virtualbool canCalculate( QString opName ) = 0;
    virtualint numVariable( QString opName ) = 0;
    virtual QString calculate( QString opName, QStringList variableList ) = 0;
};
Q_DECLARE_INTERFACE(OperationInterface,
                    "org.nikikko.CalcOp.OperationInterface/1.0")

La macro Q_DECLARE_INTERFACE permet d'indiquer lors de la compilation (à l'outil moc, le précompilateur Qt) que cette classe est une interface.

Attention : le deuxième élément de la macro "org.nikikko.CalcOp.OperationInterface" doit obligatoirement se finir par le nom de la classe (je me suis fait avoir au début).

Le reste du code, notamment la classe OperationManager, sera détaillé par la suite.

Création d'un plugin

La création du plugin est relativement simple. Il suffit de créer une classe qui hérite de notre interface OperationInterface. Voici par exemple le code pour le plugin mathématique :

#include <QObject>
#include <operationinterface.h>
class MathPlugin : public QObject, public OperationInterface
{
Q_OBJECT
Q_INTERFACES(OperationInterface)
public:
    QStringList operationList();
    bool canCalculate( QString opName );
    int numVariable( QString opName );
    QString calculate( QString opName, QStringList variableList );
};

Deux remarques importantes :

la classe de base d'un plugin (qui hérite d'une classe d'interface) doit toujours hériter de QObject,
toutes les fonctions de l'interface doivent être définies.

Note : il est possible dans un plugin d'avoir une classe qui hérite de plusieurs interfaces, pour cela voir l'exemple plugandpaint de Qt.

Et dans le fichier source :

Q_EXPORT_PLUGIN2(calcop_math, MathPlugin)

La macro Q_EXPORT_PLUGIN2 indique au compilateur qu'il faut exporter cette classe, et que cette classe est le point d'entrée du plugin. Pour faire simple, une classe exportée est une classe qui est visible à l'extérieur de la bibliothèque (donc par le programme principal).

Enfin, il faut indiquer dans le fichier .pro que l'on souhaite créer un plugin. Voici le fichier .pro correspondant au plugin calcop_math :

  TEMPLATE      = lib
  CONFIG       += release plugin
  INCLUDEPATH  += ../../src
  HEADERS       = mathplugin.h
  SOURCES       = mathplugin.cpp
  TARGET        = calcop_math
  DESTDIR       = ../../bin/plugins

Voilà quelques explications :

TEMPLATE = lib : création d'une bibliothèque
CONFIG += plugin : cette bibliothèque est un plugin
TARGET = calcop_math : ce plugin s'appelle calcop_math (même nom que dans la macro Q_EXPORT_PLUGIN2)
DESTDIR = ../../bin/plugins : mettre ce plugin dans le bon répertoire (répertoire des plugins de l'application)

Voilà, c'est relativement simple à faire, et en plus c'est multi-plateforme.

Chargement des plugins dans l'application

Dernière étape, c'est le chargement des plugins dans l'application. Tout ce qui concerne la gestion des plugins se fait à travers la classe OperationManager dans le programme principal. Cette classe charge les plugins, et s'occupe d'effectuer les appels nécessaires aux fonctions des plugins lors du calcul.

Pour me faciliter la vie, j'ai décidé d'en faire un singleton : c'est pour ça que le constructeur est privé, et que la classe comporte une fonction membre statique instance. Mais le code le plus intéressant se trouve dans le constructeur de cette classe :

QDir pluginsDir = QDir(qApp->applicationDirPath());
    pluginsDir.cd("plugins");
    foreach (QString fileName, pluginsDir.entryList(QDir::Files)) {
        QPluginLoader loader(pluginsDir.absoluteFilePath(fileName));
        QObject *plugin = loader.instance();
        if (plugin) {
            OperationInterface * op = qobject_cast<OperationInterface *>(plugin);
            if (op) {
                m_operationList << op;
            }
        }
    }

Nous avons trois actions importantes dans ce code :

déplacement dans le répertoire de plugin : les deux premières lignes vont nous permettre d'aller dans le répertoire des plugins,
chargement du plugin avec la classe QPluginLoader : on vérifie que le plugin est bien compatible avec la version du logiciel et de Qt, et crée une instance de l'objet racine (qui est une classe héritée de l'interface, dans notre cas ce sera une instance de MathPlugin).
vérification de la compatibilité du plugin : de quelle interface hérite-t-il (ici OperationInterface)

Si tout se passe bien, on enregistre le plugin dans la liste des opérations. Et voilà, c'est simple, clair et propre...

La classe QPluginLoader est au coeur de ce code : c'est elle qui va se charger de créer une instance du plugin. Au passage, l'instance créé, que l'on récupère à l'aide de la fonction instance(), est statique : si l'on utilise le même code dans une autre fonction, l'instance renvoyé sera toujours la même (ie le même pointeur).

Documentation Qtfr - class_QObject