Delphi Push Notifications To Update 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

1. extract GPS object into a separate idle-priority thread, that would keep updating data even when the main VCL thread is long busy.
2. 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.