首先，要准备的文件有：

JDK，下载地址

Android SDK   下载地址

Eclipse   下载地址

下载对应的包到本地，首先安装jdk，进入jdk所在目录，如：

cd  /home/ithouge/Android

root@ithouge-OptiPlex-780:/home/ithouge/Android# ll
总用量 206464
drwxr-xr-x 11 root       root        4096 2011-12-31 15:10 ./
drwxr-xr-x 39 ithouge    ithouge     4096 2011-12-31 14:27 ../
drwxr-xr-x  9      28587    5000     4096 2011-12-27 18:27 android-ndk-r6b/
drwxrwxr-x 12      53856    5000     4096 2011-12-29 10:35 android-sdk_r12-linux_x86/
-rw-r–r–  1 root       root    30034243 2011-09-03 18:40 android-sdk_r12-linux_x86.tgz
drwxr-x— 12      12275    5000     4096 2011-12-31 15:30 android-sdk_r16-linux/
drwxr-xr-x 14 root       root        4096 2011-12-22 18:54 cocos2d-1.0.1-x-0.9.2/
drwxrwsr-x  9 libuuid    users       4096 2012-01-10 13:56 eclipse/
drwxrwsr-x  9 libuuid    users       4096 2011-12-31 14:19 eclipse3.5/
drwxrwsr-x  9 messagebus users       4096 2012-01-11 11:54 eclipse3.6/
-rwxrwxrwx  1        777 ithouge 96870084 2011-01-13 12:33 eclipse-java-galileo-SR2-linux-gtk.tar(1).gz*
drwxr-xr-x 10 root       root        4096 2011-09-03 18:09 jdk1.6.0_23/
-rwxrwxrwx  1        777 ithouge 84461758 2011-01-13 12:50 jdk-6u23-linux-i586.bin*
drwxr-xr-x  2 root       root        4096 2011-10-13 11:45 kernel/

确保jdk-6u23-linux-i586.bin具有可执行权限后，如果没有则执行

chmod a+x  jdk-6u23-linux-i586.bin

输入命令：

./jdk-6u23-linux-i586.bin

执行安装jdk,

安装成功之后解压缩android-sdk包，得到android-sdk-linux，进入对应的tools目录，双击android可执行文件，点击运行即可，

此时仅仅是运行了sdk的外壳，其没有安装android任何的api,可以根据自身需求选择安装sdk不同版本的api,

至此最好配置下环境变量，ubuntu配置方法之一：

gedit /etc/profile

在末尾加上：

export JAVA_HOME=/home/ithouge/Android/jdk1.6.0_23
export PATH=$PATH:$JAVA_HOME/bin:/home/ithouge/Android/android-sdk_r16-linux/tools:/home/ithouge/Android/android-sdk_r16-linux/platform-tools:/home/ithouge/Android/android-ndk-r6b:/home/ithouge/Android/cocos2d-1.0.1-x-0.9.2

路径因人而已，只需要替换更改即可，保存之后，执行

source /etc/profile

使得之前配置的环境变量生效

时刻你可以尝试执行

root@ithouge-OptiPlex-780:/home/ithouge/Android# java -version
java version “1.6.0_23″
Java(TM) SE Runtime Environment (build 1.6.0_23-b05)
Java HotSpot(TM) Server VM (build 19.0-b09, mixed mode)

如果看到类似以上的信息，则说明jdk安装成功，否则再次安装

接下来解压eclipse,

双击eclipse可执行文件，点击运行，启动eclipse后配置android插件，Help->Install New SoftWare  弹出一个Install对话框，

点击Add,在name选项中输入随意名称，在Location选项处填入:https://dl-ssl.google.com/android/eclipse/  点击ok

稍等片刻出现Developer Tools

展开，选中Android DDMS ,Android Development Tool  一路next,直至安装完毕。

安装完成之后，在eclipse选项栏，选择Window进入preferences项，弹出一个对话框后，选择左侧的Android,配置SDK的路径，点击Browse找到之前解压的sdk的路径，选择Apply之后，列表里面显示之前下载安装的sdk，点击ok.

至此，Android开发环境搭建完成，开启你的android开发之旅吧。

首先我的编译环境是：

root@ithouge-OptiPlex-780:/home/ithouge/Android/jdk1.6.0_23/include/linux# lsb_release -a
No LSB modules are available.
Distributor ID:	Ubuntu
Description:	Ubuntu 11.04
Release:	11.04
Codename:	natty

gcc version 4.5.2 (Ubuntu/Linaro 4.5.2-8ubuntu4)

1,新建一个测试用的C文件：/ithouge/test/SWIG/Demo2/example.c

#include
 double My_variable = 3.0;
 
 int fact(int n) {
     if (n <= 1) return 1;
     else return n*fact(n-1);
 }
 
 int my_mod(int x, int y) {
     return (x%y);
 }
 
 char *get_time()
 {
     time_t ltime;
     time(<ime);
     return ctime(<ime);
 }

2,编写相应的接口文件：/ithouge/test/SWIG/Demo2/example.i

/* example.i */
 %module example
 %{
 /* Put header files here or function declarations like below */
 extern double My_variable;
 extern int fact(int n);
 extern int my_mod(int x, int y);
 extern char *get_time();
 %}
 
 extern double My_variable;
 extern int fact(int n);
 extern int my_mod(int x, int y);
 extern char *get_time();

3,建立java,jni,c模块

首先要确保已经正确安装：swig,可以用以下命令查看。

root@ithouge-OptiPlex-780:/ithouge/test/SWIG/Demo2# swig -version
 
SWIG Version 1.3.40
 
Compiled with g++ [i686-pc-linux-gnu]
Please see http://www.swig.org for reporting bugs and further information
 
root@ithouge-OptiPlex-780:/ithouge/test/SWIG/Demo2# whereis swig
swig: /usr/bin/swig /usr/share/swig1.3 /usr/share/man/man1/swig.1.gz

如果显示信息如上则说明已经安装swig,否则通过apt-get install swig进行安装。

现在，进入到exexample.i所在目录：cd /ithouge/test/SWIG/Demo2

在终端执行：swig -java example.i

执行完成，在当前目录下生成三个新文件：example.java  exampleJNI.java   example_wrap.c

接下来编译.c文件：

gcc -c example.c example_wrap.c -I /home/ithouge/Android/jdk1.6.0_23/include/ -I /home/ithouge/Android/jdk1.6.0_23/include/linux/

其中：
/home/ithouge/Android/jdk1.6.0_23/include/ 是jni.h文件所在路径，

查找jni.h所在路径：locate jni.h
/home/ithouge/Android/jdk1.6.0_23/include/linux/ 是jni_mb.h文件所在路径，
执行完以上命令则生成两个.o文件，分别为：example.o  example_wrap.o
最后生成共享库：

 gcc -shared example.o example_wrap.o -o libexample.so

这样在当前目录下生成libexample.so文件，

4， 编写java运行程序

至此已经生成动态库，接下来便是编写java程序，实现功能函数。

public class main {
   public static void main(String argv[]) {
//     System.loadLibrary("example");
      System.load("/ithouge/test/SWIG/Demo2/libexample.so");
     System.out.println(example.getMy_variable());
     System.out.println(example.fact(5));
     System.out.println(example.get_time());
   }
 }

System.load/System.loadLibrary作用是加载动态链接库。
之后编译java: javac main.java
运行函数:java main
得到结果如下：

root@ithouge-OptiPlex-780:/ithouge/test/SWIG/Demo2# java main
3.0
120
Tue Dec 20 14:31:20 2011

1）首先要有良好的编码习惯

一个优秀的开发者应该善于运用常识、完善的算法和标准设计模式。要有资源意识，打开了就要记得关闭，尽量做到晚获取，早释放。这些由来已久的编码准则同样适用Android应用开发，尤其是使用基础设备服务时。

2）让阻塞操作远离主UI线程

通过使用AsyncTask、线程、IntentService和自定义后台服务，保证应用的灵活性。使用加载工具简化游标等长时间加载数据的状态管理。当有其他程序运行时，不能让你的应用滞后或中止。

如果一个操作需要消耗较多时间和资源时，取消该操作，换成异步处理，这样应用就能保持响应，用户可以继续各种操作。该方法适用磁盘读写、访问内容提供方、数据库和互联网，以及解析和其他需要花费较长时间的任务。

3）使用最新的Android SDK版本和API

使用Android平台的最新产品，保证你的应用紧跟Android的更新步伐。随着Android平台的不断发展，部分功能可能被弃用或被更好的功能 取代，核心API接收了bug修复和性能改进，新API有助于开发者编写出更稳定的应用。要明白最佳的做法总是随着时间的推移而变，聪明的开发者应该总是 站在整个平台的最前沿。

4）考虑使用StrictMode

从Android 2.3开始提供了一个新的类StrictMode，该类可以用于捕捉发生在应用程序主线程中耗时的磁盘、网络访问或函数调用，可以帮助开发者改进程序，使主线程处理UI和动画在磁盘读写和网络操作时变得更平滑，避免主线程被阻塞。

5）发布前禁用或尽量减少调试

如果开发周期较长，你很可能在应用中内置了一些日志或调试代码，在发布前确保这些功能已经最小化或完全禁用。

6）确保UI布局简单优雅

简单的屏幕不仅方便阅读，还能加快加载速度。与其在一个单一屏幕上堆砌太多不必要的功能，不如花时间去开发优雅的用户界面。简单优雅的UI不仅能提高应用性能，还能提高用户使用该应用时的效率。

7）根据目标设备调整应用资源

为尽可能高效地被加载，需要根据具体设备的配置调整相应资源，尤其是图片资源。为使应用包文件合理适用不同设备，首先可只添加运行该应用需要的核心资源，然后再根据具体设备下载相关内容。

8）使用Hierachy Viewer可视化调试工具

Hierachy Viewer能很方便地在开发者设计，调试和调整界面时，快速定位问题，解决问题，提高开发效率。

9）使用layoutopt进行布局优化

Layoutopt是一款简单的命令行工具，可帮助找到不必要的控件嵌套以及缩减布局资源，从而使应用变得可能“苗条”。控件越少、布局层次越浅，性能就越好。

10）使用Traceview及其他Android工具进行分析

Android SDK随带了很多用于应用分析的工具，其中最受欢迎的是Traceview，这款图形工具可以帮助调试和找到应用中的性能瓶颈。

结语

提升Android应用性能的方法有很多，有些需要使用特定的算法，有些依赖切实可行的调试和性能监测技术。幸运的是，Android平台随带了众多免费的实用工具，可以帮助跟踪和解决应用程序中的性能问题。

android的PowerManager和PowerManager.WakeLock

Android Google Map API 开发基础知识

Android —spannableStringBuilde

——在文字中夹杂一些图片，比如QQ中使用表情图片，以及如何将文字高亮显示等等

android屏幕截图

Android:将View的内容映射成Bitmap

Android:getDrawingCache() = null的解决方法

Android 调用指定的程序打开指定文件

SurfaceView的使用 自制视频播放器

Android 获取root权限 执行Linux命令 检测是否有ROOT权限

Android在程序中捕捉HOME键的方法

Android listview 连续调用 getview问题分析及解决

Android ListView反复调用getView和getCount

我们都知道android系统没有完全将contacts向developer开放，开发人员只能通过android提供的有限的Api对contacts进行操作，我们只能通过ContentProvider对contacts的数据进行增、删、改、查等操作，并不能改变到其表结构。

首先，我们来看下如何通过ContentProvider查找contacts，以下我以查找其姓、名、公司、家庭电话、工作电话、移动电话、传真、邮箱、城市、省份、国家、出生年月为例：

	/**
	 * 取得family_name和given_name
	 */
	Cursor nameCur=cr.query(ContactsContract.Data.CONTENT_URI,
			new String[] {Data.CONTACT_ID, StructuredName.DISPLAY_NAME, StructuredName.FAMILY_NAME, StructuredName.GIVEN_NAME, StructuredName.MIDDLE_NAME},
			 ContactsContract.Data.CONTACT_ID + "=?" + " AND "
          + ContactsContract.Data.MIMETYPE + "='" +  ContactsContract.CommonDataKinds.StructuredName.CONTENT_ITEM_TYPE + "'",
			new String[]{android_id}, null);
	if(nameCur.moveToFirst()){
		firstName=nameCur.getString(nameCur.getColumnIndex(ContactsContract.CommonDataKinds.StructuredName.FAMILY_NAME));
		lastName=nameCur.getString(nameCur.getColumnIndex(ContactsContract.CommonDataKinds.StructuredName.GIVEN_NAME));
	}
	nameCur.close();
 
	Cursor companyCur=cr.query(ContactsContract.Data.CONTENT_URI,
			new String[] {CommonDataKinds.Organization.COMPANY},
			 ContactsContract.Data.CONTACT_ID + "=?" + " AND "
          + ContactsContract.Data.MIMETYPE + "='" +  ContactsContract.CommonDataKinds.Organization.CONTENT_ITEM_TYPE + "'",
			new String[]{android_id}, null);
 
	if(companyCur.moveToFirst()){
			company=companyCur.getString(companyCur.getColumnIndex(CommonDataKinds.Organization.COMPANY));
		}
	companyCur.close();
 
	// 根据contact_ID取得HomePhone号码
	Cursor homePhoneCur = cr.query(ContactsContract.Data.CONTENT_URI,
			new String[] {ContactsContract.CommonDataKinds.Phone.NUMBER},
        ContactsContract.Data.CONTACT_ID + "=?" + " AND "
          + ContactsContract.Data.MIMETYPE + "=? "+" AND "
          +ContactsContract.CommonDataKinds.Phone.TYPE + "=?",
        new String[]{android_id,ContactsContract.CommonDataKinds.Phone.CONTENT_ITEM_TYPE,String.valueOf(ContactsContract.CommonDataKinds.Phone.TYPE_HOME)}, null);
	if(homePhoneCur.moveToFirst()){
		homePhone=homePhoneCur.getString(homePhoneCur.getColumnIndex(ContactsContract.CommonDataKinds.Phone.NUMBER));
	}
	homePhoneCur.close();
 
	// 根据contact_ID取得WorkPhone号码
	Cursor workPhoneCur = cr.query(ContactsContract.Data.CONTENT_URI,
			new String[] {ContactsContract.CommonDataKinds.Phone.NUMBER},
        ContactsContract.Data.CONTACT_ID + "=?" + " AND "
          + ContactsContract.Data.MIMETYPE + "=? "+" AND "
          +ContactsContract.CommonDataKinds.Phone.TYPE + "=?",
        new String[]{android_id,ContactsContract.CommonDataKinds.Phone.CONTENT_ITEM_TYPE,String.valueOf(ContactsContract.CommonDataKinds.Phone.TYPE_WORK)}, null);
	if(workPhoneCur.moveToFirst()){
		workPhone=workPhoneCur.getString(workPhoneCur.getColumnIndex(ContactsContract.CommonDataKinds.Phone.NUMBER));
	}
	workPhoneCur.close();
 
	// 根据contact_ID取得MobilePhone号码
	Cursor mobilePhoneCur = cr.query(ContactsContract.Data.CONTENT_URI,
			new String[] {ContactsContract.CommonDataKinds.Phone.NUMBER},
        ContactsContract.Data.CONTACT_ID + "=?" + " AND "
          + ContactsContract.Data.MIMETYPE + "=? "+" AND "
          +ContactsContract.CommonDataKinds.Phone.TYPE + "=?",
        new String[]{android_id,ContactsContract.CommonDataKinds.Phone.CONTENT_ITEM_TYPE,String.valueOf(ContactsContract.CommonDataKinds.Phone.TYPE_MOBILE)}, null);
	if(mobilePhoneCur.moveToFirst()){
		mobilePhone=mobilePhoneCur.getString(mobilePhoneCur.getColumnIndex(ContactsContract.CommonDataKinds.Phone.NUMBER));
	}
	mobilePhoneCur.close();
 
	// 根据contact_ID取得MobilePhone号码
	Cursor faxPhoneCur = cr.query(ContactsContract.Data.CONTENT_URI,
			new String[] {ContactsContract.CommonDataKinds.Phone.NUMBER},
        ContactsContract.Data.CONTACT_ID + "=?" + " AND "
          + ContactsContract.Data.MIMETYPE + "=? "+" AND "
          +ContactsContract.CommonDataKinds.Phone.TYPE + "=?",
        new String[]{android_id,ContactsContract.CommonDataKinds.Phone.CONTENT_ITEM_TYPE,String.valueOf(ContactsContract.CommonDataKinds.Phone.TYPE_FAX_HOME)}, null);
	if(faxPhoneCur.moveToFirst()){
		faxPhone=faxPhoneCur.getString(faxPhoneCur.getColumnIndex(ContactsContract.CommonDataKinds.Phone.NUMBER));
	}
	faxPhoneCur.close();
 
	// 根据contact_ID取得MobilePhone号码
	Cursor emailCur = cr.query(ContactsContract.Data.CONTENT_URI,
			new String[] {ContactsContract.CommonDataKinds.Email.DATA},
        ContactsContract.Data.CONTACT_ID + "=?" + " AND "
          + ContactsContract.Data.MIMETYPE + "=? "+" AND "
          +ContactsContract.CommonDataKinds.Phone.TYPE + "=?",
        new String[]{android_id,ContactsContract.CommonDataKinds.Email.CONTENT_ITEM_TYPE,String.valueOf(ContactsContract.CommonDataKinds.Email.TYPE_WORK)}, null);
	if(emailCur.moveToFirst()){
		email=emailCur.getString(emailCur.getColumnIndex(ContactsContract.CommonDataKinds.Email.DATA));
	}
	emailCur.close();
 
	// 根据contact_ID取得MobilePhone号码
	Cursor addressCur = cr.query(ContactsContract.Data.CONTENT_URI,
			new String[] {ContactsContract.CommonDataKinds.StructuredPostal.CITY,ContactsContract.CommonDataKinds.StructuredPostal.REGION,
			ContactsContract.CommonDataKinds.StructuredPostal.COUNTRY},
        ContactsContract.Data.CONTACT_ID + "=?" + " AND "
        + ContactsContract.Data.MIMETYPE + "=? ",
        new String[]{android_id,ContactsContract.CommonDataKinds.StructuredPostal.CONTENT_ITEM_TYPE}, null);
	if(addressCur.moveToFirst()){
		city=addressCur.getString(addressCur.getColumnIndex(ContactsContract.CommonDataKinds.StructuredPostal.CITY));
		state=addressCur.getString(addressCur.getColumnIndex(ContactsContract.CommonDataKinds.StructuredPostal.REGION));
		country=addressCur.getString(addressCur.getColumnIndex(ContactsContract.CommonDataKinds.StructuredPostal.COUNTRY));
	}
	addressCur.close();
 
	// 根据contact_ID取得MobilePhone号码
	Cursor birthdayCur = cr.query(ContactsContract.Data.CONTENT_URI,
			new String[] {ContactsContract.CommonDataKinds.Event.DATA},
        ContactsContract.Data.CONTACT_ID + "=?" + " AND "
          + ContactsContract.Data.MIMETYPE + "=? "+" AND "
          + ContactsContract.CommonDataKinds.Event.TYPE + "=? ",
        new String[]{android_id,ContactsContract.CommonDataKinds.Event.CONTENT_ITEM_TYPE,String.valueOf(ContactsContract.CommonDataKinds.Event.TYPE_BIRTHDAY)}, null);
	if(birthdayCur.moveToFirst()){
		birthday=birthdayCur.getString(birthdayCur.getColumnIndex(ContactsContract.CommonDataKinds.Event.DATA));
	}
	birthdayCur.close();

以上只是查找了contacts的部分字段，同鞋们可以自行拓展，比如说查找其IM,Organization,Nickname,WebSite等等.

得到contacts联系人之后，我们可以对其做相应的修改，修改完成后，我们要将数据更新到android contacts数据库中，以下就是更新的范例:

  	ArrayList ops =
	          new ArrayList();
		// 更新family_name和given_name
	 ops.add(ContentProviderOperation.newUpdate(ContactsContract.Data.CONTENT_URI)
	          .withSelection(ContactsContract.Data.CONTACT_ID + "=?" + " AND "
	        		  + ContactsContract.Data.MIMETYPE + "=?",
	        		  new String[]{android_id,ContactsContract.CommonDataKinds.StructuredName.CONTENT_ITEM_TYPE})
                        .withValue(ContactsContract.CommonDataKinds.StructuredName.FAMILY_NAME, firstN)
                        .withValue(ContactsContract.CommonDataKinds.StructuredName.GIVEN_NAME, lastN)
                        .build());
	 // 更新comany
	 ops.add(ContentProviderOperation.newUpdate(ContactsContract.Data.CONTENT_URI)
	          .withSelection(ContactsContract.Data.CONTACT_ID + "=?" + " AND "
	        		  + ContactsContract.Data.MIMETYPE + "=?"+ " AND "
	        		  + ContactsContract.CommonDataKinds.Organization.TYPE + "=?",
	        		  new String[]{android_id,ContactsContract.CommonDataKinds.Organization.CONTENT_ITEM_TYPE,String.valueOf(ContactsContract.CommonDataKinds.Organization.TYPE_WORK)})
                       .withValue(ContactsContract.CommonDataKinds.Organization.COMPANY, com)
                       .build());
	 // 更新homePhone
	 ops.add(ContentProviderOperation.newUpdate(ContactsContract.Data.CONTENT_URI)
	          .withSelection(ContactsContract.Data.CONTACT_ID + "=?" + " AND "
	        		  + ContactsContract.Data.MIMETYPE + "=?"+ " AND "
	        		  + ContactsContract.CommonDataKinds.Organization.TYPE + "=?",
	        		  new String[]{android_id,ContactsContract.CommonDataKinds.Phone.CONTENT_ITEM_TYPE,String.valueOf(ContactsContract.CommonDataKinds.Phone.TYPE_HOME)})
                      .withValue(ContactsContract.CommonDataKinds.Phone.NUMBER, hp)
                      .build());
	 // 更新workPhone
	 ops.add(ContentProviderOperation.newUpdate(ContactsContract.Data.CONTENT_URI)
	          .withSelection(ContactsContract.Data.CONTACT_ID + "=?" + " AND "
	        		  + ContactsContract.Data.MIMETYPE + "=?"+ " AND "
	        		  + ContactsContract.CommonDataKinds.Organization.TYPE + "=?",
	        		  new String[]{android_id,ContactsContract.CommonDataKinds.Phone.CONTENT_ITEM_TYPE,String.valueOf(ContactsContract.CommonDataKinds.Phone.TYPE_WORK)})
                     .withValue(ContactsContract.CommonDataKinds.Phone.NUMBER,wp)
                     .build());
	// 更新mobilePhone
	 ops.add(ContentProviderOperation.newUpdate(ContactsContract.Data.CONTENT_URI)
	          .withSelection(ContactsContract.Data.CONTACT_ID + "=?" + " AND "
	        		  + ContactsContract.Data.MIMETYPE + "=?"+ " AND "
	        		  + ContactsContract.CommonDataKinds.Organization.TYPE + "=?",
	        		  new String[]{android_id,ContactsContract.CommonDataKinds.Phone.CONTENT_ITEM_TYPE,String.valueOf(ContactsContract.CommonDataKinds.Phone.TYPE_MOBILE)})
                    .withValue(ContactsContract.CommonDataKinds.Phone.NUMBER,mp)
                    .build());
	// 更新faxPhone
	 ops.add(ContentProviderOperation.newUpdate(ContactsContract.Data.CONTENT_URI)
	          .withSelection(ContactsContract.Data.CONTACT_ID + "=?" + " AND "
	        		  + ContactsContract.Data.MIMETYPE + "=?"+ " AND "
	        		  + ContactsContract.CommonDataKinds.Organization.TYPE + "=?",
	        		  new String[]{android_id,ContactsContract.CommonDataKinds.Phone.CONTENT_ITEM_TYPE,String.valueOf(ContactsContract.CommonDataKinds.Phone.TYPE_FAX_HOME)})
                    .withValue(ContactsContract.CommonDataKinds.Phone.NUMBER,fp)
                    .build());
	// 更新email
	 ops.add(ContentProviderOperation.newUpdate(ContactsContract.Data.CONTENT_URI)
	          .withSelection(ContactsContract.Data.CONTACT_ID + "=?" + " AND "
	        		  + ContactsContract.Data.MIMETYPE + "=?"+ " AND "
	        		  + ContactsContract.CommonDataKinds.Email.TYPE + "=?",
	        		  new String[]{android_id,ContactsContract.CommonDataKinds.Email.CONTENT_ITEM_TYPE,String.valueOf(ContactsContract.CommonDataKinds.Email.TYPE_WORK)})
                   .withValue(ContactsContract.CommonDataKinds.Email.DATA,em)
                   .build());
	// 更新city,state,country
	 ops.add(ContentProviderOperation.newUpdate(ContactsContract.Data.CONTENT_URI)
	          .withSelection(ContactsContract.Data.CONTACT_ID + "=?" + " AND "
	        		  + ContactsContract.Data.MIMETYPE + "=?"+ " AND "
	        		  + ContactsContract.CommonDataKinds.StructuredPostal.TYPE + "=?",
	        		  new String[]{android_id,ContactsContract.CommonDataKinds.StructuredPostal.CONTENT_ITEM_TYPE,String.valueOf(ContactsContract.CommonDataKinds.StructuredPostal.TYPE_HOME)})
                  .withValue(ContactsContract.CommonDataKinds.StructuredPostal.CITY, city)
                  .withValue(ContactsContract.CommonDataKinds.StructuredPostal.REGION, state)
                  .withValue(ContactsContract.CommonDataKinds.StructuredPostal.COUNTRY,cou)
                  .build());
	// 更新birthday
	 ops.add(ContentProviderOperation.newUpdate(ContactsContract.Data.CONTENT_URI)
	          .withSelection(ContactsContract.Data.CONTACT_ID + "=?" + " AND "
	        		  + ContactsContract.Data.MIMETYPE + "=?"+ " AND "
	        		  + ContactsContract.CommonDataKinds.Event.TYPE + "=?",
	        		  new String[]{android_id,ContactsContract.CommonDataKinds.Event.CONTENT_ITEM_TYPE,String.valueOf(ContactsContract.CommonDataKinds.Event.TYPE_BIRTHDAY)})
                 .withValue(ContactsContract.CommonDataKinds.Event.DATA, bir)
                 .build());
	 try
     {
         ContentProviderResult[] res = context.getContentResolver().applyBatch(ContactsContract.AUTHORITY, ops);
	//  Log.i("contact", "android_id="+android_id+",firstName="+firstName+",lastName="+lastName);
	//  appState.db.insertContactToTag(tagId,String.valueOf(contactId));
     }
     catch (RemoteException e)
     {
         // error
     }catch (OperationApplicationException e)
     {
         // error
     }

同样以上更新也仅是对contact的部分字段进行了更新，我相信聪明的你，仔细阅读，细细推敲一番，定能找到其中的规律，从而对犹如IM,Nickname,Event,Organization等字段进行更新。

以上只是对已经存在的contacts进行操作，那么我们一开始该如何向里面插入一条数据呢，以下代码是实现向数据库中插入一条数据的操作。

	ArrayList ops = new ArrayList();
		int rawContactInsertIndex = ops.size();
 
        ops.add(ContentProviderOperation.newInsert(ContactsContract.RawContacts.CONTENT_URI)
                .withValue(ContactsContract.RawContacts.ACCOUNT_TYPE, null)
                .withValue(ContactsContract.RawContacts.ACCOUNT_NAME, null)
                .build());
 
      //------------------------------------------------------ Names
        if(firstN != null && lastN!=null )
        {
            ops.add(ContentProviderOperation.newInsert(ContactsContract.Data.CONTENT_URI)
                    .withValueBackReference(ContactsContract.Data.RAW_CONTACT_ID, rawContactInsertIndex)
                    .withValue(ContactsContract.Data.MIMETYPE,
                            ContactsContract.CommonDataKinds.StructuredName.CONTENT_ITEM_TYPE)
                    .withValue(ContactsContract.CommonDataKinds.StructuredName.DISPLAY_NAME, firstN+lastN)
                    .withValue(ContactsContract.CommonDataKinds.StructuredName.FAMILY_NAME, firstN)
                    .withValue(ContactsContract.CommonDataKinds.StructuredName.GIVEN_NAME, lastN)
                    .build());
        }  
 
      //------------------------------------------------------ Organization
        if(com!=null)
        {
            ops.add(ContentProviderOperation.newInsert(ContactsContract.Data.CONTENT_URI)
                    .withValueBackReference(ContactsContract.Data.RAW_CONTACT_ID, rawContactInsertIndex)
                    .withValue(ContactsContract.Data.MIMETYPE,
                            ContactsContract.CommonDataKinds.Organization.CONTENT_ITEM_TYPE)
                    .withValue(ContactsContract.CommonDataKinds.Organization.COMPANY, com)
                    .withValue(ContactsContract.CommonDataKinds.Organization.TYPE, ContactsContract.CommonDataKinds.Organization.TYPE_WORK)
                    .build());
        }
 
      //------------------------------------------------------ Home Numbers
        if(hp!= null)
        {
            ops.add(ContentProviderOperation.newInsert(ContactsContract.Data.CONTENT_URI)
                    .withValueBackReference(ContactsContract.Data.RAW_CONTACT_ID, rawContactInsertIndex)
                    .withValue(ContactsContract.Data.MIMETYPE,
                            ContactsContract.CommonDataKinds.Phone.CONTENT_ITEM_TYPE)
                    .withValue(ContactsContract.CommonDataKinds.Phone.NUMBER, hp)
                    .withValue(ContactsContract.CommonDataKinds.Phone.TYPE,
                            ContactsContract.CommonDataKinds.Phone.TYPE_HOME)
                    .build());
        }
      //------------------------------------------------------ Work Numbers
        if(wp != null)
        {
            ops.add(ContentProviderOperation.newInsert(ContactsContract.Data.CONTENT_URI)
                    .withValueBackReference(ContactsContract.Data.RAW_CONTACT_ID, rawContactInsertIndex)
                    .withValue(ContactsContract.Data.MIMETYPE,
                            ContactsContract.CommonDataKinds.Phone.CONTENT_ITEM_TYPE)
                    .withValue(ContactsContract.CommonDataKinds.Phone.NUMBER, wp)
                    .withValue(ContactsContract.CommonDataKinds.Phone.TYPE,
                            ContactsContract.CommonDataKinds.Phone.TYPE_WORK)
                    .build());
        }
      //------------------------------------------------------ Mobile Number
        if(mp != null)
        {
            ops.add(ContentProviderOperation.newInsert(ContactsContract.Data.CONTENT_URI)
                    .withValueBackReference(ContactsContract.Data.RAW_CONTACT_ID, rawContactInsertIndex)
                    .withValue(ContactsContract.Data.MIMETYPE,
                            ContactsContract.CommonDataKinds.Phone.CONTENT_ITEM_TYPE)
                    .withValue(ContactsContract.CommonDataKinds.Phone.NUMBER, mp)
                    .withValue(ContactsContract.CommonDataKinds.Phone.TYPE,
                            ContactsContract.CommonDataKinds.Phone.TYPE_MOBILE)
                    .build());
        }
      //------------------------------------------------------ Fax Number
        if(fp != null)
        {
            ops.add(ContentProviderOperation.newInsert(ContactsContract.Data.CONTENT_URI)
                    .withValueBackReference(ContactsContract.Data.RAW_CONTACT_ID, rawContactInsertIndex)
                    .withValue(ContactsContract.Data.MIMETYPE,
                            ContactsContract.CommonDataKinds.Phone.CONTENT_ITEM_TYPE)
                    .withValue(ContactsContract.CommonDataKinds.Phone.NUMBER, fp)
                    .withValue(ContactsContract.CommonDataKinds.Phone.TYPE,
                            ContactsContract.CommonDataKinds.Phone.TYPE_FAX_HOME)
                    .build());
        }
 
      //------------------------------------------------------ Email
        if(em != null)
        {
             ops.add(ContentProviderOperation.newInsert(ContactsContract.Data.CONTENT_URI)
                        .withValueBackReference(ContactsContract.Data.RAW_CONTACT_ID, rawContactInsertIndex)
                        .withValue(ContactsContract.Data.MIMETYPE,
                                ContactsContract.CommonDataKinds.Email.CONTENT_ITEM_TYPE)
                        .withValue(ContactsContract.CommonDataKinds.Email.DATA, em)
                        .withValue(ContactsContract.CommonDataKinds.Email.TYPE, ContactsContract.CommonDataKinds.Email.TYPE_WORK)
                        .build());
        }
      //------------------------------------------------------ City,state,country
        if(city != null)
        {
             ops.add(ContentProviderOperation.newInsert(ContactsContract.Data.CONTENT_URI)
                        .withValueBackReference(ContactsContract.Data.RAW_CONTACT_ID, rawContactInsertIndex)
                        .withValue(ContactsContract.Data.MIMETYPE,
                                ContactsContract.CommonDataKinds.StructuredPostal.CONTENT_ITEM_TYPE)
                        .withValue(ContactsContract.CommonDataKinds.StructuredPostal.CITY, city)
                        .withValue(ContactsContract.CommonDataKinds.StructuredPostal.REGION, state)
                        .withValue(ContactsContract.CommonDataKinds.StructuredPostal.COUNTRY,cou)
                        .withValue(ContactsContract.CommonDataKinds.StructuredPostal.TYPE,
                        		ContactsContract.CommonDataKinds.StructuredPostal.TYPE_HOME)
                        .build());
        }
 
      //------------------------------------------------------ Birthday
        if(bir != null)
        {
             ops.add(ContentProviderOperation.newInsert(ContactsContract.Data.CONTENT_URI)
                        .withValueBackReference(ContactsContract.Data.RAW_CONTACT_ID, rawContactInsertIndex)
                        .withValue(ContactsContract.Data.MIMETYPE,
                                ContactsContract.CommonDataKinds.Event.CONTENT_ITEM_TYPE)
                        .withValue(ContactsContract.CommonDataKinds.Event.DATA, bir)
                        .withValue(ContactsContract.CommonDataKinds.Event.TYPE,
                        		ContactsContract.CommonDataKinds.Event.TYPE_BIRTHDAY)
                        .build());
        }
        try
        {
            ContentProviderResult[] res = context.getContentResolver().applyBatch(ContactsContract.AUTHORITY, ops);
 
            return res;
        }
        catch (RemoteException e)
        {
            // error
        }catch (OperationApplicationException e)
        {
            // error
        }

实现以上代码便可将一条数据插入到contacts数据库中，同样，你也可以插入其他的字段，而且你也可以细细研究下ContentProviderResult[]，看看进行这些操作后，其返回的结果都是什么。

以上实现了对android contacts 增、删、改、查中的三种，下面的代码就是实现删的，删除一个contacts相对来说比较简单些。

       String where = ContactsContract.Data._ID + " = ? ";
    	String[] params = new String[] {android_id};
 
        ArrayList ops = new ArrayList();
        ops.add(ContentProviderOperation.newDelete(ContactsContract.RawContacts.CONTENT_URI)
    	        .withSelection(where, params)
    	        .build());
        try {
		cr.applyBatch(ContactsContract.AUTHORITY, ops);
	} catch (RemoteException e) {
		// TODO Auto-generated catch block
		e.printStackTrace();
	} catch (OperationApplicationException e) {
		// TODO Auto-generated catch block
		e.printStackTrace();
	}

删除一个contacts有很多的选择，你可以只删除电话这一块，也可以删除联系人信息这一块，而且你不仅可以将id做作为条件进行删除，你也可以将联系电话做为条件进行删除，你也还可以以用户名做为条件进行删除。

想要更详细的了解通讯录的数据库内部结构及操作请访问:http://blog.csdn.net/xys289187120/article/details/6730957

以上代码便可以实现对android contacts的增、删、改、查等操作。最后不要忘了赋予APP 对contacts读写的权限：

Note: There is a poll embedded within this post, please visit the site to participate in this post's poll.

这个是C2DM官方对其的一个解释，自我感觉英文不错的童鞋可以去http://code.google.com/intl/zh-CN/android/c2dm/仔细研读一番，这里面包括了对C2DM的介绍以及实现步骤和具体实现的部分代码。当然了如果你对英文很头疼，也或懒得去看鸟语，那就请看小弟下面的心得体会吧，先预言，以下方法在本人开环境中测试是ok的。

按小编的理解，C2DM就是通过Server向mobile device发送message,并且获得message后由applications，值得注意的是发送的message是限制长度的字符串，它适用于传送间断的消息，或是告诉applications去进行某些操作。

首先我们要有一个邮箱，最好是google mail(Gmail)，至于有什么用，后面的步骤会提及到。

其次我们要去注册(Sign Up for Android Cloud to Device Messaging),注册的网址:http://code.google.com/intl/zh-CN/android/c2dm/signup.html，其中有两项:Contact email,Role (sender) account email是必填的，而且都是输入email，Contact email是google与你联系的方式，可以随意写入一个email address.比如说当你注册成功后，google会发送一个email给你，告诉你恭喜你。。。。。.Role (sender) account email则是作为Google Account ID来发送message到C2DM的，这个email最好唯一，而且应该是我们第一步注册的那个邮箱(Gmail)。注册成功后会获得一串:APA91bENnaUdTRJTyDX45BE33Ta0tQUwwv2gkC4xDqG3YX7GR76qs-epWvXDfEErkZb_osAKBBbbPN_7QPKXxRLF1RREj1eSF1vmVr4MvkEgmWZQu9IrHx0 。将其保存好，传给local server，local server会用它来和Google server进行验证、通讯。

到这里可以说是万事具备，只欠东风了，接下来我们要在application中注册一个广播，用于接收local server所发送过来的message，

1
2
3
4
5
6
7
8
9
10
11
12

<receiver android:name="com.gigatalk.service.C2DMReceiver" android:permission="com.google.android.c2dm.permission.SEND">
          <!-- Receive the actual message -->
          <intent-filter>
              <action android:name="com.google.android.c2dm.intent.RECEIVE" />
              <category android:name="com.gigatalk" />
          </intent-filter>
          <!-- Receive the registration id -->
          <intent-filter>
              <action android:name="com.google.android.c2dm.intent.REGISTRATION" />
              <category android:name="com.gigatalk" />
          </intent-filter>
      </receiver>

注册好了广播之后，我们就开始静静的等待接收广播，那么我们要先定义一个广播接收器，用来接收广播和对广播进行处理，

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

/**
 * Broadcast receiver that handles Android Cloud to Data Messaging (AC2DM) messages, initiated
 * by the JumpNote App Engine server and routed/delivered by Google AC2DM servers. The
 * only currently defined message is 'sync'.
 */
public class C2DMReceiver extends BroadcastReceiver {
 
	@Override
	public void onReceive(Context context, Intent intent) {
		// TODO Auto-generated method stub
		if (intent.getAction().equals("com.google.android.c2dm.intent.REGISTRATION")) {
	        handleRegistration(context, intent);
	    } else if (intent.getAction().equals("com.google.android.c2dm.intent.RECEIVE")) {
	        handleMessage(context, intent);
	    }
	}
	private void handleRegistration(Context context, Intent intent) {
	    String registration = intent.getStringExtra("registration_id"); 
	    if (intent.getStringExtra("error") != null) {
	        // Registration failed, should try again later.
	    	Log.i("c2dm","error");
	    } else if (intent.getStringExtra("unregistered") != null) {
	        // unregistration done, new messages from the authorized sender will be rejected
	    	Log.i("c2dm","unregistered");
	    } else if (registration != null) {
	       // Send the registration ID to the 3rd party site that is sending the messages.
	       // This should be done in a separate thread.
	       // When done, remember that all registration is done. 
	    	Log.i("c2dm",registration);
	    }
	}
	private void handleMessage(Context context, Intent intent) {
 
	    Bundle extras = intent.getExtras();
        if (extras != null) {
        	String message = intent.getExtras().getString("message");
            Log.i("c2dm", message);
            }
        }
 
}

在这里你可以接收到注册时的信息，以及接收到得广播信息，并且你可以完全自定义的对其进行相应的处理。

当然请务必不要忘记，在接收、处理广播之前，我们要事先向C2DM服务器注册，说明接收谁发送过来的message以及由谁来接收。

1
2
3
4
5

//向C2DM服务器注册         
           Intent registrationIntent = new Intent("com.google.android.c2dm.intent.REGISTER");
            registrationIntent.putExtra("app", PendingIntent.getBroadcast(this, 0, new Intent(), 0)); // boilerplate
            registrationIntent.putExtra("sender", "houjiankai@gmail.com");
            startService(registrationIntent);

其中sender就是之前第二步注册的时候注册的那个Role (sender) account email。

本章我将介绍的是一个自定义的PopupWindow，它实现的效果是固定显示在一定大小的区域内，并根据点击按钮的位置来显示箭头，用于指示当前选中的按钮，并自定义其布局，对布局中组件进行相应的监听，相应相应的操作,而且自定义其弹出和淡去的动画效果，弹出:自左向右滑动淡入，淡出:自右向左淡出。效果图如下:

图1：

图2

如图，当点击左侧的的按钮时，其箭头指向当前按钮，并点击相应的按钮color、Sort、Save、Cancel、Delete等响应响应的动作。以下是实现的部分核心代码:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277

       public class QuickActionWindow extends PopupWindow implements KeyEvent.Callback,OnClickListener,OnColorChangedListener{
	private static final String THIS_FILE = "QuickActionWindow";
	private final Context mContext;
	private final LayoutInflater mInflater;
	private final WindowManager mWindowManager;
 
	View contentView;
 
	private int mScreenWidth;
	private int mScreenHeight;
 
	private int mShadowHoriz,nine,Hundred;
//	private int mShadowVert;
//	private int mShadowTouch;
 
	private ImageView mArrowUp;
	private ImageView mArrowDown;
 
	private EditText catName;
	private Button yesButton,cancelButton,deleteButton,colorButton,sortButton;
	private int marginTop;
	private int colorGiga=Color.RED;
	private Contants appState;
	private String nameStr,tag_str="";
	private int popUpWidth,popUpHeight;
 
	/*
	 * private View mHeader; private HorizontalScrollView mTrackScroll;
	 */
	private ViewGroup mTrack;
 
	/*
	 * private View mFooter; private View mFooterDisambig; private ListView
	 * mResolveList; private CheckBox mSetPrimaryCheckBox;
	 */
 
	private View mPView;
	private Rect mAnchor,listAnchor;
 
    // context为传入的上下文,pView为对应的父级得视图
	public QuickActionWindow(Context context, View pView,String name,Rect rect,Rect listRect) {
		super(context);
 
		mPView = pView;
		nameStr=name;
 
		mAnchor = rect;
		listAnchor=listRect;
 
		marginTop=listAnchor.top;
 
		if(!nameStr.equals("")){ // 如果传入的名称不为空,则为修改Tag
			tag_str=mPView.getTag().toString();
		}
 
		mContext = context;
		appState=(Contants) mContext.getApplicationContext();
		mWindowManager = (WindowManager) mContext.getSystemService(Context.WINDOW_SERVICE);
		mInflater = ((Activity) mContext).getLayoutInflater();
 
		setContentView(R.layout.quickaction);
 
		mScreenWidth = mWindowManager.getDefaultDisplay().getWidth();//获取屏幕的宽度
		mScreenHeight = mWindowManager.getDefaultDisplay().getHeight();
 
		setWindowLayoutMode(ViewGroup.LayoutParams.FILL_PARENT, ViewGroup.LayoutParams.FILL_PARENT);
 
		final Resources res = mContext.getResources();
		mShadowHoriz = res.getDimensionPixelSize(R.dimen.quickaction_shadow_horiz);// 0dip
		nine=res.getDimensionPixelSize(R.dimen.quickaction_nine);// 9dip
		Hundred=res.getDimensionPixelSize(R.dimen.quickaction_one_Hundred);// 100dip
 
		setWidth(mScreenWidth-listAnchor.left+nine);// 设置PopupWindow的宽度
		setHeight(listAnchor.bottom-listAnchor.top);
 
		setBackgroundDrawable(new ColorDrawable(0));
 
		mArrowUp = (ImageView) contentView.findViewById(R.id.arrow_up);
		mArrowDown = (ImageView) contentView.findViewById(R.id.arrow_down);
 
		mTrack = (ViewGroup) contentView.findViewById(R.id.quickaction);//中间
 
		catName=(EditText) contentView.findViewById(R.id.cat_name);// Tag名称
		catName.setText(nameStr);
//		catName.setText(title);
    	yesButton = (Button) contentView.findViewById(R.id.cat_save);// Save Button
    	yesButton.setOnClickListener(this);
 
    	cancelButton = (Button) contentView.findViewById(R.id.cat_cancel); // Cancel Button
    	cancelButton.setOnClickListener(this);
 
    	deleteButton=(Button) contentView.findViewById(R.id.cat_delete); // Delete Button
    	deleteButton.setOnClickListener(this);
    	if(tag_str.equals("1")||tag_str.equals("2") || nameStr.equals("")){// 如果tag_id为1或2,则表明为All、Favorite
    		deleteButton.setVisibility(View.GONE);
    	}else{
    		deleteButton.setVisibility(View.VISIBLE);
    	}
    	colorButton=(Button) contentView.findViewById(R.id.cat_color); // Color Button
    	colorButton.setOnClickListener(this);
 
    	sortButton=(Button) contentView.findViewById(R.id.cat_sort);  // Sort Button
    	sortButton.setOnClickListener(this);
    	if(nameStr.equals("")){ // 如果传入的tag名称为空,则表明为新建Tag
    		sortButton.setVisibility(View.GONE);
    	}else{
    		sortButton.setVisibility(View.VISIBLE);
    	}
 
		/*
		 * mTrackScroll = (HorizontalScrollView)
		 * contentView.findViewById(R.id.scroll);
		 *
		 * mFooter = contentView.findViewById(R.id.footer); mFooterDisambig =
		 * contentView.findViewById(R.id.footer_disambig); mResolveList =
		 * (ListView) contentView.findViewById(android.R.id.list);
		 * mSetPrimaryCheckBox = (CheckBox)
		 * contentView.findViewById(android.R.id.checkbox);
		 */
 
		setFocusable(true);//是否可以获取焦点
		setTouchable(true);// 是否可以触摸
		setOutsideTouchable(true);
 
	}
 
	private void setContentView(int resId) {
		contentView = mInflater.inflate(resId, null);
		super.setContentView(contentView);
	}
 
	/**
	 * Show the correct call-out arrow based on a {@link R.id} reference.
	 */
	private void showArrow(int whichArrow, int requestedX) {
		final View showArrow = (whichArrow == R.id.arrow_up) ? mArrowUp : mArrowDown;
		final View hideArrow = (whichArrow == R.id.arrow_up) ? mArrowDown : mArrowUp;
 
		// Dirty hack to get width, might cause memory leak
		final int arrowHeight = mContext.getResources().getDrawable(R.drawable.quickaction_arrow_up).getIntrinsicHeight();
 
		showArrow.setVisibility(View.VISIBLE);
		ViewGroup.MarginLayoutParams param = (ViewGroup.MarginLayoutParams) showArrow.getLayoutParams();
		param.topMargin = requestedX - arrowHeight/2; //  设置箭头的 margin_top,它的值为 Button的中心点的y - 箭头高度二分之一
		// Log.d("QuickActionWindow",
		// "ArrowWidth: "+arrowWidth+"; LeftMargin for Arrow: "+param.leftMargin);
 
		hideArrow.setVisibility(View.INVISIBLE);
	}
 
	public boolean onKeyUp(int keyCode, KeyEvent event) {
		if (keyCode == KeyEvent.KEYCODE_BACK) {
			onBackPressed();
			return true;
		}
 
		return false;
	}
 
	private void onBackPressed() {
		dismiss();
	}
 
	public boolean onKeyDown(int keyCode, KeyEvent event) {
		return false;
	}
 
	public boolean onKeyMultiple(int keyCode, int count, KeyEvent event) {
		return false;
	}
 
	public void show() {
		show(mAnchor.centerY());
	}
 
	public void show(int requestedX) {// 传入Button的中心点的y方向坐标
		if(mAnchor == null) {
			return;
		}
		super.showAtLocation(mPView, Gravity.NO_GRAVITY, 0, 0);
 
		// Calculate properly to position the popup the correctly based on
		// height of popup
		if (isShowing()) {
			int x, y, windowAnimations;
			this.getContentView().measure(ViewGroup.LayoutParams.FILL_PARENT, ViewGroup.LayoutParams.FILL_PARENT);// 设置popUp的content的width 和height ?
			final int blockWidth = this.getContentView().getMeasuredWidth();// 取得popUp的width
 
			y = mShadowHoriz+marginTop;// 0
 
			if (mAnchor.left > blockWidth) {//如果当前按钮的上方有足够的空间可以放下PopupWindow时,则将PopUpWindow放在上方。
				// Show downwards callout when enough room, aligning bottom
				// block
				// edge with top of anchor area, and adjusting to inset arrow.
				showArrow(R.id.arrow_down, requestedX-marginTop+mShadowHoriz);
				x = mAnchor.left - blockWidth+nine;
				windowAnimations = R.style.QuickActionRightAnimation;
			} else {
				// Otherwise show upwards callout, aligning block top with
				// bottom of
				// anchor area, and adjusting to inset arrow.
				showArrow(R.id.arrow_up, requestedX-marginTop+mShadowHoriz);//显示箭头的位置
				x = mAnchor.right-nine;
				windowAnimations = R.style.QuickActionLeftAnimation;
			}
 
			setAnimationStyle(windowAnimations);
			Log.i("selector", x+"--"+y);
			this.update(x, y, -1, -1);
		}
	}
 
	@Override
	public boolean onKeyLongPress(int keyCode, KeyEvent event) {
		return false;
	}
 
	public void removeAllItems() {
		mTrack.removeViews(1, mTrack.getChildCount()-2);
	}
 
	@Override
	public void onClick(View v) {
		// TODO Auto-generated method stub
		int view_id = v.getId();
		   switch (view_id) {
				case R.id.cat_save:{
					ContentValues values=new ContentValues();
					values.put(tagsInfo.TAG_NAME,catName.getText().toString());
					values.put(tagsInfo.TAG_COLOUR,colorGiga);
 
					if(nameStr.equals("")){ // 如果传入的title为空,则为新增加Tag
						int orderId=appState.prefsDevice.getPreferenceIntValue(DBAdapter.TAG_COUNT);
						values.put(tagsInfo.TAG_ORDER_INDEX,orderId++);
						appState.db.insertTag(values);
						appState.prefsDevice.setPreferenceFloatValue(DBAdapter.TAG_COUNT, orderId++);
					}else{ // 如果传入的title不为空,则为修改tag
						appState.db.updateTag(values,tag_str);
					}
					Intent publishIntent = new Intent(SipManager.ACTION_GIGATALK_TAG_CHANGED);
					mContext.sendBroadcast(publishIntent);
					this.dismiss();
					break;
				}
				case R.id.cat_cancel:{
					this.dismiss();
					break;
				}
				case R.id.cat_delete:{
					appState.db.deleteTagById(tag_str);
					Intent publishIntent = new Intent(SipManager.ACTION_GIGATALK_TAG_CHANGED);
					mContext.sendBroadcast(publishIntent);
					this.dismiss();
					break;
				}
				case R.id.cat_color:{
					new ColorPickerDialog(mContext,this,Color.RED).show();
					break;
				}
				case R.id.cat_sort:{
					Intent intent=new Intent(mContext,DragDemo.class);
					mContext.startActivity(intent);
					this.dismiss();
					break;
				}
 
			}
	}
	/**
	 * 回调函数，获取选择颜色
	 */
	@Override
	public void colorChanged(int color) {
		// TODO Auto-generated method stub
		colorGiga=color;
	}
}

如上代码关键在于继承了PopupWindow，难点在于确定箭头和PopupWindow的位置，以及PopupWindow的大小和布局。使用方法是实现该类，并传入相应的参数:

1
2
3
4
5
6
7
8
9
10
11

                int[] xy = new int[2];
		v.getLocationInWindow(xy);
		Rect r = new Rect(xy[0], xy[1], xy[0] + v.getWidth(), xy[1] + v.getHeight());
 
		int[] listxy=new int[2];
		searchList.getLocationInWindow(listxy);
		Rect listr = new Rect(listxy[0], listxy[1], listxy[0] + searchList.getWidth(), listxy[1] + searchList.getHeight());
 
		QuickActionWindow quickAction = new QuickActionWindow(v.getContext(),v,title,r,listr);
 
		quickAction.show();

图1：

图2：

图中左侧颜色各异的按钮就是本章要实现的Custom button,下面是实现的部分核心代码:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191

    public class SampleView extends View implements OnLongClickListener,OnTouchListener{
 
    private Drawable mDrawable,mDrawable2;
    private Paint mPaint;
//    private Paint mPaint2;
    private float mPaintTextOffset;
    private PorterDuff.Mode[] mModes;
    private int mModeIndex,intColor;
    private String title;
    OnDialKeyListener onDialKeyListener;
    OnDialTouchListener onDialTouchListener;
    Bitmap bit;
    private int height,width,textSize,alpha;
 
    public SampleView(Activity activity,String t,int c) {
        super(activity);
        Context context = activity;
 
        setFocusable(true);
        setLongClickable(true);
        setPressed(true);
        setClickable(true);
 
        setOnLongClickListener(this);
        setOnTouchListener(this);
 
        title=t;//按钮 标题
        intColor=c;//按钮 颜色
 
        Resources res = SampleView.this.getResources();
        height = res.getDimensionPixelSize(R.dimen.normal_height);
        width = res.getDimensionPixelSize(R.dimen.normal_width);
        textSize = res.getDimensionPixelSize(R.dimen.normal_text_size);
        alpha = res.getDimensionPixelSize(R.dimen.normal_alpha);
 
        mDrawable = context.getResources().getDrawable(R.drawable.hhhhhh);
        mDrawable.setBounds(0,0,width,height);//相当于设置其宽和高
        mDrawable.setDither(true);//抖动   
 
        mDrawable2 = context.getResources().getDrawable(R.drawable.w);
        mDrawable2.setBounds(0,0,width,height);//相当于设置其宽和高
        mDrawable2.setDither(true);//抖动   
 
        /*bit = ((BitmapDrawable)mDrawable).getBitmap();
        bit= BitmapFactory.decodeResource(context.getResources(),
                R.drawable.w);*/
 
        mPaint = new Paint();
        mPaint.setAntiAlias(true);// 消除锯齿
        mPaint.setTextSize(textSize);
        mPaint.setTextAlign(Paint.Align.CENTER);//设置文本居中
 
        /*mPaint2 = new Paint(mPaint);
        mPaint2.setAlpha(alpha);//设置透明度
*/
        Paint.FontMetrics fm = mPaint.getFontMetrics();
        mPaintTextOffset = (fm.descent + fm.ascent) * 0.5f;//中间位置
 
        mModes = new PorterDuff.Mode[] {
//            PorterDuff.Mode.SRC_ATOP,
        	PorterDuff.Mode.DST_ATOP,// 隐藏
//            PorterDuff.Mode.MULTIPLY,
            PorterDuff.Mode.MULTIPLY,//显示凸起
        };//字体显示效果，外凸、下陷等
        mModeIndex = 1;
    }
    public SampleView(Context context, AttributeSet attrs) {
		super(context, attrs);
	}
    /**
	 * Interface definition for a callback to be invoked when a tab is triggered
	 * by moving it beyond a target zone.
	 */
	public interface OnDialKeyListener {
 
		/**
		 * Called when the user make an action
		 * 只是定义了一个方法,具体的实现还要在调用这个方法的地方实现
		 * @param keyCode keyCode pressed
		 * @param dialTone corresponding dialtone
		 */
		void onTrigger(String title,View v);
	}
 
	public interface OnDialTouchListener {
 
		/**
		 * Called when the user make an action
		 * 只是定义了一个方法,具体的实现还要在调用这个方法的地方实现
		 * @param keyCode keyCode pressed
		 * @param dialTone corresponding dialtone
		 */
		void onTouchTrigger(View v);
	}
 
    public void setIndex(int index){
    	mModeIndex=index;
    }
    public void setColor(int c){
    	intColor=c;
    }
    public void setName(String t){
    	title=t;
    	invalidate();
    }
    /*public void setPiantColor(int paintC){
    	paintColor=paintC;
    	Log.i("SampleView","setPiantColor=="+ Integer.toHexString(paintColor));
//    	mPaint2.setColor(paintColor);
    }*/
 
    @Override
    protected void onDraw(Canvas canvas) {
 
        canvas.drawColor(0x00000000);  
 
        ColorFilter filter;
        filter = new PorterDuffColorFilter(intColor,mModes[mModeIndex]);
//        drawSample(canvas,filter);
 
        Rect r = mDrawable.getBounds();//取得图片的(left, top, right bottom)信息.
        float x = (r.left + r.right) * 0.5f;//横向中点
        float y = (r.top + r.bottom) * 0.5f - mPaintTextOffset;    
 
        mDrawable2.draw(canvas);
 
        mDrawable.setColorFilter(filter);
        mDrawable.draw(canvas);
 
//      canvas.drawText(title, x+1, y+1, mPaint2);
        if(mModeIndex==0){
        	mPaint.setColor(0xFF000000);
        }else{
        	mPaint.setColor(0xFFFFFFFF);
        }
        canvas.drawText(title, x, y, mPaint);
    }
    /**
	 * Registers a callback to be invoked when the user triggers an event.
	 *
	 * @param listener
	 *            the OnTriggerListener to attach to this view
	 */
	public void setOnDialKeyListener(OnDialKeyListener listener) {
		onDialKeyListener = listener;
	}
 
	public void setOnDialTouchListener(OnDialTouchListener touchListener) {
		onDialTouchListener = touchListener;
	}
 
    private void dispatchDialKeyEvent(View v) {
		if (onDialKeyListener != null) {
 
			onDialKeyListener.onTrigger(title,v);
 
		}
	}
 
    private void dispatchDialTouchEvent(View v) {
		if (onDialTouchListener != null) {
			onDialTouchListener.onTouchTrigger(v);
		}
	}
 
	@Override
	public boolean onLongClick(View v) {
		// TODO Auto-generated method stub
		dispatchDialKeyEvent(v);
		return true;
	}
 
	@Override
	public boolean onTouch(View v, MotionEvent event) {
		// TODO Auto-generated method stub
 
		 switch (event.getAction()) {
         case MotionEvent.ACTION_DOWN:
             break;
         case MotionEvent.ACTION_MOVE:
             break;
         case MotionEvent.ACTION_UP:
             // update mode every other time we change paint colors
        	 mModeIndex=1;
        	 dispatchDialTouchEvent(v);
             break;
     }
 
		return false;
	}
}

这里创建了一个类继承View，算是完全自定义组件，然后再onDraw方法中将所需要的内容画在Canvas上。有了这个类，只要去实现这个类，并传入相应的参数便可以得到如上效果的Custom Button.

那么我们该如何去使用这个类，并且点击显示相应的效果呢？

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

<pre>private SampleView myView;
	private Map&lt;Integer, SampleView&gt; mView=new HashMap&lt;Integer,SampleView&gt;();
	private Map&lt;Integer, Integer&gt; mColor=new HashMap&lt;Integer,Integer&gt;();
 
//取得所有的分类信息
catCursor=appState.db.getAlltags();
 
linearLayoutForDetail.removeAllViews();
mView.clear();
mColor.clear();
preTag=1;
 
    	for (catCursor.moveToFirst(); !catCursor.isAfterLast(); catCursor.moveToNext()) { //根据数据库中分类的个数信息
 
        	name=catCursor.getString(catCursor.getColumnIndex(tagsInfo.TAG_NAME));
        	tag_id=catCursor.getInt(catCursor.getColumnIndex(tagsInfo.TAG_ID));
        	colorGiga=catCursor.getInt(catCursor.getColumnIndex(tagsInfo.TAG_COLOUR));
 
        	myView=new SampleView(this,name,colorGiga);
        	myView.setTag(tag_id);
 
        	mView.put(tag_id,myView);
            mColor.put(tag_id,colorGiga);
 
            myView.setOnDialKeyListener(this);
            myView.setOnDialTouchListener(this);
 
    		linearLayoutForDetail.addView(myView,lp);
    	}

实现以上代码便得到图1所示的效果，那么我们该如何实现单击变化背景色以及字体颜色呢？

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

         /**
	 * 触摸事件
	 */
	@Override
	public void onTouchTrigger(View v) {
		// TODO Auto-generated method stub
 
		nowView=(SampleView) v;
		nowView.setColor(0x00000000);
		nowView.setIndex(0);
		nowView.postInvalidate();
 
		if(!v.getTag().equals(preTag)){ //如果当前SampleView和之前点击的不一样,则将之前的SampleView颜色还原
			preView=mView.get(preTag);
			preView.setColor(mColor.get(preTag));
			preView.setIndex(1);
			preView.postInvalidate();
		}
 
		preTag=new Integer(v.getTag().toString());
 
		updateList(preTag);
	}

1

       emulator -memory 512 -partition-size 512 -avd gigabud

注释：1：-memroy 512          设置ram为 512 M
2：-partition-size 512  设置rom为512 M
3：-avd gigabud    加载指定的虚拟设备，其中的handroid2.3就是虚拟设备的名字

ROM、RAM的大小要根据PC的内存大小和实际需要进行配置，过大有可能提示内存不足。

webview的有关知识：

1、添加权限：AndroidManifest.xml中必须使用许可”android.permission.INTERNET”,否则会出Web page not available错误。
2、在要Activity中生成一个WebView组件：WebView webView = new WebView(this);

3、设置WebView基本信息：
如果访问的页面中有Javascript，则webview必须设置支持Javascript。
webview.getSettings().setJavaScriptEnabled(true);
触摸焦点起作用
requestFocus();//如果不设置，则在点击网页文本输入框时，不能弹出软键盘及不响应其他的一些事件。
取消滚动条
this.setScrollBarStyle(SCROLLBARS_OUTSIDE_OVERLAY);

4、设置WevView要显示的网页：
互联网用：webView.loadUrl(“http://www.google.com”);
本地文件用：webView.loadUrl(“file:///android_asset/XX.html”);  本地文件存放在：assets文件中

5、如果希望点击链接由自己处理，而不是新开Android的系统browser中响应该链接。

给WebView添加一个事件监听对象（WebViewClient)，并重写其中的一些方法shouldOverrideUrlLoading：对网页中超链接按钮的响应。当按下某个连接时WebViewClient会调用这个方法，并传递参数：按下的url

onLoadResource
onPageStart
onPageFinish
onReceiveError
onReceivedHttpAuthRequest
6、如果用webview点链接看了很多页以后，如果不做任何处理，点击系统“Back”键，整个浏览器会调用finish()而结束自身，如果希望浏览的网页回退而不是退出浏览器，需要在当前Activity中处理并消费掉该Back事件。

覆盖Activity类的onKeyDown(int keyCoder,KeyEvent event)方法。

1
2
3
4
5
6
7

   public boolean onKeyDown(int keyCoder,KeyEvent event){
                        if(webView.canGoBack() && keyCoder == KeyEvent.KEYCODE_BACK){
                              webview.goBack();   //goBack()表示返回webView的上一页面
                                 return true;
                           }
                        return false;
                   }

Android的webView很强大，其实就是一个浏览器，你可以把它嵌入到你想要的位置，我这里遇到两个问题，就是怎么知道网页的加载进度和加载网页时，点击网页里面的链接还是在当前的webview里跳转，不想跳到浏览器那边，解决办法如下：

1
2
3
4
5
6
7
8
9
10
11
12

//此方法可以处理webview 在加载时和加载完成时一些操作
webView.setWebChromeClient(new WebChromeClient（）{
  @Override
  public void onProgressChanged(WebView view, int newProgress) {
    if(newProgress==100){                        // 这里是设置activity的标题， 也可以根据自己的需求做一些其他的操作
          title.setText("加载完成")；
     }else{
     title.setText("加载中.......");
 
      }
    }
});

1
2
3
4
5
6

   webView.setWebViewClient(new WebViewClient（）{
  @Override
    public boolean shouldOverrideUrlLoading(WebView view, String url) {  //重写此方法表明点击网页里面的链接还是在当前的webview里跳转，不跳到浏览器那边
       view.loadUrl(url);
       return true;
  }

[/codesyntax]

[codesyntax lang="java" container="pre_valid" strict="yes"]

@Override
public void onReceivedSslError(WebView view, SslErrorHandler handler, android.net.http.SslError error) { // 重写此方法可以让webview处理https请求
handler.proceed();
}

});

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

在当前Activity中打开网页：
Intent it = new Intent(Intent.ACTION_VIEW);
			it.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
			it.setData(Uri.parse("http://code.google.com/p/csipsimple/issues"));
			startActivity(it);
用webview打开网页
WebView webView = (WebView) findViewById(R.id.webview);
	    webView.getSettings().setJavaScriptEnabled(true);
	    webView.setWebViewClient(new FaqWebViewClient());
	    webView.loadUrl(“"http://code.google.com/p/csipsimple/wiki/FAQ#Summary"”);
private class FaqWebViewClient extends WebViewClient {
		@Override
		public void onPageFinished(WebView view, String url) {
			super.onPageFinished(view, url);
			LinearLayout indicator = (LinearLayout) findViewById(R.id.loading_indicator);
			indicator.setVisibility(View.GONE);
		}
	}

Chronometer 用于倒计时

1
2
3

LayoutAnimationController controller = new LayoutAnimationController(set, 0.5f);
        ListView listView = getListView();
        listView.setLayoutAnimation(controller);

将activity显示为dialog形式:

1
2
3
4
5
6
7

    <activity android:name="com.csipsimple.ui.prefs.PrefsFast" android:label="@string/prefs_fast"
			android:theme="@style/CupcakeDialog" android:configChanges="orientation">
			<intent-filter>
				<action android:name="com.csipsimple.ui.prefs.PrefsFast" />
                 <category android:name="android.intent.category.DEFAULT" />
			</intent-filter>
		</activity>

设置Activity Title:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

     Window w = getWindow();
		w.requestFeature(Window.FEATURE_LEFT_ICON);
		super.onCreate(savedInstanceState);
		setContentView(R.layout.accounts_list);
		w.setFeatureDrawableResource(Window.FEATURE_LEFT_ICON, R.drawable.ic_list_accounts);
 
      // Custom title listing the account name for filters
        final boolean customTitleOk = requestWindowFeature(Window.FEATURE_CUSTOM_TITLE);
		setContentView(R.layout.filters_list);
		if(customTitleOk) {
		    getWindow().setFeatureInt(Window.FEATURE_CUSTOM_TITLE, R.layout.account_filters_title);
		    final TextView titleText = (TextView) findViewById(R.id.account_filters_title);
		    if (titleText != null) {
		        SipProfile acct = database.getAccount(accountId);
		        titleText.setText(R.string.filters_for);
		        titleText.append(" " + acct.display_name);
		    }
		}

ExpendListView 展开某些子view:

1
2

getExpandableListView().expandGroup(0);
getExpandableListView().expandGroup(1);

然而内存的消耗甚至泄露是不可避免的，那么首先只有养成良好的编程习惯，尽量做到减少内存的使用，尽可能的使垃圾内存得到回收，这才是解决问题的根本途径，那么我们该怎样编写代码呢？以下是本人的一些拙见以及网上达人们得一点点小小的建议：

(一) 查询数据库没有关闭游标

程序中经常会进行查询数据库的操作，但是经常会有使用完毕Cursor后没有关闭的情况。如果我们的查询结果集比较小，对内存的消耗不容易被发现，只有在常时间大量操作的情况下才会复现内存问题，这样就会给以后的测试和问题排查带来困难和风险。我觉得可以这样做：

Cursor c = sqliteDb.query(TABLE_WORDS, word_full_projection,selection, null, null, null, null);
int numRows = c.getCount();
if(numRows > 0){
c.moveToFirst();
wordProfile account = new wordProfile();
account.createFromDb(c);
c.close();
return account;
}
c.close();

可以采取将cursor里的值赋值给实现Parcelable的类的成员变量，在所需要的地方相应取值便是，这样编可以做到及时关闭游标，释放资源。

(二) 构造Adapter时，没有使用缓存的 convertView

以构造ListView的BaseAdapter为例，在BaseAdapter中提高了方法：

public View getView(int position, View convertView, ViewGroup parent)

来向ListView提供每一个item所需要的view对象。初始时ListView会从BaseAdapter中根据当前的屏幕布局实例化一定数量的view对象，同时ListView会将这些view对象缓存起来。当向上滚动ListView时，原先位于最上面的list item的view对象会被回收，然后被用来构造新出现的最下面的list item。这个构造过程就是由getView()方法完成的，getView()的第二个形参 View convertView就是被缓存起来的list item的view对象(初始化时缓存中没有view对象则convertView是null)。

由此可以看出，如果我们不去使用convertView，而是每次都在getView()中重新实例化一个View对象的话，即浪费资源也浪费时间，也会使得内存占用越来越大。ListView回收list item的view对象的过程可以查看:

android.widget.AbsListView.java –> void addScrapView(View scrap) 方法。

(三) Bitmap对象不在使用时调用recycle()释放内存

有时我们会手工的操作Bitmap对象，如果一个Bitmap对象比较占内存，当它不在被使用的时候，可以调用Bitmap.recycle()方法回收此对象的像素所占用的内存，但这不是必须的，视情况而定。

(四) 将变量的作用域设置为最小

最小化作用域意味着对垃圾收集器更快的可见。让我们举一个例子。我们有一个变量定义在方法级,当方法执行完毕后,也就是说,控制跳出方法后,则该变量将不会被引用。这也就意味着它已经可以被垃圾回收。但是如果该变量是类级的,这时垃圾回收器就需要等待直到对该类的所有的引用都被
移除后才能进行垃圾回收。优化属性的作用域是必须的。同样这也是封装原则。最小化作用域降低了通过包访问变量并减少了耦合。

(五) 仅当你确实需要时才初始化

这个的意思是在你确实需要使用对象之前才分配内存。有些时候,需要在方法的开头定义一些属性。当定义这些属性时,我们很可能在定义它们的时候对其进行初始化。 这种情况下,    如果在首次使用之前出现任何问题    (如出现异常),那么已经初始化的变量所占用的内存就被浪费了。

(六) 不要在循环中定义变量

这是大部分内存溢出的程序中的另一个常见的错误。在循环中定义和初始化变量,对于循环的每次执行,该变量实例将在内存中创建并分配内存。在循环启动后,第一个对象已经可以回收了。这种额外的内存分配也会增加垃圾回收器的负担。看一下下面的代码片段你将很容易的找出问题所在。有些时候,
确实有必要在循环内定义变量,不过一定要小心使用。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

import java.util.Vector;
public class DeclareInLoopExample {
        public void getDataIncorrect() throws Exception {
       Vector<string> data = new Vector<string>(11);
for (String str : data) {
String newStr = "";
// ...Some string operations
newStr = newStr + "X" + "X";
}
}
public void getDataCorrect() throws Exception {
Vector<string> data = new Vector<string>(11);
String newStr = "";
for (String str : data) {
// ...Some string operations
newStr = newStr + "X" + "X";
}
}
}

(七) 不要在循环中定义变量

这是和 String 相关的一些东西,所有对 String 进行的操作都将产生另一个 String 对象。通常我们使用的 String 链接操作,这个需要注意,它会导致一个很长的动态的查询或产生一个 toString 方法中的 String。如果我们使用+操作符来连接字符串,这些额外的对象将根据+产生。当有过多操作的时候会变成很大的开销。使用不是不变对象,如 StringBuffer 来进行字符串链接操作。

(八) 不要在循环中定义变量

这会使得垃圾回收器的工作变得比较容易。 将重对象的引用设置为 null。这将释放对中对象的引用,使得垃圾回收器能立即释放它们占用的内存。

(九) 简单的使用 finally 块

finally 块即使 try 或 catch 执行不成功的时候也会执行,也就是说即使在 try 或 catch 中出现了任何异常,finally 块中的语句绝对也会执行。将清理内存的语句放在这里以保证内存被清理。

(十) 分散对象创建或删除的时间
集中在短时间内大量创建新对象,特别是大对象,会导致突然需要大量内存,JVM在面临这种情况时,只能进行主GC,以回收内存或整合内存碎片,从而增 加主GC的频率。集中删除对象,道理也是一样的。它使得突然出现了大量的垃圾对象,空闲空间必然减少,从而大大增加了下一次创建新对象时强制主GC的机 会。

其他参考资料：http://www.chinaup.org/docs/toolbox/performance.html

按照以上的编程方法去写代码也许可以使你减少内存的消耗，防止内存泄露。然而当内存被慢慢的耗尽甚至出现内存泄露后，我们该怎么办呢？下面的论述也许对你定位内存泄露的原因以及找出正确的解决办法会有所帮助：

在介绍内存查看、分析工具之前，我想有必要先介绍一下相关的概念。

为何会内存溢出

我们知道JVM根据generation(代)来进行GC，根据下图所示，一共被分为young generation(年轻代)、tenured generation(老年代)、permanent generation(永久代, perm gen)，perm gen（或称Non-Heap 非堆）是个异类，稍后会讲到。注意，heap空间不包括perm gen。

绝大多数的对象都在young generation被分配，也在young generation被收回，当young generation的空间被填满，GC会进行minor collection(次回收)，这次回收不涉及到heap中的其他generation，minor collection根据weak generational hypothesis(弱年代假设)来假设young generation中大量的对象都是垃圾需要回收，minor collection的过程会非常快。young generation中未被回收的对象被转移到tenured generation，然而tenured generation也会被填满，最终触发major collection(主回收)，这次回收针对整个heap，由于涉及到大量对象，所以比minor collection慢得多。

JVM有三种垃圾回收器，分别是throughput collector，用来做并行young generation回收，由参数-XX:+UseParallelGC启动；concurrent low pause collector，用来做tenured generation并发回收，由参数-XX:+UseConcMarkSweepGC启动；incremental low pause collector，可以认为是默认的垃圾回收器。不建议直接使用某种垃圾回收器，最好让JVM自己决断，除非自己有足够的把握。

Heap中各generation空间是如何划分的？通过JVM的-Xmx=n参数可指定最大heap空间，而-Xms=n则是指定最小heap空间。在JVM初始化的时候，如果最小heap空间小于最大heap空间的话，如上图所示JVM会把未用到的空间标注为Virtual。除了这两个参数还有-XX:MinHeapFreeRatio=n和 -XX:MaxHeapFreeRatio=n来分别控制最大、最小的剩余空间与活动对象之比例。在32位Solaris SPARC操作系统下，默认值如下，在32位windows xp下，默认值也差不多。

由于tenured generation的major collection较慢，所以tenured generation空间小于young generation的话，会造成频繁的major collection，影响效率。Server JVM默认的young generation和tenured generation空间比例为1:2，也就是说young generation的eden和survivor空间之和是整个heap（当然不包括perm gen）的三分之一，该比例可以通过-XX:NewRatio=n参数来控制，而Client JVM默认的-XX:NewRatio是8。至于调整young generation空间大小的NewSize=n和MaxNewSize=n参数就不讲了，请参考后面的资料。

young generation中幸存的对象被转移到tenured generation，但不幸的是concurrent collector线程在这里进行major collection，而在回收任务结束前空间被耗尽了，这时将会发生Full Collections(Full GC)，整个应用程序都会停止下来直到回收完成。Full GC是高负载生产环境的噩梦……

现在来说说异类perm gen，它是JVM用来存储无法在Java语言级描述的对象，这些对象分别是类和方法数据（与class loader有关）以及interned strings(字符串驻留)。一般32位OS下perm gen默认64m，可通过参数-XX:MaxPermSize=n指定，JVM Memory Structure一文说，对于这块区域，没有更详细的文献了，神秘。

难么为神秘会内存泄露呢？要回答这个问题又要引出另外一个话题，既什么样的对象GC才会回收？当然是GC发现通过任何reference chain(引用链)无法访问某个对象的时候，该对象即被回收。名词GC Roots正是分析这一过程的起点，例如JVM自己确保了对象的可到达性(那么JVM就是GC Roots)，所以GC Roots就是这样在内存中保持对象可到达性的，一旦不可到达，即被回收。通常GC Roots是一个在current thread(当前线程)的call stack(调用栈)上的对象（例如方法参数和局部变量），或者是线程自身或者是system class loader(系统类加载器)加载的类以及native code(本地代码)保留的活动对象。所以GC Roots是分析对象为何还存活于内存中的利器。知道了什么样的对象GC才会回收后，再来学习下对象引用都包含哪些吧。

从最强到最弱，不同的引用（可到达性）级别反映了对象的生命周期。

1. Strong Ref(强引用)：通常我们编写的代码都是Strong Ref，于此对应的是强可达性，只有去掉强可达，对象才被回收。

2.Soft Ref(软引用)：对应软可达性，只要有足够的内存，就一直保持对象，直到发现内存吃紧且没有Strong Ref时才回收对象。一般可用来实现缓存，通过java.lang.ref.SoftReference类实现。

3.Weak Ref(弱引用)：比Soft Ref更弱，当发现不存在Strong Ref时，立刻回收对象而不必等到内存吃紧的时候。通过java.lang.ref.WeakReference和java.util.WeakHashMap类实现。

4.Phantom Ref(虚引用)：根本不会在内存中保持任何对象，你只能使用Phantom Ref本身。一般用于在进入finalize()方法后进行特殊的清理过程，通过java.lang.ref.PhantomReference实现。

有了上面的种种我相信很容易就能把heap和perm gen撑破了吧，是的利用Strong Ref，存储大量数据，直到heap撑破；利用interned strings（或者class loader加载大量的类）把perm gen撑破。

关于shallow size、retained size

Shallow size就是对象本身占用内存的大小，不包含对其他对象的引用，也就是对象头加成员变量（不是成员变量的值）的总和。在32位系统上，对象头占用8字节，int占用4字节，不管成员变量（对象或数组）是否引用了其他对象（实例）或者赋值为null它始终占用4字节。故此，对于String对象实例来说，它有三个int成员（3*4=12字节）、一个char[]成员（1*4=4字节）以及一个对象头（8字节），总共3*4 +1*4+8=24字节。根据这一原则，对String a=”rosen jiang”来说，实例a的shallow size也是24字节。

Retained size是该对象自己的shallow size，加上从该对象能直接或间接访问到对象的shallow size之和。换句话说，retained size是该对象被GC之后所能回收到内存的总和。为了更好的理解retained size，不妨看个例子。

把内存中的对象看成下图中的节点，并且对象和对象之间互相引用。这里有一个特殊的节点GC Roots，正解！这就是reference chain的起点。

从obj1入手，上图中蓝色节点代表仅仅只有通过obj1才能直接或间接访问的对象。因为可以通过GC Roots访问，所以左图的obj3不是蓝色节点；而在右图却是蓝色，因为它已经被包含在retained集合内。

所以对于左图，obj1的retained size是obj1、obj2、obj4的shallow size总和；右图的retained size是obj1、obj2、obj3、obj4的shallow size总和。obj2的retained size可以通过相同的方式计算。

Heap Dump

heap dump是特定时间点，java进程的内存快照。有不同的格式来存储这些数据，总的来说包含了快照被触发时java对象和类在heap中的情况。由于快照只是一瞬间的事情，所以heap dump中无法包含一个对象在何时、何地（哪个方法中）被分配这样的信息。

在不同平台和不同java版本有不同的方式获取heap dump，而MAT需要的是HPROF格式的heap dump二进制文件。想无需人工干预的话，要这样配置JVM参数：-XX:-HeapDumpOnOutOfMemoryError，当错误发生时，会自动生成heap dump，在生产环境中，只有用这种方式。如果你想自己控制什么时候生成heap dump，在Windows+JDK6环境中可利用JConsole工具，而在Linux或者Mac OS X环境下均可使用JDK5、6自带的jmap工具。当然，还可以配置JVM参数：-XX:+HeapDumpOnCtrlBreak，也就是在控制台使用Ctrl+Break键来生成heap dump。由于我是windows+JDK5，所以选择了-XX:-HeapDumpOnOutOfMemoryError这种方式，更多配置请参考MAT Wiki。

那么下面让我们一起来看看内存泄露调试：

一开始不得不说说ClassLoader，本质上，它的工作就是把磁盘上的类文件读入内存，然后调用java.lang.ClassLoader.defineClass方法告诉系统把内存镜像处理成合法的字节码。Java提供了抽象类ClassLoader，所有用户自定义类装载器都实例化自ClassLoader的子类。system class loader在没有指定装载器的情况下默认装载用户类，在Sun Java 1.5中既sun.misc.Launcher$AppClassLoader。更详细的内容请参看下面的资料。

（一）内存监测工具 DDMS –> Heap

无论怎么小心，想完全避免bad code是不可能的，此时就需要一些工具来帮助我们检查代码中是否存在会造成内存泄漏的地方。Android tools中的DDMS就带有一个很不错的内存监测工具Heap(这里我使用eclipse的ADT插件，并以真机为例，在模拟器中的情况类似)。用Heap监测应用进程使用内存情况的步骤如下：

1. 启动eclipse后，切换到DDMS透视图，并确认Devices视图、Heap视图都是打开的；

2. 将手机通过USB链接至电脑，链接时需要确认手机是处于“USB调试”模式，而不是作为“Mass Storage”；

3. 链接成功后，在DDMS的Devices视图中将会显示手机设备的序列号，以及设备中正在运行的部分进程信息；

4. 点击选中想要监测的进程，比如system_process进程；

5. 点击选中Devices视图界面中最上方一排图标中的“Update Heap”图标；

6. 点击Heap视图中的“Cause GC”按钮；

7. 此时在Heap视图中就会看到当前选中的进程的内存使用量的详细情况［如图所示］。

说明：

a) 点击“Cause GC”按钮相当于向虚拟机请求了一次gc操作；

b) 当内存使用信息第一次显示以后，无须再不断的点击“Cause GC”，Heap视图界面会定时刷新，在对应用的不断的操作过程中就可以看到内存使用的变化；

c) 内存使用信息的各项参数根据名称即可知道其意思，在此不再赘述。

如何才能知道我们的程序是否有内存泄漏的可能性呢。这里需要注意一个值：Heap视图中部有一个Type叫做data object，即数据对象，也就是我们的程序中大量存在的类类型的对象。在data object一行中有一列是“Total Size”，其值就是当前进程中所有Java数据对象的内存总量，一般情况下，这个值的大小决定了是否会有内存泄漏。可以这样判断：

a) 不断的操作当前应用，同时注意观察data object的Total Size值；

b) 正常情况下Total Size值都会稳定在一个有限的范围内，也就是说由于程序中的的代码良好，没有造成对象不被垃圾回收的情况，所以说虽然我们不断的操作会不断的生成很多对象，而在虚拟机不断的进行GC的过程中，这些对象都被回收了，内存占用量会会落到一个稳定的水平；

c) 反之如果代码中存在没有释放对象引用的情况，则data object的Total Size值在每次GC后不会有明显的回落，随着操作次数的增多Total Size的值会越来越大，

直到到达一个上限后导致进程被kill掉。

总之，使用DDMS的Heap视图工具可以很方便的确认我们的程序是否存在内存泄漏的可能性。

（二）内存分析工具 MAT(Memory Analyzer Tool)

如果使用DDMS确实发现了我们的程序中存在内存泄漏，那又如何定位到具体出现问题的代码片段，最终找到问题所在呢？如果从头到尾的分析代码逻辑，那肯定会把人逼疯，特别是在维护别人写的代码的时候。这里介绍一个极好的内存分析工具 – Memory Analyzer Tool(MAT)。

MAT是一个Eclipse插件，同时也有单独的RCP客户端。官方下载地址、MAT介绍和详细的使用教程请参见：www.eclipse.org/mat，在此不进行说明了。另外在MAT安装后的帮助文档里也有完备的使用教程。在此仅举例说明其使用方法。我自己使用的是MAT的eclipse插件，使用插件要比RCP稍微方便一些。

使用MAT进行内存分析需要几个步骤，包括：生成.hprof文件、打开MAT并导入.hprof文件、使用MAT的视图工具分析内存。以下详细介绍。

我们先来看一个例子：

<pre class="brush:[java]">

</pre>

<pre class="brush:[java]">

</pre>

接下来是MAT使用方法介绍：

(一) 生成.hprof文件

生成.hprof文件的方法有很多，而且Android的不同版本中生成.hprof的方式也稍有差别，我使用的版本的是2.1，各个版本中生成.prof文件的方法请参考http://android.git.kernel.org/?p=platform/dalvik.git;a=blob_plain;f=docs/heap-profiling.html;hb=HEAD

1. 打开eclipse并切换到DDMS透视图，同时确认Devices、Heap和logcat视图已经打开了；

2. 将手机设备链接到电脑，并确保使用“USB 调试”模式链接，而不是“Mass Storage“模式；

3. 链接成功后在Devices视图中就会看到设备的序列号，和设备中正在运行的部分进程；

4. 点击选中想要分析的应用的进程，在Devices视图上方的一行图标按钮中，同时选中“Update Heap”和“Dump HPROF file”两个按钮；

5. 这是DDMS工具将会自动生成当前选中进程的.hprof文件，并将其进行转换后存放在sdcard当中，如果你已经安装了MAT插件，那么此时MAT将会自动被启用，并开始对.hprof文件进行分析；

注意：第4步和第5步能够正常使用前提是我们需要有sdcard，并且当前进程有向sdcard中写入的权限(WRITE_EXTERNAL_STORAGE)，否则.hprof文件不会被生成，在logcat中会显示诸如

ERROR/dalvikvm(8574): hprof: can’t open /sdcard/com.xxx.hprof-hptemp: Permission denied.

的信息。

如果我们没有sdcard，或者当前进程没有向sdcard写入的权限（如system_process），那我们可以这样做：

6. 在当前程序中，例如framework中某些代码中，可以使用android.os.Debug中的：

public static void dumpHprofData(String fileName) throws IOException

方法，手动的指定.hprof文件的生成位置。例如：

xxxButton.setOnClickListener(new View.OnClickListener() {

public void onClick(View view) {

android.os.Debug.dumpHprofData(“/data/temp/myapp.hprof”);

… …

}

}

上述代码意图是希望在xxxButton被点击的时候开始抓取内存使用信息，并保存在我们指定的位置：/data/temp/myapp.hprof，这样就没有权限的限制了，而且也无须用sdcard。但要保证/data/temp目录是存在的。这个路径可以自己定义，当然也可以写成sdcard当中的某个路径。

(二) 使用MAT导入.hprof文件

1. 如果是eclipse自动生成的.hprof文件，可以使用MAT插件直接打开（可能是比较新的ADT才支持）；

2. 如果eclipse自动生成的.hprof文件不能被MAT直接打开，或者是使用android.os.Debug.dumpHprofData()方法手动生成的.hprof文件，则需要将.hprof文件进行转换，转换的方法：

例如我将.hprof文件拷贝到PC上的/ANDROID_SDK/tools目录下，并输入命令hprof-conv xxx.hprof yyy.hprof，其中xxx.hprof为原始文件，yyy.hprof为转换过后的文件。转换过后的文件自动放在/ANDROID_SDK/tools目录下。OK，到此为止，.hprof文件处理完毕，可以用来分析内存泄露情况了。

3. 在Eclipse中点击Windows->Open Perspective->Other->Memory Analyzer，或者打Memory Analyzer Tool的RCP。在MAT中点击File->Open File，浏览并导入刚刚转换而得到的.hprof文件。

(三) 使用MAT的视图工具分析内存

MAT工具分析了heap dump后在界面上非常直观的展示了一个饼图，该图深色区域被怀疑有内存泄漏，可以发现整个heap才64M内存，深色区域就占了99.5%。接下来是一个简短的描述，告诉我们main线程占用了大量内存，并且明确指出system class loader加载的”java.lang.Thread”实例有内存聚集，并建议用关键字”java.lang.Thread”进行检查。所以，MAT通过简单的两句话就说明了问题所在，就算使用者没什么处理内存问题的经验。在下面还有一个”Details”链接，在点开之前不妨考虑一个问题：为何对象实例会聚集在内存中，为何存活（而未被GC）？是的——Strong Ref，那么再走近一些吧。

点击了”Details”链接之后，除了在上一页看到的描述外，还有Shortest Paths To the Accumulation Point和Accumulated Objects部分，这里说明了从GC root到聚集点的最短路径，以及完整的reference chain。观察Accumulated Objects部分，java.util.HashMap和java.lang.Object[1000000]实例的retained heap(size)最大，在上一篇文章中我们知道retained heap代表从该类实例沿着reference chain往下所能收集到的其他类实例的shallow heap(size)总和，所以明显类实例都聚集在HashMap和Object数组中了。这里我们发现一个有趣的现象，既Object数组的shallow heap和retained heap竟然一样，通过Shallow and retained sizes一文可知，数组的shallow heap和一般对象（非数组）不同，依赖于数组的长度和里面的元素的类型，对数组求shallow heap，也就是求数组集合内所有对象的shallow heap之和。好，再来看org.rosenjiang.bo.ithouge对象实例的shallow heap为何是16，因为对象头是8字节，成员变量int是4字节、String引用是4字节，故总共16字节。

接着往下看，来到了Accumulated Objects by Class区域，顾名思义，这里能找到被聚集的对象实例的类名。org.rosenjiang.bo.ithouge类上头条了，被实例化了290,325次，再返回去看程序，我承认是故意这么干的。还有很多有用的报告可用来协助分析问题，只是本文中的例子太简单，也用不上。以后如有用到，一定撰文详细叙述。

又是perm gen

我们在上一篇文章中知道，perm gen是个异类，里面存储了类和方法数据（与class loader有关）以及interned strings（字符串驻留）。在heap dump中没有包含太多的perm gen信息。那么我们就用这些少量的信息来解决问题吧。

看下面的代码，利用interned strings把perm gen撑破了。

<pre class="brush:[java]">

</pre>

控制台打印如下的信息，然后把java_pid1824.hprof文件导入到MAT。其实在MAT里，看到的状况应该和“OutOfMemoryError: Java heap space”差不多（用了数组），因为heap dump并没有包含interned strings方面的任何信息。只是在这里需要强调，使用intern()方法的时候应该多加注意。

java.lang.OutOfMemoryError: PermGen space
Dumping heap to java_pid1824.hprof 
Heap dump file created [121273334 bytes in 2.845 secs]
Exception in thread ”main” java.lang.OutOfMemoryError: PermGen space

倒是在思考如何把class loader撑破废了些心思。经过尝试，发现使用ASM来动态生成类才能达到目的。ASM(http://asm.objectweb.org)的主要作用是处理已编译类(compiled class)，能对已编译类进行生成、转换、分析（功能之一是实现动态代理），而且它运行起来足够的快和小巧，文档也全面，实属居家必备之良品。ASM提供了core API和tree API，前者是基于事件的方式，后者是基于对象的方式，类似于XML的SAX、DOM解析，但是使用tree API性能会有损失。既然下面要用到ASM，这里不得不啰嗦下已编译类的结构，包括：

1、修饰符（例如public、private）、类名、父类名、接口和annotation部分。

2、类成员变量声明，包括每个成员的修饰符、名字、类型和annotation。

3、方法和构造函数描述，包括修饰符、名字、返回和传入参数类型，以及annotation。当然还包括这些方法或构造函数的具体Java字节码。

4、常量池(constant pool)部分，constant pool是一个包含类中出现的数字、字符串、类型常量的数组。

已编译类和原来的类源码区别在于，已编译类只包含类本身，内部类不会在已编译类中出现，而是生成另外一个已编译类文件；其二，已编译类中没有注释；其三，已编译类没有package和import部分。

这里还得说说已编译类对Java类型的描述，对于原始类型由单个大写字母表示，Z代表boolean、C代表char、B代表byte、S代表short、I代表int、F代表float、J代表long、D代表double；而对类类型的描述使用内部名(internal name)外加前缀L和后面的分号共同表示来表示，所谓内部名就是带全包路径的表示法，例如String的内部名是java/lang/String；对于数组类型，使用单方括号加上数据元素类型的方式描述。最后对于方法的描述，用圆括号来表示，如果返回是void用V表示，具体参考下图。

下面的代码中会使用ASM core API，注意接口ClassVisitor是核心，FieldVisitor、MethodVisitor都是辅助接口。ClassVisitor应该按照这样的方式来调用：visit visitSource? visitOuterClass? ( visitAnnotation | visitAttribute )*( visitInnerClass | visitField | visitMethod )* visitEnd。就是说visit方法必须首先调用，再调用最多一次的visitSource，再调用最多一次的visitOuterClass方法，接下来再多次调用visitAnnotation和visitAttribute方法，最后是多次调用visitInnerClass、visitField和visitMethod方法。调用完后再调用visitEnd方法作为结尾。

注意ClassWriter类，该类实现了ClassVisitor接口，通过toByteArray方法可以把已编译类直接构建成二进制形式。由于我们要动态生成子类，所以这里只对ClassWriter感兴趣。首先是抽象类原型：

<pre class="brush:[java]">

</pre>

其次是自定义类加载器，实在没法，ClassLoader的defineClass方法都是protected的，要加载字节数组形式（因为toByteArray了）的类只有继承一下自己再实现。

<pre class="brush:[java]">

</pre>

最后是测试类。

<pre class="brush:[java]">

</pre>

不一会儿，控制台就报错了。

java.lang.OutOfMemoryError: PermGen space
Dumping heap to java_pid3023.hprof 
Heap dump file created [92593641 bytes in 2.405 secs]
Exception in thread ”main” java.lang.OutOfMemoryError: PermGen space

打开java_pid3023.hprof文件，注意看下图的Classes: 88.1k和Class Loader: 87.7k部分，从这点可看出class loader加载了大量的类。

更进一步分析，点击上图中红框线圈起来的按钮，选择Java Basics——Class Loader Explorer功能。打开后能看到下图所示的界面，第一列是class loader名字；第二列是class loader已定义类(defined classes)的个数，这里要说一下已定义类和已加载类(loaded classes)了，当需要加载类的时候，相应的class loader会首先把请求委派给父class loader，只有当父class loader加载失败后，该class loader才会自己定义并加载类，这就是Java自己的“双亲委派加载链”结构；第三列是class loader所加载的类的实例数目。

在Class Loader Explorer这里，能发现class loader是否加载了过多的类。另外，还有Duplicate Classes功能，也能协助分析重复加载的类，在此就不再截图了，可以肯定的是MyAbsClass被重复加载了N多次。

最后

其实MAT工具非常的强大，上面故弄玄虚的范例代码根本用不上MAT的其他分析功能，所以就不再描述了。其实对于OOM不只我列举的两种溢出错误，还有多种其他错误，但我想说的是，对于perm gen，如果实在找不出问题所在，建议使用JVM的-verbose参数，该参数会在后台打印出日志，可以用来查看哪个class loader加载了什么类，例：“[Loaded org.rosenjiang.test.MyAbsClass from org.rosenjiang.test.MyClassLoader]”。

参考资料：

[Android] 内存泄漏调试经验分享 (一)

[Android] 内存泄漏调试经验分享 (二)

使用Memory Analyzer tool(MAT)分析内存泄漏（一）

使用Memory Analyzer tool(MAT)分析内存泄漏（二）