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.
    `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.
    `MqttEndpoint` | `disconnectHandler(Handler<Void> 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()`
    `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` | `publishAcknowledge(int publishMessageId)` Sends the PUBACK message to the remote MQTT client
    `MqttEndpoint` | `publishAcknowledgeHandler(Handler<Integer> 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` | `publishCompletionHandler(Handler<Integer> 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` | `publishReceivedHandler(Handler<Integer> handler)` Set the pubrec handler on the MQTT endpoint.
    `MqttEndpoint` | `publishRelease(int publishMessageId)` Sends the PUBREL message to the remote MQTT client
    `MqttEndpoint` | `publishReleaseHandler(Handler<Integer> 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.
    `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
    `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` | `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` | `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.

    - #### 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

    - #### 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

    - #### 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

    - #### 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

    - #### 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

    - #### 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

    - #### newInstance

          public static MqttEndpoint newInstance(MqttEndpoint arg)

Copyright © 2020 Eclipse. All rights reserved.