com.comphenix.protocol.events

Class PacketEvent

java.lang.Object

java.util.EventObject

com.comphenix.protocol.events.PacketEvent

All Implemented Interfaces:

java.io.Serializable, Cancellable

public class PacketEvent
extends java.util.EventObject
implements Cancellable

See Also:

Serialized Form

Field Summary

Fields inherited from class java.util.EventObject

source

Constructor Summary

Constructors

Constructor and Description
PacketEvent(java.lang.Object source) Use the static constructors to create instances of this event.

Method Summary

Methods

Modifier and Type	Method and Description
static PacketEvent	fromClient(java.lang.Object source, PacketContainer packet, Player client) Creates an event representing a client packet transmission.
static PacketEvent	fromServer(java.lang.Object source, PacketContainer packet, Player recipient) Creates an event representing a server packet transmission.
static PacketEvent	fromSynchronous(PacketEvent event, AsyncMarker marker) Create an asynchronous packet event from a synchronous event and a async marker.
AsyncMarker	getAsyncMarker() Retrieve the asynchronous marker.
PacketContainer	getPacket() Retrieves the packet that will be sent to the player.
int	getPacketID() Retrieves the packet ID.
Player	getPlayer() Retrieves the player that has sent the packet or is recieving it.
boolean	isAsynchronous() Determine if the packet event has been executed asynchronously or not.
boolean	isCancelled() Retrieves whether or not the packet should be cancelled.
boolean	isServerPacket() Whether or not this packet was created by the server.
void	setAsyncMarker(AsyncMarker asyncMarker) Set the asynchronous marker.
void	setCancelled(boolean cancel) Sets whether or not the packet should be cancelled.
void	setPacket(PacketContainer packet) Replace the packet that will be sent to the player.

Methods inherited from class java.util.EventObject

getSource, toString

Methods inherited from class java.lang.Object

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

Constructor Detail

PacketEvent

public PacketEvent(java.lang.Object source)

Use the static constructors to create instances of this event.

Parameters:

source - - the event source.

Method Detail

fromClient

public static PacketEvent fromClient(java.lang.Object source,
                     PacketContainer packet,
                     Player client)

Creates an event representing a client packet transmission.

Parameters:

source - - the event source.

packet - - the packet.

client - - the client that sent the packet.

Returns:

The event.

fromServer

public static PacketEvent fromServer(java.lang.Object source,
                     PacketContainer packet,
                     Player recipient)

Creates an event representing a server packet transmission.

Parameters:

source - - the event source.

packet - - the packet.

recipient - - the client that will receieve the packet.

Returns:

The event.

fromSynchronous

public static PacketEvent fromSynchronous(PacketEvent event,
                          AsyncMarker marker)

Create an asynchronous packet event from a synchronous event and a async marker.

Parameters:

event - - the original synchronous event.

marker - - the asynchronous marker.

Returns:

The new packet event.

getPacket

public PacketContainer getPacket()

Retrieves the packet that will be sent to the player.

Returns:

Packet to send to the player.

setPacket

public void setPacket(PacketContainer packet)

Replace the packet that will be sent to the player.

Parameters:

packet - - the packet that will be sent instead.

getPacketID

public int getPacketID()

Retrieves the packet ID.

Returns:

The current packet ID.

isCancelled

public boolean isCancelled()

Retrieves whether or not the packet should be cancelled.

Specified by:

isCancelled in interface Cancellable

Returns:

TRUE if it should be cancelled, FALSE otherwise.

setCancelled

public void setCancelled(boolean cancel)

Sets whether or not the packet should be cancelled. Uncancelling is possible.

Warning: A cancelled packet should never be re-transmitted. Use the asynchronous packet manager if you need to perform extensive processing. It should also be used if you need to synchronize with the main thread.

This ensures that other plugins can work with the same packet.

An asynchronous listener can also delay a packet indefinitely without having to block its thread.

Specified by:

setCancelled in interface Cancellable

Parameters:

cancel - - TRUE if it should be cancelled, FALSE otherwise.

getPlayer

public Player getPlayer()

Retrieves the player that has sent the packet or is recieving it.

Returns:

The player associated with this event.

isServerPacket

public boolean isServerPacket()

Whether or not this packet was created by the server.

Most listeners can deduce this by noting which listener method was invoked.

Returns:

TRUE if the packet was created by the server, FALSE if it was created by a client.

getAsyncMarker

public AsyncMarker getAsyncMarker()

Retrieve the asynchronous marker.

If the packet is synchronous, this marker will be used to schedule an asynchronous event. In the following asynchronous event, the marker is used to correctly pass the packet around to the different threads.

Note that if there are no asynchronous events that can receive this packet, the marker is NULL.

Returns:

The current asynchronous marker, or NULL.

setAsyncMarker

public void setAsyncMarker(AsyncMarker asyncMarker)

Set the asynchronous marker.

If the marker is non-null at the end of an synchronous event processing, the packet will be scheduled to be processed asynchronously with the given settings.

Note that if there are no asynchronous events that can receive this packet, the marker should be NULL.

Parameters:

asyncMarker - - the new asynchronous marker, or NULL.

Throws:

java.lang.IllegalStateException - If the current event is asynchronous.

isAsynchronous

public boolean isAsynchronous()

Determine if the packet event has been executed asynchronously or not.

Returns:

TRUE if this packet event is asynchronous, FALSE otherwise.