android5 位置信息默认选中 安卓content://位置

一、特性

(1)应用之间数据分享接口机制之一

(2)提供更高级的数据共享方法,应用程序可以指定要共享的数据，其他应用可以在不知道数据来源、路径的情况下，对共享数据进行增、删、改、查

(3)许多android系统内置的数据也可通过ContenProvider提供给用户使用，如音视频文件、图片、通讯录等。

二、使用ContentProvider

调用者使用ContentResolver通过Uri来间接操纵ContentProvider

 

ContentResolver 通过URI 确定所要访问的ContentProvider的数据集

   URI格式:   content://<authority>/<data_path>/<id>

          content://      固定前缀

          <authority>     数据授权者,一般采用数据授权者的包名(惟一性) 

          <data_path>     授权的数据路径，如果数据集是表格，则为表明，  如果操作对象是整个数据集，则<id>不需填写

          <id>            行记录

   eg:

     想访问com.aug.customedcontentprovider 里面的people数据集合

     content://com.aug.customedcontentprovider/people

     只想查看com.aug.customedcontentprovider里面的people数据集合中的第N项

     content://com.aug.customedcontentprovider/people/N

     当然，通过ID去指定太过死板，我们往往也不知道自己要访问的数据记录在第几行， 通常是通过URI再加上限制条件来实现的。

在发起一个请求(insert/delete/query)的过程中，Android根据URI确定要处理的ContentResolver,然后初始化ContentResolver需要的资源（由系统自动完成）;

一般情况下，一个ContentResolver对象访问ContentProvider，但是ContentProvider可以同时与多个ContentResolver进行交互;

在使用者看来，只是使用了数据提供者通过ContentProvider提供了一组标准的数据接口，但是并不知道数据提供者具体操作的是数据库、SharedPreferences、还是File、或者网络文件，即数据提供者屏蔽了数据存储方法;

ContentProvider的数据模式类似于数据表的行记录

数据提供者会继承ContentProvider提供的六个函数并进行重写override:

insert()      添加数据集

delete()      删除数据集

update()      更新数据集

onCreate()    初始化底层数据集和建立数据连接

query()       查询数据集

getType()     返回URI的MIME类型

              如果URI是单条数据，返回的MIME类型为 vnd.android.cursor.item

              如果URI是多条数据，返回的MIME类型为 vnd.android.cursor.dir

1.创建ContentProvider

(1)处于操作方便，建议将要操作的数据集封装成一个类，添上必要的数据属性。eg:

package com.aug.customedcontentprovider;


 import android.net.Uri;


 public class ElementObject {
private static final String TAG = "ElementObject";
public static final String MIME_DIR_PREFIX = "vnd.android.cursor.dir";
public static final String MIME_ITEM_PREFIX = "vnd.android.cursor.item";
public static final String MIME_ITEM = "vnd.aug.people";

public static final String MIME_TYPE_SINGLE = MIME_ITEM_PREFIX + "/" + MIME_ITEM;
public static final String MIME_TYPE_MULTIPLE = MIME_DIR_PREFIX + "/" + MIME_ITEM;

public static final String AUTHORITY = "com.aug.customedcontentprovider";
public static final String PATH_SINGLE = "people/#";
public static final String PATH_MULTIPLE = "people";

public static final String CONTENT_URI_STRING = "content://" + AUTHORITY + "/" + PATH_MULTIPLE;
public static final Uri CONTENT_URI = Uri.parse(CONTENT_URI_STRING);

public static final String KEY_ID = "_id";
public static final String KEY_NAME = "name";
public static final String KEY_AGE = "age";
public static final String KEY_HEIGHT = "height";
 }

(2)创建自己的数据提供者，底层数据形式以数据库为例

package com.aug.customedcontentprovider;


 import java.util.logging.Handler;
 import java.util.logging.LogRecord;


 import android.content.ContentProvider;
 import android.content.ContentResolver;
 import android.content.ContentUris;
 import android.content.ContentValues;
 import android.content.Context;
 import android.content.UriMatcher;
 import android.database.ContentObserver;
 import android.database.Cursor;
 import android.database.sqlite.SQLiteDatabase;
 import android.database.sqlite.SQLiteDatabase.CursorFactory;
 import android.database.sqlite.SQLiteOpenHelper;
 import android.database.sqlite.SQLiteQueryBuilder;
 import android.net.Uri;
 import android.os.Message;
 import android.util.Log;


 public class CustomedContentProvider extends ContentProvider {
private static final String TAG = "CustomedContentProvider";
private static final String DB_NAME = "user.db";
public static final String DB_TABLE = "people";
private static final int DB_VERSION = 1;

private SQLiteDatabase mDb;
private DBOpenHelper mDbOpenHelper;
private MyContentObserver mMtCobs;
private ContentObserver mCobs;
private android.os.Handler mHandler;
private static final int MULTI_USERS = 1;
private static final int SINGLE_USER = 2;
private static final UriMatcher m_UriMatcher;
static {
m_UriMatcher = new UriMatcher(UriMatcher.NO_MATCH);
m_UriMatcher.addURI(ElementObject.AUTHORITY, ElementObject.PATH_MULTIPLE, MULTI_USERS);
m_UriMatcher.addURI(ElementObject.AUTHORITY, ElementObject.PATH_SINGLE, SINGLE_USER);
}

private static class DBOpenHelper extends SQLiteOpenHelper {
private static final String DB_CREATE = "create table if not exists " + DB_TABLE + "(" + ElementObject.KEY_ID + " integer primary key autoincrement, "
+ ElementObject.KEY_NAME + " text not null, " + ElementObject.KEY_AGE + " integer, " + ElementObject.KEY_HEIGHT + " float);";

public DBOpenHelper(Context context, String name,
CursorFactory factory, int version) {
super(context, name, factory, version);
// TODO Auto-generated constructor stub
}


@Override
public void onCreate(SQLiteDatabase db) {
// TODO Auto-generated method stub
db.execSQL(DB_CREATE);
}


@Override
public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
// TODO Auto-generated method stub
db.execSQL("drop database if exists " + DB_TABLE);
onCreate(db);
}

}

@Override
public int delete(Uri uri, String selection, String[] selectionArgs) {
// TODO Auto-generated method stub
int nCount = 0;

switch (m_UriMatcher.match(uri)) {
case MULTI_USERS:
nCount = mDb.delete(DB_TABLE, selection, selectionArgs);
break;
case SINGLE_USER:
String segment = uri.getPathSegments().get(1);
nCount = mDb.delete(DB_TABLE, ElementObject.KEY_ID + "=" + segment, selectionArgs);
break;
default:
throw new IllegalArgumentException("Unknown Uri: " + uri);
}

getContext().getContentResolver().notifyChange(uri, null);//该函数通知数据集观察者数据有变化，观察者可以通过ContentResolver注册mCobs


return nCount;
}


@Override
public String getType(Uri uri) {
// TODO Auto-generated method stub
switch (m_UriMatcher.match(uri)) {
case MULTI_USERS:
return ElementObject.MIME_TYPE_MULTIPLE;
case SINGLE_USER:
return ElementObject.MIME_TYPE_SINGLE;
default:
throw new IllegalArgumentException("Unknown uri:" + uri);
}
}


@Override
public Uri insert(Uri uri, ContentValues cvs) {//#4
// TODO Auto-generated method stub
long id = mDb.insert(DB_TABLE, null, cvs);//#5
if (id > 0) {
Uri uriTmp = ContentUris.withAppendedId(ElementObject.CONTENT_URI, id);
getContext().getContentResolver().notifyChange(uriTmp, null);      //#6
return uriTmp;
}

//throw new SQLException("Fail to insert !" + uri);
return null;
}


//注册数据集观察者
public void registerObserver(Uri uri) {
ContentResolver cr = this.getContext().getContentResolver();
//cr.registerContentObserver(uri, true, mMtCobs);
cr.registerContentObserver(uri, true, mCobs);
/*cr.registerContentObserver(uri, true, new ContentObserver(mHandler){


@Override
public void onChange(boolean selfChange) {
// TODO Auto-generated method stub
super.onChange(selfChange);
Log.d(TAG, "数据集有变化  5!");
}
});*/
}

private class MyContentObserver extends ContentObserver {


@Override
public void onChange(boolean selfChange) {
// TODO Auto-generated method stub
super.onChange(selfChange);

Log.d(TAG, "数据集有变化  4!");
}


public MyContentObserver(android.os.Handler handler) {
super(handler);
// TODO Auto-generated constructor stub
}

public MyContentObserver(Context _context, android.os.Handler _handler){
super(_handler);
Log.d(TAG, "数据集有变化  2!");
}
}

@Override
public boolean onCreate() {//只要有访问该数据集，都会先调到此入口//#3
// TODO Auto-generated method stub
Log.d(TAG, "Oncreate 1 !");
Context context = getContext();
mDbOpenHelper = new DBOpenHelper(context, DB_NAME, null, DB_VERSION);
mDb = mDbOpenHelper.getWritableDatabase();

if (mDb == null) {
return false;
}

mHandler = new android.os.Handler(){


@Override
public void handleMessage(Message msg) {
// TODO Auto-generated method stub
super.handleMessage(msg);
//do what you want
Log.d(TAG, "数据集有变化  3!");
}
};

//mMtCobs = new MyContentObserver(this.getContext(), /*mHandler*/null);
mCobs = new ContentObserver(/*mHandler*/null){//当传入handler不为空的时候，不会走到onChange,而应该是走到handler对应的里面去了


@Override
public void onChange(boolean selfChange) {   //#7
// TODO Auto-generated method stub
super.onChange(selfChange);
Log.d(TAG, "数据集有变化  1!");
}
};

registerObserver(ElementObject.CONTENT_URI);
return false;
}


@Override
public Cursor query(Uri uri, String[] projectionIn, String selection, String[] selectionArgs,
String sortOrder) {
// TODO Auto-generated method stub
SQLiteQueryBuilder sqb = new SQLiteQueryBuilder();
sqb.setTables(DB_TABLE);

switch (m_UriMatcher.match(uri)) {
case MULTI_USERS:
break;
case SINGLE_USER:
sqb.appendWhere(ElementObject.KEY_ID + "=" + uri.getPathSegments().get(1));
break;
default:
break;
}

Cursor cs = sqb.query(mDb, projectionIn, selection, selectionArgs, null, null, sortOrder);
cs.setNotificationUri(getContext().getContentResolver(), uri);
return cs;
}


@Override
public int update(Uri uri, ContentValues cvs, String selection, String[] selectionArgs) {
// TODO Auto-generated method stub
int nCount = 0;
switch (m_UriMatcher.match(uri)) {
case MULTI_USERS:
   nCount = mDb.update(DB_TABLE, cvs, selection, selectionArgs);
break;
case SINGLE_USER:
nCount = mDb.update(DB_TABLE, cvs, ElementObject.KEY_ID + "=" + uri.getPathSegments().get(1), selectionArgs);
break;
default:
throw new IllegalArgumentException("Unknown Uri:" + uri);
}

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

》》》针对数据库的改动，给ContentProvider提供一个观察者，以便于检测数据库的变化，对恶意改动做处理等。

2.创建接口测试类测试ContentProvider的接口功能

package com.aug.customedcontentprovider;


 import java.util.logging.Handler;


 import android.content.ContentResolver;
 import android.content.ContentValues;
 import android.database.ContentObserver;
 import android.database.Cursor;
 import android.net.Uri;
 import android.test.AndroidTestCase;
 import android.util.Log;


 public class CustomedContentProviderTest extends AndroidTestCase {
private static final String TAG = "CustomedContentProviderTest";

public void testInsert() {
ContentResolver cr = this.getContext().getContentResolver();              //#1
Uri uri = Uri.parse("content://com.aug.customedcontentprovider/people");  //#2

ContentValues cvs = new ContentValues();
cvs.put(ElementObject.KEY_NAME, "张三");
cvs.put(ElementObject.KEY_AGE, 10);
cvs.put(ElementObject.KEY_HEIGHT, 100.1);

cr.insert(uri, cvs);
cvs.clear();

cvs.put(ElementObject.KEY_NAME, "李四");
cvs.put(ElementObject.KEY_AGE, 20);
cvs.put(ElementObject.KEY_HEIGHT, 200.1);
cr.insert(uri, cvs);

cvs.clear();

cvs.put(ElementObject.KEY_NAME, "王五");
cvs.put(ElementObject.KEY_AGE, 10);
cvs.put(ElementObject.KEY_HEIGHT, 300.1);
cr.insert(uri, cvs);

Log.d(TAG, "testInsert OK ! " + cr.insert(uri, cvs));
}

public void testDelete() {
ContentResolver cr = this.getContext().getContentResolver();
Uri uri = Uri.parse("content://com.aug.customedcontentprovider/people");
String sqlWhereClause = ElementObject.KEY_NAME + "=?";
int nResult = 0;
nResult = cr.delete(uri, sqlWhereClause, new String[]{"李四"});
Log.d(TAG, "nResult =  OK !" + nResult);
}

public void testQuerySingle() {
ContentResolver cr = this.getContext().getContentResolver();
Uri uri = Uri.parse("content://com.aug.customedcontentprovider/people");
Cursor cs = cr.query(uri, new String[]{ElementObject.KEY_ID, ElementObject.KEY_NAME, ElementObject.KEY_AGE, ElementObject.KEY_HEIGHT}, 
ElementObject.KEY_NAME + "=?", new String[]{"李四"}, ElementObject.KEY_AGE);
while (cs.moveToNext()) {
Log.d(TAG, "(" + cs.getInt(0) + ", " + cs.getString(1) + ", " + cs.getInt(2) + ", " + cs.getFloat(3));
}
}

public void testQueryMulti() {
ContentResolver cr = this.getContext().getContentResolver();
Uri uri = Uri.parse("content://com.aug.customedcontentprovider/people");
Cursor cs = cr.query(uri, null, null, null, ElementObject.KEY_AGE);
while (cs.moveToNext()) {
Log.d(TAG, "(" + cs.getInt(0) + ", " + cs.getString(1) + ", " + cs.getInt(2) + ", " + cs.getFloat(3));
}
}
public void testUpdate() {
ContentResolver cr = this.getContext().getContentResolver();
Uri uri = Uri.parse("content://com.aug.customedcontentprovider/people");
ContentValues cvs = new ContentValues();
cvs.put(ElementObject.KEY_AGE, 11000);

int nCount = cr.update(uri, cvs, ElementObject.KEY_NAME + "=?", new String[]{"李四"});
Log.d(TAG, "nCount:" + nCount);
}

public void testGetType() {
ContentResolver cr = this.getContext().getContentResolver();
Uri uri = Uri.parse("content://com.aug.customedcontentprovider/people");
Log.d(TAG, cr.getType(uri));
}
 }

运行以上测试接口，以testInsert为例，观察接口调用顺序:

#1 ->  #7

每一次针对数据集的操作都会走上面的流程。

3.测试接口需修改AndroidManifest.xml

<manifest xmlns:android="http://schemas.android.com/apk/res/android"
     package="com.aug.customedcontentprovider"
     android:versinotallow="1"
     android:versinotallow="1.0" >


     <uses-sdk
         android:minSdkVersinotallow="8"
         android:targetSdkVersinotallow="16" />


     <application
         android:allowBackup="true"
         android:icnotallow="@drawable/ic_launcher"
         android:label="@string/app_name"
         android:theme="@style/AppTheme" >
         <uses-library android:name="android.test.runner"/>
         <provider android:name=".CustomedContentProvider"
             android:authorities="com.aug.customedcontentprovider"/>
     </application>
<instrumentation android:name="android.test.InstrumentationTestRunner"     
         android:targetPackage="com.aug.customedcontentprovider" 
         android:label="Tests for My App" />
 </manifest>