Plugin dinamici

I plugin dinamici consentono di inserire e rimuovere plugin in un'istanza di Eclipse in esecuzione. Componenti riutilizzabili con la possibilità di non dover essere scaricati, i plugin dinamici consentono di tenere traccia in modo semplice del flusso dei plugin.

I plugin dinamici non durano per tutta la durata dell'applicazione, ma sono essenziali per assicurarsi che quando un componente viene rimosso, tutto i dati inerenti a tale componente vengano eliminati. Quando i listener vengono caricati sul workbench e gli elementi vengono registrati, rimangono allo stesso posto dopo la chiusura, e devono essere cancellati.

L'ipotesi che all'avvio, la lettura di tutte le implementazioni del punto di estensione sia sufficiente per tutta la durata dell'applicazione è falsa e non funzionerà. È necessario assicurarsi che il listener sia registrato e che niente sia memorizzato nella cache, in modo che le modifiche al registro vengano rilevate. È importante comprendere che gli elementi nel workbench non sono necessariamente statici, sono infatti transitivi e possono essere eliminati in qualsiasi momento. Se si desidera scrivere un plugin per una determinata vista, assicurarsi innanzitutto che la vista sia ancora presente.

In quanto sviluppatore di plugin, è necessario assicurarsi che qualsiasi estensione utilizzata possa apparire e scomparire in un determinato punto. Quando l'estensione scompare, sarà necessario eliminare qualsiasi struttura interna che possa rappresentare le estensioni e rimuovere qualsiasi risorsa UI a cui possano essere collegate. Quando vengono visualizzate, aumentare le strutture interne e possibilmente creare nuove risorse UI. Se l'applicazione legge dal registro ed ha una estensione, creare un record ed assegnarlo all'ubicazione. Alla conclusione, verrà comunicato che è necessaria una cancellazione di dati. Inoltre il listener comunica quando vengono ricevuti nuovi elementi.

org.eclipse.core.runtime.dynamicHelpers.IExtensionTracker e le interfacce associate forniscono un meccanismo per cui gli sviluppatori di plugin possono facilmente tenere traccia delle estensioni in entrata e in uscita e gestire le risorse generate da tali azioni.

Il seguente esempio presume che il plugin contiene un punto di estensione chiamato widget e che si sta utilizzando IExtensionTracker. Internamente, si dispone di WidgetDescriptors che ingloba le estensioni widget e un WidgetRegistry per gestirle.



	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)
} }

In questo esempio l'UI della piattaforma fornisce istanze IExtensionTracker a diversi libello del workbench. Se si desidera tenere traccia degli oggetti che esistono per tutta la durata del workbench, utilizzare il tracker fornito da IWorkbench.getExtensionTracker(). Se gli oggetti sono importanti per particolare pagine o finestre del workbench, utilizzare i tracker forniti da IWorkbenchWindow.getExtensionTracker() o IWorkbenchPage.getExtensionTracker(). Ad esempio, il workbench tiene traccia dei descrittori della vista al livello del workbench ma tiene traccia delle istanze della vista reale a livello della pagina del workbench. I gestori possono essere registrati con punti di estensione particolari fornendo un'istanza IFilter a IExtensionTracker.registerHandler(). Il gestore verrà richiamato solo quando le estensioni che corrispondono all'oggetto IFilter vengono aggiunte o rimosse.

Quando un estensione entra nel runtime, verrà richiamato questo metodo. Il gestore, a questo punto, avrà la possibilità di incorporare la nuova estensione nel modello associato. Qualsiasi oggetto creato in base all'estensione fornita a questa interfaccia, dovrebbe essere registrata nel tracker via IExtensionTracker.registerObject(). Quando un'estensione lascia il runtime, verrà richiamato questo metodo. Qualsiasi oggetto precedentemente registrato con l'estensione, verrà trasmesso come argomento. Il gestore, a questo punto, può eliminare gli oggetti come necessario. Si consiglia sempre di annullare la registrazione dei gestori.