Http2EventAdapter (Netty API Reference (5.0.0.Alpha2))

java.lang.Object
- io.netty.handler.codec.http2.Http2EventAdapter

All Implemented Interfaces:

Http2Connection.Listener, Http2FrameListener

Direct Known Subclasses:

InboundHttp2ToHttpAdapter
```
public class Http2EventAdapter
extends Object
implements Http2Connection.Listener, Http2FrameListener
```
This class brings Http2Connection.Listener and Http2FrameListener together to provide NOOP implementation so inheriting classes can selectively choose which methods to override.

Constructor Summary

Constructors
Constructor and Description

Http2EventAdapter()

Constructors
Constructor and Description
`Http2EventAdapter()`

Method Summary

Methods
Modifier and Type	Method and Description
`void`	`goingAway()` Called when a GO_AWAY frame has either been sent or received for the connection.
`int`	`onDataRead(ChannelHandlerContext ctx, int streamId, ByteBuf data, int padding, boolean endOfStream)` Handles an inbound `DATA` frame.
`void`	`onGoAwayRead(ChannelHandlerContext ctx, int lastStreamId, long errorCode, ByteBuf debugData)` Handles an inbound GO_AWAY frame.
`void`	`onHeadersRead(ChannelHandlerContext ctx, int streamId, Http2Headers headers, int padding, boolean endStream)` Handles an inbound HEADERS frame.
`void`	`onHeadersRead(ChannelHandlerContext ctx, int streamId, Http2Headers headers, int streamDependency, short weight, boolean exclusive, int padding, boolean endStream)` Handles an inbound HEADERS frame with priority information specified.
`void`	`onPingAckRead(ChannelHandlerContext ctx, ByteBuf data)` Handles an inbound PING acknowledgment.
`void`	`onPingRead(ChannelHandlerContext ctx, ByteBuf data)` Handles an inbound PING frame.
`void`	`onPriorityRead(ChannelHandlerContext ctx, int streamId, int streamDependency, short weight, boolean exclusive)` Handles an inbound PRIORITY frame.
`void`	`onPushPromiseRead(ChannelHandlerContext ctx, int streamId, int promisedStreamId, Http2Headers headers, int padding)` Handles an inbound PUSH_PROMISE frame.
`void`	`onRstStreamRead(ChannelHandlerContext ctx, int streamId, long errorCode)` Handles an inbound RST_STREAM frame.
`void`	`onSettingsAckRead(ChannelHandlerContext ctx)` Handles an inbound SETTINGS acknowledgment frame.
`void`	`onSettingsRead(ChannelHandlerContext ctx, Http2Settings settings)` Handles an inbound SETTINGS frame.
`void`	`onUnknownFrame(ChannelHandlerContext ctx, byte frameType, int streamId, Http2Flags flags, ByteBuf payload)` Handler for a frame not defined by the HTTP/2 spec.
`void`	`onWeightChanged(Http2Stream stream, short oldWeight)` Notifies the listener that the weight has changed for `stream`
`void`	`onWindowUpdateRead(ChannelHandlerContext ctx, int streamId, int windowSizeIncrement)` Handles an inbound WINDOW_UPDATE frame.
`void`	`priorityTreeParentChanged(Http2Stream stream, Http2Stream oldParent)` Notifies the listener that a priority tree parent change has occurred.
`void`	`priorityTreeParentChanging(Http2Stream stream, Http2Stream newParent)` Notifies the listener that a parent dependency is about to change This is called while the tree is being restructured and so the tree structure is not necessarily steady state.
`void`	`streamActive(Http2Stream stream)` Notifies the listener that the given stream was made active (i.e. open in at least one direction).
`void`	`streamAdded(Http2Stream stream)` Notifies the listener that the given stream was added to the connection.
`void`	`streamHalfClosed(Http2Stream stream)` Notifies the listener that the given stream is now half-closed.
`void`	`streamInactive(Http2Stream stream)` Notifies the listener that the given stream is now closed in both directions.
`void`	`streamRemoved(Http2Stream stream)` Notifies the listener that the given stream has now been removed from the connection and will no longer be returned via `Http2Connection.stream(int)`.

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

- Constructor Detail
  - Http2EventAdapter
```
public Http2EventAdapter()
```
- Method Detail
  - onDataRead
```
public int onDataRead(ChannelHandlerContext ctx,
             int streamId,
             ByteBuf data,
             int padding,
             boolean endOfStream)
               throws Http2Exception
```
    Description copied from interface: Http2FrameListener
    
    Handles an inbound DATA frame.
    
    Specified by:
    
    onDataRead in interface Http2FrameListener
    
    Parameters:
    ctx - the context from the handler where the frame was read.
    streamId - the subject stream for the frame.
    data - payload buffer for the frame. This buffer will be released by the codec.
    padding - the number of padding bytes found at the end of the frame.
    endOfStream - Indicates whether this is the last frame to be sent from the remote endpoint for this stream.
    
    Returns:
    the number of bytes that have been processed by the application. The returned bytes are used by the inbound flow controller to determine the appropriate time to expand the inbound flow control window (i.e. send WINDOW_UPDATE). Returning a value equal to the length of data + padding will effectively opt-out of application-level flow control for this frame. Returning a value less than the length of data + padding will defer the returning of the processed bytes, which the application must later return via Http2InboundFlowState#returnProcessedBytes(ChannelHandlerContext, int). The returned value must be >= 0 and <= data.readableBytes() + padding.
    
    Throws:
    
    Http2Exception
  - onHeadersRead
```
public void onHeadersRead(ChannelHandlerContext ctx,
                 int streamId,
                 Http2Headers headers,
                 int padding,
                 boolean endStream)
                   throws Http2Exception
```
    Description copied from interface: Http2FrameListener
    Handles an inbound HEADERS frame.
    Only one of the following methods will be called for each HEADERS frame sequence. One will be called when the END_HEADERS flag has been received.
    To say it another way; the Http2Headers will contain all of the headers for the current message exchange step (additional queuing is not necessary).
    Specified by:
    
    onHeadersRead in interface Http2FrameListener
    
    Parameters:
    ctx - the context from the handler where the frame was read.
    streamId - the subject stream for the frame.
    headers - the received headers.
    padding - the number of padding bytes found at the end of the frame.
    endStream - Indicates whether this is the last frame to be sent from the remote endpoint for this stream.
    
    Throws:
    
    Http2Exception
  - onHeadersRead
```
public void onHeadersRead(ChannelHandlerContext ctx,
                 int streamId,
                 Http2Headers headers,
                 int streamDependency,
                 short weight,
                 boolean exclusive,
                 int padding,
                 boolean endStream)
                   throws Http2Exception
```
    Description copied from interface: Http2FrameListener
    Handles an inbound HEADERS frame with priority information specified. Only called if END_HEADERS encountered.
    Only one of the following methods will be called for each HEADERS frame sequence. One will be called when the END_HEADERS flag has been received.
    To say it another way; the Http2Headers will contain all of the headers for the current message exchange step (additional queuing is not necessary).
    Specified by:
    
    onHeadersRead in interface Http2FrameListener
    
    Parameters:
    ctx - the context from the handler where the frame was read.
    streamId - the subject stream for the frame.
    headers - the received headers.
    streamDependency - the stream on which this stream depends, or 0 if dependent on the connection.
    weight - the new weight for the stream.
    exclusive - whether or not the stream should be the exclusive dependent of its parent.
    padding - the number of padding bytes found at the end of the frame.
    endStream - Indicates whether this is the last frame to be sent from the remote endpoint for this stream.
    
    Throws:
    
    Http2Exception
  - onPriorityRead
```
public void onPriorityRead(ChannelHandlerContext ctx,
                  int streamId,
                  int streamDependency,
                  short weight,
                  boolean exclusive)
                    throws Http2Exception
```
    Description copied from interface: Http2FrameListener
    
    Handles an inbound PRIORITY frame.
    
    Specified by:
    
    onPriorityRead in interface Http2FrameListener
    
    Parameters:
    ctx - the context from the handler where the frame was read.
    streamId - the subject stream for the frame.
    streamDependency - the stream on which this stream depends, or 0 if dependent on the connection.
    weight - the new weight for the stream.
    exclusive - whether or not the stream should be the exclusive dependent of its parent.
    
    Throws:
    
    Http2Exception
  - onRstStreamRead
```
public void onRstStreamRead(ChannelHandlerContext ctx,
                   int streamId,
                   long errorCode)
                     throws Http2Exception
```
    Description copied from interface: Http2FrameListener
    
    Handles an inbound RST_STREAM frame.
    
    Specified by:
    
    onRstStreamRead in interface Http2FrameListener
    
    Parameters:
    ctx - the context from the handler where the frame was read.
    streamId - the stream that is terminating.
    errorCode - the error code identifying the type of failure.
    
    Throws:
    
    Http2Exception
  - onSettingsAckRead
```
public void onSettingsAckRead(ChannelHandlerContext ctx)
                       throws Http2Exception
```
    Description copied from interface: Http2FrameListener
    
    Handles an inbound SETTINGS acknowledgment frame.
    
    Specified by:
    
    onSettingsAckRead in interface Http2FrameListener
    
    Parameters:
    ctx - the context from the handler where the frame was read.
    
    Throws:
    
    Http2Exception
  - onSettingsRead
```
public void onSettingsRead(ChannelHandlerContext ctx,
                  Http2Settings settings)
                    throws Http2Exception
```
    Description copied from interface: Http2FrameListener
    
    Handles an inbound SETTINGS frame.
    
    Specified by:
    
    onSettingsRead in interface Http2FrameListener
    
    Parameters:
    ctx - the context from the handler where the frame was read.
    settings - the settings received from the remote endpoint.
    
    Throws:
    
    Http2Exception
  - onPingRead
```
public void onPingRead(ChannelHandlerContext ctx,
              ByteBuf data)
                throws Http2Exception
```
    Description copied from interface: Http2FrameListener
    
    Handles an inbound PING frame.
    
    Specified by:
    
    onPingRead in interface Http2FrameListener
    
    Parameters:
    ctx - the context from the handler where the frame was read.
    data - the payload of the frame. If this buffer needs to be retained by the listener they must make a copy.
    
    Throws:
    
    Http2Exception
  - onPingAckRead
```
public void onPingAckRead(ChannelHandlerContext ctx,
                 ByteBuf data)
                   throws Http2Exception
```
    Description copied from interface: Http2FrameListener
    
    Handles an inbound PING acknowledgment.
    
    Specified by:
    
    onPingAckRead in interface Http2FrameListener
    
    Parameters:
    ctx - the context from the handler where the frame was read.
    data - the payload of the frame. If this buffer needs to be retained by the listener they must make a copy.
    
    Throws:
    
    Http2Exception
  - onPushPromiseRead
```
public void onPushPromiseRead(ChannelHandlerContext ctx,
                     int streamId,
                     int promisedStreamId,
                     Http2Headers headers,
                     int padding)
                       throws Http2Exception
```
    Description copied from interface: Http2FrameListener
    Handles an inbound PUSH_PROMISE frame. Only called if END_HEADERS encountered.
    Promised requests MUST be cacheable (see [RFC7231], Section 4.2.3) and MUST be safe (see [RFC7231], Section 4.2.1). If these conditions do not hold the application MUST throw a Http2Exception.StreamException with error type Http2Error.PROTOCOL_ERROR.
    Only one of the following methods will be called for each HEADERS frame sequence. One will be called when the END_HEADERS flag has been received.
    To say it another way; the Http2Headers will contain all of the headers for the current message exchange step (additional queuing is not necessary).
    Specified by:
    
    onPushPromiseRead in interface Http2FrameListener
    
    Parameters:
    ctx - the context from the handler where the frame was read.
    streamId - the stream the frame was sent on.
    promisedStreamId - the ID of the promised stream.
    headers - the received headers.
    padding - the number of padding bytes found at the end of the frame.
    
    Throws:
    
    Http2Exception
  - onGoAwayRead
```
public void onGoAwayRead(ChannelHandlerContext ctx,
                int lastStreamId,
                long errorCode,
                ByteBuf debugData)
                  throws Http2Exception
```
    Description copied from interface: Http2FrameListener
    
    Handles an inbound GO_AWAY frame.
    
    Specified by:
    
    onGoAwayRead in interface Http2FrameListener
    
    Parameters:
    ctx - the context from the handler where the frame was read.
    lastStreamId - the last known stream of the remote endpoint.
    errorCode - the error code, if abnormal closure.
    debugData - application-defined debug data. If this buffer needs to be retained by the listener they must make a copy.
    
    Throws:
    
    Http2Exception
  - onWindowUpdateRead
```
public void onWindowUpdateRead(ChannelHandlerContext ctx,
                      int streamId,
                      int windowSizeIncrement)
                        throws Http2Exception
```
    Description copied from interface: Http2FrameListener
    
    Handles an inbound WINDOW_UPDATE frame.
    
    Specified by:
    
    onWindowUpdateRead in interface Http2FrameListener
    
    Parameters:
    ctx - the context from the handler where the frame was read.
    streamId - the stream the frame was sent on.
    windowSizeIncrement - the increased number of bytes of the remote endpoint's flow control window.
    
    Throws:
    
    Http2Exception
  - onUnknownFrame
```
public void onUnknownFrame(ChannelHandlerContext ctx,
                  byte frameType,
                  int streamId,
                  Http2Flags flags,
                  ByteBuf payload)
```
    Description copied from interface: Http2FrameListener
    
    Handler for a frame not defined by the HTTP/2 spec.
    
    Specified by:
    
    onUnknownFrame in interface Http2FrameListener
    
    Parameters:
    ctx - the context from the handler where the frame was read.
    frameType - the frame type from the HTTP/2 header.
    streamId - the stream the frame was sent on.
    flags - the flags in the frame header.
    payload - the payload of the frame.
  - streamAdded
```
public void streamAdded(Http2Stream stream)
```
    Description copied from interface: Http2Connection.Listener
    
    Notifies the listener that the given stream was added to the connection. This stream may not yet be active (i.e. open/half-closed).
    
    Specified by:
    
    streamAdded in interface Http2Connection.Listener
  - streamActive
```
public void streamActive(Http2Stream stream)
```
    Description copied from interface: Http2Connection.Listener
    
    Notifies the listener that the given stream was made active (i.e. open in at least one direction).
    
    Specified by:
    
    streamActive in interface Http2Connection.Listener
  - streamHalfClosed
```
public void streamHalfClosed(Http2Stream stream)
```
    Description copied from interface: Http2Connection.Listener
    
    Notifies the listener that the given stream is now half-closed. The stream can be inspected to determine which side is closed.
    
    Specified by:
    
    streamHalfClosed in interface Http2Connection.Listener
  - streamInactive
```
public void streamInactive(Http2Stream stream)
```
    Description copied from interface: Http2Connection.Listener
    
    Notifies the listener that the given stream is now closed in both directions.
    
    Specified by:
    
    streamInactive in interface Http2Connection.Listener
  - streamRemoved
```
public void streamRemoved(Http2Stream stream)
```
    Description copied from interface: Http2Connection.Listener
    
    Notifies the listener that the given stream has now been removed from the connection and will no longer be returned via Http2Connection.stream(int). The connection may maintain inactive streams for some time before removing them.
    
    Specified by:
    
    streamRemoved in interface Http2Connection.Listener
  - priorityTreeParentChanged
```
public void priorityTreeParentChanged(Http2Stream stream,
                             Http2Stream oldParent)
```
    Description copied from interface: Http2Connection.Listener
    
    Notifies the listener that a priority tree parent change has occurred. This method will be invoked in a top down order relative to the priority tree. This method will also be invoked after all tree structure changes have been made and the tree is in steady state relative to the priority change which caused the tree structure to change.
    
    Specified by:
    
    priorityTreeParentChanged in interface Http2Connection.Listener
    
    Parameters:
    stream - The stream which had a parent change (new parent and children will be steady state)
    oldParent - The old parent which stream used to be a child of (may be null)
  - priorityTreeParentChanging
```
public void priorityTreeParentChanging(Http2Stream stream,
                              Http2Stream newParent)
```
    Description copied from interface: Http2Connection.Listener
    
    Notifies the listener that a parent dependency is about to change This is called while the tree is being restructured and so the tree structure is not necessarily steady state.
    
    Specified by:
    
    priorityTreeParentChanging in interface Http2Connection.Listener
    
    Parameters:
    stream - The stream which the parent is about to change to newParent
    newParent - The stream which will be the parent of stream
  - onWeightChanged
```
public void onWeightChanged(Http2Stream stream,
                   short oldWeight)
```
    Description copied from interface: Http2Connection.Listener
    
    Notifies the listener that the weight has changed for stream
    
    Specified by:
    
    onWeightChanged in interface Http2Connection.Listener
    
    Parameters:
    stream - The stream which the weight has changed
    oldWeight - The old weight for stream
  - goingAway
```
public void goingAway()
```
    Description copied from interface: Http2Connection.Listener
    
    Called when a GO_AWAY frame has either been sent or received for the connection.
    
    Specified by:
    
    goingAway in interface Http2Connection.Listener

Class Http2EventAdapter

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

Http2EventAdapter

Method Detail

onDataRead

onHeadersRead

onHeadersRead

onPriorityRead

onRstStreamRead

onSettingsAckRead

onSettingsRead

onPingRead

onPingAckRead

onPushPromiseRead

onGoAwayRead

onWindowUpdateRead

onUnknownFrame

streamAdded

streamActive

streamHalfClosed

streamInactive

streamRemoved

priorityTreeParentChanged

priorityTreeParentChanging

onWeightChanged

goingAway