io.vertx.mqtt

## Interface MqttEndpoint

-     public interface MqttEndpoint

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

- - ### Method Summary

    All Methods Instance Methods Abstract Methods
    Modifier and Type | Method and Description
    --- | ---
    `MqttEndpoint` | `accept()` Like `accept(boolean)` 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.
    `MqttEndpoint` | `exceptionHandler(Handler<Throwable> handler)` Set an exception handler.
    `boolean` | `isAutoKeepAlive()`
    `boolean` | `isCleanSession()`
    `boolean` | `isConnected()`
    `boolean` | `isPublishAutoAck()`
    `boolean` | `isSsl()`
    `boolean` | `isSubscriptionAutoAck()`
    `int` | `keepAliveTimeSeconds()`
    `int` | `lastMessageId()`
    `SocketAddress` | `localAddress()`
    `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 client
    `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, 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()`
    `MqttEndpoint` | `setClientIdentifier(String clientIdentifier)` Set client identifier if not provided by the remote MQTT client (zero-bytes)
    `SSLSession` | `sslSession()`
    `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
    `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()`

- - ### Method Detail

    - #### close

          void close()

      Close the endpoint, so the connection with remote MQTT client

    - #### remoteAddress

          SocketAddress remoteAddress()

      Returns:
        the remote address for this socket

    - #### localAddress

          SocketAddress localAddress()

      Returns:
        the local address for this socket

    - #### isSsl

          boolean isSsl()

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

    - #### sslSession

          SSLSession sslSession()

      Returns:
        SSLSession associated with the underlying socket. Returns null if connection is not SSL.
      See Also:
        `SSLSession`

    - #### clientIdentifier

          String clientIdentifier()

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

    - #### auth

          MqttAuth auth()

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

    - #### will

          MqttWill will()

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

    - #### protocolVersion

          int protocolVersion()

      Returns:
        the protocol version required by the remote MQTT client

    - #### protocolName

          String protocolName()

      Returns:
        the protocol name provided by the remote MQTT client

    - #### isCleanSession

          boolean isCleanSession()

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

    - #### keepAliveTimeSeconds

          int keepAliveTimeSeconds()

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

    - #### lastMessageId

          int lastMessageId()

      Returns:
        the message identifier used for last published message

    - #### subscriptionAutoAck

          void subscriptionAutoAck(boolean isSubscriptionAutoAck)

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

    - #### isSubscriptionAutoAck

          boolean isSubscriptionAutoAck()

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

    - #### publishAutoAck

          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

          boolean isPublishAutoAck()

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

    - #### autoKeepAlive

          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

          boolean isAutoKeepAlive()

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

    - #### isConnected

          boolean isConnected()

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

    - #### setClientIdentifier

          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

          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

          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

          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

          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

          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

          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

          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

          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

          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

          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

          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

          MqttEndpoint accept()

      Like `accept(boolean)` with no session is present.

    - #### accept

          MqttEndpoint accept(boolean sessionPresent)

      Sends the CONNACK message to the remote MQTT client with "connection accepted" return code. See `reject(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

          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(boolean)` for accepting connection
      Parameters:
        `returnCode` - the connect return code
      Returns:
        a reference to this, so the API can be used fluently

    - #### subscribeAcknowledge

          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

          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

          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

          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

          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

          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

          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 client
      Parameters:
        `topic` - topic on which the message is published
        `payload` - message payload
        `qosLevel` - quality of service level
        `isDup` - if the message is a duplicate
        `isRetain` - if the message needs to be retained
      Returns:
        a reference to this, so the API can be used fluently

    - #### publish

          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

          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

    - #### pong

          MqttEndpoint pong()

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

Copyright © 2020 Eclipse. All rights reserved.