从Notepad实例学习Content Providers

Content providers是程序间共享数据的唯一方法。Android在 android.provider 包下提供了一些访问音频，视频，图像，个人联系信息等常用数据的Content providers，我们可以直接使用这些类来访问这些数据。如果想要分享自己的数据给别人，需要实现自定义的Content Provider，这通过继承类 ContentProvider 来实现。通过学习SDK下面Notepad的源码来学习如何自定义Content Provider。

创建Content Provider分三个步骤：

1. 建立一个存储数据的系统，android中的大多数都是使用SQLite数据库（本文不涉及其它方式）

2. 扩展 ContentProvider 类访问数据

3. 在程序的AndroidManifest.xml文件中声明。

继承ContentProvider需要实现这六个方法：

query()
insert()
update()
delete()
getType()
onCreate()

注意：因为ContentProvider可能被不同的进程和线程调用，所以这些方法必须是线程安全的。

package com.example.android.notepad;   
  
import android.net.Uri;   
import android.provider.BaseColumns;   
  
/**  
 * Convenience definitions for NotePadProvider  
 * Content Provider的基础类，该类定义了每一列的名字，内容Uri，默认排序方式等常量  
 */  
public final class NotePad {   
    public static final String AUTHORITY = "com.google.provider.NotePad";   
  
    // This class cannot be instantiated   
    private NotePad() {}   
       
    /**  
     * Notes table  
     * BaseColumns定义了两个基本字段_ID(每一行的ID)和_COUNT(每个目录下的行数)  
     */  
    public static final class Notes implements BaseColumns {   
        // This class cannot be instantiated   
        private Notes() {}   
  
        /**  
         * The content:// style URL for this table  
         */  
        public static final Uri CONTENT_URI = Uri.parse("content://" + AUTHORITY + "/notes");   
  
        /**  
         * The MIME type of {@link #CONTENT_URI} providing a directory of notes.  
         * 定义新的MIME类型对应notes的目录  
         */  
        public static final String CONTENT_TYPE = "vnd.android.cursor.dir/vnd.google.note";   
  
        /**  
         * The MIME type of a {@link #CONTENT_URI} sub-directory of a single note.  
         * 定义新的MIME类型对应一个note  
         */  
        public static final String CONTENT_ITEM_TYPE = "vnd.android.cursor.item/vnd.google.note";   
  
        /**  
         * The default sort order for this table  
         */  
        public static final String DEFAULT_SORT_ORDER = "modified DESC";   
  
        /**  
         * The title of the note  
         * <P>Type: TEXT</P>  
         */  
        public static final String TITLE = "title";   
  
        /**  
         * The note itself  
         * <P>Type: TEXT</P>  
         */  
        public static final String NOTE = "note";   
  
        /**  
         * The timestamp for when the note was created  
         * <P>Type: INTEGER (long from System.curentTimeMillis())</P>  
         */  
        public static final String CREATED_DATE = "created";   
  
        /**  
         * The timestamp for when the note was last modified  
         * <P>Type: INTEGER (long from System.curentTimeMillis())</P>  
         */  
        public static final String MODIFIED_DATE = "modified";   
    }   
}  

package com.example.android.notepad;   
  
import com.example.android.notepad.NotePad.Notes;   
  
import android.content.ContentProvider;   
import android.content.ContentUris;   
import android.content.ContentValues;   
import android.content.Context;   
import android.content.UriMatcher;   
import android.content.res.Resources;   
import android.database.Cursor;   
import android.database.SQLException;   
import android.database.sqlite.SQLiteDatabase;   
import android.database.sqlite.SQLiteOpenHelper;   
import android.database.sqlite.SQLiteQueryBuilder;   
import android.net.Uri;   
import android.text.TextUtils;   
import android.util.Log;   
  
import java.util.HashMap;   
  
/**  
 * Provides access to a database of notes. Each note has a title, the note  
 * itself, a creation date and a modified data.  
 */  
public class NotePadProvider extends ContentProvider {   
  
    private static final String TAG = "NotePadProvider";   
        //数据库名   
    private static final String DATABASE_NAME = "note_pad.db";   
    private static final int DATABASE_VERSION = 2;   
    //表名   
    private static final String NOTES_TABLE_NAME = "notes";   
  
    private static HashMap<String, String> sNotesProjectionMap;   
  
    private static final int NOTES = 1;   
    private static final int NOTE_ID = 2;   
  
    private static final UriMatcher sUriMatcher;   
  
    /**  
     * This class helps open, create, and upgrade the database file.  
     */  
    private static class DatabaseHelper extends SQLiteOpenHelper {   
  
        DatabaseHelper(Context context) {   
            super(context, DATABASE_NAME, null, DATABASE_VERSION);   
        }   
  
        @Override  
        public void onCreate(SQLiteDatabase db) {   
            db.execSQL("CREATE TABLE " + NOTES_TABLE_NAME + " ("  
                    + Notes._ID + " INTEGER PRIMARY KEY,"  
                    + Notes.TITLE + " TEXT,"  
                    + Notes.NOTE + " TEXT,"  
                    + Notes.CREATED_DATE + " INTEGER,"  
                    + Notes.MODIFIED_DATE + " INTEGER"  
                    + ");");   
        }   
  
        @Override  
        public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {   
            Log.w(TAG, "Upgrading database from version " + oldVersion + " to "  
                    + newVersion + ", which will destroy all old data");   
            db.execSQL("DROP TABLE IF EXISTS notes");   
            onCreate(db);   
        }   
    }   
  
    private DatabaseHelper mOpenHelper;   
  
    @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();   
  
        switch (sUriMatcher.match(uri)) {   
        case NOTES:   
            qb.setTables(NOTES_TABLE_NAME);   
            qb.setProjectionMap(sNotesProjectionMap);   
            break;   
  
        case NOTE_ID:   
            qb.setTables(NOTES_TABLE_NAME);   
            qb.setProjectionMap(sNotesProjectionMap);   
            qb.appendWhere(Notes._ID + "=" + uri.getPathSegments().get(1));   
            break;   
  
        default:   
            throw new IllegalArgumentException("Unknown URI " + uri);   
        }   
  
        // If no sort order is specified use the default   
        String orderBy;   
        if (TextUtils.isEmpty(sortOrder)) {   
            orderBy = NotePad.Notes.DEFAULT_SORT_ORDER;   
        } else {   
            orderBy = sortOrder;   
        }   
  
        // Get the database and run the query   
        SQLiteDatabase db = mOpenHelper.getReadableDatabase();   
        Cursor c = qb.query(db, projection, selection, selectionArgs, null, null, orderBy);   
  
        // 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 NOTES:   
            return Notes.CONTENT_TYPE;   
  
        case NOTE_ID:   
            return Notes.CONTENT_ITEM_TYPE;   
  
        default:   
            throw new IllegalArgumentException("Unknown URI " + uri);   
        }   
    }   
  
    @Override  
    public Uri insert(Uri uri, ContentValues initialValues) {   
        // Validate the requested uri   
        if (sUriMatcher.match(uri) != NOTES) {   
            throw new IllegalArgumentException("Unknown URI " + uri);   
        }   
  
        ContentValues values;   
        if (initialValues != null) {   
            values = new ContentValues(initialValues);   
        } else {   
            values = new ContentValues();   
        }   
  
        Long now = Long.valueOf(System.currentTimeMillis());   
  
        // Make sure that the fields are all set   
        if (values.containsKey(NotePad.Notes.CREATED_DATE) == false) {   
            values.put(NotePad.Notes.CREATED_DATE, now);   
        }   
  
        if (values.containsKey(NotePad.Notes.MODIFIED_DATE) == false) {   
            values.put(NotePad.Notes.MODIFIED_DATE, now);   
        }   
  
        if (values.containsKey(NotePad.Notes.TITLE) == false) {   
            Resources r = Resources.getSystem();   
            values.put(NotePad.Notes.TITLE, r.getString(android.R.string.untitled));   
        }   
  
        if (values.containsKey(NotePad.Notes.NOTE) == false) {   
            values.put(NotePad.Notes.NOTE, "");   
        }   
  
        SQLiteDatabase db = mOpenHelper.getWritableDatabase();   
        long rowId = db.insert(NOTES_TABLE_NAME, Notes.NOTE, values);   
        if (rowId > 0) {   
            Uri noteUri = ContentUris.withAppendedId(NotePad.Notes.CONTENT_URI, rowId);   
            getContext().getContentResolver().notifyChange(noteUri, null);   
            return noteUri;   
        }   
  
        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 NOTES:   
            count = db.delete(NOTES_TABLE_NAME, where, whereArgs);   
            break;   
  
        case NOTE_ID:   
            String noteId = uri.getPathSegments().get(1);   
            count = db.delete(NOTES_TABLE_NAME, Notes._ID + "=" + noteId   
                    + (!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 NOTES:   
            count = db.update(NOTES_TABLE_NAME, values, where, whereArgs);   
            break;   
  
        case NOTE_ID:   
            String noteId = uri.getPathSegments().get(1);   
            count = db.update(NOTES_TABLE_NAME, values, Notes._ID + "=" + noteId   
                    + (!TextUtils.isEmpty(where) ? " AND (" + where + ')' : ""), whereArgs);   
            break;   
  
        default:   
            throw new IllegalArgumentException("Unknown URI " + uri);   
        }   
  
        getContext().getContentResolver().notifyChange(uri, null);   
        return count;   
    }   
  
    static {   
        sUriMatcher = new UriMatcher(UriMatcher.NO_MATCH);   
        sUriMatcher.addURI(NotePad.AUTHORITY, "notes", NOTES);   
        sUriMatcher.addURI(NotePad.AUTHORITY, "notes/#", NOTE_ID);   
  
        sNotesProjectionMap = new HashMap<String, String>();   
        sNotesProjectionMap.put(Notes._ID, Notes._ID);   
        sNotesProjectionMap.put(Notes.TITLE, Notes.TITLE);   
        sNotesProjectionMap.put(Notes.NOTE, Notes.NOTE);   
        sNotesProjectionMap.put(Notes.CREATED_DATE, Notes.CREATED_DATE);   
        sNotesProjectionMap.put(Notes.MODIFIED_DATE, Notes.MODIFIED_DATE);   
    }   
}