3.基于xmpp openfire smack開發之Android用戶端開發

基于xmpp openfire smack開發之Android用戶端開發[3]

分類： Android開發 2013-09-06 16:29  25529人閱讀  評論(106)  收藏  舉報

目錄(?)[+]

在上兩篇文章中，我們依次介紹openfire部署以及smack常用API的使用，這一節中我們着力介紹如何基于asmack開發一個Android的用戶端，本篇的重點在實踐，講解和原理環節，大家可以參考前兩篇的文章

基于xmpp openfire smack開發之openfire介紹和部署[1]

基于xmpp openfire smack開發之smack類庫介紹和使用[2]

1.源碼結構介紹

activity包下存放一些android頁面互動相關的控制程式，還有一個些公共幫助類

db包為sqlite的工具類封裝，這裡做了一些自定義的改造，稍微仿Spring的JdbcTemplate結構，使用起來更加友善一點

manager包留下主要是一些管理元件，包括聯系人管理，消息管理，提醒管理，離線消息管理，使用者管理，xmpp連接配接管理

model包中都是一些對象模型，傳輸媒體

service中存放一些android背景的核心服務，主要包括聊天服務，聯系人服務，系統消息服務，重連接配接服務

task包中存放一些耗時的異步操作

util中存放一些常用的工具類

view中一些和android的UI相關的顯示控件

anim中存放一些動畫元素的配置

layout是布局頁面

menu是地步菜單布局頁面

values中存放一些字元，顔色，樣式，參數的配置資訊

其中strings.xml中，儲存的預設配置為gtalk的伺服器資訊，大家如果有谷歌gtalk的賬号可以直接登入，否則需要更改這裡的配置才可以使用其他的xmpp伺服器

[html]  view plain copy

1. <!-- 預設的伺服器配置 -->   
2.   <integer name="xmpp_port">5222</integer>   
3.   <string name="xmpp_host">talk.google.com</string>   
4.   <string name="xmpp_service_name">gmail.com</string>  
5.   <bool name="is_remember">true</bool>  
6.   <bool name="is_autologin">false</bool>  
7.   <bool name="is_novisible">false</bool>   

AndroidManifest.xml為android功能清單的配置檔案，我們這裡開放的權限并不多

[html]  view plain copy

1.     <!-- 通路Internet -->  
2. <uses-permission android:name="android.permission.INTERNET" />  
3. <!--- 通路網絡狀态 -->  
4.     <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />  
5.     <!-- 往SDCard寫入資料權限 -->  
6.     <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE"/>  
7.    <span style="WHITE-SPACE: pre">  </span><!-- 在SDCard中建立與删除檔案權限 -->  
8.    <span style="WHITE-SPACE: pre">  </span><uses-permission android:name="android.permission.MOUNT_UNMOUNT_FILESYSTEMS"/>  
9.    <span style="WHITE-SPACE: pre">  </span><!-- 往SDCard寫入資料權限 -->  
10.    <span style="WHITE-SPACE: pre">  </span><uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE"/>  

2.核心類介紹

1.ActivitySupport類 [java]  view plain copy

1. package csdn.shimiso.eim.activity;  
2. import android.app.Activity;  
3. import android.app.AlertDialog;  
4. import android.app.Notification;  
5. import android.app.NotificationManager;  
6. import android.app.PendingIntent;  
7. import android.app.ProgressDialog;  
8. import android.content.Context;  
9. import android.content.DialogInterface;  
10. import android.content.Intent;  
11. import android.content.SharedPreferences;  
12. import android.location.LocationManager;  
13. import android.net.ConnectivityManager;  
14. import android.net.NetworkInfo;  
15. import android.os.Bundle;  
16. import android.os.Environment;  
17. import android.provider.Settings;  
18. import android.view.inputmethod.InputMethodManager;  
19. import android.widget.Toast;  
20. import csdn.shimiso.eim.R;  
21. import csdn.shimiso.eim.comm.Constant;  
22. import csdn.shimiso.eim.model.LoginConfig;  
23. import csdn.shimiso.eim.service.IMChatService;  
24. import csdn.shimiso.eim.service.IMContactService;  
25. import csdn.shimiso.eim.service.IMSystemMsgService;  
26. import csdn.shimiso.eim.service.ReConnectService;  
27. public class ActivitySupport extends Activity implements IActivitySupport {  
28.     protected Context context = null;  
29.     protected SharedPreferences preferences;  
30.     protected EimApplication eimApplication;  
31.     protected ProgressDialog pg = null;  
32.     protected NotificationManager notificationManager;  
33.     @Override  
34.     protected void onCreate(Bundle savedInstanceState) {  
35.         super.onCreate(savedInstanceState);  
36.         context = this;  
37.         preferences = getSharedPreferences(Constant.LOGIN_SET, 0);  
38.         notificationManager = (NotificationManager) getSystemService(NOTIFICATION_SERVICE);  
39.         pg = new ProgressDialog(context);  
40.         eimApplication = (EimApplication) getApplication();  
41.         eimApplication.addActivity(this);  
42.     }  
43.     @Override  
44.     protected void onStart() {  
45.         super.onStart();  
46.     }  
47.     @Override  
48.     protected void onResume() {  
49.         super.onResume();  
50.     }  
51.     @Override  
52.     protected void onPause() {  
53.         super.onPause();  
54.     }  
55.     @Override  
56.     protected void onStop() {  
57.         super.onStop();  
58.     }  
59.     @Override  
60.     public void onDestroy() {  
61.         super.onDestroy();  
62.     }  
63.     @Override  
64.     public ProgressDialog getProgressDialog() {  
65.         return pg;  
66.     }  
67.     @Override  
68.     public void startService() {  
69.         // 好友聯系人服務  
70.         Intent server = new Intent(context, IMContactService.class);  
71.         context.startService(server);  
72.         // 聊天服務  
73.         Intent chatServer = new Intent(context, IMChatService.class);  
74.         context.startService(chatServer);  
75.         // 自動恢複連接配接服務  
76.         Intent reConnectService = new Intent(context, ReConnectService.class);  
77.         context.startService(reConnectService);  
78.         // 系統消息連接配接服務  
79.         Intent imSystemMsgService = new Intent(context,  
80.                 IMSystemMsgService.class);  
81.         context.startService(imSystemMsgService);  
82.     }  
83.     @Override  
84.     public void stopService() {  
85.         // 好友聯系人服務  
86.         Intent server = new Intent(context, IMContactService.class);  
87.         context.stopService(server);  
88.         // 聊天服務  
89.         Intent chatServer = new Intent(context, IMChatService.class);  
90.         context.stopService(chatServer);  
91.         // 自動恢複連接配接服務  
92.         Intent reConnectService = new Intent(context, ReConnectService.class);  
93.         context.stopService(reConnectService);  
94.         // 系統消息連接配接服務  
95.         Intent imSystemMsgService = new Intent(context,  
96.                 IMSystemMsgService.class);  
97.         context.stopService(imSystemMsgService);  
98.     }  
99.     @Override  
100.     public void isExit() {  
101.         new AlertDialog.Builder(context).setTitle("确定退出嗎?")  
102.                 .setNeutralButton("确定", new DialogInterface.OnClickListener() {  
103.                     @Override  
104.                     public void onClick(DialogInterface dialog, int which) {  
105.                         stopService();  
106.                         eimApplication.exit();  
107.                     }  
108.                 })  
109.                 .setNegativeButton("取消", new DialogInterface.OnClickListener() {  
110.                     @Override  
111.                     public void onClick(DialogInterface dialog, int which) {  
112.                         dialog.cancel();  
113.                     }  
114.                 }).show();  
115.     }  
116.     @Override  
117.     public boolean hasInternetConnected() {  
118.         ConnectivityManager manager = (ConnectivityManager) context  
119.                 .getSystemService(context.CONNECTIVITY_SERVICE);  
120.         if (manager != null) {  
121.             NetworkInfo network = manager.getActiveNetworkInfo();  
122.             if (network != null && network.isConnectedOrConnecting()) {  
123.                 return true;  
124.             }  
125.         }  
126.         return false;  
127.     }  
128.     @Override  
129.     public boolean validateInternet() {  
130.         ConnectivityManager manager = (ConnectivityManager) context  
131.                 .getSystemService(context.CONNECTIVITY_SERVICE);  
132.         if (manager == null) {  
133.             openWirelessSet();  
134.             return false;  
135.         } else {  
136.             NetworkInfo[] info = manager.getAllNetworkInfo();  
137.             if (info != null) {  
138.                 for (int i = 0; i < info.length; i++) {  
139.                     if (info[i].getState() == NetworkInfo.State.CONNECTED) {  
140.                         return true;  
141.                     }  
142.                 }  
143.             }  
144.         }  
145.         openWirelessSet();  
146.         return false;  
147.     }  
148.     @Override  
149.     public boolean hasLocationGPS() {  
150.         LocationManager manager = (LocationManager) context  
151.                 .getSystemService(context.LOCATION_SERVICE);  
152.         if (manager  
153.                 .isProviderEnabled(android.location.LocationManager.GPS_PROVIDER)) {  
154.             return true;  
155.         } else {  
156.             return false;  
157.         }  
158.     }  
159.     @Override  
160.     public boolean hasLocationNetWork() {  
161.         LocationManager manager = (LocationManager) context  
162.                 .getSystemService(context.LOCATION_SERVICE);  
163.         if (manager  
164.                 .isProviderEnabled(android.location.LocationManager.NETWORK_PROVIDER)) {  
165.             return true;  
166.         } else {  
167.             return false;  
168.         }  
169.     }  
170.     @Override  
171.     public void checkMemoryCard() {  
172.         if (!Environment.MEDIA_MOUNTED.equals(Environment  
173.                 .getExternalStorageState())) {  
174.             new AlertDialog.Builder(context)  
175.                     .setTitle(R.string.prompt)  
176.                     .setMessage("請檢查記憶體卡")  
177.                     .setPositiveButton(R.string.menu_settings,  
178.                             new DialogInterface.OnClickListener() {  
179.                                 @Override  
180.                                 public void onClick(DialogInterface dialog,  
181.                                         int which) {  
182.                                     dialog.cancel();  
183.                                     Intent intent = new Intent(  
184.                                             Settings.ACTION_SETTINGS);  
185.                                     context.startActivity(intent);  
186.                                 }  
187.                             })  
188.                     .setNegativeButton("退出",  
189.                             new DialogInterface.OnClickListener() {  
190.                                 @Override  
191.                                 public void onClick(DialogInterface dialog,  
192.                                         int which) {  
193.                                     dialog.cancel();  
194.                                     eimApplication.exit();  
195.                                 }  
196.                             }).create().show();  
197.         }  
198.     }  
199.     public void openWirelessSet() {  
200.         AlertDialog.Builder dialogBuilder = new AlertDialog.Builder(context);  
201.         dialogBuilder  
202.                 .setTitle(R.string.prompt)  
203.                 .setMessage(context.getString(R.string.check_connection))  
204.                 .setPositiveButton(R.string.menu_settings,  
205.                         new DialogInterface.OnClickListener() {  
206.                             @Override  
207.                             public void onClick(DialogInterface dialog,  
208.                                     int which) {  
209.                                 dialog.cancel();  
210.                                 Intent intent = new Intent(  
211.                                         Settings.ACTION_WIRELESS_SETTINGS);  
212.                                 context.startActivity(intent);  
213.                             }  
214.                         })  
215.                 .setNegativeButton(R.string.close,  
216.                         new DialogInterface.OnClickListener() {  
217.                             @Override  
218.                             public void onClick(DialogInterface dialog,  
219.                                     int whichButton) {  
220.                                 dialog.cancel();  
221.                             }  
222.                         });  
223.         dialogBuilder.show();  
224.     }  
225.     public void showToast(String text, int longint) {  
226.         Toast.makeText(context, text, longint).show();  
227.     }  
228.     @Override  
229.     public void showToast(String text) {  
230.         Toast.makeText(context, text, Toast.LENGTH_SHORT).show();  
231.     }  
232.     public void closeInput() {  
233.         InputMethodManager inputMethodManager = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);  
234.         if (inputMethodManager != null && this.getCurrentFocus() != null) {  
235.             inputMethodManager.hideSoftInputFromWindow(this.getCurrentFocus()  
236.                     .getWindowToken(), InputMethodManager.HIDE_NOT_ALWAYS);  
237.         }  
238.     }  
239.     public void setNotiType(int iconId, String contentTitle,  
240.             String contentText, Class activity, String from) {  
241.         Intent notifyIntent = new Intent(this, activity);  
242.         notifyIntent.putExtra("to", from);  
243.         // notifyIntent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);  
244.         PendingIntent appIntent = PendingIntent.getActivity(this, 0,  
245.                 notifyIntent, 0);  
246.         Notification myNoti = new Notification();  
247.         // 點選自動消失  
248.         myNoti.flags = Notification.FLAG_AUTO_CANCEL;  
249.         myNoti.icon = iconId;  
250.         myNoti.tickerText = contentTitle;  
251.         myNoti.defaults = Notification.DEFAULT_SOUND;  
252.         myNoti.setLatestEventInfo(this, contentTitle, contentText, appIntent);  
253.         notificationManager.notify(0, myNoti);  
254.     }  
255.     @Override  
256.     public Context getContext() {  
257.         return context;  
258.     }  
259.     @Override  
260.     public SharedPreferences getLoginUserSharedPre() {  
261.         return preferences;  
262.     }  
263.     @Override  
264.     public void saveLoginConfig(LoginConfig loginConfig) {  
265.         preferences.edit()  
266.                 .putString(Constant.XMPP_HOST, loginConfig.getXmppHost())  
267.                 .commit();  
268.         preferences.edit()  
269.                 .putInt(Constant.XMPP_PORT, loginConfig.getXmppPort()).commit();  
270.         preferences  
271.                 .edit()  
272.                 .putString(Constant.XMPP_SEIVICE_NAME,  
273.                         loginConfig.getXmppServiceName()).commit();  
274.         preferences.edit()  
275.                 .putString(Constant.USERNAME, loginConfig.getUsername())  
276.                 .commit();  
277.         preferences.edit()  
278.                 .putString(Constant.PASSWORD, loginConfig.getPassword())  
279.                 .commit();  
280.         preferences.edit()  
281.                 .putBoolean(Constant.IS_AUTOLOGIN, loginConfig.isAutoLogin())  
282.                 .commit();  
283.         preferences.edit()  
284.                 .putBoolean(Constant.IS_NOVISIBLE, loginConfig.isNovisible())  
285.                 .commit();  
286.         preferences.edit()  
287.                 .putBoolean(Constant.IS_REMEMBER, loginConfig.isRemember())  
288.                 .commit();  
289.         preferences.edit()  
290.                 .putBoolean(Constant.IS_ONLINE, loginConfig.isOnline())  
291.                 .commit();  
292.         preferences.edit()  
293.                 .putBoolean(Constant.IS_FIRSTSTART, loginConfig.isFirstStart())  
294.                 .commit();  
295.     }  
296.     @Override  
297.     public LoginConfig getLoginConfig() {  
298.         LoginConfig loginConfig = new LoginConfig();  
299.         String a = preferences.getString(Constant.XMPP_HOST, null);  
300.         String b = getResources().getString(R.string.xmpp_host);  
301.         loginConfig.setXmppHost(preferences.getString(Constant.XMPP_HOST,  
302.                 getResources().getString(R.string.xmpp_host)));  
303.         loginConfig.setXmppPort(preferences.getInt(Constant.XMPP_PORT,  
304.                 getResources().getInteger(R.integer.xmpp_port)));  
305.         loginConfig.setUsername(preferences.getString(Constant.USERNAME, null));  
306.         loginConfig.setPassword(preferences.getString(Constant.PASSWORD, null));  
307.         loginConfig.setXmppServiceName(preferences.getString(  
308.                 Constant.XMPP_SEIVICE_NAME,  
309.                 getResources().getString(R.string.xmpp_service_name)));  
310.         loginConfig.setAutoLogin(preferences.getBoolean(Constant.IS_AUTOLOGIN,  
311.                 getResources().getBoolean(R.bool.is_autologin)));  
312.         loginConfig.setNovisible(preferences.getBoolean(Constant.IS_NOVISIBLE,  
313.                 getResources().getBoolean(R.bool.is_novisible)));  
314.         loginConfig.setRemember(preferences.getBoolean(Constant.IS_REMEMBER,  
315.                 getResources().getBoolean(R.bool.is_remember)));  
316.         loginConfig.setFirstStart(preferences.getBoolean(  
317.                 Constant.IS_FIRSTSTART, true));  
318.         return loginConfig;  
319.     }  
320.     @Override  
321.     public boolean getUserOnlineState() {  
322.         // preferences = getSharedPreferences(Constant.LOGIN_SET,0);  
323.         return preferences.getBoolean(Constant.IS_ONLINE, true);  
324.     }  
325.     @Override  
326.     public void setUserOnlineState(boolean isOnline) {  
327.         // preferences = getSharedPreferences(Constant.LOGIN_SET,0);  
328.         preferences.edit().putBoolean(Constant.IS_ONLINE, isOnline).commit();  
329.     }  
330.     @Override  
331.     public EimApplication getEimApplication() {  
332.         return eimApplication;  
333.     }  
334. }  

大家寫android程式會發現，不同的activity之間經常需要調用一些公共的資源，這裡的資源不僅包括android自身的，還有我們自己的管理服務類，甚至互相之間傳遞一些參數，這裡我仿照struts2的設計，提煉出一個ActivitySupport類，同時抽取一個接口，讓所有的Activity都內建這個類，因為有了接口，我們便可以采用回調模式，非常友善的傳遞資料和使用公共的資源，這種好處相信大家使用之後都能有深刻的體會，通過接口回調傳遞參數和互相調用的方式無疑是最優雅的，spring和hibernate源碼中曾經大量使用這種結構。

2.SQLiteTemplate類 [java]  view plain copy

1. package csdn.shimiso.eim.db;  
2. import java.util.ArrayList;  
3. import java.util.List;  
4. import android.content.ContentValues;  
5. import android.database.Cursor;  
6. import android.database.sqlite.SQLiteDatabase;  
7. public class SQLiteTemplate {  
8.     protected String mPrimaryKey = "_id";  
9.     private DBManager dBManager;  
10.     private boolean isTransaction = false;  
11.     private SQLiteDatabase dataBase = null;  
12.     private SQLiteTemplate() {  
13.     }  
14.     private SQLiteTemplate(DBManager dBManager, boolean isTransaction) {  
15.         this.dBManager = dBManager;  
16.         this.isTransaction = isTransaction;  
17.     }  
18.     public static SQLiteTemplate getInstance(DBManager dBManager,  
19.             boolean isTransaction) {  
20.         return new SQLiteTemplate(dBManager, isTransaction);  
21.     }  
22.     public void execSQL(String sql) {  
23.         try {  
24.             dataBase = dBManager.openDatabase();  
25.             dataBase.execSQL(sql);  
26.         } catch (Exception e) {  
27.             e.printStackTrace();  
28.         } finally {  
29.             if (!isTransaction) {  
30.                 closeDatabase(null);  
31.             }  
32.         }  
33.     }  
34.     public void execSQL(String sql, Object[] bindArgs) {  
35.         try {  
36.             dataBase = dBManager.openDatabase();  
37.             dataBase.execSQL(sql, bindArgs);  
38.         } catch (Exception e) {  
39.             e.printStackTrace();  
40.         } finally {  
41.             if (!isTransaction) {  
42.                 closeDatabase(null);  
43.             }  
44.         }  
45.     }  
46.     public long insert(String table, ContentValues content) {  
47.         try {  
48.             dataBase = dBManager.openDatabase();  
49.             // insert方法第一參數：資料庫表名，第二個參數如果CONTENT為空時則向表中插入一個NULL,第三個參數為插入的内容  
50.             return dataBase.insert(table, null, content);  
51.         } catch (Exception e) {  
52.             e.printStackTrace();  
53.         } finally {  
54.             if (!isTransaction) {  
55.                 closeDatabase(null);  
56.             }  
57.         }  
58.         return 0;  
59.     }  
60.     public void deleteByIds(String table, Object... primaryKeys) {  
61.         try {  
62.             if (primaryKeys.length > 0) {  
63.                 StringBuilder sb = new StringBuilder();  
64.                 for (@SuppressWarnings("unused")  
65.                 Object id : primaryKeys) {  
66.                     sb.append("?").append(",");  
67.                 }  
68.                 sb.deleteCharAt(sb.length() - 1);  
69.                 dataBase = dBManager.openDatabase();  
70.                 dataBase.execSQL("delete from " + table + " where "  
71.                         + mPrimaryKey + " in(" + sb + ")",  
72.                         (Object[]) primaryKeys);  
73.             }  
74.         } catch (Exception e) {  
75.             e.printStackTrace();  
76.         } finally {  
77.             if (!isTransaction) {  
78.                 closeDatabase(null);  
79.             }  
80.         }  
81.     }  
82.     public int deleteByField(String table, String field, String value) {  
83.         try {  
84.             dataBase = dBManager.openDatabase();  
85.             return dataBase.delete(table, field + "=?", new String[] { value });  
86.         } catch (Exception e) {  
87.             e.printStackTrace();  
88.         } finally {  
89.             if (!isTransaction) {  
90.                 closeDatabase(null);  
91.             }  
92.         }  
93.         return 0;  
94.     }  
95.     public int deleteByCondition(String table, String whereClause,  
96.             String[] whereArgs) {  
97.         try {  
98.             dataBase = dBManager.openDatabase();  
99.             return dataBase.delete(table, whereClause, whereArgs);  
100.         } catch (Exception e) {  
101.             e.printStackTrace();  
102.         } finally {  
103.             if (!isTransaction) {  
104.                 closeDatabase(null);  
105.             }  
106.         }  
107.         return 0;  
108.     }  
109.     public int deleteById(String table, String id) {  
110.         try {  
111.             dataBase = dBManager.openDatabase();  
112.             return deleteByField(table, mPrimaryKey, id);  
113.         } catch (Exception e) {  
114.             e.printStackTrace();  
115.         } finally {  
116.             if (!isTransaction) {  
117.                 closeDatabase(null);  
118.             }  
119.         }  
120.         return 0;  
121.     }  
122.     public int updateById(String table, String id, ContentValues values) {  
123.         try {  
124.             dataBase = dBManager.openDatabase();  
125.             return dataBase.update(table, values, mPrimaryKey + "=?",  
126.                     new String[] { id });  
127.         } catch (Exception e) {  
128.             e.printStackTrace();  
129.         } finally {  
130.             if (!isTransaction) {  
131.                 closeDatabase(null);  
132.             }  
133.         }  
134.         return 0;  
135.     }  
136.     public int update(String table, ContentValues values, String whereClause,  
137.             String[] whereArgs) {  
138.         try {  
139.             dataBase = dBManager.openDatabase();  
140.             return dataBase.update(table, values, whereClause, whereArgs);  
141.         } catch (Exception e) {  
142.             e.printStackTrace();  
143.         } finally {  
144.             if (!isTransaction) {  
145.                 closeDatabase(null);  
146.             }  
147.         }  
148.         return 0;  
149.     }  
150.     public Boolean isExistsById(String table, String id) {  
151.         try {  
152.             dataBase = dBManager.openDatabase();  
153.             return isExistsByField(table, mPrimaryKey, id);  
154.         } catch (Exception e) {  
155.             e.printStackTrace();  
156.         } finally {  
157.             if (!isTransaction) {  
158.                 closeDatabase(null);  
159.             }  
160.         }  
161.         return null;  
162.     }  
163.     public Boolean isExistsByField(String table, String field, String value) {  
164.         StringBuilder sql = new StringBuilder();  
165.         sql.append("SELECT COUNT(*) FROM ").append(table).append(" WHERE ")  
166.                 .append(field).append(" =?");  
167.         try {  
168.             dataBase = dBManager.openDatabase();  
169.             return isExistsBySQL(sql.toString(), new String[] { value });  
170.         } catch (Exception e) {  
171.             e.printStackTrace();  
172.         } finally {  
173.             if (!isTransaction) {  
174.                 closeDatabase(null);  
175.             }  
176.         }  
177.         return null;  
178.     }  
179.     public Boolean isExistsBySQL(String sql, String[] selectionArgs) {  
180.         Cursor cursor = null;  
181.         try {  
182.             dataBase = dBManager.openDatabase();  
183.             cursor = dataBase.rawQuery(sql, selectionArgs);  
184.             if (cursor.moveToFirst()) {  
185.                 return (cursor.getInt(0) > 0);  
186.             } else {  
187.                 return false;  
188.             }  
189.         } catch (Exception e) {  
190.             e.printStackTrace();  
191.         } finally {  
192.             if (!isTransaction) {  
193.                 closeDatabase(cursor);  
194.             }  
195.         }  
196.         return null;  
197.     }  
198.     public <T> T queryForObject(RowMapper<T> rowMapper, String sql,  
199.             String[] args) {  
200.         Cursor cursor = null;  
201.         T object = null;  
202.         try {  
203.             dataBase = dBManager.openDatabase();  
204.             cursor = dataBase.rawQuery(sql, args);  
205.             if (cursor.moveToFirst()) {  
206.                 object = rowMapper.mapRow(cursor, cursor.getCount());  
207.             }  
208.         } finally {  
209.             if (!isTransaction) {  
210.                 closeDatabase(cursor);  
211.             }  
212.         }  
213.         return object;  
214.     }  
215.     public <T> List<T> queryForList(RowMapper<T> rowMapper, String sql,  
216.             String[] selectionArgs) {  
217.         Cursor cursor = null;  
218.         List<T> list = null;  
219.         try {  
220.             dataBase = dBManager.openDatabase();  
221.             cursor = dataBase.rawQuery(sql, selectionArgs);  
222.             list = new ArrayList<T>();  
223.             while (cursor.moveToNext()) {  
224.                 list.add(rowMapper.mapRow(cursor, cursor.getPosition()));  
225.             }  
226.         } finally {  
227.             if (!isTransaction) {  
228.                 closeDatabase(cursor);  
229.             }  
230.         }  
231.         return list;  
232.     }  
233.     public <T> List<T> queryForList(RowMapper<T> rowMapper, String sql,  
234.             int startResult, int maxResult) {  
235.         Cursor cursor = null;  
236.         List<T> list = null;  
237.         try {  
238.             dataBase = dBManager.openDatabase();  
239.             cursor = dataBase.rawQuery(sql + " limit ?,?", new String[] {  
240.                     String.valueOf(startResult), String.valueOf(maxResult) });  
241.             list = new ArrayList<T>();  
242.             while (cursor.moveToNext()) {  
243.                 list.add(rowMapper.mapRow(cursor, cursor.getPosition()));  
244.             }  
245.         } finally {  
246.             if (!isTransaction) {  
247.                 closeDatabase(cursor);  
248.             }  
249.         }  
250.         return list;  
251.     }  
252.     public Integer getCount(String sql, String[] args) {  
253.         Cursor cursor = null;  
254.         try {  
255.             dataBase = dBManager.openDatabase();  
256.             cursor = dataBase.rawQuery("select count(*) from (" + sql + ")",  
257.                     args);  
258.             if (cursor.moveToNext()) {  
259.                 return cursor.getInt(0);  
260.             }  
261.         } catch (Exception e) {  
262.             e.printStackTrace();  
263.         } finally {  
264.             if (!isTransaction) {  
265.                 closeDatabase(cursor);  
266.             }  
267.         }  
268.         return 0;  
269.     }  
270.     public <T> List<T> queryForList(RowMapper<T> rowMapper, String table,  
271.             String[] columns, String selection, String[] selectionArgs,  
272.             String groupBy, String having, String orderBy, String limit) {  
273.         List<T> list = null;  
274.         Cursor cursor = null;  
275.         try {  
276.             dataBase = dBManager.openDatabase();  
277.             cursor = dataBase.query(table, columns, selection, selectionArgs,  
278.                     groupBy, having, orderBy, limit);  
279.             list = new ArrayList<T>();  
280.             while (cursor.moveToNext()) {  
281.                 list.add(rowMapper.mapRow(cursor, cursor.getPosition()));  
282.             }  
283.         } finally {  
284.             if (!isTransaction) {  
285.                 closeDatabase(cursor);  
286.             }  
287.         }  
288.         return list;  
289.     }  
290.     public String getPrimaryKey() {  
291.         return mPrimaryKey;  
292.     }  
293.     public void setPrimaryKey(String primaryKey) {  
294.         this.mPrimaryKey = primaryKey;  
295.     }  
296.     public interface RowMapper<T> {  
297.         public T mapRow(Cursor cursor, int index);  
298.     }  
299.     public void closeDatabase(Cursor cursor) {  
300.         if (null != dataBase) {  
301.             dataBase.close();  
302.         }  
303.         if (null != cursor) {  
304.             cursor.close();  
305.         }  
306.     }  
307. }  

我們希望在android操作資料庫是優雅的一種方式，這裡不必關注事務，也不用擔心分頁，更不用為了封裝傳遞對象煩惱，總之一切就像面向對象那樣，簡單，模闆類的出現正是解決這個問題，雖然它看上去可能不是那麼完美有待提高，這裡我封裝了很多sqlite常用的工具，大家可以借鑒使用。

3.XmppConnectionManager管理類 [java]  view plain copy

1. package csdn.shimiso.eim.manager;  
2. import org.jivesoftware.smack.Connection;  
3. import org.jivesoftware.smack.ConnectionConfiguration;  
4. import org.jivesoftware.smack.Roster;  
5. import org.jivesoftware.smack.XMPPConnection;  
6. import org.jivesoftware.smack.provider.ProviderManager;  
7. import org.jivesoftware.smackx.GroupChatInvitation;  
8. import org.jivesoftware.smackx.PrivateDataManager;  
9. import org.jivesoftware.smackx.packet.ChatStateExtension;  
10. import org.jivesoftware.smackx.packet.LastActivity;  
11. import org.jivesoftware.smackx.packet.OfflineMessageInfo;  
12. import org.jivesoftware.smackx.packet.OfflineMessageRequest;  
13. import org.jivesoftware.smackx.packet.SharedGroupsInfo;  
14. import org.jivesoftware.smackx.provider.DataFormProvider;  
15. import org.jivesoftware.smackx.provider.DelayInformationProvider;  
16. import org.jivesoftware.smackx.provider.DiscoverInfoProvider;  
17. import org.jivesoftware.smackx.provider.DiscoverItemsProvider;  
18. import org.jivesoftware.smackx.provider.MUCAdminProvider;  
19. import org.jivesoftware.smackx.provider.MUCOwnerProvider;  
20. import org.jivesoftware.smackx.provider.MUCUserProvider;  
21. import org.jivesoftware.smackx.provider.MessageEventProvider;  
22. import org.jivesoftware.smackx.provider.MultipleAddressesProvider;  
23. import org.jivesoftware.smackx.provider.RosterExchangeProvider;  
24. import org.jivesoftware.smackx.provider.StreamInitiationProvider;  
25. import org.jivesoftware.smackx.provider.VCardProvider;  
26. import org.jivesoftware.smackx.provider.XHTMLExtensionProvider;  
27. import org.jivesoftware.smackx.search.UserSearch;  
28. import csdn.shimiso.eim.model.LoginConfig;  
29. public class XmppConnectionManager {  
30.     private XMPPConnection connection;  
31.     private static ConnectionConfiguration connectionConfig;  
32.     private static XmppConnectionManager xmppConnectionManager;  
33.     private XmppConnectionManager() {  
34.     }  
35.     public static XmppConnectionManager getInstance() {  
36.         if (xmppConnectionManager == null) {  
37.             xmppConnectionManager = new XmppConnectionManager();  
38.         }  
39.         return xmppConnectionManager;  
40.     }  
41.     // init  
42.     public XMPPConnection init(LoginConfig loginConfig) {  
43.         Connection.DEBUG_ENABLED = false;  
44.         ProviderManager pm = ProviderManager.getInstance();  
45.         configure(pm);  
46.         connectionConfig = new ConnectionConfiguration(  
47.                 loginConfig.getXmppHost(), loginConfig.getXmppPort(),  
48.                 loginConfig.getXmppServiceName());  
49.         connectionConfig.setSASLAuthenticationEnabled(false);// 不使用SASL驗證，設定為false  
50.         connectionConfig  
51.                 .setSecurityMode(ConnectionConfiguration.SecurityMode.enabled);  
52.         // 允許自動連接配接  
53.         connectionConfig.setReconnectionAllowed(false);  
54.         // 允許登陸成功後更新線上狀态  
55.         connectionConfig.setSendPresence(true);  
56.         // 收到好友邀請後manual表示需要經過同意,accept_all表示不經同意自動為好友  
57.         Roster.setDefaultSubscriptionMode(Roster.SubscriptionMode.manual);  
58.         connection = new XMPPConnection(connectionConfig);  
59.         return connection;  
60.     }  
61.     public XMPPConnection getConnection() {  
62.         if (connection == null) {  
63.             throw new RuntimeException("請先初始化XMPPConnection連接配接");  
64.         }  
65.         return connection;  
66.     }  
67.     public void disconnect() {  
68.         if (connection != null) {  
69.             connection.disconnect();  
70.         }  
71.     }  
72.     public void configure(ProviderManager pm) {  
73.         // Private Data Storage  
74.         pm.addIQProvider("query", "jabber:iq:private",  
75.                 new PrivateDataManager.PrivateDataIQProvider());  
76.         // Time  
77.         try {  
78.             pm.addIQProvider("query", "jabber:iq:time",  
79.                     Class.forName("org.jivesoftware.smackx.packet.Time"));  
80.         } catch (ClassNotFoundException e) {  
81.         }  
82.         // XHTML  
83.         pm.addExtensionProvider("html", "http://jabber.org/protocol/xhtml-im",  
84.                 new XHTMLExtensionProvider());  
85.         // Roster Exchange  
86.         pm.addExtensionProvider("x", "jabber:x:roster",  
87.                 new RosterExchangeProvider());  
88.         // Message Events  
89.         pm.addExtensionProvider("x", "jabber:x:event",  
90.                 new MessageEventProvider());  
91.         // Chat State  
92.         pm.addExtensionProvider("active",  
93.                 "http://jabber.org/protocol/chatstates",  
94.                 new ChatStateExtension.Provider());  
95.         pm.addExtensionProvider("composing",  
96.                 "http://jabber.org/protocol/chatstates",  
97.                 new ChatStateExtension.Provider());  
98.         pm.addExtensionProvider("paused",  
99.                 "http://jabber.org/protocol/chatstates",  
100.                 new ChatStateExtension.Provider());  
101.         pm.addExtensionProvider("inactive",  
102.                 "http://jabber.org/protocol/chatstates",  
103.                 new ChatStateExtension.Provider());  
104.         pm.addExtensionProvider("gone",  
105.                 "http://jabber.org/protocol/chatstates",  
106.                 new ChatStateExtension.Provider());  
107.         // FileTransfer  
108.         pm.addIQProvider("si", "http://jabber.org/protocol/si",  
109.                 new StreamInitiationProvider());  
110.         // Group Chat Invitations  
111.         pm.addExtensionProvider("x", "jabber:x:conference",  
112.                 new GroupChatInvitation.Provider());  
113.         // Service Discovery # Items  
114.         pm.addIQProvider("query", "http://jabber.org/protocol/disco#items",  
115.                 new DiscoverItemsProvider());  
116.         // Service Discovery # Info  
117.         pm.addIQProvider("query", "http://jabber.org/protocol/disco#info",  
118.                 new DiscoverInfoProvider());  
119.         // Data Forms  
120.         pm.addExtensionProvider("x", "jabber:x:data", new DataFormProvider());  
121.         // MUC User  
122.         pm.addExtensionProvider("x", "http://jabber.org/protocol/muc#user",  
123.                 new MUCUserProvider());  
124.         // MUC Admin  
125.         pm.addIQProvider("query", "http://jabber.org/protocol/muc#admin",  
126.                 new MUCAdminProvider());  
127.         // MUC Owner  
128.         pm.addIQProvider("query", "http://jabber.org/protocol/muc#owner",  
129.                 new MUCOwnerProvider());  
130.         // Delayed Delivery  
131.         pm.addExtensionProvider("x", "jabber:x:delay",  
132.                 new DelayInformationProvider());  
133.         // Version  
134.         try {  
135.             pm.addIQProvider("query", "jabber:iq:version",  
136.                     Class.forName("org.jivesoftware.smackx.packet.Version"));  
137.         } catch (ClassNotFoundException e) {  
138.         }  
139.         // VCard  
140.         pm.addIQProvider("vCard", "vcard-temp", new VCardProvider());  
141.         // Offline Message Requests  
142.         pm.addIQProvider("offline", "http://jabber.org/protocol/offline",  
143.                 new OfflineMessageRequest.Provider());  
144.         // Offline Message Indicator  
145.         pm.addExtensionProvider("offline",  
146.                 "http://jabber.org/protocol/offline",  
147.                 new OfflineMessageInfo.Provider());  
148.         // Last Activity  
149.         pm.addIQProvider("query", "jabber:iq:last", new LastActivity.Provider());  
150.         // User Search  
151.         pm.addIQProvider("query", "jabber:iq:search", new UserSearch.Provider());  
152.         // SharedGroupsInfo  
153.         pm.addIQProvider("sharedgroup",  
154.                 "http://www.jivesoftware.org/protocol/sharedgroup",  
155.                 new SharedGroupsInfo.Provider());  
156.         // JEP-33: Extended Stanza Addressing  
157.         pm.addExtensionProvider("addresses",  
158.                 "http://jabber.org/protocol/address",  
159.                 new MultipleAddressesProvider());  
160.     }  
161. }  

這個類是xmpp連接配接的管理類，如果大家使用smack的api對這個應該不會陌生，asmack對xmpp連接配接的管理，與smack的差别不大，但是部分細微差別也有，我們在使用中如果遇到問題，還要多加注意，我們這裡将其設計成單例，畢竟重複建立連接配接是個非常消耗的過程。

3.示範效果

很像QQ吧，沒錯，這是2012年版本qq的安卓界面，隻是界面元素一樣，實作方式大不相同，下面簡單列一下這個用戶端實作的功能： 1.聊天 2.離線消息 3.添加，删除好友 4.添加，移動好友分組 5.設定昵稱 6.監控好友狀态 7.網絡斷開系統自動重連接配接 8.收到添加好友請求消息處理 9.收到系統廣播消息處理 10.檢視曆史聊天記錄 11.消息彈出提醒，和小氣泡 .... 因為時間關系不是很完美，主要用于學習研究，歡迎大家給我提bug和改進意見。

4.源碼下載下傳

分數比較大，不是為了坑大家，是怕有伸手黨出現，拿了源碼出去招搖撞騙，請尊重作者原創！

參閱文獻

Openfirehttp://www.igniterealtime.org/

push-notificationhttp://www.push-notification.org/

Claros chathttp://www.claros.org/

androidpnsourceforgehttp://sourceforge.net/projects/androidpn/

android消息推送解決方案http://www.cnblogs.com/hanyonglu/archive/2012/03/04/2378971.html

xmpp協定實作原理介紹 http://www.cnblogs.com/hanyonglu/archive/2012/03/04/2378956.html