io.vertx.rxjava.mqtt

## Class MqttEndpoint

- java.lang.Object
- - io.vertx.rxjava.mqtt.MqttEndpoint

-     public class MqttEndpoint
      extends Object

  Represents an MQTT endpoint for point-to-point communication with the remote MQTT client

  NOTE: This class has been automatically generated from the `original` non RX-ified interface using Vert.x codegen.

- - ### Field Summary

    Fields
    Modifier and Type | Field and Description
    --- | ---
    `static io.vertx.lang.rx.TypeArg<MqttEndpoint>` | `__TYPE_ARG`

  - ### Constructor Summary

    Constructors
    Constructor and Description
    `MqttEndpoint(MqttEndpoint delegate)`
    `MqttEndpoint(Object delegate)`

  - ### Method Summary

    All Methods Static Methods Instance Methods Concrete Methods
    Modifier and Type | Method and Description
    --- | ---
    `MqttEndpoint` | `accept()` Like `accept()` with no session is present.
    `MqttEndpoint` | `accept(boolean sessionPresent)` Sends the CONNACK message to the remote MQTT client with "connection accepted" return code.
    `MqttEndpoint` | `accept(boolean sessionPresent, io.netty.handler.codec.mqtt.MqttProperties properties)` Sends the CONNACK message to the remote MQTT client with "connection accepted" return code.
    `MqttAuth` | `auth()`
    `MqttEndpoint` | `autoKeepAlive(boolean isAutoKeepAlive)` Enable/disable auto keep alive (sending ping response)
    `String` | `clientIdentifier()`
    `void` | `close()` Close the endpoint, so the connection with remote MQTT client
    `MqttEndpoint` | `closeHandler(Handler<Void> handler)` Set a close handler.
    `io.netty.handler.codec.mqtt.MqttProperties` | `connectProperties()`
    `MqttEndpoint` | `disconnect(MqttDisconnectReasonCode code, io.netty.handler.codec.mqtt.MqttProperties properties)` Sends the DISCONNECT message to the remote MQTT client
    `MqttEndpoint` | `disconnectHandler(Handler<Void> handler)` Set a disconnect handler on the MQTT endpoint.
    `MqttEndpoint` | `disconnectMessageHandler(Handler<MqttDisconnectMessage> handler)` Set a disconnect handler on the MQTT endpoint.
    `boolean` | `equals(Object o)`
    `MqttEndpoint` | `exceptionHandler(Handler<Throwable> handler)` Set an exception handler.
    `MqttEndpoint` | `getDelegate()`
    `int` | `hashCode()`
    `MultiMap` | `httpHeaders()` Returns the HTTP headers sent by the client when a WebSocket transport is used otherwise `null`
    `String` | `httpRequestURI()` Returns the HTTP request URI sent by the client when a WebSocket transport is used otherwise `null`
    `boolean` | `isAutoKeepAlive()`
    `boolean` | `isCleanSession()`
    `boolean` | `isConnected()`
    `boolean` | `isPublishAutoAck()`
    `boolean` | `isSsl()`
    `boolean` | `isSubscriptionAutoAck()`
    `int` | `keepAliveTimeSeconds()`
    `int` | `lastMessageId()`
    `SocketAddress` | `localAddress()`
    `static MqttEndpoint` | `newInstance(MqttEndpoint arg)`
    `MqttEndpoint` | `pingHandler(Handler<Void> handler)` Set the pingreq handler on the MQTT endpoint.
    `MqttEndpoint` | `pong()` Sends the PINGRESP message to the remote MQTT client
    `String` | `protocolName()`
    `int` | `protocolVersion()`
    `MqttEndpoint` | `publish(String topic, Buffer payload, io.netty.handler.codec.mqtt.MqttQoS qosLevel, boolean isDup, boolean isRetain)` Sends the PUBLISH message to the remote MQTT server
    `MqttEndpoint` | `publish(String topic, Buffer payload, io.netty.handler.codec.mqtt.MqttQoS qosLevel, boolean isDup, boolean isRetain, Handler<AsyncResult<Integer>> publishSentHandler)` Sends the PUBLISH message to the remote MQTT server
    `MqttEndpoint` | `publish(String topic, Buffer payload, io.netty.handler.codec.mqtt.MqttQoS qosLevel, boolean isDup, boolean isRetain, int messageId)` Sends the PUBLISH message to the remote MQTT server explicitly specifying the messageId
    `MqttEndpoint` | `publish(String topic, Buffer payload, io.netty.handler.codec.mqtt.MqttQoS qosLevel, boolean isDup, boolean isRetain, int messageId, Handler<AsyncResult<Integer>> publishSentHandler)` Sends the PUBLISH message to the remote MQTT server explicitly specifying the messageId
    `MqttEndpoint` | `publish(String topic, Buffer payload, io.netty.handler.codec.mqtt.MqttQoS qosLevel, boolean isDup, boolean isRetain, int messageId, io.netty.handler.codec.mqtt.MqttProperties properties)` Sends the PUBLISH message to the remote MQTT server explicitly specifying the messageId
    `MqttEndpoint` | `publish(String topic, Buffer payload, io.netty.handler.codec.mqtt.MqttQoS qosLevel, boolean isDup, boolean isRetain, int messageId, io.netty.handler.codec.mqtt.MqttProperties properties, Handler<AsyncResult<Integer>> publishSentHandler)` Sends the PUBLISH message to the remote MQTT server explicitly specifying the messageId
    `MqttEndpoint` | `publishAcknowledge(int publishMessageId)` Sends the PUBACK message to the remote MQTT client
    `MqttEndpoint` | `publishAcknowledge(int publishMessageId, MqttPubAckReasonCode reasonCode, io.netty.handler.codec.mqtt.MqttProperties properties)`
    `MqttEndpoint` | `publishAcknowledgeHandler(Handler<Integer> handler)` Set the puback handler on the MQTT endpoint.
    `MqttEndpoint` | `publishAcknowledgeMessageHandler(Handler<MqttPubAckMessage> handler)` Set the puback handler on the MQTT endpoint.
    `MqttEndpoint` | `publishAutoAck(boolean isPublishAutoAck)` Enable/disable publishing (in/out) auto acknowledge
    `MqttEndpoint` | `publishComplete(int publishMessageId)` Sends the PUBCOMP message to the remote MQTT client
    `MqttEndpoint` | `publishComplete(int publishMessageId, MqttPubCompReasonCode reasonCode, io.netty.handler.codec.mqtt.MqttProperties properties)` Sends the PUBCOMP message to the remote MQTT client
    `MqttEndpoint` | `publishCompletionHandler(Handler<Integer> handler)` Set the pubcomp handler on the MQTT endpoint.
    `MqttEndpoint` | `publishCompletionMessageHandler(Handler<MqttPubCompMessage> handler)` Set the pubcomp handler on the MQTT endpoint.
    `MqttEndpoint` | `publishHandler(Handler<MqttPublishMessage> handler)` Set the publish handler on the MQTT endpoint.
    `MqttEndpoint` | `publishReceived(int publishMessageId)` Sends the PUBREC message to the remote MQTT client
    `MqttEndpoint` | `publishReceived(int publishMessageId, MqttPubRecReasonCode reasonCode, io.netty.handler.codec.mqtt.MqttProperties properties)` Sends the PUBREC message to the remote MQTT client
    `MqttEndpoint` | `publishReceivedHandler(Handler<Integer> handler)` Set the pubrec handler on the MQTT endpoint.
    `MqttEndpoint` | `publishReceivedMessageHandler(Handler<MqttPubRecMessage> handler)` Set the pubrec handler on the MQTT endpoint.
    `MqttEndpoint` | `publishRelease(int publishMessageId)` Sends the PUBREL message to the remote MQTT client
    `MqttEndpoint` | `publishRelease(int publishMessageId, MqttPubRelReasonCode reasonCode, io.netty.handler.codec.mqtt.MqttProperties properties)` Sends the PUBREL message to the remote MQTT client
    `MqttEndpoint` | `publishReleaseHandler(Handler<Integer> handler)` Set the pubrel handler on the MQTT endpoint.
    `MqttEndpoint` | `publishReleaseMessageHandler(Handler<MqttPubRelMessage> handler)` Set the pubrel handler on the MQTT endpoint.
    `MqttEndpoint` | `reject(io.netty.handler.codec.mqtt.MqttConnectReturnCode returnCode)` Sends the CONNACK message to the remote MQTT client rejecting the connection request with specified return code.
    `MqttEndpoint` | `reject(io.netty.handler.codec.mqtt.MqttConnectReturnCode returnCode, io.netty.handler.codec.mqtt.MqttProperties properties)` Sends the CONNACK message to the remote MQTT client rejecting the connection request with specified return code.
    `SocketAddress` | `remoteAddress()`
    `Single<Integer>` | `rxPublish(String topic, Buffer payload, io.netty.handler.codec.mqtt.MqttQoS qosLevel, boolean isDup, boolean isRetain)` Sends the PUBLISH message to the remote MQTT server
    `Single<Integer>` | `rxPublish(String topic, Buffer payload, io.netty.handler.codec.mqtt.MqttQoS qosLevel, boolean isDup, boolean isRetain, int messageId)` Sends the PUBLISH message to the remote MQTT server explicitly specifying the messageId
    `Single<Integer>` | `rxPublish(String topic, Buffer payload, io.netty.handler.codec.mqtt.MqttQoS qosLevel, boolean isDup, boolean isRetain, int messageId, io.netty.handler.codec.mqtt.MqttProperties properties)` Sends the PUBLISH message to the remote MQTT server explicitly specifying the messageId
    `MqttEndpoint` | `setClientIdentifier(String clientIdentifier)` Set client identifier if not provided by the remote MQTT client (zero-bytes)
    `MqttEndpoint` | `subscribeAcknowledge(int subscribeMessageId, List<io.netty.handler.codec.mqtt.MqttQoS> grantedQoSLevels)` Sends the SUBACK message to the remote MQTT client
    `MqttEndpoint` | `subscribeAcknowledge(int subscribeMessageId, List<MqttSubAckReasonCode> reasonCodes, io.netty.handler.codec.mqtt.MqttProperties properties)` Sends the SUBACK message to the remote MQTT client
    `MqttEndpoint` | `subscribeHandler(Handler<MqttSubscribeMessage> handler)` Set a subscribe handler on the MQTT endpoint.
    `void` | `subscriptionAutoAck(boolean isSubscriptionAutoAck)` Enable/disable subscription/unsubscription requests auto acknowledge
    `String` | `toString()`
    `MqttEndpoint` | `unsubscribeAcknowledge(int unsubscribeMessageId)` Sends the UNSUBACK message to the remote MQTT client
    `MqttEndpoint` | `unsubscribeAcknowledge(int unsubscribeMessageId, List<MqttUnsubAckReasonCode> reasonCodes, io.netty.handler.codec.mqtt.MqttProperties properties)` Sends the UNSUBACK message to the remote MQTT client
    `MqttEndpoint` | `unsubscribeHandler(Handler<MqttUnsubscribeMessage> handler)` Set a unsubscribe handler on the MQTT endpoint.
    `MqttWill` | `will()`

    - ### Methods inherited from class java.lang.Object

      `clone, finalize, getClass, notify, notifyAll, wait, wait, wait`

- - ### Field Detail

    - #### __TYPE_ARG

          public static final io.vertx.lang.rx.TypeArg<MqttEndpoint> __TYPE_ARG

  - ### Constructor Detail

    - #### MqttEndpoint

          public MqttEndpoint(MqttEndpoint delegate)

    - #### MqttEndpoint

          public MqttEndpoint(Object delegate)

  - ### Method Detail

    - #### toString

          public String toString()

      Overrides:
        `toString` in class `Object`

    - #### equals

          public boolean equals(Object o)

      Overrides:
        `equals` in class `Object`

    - #### hashCode

          public int hashCode()

      Overrides:
        `hashCode` in class `Object`

    - #### getDelegate

          public MqttEndpoint getDelegate()

    - #### close

          public void close()

      Close the endpoint, so the connection with remote MQTT client

    - #### remoteAddress

          public SocketAddress remoteAddress()

      Returns:
        the remote address for this socket

    - #### localAddress

          public SocketAddress localAddress()

      Returns:
        the local address for this socket

    - #### isSsl

          public boolean isSsl()

      Returns:
        true if this `MqttEndpoint` is encrypted via SSL/TLS.

    - #### httpHeaders

          public MultiMap httpHeaders()

      Returns the HTTP headers sent by the client when a WebSocket transport is used otherwise `null`
      Returns:
        the HTTP headers

    - #### httpRequestURI

          public String httpRequestURI()

      Returns the HTTP request URI sent by the client when a WebSocket transport is used otherwise `null`
      Returns:
        the HTTP request uri

    - #### clientIdentifier

          public String clientIdentifier()

      Returns:
        the client identifier as provided by the remote MQTT client

    - #### auth

          public MqttAuth auth()

      Returns:
        the Authentication information as provided by the remote MQTT client

    - #### will

          public MqttWill will()

      Returns:
        the Will information as provided by the remote MQTT client

    - #### protocolVersion

          public int protocolVersion()

      Returns:
        the protocol version required by the remote MQTT client

    - #### protocolName

          public String protocolName()

      Returns:
        the protocol name provided by the remote MQTT client

    - #### isCleanSession

          public boolean isCleanSession()

      Returns:
        true when clean session is requested by the remote MQTT client

    - #### keepAliveTimeSeconds

          public int keepAliveTimeSeconds()

      Returns:
        the keep alive timeout (in seconds) specified by the remote MQTT client

    - #### lastMessageId

          public int lastMessageId()

      Returns:
        the message identifier used for last published message

    - #### subscriptionAutoAck

          public void subscriptionAutoAck(boolean isSubscriptionAutoAck)

      Enable/disable subscription/unsubscription requests auto acknowledge
      Parameters:
        `isSubscriptionAutoAck` - auto acknowledge status

    - #### isSubscriptionAutoAck

          public boolean isSubscriptionAutoAck()

      Returns:
        true when auto acknowledge status for subscription/unsubscription requests

    - #### publishAutoAck

          public MqttEndpoint publishAutoAck(boolean isPublishAutoAck)

      Enable/disable publishing (in/out) auto acknowledge
      Parameters:
        `isPublishAutoAck` - auto acknowledge status
      Returns:
        a reference to this, so the API can be used fluently

    - #### isPublishAutoAck

          public boolean isPublishAutoAck()

      Returns:
        auto acknowledge status for publishing (in/out)

    - #### autoKeepAlive

          public MqttEndpoint autoKeepAlive(boolean isAutoKeepAlive)

      Enable/disable auto keep alive (sending ping response)
      Parameters:
        `isAutoKeepAlive` - auto keep alive
      Returns:
        a reference to this, so the API can be used fluently

    - #### isAutoKeepAlive

          public boolean isAutoKeepAlive()

      Returns:
        the auto keep alive status (sending ping response)

    - #### isConnected

          public boolean isConnected()

      Returns:
        if the connection between remote client and local endpoint is established/open

    - #### setClientIdentifier

          public MqttEndpoint setClientIdentifier(String clientIdentifier)

      Set client identifier if not provided by the remote MQTT client (zero-bytes)
      Parameters:
        `clientIdentifier` - the client identifier
      Returns:
        a reference to this, so the API can be used fluently

    - #### disconnectHandler

          public MqttEndpoint disconnectHandler(Handler<Void> handler)

      Set a disconnect handler on the MQTT endpoint. This handler is called when a DISCONNECT message is received by the remote MQTT client
      Parameters:
        `handler` - the handler
      Returns:
        a reference to this, so the API can be used fluently

    - #### disconnectMessageHandler

          public MqttEndpoint disconnectMessageHandler(Handler<MqttDisconnectMessage> handler)

      Set a disconnect handler on the MQTT endpoint. This handler is called when a DISCONNECT message is received by the remote MQTT client
      Parameters:
        `handler` - the handler
      Returns:
        a reference to this, so the API can be used fluently

    - #### subscribeHandler

          public MqttEndpoint subscribeHandler(Handler<MqttSubscribeMessage> handler)

      Set a subscribe handler on the MQTT endpoint. This handler is called when a SUBSCRIBE message is received by the remote MQTT client
      Parameters:
        `handler` - the handler
      Returns:
        a reference to this, so the API can be used fluently

    - #### unsubscribeHandler

          public MqttEndpoint unsubscribeHandler(Handler<MqttUnsubscribeMessage> handler)

      Set a unsubscribe handler on the MQTT endpoint. This handler is called when a UNSUBSCRIBE message is received by the remote MQTT client
      Parameters:
        `handler` - the handler
      Returns:
        a reference to this, so the API can be used fluently

    - #### publishHandler

          public MqttEndpoint publishHandler(Handler<MqttPublishMessage> handler)

      Set the publish handler on the MQTT endpoint. This handler is called when a PUBLISH message is received by the remote MQTT client
      Parameters:
        `handler` - the handler
      Returns:
        a reference to this, so the API can be used fluently

    - #### publishAcknowledgeHandler

          public MqttEndpoint publishAcknowledgeHandler(Handler<Integer> handler)

      Set the puback handler on the MQTT endpoint. This handler is called when a PUBACK message is received by the remote MQTT client
      Parameters:
        `handler` - the handler
      Returns:
        a reference to this, so the API can be used fluently

    - #### publishAcknowledgeMessageHandler

          public MqttEndpoint publishAcknowledgeMessageHandler(Handler<MqttPubAckMessage> handler)

      Set the puback handler on the MQTT endpoint. This handler is called when a PUBACK message is received by the remote MQTT client
      Parameters:
        `handler` - the handler
      Returns:
        a reference to this, so the API can be used fluently

    - #### publishReceivedHandler

          public MqttEndpoint publishReceivedHandler(Handler<Integer> handler)

      Set the pubrec handler on the MQTT endpoint. This handler is called when a PUBREC message is received by the remote MQTT client
      Parameters:
        `handler` - the handler
      Returns:
        a reference to this, so the API can be used fluently

    - #### publishReceivedMessageHandler

          public MqttEndpoint publishReceivedMessageHandler(Handler<MqttPubRecMessage> handler)

      Set the pubrec handler on the MQTT endpoint. This handler is called when a PUBREC message is received by the remote MQTT client
      Parameters:
        `handler` - the handler
      Returns:
        a reference to this, so the API can be used fluently

    - #### publishReleaseHandler

          public MqttEndpoint publishReleaseHandler(Handler<Integer> handler)

      Set the pubrel handler on the MQTT endpoint. This handler is called when a PUBREL message is received by the remote MQTT client
      Parameters:
        `handler` - the handler
      Returns:
        a reference to this, so the API can be used fluently

    - #### publishReleaseMessageHandler

          public MqttEndpoint publishReleaseMessageHandler(Handler<MqttPubRelMessage> handler)

      Set the pubrel handler on the MQTT endpoint. This handler is called when a PUBREL message is received by the remote MQTT client
      Parameters:
        `handler` - the handler
      Returns:
        a reference to this, so the API can be used fluently

    - #### publishCompletionHandler

          public MqttEndpoint publishCompletionHandler(Handler<Integer> handler)

      Set the pubcomp handler on the MQTT endpoint. This handler is called when a PUBCOMP message is received by the remote MQTT client
      Parameters:
        `handler` - the handler
      Returns:
        a reference to this, so the API can be used fluently

    - #### publishCompletionMessageHandler

          public MqttEndpoint publishCompletionMessageHandler(Handler<MqttPubCompMessage> handler)

      Set the pubcomp handler on the MQTT endpoint. This handler is called when a PUBCOMP message is received by the remote MQTT client
      Parameters:
        `handler` - the handler
      Returns:
        a reference to this, so the API can be used fluently

    - #### pingHandler

          public MqttEndpoint pingHandler(Handler<Void> handler)

      Set the pingreq handler on the MQTT endpoint. This handler is called when a PINGREQ message is received by the remote MQTT client. In any case the endpoint sends the PINGRESP internally after executing this handler.
      Parameters:
        `handler` - the handler
      Returns:
        a reference to this, so the API can be used fluently

    - #### closeHandler

          public MqttEndpoint closeHandler(Handler<Void> handler)

      Set a close handler. This will be called when the MQTT endpoint is closed
      Parameters:
        `handler` - the handler
      Returns:
        a reference to this, so the API can be used fluently

    - #### exceptionHandler

          public MqttEndpoint exceptionHandler(Handler<Throwable> handler)

      Set an exception handler. This will be called when an error at protocol level happens
      Parameters:
        `handler` - the handler
      Returns:
        a reference to this, so the API can be used fluently

    - #### accept

          public MqttEndpoint accept()

      Like `accept()` with no session is present.
      Returns:

    - #### accept

          public MqttEndpoint accept(boolean sessionPresent)

      Sends the CONNACK message to the remote MQTT client with "connection accepted" return code. See `reject(io.netty.handler.codec.mqtt.MqttConnectReturnCode)` for refusing connection
      Parameters:
        `sessionPresent` - if a previous session is present
      Returns:
        a reference to this, so the API can be used fluently

    - #### reject

          public MqttEndpoint reject(io.netty.handler.codec.mqtt.MqttConnectReturnCode returnCode)

      Sends the CONNACK message to the remote MQTT client rejecting the connection request with specified return code. See `accept()` for accepting connection
      Parameters:
        `returnCode` - the connect return code
      Returns:
        a reference to this, so the API can be used fluently

    - #### subscribeAcknowledge

          public MqttEndpoint subscribeAcknowledge(int subscribeMessageId,
                                                   List<io.netty.handler.codec.mqtt.MqttQoS> grantedQoSLevels)

      Sends the SUBACK message to the remote MQTT client
      Parameters:
        `subscribeMessageId` - identifier of the SUBSCRIBE message to acknowledge
        `grantedQoSLevels` - granted QoS levels for the requested topics
      Returns:
        a reference to this, so the API can be used fluently

    - #### unsubscribeAcknowledge

          public MqttEndpoint unsubscribeAcknowledge(int unsubscribeMessageId)

      Sends the UNSUBACK message to the remote MQTT client
      Parameters:
        `unsubscribeMessageId` - identifier of the UNSUBSCRIBE message to acknowledge
      Returns:
        a reference to this, so the API can be used fluently

    - #### publishAcknowledge

          public MqttEndpoint publishAcknowledge(int publishMessageId)

      Sends the PUBACK message to the remote MQTT client
      Parameters:
        `publishMessageId` - identifier of the PUBLISH message to acknowledge
      Returns:
        a reference to this, so the API can be used fluently

    - #### publishReceived

          public MqttEndpoint publishReceived(int publishMessageId)

      Sends the PUBREC message to the remote MQTT client
      Parameters:
        `publishMessageId` - identifier of the PUBLISH message to acknowledge
      Returns:
        a reference to this, so the API can be used fluently

    - #### publishRelease

          public MqttEndpoint publishRelease(int publishMessageId)

      Sends the PUBREL message to the remote MQTT client
      Parameters:
        `publishMessageId` - identifier of the PUBLISH message to acknowledge
      Returns:
        a reference to this, so the API can be used fluently

    - #### publishComplete

          public MqttEndpoint publishComplete(int publishMessageId)

      Sends the PUBCOMP message to the remote MQTT client
      Parameters:
        `publishMessageId` - identifier of the PUBLISH message to acknowledge
      Returns:
        a reference to this, so the API can be used fluently

    - #### publish

          public MqttEndpoint publish(String topic,
                                      Buffer payload,
                                      io.netty.handler.codec.mqtt.MqttQoS qosLevel,
                                      boolean isDup,
                                      boolean isRetain,
                                      Handler<AsyncResult<Integer>> publishSentHandler)

      Sends the PUBLISH message to the remote MQTT server
      Parameters:
        `topic` - topic on which the message is published
        `payload` - message payload
        `qosLevel` - QoS level
        `isDup` - if the message is a duplicate
        `isRetain` - if the message needs to be retained
        `publishSentHandler` - handler called after PUBLISH packet sent with a packetId
      Returns:
        current MQTT client instance

    - #### publish

          public MqttEndpoint publish(String topic,
                                      Buffer payload,
                                      io.netty.handler.codec.mqtt.MqttQoS qosLevel,
                                      boolean isDup,
                                      boolean isRetain)

      Sends the PUBLISH message to the remote MQTT server
      Parameters:
        `topic` - topic on which the message is published
        `payload` - message payload
        `qosLevel` - QoS level
        `isDup` - if the message is a duplicate
        `isRetain` - if the message needs to be retained
      Returns:
        current MQTT client instance

    - #### rxPublish

          public Single<Integer> rxPublish(String topic,
                                           Buffer payload,
                                           io.netty.handler.codec.mqtt.MqttQoS qosLevel,
                                           boolean isDup,
                                           boolean isRetain)

      Sends the PUBLISH message to the remote MQTT server
      Parameters:
        `topic` - topic on which the message is published
        `payload` - message payload
        `qosLevel` - QoS level
        `isDup` - if the message is a duplicate
        `isRetain` - if the message needs to be retained
      Returns:
        current MQTT client instance

    - #### publish

          public MqttEndpoint publish(String topic,
                                      Buffer payload,
                                      io.netty.handler.codec.mqtt.MqttQoS qosLevel,
                                      boolean isDup,
                                      boolean isRetain,
                                      int messageId,
                                      Handler<AsyncResult<Integer>> publishSentHandler)

      Sends the PUBLISH message to the remote MQTT server explicitly specifying the messageId
      Parameters:
        `topic` - topic on which the message is published
        `payload` - message payload
        `qosLevel` - QoS level
        `isDup` - if the message is a duplicate
        `isRetain` - if the message needs to be retained
        `messageId` - message ID
        `publishSentHandler` - handler called after PUBLISH packet sent with a packetId
      Returns:
        current MQTT client instance

    - #### publish

          public MqttEndpoint publish(String topic,
                                      Buffer payload,
                                      io.netty.handler.codec.mqtt.MqttQoS qosLevel,
                                      boolean isDup,
                                      boolean isRetain,
                                      int messageId)

      Sends the PUBLISH message to the remote MQTT server explicitly specifying the messageId
      Parameters:
        `topic` - topic on which the message is published
        `payload` - message payload
        `qosLevel` - QoS level
        `isDup` - if the message is a duplicate
        `isRetain` - if the message needs to be retained
        `messageId` - message ID
      Returns:
        current MQTT client instance

    - #### rxPublish

          public Single<Integer> rxPublish(String topic,
                                           Buffer payload,
                                           io.netty.handler.codec.mqtt.MqttQoS qosLevel,
                                           boolean isDup,
                                           boolean isRetain,
                                           int messageId)

      Sends the PUBLISH message to the remote MQTT server explicitly specifying the messageId
      Parameters:
        `topic` - topic on which the message is published
        `payload` - message payload
        `qosLevel` - QoS level
        `isDup` - if the message is a duplicate
        `isRetain` - if the message needs to be retained
        `messageId` - message ID
      Returns:
        current MQTT client instance

    - #### pong

          public MqttEndpoint pong()

      Sends the PINGRESP message to the remote MQTT client
      Returns:
        a reference to this, so the API can be used fluently

    - #### connectProperties

          public io.netty.handler.codec.mqtt.MqttProperties connectProperties()

      Returns:
        MQTT properties of the CONNECT message

    - #### accept

          public MqttEndpoint accept(boolean sessionPresent,
                                     io.netty.handler.codec.mqtt.MqttProperties properties)

      Sends the CONNACK message to the remote MQTT client with "connection accepted" return code. See `reject(io.netty.handler.codec.mqtt.MqttConnectReturnCode)` for refusing connection
      Parameters:
        `sessionPresent` - if a previous session is present
        `properties` - CONNACK message properties (MQTT5)
      Returns:
        a reference to this, so the API can be used fluently

    - #### reject

          public MqttEndpoint reject(io.netty.handler.codec.mqtt.MqttConnectReturnCode returnCode,
                                     io.netty.handler.codec.mqtt.MqttProperties properties)

      Sends the CONNACK message to the remote MQTT client rejecting the connection request with specified return code. See `accept()` for accepting connection
      Parameters:
        `returnCode` - the connect return code
        `properties` - CONNACK message properties
      Returns:
        a reference to this, so the API can be used fluently

    - #### subscribeAcknowledge

          public MqttEndpoint subscribeAcknowledge(int subscribeMessageId,
                                                   List<MqttSubAckReasonCode> reasonCodes,
                                                   io.netty.handler.codec.mqtt.MqttProperties properties)

      Sends the SUBACK message to the remote MQTT client
      Parameters:
        `subscribeMessageId` - identifier of the SUBSCRIBE message to acknowledge
        `reasonCodes` - reason codes
        `properties` - MQTT message properties
      Returns:
        a reference to this, so the API can be used fluently

    - #### unsubscribeAcknowledge

          public MqttEndpoint unsubscribeAcknowledge(int unsubscribeMessageId,
                                                     List<MqttUnsubAckReasonCode> reasonCodes,
                                                     io.netty.handler.codec.mqtt.MqttProperties properties)

      Sends the UNSUBACK message to the remote MQTT client
      Parameters:
        `unsubscribeMessageId` - identifier of the UNSUBSCRIBE message to acknowledge
        `reasonCodes` - reason codes
        `properties` - MQTT message properties
      Returns:
        a reference to this, so the API can be used fluently

    - #### publishAcknowledge

          public MqttEndpoint publishAcknowledge(int publishMessageId,
                                                 MqttPubAckReasonCode reasonCode,
                                                 io.netty.handler.codec.mqtt.MqttProperties properties)

    - #### publishReceived

          public MqttEndpoint publishReceived(int publishMessageId,
                                              MqttPubRecReasonCode reasonCode,
                                              io.netty.handler.codec.mqtt.MqttProperties properties)

      Sends the PUBREC message to the remote MQTT client
      Parameters:
        `publishMessageId` - identifier of the PUBLISH message to acknowledge
        `reasonCode` - code of the outcome
        `properties` - MQTT properties
      Returns:
        a reference to this, so the API can be used fluently

    - #### publishRelease

          public MqttEndpoint publishRelease(int publishMessageId,
                                             MqttPubRelReasonCode reasonCode,
                                             io.netty.handler.codec.mqtt.MqttProperties properties)

      Sends the PUBREL message to the remote MQTT client
      Parameters:
        `publishMessageId` - identifier of the PUBLISH message to acknowledge
        `reasonCode` - reason code
        `properties` - MQTT message properties
      Returns:
        a reference to this, so the API can be used fluently

    - #### publishComplete

          public MqttEndpoint publishComplete(int publishMessageId,
                                              MqttPubCompReasonCode reasonCode,
                                              io.netty.handler.codec.mqtt.MqttProperties properties)

      Sends the PUBCOMP message to the remote MQTT client
      Parameters:
        `publishMessageId` - identifier of the PUBLISH message to acknowledge
        `reasonCode` - reason code
        `properties` - MQTT message properties
      Returns:
        a reference to this, so the API can be used fluently

    - #### publish

          public MqttEndpoint publish(String topic,
                                      Buffer payload,
                                      io.netty.handler.codec.mqtt.MqttQoS qosLevel,
                                      boolean isDup,
                                      boolean isRetain,
                                      int messageId,
                                      io.netty.handler.codec.mqtt.MqttProperties properties,
                                      Handler<AsyncResult<Integer>> publishSentHandler)

      Sends the PUBLISH message to the remote MQTT server explicitly specifying the messageId
      Parameters:
        `topic` - topic on which the message is published
        `payload` - message payload
        `qosLevel` - QoS level
        `isDup` - if the message is a duplicate
        `isRetain` - if the message needs to be retained
        `messageId` - message ID
        `properties` - PUBLISH message properties
        `publishSentHandler` - handler called after PUBLISH packet sent with a packetId
      Returns:
        current MQTT client instance

    - #### publish

          public MqttEndpoint publish(String topic,
                                      Buffer payload,
                                      io.netty.handler.codec.mqtt.MqttQoS qosLevel,
                                      boolean isDup,
                                      boolean isRetain,
                                      int messageId,
                                      io.netty.handler.codec.mqtt.MqttProperties properties)

      Sends the PUBLISH message to the remote MQTT server explicitly specifying the messageId
      Parameters:
        `topic` - topic on which the message is published
        `payload` - message payload
        `qosLevel` - QoS level
        `isDup` - if the message is a duplicate
        `isRetain` - if the message needs to be retained
        `messageId` - message ID
        `properties` - PUBLISH message properties
      Returns:
        current MQTT client instance

    - #### rxPublish

          public Single<Integer> rxPublish(String topic,
                                           Buffer payload,
                                           io.netty.handler.codec.mqtt.MqttQoS qosLevel,
                                           boolean isDup,
                                           boolean isRetain,
                                           int messageId,
                                           io.netty.handler.codec.mqtt.MqttProperties properties)

      Sends the PUBLISH message to the remote MQTT server explicitly specifying the messageId
      Parameters:
        `topic` - topic on which the message is published
        `payload` - message payload
        `qosLevel` - QoS level
        `isDup` - if the message is a duplicate
        `isRetain` - if the message needs to be retained
        `messageId` - message ID
        `properties` - PUBLISH message properties
      Returns:
        current MQTT client instance

    - #### disconnect

          public MqttEndpoint disconnect(MqttDisconnectReasonCode code,
                                         io.netty.handler.codec.mqtt.MqttProperties properties)

      Sends the DISCONNECT message to the remote MQTT client
      Parameters:
        `code` - reason code
        `properties` - MQTT message properties
      Returns:
        a reference to this, so the API can be used fluently

    - #### newInstance

          public static MqttEndpoint newInstance(MqttEndpoint arg)

Copyright © 2021 Eclipse. All rights reserved.