一．基础知识

当我们开发需要和服务器交互的应用程序时，基本上都需要获取服务器端的数据，比如《地震及时通》就需要及时获取服务器上最新的地震信息。要获取服务器上不定时更新的信息一般来说有两种方法，第一种是客户端使用Pull（拉）的方式，隔一段时间就去服务器上获取信息，看是否有更新的信息出现。第二种就是服务器使用Push（推送）的方式，当服务器端有新信息了，则把最新的信息Push到客户端上。

虽然Pull和Push两种方式都能实现获取服务器端更新信息的功能，但是明显来说Push is better than pull。因为Pull方式更费客户端的网络流量，更主要的是费电量。

Android从2.2版本开始增加了Cloud to Device Messaging（C2DM）框架，在系统中支持了Push功能，基于Android平台使用Push功能更加简单了。虽然C2DM目前还处在实验室阶段，不过小规模的使用应该没问题

下面我们就来体验一下Android的C2DM功能。

二．C2DM框架

使用Android的C2DM功能有几个要求：

1. 需要Android2.2及以上的系统版本。

2. 使用C2DM功能的Android设备上需要设置好Google的账户。

3. 需要在这里注册使用C2DM功能的用户邮箱账号（最好为C2DM单独注册一个Gmail邮箱账号）。

我们接下来C2DM的一个完整过程，这里借用一下Google官方推出的Chrome To Phone过程图来说明下。

图1 C2DM操作过程图

要使用C2DM来进行Push操作，基本上要使用以下6个步骤：

（1）注册：Android设备把使用C2DM功能的用户账户（比如android.c2dm.demo@gmail.com）和App名称发送给C2DM服务器。

（2）C2DM服务器会返回一个registration_id值给Android设备，设备需要保存这个registration_id值。

（3）Android设备把获得的registration_id和C2DM功能的用户账户（android.c2dm.demo@gmail.com）发送给自己的服务器，不过一般用户账户信息因为和服务器确定好的，所以不必发送。

这样Android设备就完成了C2DM功能的注册过程，接下来就可以接收C2DM服务器Push过来的消息了。

（4）服务器获得数据。这里图中的例子Chrome To Phone，服务器接收到Chrome浏览器发送的数据。数据也可以是服务器本地产生的。这里的服务器是Google AppEngine（很好的一项服务，可惜在国内被屏了），要换成自己的服务器。服务器还要获取注册使用C2DM功能的用户账户（android.c2dm.demo@gmail.com）的ClientLogin权限Auth。

（5）服务器把要发送的数据和registration_id一起，并且头部带上获取的Auth，使用POST的方式发送给C2DM服务器。

（6）C2DM服务器会以Push的方式把数据发送给对应的Android设备，Android设备只要在程序中按之前和服务器商量好的格式从对应的key中获取数据即可。

这样我们就大概明白了C2DM的工作流程，下面我们就结合一个实例来具体的说明以上6个步骤。

三．实例开发

我们要创建的程序名称为AndroidC2DMDemo，包名为com.ichliebephone.c2dm。

开始之前我们先去C2DM网页上注册一下使用C2DM功能的用户账户。

图2 应用程序名

其中应用程序名要填写带包名的完整名称，比如这里为om.ichliebephone.c2dm. AndroidC2DMDemo。

图3 C2DM用户账户注册

这里的contact邮箱使用一个你能接收到邮件的邮箱即可，下面的Role（sender）account邮箱最好单独注册一个Gmail邮箱来使用C2DM服务。我们这里使用的是专门注册的android.c2dm.deno@gmail.com邮箱。

提交后，过一段时间就会收到Google发送过来的确认邮件，然后你就可以使用C2DM的Push服务了。

介绍了这么多，我们先来快速完成一个实例，只完成Android设备端的注册部分，不包含向服务器发送registration_id和服务器向C2DM服务器发送数据的具体代码，这部分只是用Ubuntu下的curl命令来模拟，主要是快速亲自体验一下Push的结果。

创建一个Android工程AndroidC2DMDemo，并且包含进Google的开源例子Chrome To Phone中的c2dm包com.google.android.c2dm，包中包含三个Java类，分别为：

第一个类为C2DMBaseReceiver：

1. /*
2. * Copyright 2010 Google Inc.
3. *
4. * Licensed under the Apache License, Version 2.0 (the "License");
5. * you may not use this file except in compliance with the License.
6. * You may obtain a copy of the License at
7. *
8. * http://www.apache.org/licenses/LICENSE-2.0
9. *
10. * Unless required by applicable law or agreed to in writing, software
11. * distributed under the License is distributed on an "AS IS" BASIS,
12. * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13. * See the License for the specific language governing permissions and
14. * limitations under the License.
15. */
17. package com.google.android.c2dm;
19. import java.io.IOException;
21. import android.app.AlarmManager;
22. import android.app.IntentService;
23. import android.app.PendingIntent;
24. import android.content.Context;
25. import android.content.Intent;
26. import android.os.PowerManager;
27. import android.util.Log;
29. /**
30. * Base class for C2D message receiver. Includes constants for the
31. * strings used in the protocol.
32. */
33. /**
34. * 接收和处理C2DM消息的基类
35. * */
36. public abstract class C2DMBaseReceiver extends IntentService {
37. //和C2DM Push的Intent内容相关
38. //重新向C2DM服务器注册
39. private static final String C2DM_RETRY = "com.google.android.c2dm.intent.RETRY";
40. //向C2DM服务器注册后的回调处理
41. public static final String REGISTRATION_CALLBACK_INTENT = "com.google.android.c2dm.intent.REGISTRATION";
42. //接收到C2DM服务器的推送消息
43. private static final String C2DM_INTENT = "com.google.android.c2dm.intent.RECEIVE";
45. // Logging tag
46. private static final String TAG = "C2DM";
48. // Extras in the registration callback intents.
49. //向C2DM注册返回的intent中包含的key
50. public static final String EXTRA_UNREGISTERED = "unregistered";
51. public static final String EXTRA_ERROR = "error";
52. public static final String EXTRA_REGISTRATION_ID = "registration_id";
53. //向C2DM注册出错的原因
54. public static final String ERR_SERVICE_NOT_AVAILABLE = "SERVICE_NOT_AVAILABLE";
55. public static final String ERR_ACCOUNT_MISSING = "ACCOUNT_MISSING";
56. public static final String ERR_AUTHENTICATION_FAILED = "AUTHENTICATION_FAILED";
57. public static final String ERR_TOO_MANY_REGISTRATIONS = "TOO_MANY_REGISTRATIONS";
58. public static final String ERR_INVALID_PARAMETERS = "INVALID_PARAMETERS";
59. public static final String ERR_INVALID_SENDER = "INVALID_SENDER";
60. public static final String ERR_PHONE_REGISTRATION_ERROR = "PHONE_REGISTRATION_ERROR";
62. // wakelock
63. private static final String WAKELOCK_KEY = "C2DM_LIB";
65. private static PowerManager.WakeLock mWakeLock;
66. private final String senderId;
68. /**
69. * The C2DMReceiver class must create a no-arg constructor and pass the
70. * sender id to be used for registration.
71. */
72. public C2DMBaseReceiver(String senderId) {
73. // senderId is used as base name for threads, etc.
74. super(senderId);
75. this.senderId = senderId;
76. }
77. //下面几个是接收到C2DM Push过来的信息后的回调函数，都可以在继承的子类中处理
78. /**
79. * Called when a cloud message has been received.
80. */
81. /**
82. * 接收到C2DM服务器Push的消息后的回调函数，需要在继承的子类中处理
83. * */
84. protected abstract void onMessage(Context context, Intent intent);
86. /**
87. * Called on registration error. Override to provide better
88. * error messages.
89. *
90. * This is called in the context of a Service - no dialog or UI.
91. */
92. /**
93. * 出错的回调函数
94. * */
95. public abstract void onError(Context context, String errorId);
97. /**
98. * Called when a registration token has been received.
99. */
100. /**
101. * 注册后的回调函数
102. * */
103. public void onRegistered(Context context, String registrationId) throws IOException {
104. // registrationId will also be saved
105. }
107. /**
108. * Called when the device has been unregistered.
109. */
110. /**
111. * 取消注册的回调函数
112. * */
113. public void onUnregistered(Context context) {
114. }
116. //IntentService的方法
117. @Override
118. public final void onHandleIntent(Intent intent) {
119. try {
120. Context context = getApplicationContext();
121. if (intent.getAction().equals(REGISTRATION_CALLBACK_INTENT)) {
122. handleRegistration(context, intent);//处理注册后的回调
123. } else if (intent.getAction().equals(C2DM_INTENT)) {
124. onMessage(context, intent);//处理C2DM Push消息的回调
125. } else if (intent.getAction().equals(C2DM_RETRY)) {
126. C2DMessaging.register(context, senderId); //重新注册
127. }
128. } finally {
129. // Release the power lock, so phone can get back to sleep.
130. // The lock is reference counted by default, so multiple
131. // messages are ok.
133. // If the onMessage() needs to spawn a thread or do something else,
134. // it should use it's own lock.
135. mWakeLock.release();
136. }
137. }
140. /**
141. * Called from the broadcast receiver.
142. * Will process the received intent, call handleMessage(), registered(), etc.
143. * in background threads, with a wake lock, while keeping the service
144. * alive.
145. */
146. static void runIntentInService(Context context, Intent intent) {
147. if (mWakeLock == null) {
148. // This is called from BroadcastReceiver, there is no init.
149. PowerManager pm =
150. (PowerManager) context.getSystemService(Context.POWER_SERVICE);
151. mWakeLock = pm.newWakeLock(PowerManager.PARTIAL_WAKE_LOCK,
152. WAKELOCK_KEY);
153. }
154. mWakeLock.acquire();
156. // Use a naming convention, similar with how permissions and intents are
157. // used. Alternatives are introspection or an ugly use of statics.
158. String receiver = context.getPackageName() + ".C2DMReceiver";
159. intent.setClassName(context, receiver);
161. context.startService(intent);
163. }
165. //处理注册后的回调
166. private void handleRegistration(final Context context, Intent intent) {
167. final String registrationId = intent.getStringExtra(EXTRA_REGISTRATION_ID);
168. String error = intent.getStringExtra(EXTRA_ERROR);
169. String removed = intent.getStringExtra(EXTRA_UNREGISTERED);
170. Log.v(TAG, "handleRegistration");
171. //打印出接收到的registraton_id
172. Log.v(TAG, "dmControl: registrationId = " + registrationId +
173. ", error = " + error + ", removed = " + removed);
174. if (Log.isLoggable(TAG, Log.DEBUG)) {
175. Log.d(TAG, "dmControl: registrationId = " + registrationId +
176. ", error = " + error + ", removed = " + removed);
177. }
178. if (removed != null) {
179. // Remember we are unregistered
180. C2DMessaging.clearRegistrationId(context);
181. onUnregistered(context);
182. return;
183. } else if (error != null) {
184. // we are not registered, can try again
185. C2DMessaging.clearRegistrationId(context);
186. // Registration failed
187. Log.e(TAG, "Registration error " + error);
188. onError(context, error);
189. if ("SERVICE_NOT_AVAILABLE".equals(error)) {
190. long backoffTimeMs = C2DMessaging.getBackoff(context);
192. Log.d(TAG, "Scheduling registration retry, backoff = " + backoffTimeMs);
193. Intent retryIntent = new Intent(C2DM_RETRY);
194. PendingIntent retryPIntent = PendingIntent.getBroadcast(context,
195. 0 /*requestCode*/, retryIntent, 0 /*flags*/);
197. AlarmManager am = (AlarmManager) context.getSystemService(Context.ALARM_SERVICE);
198. am.set(AlarmManager.ELAPSED_REALTIME,
199. backoffTimeMs, retryPIntent);
201. // Next retry should wait longer.
202. backoffTimeMs *= 2;
203. C2DMessaging.setBackoff(context, backoffTimeMs);
204. }
205. } else {
206. try {
207. onRegistered(context, registrationId);
208. C2DMessaging.setRegistrationId(context, registrationId);
209. } catch (IOException ex) {
210. Log.e(TAG, "Registration error " + ex.getMessage());
211. }
212. }
213. }
214. }

第二个类为C2DMBroadcastReceiver：

1. /*
2. */
3. package com.google.android.c2dm;
5. import android.app.Activity;
6. import android.content.BroadcastReceiver;
7. import android.content.Context;
8. import android.content.Intent;
10. /**
11. * Helper class to handle BroadcastReciver behavior.
12. * - can only run for a limited amount of time - it must start a real service
13. * for longer activity
14. * - must get the power lock, must make sure it's released when all done.
15. *
16. */
17. /**
18. * 帮助类，帮忙处理BroadcastReciver过程
19. * */
20. public class C2DMBroadcastReceiver extends BroadcastReceiver {
22. @Override
23. public final void onReceive(Context context, Intent intent) {
24. // To keep things in one place.
25. C2DMBaseReceiver.runIntentInService(context, intent);
26. setResult(Activity.RESULT_OK, null /* data */, null /* extra */);
27. }
28. }

第三个类为C2DMessaging：

1. /*
2. * Copyright 2010 Google Inc.
3. *
4. * Licensed under the Apache License, Version 2.0 (the "License");
5. * you may not use this file except in compliance with the License.
6. * You may obtain a copy of the License at
7. *
8. * http://www.apache.org/licenses/LICENSE-2.0
9. *
10. * Unless required by applicable law or agreed to in writing, software
11. * distributed under the License is distributed on an "AS IS" BASIS,
12. * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13. * See the License for the specific language governing permissions and
14. * limitations under the License.
15. */
17. package com.google.android.c2dm;
19. import android.app.PendingIntent;
20. import android.content.Context;
21. import android.content.Intent;
22. import android.content.SharedPreferences;
23. import android.content.SharedPreferences.Editor;
25. /**
26. * Utilities for device registration.
27. *
28. * Will keep track of the registration token in a private preference.
29. */
30. /**
31. * 和注册相关的一些实用函数
32. * */
33. public class C2DMessaging {
34. public static final String EXTRA_SENDER = "sender";
35. public static final String EXTRA_APPLICATION_PENDING_INTENT = "app";
36. public static final String REQUEST_UNREGISTRATION_INTENT = "com.google.android.c2dm.intent.UNREGISTER";
37. public static final String REQUEST_REGISTRATION_INTENT = "com.google.android.c2dm.intent.REGISTER";
38. public static final String LAST_REGISTRATION_CHANGE = "last_registration_change";
39. public static final String BACKOFF = "backoff";
40. public static final String GSF_PACKAGE = "com.google.android.gsf"; //GSF为GoogleServicesFramework.apk的缩写
43. // package
44. static final String PREFERENCE = "com.google.android.c2dm";
46. private static final long DEFAULT_BACKOFF = 30000;
48. /**
49. * Initiate c2d messaging registration for the current application
50. */
51. public static void register(Context context,
52. String senderId) {
53. Intent registrationIntent = new Intent(REQUEST_REGISTRATION_INTENT);
54. registrationIntent.setPackage(GSF_PACKAGE);
55. registrationIntent.putExtra(EXTRA_APPLICATION_PENDING_INTENT,
56. PendingIntent.getBroadcast(context, 0, new Intent(), 0));
57. registrationIntent.putExtra(EXTRA_SENDER, senderId);
58. context.startService(registrationIntent);
59. // TODO: if intent not found, notification on need to have GSF
60. }
62. /**
63. * Unregister the application. New messages will be blocked by server.
64. */
65. public static void unregister(Context context) {
66. Intent regIntent = new Intent(REQUEST_UNREGISTRATION_INTENT);
67. regIntent.setPackage(GSF_PACKAGE);
68. regIntent.putExtra(EXTRA_APPLICATION_PENDING_INTENT, PendingIntent.getBroadcast(context,
69. 0, new Intent(), 0));
70. context.startService(regIntent);
71. }
73. /**
74. * Return the current registration id.
75. *
76. * If result is empty, the registration has failed.
77. *
78. * @return registration id, or empty string if the registration is not complete.
79. */
80. public static String getRegistrationId(Context context) {
81. final SharedPreferences prefs = context.getSharedPreferences(
82. PREFERENCE,
83. Context.MODE_PRIVATE);
84. String registrationId = prefs.getString("dm_registration", "");
85. return registrationId;
86. }
88. public static long getLastRegistrationChange(Context context) {
89. final SharedPreferences prefs = context.getSharedPreferences(
90. PREFERENCE,
91. Context.MODE_PRIVATE);
92. return prefs.getLong(LAST_REGISTRATION_CHANGE, 0);
93. }
95. static long getBackoff(Context context) {
96. final SharedPreferences prefs = context.getSharedPreferences(
97. PREFERENCE,
98. Context.MODE_PRIVATE);
99. return prefs.getLong(BACKOFF, DEFAULT_BACKOFF);
100. }
102. static void setBackoff(Context context, long backoff) {
103. final SharedPreferences prefs = context.getSharedPreferences(
104. PREFERENCE,
105. Context.MODE_PRIVATE);
106. Editor editor = prefs.edit();
107. editor.putLong(BACKOFF, backoff);
108. editor.commit();
110. }
112. // package
113. static void clearRegistrationId(Context context) {
114. final SharedPreferences prefs = context.getSharedPreferences(
115. PREFERENCE,
116. Context.MODE_PRIVATE);
117. Editor editor = prefs.edit();
118. editor.putString("dm_registration", "");
119. editor.putLong(LAST_REGISTRATION_CHANGE, System.currentTimeMillis());
120. editor.commit();
122. }
124. // package
125. static void setRegistrationId(Context context, String registrationId) {
126. final SharedPreferences prefs = context.getSharedPreferences(
127. PREFERENCE,
128. Context.MODE_PRIVATE);
129. Editor editor = prefs.edit();
130. editor.putString("dm_registration", registrationId);
131. editor.commit();
133. }
134. }

代码中已添加了部分中文注释，可以先大概了解下，等整个工程建立完了在一起解释。

然后创建我们自己的包com.ichliebephone.c2dm，包含两个类，一个是工程的入口AndroidC2DMDemo：

1. package com.ichliebephone.c2dm;
3. import com.google.android.c2dm.C2DMessaging;
5. import android.app.Activity;
6. import android.os.Bundle;
7. import android.util.Log;
9. public class AndroidC2DMDemo extends Activity {
10. /** Called when the activity is first created. */
11. private static final String TAG = "AndroidC2DMDemo";
12. public static final String SENDER_ID = "android.c2dm.demo@gmail.com"; //使用C2DM服务的用户账户
13. public static final String MESSAGE_KEY_ONE = "msg"; //和服务器商量好的接收消息的键值key
15. @Override
16. public void onCreate(Bundle savedInstanceState) {
17. super.onCreate(savedInstanceState);
18. setContentView(R.layout.main);
20. Log.v(TAG, "Start");
21. //向C2DM服务器注册
22. C2DMessaging.register(this, SENDER_ID);
23. }
26. }

很简单，就是开始向C2DM服务器进行注册。

另一个类为C2DMBaseReceiver的子类C2DMReceiver：

1. package com.ichliebephone.c2dm;
3. import java.io.IOException;
5. import android.app.Notification;
6. import android.app.NotificationManager;
7. import android.app.PendingIntent;
8. import android.content.Context;
9. import android.content.Intent;
10. import android.os.Bundle;
11. import android.util.Log;
13. import com.google.android.c2dm.C2DMBaseReceiver;
14. //接收C2DM服务器Push的消息，包括注册返回的registration_id消息，推送的数据消息等
15. public class C2DMReceiver extends C2DMBaseReceiver{
17. private static final String TAG="C2DMReceiver";
18. //
19. public C2DMReceiver()
20. {
21. super(AndroidC2DMDemo.SENDER_ID);
22. }
23. public C2DMReceiver(String senderId) {
24. super(senderId);
25. // TODO Auto-generated constructor stub
26. }
27. //接收到Push消息的回调函数
28. @Override
29. protected void onMessage(Context context, Intent intent) {
30. // TODO Auto-generated method stub
31. Log.v(TAG, "C2DMReceiver message");
32. Bundle extras = intent.getExtras();
33. if(extras!=null){
34. String msg = (String)extras.get(AndroidC2DMDemo.MESSAGE_KEY_ONE);
35. Log.v(TAG, "The received msg = "+msg);
36. //在标题栏上显示通知
37. NotificationManager notificationManager = (NotificationManager)getSystemService(NOTIFICATION_SERVICE);
38. Notification notification = new Notification(R.drawable.icon, msg, System.currentTimeMillis());
39. PendingIntent contentIntent = PendingIntent.getActivity(this, 0, new Intent(this, AndroidC2DMDemo.class), 0);
40. notification.setLatestEventInfo(this, getString(R.string.app_name), msg, contentIntent);
41. notificationManager.notify(0, notification);
43. }
44. }
46. @Override
47. public void onError(Context context, String errorId) {
48. // TODO Auto-generated method stub
49. Log.v(TAG, "C2DMReceiver error");
50. }
52. @Override
53. public void onRegistered(Context context, String registrationId)
54. throws IOException {
55. // TODO Auto-generated method stub
56. super.onRegistered(context, registrationId);
57. Log.v(TAG, "C2DMReceiver Register");
58. }
59. @Override
60. public void onUnregistered(Context context) {
61. // TODO Auto-generated method stub
62. super.onUnregistered(context);
63. Log.v(TAG, "C2DMReceiver UnRegister");
64. }
65. }

在这个类中我们主要在接收到Push的回调函数onMessage中对消息进行了接收，并且使用Notification的方式显示在状态栏上。

我们完整的工程目录是这样的：

图4 工程目录

最后我们还要在AndroidManifest.xml中增加对应的权限等内容:

1. version="1.0" encoding="utf-8"?>
2. xmlns:android="http://schemas.android.com/apk/res/android"
3. package="com.ichliebephone.c2dm"
4. android:versionCode="1"
5. android:versionName="1.0">
6. android:minSdkVersion="8" />
10. android:name="com.ichliebephone.c2dm.permission.C2D_MESSAGE"
11. android:protectionLevel="signature">
12. android:name="com.ichliebephone.c2dm.permission.C2D_MESSAGE"/>
15. android:name="com.google.android.c2dm.permission.RECEIVE" />
18. android:name="android.permission.INTERNET" />
21. android:name="android.permission.WAKE_LOCK" />
22. android:name="android.permission.GET_ACCOUNTS" />
23. android:name="android.permission.USE_CREDENTIALS" />
25. android:icon="@drawable/icon" android:label="@string/app_name">
26. android:name=".AndroidC2DMDemo"
27. android:label="@string/app_name">
29. android:name="android.intent.action.MAIN" />
30. android:name="android.intent.category.LAUNCHER" />
35. android:name="com.google.android.c2dm.C2DMBroadcastReceiver"
36. android:permission="com.google.android.c2dm.permission.SEND">
40. android:name="com.google.android.c2dm.intent.RECEIVE" />
41. android:name="com.ichliebephone.c2dm" />
46. android:name="com.google.android.c2dm.intent.REGISTRATION" />
47. android:name="com.ichliebephone.c2dm" />

因为C2DM功能只有2.2及以上的Android系统才支持，因此创建一个2.2及以上的AVD，然后在”设置->账户与同步”里还要设置好Google Account，如下图所示：

图5 设置Android设备中的Google账户

然后就可以运行程序了，我们会在DDMS输出中看到获得的registration_id：

图6 获得的registration_id

如果第一次运行没有出现，试着再运行一次。

有了registration_id，我们的服务器端就可以向C2DM端发送需要Push的数据了，这里进行简单化处理下，在Ubuntu下直接使用curl命令来模拟服务器功能向C2DM发送数据。

我们先来获取C2DM的ClientLogin权限Auth，在Ubuntu终端下输入：