/*
** Copyright 2006, The Android Open Source Project
**
** Licensed under the Apache License, Version 2.0 (the "License");
** you may not use this file except in compliance with the License.
** You may obtain a copy of the License at
**
** http://www.apache.org/licenses/LICENSE-2.0
**
** Unless required by applicable law or agreed to in writing, software
** distributed under the License is distributed on an "AS IS" BASIS,
** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
** See the License for the specific language governing permissions and
** limitations under the License.
*/
package com.android.providers.subscribedfeeds;
import android.content.UriMatcher;
import android.content.*;
import android.database.Cursor;
import android.database.DatabaseUtils;
import android.database.sqlite.SQLiteDatabase;
import android.database.sqlite.SQLiteQueryBuilder;
import android.net.Uri;
import android.provider.SubscribedFeeds;
import android.text.TextUtils;
import android.util.Config;
import android.util.Log;
import java.util.Collections;
import java.util.Map;
import java.util.HashMap;
/**
* Manages a list of feeds for which this client is interested in receiving
* change notifications.
*/
public class SubscribedFeedsProvider extends AbstractSyncableContentProvider {
private static final String TAG = "SubscribedFeedsProvider";
private static final String DATABASE_NAME = "subscribedfeeds.db";
private static final int DATABASE_VERSION = 10;
private static final int FEEDS = 1;
private static final int FEED_ID = 2;
private static final int DELETED_FEEDS = 3;
private static final int ACCOUNTS = 4;
private static final Map<String, String> ACCOUNTS_PROJECTION_MAP;
private static final UriMatcher sURLMatcher =
new UriMatcher(UriMatcher.NO_MATCH);
private static String sFeedsTable = "feeds";
private static Uri sFeedsUrl =
Uri.parse("content://subscribedfeeds/feeds/");
private static String sDeletedFeedsTable = "_deleted_feeds";
private static Uri sDeletedFeedsUrl =
Uri.parse("content://subscribedfeeds/deleted_feeds/");
public SubscribedFeedsProvider() {
super(DATABASE_NAME, DATABASE_VERSION, sFeedsUrl);
}
static {
sURLMatcher.addURI("subscribedfeeds", "feeds", FEEDS);
sURLMatcher.addURI("subscribedfeeds", "feeds/#", FEED_ID);
sURLMatcher.addURI("subscribedfeeds", "deleted_feeds", DELETED_FEEDS);
sURLMatcher.addURI("subscribedfeeds", "accounts", ACCOUNTS);
}
@Override
protected boolean upgradeDatabase(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 TRIGGER IF EXISTS feed_cleanup");
db.execSQL("DROP TABLE IF EXISTS _deleted_feeds");
db.execSQL("DROP TABLE IF EXISTS feeds");
bootstrapDatabase(db);
return false; // this was lossy
}
@Override
protected void bootstrapDatabase(SQLiteDatabase db) {
super.bootstrapDatabase(db);
db.execSQL("CREATE TABLE feeds (" +
"_id INTEGER PRIMARY KEY," +
"_sync_account TEXT," + // From the sync source
"_sync_id TEXT," + // From the sync source
"_sync_time TEXT," + // From the sync source
"_sync_version TEXT," + // From the sync source
"_sync_local_id INTEGER," + // Used while syncing,
// never stored persistently
"_sync_dirty INTEGER," + // if syncable, set if the record
// has local, unsynced, changes
"_sync_mark INTEGER," + // Used to filter out new rows
"feed TEXT," +
"authority TEXT," +
"service TEXT" +
");");
// Trigger to completely remove feeds data when they're deleted
db.execSQL("CREATE TRIGGER feed_cleanup DELETE ON feeds " +
"WHEN old._sync_id is not null " +
"BEGIN " +
"INSERT INTO _deleted_feeds " +
"(_sync_id, _sync_account, _sync_version) " +
"VALUES (old._sync_id, old._sync_account, " +
"old._sync_version);" +
"END");
db.execSQL("CREATE TABLE _deleted_feeds (" +
"_sync_version TEXT," + // From the sync source
"_sync_id TEXT," +
(isTemporary() ? "_sync_local_id INTEGER," : "") + // Used while syncing,
"_sync_account TEXT," +
"_sync_mark INTEGER, " + // Used to filter out new rows
"UNIQUE(_sync_id))");
}
@Override
protected void onDatabaseOpened(SQLiteDatabase db) {
db.markTableSyncable("feeds", "_deleted_feeds");
}
@Override
protected Iterable<FeedMerger> getMergers() {
return Collections.singletonList(new FeedMerger());
}
@Override
public String getType(Uri url) {
int match = sURLMatcher.match(url);
switch (match) {
case FEEDS:
return SubscribedFeeds.Feeds.CONTENT_TYPE;
case FEED_ID:
return SubscribedFeeds.Feeds.CONTENT_ITEM_TYPE;
default:
throw new IllegalArgumentException("Unknown URL");
}
}
@Override
public Cursor queryInternal(Uri url, String[] projection,
String selection, String[] selectionArgs, String sortOrder) {
SQLiteQueryBuilder qb = new SQLiteQueryBuilder();
// Generate the body of the query
int match = sURLMatcher.match(url);
if (Config.LOGV) Log.v(TAG, "SubscribedFeedsProvider.query: url=" +
url + ", match is " + match);
switch (match) {
case FEEDS:
qb.setTables(sFeedsTable);
break;
case DELETED_FEEDS:
if (!isTemporary()) {
throw new UnsupportedOperationException();
}
qb.setTables(sDeletedFeedsTable);
break;
case ACCOUNTS:
qb.setTables(sFeedsTable);
qb.setDistinct(true);
qb.setProjectionMap(ACCOUNTS_PROJECTION_MAP);
return qb.query(getDatabase(), projection, selection, selectionArgs,
SubscribedFeeds.Feeds._SYNC_ACCOUNT, null, sortOrder);
case FEED_ID:
qb.setTables(sFeedsTable);
qb.appendWhere(sFeedsTable + "._id=");
qb.appendWhere(url.getPathSegments().get(1));
break;
default:
throw new IllegalArgumentException("Unknown URL " + url);
}
// run the query
return qb.query(getDatabase(), projection, selection, selectionArgs,
null, null, sortOrder);
}
@Override
public Uri insertInternal(Uri url, ContentValues initialValues) {
final SQLiteDatabase db = getDatabase();
Uri resultUri = null;
long rowID;
int match = sURLMatcher.match(url);
switch (match) {
case FEEDS:
ContentValues values = new ContentValues(initialValues);
values.put(SubscribedFeeds.Feeds._SYNC_DIRTY, 1);
rowID = db.insert(sFeedsTable, "feed", values);
if (rowID > 0) {
resultUri = Uri.parse(
"content://subscribedfeeds/feeds/" + rowID);
}
break;
case DELETED_FEEDS:
if (!isTemporary()) {
throw new UnsupportedOperationException();
}
rowID = db.insert(sDeletedFeedsTable, "_sync_id",
initialValues);
if (rowID > 0) {
resultUri = Uri.parse(
"content://subscribedfeeds/deleted_feeds/" + rowID);
}
break;
default:
throw new UnsupportedOperationException(
"Cannot insert into URL: " + url);
}
return resultUri;
}
@Override
public int deleteInternal(Uri url, String userWhere, String[] whereArgs) {
final SQLiteDatabase db = getDatabase();
String changedItemId;
switch (sURLMatcher.match(url)) {
case FEEDS:
changedItemId = null;
break;
case FEED_ID:
changedItemId = url.getPathSegments().get(1);
break;
default:
throw new UnsupportedOperationException(
"Cannot delete that URL: " + url);
}
String where = addIdToWhereClause(changedItemId, userWhere);
return db.delete(sFeedsTable, where, whereArgs);
}
@Override
public int updateInternal(Uri url, ContentValues initialValues,
String userWhere, String[] whereArgs) {
final SQLiteDatabase db = getDatabase();
ContentValues values = new ContentValues(initialValues);
values.put(SubscribedFeeds.Feeds._SYNC_DIRTY, 1);
String changedItemId;
switch (sURLMatcher.match(url)) {
case FEEDS:
changedItemId = null;
break;
case FEED_ID:
changedItemId = url.getPathSegments().get(1);
break;
default:
throw new UnsupportedOperationException(
"Cannot update URL: " + url);
}
String where = addIdToWhereClause(changedItemId, userWhere);
return db.update(sFeedsTable, values, where, whereArgs);
}
private static String addIdToWhereClause(String id, String where) {
if (id != null) {
StringBuilder whereSb = new StringBuilder("_id=");
whereSb.append(id);
if (!TextUtils.isEmpty(where)) {
whereSb.append(" AND (");
whereSb.append(where);
whereSb.append(')');
}
return whereSb.toString();
} else {
return where;
}
}
private class FeedMerger extends AbstractTableMerger {
private ContentValues mValues = new ContentValues();
FeedMerger() {
super(getDatabase(), sFeedsTable, sFeedsUrl, sDeletedFeedsTable, sDeletedFeedsUrl);
}
@Override
protected void notifyChanges() {
getContext().getContentResolver().notifyChange(
sFeedsUrl, null /* data change observer */,
false /* do not sync to network */);
}
@Override
public void insertRow(ContentProvider diffs, Cursor diffsCursor) {
final SQLiteDatabase db = getDatabase();
// We don't ever want to add entries from the server, instead
// we want to tell the server to delete any entries we receive
// from the server that aren't already known by the client.
mValues.clear();
DatabaseUtils.cursorStringToContentValues(diffsCursor,
SubscribedFeeds.Feeds._SYNC_ID, mValues);
DatabaseUtils.cursorStringToContentValues(diffsCursor,
SubscribedFeeds.Feeds._SYNC_ACCOUNT, mValues);
DatabaseUtils.cursorStringToContentValues(diffsCursor,
SubscribedFeeds.Feeds._SYNC_VERSION, mValues);
db.replace(mDeletedTable, SubscribedFeeds.Feeds._SYNC_ID, mValues);
}
@Override
public void updateRow(long localPersonID, ContentProvider diffs,
Cursor diffsCursor) {
updateOrResolveRow(localPersonID, null, diffs, diffsCursor, false);
}
@Override
public void resolveRow(long localPersonID, String syncID,
ContentProvider diffs, Cursor diffsCursor) {
updateOrResolveRow(localPersonID, syncID, diffs, diffsCursor, true);
}
protected void updateOrResolveRow(long localPersonID, String syncID,
ContentProvider diffs, Cursor diffsCursor, boolean conflicts) {
mValues.clear();
// only copy over the fields that the server owns
DatabaseUtils.cursorStringToContentValues(diffsCursor,
SubscribedFeeds.Feeds._SYNC_ID, mValues);
DatabaseUtils.cursorStringToContentValues(diffsCursor,
SubscribedFeeds.Feeds._SYNC_TIME, mValues);
DatabaseUtils.cursorStringToContentValues(diffsCursor,
SubscribedFeeds.Feeds._SYNC_VERSION, mValues);
mValues.put(SubscribedFeeds.Feeds._SYNC_DIRTY, conflicts ? 1 : 0);
final SQLiteDatabase db = getDatabase();
db.update(mTable, mValues,
SubscribedFeeds.Feeds._ID + '=' + localPersonID, null);
}
@Override
public void deleteRow(Cursor localCursor) {
// Since the client is the authority we don't actually delete
// the row when the server says it has been deleted. Instead
// we break the association with the server by clearing out
// the id, time, and version, then we mark it dirty so that
// it will be synced back to the server.
long localPersonId = localCursor.getLong(localCursor.getColumnIndex(
SubscribedFeeds.Feeds._ID));
mValues.clear();
mValues.put(SubscribedFeeds.Feeds._SYNC_DIRTY, 1);
mValues.put(SubscribedFeeds.Feeds._SYNC_ID, (String) null);
mValues.put(SubscribedFeeds.Feeds._SYNC_TIME, (Long) null);
mValues.put(SubscribedFeeds.Feeds._SYNC_VERSION, (String) null);
final SQLiteDatabase db = getDatabase();
db.update(mTable, mValues, SubscribedFeeds.Feeds._ID + '=' + localPersonId, null);
localCursor.moveToNext();
}
}
static {
Map<String, String> map;
map = new HashMap<String, String>();
ACCOUNTS_PROJECTION_MAP = map;
map.put(SubscribedFeeds.Accounts._COUNT, "COUNT(*) AS _count");
map.put(SubscribedFeeds.Accounts._SYNC_ACCOUNT, SubscribedFeeds.Accounts._SYNC_ACCOUNT);
}
}