Android MQTT

1.在项目根目录下的build.gradle中添加

repositories {
    maven {
        url "https://repo.eclipse.org/content/repositories/paho-releases/"
    }
}

2.在app目录下的build.gradle中添加：

 //mqtt
    implementation 'org.eclipse.paho:org.eclipse.paho.client.mqttv3:1.1.0'
    implementation 'org.eclipse.paho:org.eclipse.paho.android.service:1.1.1'
   //implementation 'com.android.support:support-v4:4.4.1'

3.权限

    <uses-permission android:name="android.permission.WAKE_LOCK" />
    <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />
    <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
    <uses-permission android:name="android.permission.READ_PHONE_STATE" />
    <uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE" />
    <uses-permission android:name="android.permission.INTERNET" />

4.在AndroidManifest.xml中添加

    <!-- Mqtt服务 -->
    <service android:name="org.eclipse.paho.android.service.MqttService" />

5.新建EasyMqttMethod.class

public class EasyMqttMethod {

    private static OnConnectListener onConnectListener;

    /**
     * 构建EasyMqttService对象
     */
    public EasyMqttService buildEasyMqttService() {
        EasyMqttService mMQTTService = new EasyMqttService.Builder()
                //设置自动重连
                .autoReconnect(true)
                //设置不清除回话session 可收到服务器之前发出的推送消息
                .cleanSession(false)
                //唯一标示 保证每个设备都唯一就可以 建议 imei
                .clientId("RelayUAVGround")     //中继无人机地面端
                //mqtt服务器地址 格式例如：tcp://10.0.261.159:1883
                .serverUrl("tcp://212.64.56.66:1883")
                //心跳包默认的发送间隔
                .keepAliveInterval(20)
                //构建出EasyMqttService 建议用application的context
                .bulid(CompleteWidgetActivity.getContext().getApplicationContext());
        connect(mMQTTService);
        return mMQTTService;
    }

    /**
     * 连接Mqtt服务器
     */
    public void connect(final EasyMqttService mqttService) {
        mqttService.connect(new IEasyMqttCallBack() {
            @Override
            public void messageArrived(String topic, String message, int qos) {
                //推送消息到达
                //通过接口传递接收到的数据
                getOnConnectListener().onConnectSuccess(message);
            }

            @Override
            public void connectionLost(Throwable arg0) {
                //连接断开
                Log.e("-----------", "连接断开");
//                ConnectionStatus = "连接断开";
            }

            @Override
            public void deliveryComplete(IMqttDeliveryToken arg0) {
            }

            @Override
            public void connectSuccess(IMqttToken arg0) {
                //连接成功
                subscribe(mqttService);
                Log.e("-----------", "MQTT连接成功 ");
            }

            @Override
            public void connectFailed(IMqttToken arg0, Throwable arg1) {
                //连接失败
                Log.e("-----------", "连接失败" + " " + arg1.getMessage());
            }
        });
    }

    /**
     * 订阅主题 这里订阅三个主题分别是"a", "b", "c"
     */
    public void subscribe(EasyMqttService mqttService) {
        Log.e("----------", "订阅主题");

        //主题对应的推送策略 分别是0, 1, 2 建议服务端和客户端配置的主题一致
        // 0 表示只会发送一次推送消息 收到不收到都不关心
        // 1 保证能收到消息，但不一定只收到一条
        // 2 保证收到切只能收到一条消息
        int[] qoss = new int[]{0};
        mqttService.subscribe(new String[] {"RelayUAVKey"}, qoss);
    }

    /**
     * 发布String消息
     */
    public void publishString(final String msg, String topic, int qos, boolean retained, EasyMqttService mqttService) {
        if(mqttService != null) {
            mqttService.publishString(msg, topic, qos, retained);
        }
    }

    /**
     * 发布Byte消息
     */
    public void publishByte(byte[] msg, String topic, int qos, boolean retained, EasyMqttService mqttService) {
        if(mqttService != null) {
            mqttService.publishByte(msg, topic, qos, retained);
        }
    }

    //创建方法
    public void getMsg(OnConnectListener listener) {
        setOnConnectListener(listener);
    }

    //回调接口
    public interface OnConnectListener{
        //连接成功
        void onConnectSuccess(String msg);
        //连接异常信息
        void onConnectFailed(Exception e);
    }

    /**
     * 判断服务是否连接
     */
    public boolean isConnected(EasyMqttService mqttService) {
        return mqttService.isConnected();
    }

    private OnConnectListener getOnConnectListener() {
        return onConnectListener;
    }

    private void setOnConnectListener(OnConnectListener onConnectListener) {
        this.onConnectListener = onConnectListener;
    }
}

5.新建EasyMqttService.class

/**
 * Mqtt服务
 * @author GrainRain
 */
public class EasyMqttService implements Serializable {
    private final String TAG = "EasyMqttService";
    private boolean canDoConnect = true;

    private MqttAndroidClient client;
    private MqttConnectOptions conOpt;

    private Context context;
    private String serverUrl = "";
    private String userName = "admin";
    private String passWord = "password";
    private String clientId = "";
    private int timeOut = 10;
    private int keepAliveInterval = 20;
    private boolean retained = false;
    private boolean cleanSession = true;
    private boolean autoReconnect = true;
    private IEasyMqttCallBack starMQTTCallBack;

    /**
     * builder设计模式
     *
     * @param builder
     */
    private EasyMqttService(Builder builder) {
        this.context = builder.context;
        this.serverUrl = builder.serverUrl;
        this.userName = builder.userName;
        this.passWord = builder.passWord;
        this.clientId = builder.clientId;
        this.timeOut = builder.timeOut;
        this.keepAliveInterval = builder.keepAliveInterval;
        this.retained = builder.retained;
        this.cleanSession = builder.cleanSession;
        this.autoReconnect = builder.autoReconnect;

        init();
    }

    /**
     * Builder 构造类
     */
    public static final class Builder {

        private Context context;
        private String serverUrl;
        private String userName = "admin";
        private String passWord = "password";
        private String clientId;
        private int timeOut = 10;
        private int keepAliveInterval = 20;
        private boolean retained = false;
        private boolean cleanSession = false;
        private boolean autoReconnect = false;

        public Builder serverUrl(String serverUrl) {
            this.serverUrl = serverUrl;
            return this;
        }

        public Builder userName(String userName) {
            this.userName = userName;
            return this;
        }

        public Builder passWord(String passWord) {
            this.passWord = passWord;
            return this;
        }

        public Builder clientId(String clientId) {
            this.clientId = clientId;
            return this;
        }

        public Builder timeOut(int timeOut) {
            this.timeOut = timeOut;
            return this;
        }

        public Builder keepAliveInterval(int keepAliveInterval) {
            this.keepAliveInterval = keepAliveInterval;
            return this;
        }

        public Builder retained(boolean retained) {
            this.retained = retained;
            return this;
        }

        public Builder autoReconnect(boolean autoReconnect) {
            this.autoReconnect = autoReconnect;
            return this;
        }

        public Builder cleanSession(boolean cleanSession) {
            this.cleanSession = cleanSession;
            return this;
        }

        public EasyMqttService bulid(Context context) {
            this.context = context;
            return new EasyMqttService(this);
        }
    }

    /**
     * 发布消息
     * @param msg
     * @param topic
     * @param qos
     * @param retained
     */
    public void publishString(String msg, String topic, int qos, boolean retained) {
        try {
            client.publish(topic, msg.getBytes(), qos, retained);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public void publishByte(byte[] msg, String topic, int qos, boolean retained) {
        try {
            client.publish(topic, msg, qos, retained);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    private void init() {
        // 服务器地址（协议+地址+端口号）
        client = new MqttAndroidClient(context, serverUrl, clientId);
        // 设置MQTT监听并且接受消息
        client.setCallback(mqttCallback);

        conOpt = new MqttConnectOptions();
        // 清除缓存
        conOpt.setCleanSession(cleanSession);
        // 设置超时时间，单位：秒
        conOpt.setConnectionTimeout(timeOut);
        // 心跳包发送间隔，单位：秒
        conOpt.setKeepAliveInterval(keepAliveInterval);
        // 用户名
        conOpt.setUserName(userName);
        // 密码
        conOpt.setPassword(passWord.toCharArray());
        conOpt.setAutomaticReconnect(autoReconnect);
    }

    /**
     * 关闭客户端
     */
    public void close() {
        try {
            client.close();
        } catch (Exception e) {
            Log.e(TAG,e.toString());
        }
    }

    /**
     * 连接MQTT服务器
     */
    public void connect(IEasyMqttCallBack starMQTTCallBack) {
        this.starMQTTCallBack = starMQTTCallBack;
        if (canDoConnect && !client.isConnected()) {
            try {
                client.connect(conOpt,null, iMqttActionListener);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }

    /**
     * 订阅主题
     *
     * @param topics 主题
     * @param qos    策略
     */
    public void subscribe(String[] topics, int[] qos) {
        try {
            // 订阅topic话题
            Log.i(TAG, "execute subscribe -- qos = " + qos.toString());
            client.subscribe(topics, qos);
        } catch (Exception e) {
            Log.e(TAG,e.toString());
        }
    }

    /**
     * 断开连接
     */
    public void disconnect(){
        try {
            client.disconnect();
        } catch (Exception e) {
            Log.e(TAG,e.toString());
        }
    }

    /**
     * 判断连接是否断开
     */
    public boolean isConnected(){
        try {
            return client.isConnected();
        } catch (Exception e) {
            Log.e(TAG,e.toString());
        }
        return false;
    }

    /**
     *  MQTT是否连接成功
     */
    private IMqttActionListener iMqttActionListener = new IMqttActionListener() {

        @Override
        public void onSuccess(IMqttToken arg0) {
            Log.i(TAG, "mqtt connect success ");
            if (starMQTTCallBack != null) {
                starMQTTCallBack.connectSuccess(arg0);
            }
        }

        @Override
        public void onFailure(IMqttToken arg0, Throwable arg1) {
            Log.i(TAG, "mqtt connect failed ");
            if (starMQTTCallBack != null) {
                starMQTTCallBack.connectFailed(arg0, arg1);
            }
        }
    };

    // MQTT监听并且接受消息
    private MqttCallback mqttCallback = new MqttCallback() {

        @Override
        public void messageArrived(String topic, MqttMessage message) throws Exception {

            String msgContent = new String(message.getPayload());
            String detailLog = topic + ";qos:" + message.getQos() + ";retained:" + message.isRetained();
            Log.i(TAG, "messageArrived:" + msgContent);
            Log.i(TAG, detailLog);
            if (starMQTTCallBack != null) {
                starMQTTCallBack.messageArrived(topic, msgContent, message.getQos());
            }
        }

        @Override
        public void deliveryComplete(IMqttDeliveryToken arg0) {
            if (starMQTTCallBack != null) {
                starMQTTCallBack.deliveryComplete(arg0);
            }
            Log.i(TAG, "deliveryComplete");
        }

        @Override
        public void connectionLost(Throwable arg0) {
            if (starMQTTCallBack != null) {
                starMQTTCallBack.connectionLost(arg0);
            }
            Log.i(TAG, "connectionLost");
            // 失去连接，重连
        }
    };

    /**
     * 判断网络是否连接
     */
    private boolean isConnectIsNomarl() {
        ConnectivityManager connectivityManager = (ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE);
        @SuppressLint("MissingPermission") NetworkInfo info = connectivityManager.getActiveNetworkInfo();
        if (info != null && info.isAvailable()) {
            String name = info.getTypeName();
            Log.i(TAG, "MQTT current network name：" + name);
            return true;
        } else {
            Log.i(TAG, "MQTT no network");
            return false;
        }
    }
}

6.新建接口IEasyMqttCallBack

public interface IEasyMqttCallBack {

    /**
     * 收到消息
     *
     * @param topic   主题
     * @param message 消息内容
     * @param qos     消息策略
     */
    void messageArrived(String topic, String message, int qos);

    /**
     * 连接断开
     *
     * @param arg0 抛出的异常信息
     */
    void connectionLost(Throwable arg0);

    /**
     * 传送完成
     *
     * @param arg0
     */
    void deliveryComplete(IMqttDeliveryToken arg0);

    /**
     * 连接成功
     *
     * @param arg0
     */
    void connectSuccess(IMqttToken arg0);

    /**
     * 连接失败
     *
     * @param arg0
     */
    void connectFailed(IMqttToken arg0, Throwable arg1);

}

7.使用

 private EasyMqttService easyMqttService;
 private void initMQTT() {
        EasyMqttMethod easyMqttMethod = new EasyMqttMethod();
        easyMqttService = easyMqttMethod.buildEasyMqttService();

        //获取数据
        easyMqttMethod.getMsg(new EasyMqttMethod.OnConnectListener() {
            @Override
            public void onConnectSuccess(String msg) {

            }

            @Override
            public void onConnectFailed(Exception e) {

            }
        });
    }

8.发送

//发送MQTT信息
            new EasyMqttMethod().publishString("msg", "RelayUAVGround", 0, false, easyMqttService);