RomCheater.PluginFramework/Core/PluginLoader.cs

#region Logging Defines
// include this any class or method that required logging, and comment-out what is not needed

#region Enabled logging levels
#define LOGGING_ENABLE_INFO
#define LOGGING_ENABLE_WARN
#define LOGGING_ENABLE_DEBUG
#define LOGGING_ENABLE_VERBOSEDEBUG
#define LOGGING_ENABLE_ERROR
#define LOGGING_ENABLE_VERBOSEERROR
#define LOGGING_ENABLE_PROFILER
#endregion
#endregion
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using RomCheater.PluginFramework.Interfaces;
using RomCheater.Logging;
using System.IO;
using System.Reflection;

namespace RomCheater.PluginFramework.Core
{
    public class PluginLoader : IPluginLoader
    {
        public PluginLoader()
        {
            LoadedConfigPlugins = new List<IConfigPlugin>();
            LoadedInputPlugins = new List<IInputPlugin>();
            LoadedWindowPlugins = new List<IWindowPlugin>();
            LoadedUserControlPlugins = new List<IUserControlPlugin>();
        }
        #region IPluginLoader Members
        public void LoadPlugins() { LoadPlugins(false); }
        public void LoadPlugins(bool silent)
        {
            try
            {
                if (!silent)
                    logger.Info.WriteLine("Loading Plugins...");

                string PluginPath = string.Format(@"{0}\Plugins", typeof(PluginLoader).Assembly.Location.Replace(@"\RomCheater.PluginFramework.dll", ""));
                if (!silent)
                    logger.Debug.WriteLine("Plugins Path: {0}", PluginPath);
                List<string> dlls = new List<string>(Directory.GetFiles(PluginPath, "*.dll"));
                if (!silent)
                    logger.Debug.WriteLine("  Found: {0} plugin dlls", dlls.Count);
                foreach (string dll in dlls)
                {
                    FileInfo fi = new FileInfo(dll);
                    if (!silent)
                        logger.Debug.WriteLine("    plugin[{0}]: {1}", dlls.IndexOf(dll), fi.Name);
                    GetConfigPluginsFromDll(fi);
                    GetInputPluginsFromDll(fi);
                    GetWindowPluginsFromDll(fi);
                    GetUserControlPluginsFromDll(fi);
                }

                if (!silent)
                    logger.Info.WriteLine("  Loaded {0} config plugins", LoadedConfigPlugins.Count);
                if (!silent)
                    logger.Info.WriteLine("  Loaded {0} input plugins", LoadedInputPlugins.Count);
                if (!silent)
                    logger.Info.WriteLine("  Loaded {0} window plugins", LoadedWindowPlugins.Count);
                if (!silent)
                    logger.Info.WriteLine("  Loaded {0} usercontrol plugins", LoadedUserControlPlugins.Count);
                if (!silent)
                    logger.Info.WriteLine("Plugins Loaded.");
            }
            catch (ReflectionTypeLoadException ex)
            {
                StringBuilder builder = new StringBuilder();
                if (ex.LoaderExceptions.Count() > 0)
                {
                    foreach (Exception c in ex.LoaderExceptions)
                    {
                        builder.AppendLine(c.ToString());
                    }
                }
                if (!silent)
                    logger.Error.WriteLine("Failed to load one or more plugins{0}Possible Reason:{0}{1}", System.Environment.NewLine, builder.ToString());
            }
            catch (Exception ex)
            {
                if (!silent)
                    logger.Error.WriteLine("Failed to load one or more plugins{0}Possible Reason:{0}{1}", System.Environment.NewLine, ex.ToString());
            }
        }
        public List<IConfigPlugin> LoadedConfigPlugins { get; private set; }
        public List<IInputPlugin> LoadedInputPlugins { get; private set; }
        public List<IWindowPlugin> LoadedWindowPlugins { get; private set; }
        public List<IUserControlPlugin> LoadedUserControlPlugins { get; private set; }

        public IConfigPlugin GetConfigPlugin(string t)
        {
            foreach (IConfigPlugin c in LoadedConfigPlugins) { if (c.ToString().ToLower() == t.ToLower()) { return c; } }
            return GetGenericConfigPlugin();
        }
        private IConfigPlugin GetGenericConfigPlugin()
        {
            foreach (IConfigPlugin c in LoadedConfigPlugins) { if (c.ID.ToString().ToLower() == "478e225b-c3e8-9280-57ca-384b884fc4cc".ToLower()) { return c; } }
            return null;
        }
        public IInputPlugin GetInputPlugin(string t)
        {
            foreach (IInputPlugin c in LoadedInputPlugins) { if (c.ToString().ToLower() == t.ToLower()) { return c; } }
            return GetGenericInputPlugin();
        }
        private IInputPlugin GetGenericInputPlugin()
        {
            foreach (IInputPlugin c in LoadedInputPlugins) { }
            return null;
        }
        public IWindowPlugin GetWindowPlugin(string t)
        {
            foreach (IWindowPlugin c in LoadedWindowPlugins) { if (c.ToString().ToLower() == t.ToLower()) { return c; } }
            return GetGenericWindowPlugin();
        }
        private IWindowPlugin GetGenericWindowPlugin()
        {
            foreach (IWindowPlugin c in LoadedWindowPlugins) { }
            return null;
        }
        private IUserControlPlugin GetUserControlPlugin()
        {
            foreach (IUserControlPlugin c in LoadedUserControlPlugins) { }
            return null;
        }
        #endregion

        private void GetConfigPluginsFromDll(FileInfo dll)
        {
            logger.Debug.WriteLine("  Getting Config plugins contained in {0}", dll.Name);
            Assembly asm = Assembly.LoadFile(dll.FullName);
            List<Type> types = new List<Type>(asm.GetTypes());
            foreach (Type type in types)
            {
                if (type.BaseType == typeof(ConfigPlugin))
                {
                    ConstructorInfo ci = null;
                    ci = type.GetConstructor(new Type[] { });
                    if (ci == null)
                    {
                        throw new NullReferenceException(string.Format("Unable to bind to constructor for type: {0}", type.Name));
                    }
                    else
                    {
                        object o = ci.Invoke(new object[] { });
                        IConfigPlugin c = (IConfigPlugin)o;
                        if (c == null)
                        {
                            throw new NullReferenceException(string.Format("Failed to cast type {0} to IConfigPlugin", type.Name));
                        }
                        else
                        {
                            logger.Debug.WriteLine("    Loaded Config Plugin [name={0}] from {1}", c.Name, dll.Name);
                            LoadedConfigPlugins.Add(c);
                        }
                    }
                }
            }
        }
        private void GetInputPluginsFromDll(FileInfo dll)
        {
            logger.Debug.WriteLine("  Getting Input plugins contained in {0}", dll.Name);
            Assembly asm = Assembly.LoadFile(dll.FullName);
            List<Type> types = new List<Type>(asm.GetTypes());
            foreach (Type type in types)
            {
                if (type.BaseType == typeof(InputPlugin))
                {
                    ConstructorInfo ci = null;
                    ci = type.GetConstructor(new Type[] { });
                    if (ci == null)
                    {
                        throw new NullReferenceException(string.Format("Unable to bind to constructor for type: {0}", type.Name));
                    }
                    else
                    {
                        object o = ci.Invoke(new object[] { });
                        IInputPlugin c = (IInputPlugin)o;
                        if (c == null)
                        {
                            throw new NullReferenceException(string.Format("Failed to cast type {0} to IConfigPlugin", type.Name));
                        }
                        else
                        {
                            logger.Debug.WriteLine("    Loaded Input Plugin [name={0}] from {1}", c.Name, dll.Name);
                            LoadedInputPlugins.Add(c);
                        }
                    }
                }
            }
        }
        private void GetWindowPluginsFromDll(FileInfo dll)
        {
            logger.Debug.WriteLine("  Getting Window plugins contained in {0}", dll.Name);
            Assembly asm = Assembly.LoadFile(dll.FullName);
            List<Type> types = new List<Type>(asm.GetTypes());
            foreach (Type type in types)
            {
                if (type.BaseType == typeof(WindowPlugin))
                {
                    ConstructorInfo ci = null;
                    ci = type.GetConstructor(new Type[] { });
                    if (ci == null)
                    {
                        throw new NullReferenceException(string.Format("Unable to bind to constructor for type: {0}", type.Name));
                    }
                    else
                    {
                        object o = ci.Invoke(new object[] { });
                        IWindowPlugin c = (IWindowPlugin)o;
                        if (c == null)
                        {
                            throw new NullReferenceException(string.Format("Failed to cast type {0} to IConfigPlugin", type.Name));
                        }
                        else
                        {
                            logger.Debug.WriteLine("    Loaded Window Plugin [name={0}] from {1}", c.Name, dll.Name);
                            LoadedWindowPlugins.Add(c);
                        }
                    }
                }
            }
        }
        private void GetUserControlPluginsFromDll(FileInfo dll)
        {
            logger.Debug.WriteLine("  Getting UserControl plugins contained in {0}", dll.Name);
            Assembly asm = Assembly.LoadFile(dll.FullName);
            List<Type> types = new List<Type>(asm.GetTypes());
            foreach (Type type in types)
            {
                if (type.BaseType == typeof(UserControlPlugin))
                {
                    ConstructorInfo ci = null;
                    ci = type.GetConstructor(new Type[] { });
                    if (ci == null)
                    {
                        throw new NullReferenceException(string.Format("Unable to bind to constructor for type: {0}", type.Name));
                    }
                    else
                    {
                        object o = ci.Invoke(new object[] { });
                        IUserControlPlugin c = (IUserControlPlugin)o;
                        if (c == null)
                        {
                            throw new NullReferenceException(string.Format("Failed to cast type {0} to IConfigPlugin", type.Name));
                        }
                        else
                        {
                            logger.Debug.WriteLine("    Loaded UserControl Plugin [name={0}] from {1}", c.Name, dll.Name);
                            LoadedUserControlPlugins.Add(c);
                        }
                    }
                }
            }
        }
    }
}
1	william	414	#region Logging Defines
2			// include this any class or method that required logging, and comment-out what is not needed
3	william	415
4	william	414	#region Enabled logging levels
5			#define LOGGING_ENABLE_INFO
6			#define LOGGING_ENABLE_WARN
7			#define LOGGING_ENABLE_DEBUG
8			#define LOGGING_ENABLE_VERBOSEDEBUG
9			#define LOGGING_ENABLE_ERROR
10			#define LOGGING_ENABLE_VERBOSEERROR
11			#define LOGGING_ENABLE_PROFILER
12			#endregion
13			#endregion
14			using System;
15	william	83	using System.Collections.Generic;
16			using System.Linq;
17			using System.Text;
18			using RomCheater.PluginFramework.Interfaces;
19			using RomCheater.Logging;
20	william	84	using System.IO;
21	william	85	using System.Reflection;
22	william	83
23			namespace RomCheater.PluginFramework.Core
24			{
25			public class PluginLoader : IPluginLoader
26			{
27			public PluginLoader()
28			{
29			LoadedConfigPlugins = new List<IConfigPlugin>();
30			LoadedInputPlugins = new List<IInputPlugin>();
31			LoadedWindowPlugins = new List<IWindowPlugin>();
32	william	437	LoadedUserControlPlugins = new List<IUserControlPlugin>();
33	william	83	}
34			#region IPluginLoader Members
35	william	366	public void LoadPlugins() { LoadPlugins(false); }
36			public void LoadPlugins(bool silent)
37	william	83	{
38	william	85	try
39			{
40	william	366	if (!silent)
41			logger.Info.WriteLine("Loading Plugins...");
42	william	84
43	william	85	string PluginPath = string.Format(@"{0}\Plugins", typeof(PluginLoader).Assembly.Location.Replace(@"\RomCheater.PluginFramework.dll", ""));
44	william	366	if (!silent)
45			logger.Debug.WriteLine("Plugins Path: {0}", PluginPath);
46	william	85	List<string> dlls = new List<string>(Directory.GetFiles(PluginPath, "*.dll"));
47	william	366	if (!silent)
48			logger.Debug.WriteLine(" Found: {0} plugin dlls", dlls.Count);
49	william	85	foreach (string dll in dlls)
50			{
51			FileInfo fi = new FileInfo(dll);
52	william	366	if (!silent)
53			logger.Debug.WriteLine(" plugin[{0}]: {1}", dlls.IndexOf(dll), fi.Name);
54	william	85	GetConfigPluginsFromDll(fi);
55			GetInputPluginsFromDll(fi);
56			GetWindowPluginsFromDll(fi);
57	william	437	GetUserControlPluginsFromDll(fi);
58	william	85	}
59
60	william	366	if (!silent)
61			logger.Info.WriteLine(" Loaded {0} config plugins", LoadedConfigPlugins.Count);
62			if (!silent)
63			logger.Info.WriteLine(" Loaded {0} input plugins", LoadedInputPlugins.Count);
64			if (!silent)
65			logger.Info.WriteLine(" Loaded {0} window plugins", LoadedWindowPlugins.Count);
66			if (!silent)
67	william	437	logger.Info.WriteLine(" Loaded {0} usercontrol plugins", LoadedUserControlPlugins.Count);
68			if (!silent)
69	william	366	logger.Info.WriteLine("Plugins Loaded.");
70	william	85	}
71	william	86	catch (ReflectionTypeLoadException ex)
72			{
73			StringBuilder builder = new StringBuilder();
74			if (ex.LoaderExceptions.Count() > 0)
75			{
76			foreach (Exception c in ex.LoaderExceptions)
77			{
78			builder.AppendLine(c.ToString());
79			}
80			}
81	william	366	if (!silent)
82			logger.Error.WriteLine("Failed to load one or more plugins{0}Possible Reason:{0}{1}", System.Environment.NewLine, builder.ToString());
83	william	86	}
84	william	85	catch (Exception ex)
85	william	84	{
86	william	366	if (!silent)
87			logger.Error.WriteLine("Failed to load one or more plugins{0}Possible Reason:{0}{1}", System.Environment.NewLine, ex.ToString());
88	william	84	}
89	william	83	}
90			public List<IConfigPlugin> LoadedConfigPlugins { get; private set; }
91			public List<IInputPlugin> LoadedInputPlugins { get; private set; }
92			public List<IWindowPlugin> LoadedWindowPlugins { get; private set; }
93	william	437	public List<IUserControlPlugin> LoadedUserControlPlugins { get; private set; }
94	william	87
95			public IConfigPlugin GetConfigPlugin(string t)
96			{
97			foreach (IConfigPlugin c in LoadedConfigPlugins) { if (c.ToString().ToLower() == t.ToLower()) { return c; } }
98	william	148	return GetGenericConfigPlugin();
99			}
100			private IConfigPlugin GetGenericConfigPlugin()
101			{
102			foreach (IConfigPlugin c in LoadedConfigPlugins) { if (c.ID.ToString().ToLower() == "478e225b-c3e8-9280-57ca-384b884fc4cc".ToLower()) { return c; } }
103	william	87	return null;
104			}
105			public IInputPlugin GetInputPlugin(string t)
106			{
107			foreach (IInputPlugin c in LoadedInputPlugins) { if (c.ToString().ToLower() == t.ToLower()) { return c; } }
108	william	148	return GetGenericInputPlugin();
109			}
110			private IInputPlugin GetGenericInputPlugin()
111			{
112			foreach (IInputPlugin c in LoadedInputPlugins) { }
113	william	87	return null;
114			}
115			public IWindowPlugin GetWindowPlugin(string t)
116			{
117			foreach (IWindowPlugin c in LoadedWindowPlugins) { if (c.ToString().ToLower() == t.ToLower()) { return c; } }
118	william	148	return GetGenericWindowPlugin();
119			}
120			private IWindowPlugin GetGenericWindowPlugin()
121			{
122			foreach (IWindowPlugin c in LoadedWindowPlugins) { }
123	william	87	return null;
124			}
125	william	437	private IUserControlPlugin GetUserControlPlugin()
126			{
127			foreach (IUserControlPlugin c in LoadedUserControlPlugins) { }
128			return null;
129			}
130	william	83	#endregion
131	william	85
132			private void GetConfigPluginsFromDll(FileInfo dll)
133			{
134			logger.Debug.WriteLine(" Getting Config plugins contained in {0}", dll.Name);
135			Assembly asm = Assembly.LoadFile(dll.FullName);
136			List<Type> types = new List<Type>(asm.GetTypes());
137			foreach (Type type in types)
138			{
139			if (type.BaseType == typeof(ConfigPlugin))
140			{
141			ConstructorInfo ci = null;
142	william	366	ci = type.GetConstructor(new Type[] { });
143	william	85	if (ci == null)
144			{
145			throw new NullReferenceException(string.Format("Unable to bind to constructor for type: {0}", type.Name));
146			}
147			else
148			{
149			object o = ci.Invoke(new object[] { });
150			IConfigPlugin c = (IConfigPlugin)o;
151			if (c == null)
152			{
153			throw new NullReferenceException(string.Format("Failed to cast type {0} to IConfigPlugin", type.Name));
154			}
155			else
156			{
157			logger.Debug.WriteLine(" Loaded Config Plugin [name={0}] from {1}", c.Name, dll.Name);
158			LoadedConfigPlugins.Add(c);
159			}
160			}
161			}
162			}
163			}
164			private void GetInputPluginsFromDll(FileInfo dll)
165			{
166			logger.Debug.WriteLine(" Getting Input plugins contained in {0}", dll.Name);
167			Assembly asm = Assembly.LoadFile(dll.FullName);
168			List<Type> types = new List<Type>(asm.GetTypes());
169			foreach (Type type in types)
170			{
171			if (type.BaseType == typeof(InputPlugin))
172			{
173			ConstructorInfo ci = null;
174			ci = type.GetConstructor(new Type[] { });
175			if (ci == null)
176			{
177			throw new NullReferenceException(string.Format("Unable to bind to constructor for type: {0}", type.Name));
178			}
179			else
180			{
181			object o = ci.Invoke(new object[] { });
182			IInputPlugin c = (IInputPlugin)o;
183			if (c == null)
184			{
185			throw new NullReferenceException(string.Format("Failed to cast type {0} to IConfigPlugin", type.Name));
186			}
187			else
188			{
189			logger.Debug.WriteLine(" Loaded Input Plugin [name={0}] from {1}", c.Name, dll.Name);
190			LoadedInputPlugins.Add(c);
191			}
192			}
193			}
194			}
195			}
196			private void GetWindowPluginsFromDll(FileInfo dll)
197			{
198			logger.Debug.WriteLine(" Getting Window plugins contained in {0}", dll.Name);
199			Assembly asm = Assembly.LoadFile(dll.FullName);
200			List<Type> types = new List<Type>(asm.GetTypes());
201			foreach (Type type in types)
202			{
203			if (type.BaseType == typeof(WindowPlugin))
204			{
205			ConstructorInfo ci = null;
206			ci = type.GetConstructor(new Type[] { });
207			if (ci == null)
208			{
209			throw new NullReferenceException(string.Format("Unable to bind to constructor for type: {0}", type.Name));
210			}
211			else
212			{
213			object o = ci.Invoke(new object[] { });
214			IWindowPlugin c = (IWindowPlugin)o;
215			if (c == null)
216			{
217			throw new NullReferenceException(string.Format("Failed to cast type {0} to IConfigPlugin", type.Name));
218			}
219			else
220			{
221			logger.Debug.WriteLine(" Loaded Window Plugin [name={0}] from {1}", c.Name, dll.Name);
222			LoadedWindowPlugins.Add(c);
223			}
224			}
225			}
226			}
227			}
228	william	437	private void GetUserControlPluginsFromDll(FileInfo dll)
229			{
230			logger.Debug.WriteLine(" Getting UserControl plugins contained in {0}", dll.Name);
231			Assembly asm = Assembly.LoadFile(dll.FullName);
232			List<Type> types = new List<Type>(asm.GetTypes());
233			foreach (Type type in types)
234			{
235			if (type.BaseType == typeof(UserControlPlugin))
236			{
237			ConstructorInfo ci = null;
238			ci = type.GetConstructor(new Type[] { });
239			if (ci == null)
240			{
241			throw new NullReferenceException(string.Format("Unable to bind to constructor for type: {0}", type.Name));
242			}
243			else
244			{
245			object o = ci.Invoke(new object[] { });
246			IUserControlPlugin c = (IUserControlPlugin)o;
247			if (c == null)
248			{
249			throw new NullReferenceException(string.Format("Failed to cast type {0} to IConfigPlugin", type.Name));
250			}
251			else
252			{
253			logger.Debug.WriteLine(" Loaded UserControl Plugin [name={0}] from {1}", c.Name, dll.Name);
254			LoadedUserControlPlugins.Add(c);
255			}
256			}
257			}
258			}
259			}
260	william	83	}
261			}