基础总结篇之六：ContentProvider之读写联系人

今天我们来讲解一下如何利用ContentProvider机制读写联系人信息。

在Android中，ContentProvider是一种数据包装器，适合在不同进程间实现信息的共享。例如，在Android中SQLite数据库是一个典型的数据源，我们可以把它封装到ContentProvider中，这样就可以很好的为其他应用提供信息共享服务。其他应用在访问ContentProvider时，可以使用一组类似REST的URI的方式进行数据操作，大大简化了读写信息的复杂度。例如，如果要从封装图书数据库的ContentProvider获取一组图书，需要使用类似以下形式的URI：

content://com.scott.book.BookProvider/books

而要从图书数据库中获取指定图书（比如23号图书），需要使用类似以下形式的URI：

content://com.scott.book.BookProvider/books/23

注：ContentProvider是一个抽象类，定义了一系列操作数据的方法模板，BookProvider需要实现这些方法，实现图书信息的各种操作。

那么，现在知道了具体的URI之后，我们又如何操作进而取得数据呢？

此时，我们就要了解ContentResolver这个类，它跟ContentProvider是对应的关系，我们正是通过它来与ContentProvider进行数据交换的。android.content.Context类为我们定义了getContentResolver()方法，用于获取一个ContentResolver对象，如果我们在运行期可以通过getContext()获取当前Context实例对象，就可以通过这个实例对象所提供的getContentResolver()方法获取到ContentResolver类型的实例对象，进而可以操作对应的数据。

下面我们就通过联系人实例对这种机制进行演示。

在Android中，联系人的操作都是通过一个统一的途径来读写数据的，我们打开/data/data/com.android.providers.contacts可以看到联系人的数据源：

有兴趣的朋友可以导出这个文件，用专业的工具软件打开看一下表结构。

对这个SQLite类型的数据源的封装后，联系人就以ContentProvider的形式为其他应用进程提供联系人的读写服务，我们就可以顺利成章的操作自己的联系人信息了。

为了方便测试，我们先添加两个联系人到数据源中，如图所示：

我们看到，每个联系人都有两个电话号码和两个邮箱账号，分别为家庭座机号码、移动手机号码、家庭邮箱账号和工作邮箱账号。当然在添加联系人时有很多其他信息，我们这里都没有填写，只选择了最常用的电话和邮箱，主要是方便演示这个过程。

在演示代码之前，我们需要了解一下android.provider.ContactsContract这个类（注：在较早的版本中是android.provider.Contacts这个类，不过现在已被废弃，不建议使用），它定义了各种联系人相关的URI和每一种类型信息的属性信息：

有兴趣的朋友还可以读一下源代码，不过比较多，而且内部类使用的特别多，读起来有一定的困难，还是要做好心理准备。

下面我们通过一个项目，来演示一下联系人操作的具体过程。新建一个名为provider的项目，创建一个名为ContactsReadTest的测试用例，如下：

[java] view plaincopy

1. package com.scott.provider;  
2.   
3. import java.util.ArrayList;  
4.   
5. import android.content.ContentResolver;  
6. import android.database.Cursor;  
7. import android.net.Uri;  
8. import android.provider.ContactsContract;  
9. import android.test.AndroidTestCase;  
10. import android.util.Log;  
11.   
12. public class ContactsReadTest extends AndroidTestCase {  
13.       
14.     private static final String TAG = "ContactsReadTest";  
15.       
16.     //[content://com.android.contacts/contacts]  
17.     private static final Uri CONTACTS_URI = ContactsContract.Contacts.CONTENT_URI;  
18.     //[content://com.android.contacts/data/phones]  
19.     private static final Uri PHONES_URI = ContactsContract.CommonDataKinds.Phone.CONTENT_URI;  
20.     //[content://com.android.contacts/data/emails]  
21.     private static final Uri EMAIL_URI = ContactsContract.CommonDataKinds.Email.CONTENT_URI;  
22.       
23.     private static final String _ID = ContactsContract.Contacts._ID;  
24.     private static final String DISPLAY_NAME = ContactsContract.Contacts.DISPLAY_NAME;  
25.     private static final String HAS_PHONE_NUMBER = ContactsContract.Contacts.HAS_PHONE_NUMBER;  
26.     private static final String CONTACT_ID = ContactsContract.Data.CONTACT_ID;  
27.       
28.     private static final String PHONE_NUMBER = ContactsContract.CommonDataKinds.Phone.NUMBER;  
29.     private static final String PHONE_TYPE = ContactsContract.CommonDataKinds.Phone.TYPE;  
30.     private static final String EMAIL_DATA = ContactsContract.CommonDataKinds.Email.DATA;  
31.     private static final String EMAIL_TYPE = ContactsContract.CommonDataKinds.Email.TYPE;  
32.       
33.     public void testReadContacts() {  
34.         ContentResolver resolver = getContext().getContentResolver();  
35.         Cursor c = resolver.query(CONTACTS_URI, null, null, null, null);  
36.         while (c.moveToNext()) {  
37.             int _id = c.getInt(c.getColumnIndex(_ID));  
38.             String displayName = c.getString(c.getColumnIndex(DISPLAY_NAME));  
39.               
40.             Log.i(TAG, displayName);  
41.               
42.             ArrayList<String> phones = new ArrayList<String>();  
43.             ArrayList<String> emails = new ArrayList<String>();  
44.               
45.             String selection = CONTACT_ID + "=" + _id;  //the 'where' clause  
46.               
47.             //获取手机号  
48.             int hasPhoneNumber = c.getInt(c.getColumnIndex(HAS_PHONE_NUMBER));  
49.             if (hasPhoneNumber > 0) {  
50.                 Cursor  phc = resolver.query(PHONES_URI, null, selection, null, null);  
51.                 while (phc.moveToNext()) {  
52.                     String phoneNumber = phc.getString(phc.getColumnIndex(PHONE_NUMBER));  
53.                     int phoneType = phc.getInt(phc.getColumnIndex(PHONE_TYPE));  
54.                     phones.add(getPhoneTypeNameById(phoneType) + " : " + phoneNumber);  
55.                 }  
56.                 phc.close();  
57.             }  
58.               
59.             Log.i(TAG, "phones: " + phones);  
60.               
61.             //获取邮箱  
62.             Cursor emc = resolver.query(EMAIL_URI,null, selection, null, null);  
63.             while (emc.moveToNext()) {  
64.                 String emailData = emc.getString(emc.getColumnIndex(EMAIL_DATA));  
65.                 int emailType = emc.getInt(emc.getColumnIndex(EMAIL_TYPE));  
66.                 emails.add(getEmailTypeNameById(emailType) + " : " + emailData);  
67.             }  
68.             emc.close();  
69.               
70.             Log.i(TAG, "emails: " + emails);  
71.         }  
72.         c.close();  
73.     }  
74.       
75.     private String getPhoneTypeNameById(int typeId) {  
76.         switch (typeId) {  
77.         case ContactsContract.CommonDataKinds.Phone.TYPE_HOME: return "home";  
78.         case ContactsContract.CommonDataKinds.Phone.TYPE_MOBILE: return "mobile";  
79.         case ContactsContract.CommonDataKinds.Phone.TYPE_WORK: return "work";  
80.         default: return "none";  
81.         }  
82.     }  
83.       
84.     private String getEmailTypeNameById(int typeId) {  
85.         switch (typeId) {  
86.         case ContactsContract.CommonDataKinds.Email.TYPE_HOME: return "home";  
87.         case ContactsContract.CommonDataKinds.Email.TYPE_WORK: return "work";  
88.         case ContactsContract.CommonDataKinds.Email.TYPE_OTHER: return "other";  
89.         default: return "none";  
90.         }  
91.     }  
92. }  

为了使这个测试用例运行起来，我们需要在AndroidManifest.xml中配置一下测试设备的声明，它与<application>元素处于同一级别位置：

[html] view plaincopy

1. <!-- 配置测试设备的主类和目标包 -->  
2.     <instrumentation android:name="android.test.InstrumentationTestRunner"  
3.                      android:targetPackage="com.scott.provider"/>  

然后再配置使用测试类库声明，它与<activity>元素处于同一级别位置：

[html] view plaincopy

1. <!-- 配置测试要使用的类库 -->  
2.    <uses-library android:name="android.test.runner"/>  

最后，还有一个重要的声明需要配置，就是读取联系人权限，声明如下：

[html] view plaincopy

1. <!-- 读取联系人 -->  
2. <uses-permission android:name="android.permission.READ_CONTACTS"/>  

经过以上准备工作，这个测试用例就可以运转起来了，我们运行一下testReadContacts()方法，打印结果如下：

看来联系人里的信息都被我们准确无误的读取出来了。

如果我们在一个Activity里运行读取联系人的代码，不仅可以使用ContentResolver直接进行读取操作（即查询），还可以使用Activity提供的managedQuery方法方便的实现同样的效果，我们来看一下这个方法的具体代码：

[java] view plaincopy

1. public final Cursor managedQuery(Uri uri,  
2.                                  String[] projection,  
3.                                  String selection,  
4.                                  String[] selectionArgs,  
5.                                  String sortOrder)  
6. {  
7.     Cursor c = getContentResolver().query(uri, projection, selection, selectionArgs, sortOrder);  
8.     if (c != null) {  
9.         startManagingCursor(c);  
10.     }  
11.     return c;  
12. }  

我们发现，其实它还是使用了ContentResolver进行查询操作，但是多了一步startManagingCursor的操作，它会根据Activity的生命周期对Cursor对象进行管理，避免了一些因Cursor是否释放引起的问题，所以非常方便，大大简化了我们的工作量。

接下来我们将要尝试将一个联系人信息添加到系统联系人的数据源中，实现对联系人的写入操作。我们新建一个名为ContactsWriteTest的测试用例，如下：

[java] view plaincopy

1. package com.scott.provider;  
2.   
3. import java.util.ArrayList;  
4.   
5. import android.content.ContentProviderOperation;  
6. import android.content.ContentProviderResult;  
7. import android.content.ContentResolver;  
8. import android.net.Uri;  
9. import android.provider.ContactsContract;  
10. import android.test.AndroidTestCase;  
11. import android.util.Log;  
12.   
13. public class ContactsWriteTest extends AndroidTestCase {  
14.   
15.     private static final String TAG = "ContactsWriteTest";  
16.   
17.     //[content://com.android.contacts/raw_contacts]  
18.     private static final Uri RAW_CONTACTS_URI = ContactsContract.RawContacts.CONTENT_URI;  
19.     //[content://com.android.contacts/data]  
20.     private static final Uri DATA_URI = ContactsContract.Data.CONTENT_URI;  
21.       
22.     private static final String ACCOUNT_TYPE = ContactsContract.RawContacts.ACCOUNT_TYPE;  
23.     private static final String ACCOUNT_NAME = ContactsContract.RawContacts.ACCOUNT_NAME;  
24.       
25.     private static final String RAW_CONTACT_ID = ContactsContract.Data.RAW_CONTACT_ID;  
26.     private static final String MIMETYPE = ContactsContract.Data.MIMETYPE;  
27.       
28.     private static final String NAME_ITEM_TYPE = ContactsContract.CommonDataKinds.StructuredName.CONTENT_ITEM_TYPE;  
29.     private static final String DISPLAY_NAME = ContactsContract.CommonDataKinds.StructuredName.DISPLAY_NAME;  
30.       
31.     private static final String PHONE_ITEM_TYPE = ContactsContract.CommonDataKinds.Phone.CONTENT_ITEM_TYPE;  
32.     private static final String PHONE_NUMBER = ContactsContract.CommonDataKinds.Phone.NUMBER;  
33.     private static final String PHONE_TYPE = ContactsContract.CommonDataKinds.Phone.TYPE;  
34.     private static final int PHONE_TYPE_HOME = ContactsContract.CommonDataKinds.Phone.TYPE_HOME;  
35.     private static final int PHONE_TYPE_MOBILE = ContactsContract.CommonDataKinds.Phone.TYPE_MOBILE;  
36.       
37.     private static final String EMAIL_ITEM_TYPE = ContactsContract.CommonDataKinds.Email.CONTENT_ITEM_TYPE;  
38.     private static final String EMAIL_DATA = ContactsContract.CommonDataKinds.Email.DATA;  
39.     private static final String EMAIL_TYPE = ContactsContract.CommonDataKinds.Email.TYPE;  
40.     private static final int EMAIL_TYPE_HOME = ContactsContract.CommonDataKinds.Email.TYPE_HOME;  
41.     private static final int EMAIL_TYPE_WORK = ContactsContract.CommonDataKinds.Email.TYPE_WORK;  
42.   
43.     private static final String AUTHORITY = ContactsContract.AUTHORITY;  
44.       
45.     public void testWriteContacts() throws Exception {  
46.         ArrayList<ContentProviderOperation> operations = new ArrayList<ContentProviderOperation>();  
47.   
48.         ContentProviderOperation operation = ContentProviderOperation.newInsert(RAW_CONTACTS_URI)  
49.                                     .withValue(ACCOUNT_TYPE, null)  
50.                                     .withValue(ACCOUNT_NAME, null)  
51.                                     .build();  
52.         operations.add(operation);  
53.   
54.         //添加联系人名称操作  
55.         operation = ContentProviderOperation.newInsert(DATA_URI)  
56.                                     .withValueBackReference(RAW_CONTACT_ID, 0)  
57.                                     .withValue(MIMETYPE, NAME_ITEM_TYPE)  
58.                                     .withValue(DISPLAY_NAME, "Scott Liu")  
59.                                     .build();  
60.         operations.add(operation);  
61.   
62.         //添加家庭座机号码  
63.         operation = ContentProviderOperation.newInsert(DATA_URI)  
64.                                     .withValueBackReference(RAW_CONTACT_ID, 0)  
65.                                     .withValue(MIMETYPE, PHONE_ITEM_TYPE)  
66.                                     .withValue(PHONE_TYPE, PHONE_TYPE_HOME)  
67.                                     .withValue(PHONE_NUMBER, "01034567890")  
68.                                     .build();  
69.         operations.add(operation);  
70.           
71.         //添加移动手机号码  
72.         operation = ContentProviderOperation.newInsert(DATA_URI)  
73.                                     .withValueBackReference(RAW_CONTACT_ID, 0)  
74.                                     .withValue(MIMETYPE, PHONE_ITEM_TYPE)  
75.                                     .withValue(PHONE_TYPE, PHONE_TYPE_MOBILE)  
76.                                     .withValue(PHONE_NUMBER, "13034567890")  
77.                                     .build();  
78.         operations.add(operation);  
79.   
80.         //添加家庭邮箱  
81.         operation = ContentProviderOperation.newInsert(DATA_URI)  
82.                                     .withValueBackReference(RAW_CONTACT_ID, 0)  
83.                                     .withValue(MIMETYPE, EMAIL_ITEM_TYPE)  
84.                                     .withValue(EMAIL_TYPE, EMAIL_TYPE_HOME)  
85.                                     .withValue(EMAIL_DATA, "scott@android.com")  
86.                                     .build();  
87.         operations.add(operation);  
88.   
89.         //添加工作邮箱  
90.         operation = ContentProviderOperation.newInsert(DATA_URI)  
91.                                     .withValueBackReference(RAW_CONTACT_ID, 0)  
92.                                     .withValue(MIMETYPE, EMAIL_ITEM_TYPE)  
93.                                     .withValue(EMAIL_TYPE, EMAIL_TYPE_WORK)  
94.                                     .withValue(EMAIL_DATA, "scott@msapple.com")  
95.                                     .build();  
96.         operations.add(operation);  
97.           
98.         ContentResolver resolver = getContext().getContentResolver();  
99.         //批量执行,返回执行结果集  
100.         ContentProviderResult[] results = resolver.applyBatch(AUTHORITY, operations);  
101.         for (ContentProviderResult result : results) {  
102.             Log.i(TAG, result.uri.toString());  
103.         }  
104.     }  
105. }  

在上面的代码中，我们把整个操作分为几个ContentProviderOperation操作，并将他们做批处理操作，我们也许注意到，从第二个操作开始，每一项都有一个withValueBackReference(RAW_CONTACT_ID, 0)步骤，它参照了第一项操作新添加的联系人的id，因为是批处理，我们插入数据前并不知道id的值，不过这个不用担心，在进行批处理插入数据时，它会重新引用新的id值，不会影响最终的结果。

当然，这个也不能忘了配置写入联系人的权限声明：

[html] view plaincopy

1. <!-- 写入联系人 -->  
2. <uses-permission android:name="android.permission.WRITE_CONTACTS" />  

经过以上步骤之后，我们运行一下testWriteContacts()方法，看看联系人是否添加进去了：

来源：http://blog.csdn.net/liuhe688/article/details/7006556