Plugins en Delphi

[elcolo83]

Hola a todos.... bueno, luego de andar por unos foros, leer un poco sobre el tema y finalmente sentarme a programar algo se me ocurrio hacer una Unit para administrar los plugins (archivos BPL) que una aplicacion pueda usar. Con esta unit podran usar facilmente los archivos bpl utilizados en este caso como plugins.
Aca va un poco de mi trabajo:

Código Delphi [-]
unit Plugins_Master_;

interface

uses
  Windows, SysUtils, Classes, Forms, Dialogs, Messages;
/////////////////////////////////////////////////////////////////////////////////////////////
///  Otras Unidades:
///  Messages, Variants, Graphics, Controls,  ComCtrls, StdCtrls, ShellApi
/////////////////////////////////////////////////////////////////////////////////////////////

type
  TExecuteRoutine = procedure(sender:TObject) of Object;

  TPluginsList = Record
    Activo: Boolean;
    NombreCorto, Plugin, PFORM, Command: string;
    AForm: TForm;
    hndl: HModule;
  End;

var
  inicio: boolean;
  Apl: TApplication;
  self_: TObject;
  PluginsList: array of TPlugInsList;


function SpStr(str: string): string;

Procedure Iniciar_PlugIn_Master(_Apl: TApplication; _self_: TObject);
function AddPlugin(Plugin, PFORM, Command, NombreCorto: string): boolean;
function ExecutePlugin(Plugin: string; p: integer): integer;
function Plugin_OFF(NombreCorto: string): boolean;
function Plugin_OFF_ALL: boolean;
function Plugin_ON(NombreCorto: string): boolean;
function Plugin_STATE(NombreCorto: string): boolean;
function Plugin_Name_Exist(NombreCorto: string): integer;
function Plugin_Exist(Plugin: string): integer;


implementation

function SpStr(str: string): string;
begin
  str:= lowercase(trim(str));
  if Str[1] in ['a'..'z'] then
    Str[1]:=  chr(ord(Str[1])-32);
  Result:= Str;
end;


Procedure Iniciar_PlugIn_Master(_Apl: TApplication; _self_: TObject);
begin
 Apl:= _Apl;
 Self_:= _self_;
 Inicio:= True;
end;

function AddPlugin(Plugin, PFORM, Command, NombreCorto: string): boolean;
////////////////////////////////////////////////////////////////////////////////////////
/// Agrega un Plug-In a la lista. Luego quedara disponible para su ejecución.
////////////////////////////////////////////////////////////////////////////////////////
var i: integer;
    esta: Boolean;
begin
if not inicio then
    begin
      Result:= false;
      exit;
    end;

esta:= False;
if (Plugin_Exist(Plugin)>-1)or(Plugin_Name_Exist(NombreCorto)>-1) then
    begin
      result:= false;
      exit;
    end;

SetLength(PluginsList, Length(PluginsList)+1); //agrego un lugar mas en el arreglo
PluginsList[Length(PluginsList)-1].Activo:= False;
PluginsList[Length(PluginsList)-1].Plugin:= LowerCase(Plugin);
PluginsList[Length(PluginsList)-1].PFORM:= PForm;
PluginsList[Length(PluginsList)-1].Command:= Command;
PluginsList[Length(PluginsList)-1].NombreCorto:= spStr(NombreCorto);
result:= true;
end;


function ExecutePlugin(Plugin: string; P: integer): integer;
////////////////////////////////////////////////////////////////////////////////////////
///  ExecutePluin se encarga de cargar el plug-in, ejecutarlo y agregarlo a la lista de
///  Plug-ins activos para darlos de baja cuendo ya no se utilice.
///  Result:
///     0: No hay Error;
///     1: No se econtro el procedimiento (command) buscado.
////////////////////////////////////////////////////////////////////////////////////////
var
  hndl: HModule;
  AClass: TPersistentClass;
  AForm: TForm;
  Routine: TMethod;
begin
if not inicio then
    begin
      Result:= -1;
      exit;
    end;

if FileExists(Plugin) then
  begin
    hndl:= LoadPackage(PluginsList[p].Plugin);
    AClass:= GetClass(PluginsList[p].PFORM);
    try
        if (AClass <> nil) then
          begin
            AForm:= TComponentClass(AClass).Create(Apl) as TForm;
            try
              Routine.Data:= Pointer(AForm);
              Routine.Code:= (AForm).MethodAddress(PluginsList[p].Command);

              if (Routine.Code = Nil) then
                begin
                  MessageDlg('Error al cargar el Plug-in', mterror, [mbOk], 0);
                  MessageDlg('Error, no se ha encontrado el procedimiento (Execute) para el correcto funcionamieno del Plug-in.', mtError, [mbOK], 0);
                  Result:= 1;
                  Exit;
                end;
              TExecuteRoutine(Routine)(self_);
              result:= 0;
            finally
              //AForm.Free;
            end;
            PluginsList[p].Activo:= True;
            PluginsList[p].hndl:= hndl;
            PluginsList[p].AForm:= AForm;//.Handle;
          end
        else
          MessageDlg('La clase para acceder al plug-in parece que no está correctamente registrada.', mtError, [mbOK], 0);
    except
      on E:Exception do
         MessageDlg('Error al cargar el plug-in.', mtError, [mbOK], 0);
    end;
  end;
end;



function Plugin_OFF(NombreCorto: string): boolean;
var i, j: integer;
    H: HWND;
    M: TMemoryBasicInformation;
begin
  Result:= True;
  if not inicio then
    begin
      Result:= false;
      exit;
    end;
try
  NombreCorto:= spStr(NombreCorto);
  for i := 0 to Length(PluginsList) - 1 do
      if (PluginsList[i].NombreCorto = NombreCorto)and(PluginsList[i].Activo) then
        begin
          try
            PluginsList[i].Activo:= False;
            //H:= PluginsList[i].HForm;
            //if h <> 0 then PostMessage(h, WM_DESTROY, 0, 0);
            h:= PluginsList[i].hndl;

            for j := Application.ComponentCount - 1 downto 0 do
              begin
                VirtualQuery(
                GetClass(Application.Components[j].ClassName),
                        M, SizeOf(M));
                if (h = 0) or
                  (HMODULE(M.AllocationBase) = h) then
                      Application.Components[j].Free;
              end;
            UnRegisterModuleClasses(h);
            UnLoadPackage(h);

            Result:= True;
          except
            Result:= False;
          end;
          break;
        end;
finally

end;
end;


function Plugin_OFF_ALL: boolean;
var i, j: integer;
    h: HWND;
    M: TMemoryBasicInformation;
begin
try
  Result:= True;
  if not inicio then
    begin
      Result:= false;
      exit;
    end;
  for i := 0 to Length(PluginsList) - 1 do
      if PluginsList[i].Activo then
        begin
          try
            PluginsList[i].Activo:= False;
            //H:= PluginsList[i].HForm;
            //if h <> 0 then PostMessage(h, WM_DESTROY, 0, 0);
            h:= PluginsList[i].hndl;

            for j := Application.ComponentCount - 1 downto 0 do
              begin
                VirtualQuery(
                GetClass(Application.Components[j].ClassName),
                        M, SizeOf(M));
                if (h = 0) or
                  (HMODULE(M.AllocationBase) = h) then
                      Application.Components[j].Free;
              end;
            UnRegisterModuleClasses(h);
            UnLoadPackage(h);

            Result:= True;
          except
            Result:= False;
            Break;
          end;
        end;
finally

end;
end;



function Plugin_ON(NombreCorto: string): boolean;
var i: integer;
begin
  if not inicio then 
    begin
      Result:= false;
      exit;
    end;

  NombreCorto:= spStr(NombreCorto);
  Result:= False;
  for i := 0 to Length(PluginsList) - 1 do
      if PluginsList[i].NombreCorto = NombreCorto then
        begin
          ExecutePlugin(PluginsList[i].Plugin, i);  
          Result:= true;    
          break;
        end;   
end;


function Plugin_STATE(NombreCorto: string): boolean;
var i: integer;
begin
  if not inicio then 
    begin
      Result:= false;
      exit;
    end;

  NombreCorto:= spStr(NombreCorto);
  for i := 0 to Length(PluginsList) - 1 do
      if PluginsList[i].NombreCorto = NombreCorto then
        begin          
          Result:= PluginsList[i].Activo;    
          break;
        end; 
end;


function Plugin_Name_Exist(NombreCorto: string): Integer;
var i: integer;
begin
  if not inicio then 
    begin
      Result:= -1;
      exit;
    end;
    
  NombreCorto:= spStr(NombreCorto);
  result:= -1;
  for i := 0 to Length(PluginsList) - 1 do
      if PluginsList[i].NombreCorto = NombreCorto then
        begin          
          Result:= i;    
          break;
        end;
end;


function Plugin_Exist(Plugin: string): Integer;
var i: integer;
begin 
  if not inicio then 
    begin
      Result:= -1;
      exit;
    end;
  Plugin:= LowerCase(Plugin);
  result:= -1;
  for i := 0 to Length(PluginsList) - 1 do
      if PluginsList[i].Plugin = Plugin then
        begin          
          Result:= i;    
          break;
        end;
end;


initialization
  Inicio:= False;  

end.

Como usarla:
1) Para iniciar poner en el evento OnCreate de la aplicacion

Código Delphi [-]
Iniciar_PlugIn_Master(Application, sender);

2) Para usarla, una forma sencilla es cargar en un TCheckListBox los plugins (archivos bpl) de una carpeta X y en el evento onClickCheck del componente poner lo siguiente:

Código Delphi [-]
procedure TPrincipal.ListaPluginsClickCheck(Sender: TObject);
var i:integer;
    ListaP: TStringList;
begin
try
ListaArchPlugins.ItemIndex:= ListaPlugins.ItemIndex;
if ListaPlugins.Checked[ListaPlugins.ItemIndex] then
  begin
    if plugin_exist(ListaArchPlugins.FileName)<0 then
      if not (AddPlugin(ListaArchPlugins.FileName, 'TOtroPlugin'{Clase registrada del Plugin},
          'Execute'{nombre de la funcion a ejecutar del plugin}, ExtractFileName(ListaArchPlugins.FileName)){la ruta completa del archivo}) then
        showmessage('No se pudo Agregar el Plug-In');
    if not Plugin_ON(ExtractFileName(ListaArchPlugins.FileName)) then
      showmessage('No se pudo ejecutar el Plug-In');
  end
else Plugin_OFF(ExtractFileName(ListaArchPlugins.FileName));

ListaP:= TStringList.Create;
for i := 0 to ListaPlugins.Count - 1 do
    if ListaPlugins.Checked[i] then
         ListaP.Add(Cifrar(ListaPlugins.Items[i], gg+gs));
ListaP.SaveToFile(CarpetaDatos+'Extras.phcea');
ListaP.Free;
finally

end;
end;

La ruta completa del archivo en mi caso lo saco de un TFileListBox.


Si a alguno le interesa pongo un modelo de plugin para que vean el ejemplo...

No cuesta nada compartir lo que uno hace... Espero que sea de utilidad...

[elcolo83]

Me olvide de comertarles que la unidad la hice en Delphi 2007, no la probe con otras versiones... Si alguno tiene tiempo de compilarla en alguna otra version de Delphi que me avise como les fue con esto...

[burgosrodas]

interesante trabajo
deberias de compilarlo en un componente Delphi, asi es solo soltar en el Form y listo
pues yo uso el JvPluginManager, que es algo parecido a lo que digo
solo que con este no he podido ejecutar una funcion del HostApplication desde el plugin o viceversa, solo los procedimientos que se publican desde el plugin, o no se como hacerlo
buen trabajo
intentare tomar algo de tu codigo

[elcolo83]

Hola burgosrodas!!! La forma en que implemente este (ya viejo) proyecto era haciendo que los plugins se integren ellos al main de manera que el main es solo el framework que se encarga de iniciar los plugins. La idea es que una vez cargados los bpl la aplicación funcion como una única entidad... una forma de hacer esto era por ejemplo si lo que quiero es agregar un nuevo control visual a un TPanel que esta en el main solo que que hay que hacer es buscar el componente en la aplicacion principal mediante TPanel(Application.findcomponent('TPanel1')).... y de esa forma agregar todo lo que se quiera (componentes, funciones, procedimientos, eventos...) a la aplicacion principal.

Otra cosa que tambien ultilice fue este componente que hice http://www.clubdelphi.com/foros/show...t=tmemofilemap para comunicar y pasar datos entre 2 plugins o mas y de esa manera poder llamar a un plagin desde otro mediante esta interface....

El año pasado me descargue los componentes TPascalScript con los cuales se me ocurrio hacer un framework de manera tal que los formularios y el código de los mismos este en una base de datos, entonces se esta forma la aplicacion es totalmente dinamica.... :P

[burgosrodas]

Hola
que bien, es justo lo que estoy tratando de hacer también
tengo una aplicación que simplemente carga Plug's y los administra, pero las funcionalidades están es en los plugins (inclusive tablas conexiones y Querys).
desde el plugin puedo acceder a los forms del main mediante
HostApplication.FindComponent('Objeto_a_Buscar')
lo que no logro es ejecutar una funcion del plugin desde la aplicacion principal,
desafortunadamente ya tiré mucho codigo con los JEDI y su PluginManager como para implementar el que propones, pero intentare heredar del plugin manager y añadir algo de tu codigo
mis BPL's los guardo en la base de datos y los cargo al inicio de la aplicacion.
muchas gracias
saludos desde Colombia.