Links
Android Sites
Language
Results
Loading...
1
/*
2
* Copyright 2013 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.example.android.basicsyncadapter.provider;
18
19
import android.content.ContentProvider;
20
import android.content.ContentValues;
21
import android.content.Context;
22
import android.content.UriMatcher;
23
import android.database.Cursor;
24
import android.database.sqlite.SQLiteDatabase;
25
import android.database.sqlite.SQLiteOpenHelper;
26
import android.net.Uri;
27
28
import com.example.android.common.db.SelectionBuilder;
29
30
public class FeedProvider extends ContentProvider {
31
FeedDatabase mDatabaseHelper;
32
33
/**
34
* Content authority for this provider.
35
*/
36
private static final String AUTHORITY = FeedContract.CONTENT_AUTHORITY;
37
38
// The constants below represent individual URI routes, as IDs. Every URI pattern recognized by
39
// this ContentProvider is defined using sUriMatcher.addURI(), and associated with one of these
40
// IDs.
41
//
42
// When a incoming URI is run through sUriMatcher, it will be tested against the defined
43
// URI patterns, and the corresponding route ID will be returned.
44
/**
45
* URI ID for route: /entries
46
*/
47
public static final int ROUTE_ENTRIES = 1;
48
49
/**
50
* URI ID for route: /entries/{ID}
51
*/
52
public static final int ROUTE_ENTRIES_ID = 2;
53
54
/**
55
* UriMatcher, used to decode incoming URIs.
56
*/
57
private static final UriMatcher sUriMatcher = new UriMatcher(UriMatcher.NO_MATCH);
58
static {
59
sUriMatcher.addURI(AUTHORITY, "entries", ROUTE_ENTRIES);
60
sUriMatcher.addURI(AUTHORITY, "entries/*", ROUTE_ENTRIES_ID);
61
}
62
63
@Override
64
public boolean onCreate() {
65
mDatabaseHelper = new FeedDatabase(getContext());
66
return true;
67
}
68
69
/**
70
* Determine the mime type for entries returned by a given URI.
71
*/
72
@Override
73
public String getType(Uri uri) {
74
final int match = sUriMatcher.match(uri);
75
switch (match) {
76
case ROUTE_ENTRIES:
77
return FeedContract.Entry.CONTENT_TYPE;
78
case ROUTE_ENTRIES_ID:
79
return FeedContract.Entry.CONTENT_ITEM_TYPE;
80
default:
81
throw new UnsupportedOperationException("Unknown uri: " + uri);
82
}
83
}
84
85
/**
86
* Perform a database query by URI.
87
*
88
* <p>Currently supports returning all entries (/entries) and individual entries by ID
89
* (/entries/{ID}).
90
*/
91
@Override
92
public Cursor query(Uri uri, String[] projection, String selection, String[] selectionArgs,
93
String sortOrder) {
94
SQLiteDatabase db = mDatabaseHelper.getReadableDatabase();
95
SelectionBuilder builder = new SelectionBuilder();
96
int uriMatch = sUriMatcher.match(uri);
97
switch (uriMatch) {
98
case ROUTE_ENTRIES_ID:
99
// Return a single entry, by ID.
100
String id = uri.getLastPathSegment();
101
builder.where(FeedContract.Entry._ID + "=?", id);
102
case ROUTE_ENTRIES:
103
// Return all known entries.
104
builder.table(FeedContract.Entry.TABLE_NAME)
105
.where(selection, selectionArgs);
106
Cursor c = builder.query(db, projection, sortOrder);
107
// Note: Notification URI must be manually set here for loaders to correctly
108
// register ContentObservers.
109
Context ctx = getContext();
110
assert ctx != null;
111
c.setNotificationUri(ctx.getContentResolver(), uri);
112
return c;
113
default:
114
throw new UnsupportedOperationException("Unknown uri: " + uri);
115
}
116
}
117
118
/**
119
* Insert a new entry into the database.
120
*/
121
@Override
122
public Uri insert(Uri uri, ContentValues values) {
123
final SQLiteDatabase db = mDatabaseHelper.getWritableDatabase();
124
assert db != null;
125
final int match = sUriMatcher.match(uri);
126
Uri result;
127
switch (match) {
128
case ROUTE_ENTRIES:
129
long id = db.insertOrThrow(FeedContract.Entry.TABLE_NAME, null, values);
130
result = Uri.parse(FeedContract.Entry.CONTENT_URI + "/" + id);
131
break;
132
case ROUTE_ENTRIES_ID:
133
throw new UnsupportedOperationException("Insert not supported on URI: " + uri);
134
default:
135
throw new UnsupportedOperationException("Unknown uri: " + uri);
136
}
137
// Send broadcast to registered ContentObservers, to refresh UI.
138
Context ctx = getContext();
139
assert ctx != null;
140
ctx.getContentResolver().notifyChange(uri, null, false);
141
return result;
142
}
143
144
/**
145
* Delete an entry by database by URI.
146
*/
147
@Override
148
public int delete(Uri uri, String selection, String[] selectionArgs) {
149
SelectionBuilder builder = new SelectionBuilder();
150
final SQLiteDatabase db = mDatabaseHelper.getWritableDatabase();
151
final int match = sUriMatcher.match(uri);
152
int count;
153
switch (match) {
154
case ROUTE_ENTRIES:
155
count = builder.table(FeedContract.Entry.TABLE_NAME)
156
.where(selection, selectionArgs)
157
.delete(db);
158
break;
159
case ROUTE_ENTRIES_ID:
160
String id = uri.getLastPathSegment();
161
count = builder.table(FeedContract.Entry.TABLE_NAME)
162
.where(FeedContract.Entry._ID + "=?", id)
163
.where(selection, selectionArgs)
164
.delete(db);
165
break;
166
default:
167
throw new UnsupportedOperationException("Unknown uri: " + uri);
168
}
169
// Send broadcast to registered ContentObservers, to refresh UI.
170
Context ctx = getContext();
171
assert ctx != null;
172
ctx.getContentResolver().notifyChange(uri, null, false);
173
return count;
174
}
175
176
/**
177
* Update an etry in the database by URI.
178
*/
179
@Override
180
public int update(Uri uri, ContentValues values, String selection, String[] selectionArgs) {
181
SelectionBuilder builder = new SelectionBuilder();
182
final SQLiteDatabase db = mDatabaseHelper.getWritableDatabase();
183
final int match = sUriMatcher.match(uri);
184
int count;
185
switch (match) {
186
case ROUTE_ENTRIES:
187
count = builder.table(FeedContract.Entry.TABLE_NAME)
188
.where(selection, selectionArgs)
189
.update(db, values);
190
break;
191
case ROUTE_ENTRIES_ID:
192
String id = uri.getLastPathSegment();
193
count = builder.table(FeedContract.Entry.TABLE_NAME)
194
.where(FeedContract.Entry._ID + "=?", id)
195
.where(selection, selectionArgs)
196
.update(db, values);
197
break;
198
default:
199
throw new UnsupportedOperationException("Unknown uri: " + uri);
200
}
201
Context ctx = getContext();
202
assert ctx != null;
203
ctx.getContentResolver().notifyChange(uri, null, false);
204
return count;
205
}
206
207
/**
208
* SQLite backend for @{link FeedProvider}.
209
*
210
* Provides access to an disk-backed, SQLite datastore which is utilized by FeedProvider. This
211
* database should never be accessed by other parts of the application directly.
212
*/
213
static class FeedDatabase extends SQLiteOpenHelper {
214
/** Schema version. */
215
public static final int DATABASE_VERSION = 1;
216
/** Filename for SQLite file. */
217
public static final String DATABASE_NAME = "feed.db";
218
219
private static final String TYPE_TEXT = " TEXT";
220
private static final String TYPE_INTEGER = " INTEGER";
221
private static final String COMMA_SEP = ",";
222
/** SQL statement to create "entry" table. */
223
private static final String SQL_CREATE_ENTRIES =
224
"CREATE TABLE " + FeedContract.Entry.TABLE_NAME + " (" +
225
FeedContract.Entry._ID + " INTEGER PRIMARY KEY," +
226
FeedContract.Entry.COLUMN_NAME_ENTRY_ID + TYPE_TEXT + COMMA_SEP +
227
FeedContract.Entry.COLUMN_NAME_TITLE + TYPE_TEXT + COMMA_SEP +
228
FeedContract.Entry.COLUMN_NAME_LINK + TYPE_TEXT + COMMA_SEP +
229
FeedContract.Entry.COLUMN_NAME_PUBLISHED + TYPE_INTEGER + ")";
230
231
/** SQL statement to drop "entry" table. */
232
private static final String SQL_DELETE_ENTRIES =
233
"DROP TABLE IF EXISTS " + FeedContract.Entry.TABLE_NAME;
234
235
public FeedDatabase(Context context) {
236
super(context, DATABASE_NAME, null, DATABASE_VERSION);
237
}
238
239
@Override
240
public void onCreate(SQLiteDatabase db) {
241
db.execSQL(SQL_CREATE_ENTRIES);
242
}
243
244
@Override
245
public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
246
// This database is only a cache for online data, so its upgrade policy is
247
// to simply to discard the data and start over
248
db.execSQL(SQL_DELETE_ENTRIES);
249
onCreate(db);
250
}
251
}
252
}