Plug-ins Dinâmicos

Plug-ins dinâmicos fornecem a habilidade de inserir e remover plug-ins em uma instância em execução do Eclipse. Um componente reutilizável com o potencial de se descarregado, Plug-ins Dinâmicos fornecem uma maneira fácil de ajudar a controlar as idas e vindas de plug-ins.

Um plug-in dinâmico pode não permanecer por todo o ciclo de vida do aplicativo, como tal, ele é essencial para garantir que quando o componente sai, tudo é limpo. Quando os listeners são capturados no Workbench e itens são registrados, eles permanecem ali após o encerramento, esses plug-ins devem saber que precisam de limpeza.

A suposição de que na inicialização, uma leitura de todas as implementações do ponto de extensão será suficiente para o ciclo de vida do aplicativo é falsa, pois isso não funciona. Você deve garantir que o listener seja capturado ou que nada seja nunca colocado em cache, de maneira que alterações no registro sejam escutadas. É importante entender que itens no workbench não são necessariamente estáticos; na verdade, eles são temporários e podem sair a qualquer momento. Se estiver gravando um plug-in para uma visualização específica, primeiro verifique se a visualização ainda está lá.

Como um desenvolvedor de plug-in, você precisa verificar se qualquer extensão que possa utilizar tem permissão para aparecer e desaparecer em qualquer ponto específico. Quando elas desaparecem, você deve confirmar seu desaparecimento, limpando quaisquer estruturas internas que possam representar as extensões e remover quaisquer artefatos da UI que elas possam dirigir. Quando elas aparecem, você deve aumentar suas estruturas internas e possivelmente criar novos artefatos da UI. Suponha que o aplicativo esteja lendo a partir do registro e tenha uma extensão, você cria um registro para ele e designa seu local. Na conclusão, você será notificado de que uma limpeza é necessária. Além disso, um listener anunciará quando novos itens entrarem e os criarem.

O org.eclipse.core.runtime.dynamicHelpers.IExtensionTracker e as interfaces associadas fornecem um mecanismo pelo qual os desenvolvedores de plug-in podem facilmente controlar as idas e vindas de extensões e gerenciar os recursos gerados por essas ações.

O seguinte exemplo assume que você possui um ponto de extensão em seus widgets chamados pelo plug-in e que está utilizando o IExtensionTracker. Internamente, você tem WidgetDescriptors que encapsulam extensões de widget e um WidgetRegistry para gerenciá-los.



	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();
// população inicial
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) { // lógica específica do registro } 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) { // lógica específica do registro }
} public void dispose() { PlatformUI.getWorkbench() .getExtensionTracker().unregisterHandler(this)
} }

Neste exemplo a UI da Plataforma fornece instâncias do IExtensionTracker em vários níveis do Workbench. Se você estiver controlando objetos que existem pelo ciclo de vida do workbench, deverá utilizar o rastreador fornecido pelo IWorkbench.getExtensionTracker(). Se seus objetos forem relevantes para janelas ou páginas específicas do workbench, você deverá utilizar os rastreadores fornecidos pelo IWorkbenchWindow.getExtensionTracker() ou IWorkbenchPage.getExtensionTracker(). Por exemplo, o Workbench rastreia descritores de visualização no nível do Workbench, mas rastreia instâncias reais de visualização no nível da página do workbench. Suas rotinas de tratamento devem estar registradas em pontos de extensão específicos por meio do fornecimento de uma instância de IFilter para IExtensionTracker.registerHandler(). A rotina de tratamento será chamada apenas quando extensões que correspondem ao objeto IFilter forem incluídas ou removidas.

Quando uma extensão entra no tempo de execução, esse método é chamado. Então, a rotina de tratamento tem a oportunidade de incorporar a nova extensão em seu modelo associado. Quaisquer objetos criados com base na IExtension fornecida para essa interface devem ser registrados no rastreador por meio do IExtensionTracker.registerObject(). Quando uma extensão sai do tempo de execução, esse método é chamado. Quaisquer objetos registrados anteriormente na extensão são transmitidos como argumentos. Em seguida, a rotina de tratamento pode limpar e descartar os objetos, conforme necessário. É uma boa prática cancelar o registro de suas rotinas de tratamento para que seus registros não tenham vazamentos.