Pro Android学习笔记（二）——ContentProvider（下）

版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/Ithink213/article/details/46858995

上一章讲解了ContentProvider的一些基本概念和涉及到的知识。这一章就来实现它。
要实现ContentProvider，我们继承自ContentProvider这个抽象类，实现其中的抽象方法就可以了，其中的抽象方法包括：
query
insert
update
delete
getType
在实现他们之前需要大量的设置。按照以下步骤设计：
（1)计划数据库
（2）扩展抽象类ContentProvider
（3）实现方法：query，insert，update，delete，getType
（4）描述文件中注册程序
OK，按照以上步骤按部就班

（1）计划数据库

创建一个图书数据库，包含一张books表，表中的列包括name，isbn和author。这些列名对应着元数据，相关的元数据在java类中定义。定义的元数据java类为BookProviderMetaData。如下：

public class BookProviderMetaData {

    public static final String AUTHORITY = "com.zxn.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() {}

    // inner class describing columns and their types
    public static final class BookTableMetaData implements BaseColumns {

        private BookTableMetaData() {}
        public static final String TABLE_NAME = "books";

        // uri and mime type definitions
        public static final Uri CONTENT_URI = Uri.parse("content://" + AUTHORITY + "/books");
        public static final String CONTENT_TYPE = "vnd.android.Cursor.dir/vnd.androidbook.book";
        public static final String CONTENT_ITEM_TYPE = "vnd.android.Cursor.item/vnd.androidbook.book";

        public static final String DEFAULT_SORT_ORDER = "modified DESC";

        // Additional Columns start here
        // String type
        public static final String BOOK_NAME = "name";
        // String type
        public static final String BOOK_ISBN = "isbn";
        // String type
        public static final String BOOK_AUTHOR = "author";
        // Integer from System.currentTimeMillis()
        public static final String CREATED_DATE = "created";
        // Integer from System.currentTimeMillis()
        public static final String MODIFIED_DATE = "modified";

    }
}

BookProviderMetaData类首先定义其授权为“com.zxn.BookProvider”，我们就可以使用这个字符串在Android的描述文件中注册这段程序了。这段程序形成了让这段程序使用的URI的前面部分。就像这样：
content://com.zxn.BookProvider/books
我们可以使用一下常量标识：
BookProviderMetaData.BookTableMetaData.CONTENT_URI
BookTableMetaData类定义了图书合集和一本图书的MIME类型，然后定义了一组列：name，isbn，author，created，modified。
BookTableMetaData继承自BaseColumns,提供了标准的_id字段。
有了这些元数据之后，我们就能实现我们的程序了。

（2）拓展ContentProvider

拓展ContentProvider，重写onCreate()来创建数据库，然后实现query，insert，update，delete，getType等方法。
程序如下：

public class BookProvider extends ContentProvider {

    // Logging helper tag. No significance to providers.
    private static final String TAG = "BookProvider";

    // 定义一个投影映射以便我们可以重命名列，这里均设置的相同
    // Projection maps are similar to "as" construct in an sql statement where by you can rename the Columns;
    private static HashMap<String, String> sBooksProjectionMap;
    static {
        sBooksProjectionMap = new HashMap<String, String>();
        sBooksProjectionMap.put(BookProviderMetaData.BookTableMetaData._ID, BookProviderMetaData.BookTableMetaData._ID);

        // name, isbn, author
        sBooksProjectionMap.put(BookProviderMetaData.BookTableMetaData.BOOK_NAME, BookProviderMetaData.BookTableMetaData.BOOK_NAME);
        sBooksProjectionMap.put(BookProviderMetaData.BookTableMetaData.BOOK_ISBN, BookProviderMetaData.BookTableMetaData.BOOK_ISBN);
        sBooksProjectionMap.put(BookProviderMetaData.BookTableMetaData.BOOK_AUTHOR, BookProviderMetaData.BookTableMetaData.BOOK_AUTHOR);

        // created date, modified date
        sBooksProjectionMap.put(BookProviderMetaData.BookTableMetaData.CREATED_DATE, BookProviderMetaData.BookTableMetaData.CREATED_DATE);
        sBooksProjectionMap.put(BookProviderMetaData.BookTableMetaData.MODIFIED_DATE, BookProviderMetaData.BookTableMetaData.MODIFIED_DATE);
    }

    // Provide a mechanism to identify
    // all the incoming uri patterns
    private static final UriMatcher sUriMatcher;  // 定义一个URI匹配器，用于之后的URI匹配
    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);
    }

    // 定义一个DatabaseHelper以便我们能够方便的打开，创建，更新数据库文件
    // This class helps open, create, and upgrade the database file
    private static class DatabaseHelper extends SQLiteOpenHelper {

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

        @Override
        public void onCreate(SQLiteDatabase sqLiteDatabase) {
            Log.d(TAG, "inner oncreate called");
            sqLiteDatabase.execSQL("CREATE TABLE " + BookProviderMetaData.BookTableMetaData.TABLE_NAME + " ("
                    + BookProviderMetaData.BookTableMetaData._ID + " INTEGER PRIMARY KEY,"
                    + BookProviderMetaData.BookTableMetaData.BOOK_NAME + " TEXT,"
                    + BookProviderMetaData.BookTableMetaData.BOOK_ISBN + " TEXT,"
                    + BookProviderMetaData.BookTableMetaData.BOOK_AUTHOR + " TEXT,"
                    + BookProviderMetaData.BookTableMetaData.CREATED_DATE + " INTEGER,"
                    + BookProviderMetaData.BookTableMetaData.MODIFIED_DATE + " INTEGER"
                    + ");");
        }

        @Override
        public void onUpgrade(SQLiteDatabase sqLiteDatabase, int i, int i2) {
            Log.d(TAG, "inner onupgrade called");
            Log.w(TAG, "Upgrading database from version" + i + " to " + i2 + ", which will destroy all old data");
            sqLiteDatabase.execSQL("DROP TABLE IF EXISTS " + BookProviderMetaData.BookTableMetaData.TABLE_NAME);
            onCreate(sqLiteDatabase);
        }
    }

    private DatabaseHelper mOpenHelper;

    @Override
    public boolean onCreate() {
        Log.d(TAG, "main onCreate called");
        mOpenHelper = new DatabaseHelper(getContext());
        return true;
    }

    @Override
    public Cursor query(Uri uri, String[] projection, String selection, String[] selectionArgs, String sortOrder) {
        SQLiteQueryBuilder qb = new SQLiteQueryBuilder();
        switch(sUriMatcher.match(uri)) {  // 匹配URI
            case INCOMING_BOOK_COLLECTION_URI_INDICATOR:  // 如果是图书集合
                qb.setTables(BookProviderMetaData.BookTableMetaData.TABLE_NAME);  // 设置查询表
                qb.setProjectionMap(sBooksProjectionMap);  // 设置查询的投影映射，官方说明是：投影映射将从调用方传入查询的列名称映射到数据库列名称。
                                                           // 这对于重命名列以及在进行联结时消除列名称歧义非常有用。
                break;
            case INCOMING_SINGLE_BOOK_URI_INDICATOR:  // 如果是单个图书
                qb.setTables(BookProviderMetaData.BookTableMetaData.TABLE_NAME);
                qb.setProjectionMap(sBooksProjectionMap);
                qb.appendWhere(BookProviderMetaData.BookTableMetaData._ID + "=" + uri.getPathSegments().get(1)); // 给一些条件到查询中的Where子句
                break;
            default:
                throw new IllegalArgumentException("Unknow URI" + uri); //  抛出参数异常
        }

        // if no sort order is specified use the default
        String orderBy;
        if(TextUtils.isEmpty(sortOrder)) {
            orderBy = BookProviderMetaData.BookTableMetaData.DEFAULT_SORT_ORDER;
        } else {
            orderBy = sortOrder;
        }

        // Get the databases and run query
        SQLiteDatabase db = mOpenHelper.getReadableDatabase();
        Cursor c = qb.query(db, projection, selection, selectionArgs, null, null, orderBy);  //  进行查询操作，返回当前查询结果的cursor

        // example of getting a count
        int i = c.getCount();

        // Tell the cursor what uri to watch
        // so it knows when its source data changes
        c.setNotificationUri(getContext().getContentResolver(), uri);

        return c;
    }

    @Override
    public String getType(Uri uri) {
        switch(sUriMatcher.match(uri)) {
            case INCOMING_BOOK_COLLECTION_URI_INDICATOR:
                return BookProviderMetaData.BookTableMetaData.CONTENT_TYPE;  // 返回图书集合URI的MIME类型
            case INCOMING_SINGLE_BOOK_URI_INDICATOR:
                return BookProviderMetaData.BookTableMetaData.CONTENT_ITEM_TYPE;  // 返回单个图书URI的MIME类型
            default:
                throw new IllegalArgumentException("Unknown URI " + uri);
        }
    }

    @Override
    public Uri insert(Uri uri, ContentValues contentValues) {
        // Validate the requested uri
        if(sUriMatcher.match(uri) != INCOMING_BOOK_COLLECTION_URI_INDICATOR) {
            throw new IllegalArgumentException("Unknown URI " + uri);
        }

        // contentValues可以存储一个键值映射用于ContentResolver处理
        ContentValues values;
        if(contentValues != null) {
            values = new ContentValues(contentValues);
        } else {
            values = new ContentValues();
        }

        Long now = Long.valueOf(System.currentTimeMillis());

        // 插入操作要保证每个列必须存在
        // Make sure that the fields are all set
        if(values.containsKey(BookProviderMetaData.BookTableMetaData.CREATED_DATE) == false) {
            values.put(BookProviderMetaData.BookTableMetaData.CREATED_DATE, now);
        }
        if(values.containsKey(BookProviderMetaData.BookTableMetaData.MODIFIED_DATE) == false) {
            values.put(BookProviderMetaData.BookTableMetaData.MODIFIED_DATE, now);
        }
        if(values.containsKey(BookProviderMetaData.BookTableMetaData.BOOK_NAME) == false) {
            throw new SQLException("Failed to insert row because Book Name is needed " + uri);
        }
        if(values.containsKey(BookProviderMetaData.BookTableMetaData.BOOK_ISBN) == false) {
            values.put(BookProviderMetaData.BookTableMetaData.BOOK_ISBN, "Unknown ISBN");
        }
        if(values.containsKey(BookProviderMetaData.BookTableMetaData.BOOK_AUTHOR) == false) {
            values.put(BookProviderMetaData.BookTableMetaData.BOOK_AUTHOR, "Unknown Author");
        }

        SQLiteDatabase db = mOpenHelper.getWritableDatabase();
        long rowId = db.insert(BookProviderMetaData.BookTableMetaData.TABLE_NAME, BookProviderMetaData.BookTableMetaData.BOOK_NAME, values);
        if(rowId > 0) {
            Uri insertedBookUri = ContentUris.withAppendedId(BookProviderMetaData.BookTableMetaData.CONTENT_URI, rowId);
            getContext().getContentResolver().notifyChange(insertedBookUri, null);
            return insertedBookUri;
        }

        throw new SQLException("Failed to insert row into " + uri);

    }

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

        getContext().getContentResolver().notifyChange(uri, null);
        return count;
    }

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

        getContext().getContentResolver().notifyChange(uri, null);
        return count;
    }
}

getType方法中，通过判断返回的URI的MIME类型从而知道是一个图书的集合还是一本图书。
query方法中，首先根据传入的URI判断类型，如果是单个类型，则要获取传入ID。然后通过SQLiteQueryBuilder.query方法查询，返回游标。
insert方法中，首先判断URI类型，然后验证列参数，然后通过SQLiteDatabase.insert方法插入，返回新插入的ID。
update方法中，首先判断URI类型，如果是集合，则传入where子句，使用SQLiteDatabase.update方法更新；如果是单个图书，则首先从URI中获取ID，然后指派一条新的where子句，最后执行update。该方法返回更新的数量。
delete方法中，首先判断URI类型，如果是图书集合，然后传入where子句，执行SqliteDatabase.delete删除操作。如果是单个图书，首先获取URI中的ID，然后指派一条新的where子句，最后执行delelte。该方法返回删除的数量。
注意以上程序中的sBooksProjectionMap。由于ContentProvider充当着抽象列集和数据库中真实的列集之间的媒介，这些列集可能是不同的。所以在构造查询的时候，必须在客户端指定的where子句列与真实的数据库列之间建立映射。借助于SQLiteQueryBuilder类来构建映射。

（3）注册程序

最后，记得在AndroidManifest.xml文件中注册ContentProvider

<provider
            android:authorities="com.androidbook.provider.BookProvider"
            android:name=".BookProvider" />

依据以上步骤就可以实现ContentProvider。参考Pro Android书本源码。书本源码我已上传到CSDN地址
http://download.csdn.net/detail/ithink213/8878935
以上代码在我的GitHub也有
https://github.com/EvidenceKiller/ProAndroid