侯剑凯的博客[ithouge]

Ubuntu wireshark install

ithouge — Thu, 12 Apr 2012 02:42:41 +0000

Wireshark是世界上最流行的网络分析工具。这个强大的工具可以捕捉网络中的数据，并为用户提供关于网络和上层协议的各种信息。
与很多其他网络工具一样，Wireshark也使用pcap network library来进行封包捕捉。

Wireshark的优势：

- 安装方便。

- 简单易用的界面。

- 提供丰富的功能。

Wireshark的原名是Ethereal，新名字是2006年起用的。当时Ethereal的主要开发者决定离开他原来供职的公司，并继续开发这个软件。但由于Ethereal这个名称的使用权已经被原来那个公司注册，Wireshark这个新名字也就应运而生了。

系统要求：

libpcap库对于Ethereal和Wireshark都非常重要，它们需要使用这个库的功能进行封包捕捉工作。
如果您的系统中没有安装libpcap或者其它必要的组件,

#apt-get install libgtk2.0-dev libglib2.0-dev

#apt-get install checkinstall

安装完这个还会报一个libpcap的错，libpcap的安装方法如下：

下载libpcap的源码包

解压之后依次执行：

./configure
make
make install

安装完成之后：

下载Wireshark的源码包

下载完成之后依次执行：

#./configure

编译和安装：

#make

#make install
#checkinstall

运行Wireshark：
#wireshark

Android source code

ithouge — Sat, 07 Apr 2012 09:49:33 +0000

Android最好、最权威的东西自然是在源码里，以下文章零起点逐步揭露android的神秘面纱。

准备篇：

设置Linux的编译环境：

In general you will need:

Python 2.5 — 2.7, which you can download from python.org.
GNU Make 3.81 — 3.82, which you can download from gnu.org,
JDK 6 if you wish to build Gingerbread or newer; JDK 5 for Froyo or older. You can download both from java.sun.com.
Git 1.7 or newer. You can find it at git-scm.com.

Detailed instructions for Ubuntu 10.04+ follow.

这里建议搭建一套Android开发环境，具体参考文章：Android开发环境搭建

当然也可以选择性的安装。

Installing required packages (Ubuntu 10.04 — 11.10)

Ubuntu 10.04 64-bit is recommended. Building using a newer version of Ubuntu or a 32-bit Ubuntu is currently only experimentally supported and is not guaranteed to work on branches other than master.

64-bit (recommended)

$ sudo apt-get install git-core gnupg flex bison gperf build-essential \
  zip curl zlib1g-dev libc6-dev lib32ncurses5-dev ia32-libs \
  x11proto-core-dev libx11-dev lib32readline5-dev lib32z-dev \
  libgl1-mesa-dev g++-multilib mingw32 tofrodos python-markdown \
  libxml2-utils xsltproc

On Ubuntu 10.10:

$ sudo ln -s /usr/lib32/mesa/libGL.so.1 /usr/lib32/mesa/libGL.so

On Ubuntu 11.10:

$ sudo apt-get install libx11-dev:i386

32-bit (experimental)

$ sudo apt-get install git-core gnupg flex bison gperf build-essential \
  zip curl zlib1g-dev libc6-dev libncurses5-dev x11proto-core-dev \
  libx11-dev libreadline6-dev libgl1-mesa-dev tofrodos python-markdown \
  libxml2-utils xsltproc

Installing required packages (Ubuntu 12.04)

Building on Ubuntu 12.04 is currently only experimentally supported and is not guaranteed to work on branches other than master.

$ sudo apt-get install git-core gnupg flex bison gperf build-essential \
  zip curl libc6-dev libncurses5-dev:i386 x11proto-core-dev \
  libx11-dev:i386 libreadline6-dev:i386 libgl1-mesa-dev:i386 \
  g++-multilib mingw32 openjdk-6-jdk tofrodos python-markdown \
  libxml2-utils xsltproc zlib1g-dev:i386

You may also need to fix a compilation issue in a kernel header:

$ sudo vim /usr/include/linux/usb/ch9.h  # line 592

# return le16_to_cpu(epd->wMaxPacketSize);
return __le16_to_cpu(epd->wMaxPacketSize);

前期准备工作完成，开始进入下载阶段。

下载篇：

To install, initialize, and configure Repo, follow these steps:

Make sure you have a bin/ directory in your home directory, and that it is included in your path:
```
$ mkdir ~/bin
$ PATH=~/bin:$PATH
```

Download the Repo script and ensure it is executable:

$ curl https://dl-ssl.google.com/dl/googlesource/git-repo/repo > ~/bin/repo
$ chmod a+x ~/bin/repo

The SHA-1 checksum for repo is 29ba4221d4fccdfa8d87931cd73466fdc24040b5

Initializing a Repo client

After installing Repo, set up your client to access the android source repository:

Create an empty directory to hold your working files. If you’re using MacOS, this has to be on a case-sensitive filesystem. Give it any name you like:
```
$ mkdir WORKING_DIRECTORY
$ cd WORKING_DIRECTORY
```
Run repo init to bring down the latest version of Repo with all its most recent bug fixes. You must specify a URL for the manifest, which specifies where the various repositories included in the Android source will be placed within your working directory.
```
$ repo init -u https://android.googlesource.com/platform/manifest
```
To check out a branch other than “master”, specify it with -b:
```
$ repo init -u https://android.googlesource.com/platform/manifest -b android-4.0.1_r1
```

完成之后在当前目录下产生一个.repo的目录。

Getting the files

To pull down files to your working directory from the repositories as specified in the default manifest, run

$ repo sync

这步之后就开始漫长的等待，快则几个小时，慢的话也许几天。。。。

如果中途断开，则重新执行：repo sync 或repo -f sync

下载完成之后，便可以开启编译之旅。

编译篇：

Building the System

The basic sequence of build commands is as follows:

Initialize

Initialize the environment with the envsetup.sh script. Note that replacing “source” with a single dot saves a few characters, and the short form is more commonly used in documentation.

$ source build/envsetup.sh

$ . build/envsetup.sh

Choose a Target

Choose which target to build with lunch. The exact configuration can be passed as an argument, e.g.

$ lunch full-eng

The example above refers to a complete build for the emulator, with all debugging enabled.

If run with no arguments lunch will prompt you to choose a target from the menu.

All build targets take the form BUILD-BUILDTYPE, where the BUILD is a codename referring to the particular feature combination:

Build name	Device	Notes
full	emulator	fully configured with all languages, apps, input methods
full_maguro	maguro	`full` build running on Galaxy Nexus GSM/HSPA+ (“maguro”)
full_panda	panda	`full` build running on PandaBoard (“panda”)

and the BUILDTYPE is one of the following:

Buildtype	Use
user	limited access; suited for production
userdebug	like “user” but with root access and debuggability; preferred for debugging
eng	development configuration with additional debugging tools

For more information about building for and running on actual hardware, see Building for devices

Build the Code

Build everything with make. GNU make can handle parallel tasks with a -jN argument, and it’s common to use a number of tasks N that’s between 1 and 2 times the number of hardware threads on the computer being used for the build. E.g. on a dual-E5520 machine (2 CPUs, 4 cores per CPU, 2 threads per core), the fastest builds are made with commands between make -j16 and make -j32.

$ make -j4

编译一般也不会出现什么问题，只是如果是要在32bit的Ubuntu下编译，则要做以下处理：

1、修改Android.mk配置文件

将以下位置的几个配置文件：

./external/clearsilver/cgi/Android.mk

./external/clearsilver/cs/Android.mk

./external/clearsilver/java-jni/Android.mk

./external/clearsilver/util/Android.mk

文件中的

LOCAL_CFLAGS += -m64

LOCAL_LDFLAGS += -m64

m64替换m32（或者注释掉，然后重写也可以）

LOCAL_CFLAGS += -m32

LOCAL_LDFLAGS += -m32

2、修改main.mk

再将./build/core/main.mk 中的

ifneq (64,$(findstring 64,$(build_arch)))

改为：

ifneq (i686,$(findstring i686,$(build_arch)))

首次编译，可能要花点时间，静静的等待，出现如下字样，则恭喜您编译成功啦。

Target system fs image: out/target/product/generic/obj/PACKAGING/systemimage_intermediates/system.img

Install system fs image: out/target/product/generic/system.img

Installed file list: out/target/product/generic/installed-files.txt

编译完成之后便可以开始在Eclipse里面调试源码啦。

调试篇：

Using Eclipse

Basic setup

First, it’s important to make sure the regular Android development system is set up.

cd /path/to/android/root
make

Important: You will still be using make to build the files you will actually run (in the emulator or on a device). You will be using Eclipse to edit files and verify that they compile, but when you want to run something you will need to make sure files are saved in Eclipse and run make in a shell. The Eclipse build is just for error checking.

Eclipse needs a list of directories to search for Java files. This is called the “Java Build Path” and can be set with the .classpath file. We have a sample version to start you off.

cd /path/to/android/root
cp development/ide/eclipse/.classpath .
chmod u+w .classpath

Now edit that copy of .classpath, if necessary.

注意：Eclipse里只是用于对源码调试，如果要运行到模拟器或Device则还另须make。

Increase Eclipse’s Memory Settings

The Android project is large enough that Eclipse’s Java VM sometimes runs out of memory while compiling it. Avoid this problem by editing the eclipse.ini file. On Apple OSX the eclipse.ini file is located at

/Applications/eclipse/Eclipse.app/Contents/MacOS/eclipse.ini

Memory-related defaults (as of Eclipse 3.4):

-Xms40m
-Xmx256m
-XX:MaxPermSize=256m

Recommended settings for Android development:

-Xms128m
-Xmx512m
-XX:MaxPermSize=256m

These settings set Eclipse’s minimum Java heap size to 128MB, set the maximum Java heap size to 512MB, and keep the maximum permanent generation size at the default of 256MB.

修改完之后，对于3.5及以下的版本可以如下操作：

Now create a project for Android development:

If Eclipse asks you for a workspace location, choose the default.
If you have a “Welcome” screen, close it to reveal the Java perspective.
File > New > Java Project
Pick a project name, “android” or anything you like.
Select “Create project from existing source”, enter the path to your Android root directory, and click Finish.
Wait while it sets up the project. (You’ll see a subtle progress meter in th

对于3.5以上的版本的版本可以尝试以下操作：

由于3.5以上版本没有Create project from existing source这个选项，因此读者可以尝试方法：在启动Eclipse的时候，选择工作区时不要勾选设置为默认工作区，同时工作区指向下载的android source code的根目录，点击“确定”,加载完成之后，整个源码便加载进来啦。

注意：在导入完整个source code之后，经常报如下错误：

Project'gingerbread' is missing required library:'out/target/common/obj/JAVA_LIBRARIES/google-common_intermediates/javalib.jar' Project'gingerbread' is missing required library:'out/target/common/obj/JAVA_LIBRARIES/gsf-client_intermediates/javalib.jar'

删除.classpath中的这两行路径：

添加

然后重启Eclipse，即可解决。

当然我们也可以单独调试某个模块，比如说：Contacts，Settings，Launcher2，Mms，Browser等等。

1、使用到了未包括在SDK中（公开发布）的API，有两种情况：

a 被 @hide 标注了的类：这些类是被隐藏起来的，这些类大多都在com.android.internal包下面；

b 一些未包括在SDK中的、Google私有的Api，它们大多都在com.google.android包下面

2、使用了一些由framework层声明的aidl接口访问系统服务，然而这些aidl在编译时才会转换成.java源码，因此在SDK环境下编译这些应用时无法访问到它们。

解决方法是：

（请注意：out目录是在完整源码编译环境下（Linux下），执行一次完整编译后的输出目录）

1、找到那些被隐藏起来的类、它们在以下两个位置：

A、out\target\common\obj\JAVA_LIBRARIES\framework_intermediates/ classes.jar ；

B、out\target\common\obj\JAVA_LIBRARIES\android-common_intermediates\ classes.jar ；

将找到的.jar文件，在Eclipse中作为User Library 添加到 Project 的Librarys依赖中，并将该库的顺序置于Android SDK Library之上。

在 out\target\common\obj\JAVA_LIBRARIES\ 目录下，还有很多其它具体应用相关的jar包，…. ；

2、找到那些缺失的、编译时才生成的，.java源文件，它们通常在以下位置：

A、 out\target\common\obj\JAVA_LIBRARIES\XXX _intermediates\src 目录下，XXX是相关模块的名称；

B、out\target\common\obj\APPS\ XXX _intermediates\src 目录下；

将找到的src目录，在Eclipse下，以Link Source的方式，连接到Project 中作为源码的一部分

例如：

Eclipse下编译Android自带联系人应用，错误信息：

import com.android.phone.CallLogAsync;
import com.android.phone.HapticFeedback;

解决方法导入：

out\target\common\obj\APPS\Phone_intermediates\classes.jar

Android开发环境搭建

root — Wed, 11 Jan 2012 09:22:56 +0000

最近经常搭建android开发环境，在此记录下来仅供参考，搭建的系统环境：Ubuntu 11.04 32位。

首先，要准备的文件有：

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开发之旅吧。

SWIG Tutorial

ithouge — Tue, 20 Dec 2011 07:11:57 +0000

关于SWIG官方的一个Demo,参见：http://www.swig.org/tutorial.html，有些地方讲解的不是很详细，初次尝试编译的时候，往往编译不通过，下面结合我编译的过程做一个分析。

首先我的编译环境是：

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 &lt;= 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(&lt;ime);
     return ctime(&lt;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

Android开发经验积累

ithouge — Tue, 13 Dec 2011 07:30:41 +0000

随着移动平台的发展和其应用的不断改善，质量成为决定成败的关键。用户要求他们选择安装的应用响应快、性能好，如果某个应用不能提供卓越的功能和稳定的用户体验，那这样的应用注定会被很快卸载。
尽管现在Android智能手机和平板电脑的运行速率越来越快，但开发者仍需牢记，应用的运行环境仍受到电池和处理器等诸多资源的限制。以下是如何为应用“瘦身”的十条建议，以便能在当前和以后的所有Android设备都能运行出最佳效果。

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平台随带了众多免费的实用工具，可以帮助跟踪和解决应用程序中的性能问题。

资源库

ithouge — Tue, 27 Sep 2011 02:25:09 +0000

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流量统计TrafficStats类的使用

android contacts

ithouge — Sat, 17 Sep 2011 04:52:25 +0000

本章和大家分享的是手机通讯录方面的经验，需求背景:对手机通讯录进行增、删、改、查，或者有时候App需要与手机 contacts进行交互或共享contacts。

我们都知道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 &amp;&amp; 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(Android Cloud to Device Messaging)

root — Sat, 20 Aug 2011 07:20:27 +0000

Android Cloud to Device Messaging (C2DM) is a service that helps developers send data from servers to their applications on Android devices. The service provides a simple, lightweight mechanism that servers can use to tell mobile applications to contact the server directly, to fetch updated application or user data. The C2DM service handles all aspects of queueing of messages and delivery to the target application running on the target device.

这个是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，

<receiver android:name="com.gigatalk.service.C2DMReceiver" android:permission="com.google.android.c2dm.permission.SEND">
          
          <intent-filter>
              <action android:name="com.google.android.c2dm.intent.RECEIVE" />
              <category android:name="com.gigatalk" />
          intent-filter>
          
          <intent-filter>
              <action android:name="com.google.android.c2dm.intent.REGISTRATION" />
              <category android:name="com.gigatalk" />
          intent-filter>
      receiver>

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

/**
 * 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以及由谁来接收。

//向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

ithouge — Sat, 20 Aug 2011 06:31:03 +0000

PopupWindow有点类似于Dialog，相同点在于都是弹出窗口，并且都可以对其进行自定义显示，并且里面的监听组件，进行相应的操作，但它与Dialog又有很大的区别，PopupWindow只是弹出窗口，不会使宿主Activity组件失去焦点，也就是说PopupWindow弹出后，你仍可以与宿主Activity进行交互，Dialog却不能做到这一点。

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

图1：

图2

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

       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 &gt; 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的大小和布局。使用方法是实现该类，并传入相应的参数:

                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();

Custom Button

ithouge — Sat, 20 Aug 2011 06:10:09 +0000

本章我将和大家一起分享的是Custom Button（自定义组件）,实现的效果是组件颜色要有渐变，看起来有种立体的感觉，当组件没有被点击时，其字体颜色是黑色，但组件被点击时，其背景色变为白色，且字体颜色变为黑色，效果图如下:

图1：

图2：

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

    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.

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

<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所示的效果，那么我们该如何实现单击变化背景色以及字体颜色呢？

         /**
	 * 触摸事件
	 */
	@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);
	}