About this task
To implement event notification, perform the following tasks:
- Implement the com.ibm.btt.base.Notifier interface.
For example, suppose a client application needs to know about all
printer error messages from any printer in the network. To accomplish
this purpose you need to create a DSENotifier subclass
called SampleNotifier that instantiate on the server
workstation for the printer services. This class also implements a printerError method
called by any service that is accessing a printer when the printer
fails. SampleNotifier signals a toolkit event with
the following arguments:
- The name of the error message passed as an argument of printerError method
- Attributes identifying the printer address in the network
- The document to be printed when the failure occurred
public class SampleNotifier extends DSENotifier {
public DSEEventObject printerEvent;
}
public SampleNotifier () {
super();
}
public SampleNotifier(String aName) {
super(aName);
}
public void printerError(String aPrt, String aDocName, String message) {
Hashtable eventAttributes = new Hashtable();
eventAttributes.put ("printerAddress", aPrt);
eventAttributes.put ("document", aDocName);
printerEvent = new DSEEventObject("mMessage",this,eventAttributes);
signalEvent(printerEvent);
}
You can integrate the standard Java events with the event management of BTT.
- Implement the signalEvent method for
each event that the notifier can send out. Note the standard Java event notification mechanism
will call any other local listeners for that event.
- Create a handler for the event and implement a dispatchEvent method
to provide the behavior to process the event. For example, the SampleNotifier uses
the PrinterEventsHandler:
public class PrinterEventsHandler extends DSEHandler {
}
public Handler dispatchEvent(DSEEventObject anEvent) {
// The dispatch method displays a string in the system standard output
// containing the event information
System.out.println("The event"+ anEvent.getName()+ "has been signaled. Printer:"+
anEvent.getParameters().get("printerAddress")+" Document:"
+anEvent.getParamenters().get("document"));
// The handler enables further event propagation by returning this
return this;
}
In this case, the dispatchEvent method
passes a message to the system standard output. Note if you do not
want to propagate this event to the next registered handler, the return
value of dispatchEvent must be null.
- Add the handler registration to the client operation that
requires event notification as shown in the following example:
import com.ibm.dse.base.*;
import com.ibm.dse.clientserver.*;
public class myClientOperation extends DSEClientOperation {
public PrinterEventsHandler eventsHandler;
}
public void execute() throws Exception() {
// If the client workstation where the application is running has
// sessions with different server workstations, the application must
// know which CSClient instance identifies the session with the
// server that fires the event. This can be requested by name
// from the Context class. In this case, the name of the CSClient
// instance that establishes the session with a server
// is "CSSessionTID".
CSClientService clientServerSession = (CSClientService)getService("CSSessionTID");
EventManager.registerInterestInRemoteEvent("allEvents", "SampleNotifier",
clientServerSession);
// The previous statements can be run only once in the lifecycle
// of the application, possibly at application startup.
// At any time, the application can instantiate a handler and
// register it for events coming from the SampleNotifier object.
eventsHandler= new PrinterEventsHandler;
eventsHandler.handleEvent("allEvents", "SampleNotifier", getContext());
// The application can continue its operation flow. The handler
// processes the event as soon as it is fired.
}
When the SampleNotifier instance
sends out an event, it calls the dispatchEvent method
of the PrinterEventsHandler. The handler displays
a message in the system standard output. - Create a DSEEventObject instance. DSEEventObject is
a subclass of EventObject with the following attributes:
- name - the name of the event to which a handler should be registered
- sourceName - the name of the notifier that signals the event
- parameters - a Hash table containing the event information required
by the event handler
- originWorkstation - the TID of the workstation generating the
event
One of the signalEvent methods accepts the DSEEventObject argument.
- If the application is already working with an EventObject instance,
use the signalEvent method that accepts a string
with the event name and, if required, a Hash table containing the
event attributes as arguments. This method builds a DSEEventObject that
the event manager sends to the listening remote workstation.