pepperdash/Essentials
1
0
Fork 0
mirror of https://github.com/PepperDash/Essentials.git synced 2026-01-30 21:04:48 +00:00
Code Issues Packages Projects Releases Wiki Activity

feat: modify plugin loading process

Browse Source
This commit is contained in:
Andrew Welker
2025-07-04 13:33:56 -05:00
parent 58a2a5c008
commit 8b873b7248
5 changed files with 86 additions and 80 deletions
Download Patch File Download Diff File Expand all files Collapse all files

48
src/PepperDash.Essentials.Core/Devices/EssentialsDevice.cs
View File

@@ -121,43 +121,6 @@ namespace PepperDash.Essentials.Core
}
}
/// <summary>
/// Devices the basic needs for a Device Factory
/// </summary>
public abstract class EssentialsDeviceFactory<T> : IDeviceFactory where T:EssentialsDevice
{
#region IDeviceFactory Members
/// <summary>
/// A list of strings that can be used in the type property of a DeviceConfig object to build an instance of this device
/// </summary>
public List<string> TypeNames { get; protected set; }
/// <summary>
/// Loads an item to the DeviceFactory.FactoryMethods dictionary for each entry in the TypeNames list
/// </summary>
public void LoadTypeFactories()
{
foreach (var typeName in TypeNames)
{
//Debug.LogMessage(LogEventLevel.Verbose, "Getting Description Attribute from class: '{0}'", typeof(T).FullName);
var descriptionAttribute = typeof(T).GetCustomAttributes(typeof(DescriptionAttribute), true) as DescriptionAttribute[];
string description = descriptionAttribute[0].Description;
var snippetAttribute = typeof(T).GetCustomAttributes(typeof(ConfigSnippetAttribute), true) as ConfigSnippetAttribute[];
DeviceFactory.AddFactoryForType(typeName.ToLower(), description, typeof(T), BuildDevice);
}
}
/// <summary>
/// The method that will build the device
/// </summary>
/// <param name="dc">The device config</param>
/// <returns>An instance of the device</returns>
public abstract EssentialsDevice BuildDevice(DeviceConfig dc);
#endregion
}
public abstract class ProcessorExtensionDeviceFactory<T> : IProcessorExtensionDeviceFactory where T: EssentialsDevice
{
#region IProcessorExtensionDeviceFactory Members
@@ -203,15 +166,4 @@ namespace PepperDash.Essentials.Core
/// </summary>
public string MinimumEssentialsFrameworkVersion { get; protected set; }
}
public abstract class EssentialsPluginDevelopmentDeviceFactory<T> : EssentialsDeviceFactory<T>, IPluginDevelopmentDeviceFactory where T : EssentialsDevice
{
/// <summary>
/// Specifies the minimum version of Essentials required for a plugin to run. Must use the format Major.Minor.Build (ex. "1.4.33")
/// </summary>
public string MinimumEssentialsFrameworkVersion { get; protected set; }
public List<string> DevelopmentEssentialsFrameworkVersions { get; protected set; }
}
}

32
src/PepperDash.Essentials.Core/Devices/EssentialsDeviceFactory.cs Normal file
View File

@@ -0,0 +1,32 @@
using System;
using System.Collections.Generic;
using PepperDash.Essentials.Core.Config;
namespace PepperDash.Essentials.Core
{
/// <summary>
/// Devices the basic needs for a Device Factory
/// </summary>
public abstract class EssentialsDeviceFactory<T> : IDeviceFactory where T:EssentialsDevice
{
#region IDeviceFactory Members
/// <inheritdoc />
public Type FactoryType => typeof(T);
/// <summary>
/// A list of strings that can be used in the type property of a DeviceConfig object to build an instance of this device
/// </summary>
public List<string> TypeNames { get; protected set; }
/// <summary>
/// The method that will build the device
/// </summary>
/// <param name="dc">The device config</param>
/// <returns>An instance of the device</returns>
public abstract EssentialsDevice BuildDevice(DeviceConfig dc);
#endregion
}
}

25
src/PepperDash.Essentials.Core/Factory/IDeviceFactory.cs
View File

@@ -1,13 +1,30 @@
namespace PepperDash.Essentials.Core
using PepperDash.Essentials.Core.Config;
using System;
using System.Collections.Generic;
namespace PepperDash.Essentials.Core
{
/// <summary>
/// Defines a class that is capable of loading device types
/// </summary>
public interface IDeviceFactory
{
/// <summary>
/// Loads all the types to the DeviceFactory
/// <summary>
/// Gets the type of the factory associated with the current instance.
/// </summary>
void LoadTypeFactories();
Type FactoryType { get; }
/// <summary>
/// Gets a list of type names associated with the current plugin.
/// </summary>
List<string> TypeNames { get; }
/// <summary>
/// Builds and returns an <see cref="EssentialsDevice"/> instance based on the provided configuration.
/// </summary>
/// <param name="deviceConfig">The configuration settings used to initialize the device. This parameter cannot be null.</param>
/// <returns>An <see cref="EssentialsDevice"/> instance configured according to the specified <paramref
/// name="deviceConfig"/>.</returns>
EssentialsDevice BuildDevice(DeviceConfig deviceConfig);
}
}

17
src/PepperDash.Essentials.Core/Plugins/IPluginDeviceFactory.cs
View File

@@ -1,3 +1,4 @@
using PepperDash.Essentials.Core.Config;
using System.Collections.Generic;
@@ -7,25 +8,11 @@ namespace PepperDash.Essentials.Core
/// Defines a class that is capable of loading custom plugin device types
/// </summary>
public interface IPluginDeviceFactory : IDeviceFactory
{
{
/// <summary>
/// Required to define the minimum version for Essentials in the format xx.yy.zz
/// </summary>
string MinimumEssentialsFrameworkVersion { get; }
}
/// <summary>
/// Defines a factory for creating plugin development devices, including support for specific framework versions.
/// </summary>
/// <remarks>This interface extends <see cref="IPluginDeviceFactory"/> to provide additional functionality
/// specific to plugin development environments.</remarks>
public interface IPluginDevelopmentDeviceFactory : IPluginDeviceFactory
{
/// <summary>
/// Gets a list of Essentials versions that this device is compatible with.
/// </summary>
List<string> DevelopmentEssentialsFrameworkVersions { get; }
}
}

44
src/PepperDash.Essentials.Core/Plugins/PluginLoader.cs
View File

@@ -808,35 +808,53 @@ public static class PluginLoader
/// <remarks>This method verifies that the plugin meets the minimum required Essentials framework version
/// before loading it. If the plugin fails the dependency check, it is skipped, and a log message is generated. If
/// the plugin passes the check, it is loaded, and its type factories are initialized.</remarks>
/// <param name="plugin">The plugin to be loaded, implementing the <see cref="IPluginDeviceFactory"/> interface. If the plugin also
/// <param name="deviceFactory">The plugin to be loaded, implementing the <see cref="IPluginDeviceFactory"/> interface. If the plugin also
/// implements <see cref="IPluginDevelopmentDeviceFactory"/>, additional checks for development versions are
/// performed.</param>
/// <param name="loadedAssembly">The assembly associated with the plugin being loaded. This is used for logging and tracking purposes.</param>
private static void LoadCustomPlugin(IPluginDeviceFactory plugin, LoadedAssembly loadedAssembly)
private static void LoadCustomPlugin(IPluginDeviceFactory deviceFactory, LoadedAssembly loadedAssembly)
{
var passed = plugin is IPluginDevelopmentDeviceFactory developmentPlugin ? Global.IsRunningDevelopmentVersion
(developmentPlugin.DevelopmentEssentialsFrameworkVersions, developmentPlugin.MinimumEssentialsFrameworkVersion)
: Global.IsRunningMinimumVersionOrHigher(plugin.MinimumEssentialsFrameworkVersion);
var passed = Global.IsRunningMinimumVersionOrHigher(deviceFactory.MinimumEssentialsFrameworkVersion);
if (!passed)
{
Debug.LogMessage(LogEventLevel.Information,
"\r\n********************\r\n\tPlugin indicates minimum Essentials version {0}. Dependency check failed. Skipping Plugin {1}\r\n********************",
plugin.MinimumEssentialsFrameworkVersion, loadedAssembly.Name);
Debug.LogInformation(
"\r\n********************\r\n\tPlugin indicates minimum Essentials version {minimumEssentialsVersion}. Dependency check failed. Skipping Plugin {pluginName}\r\n********************",
deviceFactory.MinimumEssentialsFrameworkVersion, loadedAssembly.Name);
return;
}
else
{
Debug.LogMessage(LogEventLevel.Information, "Passed plugin passed dependency check (required version {0})", plugin.MinimumEssentialsFrameworkVersion);
Debug.LogInformation("Passed plugin passed dependency check (required version {essentialsMinimumVersion})", deviceFactory.MinimumEssentialsFrameworkVersion);
}
Debug.LogMessage(LogEventLevel.Information, "Loading plugin: {0}", loadedAssembly.Name);
plugin.LoadTypeFactories();
Debug.LogInformation("Loading plugin: {pluginName}", loadedAssembly.Name);
LoadDeviceFactories(deviceFactory);
if(!EssentialsPluginAssemblies.Contains(loadedAssembly))
EssentialsPluginAssemblies.Add(loadedAssembly);
}
}
/// <summary>
/// Loads device factories from the specified plugin device factory and registers them for use.
/// </summary>
/// <remarks>This method retrieves metadata from the provided <paramref name="deviceFactory"/>, including
/// type names, descriptions, and configuration snippets, and registers the factory for each device type. The type
/// names are converted to lowercase for registration.</remarks>
/// <param name="deviceFactory">The plugin device factory that provides the device types, descriptions, and factory methods to be registered.</param>
private static void LoadDeviceFactories(IPluginDeviceFactory deviceFactory)
{
foreach (var typeName in deviceFactory.TypeNames)
{
//Debug.LogMessage(LogEventLevel.Verbose, "Getting Description Attribute from class: '{0}'", typeof(T).FullName);
var descriptionAttribute = deviceFactory.FactoryType.GetCustomAttributes(typeof(DescriptionAttribute), true) as DescriptionAttribute[];
string description = descriptionAttribute[0].Description;
var snippetAttribute = deviceFactory.FactoryType.GetCustomAttributes(typeof(ConfigSnippetAttribute), true) as ConfigSnippetAttribute[];
DeviceFactory.AddFactoryForType(typeName.ToLower(), description, deviceFactory.FactoryType, deviceFactory.BuildDevice);
}
}
/// <summary>
/// Loads plugins from the designated plugin directory, processes them, and integrates them into the application.
/// </summary>