Android推送 基于MQTT

客户端：

package com.example.fc.activity;

import android.app.AlarmManager;
import android.app.PendingIntent;
import android.app.Service;
import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import android.net.ConnectivityManager;
import android.net.NetworkInfo;
import android.os.Handler;
import android.os.HandlerThread;
import android.os.IBinder;
import android.provider.Settings.Secure;
import android.util.Log;

import org.eclipse.paho.client.mqttv3.IMqttDeliveryToken;
import org.eclipse.paho.client.mqttv3.MqttCallback;
import org.eclipse.paho.client.mqttv3.MqttClient;
import org.eclipse.paho.client.mqttv3.MqttDeliveryToken;
import org.eclipse.paho.client.mqttv3.MqttException;
import org.eclipse.paho.client.mqttv3.MqttMessage;
import org.eclipse.paho.client.mqttv3.MqttPersistenceException;
import org.eclipse.paho.client.mqttv3.MqttTopic;
import org.eclipse.paho.client.mqttv3.persist.MqttDefaultFilePersistence;

import java.util.Locale;


/** * 推送服务 */
public class MqttService extends Service implements MqttCallback {
    public static final String DEBUG_TAG = "MqttService"; // Log标记
    public static String            MQTT_CLIENT_ID = "Fangchao";
    private static final String MQTT_THREAD_NAME = "MqttService[" + DEBUG_TAG + "]"; // Handler Thread ID

    private static final String MQTT_BROKER_TEST = "192.168.0.183"; //测试地址
    private static final String MQTT_BROKER_ONLINE = "mqtt.supumall.com"; //正式地址
    private static final String MQTT_BROKER = MQTT_BROKER_TEST;

    private static final int MQTT_PORT = 1883;                // 服务器推送端口

    public static final int MQTT_QOS_0 = 0; //消息投放级别 QOS Level 0 (最多一次，有可能重复或丢失。 )
    public static final int MQTT_QOS_1 = 1; //消息投放级别 QOS Level 1 (至少一次，有可能重复。 )
    public static final int MQTT_QOS_2 = 2; //消息投放级别 QOS Level 2 (只有一次，确保消息只到达一次（用于比较严格的计费系统）。)

    public static final String[] topicFilters = {"Fangchao"};//订阅的主题
    public static int[] qos = {MQTT_QOS_0};//订阅级别

    private static final int MQTT_KEEP_ALIVE = 4 * 60 * 1000; //心跳包时间，毫秒
    private static final String MQTT_KEEP_ALIVE_TOPIC_FORAMT = "/users/%s/keepalive"; // Topic format for KeepAlives
    private static final byte[] MQTT_KEEP_ALIVE_MESSAGE = {0}; // 心跳包发送内容
    private static final int MQTT_KEEP_ALIVE_QOS = MQTT_QOS_0; //心跳包的发送级别默认最低

    private static final boolean MQTT_CLEAN_SESSION = true; // Start a clean session?

    private static final String MQTT_URL_FORMAT = "tcp://%s:%d"; // 推送url格式组装

    private static final String ACTION_START = MQTT_CLIENT_ID + ".START"; // Action to start 启动
    private static final String ACTION_STOP = MQTT_CLIENT_ID + ".STOP"; // Action to stop 停止
    private static final String ACTION_KEEPALIVE = MQTT_CLIENT_ID + ".KEEPALIVE"; // Action to keep alive used by alarm manager保持心跳闹钟使用
    private static final String ACTION_RECONNECT = MQTT_CLIENT_ID + ".RECONNECT"; // Action to reconnect 重新连接


    private static final String DEVICE_ID_FORMAT = "an_%s"; // 设备id的前缀
    // Note:设备id限制长度为23个 字符
    // An NPE if you go over that limit
    private boolean mStarted = false; //推送client是否启动
    private String mDeviceId;          // Device ID, Secure.ANDROID_ID
    private Handler mConnHandler;      // Seperate Handler thread for networking

    private MqttDefaultFilePersistence mDataStore; // Defaults to FileStore
// private MqttConnectOptions mOpts; //连接参数

    private MqttTopic mKeepAliveTopic;            // Instance Variable for Keepalive topic

    private MqttClient mClient;                    // Mqtt Client

    private AlarmManager mAlarmManager;            //闹钟
    private ConnectivityManager mConnectivityManager; //网络改变接收器

    /** * 启动推送服务 * * @param ctx context to start the service with * @return void */
    public static void actionStart(Context ctx) {
        Intent i = new Intent(ctx, MqttService.class);
        i.setAction(ACTION_START);
        ctx.startService(i);
    }

    /** * 停止推送服务 * * @param ctx context to start the service with * @return void */
    public static void actionStop(Context ctx) {
        Intent i = new Intent(ctx, MqttService.class);
        i.setAction(ACTION_STOP);
        ctx.startService(i);
    }

    /** * 发送心跳包 * * @param ctx context to start the service with * @return void */
    public static void actionKeepalive(Context ctx) {
        Intent i = new Intent(ctx, MqttService.class);
        i.setAction(ACTION_KEEPALIVE);
        ctx.startService(i);
    }

    /** * Initalizes the DeviceId and most instance variables * Including the Connection Handler, Datastore, Alarm Manager * and ConnectivityManager. * 初始化设备id和请求参数包含连接处理、数据存储、闹钟警报、网络接收器 */
    @Override
    public void onCreate() {
        super.onCreate();
        Log.e("fc","oncreate");
        //初始化设备id，长度不能超过23
        mDeviceId = String.format(DEVICE_ID_FORMAT,
                Secure.getString(getContentResolver(), Secure.ANDROID_ID));

        HandlerThread thread = new HandlerThread(MQTT_THREAD_NAME);
        thread.start();

        mConnHandler = new Handler(thread.getLooper());

        mDataStore = new MqttDefaultFilePersistence(getCacheDir().getAbsolutePath());


// mOpts = new MqttConnectOptions();
// mOpts.setCleanSession(MQTT_CLEAN_SESSION);
        // Do not set keep alive interval on mOpts we keep track of it with alarm's

        mAlarmManager = (AlarmManager) getSystemService(ALARM_SERVICE);
        mConnectivityManager = (ConnectivityManager) getSystemService(CONNECTIVITY_SERVICE);
    }

    @Override
    public boolean isRestricted() {
        return super.isRestricted();
    }

    /** * Service onStartCommand * Handles the action passed via the Intent * 通过意图处理服务 * * @return START_REDELIVER_INTENT */
    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {
        super.onStartCommand(intent, flags, startId);

        String action = intent.getAction();
        Log.e(DEBUG_TAG, "推送服务接收到一个请求 " + action);

        if (action == null) {
            Log.e(DEBUG_TAG, "推送服务接收到的请求为null！推送服务不执行任何操作");
        } else {
            if (action.equals(ACTION_START)) {
                       Log.e(DEBUG_TAG, "接收到《启动》推送服务命令");
                start();
            } else if (action.equals(ACTION_STOP)) {
                       Log.e(DEBUG_TAG, "接收到《停止》推送服务命令");
                stop();
            } else if (action.equals(ACTION_KEEPALIVE)) {
                       Log.e(DEBUG_TAG, "接收到《发送心跳包》推送服务命令");
                keepAlive();
            } else if (action.equals(ACTION_RECONNECT)) {
                       Log.e(DEBUG_TAG, "接收到《重启》推送服务命令");
                if (isNetworkAvailable()) {
                    reconnectIfNecessary();
                }
            }
        }

        return START_REDELIVER_INTENT;
    }

    /** * 尝试启动推送服务器，并注册网络改变接收器 */
    private synchronized void start() {
        if (mStarted) {
                   Log.e(DEBUG_TAG, "尝试启动推送服务，但推送服务已经启动");
            return;
        }

        if (hasScheduledKeepAlives()) {
            stopKeepAlives();
        }

        connect();

        registerReceiver(mConnectivityReceiver, new IntentFilter(ConnectivityManager.CONNECTIVITY_ACTION));
    }

    /** * 停止推送服务 */
    private synchronized void stop() {
        if (!mStarted) {
                   Log.e(DEBUG_TAG, "试图停止推送服务器但是推送服务并没有运行");
            return;
        }

        if (mClient != null) {
            mConnHandler.post(new Runnable() {
                @Override
                public void run() {
                    try {
                        mClient.disconnect();
                    } catch (MqttException ex) {
                        ex.printStackTrace();
                    }
                    mClient = null;
                    mStarted = false;

                    stopKeepAlives();
                }
            });
        }

        unregisterReceiver(mConnectivityReceiver);
    }

    /** * Connects to the broker with the appropriate datastore * 连接到推送服务器与适当的数据存储 */
    private synchronized void connect() {
        String url = String.format(Locale.US, MQTT_URL_FORMAT, MQTT_BROKER, MQTT_PORT);
               Log.e(DEBUG_TAG, "连接推送服务器 设备id：" + mDeviceId + " with URL: " + url);
        try {
            mClient = new MqttClient(url, mDeviceId, mDataStore);

        } catch (MqttException e) {
            e.printStackTrace();
        }

        mConnHandler.post(new Runnable() {
            @Override
            public void run() {
                try {
                    mClient.connect();

                    mClient.subscribe(topicFilters, qos);

                    mClient.setCallback(MqttService.this);

                    mStarted = true; // Service is now connected

                           Log.e(DEBUG_TAG, "成功连接推送服务器并启动心跳包闹钟");

                    startKeepAlives();
                } catch (MqttException e) {
                    e.printStackTrace();
                }
            }
        });
    }

    /** * 启动心跳包闹钟 */
    private void startKeepAlives() {
        Intent i = new Intent();
        i.setClass(this, MqttService.class);
        i.setAction(ACTION_KEEPALIVE);
        PendingIntent pi = PendingIntent.getService(this, 0, i, 0);
        mAlarmManager.setRepeating(AlarmManager.RTC_WAKEUP,
                System.currentTimeMillis() + MQTT_KEEP_ALIVE,
                MQTT_KEEP_ALIVE, pi);
    }

    /** * 取消已经存在的闹钟 */
    private void stopKeepAlives() {
        Intent i = new Intent();
        i.setClass(this, MqttService.class);
        i.setAction(ACTION_KEEPALIVE);
        PendingIntent pi = PendingIntent.getService(this, 0, i, 0);
        mAlarmManager.cancel(pi);
    }

    /** * 发送心跳数据到服务器 */
    private synchronized void keepAlive() {
        if (isConnected()) {
            try {
                sendKeepAlive();
                return;
            } catch (MqttConnectivityException ex) {
                ex.printStackTrace();
                reconnectIfNecessary();
            } catch (MqttPersistenceException ex) {
                ex.printStackTrace();
                stop();
            } catch (MqttException ex) {
                ex.printStackTrace();
                stop();
            }
        }
    }

    /** * 重新连接如果他是必须的 */
    private synchronized void reconnectIfNecessary() {

        if (mStarted && mClient == null) {
            connect();
        } else {
                   Log.e(DEBUG_TAG, "重新连接没有启动，mStarted:" + String.valueOf(mStarted) + " mClient:" + mClient);
        }
    }

    @Override
    public void onStart(Intent intent, int startId) {
        super.onStart(intent, startId);
    }

    /** * 通过ConnectivityManager查询网络连接状态 * * @return 如果网络状态正常则返回true反之flase */
    private boolean isNetworkAvailable() {
        NetworkInfo info = mConnectivityManager.getActiveNetworkInfo();

        return (info == null) ? false : info.isConnected() && info.isAvailable();

    }

    /** * 判断推送服务是否连接 * * @return 如果是连接的则返回true反之false */
    private boolean isConnected() {
        if (mStarted && mClient != null && !mClient.isConnected()) {
                   Log.e(DEBUG_TAG, "判断推送服务已经断开");
        }

        if (mClient != null) {
            return (mStarted && mClient.isConnected()) ? true : false;
        }

        return false;
    }

    /** * 网络状态发生变化接收器 */
    private final BroadcastReceiver mConnectivityReceiver = new BroadcastReceiver() {
        @Override
        public void onReceive(Context context, Intent intent) {
            if (isNetworkAvailable()) {
                       Log.e(DEBUG_TAG, "网络连接发生了变化--网络连接");
                reconnectIfNecessary();
            } else {
                       Log.e(DEBUG_TAG, "网络连接发生了变化--网络断开");
                stopKeepAlives();
                mClient = null;
            }
        }
    };

    /** * 发送保持连接的指定的主题 * * @return MqttDeliveryToken specified token you can choose to wait for completion */
    private synchronized MqttDeliveryToken sendKeepAlive()
            throws MqttConnectivityException, MqttPersistenceException, MqttException {
        if (!isConnected())
            throw new MqttConnectivityException();

        if (mKeepAliveTopic == null) {
            mKeepAliveTopic = mClient.getTopic(
                    String.format(Locale.US, MQTT_KEEP_ALIVE_TOPIC_FORAMT, mDeviceId));
        }

               Log.e(DEBUG_TAG, "向服务器发送心跳包url： " + MQTT_BROKER);

        MqttMessage message = new MqttMessage(MQTT_KEEP_ALIVE_MESSAGE);
        message.setQos(MQTT_KEEP_ALIVE_QOS);

        return mKeepAliveTopic.publish(message);
    }

    /** * 查询是否已经有一个心跳包的闹钟 * * @return 如果已经有一个心跳包的闹钟则返回true反之false */
    private synchronized boolean hasScheduledKeepAlives() {
        Intent i = new Intent();
        i.setClass(this, MqttService.class);
        i.setAction(ACTION_KEEPALIVE);
        PendingIntent pi = PendingIntent.getBroadcast(this, 0, i, PendingIntent.FLAG_NO_CREATE);

        return (pi != null) ? true : false;
    }


    @Override
    public IBinder onBind(Intent arg0) {
        return null;
    }

    /** * 连接丢失回调 */
    @Override
    public void connectionLost(Throwable arg0) {
               Log.e(DEBUG_TAG, "推送回调函数连接丢失connectionLost方法执行");
        stopKeepAlives();

        mClient = null;

        if (isNetworkAvailable()) {
            reconnectIfNecessary();
        }
    }

    /** * 收到推送信息 */
    @Override
    public void messageArrived(String topic, MqttMessage mqttMessage) throws Exception {
               Log.e(DEBUG_TAG, "收到推送信息如下\n Topic:\t" + topic +
                " Message:\t" + new String(mqttMessage.getPayload()) +
                " QoS:\t" + mqttMessage.getQos());

        com.example.fc.activity.MqttNotifier.notify(this, new String(mqttMessage.getPayload()));
    }

    @Override
    public void deliveryComplete(IMqttDeliveryToken iMqttDeliveryToken) {
               Log.e(DEBUG_TAG, "推送回调函数deliveryComplete方法执行");
    }

    /** * MqttConnectivityException Exception class */
    private class MqttConnectivityException extends Exception {
        private static final long serialVersionUID = -7385866796799469420L;
    }
}

服务端：

package com.fc;

import javax.jms.Connection;  
import javax.jms.ConnectionFactory;  
import javax.jms.DeliveryMode;  
import javax.jms.Destination;  
import javax.jms.JMSException;
import javax.jms.MessageProducer;  
import javax.jms.Session;  
import javax.jms.TextMessage;  
import javax.jms.TopicConnection;
import javax.jms.TopicConnectionFactory;
import javax.jms.TopicSession;
import javax.swing.JScrollBar;

import org.apache.activemq.ActiveMQConnection;  
import org.apache.activemq.ActiveMQConnectionFactory;  
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;

import com.ibm.mqtt.MqttClient;
import com.ibm.mqtt.MqttException;
import com.ibm.mqtt.MqttSimpleCallback;


@SuppressWarnings("unused")
public class MqttBroker {  
    private static final int SEND_NUMBER = 5;  
    static TopicConnection  connection;
    static TopicSession session;/* public static void main(String[] args) throws JMSException { // ConnectionFactory ：连接工厂，JMS 用它创建连接 ConnectionFactory connectionFactory; // Connection ：JMS 客户端到JMS Provider 的连接 Connection connection = null; // Session： 一个发送或接收消息的线程 Session session; // Destination ：消息的目的地;消息发送给谁. ActiveMQConnectionFactory Destination destination; // MessageProducer：消息发送者 MessageProducer producer; // TextMessage message; // 构造ConnectionFactory实例对象，此处采用ActiveMq的实现jar connectionFactory = new ActiveMQConnectionFactory(ActiveMQConnection.DEFAULT_USER, ActiveMQConnection.DEFAULT_PASSWORD, "tcp://192.168.0.183:61616"); try { // 构造从工厂得到连接对象 connection = connectionFactory.createConnection(); // 启动 connection.start(); // 获取操作连接 session = connection.createSession(Boolean.TRUE, Session.AUTO_ACKNOWLEDGE); // 获取session注意参数值xingbo.xu-queue是一个服务器的queue，须在在ActiveMq的console配置 destination = session.createQueue("FirstQueue"); // 得到消息生成者【发送者】 producer = session.createProducer(destination); // 设置不持久化，此处学习，实际根据项目决定 producer.setDeliveryMode(DeliveryMode.NON_PERSISTENT); // 构造消息，此处写死，项目就是参数，或者方法获取 sendMessage(session, producer); session.commit(); } catch (Exception e) { e.printStackTrace(); } finally { try { if (null != connection) connection.close(); } catch (Throwable ignore) { } } init(); sendMessage("client123456","11111111111111111111111111111111"); } private static void init() throws JMSException { // 创建链接工厂 TopicConnectionFactory factory = new ActiveMQConnectionFactory( ActiveMQConnection.DEFAULT_USER, ActiveMQConnection.DEFAULT_PASSWORD, "tcp://192.168.0.183:1883"); connection = factory.createTopicConnection(); // 启动连接 connection.start(); System.out.println("启动成功"); // 创建一个session会话 transacted session = connection.createTopicSession( Boolean.TRUE, Session.AUTO_ACKNOWLEDGE); } *//** * 关闭connection和session * * @throws Exception *//* private void close() throws Exception { // 关闭释放资源 if (session != null) { session.close(); session = null; } if (connection != null) { connection.close(); connection = null; } System.out.println("断开连接"); } public static int sendMessage( String DESTINATION,String message)throws Exception { for (int i = 1; i <= 1; i++) { TextMessage message = session.createTextMessage("ActiveMq 发送的消息" + i); // 发送消息到目的地方 System.out.println("发送消息：" + "ActiveMq 发送的消息" + i); producer.send(message); } javax.jms.Topic topic; try { // 创建一个消息队列 topic = session.createTopic(DESTINATION); } catch (Exception e) { init(); topic = session.createTopic(DESTINATION); } // 创建消息发送者 javax.jms.TopicPublisher publisher = session.createPublisher(topic); // 设置持久化模式 publisher.setDeliveryMode(DeliveryMode.PERSISTENT); // flag=0,表示成功;flag=1,表示失败 int flag = 0; System.out.println(message); TextMessage textMessage = session.createTextMessage(message); publisher.send(textMessage); return flag; } */


     private final static Log logger = LogFactory.getLog(MqttBroker.class);// 日志对象 
        // 连接参数 
        private final static String CONNECTION_STRING = "tcp://192.168.0.183:1883";  
// private final static String CONNECTION_STRING = "tcp://192.168.0.183:1883"; 

        private final static boolean CLEAN_START = true;  
        private final static short KEEP_ALIVE = 30;// 低耗网络，但是又需要及时获取数据，心跳30s 
        private final static String CLIENT_ID = "master";// 客户端标识 
        private final static int[] QOS_VALUES = { 0, 0, 2, 0 };// 对应主题的消息级别 
        private final static String[] TOPICS = { "Test/TestTopics/Topic1",  
                "Test/TestTopics/Topic2", "Test/TestTopics/Topic3",  
                "client/keepalive" };  
        private static MqttBroker instance = new MqttBroker();  

        private MqttClient mqttClient;  

        /** * 返回实例对象 * * @return */  
        public static MqttBroker getInstance() {  
            return instance;  
        }  

        /** * 重新连接服务 */  
        private void connect() throws MqttException {  
            logger.info("connect to mqtt broker.");  
            System.out.println("connect to mqtt broker.");  
            mqttClient = new MqttClient(CONNECTION_STRING);  
            logger.info("***********register Simple Handler***********");  
            System.out.println("***********register Simple Handler***********");  
            SimpleCallbackHandler simpleCallbackHandler = new SimpleCallbackHandler();  
            mqttClient.registerSimpleHandler(simpleCallbackHandler);// 注册接收消息方法 
            mqttClient.connect(CLIENT_ID, CLEAN_START, KEEP_ALIVE);  
            logger.info("***********subscribe receiver topics***********");  
            System.out.println("***********subscribe receiver topics***********");  
            mqttClient.subscribe(TOPICS, QOS_VALUES);// 订阅接主题 

            logger.info("***********CLIENT_ID:" + CLIENT_ID);  
            System.out.println("***********CLIENT_ID:" + CLIENT_ID);  
            /** * 完成订阅后，可以增加心跳，保持网络通畅，也可以发布自己的消息 */  
            mqttClient.publish("keepalive", "keepalive".getBytes(), QOS_VALUES[0],  
                    true);// 增加心跳，保持网络通畅 
        }  

        /** * 发送消息 * * @param clientId 客户端主题 不是id * @param messageId */  
        public void sendMessage(String clientId, String message) {  
            try {  
                if (mqttClient == null || !mqttClient.isConnected()) {  
                    connect();  
                }  
                System.out.println("send message to " + clientId + ", message is "  
                        + message);  
                logger.info("send message to " + clientId + ", message is "  
                        + message);  
                // 发布自己的消息 
                mqttClient.publish(clientId, message.getBytes(),  
                        0, false);  
                /*mqttClient.publish("GMCC/tokudu/" + clientId, message.getBytes(), 0, false); */ 
              System.out.println(" #####################" + CLIENT_ID);  
            } catch (MqttException e) {  
                logger.error(e.getCause());  
                e.printStackTrace();  
            }  
        }  

        /** * 简单回调函数，处理server接收到的主题消息 * * @author Join * */  
        class SimpleCallbackHandler implements MqttSimpleCallback {  

            /** * 当客户机和broker意外断开时触发 可以再此处理重新订阅 */  
            @Override  
            public void connectionLost() throws Exception {  
                // TODO Auto-generated method stub 
                System.out.println("客户机和broker已经断开");  
            }  

            /** 和broker已 * 客户端订阅消息后，该方法负责回调接收处理消息 */  
            @Override  
            public void publishArrived(String topicName, byte[] payload, int Qos,  
                    boolean retained) throws Exception {  
                // TODO Auto-generated method stub 
                System.out.println("订阅主题: " + topicName);  
                System.out.println("消息数据: " + new String(payload));  
                System.out.println("消息级别(0,1,2): " + Qos);  
                System.out.println("是否是实时发送的消息(false=实时，true=服务器上保留的最后消息): "  
                        + retained);  
            }  

        }  

        public static void main(String[] args) {  
            String ss="{\"title\": \"ghjklffff\",\"content\":\"aaaaaaaaaaaaaaaaaaa\",\"type\":1}";
            new MqttBroker().sendMessage("Fangchao",ss.replace("\\", ""));  
        }  //一定要用tokudu/a06e51a5f424fb70 不要用tokudu.aasdf 用反斜杠 不要用点
    } 

客户端 服务器 所用到的jar 包 。只用wmqtt.jar 就可以进行发送与接收消息，但notification弹窗跳转有问题，所以客户端 改用org.eclipse ….jar 服务器还用wmqtt.jar 就可以.客户端有两个接受推送服务：第一个是pushservice 用的是wmqtt.jar 第二个是Mqttservice 用到的是org.eclipse…那个。这两个服务可以在pushactivity中切换，去掉注释即可。下载链接

客户端源码 只看PushClient