path: root/src/com/android/providers/contacts/SocialProvider.java

/*
 * Copyright (C) 2009 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.contacts;

import com.android.providers.contacts.ContactsDatabaseHelper.ActivitiesColumns;
import com.android.providers.contacts.ContactsDatabaseHelper.ContactsColumns;
import com.android.providers.contacts.ContactsDatabaseHelper.PackagesColumns;
import com.android.providers.contacts.ContactsDatabaseHelper.Tables;

import android.content.ContentProvider;
import android.content.ContentUris;
import android.content.ContentValues;
import android.content.Context;
import android.content.UriMatcher;
import android.database.Cursor;
import android.database.sqlite.SQLiteDatabase;
import android.database.sqlite.SQLiteQueryBuilder;
import android.provider.BaseColumns;
import android.provider.ContactsContract;
import android.provider.ContactsContract.Contacts;
import android.provider.ContactsContract.RawContacts;
import android.provider.SocialContract;
import android.provider.SocialContract.Activities;

import android.net.Uri;

import java.util.ArrayList;
import java.util.HashMap;

/**
 * Social activity content provider. The contract between this provider and
 * applications is defined in {@link SocialContract}.
 */
public class SocialProvider extends ContentProvider {
    // TODO: clean up debug tag
    private static final String TAG = "SocialProvider ~~~~";

    private static final UriMatcher sUriMatcher = new UriMatcher(UriMatcher.NO_MATCH);

    private static final int ACTIVITIES = 1000;
    private static final int ACTIVITIES_ID = 1001;
    private static final int ACTIVITIES_AUTHORED_BY = 1002;

    private static final int CONTACT_STATUS_ID = 3000;

    private static final String DEFAULT_SORT_ORDER = Activities.THREAD_PUBLISHED + " DESC, "
            + Activities.PUBLISHED + " ASC";

    /** Contains just the contacts columns */
    private static final HashMap<String, String> sContactsProjectionMap;
    /** Contains just the contacts columns */
    private static final HashMap<String, String> sRawContactsProjectionMap;
    /** Contains just the activities columns */
    private static final HashMap<String, String> sActivitiesProjectionMap;

    /** Contains the activities, raw contacts, and contacts columns, for joined tables */
    private static final HashMap<String, String> sActivitiesContactsProjectionMap;

    static {
        // Contacts URI matching table
        final UriMatcher matcher = sUriMatcher;

        matcher.addURI(SocialContract.AUTHORITY, "activities", ACTIVITIES);
        matcher.addURI(SocialContract.AUTHORITY, "activities/#", ACTIVITIES_ID);
        matcher.addURI(SocialContract.AUTHORITY, "activities/authored_by/#", ACTIVITIES_AUTHORED_BY);

        matcher.addURI(SocialContract.AUTHORITY, "contact_status/#", CONTACT_STATUS_ID);

        HashMap<String, String> columns;

        // Contacts projection map
        columns = new HashMap<String, String>();
        columns.put(Contacts.DISPLAY_NAME, ContactsColumns.CONCRETE_DISPLAY_NAME + " AS "
                + Contacts.DISPLAY_NAME);
        sContactsProjectionMap = columns;

        // Contacts projection map
        columns = new HashMap<String, String>();
        columns.put(RawContacts._ID, Tables.RAW_CONTACTS + "." + RawContacts._ID + " AS _id");
        columns.put(RawContacts.CONTACT_ID, RawContacts.CONTACT_ID);
        sRawContactsProjectionMap = columns;

        // Activities projection map
        columns = new HashMap<String, String>();
        columns.put(Activities._ID, "activities._id AS _id");
        columns.put(Activities.RES_PACKAGE, PackagesColumns.PACKAGE + " AS "
                + Activities.RES_PACKAGE);
        columns.put(Activities.MIMETYPE, Activities.MIMETYPE);
        columns.put(Activities.RAW_ID, Activities.RAW_ID);
        columns.put(Activities.IN_REPLY_TO, Activities.IN_REPLY_TO);
        columns.put(Activities.AUTHOR_CONTACT_ID, Activities.AUTHOR_CONTACT_ID);
        columns.put(Activities.TARGET_CONTACT_ID, Activities.TARGET_CONTACT_ID);
        columns.put(Activities.PUBLISHED, Activities.PUBLISHED);
        columns.put(Activities.THREAD_PUBLISHED, Activities.THREAD_PUBLISHED);
        columns.put(Activities.TITLE, Activities.TITLE);
        columns.put(Activities.SUMMARY, Activities.SUMMARY);
        columns.put(Activities.LINK, Activities.LINK);
        columns.put(Activities.THUMBNAIL, Activities.THUMBNAIL);
        sActivitiesProjectionMap = columns;

        // Activities, raw contacts, and contacts projection map for joins
        columns = new HashMap<String, String>();
        columns.putAll(sContactsProjectionMap);
        columns.putAll(sRawContactsProjectionMap);
        columns.putAll(sActivitiesProjectionMap); // Final _id will be from Activities
        sActivitiesContactsProjectionMap = columns;

    }

    private ContactsDatabaseHelper mDbHelper;

    /** {@inheritDoc} */
    @Override
    public boolean onCreate() {
        final Context context = getContext();
        mDbHelper = ContactsDatabaseHelper.getInstance(context);

        // TODO remove this, it's here to force opening the database on boot for testing
        mDbHelper.getReadableDatabase();

        return true;
    }

    /**
     * Called when a change has been made.
     *
     * @param uri the uri that the change was made to
     */
    private void onChange(Uri uri) {
        getContext().getContentResolver().notifyChange(ContactsContract.AUTHORITY_URI, null);
    }

    /** {@inheritDoc} */
    @Override
    public boolean isTemporary() {
        return false;
    }

    /** {@inheritDoc} */
    @Override
    public Uri insert(Uri uri, ContentValues values) {
        final int match = sUriMatcher.match(uri);
        long id = 0;
        switch (match) {
            case ACTIVITIES: {
                id = insertActivity(values);
                break;
            }

            default:
                throw new UnsupportedOperationException("Unknown uri: " + uri);
        }

        final Uri result = ContentUris.withAppendedId(Activities.CONTENT_URI, id);
        onChange(result);
        return result;
    }

    /**
     * Inserts an item into the {@link Tables#ACTIVITIES} table.
     *
     * @param values the values for the new row
     * @return the row ID of the newly created row
     */
    private long insertActivity(ContentValues values) {

        // TODO verify that IN_REPLY_TO != RAW_ID

        final SQLiteDatabase db = mDbHelper.getWritableDatabase();
        long id = 0;
        db.beginTransaction();
        try {
            // TODO: Consider enforcing Binder.getCallingUid() for package name
            // requested by this insert.

            // Replace package name and mime-type with internal mappings
            final String packageName = values.getAsString(Activities.RES_PACKAGE);
            if (packageName != null) {
                values.put(ActivitiesColumns.PACKAGE_ID, mDbHelper.getPackageId(packageName));
            }
            values.remove(Activities.RES_PACKAGE);

            final String mimeType = values.getAsString(Activities.MIMETYPE);
            values.put(ActivitiesColumns.MIMETYPE_ID, mDbHelper.getMimeTypeId(mimeType));
            values.remove(Activities.MIMETYPE);

            long published = values.getAsLong(Activities.PUBLISHED);
            long threadPublished = published;

            String inReplyTo = values.getAsString(Activities.IN_REPLY_TO);
            if (inReplyTo != null) {
                threadPublished = getThreadPublished(db, inReplyTo, published);
            }

            values.put(Activities.THREAD_PUBLISHED, threadPublished);

            // Insert the data row itself
            id = db.insert(Tables.ACTIVITIES, Activities.RAW_ID, values);

            // Adjust thread timestamps on replies that have already been inserted
            if (values.containsKey(Activities.RAW_ID)) {
                adjustReplyTimestamps(db, values.getAsString(Activities.RAW_ID), published);
            }

            db.setTransactionSuccessful();
        } finally {
            db.endTransaction();
        }
        return id;
    }

    /**
     * Finds the timestamp of the original message in the thread. If not found, returns
     * {@code defaultValue}.
     */
    private long getThreadPublished(SQLiteDatabase db, String rawId, long defaultValue) {
        String inReplyTo = null;
        long threadPublished = defaultValue;

        final Cursor c = db.query(Tables.ACTIVITIES,
                new String[]{Activities.IN_REPLY_TO, Activities.PUBLISHED},
                Activities.RAW_ID + " = ?", new String[]{rawId}, null, null, null);
        try {
            if (c.moveToFirst()) {
                inReplyTo = c.getString(0);
                threadPublished = c.getLong(1);
            }
        } finally {
            c.close();
        }

        if (inReplyTo != null) {

            // Call recursively to obtain the original timestamp of the entire thread
            return getThreadPublished(db, inReplyTo, threadPublished);
        }

        return threadPublished;
    }

    /**
     * In case the original message of a thread arrives after its reply messages, we need
     * to check if there are any replies in the database and if so adjust their thread_published.
     */
    private void adjustReplyTimestamps(SQLiteDatabase db, String inReplyTo, long threadPublished) {

        ContentValues values = new ContentValues();
        values.put(Activities.THREAD_PUBLISHED, threadPublished);

        /*
         * Issuing an exploratory update. If it updates nothing, we are done.  Otherwise,
         * we will run a query to find the updated records again and repeat recursively.
         */
        int replies = db.update(Tables.ACTIVITIES, values,
                Activities.IN_REPLY_TO + "= ?", new String[] {inReplyTo});

        if (replies == 0) {
            return;
        }

        /*
         * Presumably this code will be executed very infrequently since messages tend to arrive
         * in the order they get sent.
         */
        ArrayList<String> rawIds = new ArrayList<String>(replies);
        final Cursor c = db.query(Tables.ACTIVITIES,
                new String[]{Activities.RAW_ID},
                Activities.IN_REPLY_TO + " = ?", new String[] {inReplyTo}, null, null, null);
        try {
            while (c.moveToNext()) {
                rawIds.add(c.getString(0));
            }
        } finally {
            c.close();
        }

        for (String rawId : rawIds) {
            adjustReplyTimestamps(db, rawId, threadPublished);
        }
    }

    /** {@inheritDoc} */
    @Override
    public int delete(Uri uri, String selection, String[] selectionArgs) {
        final SQLiteDatabase db = mDbHelper.getWritableDatabase();

        final int match = sUriMatcher.match(uri);
        switch (match) {
            case ACTIVITIES_ID: {
                final long activityId = ContentUris.parseId(uri);
                return db.delete(Tables.ACTIVITIES, Activities._ID + "=" + activityId, null);
            }

            case ACTIVITIES_AUTHORED_BY: {
                final long contactId = ContentUris.parseId(uri);
                return db.delete(Tables.ACTIVITIES, Activities.AUTHOR_CONTACT_ID + "=" + contactId, null);
            }

            default:
                throw new UnsupportedOperationException("Unknown uri: " + uri);
        }
    }

    /** {@inheritDoc} */
    @Override
    public int update(Uri uri, ContentValues values, String selection, String[] selectionArgs) {
        throw new UnsupportedOperationException();
    }

    /** {@inheritDoc} */
    @Override
    public Cursor query(Uri uri, String[] projection, String selection, String[] selectionArgs,
            String sortOrder) {
        final SQLiteDatabase db = mDbHelper.getReadableDatabase();
        final SQLiteQueryBuilder qb = new SQLiteQueryBuilder();
        String limit = null;

        final int match = sUriMatcher.match(uri);
        switch (match) {
            case ACTIVITIES: {
                qb.setTables(Tables.ACTIVITIES_JOIN_PACKAGES_MIMETYPES_RAW_CONTACTS_CONTACTS);
                qb.setProjectionMap(sActivitiesContactsProjectionMap);
                break;
            }

            case ACTIVITIES_ID: {
                // TODO: enforce that caller has read access to this data
                long activityId = ContentUris.parseId(uri);
                qb.setTables(Tables.ACTIVITIES_JOIN_PACKAGES_MIMETYPES_RAW_CONTACTS_CONTACTS);
                qb.setProjectionMap(sActivitiesContactsProjectionMap);
                qb.appendWhere(Activities._ID + "=" + activityId);
                break;
            }

            case ACTIVITIES_AUTHORED_BY: {
                long contactId = ContentUris.parseId(uri);
                qb.setTables(Tables.ACTIVITIES_JOIN_PACKAGES_MIMETYPES_RAW_CONTACTS_CONTACTS);
                qb.setProjectionMap(sActivitiesContactsProjectionMap);
                qb.appendWhere(Activities.AUTHOR_CONTACT_ID + "=" + contactId);
                break;
            }

            case CONTACT_STATUS_ID: {
                long aggId = ContentUris.parseId(uri);
                qb.setTables(Tables.ACTIVITIES_JOIN_PACKAGES_MIMETYPES_RAW_CONTACTS_CONTACTS);
                qb.setProjectionMap(sActivitiesContactsProjectionMap);

                // Latest status of a contact is any top-level status
                // authored by one of its children contacts.
                qb.appendWhere(Activities.IN_REPLY_TO + " IS NULL AND ");
                qb.appendWhere(Activities.AUTHOR_CONTACT_ID + " IN (SELECT " + BaseColumns._ID
                        + " FROM " + Tables.RAW_CONTACTS + " WHERE " + RawContacts.CONTACT_ID + "="
                        + aggId + ")");
                sortOrder = Activities.PUBLISHED + " DESC";
                limit = "1";
                break;
            }

            default:
                throw new UnsupportedOperationException("Unknown uri: " + uri);
        }

        // Default to reverse-chronological sort if nothing requested
        if (sortOrder == null) {
            sortOrder = DEFAULT_SORT_ORDER;
        }

        // Perform the query and set the notification uri
        final Cursor c = qb.query(db, projection, selection, selectionArgs, null, null, sortOrder, limit);
        if (c != null) {
            c.setNotificationUri(getContext().getContentResolver(), ContactsContract.AUTHORITY_URI);
        }
        return c;
    }

    @Override
    public String getType(Uri uri) {
        final int match = sUriMatcher.match(uri);
        switch (match) {
            case ACTIVITIES:
            case ACTIVITIES_AUTHORED_BY:
                return Activities.CONTENT_TYPE;
            case ACTIVITIES_ID:
                final SQLiteDatabase db = mDbHelper.getReadableDatabase();
                long activityId = ContentUris.parseId(uri);
                return mDbHelper.getActivityMimeType(activityId);
            case CONTACT_STATUS_ID:
                return Contacts.CONTENT_ITEM_TYPE;
        }
        throw new UnsupportedOperationException("Unknown uri: " + uri);
    }
}