PlayerInjector (ProtocolLib JavaDocs)

java.lang.Object
- com.comphenix.protocol.injector.player.PlayerInjector

All Implemented Interfaces:

SocketInjector

Direct Known Subclasses:

NetworkObjectInjector
```
public abstract class PlayerInjector
extends Object
implements SocketInjector
```

Nested Class Summary

Nested Classes
Modifier and Type Class and Description

static class PlayerInjector.ServerHandlerNull
Indicates that a player's NetServerHandler or PlayerConnection was NULL.

Nested Classes
Modifier and Type	Class and Description
`static class`	`PlayerInjector.ServerHandlerNull` Indicates that a player's NetServerHandler or PlayerConnection was NULL.

Field Summary

Fields
Modifier and Type	Field and Description
`protected DataInputStream`	`cachedInput`
`protected boolean`	`hasInitialized`
`protected ListenerInvoker`	`invoker`
`protected Object`	`loginHandler`
`protected Object`	`netHandler`
`protected static Field`	`netHandlerField`
`protected Object`	`networkManager`
`protected static Field`	`networkManagerField`
`protected VolatileField`	`networkManagerRef`
`protected static StructureModifier<Object>`	`networkModifier`
`protected org.bukkit.entity.Player`	`player`
`protected static Method`	`processMethod`
`protected static Field`	`proxyServerField`
`protected Map<Object,NetworkMarker>`	`queuedMarkers`
`protected static Method`	`queueMethod`
`static ReportType`	`REPORT_ACCESS_DENIED_CLOSE_SOCKET`
`static ReportType`	`REPORT_ASSUME_DISCONNECT_METHOD`
`static ReportType`	`REPORT_CANNOT_ACCESS_DISCONNECT`
`static ReportType`	`REPORT_CANNOT_CLOSE_SOCKET`
`static ReportType`	`REPORT_CANNOT_HANDLE_PACKET`
`static ReportType`	`REPORT_CANNOT_PROXY_SERVER_HANDLER`
`static ReportType`	`REPORT_CANNOT_UPDATE_PLAYER`
`static ReportType`	`REPORT_DETECTED_CUSTOM_SERVER_HANDLER`
`static ReportType`	`REPORT_INVALID_ARGUMENT_DISCONNECT`
`static ReportType`	`REPORT_INVALID_NETWORK_MANAGER`
`protected ErrorReporter`	`reporter`
`protected Object`	`serverHandler`
`protected static Field`	`serverHandlerField`
`protected VolatileField`	`serverHandlerRef`
`protected Socket`	`socket`
`protected SocketAddress`	`socketAddress`
`protected static Field`	`socketAddressField`
`protected static Field`	`socketField`
`protected InterceptWritePacket`	`writePacketInterceptor`

Constructor Summary

Constructors
Constructor and Description

PlayerInjector(ErrorReporter reporter, org.bukkit.entity.Player player, ListenerInvoker invoker)

Constructors
Constructor and Description
`PlayerInjector(ErrorReporter reporter, org.bukkit.entity.Player player, ListenerInvoker invoker)`

Method Summary

All Methods Instance Methods Abstract Methods Concrete Methods
Modifier and Type	Method and Description
`abstract boolean`	`canInject(GamePhase state)` Determine if this inject method can even be attempted.
`abstract com.comphenix.protocol.injector.player.UnsupportedListener`	`checkListener(MinecraftVersion version, PacketListener listener)` Invoked before a new listener is registered.
`protected abstract void`	`cleanHook()` Override to add custom cleanup behavior.
`void`	`cleanupAll()` Remove all hooks and modifications.
`void`	`disconnect(String message)` Attempt to disconnect the current client.
`SocketAddress`	`getAddress()` Retrieve the associated remote address of a player.
`protected Object`	`getEntityPlayer(org.bukkit.entity.Player player)` Retrieve the notch (NMS) entity player object.
`abstract PlayerInjectHooks`	`getHookType()` Retrieve the hook type this class represents.
`DataInputStream`	`getInputStream(boolean cache)` Retrieve the current player's input stream.
`ListenerInvoker`	`getInvoker()` Object that can invoke the packet events.
`protected Object`	`getNetHandler()` Retrieves the current net handler for this player.
`protected Object`	`getNetHandler(boolean refresh)` Retrieves the current net handler for this player.
`Object`	`getNetworkManager()` Retrieve the current network manager.
`org.bukkit.entity.Player`	`getPlayer()` Retrieve the hooked player.
`Object`	`getServerHandler()` Retrieve the current server handler (PlayerConnection).
`Socket`	`getSocket()` Retrieve the associated socket of this player.
`org.bukkit.entity.Player`	`getUpdatedPlayer()` Retrieve the hooked player object OR the more up-to-date player instance.
`abstract void`	`handleDisconnect()` Clean up after the player has disconnected.
`Object`	`handlePacketSending(Object packet)` Allows a packet to be sent by the listeners.
`protected abstract boolean`	`hasListener(int packetID)` Determine if the given injector is listening for this packet ID.
`protected boolean`	`hasProxyServerHandler()` Retrieve whether or not the server handler is a proxy object.
`void`	`initialize(Object injectionSource)` Initialize all fields for this player injector, if it hasn't already.
`void`	`initializeLogin(Object netLoginHandler)` Initialize the player injector from a NetLoginHandler.
`void`	`initializePlayer(org.bukkit.entity.Player player)` Initialize the player injector using an actual player instance.
`abstract void`	`injectManager()` Inject a hook to catch packets sent to the current player.
`boolean`	`isClean()` Determine whether or not this hook has already been cleaned.
`void`	`processPacket(Object packet)` Processes the given packet as if it was transmitted by the current player.
`abstract void`	`sendServerPacket(Object packet, NetworkMarker marker, boolean filtered)` Send a packet to the client.
`void`	`setNetworkManager(Object value, boolean force)` Set the current network manager.
`void`	`setPlayer(org.bukkit.entity.Player player)` Set the hooked player.
`void`	`setUpdatedPlayer(org.bukkit.entity.Player updatedPlayer)` Set the real Bukkit player that we will use.
`void`	`transferState(SocketInjector delegate)` Invoked when a delegated socket injector transfers the state of one injector to the next.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Field Detail
  - REPORT_ASSUME_DISCONNECT_METHOD
```
public static final ReportType REPORT_ASSUME_DISCONNECT_METHOD
```
  - REPORT_INVALID_ARGUMENT_DISCONNECT
```
public static final ReportType REPORT_INVALID_ARGUMENT_DISCONNECT
```
  - REPORT_CANNOT_ACCESS_DISCONNECT
```
public static final ReportType REPORT_CANNOT_ACCESS_DISCONNECT
```
  - REPORT_CANNOT_CLOSE_SOCKET
```
public static final ReportType REPORT_CANNOT_CLOSE_SOCKET
```
  - REPORT_ACCESS_DENIED_CLOSE_SOCKET
```
public static final ReportType REPORT_ACCESS_DENIED_CLOSE_SOCKET
```
  - REPORT_DETECTED_CUSTOM_SERVER_HANDLER
```
public static final ReportType REPORT_DETECTED_CUSTOM_SERVER_HANDLER
```
  - REPORT_CANNOT_PROXY_SERVER_HANDLER
```
public static final ReportType REPORT_CANNOT_PROXY_SERVER_HANDLER
```
  - REPORT_CANNOT_UPDATE_PLAYER
```
public static final ReportType REPORT_CANNOT_UPDATE_PLAYER
```
  - REPORT_CANNOT_HANDLE_PACKET
```
public static final ReportType REPORT_CANNOT_HANDLE_PACKET
```
  - REPORT_INVALID_NETWORK_MANAGER
```
public static final ReportType REPORT_INVALID_NETWORK_MANAGER
```
  - serverHandlerField
```
protected static Field serverHandlerField
```
  - proxyServerField
```
protected static Field proxyServerField
```
  - networkManagerField
```
protected static Field networkManagerField
```
  - netHandlerField
```
protected static Field netHandlerField
```
  - socketField
```
protected static Field socketField
```
  - socketAddressField
```
protected static Field socketAddressField
```
  - networkModifier
```
protected static StructureModifier<Object> networkModifier
```
  - queueMethod
```
protected static Method queueMethod
```
  - processMethod
```
protected static Method processMethod
```
  - player
```
protected volatile org.bukkit.entity.Player player
```
  - hasInitialized
```
protected boolean hasInitialized
```
  - networkManagerRef
```
protected VolatileField networkManagerRef
```
  - serverHandlerRef
```
protected VolatileField serverHandlerRef
```
  - networkManager
```
protected Object networkManager
```
  - loginHandler
```
protected Object loginHandler
```
  - serverHandler
```
protected Object serverHandler
```
  - netHandler
```
protected Object netHandler
```
  - socket
```
protected Socket socket
```
  - socketAddress
```
protected SocketAddress socketAddress
```
  - invoker
```
protected ListenerInvoker invoker
```
  - cachedInput
```
protected DataInputStream cachedInput
```
  - reporter
```
protected ErrorReporter reporter
```
  - queuedMarkers
```
protected Map<Object,NetworkMarker> queuedMarkers
```
  - writePacketInterceptor
```
protected InterceptWritePacket writePacketInterceptor
```
- Constructor Detail
  - PlayerInjector
```
public PlayerInjector(ErrorReporter reporter,
                      org.bukkit.entity.Player player,
                      ListenerInvoker invoker)
```
- Method Detail
  - getEntityPlayer
```
protected Object getEntityPlayer(org.bukkit.entity.Player player)
```
    Retrieve the notch (NMS) entity player object.
    
    Parameters:
    
    player - - the player to retrieve.
    
    Returns:
    
    Notch player object.
  - initialize
```
public void initialize(Object injectionSource)
                throws IllegalAccessException
```
    Initialize all fields for this player injector, if it hasn't already.
    
    Parameters:
    
    injectionSource - - Injection source
    
    Throws:
    
    IllegalAccessException - An error has occured.
  - initializePlayer
```
public void initializePlayer(org.bukkit.entity.Player player)
```
    Initialize the player injector using an actual player instance.
    
    Parameters:
    
    player - - the player to hook.
  - initializeLogin
```
public void initializeLogin(Object netLoginHandler)
```
    Initialize the player injector from a NetLoginHandler.
    
    Parameters:
    
    netLoginHandler - - the net login handler to inject.
  - hasProxyServerHandler
```
protected boolean hasProxyServerHandler()
```
    Retrieve whether or not the server handler is a proxy object.
    
    Returns:
    
    TRUE if it is, FALSE otherwise.
  - getNetworkManager
```
public Object getNetworkManager()
```
    Retrieve the current network manager.
    
    Returns:
    
    Current network manager.
  - getServerHandler
```
public Object getServerHandler()
```
    Retrieve the current server handler (PlayerConnection).
    
    Returns:
    
    Current server handler.
  - setNetworkManager
```
public void setNetworkManager(Object value,
                              boolean force)
```
    Set the current network manager.
    
    Parameters:
    
    value - - new network manager.
    
    force - - whether or not to save this value.
  - getSocket
```
public Socket getSocket()
                 throws IllegalAccessException
```
    Retrieve the associated socket of this player.
    
    Specified by:
    
    getSocket in interface SocketInjector
    
    Returns:
    
    The associated socket.
    
    Throws:
    
    IllegalAccessException - If we're unable to read the socket field.
  - getAddress
```
public SocketAddress getAddress()
                         throws IllegalAccessException
```
    Retrieve the associated remote address of a player.
    
    Specified by:
    
    getAddress in interface SocketInjector
    
    Returns:
    
    The associated remote address.
    
    Throws:
    
    IllegalAccessException - If we're unable to read the socket address field.
  - disconnect
```
public void disconnect(String message)
                throws InvocationTargetException
```
    Attempt to disconnect the current client.
    
    Specified by:
    
    disconnect in interface SocketInjector
    
    Parameters:
    
    message - - the message to display.
    
    Throws:
    
    InvocationTargetException - If disconnection failed.
  - getNetHandler
```
protected Object getNetHandler()
                        throws IllegalAccessException
```
    Retrieves the current net handler for this player.
    
    Returns:
    
    Current net handler.
    
    Throws:
    
    IllegalAccessException - Unable to find or retrieve net handler.
  - getNetHandler
```
protected Object getNetHandler(boolean refresh)
                        throws IllegalAccessException
```
    Retrieves the current net handler for this player.
    
    Parameters:
    
    refresh - - Whether or not to refresh
    
    Returns:
    
    Current net handler.
    
    Throws:
    
    IllegalAccessException - Unable to find or retrieve net handler.
  - processPacket
```
public void processPacket(Object packet)
                   throws IllegalAccessException,
                          InvocationTargetException
```
    Processes the given packet as if it was transmitted by the current player.
    
    Parameters:
    
    packet - - packet to process.
    
    Throws:
    
    IllegalAccessException - If the reflection machinery failed.
    
    InvocationTargetException - If the underlying method caused an error.
  - sendServerPacket
```
public abstract void sendServerPacket(Object packet,
                                      NetworkMarker marker,
                                      boolean filtered)
                               throws InvocationTargetException
```
    Send a packet to the client.
    
    Specified by:
    
    sendServerPacket in interface SocketInjector
    
    Parameters:
    
    packet - - server packet to send.
    
    marker - - the network marker.
    
    filtered - - whether or not the packet will be filtered by our listeners.
    
    Throws:
    
    InvocationTargetException - If an error occured when sending the packet.
  - injectManager
```
public abstract void injectManager()
```
    Inject a hook to catch packets sent to the current player.
  - cleanupAll
```
public final void cleanupAll()
```
    Remove all hooks and modifications.
  - handleDisconnect
```
public abstract void handleDisconnect()
```
    Clean up after the player has disconnected.
  - cleanHook
```
protected abstract void cleanHook()
```
    Override to add custom cleanup behavior.
  - isClean
```
public boolean isClean()
```
    Determine whether or not this hook has already been cleaned.
    
    Returns:
    
    TRUE if it has, FALSE otherwise.
  - canInject
```
public abstract boolean canInject(GamePhase state)
```
    Determine if this inject method can even be attempted.
    
    Parameters:
    
    state - - Game phase
    
    Returns:
    
    TRUE if can be attempted, though possibly with failure, FALSE otherwise.
  - getHookType
```
public abstract PlayerInjectHooks getHookType()
```
    Retrieve the hook type this class represents.
    
    Returns:
    
    Hook type this class represents.
  - checkListener
```
public abstract com.comphenix.protocol.injector.player.UnsupportedListener checkListener(MinecraftVersion version,
                                                                                         PacketListener listener)
```
    Invoked before a new listener is registered.
    The player injector should only return a non-null value if some or all of the packet IDs are unsupported.
    
    Parameters:
    
    version - - the current Minecraft version, or NULL if unknown.
    
    listener - - the listener that is about to be registered.
    
    Returns:
    
    A error message with the unsupported packet IDs, or NULL if this listener is valid.
  - handlePacketSending
```
public Object handlePacketSending(Object packet)
```
    Allows a packet to be sent by the listeners.
    
    Parameters:
    
    packet - - packet to sent.
    
    Returns:
    
    The given packet, or the packet replaced by the listeners.
  - hasListener
```
protected abstract boolean hasListener(int packetID)
```
    Determine if the given injector is listening for this packet ID.
    
    Parameters:
    
    packetID - - packet ID to check.
    
    Returns:
    
    TRUE if it is, FALSE oterhwise.
  - getInputStream
```
public DataInputStream getInputStream(boolean cache)
```
    Retrieve the current player's input stream.
    
    Parameters:
    
    cache - - whether or not to cache the result of this method.
    
    Returns:
    
    The player's input stream.
  - getPlayer
```
public org.bukkit.entity.Player getPlayer()
```
    Retrieve the hooked player.
    
    Specified by:
    
    getPlayer in interface SocketInjector
    
    Returns:
    
    The hooked player.
  - setPlayer
```
public void setPlayer(org.bukkit.entity.Player player)
```
    Set the hooked player.
    Should only be called during the creation of the injector.
    
    Parameters:
    
    player - - the new hooked player.
  - getInvoker
```
public ListenerInvoker getInvoker()
```
    Object that can invoke the packet events.
    
    Returns:
    
    Packet event invoker.
  - getUpdatedPlayer
```
public org.bukkit.entity.Player getUpdatedPlayer()
```
    Retrieve the hooked player object OR the more up-to-date player instance.
    
    Specified by:
    
    getUpdatedPlayer in interface SocketInjector
    
    Returns:
    
    The hooked player, or a more up-to-date instance.
  - transferState
```
public void transferState(SocketInjector delegate)
```
    Description copied from interface: SocketInjector
    
    Invoked when a delegated socket injector transfers the state of one injector to the next.
    
    Specified by:
    
    transferState in interface SocketInjector
    
    Parameters:
    
    delegate - - the new injector.
  - setUpdatedPlayer
```
public void setUpdatedPlayer(org.bukkit.entity.Player updatedPlayer)
```
    Description copied from interface: SocketInjector
    
    Set the real Bukkit player that we will use.
    
    Specified by:
    
    setUpdatedPlayer in interface SocketInjector
    
    Parameters:
    
    updatedPlayer - - the real Bukkit player.

Class PlayerInjector

Nested Class Summary

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

REPORT_ASSUME_DISCONNECT_METHOD

REPORT_INVALID_ARGUMENT_DISCONNECT

REPORT_CANNOT_ACCESS_DISCONNECT

REPORT_CANNOT_CLOSE_SOCKET

REPORT_ACCESS_DENIED_CLOSE_SOCKET

REPORT_DETECTED_CUSTOM_SERVER_HANDLER

REPORT_CANNOT_PROXY_SERVER_HANDLER

REPORT_CANNOT_UPDATE_PLAYER

REPORT_CANNOT_HANDLE_PACKET

REPORT_INVALID_NETWORK_MANAGER

serverHandlerField

proxyServerField

networkManagerField

netHandlerField

socketField

socketAddressField

networkModifier

queueMethod

processMethod

player

hasInitialized

networkManagerRef

serverHandlerRef

networkManager

loginHandler

serverHandler

netHandler

socket

socketAddress

invoker

cachedInput

reporter

queuedMarkers

writePacketInterceptor

Constructor Detail

PlayerInjector

Method Detail

getEntityPlayer

initialize

initializePlayer

initializeLogin

hasProxyServerHandler

getNetworkManager

getServerHandler

setNetworkManager

getSocket

getAddress

disconnect

getNetHandler

getNetHandler

processPacket

sendServerPacket

injectManager

cleanupAll

handleDisconnect

cleanHook

isClean

canInject

getHookType

checkListener

handlePacketSending

hasListener

getInputStream

getPlayer

setPlayer

getInvoker

getUpdatedPlayer

transferState

setUpdatedPlayer