com.comphenix.protocol.events

Class PacketEvent

java.lang.Object

java.util.EventObject

com.comphenix.protocol.events.PacketEvent

All Implemented Interfaces:

java.io.Serializable, org.bukkit.event.Cancellable

public class PacketEvent
extends java.util.EventObject
implements org.bukkit.event.Cancellable

Represents a packet sending or receiving event. Changes to the packet will be reflected in the final version to be sent or received. It is also possible to cancel an event.

Author:

Kristian

See Also:

Serialized Form

Field Summary

Fields

Modifier and Type	Field and Description
static ReportType	REPORT_CHANGING_PACKET_TYPE_IS_CONFUSING

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, NetworkMarker marker, org.bukkit.entity.Player client) Creates an event representing a client packet transmission.
static PacketEvent	fromClient(java.lang.Object source, PacketContainer packet, org.bukkit.entity.Player client) Creates an event representing a client packet transmission.
static PacketEvent	fromServer(java.lang.Object source, PacketContainer packet, NetworkMarker marker, org.bukkit.entity.Player recipient) Creates an event representing a server packet transmission.
static PacketEvent	fromServer(java.lang.Object source, PacketContainer packet, org.bukkit.entity.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.
NetworkMarker	getNetworkMarker() Retrieve the object responsible for managing the serialized input and output of a packet.
PacketContainer	getPacket() Retrieves the packet that will be sent to the player.
int	getPacketID() Deprecated.
PacketType	getPacketType() Retrieve the packet type.
org.bukkit.entity.Player	getPlayer() Retrieves the player that has sent the packet or is recieving it.
boolean	isAsync() Determine if we are executing the packet event in an asynchronous thread.
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	isReadOnly() Determine if the current packet event is read only.
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	setNetworkMarker(NetworkMarker networkMarker) Update the network manager.
void	setPacket(PacketContainer packet) Replace the packet that will be sent to the player.
void	setReadOnly(boolean readOnly) Set the read-only state of this packet event.

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

Field Detail

REPORT_CHANGING_PACKET_TYPE_IS_CONFUSING

public static final ReportType REPORT_CHANGING_PACKET_TYPE_IS_CONFUSING

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,
                     org.bukkit.entity.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.

fromClient

public static PacketEvent fromClient(java.lang.Object source,
                     PacketContainer packet,
                     NetworkMarker marker,
                     org.bukkit.entity.Player client)

Creates an event representing a client packet transmission.

Parameters:

source - - the event source.

packet - - the packet.

marker - - the network marker.

client - - the client that sent the packet.

Returns:

The event.

fromServer

public static PacketEvent fromServer(java.lang.Object source,
                     PacketContainer packet,
                     org.bukkit.entity.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.

fromServer

public static PacketEvent fromServer(java.lang.Object source,
                     PacketContainer packet,
                     NetworkMarker marker,
                     org.bukkit.entity.Player recipient)

Creates an event representing a server packet transmission.

Parameters:

source - - the event source.

packet - - the packet.

marker - - the network marker.

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.

isAsync

public boolean isAsync()

Determine if we are executing the packet event in an asynchronous thread.

If so, you must synchronize all calls to the Bukkit API.

Generally, most server packets are executed on the main thread, whereas client packets are all executed asynchronously.

Returns:

TRUE if we are, FALSE otherwise.

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

@Deprecated
public int getPacketID()

Deprecated.

Retrieves the packet ID.

Deprecated: Use getPacketType() instead.

Returns:

The current packet ID.

getPacketType

public PacketType getPacketType()

Retrieve the packet type.

Returns:

The type.

isCancelled

public boolean isCancelled()

Retrieves whether or not the packet should be cancelled.

Specified by:

isCancelled in interface org.bukkit.event.Cancellable

Returns:

TRUE if it should be cancelled, FALSE otherwise.

getNetworkMarker

public NetworkMarker getNetworkMarker()

Retrieve the object responsible for managing the serialized input and output of a packet.

Note that the serialized input data is only available for client-side packets, and the output handlers can only be applied to server-side packets.

Returns:

The network manager.

setNetworkMarker

public void setNetworkMarker(NetworkMarker networkMarker)

Update the network manager.

This method is internal - do not call.

Parameters:

networkMarker - - the new network manager.

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 org.bukkit.event.Cancellable

Parameters:

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

getPlayer

public org.bukkit.entity.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.

isReadOnly

public boolean isReadOnly()

Determine if the current packet event is read only.

This is used to ensure that a monitor listener doesn't accidentally alter the state of the event. However, it is still possible to modify the packet itself, as it would require too many resources to verify its integrity.

Thus, the packet is considered immutable if the packet event is read only.

Returns:

TRUE if it is, FALSE otherwise.

setReadOnly

public void setReadOnly(boolean readOnly)

Set the read-only state of this packet event.

This will be reset for every packet listener.

Parameters:

readOnly - - TRUE if it is read-only, FALSE otherwise.

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.