edu.berkeley.guir.ptk
Class PeripheralDisplay

java.lang.Object
  edu.berkeley.guir.ptk.PTK
      edu.berkeley.guir.ptk.PeripheralDisplay

All Implemented Interfaces:

PEventReceiver

Direct Known Subclasses:

AudioApp, AudioAppAbstractInput, AudioAppNon, AudioGuitarApp, AudioGuitarAppNon, AudioOrbApp, AudioOrbAppNon, BusLEDApp, BusLEDAppNon, BusMobileApp, BusMobileAppNon, InfoCanvas, MotionMonitor, NumPeopleTicker, PressureAudioAppNon, RemoteActivityApp, RingVoiceAppNon, StockNewsApp, StockNewsAppNon, StockNewsButtonAppNon, TickerTestApp

public abstract class PeripheralDisplay

extends PTK

implements PEventReceiver

Represents a peripheral display application. Connects all the components of the application: Inputs, Outputs, Abstractors, and NotificationSetters. Handles new event sent from Inputs via the PTK Server.

See the package comments for much more information.

This class defines the PTK architecture. This architecture is made up of policy classes, that route events through a chain of components (e.g., the NotificationPolicy routes events through a chain of NotificationSetter objects.

One "row" of policy classes represents a connection, as created by a call to makeConnection. "Row" refers to a set made up of an AbstractionPolicy, a NotificationPolicy, and an OutputPolicy that call their chained components (if any) when an Event from the correct InputSource arrives (the correct InputSource is identified by comparing the Event's metadata with the component's desired metadata).

The application keeps a history of all events that arrive before they are abstracted. A new event is stored in the app_abstraction_history data field. Each policy keeps its own history as well.

Author:

tmatthew Created: Mar 1, 2003

Field Summary

protected float	AUDIO_THRESHOLD The threshold, above which the user is not interruptible.
protected boolean	check_interruptibility Indicates whether this application should check for interruptibility when setting the notification level.
protected java.lang.String	my_id A unique ID for this application.
protected java.lang.String	my_ip IP address where this application is running.
protected int	my_port Port number where this application is running.
protected float	volume Volume to determine interruptibility of user using this application.

Fields inherited from class edu.berkeley.guir.ptk.PTK

debug, MAX_DEBUG, MED_DEBUG, MIN_DEBUG, NO_DEBUG

Constructor Summary

protected	PeripheralDisplay()
	PeripheralDisplay(java.lang.String my_id) This constructor is called when the application is not distributed.
	PeripheralDisplay(java.lang.String my_id, java.lang.String my_ip, int my_port) This constructor is called when the application is distributed.

Method Summary

abstract void	buildUI() Build any user interface components necessary, such as JFrames or hardware.
boolean	checkInterruptibility() Indicates if the user is interruptible: returns true if the user is or when the application is not supposed to care about interruptibility..
void	checkInterruptibility(boolean b) Sets the check_interruptibility flag for the application to the parameter b.
protected void	finalize() Should unregister all the output objects in this application upon Java garbage collection.
abstract void	initialize() Override this method to initalize peripheral display elements: abstractors, notification setters, transitions, outputs.
protected void	makeAggregateConnection_distributed(Metadata[] mds, Output[] outs, Abstractor[] abs, NotificationSetter[] nots)
protected void	makeAggregateConnection_nondistributed(InputSource[] ins, Output[] outs, Abstractor[] abs, NotificationSetter[] nots)
protected void	makeConnection_distributed(Metadata in_mds, Output[] outs, Abstractor[] abs, NotificationSetter[] nots) Handles making the connection between the given input and output, via the abstractors, notification setters, and transitions specified, for distributed applications.
protected void	makeConnection_nondistributed(InputSource in, Output[] outs, Abstractor[] abs, NotificationSetter[] nots) Handles making the connection between the given input and output, via the abstractors, notification setters, and transitions specified, for non-distributed applications.
void	makeConnection(InputSource[] in, Output out)
void	makeConnection(InputSource[] in, Output[] outs)
void	makeConnection(InputSource[] in, Output[] outs, Abstractor abstractor)
void	makeConnection(InputSource[] in, Output[] outs, Abstractor[] abs)
void	makeConnection(InputSource[] in, Output[] outs, Abstractor[] abs, NotificationSetter notify_setter)
void	makeConnection(InputSource[] in, Output[] outs, Abstractor[] abs, NotificationSetter[] nots)
void	makeConnection(InputSource[] in, Output[] outs, Abstractor abstractor, NotificationSetter notify_setter)
void	makeConnection(InputSource[] in, Output[] outs, Abstractor abstractor, NotificationSetter[] nots)
void	makeConnection(InputSource[] in, Output[] outs, NotificationSetter notify_setter)
void	makeConnection(InputSource[] in, Output[] outs, NotificationSetter[] nots)
void	makeConnection(InputSource[] in, Output out, Abstractor abstractor)
void	makeConnection(InputSource[] in, Output out, Abstractor[] abs)
void	makeConnection(InputSource[] in, Output out, Abstractor[] abs, NotificationSetter notify_setter)
void	makeConnection(InputSource[] in, Output out, Abstractor[] abs, NotificationSetter[] nots)
void	makeConnection(InputSource[] in, Output out, Abstractor abstractor, NotificationSetter notify_setter) When you want to connect multiple inputs to each of the given outputs, abstractors, and notification setters, pass an array of InputSource objects into makeConnection.
void	makeConnection(InputSource[] in, Output out, Abstractor abstractor, NotificationSetter[] nots)
void	makeConnection(InputSource[] in, Output out, NotificationSetter notify_setter)
void	makeConnection(InputSource[] in, Output out, NotificationSetter[] nots)
void	makeConnection(InputSource in, Output out)
void	makeConnection(InputSource in, Output[] outs)
void	makeConnection(InputSource in, Output[] outs, Abstractor abstractor)
void	makeConnection(InputSource in, Output[] outs, Abstractor[] abs)
void	makeConnection(InputSource in, Output[] outs, Abstractor[] abs, NotificationSetter notify_setter)
void	makeConnection(InputSource in, Output[] outs, Abstractor[] abs, NotificationSetter[] nots)
void	makeConnection(InputSource in, Output[] outs, Abstractor abstractor, NotificationSetter notify_setter)
void	makeConnection(InputSource in, Output[] outs, Abstractor abstractor, NotificationSetter[] nots)
void	makeConnection(InputSource in, Output[] outs, NotificationSetter notify_setter)
void	makeConnection(InputSource in, Output[] outs, NotificationSetter[] nots)
void	makeConnection(InputSource in, Output out, Abstractor abstractor)
void	makeConnection(InputSource in, Output out, Abstractor[] abs)
void	makeConnection(InputSource in, Output out, Abstractor[] abs, NotificationSetter notify_setter)
void	makeConnection(InputSource in, Output out, Abstractor[] abs, NotificationSetter[] nots)
void	makeConnection(InputSource in, Output out, Abstractor abstractor, NotificationSetter notify_setter) For non-distributed applications, makeConnection takes an InputSource object.
void	makeConnection(InputSource in, Output out, Abstractor abstractor, NotificationSetter[] nots)
void	makeConnection(InputSource in, Output out, NotificationSetter notify_setter)
void	makeConnection(InputSource in, Output out, NotificationSetter[] nots)
void	makeConnection(Metadata[] mds, Output out)
void	makeConnection(Metadata[] mds, Output[] outs)
void	makeConnection(Metadata[] mds, Output[] outs, Abstractor abstractor)
void	makeConnection(Metadata[] mds, Output[] outs, Abstractor[] abs)
void	makeConnection(Metadata[] mds, Output[] outs, Abstractor[] abs, NotificationSetter notify_setter)
void	makeConnection(Metadata[] mds, Output[] outs, Abstractor[] abs, NotificationSetter[] nots)
void	makeConnection(Metadata[] mds, Output[] outs, Abstractor abstractor, NotificationSetter notify_setter)
void	makeConnection(Metadata[] mds, Output[] outs, Abstractor abstractor, NotificationSetter[] nots)
void	makeConnection(Metadata[] mds, Output[] outs, NotificationSetter notify_setter)
void	makeConnection(Metadata[] mds, Output[] outs, NotificationSetter[] nots)
void	makeConnection(Metadata[] mds, Output out, Abstractor abstractor)
void	makeConnection(Metadata[] mds, Output out, Abstractor[] abs)
void	makeConnection(Metadata[] mds, Output out, Abstractor[] abs, NotificationSetter notify_setter)
void	makeConnection(Metadata[] mds, Output out, Abstractor[] abs, NotificationSetter[] nots)
void	makeConnection(Metadata[] mds, Output out, Abstractor abstractor, NotificationSetter notify_setter) Use versions of makeConnection that take an array of Metadata objects when you want to connect multiple inputs to each of the given outputs, abstractors, and notification setters.
void	makeConnection(Metadata[] mds, Output out, Abstractor abstractor, NotificationSetter[] nots)
void	makeConnection(Metadata[] mds, Output out, NotificationSetter notify_setter)
void	makeConnection(Metadata[] mds, Output out, NotificationSetter[] nots)
void	makeConnection(Metadata mds, Output out)
void	makeConnection(Metadata mds, Output[] outs)
void	makeConnection(Metadata mds, Output[] outs, Abstractor abstractor)
void	makeConnection(Metadata mds, Output[] outs, Abstractor[] abs)
void	makeConnection(Metadata mds, Output[] outs, Abstractor[] abs, NotificationSetter notify_setter)
void	makeConnection(Metadata mds, Output[] outs, Abstractor[] abs, NotificationSetter[] nots)
void	makeConnection(Metadata mds, Output[] outs, Abstractor abstractor, NotificationSetter notify_setter)
void	makeConnection(Metadata mds, Output[] outs, Abstractor abstractor, NotificationSetter[] nots)
void	makeConnection(Metadata mds, Output[] outs, NotificationSetter notify_setter)
void	makeConnection(Metadata mds, Output[] outs, NotificationSetter[] nots)
void	makeConnection(Metadata mds, Output out, Abstractor abstractor)
void	makeConnection(Metadata mds, Output out, Abstractor[] abs)
void	makeConnection(Metadata mds, Output out, Abstractor[] abs, NotificationSetter notify_setter)
void	makeConnection(Metadata mds, Output out, Abstractor[] abs, NotificationSetter[] nots)
void	makeConnection(Metadata mds, Output out, Abstractor abstractor, NotificationSetter notify_setter) Makes connections between the input and output, via the abstractors, notification setters, and transitions specified.
void	makeConnection(Metadata mds, Output out, Abstractor abstractor, NotificationSetter[] nots)
void	makeConnection(Metadata mds, Output out, NotificationSetter notify_setter)
void	makeConnection(Metadata mds, Output out, NotificationSetter[] nots)
void	receive(Event e) Receives events from the PTK Server and calls processEvent to start event processing.

Methods inherited from class edu.berkeley.guir.ptk.PTK

getMAX, getMED, getMIN, getNO, printDebug, printDebug, printError

Methods inherited from class java.lang.Object

clone, equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail

my_id

protected java.lang.String my_id

A unique ID for this application. Set by subscribe method.

my_ip

protected java.lang.String my_ip

IP address where this application is running. Set by subscribe method.

my_port

protected int my_port

Port number where this application is running. Set by subscribe method.

check_interruptibility

protected boolean check_interruptibility

Indicates whether this application should check for interruptibility when setting the notification level. If the user is not interruptible, the defaults is to decrease interrupt notification levels to make aware.

volume

protected float volume

Volume to determine interruptibility of user using this application.

AUDIO_THRESHOLD

protected float AUDIO_THRESHOLD

The threshold, above which the user is not interruptible.

Constructor Detail

PeripheralDisplay

protected PeripheralDisplay()

PeripheralDisplay

public PeripheralDisplay(java.lang.String my_id)

This constructor is called when the application is not distributed. It initializes the communication to and from the application as being same- machine (i.e., via the localhost).

This method also has the capability to check the interruptibility of an application user. This is done by measuring the noise near the application, where high volumes are indicative of low interruptibility (from Hudson's work, we learned that people who are talking are oftn busy). This code is currently commented.

This method does not currently initialize the policies: this is done by a calls to makeConnection, which connect an input to one or more outputs, via zero or more abstractors, notification setters, and transitions.

Calls buildUI and initialize to start up the peripheral display.

Parameters:

my_id - the unique ID of this application. This is used to distinguish this application from any other application that may be running.

PeripheralDisplay

public PeripheralDisplay(java.lang.String my_id,
                         java.lang.String my_ip,
                         int my_port)

This constructor is called when the application is distributed. It initializes the communication to and from the application as being across- machine (i.e., via the IP and port provided).

Calls buildUI and initialize to start up the peripheral display.

Parameters:

my_id - the unique ID of this application. This is used to distinguish this application from any other application that may be running.

my_ip - the IP address where this application is running.

my_port - the port number where this application is running.

Method Detail

initialize

public abstract void initialize()

Override this method to initalize peripheral display elements: abstractors, notification setters, transitions, outputs. Calls one of the makeConnection methods to connect the initialized elements and to start the application.

buildUI

public abstract void buildUI()

Build any user interface components necessary, such as JFrames or hardware.

makeConnection

public void makeConnection(InputSource in,
                           Output out,
                           Abstractor abstractor,
                           NotificationSetter notify_setter)

For non-distributed applications, makeConnection takes an InputSource object. For distributed applications, makeConnection takes the metadata Strings describing the input to make the connection.

To make an aggregate connection between multiple inputs and some combination of Outputs, Abstractors, and Notification Setters in a non-distributed application, pass an array of InputSource objects (for non-distributed applications) or an array of Metadata objects (for distributed applications) to makeConnection.

Following, are many permutations of the same basic method that connects an input to an application with different numbers of components.

makeConnection

public void makeConnection(InputSource in,
                           Output out,
                           Abstractor[] abs,
                           NotificationSetter notify_setter)

makeConnection

public void makeConnection(InputSource in,
                           Output out,
                           Abstractor[] abs,
                           NotificationSetter[] nots)

makeConnection

public void makeConnection(InputSource in,
                           Output[] outs,
                           Abstractor[] abs,
                           NotificationSetter[] nots)

makeConnection

public void makeConnection(InputSource in,
                           Output out,
                           Abstractor abstractor,
                           NotificationSetter[] nots)

makeConnection

public void makeConnection(InputSource in,
                           Output[] outs,
                           Abstractor[] abs,
                           NotificationSetter notify_setter)

makeConnection

public void makeConnection(InputSource in,
                           Output[] outs,
                           Abstractor abstractor,
                           NotificationSetter notify_setter)

makeConnection

public void makeConnection(InputSource in,
                           Output[] outs,
                           Abstractor abstractor,
                           NotificationSetter[] nots)

makeConnection

public void makeConnection(InputSource in,
                           Output out,
                           Abstractor abstractor)

makeConnection

public void makeConnection(InputSource in,
                           Output[] outs,
                           Abstractor abstractor)

makeConnection

public void makeConnection(InputSource in,
                           Output out,
                           Abstractor[] abs)

makeConnection

public void makeConnection(InputSource in,
                           Output[] outs,
                           Abstractor[] abs)

makeConnection

public void makeConnection(InputSource in,
                           Output out,
                           NotificationSetter notify_setter)

makeConnection

public void makeConnection(InputSource in,
                           Output[] outs,
                           NotificationSetter notify_setter)

makeConnection

public void makeConnection(InputSource in,
                           Output out,
                           NotificationSetter[] nots)

makeConnection

public void makeConnection(InputSource in,
                           Output[] outs,
                           NotificationSetter[] nots)

makeConnection

public void makeConnection(InputSource in,
                           Output out)

makeConnection

public void makeConnection(InputSource in,
                           Output[] outs)

makeConnection

public void makeConnection(InputSource[] in,
                           Output out,
                           Abstractor abstractor,
                           NotificationSetter notify_setter)

When you want to connect multiple inputs to each of the given outputs, abstractors, and notification setters, pass an array of InputSource objects into makeConnection. This is for use in a non-distributed application, since it takes an array of InputSource objects (rather than an array of Metadata objects, like the distributed versions).

makeConnection

public void makeConnection(InputSource[] in,
                           Output out,
                           Abstractor[] abs,
                           NotificationSetter notify_setter)

makeConnection

public void makeConnection(InputSource[] in,
                           Output out,
                           Abstractor[] abs,
                           NotificationSetter[] nots)

makeConnection

public void makeConnection(InputSource[] in,
                           Output[] outs,
                           Abstractor[] abs,
                           NotificationSetter[] nots)

makeConnection

public void makeConnection(InputSource[] in,
                           Output out,
                           Abstractor abstractor,
                           NotificationSetter[] nots)

makeConnection

public void makeConnection(InputSource[] in,
                           Output[] outs,
                           Abstractor[] abs,
                           NotificationSetter notify_setter)

makeConnection

public void makeConnection(InputSource[] in,
                           Output[] outs,
                           Abstractor abstractor,
                           NotificationSetter notify_setter)

makeConnection

public void makeConnection(InputSource[] in,
                           Output[] outs,
                           Abstractor abstractor,
                           NotificationSetter[] nots)

makeConnection

public void makeConnection(InputSource[] in,
                           Output out,
                           Abstractor abstractor)

makeConnection

public void makeConnection(InputSource[] in,
                           Output[] outs,
                           Abstractor abstractor)

makeConnection

public void makeConnection(InputSource[] in,
                           Output out,
                           Abstractor[] abs)

makeConnection

public void makeConnection(InputSource[] in,
                           Output[] outs,
                           Abstractor[] abs)

makeConnection

public void makeConnection(InputSource[] in,
                           Output out,
                           NotificationSetter notify_setter)

makeConnection

public void makeConnection(InputSource[] in,
                           Output[] outs,
                           NotificationSetter notify_setter)

makeConnection

public void makeConnection(InputSource[] in,
                           Output out,
                           NotificationSetter[] nots)

makeConnection

public void makeConnection(InputSource[] in,
                           Output[] outs,
                           NotificationSetter[] nots)

makeConnection

public void makeConnection(InputSource[] in,
                           Output out)

makeConnection

public void makeConnection(InputSource[] in,
                           Output[] outs)

makeConnection

public void makeConnection(Metadata mds,
                           Output out,
                           Abstractor abstractor,
                           NotificationSetter notify_setter)

Makes connections between the input and output, via the abstractors, notification setters, and transitions specified. These methods are for distributed applications and they take the metadata Strings describing the input to make the connection. The distributed application case requires that the PTK Server has been started independently (by running PDiscovery on some machine) before calling makeConnection.

For aggregate input connections in distributed applications, simply pass an array of all the metadata for each input to one of these makeConnection methods (i.e., pass in a Metadata[] that includes the metadata from all InputSources you wish to connect to).

makeConnection

public void makeConnection(Metadata mds,
                           Output out,
                           Abstractor[] abs,
                           NotificationSetter[] nots)

makeConnection

public void makeConnection(Metadata mds,
                           Output out,
                           Abstractor abstractor,
                           NotificationSetter[] nots)

makeConnection

public void makeConnection(Metadata mds,
                           Output out,
                           Abstractor[] abs,
                           NotificationSetter notify_setter)

makeConnection

public void makeConnection(Metadata mds,
                           Output[] outs,
                           Abstractor[] abs,
                           NotificationSetter[] nots)

makeConnection

public void makeConnection(Metadata mds,
                           Output[] outs,
                           Abstractor[] abs,
                           NotificationSetter notify_setter)

makeConnection

public void makeConnection(Metadata mds,
                           Output[] outs,
                           Abstractor abstractor,
                           NotificationSetter notify_setter)

makeConnection

public void makeConnection(Metadata mds,
                           Output[] outs,
                           Abstractor abstractor,
                           NotificationSetter[] nots)

makeConnection

public void makeConnection(Metadata mds,
                           Output out,
                           Abstractor abstractor)

makeConnection

public void makeConnection(Metadata mds,
                           Output[] outs,
                           Abstractor abstractor)

makeConnection

public void makeConnection(Metadata mds,
                           Output out,
                           Abstractor[] abs)

makeConnection

public void makeConnection(Metadata mds,
                           Output[] outs,
                           Abstractor[] abs)

makeConnection

public void makeConnection(Metadata mds,
                           Output out,
                           NotificationSetter notify_setter)

makeConnection

public void makeConnection(Metadata mds,
                           Output[] outs,
                           NotificationSetter notify_setter)

makeConnection

public void makeConnection(Metadata mds,
                           Output out,
                           NotificationSetter[] nots)

makeConnection

public void makeConnection(Metadata mds,
                           Output[] outs,
                           NotificationSetter[] nots)

makeConnection

public void makeConnection(Metadata mds,
                           Output out)

makeConnection

public void makeConnection(Metadata mds,
                           Output[] outs)

makeConnection

public void makeConnection(Metadata[] mds,
                           Output out,
                           Abstractor abstractor,
                           NotificationSetter notify_setter)

Use versions of makeConnection that take an array of Metadata objects when you want to connect multiple inputs to each of the given outputs, abstractors, and notification setters. This is for use in a distributed application, since it takes an array of Metadata objects (rather than an array of InputSource objects, like the non-distributed versions).

makeConnection

public void makeConnection(Metadata[] mds,
                           Output out,
                           Abstractor[] abs,
                           NotificationSetter notify_setter)

makeConnection

public void makeConnection(Metadata[] mds,
                           Output out,
                           Abstractor[] abs,
                           NotificationSetter[] nots)

makeConnection

public void makeConnection(Metadata[] mds,
                           Output[] outs,
                           Abstractor[] abs,
                           NotificationSetter[] nots)

makeConnection

public void makeConnection(Metadata[] mds,
                           Output out,
                           Abstractor abstractor,
                           NotificationSetter[] nots)

makeConnection

public void makeConnection(Metadata[] mds,
                           Output[] outs,
                           Abstractor[] abs,
                           NotificationSetter notify_setter)

makeConnection

public void makeConnection(Metadata[] mds,
                           Output[] outs,
                           Abstractor abstractor,
                           NotificationSetter notify_setter)

makeConnection

public void makeConnection(Metadata[] mds,
                           Output[] outs,
                           Abstractor abstractor,
                           NotificationSetter[] nots)

makeConnection

public void makeConnection(Metadata[] mds,
                           Output out,
                           Abstractor abstractor)

makeConnection

public void makeConnection(Metadata[] mds,
                           Output[] outs,
                           Abstractor abstractor)

makeConnection

public void makeConnection(Metadata[] mds,
                           Output out,
                           Abstractor[] abs)

makeConnection

public void makeConnection(Metadata[] mds,
                           Output[] outs,
                           Abstractor[] abs)

makeConnection

public void makeConnection(Metadata[] mds,
                           Output out,
                           NotificationSetter notify_setter)

makeConnection

public void makeConnection(Metadata[] mds,
                           Output[] outs,
                           NotificationSetter notify_setter)

makeConnection

public void makeConnection(Metadata[] mds,
                           Output out,
                           NotificationSetter[] nots)

makeConnection

public void makeConnection(Metadata[] mds,
                           Output[] outs,
                           NotificationSetter[] nots)

makeConnection

public void makeConnection(Metadata[] mds,
                           Output out)

makeConnection

public void makeConnection(Metadata[] mds,
                           Output[] outs)

makeConnection_nondistributed

protected void makeConnection_nondistributed(InputSource in,
                                             Output[] outs,
                                             Abstractor[] abs,
                                             NotificationSetter[] nots)

Handles making the connection between the given input and output, via the abstractors, notification setters, and transitions specified, for non-distributed applications.

makeAggregateConnection_nondistributed

protected void makeAggregateConnection_nondistributed(InputSource[] ins,
                                                      Output[] outs,
                                                      Abstractor[] abs,
                                                      NotificationSetter[] nots)

makeConnection_distributed

protected void makeConnection_distributed(Metadata in_mds,
                                          Output[] outs,
                                          Abstractor[] abs,
                                          NotificationSetter[] nots)

Handles making the connection between the given input and output, via the abstractors, notification setters, and transitions specified, for distributed applications.

makeAggregateConnection_distributed

protected void makeAggregateConnection_distributed(Metadata[] mds,
                                                   Output[] outs,
                                                   Abstractor[] abs,
                                                   NotificationSetter[] nots)

checkInterruptibility

public void checkInterruptibility(boolean b)

Sets the check_interruptibility flag for the application to the parameter b. If true, this means that the notification policies will decrease any events set to the interrupt notification level to the make aware notification level. All other notification levels are left as is. The code that uses this boolean is in NotificationPolicy.setNotification.

Parameters:

b - Boolean that indicates if the application should check for the interruptibility of a user when setting the notification level.

checkInterruptibility

public boolean checkInterruptibility()

Indicates if the user is interruptible: returns true if the user is or when the application is not supposed to care about interruptibility.. When a user is not interruptible (when this method returns false), the notification level is decreased (for certain notification levels). This method is used by NotificationPolicy.setNotification to check the check_interruptibility data field of this class.

Returns:

boolean True when the application does not check interruptibility or when the user is interruptible. False when the user is not interruptibility (is busy). Interruptibility is determined by noise level around the applications: high volumes indicate low interruptibility. gh

finalize

protected void finalize()
                 throws java.lang.Throwable

Should unregister all the output objects in this application upon Java garbage collection. Does not unregister if client is null.

This method may not work properly. This means that you must restart Server to be guaranteed an output is not still subscribed, until this method is fixed.

Throws:

java.lang.Throwable

See Also:

Object.finalize()

receive

public void receive(Event e)

Receives events from the PTK Server and calls processEvent to start event processing. The POutput data member of this class is what handles communication between the PTK Server and this class. When it receives an event from the server, it calls this event.

Specified by:

receive in interface PEventReceiver