ContentProvider数据共享

创建数据库

创建一个类放置ContentProvider会用到的列名

创建ContentProvider的子类

定义URI

在Manifest的XML中添加android:authorities属性与URI一致

定义MIME类型

package d.m;

import android.net.Uri;

/**
 * @version 2012-7-17 上午11:10:12
 **/
public final class table {
    private table() {
    }

    // 数据路径 与Manifest.xml中android:authorities的值相同
    public static String AUTHORITY = "d.m.dbname";
    // 列名
    public static final String KEY_ID = "_id";
    public static final String KEY_NAME = "name";
    public static final String KEY_NUM = "num";

    // URI 固定格式 content://+数据路径+标示ID(可选)
    public static final Uri CONTENT_URI = Uri.parse("content://" + AUTHORITY);

    // 新的MIME类型-多个
    public static final String CONTENT_TYPE = "vnd.android.cursor.dir/vnd.google.note";

    // 新的MIME类型-单个
    public static final String CONTENT_ITEM_TYPE = "vnd.android.cursor.item/vnd.google.note";

}
           

package d.m;

import java.util.HashMap;
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.database.sqlite.SQLiteQueryBuilder;
import android.net.Uri;
import android.text.TextUtils;

/**
 * @version 2012-7-17 上午11:27:09
 **/
public class cp extends ContentProvider {
    // 标示使用UriMatcher匹配的标示ID
    private static final int TB = 1;
    private static final int TB_ID = 2;

    private DatabaseHelper databaseHelper;
    // 用于匹配Uri
    private static final UriMatcher MATCHER;
    // 设置
    private static HashMap<String, String> projectMap;
    static {
        projectMap = new HashMap<String, String>();
        projectMap.put(table.KEY_ID, table.KEY_ID);
        projectMap.put(table.KEY_NAME, table.KEY_NAME);
        projectMap.put(table.KEY_NUM, table.KEY_NUM);

        // 常量UriMatcher.NO_MATCH表示不匹配任何路径的返回码(-1)。
        MATCHER = new UriMatcher(UriMatcher.NO_MATCH);
        // 如果match()方法匹配AUTHORITY的值加上/TB 则返回1
        MATCHER.addURI(table.AUTHORITY, "tb", TB);
        // 如果match()方法匹配AUTHORITY的值加上/TB/数字 则返回2
        MATCHER.addURI(table.AUTHORITY, "tb/#", TB_ID);
        // 加*标示任意字符
    }

    /*
     * 每当ContentProvider启动时都会回调onCreate()方法。此方法主要执行一些ContentProvider初始化
     * 的工作，返回true表示初始化成功，返回false则初始化失败。
     */
    @Override
    public boolean onCreate() {
        databaseHelper = new DatabaseHelper(getContext());
        return true;
    }

    @Override
    public Cursor query(Uri uri, String[] projection, String selection,
            String[] selectionArgs, String sortOrder) {
        SQLiteQueryBuilder qb = new SQLiteQueryBuilder();
        switch(MATCHER.match(uri)) {
            case TB:
                qb.setTables(DatabaseHelper.DB_TABLE);
                qb.setProjectionMap(projectMap);
                break;
            case TB_ID:
                qb.setTables(DatabaseHelper.DB_TABLE);
                qb.setProjectionMap(projectMap);
                qb.appendWhere(table.KEY_ID + "="
                        + uri.getPathSegments().get(1));
                // uri.getPathSegments().get(1)用来获得URI中的参数
                break;
        }
        SQLiteDatabase db = databaseHelper.getReadableDatabase();
        Cursor c = qb.query(db, projection, selection, selectionArgs, null,
                null, sortOrder);

        c.setNotificationUri(getContext().getContentResolver(), uri);
        return c;
    }

    @Override
    public String getType(Uri uri) {
        switch(MATCHER.match(uri)) {
            case TB:
                return table.CONTENT_TYPE;
            case TB_ID:
                return table.CONTENT_ITEM_TYPE;
            default:
                throw new IllegalArgumentException("Unknow URI " + uri);
        } 
    }

    @Override
    public Uri insert(Uri uri, ContentValues values) {
        switch(MATCHER.match(uri)) {
            case TB:
                ContentValues v2 = new ContentValues(values);
                // 判断是否存在该值
                if(!v2.containsKey(table.KEY_NAME)) {
                    values.put(table.KEY_NAME, "def_name");
                }
                if(!v2.containsKey(table.KEY_NUM)) {
                    values.put(table.KEY_NUM, "def_num");
                }
                SQLiteDatabase db = databaseHelper.getWritableDatabase();
                // 返回行ID
                long rowId = db.insert(databaseHelper.DB_TABLE, table.KEY_NAME,
                        values);
                if(rowId > 0) {
                    // 生成一个URI content://d.m.dbname/tb/1
                    Uri noteUri = ContentUris.withAppendedId(
                            Uri.parse("content://" + table.AUTHORITY + "/tb"),
                            rowId);
                    // 监听数据库的程序发一个通知
                    getContext().getContentResolver().notifyChange(noteUri,
                            null);
                    return noteUri;
                }
                break;
        }
        return null;
    }

    @Override
    // 删除数据
    public int delete(Uri uri, String where, String[] whereArgs) {
        SQLiteDatabase db = databaseHelper.getWritableDatabase();
        int count;
        switch(MATCHER.match(uri)) {
            case TB:
                count = db.delete(DatabaseHelper.DB_TABLE, where, whereArgs);
                break;

            case TB_ID:
                String noteId = uri.getPathSegments().get(1);
                count = db.delete(DatabaseHelper.DB_TABLE, table.KEY_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 = databaseHelper.getWritableDatabase();
        int count;
        switch(MATCHER.match(uri)) {
            case TB:
                count = db.update(DatabaseHelper.DB_TABLE, values, where,
                        whereArgs);
                break;

            case TB_ID:
                String noteId = uri.getPathSegments().get(1);
                count = db.update(DatabaseHelper.DB_TABLE, values, table.KEY_ID
                        + "="
                        + noteId
                        + (!TextUtils.isEmpty(where) ? " AND (" + where + ')'
                                : ""), whereArgs);
                break;

            default:
                throw new IllegalArgumentException("Unknown URI " + uri);
        }
        // 监听数据库的程序发一个通知
        getContext().getContentResolver().notifyChange(uri, null);
        return count;
    }
}