Plug-ins dynamiques

Les plug-ins dynamiques permettent d'insérer et de retirer des plug-ins dans une instance d'Eclipse en cours de fonctionnement. Composant réutilisable pouvant être déchargé, les plug-ins dynamiques vous aident à surveiller les allées et venues des plug-ins.

Un plug-in dynamique peut ne pas rester pendant toute la vie de l'application, et il est donc essentiel de s'assurer que tout est nettoyé quand le composant n'est plus là. Quand des programmes d'écoute sont ancrés sur le plan de travail et que des éléments sont enregistrés, ils restent là après l'arrêt, et ces plug-ins doivent savoir qu'il faut nettoyer.

Il est faux de penser qu'une lecture de toutes les implémentations des points d'extension est suffisante pour la durée de vie de l'application. Vous devez vous assurer que le programme d'écoute est ancré ou que rien n'est encaissé, de manière à ce que les changements de registre soient écoutés. Il est important de comprendre que les éléments du plan de travail ne sont pas forcément fixes, ils sont transitoires et peuvent partir n'importe quand. Si vous écrivez un plug-in pour une vue particulière, vérifiez d'abord que la vue est toujours là.

En tant que développeur de plug-in vous devez vérifier que les extensions que vous êtes susceptible d'utiliser ont le droit d'apparaître et de disparaître à n'importe quel point. Quand ils disparaissent, vous devez nettoyer toutes les structures internes pouvant représenter les extensions et retirer tout artefact d'interface qu'ils pourraient piloter. Quand ils apparaissent vous devriez augmenter vos structures internes et peut-être créer de nouveaux artefacts d'interface. En partant du principe que votre application lit depuis le registre et possède une extension, vous lui créez un enregistrement et l'affectez à son emplacement. A sa fin, vous serez prévenu qu'un nettoyage est nécessaire. De plus, un programme d'écoute annoncera quand de nouveaux éléments arrivent et les créera.

org.eclipse.core.runtime.dynamicHelpers.IExtensionTracker et les interfaces associées fournissent un mécanisme par lequel les développeurs de plug-in peuvent facilement suivre les arrivées et les départs des extensions et gérer les ressources générées par ces actions.

L'exemple qui suit part du principe que vous avez un point d'extension dans votre plug-in appelé widgets et que vous utilisez IExtensionTracker. En interne, vous avez WidgetDescriptors qui encapsule les extensions de widget et un WidgetRegistry pour les gérer.



	public class WidgetRegistry implements IExtensionChangeHandler {

	
	
	  public WidgetRegistry() {
		
		IExtensionTracker tracker = PlatformUI.getWorkbench()
	
  	.getExtensionTracker();
IExtensionPoint point = Platform.getExtensionRegistry() .getExtensionPoint("my.plugin.namespace", "widget");
IExtension[] extensions = point.getExtensions();
// initial population
for (int i = 0; i < extensions.length; i++) { addExtension(tracker, extensions[i]);
} tracker
.registerHandler(this, tracker
.createExtensionPointFilter(point)); } public void addExtension(IExtensionTracker tracker, IExtension extension){ WidgetDescriptor descriptor = new WidgetDescriptor(extension); tracker.registerObject(extension, descriptor,
IExtensionTracker.REF_STRONG); addToInternalStructure(descriptor) } private void addToInternalStructure(WidgetDescriptor descriptor) { // registry specific logic } public void removeExtension(IExtension extension, Object[] objects) { for (int i = 0; i < objects.length; i++) { WidgetDescriptor descriptor = (WidgetDescriptor) objects[i];
removeFromInternalStructure(descriptor);
}
} private void removeFromInternalStructure(WidgetDescriptor descriptor) { // registry specific logic }
} public void dispose() { PlatformUI.getWorkbench() .getExtensionTracker().unregisterHandler(this)
} }

Dans cet exemple l'interface de la plate-forme fournit des instances IExtensionTracker à divers niveaux du plan de travail. Si vous suivez des objets qui ont la même durée de vie que le plan de travail, utilisez le traqueur fournit par IWorkbench.getExtensionTracker(). Si vos objets relèvent de pages ou fenêtres d'un plan de travail particulier, utilisez les traqueurs fournis par IWorkbenchWindow.getExtensionTracker() ou IWorkbenchPage.getExtensionTracker(). Par exemple, le plan de travail traque les descripteurs de vue au niveau du plan de travail, mais les instances de vues au niveau de la page du plan de travail. Vos descripteurs peuvent être enregistrés contre des points d'extension particuliers en fournissant une instance IFilter au IExtensionTracker.registerHandler(). Votre descripteur ne sera appelé que quand des extensions correspondant à l'objet du IFilter sont ajoutées ou retirées.

Quand une extension entre dans le temps d'exécution, cette méthode sera appelée. Votre descripteur a alors la possibilité d'incorporer la nouvelle extension à son modèle associé. Tout objet créé sur la base de l'IExtension fournie à cette interface devrait être enregistrée contre le traqueur via IExtensionTracker.registerObject(). Quand une extension quitte le temps d'exécution, cette méthode sera appelée. Tout objet enregistré précédemment contre l'extension sera considéré comme un argument. Votre descripteur pourra alors nettoyer et se débarrasser des objets, selon ce qui sera nécessaire. Il est bon de radier vos descripteurs de façon à ce que vos registres ne fuient pas.