本文详细介绍了Android中的ContentProvider组件，通过具体实例展示了如何使用ContentProvider进行数据库的增删查改操作。
说说ContentProvider的用法
作者：尚弦月 | 出处：博客园 | 2011/12/10 17:28:46 | 阅读
16次
最近写了一个数据库，这个数据库的服务没包装在Provider中，导致在测试的时候老是出现Cursor没有关闭的问题，搞不定，所以决定把数据的增删查改都写在Provider中，刚开始的时候不知道怎么写，参考了下源码中的闹钟的Provider。
下面是系统源码中的闹钟的Provider：
1 /*
2 * Copyright (C) 2007 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17 package com.android.alarmclock;
18
19 import android.content.ContentProvider;
20 import android.content.ContentUris;
21 import android.content.ContentValues;
22 import android.content.Context;
23 import android.content.UriMatcher;
24 import android.database.Cursor;
25 import android.database.SQLException;
26 import android.database.sqlite.SQLiteDatabase;
27 import android.database.sqlite.SQLiteOpenHelper;
28 import android.database.sqlite.SQLiteQueryBuilder;
29 import android.net.Uri;
30 import android.text.TextUtils;
31
32 public class AlarmProvider extends ContentProvider {
33 private SQLiteOpenHelper mOpenHelper;
34
35 private static final int ALARMS = 1 ;
36 private static final int ALARMS_ID = 2 ;
37 private static final UriMatcher sURLMatcher = new UriMatcher(
38 UriMatcher.NO_MATCH);
39
40 static {
41 sURLMatcher.addURI( " com.android.alarmclock " , " alarm " , ALARMS);
42 sURLMatcher.addURI( " com.android.alarmclock " , " alarm/# " , ALARMS_ID);
43 }
44
45 private static class DatabaseHelper extends SQLiteOpenHelper {
46 private static final String DATABASE_NAME = " alarms.db " ;
47 private static final int DATABASE_VERSION = 5 ;
48
49 public DatabaseHelper(Context context) {
50 super (context, DATABASE_NAME, null , DATABASE_VERSION);
51 }
52
53 @Override
54 public void onCreate(SQLiteDatabase db) {
55 db.execSQL( " CREATE TABLE alarms ( " +
56 " _id INTEGER PRIMARY KEY, " +
57 " hour INTEGER, " +
58 " minutes INTEGER, " +
59 " daysofweek INTEGER, " +
60 " alarmtime INTEGER, " +
61 " enabled INTEGER, " +
62 " vibrate INTEGER, " +
63 " message TEXT, " +
64 " alert TEXT); " );
65
66 // insert default alarms
67 String insertMe = " INSERT INTO alarms " +
68 " (hour, minutes, daysofweek, alarmtime, enabled, vibrate, message, alert) " +
69 " VALUES " ;
70 db.execSQL(insertMe + " (7, 0, 127, 0, 0, 1, '', ''); " );
71 db.execSQL(insertMe + " (8, 30, 31, 0, 0, 1, '', ''); " );
72 db.execSQL(insertMe + " (9, 00, 0, 0, 0, 1, '', ''); " );
73 }
74
75 @Override
76 public void onUpgrade(SQLiteDatabase db, int oldVersion, int currentVersion) {
77 if (Log.LOGV) Log.v(
78 " Upgrading alarms database from version " +
79 oldVersion + " to " + currentVersion +
80 " , which will destroy all old data " );
81 db.execSQL( " DROP TABLE IF EXISTS alarms " );
82 onCreate(db);
83 }
84 }
85
86 public AlarmProvider() {
87 }
88
89 @Override
90 public boolean onCreate() {
91 mOpenHelper = new DatabaseHelper(getContext());
92 return true ;
93 }
94
95 @Override
96 public Cursor query(Uri url, String[] projectionIn, String selection,
97 String[] selectionArgs, String sort) {
98 SQLiteQueryBuilder qb = new SQLiteQueryBuilder();
99
100 // Generate the body of the query
101 int match = sURLMatcher.match(url);
102 switch (match) {
103 case ALARMS:
104 qb.setTables( " alarms " );
105 break ;
106 case ALARMS_ID:
107 qb.setTables( " alarms " );
108 qb.appendWhere( " _id= " );
109 qb.appendWhere(url.getPathSegments().get( 1 ));
110 break ;
111 default :
112 throw new IllegalArgumentException( " Unknown URL " + url);
113 }
114
115 SQLiteDatabase db = mOpenHelper.getReadableDatabase();
116 Cursor ret = qb.query(db, projectionIn, selection, selectionArgs,
117 null , null , sort);
118
119 if (ret == null ) {
120 if (Log.LOGV) Log.v( " Alarms.query: failed " );
121 } else {
122 ret.setNotificationUri(getContext().getContentResolver(), url);
123 }
124
125 return ret;
126 }
127
128 @Override
129 public String getType(Uri url) {
130 int match = sURLMatcher.match(url);
131 switch (match) {
132 case ALARMS:
133 return " vnd.android.cursor.dir/alarms " ;
134 case ALARMS_ID:
135 return " vnd.android.cursor.item/alarms " ;
136 default :
137 throw new IllegalArgumentException( " Unknown URL " );
138 }
139 }
140
141 @Override
142 public int update(Uri url, ContentValues values, String where, String[] whereArgs) {
143 int count;
144 long rowId = 0 ;
145 int match = sURLMatcher.match(url);
146 SQLiteDatabase db = mOpenHelper.getWritableDatabase();
147 switch (match) {
148 case ALARMS_ID: {
149 String segment = url.getPathSegments().get( 1 );
150 rowId = Long.parseLong(segment);
151 count = db.update( " alarms " , values, " _id= " + rowId, null );
152 break ;
153 }
154 default : {
155 throw new UnsupportedOperationException(
156 " Cannot update URL: " + url);
157 }
158 }
159 if (Log.LOGV) Log.v( " *** notifyChange() rowId: " + rowId + " url " + url);
160 getContext().getContentResolver().notifyChange(url, null );
161 return count;
162 }
163
164 @Override
165 public Uri insert(Uri url, ContentValues initialValues) {
166 if (sURLMatcher.match(url) != ALARMS) {
167 throw new IllegalArgumentException( " Cannot insert into URL: " + url);
168 }
169
170 ContentValues values;
171 if (initialValues != null )
172 values = new ContentValues(initialValues);
173 else
174 values = new ContentValues();
175
176 if ( ! values.containsKey(Alarm.Columns.HOUR))
177 values.put(Alarm.Columns.HOUR, 0 );
178
179 if ( ! values.containsKey(Alarm.Columns.MINUTES))
180 values.put(Alarm.Columns.MINUTES, 0 );
181
182 if ( ! values.containsKey(Alarm.Columns.DAYS_OF_WEEK))
183 values.put(Alarm.Columns.DAYS_OF_WEEK, 0 );
184
185 if ( ! values.containsKey(Alarm.Columns.ALARM_TIME))
186 values.put(Alarm.Columns.ALARM_TIME, 0 );
187
188 if ( ! values.containsKey(Alarm.Columns.ENABLED))
189 values.put(Alarm.Columns.ENABLED, 0 );
190
191 if ( ! values.containsKey(Alarm.Columns.VIBRATE))
192 values.put(Alarm.Columns.VIBRATE, 1 );
193
194 if ( ! values.containsKey(Alarm.Columns.MESSAGE))
195 values.put(Alarm.Columns.MESSAGE, "" );
196
197 if ( ! values.containsKey(Alarm.Columns.ALERT))
198 values.put(Alarm.Columns.ALERT, "" );
199
200 SQLiteDatabase db = mOpenHelper.getWritableDatabase();
201 long rowId = db.insert( " alarms " , Alarm.Columns.MESSAGE, values);
202 if (rowId < 0 ) {
203 throw new SQLException( " Failed to insert row into " + url);
204 }
205 if (Log.LOGV) Log.v( " Added alarm rowId = " + rowId);
206
207 Uri newUrl = ContentUris.withAppendedId(Alarm.Columns.CONTENT_URI, rowId);
208 getContext().getContentResolver().notifyChange(newUrl, null );
209 return newUrl;
210 }
211
212 public int delete(Uri url, String where, String[] whereArgs) {
213 SQLiteDatabase db = mOpenHelper.getWritableDatabase();
214 int count;
215 long rowId = 0 ;
216 switch (sURLMatcher.match(url)) {
217 case ALARMS:
218 count = db.delete( " alarms " , where, whereArgs);
219 break ;
220 case ALARMS_ID:
221 String segment = url.getPathSegments().get( 1 );
222 rowId = Long.parseLong(segment);
223 if (TextUtils.isEmpty(where)) {
224 where = " _id= " + segment;
225 } else {
226 where = " _id= " + segment + " AND ( " + where + " ) " ;
227 }
228 count = db.delete( " alarms " , where, whereArgs);
229 break ;
230 default :
231 throw new IllegalArgumentException( " Cannot delete from URL: " + url);
232 }
233
234 getContext().getContentResolver().notifyChange(url, null );
235 return count;
236 }
237 }
其实对于数据库的操作，无非是四种，增删查改；在这里我仿照系统的闹钟的Provider自己写了一个Provider。以供以后忘记了的时候好参考参考：
首先我们邀创建一个数据库，并确定数据库是否生成。
1 package com.test.provider;
2
3 import android.content.ContentValues;
4 import android.content.Context;
5 import android.database.sqlite.SQLiteDatabase;
6 import android.database.sqlite.SQLiteOpenHelper;
7 import android.net.Uri;
8 import android.provider.BaseColumns;
9
10 public class AppDataBase extends SQLiteOpenHelper {
11
12 // 数据库的名字
13 private static final String DATABASE_NAME = " test.db " ;
14 private static final int DATABASE_VERSION = 1 ;
15 // 数据表的名字
16 private static final String TABLE_NAME = " test " ;
17 // 数据表中的字段
18 public static final String FIELD_ID = " field_id " ;
19 public static final String FIELD_SHOW = " field_show " ;
20 public static final String FIELD_LOCTION = " field_location " ;
21
22 // 用于表示该数据的一个Uri
23 public static final Uri CONTENT_URI = Uri.parse( " content://com.fermax.monitor/apps " );
24
25 // 创建数据库
26 public AppDataBase (Context context) {
27 super (context, DATABASE_NAME, null , DATABASE_VERSION);
28 }
29
30 // 创建表
31 @Override
32 public void onCreate (SQLiteDatabase db) {
33 String sql = " Create table " + TABLE_NAME + " ( " + BaseColumns._ID + " integer primary key autoincrement, " +
34 FIELD_ID + " integer not null, " +
35 FIELD_LOCTION + " integer not null, " +
36 FIELD_SHOW + " integer not null ); " ;
37 db.execSQL(sql);
38
39 initDataBase(db);
40 }
41
42 // 初始化表
43 private void initDataBase (SQLiteDatabase db) {
44 ContentValues cv = new ContentValues();
45 cv.put(FIELD_ID, 1 );
46 cv.put(FIELD_LOCTION, 1 );
47 cv.put(FIELD_SHOW, 1 );
48 db.insert(TABLE_NAME, null , cv);
49
50 cv.clear();
51 cv.put(FIELD_ID, 2 );
52 cv.put(FIELD_LOCTION, 2 );
53 cv.put(FIELD_SHOW, 1 );
54 db.insert(TABLE_NAME, null , cv);
55
56 cv.clear();
57 cv.put(FIELD_ID, 3 );
58 cv.put(FIELD_LOCTION, 3 );
59 cv.put(FIELD_SHOW, 0 );
60 db.insert(TABLE_NAME, null , cv);
61
62 cv.clear();
63 cv.put(FIELD_ID, 4 );
64 cv.put(FIELD_LOCTION, 4 );
65 cv.put(FIELD_SHOW, 1 );
66 db.insert(TABLE_NAME, null , cv);
67
68 cv.clear();
69 cv.put(FIELD_ID, 5 );
70 cv.put(FIELD_LOCTION, 5 );
71 cv.put(FIELD_SHOW, 0 );
72 db.insert(TABLE_NAME, null , cv);
73
74 cv.clear();
75 cv.put(FIELD_ID, 6 );
76 cv.put(FIELD_LOCTION, 6 );
77 cv.put(FIELD_SHOW, 0 );
78 db.insert(TABLE_NAME, null , cv);
79
80 cv.clear();
81 cv.put(FIELD_ID, 7 );
82 cv.put(FIELD_LOCTION, 7 );
83 cv.put(FIELD_SHOW, 0 );
84 db.insert(TABLE_NAME, null , cv);
85
86 cv.clear();
87 cv.put(FIELD_ID, 8 );
88 cv.put(FIELD_LOCTION, 8 );
89 cv.put(FIELD_SHOW, 1 );
90 db.insert(TABLE_NAME, null , cv);
91
92 cv.clear();
93 cv.put(FIELD_ID, 9 );
94 cv.put(FIELD_LOCTION, 9 );
95 cv.put(FIELD_SHOW, 0 );
96 db.insert(TABLE_NAME, null , cv);
97
98 cv.clear();
99 cv.put(FIELD_ID, 10 );
100 cv.put(FIELD_LOCTION, 10 );
101 cv.put(FIELD_SHOW, 0 );
102 db.insert(TABLE_NAME, null , cv);
103
104 cv.clear();
105 cv.put(FIELD_ID, 11 );
106 cv.put(FIELD_LOCTION, 11 );
107 cv.put(FIELD_SHOW, 0 );
108 db.insert(TABLE_NAME, null , cv);
109
110 cv.clear();
111 cv.put(FIELD_ID, 12 );
112 cv.put(FIELD_LOCTION, 12 );
113 cv.put(FIELD_SHOW, 0 );
114 db.insert(TABLE_NAME, null , cv);
115
116 cv.clear();
117 cv.put(FIELD_ID, 13 );
118 cv.put(FIELD_LOCTION, 13 );
119 cv.put(FIELD_SHOW, 0 );
120 db.insert(TABLE_NAME, null , cv);
121
122 cv.clear();
123 cv.put(FIELD_ID, 14 );
124 cv.put(FIELD_LOCTION, 14 );
125 cv.put(FIELD_SHOW, 1 );
126 db.insert(TABLE_NAME, null , cv);
127
128 cv.clear();
129 cv.put(FIELD_ID, 15 );
130 cv.put(FIELD_LOCTION, 15 );
131 cv.put(FIELD_SHOW, 1 );
132 db.insert(TABLE_NAME, null , cv);
133
134 cv.clear();
135 cv.put(FIELD_ID, 16 );
136 cv.put(FIELD_LOCTION, 16 );
137 cv.put(FIELD_SHOW, 1 );
138 db.insert(TABLE_NAME, null , cv);
139
140 cv.clear();
141 cv.put(FIELD_ID, 17 );
142 cv.put(FIELD_LOCTION, 17 );
143 cv.put(FIELD_SHOW, 0 );
144 db.insert(TABLE_NAME, null , cv);
145
146 cv.clear();
147 cv.put(FIELD_ID, 18 );
148 cv.put(FIELD_LOCTION, 18 );
149 cv.put(FIELD_SHOW, 1 );
150 db.insert(TABLE_NAME, null , cv);
151
152 cv.clear();
153 cv.put(FIELD_ID, 19 );
154 cv.put(FIELD_LOCTION, 19 );
155 cv.put(FIELD_SHOW, 0 );
156 db.insert(TABLE_NAME, null , cv);
157
158 cv.clear();
159 cv.put(FIELD_ID, 20 );
160 cv.put(FIELD_LOCTION, 20 );
161 cv.put(FIELD_SHOW, 0 );
162 db.insert(TABLE_NAME, null , cv);
163
164 cv.clear();
165 cv.put(FIELD_ID, 21 );
166 cv.put(FIELD_LOCTION, 21 );
167 cv.put(FIELD_SHOW, 0 );
168 db.insert(TABLE_NAME, null , cv);
169
170 cv.clear();
171 cv.put(FIELD_ID, 22 );
172 cv.put(FIELD_LOCTION, 22 );
173 cv.put(FIELD_SHOW, 0 );
174 db.insert(TABLE_NAME, null , cv);
175
176 cv.clear();
177 cv.put(FIELD_ID, 23 );
178 cv.put(FIELD_LOCTION, 23 );
179 cv.put(FIELD_SHOW, 0 );
180 db.insert(TABLE_NAME, null , cv);
181
182 cv.clear();
183 cv.put(FIELD_ID, 24 );
184 cv.put(FIELD_LOCTION, 24 );
185 cv.put(FIELD_SHOW, 0 );
186 db.insert(TABLE_NAME, null , cv);
187 }
188
189 // 用于更新表
190 @Override
191 public void onUpgrade (SQLiteDatabase db, int oldVersion, int newVersion) {
192 String sql = " DROP TABLE IF EXISTS " + TABLE_NAME;
193 db.execSQL(sql);
194 onCreate(db);
195 }
196 }
上面是创建了一个数据库并初始化了很多值，但我们并不知道数据库是否生成了，我们可以写一个测试类，来测试一下数据库是否生成了。
package com.test.provider;
import android.test.AndroidTestCase;
/**
* test the database.
* @author shang
*
*/
public class DBTest extends AndroidTestCase {
// 用于测试数据库是否生成
public void TestHomeDB() throws Exception {
AppDataBase appDataBase = new AppDataBase( this .getContext());
appDataBase.getWritableDatabase();
}
}
写完测试类后不要忘记在manifest.xml文件中加上包和instrumentation：
1 <!-- android:targetPackage 是用来存放生成的数据库的位置的，可以和manifest中的package相同 -->
2 < instrumentation
3 android:name ="android.test.InstrumentationTestRunner"
4 android:targetPackage ="com.test.provider"
5 android:label ="test for my app" />
如下所示：
还有测试包，这个放在application下面，上面一个放在manifest根目录下面：
1 <!-- 这个是用来说明android测试的包 -->
2 < uses-library android:name ="android.test.runner" />
然后运行测试包，看data中对应的目录下生成了数据库文件没有：
我们可以看到生成了数据库了，好了，既然生成了数据库，我们就要把数据库的增删查改包装在一个Provider中，这个Provider是要继承ContentProvider的：
1 package com.test.provider;
2
3 import android.content.ContentProvider;
4 import android.content.ContentUris;
5 import android.content.ContentValues;
6 import android.content.UriMatcher;
7 import android.database.Cursor;
8 import android.database.sqlite.SQLiteDatabase;
9 import android.database.sqlite.SQLiteOpenHelper;
10 import android.database.sqlite.SQLiteQueryBuilder;
11 import android.net.Uri;
12 import android.text.TextUtils;
13 import android.util.Log;
14
15 public class AppProvider extends ContentProvider {
16
17 private SQLiteOpenHelper mOpenHelper;
18
19 // 用于做所有的操作
20 private static final int APPS = 1 ;
21
22 // 用于做跟ID有关的操作
23 private static final int APPS_ID = 2 ;
24
25 // 初始化UriMatcher
26 private static final UriMatcher mUriMatcher = new UriMatcher(UriMatcher.NO_MATCH);
27
28 // 在UriMatcher中加入指定的Uri
29 static {
30 mUriMatcher.addURI( " com.fermax.monitor " , " apps " , APPS);
31 mUriMatcher.addURI( " com.fermax.monitor " , " apps/# " , APPS_ID);
32 }
33
34 // 拿到OpenHelper的对象
35 @Override
36 public boolean onCreate () {
37 mOpenHelper = new AppDataBase(getContext());
38 return true ;
39 }
40
41 // 做查询操作
42 @Override
43 public Cursor query (Uri uri, String[] projection, String selection,
44 String[] selectionArgs, String sortOrder) {
45 SQLiteQueryBuilder qb = new SQLiteQueryBuilder();
46
47 int match = mUriMatcher.match(uri);
48 switch (match) {
49 // 直接查询表中的所有的数据
50 case APPS:
51 qb.setTables( " test " );
52 break ;
53
54 // 根据Id查询
55 case APPS_ID:
56 qb.setTables( " test " );
57 qb.appendWhere( " _id = " );
58
59 // 拿到Uri后面的第一个参数，并将它赋给数据库中的字段_id.
60 qb.appendWhere(uri.getPathSegments().get( 1 ));
61 break ;
62
63 default :
64 throw new IllegalArgumentException( " Unknow Uri " + uri);
65 }
66
67 // 根据指定的条件查询数据，并返回Cursor
68 SQLiteDatabase db = mOpenHelper.getReadableDatabase();
69 Cursor ret = qb.query(db, projection, selection, selectionArgs, null , null , sortOrder);
70 if (ret == null ) {
71 Log.v( " ddd " , " apps: apps query failed " );
72 } else {
73 ret.setNotificationUri(getContext().getContentResolver(), uri);
74 }
75 return ret;
76 }
77
78 // 返回给定的Uri数据的MIME类型
79 @Override
80 public String getType (Uri uri) {
81 int match = mUriMatcher.match(uri);
82 switch (match) {
83 case APPS:
84 return " vnd.android.cursor.dir/apps " ;
85
86 case APPS_ID:
87 return " vnd.android.cursor.item/apps " ;
88
89 default :
90 throw new IllegalArgumentException( " Unknow uri " );
91 }
92 }
93
94 // 做插入操作
95 @Override
96 public Uri insert (Uri uri, ContentValues initialValues) {
97 // 插入操作要对所有的字段插入，如果带有参数，则报异常
98 if (mUriMatcher.match(uri) != APPS) {
99 throw new IllegalArgumentException( " Can not insert into uri " + uri);
100 }
101
102 // 将给定的值插入数据库，如果给的值为空，则设默认值0
103 ContentValues values;
104 if (initialValues != null ) {
105 values = new ContentValues(initialValues);
106 } else {
107 values = new ContentValues();
108 }
109
110 if ( ! values.containsKey(AppDataBase.FIELD_ID)) {
111 values.put(AppDataBase.FIELD_ID, 0 );
112 }
113
114 if ( ! values.containsKey(AppDataBase.FIELD_LOCTION)) {
115 values.put(AppDataBase.FIELD_LOCTION, 0 );
116 }
117
118 if ( ! values.containsKey(AppDataBase.FIELD_SHOW)) {
119 values.put(AppDataBase.FIELD_SHOW, 0 );
120 }
121
122 // 向表中插入数据。
123 SQLiteDatabase db = mOpenHelper.getWritableDatabase();
124 long rowId = db.insert( " test " , null , values);
125 if (rowId < 0 ) {
126 throw new IllegalArgumentException( " Failed to insert to " + uri);
127 }
128
129 Uri newUri = ContentUris.withAppendedId(AppDataBase.CONTENT_URI, rowId);
130 getContext().getContentResolver().notifyChange(newUri, null );
131 return newUri;
132 }
133
134 // 删除数据
135 @Override
136 public int delete (Uri uri, String selection, String[] selectionArgs) {
137 SQLiteDatabase db = mOpenHelper.getWritableDatabase();
138 int count;
139 int match = mUriMatcher.match(uri);
140 switch (match) {
141
142 // 如果没有参数，则删除指定的参数的列
143 case APPS:
144 count = db.delete( " test " , selection, selectionArgs);
145 break ;
146
147 // 如果带有参数ID，则删除指定的参数和指定Id的列
148 case APPS_ID:
149 String segment = uri.getPathSegments().get( 1 );
150 if (TextUtils.isEmpty(selection)) {
151 selection = " _id =" + segment;
152 } else {
153 selection = " _id =" + segment + " and ( " + selection + " ) " ;
154 }
155
156 // 执行删除操作
157 count = db.delete( " test " , selection, selectionArgs);
158 break ;
159
160 default :
161 throw new IllegalArgumentException( " can not delete from uri " + uri);
162
163 }
164 getContext().getContentResolver().notifyChange(uri, null );
165 return count;
166 }
167
168 // 执行更新操作
169 @Override
170 public int update (Uri uri, ContentValues values, String selection,
171 String[] selectionArgs) {
172 int count;
173 long rowId = 0 ;
174 int match = mUriMatcher.match(uri);
175 SQLiteDatabase db = mOpenHelper.getWritableDatabase();
176 switch (match) {
177 // 对指定的id的列进行更新
178 case APPS_ID:
179
180 // 拿到Uri参数中的id，并转化成long类型，然后根据指定的id更新
181 String segment = uri.getPathSegments().get( 1 );
182 rowId = Long.valueOf(segment);
183 count = db.update( " test " , values, " _id = " + rowId, null );
184 break ;
185
186 default :
187 throw new IllegalArgumentException( " can not update the uri " + uri);
188 }
189 getContext().getContentResolver().notifyChange(uri, null );
190 return count;
191 }
192
193 }
完了之后我们要在manifest里面注册这个Provider：
1 <!-- 注册数据库的Provider -->
2 < provider
3 android:name =".AppProvider"
4 android:authorities ="com.fermax.monitor"
5 android:exported ="true" /
完了之后就可以在测试类中测试了，用Provider做增删查改非常方便：
1
2 // 用于测试插入一条数据到数据库
3 public void testInsert() throws Exception {
4 ContentValues cv = new ContentValues();
5 cv.put(AppDataBase.FIELD_ID, 100 );
6 cv.put(AppDataBase.FIELD_LOCTION, 100 );
7 cv.put(AppDataBase.FIELD_SHOW, 100 );
8 getContext().getContentResolver().insert(AppDataBase.CONTENT_URI, cv);
9 }
10
11 // 用于测试从数据库中删除一条数据
12 public void testDelete() throws Exception {
13 int _id = 25 ;
14 String uriStr = " content://com.fermax.monitor/apps/ " + _id;
15 Uri uri = Uri.parse(uriStr);
16 getContext().getContentResolver().delete(uri, null , null );
17 }
18
19 // 用于测试从数据库中查询数据
20 public void testQuery() throws Exception {
21 Cursor c = getContext().getContentResolver().query(AppDataBase.CONTENT_URI, null , null , null , null );
22 if (c != null && c.getCount() != 0 ) {
23 while (c.moveToNext()) {
24 int location = c.getInt(c.getColumnIndexOrThrow(AppDataBase.FIELD_LOCTION));
25 System.out.println( " location = " + location);
26 }
27 }
28 c.close();
29 }
30
31 // 用于测试从数据库中更新一条数据
32 public void testUpdate() throws Exception {
33 int _id = 24 ;
34 String uriString = " content://com.fermax.monitor/apps/ " + _id;
35 Uri uri = Uri.parse(uriString);
36 ContentValues cv = new ContentValues();
37 cv.put(AppDataBase.FIELD_LOCTION, 150 );
38 getContext().getContentResolver().update(uri, cv, null , null );
39 }
运行完成之后可以去数据库中查看数据库中的数据是否发生了变化，这里我就不在赘述。
下面是这个工程的打包文件：
点击我下载
扫一扫
2027
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
