ClientState

java.lang.Object
- org.eclipse.paho.client.mqttv3.internal.ClientState

```
public class ClientState
extends java.lang.Object
```
The core of the client, which holds the state information for pending and in-flight messages. Messages that have been accepted for delivery are moved between several objects while being delivered. 1) When the client is not running messages are stored in a persistent store that implements the MqttClientPersistent Interface. The default is MqttDefaultFilePersistencew which stores messages safely across failures and system restarts. If no persistence is specified there is a fall back to MemoryPersistence which will maintain the messages while the Mqtt client is instantiated. 2) When the client or specifically ClientState is instantiated the messages are read from the persistent store into: - outboundqos2 hashtable if a QoS 2 PUBLISH or PUBREL - outboundqos1 hashtable if a QoS 1 PUBLISH (see restoreState) 3) On Connect, copy messages from the outbound hashtables to the pendingMessages or pendingFlows vector in messageid order. - Initial message publish goes onto the pendingmessages buffer. - PUBREL goes onto the pendingflows buffer (see restoreInflightMessages) 4) Sender thread reads messages from the pendingflows and pendingmessages buffer one at a time. The message is removed from the pendingbuffer but remains on the outbound* hashtable. The hashtable is the place where the full set of outstanding messages are stored in memory. (Persistence is only used at start up) 5) Receiver thread - receives wire messages: - if QoS 1 then remove from persistence and outboundqos1 - if QoS 2 PUBREC send PUBREL. Updating the outboundqos2 entry with the PUBREL and update persistence. - if QoS 2 PUBCOMP remove from persistence and outboundqos2 Notes: because of the multithreaded nature of the client it is vital that any changes to this class take concurrency into account. For instance as soon as a flow / message is put on the wire it is possible for the receiving thread to receive the ack and to be processing the response before the sending side has finished processing. For instance a connect may be sent, the conack received before the connect notify send has been processed!

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`MqttToken`	`checkForActivity(IMqttActionListener pingCallback)` Check and send a ping if needed and check for ping timeout.
`void`	`connected()` Called when the client has successfully connected to the broker
`void`	`disconnected(MqttException reason)` Called when the client has been disconnected from the broker.
`int`	`getActualInFlight()`
`java.util.Properties`	`getDebug()`
`int`	`getMaxInFlight()`
`void`	`notifyQueueLock()`
`void`	`notifyReceivedBytes(int receivedBytesCount)`
`void`	`notifySentBytes(int sentBytesCount)` COMMENTED OUT AS NO LONGER USED.
`void`	`persistBufferedMessage(MqttWireMessage message)` Persists a buffered message to the persistence layer
`void`	`quiesce(long timeout)` Quiesce the client state, preventing any new messages getting sent, and preventing the callback on any newly received messages.
`java.util.Vector`	`resolveOldTokens(MqttException reason)` Called during shutdown to work out if there are any tokens still to be notified and waiters to be unblocked.
`void`	`send(MqttWireMessage message, MqttToken token)` Submits a message for delivery.
`void`	`setKeepAliveInterval(long interval)`
`void`	`unPersistBufferedMessage(MqttWireMessage message)`

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

- Method Detail
  - send
```
public void send(MqttWireMessage message,
                 MqttToken token)
          throws MqttException
```
    Submits a message for delivery. This method will block until there is room in the inFlightWindow for the message. The message is put into persistence before returning.
    
    Parameters:
    
    message - the message to send
    
    token - the token that can be used to track delivery of the message
    
    Throws:
    
    MqttException
  - persistBufferedMessage
```
public void persistBufferedMessage(MqttWireMessage message)
```
    Persists a buffered message to the persistence layer
    
    Parameters:
    
    message -
    
    Throws:
    
    MqttPersistenceException
  - unPersistBufferedMessage
```
public void unPersistBufferedMessage(MqttWireMessage message)
                              throws MqttPersistenceException
```
    Throws:
    
    MqttPersistenceException
  - checkForActivity
```
public MqttToken checkForActivity(IMqttActionListener pingCallback)
                           throws MqttException
```
    Check and send a ping if needed and check for ping timeout. Need to send a ping if nothing has been sent or received in the last keepalive interval. It is important to check for both sent and received packets in order to catch the case where an app is solely sending QoS 0 messages or receiving QoS 0 messages. QoS 0 message are not good enough for checking a connection is alive as they are one way messages. If a ping has been sent but no data has been received in the last keepalive interval then the connection is deamed to be broken.
    
    Returns:
    
    token of ping command, null if no ping command has been sent.
    
    Throws:
    
    MqttException
  - setKeepAliveInterval
```
public void setKeepAliveInterval(long interval)
```
  - notifySentBytes
```
public void notifySentBytes(int sentBytesCount)
```
    COMMENTED OUT AS NO LONGER USED. Deduce how long to to wait until a ping is required. In order to keep the connection alive the server must see activity within the keepalive interval. If the application is not sending / receiving any messages then the client will send a ping. This method works out the next time that a ping must be sent in order for the server to know the client is alive.
  - notifyReceivedBytes
```
public void notifyReceivedBytes(int receivedBytesCount)
```
  - connected
```
public void connected()
```
    Called when the client has successfully connected to the broker
  - resolveOldTokens
```
public java.util.Vector resolveOldTokens(MqttException reason)
```
    Called during shutdown to work out if there are any tokens still to be notified and waiters to be unblocked. Notifying and unblocking takes place after most shutdown processing has completed. The tokenstore is tidied up so it only contains outstanding delivery tokens which are valid after reconnect (if clean session is false)
    
    Parameters:
    
    reason - The root cause of the disconnection, or null if it is a clean disconnect
  - disconnected
```
public void disconnected(MqttException reason)
```
    Called when the client has been disconnected from the broker.
    
    Parameters:
    
    reason - The root cause of the disconnection, or null if it is a clean disconnect
  - quiesce
```
public void quiesce(long timeout)
```
    Quiesce the client state, preventing any new messages getting sent, and preventing the callback on any newly received messages. After the timeout expires, delete any pending messages except for outbound ACKs, and wait for those ACKs to complete.
  - notifyQueueLock
```
public void notifyQueueLock()
```
  - getActualInFlight
```
public int getActualInFlight()
```
  - getMaxInFlight
```
public int getMaxInFlight()
```
  - getDebug
```
public java.util.Properties getDebug()
```

Class ClientState

Method Summary

Methods inherited from class java.lang.Object

Method Detail

send

persistBufferedMessage

unPersistBufferedMessage

checkForActivity

setKeepAliveInterval

notifySentBytes

notifyReceivedBytes

connected

resolveOldTokens

disconnected

quiesce

notifyQueueLock

getActualInFlight

getMaxInFlight

getDebug