Android开发ContentProvider

Content Provider是Android四大组件之一，其主要作用是作为内容（数据）提供方存在，可以用于解决Android进程间数据的共享；
Android中内置了一些Provider，这些Provider提供着一些常用的数据，比如联系人信息等，在这里主要讨论如何在Android中开发自己的Provider；
在Android中开发自己的Provider需要以下的几步：
1）规划数据库、URI、列名称，创建元数据类来定义这些元数据元素的常量；
2）扩展抽象类ContentProvider，设置列映射，URI匹配和实现SQLiteOpenHelper；
3）实现方法：query、insert、update、delete和getType；
4）在描述文件中注册Provider；
代码如下：
1）规划数据库、URI等元数据

package main.app.provider;

import android.net.Uri;
import android.provider.BaseColumns;

public class BookProviderMetaData {
	public static final String AUTHORITY = "main.app.provider.BookProvider";
	public static final String DATABASE_NAME = "book.db";
	public static final int DATABASE_VERSION = 1;
	public static final String BOOKS_TABLE_NAME = "books";

	private BookProviderMetaData() {
	}

	public static final class BookTableMetaData implements BaseColumns {
		private BookTableMetaData() {
		}

		public static final String TABLE_NAME = "books";
		public static final Uri CONTENT_URI = Uri.parse("content://"
				+ AUTHORITY + "/books");
		public static final String CONTENT_TYPE = "vnd.android.cursor.dir/vnd.android.book";
		public static final String CONTENT_ITEM_TYPE = "vnd.android.cursor.item/vnd.android.book";
		public static final String DEFAULT_SORT_ORDER = "modified DESC";

		public static final String BOOK_NAME = "name";
		public static final String BOOK_ISBN = "isbn";
		public static final String BOOK_AUTHOR = "author";
		public static final String CREATED_DATE = "created";
		public static final String MODIFIED_DATE = "modified";
	}
}

注：Provider使用的MIME类型需要记住以下几点：
[list]
[*]类型和子类型所标示的内容必须是唯一的，类型基本确定为项目录或者单个项，Android中返回项集合的类型应该始终为vnd.android.cursor.dir，单个项使用的类型应该始终为vnd.android.cursor.item；
[*]如果类型和子类型不是标准的，则需要在它们之前添加vnd；
[*]通常针对具体需求添加命名空间；
[/list]


2）扩展抽象类，设置列映射，URI匹配和实现SQLiteOpenHelper：

 // 设置列投影
	private static HashMap<String, String> sBookProjectionMap;
	static {
		sBookProjectionMap = new HashMap<String, String>();
		sBookProjectionMap.put(BookTableMetaData._ID, BookTableMetaData._ID);
		sBookProjectionMap.put(BookTableMetaData.BOOK_NAME,
				BookTableMetaData.BOOK_NAME);
		sBookProjectionMap.put(BookTableMetaData.BOOK_ISBN,
				BookTableMetaData.BOOK_ISBN);
		sBookProjectionMap.put(BookTableMetaData.BOOK_AUTHOR,
				BookTableMetaData.BOOK_AUTHOR);
		sBookProjectionMap.put(BookTableMetaData.CREATED_DATE,
				BookTableMetaData.CREATED_DATE);
		sBookProjectionMap.put(BookTableMetaData.MODIFIED_DATE,
				BookTableMetaData.MODIFIED_DATE);
	}
	// 设置UriMatcher
	private static final UriMatcher sUriMatcher;
	private static final int INCOMING_BOOK_COLLECTION_URI_INDICATOR = 1;
	private static final int INCOMING_SINGLE_BOOK_URI_INDICATOR = 2;
	static {
		sUriMatcher = new UriMatcher(UriMatcher.NO_MATCH);
		sUriMatcher.addURI(BookProviderMetaData.AUTHORITY, "books",
				INCOMING_BOOK_COLLECTION_URI_INDICATOR);
		sUriMatcher.addURI(BookProviderMetaData.AUTHORITY, "books/#",
				INCOMING_SINGLE_BOOK_URI_INDICATOR);
	}
	// 创建数据库
	private DatabaseHelper mOpenHelper;

	private static class DatabaseHelper extends SQLiteOpenHelper {

		public DatabaseHelper(Context context) {
			super(context, BookProviderMetaData.DATABASE_NAME, null,
					BookProviderMetaData.DATABASE_VERSION);
		}

		@Override
		public void onCreate(SQLiteDatabase db) {
			db.execSQL("CREATE TABLE IF NOT EXISTS "
					+ BookTableMetaData.TABLE_NAME + " ("
					+ BookTableMetaData._ID + " INTEGER PRIMARY KEY, "
					+ BookTableMetaData.BOOK_NAME + " TEXT, "
					+ BookTableMetaData.BOOK_ISBN + " TEXT, "
					+ BookTableMetaData.BOOK_AUTHOR + " TEXT, "
					+ BookTableMetaData.CREATED_DATE + " INTEGER, "
					+ BookTableMetaData.MODIFIED_DATE + " INTEGER" + ");");
		}

		@Override
		public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
			Log.w("DB", "Upgrade database from " + oldVersion + " to "
					+ newVersion + ", which will destory all old data!");
			db.execSQL("DROP TABLE IF EXISTS " + BookTableMetaData.TABLE_NAME);
			onCreate(db);
		}
	}

3）实现方法：query、insert、update、delete和getType：

 @Override
	public int delete(Uri uri, String where, String[] whereArgs) {
		SQLiteDatabase db = mOpenHelper.getWritableDatabase();
		int count = 0;
		switch (sUriMatcher.match(uri)) {
		case INCOMING_BOOK_COLLECTION_URI_INDICATOR:
			count = db.delete(BookTableMetaData.TABLE_NAME, where, whereArgs);
			break;
		case INCOMING_SINGLE_BOOK_URI_INDICATOR:
			String rowId = uri.getPathSegments().get(1);
			count = db.delete(
					BookTableMetaData.TABLE_NAME,
					BookTableMetaData._ID
							+ "="
							+ rowId
							+ (!TextUtils.isEmpty(where) ? " AND (" + where
									+ ")" : ""), whereArgs);
			break;
		default:
			throw new IllegalArgumentException("Unknown Uri: " + uri);
		}
		getContext().getContentResolver().notifyChange(uri, null);
		return count;
	}

	// 根据Uri确定返回的MIME类型
	@Override
	public String getType(Uri uri) {
		switch (sUriMatcher.match(uri)) {
		case INCOMING_BOOK_COLLECTION_URI_INDICATOR:
			return BookTableMetaData.CONTENT_TYPE;
		case INCOMING_SINGLE_BOOK_URI_INDICATOR:
			return BookTableMetaData.CONTENT_ITEM_TYPE;
		default:
			throw new IllegalArgumentException("Unknown URI: " + uri);
		}
	}

	@Override
	public Uri insert(Uri uri, ContentValues values) {
		if (sUriMatcher.match(uri) == INCOMING_BOOK_COLLECTION_URI_INDICATOR) {
			throw new IllegalArgumentException("Unknown Uri: " + uri);
		}
		Long now = Long.valueOf(System.currentTimeMillis());
		if (!values.containsKey(BookTableMetaData.CREATED_DATE)) {
			values.put(BookTableMetaData.CREATED_DATE, now);
		}
		if (!values.containsKey(BookTableMetaData.MODIFIED_DATE)) {
			values.put(BookTableMetaData.MODIFIED_DATE, now);
		}
		if (!values.containsKey(BookTableMetaData.BOOK_NAME)) {
			throw new IllegalArgumentException(
					"Fail to insert row because Book Name is needed " + uri);
		}
		if (!values.containsKey(BookTableMetaData.BOOK_ISBN)) {
			values.put(BookTableMetaData.BOOK_ISBN, "Unknown ISBN");
		}
		if (!values.containsKey(BookTableMetaData.BOOK_AUTHOR)) {
			values.put(BookTableMetaData.BOOK_AUTHOR, "Unknown Author");
		}
		SQLiteDatabase db = mOpenHelper.getWritableDatabase();
		Long rowId = db.insert(BookTableMetaData.TABLE_NAME,
				BookTableMetaData.BOOK_NAME, values);
		if (rowId > 0) {
			Uri insertedBookUri = ContentUris.withAppendedId(
					BookTableMetaData.CONTENT_URI, rowId);
			getContext().getContentResolver().notifyChange(insertedBookUri,
					null);
			return insertedBookUri;
		}
		throw new SQLException("Failed to insert row into " + uri);
	}

	@Override
	public boolean onCreate() {
		mOpenHelper = new DatabaseHelper(getContext());
		return true;
	}

	@Override
	public Cursor query(Uri uri, String[] projection, String selection,
			String[] selectionArgs, String sortOrder) {
		SQLiteQueryBuilder qb = new SQLiteQueryBuilder();
		qb.setTables(BookTableMetaData.TABLE_NAME);
		qb.setProjectionMap(sBookProjectionMap);
		switch (sUriMatcher.match(uri)) {
		case INCOMING_BOOK_COLLECTION_URI_INDICATOR:
			break;
		case INCOMING_SINGLE_BOOK_URI_INDICATOR:
			qb.appendWhere(BookTableMetaData._ID + "="
					+ uri.getPathSegments().get(1));
			break;
		default:
			throw new IllegalArgumentException("Unknown Uri: " + uri);
		}
		String orderBy;
		if (TextUtils.isEmpty(sortOrder)) {
			orderBy = BookTableMetaData.DEFAULT_SORT_ORDER;
		} else {
			orderBy = sortOrder;
		}
		SQLiteDatabase db = mOpenHelper.getReadableDatabase();
		Cursor c = qb.query(db, projection, selection, selectionArgs, null,
				null, orderBy);
		// int i = c.getCount();
		c.setNotificationUri(getContext().getContentResolver(), uri);
		return c;
	}

	@Override
	public int update(Uri uri, ContentValues values, String where,
			String[] whereArgs) {
		SQLiteDatabase db = mOpenHelper.getWritableDatabase();
		int count = 0;
		switch (sUriMatcher.match(uri)) {
		case INCOMING_BOOK_COLLECTION_URI_INDICATOR:
			count = db.update(BookTableMetaData.TABLE_NAME, values, where,
					whereArgs);
			break;
		case INCOMING_SINGLE_BOOK_URI_INDICATOR:
			String rowId = uri.getPathSegments().get(1);
			count = db.update(
					BookTableMetaData.TABLE_NAME,
					values,
					BookTableMetaData._ID
							+ "="
							+ rowId
							+ (!TextUtils.isEmpty(where) ? " AND (" + where
									+ ")" : ""), whereArgs);
			break;
		default:
			throw new IllegalArgumentException("Unknown Uri: " + uri);
		}
		getContext().getContentResolver().notifyChange(uri, null);
		return count;
	}

4）在描述文件中注册Provider：

        <provider
            android:name=".provider.BookProvider"
            android:authorities="main.app.provider.BookProvider" >
        </provider>