Android之ContentProvider分析
ContentProvider作为android的四大组件与其他三大组件（Activity，BroadcastReciver，Service）较其他三大组件确实有一些地方不一样。这里我们先可不必详说！我们完全可以将contentprovider理解为一个数据库，作用就是完成应用程序之间的数据的共享（比如联系人，短信……），这里就需要解决三个问题：
1、 怎么将自己需要暴露出来的数据暴露出来
2、 怎么操作（增，查，改，删）自己暴露出来的数据
3、 怎么监听暴露出来的数据的变化
本文的文章结构：
1、 简单的解析contentprovider的概念
2、 介绍contentprovider如何共享数据
3、 介绍contentprovider如何操作共享数据
4、 监听contentprovider共享出来的数据的变化
5、 实现一个ContentProvider共享数据的实例
一、简单的解析contentprovider的概念
在Android官方指出的Android的数据存储方式总共有五种，分别是：Shared Preferences、网络存储、文件存储、外储存储、SQLite。但是我个人理解的数据存储就三种：SharedPreferences，文件存储，SQLite。这些存储基本上都是在单独的一个应用程序之中达到的数据共享。为了实现应用程序之间的数据共享，比如操作系统中的联系人，照片库等，这时我们就可能通过ContentProvider来满足我们的需求了，而Contentprovider对外共享数据的一个很大的好处是它提供了统一了数据访问方式。其次一旦某一个应用通过Contentprovider暴露了自己的数据操作的接口，那么不管该应用和程序是否启动，其他应用都可以通过该接口来操作该应用程序的内部数据（增删改查）。
ContentProvider组件实现其功能主要是依靠三个API类：
1， ContentResolver （用于操作ContentProvider提供的数据）
2， ContentProvider （是所有ContentProvider组件的基类）
3， ContentObserver （用于监听ContentProvider的共享数据的改变）
二、介绍contentprovider如何共享数据
1、使用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"。
import android.content.ContentProvider;
import android.content.ContentUris;
import android.content.ContentValues;
import android.content.UriMatcher;
import android.database.Cursor;
import android.database.sqlite.SQLiteDatabase;
import android.net.Uri;
/**
* Description:
* <br/>网站: <a href="http://www.crazyit.org">疯狂Java联盟</a>
* <br/>Copyright (C), 2001-2014, Yeeku.H.Lee
* <br/>This program is protected bycopyright laws.
* <br/>Program Name:
* <br/>Date:
* @author Yeeku.H.Lee kongyeeku@163.com
* @version 1.0
*/
public classDictProvider extends ContentProvider
{
private static UriMatcher matcher
=newUriMatcher(UriMatcher.NO_MATCH);
private static final int WORDS = 1;
private static final int WORD = 2;
private MyDatabaseHelper dbOpenHelper;
static
{
// 为UriMatcher注册两个Uri
matcher.addURI(Words.AUTHORITY, "words",WORDS);
matcher.addURI(Words.AUTHORITY, "word/#",WORD);
}
// 第一次调用该DictProvider时，系统先创建DictProvider对象，并回调该方法
@Override
public boolean onCreate()
{
dbOpenHelper = new MyDatabaseHelper(this.getContext(),
"myDict.db3",1);
return true;
}
// 返回指定Uri参数对应的数据的MIME类型
@Override
public String getType(Uri uri)
{
switch (matcher.match(uri))
{
// 如果操作的数据是多项记录
case WORDS:
return "vnd.android.cursor.dir/org.crazyit.dict";
// 如果操作的数据是单项记录
case WORD:
return "vnd.android.cursor.item/org.crazyit.dict";
default:
throw newIllegalArgumentException("未知Uri:" + uri);
}
}
// 查询数据的方法
@Override
public Cursor query(Uri uri,String[] projection, String where,
String[]whereArgs, String sortOrder)
{
SQLiteDatabasedb = dbOpenHelper.getReadableDatabase();
switch (matcher.match(uri))
{
// 如果Uri参数代表操作全部数据项
case WORDS:
// 执行查询
return db.query("dict", projection,where,
whereArgs,null,null,sortOrder);
// 如果Uri参数代表操作指定数据项
case WORD:
// 解析出想查询的记录ID
long id = ContentUris.parseId(uri);
StringwhereClause = Words.Word._ID + "="+ id;
// 如果原来的where子句存在，拼接where子句
if (where != null && !"".equals(where))
{
whereClause= whereClause + " and " + where;
}
return db.query("dict", projection,whereClause, whereArgs,
null, null, sortOrder);
default:
throw newIllegalArgumentException("未知Uri:" + uri);
}
}
// 插入数据方法
@Override
public Uri insert(Uri uri,ContentValues values)
{
// 获得数据库实例
SQLiteDatabasedb = dbOpenHelper.getReadableDatabase();
switch (matcher.match(uri))
{
// 如果Uri参数代表操作全部数据项
case WORDS:
// 插入数据，返回插入记录的ID
long rowId = db.insert("dict", Words.Word._ID, values);
// 如果插入成功返回uri
if (rowId > 0)
{
// 在已有的 Uri的后面追加ID
UriwordUri = ContentUris.withAppendedId(uri, rowId);
// 通知数据已经改变
getContext().getContentResolver().notifyChange(wordUri,null);
return wordUri;
}
break;
default :
throw newIllegalArgumentException("未知Uri:" + uri);
}
return null;
}
// 修改数据的方法
@Override
public int update(Uri uri,ContentValues values, String where,
String[]whereArgs)
{
SQLiteDatabasedb = dbOpenHelper.getWritableDatabase();
// 记录所修改的记录数
int num = 0;
switch (matcher.match(uri))
{
// 如果Uri参数代表操作全部数据项
case WORDS:
num= db.update("dict",values, where, whereArgs);
break;
// 如果Uri参数代表操作指定数据项
case WORD:
// 解析出想修改的记录ID
long id = ContentUris.parseId(uri);
StringwhereClause = Words.Word._ID + "="+ id;
// 如果原来的where子句存在，拼接where子句
if (where != null &&!where.equals(""))
{
whereClause= whereClause + " and " + where;
}
num= db.update("dict",values, whereClause, whereArgs);
break;
default:
throw newIllegalArgumentException("未知Uri:" + uri);
}
// 通知数据已经改变
getContext().getContentResolver().notifyChange(uri,null);
return num;
}
// 删除数据的方法
@Override
public int delete(Uri uri, Stringwhere, String[] whereArgs)
{
SQLiteDatabasedb = dbOpenHelper.getReadableDatabase();
// 记录所删除的记录数
int num = 0;
// 对于uri进行匹配。
switch (matcher.match(uri))
{
// 如果Uri参数代表操作全部数据项
case WORDS:
num= db.delete("dict",where, whereArgs);
break;
// 如果Uri参数代表操作指定数据项
case WORD:
// 解析出所需要删除的记录ID
long id = ContentUris.parseId(uri);
StringwhereClause = Words.Word._ID + "="+ id;
// 如果原来的where子句存在，拼接where子句
if (where != null &&!where.equals(""))
{
whereClause= whereClause + " and " + where;
}
num= db.delete("dict",whereClause, whereArgs);
break;
default:
throw newIllegalArgumentException("未知Uri:" + uri);
}
// 通知数据已经改变
getContext().getContentResolver().notifyChange(uri,null);
return num;
}
}2、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：ID或者全部：如果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")
3、UriMatcher类使用介绍
因为Uri代表了要操作的数据，所以我们经常需要解析Uri，并从Uri中获取数据。Android系统提供了两个用于操作Uri的工具类，分别为UriMatcher和ContentUris 。掌握它们的使用，会便于我们的开发工作。
UriMatcher类用于匹配Uri，它的用法如下：
首先第一步把你需要匹配Uri路径全部给注册上，如下：
//常量UriMatcher.NO_MATCH表示不匹配任何路径的返回码
UriMatcher sMatcher = new UriMatcher(UriMatcher.NO_MATCH);
//如果match()方法匹配content://com.bing.procvide.personprovider/person路径，返回匹配码为1
sMatcher.addURI("com.bing.procvide.personprovider","person", 1);//添加需要匹配uri，如果匹配就会返回匹配码
//如果match()方法匹配content://com.bing.provider.personprovider/person/230路径，返回匹配码为2
sMatcher.addURI("com.bing.provider.personprovider","person/#", 2);//#号为通配符
switch (sMatcher.match(Uri.parse("content://com.ljq.provider.personprovider/person/10"))){
case 1
break;
case 2
break;
default://不匹配
break;
}注册完需要匹配的Uri后，就可以使用sMatcher.match(uri)方法对输入的Uri进行匹配，如果匹配就返回匹配码，匹配码是调用addURI()方法传入的第三个参数，假设匹配content://com.ljq.provider.personprovider/person路径，返回的匹配码为1
4、ContentUris类使用介绍
ContentUris类用于操作Uri路径后面的ID部分，它有两个比较实用的方法：
withAppendedId(uri, id)用于为路径加上ID部分：
Uri uri = Uri.parse("content://com.bing.provider.personprovider/person")
Uri resultUri =ContentUris.withAppendedId(uri, 10);
//生成后的Uri为：content://com.bing.provider.personprovider/person/10Uri uri = Uri.parse("content://com.ljq.provider.personprovider/person/10")
long personid = ContentUris.parseId(uri);//获取的结果为:10三、介绍contentResolver如何操作数据
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中的数据进行添加、删除、修改和查询操作：
ContentResolver resolver = getContentResolver();
Uri uri = Uri.parse("content://com.bing.provider.personprovider/person");
//添加一条记录
ContentValues values = new ContentValues();
values.put("name","bingxin");
values.put("age", 25);
resolver.insert(uri, values);
//获取person表中所有记录
Cursor cursor = resolver.query(uri, null,null, null, "personid desc");
while(cursor.moveToNext()){
Log.i("ContentTest","personid="+ cursor.getInt(0)+ ",name="+cursor.getString(1));
}
//把id为1的记录的name字段值更改新为zhangsan
ContentValues updateValues = newContentValues();
updateValues.put("name","zhangsan");
Uri updateIdUri =ContentUris.withAppendedId(uri, 2);
resolver.update(updateIdUri, updateValues,null, null);
//删除id为2的记录
Uri deleteIdUri =ContentUris.withAppendedId(uri, 2);
resolver.delete(deleteIdUri, null, null);四、监听contentprovider共享出来的数据的变化
监听ContentProvider中数据的变化
如果ContentProvider的访问者需要知道ContentProvider中的数据发生变化，可以在ContentProvider发生数据变化时调用getContentResolver().notifyChange(uri, null)来通知注册在此URI上的访问者，例子如下：
public class PersonContentProvider extendsContentProvider {
public Uri insert(Uriuri, ContentValues values) {
db.insert("person","personid", values);
getContext().getContentResolver().notifyChange(uri,null);
}
}public class MonitorSms extends Activity
{
@Override
public void onCreate(Bundle savedInstanceState)
{
super.onCreate(savedInstanceState);
setContentView(R.layout.main);
// 为content://sms的数据改变注册监听器
getContentResolver().registerContentObserver(
Uri.parse("content://sms"), true,
new SmsObserver(new Handler()));
}
// 提供自定义的ContentObserver监听器类
private final class SmsObserver extends ContentObserver
{
public SmsObserver(Handler handler)
{
super(handler);
}
public void onChange(boolean selfChange)
{
// 查询发送箱中的短信(处于正在发送状态的短信放在发送箱)
Cursor cursor = getContentResolver().query(
Uri.parse("content://sms/outbox")
, null, null, null, null);
// 遍历查询得到的结果集，即可获取用户正在发送的短信
while (cursor.moveToNext())
{
StringBuilder sb = new StringBuilder();
// 获取短信的发送地址
sb.append("address=").append(cursor
.getString(cursor.getColumnIndex("address")));
// 获取短信的标题
sb.append(";subject=").append(cursor
.getString(cursor.getColumnIndex("subject")));
// 获取短信的内容
sb.append(";body=").append(cursor
.getString(cursor.getColumnIndex("body")));
// 获取短信的发送时间
sb.append(";time=").append(cursor
.getLong(cursor.getColumnIndex("date")));
System.out.println("Has Sent SMS::" + sb.toString());
}
}
}
}五、实现一个ContentProvider共享数据的实例
1、 定义一个CONTENT_URI常量，提供了访问ContentProvider的标识符。
public static final Uri CONTENT_URI
=Uri.parse("content://com.example.codelab.transportationprovider");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。
public class FirstContentProvider extendsContentProvider
先介绍一下ContentProvider用到的UriMatcher。UriMatcher的一个重要的函数是match(Uri uri)。这个函数可以匹配Uri，根据传入的不同Uri返回不同的自定义整形值，以表明Uri访问的不同资源的类型。例如：
public static final UriMatcher uriMatcher;
static{
uriMatcher= new UriMatcher(UriMatcher.NO_MATCH);
uriMatcher.addURI(Book.AUTHORITY,"item", Book.ITEM);
uriMatcher.addURI(Book.AUTHORITY,"item/#", Book.ITEM_ID);
}addURI()方法是用来增加其他URI匹配路径的，
第一个参数传入标识ContentProvider的AUTHORITY字符串。
第二个参数传入需要匹配的路径，这里的#号为通配符，代表匹配任意数字，另外还可以用*来匹配任意文本。
第三个参数必须传入一个大于零的匹配码，用于match()方法对相匹配的URI返回相对应的匹配码。例如：sMatcher.addURI(“com.test.provider.personprovider”, “person”, 1);如果match()方法匹配content://com.test.provider.personprovider/person路径，返回匹配码为1。
2、 实现query,insert,update,delete,getType和onCreate方法。
4、在AndroidManifest.xml当中进行声明。
<!-- android:name是完成ContentProvider类的全称
android:authorities是和FirstProvidermetaData中的常量AUTHORITY的值一样，否则会报错
-->
<providerandroid:name="com.bj.FirstContentProvider"android:authorities="com.bj.firstcontentprovider"></provider>/**
* 提供ContentProvider对外的各种常量，当外部数据需要访问的时候，就可以参考这些常量操作数据。
* @author HB
*
*/
public class ContentData {
public static finalString AUTHORITY = "hb.android.contentProvider";
public static finalString DATABASE_NAME = "teacher.db";
//创建 数据库的时候，都必须加上版本信息；并且必须大于4
public static finalint DATABASE_VERSION = 4;
public static finalString USERS_TABLE_NAME = "teacher";
public static finalclass UserTableData implements BaseColumns {
publicstatic final String TABLE_NAME = "teacher";
//Uri，外部程序需要访问就是通过这个Uri访问的，这个Uri必须的唯一的。
publicstatic final Uri CONTENT_URI = Uri.parse("content://"+AUTHORITY + "/teacher");
//数据集的MIME类型字符串则应该以vnd.android.cursor.dir/开头
publicstatic final String CONTENT_TYPE ="vnd.android.cursor.dir/hb.android.teachers";
//单一数据的MIME类型字符串应该以vnd.android.cursor.item/开头
publicstatic final String CONTENT_TYPE_ITME ="vnd.android.cursor.item/hb.android.teacher";
/*自定义匹配码 */
publicstatic final int TEACHERS = 1;
/*自定义匹配码 */
publicstatic final int TEACHER = 2;
publicstatic final String TITLE = "title";
publicstatic final String NAME = "name";
publicstatic final String DATE_ADDED = "date_added";
publicstatic final String SEX = "SEX";
publicstatic final String DEFAULT_SORT_ORDER = "_id desc";
publicstatic final UriMatcher uriMatcher;
static{
//常量UriMatcher.NO_MATCH表示不匹配任何路径的返回码
uriMatcher= new UriMatcher(UriMatcher.NO_MATCH);
//如果match()方法匹配content://hb.android.teacherProvider/teachern路径,返回匹配码为TEACHERS
uriMatcher.addURI(ContentData.AUTHORITY,"teacher", TEACHERS);
//如果match()方法匹配content://hb.android.teacherProvider/teacher/230,路径，返回匹配码为TEACHER
uriMatcher.addURI(ContentData.AUTHORITY,"teacher/#", TEACHER);
}
}
}它们的匹配码分别是teacher.ITEM、teacher.ITEM_ID和teacher.ITEM_POS，其中，符号#表示匹配任何数字。
2、SQLite操作类DBOpenHelper
/**
* 这个类继承SQLiteOpenHelper抽象类，用于创建数据库和表。创建数据库是调用它的父类构造方法创建。
* @author HB
*/
public class DBOpenHelper extendsSQLiteOpenHelper {
// 在SQLiteOepnHelper的子类当中，必须有该构造函数，用来创建一个数据库；
publicDBOpenHelper(Context context, String name, CursorFactory factory,
intversion) {
//必须通过super调用父类当中的构造函数
super(context,name, factory, version);
//TODO Auto-generated constructor stub
}
// publicDBOpenHelper(Context context, String name) {
// this(context,name, VERSION);
// }
publicDBOpenHelper(Context context, String name, int version) {
this(context,name, null, version);
}
/**
* 只有当数据库执行创建 的时候，才会执行这个方法。如果更改表名，也不会创建，只有当创建数据库的时候，才会创建改表名之后的数据表
*/
@Override
public void onCreate(SQLiteDatabasedb) {
System.out.println("createtable");
db.execSQL("createtable " + ContentData.UserTableData.TABLE_NAME
+"(" + ContentData.UserTableData._ID
+" INTEGER PRIMARY KEY autoincrement,"
+ContentData.UserTableData.NAME + " varchar(20),"
+ContentData.UserTableData.TITLE + " varchar(20),"
+ContentData.UserTableData.DATE_ADDED + " long,"
+ContentData.UserTableData.SEX + " boolean)" + ";");
}
@Override
public voidonUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
}
}/**
* 这个类给外部程序提供访问内部数据的一个接口
* @author HB
*
*/
public class TeacherContentProvider extendsContentProvider {
privateDBOpenHelper dbOpenHelper = null;
// UriMatcher类用来匹配Uri，使用match()方法匹配路径时返回匹配码
/**
* 是一个回调函数，在ContentProvider创建的时候，就会运行,第二个参数为指定数据库名称，如果不指定，就会找不到数据库；
* 如果数据库存在的情况下是不会再创建一个数据库的。（当然首次调用在这里也不会生成数据库必须调用SQLiteDatabase的 getWritableDatabase,getReadableDatabase两个方法中的一个才会创建数据库）
*/
@Override
public booleanonCreate() {
//这里会调用DBOpenHelper的构造函数创建一个数据库；
dbOpenHelper= new DBOpenHelper(this.getContext(), ContentData.DATABASE_NAME,ContentData.DATABASE_VERSION);
returntrue;
}
/**
* 当执行这个方法的时候，如果没有数据库，他会创建，同时也会创建表，但是如果没有表，下面在执行insert的时候就会出错
* 这里的插入数据也完全可以用sql语句书写，然后调用db.execSQL(sql)执行。
*/
@Override
public Uriinsert(Uri uri, ContentValues values){
//获得一个可写的数据库引用，如果数据库不存在，则根据onCreate的方法里创建；
SQLiteDatabasedb = dbOpenHelper.getWritableDatabase();
longid = 0;
switch(uriMatcher.match(uri)) {
caseTEACHERS:
id= db.insert("teacher", null, values); // 返回的是记录的行号，主键为int，实际上就是主键值
returnContentUris.withAppendedId(uri, id);
caseTEACHER:
id= db.insert("teacher", null, values);
Stringpath = uri.toString();
returnUri.parse(path.substring(0, path.lastIndexOf("/"))+id); // 替换掉id
default:
thrownew IllegalArgumentException("Unknown URI " + uri);
}
}
@Override
public intdelete(Uri uri, String selection, String[] selectionArgs) {
SQLiteDatabasedb = dbOpenHelper.getWritableDatabase();
intcount = 0;
switch(uriMatcher.match(uri)) {
caseTEACHERS:
count= db.delete("teacher", selection, selectionArgs);
break;
caseTEACHER:
//下面的方法用于从URI中解析出id，对这样的路径content://hb.android.teacherProvider/teacher/10
//进行解析，返回值为10
longpersonid = ContentUris.parseId(uri);
Stringwhere = "_ID=" + personid; // 删除指定id的记录
where+= !TextUtils.isEmpty(selection) ? " and (" + selection +")" : ""; // 把其它条件附加上
count= db.delete("teacher", where, selectionArgs);
break;
default:
thrownew IllegalArgumentException("Unknown URI " + uri);
}
db.close();
returncount;
}
@Override
public intupdate(Uri uri, ContentValues values, String selection,
String[]selectionArgs) {
SQLiteDatabasedb = dbOpenHelper.getWritableDatabase();
intcount = 0;
switch(uriMatcher.match(uri)) {
caseTEACHERS:
count= db.update("teacher", values, selection, selectionArgs);
break;
caseTEACHER:
//下面的方法用于从URI中解析出id，对这样的路径content://com.ljq.provider.personprovider/person/10
//进行解析，返回值为10
longpersonid = ContentUris.parseId(uri);
Stringwhere = "_ID=" + personid;// 获取指定id的记录
where+= !TextUtils.isEmpty(selection) ? " and (" + selection +")" : "";// 把其它条件附加上
count= db.update("teacher", values, where, selectionArgs);
break;
default:
thrownew IllegalArgumentException("Unknown URI " + uri);
}
db.close();
returncount;
}
@Override
public StringgetType(Uri uri) {
switch(uriMatcher.match(uri)) {
caseTEACHERS:
returnCONTENT_TYPE;
caseTEACHER:
returnCONTENT_TYPE_ITME;
default:
thrownew IllegalArgumentException("Unknown URI " + uri);
}
}
@Override
public Cursorquery(Uri uri, String[] projection, String selection,
String[]selectionArgs, String sortOrder) {
SQLiteDatabasedb = dbOpenHelper.getReadableDatabase();
switch(uriMatcher.match(uri)) {
caseTEACHERS:
returndb.query("teacher", projection, selection, selectionArgs, null, null,sortOrder);
caseTEACHER:
//进行解析，返回值为10
longpersonid = ContentUris.parseId(uri);
Stringwhere = "_ID=" + personid;// 获取指定id的记录
where+= !TextUtils.isEmpty(selection) ? " and (" + selection +")" : "";// 把其它条件附加上
returndb.query("teacher", projection, where, selectionArgs, null, null,sortOrder);
default:
thrownew IllegalArgumentException("Unknown URI " + uri);
}
}
}2、我们在实现自己的ContentProvider时，必须继承于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
<!--?xml version="1.0"encoding="utf-8"?-->
<manifest xmlns:android="http://schemas.android.com/apk/res/android"package="hb.android.contentProvider"android:versioncode="1" android:versionname="1.0">
<uses-sdkandroid:minsdkversion="8">
<intent-filter>
<categoryandroid:name="android.intent.category.LAUNCHER">
</category></action></intent-filter>
</activity>
<providerandroid:name=".TeacherContentProvider"android:authorities="hb.android.contentProvider"android:multiprocess="false">
</provider></application>
</uses-sdk></manifest>6、布局文件
<!--?xml version="1.0"encoding="utf-8"?-->
<linearlayout xmlns:android="http://schemas.android.com/apk/res/android"android:orientation="vertical" android:layout_width="fill_parent"android:layout_height="fill_parent">
<buttonandroid:id="@+id/insert" android:text="@string/insert"android:layout_width="fill_parent"android:layout_height="wrap_content">
</button><buttonandroid:id="@+id/query" android:text="@string/query" android:layout_width="fill_parent"android:layout_height="wrap_content">
</button><buttonandroid:id="@+id/querys" android:text="@string/querys"android:layout_width="fill_parent"android:layout_height="wrap_content">
</button><buttonandroid:id="@+id/update" android:text="@string/update"android:layout_width="fill_parent"android:layout_height="wrap_content">
</button><buttonandroid:id="@+id/delete" android:text="@string/delete"android:layout_width="fill_parent"android:layout_height="wrap_content">
</button></linearlayout>7、activity
package hb.android.contentProvider;
import java.util.Date;
import android.app.Activity;
import android.content.ContentResolver;
import android.content.ContentValues;
import android.database.Cursor;
import android.net.Uri;
import android.os.Bundle;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.Button;
/**
* 这个类用来测试ContentProvider是否可用。通过 给定的uri访问，数据库；
*
* @author HB
*
*/
public class TeacherActivity extendsActivity {
Button insert;
Button query;
Button update;
Button delete;
Button querys;
Uri uri =Uri.parse("content://hb.android.contentProvider/teacher");
/** Called when theactivity is first created. */
@Override
public voidonCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.main);
insert= (Button) findViewById(R.id.insert);
query= (Button) findViewById(R.id.query);
update= (Button) findViewById(R.id.update);
delete= (Button) findViewById(R.id.delete);
querys= (Button) findViewById(R.id.querys);
//绑定监听器的两种方法一；
insert.setOnClickListener(newInsertListener());
query.setOnClickListener(newQueryListener());
//方法二
update.setOnClickListener(newOnClickListener() {
publicvoid onClick(View v) {
//TODO Auto-generated method stub
ContentResolvercr = getContentResolver();
ContentValuescv = new ContentValues();
cv.put("name","huangbiao");
cv.put("date_added",(new Date()).toString());
inturi2 = cr.update(uri, cv, "_ID=?", new String[]{"3"});
System.out.println("updated"+":"+uri2);
}
});
delete.setOnClickListener(newOnClickListener() {
publicvoid onClick(View v) {
ContentResolvercr = getContentResolver();
cr.delete(uri,"_ID=?", new String[]{"2"});
}
});
querys.setOnClickListener(newOnClickListener() {
publicvoid onClick(View v) {
//TODO Auto-generated method stub
ContentResolvercr = getContentResolver();
//查找id为1的数据
Cursorc = cr.query(uri, null, null,null, null);
System.out.println(c.getCount());
c.close();
}
});
}
classInsertListener implements OnClickListener {
publicvoid onClick(View v) {
//TODO Auto-generated method stub
ContentResolvercr = getContentResolver();
ContentValuescv = new ContentValues();
cv.put("title","jiaoshou");
cv.put("name","jiaoshi");
cv.put("sex",true);
Uriuri2 = cr.insert(uri, cv);
System.out.println(uri2.toString());
}
}
class QueryListenerimplements OnClickListener {
publicvoid onClick(View v) {
//TODO Auto-generated method stub
ContentResolvercr = getContentResolver();
//查找id为1的数据
Cursorc = cr.query(uri, null, "_ID=?", new String[] { "1" },null);
//这里必须要调用c.moveToFirst将游标移动到第一条数据,不然会出现index -1 requested , with a size of 1错误；cr.query返回的是一个结果集。
if(c.moveToFirst() == false) {
//为空的Cursor
return;
}
intname = c.getColumnIndex("name");
System.out.println(c.getString(name));
c.close();
}
}
}组件Content Provider中的数据更新通知机制和Android系统中的广播（Broadcast）通知机制的实现思路是相似的。
在Android的广播机制中，首先是接收者对自己感兴趣的广播进行注册，接着当发送者发出这些广播时，接收者就会得到通知了。
然而，Content Provider中的数据监控机制与Android系统中的广播机制又有三个主要的区别，
一：是前者是通过URI来把通知的发送者和接收者关联在一起的，而后者是通过Intent来关联的，
二：是前者的通知注册中心是由ContentService服务来扮演的，而后者是由ActivityManagerService服务来扮演的，
三：是前者负责接收数据更新通知的类必须要继承ContentObserver类，而后者要继承BroadcastReceiver类。
之所以会有这些区别，是由于Content Proivder组件的数据共享功能本身就是建立在URI的基础之上的，因此专门针对URI来设计另外一套通知机制会更实用和方便，而Android系统的广播机制是一种更加通用的事件通知机制，它的适用范围会更广泛一些。
369
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
