Plugins activation

The activation of the plugins is performed through several ordered steps, which depend on if the application has a UI or not.

Overview

Activation for non UI applications

For an application which has no UI:

1. Instanciation of the Plugins
2. Getting the Plugins properties, allowing to get the dependencies between Plugins. After this step, Plugins which have declared dependencies on other Plugins but for which some of the Plugins on which they depend are not present will be discarded
3. After this step, the plugins initialization order will be used for the remaining steps of the process
4. Register the Plugins, allowing to declare the Plugin in the framework
5. If a Configuration manager exists for the application, Deserialize the Plugin configuration
6. Initialize the Plugins
7. Reset the Plugin settings

Activation for UI applications

For an application which has an UI:

1. Instanciation of the Plugins
2. Getting the Plugins properties, allowing to get the dependencies between Plugins. After this step, Plugins which have declared dependencies on other Plugins but for which some of the Plugins on which they depend are not present will be discarded
3. After this step, the plugins initialization order will be used for the remaining steps of the process
4. Register the Plugins, allowing to declare the Plugin in the framework
5. If a Configuration manager exists for the application, Deserialize the Plugins configuration
6. Initialize the Plugins
7. For all GUI Plugins (instances of GUI Plugins), initialize the Plugin GUI
8. Reset the Plugin settings

Plugins instanciation

The Plugins which are specified in the plugins directory or directories are instanciated in the following condition:

• Their manifest must specify the MDIPluginClass which will be instanciated. Note that it is safe to have other jar files in the directory because files which do not have the MDIPluginClass property in their manifest won't be loaded.

After the instanciation and for each Plugin, the Plugin name is retrieved:

• If the name belongs to another Plugin previously processed in this step, it will be discarded
• If the Plugin has been disabled in the application Plugin interface, it will be discarded

Getting the Plugin properties

To retrieve the characteristics of each Plugin, the Plugin.getProperty(Object) is called by the application PluginsManager.

The properties in particular allows to specify the Plugins on which each Plugin depends on. If one of the Plugins on which a Plugins depends on is not present or is disabled, the dependent Plugin will be disabled.

The dependency list of Plugins will determine the plugins initialization order for the remaining steps of the process.

Registering the Plugins

Registering a Plugin is performed through the Plugin.register(MDIApplication) method. The Plugin is not required to perform anything in this method, but it allows to pass the application to the Plugin.

Serializing and deserializing the Plugins configuration

The configuration for a Plugin will be automatically retrieved by the application by calling the Plugin.getPluginConfiguration() method. By default this method returns null, which means that the Plugin has no configuration.

For example:

      public class OpenImagePlugin extends AbstractMDIPlugin {
      
        public OpenImagePlugin() {
        }   
      
        public Configuration getPluginConfiguration() {
          return MyConfiguration.getInstance();
        }           

Initializing the Plugins

Initializing the Plugin is performed through the Plugin.init(MDIApplication) method. The Plugin is not required to perform anything in this method.

Reset the Plugin settings

The Plugin.resetSettings() method is called during the Plugins activation. It is up to the Plugin to decide what to do.

Initializing the Plugins GUI

The MDIPlugin.initAfterGUI(MDIApplication) method will be called GUI applications for each Plugin In the EDT or Platform Thread (which means that you don't need to take care of the Thread yourself in the Plugin).

The initAfterGUI method will call by default the AbstractMDIPlugin.initializeUIImpl() method so you can either:

• Implement the MDIPlugin.initAfterGUI(MDIApplication) method in your Plugin (the default calls the initializeUIImpl() method)
• Or implement the AbstractMDIPlugin.initializeUIImpl() method in your Plugin (the default does nothing)

Initializing GUI options

By default the method will be called for all GUI Plugins In the EDT or Platform Thread in a non blocking process. However you can customize how the call is performed by the plugins Manager by setting the mode in the AbstractApplication.initConfiguration(Preferences, short):

• The value MDIPluginsInitMode.INIT_EDT_NOT_BLOCKING: the initAfterGUI is called in the EDT or Platform Thread,, the process is not blocking
• The value MDIPluginsInitMode.INIT_EDT_BLOCKING: the initAfterGUI is called in the EDT or Platform Thread,, the process is blocking
• The value MDIPluginsInitMode.INIT_DEFAULT: the initAfterGUI is called in caller Thread

By default the INIT_EDT_NOT_BLOCKING mode will be used. It will be the case if you use the AbstractApplication.initConfiguration(Preferences) (which is, without specifying the mode).