TD6 - Etude d'un programme utilisant des plugins

Projet MiniJeu1

Lorsque il a fallu transformer le TP du jeu pour mettre en évidence une conception à base de plugins, il a fallu refactorer le projet. Pourquoi ? Parceque dans l'hypothèse où un groupe développe le jeu et où d'autres groupes développent les plugins, il faut identifier quelles seront les classes qui seront nécessaires à l'écriture de plugins. On les a mises dans le package pluginsSDK. Vous remarquerez que la classe Jeu.java y figure, simplement, on ne "construit" plus le jeu dans cette classe, regardez là et comparez avec la version de l'ancien TP. Le constructeur ne crée plus d'objets...er

En revanche la classe MaFenetre.java qui construit la GUI du jeu a légèrement changé. Elle crée la fenêtre principale, instancie le Jeu (qui est un JPanel) et le met au centre, puis ajoute un Cercle dans le jeu. Ensuite on utilise les classes PluginManager et PluginLoader de la librairie de gestion des plugins pour :

1. Charger les classes de Plugins dans un tableau de plugins (toutes celles qui sont des Plugin)
2. Instancier celles qui sont des ComportementPlugins (rappel, si vous regardez le code, ComportementPlugin implémente Plugin)
3. Créer un menu déroulant avec des CheckBoxMenuItems pour chaque comportement, associer un ActionListener à chaque entrée pour ajouter/enlever le comportement sélectionné au cercle.

Etudions plus en détail... tout se passe dans l'appel de la méthode :

private void litPluginsEtConstruitMenuDesComportements(final JMenuBar mb) {
        // Ici on lit les plugins et on construit le menu
        pluginManager = PluginManager.getPluginManager();

        try {
            // Tous les jars dans le sous dir plugins seront lus
            pluginManager.addJarURLsInDirectories(new URL[]{new URL("file:plugins")});
        } catch (MalformedURLException ex) {
            Logger.getLogger(MaFenetre.class.getName()).log(Level.SEVERE, null, ex);
        } 

        // On charge les classes qui oimplémentent l'interface Plugin.class. Voir le package pluginsSDK
        pluginManager.loadPlugins();

        // Ici on crée un tableau avec une instance de chaque plugin. On s'en sert un peu plus bas pour
        // construire un menu de comportements
        plugins = (ComportementPlugin[]) pluginManager.getPluginInstances(ComportementPlugin.class);

        // On construit le menu nous indiquant les comportements possibles
        // Dans cette méthode on ajoute un écouteur à chaque menuItem
        // qui associe un comportement/plugin au cercle créé dans le jeu
        buildPluginMenu(mb);
    }

 Une fois le tableau des ComportementPlugins rempli avec une instance de chaque comportement, on peut construire le menu. Pour cela on utilise les classes PluginMenuFactory.java et PluginMenuItem.java qui nous facilitent la vie.

private void buildPluginMenu(JMenuBar menuBar) {
        menuPlugins = new JMenu("Plugins");

        // L'actionListener qui va écouter les entrées du menu des plugins. C'est une instance d'une     
        // classe interne anonyme...
        ActionListener listener = new ActionListener() {

            public void actionPerformed(ActionEvent e) {
                // On récupère le menu item qui a été choisi
                JCheckBoxMenuItem cb = (JCheckBoxMenuItem) e.getSource();

                // On récupère la chaine qui était affichée dans le menu,
                // c'est par défaut dans l'attribut ActionCommand du menu item
                String nameCommand = cb.getActionCommand();

                // On va chercher dans le tableau des plugins celui qui porte le même nom
                ComportementPlugin c = searchPlugin(nameCommand);

                // On regarde si il est selectionné, si il est selectionné c'est que
                // l'objet avait déjà ce comportement, dans ce cas on le retire,
                // sinon on l'ajoute. Dans tous les cas, on inverse l'état du
                // checkbox menu item
                if (cb.getState() == true) {
                    System.out.println("J'ajoute le " + c.getName());
                    objetAnime.ajouteComportement(c);
                } else {
                    System.out.println("Je supprime le " + c.getName());
                    objetAnime.supprimeComportement(c);
                }
            }
        };


        if (pluginMenuItemFactory == null) {
            // Utilisation d'une factory pour construire les menus à partir du tableau de plugins
            // Remarque : le dernier paramètre est l'écouteur qui sera exécuté lorsque le menu item sera selectionné
            pluginMenuItemFactory = new PluginMenuItemFactory(menuPlugins, pluginManager, listener);

        }

        buildPluginMenuEntries();  

        // On rajoute le menu à la barre de menus
        menuBar.add(menuPlugins);


    } 

private void buildPluginMenuEntries() {

        // Fait construire les entrées du menu des plugins
        pluginMenuItemFactory.buildMenu(null);
    }

Projet MinJeu1Plugins

Dans ce projet on retrouve les comportements du TP précédent, à quelques différences près :

1. Les noms des packages ont changé,
2. Une classe ComportementPlugin a fait son apparition, tous les Comportements vont l'étendre. Cette classe implémente la classe Plugin qui vient de la librairie de plugins. Elle oblige tous les plugins à implémenter des méthodes getName(), getDescription(), getVersion() c'est-à-dire qu'elle oblige tous les plugins à se décrire. Elle oblige aussi à implémenter canProcess(Object o) et une autre méthode, nous en verrons l'utilité plus tard. Pour le moment, lorsque vous les implémenterez elle renverront true. (Pour info : elles servent à dire si un plugin donné peut traiter un autre type d'objet).

package minijeu.pluginsSDK;

import fr.unice.plugin.Plugin;

public interface ComportementPlugin extends Plugin {

    public void deplace(ObjetAnime o);


}

Et voici par exemple le comportement par défaut :

package minijeu.comportements;

import minijeu.pluginsSDK.ComportementPlugin;
import minijeu.pluginsSDK.ObjetAnime;

public class ComportementParDefaut implements ComportementPlugin {

 public void deplace(ObjetAnime o) {
     // le comportement de base, fait avancer l'objet dans sa direction,
     // en fonction de sa vitesse linéaire. Il fait aussi varier sa vitesse linéaire
     // et angulaire en fonction des accélérations linéaires et angulaires

         o.xPos +=  o.vitesse * Math.cos( o.direction);
         o.yPos +=  o.vitesse * Math.sin( o.direction);
         o.vitesse =  o.vitesse +  o.acceleration;
         o.direction =  o.direction + o. accelerationAngulaire;

        // On garde la direction entre 0 et 2*PI
       o.normaliseDirection();

    }


    public String getName()  {
        return "Comportement par defaut";
    }

    public Class getType() {
        return ComportementParDefaut.class;
    }

    public String getDescription() {
        return "Comportement par defaut : l'objet avance dans sa direction, à  sa vitesse...";
    }

    ...

    public String getVersion() {
        return "1.0";
    }
}

Projet libPlugins

Ce projet est assez compliqué, en plus sous Eclipse, tous les accents dans les commentaires ont été transformés en trucs bizarre suite à des problèmes d'encodage (ça marche dans Netbeans)... Regardez surtout les classes Plugin.java, PluginLoader.java, PluginManager.java

On ne vous demande pas de tout comprendre dans le détail (à propos, ce projet utilise des enums qui ont changé depuis java 1.3, il a été écrit à l'époque de java 1.3, avant que cela change, c'est pourquoi dans les propriétés du projet nous sommes dans un mode de compatibilité java 1.3). Notez cependant que gérer tous les cas de figures (plugins dans un jar, dans plusieurs jars, hors des jars, filesystem unix ou windows, nombreux cas d'erreurs gérés par de très nombreuses exceptions, etc) représente pas mal de travail.

Cette librairie a été écrite par Richard Grin et pas mal modifiée par Michel Buffa il y a quelques années. Vous pouvez la réutiliser telle quelle dans vos projets.