PluginManifestKeys (MDIFramework API)

All Known Implementing Classes:

PluginsManager
```
public interface PluginManifestKeys
```
The Manifest keys for Plugins.

Since:

1.4.16

Field Summary

Fields
Modifier and Type	Field and Description
`static java.lang.String`	`KEY_PLUGIN_CLASS` "MDIPluginClass":The Plugin ClassPath manifest key.
`static java.lang.String`	`KEY_PLUGIN_CONFIG` "MDIPluginConfig": The manifest key for a list of configuration names use by this Plugin.
`static java.lang.String`	`KEY_PLUGIN_DEPENDENCIES` "MDIPluginDependencies": The manifest key to set the list of other Plugins on which this Plugin is dependant on.
`static java.lang.String`	`KEY_PLUGIN_FACTORY` "MDIPluginFactory": The Plugin factory. it can be used to customize a Plugin initialization.
`static java.lang.String`	`KEY_PLUGIN_TYPE` "MDIPluginType": The Plugin type manifest key.

- Field Detail
  - KEY_PLUGIN_TYPE
```
static final java.lang.String KEY_PLUGIN_TYPE
```
    "MDIPluginType": The Plugin type manifest key. This is used to retrict the allowed Plugins depending on their type. The list of allowed Types can be set through the PluginsManager.setAllowedPluginTypes(java.util.Map) method. Plugins which are not allowed will not be loaded by the PluginsManager.
    
    See Also:
    
    PluginsManager.setAllowedPluginTypes(java.util.Map), Constant Field Values
  - KEY_PLUGIN_FACTORY
```
static final java.lang.String KEY_PLUGIN_FACTORY
```
    "MDIPluginFactory": The Plugin factory. it can be used to customize a Plugin initialization.
    
    See Also:
    
    Constant Field Values
  - KEY_PLUGIN_CLASS
```
static final java.lang.String KEY_PLUGIN_CLASS
```
    "MDIPluginClass":The Plugin ClassPath manifest key. This key must have one of the following formats:
    - <ClassPath declaration> (for example "org.package.Class")
    - (<appliID>:<ClassPath declaration>)(<appliID>:<ClassPath declaration>)*
    In the second case, the Plugin ClassPath will be chosen depending on the PluginsManager.setApplicationID(java.lang.String) value.
    Examples
```
 MDIPluginClass: org.mypackage.MyClass
 
```
    In this case the parser will return org.mypackage.MyClass in all cases.
```
 MDIPluginClass: appli:org.mypackage.MyClass
 
```
    In this case the parser will return "org.mypackage.MyClass" if the PluginManager is initialized with "appli" or null, and null in all other cases.
```
 MDIPluginClass: appli:org.mypackage.MyClass;appli2:org.mypackage.MyClass2
 
```
    In this case the parser will return "org.mypackage.MyClass" if the parser is initialized with "appli" or null, "org.mypackage.MyClass2" if the parser is initialized with "appli2", and null in all other cases.
    See Also:
    
    Constant Field Values
  - KEY_PLUGIN_DEPENDENCIES
```
static final java.lang.String KEY_PLUGIN_DEPENDENCIES
```
    "MDIPluginDependencies": The manifest key to set the list of other Plugins on which this Plugin is dependant on. If one of the Plugins on this list is not loaded, this Plugin will not be loaded too. Note that contrary to the PluginElementTypes.PROPERTY_DEPEND property, the manage won't even try to load the Plugin if a Plugin on which the associated Plugin depends on is not present. Note that:
    - The list of Plugins is separated by ";" characters
    - Each Plugin is characterized by the ClassPath of its loaded Class (see KEY_PLUGIN_CLASS)
    Examples
    
    Simple example
    Lets define one Plugin with the following manifest declaration:
```
 MDIPluginClass: org.package1.plugin1
 
```
    And another one with the following manifest declarations:
```
 MDIPluginClass: org.package2.plugin2
 MDIPluginDependencies: org.package1.plugin1
 
```
    The second Plugin will only be loaded if the first one is found and loaded.
    Example with two dependencies
    Lets define two Plugins with the following manifest declarations:
```
 MDIPluginClass: org.package1.plugin1
 
```
    and:
```
 MDIPluginClass: org.package2.plugin2
 
```
    And a last one with the following manifest declarations:
```
 MDIPluginClass: org.package3.plugin3
 MDIPluginDependencies: org.package1.plugin1;org.package2.plugin2
 
```
    Example with a Plugin type
    Lets define one Plugin with the following manifest declaration:
```
 MDIPluginClass: appli1:org.package1.plugin1;appli2:org.package1.plugin2
 
```
    And another one with the following manifest declarations:
```
 MDIPluginClass: org.package3.plugin3
 MDIPluginDependencies: org.package1.plugin1
 
```
    The second Plugin will only be loaded if the first one is found and loaded, wheach means that it won't be loaded if the application ID is different from "appli1".
    See Also:
    
    Constant Field Values
  - KEY_PLUGIN_CONFIG
```
static final java.lang.String KEY_PLUGIN_CONFIG
```
    "MDIPluginConfig": The manifest key for a list of configuration names use by this Plugin. It must be a list of names separated by ";" characters. For example:
```
 MDIPluginClass: org.package3.plugin3
 MDIPluginConfig: myConf1;myConf2
 
```
    See Also:
    
    Constant Field Values

Interface PluginManifestKeys

Field Summary

Field Detail

KEY_PLUGIN_TYPE

KEY_PLUGIN_FACTORY

KEY_PLUGIN_CLASS

Examples

KEY_PLUGIN_DEPENDENCIES

Examples

Simple example

Example with two dependencies

Example with a Plugin type

KEY_PLUGIN_CONFIG