public static void LoadPlugins(string pluginFile)
{
if (!File.Exists(pluginFile))
{
MessageBox.Show("File not found " + pluginFile);
return;
}
try
{
Assembly pluginAssembly = Assembly.LoadFrom(pluginFile);
if (pluginAssembly != null)
{
Type[] exportedTypes = pluginAssembly.GetExportedTypes();
foreach (Type type in exportedTypes)
{
if (type.IsAbstract)
{
continue;
}
if (type.GetInterface("MediaPortal.GUI.Library.ISetupForm") != null)
{
try
{
//
// Create instance of the current type
//
object pluginObject = Activator.CreateInstance(type);
ISetupForm pluginForm = pluginObject as ISetupForm;
if (pluginForm != null)
{
if (pluginForm.HasSetup())
{
pluginForm.ShowPlugin();
}
}
}
catch (Exception setupFormException)
{
MessageBox.Show(string.Format("Exception in plugin SetupForm loading : {0} ", setupFormException.Message));
}
}
}
}
}
catch (Exception unknownException)
{
MessageBox.Show(string.Format("Exception in plugin loading :{0}", unknownException.Message));
}
}
public PluginInfo(ISetupForm setup)
{
_setup = setup;
LoadData();
}
private void LoadPlugins()
{
tvMenu.Nodes.Clear();
string directory = Config.GetSubFolder(Config.Dir.Plugins, "windows");
if (!Directory.Exists(directory))
{
return;
}
using (Profile.Settings xmlreader = new Profile.MPSettings())
{
TreeNode tnMyPlugIns = null;
bool useMyPlugins = xmlreader.GetValueAsBool("home", "usemyplugins", true);
if (useMyPlugins)
{
tnMyPlugIns = new TreeNode("my Plugins");
tnMyPlugIns.Tag = new PluginInfo("my Plugins");
tvMenu.Nodes.Add(tnMyPlugIns);
}
string[] files = Directory.GetFiles(directory, "*.dll");
foreach (string pluginFile in files)
{
try
{
Assembly pluginAssembly = Assembly.LoadFrom(pluginFile);
if (pluginAssembly != null)
{
Type[] exportedTypes = pluginAssembly.GetExportedTypes();
foreach (Type type in exportedTypes)
{
// an abstract class cannot be instanciated
if (type.IsAbstract)
{
continue;
}
// Try to locate the interface we're interested in
if (type.GetInterface("MediaPortal.GUI.Library.ISetupForm") != null)
{
try
{
// Create instance of the current type
object pluginObject = Activator.CreateInstance(type);
ISetupForm pluginForm = pluginObject as ISetupForm;
if (pluginForm != null)
{
if (pluginForm.PluginName().Equals("Home"))
{
continue;
}
if (pluginForm.PluginName().Equals("my Plugins"))
{
if (tnMyPlugIns != null)
{
tnMyPlugIns.Tag = new PluginInfo(pluginForm);
tvMenu.Nodes.Add(tnMyPlugIns);
}
continue;
}
string enabled = xmlreader.GetValue("plugins", pluginForm.PluginName());
if (enabled.CompareTo("yes") != 0)
{
continue;
}
string showInHome = xmlreader.GetValue("home", pluginForm.PluginName());
TreeNode node;
if ((useMyPlugins) && (showInHome.CompareTo("no") == 0))
{
node = tnMyPlugIns.Nodes.Add(pluginForm.PluginName());
}
else
{
node = tvMenu.Nodes.Add(pluginForm.PluginName());
}
if (node != null)
{
node.Tag = new PluginInfo(pluginForm);
}
}
}
catch (Exception setupFormException)
{
Log.Info("Exception in plugin SetupForm loading :{0}", setupFormException.Message);
Log.Info("Current class is :{0}", type.FullName);
Log.Info(setupFormException.StackTrace);
}
}
}
}
}
catch (Exception unknownException)
{
Log.Info("Exception in plugin loading :{0}", unknownException.Message);
Log.Info(unknownException.StackTrace);
}
}
}
ValidateIndex();
tvMenu.TreeViewNodeSorter = this;
tvMenu.Sort();
}
public static void LoadWindowPlugin(string strFile)
{
if (!IsPlugInEnabled(strFile))
{
return;
}
Log.Info(" Load plugins from : {0}", strFile);
try
{
Assembly assem = Assembly.LoadFrom(strFile);
if (assem != null)
{
Log.Info(" File Version : {0}", FileVersionInfo.GetVersionInfo(strFile).ProductVersion);
Type[] types = assem.GetExportedTypes();
if (types.Any(t => t.IsClass && !t.IsAbstract && t.IsSubclassOf(typeof(GUIWindow))) && !CompatibilityManager.IsPluginCompatible(assem))
{
Log.Error(
"PluginManager: {0} is tagged as incompatible with the current MediaPortal version and won't be loaded!",
assem.FullName);
_incompatibilities.Add(assem);
}
else
{
//MarkPluginAsCompatible(assem);
Type[] foundInterfaces = null;
foreach (Type t in types)
{
try
{
if (t.IsClass)
{
if (t.IsAbstract)
{
continue;
}
Object newObj = null;
if (t.IsSubclassOf(typeof(GUIWindow)))
{
try
{
if (!CompatibilityManager.IsPluginCompatible(t))
{
Log.Error(
"PluginManager: {0} is tagged as incompatible with the current MediaPortal version and won't be loaded!",
t.FullName);
_incompatibilities.Add(t);
continue;
}
newObj = (object)Activator.CreateInstance(t);
GUIWindow win = (GUIWindow)newObj;
if (win.GetID >= 0 && IsWindowPlugInEnabled(win.GetType().ToString()))
{
try
{
win.Init();
_guiPlugins.Add(win);
}
catch (Exception ex)
{
Log.Error("Error initializing window:{0} {1} {2} {3}", win.ToString(), ex.Message, ex.Source,
ex.StackTrace);
}
GUIWindowManager.Add(ref win);
}
//else Log.Info(" plugin:{0} not enabled",win.GetType().ToString());
}
catch (Exception guiWindowsException)
{
Log.Error("Exception while loading GUIWindows instances: {0}", t.FullName);
Log.Error(guiWindowsException.Message);
Log.Error(guiWindowsException.StackTrace);
}
}
// If we get to this point, the plugin has loaded successfully
// Mark it as compatible.
//MarkPluginAsCompatible(t);
TypeFilter myFilter2 = new TypeFilter(MyInterfaceFilter);
try
{
foundInterfaces = t.FindInterfaces(myFilter2, "MediaPortal.GUI.Library.ISetupForm");
if (foundInterfaces.Length > 0)
{
if (newObj == null)
{
newObj = (object)Activator.CreateInstance(t);
}
ISetupForm setup = (ISetupForm)newObj;
if (!PluginEntryExists(setup.PluginName()))
{
Log.Info("PluginManager: {0} {1} not found in Mediaportal.xml so adding it now",
setup.PluginName(), t.Assembly.ManifestModule.Name);
AddPluginEntry(setup.PluginName(), t.Assembly.ManifestModule.Name);
}
if (IsPluginNameEnabled(setup.PluginName()))
{
_setupForms.Add(setup);
}
}
}
catch (Exception iSetupFormException)
{
Log.Error("Exception while loading ISetupForm instances: {0}", t.FullName);
Log.Error(iSetupFormException.Message);
Log.Error(iSetupFormException.StackTrace);
}
try
{
foundInterfaces = t.FindInterfaces(myFilter2, "MediaPortal.GUI.Library.IWakeable");
if (foundInterfaces.Length > 0)
{
if (newObj == null)
{
newObj = (object)Activator.CreateInstance(t);
}
IWakeable setup = (IWakeable)newObj;
if (PluginEntryExists(setup.PluginName()) && IsPluginNameEnabled(setup.PluginName()))
{
_wakeables.Add(setup);
}
}
}
catch (Exception iWakeableException)
{
Log.Error("Exception while loading IWakeable instances: {0}", t.FullName);
Log.Error(iWakeableException.Message);
Log.Error(iWakeableException.StackTrace);
}
}
}
catch (NullReferenceException) {}
}
}
}
}
catch (BadImageFormatException) { }
catch (Exception ex)
{
Log.Info(
"PluginManager: Plugin file {0} is broken or incompatible with the current MediaPortal version and won't be loaded!",
strFile.Substring(strFile.LastIndexOf(@"\") + 1));
Log.Info("PluginManager: Exception: {0}", ex);
}
}
private static void LoadPlugin(string strFile)
{
if (!IsPlugInEnabled(strFile))
{
return;
}
Type[] foundInterfaces = null;
Log.Info(" Load plugins from : {0}", strFile);
try
{
Assembly assem = Assembly.LoadFrom(strFile);
if (assem != null)
{
Log.Info(" File Version : {0}", FileVersionInfo.GetVersionInfo(strFile).ProductVersion);
Type[] types = assem.GetExportedTypes();
TypeFilter myFilter2 = new TypeFilter(MyInterfaceFilter);
if (types.Any(t => t.IsClass && !t.IsAbstract && typeof(IPlugin).IsAssignableFrom(t)) &&
!CompatibilityManager.IsPluginCompatible(assem))
{
Log.Error(
"PluginManager: {0} is tagged as incompatible with the current MediaPortal version and won't be loaded!", assem.FullName);
_incompatibilities.Add(assem);
}
else
{
foreach (Type t in types)
{
try
{
if (t.IsClass)
{
if (t.IsAbstract)
{
continue;
}
Object newObj = null;
IPlugin plugin = null;
try
{
foundInterfaces = t.FindInterfaces(myFilter2, "MediaPortal.GUI.Library.IPlugin");
if (foundInterfaces.Length > 0)
{
if (!CompatibilityManager.IsPluginCompatible(t))
{
Log.Error(
"PluginManager: {0} is tagged as incompatible with the current MediaPortal version and won't be loaded!",
t.FullName);
_incompatibilities.Add(t);
continue;
}
newObj = (object)Activator.CreateInstance(t);
plugin = (IPlugin)newObj;
}
}
catch (TargetInvocationException ex)
{
Log.Error(ex);
Log.Error(
"PluginManager: {0} is incompatible with the current MediaPortal version and won't be loaded!",
t.FullName);
continue;
}
catch (Exception iPluginException)
{
Log.Error("Exception while loading IPlugin instances: {0}", t.FullName);
Log.Error(iPluginException.ToString());
Log.Error(iPluginException.Message);
Log.Error(iPluginException.StackTrace);
}
if (plugin == null)
{
continue;
}
// If we get to this point, the plugin has loaded successfully
// Mark it as compatible.
//MarkPluginAsCompatible(t);
try
{
foundInterfaces = t.FindInterfaces(myFilter2, "MediaPortal.GUI.Library.ISetupForm");
if (foundInterfaces.Length > 0)
{
if (newObj == null)
{
newObj = (object)Activator.CreateInstance(t);
}
ISetupForm setup = (ISetupForm)newObj;
// don't activate plugins that have NO entry at all in
// MediaPortal.xml
if (!PluginEntryExists(setup.PluginName()))
{
Log.Info("PluginManager: {0} {1} not found in Mediaportal.xml so adding it now",
setup.PluginName(), t.Assembly.ManifestModule.Name);
AddPluginEntry(setup.PluginName(), t.Assembly.ManifestModule.Name);
MPSettings.Instance.SetValueAsBool("home", setup.PluginName(), false);
MPSettings.Instance.SetValueAsBool("myplugins", setup.PluginName(), true);
MPSettings.Instance.SetValueAsBool("pluginswindows", t.ToString(), true);
}
if (IsPluginNameEnabled(setup.PluginName()))
{
_setupForms.Add(setup);
_nonGuiPlugins.Add(plugin);
}
}
else
{
//IPlugin without ISetupForm, adding anyway
if (!PluginEntryExists(t.Name))
{
AddPluginEntry(t.Name, t.Assembly.ManifestModule.Name);
}
_nonGuiPlugins.Add(plugin);
}
}
catch (Exception iSetupFormException)
{
Log.Error("Exception while loading ISetupForm instances: {0}", t.FullName);
Log.Error(iSetupFormException.Message);
Log.Error(iSetupFormException.StackTrace);
}
try
{
foundInterfaces = t.FindInterfaces(myFilter2, "MediaPortal.GUI.Library.IWakeable");
if (foundInterfaces.Length > 0)
{
if (newObj == null)
{
newObj = (object)Activator.CreateInstance(t);
}
IWakeable setup = (IWakeable)newObj;
if (PluginEntryExists(setup.PluginName()) && IsPluginNameEnabled(setup.PluginName()))
{
_wakeables.Add(setup);
}
}
}
catch (Exception iWakeableException)
{
Log.Error("Exception while loading IWakeable instances: {0}", t.FullName);
Log.Error(iWakeableException.Message);
Log.Error(iWakeableException.StackTrace);
}
}
}
catch (NullReferenceException) {}
}
}
}
}
catch (Exception ex)
{
Log.Info(
"PluginManager: Plugin file {0} is broken or incompatible with the current MediaPortal version and won't be loaded!",
strFile.Substring(strFile.LastIndexOf(@"\") + 1));
Log.Info("PluginManager: Exception: {0}", ex);
}
}
private void LoadPlugins()
{
foreach (string pluginFile in availablePlugins)
{
Assembly pluginAssembly = null;
try
{
Log.Debug("PluginsNew: loadPlugins {0}", pluginFile);
pluginAssembly = Assembly.LoadFrom(pluginFile);
}
catch (BadImageFormatException)
{
Log.Warn("PluginsNew: {0} has a bad image format", pluginFile);
}
if (pluginAssembly != null)
{
try
{
Type[] exportedTypes = pluginAssembly.GetExportedTypes();
List <object> NonSetupWindows = new List <object>();
foreach (Type type in exportedTypes)
{
bool isPlugin = (type.GetInterface("MediaPortal.GUI.Library.ISetupForm") != null);
bool isGuiWindow = ((type.IsClass) && (type.IsSubclassOf(typeof(GUIWindow))));
// an abstract class cannot be instanciated
if (type.IsAbstract)
{
continue;
}
bool isIncompatible = !CompatibilityManager.IsPluginCompatible(type);
if (isIncompatible)
{
Log.Warn(
"Plugin Manager: Plugin {0} is incompatible with the current MediaPortal version! (File: {1})",
type.FullName, pluginFile.Substring(pluginFile.LastIndexOf(@"\") + 1));
}
// Try to locate the interface we're interested in
if (isPlugin || isGuiWindow)
{
// Create instance of the current type
object pluginObject;
try
{
pluginObject = Activator.CreateInstance(type);
}
catch (TargetInvocationException)
{
MessageBox.Show(
string.Format(
"An error occured while loading the plugin {0}.\n\nIt's incompatible with the current MediaPortal version and won't be loaded.",
type.FullName
), "Plugin Manager", MessageBoxButtons.OK, MessageBoxIcon.Error);
Log.Warn(
"Plugin Manager: Plugin {0} is incompatible with the current MediaPortal version! (File: {1})",
type.FullName, pluginFile.Substring(pluginFile.LastIndexOf(@"\") + 1));
continue;
}
if (isPlugin)
{
ISetupForm pluginForm = pluginObject as ISetupForm;
IExternalPlayer extPlayer = pluginObject as IExternalPlayer;
IShowPlugin showPlugin = pluginObject as IShowPlugin;
if (pluginForm != null)
{
ItemTag tag = new ItemTag();
tag.SetupForm = pluginForm;
tag.DllName = pluginFile.Substring(pluginFile.LastIndexOf(@"\") + 1);
tag.WindowId = pluginForm.GetWindowId();
if (isGuiWindow)
{
GUIWindow win = (GUIWindow)pluginObject;
if (tag.WindowId == win.GetID)
{
tag.Type = win.GetType().ToString();
tag.IsProcess = false;
tag.IsWindow = true;
}
}
else if (extPlayer != null)
{
tag.IsExternalPlayer = true;
}
else
{
tag.IsProcess = true;
}
if (showPlugin != null)
{
tag.ShowDefaultHome = showPlugin.ShowDefaultHome();
}
tag.IsIncompatible = isIncompatible;
LoadPluginImages(type, tag);
loadedPlugins.Add(tag);
}
}
else
{
NonSetupWindows.Add(pluginObject);
}
}
}
// Filter plugins from e.g. dialogs or other windows.
foreach (GUIWindow win in NonSetupWindows)
{
foreach (ItemTag tag in loadedPlugins)
{
if (tag.WindowId == win.GetID)
{
tag.Type = win.GetType().ToString();
tag.IsProcess = false;
tag.IsWindow = true;
Log.Debug(
"PluginsNew: {0}, window plugin, does not implement \"ISetupForm\" and \"GUIWindow\" in the same class",
tag.Type);
break;
}
}
}
}
catch (Exception ex)
{
MessageBox.Show(
string.Format(
"An error occured while loading the plugin file {0}.\n\nIt's broken or incompatible with the current MediaPortal version and won't be loaded.",
pluginFile.Substring(pluginFile.LastIndexOf(@"\") + 1)), "Plugin Manager", MessageBoxButtons.OK,
MessageBoxIcon.Error);
Log.Warn(
"PluginManager: Plugin file {0} is broken or incompatible with the current MediaPortal version and won't be loaded!",
pluginFile.Substring(pluginFile.LastIndexOf(@"\") + 1));
Log.Error("PluginManager: Exception: {0}", ex);
}
}
}
}
/// <summary>
/// Load available window plugins in a list
///
/// Copied and modified from MediaPortal config: PluginsNew.cs
/// </summary>
private void LoadPlugins()
{
try
{
foreach (string pluginFile in availablePlugins)
{
Assembly pluginAssembly = null;
try
{
pluginAssembly = Assembly.LoadFrom(pluginFile);
}
catch (BadImageFormatException)
{
Log.Warn("[WifiRemote Setup] {0} has a bad image format", pluginFile);
}
if (pluginAssembly != null)
{
try
{
Type[] exportedTypes = pluginAssembly.GetExportedTypes();
foreach (Type type in exportedTypes)
{
bool isPlugin = (type.GetInterface("MediaPortal.GUI.Library.ISetupForm") != null);
bool isGuiWindow = ((type.IsClass) && (type.IsSubclassOf(typeof(GUIWindow))));
// an abstract class cannot be instanciated
if (type.IsAbstract)
{
continue;
}
// Try to locate the interface we're interested in
if (isPlugin || isGuiWindow)
{
// Create instance of the current type
object pluginObject;
try
{
pluginObject = Activator.CreateInstance(type);
}
catch (TargetInvocationException)
{
// Plugin is incompatible with current MediaPortal
Log.Error("[WifiRemote Setup] Plugin " + pluginFile + " incompatible");
continue;
}
if (isPlugin)
{
ISetupForm pluginForm = pluginObject as ISetupForm;
if (pluginForm != null)
{
ItemTag tag = new ItemTag();
tag.SetupForm = pluginForm;
tag.DllName = pluginFile.Substring(pluginFile.LastIndexOf(@"\") + 1);
tag.WindowId = pluginForm.GetWindowId();
if (isGuiWindow)
{
GUIWindow win = (GUIWindow)pluginObject;
if (tag.WindowId == win.GetID)
{
tag.Type = win.GetType().ToString();
}
}
LoadPluginImages(type, tag);
plugins.Add(tag);
}
}
}
}
}
catch (Exception ex)
{
// plugin broken or incompatible
Log.Error("[WifiRemote Setup] Exception: {0}", ex);
}
}
}
}
catch (Exception excep)
{
Log.Error("[WifiRemote Setup] Error loading plugins: " + excep.Message);
}
}
public PluginInfo(ISetupForm setup)
{
_setup = setup;
LoadData();
}
public static void LoadPluginConfiguration(string pluginFile)
{
if (!File.Exists(pluginFile))
{
string message = string.Format("Plugin not found: {0}", pluginFile);
ShowMessage(message, MsgBoxIcon.INFO);
return;
}
// Flag if plugin has a configuration form
bool hasConfigForm = false;
string[] assemblies = null;
try {
// Get Plugin Assembly and check if its valid
Assembly pluginAssembly = Assembly.LoadFrom(pluginFile);
if (pluginAssembly == null)
{
string message = string.Format("Invalid Plugin: {0}", pluginFile);
ShowMessage(message, MsgBoxIcon.INFO);
}
Type[] exportedTypes = pluginAssembly.GetExportedTypes();
foreach (Type type in exportedTypes)
{
if (type.IsAbstract)
{
continue;
}
if (type.GetInterface("MediaPortal.GUI.Library.ISetupForm") != null)
{
// Load any optional assemblies to support the plugin
if (assemblies != null)
{
foreach (string assembly in assemblies)
{
if (File.Exists(assembly))
{
try {
Assembly.LoadFile(assembly);
}
catch (Exception e) {
string message = string.Format("Exception in plugin SetupForm loading: \n\n{0} ", e.Message);
ShowMessage(message, MsgBoxIcon.CRITICAL);
}
}
}
}
try {
// Create instance of the current type
object pluginObject = Activator.CreateInstance(type);
ISetupForm pluginForm = pluginObject as ISetupForm;
// If the plugin has a Configuration form, show it
if (pluginForm != null)
{
if (pluginForm.HasSetup())
{
hasConfigForm = true;
pluginForm.ShowPlugin();
return;
}
}
}
catch (Exception setupFormException) {
string message = string.Format("Exception in plugin SetupForm loading: \n\n{0} ", setupFormException.Message);
ShowMessage(message, MsgBoxIcon.CRITICAL);
}
}
}
}
catch (Exception unknownException) {
string message = string.Format("Exception in plugin loading: \n\n{0}", unknownException.Message);
ShowMessage(message, MsgBoxIcon.CRITICAL);
}
if (!hasConfigForm)
{
string message = "Plugin does not have a configuration form to show";
ShowMessage(message, MsgBoxIcon.INFO);
}
}
