src/com/android/providers/contacts/SocialProvider.java - platform/packages/providers/ContactsProvider - Git at Google

 /*
  * 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>();
         // TODO: fix display name reference (in fact, use the contacts view instead of the table)
         columns.put(Contacts.DISPLAY_NAME, "contact." + Contacts.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);
         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);
     }
 }
	/*
	* 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>();
	// TODO: fix display name reference (in fact, use the contacts view instead of the table)
	columns.put(Contacts.DISPLAY_NAME, "contact." + Contacts.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);
	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);
	}
	}