Delphi Imbricated callback functions - delphi

Question

I have the following situation.
I made one component. I want to get some feedback from the component when I use one method.
Like component.Method(param1 : callback function);
all good and shiny so far.
the project have the following units.
formMain - visible form.
dataModule - working with the component.
form main need to pass to the datamodule one callback function to receive his feedback. this callback function is a different function from the component (has more params).
I dont know how to do this.
TFeedBackProcedure = procedure(param1 : Integer) of object;
TFeedBackProcedureByTypeOf = procedure(aTypeOf : Integer; param1 : Integer) of object;
// component
procedure Syncro(feedBack : TFeedBackProcedure);
begin
//somewhere inside
for i := 0 to 15 do begin
feedBack(i);
end;
end;
// the feeedback received so far when someone use the Syncro procedure is the value of i
// the datamodule
// inside of a method I need to pass also the i received from compoent also a typeof value used only inside datamodule
procedure UseMethod(feedbackProcedure : TFeedBackProcedureByTypeOf); // the extended callback
begin
typeof = 1;
if component.Syncro(???) then begin // <-------- how to ???
// do stuff
end;
end;
// the main form
// the real callback function
procedure TFormMain.Feddback(aTypeOf : Integer; param1: Integer);
begin
if aTypeOf = 0 then begin
label1.caption = IntToStr(param1);
end else begin
label2.caption = IntToStr(param1);
end;
end;
// usage of datamodule
procedure TFormMain.btn1Click(Sender: TObject);
begin
dataModule.UseMethod(Feddback);
end;
any ideas? any other methods to do this? (I also need this in FMX enviroment)
tks alot
Razvan

Answer 1

If you've written the component yourself then the easiest thing to do is to change the type declaration of TFeedbackProcedure so that it also accepts anonymous methods (as well as object methods):
TFeedBackProcedure = reference to procedure(param1 : Integer);
This lets you wrap the extended method in place and call it like so:
procedure UseMethod(feedbackProcedure : TFeedBackProcedureByTypeOf);
var
_typeOf : integer;
begin
_typeOf = 1;
component.Syncro(procedure(AParam : integer)
begin
feedbackProcedure(_typeOf, AParam);
end);
end;
I've simply shown calling the method here because your example writes .Synchro as if it were a function returning a boolean when, in fact, you've declared it as a simple procedure.
As an alternative, if you cannot change the method signature or add a wrapper to an existing class, you can always write a wrapper class to do the job. I've shown a dedicated wrapper class here, but you could just as easily add these fields and methods to any suitable class to wrap the functionality into an object method with the correct signature.
TCallbackContainer = class
private
FParam : integer;
FFeedbackProcByTypeOf : TFeedBackProcedureByTypeOf;
public
constructor Create(AProcByTypeOf : TFeedBackProcedureByTypeOf);
procedure WrapCallback(AParam:integer);
property IntParam : integer read FParam write FParam;
end;
with implementation :
constructor TCallbackContainer.Create(AProcByTypeOf : TFeedBackProcedureByTypeOf);
begin
FFeedbackProcByTypeOf := AProcByTypeOf;
end;
procedure TCallbackContainer.WrapCallback(AParam: Integer);
begin
FFeedbackProcByTypeOf(FParam, AParam);
end;
You can then call this like :
procedure UseMethod(feedbackProcedure : TFeedBackProcedureByTypeOf);
var
LCallbackContainer : TCallbackContainer;
begin
LCallBackContainer := TCallbackContainer.Create(feedbackProcedure);
try
LCallBackContainer.IntParam := 1;
component.Syncro(LCallbackContainer.WrapCallback);
finally
LCallBackContainer.Free;
end;
{ Or, make it FCallBackContainer and manage lifetime somehow...}
end;
Unlike with anonymous methods, which are reference counted, you have to manage the LCallbackContainer object lifetime here somehow. I've shown it as a local, which is fine if .Synchro is actually fully synchronous and you can free the callback container when it returns. If .Synchro is actually an async method, however, and returns before its work is complete then you need some way to manage the callback wrapper's lifetime.
You should also avoid naming a variable TypeOf since this will hide the standard method with that name. System.TypeOf is deprecated but it is still good practice to avoid naming conflicts like this.