packages/SubscribedFeedsProvider/src/com/android/providers/subscribedfeeds/SubscribedFeedsProvider.java

/*
** 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);
    }
}