Packagenet.user1.reactor
Classpublic class ClientManager
InheritanceClientManager Inheritance flash.events.EventDispatcher

Since : Reactor 1.0.0

The ClientManager class provides centralized access to Client instances, which represent clients connected to Union Server. Any client that is known to the current client (for example, a client in the same room as the current client) can be accessed via ClientManager's getClient() method. For example,

reactor.getClientManager().getClient(someClientID);

To keep the current client's list of clients on the server synchronized with the state of the server, use the watchForClients() method, as in:

reactor.getClientManager().watchForClients();

ClientManager can also be used to specify a default custom class for client objects. See the setDefaultClientClass() method.

See also

Client
watchForClients()
setDefaultClientClass()


Public Methods
 MethodDefined By
  
ClientManager(roomManager:RoomManager, accountManager:AccountManager, connectionManager:ConnectionManager, messageManager:MessageManager, server:Server, log:Logger)
Constructor.
ClientManager
  
ban(address:String, duration:int, reason:String = null):void
Disconnects any clients with the specified address (typically an IP address) and prevents any future client connections from that address.
ClientManager
  
clientIsKnown(clientID:String):Boolean
Returns a Boolean indicating whether the client with the specified clientID is known to the current client.
ClientManager
  
dispose():void
Permanently disables this object.
ClientManager
  
getAttributeForClients(clientIDs:Array, attrName:String, attrScope:String):Array
Returns an array of objects containing values for the specified attribute for all clients in supplied clientIDs.
ClientManager
  
ClientManager
  
getClient(clientID:String, scope:String = null):IClient
Returns an object representing the specified client; by default, the object is an instance of the net.user1.reactor.Client class.
ClientManager
  
getClientByAttribute(attributeName:String, attributeValue:String, attributeScope:String = null, roomScope:String = null):IClient
Returns the first client known to the ClientManager that has an attribute name and value matching the specified attribute name and value.
ClientManager
  
getClientByUserID(userID:String, scope:String = null):IClient
Returns the client that is logged into the account specified by userID.
ClientManager
  
getClients():Array
Returns a list of all client objects known to the current client.
ClientManager
  
Returns the class used as the global default class for clients in this application.
ClientManager
  
getInternalClient(clientID:String):Client
Returns the internal Client object for the specified client id.
ClientManager
  
Returns a hash of Client objects known to the current client, where the hash keys are client IDs, and the hash values are Client objects.
ClientManager
  
Returns the total number of clients that have ever been known to the current client, excluding itself.
ClientManager
  
Returns the number of clients known to Reactor.
ClientManager
  
If the ClientManager is watching for clients, getNumClientsOnServer() returns the number of clients on the server; otherwise, getNumClientsOnServer() returns 0.
ClientManager
  
hasWatchedClient(clientID:String):Boolean
Returns true if the client with the specified clientID is in the watched client list; false otherwise.
ClientManager
  
isObservingClient(clientID:String):Boolean
Returns true if the client with the specified clientID is currently being observed; false otherwise.
ClientManager
  
ClientManager
  
Indicates whether the current client is currently watching for clients.
ClientManager
  
kickClient(clientID:String):void
Disconnects the specified client from the server.
ClientManager
  
observeClient(clientID:String):void
Asks the server to register the current client as an observer of the client specified by clientID.
ClientManager
  
sendMessage(messageName:String, clientIDs:Array = null, filters:IFilter = null, ... rest):void
Sends a message to a set of specified clientIDs.
ClientManager
  
setDefaultClientClass(defaultClass:Class):void
Assigns a class to use as the default class for all clients in the Reactor application.
ClientManager
  
Asks the server to stop watching for banned addresses.
ClientManager
  
Asks the server to stop watching for clients.
ClientManager
  
unban(address:String):void
Removes any ban currently in effect for the specified address (typically an IP address).
ClientManager
  
Asks the server to send its list of banned client addresses, and then send notification any time an address is banned or unbanned.
ClientManager
  
Asks the server to send a list of clients currently connected to the server, and then send notification any time a client connects or disconnects.
ClientManager
Events
 Event Summary Defined By
   Dispatched when the ClientManager is informed by Union Server that a client address was banned.ClientManager
   Dispatched when the ClientManager is informed by Union Server that a client address was unbanned.ClientManager
   Dispatched when the result of an earlier Client.ban() or ClientManager.ban() request is received.ClientManager
   Dispatched when the ClientManager is informed by Union Server that a client connected.ClientManager
   Dispatched when the ClientManager is informed by Union Server that a client disconnected.ClientManager
   Dispatched when the result of an earlier Client.kick() or ClientManager.kickClient() request is received.ClientManager
   Dispatched when the current client observes a client.ClientManager
   Dispatched when the result of an earlier Client.observe() or ClientManager.observeClient() request is received.ClientManager
   Dispatched when the current client stops observing a client.ClientManager
   Dispatched when the result of an earlier Client.stopObserving() or ClientManager.stopObservingClient() request is received.ClientManager
   Dispatched when the result of an earlier call to ClientManager.stopWatchingForBannedAddresses() is received.ClientManager
   Dispatched when the ClientManager receives the result of an earlier stopWatchingForClients() request.ClientManager
   Dispatched when the ClientManager's list of clients has finished being synchronized after a watchForClients() request.ClientManager
   Dispatched when the ClientManager's list of clients has finished being synchronized after a watchForBannedAddresses() request.ClientManager
   Dispatched when the result of an earlier ClientManager.unban() request is received.ClientManager
   Dispatched when the result of an earlier call to ClientManager.watchForBannedAddresses() is received.ClientManager
   Dispatched when the ClientManager receives the result of an earlier watchForClients() request.ClientManager
Constructor Description
ClientManager()Constructor
public function ClientManager(roomManager:RoomManager, accountManager:AccountManager, connectionManager:ConnectionManager, messageManager:MessageManager, server:Server, log:Logger)

Constructor.

Parameters
roomManager:RoomManager
 
accountManager:AccountManager
 
connectionManager:ConnectionManager
 
messageManager:MessageManager
 
server:Server
 
log:Logger
Method Descriptions
ban()method
public function ban(address:String, duration:int, reason:String = null):void

Since : Reactor 1.0.0

Disconnects any clients with the specified address (typically an IP address) and prevents any future client connections from that address. By default, ban() requires administrator privileges. To allow other types of clients (such as moderators) to ban addresses, define a remote-client security rule as described in Union Server's security documentation.

The result of the ban attempt is returned via a ClientManagerEvent.BAN_RESULT event.

Parameters

address:String — The address to ban (typically an IP address).
 
duration:int — The duration of the ban, in seconds.
 
reason:String (default = null) — An arbitrary, optional string indicating the reason for the ban. The reason string is saved in the server-side ban list.

See also


Example
The following code bans the fictional ip "1.2.3.4" for 10 minutes with the reason "For cheating":
     reactor.getClientManager().ban("1.2.3.4", 600, "For cheating");
     
clientIsKnown()method 
public function clientIsKnown(clientID:String):Boolean

Since : Reactor 1.0.0

Returns a Boolean indicating whether the client with the specified clientID is known to the current client. The client is "known" in the following situations:

Parameters

clientID:String

Returns
Boolean
dispose()method 
public function dispose():void

Permanently disables this object. The object cannot be reused. The dispose() method's purpose is to put this object into a state in which it can be garbage collected (for example, before a .swf file is unloaded). The ClientManager class's dispose() method is invoked automatically when the Reactor class's dispose() method is invoked.

getAttributeForClients()method 
public function getAttributeForClients(clientIDs:Array, attrName:String, attrScope:String):Array

Since : Reactor 1.0.0

Returns an array of objects containing values for the specified attribute for all clients in supplied clientIDs. Each object in the returned array has a clientID property (giving the client id), and a value property (giving the attribute value). The value property will be null for clients in clientIDs that either do not exist or do not have a value set for the specified attribute.

For information on client attributes see the Client class's setAttribute() method.

Parameters

clientIDs:Array — An array of client ids indicating the clients for which to retrieve the specified attribute.
 
attrName:String — The name of the attribute to retrieve.
 
attrScope:String — The scope of the attribute to retrieve. Use null or omit attrScope for global attributes.

Returns
Array

See also


Example
The following code demonstrates how to use getAttributeForClients() to retrieve the ages for all the clients in a particular room.
     var theRoom:Room = reactor.getRoomManager().getRoom("examples.chatroom");
     var clientList:Array = theRoom.getClientIDs();
     // Here, the "age" attribute is global, so attrScope is omitted.
     var attrList:Array = reactor.getClientManager().getAttributeForClients(
                                                                    clientList,
                                                                    "age");
     
     for each (var item:Object in attrList) {
       trace("The value of 'age' for client "
             + item.clientID + " is: " + item.value);
     }
getBannedAddresses()method 
public function getBannedAddresses():Array

Returns
Array
getClient()method 
public function getClient(clientID:String, scope:String = null):IClient

Since : Reactor 1.0.0

Returns an object representing the specified client; by default, the object is an instance of the net.user1.reactor.Client class. However, if a custom class has been specified for the client in the specified scope, the object will be an instance of that custom class. Client custom classes are specified via IClient's setClientClass() method, the Room class's setDefaultClientClass() method, and the ClientManager's setDefaultClientClass() method.

The client object's class is determined as follows:

Parameters

clientID:String — The server-generated client ID for the client.
 
scope:String (default = null) — A fully qualified room id (e.g., "examples.chatRoom"). Use null for the global scope.

Returns
IClient

See also


Example
The following code retrieves a reference to the client with the ID "5":
     var client:Client = reactor.getClientManager().getClient("5");
     
getClientByAttribute()method 
public function getClientByAttribute(attributeName:String, attributeValue:String, attributeScope:String = null, roomScope:String = null):IClient

Since : Reactor 1.0.0

Returns the first client known to the ClientManager that has an attribute name and value matching the specified attribute name and value. If no client has a matching attribute, returns null.

Parameters

attributeName:String — The name of the attribute to match.
 
attributeValue:String — The value of the attribute to match.
 
attributeScope:String (default = null) — The scope of the attribute to match. Use null for global scope.
 
roomScope:String (default = null) — A fully qualified room id (e.g., "examples.chatRoom"). For details, see the "scope" parameter of the getClient() method.

Returns
IClient

See also

getClientByUserID()method 
public function getClientByUserID(userID:String, scope:String = null):IClient

Since : Reactor 1.0.0

Returns the client that is logged into the account specified by userID. If no known client is logged in under the specified userID, returns null.

Parameters

userID:String — A user account's userID.
 
scope:String (default = null) — A fully qualified room id (e.g., "examples.chatRoom"). For details, see the "scope" parameter of the ClientManager's getClient() method.

Returns
IClient

See also

getClients()method 
public function getClients():Array

Since : Reactor 1.0.0

Returns a list of all client objects known to the current client. Each client object in the list is an instance of either net.user1.reactor.Client or a custom client class, determined as follows:

Returns
Array

See also

getDefaultClientClass()method 
public function getDefaultClientClass():Class

Since : Reactor 1.0.0

Returns the class used as the global default class for clients in this application.

Returns
Class

See also

getInternalClient()method 
public function getInternalClient(clientID:String):Client

Since : Reactor 1.0.0

Returns the internal Client object for the specified client id. This method is required in one situation only: when an application specifies a custom client class that does not extend CustomClient, it must implement IClient directly, and compose a Client instance. To obtain the composed instance, the custom class must use getInternalClient(). Otherwise, client applications should retrieve Client objects via getClient(), not getInternalClient().

Parameters

clientID:String — The server-generated client ID.

Returns
Client

See also

getInternalClients()method 
public function getInternalClients():Object

Since : Reactor 1.0.0

Returns a hash of Client objects known to the current client, where the hash keys are client IDs, and the hash values are Client objects. Contrast with getClients(), whose client objects are instances custom client classes for any client that specifies a custom client class. Because getInternalClients() performs no custom-client-class lookup, is faster than getClients().

Returns
Object

See also

getLifetimeNumClientsKnown()method 
public function getLifetimeNumClientsKnown():int

Since : Reactor 1.0.0

Returns the total number of clients that have ever been known to the current client, excluding itself.

Returns
int

See also

getNumClients()method 
public function getNumClients():int

Since : Reactor 1.0.0; Implementation fixed in 2.0.0

Returns the number of clients known to Reactor. When the ClientManager is watching for clients (see watchForClients()), getNumClients() returns the actual number of clients currently connected to Union Server. When the ClientManager is not watching for clients, getNumClients() returns only the number of clients about which the current client is aware. For example, if the current client is in a room with three other clients, and has no other awareness of clients on the server, then getNumClients() will return 4, even though more than 4 clients might be connected to the server.

Returns
int

See also

getNumClientsOnServer()method 
public function getNumClientsOnServer():int

Since : Reactor 1.0.0

If the ClientManager is watching for clients, getNumClientsOnServer() returns the number of clients on the server; otherwise, getNumClientsOnServer() returns 0. When the ClientManager is watching for clients, the getNumClientsOnServer() method provides a faster alternative to getNumClients().

Returns
int

See also

hasWatchedClient()method 
public function hasWatchedClient(clientID:String):Boolean

Since : Reactor 1.0.0 #see watchForAccounts()

Returns true if the client with the specified clientID is in the watched client list; false otherwise.

Parameters

clientID:String

Returns
Boolean
isObservingClient()method 
public function isObservingClient(clientID:String):Boolean

Since : Reactor 1.0.0

Returns true if the client with the specified clientID is currently being observed; false otherwise.

Parameters

clientID:String

Returns
Boolean

See also

isWatchingForBannedAddresses()method 
public function isWatchingForBannedAddresses():Boolean

Returns
Boolean
isWatchingForClients()method 
public function isWatchingForClients():Boolean

Since : Reactor 1.0.0

Indicates whether the current client is currently watching for clients.

Returns
Boolean

See also

kickClient()method 
public function kickClient(clientID:String):void

Since : Reactor 1.0.0

Disconnects the specified client from the server. By default, requires moderator privileges.

The result of the kick attempt is returned via a ClientManagerEvent.KICK_RESULT event.

Parameters

clientID:String — The clientID of the client to kick.

observeClient()method 
public function observeClient(clientID:String):void

Since : Reactor 1.0.0

Asks the server to register the current client as an observer of the client specified by clientID. The result of the request is returned via a ClientEvent.OBSERVE_RESULT event triggered by the ClientManager. If the request succeeds, Reactor creates a Client object for the client (if one does not already exist), and a ClientEvent.OBSERVE event is triggered by the ClientManager. The Client object is then synchronized with the server-side state of the client. Subsequently if the specified client's state changes, the current client is notified in the following ways:

To stop observing a client, use Client's stopObserving() method.

Client observation is used when a client wishes to stay informed of the state of an arbitrary list of clients, as is typical in applications with client match-making or administrative interfaces.

Parameters

clientID:String — The clientID of the client to observe.

See also

sendMessage()method 
public function sendMessage(messageName:String, clientIDs:Array = null, filters:IFilter = null, ... rest):void

Since : Reactor 1.0.0

Sends a message to a set of specified clientIDs. To send a message to a single client only, use Client's sendMessage() method.

To receive the message, recipient clients must register a message listener via MessageManager's addMessageListener() method. For example,

    // Send the message named "SMILE" to clients with clientIDs 2, 34, and 84
    reactor.getClientManager().sendMessage("SMILE", ["2", "34", "84"]);
    
    // Code in the recipient clients registers for the message
    connection.getMessageManager().addMessageListener("SMILE",
                                                      smileListener);
    
    // Method invoked when a SMILE message is received
    protected function privateMessageListener (fromClient:IClient,
                                               messageText:String):void {
      trace("Smile from client: " + fromClient.getClientID());
    }
    

To send a message to all clients in a room, use Room's sendMessage() method.

To send a message to all clients on the server, use Server's sendMessage() method.

Parameters

messageName:String — The name of the message to send.
 
clientIDs:Array (default = null) — An array of the recipient client ID(s) for the message.
 
filters:IFilter (default = null) — Specifies one or more filters for the message. A filter specifies a requirement that each client must meet in order to receive the message. For example, a filter might indicate that only those clients with the attribute "team" set to "red" should receive the message. For complete details, see the IFilter interface. If filters is null, all specified clients receive the message.
 
... rest — An optional comma-separated list of string arguments for the message. These will be passed to any listeners registered to receive the message. See MessageManager's addMessageListener() method.

See also

setDefaultClientClass()method 
public function setDefaultClientClass(defaultClass:Class):void

Since : Reactor 1.0.0

Assigns a class to use as the default class for all clients in the Reactor application.

By default, all clients are represented by instances of the Client class, which implements IClient. An application can, however, choose to represent clients with a custom class. The custom client class can be specified on a per-client basis via the Client class's setClientClass() method. Or, the custom class can be specified on a per-room basis via the Room class's setDefaultClientClass() method. Or, the custom class can be specified globally via the ClientManager class's setDefaultClientClass() method. When a class has been specified globally via setDefaultClientClass(), it is used as the client class for any client retrieved via ClientManager's getClient() method with an unspecified scope.

Any custom class specified via Room's setDefaultClientClass() method overrides the global default client class. Similarly, any custom class specified via Client's setClientClass() method overrides the room and global default client class.

Parameters

defaultClass:Class — The global default client class. The class is normally a descendant of CustomClient, but can be any class that implements the IClient interface.

See also

stopWatchingForBannedAddresses()method 
public function stopWatchingForBannedAddresses():void

Since : Reactor 1.0.0

Asks the server to stop watching for banned addresses. In response, the server no longer sends notifications when an addresses is banned or unbanned.

The result of a stopWatchingForBannedAddresses() request is returned via a ClientManagerEvent.STOP_WATCHING_FOR_BANNED_ADDRESSES_RESULT event.

See also

stopWatchingForClients()method 
public function stopWatchingForClients():void

Since : Reactor 1.0.0

Asks the server to stop watching for clients. In response, the server no longer sends notifications when a client connects or disconnects.

The result of a stopWatchingForClients() request is returned via ClientManagerEvent.STOP_WATCHING_FOR_CLIENTS_RESULT.

See also

unban()method 
public function unban(address:String):void

Since : Reactor 1.0.0

Removes any ban currently in effect for the specified address (typically an IP address). By default, unban() requires administrator privileges. To allow other types of clients (such as moderators) to unban addresses, define a remote-client security rule as described in Union Server's security documentation.

The result of the unban attempt is returned via a ClientManagerEvent.UNBAN_RESULT event.

Parameters

address:String — The address to unban (typically an IP address).

See also


Example
The following code unbans the fictional ip "1.2.3.4":
     reactor.getClientManager().ban("1.2.3.4", 600, "For cheating");
     
watchForBannedAddresses()method 
public function watchForBannedAddresses():void

Since : Reactor 1.0.0

Asks the server to send its list of banned client addresses, and then send notification any time an address is banned or unbanned. When the banned list is ready, ClientManager dispatches a ClientManagerEvent.SYNCHRONIZE_BANLIST event. Subsequently, when a client address is banned, ClientManager dispatches a ClientManagerEvent.ADDRESS_BANNED event and when a client address is unbanned, ClientManager dispatches a ClientManagerEvent.ADDRESS_UNBANNED event.

The result of a watchForBannedAddresses() request is returned via a ClientManagerEvent.WATCH_FOR_BANNED_ADDRESSES_RESULT event.

By default, watchForBannedAddresses() requires administrator privileges. To allow other types of clients (such as moderators) to access the banned address list, define a remote-client security rule as described in Union Server's security documentation.

See also

stopWatchingForBannedAddresses()
watchForClients()method 
public function watchForClients():void

Since : Reactor 1.0.0

Asks the server to send a list of clients currently connected to the server, and then send notification any time a client connects or disconnects. When the client list is ready, ClientManager dispatches a ClientManagerEvent.SYNCHRONIZE event. Subsequent client connections trigger a ClientManagerEvent.CLIENT_CONNECTED event. Subsequent disconnections trigger a ClientManagerEvent.CLIENT_DISCONNECTED event.

Clients that are added to the ClientManager's client list in response to watchForClients() do not have attributes loaded. To load attributes for a specific client, use IClient's observe() method or ClientManager's observeClient() method. In the default configuration, attributes can also be loaded for a given client by joining a room containing that client.

As an alternative to watchForClients(), applications can maintain an arbitrary shared list of clients (with attributes automatically loaded or not) by creating an application room and then forcing all clients in the application to join that room. Clients wishing to load the list without being included in it can observe the application room and register for RoomEvent.ADD_OCCUPANT and RoomEvent.REMOVE_OCCUPANT events. Clients in the list can ignore client list updates by turning off updates for the room via the Room class's setUpdateLevels() method. In applications that wish to manage client lists, room-based client lists are normally more appropriate than watchForClients(). The watchForClients() method is intended for use primarily in cases where the list of rooms and clients on Union Server is not known in advance, and cannot be controlled (as is often true for server-administration applications). As a final alternative to watchForClients(), applications can use the ClientListSnapshot class to load a one-time list of clients on the server.

The result of a watchForClients() request is returned via a ClientManagerEvent.WATCH_FOR_CLIENTS_RESULT event.

See also

Event Detail
ADDRESS_BANNED Event
Event Object Type: ClientManagerEvent
ClientManagerEvent.type variable = net.user1.reactor.ClientManagerEvent.ADDRESS_BANNED

Dispatched when the ClientManager is informed by Union Server that a client address was banned. This event is available when the ClientManager is watching for banned addresses only (see watchForBannedAddresses()).

See also

ADDRESS_UNBANNED Event  
Event Object Type: ClientManagerEvent
ClientManagerEvent.type variable = net.user1.reactor.ClientManagerEvent.ADDRESS_UNBANNED

Dispatched when the ClientManager is informed by Union Server that a client address was unbanned. This event is available when the ClientManager is watching for banned addresses only (see watchForBannedAddresses()).

See also

BAN_RESULT Event  
Event Object Type: ClientManagerEvent
ClientManagerEvent.type variable = net.user1.reactor.ClientManagerEvent.BAN_RESULT

Dispatched when the result of an earlier Client.ban() or ClientManager.ban() request is received.

See also

CLIENT_CONNECTED Event  
Event Object Type: ClientManagerEvent
ClientManagerEvent.type variable = net.user1.reactor.ClientManagerEvent.CLIENT_CONNECTED

Dispatched when the ClientManager is informed by Union Server that a client connected. This event is available when the ClientManager is watching for clients only (see watchForClients()).

See also

CLIENT_DISCONNECTED Event  
Event Object Type: ClientManagerEvent
ClientManagerEvent.type variable = net.user1.reactor.ClientManagerEvent.CLIENT_DISCONNECTED

Dispatched when the ClientManager is informed by Union Server that a client disconnected. This event is available when the ClientManager is watching for clients (see watchForClients()) or observing the client that disconnected (see observeClient()) only.

See also

KICK_RESULT Event  
Event Object Type: ClientManagerEvent
ClientManagerEvent.type variable = net.user1.reactor.ClientManagerEvent.KICK_RESULT

Dispatched when the result of an earlier Client.kick() or ClientManager.kickClient() request is received.

See also

OBSERVE Event  
Event Object Type: ClientEvent
ClientEvent.type variable = net.user1.reactor.ClientEvent.OBSERVE

Dispatched when the current client observes a client. The client that is now being observed can be accessed via ClientEvent's getClient() method.

See also

OBSERVE_RESULT Event  
Event Object Type: ClientEvent
ClientEvent.type variable = net.user1.reactor.ClientEvent.OBSERVE_RESULT

Dispatched when the result of an earlier Client.observe() or ClientManager.observeClient() request is received.

See also

STOP_OBSERVING Event  
Event Object Type: ClientEvent
ClientEvent.type variable = net.user1.reactor.ClientEvent.STOP_OBSERVING

Dispatched when the current client stops observing a client. The client that is no longer being observed can be accessed via ClientEvent's getClient() method.

See also

STOP_OBSERVING_RESULT Event  
Event Object Type: ClientEvent
ClientEvent.type variable = net.user1.reactor.ClientEvent.STOP_OBSERVING_RESULT

Dispatched when the result of an earlier Client.stopObserving() or ClientManager.stopObservingClient() request is received.

See also

STOP_WATCHING_FOR_BANNED_ADDRESSES_RESULT Event  
Event Object Type: ClientManagerEvent
ClientManagerEvent.type variable = net.user1.reactor.ClientManagerEvent.STOP_WATCHING_FOR_BANNED_ADDRESSES_RESULT

Dispatched when the result of an earlier call to ClientManager.stopWatchingForBannedAddresses() is received.

See also

STOP_WATCHING_FOR_CLIENTS_RESULT Event  
Event Object Type: ClientManagerEvent
ClientManagerEvent.type variable = net.user1.reactor.ClientManagerEvent.STOP_WATCHING_FOR_CLIENTS_RESULT

Dispatched when the ClientManager receives the result of an earlier stopWatchingForClients() request. To determine the result of the attempt, use getStatus(), which has the following possible return values:

See also

SYNCHRONIZE Event  
Event Object Type: ClientManagerEvent
ClientManagerEvent.type variable = net.user1.reactor.ClientManagerEvent.SYNCHRONIZE

Dispatched when the ClientManager's list of clients has finished being synchronized after a watchForClients() request.

See also

SYNCHRONIZE_BANLIST Event  
Event Object Type: ClientManagerEvent
ClientManagerEvent.type variable = net.user1.reactor.ClientManagerEvent.SYNCHRONIZE_BANLIST

Dispatched when the ClientManager's list of clients has finished being synchronized after a watchForBannedAddresses() request.

See also

UNBAN_RESULT Event  
Event Object Type: ClientManagerEvent
ClientManagerEvent.type variable = net.user1.reactor.ClientManagerEvent.UNBAN_RESULT

Dispatched when the result of an earlier ClientManager.unban() request is received.

See also

WATCH_FOR_BANNED_ADDRESSES_RESULT Event  
Event Object Type: ClientManagerEvent
ClientManagerEvent.type variable = net.user1.reactor.ClientManagerEvent.WATCH_FOR_BANNED_ADDRESSES_RESULT

Dispatched when the result of an earlier call to ClientManager.watchForBannedAddresses() is received.

See also

WATCH_FOR_CLIENTS_RESULT Event  
Event Object Type: ClientManagerEvent
ClientManagerEvent.type variable = net.user1.reactor.ClientManagerEvent.WATCH_FOR_CLIENTS_RESULT

Dispatched when the ClientManager receives the result of an earlier watchForClients() request. To determine the result of the request, use getStatus(), which has the following possible return values:

See also