MQTT实现消息推送

MQTT实现消息接收(接收消息需实现MqttSimpleCallback接口并实现它的publishArrived方法)必须注册接收消息方法

[java]

mqttClient.registerSimpleHandler(simpleCallbackHandler);
// 注册接收消息方法

[/java]

和订阅接主题

[java]</pre>
mqttClient.subscribe(TOPICS, QOS_VALUES);

// 订阅接主题
<pre>[/java]

服务端：

[java]</pre>
package com.gmcc.kuchuan.business;

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;

/**
 * MQTT消息发送与接收
 * @author Join
 *
 */
public class MqttBroker {
 private final static Log logger = LogFactory.getLog(MqttBroker.class);// 日志对象
 // 连接参数
 private final static String CONNECTION_STRING = "tcp://localhost:9901";
 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.");
 mqttClient = new MqttClient(CONNECTION_STRING);
 logger.info("***********register Simple Handler***********");
 SimpleCallbackHandler simpleCallbackHandler = new SimpleCallbackHandler();
 mqttClient.registerSimpleHandler(simpleCallbackHandler);// 注册接收消息方法
 mqttClient.connect(CLIENT_ID, CLEAN_START, KEEP_ALIVE);
 logger.info("***********subscribe receiver topics***********");
 mqttClient.subscribe(TOPICS, QOS_VALUES);// 订阅接主题

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

/**
 * 发送消息
 *
 * @param clientId
 * @param messageId
 */
 public void sendMessage(String clientId, String message) {
 try {
 if (mqttClient == null || !mqttClient.isConnected()) {
 connect();
 }

logger.info("send message to " + clientId + ", message is "
 + message);
 // 发布自己的消息
 mqttClient.publish("GMCC/client/" + clientId, message.getBytes(),
 0, false);
 } 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已经断开");
 }

/**
 * 客户端订阅消息后，该方法负责回调接收处理消息
 */
 @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) {
 new MqttBroker().sendMessage("client", "message");
 }
}
<pre>
[/java]

Android客户端：

核心代码：MQTTConnection内部类

[java]

<pre class="java" name="code">import java.io.ByteArrayInputStream;
import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.io.RandomAccessFile;
import java.net.HttpURLConnection;
import java.net.URL;
import java.util.ArrayList;
import java.util.Timer;
import java.util.TimerTask;

import android.app.AlarmManager;
import android.app.Notification;
import android.app.NotificationManager;
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.content.SharedPreferences;
import android.database.Cursor;
import android.net.ConnectivityManager;
import android.net.NetworkInfo;
import android.os.Binder;
import android.os.Bundle;
import android.os.IBinder;
import android.provider.ContactsContract;
import android.util.Log;
//此部分项目导包已被删除</pre><pre class="java" name="code">import com.ibm.mqtt.IMqttClient;
import com.ibm.mqtt.MqttClient;
import com.ibm.mqtt.MqttException;
import com.ibm.mqtt.MqttPersistence;
import com.ibm.mqtt.MqttPersistenceException;
import com.ibm.mqtt.MqttSimpleCallback;

/*
 * PushService that does all of the work.
 * Most of the logic is borrowed from KeepAliveService.
 * http://code.google.com/p/android-random/source/browse/trunk/TestKeepAlive/src/org/devtcg/demo/keepalive/KeepAliveService.java?r=219
 */
public class PushService extends Service {
	private MyBinder mBinder = new MyBinder();
	// this is the log tag
	public static final String TAG = "PushService";

	// the IP address, where your MQTT broker is running.
	private static final String MQTT_HOST = "120.197.230.53"; // "209.124.50.174";//
	// the port at which the broker is running.
	private static int MQTT_BROKER_PORT_NUM = 9901;
	// Let's not use the MQTT persistence.
	private static MqttPersistence MQTT_PERSISTENCE = null;
	// We don't need to remember any state between the connections, so we use a
	// clean start.
	private static boolean MQTT_CLEAN_START = true;
	// Let's set the internal keep alive for MQTT to 15 mins. I haven't tested
	// this value much. It could probably be increased.
	private static short MQTT_KEEP_ALIVE = 60 * 15;
	// Set quality of services to 0 (at most once delivery), since we don't want
	// push notifications
	// arrive more than once. However, this means that some messages might get
	// lost (delivery is not guaranteed)
	private static int[] MQTT_QUALITIES_OF_SERVICE = { 0 };
	private static int MQTT_QUALITY_OF_SERVICE = 0;
	// The broker should not retain any messages.
	private static boolean MQTT_RETAINED_PUBLISH = false;

	// MQTT client ID, which is given the broker. In this example, I also use
	// this for the topic header.
	// You can use this to run push notifications for multiple apps with one
	// MQTT broker.
	public static String MQTT_CLIENT_ID = "client";

	// These are the actions for the service (name are descriptive enough)
	public static final String ACTION_START = MQTT_CLIENT_ID + ".START";
	private static final String ACTION_STOP = MQTT_CLIENT_ID + ".STOP";
	private static final String ACTION_KEEPALIVE = MQTT_CLIENT_ID
			+ ".KEEP_ALIVE";
	private static final String ACTION_RECONNECT = MQTT_CLIENT_ID
			+ ".RECONNECT";

	// Connection log for the push service. Good for debugging.
	private ConnectionLog mLog;

	// Connectivity manager to determining, when the phone loses connection
	private ConnectivityManager mConnMan;
	// Notification manager to displaying arrived push notifications
	private NotificationManager mNotifMan;

	// Whether or not the service has been started.
	private boolean mStarted;

	// This the application level keep-alive interval, that is used by the
	// AlarmManager
	// to keep the connection active, even when the device goes to sleep.
	private static final long KEEP_ALIVE_INTERVAL = 1000 * 60 * 28;

	// Retry intervals, when the connection is lost.
	private static final long INITIAL_RETRY_INTERVAL = 1000 * 10;
	private static final long MAXIMUM_RETRY_INTERVAL = 1000 * 60 * 30;

	// Preferences instance
	private SharedPreferences mPrefs;
	// We store in the preferences, whether or not the service has been started
	public static final String PREF_STARTED = "isStarted";
	// We also store the deviceID (target)
	public static final String PREF_DEVICE_ID = "deviceID";
	// We store the last retry interval
	public static final String PREF_RETRY = "retryInterval";

	// Notification title
	public static String NOTIF_TITLE = "client";
	// Notification id
	private static final int NOTIF_CONNECTED = 0;

	// This is the instance of an MQTT connection.
	private MQTTConnection mConnection;
	private long mStartTime;
	boolean mShowFlag = true;// 是否显示通知
	public static Context ctx;
	private boolean mRunFlag = true;// 是否向服务器发送心跳
	Timer mTimer = new Timer();

	// Static method to start the service
	public static void actionStart(Context ctx) {
		Intent i = new Intent(ctx, PushService.class);
		i.setAction(ACTION_START);
		ctx.startService(i);
		PushService.ctx = ctx;
	}

	// Static method to stop the service
	public static void actionStop(Context ctx) {
		Intent i = new Intent(ctx, PushService.class);
		i.setAction(ACTION_STOP);
		ctx.startService(i);
	}

	// Static method to send a keep alive message
	public static void actionPing(Context ctx) {
		Intent i = new Intent(ctx, PushService.class);
		i.setAction(ACTION_KEEPALIVE);
		ctx.startService(i);
	}

	@Override
	public void onCreate() {
		super.onCreate();

		log("Creating service");
		mStartTime = System.currentTimeMillis();

		try {
			mLog = new ConnectionLog();
			Log.i(TAG, "Opened log at " + mLog.getPath());
		} catch (IOException e) {
			Log.e(TAG, "Failed to open log", e);
		}

		// Get instances of preferences, connectivity manager and notification
		// manager
		mPrefs = getSharedPreferences(TAG, MODE_PRIVATE);
		mConnMan = (ConnectivityManager) getSystemService(CONNECTIVITY_SERVICE);
		mNotifMan = (NotificationManager) getSystemService(NOTIFICATION_SERVICE);

		/*
		 * If our process was reaped by the system for any reason we need to
		 * restore our state with merely a call to onCreate. We record the last
		 * "started" value and restore it here if necessary.
		 */
		handleCrashedService();
	}

	// This method does any necessary clean-up need in case the server has been
	// destroyed by the system
	// and then restarted
	private void handleCrashedService() {
		if (wasStarted() == true) {
			log("Handling crashed service...");
			// stop the keep alives
			stopKeepAlives();

			// Do a clean start
			start();
		}
	}

	@Override
	public void onDestroy() {
		log("Service destroyed (started=" + mStarted + ")");

		// Stop the services, if it has been started
		if (mStarted == true) {
			stop();
		}

		try {
			if (mLog != null)
				mLog.close();
		} catch (IOException e) {
		}
	}

	@Override
	public void onStart(Intent intent, int startId) {
		super.onStart(intent, startId);
		log("Service started with intent=" + intent);
		if (intent == null) {
			return;
		}
		// Do an appropriate action based on the intent.
		if (intent.getAction().equals(ACTION_STOP) == true) {
			stop();
			stopSelf();
		} else if (intent.getAction().equals(ACTION_START) == true) {
			start();

		} else if (intent.getAction().equals(ACTION_KEEPALIVE) == true) {
			keepAlive();
		} else if (intent.getAction().equals(ACTION_RECONNECT) == true) {
			if (isNetworkAvailable()) {
				reconnectIfNecessary();
			}
		}
	}

	public class MyBinder extends Binder {
		public PushService getService() {
			return PushService.this;
		}
	}

	@Override
	public IBinder onBind(Intent intent) {
		return mBinder;
	}

	// log helper function
	private void log(String message) {
		log(message, null);
	}

	private void log(String message, Throwable e) {
		if (e != null) {
			Log.e(TAG, message, e);

		} else {
			Log.i(TAG, message);
		}

		if (mLog != null) {
			try {
				mLog.println(message);
			} catch (IOException ex) {
			}
		}
	}

	// Reads whether or not the service has been started from the preferences
	private boolean wasStarted() {
		return mPrefs.getBoolean(PREF_STARTED, false);
	}

	// Sets whether or not the services has been started in the preferences.
	private void setStarted(boolean started) {
		mPrefs.edit().putBoolean(PREF_STARTED, started).commit();
		mStarted = started;
	}

	private synchronized void start() {
		log("Starting service...");

		// Do nothing, if the service is already running.
		if (mStarted == true) {
			Log.w(TAG, "Attempt to start connection that is already active");
			return;
		}

		// Establish an MQTT connection

		connect();

		// 向服务器定时发送心跳，一分钟一次
		mRunFlag = true;
		mTimer.schedule(new TimerTask() {
			@Override
			public void run() {
				if (!mRunFlag) {
					// this.cancel();
					// PushService.this.stopSelf();
					return;
				}
				System.out.println("run");
				try {
					if (isNetworkAvailable()) {
						SharedPreferences pref = getSharedPreferences(
								"client", 0);
						String MOBILE_NUM = pref.getString("MOBILE_NUM", "");
						HttpUtil.post(Constants.KEEPALIVE + "&mobile="
								+ MOBILE_NUM + "&online_flag=1");
					}
				} catch (Exception e) {
					e.printStackTrace();
					// TODO: handle exception
				}
			}
		}, 0, 60 * 1000);
		// Register a connectivity listener
		registerReceiver(mConnectivityChanged, new IntentFilter(
				ConnectivityManager.CONNECTIVITY_ACTION));
	}

	private synchronized void stop() {
		// Do nothing, if the service is not running.
		if (mStarted == false) {
			Log.w(TAG, "Attempt to stop connection not active.");
			return;
		}

		// Save stopped state in the preferences
		setStarted(false);

		// Remove the connectivity receiver
		unregisterReceiver(mConnectivityChanged);
		// Any existing reconnect timers should be removed, since we explicitly
		// stopping the service.
		cancelReconnect();

		// Destroy the MQTT connection if there is one
		if (mConnection != null) {
			mConnection.disconnect();
			mConnection = null;
		}
	}

	//
	private synchronized void connect() {
		log("Connecting...");
		// Thread t = new Thread() {
		// @Override
		// public void run() {
		// fetch the device ID from the preferences.
		String deviceID = "GMCC/client/"
				+ mPrefs.getString(PREF_DEVICE_ID, null);

		// Create a new connection only if the device id is not NULL
		try {
			mConnection = new MQTTConnection(MQTT_HOST, deviceID);
		} catch (MqttException e) {
			// Schedule a reconnect, if we failed to connect
			log("MqttException: "
					+ (e.getMessage() != null ? e.getMessage() : "NULL"));
			if (isNetworkAvailable()) {
				scheduleReconnect(mStartTime);
			}
		}
		setStarted(true);
		// }
		// };
		// t.start();
		// 向服务器定时发送心跳，一分钟一次
		mRunFlag = true;
	}

	private synchronized void keepAlive() {
		try {
			// Send a keep alive, if there is a connection.
			if (mStarted == true && mConnection != null) {
				mConnection.sendKeepAlive();
			}
		} catch (MqttException e) {
			log("MqttException: "
					+ (e.getMessage() != null ? e.getMessage() : "NULL"), e);

			mConnection.disconnect();
			mConnection = null;
			cancelReconnect();
		}
	}

	// Schedule application level keep-alives using the AlarmManager
	private void startKeepAlives() {
		Intent i = new Intent();
		i.setClass(this, PushService.class);
		i.setAction(ACTION_KEEPALIVE);
		PendingIntent pi = PendingIntent.getService(this, 0, i, 0);
		AlarmManager alarmMgr = (AlarmManager) getSystemService(ALARM_SERVICE);
		alarmMgr.setRepeating(AlarmManager.RTC_WAKEUP,
				System.currentTimeMillis() + KEEP_ALIVE_INTERVAL,
				KEEP_ALIVE_INTERVAL, pi);
	}

	// Remove all scheduled keep alives
	private void stopKeepAlives() {
		Intent i = new Intent();
		i.setClass(this, PushService.class);
		i.setAction(ACTION_KEEPALIVE);
		PendingIntent pi = PendingIntent.getService(this, 0, i, 0);
		AlarmManager alarmMgr = (AlarmManager) getSystemService(ALARM_SERVICE);
		alarmMgr.cancel(pi);
	}

	// We schedule a reconnect based on the starttime of the service
	public void scheduleReconnect(long startTime) {
		// the last keep-alive interval
		long interval = mPrefs.getLong(PREF_RETRY, INITIAL_RETRY_INTERVAL);

		// Calculate the elapsed time since the start
		long now = System.currentTimeMillis();
		long elapsed = now - startTime;

		// Set an appropriate interval based on the elapsed time since start
		if (elapsed < interval) {
			interval = Math.min(interval * 4, MAXIMUM_RETRY_INTERVAL);
		} else {
			interval = INITIAL_RETRY_INTERVAL;
		}

		log("Rescheduling connection in " + interval + "ms.");

		// Save the new internval
		mPrefs.edit().putLong(PREF_RETRY, interval).commit();

		// Schedule a reconnect using the alarm manager.
		Intent i = new Intent();
		i.setClass(this, PushService.class);
		i.setAction(ACTION_RECONNECT);
		PendingIntent pi = PendingIntent.getService(this, 0, i, 0);
		AlarmManager alarmMgr = (AlarmManager) getSystemService(ALARM_SERVICE);
		alarmMgr.set(AlarmManager.RTC_WAKEUP, now + interval, pi);
	}

	// Remove the scheduled reconnect
	public void cancelReconnect() {
		Intent i = new Intent();
		i.setClass(PushService.this, PushService.class);
		i.setAction(ACTION_RECONNECT);
		PendingIntent pi = PendingIntent.getService(PushService.this, 0, i, 0);
		AlarmManager alarmMgr = (AlarmManager) getSystemService(ALARM_SERVICE);
		alarmMgr.cancel(pi);
	}

	private synchronized void reconnectIfNecessary() {
		log("mStarted" + mStarted);
		log("mConnection" + mConnection);
		if (mStarted == true && mConnection == null) {
			log("Reconnecting...");
			connect();
		}
	}

	// This receiver listeners for network changes and updates the MQTT
	// connection
	// accordingly
	private BroadcastReceiver mConnectivityChanged = new BroadcastReceiver() {
		@Override
		public void onReceive(Context context, final Intent intent) {
			// Get network info
			// Thread mReconnect = new Thread(){
			// public void run() {
			NetworkInfo info = (NetworkInfo) intent
					.getParcelableExtra(ConnectivityManager.EXTRA_NETWORK_INFO);
			// Is there connectivity?
			boolean hasConnectivity = (info != null && info.isConnected()) ? true
					: false;

			log("Connectivity changed: connected=" + hasConnectivity);

			if (hasConnectivity) {
				reconnectIfNecessary();
			} else if (mConnection != null) {
				// Thread cancelConn = new Thread(){
				// public void run() {
				// // if there no connectivity, make sure MQTT connection is
				// destroyed
				log("cancelReconnect");
				mConnection.disconnect();
				mConnection = null;
				log("cancelReconnect" + mConnection);
				cancelReconnect();
				// }
				// };
				// cancelConn.start();
			}
			// };
			//
			// };
			// mReconnect.start();
		}
	};

	// Display the topbar notification
	private void showNotification(String text, Request request) {

		Notification n = new Notification();
		n.flags |= Notification.FLAG_SHOW_LIGHTS;
		n.flags |= Notification.FLAG_AUTO_CANCEL;
		n.defaults = Notification.DEFAULT_ALL;
		n.icon = R.drawable.ico;
		n.when = System.currentTimeMillis();
		Intent intent = new Intent();
		Bundle bundle = new Bundle();
		bundle.putSerializable("request", request);
		bundle.putString("currentTab", "1");
		intent.putExtras(bundle);
		intent.setClass(this, MainActivity.class);
		intent.setAction(Intent.ACTION_MAIN);
		intent.addCategory(Intent.CATEGORY_LAUNCHER);
		intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK
				| Intent.FLAG_ACTIVITY_RESET_TASK_IF_NEEDED);
		// Simply open the parent activity
		PendingIntent pi = PendingIntent.getActivity(this, 0, intent, 0);

		// Change the name of the notification here
		n.setLatestEventInfo(this, NOTIF_TITLE, text, pi);
		mNotifMan.notify(NOTIF_CONNECTED, n);
	}

	// Check if we are online
	private boolean isNetworkAvailable() {
		NetworkInfo info = mConnMan.getActiveNetworkInfo();
		if (info == null) {
			return false;
		}
		return info.isConnected();
	}

<span style="BACKGROUND-COLOR: #ccffff">	// This inner class is a wrapper on top of MQTT client.
	private class MQTTConnection implements MqttSimpleCallback {
		IMqttClient mqttClient = null;

		// Creates a new connection given the broker address and initial topic
		public MQTTConnection(String brokerHostName, String initTopic)
				throws MqttException {
			// Create connection spec
			String mqttConnSpec = "tcp://" + brokerHostName + "@"
					+ MQTT_BROKER_PORT_NUM;
			// Create the client and connect
			mqttClient = MqttClient.createMqttClient(mqttConnSpec,
					MQTT_PERSISTENCE);
			String clientID = MQTT_CLIENT_ID + "/"
					+ mPrefs.getString(PREF_DEVICE_ID, "");
			Log.d(TAG, "mqttConnSpec:" + mqttConnSpec + "  clientID:"
					+ clientID);
			mqttClient.connect(clientID, MQTT_CLEAN_START, MQTT_KEEP_ALIVE);

			// register this client app has being able to receive messages
			mqttClient.registerSimpleHandler(this);

			// Subscribe to an initial topic, which is combination of client ID
			// and device ID.
			// initTopic = MQTT_CLIENT_ID + "/" + initTopic;
			subscribeToTopic(initTopic);

			log("Connection established to " + brokerHostName + " on topic "
					+ initTopic);

			// Save start time
			mStartTime = System.currentTimeMillis();
			// Star the keep-alives
			startKeepAlives();
		}

		// Disconnect
		public void disconnect() {
			// try {
			stopKeepAlives();
			log("stopKeepAlives");
			Thread t = new Thread() {
				public void run() {
					try {
						mqttClient.disconnect();
						log("mqttClient.disconnect();");
					} catch (MqttPersistenceException e) {
						log("MqttException"
								+ (e.getMessage() != null ? e.getMessage()
										: " NULL"), e);
					}
				};
			};
			t.start();
			// } catch (MqttPersistenceException e) {
			// log("MqttException"
			// + (e.getMessage() != null ? e.getMessage() : " NULL"),
			// e);
			// }
		}

		/*
		 * Send a request to the message broker to be sent messages published
		 * with the specified topic name. Wildcards are allowed.
		 */
		private void subscribeToTopic(String topicName) throws MqttException {

			if ((mqttClient == null) || (mqttClient.isConnected() == false)) {
				// quick sanity check - don't try and subscribe if we don't have
				// a connection
				log("Connection error" + "No connection");
			} else {
				String[] topics = { topicName };
				mqttClient.subscribe(topics, MQTT_QUALITIES_OF_SERVICE);
			}
		}

		/*
		 * Sends a message to the message broker, requesting that it be
		 * published to the specified topic.
		 */
		private void publishToTopic(String topicName, String message)
				throws MqttException {
			if ((mqttClient == null) || (mqttClient.isConnected() == false)) {
				// quick sanity check - don't try and publish if we don't have
				// a connection
				log("No connection to public to");
			} else {
				mqttClient.publish(topicName, message.getBytes(),
						MQTT_QUALITY_OF_SERVICE, MQTT_RETAINED_PUBLISH);
			}
		}

		/*
		 * Called if the application loses it's connection to the message
		 * broker.
		 */
		public void connectionLost() throws Exception {
			log("Loss of connection" + "connection downed");
			stopKeepAlives();
			// 取消定时发送心跳
			mRunFlag = false;
			// 向服务器发送请求，更改在线状态
			// SharedPreferences pref = getSharedPreferences("client",0);
			// String MOBILE_NUM=pref.getString("MOBILE_NUM", "");
			// HttpUtil.post(Constants.KEEPALIVE + "&mobile="
			// + MOBILE_NUM+"&online_flag=0");
			// null itself
			mConnection = null;
			if (isNetworkAvailable() == true) {
				reconnectIfNecessary();
			}
		}

		/*
		 * Called when we receive a message from the message broker.
		 */
		public void publishArrived(String topicName, byte[] payload, int qos,
				boolean retained) throws MqttException {
			// Show a notification
			// synchronized (lock) {
			String s = new String(payload);
			Request request = null;
			try {// 解析服务端推送过来的消息
				request = XmlPaserTool.getMessage(new ByteArrayInputStream(s
						.getBytes()));
				// request=Constants.request;
			} catch (Exception e) {
				e.printStackTrace();
			}
			final Request mRequest = request;
			DownloadInfo down = new DownloadInfo(mRequest);
			down.setDownLoad(down);
			downloadInfos.add(down);
			sendUpdateBroast();
			down.start();
			showNotification("您有一条新的消息!", mRequest);
			Log.d(PushService.TAG, s);
			Log.d(PushService.TAG, mRequest.getMessageId());
			// 再向服务端推送消息
			new AdvancedCallbackHandler().sendMessage(MQTT_CLIENT_ID
					+ "/keepalive", "***********send message**********");
		}

		public void sendKeepAlive() throws MqttException {
			log("Sending keep alive");
			// publish to a keep-alive topic
			publishToTopic(MQTT_CLIENT_ID + "/keepalive",
					mPrefs.getString(PREF_DEVICE_ID, ""));
		}
	}

	class AdvancedCallbackHandler {
		IMqttClient mqttClient = null;
		public final int[] QOS_VALUES = { 0, 0, 2, 0 };// 对应主题的消息级别

		/**
		 * 重新连接服务
		 */
		private void connect() throws MqttException {
			String mqttConnSpec = "tcp://" + MQTT_HOST + "@"
					+ MQTT_BROKER_PORT_NUM;
			// Create the client and connect
			mqttClient = MqttClient.createMqttClient(mqttConnSpec,
					MQTT_PERSISTENCE);
			String clientID = MQTT_CLIENT_ID + "/"
					+ mPrefs.getString(PREF_DEVICE_ID, "");
			mqttClient.connect(clientID, MQTT_CLEAN_START, MQTT_KEEP_ALIVE);
			Log.d(TAG, "连接服务器，推送消息");
			Log.d(TAG, "**mqttConnSpec:" + mqttConnSpec + "  clientID:"
					+ clientID);
			Log.d(TAG, MQTT_CLIENT_ID + "/keepalive");
			// 增加心跳，保持网络通畅
			mqttClient.publish(MQTT_CLIENT_ID + "/keepalive",
					"keepalive".getBytes(), QOS_VALUES[0], true);
		}

		/**
		 * 发送消息
		 *
		 * @param clientId
		 * @param messageId
		 */
		public void sendMessage(String clientId, String message) {
			try {
				if (mqttClient == null || !mqttClient.isConnected()) {
					connect();
				}

				Log.d(TAG, "send message to " + clientId + ", message is "
						+ message);
				// 发布自己的消息
				// mqttClient.publish(MQTT_CLIENT_ID + "/keepalive",
				// message.getBytes(), 0, false);
				mqttClient.publish(MQTT_CLIENT_ID + "/keepalive",
						message.getBytes(), 0, false);
			} catch (MqttException e) {
				Log.d(TAG, e.getCause() + "");
				e.printStackTrace();
			}
		}
	}
</span>
	public String getPeople(String phone_number) {
		String name = "";
		String[] projection = { ContactsContract.PhoneLookup.DISPLAY_NAME,
				ContactsContract.CommonDataKinds.Phone.NUMBER };
		Log.d(TAG, "getPeople ---------");
		// 将自己添加到 msPeers 中
		Cursor cursor = this.getContentResolver().query(
				ContactsContract.CommonDataKinds.Phone.CONTENT_URI,
				projection, // Which columns to return.
				ContactsContract.CommonDataKinds.Phone.NUMBER + " = '"
						+ phone_number + "'", // WHERE clause.
				null, // WHERE clause value substitution
				null); // Sort order.

		if (cursor == null) {
			Log.d(TAG, "getPeople null");
			return "";
		}
		Log.d(TAG, "getPeople cursor.getCount() = " + cursor.getCount());
		if (cursor.getCount() > 0) {
			cursor.moveToPosition(0);

			// 取得联系人名字
			int nameFieldColumnIndex = cursor
					.getColumnIndex(ContactsContract.PhoneLookup.DISPLAY_NAME);
			name = cursor.getString(nameFieldColumnIndex);
			Log.i("Contacts", "" + name + " .... " + nameFieldColumnIndex); // 这里提示
																			// force
																			// close
			System.out.println("联系人姓名：" + name);
			return name;
		}
		return phone_number;
	}

	public void sendUpdateBroast() {
		Intent intent = new Intent();
		intent.setAction("update");
		sendBroadcast(intent);
	}

	public void sendUpdateFinishBroast() {
		Intent intent = new Intent();
		intent.setAction("updateFinishList");
		sendBroadcast(intent);
	}

	public class DownloadInfo extends Thread {
		boolean runflag = true;
		Request mRequest;
		public float progress;
		public MessageBean bean = null;
		DownloadInfo download = null;
		MessageDetailDao dao = new MessageDetailDao(
				PushService.this.getApplicationContext());

		public synchronized void stopthread() {
			runflag = false;
		}

		public synchronized boolean getrunflag() {
			return runflag;
		}

		DownloadInfo(Request mRequest) {
			this.mRequest = mRequest;

		}

		public void setDownLoad(DownloadInfo download) {
			this.download = download;
		}

		@Override
		public void run() {
			try {

				File dir = new File(Constants.DOWNLOAD_PATH);
				if (!dir.exists()) {
					dir.mkdirs();
				}
				String filePath = Constants.DOWNLOAD_PATH
						+ mRequest.getMessageId() + "." + mRequest.getExt();
				bean = new MessageBean();
				bean.setPath(filePath);
				bean.setStatus(0);
				bean.setDate(mRequest.getTimestamp());
				bean.setLayoutID(R.layout.list_say_he_item);
				bean.setPhotoID(R.drawable.receive_ico);
				bean.setMessage_key(mRequest.getMessageId());
				bean.setPhone_number(mRequest.getReceiver());
				bean.setAction(1);
				String name = getPeople(mRequest.getSender());
				bean.setName(name);
				bean.setFileType(Integer.parseInt(mRequest.getCommand()));
				if (mRequest.getCommand().equals(Request.TYPE_MUSIC)) {
					bean.setMsgIco(R.drawable.music_temp);
					bean.setText(name + "给你发送了音乐");
					mRequest.setBody(Base64.encodeToString(bean.getText()
							.getBytes(), Base64.DEFAULT));
				} else if (mRequest.getCommand().equals(Request.TYPE_CARD)) {
					bean.setMsgIco(R.drawable.card_temp);
					bean.setText(new String(Base64.decode(mRequest.getBody(),
							Base64.DEFAULT)));
					mRequest.setBody(Base64.encodeToString(bean.getText()
							.getBytes(), Base64.DEFAULT));
				} else if (mRequest.getCommand().equals(Request.TYPE_LBS)) {
					bean.setMsgIco(R.drawable.address_temp);
					bean.setText(new String(Base64.decode(mRequest.getBody(),
							Base64.DEFAULT)));
					mRequest.setBody(Base64.encodeToString(bean.getText()
							.getBytes(), Base64.DEFAULT));
				} else if (mRequest.getCommand().equals(Request.TYPE_PHOTO)) {
					bean.setText(name + "向你发送了照片");
					bean.setMsgIco(-1);
				} else if (mRequest.getCommand().equals(Request.TYPE_PIC)) {
					bean.setText(name + "向你发送了图片");
					bean.setMsgIco(-1);
				} else if (mRequest.getCommand().equals(Request.TYPE_SMS)) {
					bean.setFileType(0);
				}

				if (!mRequest.getCommand().equals(Request.TYPE_CARD)
						&& !mRequest.getCommand().equals(Request.TYPE_SMS)) {
					String path = Constants.FILE_DOWNLOAD_URL
							+ mRequest.getMessageId();
					URL url = new URL(path);
					HttpURLConnection hurlconn = (HttpURLConnection) url
							.openConnection();// 基于HTTP协议的连接对象
					hurlconn.setConnectTimeout(5000);// 请求超时时间 5s
					hurlconn.setRequestMethod("GET");// 请求方式
					hurlconn.connect();
					long fileSize = hurlconn.getContentLength();
					InputStream instream = hurlconn.getInputStream();
					byte[] buffer = new byte[1024];
					int len = 0;
					int number = 0;
					RandomAccessFile rasf = new RandomAccessFile(filePath,
							"rwd");
					while ((len = instream.read(buffer)) != -1) {// 开始下载文件
						if (getrunflag() && progress < 100) {
							rasf.seek(number);
							number += len;
							rasf.write(buffer, 0, len);
							progress = (((float) number) / fileSize) * 100;
							// 发送广播，修改进度条进度
							sendUpdateBroast();
						} else {
							this.interrupt();
							if (number != fileSize) {// 取消下载，将已经缓存的未下载完成的文件删除
								File file = new File(filePath);
								if (file.exists())
									file.delete();
							}
							PushService.downloadInfos.remove(download);
							sendUpdateBroast();
							return;
						}
					}
					instream.close();
					PushService.downloadInfos.remove(download);
					sendUpdateBroast();
				} else {// 收到消息，将信息保存到数据库

					PushService.downloadInfos.remove(download);
					sendUpdateBroast();
				}
				// 将文件信息保存到数据库
				dao.create(bean);
				sendUpdateFinishBroast();

			} catch (Exception e) {
				PushService.downloadInfos.remove(download);
				sendUpdateBroast();
				e.printStackTrace();
			}
		}
	}

	public static ArrayList<DownloadInfo> downloadInfos = new ArrayList<DownloadInfo>();

	public ArrayList<DownloadInfo> getDownloadInfos() {
		return PushService.downloadInfos;
	}

	public void setDownloadInfos(ArrayList<DownloadInfo> downloadInfos) {
		PushService.downloadInfos = downloadInfos;
	}
}</pre>
<p><br>
 ps：</p>
<p>接收者必须订阅发送者的TOPICS才能收到消息</p>
<p> </p>
<pre></pre>
<pre></pre>
<pre></pre>
<pre></pre>

[/java]