Tutoriel sur la construction de plug-in avec la plateforme Eclipse (Leçon 1)

Mickael BARON

Le but de cette première leçon est d'apprendre à construire et exécuter un plug-in minimal sous Eclipse.

Buts pédagogiques : assistant de création de plug-ins, manipulation de concepts OSGi, création d'extensions, de vues, de catégories et mise en place de configurations d'exécution d'applications Eclipse.

Codes source : les codes source et la solution de la leçon sont disponibles à l'adresse suivante : lesson1-ressources.zip

Pour réagir à ce support de cours, un espace de dialogue vous est proposé sur le forum Commentez .

- Titre : Tutoriel sur la construction de plug-in avec la plateforme Eclipse (Leçon 1)

- Auteur : Mickael BARON

- Parution : 28 septembre 2009

- Mise à jour : 22 février 2020

- Licence : Le contenu de cet article est rédigé par Mickael BARON et est mis à disposition selon les termes de la Licence Creative Commons Attribution - Partage dans les Mêmes Conditions 3.0 non transposé. Les logos Developpez.com, en-tête, pied de page, css, et look & feel de l'article sont Copyright ® 2013 Developpez.com.

Sommaire

- Exercice 1 : Construction interactive d'un plug-in Eclipse

- But

- Description

- Étapes à suivre

- Exercice 2 : Manipuler les concepts OSGi

- But

- Description

- Étapes à suivre

- Exercice 3 : Construire des vues

- But

- Description

- Étapes à suivre

- Exercice 4 : Exécution d'un plug-in

- But

- Description

- Étapes à suivre

- Exercice 5 : Construire une catégorie pour une vue

- But

- Description

- Étapes à suivre

- Pour aller plus loin…

Exercice 1 : Construction interactive d'un plug-in Eclipse

But

- Construire un plug-in en utilisant l'assistant de création fourni par l'environnement Eclipse.

- Examiner les classes qui ont été générées.

Description

Le plug-in eclipse.labs.jugercp.attendees s'occupe de la gestion des participants de la session Atelier Construction Plug-in avec la plateforme Eclipse. Il fournit une vue pour la saisie d'un nouveau participant, une vue pour afficher la liste des participants et une perspective pour agencer ces vues. Dans cet exercice, on se limite à la construction de la structure du plug-in.

Étapes à suivre

Démarrez Eclipse.

Choisissez comme nom du Workspace la valeur workspaceEclipseLabs.

Sélectionnez à partir du menu Eclipse l'action File -> New -> Project pour ouvrir l'assistant de création de projets. Le groupe « Plug-in Development » fournit un ensemble d'assistants liés au développement de plug-ins. Sélectionnez l'assistant de création de projets de plug-in (Plug-in Project).

Dans la zone de saisie Project name saisissez le nom du projet eclipse.labs.jugercp.attendees lié au plug-in à créer. Laissez les paramètres par défaut en s'assurant que la cible d'exécution est une application Eclipse.

Le prochain écran permet de paramétrer le plug-in en cours de construction. Laissez les paramètres par défaut comme indiqué sur la figure ci-dessous.

NE PAS UTILISER de patron de génération qui, pour cette première prise en main de la plateforme Eclipse, masque certains concepts intéressants à réaliser manuellement. Veuillez par conséquent décocher la case Create a plug-in using one of the templates.

L'environnement Eclipse génère un ensemble de fichiers dont la structure doit être identique à la structure présentée ci-dessous. Prenez connaissance des différents fichiers et répertoires générés. Veuillez remarquer dans l'arborescence le nœud Plug-in Dependencies qui permet de connaître les dépendances de ce plug-in (ce sont à cet instant des plug-ins de la plateforme Eclipse).

Toutes les informations liées au plug-in sont stockées dans le fichier MANIFEST.MF (partie OSGi) et plugin.xml (partie extension). L'édition de ces fichiers peut être réalisée de manière textuelle ou en utilisant l'outil PDE (Plugin Development Environment) dont une capture d'écran est donnée ci-dessous.

Exercice 2 : Manipuler les concepts OSGi

But

- Comprendre le cycle de vie d'un plug-in via la classe Activator.

- Exporter des services.

- Effectuer un parallèle entre un bundle OSGi et un plug-in Eclipse.

Description

Un ensemble de classes Java décrivant une API pour la création et l'interrogation d'un participant a été réalisé, l'objectif étant de se focaliser principalement sur le développement de plug-in. Il vous est demandé dans cet exercice d'enrichir le plug-in eclipse.labs.jugercp.attendees en ajoutant cette API, en initialisant le gestionnaire de participants dans la classe Activator puis en exposant certains services de cette API.

Étapes à suivre

Copiez les interfaces IAttendee, IAttendeesManager et IAttendeeListener puis les classes Attendee et AttendeesManager situées dans le répertoire ressources\lesson 1 - Construction d'un plug-in\exercice2-1 dans le plug-in créé précédemment en respectant le chemin défini par le package de chaque interface et classe.

Ce plug-in fournit un service de gestion des participants par l'intermédiaire de IAttendeesManager et de son implémentation AttendeesManager. Pour que ce plug-in puisse exposer ce service à d'autres plug-ins (utile notamment pour la leçon 3), il est nécessaire de le préciser dans les métadonnées du plug-in (fichier MANIFEST.MF). Éditez interactivement, via l'outil PDE le fichier MANIFEST.MF, la section Runtime en ajoutant le package eclipse.labs.jugercp.attendees (résultat doit être identique à la figure ci-dessous).

Modifiez la classe Activator (qui gère le cycle de vie du plug-in) de telle sorte que le gestionnaire des participants soit initialisé au démarrage du plug-in, que le gestionnaire des participants soit accessible via un accesseur (IAttendeesManager getAttendeesManager()), qu'une fabrique d'objets IAttendee soit disponible (IAttendee createAttendee(String pName, String pCompany)) et enfin que la liste des participants soit vidée à l'arrêt du plug-in.

1. private IAttendeesManager refAttendeesManager;

3. private int count = 0;

5. /**

6. * The constructor

7. */

8. public Activator() {

9. }

11. public void start(BundleContext context) throws Exception {

12. super.start(context);

13. plugin = this;

14. refAttendeesManager = new AttendeesManager();

15. }

17. public void stop(BundleContext context) throws Exception {

18. plugin = null;

19. refAttendeesManager.removeAllAttendees();

20. super.stop(context);

21. }

23. public IAttendeesManager getAttendeesManager() {

24. return refAttendeesManager;

25. }

27. public IAttendee createAttendee(String pName, String pCompanyName) {

28. return new Attendee(pName, pCompanyName, count++);

29. }

31. /**

32. * Returns the shared instance

33. *

34. * @return the shared instance

35. */

36. public static Activator getDefault() {

37. return plugin;

38. }

Exercice 3 : Construire des vues

But

- Construire une extension.

- Implémenter une vue en dérivant de la classe ViewPart.

- Notion d'identifiant.

- Manipulation de l'API JFace / SWT.

Description

Deux vues sont à définir : une interface graphique pour la saisie du nom et de la société (deux champs de texte) puis une vue qui affiche la liste de l'ensemble des participants (une table). Lorsqu'un participant est ajouté bouton Ajouter, la liste est mise à jour. ATTENTION : à ce niveau nous ne gérons pas la sélection d'un participant dans la liste qui permettrait par exemple d'éditer un profil d'un participant (voir leçon 3). Par ailleurs, une partie des interfaces graphiques a été définie pour faciliter le développement.

Étapes à suivre

À partir de l'outil PDE, sélectionnez l'onglet des Extensions qui permet de construire de nouvelles extensions.

Sélectionnez l'action Add qui permet d'ajouter une nouvelle série d'extensions à partir d'une extension donnée, en l'occurrence ici le point d'extension org.eclipse.ui.views.

Dans le champ de saisie Extension Point filter, faites un filtre sur *views* et choisissez le point d'extension org.eclipse.ui.views (voir capture d'écran ci-dessous). Ne pas sélectionner le patron Sample View.

Ajoutez un nouvel élément de type view pour créer une vue Edition Participant (sélectionnez l'élément org.eclipse.ui.views puis bouton droit et enfin choisir view).

Remplissez les différents champs en respectant les valeurs comme cela est précisé sur la capture d'écran ci-dessous. Le champ class permet de définir la classe qui implémentera l'interface graphique de la vue.

Une partie du code de la classe AttendeeViewPart a déjà été développée pour simplifier l'exercice. Copiez cette classe située dans le répertoire ressources\lesson 1 - Construction d'un plug-in\exercice3-6 en respectant le chemin défini par le package.

À partir de la classe AttendeeViewPart complétez le code du traitement de l'action Ajouter (récupérez l'instance de l'objet Activator, créez un participant, ajoutez ce participant au gestionnaire des participants puis effacer le contenu des champs de texte).

1. newAttendee.addSelectionListener(new SelectionListener() {

2. @Override

3. public void widgetSelected(SelectionEvent e) {

4. // Add

5. Activator currentActivator = Activator.getDefault();

6. IAttendee createAttendee = currentActivator.createAttendee(attendeeNameValue.getText(),

7. companyNameValue.getText());

8. Activator.getDefault().getAttendeesManager().addAttendee(createAttendee);

10. attendeeNameValue.setText("");

11. companyNameValue.setText("");

12. }

14. @Override

15. public void widgetDefaultSelected(SelectionEvent e) {

16. }

17. });

Créez un nouvel élément de type view pour créer une vue Liste Participants (sélectionnez l'élément org.eclipse.ui.views puis bouton droit et enfin choisir view) et remplissez les différents champs comme cela est précisé sur la capture d'écran ci-dessous.

La classe AttendeesViewPart a déjà été développée en partie, copiez cette classe située dans le répertoire ressources\lesson 1 - Construction d'un plug-in\exercice3-9 en respectant le chemin défini par le package.

Complétez la classe AttendeesViewPart pour réaliser un abonnement d'un écouteur IAttendeeListener de telle sorte que tout changement du gestionnaire de participants notifie la vue Liste Participants. Utilisez la méthode refresh() et refresh(Object) de la classe TableViewer pour notifier la table qu'une modification du modèle a été réalisée.

1. Activator.getDefault().getAttendeesManager().addAttendeeListener(new IAttendeeListener() {

2. @Override

3. public void attendeeRemoved(IAttendee p) {

4. viewer.refresh(p);

5. }

7. @Override

8. public void attendeeAdded(IAttendee p) {

9. viewer.refresh();

10. }

12. @Override

13. public void allAttendeeRemoved() {

14. viewer.refresh();

15. }

17. @Override

18. public void attendedUpdated(IAttendee p) {

19. viewer.refresh(p);

20. }

21. });

Exercice 4 : Exécution d'un plug-in

But

- Exécuter un plug-in à partir d'une configuration d'exécution.

- Lier à la configuration d'exécution les dépendances nécessaires.

Description

Dans cet exercice nous définissons une configuration d'exécution permettant de tester le plug-in eclipse.labs.jugercp.attendees. Ce plug-in est associé avec un sous-ensemble de plug-ins de la plateforme Eclipse qui constitue un noyau minimum pour tester de nouveaux plug-ins développés.

Étapes à suivre

Ouvrez le menu d'édition des configurations d'exécution comme indiqué sur la capture d'écran ci-dessous. ALTERNATIVE : passez par le menu Eclipse Run -> Run Configurations…

Créez une nouvelle configuration via l'action New launch Configuration.

Dans la zone de droite, modifiez le nom de la configuration en JugercpAttendeesConfiguration puis modifiez l'emplacement des données du Worskpace (utilisé pour l'exécution) en ${workspace_loc}/../JugercpAttendeesConfiguration.

Dans l'onglet Plug-ins, modifiez la valeur Launch with en plug-ins selected below only puis sélectionnez uniquement le plug-in eclipse.labs.jugercp.attendees.

Décochez l'élément Target Platform puis sélectionnez l'action Add Required Plug-ins. Ceci a pour effet d'ajouter uniquement les plug-ins utiles pour l'exécution de notre plug-in (voir résultat attendu sur la capture d'écran ci-dessous).

Démarrez la configuration d'exécution via l'action Run. Une nouvelle instance d'Eclipse (avec des fonctionnalités réduites) démarre.

À partir de cette nouvelle instance d'Eclipse, visualisez les vues du plug-in qui ont été développées via le menu Window -> Show View -> Other. Dans la fenêtre dépliez le nœud Other et sélectionnez les deux vues : Edition Participant, Liste Participants. Elles s'affichent dans la perspective courante.

ASTUCE : il est possible de persister dans un fichier physique les paramétrages des configurations d'exécution. L'avantage étant que tous ces paramétrages sont alors associés au projet du plug-in et non au Workspace. Par conséquent lors de l'importation d'un projet dans un autre Workspace la configuration d'exécution est également importée.

Éditez la configuration d'exécution précédente et sélectionnez l'onglet Common. Puis dans la partie Save As, choisissez Shared file et sélectionnez le projet eclipse.labs.jugercp.attendees. En appliquant les modifications, un nouveau fichier est ajouté à la racine du projet JugercpAttendeesConfiguration.launch.

Exercice 5 : Construire une catégorie pour une vue

But

- Créer un élément category du point d'extension org.eclipse.ui.views.

- Associer des vues à une catégorie.

Description

Une catégorie de vues permet de réaliser des regroupements de vues. La décomposition en catégories est visible au niveau de la liste de l'ensemble des vues. Il vous est demandé dans cet exercice de créer une nouvelle catégorie jugercp et d'associer les vues Edition Participant et Liste Participants à cette catégorie.

Étapes à suivre

Créez un élément category à partir du point d'extension org.eclipse.ui.views dont l'identifiant est eclipse.labs.jugercp.attendees.category et son nom est jugercp (valeur qui sera affichée à l'utilisateur).

Associez l'identifiant de la catégorie aux paramètres des deux vues (capture d'écran des paramètres de la vue Edition Participant).

Démarrez la configuration d'exécution associée au plug-in et affichez la liste des vues disponibles Window -> Show View -> Other. Le nœud Other a été remplacé par jugercp.

Pour aller plus loin…

- https://mbaron.developpez.com/eclipse/swt/ : support de cours relatif à la boîte à outils SWT.

- https://mbaron.developpez.com/eclipse/jface1/ : support de cours relatif à l'utilisation des composants Viewer.

- https://mbaron.developpez.com/eclipse/introplugin/ : support de cours relatif à la conception de plug-in (cycle de vie, concepts OSGi).

- https://mbaron.developpez.com/eclipse/extension/ : support de cours relatif à la construction d'extensions et de points d'extension.