Delphi Push Notifications To Update Forms - forms

Question

I'm trying to figure out the best way to distribute state changes to multiple forms which make up an application.
In my scenario, I have a number of hardware devices which are monitored by my application. As an example, one of the devices is a GPS device. Data from these devices come in and information is then stored in one big state object. As an example, GPS positions coming in are stored with both present and historic positions made available to the application.
The application has many different forms and windows available to the user. As an example, the GPS has a form which displays the visible satellites overhead, as well as a form displaying the signal-to-noise ratios and another showing the GPS track over time.
One solution I've considered is to using something like the Observer pattern on my state object. New forms subscribe to the state object and then receive push notifications when the state object changes (new GPS position forces a push to the forms, who then re-paint and re-update their own states).
IObserver = interface
procedure Update;
end;
IObservable = interface
procedure Subscribe(Observer : IObserver);
end;
TObserverForm = class(TForm, IObserver)
// ....
procedure Update;
begin
// State has changed, update
end;
end;
TApplicationState = class(IObservable);
private
FObservers : TList<IObserver>;
FPosition : TPoint;
public
procedure Subscribe(Observer : IObserver);
begin
FObservers.Add(Observer);
end;
procedure PushUpdate;
begin
foreach Observer in Observers
Observer.Update;
end;
property Position : TPoint read GetPosition write SetPosition;
procedure SetPosition(Pos : TPoint);
begin
FPosition : Pos;
// Notify all observers
Self.PushUpdate;
end;
end;
The above is a crude mock-up of what I'm considering. This relies on state calling Subscribe on each TObserverForm that is created during the application life-cycle (and un-subscribing when they're destroyed).
I can't really see any downsides to this. This solution could be tailored somewhat so that the TObserverForms only update and react to certain types of push updates.
Is there something fundamental missing here? Are there more logical/simple solutions to this common problem?

Answer 1

I think you should first determine what you try to get.
Should the event receiving and propagation be:
single threaded or multithreaded
synchronous or asynchronous
cross-platform or Windows/VCL-only
For simplistic - single-thread synchronous VCL - application you may just use multi-events from http://www.Spring4D.org library. All interested forms just declare the event handler and register/unregister it in the Tracker object.
type iTrackerUpdated = iEvent<TNotifyEvent>;
type TMyGPSTracker = class.....
public
property OnUpdate: iTrackerUpdated read FOnUpdate;
procedure AfterCreation; override;
property Coords: TMyGPSCoords read FCoords write SetCoords;
end;
var GPSTracker: TMyGPSTracker;
procedure TMyGPSTracker.AfterCreation;
begin
inherited;
FOnUpdate := TEvent<TNotifyEvent>.Create; // auto-freed on destruction
end;
procedure TMyGPSTracker.SetCoords(const NewValue: FCoords);
begin
if NewValue = FCoords then exit;
FCoords := NewValue;
OnUpdate.Invoke(Self);
end;
And in forms then something like that
type TMyForm = class(TForm)
.....
private
procedure CoordsUpdated(Sender: TObject);
public
procedure AfterCreation; override;
procedure BeforeDestruction; override;
end;
procedure TMyForm.CoordsUpdated(Sender: TObject);
begin
Caption := (Sender as TMyGPSTracker).Coords.ToString();
end;
procedure TMyForm.AfterCreation;
begin
inherited;
GPSTracker.OnUpdate.Add( CoordsUpdated );
end;
procedure TMyForm.BeforeDestruction;
begin
inherited;
GPSTracker.OnUpdate.RemoveAll( Self );
end;
This is all it takes for such a situation. However...
If some form might take a loooong processing of the change - then it would block both other forms updating and the new coords acquiring from GPS driver.
In such a situation you better
extract GPS object into a separate idle-priority thread, that would keep updating data even when the main VCL thread is long busy.
switch to asynchronous event propagation, for VCL the simplest thing would be using PostMessage API. Then you should know that a busy form might "collect" few alerts before it would be ready to process them - and would only have to process one of those.
http://docwiki.embarcadero.com/RADStudio/Berlin/en/Understanding_the_Message-Handling_System
const WM_GPS_UPDATE = WM_USER + 10;
type TMyGPSTracker = class.....
public
property OnUpdateAlertForms: TThreadList<TForm> read FOnUpdate;
property UpdateCounter: Cardinal read FUpdateCounter;
property Coords: TMyGPSCoords read FCoords write SetCoords;
end;
var GPSTracker: TMyGPSTracker;
procedure TMyGPSTracker.SetCoords(const NewValue: FCoords);
var Form: TForm;
begin
if NewValue = FCoords then exit;
Inc(FUpdateCounter);
FCoords := NewValue;
for Form in FOnUpdate do
if Form.HandleAllocated and Form.Showing then
PostMessage( Form.WindowHandle, WM_GPS_UPDATE,
FUpdateCounter, LPARAM(Pointer(Self)) );
// in some rare cases sometimes this might post messages to nowhere
// but the only consequence would be a single non-update
end;
And then
type TMyForm = class(TForm)
.....
private
procedure CoordsUpdated(var Message: TMessage); message WM_GPS_UPDATE;
var LastCoordUpdateProcessed: Cardinal;
end;
procedure TMyForm.CoordsUpdated(var Message: TMessage);
begin
if LastCoordUpdateProcessed >= UpdateCounter then exit;
Caption := GPSTracker.Coords.ToString();
LastCoordUpdateProcessed := GPSTracker.UpdateCounter;
end;
procedure TMyForm.FormShow(Sender: TObject);
begin
GPSTracker.OnUpdateAlertForms.Add( Self );
end;
procedure TMyForm.FormHide(Sender: TObject);
begin
GPSTracker.OnUpdateAlertForms.Remove( Self );
end;
For non-VCL cross-platform targets you would have to find similar asynchronous messaging tools and replace PostMessage and Windows GDI Handles with their corresponding means.