基础总结篇之八：创建及调用自己的ContentProvider

转自：http://blog.csdn.net/wellsoho/article/details/49494141

若不能坚持到底，即使是朽木也不能折断；只要坚持不停地用刀刻，就算是金属玉石也可以雕出花饰。用今天的话来说就是：再容易的事情，没有锲而不舍的精神，都不可能做到；再难的事情，只要有坚持不懈的努力，都一定能够做到。希望我们在坚持理想的道路上都能够锲而不舍地雕刻自己的那块“金石”。

今天我们来讲解一下如何创建及调用自己的ContentProvider。

在前面两篇文章中我们分别讲了如何读写联系人和短消息，相信大家对于ContentProvider的操作方法已经有了一定程度的了解。在有些场合，除了操作ContentProvider之外，我们还有可能需要创建自己的ContentProvider，来提供信息共享的服务，这就要求我们很好的掌握ContentProvider的创建及使用技巧。下面我们就由表及里的逐步讲解每个步骤。

在正式开始实例演示之前，我们先来了解以下两个知识点：

授权：

在Android中，每一个ContentProvider都会用类似于域名的字符串来注册自己，我们成为授权(authority)。这个唯一标识的字符串是此ContentProvider可提供的一组URI的基础，有了这个基础，才能够向外界提供信息的共享服务。

授权是在AndroidManifest.xml中完成的，每一个ContentProvider必须在此声明并授权，方式如下：

1. <provider android:name=".SomeProvider"
2. android:authorities="com.your-company.SomeProvider"/>

上面的<provider>元素指明了ContentProvider的提供者是“SomeProvider”这个类，并为其授权，授权的基础URI为“com.your-company.SomeProvider”。有了这个授权信息，系统可以准确的定位到具体的ContentProvider，从而使访问者能够获取到指定的信息。这和浏览Web页面的方式很相似，“SomeProvider”就像一台具体的服务器，而“com.your-company.SomeProvider”就像注册的域名，相信大家对这个概念并不陌生，由此联想一下就可以了解ContentProvider授权的作用了。（需要注意的是，除了Android内置应用程序之外，第三方程序应尽量使用以上方式的完全限定的授权名。）

MIME类型：

就像网站返回给定URL的MIME（Multipurpose Internet Mail Extensions，多用途Internet邮件扩展）类型一样（这使浏览器能够用正确的程序来查看内容），ContentProvider还负责返回给定URI的MIME类型。根据MIME类型规范，MIME类型包含两部分：类型和子类型。例如：text/html，text/css，text/xml等等。

Android也遵循类似的约定来定义MIME类型。

对于单条记录，MIME类型类似于：

vnd.android.cursor.item/vnd.your-company.content-type

而对于记录的集合，MIME类型类似于：

vnd.android.cursor.dir/vnd.your-company.comtent-type

其中的vnd表示这些类型和子类型具有非标准的、供应商特定的形式；content-type可以根据ContentProvider的功能来定，比如日记的ContentProvider可以为note，日程安排的ContentProvider可以为schedule，等等。

了解了以上两个知识点之后，我们就结合实例来演示一下具体的过程。

我们将会创建一个记录person信息的ContentProvider，实现对person的CRUD操作，访问者可以通过下面路径操作我们的ContentProvider：

访问者可以通过“[BASE_URI]/persons”来操作person集合，也可以通过“[BASE_URI]/persons/#”的形式操作单个person。

我们创建一个person的ContentProvider需要两个步骤：

1.创建PersonProvider类：

我们需要继承ContentProvider类，实现onCreate、query、insert、update、delete和getType这几个方法。具体代码如下：

1. package com.scott.provider;
2. import android.content.ContentProvider;
3. import android.content.ContentUris;
4. import android.content.ContentValues;
5. import android.content.UriMatcher;
6. import android.database.Cursor;
7. import android.database.sqlite.SQLiteDatabase;
8. import android.net.Uri;
9. public class PersonProvider extends ContentProvider {
10. private static final UriMatcher matcher;
11. private DBHelper helper;
12. private SQLiteDatabase db;
13. private static final String AUTHORITY = "com.scott.provider.PersonProvider";
14. private static final int PERSON_ALL = 0;
15. private static final int PERSON_ONE = 1;
16. public static final String CONTENT_TYPE = "vnd.android.cursor.dir/vnd.scott.person";
17. public static final String CONTENT_ITEM_TYPE = "vnd.android.cursor.item/vnd.scott.person";
18. //数据改变后立即重新查询
19. private static final Uri NOTIFY_URI = Uri.parse("content://" + AUTHORITY + "/persons");
20. static {
21. matcher = new UriMatcher(UriMatcher.NO_MATCH);
22. matcher.addURI(AUTHORITY, "persons", PERSON_ALL);   //匹配记录集合
23. matcher.addURI(AUTHORITY, "persons/#", PERSON_ONE); //匹配单条记录
24. }
25. @Override
26. public boolean onCreate() {
27. helper = new DBHelper(getContext());
28. return true;
29. }
30. @Override
31. public String getType(Uri uri) {
32. int match = matcher.match(uri);
33. switch (match) {
34. case PERSON_ALL:
35. return CONTENT_TYPE;
36. case PERSON_ONE:
37. return CONTENT_ITEM_TYPE;
38. default:
39. throw new IllegalArgumentException("Unknown URI: " + uri);
40. }
41. }
42. @Override
43. public Cursor query(Uri uri, String[] projection, String selection, String[] selectionArgs, String sortOrder) {
44. db = helper.getReadableDatabase();
45. int match = matcher.match(uri);
46. switch (match) {
47. case PERSON_ALL:
48. //doesn't need any code in my provider.
49. break;
50. case PERSON_ONE:
51. long _id = ContentUris.parseId(uri);
52. selection = "_id = ?";
53. selectionArgs = new String[]{String.valueOf(_id)};
54. break;
55. default:
56. throw new IllegalArgumentException("Unknown URI: " + uri);
57. }
58. return db.query("person", projection, selection, selectionArgs, null, null, sortOrder);
59. }
60. @Override
61. public Uri insert(Uri uri, ContentValues values) {
62. int match = matcher.match(uri);
63. if (match != PERSON_ALL) {
64. throw new IllegalArgumentException("Wrong URI: " + uri);
65. }
66. db = helper.getWritableDatabase();
67. if (values == null) {
68. values = new ContentValues();
69. values.put("name", "no name");
70. values.put("age", "1");
71. values.put("info", "no info.");
72. }
73. long rowId = db.insert("person", null, values);
74. if (rowId > 0) {
75. notifyDataChanged();
76. return ContentUris.withAppendedId(uri, rowId);
77. }
78. return null;
79. }
80. @Override
81. public int delete(Uri uri, String selection, String[] selectionArgs) {
82. db = helper.getWritableDatabase();
83. int match = matcher.match(uri);
84. switch (match) {
85. case PERSON_ALL:
86. //doesn't need any code in my provider.
87. break;
88. case PERSON_ONE:
89. long _id = ContentUris.parseId(uri);
90. selection = "_id = ?";
91. selectionArgs = new String[]{String.valueOf(_id)};
92. }
93. int count = db.delete("person", selection, selectionArgs);
94. if (count > 0) {
95. notifyDataChanged();
96. }
97. return count;
98. }
99. @Override
100. public int update(Uri uri, ContentValues values, String selection, String[] selectionArgs) {
101. db = helper.getWritableDatabase();
102. int match = matcher.match(uri);
103. switch (match) {
104. case PERSON_ALL:
105. //doesn't need any code in my provider.
106. break;
107. case PERSON_ONE:
108. long _id = ContentUris.parseId(uri);
109. selection = "_id = ?";
110. selectionArgs = new String[]{String.valueOf(_id)};
111. break;
112. default:
113. throw new IllegalArgumentException("Unknown URI: " + uri);
114. }
115. int count = db.update("person", values, selection, selectionArgs);
116. if (count > 0) {
117. notifyDataChanged();
118. }
119. return count;
120. }
121. //通知指定URI数据已改变
122. private void notifyDataChanged() {
123. getContext().getContentResolver().notifyChange(NOTIFY_URI, null);
124. }
125. }

在PersonProvider中，我们定义了授权地址为“com.scott.provider.PersonProvider”，相信大家在前面也有所了解了。基于这个授权，我们使用了一个UriMatcher对其路径进行匹配，“[BASE_URI]/persons"和“[BASE_URI]/persons/#”这两种路径我们在上面也介绍过，分别对应记录集合和单个记录的操作。在query、insert、update和delete方法中我们根据UriMatcher匹配结果来判断该URI是操作记录集合还是单条记录，从而采取不同的处理方法。在getType方法中，我们会根据匹配的结果返回不同的MIME类型，这一步是不能缺少的，比如我们在query方法中有可能是查询全部集合，有可能是查询单条记录，那么我们返回的Cursor或是集合类型，或是单条记录，这个跟getType返回的MIME类型是一致的，就好像浏览网页一样，指定的url返回的信息是什么类型，那么浏览器就应该接收到对应的MIME类型。另外，我们注意到，上面代码中，在insert、update、delete方法中都调用了notifyDataChanged方法，这个方法中仅有的一步操作就是通知“[BASE_URI]/persons"的访问者，数据发生改变了，应该重新加载了。

在我们的PersonProvider中，我们用到了Person、DBHelper类，代码如下：

1. package com.scott.provider;
2. public class Person {
3. public int _id;
4. public String name;
5. public int age;
6. public String info;
7. public Person() {
8. }
9. public Person(String name, int age, String info) {
10. this.name = name;
11. this.age = age;
12. this.info = info;
13. }
14. }

1. package com.scott.provider;
2. import android.content.Context;
3. import android.database.sqlite.SQLiteDatabase;
4. import android.database.sqlite.SQLiteOpenHelper;
5. public class DBHelper extends SQLiteOpenHelper {
6. private static final String DATABASE_NAME = "provider.db";
7. private static final int DATABASE_VERSION = 1;
8. public DBHelper(Context context) {
9. super(context, DATABASE_NAME, null, DATABASE_VERSION);
10. }
11. @Override
12. public void onCreate(SQLiteDatabase db) {
13. String sql = "CREATE TABLE IF NOT EXISTS person" +
14. "(_id INTEGER PRIMARY KEY AUTOINCREMENT, name VARCHAR, age INTEGER, info TEXT)";
15. db.execSQL(sql);
16. }
17. @Override
18. public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
19. db.execSQL("DROP TABLE IF EXISTS person");
20. onCreate(db);
21. }
22. }

最后，要想让这个ContentProvider生效，我们需要在AndroidManifest.xml中声明并为其授权，如下所示：

1. <provider android:name=".PersonProvider"
2. android:authorities="com.scott.provider.PersonProvider"
3. android:multiprocess="true"/>

其中，android:multiprocess代表是否允许多进程操作。另外我们也可以为其声明相应的权限，对应的属性是：android:permission。

完成了ContentProvider后，下面我们来看一下访问者。这一步我们在MainActivity中完成，看下面代码：

1. package com.scott.provider;
2. import java.util.ArrayList;
3. import android.app.Activity;
4. import android.content.ContentResolver;
5. import android.content.ContentUris;
6. import android.content.ContentValues;
7. import android.database.Cursor;
8. import android.database.CursorWrapper;
9. import android.net.Uri;
10. import android.os.Bundle;
11. import android.os.Handler;
12. import android.os.Message;
13. import android.view.View;
14. import android.widget.ListView;
15. import android.widget.SimpleCursorAdapter;
16. public class MainActivity extends Activity {
17. private ContentResolver resolver;
18. private ListView listView;
19. private static final String AUTHORITY = "com.scott.provider.PersonProvider";
20. private static final Uri PERSON_ALL_URI = Uri.parse("content://" + AUTHORITY + "/persons");
21. private Handler handler = new Handler() {
22. public void handleMessage(Message msg) {
23. //update records.
24. requery();
25. };
26. };
27. @Override
28. public void onCreate(Bundle savedInstanceState) {
29. super.onCreate(savedInstanceState);
30. setContentView(R.layout.main);
31. resolver = getContentResolver();
32. listView = (ListView) findViewById(R.id.listView);
33. //为PERSON_ALL_URI注册变化通知
34. getContentResolver().registerContentObserver(PERSON_ALL_URI, true, new PersonObserver(handler));
35. }
36. /**
37. * 初始化
38. * @param view
39. */
40. public void init(View view) {
41. ArrayList<Person> persons = new ArrayList<Person>();
42. Person person1 = new Person("Ella", 22, "lively girl");
43. Person person2 = new Person("Jenny", 22, "beautiful girl");
44. Person person3 = new Person("Jessica", 23, "sexy girl");
45. Person person4 = new Person("Kelly", 23, "hot baby");
46. Person person5 = new Person("Jane", 25, "pretty woman");
47. persons.add(person1);
48. persons.add(person2);
49. persons.add(person3);
50. persons.add(person4);
51. persons.add(person5);
52. for (Person person : persons) {
53. ContentValues values = new ContentValues();
54. values.put("name", person.name);
55. values.put("age", person.age);
56. values.put("info", person.info);
57. resolver.insert(PERSON_ALL_URI, values);
58. }
59. }
60. /**
61. * 查询所有记录
62. * @param view
63. */
64. public void query(View view) {
65. //      Uri personOneUri = ContentUris.withAppendedId(PERSON_ALL_URI, 1);查询_id为1的记录
66. Cursor c = resolver.query(PERSON_ALL_URI, null, null, null, null);
67. CursorWrapper cursorWrapper = new CursorWrapper(c) {
68. @Override
69. public String getString(int columnIndex) {
70. //将简介前加上年龄
71. if (getColumnName(columnIndex).equals("info")) {
72. int age = getInt(getColumnIndex("age"));
73. return age + " years old, " + super.getString(columnIndex);
74. }
75. return super.getString(columnIndex);
76. }
77. };
78. //Cursor须含有"_id"字段
79. SimpleCursorAdapter adapter = new SimpleCursorAdapter(this, android.R.layout.simple_list_item_2,
80. cursorWrapper, new String[]{"name", "info"}, new int[]{android.R.id.text1, android.R.id.text2});
81. listView.setAdapter(adapter);
82. startManagingCursor(cursorWrapper); //管理Cursor
83. }
84. /**
85. * 插入一条记录
86. * @param view
87. */
88. public void insert(View view) {
89. Person person = new Person("Alina", 26, "attractive lady");
90. ContentValues values = new ContentValues();
91. values.put("name", person.name);
92. values.put("age", person.age);
93. values.put("info", person.info);
94. resolver.insert(PERSON_ALL_URI, values);
95. }
96. /**
97. * 更新一条记录
98. * @param view
99. */
100. public void update(View view) {
101. Person person = new Person();
102. person.name = "Jane";
103. person.age = 30;
104. //将指定name的记录age字段更新为30
105. ContentValues values = new ContentValues();
106. values.put("age", person.age);
107. resolver.update(PERSON_ALL_URI, values, "name = ?", new String[]{person.name});
108. //将_id为1的age更新为30
109. //      Uri updateUri = ContentUris.withAppendedId(PERSON_ALL_URI, 1);
110. //      resolver.update(updateUri, values, null, null);
111. }
112. /**
113. * 删除一条记录
114. * @param view
115. */
116. public void delete(View view) {
117. //删除_id为1的记录
118. Uri delUri = ContentUris.withAppendedId(PERSON_ALL_URI, 1);
119. resolver.delete(delUri, null, null);
120. //删除所有记录
121. //      resolver.delete(PERSON_ALL_URI, null, null);
122. }
123. /**
124. * 重新查询
125. */
126. private void requery() {
127. //实际操作中可以查询集合信息后Adapter.notifyDataSetChanged();
128. query(null);
129. }
130. }

我们看到，在上面的代码中，分别对应每一种情况进行测试，相对较为简单。我们主要讲一下registerContentObserver这一环节。

在前面的PersonProvider我们也提到，在数据更改后，会向指定的URI访问者发出通知，以便于更新查询记录。大家注意，仅仅是ContentProvider出力还不够，我们还需要在访问者中注册一个ContentObserver，才能够接收到这个通知。下面我们创建一个PersonObserver：

1. package com.scott.provider;
2. import android.database.ContentObserver;
3. import android.os.Handler;
4. import android.os.Message;
5. import android.util.Log;
6. public class PersonObserver extends ContentObserver {
7. public static final String TAG = "PersonObserver";
8. private Handler handler;
9. public PersonObserver(Handler handler) {
10. super(handler);
11. this.handler = handler;
12. }
13. @Override
14. public void onChange(boolean selfChange) {
15. super.onChange(selfChange);
16. Log.i(TAG, "data changed, try to requery.");
17. //向handler发送消息,更新查询记录
18. Message msg = new Message();
19. handler.sendMessage(msg);
20. }
21. }

这样一来，当ContentProvider发来通知之后，我们就能立即接收到，从而向handler发送一条消息，重新查询记录，使我们能够看到最新的记录信息。

最后，我们要在AndroidManifest.xml中为MainActivity添加MIME类型过滤器，告诉系统MainActivity可以处理的信息类型：

1. <!-- MIME类型 -->
2. <intent-filter>
3. <data android:mimeType="vnd.android.cursor.dir/vnd.scott.person"/>
4. </intent-filter>
5. <intent-filter>
6. <data android:mimeType="vnd.android.cursor.item/vnd.scott.person"/>
7. </intent-filter>

这样就完成了访问者的代码，我们来看一下效果：

鉴于操作类型太多，我在这里就不再展示了，大家可以自己试一试。

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

 

顶

0

踩