ContenteProvider

时间：2015-07-01 19:58:45 阅读：124 评论：0 收藏：0 [点我收藏+]

标签：

以前只写过程序中添加背景音乐，在程序一开始就运行音乐，当程序结束后音乐也随即停止。遇到这样的功能，我们一般是通过系统提供的ContentProvider来实现的，系统对于常用的数据也给开发者提供了方便的获取方式，例如：手机短信获取和手机电话本的获取等。

关于ContentProvider：

一、相关ContentProvider概念解析：

1、ContentProvider简介
在Android官方指出的Android的数据存储方式总共有五种，分别是：Shared Preferences、网络存储、文件存储、外储存储、SQLite。但是我们知道一般这些存储都只是在单独的一个应用程序之中达到一个数据的共享，有时候我们需要操作其他应用程序的一些数据，例如我们需要操作系统里的媒体库、通讯录等，这时我们就可能通过ContentProvider来满足我们的需求了。

2、为什么要选择ContentProvider？

ContentProvider向我们提供了我们在应用程序之前共享数据的一种机制，而我们知道每一个应用程序都是运行在不同的应用程序的，数据和文件在不同应用程序之间达到数据的共享不是没有可能，而是显得比较复杂，而正好Android中的ContentProvider则达到了这一需求，比如有时候我们需要操作手机里的联系人，手机里的多媒体等一些信息，我们都可以用到这个ContentProvider来达到我们所需。

1）、ContentProvider为存储和获取数据提供了统一的接口。ContentProvide对数据进行封装，不用关心数据存储的细节。使用表的形式来组织数据。
2）、使用ContentProvider可以在不同的应用程序之间共享数据。
3）、Android为常见的一些数据提供了默认的ContentProvider（包括音频、视频、图片和通讯录等）。
总的来说使用ContentProvider对外共享数据的好处是统一了数据的访问方式。

3、Uri介绍

为系统的每一个资源给其一个名字，比方说通话记录。
1）、每一个ContentProvider都拥有一个公共的URI，这个URI用于表示这个ContentProvider所提供的数据。
2）、Android所提供的ContentProvider都存放在android.provider包中。将其分为A，B，C，D 4个部分：

技术分享
A：标准前缀，用来说明一个Content Provider控制这些数据，无法改变的；"content://"
B：URI 的标识，用于唯一标识这个ContentProvider，外部调用者可以根据这个标识来找到它。它定义了是哪个Content Provider提供这些数据。对于第三方应用程序，为了保证URI标识的唯一性，它必须是一个完整的、小写的类名。这个标识在元素的 authorities属性中说明：一般是定义该ContentProvider的包.类的名称
C：路径（path），通俗的讲就是你要操作的数据库中表的名字，或者你也可以自己定义，记得在使用的时候保持一致就可以了；"content://com.bing.provider.myprovider/tablename"
D：如果URI中包含表示需要获取的记录的ID；则就返回该id对应的数据，如果没有ID，就表示返回全部； "content://com.bing.provider.myprovider/tablename/#" #表示数据id。

PS：

路径（path）可以用来表示我们要操作的数据，路径的构建应根据业务而定，如下:
1、要操作person表中id为10的记录，可以构建这样的路径:/person/10
2、要操作person表中id为10的记录的name字段， person/10/name
3、要操作person表中的所有记录，可以构建这样的路径:/person
4、要操作xxx表中的记录，可以构建这样的路径:/xxx
5、当然要操作的数据不一定来自数据库，也可以是文件、xml或网络等其他存储方式，如下:
要操作xml文件中person节点下的name节点，可以构建这样的路径：/person/name
6、如果要把一个字符串转换成Uri，可以使用Uri类中的parse()方法，如下：Uri uri = Uri.parse("content://com.bing.provider.personprovider/person")

4、UriMatcher类使用介绍

因为Uri代表了要操作的数据，所以我们经常需要解析Uri，并从Uri中获取数据。Android系统提供了两个用于操作Uri的工具类，分别为UriMatcher和ContentUris 。掌握它们的使用，会便于我们的开发工作。
UriMatcher类用于匹配Uri，它的用法如下：
首先第一步把你需要匹配Uri路径全部给注册上，如下：

 1 //常量UriMatcher.NO_MATCH表示不匹配任何路径的返回码
 2 UriMatcher  sMatcher = new UriMatcher(UriMatcher.NO_MATCH);
 3 //如果match()方法匹配content://com.bing.procvide.personprovider/person路径，返回匹配码为1
 4 sMatcher.addURI("com.bing.procvide.personprovider", "person", 1);//添加需要匹配uri，如果匹配就会返回匹配码
 5 //如果match()方法匹配content://com.bing.provider.personprovider/person/230路径，返回匹配码为2
 6 sMatcher.addURI("com.bing.provider.personprovider", "person/#", 2);//#号为通配符
 7 switch (sMatcher.match(Uri.parse("content://com.ljq.provider.personprovider/person/10"))) { 
 8    case 1
 9      break;
10    case 2
11      break;
12    default://不匹配
13      break;
14 }

注册完需要匹配的Uri后，就可以使用sMatcher.match(uri)方法对输入的Uri进行匹配，如果匹配就返回匹配码，匹配码是调用addURI()方法传入的第三个参数，假设匹配content://com.ljq.provider.personprovider/person路径，返回的匹配码为1

5、ContentUris类使用介绍

ContentUris类用于操作Uri路径后面的ID部分，它有两个比较实用的方法：
withAppendedId(uri, id)用于为路径加上ID部分：

1 Uri uri = Uri.parse("content://com.bing.provider.personprovider/person")
2 Uri resultUri = ContentUris.withAppendedId(uri, 10); 
3 //生成后的Uri为：content://com.bing.provider.personprovider/person/10

parseId(uri)方法用于从路径中获取ID部分

1 Uri uri = Uri.parse("content://com.ljq.provider.personprovider/person/10")
2 long personid = ContentUris.parseId(uri);//获取的结果为:10

6、使用ContentProvider共享数据

1）ContentProvider类主要方法的作用：
public boolean onCreate()：该方法在ContentProvider创建后就会被调用，Android开机后，ContentProvider在其它应用第一次访问它时才会被创建。
public Uri insert(Uri uri, ContentValues values)：该方法用于供外部应用往ContentProvider添加数据。
public int delete(Uri uri, String selection, String[] selectionArgs)：该方法用于供外部应用从ContentProvider删除数据。
public int update(Uri uri, ContentValues values, String selection, String[] selectionArgs)：该方法用于供外部应用更新ContentProvider中的数据。
public Cursor query(Uri uri, String[] projection, String selection, String[] selectionArgs, String sortOrder)：该方法用于供外部应用从ContentProvider中获取数据。
public String getType(Uri uri)：该方法用于返回当前Url所代表数据的MIME类型。

2）如果操作的数据属于集合类型，那么MIME类型字符串应该以vnd.android.cursor.dir/开头，

例如：要得到所有person记录的Uri为content://com.bing.provider.personprovider/person，那么返回的MIME类型字符串应该为："vnd.android.cursor.dir/person"。

3）如果要操作的数据属于非集合类型数据，那么MIME类型字符串应该以vnd.android.cursor.item/开头，

例如：得到id为10的person记录，Uri为content://com.bing.provider.personprovider/person/10，那么返回的MIME类型字符串为："vnd.android.cursor.item/person"。

7、ContentResolver操作ContentProvider中的数据

1）当外部应用需要对ContentProvider中的数据进行添加、删除、修改和查询操作时，可以使用ContentResolver 类来完成，要获取ContentResolver 对象，可以使用Activity提供的getContentResolver()方法。

2）ContentResolver 类提供了与ContentProvider类相同签名的四个方法：
public Uri insert(Uri uri, ContentValues values)：该方法用于往ContentProvider添加数据。
public int delete(Uri uri, String selection, String[] selectionArgs)：该方法用于从ContentProvider删除数据。
public int update(Uri uri, ContentValues values, String selection, String[] selectionArgs)：该方法用于更新ContentProvider中的数据。
public Cursor query(Uri uri, String[] projection, String selection, String[] selectionArgs, String sortOrder)：该方法用于从ContentProvider中获取数据。

这些方法的第一个参数为Uri，代表要操作的ContentProvider和对其中的什么数据进行操作，
其实和contentprovider里面的方法是一样的.他们所对应的数据,最终是会被传到我们在之前程序里面定义的那个contentprovider类的方法,
假设给定的是：Uri.parse("content://com.bing.providers.personprovider/person/10")，那么将会对主机名为com.bing.providers.personprovider的ContentProvider进行操作，操作的数据为person表中id为10的记录。

使用ContentResolver对ContentProvider中的数据进行添加、删除、修改和查询操作：

 1 ContentResolver resolver =  getContentResolver();
 2 Uri uri = Uri.parse("content://com.bing.provider.personprovider/person");
 3 //添加一条记录
 4 ContentValues values = new ContentValues();
 5 values.put("name", "bingxin");
 6 values.put("age", 25);
 7 resolver.insert(uri, values);  
 8 //获取person表中所有记录
 9 Cursor cursor = resolver.query(uri, null, null, null, "personid desc");
10 while(cursor.moveToNext()){
11    Log.i("ContentTest", "personid="+ cursor.getInt(0)+ ",name="+ cursor.getString(1));
12 }
13 //把id为1的记录的name字段值更改新为zhangsan
14 ContentValues updateValues = new ContentValues();
15 updateValues.put("name", "zhangsan");
16 Uri updateIdUri = ContentUris.withAppendedId(uri, 2);
17 resolver.update(updateIdUri, updateValues, null, null);
18 //删除id为2的记录
19 Uri deleteIdUri = ContentUris.withAppendedId(uri, 2);
20 resolver.delete(deleteIdUri, null, null);

8、监听ContentProvider中数据的变化

如果ContentProvider的访问者需要知道ContentProvider中的数据发生变化，可以在ContentProvider发生数据变化时调用getContentResolver().notifyChange(uri, null)来通知注册在此URI上的访问者，例子如下：

1 public class PersonContentProvider extends ContentProvider {
2    public Uri insert(Uri uri, ContentValues values) {
3       db.insert("person", "personid", values);
4       getContext().getContentResolver().notifyChange(uri, null);
5    }
6 }

如果ContentProvider的访问者需要得到数据变化通知，必须使用ContentObserver对数据（数据采用uri描述）进行监听，当监听到数据变化通知时，系统就会调用ContentObserver的onChange()方法：

 1 getContentResolver().registerContentObserver(Uri.parse("content://com.ljq.providers.personprovider/person"),
 2        true, new PersonObserver(new Handler()));
 3 public class PersonObserver extends ContentObserver{
 4    public PersonObserver(Handler handler) {
 5       super(handler);
 6    }
 7    public void onChange(boolean selfChange) {
 8       //此处可以进行相应的业务处理
 9    }
10 }

二、ContentProvider的实现过程

1、定义一个CONTENT_URI常量，提供了访问ContentProvider的标识符。

 1 public static final Uri CONTENT_URI = Uri.parse("content://com.example.codelab.transportationprovider"); 

其中：content是协议
Com.exmaple.codelab.transportationprovider是类名，包含完整的包名。
Uri.parse将一个字符串转换成Uri类型。
如果Provider包含子表，同样定义包含字表的CONTENT_URI。
content://com.example.codelab.transportationprovider/train
content://com.example.codelab.transportationprovider/air/domestic
content://com.example.codelab.transportationprovider/air/international
然后定义列，确保里面包含一个_id的列。
2、定义一个类，继承ContentProvider。

1 public class FirstContentProvider extends ContentProvider

先介绍一下ContentProvider用到的UriMatcher。UriMatcher的一个重要的函数是match(Uri uri)。这个函数可以匹配Uri，根据传入的不同Uri返回不同的自定义整形值，以表明Uri访问的不同资源的类型。
例如：

1 public static final UriMatcher uriMatcher; 
2       static { 
3                      uriMatcher = new UriMatcher(UriMatcher.NO_MATCH); 
4                      uriMatcher.addURI(Book.AUTHORITY, "item", Book.ITEM); 
5                      uriMatcher.addURI(Book.AUTHORITY, "item/#", Book.ITEM_ID); 
6               }

这里UriMatcher类型的静态字段是用来匹配传入到ContentProvider中的Uri的类。其构造方法传入的匹配码是使用match()方法匹配根路径时返回的值，这个匹配码可以为一个大于零的数表示匹配根路径或传入-1，即常量UriMatcher.NO_MATCH表示不匹配根路径。

addURI()方法是用来增加其他URI匹配路径的，

第一个参数传入标识ContentProvider的AUTHORITY字符串。

第二个参数传入需要匹配的路径，这里的#号为通配符，代表匹配任意数字，另外还可以用*来匹配任意文本。

第三个参数必须传入一个大于零的匹配码，用于match()方法对相匹配的URI返回相对应的匹配码。例如：sMatcher.addURI(“com.test.provider.personprovider”, “person”, 1);如果match()方法匹配content://com.test.provider.personprovider/person路径，返回匹配码为1。

3、实现query,insert,update,delete,getType和onCreate方法。
4、在AndroidManifest.xml当中进行声明。

1 android:name是完成ContentProvider类的全称
2              android:authorities是和FirstProvidermetaData中的常量AUTHORITY的值一样，否则会报错
3          -->
4         <provider android:name="com.bj.FirstContentProvider" 
     android:authorities="com.bj.firstcontentprovider"></provider>

三、实例

1、常量类

 1 /**
 2  * 提供ContentProvider对外的各种常量，当外部数据需要访问的时候，就可以参考这些常量操作数据。
 3  * @author HB
 4  *
 5  */
 6 public class ContentData {
 7     public static final String AUTHORITY = "hb.android.contentProvider";
 8     public static final String DATABASE_NAME = "teacher.db";
 9     //创建 数据库的时候，都必须加上版本信息；并且必须大于4
10     public static final int DATABASE_VERSION = 4;
11     public static final String USERS_TABLE_NAME = "teacher";
12      
13     public static final class UserTableData implements BaseColumns {
14         public static final String TABLE_NAME = "teacher";
15         //Uri，外部程序需要访问就是通过这个Uri访问的，这个Uri必须的唯一的。
16         public static final Uri CONTENT_URI = Uri.parse("content://"+ AUTHORITY + "/teacher");
17         // 数据集的MIME类型字符串则应该以vnd.android.cursor.dir/开头  
18         public static final String CONTENT_TYPE = "vnd.android.cursor.dir/hb.android.teachers";
19         // 单一数据的MIME类型字符串应该以vnd.android.cursor.item/开头  
20         public static final String CONTENT_TYPE_ITME = "vnd.android.cursor.item/hb.android.teacher";
21         /* 自定义匹配码 */ 
22         public static final int TEACHERS = 1;  
23         /* 自定义匹配码 */ 
24         public static final int TEACHER = 2;  
25          
26         public static final String TITLE = "title";
27         public static final String NAME = "name";
28         public static final String DATE_ADDED = "date_added";
29         public static final String SEX = "SEX";
30         public static final String DEFAULT_SORT_ORDER = "_id desc";
31          
32         public static final UriMatcher uriMatcher;  
33         static {  
34             // 常量UriMatcher.NO_MATCH表示不匹配任何路径的返回码  
35             uriMatcher = new UriMatcher(UriMatcher.NO_MATCH);  
36             // 如果match()方法匹配content://hb.android.teacherProvider/teachern路径,返回匹配码为TEACHERS  
37             uriMatcher.addURI(ContentData.AUTHORITY, "teacher", TEACHERS);  
38             // 如果match()方法匹配content://hb.android.teacherProvider/teacher/230,路径，返回匹配码为TEACHER  
39             uriMatcher.addURI(ContentData.AUTHORITY, "teacher/#", TEACHER);  
40         }
41     }
42 }

在创建UriMatcher对象uriMatcher时，我们传给构造函数的参数为UriMatcher.NO_MATCH，它表示当uriMatcher不能匹配指定的URI时，就返回代码UriMatcher.NO_MATCH。接下来增加了三个匹配规则，分别是uriMatcher = new UriMatcher(UriMatcher.NO_MATCH); uriMatcher.addURI(ContentData.AUTHORITY, "teacher", TEACHERS); uriMatcher.addURI(ContentData.AUTHORITY, "teacher/#", TEACHER);

它们的匹配码分别是teacher.ITEM、teacher.ITEM_ID和teacher.ITEM_POS，其中，符号#表示匹配任何数字。

2、SQLite操作类DBOpenHelper

 1 /**
 2  * 这个类继承SQLiteOpenHelper抽象类，用于创建数据库和表。创建数据库是调用它的父类构造方法创建。
 3  * @author HB
 4  */
 5 public class DBOpenHelper extends SQLiteOpenHelper {
 6  
 7     // 在SQLiteOepnHelper的子类当中，必须有该构造函数，用来创建一个数据库；
 8     public DBOpenHelper(Context context, String name, CursorFactory factory,
 9             int version) {
10         // 必须通过super调用父类当中的构造函数
11         super(context, name, factory, version);
12         // TODO Auto-generated constructor stub
13     }
14  
15     // public DBOpenHelper(Context context, String name) {
16     // this(context, name, VERSION);
17     // }
18  
19     public DBOpenHelper(Context context, String name, int version) {
20         this(context, name, null, version);
21     }
22      
23     /**
24      * 只有当数据库执行创建 的时候，才会执行这个方法。如果更改表名，也不会创建，只有当创建数据库的时候，才会创建改表名之后 的数据表
25      */
26     @Override
27     public void onCreate(SQLiteDatabase db) {
28 System.out.println("create table");
29         db.execSQL("create table " + ContentData.UserTableData.TABLE_NAME
30                 + "(" + ContentData.UserTableData._ID
31                 + " INTEGER PRIMARY KEY autoincrement,"
32                 + ContentData.UserTableData.NAME + " varchar(20),"
33                 + ContentData.UserTableData.TITLE + " varchar(20),"
34                 + ContentData.UserTableData.DATE_ADDED + " long,"
35                 + ContentData.UserTableData.SEX + " boolean)" + ";");
36     }
37  
38     @Override
39     public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
40  
41     }
42  
43 }

3、内容提供者代码

  1 /**
  2  * 这个类给外部程序提供访问内部数据的一个接口
  3  * @author HB
  4  *
  5  */
  6 public class TeacherContentProvider extends ContentProvider {
  7      
  8     private DBOpenHelper dbOpenHelper = null;  
  9     // UriMatcher类用来匹配Uri，使用match()方法匹配路径时返回匹配码  
 10        
 11        
 12     /**
 13      * 是一个回调函数，在ContentProvider创建的时候，就会运行,第二个参数为指定数据库名称，如果不指定，就会找不到数据库；
 14      * 如果数据库存在的情况下是不会再创建一个数据库的。（当然首次调用 在这里也不会生成数据库必须调用SQLiteDatabase的 getWritableDatabase,getReadableDatabase两个方法中的一个才会创建数据库）
 15      */
 16     @Override 
 17     public boolean onCreate() { 
 18         //这里会调用 DBOpenHelper的构造函数创建一个数据库；
 19         dbOpenHelper = new DBOpenHelper(this.getContext(), ContentData.DATABASE_NAME, ContentData.DATABASE_VERSION);
 20         return true;  
 21     }  
 22     /**
 23      * 当执行这个方法的时候，如果没有数据库，他会创建，同时也会创建表，但是如果没有表，下面在执行insert的时候就会出错
 24      * 这里的插入数据也完全可以用sql语句书写，然后调用 db.execSQL(sql)执行。
 25      */
 26     @Override 
 27     public Uri insert(Uri uri, ContentValues values){  
 28         //获得一个可写的数据库引用，如果数据库不存在，则根据onCreate的方法里创建；
 29         SQLiteDatabase db = dbOpenHelper.getWritableDatabase();  
 30         long id = 0;  
 31          
 32         switch (uriMatcher.match(uri)) {  
 33         case TEACHERS:  
 34             id = db.insert("teacher", null, values);    // 返回的是记录的行号，主键为int，实际上就是主键值  
 35             return ContentUris.withAppendedId(uri, id);  
 36         case TEACHER:  
 37             id = db.insert("teacher", null, values); 
 38             String path = uri.toString();  
 39             return Uri.parse(path.substring(0, path.lastIndexOf("/"))+id); // 替换掉id  
 40         default:  
 41             throw new IllegalArgumentException("Unknown URI " + uri);  
 42         }
 43     }  
 44        
 45     @Override 
 46     public int delete(Uri uri, String selection, String[] selectionArgs) {  
 47         SQLiteDatabase db = dbOpenHelper.getWritableDatabase();  
 48         int count = 0;  
 49         switch (uriMatcher.match(uri)) {  
 50         case TEACHERS:  
 51             count = db.delete("teacher", selection, selectionArgs);  
 52             break;  
 53         case TEACHER:  
 54             // 下面的方法用于从URI中解析出id，对这样的路径content://hb.android.teacherProvider/teacher/10  
 55             // 进行解析，返回值为10  
 56             long personid = ContentUris.parseId(uri);  
 57             String where = "_ID=" + personid;   // 删除指定id的记录  
 58             where += !TextUtils.isEmpty(selection) ? " and (" + selection + ")" : "";   // 把其它条件附加上  
 59             count = db.delete("teacher", where, selectionArgs);  
 60             break;  
 61         default:  
 62             throw new IllegalArgumentException("Unknown URI " + uri);  
 63         }  
 64         db.close();  
 65         return count;  
 66     }  
 67    
 68     @Override 
 69     public int update(Uri uri, ContentValues values, String selection,  
 70             String[] selectionArgs) {  
 71         SQLiteDatabase db = dbOpenHelper.getWritableDatabase();  
 72         int count = 0;  
 73         switch (uriMatcher.match(uri)) {  
 74         case TEACHERS:  
 75             count = db.update("teacher", values, selection, selectionArgs);  
 76             break;  
 77         case TEACHER:  
 78             // 下面的方法用于从URI中解析出id，对这样的路径content://com.ljq.provider.personprovider/person/10  
 79             // 进行解析，返回值为10  
 80             long personid = ContentUris.parseId(uri);  
 81             String where = "_ID=" + personid;// 获取指定id的记录  
 82             where += !TextUtils.isEmpty(selection) ? " and (" + selection + ")" : "";// 把其它条件附加上  
 83             count = db.update("teacher", values, where, selectionArgs);  
 84             break;  
 85         default:  
 86             throw new IllegalArgumentException("Unknown URI " + uri);  
 87         }  
 88         db.close();  
 89         return count;  
 90     }  
 91        
 92     @Override 
 93     public String getType(Uri uri) {  
 94         switch (uriMatcher.match(uri)) {  
 95         case TEACHERS:  
 96             return CONTENT_TYPE;  
 97         case TEACHER:  
 98             return CONTENT_TYPE_ITME;  
 99         default:  
100             throw new IllegalArgumentException("Unknown URI " + uri);  
101         }  
102     }  
103    
104     @Override 
105     public Cursor query(Uri uri, String[] projection, String selection,  
106             String[] selectionArgs, String sortOrder) {  
107         SQLiteDatabase db = dbOpenHelper.getReadableDatabase();  
108         switch (uriMatcher.match(uri)) {  
109         case TEACHERS:  
110             return db.query("teacher", projection, selection, selectionArgs, null, null, sortOrder);  
111         case TEACHER:  
112             // 进行解析，返回值为10  
113             long personid = ContentUris.parseId(uri);  
114             String where = "_ID=" + personid;// 获取指定id的记录  
115             where += !TextUtils.isEmpty(selection) ? " and (" + selection + ")" : "";// 把其它条件附加上  
116             return db.query("teacher", projection, where, selectionArgs, null, null, sortOrder);  
117         default:  
118             throw new IllegalArgumentException("Unknown URI " + uri);  
119         }  
120     }  
121 }

1、这里我们在ArticlesProvider类的内部中定义了一个DBHelper类，它继承于SQLiteOpenHelper类，它用是用辅助我们操作数据库的。使用这个DBHelper类来辅助操作数据库的好处是只有当我们第一次对数据库时行操作时，系统才会执行打开数据库文件的操作。拿我们这个例子来说，只有第三方应用程序第一次调用query、insert、update或者delete函数来操作数据库时，我们才会真正去打开相应的数据库文件。这样在onCreate函数里，就不用执行打开数据库的操作，因为这是一个耗时的操作，而在onCreate函数中，要避免执行这些耗时的操作。

2、我们在实现自己的Content Provider时，必须继承于ContentProvider类，并且实现以下六个函数：

-- onCreate()，用来执行一些初始化的工作。

-- query(Uri, String[], String, String[], String)，用来返回数据给调用者。

-- insert(Uri, ContentValues)，用来插入新的数据。

-- update(Uri, ContentValues, String, String[])，用来更新已有的数据。

-- delete(Uri, String, String[])，用来删除数据。

-- getType(Uri)，用来返回数据的MIME类型。

4、manifest

 1 <!--?xml version="1.0" encoding="utf-8"?-->
 2 <manifest xmlns:android="http://schemas.android.com/apk/res/android" package="hb.android.contentProvider" android:versioncode="1" android:versionname="1.0">
 3     <uses-sdk android:minsdkversion="8">
 4      
 5          
 6             <intent-filter>
 7                  
 8                 <category android:name="android.intent.category.LAUNCHER">
 9             </category></action></intent-filter>
10         </activity>
11 <provider android:name=".TeacherContentProvider" android:authorities="hb.android.contentProvider" android:multiprocess="false">
12     </provider></application>
13 </uses-sdk></manifest>

在配置Content Provider的时候，最重要的就是要指定它的authorities属性了，只有配置了这个属性，第三方应用程序才能通过它来找到这个Content Provider。这要需要注意的，这里配置的authorities属性的值是和我们前面在Articles.java文件中定义的AUTHORITY常量的值是一致的。另外一个属性multiprocess是一个布尔值，它表示这个Content Provider是否可以在每个客户进程中创建一个实例，这样做的目的是为了减少进程间通信的开销。这里我们为了减少不必要的内存开销，把属性multiprocess的值设置为false，使得系统只能有一个Content Provider实例存在，它运行在自己的进程中。在这个配置文件里面，我们还可以设置这个Content Provider的访问权限，这里我们为了简单起见，就不设置权限了。
6、布局文件

1 <!--?xml version="1.0" encoding="utf-8"?-->
2 <linearlayout xmlns:android="http://schemas.android.com/apk/res/android" android:orientation="vertical" android:layout_width="fill_parent" android:layout_height="fill_parent">
3 <button android:id="@+id/insert" android:text="@string/insert" android:layout_width="fill_parent" android:layout_height="wrap_content">
4 </button><button android:id="@+id/query" android:text="@string/query" android:layout_width="fill_parent" android:layout_height="wrap_content">
5 </button><button android:id="@+id/querys" android:text="@string/querys" android:layout_width="fill_parent" android:layout_height="wrap_content">
6 </button><button android:id="@+id/update" android:text="@string/update" android:layout_width="fill_parent" android:layout_height="wrap_content">
7 </button><button android:id="@+id/delete" android:text="@string/delete" android:layout_width="fill_parent" android:layout_height="wrap_content">
8  
9 </button></linearlayout>

7、activity

  1 package hb.android.contentProvider;
  2  
  3 import java.util.Date;
  4  
  5 import android.app.Activity;
  6 import android.content.ContentResolver;
  7 import android.content.ContentValues;
  8 import android.database.Cursor;
  9 import android.net.Uri;
 10 import android.os.Bundle;
 11 import android.view.View;
 12 import android.view.View.OnClickListener;
 13 import android.widget.Button;
 14  
 15 /**
 16  * 这个类用来测试ContentProvider是否可用。通过 给定的uri访问，数据库；
 17  * 
 18  * @author HB
 19  * 
 20  */
 21 public class TeacherActivity extends Activity {
 22     Button insert;
 23     Button query;
 24     Button update;
 25     Button delete;
 26     Button querys;
 27     Uri uri = Uri.parse("content://hb.android.contentProvider/teacher");
 28  
 29     /** Called when the activity is first created. */
 30     @Override
 31     public void onCreate(Bundle savedInstanceState) {
 32         super.onCreate(savedInstanceState);
 33         setContentView(R.layout.main);
 34  
 35         insert = (Button) findViewById(R.id.insert);
 36         query = (Button) findViewById(R.id.query);
 37         update = (Button) findViewById(R.id.update);
 38         delete = (Button) findViewById(R.id.delete);
 39         querys = (Button) findViewById(R.id.querys);
 40         // 绑定监听器的两种方法一；
 41         insert.setOnClickListener(new InsertListener());
 42         query.setOnClickListener(new QueryListener());
 43         // 方法二
 44         update.setOnClickListener(new OnClickListener() {
 45             public void onClick(View v) {
 46                 // TODO Auto-generated method stub
 47                 ContentResolver cr = getContentResolver();
 48                 ContentValues cv = new ContentValues();
 49                 cv.put("name", "huangbiao");
 50                 cv.put("date_added", (new Date()).toString());
 51                 int uri2 = cr.update(uri, cv, "_ID=?", new String[]{"3"});
 52 System.out.println("updated"+":"+uri2);
 53             }
 54         });
 55  
 56         delete.setOnClickListener(new OnClickListener() {
 57              
 58             public void onClick(View v) {
 59                 ContentResolver cr = getContentResolver();
 60                 cr.delete(uri, "_ID=?", new String[]{"2"});
 61             }
 62         });
 63  
 64         querys.setOnClickListener(new OnClickListener() {
 65  
 66             public void onClick(View v) {
 67                 // TODO Auto-generated method stub
 68                 ContentResolver cr = getContentResolver();
 69                 // 查找id为1的数据
 70                 Cursor c = cr.query(uri, null, null,null, null);
 71                 System.out.println(c.getCount());
 72                 c.close();
 73             }
 74         });
 75     }
 76  
 77     class InsertListener implements OnClickListener {
 78  
 79         public void onClick(View v) {
 80             // TODO Auto-generated method stub
 81             ContentResolver cr = getContentResolver();
 82  
 83             ContentValues cv = new ContentValues();
 84             cv.put("title", "jiaoshou");
 85             cv.put("name", "jiaoshi");
 86             cv.put("sex", true);
 87             Uri uri2 = cr.insert(uri, cv);
 88             System.out.println(uri2.toString());
 89         }
 90  
 91     }
 92  
 93     class QueryListener implements OnClickListener {
 94  
 95         public void onClick(View v) {
 96             // TODO Auto-generated method stub
 97             ContentResolver cr = getContentResolver();
 98             // 查找id为1的数据
 99             Cursor c = cr.query(uri, null, "_ID=?", new String[] { "1" }, null);
100             //这里必须要调用 c.moveToFirst将游标移动到第一条数据,不然会出现index -1 requested , with a size of 1错误；cr.query返回的是一个结果集。
101             if (c.moveToFirst() == false) {
102                 // 为空的Cursor
103                 return;
104             }
105             int name = c.getColumnIndex("name");
106             System.out.println(c.getString(name));
107             c.close();
108         }
109     }
110 }