org.eclipse.paho.client.mqttv3-1.2.0-sources.zip

/******************************************************************************* * Copyright (c) 2009, 2016 IBM Corp. * * All rights reserved. This program and the accompanying materials * are made available under the terms of the Eclipse Public License v1.0 * and Eclipse Distribution License v1.0 which accompany this distribution. * * The Eclipse Public License is available at * http://www.eclipse.org/legal/epl-v10.html * and the Eclipse Distribution License is available at * http://www.eclipse.org/org/documents/edl-v10.php. * * Contributors: * Dave Locke - initial API and implementation and/or initial documentation * Ian Craggs - MQTT 3.1.1 support * Ian Craggs - per subscription message handlers (bug 466579) * Ian Craggs - ack control (bug 472172) * James Sutton - Bug 459142 - WebSocket support for the Java client. * James Sutton - Automatic Reconnect & Offline Buffering. */ package org.eclipse.paho.client.mqttv3; import java.lang.reflect.Field; import java.net.URI; import java.net.URISyntaxException; import java.util.Hashtable; import java.util.Properties; import java.util.Timer; import java.util.TimerTask; import java.util.concurrent.Executors; import java.util.concurrent.ScheduledExecutorService; import javax.net.SocketFactory; import javax.net.ssl.SSLSocketFactory; import org.eclipse.paho.client.mqttv3.internal.ClientComms; import org.eclipse.paho.client.mqttv3.internal.ConnectActionListener; import org.eclipse.paho.client.mqttv3.internal.DisconnectedMessageBuffer; import org.eclipse.paho.client.mqttv3.internal.ExceptionHelper; import org.eclipse.paho.client.mqttv3.internal.NetworkModule; import org.eclipse.paho.client.mqttv3.internal.SSLNetworkModule; import org.eclipse.paho.client.mqttv3.internal.TCPNetworkModule; import org.eclipse.paho.client.mqttv3.internal.security.SSLSocketFactoryFactory; import org.eclipse.paho.client.mqttv3.internal.websocket.WebSocketNetworkModule; import org.eclipse.paho.client.mqttv3.internal.websocket.WebSocketSecureNetworkModule; import org.eclipse.paho.client.mqttv3.internal.wire.MqttDisconnect; import org.eclipse.paho.client.mqttv3.internal.wire.MqttPublish; import org.eclipse.paho.client.mqttv3.internal.wire.MqttSubscribe; import org.eclipse.paho.client.mqttv3.internal.wire.MqttUnsubscribe; import org.eclipse.paho.client.mqttv3.logging.Logger; import org.eclipse.paho.client.mqttv3.logging.LoggerFactory; import org.eclipse.paho.client.mqttv3.persist.MemoryPersistence; import org.eclipse.paho.client.mqttv3.persist.MqttDefaultFilePersistence; import org.eclipse.paho.client.mqttv3.util.Debug; /** * Lightweight client for talking to an MQTT server using non-blocking methods * that allow an operation to run in the background. * * <p> * This class implements the non-blocking {@link IMqttAsyncClient} client * interface allowing applications to initiate MQTT actions and then carry on * working while the MQTT action completes on a background thread. This * implementation is compatible with all Java SE runtimes from 1.7 and up. * </p> * <p> * An application can connect to an MQTT server using: * </p> * <ul> * <li>A plain TCP socket * <li>A secure SSL/TLS socket * </ul> * * <p> * To enable messages to be delivered even across network and client restarts * messages need to be safely stored until the message has been delivered at the * requested quality of service. A pluggable persistence mechanism is provided * to store the messages. * </p> * <p> * By default {@link MqttDefaultFilePersistence} is used to store messages to a * file. If persistence is set to null then messages are stored in memory and * hence can be lost if the client, Java runtime or device shuts down. * </p> * <p> * If connecting with {@link MqttConnectOptions#setCleanSession(boolean)} set to * true it is safe to use memory persistence as all state is cleared when a * client disconnects. If connecting with cleanSession set to false in order to * provide reliable message delivery then a persistent message store such as the * default one should be used. * </p> * <p> * The message store interface is pluggable. Different stores can be used by * implementing the {@link MqttClientPersistence} interface and passing it to * the clients constructor. * </p> * * @see IMqttAsyncClient */ public class MqttAsyncClient implements IMqttAsyncClient { private static final String CLASS_NAME = MqttAsyncClient.class.getName(); private static final Logger log = LoggerFactory.getLogger(LoggerFactory.MQTT_CLIENT_MSG_CAT, CLASS_NAME); private static final String CLIENT_ID_PREFIX = "paho"; private static final long QUIESCE_TIMEOUT = 30000; // ms private static final long DISCONNECT_TIMEOUT = 10000; // ms private static final char MIN_HIGH_SURROGATE = '\uD800'; private static final char MAX_HIGH_SURROGATE = '\uDBFF'; private String clientId; private String serverURI; protected ClientComms comms; private Hashtable topics; private MqttClientPersistence persistence; private MqttCallback mqttCallback; private MqttConnectOptions connOpts; private Object userContext; private Timer reconnectTimer; // Automatic reconnect timer private static int reconnectDelay = 1000; // Reconnect delay, starts at 1 // second private boolean reconnecting = false; private static Object clientLock = new Object(); // Simple lock private ScheduledExecutorService executorService; /** * Create an MqttAsyncClient that is used to communicate with an MQTT * server. * <p> * The address of a server can be specified on the constructor. * Alternatively a list containing one or more servers can be specified * using the {@link MqttConnectOptions#setServerURIs(String[]) * setServerURIs} method on MqttConnectOptions. * * <p> * The <code>serverURI</code> parameter is typically used with the the * <code>clientId</code> parameter to form a key. The key is used to store * and reference messages while they are being delivered. Hence the * serverURI specified on the constructor must still be specified even if a * list of servers is specified on an MqttConnectOptions object. The * serverURI on the constructor must remain the same across restarts of the * client for delivery of messages to be maintained from a given client to a * given server or set of servers. * * <p> * The address of the server to connect to is specified as a URI. Two types * of connection are supported <code>tcp://</code> for a TCP connection and * <code>ssl://</code> for a TCP connection secured by SSL/TLS. For example: * </p> * <ul> * <li><code>tcp://localhost:1883</code></li> * <li><code>ssl://localhost:8883</code></li> * </ul> * <p> * If the port is not specified, it will default to 1883 for * <code>tcp://</code>" URIs, and 8883 for <code>ssl://</code> URIs. * </p> * * <p> * A client identifier <code>clientId</code> must be specified and be less * that 65535 characters. It must be unique across all clients connecting to * the same server. The clientId is used by the server to store data related * to the client, hence it is important that the clientId remain the same * when connecting to a server if durable subscriptions or reliable * messaging are required. * <p> * A convenience method is provided to generate a random client id that * should satisfy this criteria - {@link #generateClientId()}. As the client * identifier is used by the server to identify a client when it reconnects, * the client must use the same identifier between connections if durable * subscriptions or reliable delivery of messages is required. * </p> * <p> * In Java SE, SSL can be configured in one of several ways, which the * client will use in the following order: * </p> * <ul> * <li><strong>Supplying an <code>SSLSocketFactory</code></strong> - * applications can use * {@link MqttConnectOptions#setSocketFactory(SocketFactory)} to supply a * factory with