diff --git a/Android.mk b/Android.mk
index b13e757..e963f99 100644
--- a/Android.mk
+++ b/Android.mk
@@ -3,7 +3,8 @@
 
 LOCAL_MODULE_TAGS := user
 
-LOCAL_SRC_FILES := $(call all-subdir-java-files)
+# Only compile source java files in this apk.
+LOCAL_SRC_FILES := $(call all-java-files-under, src)
 
 LOCAL_JAVA_LIBRARIES := ext
 
@@ -11,3 +12,6 @@
 LOCAL_CERTIFICATE := shared
 
 include $(BUILD_PACKAGE)
+
+# Use the following include to make our test apk.
+include $(call all-makefiles-under,$(LOCAL_PATH))
diff --git a/AndroidManifest.xml b/AndroidManifest.xml
index 8f967d2..d7de1fb 100644
--- a/AndroidManifest.xml
+++ b/AndroidManifest.xml
@@ -7,20 +7,50 @@
     <uses-permission android:name="android.permission.GET_ACCOUNTS" />
     <uses-permission android:name="android.permission.READ_SYNC_STATS" />
     <uses-permission android:name="android.permission.INTERNET" />
+    <uses-permission android:name="android.permission.USE_CREDENTIALS" />
     <uses-permission android:name="com.google.android.googleapps.permission.GOOGLE_AUTH" />
     <uses-permission android:name="com.google.android.googleapps.permission.GOOGLE_AUTH.cp" />
     <uses-permission android:name="android.permission.SUBSCRIBED_FEEDS_READ" />
     <uses-permission android:name="android.permission.SUBSCRIBED_FEEDS_WRITE" />
 
     <application android:process="android.process.acore"
-                 android:label="@string/app_label"
-                 android:icon="@drawable/app_icon">
-        <provider android:name="ContactsProvider" android:authorities="contacts;call_log"
-                android:syncable="false" android:multiprocess="false"
-                android:readPermission="android.permission.READ_CONTACTS"
-                android:writePermission="android.permission.WRITE_CONTACTS">
-            <path-permission android:path="/people/search_suggest_query"
+        android:label="@string/app_label"
+        android:icon="@drawable/app_icon">
+
+        <provider android:name="ContactsProvider" 
+            android:authorities="contacts"
+            android:syncable="false" android:multiprocess="false"
+            android:readPermission="android.permission.READ_CONTACTS"
+            android:writePermission="android.permission.WRITE_CONTACTS">
+            <path-permission
+                    android:path="/people/search_suggest_query"
                     android:readPermission="android.permission.GLOBAL_SEARCH" />
         </provider>
+
+        <provider android:name="ContactsProvider2"
+            android:authorities="com.android.contacts"
+            android:syncable="false"
+            android:multiprocess="false"
+            android:readPermission="android.permission.READ_CONTACTS"
+            android:writePermission="android.permission.WRITE_CONTACTS">
+            <path-permission
+                    android:path="/contacts/search_suggest_query"
+                    android:readPermission="android.permission.GLOBAL_SEARCH" />
+        </provider>
+
+        <provider android:name="CallLogProvider"
+            android:authorities="call_log"
+            android:syncable="false" android:multiprocess="false"
+            android:readPermission="android.permission.READ_CONTACTS"
+            android:writePermission="android.permission.WRITE_CONTACTS">
+        </provider>
+
+        <!-- TODO: create permissions for social data -->
+        <provider android:name="SocialProvider"
+            android:authorities="com.android.social"
+            android:syncable="false"
+            android:multiprocess="false"
+            android:readPermission="android.permission.READ_CONTACTS"
+            android:writePermission="android.permission.WRITE_CONTACTS" />
     </application>
 </manifest>
diff --git a/res/values/strings.xml b/res/values/strings.xml
index 45637dd..ac119ed 100644
--- a/res/values/strings.xml
+++ b/res/values/strings.xml
@@ -1,5 +1,5 @@
-<?xml version="1.0" encoding="utf-8"?>
-<!-- Copyright (C) 2008 The Android Open Source Project
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- 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.
@@ -14,7 +14,8 @@
      limitations under the License.
 -->
 
-<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+           xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
 
     <!-- This is the label for the application that stores contacts data -->
     <string name="app_label">Contacts Storage</string>
diff --git a/src/com/android/providers/contacts/CallLogProvider.java b/src/com/android/providers/contacts/CallLogProvider.java
new file mode 100644
index 0000000..fbda970
--- /dev/null
+++ b/src/com/android/providers/contacts/CallLogProvider.java
@@ -0,0 +1,190 @@
+/*
+ * 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.OpenHelper.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.DatabaseUtils;
+import android.database.sqlite.SQLiteDatabase;
+import android.database.sqlite.SQLiteQueryBuilder;
+import android.net.Uri;
+import android.provider.CallLog;
+import android.provider.CallLog.Calls;
+
+import java.util.HashMap;
+
+/**
+ * Call log content provider.
+ */
+public class CallLogProvider extends ContentProvider {
+
+    private static final int CALLS = 1;
+
+    private static final int CALLS_ID = 2;
+
+    private static final int CALLS_FILTER = 3;
+
+    private static final UriMatcher sURIMatcher = new UriMatcher(UriMatcher.NO_MATCH);
+    static {
+        sURIMatcher.addURI(CallLog.AUTHORITY, "calls", CALLS);
+        sURIMatcher.addURI(CallLog.AUTHORITY, "calls/#", CALLS_ID);
+        sURIMatcher.addURI(CallLog.AUTHORITY, "calls/filter/*", CALLS_FILTER);
+    }
+
+    private static final HashMap<String, String> sCallsProjectionMap;
+    static {
+
+        // Calls projection map
+        sCallsProjectionMap = new HashMap<String, String>();
+        sCallsProjectionMap.put(Calls._ID, Calls._ID);
+        sCallsProjectionMap.put(Calls.NUMBER, Calls.NUMBER);
+        sCallsProjectionMap.put(Calls.DATE, Calls.DATE);
+        sCallsProjectionMap.put(Calls.DURATION, Calls.DURATION);
+        sCallsProjectionMap.put(Calls.TYPE, Calls.TYPE);
+        sCallsProjectionMap.put(Calls.NEW, Calls.NEW);
+        sCallsProjectionMap.put(Calls.CACHED_NAME, Calls.CACHED_NAME);
+        sCallsProjectionMap.put(Calls.CACHED_NUMBER_TYPE, Calls.CACHED_NUMBER_TYPE);
+        sCallsProjectionMap.put(Calls.CACHED_NUMBER_LABEL, Calls.CACHED_NUMBER_LABEL);
+    }
+
+    private OpenHelper mOpenHelper;
+    private DatabaseUtils.InsertHelper mCallsInserter;
+
+    @Override
+    public boolean onCreate() {
+        final Context context = getContext();
+
+        mOpenHelper = getOpenHelper(context);
+        SQLiteDatabase db = mOpenHelper.getWritableDatabase();
+        mCallsInserter = new DatabaseUtils.InsertHelper(db, Tables.CALLS);
+
+        return true;
+    }
+
+    /* Visible for testing */
+    protected OpenHelper getOpenHelper(final Context context) {
+        return OpenHelper.getInstance(context);
+    }
+
+    @Override
+    public Cursor query(Uri uri, String[] projection, String selection, String[] selectionArgs,
+            String sortOrder) {
+        SQLiteQueryBuilder qb = new SQLiteQueryBuilder();
+        int match = sURIMatcher.match(uri);
+        switch (match) {
+            case CALLS: {
+                qb.setTables("calls");
+                qb.setProjectionMap(sCallsProjectionMap);
+                break;
+            }
+
+            case CALLS_ID: {
+                qb.setTables("calls");
+                qb.setProjectionMap(sCallsProjectionMap);
+                qb.appendWhere("calls._id=");
+                qb.appendWhere(uri.getPathSegments().get(1));
+                break;
+            }
+
+            case CALLS_FILTER: {
+                qb.setTables("calls");
+                qb.setProjectionMap(sCallsProjectionMap);
+                String phoneNumber = uri.getPathSegments().get(2);
+                qb.appendWhere("PHONE_NUMBERS_EQUAL(number, ");
+                qb.appendWhereEscapeString(phoneNumber);
+                qb.appendWhere(")");
+                break;
+            }
+
+            default:
+                throw new IllegalArgumentException("Unknown URL " + uri);
+        }
+
+        final SQLiteDatabase db = mOpenHelper.getReadableDatabase();
+        Cursor c = qb.query(db, projection, selection, selectionArgs, null, null, sortOrder, null);
+        if (c != null) {
+            c.setNotificationUri(getContext().getContentResolver(), CallLog.CONTENT_URI);
+        }
+        return c;
+    }
+
+    @Override
+    public String getType(Uri uri) {
+        int match = sURIMatcher.match(uri);
+        switch (match) {
+            case CALLS:
+                return Calls.CONTENT_TYPE;
+            case CALLS_ID:
+                return Calls.CONTENT_ITEM_TYPE;
+            case CALLS_FILTER:
+                return Calls.CONTENT_TYPE;
+            default:
+                throw new IllegalArgumentException("Unknown URI: " + uri);
+        }
+    }
+
+    @Override
+    public Uri insert(Uri uri, ContentValues values) {
+        long rowId = mCallsInserter.insert(values);
+        if (rowId > 0) {
+            return ContentUris.withAppendedId(uri, rowId);
+        }
+        return null;
+    }
+
+    @Override
+    public int update(Uri url, ContentValues values, String selection, String[] selectionArgs) {
+        final SQLiteDatabase db = mOpenHelper.getWritableDatabase();
+        String where;
+        final int matchedUriId = sURIMatcher.match(url);
+        switch (matchedUriId) {
+            case CALLS:
+                where = selection;
+                break;
+
+            case CALLS_ID:
+                where = DatabaseUtils.concatenateWhere(selection, Calls._ID + "="
+                        + url.getPathSegments().get(1));
+                break;
+
+            default:
+                throw new UnsupportedOperationException("Cannot update URL: " + url);
+        }
+
+        return db.update(Tables.CALLS, values, where, selectionArgs);
+    }
+
+    @Override
+    public int delete(Uri uri, String selection, String[] selectionArgs) {
+        final SQLiteDatabase db = mOpenHelper.getWritableDatabase();
+
+        final int matchedUriId = sURIMatcher.match(uri);
+        switch (matchedUriId) {
+            case CALLS:
+                return db.delete(Tables.CALLS, selection, selectionArgs);
+
+            default:
+                throw new UnsupportedOperationException("Cannot delete that URL: " + uri);
+        }
+    }
+}
diff --git a/src/com/android/providers/contacts/ContactAggregationScheduler.java b/src/com/android/providers/contacts/ContactAggregationScheduler.java
new file mode 100644
index 0000000..59bb8cd
--- /dev/null
+++ b/src/com/android/providers/contacts/ContactAggregationScheduler.java
@@ -0,0 +1,176 @@
+/*
+ * 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 android.os.Handler;
+import android.os.HandlerThread;
+import android.os.Looper;
+import android.os.Message;
+import android.os.Process;
+
+/**
+ * A scheduler for asynchronous aggregation of contacts. Aggregation will start after
+ * a short delay after it is scheduled, unless it is scheduled again, in which case the
+ * aggregation pass is delayed.  There is an upper boundary on how long aggregation can
+ * be delayed.
+ */
+public class ContactAggregationScheduler {
+
+    public interface Aggregator {
+
+        /**
+         * Performs an aggregation run.
+         */
+        void run();
+
+        /**
+         * Interrupts aggregation.
+         */
+        void interrupt();
+    }
+
+    // Message ID used for communication with the aggregator
+    private static final int START_AGGREGATION_MESSAGE_ID = 1;
+
+    // Aggregation is delayed by this many milliseconds to allow changes to accumulate
+    public static final int AGGREGATION_DELAY = 500;
+
+    // Maximum delay of aggregation from the initial aggregation request
+    public static final int MAX_AGGREGATION_DELAY = 5000;
+
+    public static final int STATUS_STAND_BY = 0;
+    public static final int STATUS_SCHEDULED = 1;
+    public static final int STATUS_RUNNING = 2;
+
+    private Aggregator mAggregator;
+
+    // Aggregation status
+    private int mStatus = STATUS_STAND_BY;
+
+    // If true, we need to automatically reschedule aggregation after the current pass is done
+    private boolean mRescheduleWhenComplete;
+
+    // The time when aggregation was request for the first time. Reset when aggregation is completed
+    private long mInitialRequestTimestamp;
+
+    private HandlerThread mHandlerThread;
+    private Handler mMessageHandler;
+
+    public void setAggregator(Aggregator aggregator) {
+        mAggregator = aggregator;
+    }
+
+    public void start() {
+        mHandlerThread = new HandlerThread("ContactAggregator", Process.THREAD_PRIORITY_BACKGROUND);
+        mHandlerThread.start();
+        mMessageHandler = new Handler(mHandlerThread.getLooper()) {
+
+            @Override
+            public void handleMessage(Message msg) {
+                switch (msg.what) {
+                    case START_AGGREGATION_MESSAGE_ID:
+                        run();
+                        break;
+
+                    default:
+                        throw new IllegalStateException("Unhandled message: " + msg.what);
+                }
+            }
+        };
+    }
+
+    public void stop() {
+        mAggregator.interrupt();
+        Looper looper = mHandlerThread.getLooper();
+        if (looper != null) {
+            looper.quit();
+        }
+    }
+
+    /**
+     * Schedules an aggregation pass after a short delay.
+     */
+    public synchronized void schedule() {
+
+        switch (mStatus) {
+            case STATUS_STAND_BY: {
+
+                mInitialRequestTimestamp = currentTime();
+                mStatus = STATUS_SCHEDULED;
+                runDelayed();
+                break;
+            }
+
+            case STATUS_SCHEDULED: {
+
+                // If it has been less than MAX_AGGREGATION_DELAY millis since the initial request,
+                // reschedule the request.
+                if (currentTime() - mInitialRequestTimestamp < MAX_AGGREGATION_DELAY) {
+                    runDelayed();
+                }
+                break;
+            }
+
+            case STATUS_RUNNING: {
+
+                // If it has been less than MAX_AGGREGATION_DELAY millis since the initial request,
+                // interrupt the current pass and reschedule the request.
+                if (currentTime() - mInitialRequestTimestamp < MAX_AGGREGATION_DELAY) {
+                    mAggregator.interrupt();
+                }
+
+                mRescheduleWhenComplete = true;
+                break;
+            }
+        }
+    }
+
+    /**
+     * Called just before an aggregation pass begins.
+     */
+    public void run() {
+        synchronized (this) {
+            mStatus = STATUS_RUNNING;
+            mRescheduleWhenComplete = false;
+        }
+        try {
+            mAggregator.run();
+        } finally {
+            synchronized (this) {
+                mStatus = STATUS_STAND_BY;
+                mInitialRequestTimestamp = 0;
+                if (mRescheduleWhenComplete) {
+                    mRescheduleWhenComplete = false;
+                    schedule();
+                }
+            }
+        }
+    }
+
+    /* package */ void runDelayed() {
+
+        // If aggregation has already been requested, cancel the previous request
+        mMessageHandler.removeMessages(START_AGGREGATION_MESSAGE_ID);
+
+        // Schedule aggregation for AGGREGATION_DELAY milliseconds from now
+        mMessageHandler.sendEmptyMessageDelayed(
+                START_AGGREGATION_MESSAGE_ID, AGGREGATION_DELAY);
+    }
+
+    /* package */ long currentTime() {
+        return System.currentTimeMillis();
+    }
+}
diff --git a/src/com/android/providers/contacts/ContactAggregator.java b/src/com/android/providers/contacts/ContactAggregator.java
new file mode 100644
index 0000000..ad70640
--- /dev/null
+++ b/src/com/android/providers/contacts/ContactAggregator.java
@@ -0,0 +1,1226 @@
+/*
+ * 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.ContactMatcher.MatchScore;
+import com.android.providers.contacts.OpenHelper.AggregationExceptionColumns;
+import com.android.providers.contacts.OpenHelper.Clauses;
+import com.android.providers.contacts.OpenHelper.ContactsColumns;
+import com.android.providers.contacts.OpenHelper.MimetypesColumns;
+import com.android.providers.contacts.OpenHelper.NameLookupColumns;
+import com.android.providers.contacts.OpenHelper.NameLookupType;
+import com.android.providers.contacts.OpenHelper.RawContactsColumns;
+import com.android.providers.contacts.OpenHelper.Tables;
+
+import android.content.ContentValues;
+import android.content.Context;
+import android.database.Cursor;
+import android.database.DatabaseUtils;
+import android.database.sqlite.SQLiteDatabase;
+import android.database.sqlite.SQLiteQueryBuilder;
+import android.provider.ContactsContract.AggregationExceptions;
+import android.provider.ContactsContract.CommonDataKinds;
+import android.provider.ContactsContract.Contacts;
+import android.provider.ContactsContract.Data;
+import android.provider.ContactsContract.RawContacts;
+import android.provider.ContactsContract.CommonDataKinds.Email;
+import android.provider.ContactsContract.CommonDataKinds.Nickname;
+import android.provider.ContactsContract.CommonDataKinds.Phone;
+import android.provider.ContactsContract.CommonDataKinds.Photo;
+import android.provider.ContactsContract.CommonDataKinds.StructuredName;
+import android.text.TextUtils;
+import android.text.util.Rfc822Token;
+import android.text.util.Rfc822Tokenizer;
+import android.util.Log;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+
+
+/**
+ * ContactAggregator deals with aggregating contact information coming from different sources.
+ * Two John Doe contacts from two disjoint sources are presumed to be the same
+ * person unless the user declares otherwise.
+ * <p>
+ * ContactAggregator runs on a separate thread.
+ */
+public class ContactAggregator implements ContactAggregationScheduler.Aggregator {
+
+    private static final String TAG = "ContactAggregator";
+
+    // Data mime types used in the contact matching algorithm
+    private static final String MIMETYPE_SELECTION_IN_CLAUSE = MimetypesColumns.MIMETYPE + " IN ('"
+            + Email.CONTENT_ITEM_TYPE + "','"
+            + Nickname.CONTENT_ITEM_TYPE + "','"
+            + Phone.CONTENT_ITEM_TYPE + "','"
+            + StructuredName.CONTENT_ITEM_TYPE + "')";
+
+    private static final String[] DATA_JOIN_MIMETYPE_COLUMNS = new String[] {
+            MimetypesColumns.MIMETYPE,
+            Data.DATA1,
+            Data.DATA2
+    };
+
+    private static final int COL_MIMETYPE = 0;
+    private static final int COL_DATA1 = 1;
+    private static final int COL_DATA2 = 2;
+
+    private static final String[] DATA_JOIN_MIMETYPE_AND_CONTACT_COLUMNS = new String[] {
+            Data.DATA1, Data.DATA2, RawContacts.CONTACT_ID
+    };
+
+    private static final int COL_DATA_CONTACT_DATA1 = 0;
+    private static final int COL_DATA_CONTACT_DATA2 = 1;
+    private static final int COL_DATA_CONTACT_CONTACT_ID = 2;
+
+    private static final String[] NAME_LOOKUP_COLUMNS = new String[] {
+            RawContacts.CONTACT_ID, NameLookupColumns.NORMALIZED_NAME, NameLookupColumns.NAME_TYPE
+    };
+
+    private static final int COL_NAME_LOOKUP_CONTACT_ID = 0;
+    private static final int COL_NORMALIZED_NAME = 1;
+    private static final int COL_NAME_TYPE = 2;
+
+    private static final String[] AGGREGATE_EXCEPTION_JOIN_CONTACT_TWICE_COLUMNS = new String[]{
+            AggregationExceptions.TYPE,
+            AggregationExceptionColumns.RAW_CONTACT_ID1,
+            "raw_contacts1." + RawContacts.CONTACT_ID,
+            "raw_contacts2." + RawContacts.CONTACT_ID
+    };
+
+    private static final int COL_TYPE = 0;
+    private static final int COL_RAW_CONTACT_ID1 = 1;
+    private static final int COL_CONTACT_ID1 = 2;
+    private static final int COL_CONTACT_ID2 = 3;
+
+    private static final String[] CONTACT_ID_COLUMN = new String[] { RawContacts._ID };
+
+    private static final String[] CONTACT_OPTIONS_COLUMNS = new String[] {
+            RawContacts.CUSTOM_RINGTONE,
+            RawContacts.SEND_TO_VOICEMAIL,
+            RawContacts.LAST_TIME_CONTACTED,
+            RawContacts.TIMES_CONTACTED,
+            RawContacts.STARRED,
+    };
+
+    private static final int COL_CUSTOM_RINGTONE = 0;
+    private static final int COL_SEND_TO_VOICEMAIL = 1;
+    private static final int COL_LAST_TIME_CONTACTED = 2;
+    private static final int COL_TIMES_CONTACTED = 3;
+    private static final int COL_STARRED = 4;
+
+    private static final String[] CONTACT_ID_COLUMNS = new String[]{ RawContacts.CONTACT_ID };
+    private static final int COL_CONTACT_ID = 0;
+
+    private static final int MODE_INSERT_LOOKUP_DATA = 0;
+    private static final int MODE_AGGREGATION = 1;
+    private static final int MODE_SUGGESTIONS = 2;
+
+    private final OpenHelper mOpenHelper;
+    private final ContactAggregationScheduler mScheduler;
+
+    // Set if the current aggregation pass should be interrupted
+    private volatile boolean mCancel;
+
+    /**
+     * Captures a potential match for a given name. The matching algorithm
+     * constructs a bunch of NameMatchCandidate objects for various potential matches
+     * and then executes the search in bulk.
+     */
+    private static class NameMatchCandidate {
+        String mName;
+        int mLookupType;
+
+        public NameMatchCandidate(String name, int nameLookupType) {
+            mName = name;
+            mLookupType = nameLookupType;
+        }
+    }
+
+    /**
+     * A list of {@link NameMatchCandidate} that keeps its elements even when the list is
+     * truncated. This is done for optimization purposes to avoid excessive object allocation.
+     */
+    private static class MatchCandidateList {
+        private final ArrayList<NameMatchCandidate> mList = new ArrayList<NameMatchCandidate>();
+        private int mCount;
+
+        /**
+         * Adds a {@link NameMatchCandidate} element or updates the next one if it already exists.
+         */
+        public void add(String name, int nameLookupType) {
+            if (mCount >= mList.size()) {
+                mList.add(new NameMatchCandidate(name, nameLookupType));
+            } else {
+                NameMatchCandidate candidate = mList.get(mCount);
+                candidate.mName = name;
+                candidate.mLookupType = nameLookupType;
+            }
+            mCount++;
+        }
+
+        public void clear() {
+            mCount = 0;
+        }
+    }
+
+    /**
+     * Constructor.  Starts a contact aggregation thread.  Call {@link #quit} to kill the
+     * aggregation thread.  Call {@link #schedule} to kick off the aggregation process after
+     * a delay of {@link #AGGREGATION_DELAY} milliseconds.
+     */
+    public ContactAggregator(Context context, OpenHelper openHelper,
+            ContactAggregationScheduler scheduler) {
+        mOpenHelper = openHelper;
+        mScheduler = scheduler;
+        mScheduler.setAggregator(this);
+        mScheduler.start();
+
+        // Perform an aggregation pass in the beginning, which will most of the time
+        // do nothing.  It will only be useful if the content provider has been killed
+        // before completing aggregation.
+        mScheduler.schedule();
+    }
+
+    /**
+     * Schedules aggregation pass after a short delay.  This method should be called every time
+     * the {@link RawContacts#CONTACT_ID} field is reset on any record.
+     */
+    public void schedule() {
+        mScheduler.schedule();
+    }
+
+    /**
+     * Kills the contact aggregation thread.
+     */
+    public void quit() {
+        mScheduler.stop();
+    }
+
+    /**
+     * Invoked by the scheduler to cancel aggregation.
+     */
+    public void interrupt() {
+        mCancel = true;
+    }
+
+    /**
+     * Find all contacts that require aggregation and pass them through aggregation one by one.
+     * Do not call directly.  It is invoked by the scheduler.
+     */
+    public void run() {
+        mCancel = false;
+        Log.i(TAG, "Contact aggregation");
+
+        MatchCandidateList candidates = new MatchCandidateList();
+        ContactMatcher matcher = new ContactMatcher();
+        ContentValues values = new ContentValues();
+
+        final SQLiteDatabase db = mOpenHelper.getWritableDatabase();
+        final Cursor c = db.query(Tables.RAW_CONTACTS, new String[]{RawContacts._ID},
+                RawContacts.CONTACT_ID + " IS NULL AND "
+                        + RawContacts.AGGREGATION_MODE + "=" + RawContacts.AGGREGATION_MODE_DEFAULT,
+                null, null, null, null);
+
+        int totalCount = c.getCount();
+        int count = 0;
+        try {
+            if (c.moveToFirst()) {
+                db.beginTransaction();
+                try {
+                    do {
+                        if (mCancel) {
+                            break;
+                        }
+                        aggregateContact(db, c.getInt(0), candidates, matcher, values);
+                        count++;
+                        db.yieldIfContendedSafely();
+                    } while (c.moveToNext());
+
+                    db.setTransactionSuccessful();
+                } finally {
+                    db.endTransaction();
+                }
+            }
+        } finally {
+            c.close();
+
+            // Unless the aggregation pass was not interrupted, reset the last request timestamp
+            if (count == totalCount) {
+                Log.i(TAG, "Contact aggregation complete: " + totalCount);
+            } else {
+                Log.i(TAG, "Contact aggregation interrupted: " + count + "/" + totalCount);
+            }
+        }
+    }
+
+    /**
+     * Synchronously aggregate the specified contact.
+     */
+    public void aggregateContact(long rawContactId) {
+        final SQLiteDatabase db = mOpenHelper.getWritableDatabase();
+        db.beginTransaction();
+        try {
+            aggregateContact(db, rawContactId);
+            db.setTransactionSuccessful();
+        } finally {
+            db.endTransaction();
+        }
+    }
+
+    /**
+     * Synchronously aggregate the specified contact assuming an open transaction.
+     */
+    public void aggregateContact(SQLiteDatabase db, long rawContactId) {
+        MatchCandidateList candidates = new MatchCandidateList();
+        ContactMatcher matcher = new ContactMatcher();
+        ContentValues values = new ContentValues();
+        aggregateContact(db, rawContactId, candidates, matcher, values);
+    }
+
+    /**
+     * Marks the specified contact for (re)aggregation.
+     *
+     * @param rawContactId contact ID that needs to be (re)aggregated
+     * @return The contact aggregation mode:
+     *         {@link RawContacts#AGGREGATION_MODE_DEFAULT},
+     *         {@link RawContacts#AGGREGATION_MODE_IMMEDIATE} or
+     *         {@link RawContacts#AGGREGATION_MODE_DISABLED}.
+     */
+    public int markContactForAggregation(long rawContactId) {
+        final SQLiteDatabase db = mOpenHelper.getWritableDatabase();
+
+        int aggregationMode = mOpenHelper.getAggregationMode(rawContactId);
+        if (aggregationMode == RawContacts.AGGREGATION_MODE_DISABLED) {
+            return aggregationMode;
+        }
+
+        long contactId = mOpenHelper.getContactId(rawContactId);
+        if (contactId == 0) {
+            // Not aggregated
+            return aggregationMode;
+        }
+
+        mOpenHelper.removeContactIfSingleton(rawContactId);
+
+        // TODO compiled statements
+
+        // Clear out data used for aggregation - we will recreate it during aggregation
+        db.execSQL("DELETE FROM " + Tables.NAME_LOOKUP + " WHERE "
+                + NameLookupColumns.RAW_CONTACT_ID + "=" + rawContactId);
+
+        // Clear out the contact ID field on the contact
+        ContentValues values = new ContentValues();
+        values.putNull(RawContacts.CONTACT_ID);
+        db.update(Tables.RAW_CONTACTS, values, RawContacts._ID + "=" + rawContactId, null);
+
+        return aggregationMode;
+    }
+
+    public void updateAggregateData(long contactId) {
+        final SQLiteDatabase db = mOpenHelper.getWritableDatabase();
+        final ContentValues values = new ContentValues();
+        updateAggregateData(db, contactId, values);
+    }
+
+    /**
+     * Given a specific raw contact, finds all matching aggregate contacts and chooses the one
+     * with the highest match score.  If no such contact is found, creates a new contact.
+     */
+    /* package */ synchronized void aggregateContact(SQLiteDatabase db, long rawContactId,
+            MatchCandidateList candidates, ContactMatcher matcher, ContentValues values) {
+        candidates.clear();
+        matcher.clear();
+
+        long contactId = pickBestMatchBasedOnExceptions(db, rawContactId, matcher);
+        if (contactId == -1) {
+            contactId = pickBestMatchBasedOnData(db, rawContactId, candidates, matcher);
+        }
+
+        boolean newAgg = false;
+
+        if (contactId == -1) {
+            newAgg = true;
+            ContentValues contactValues = new ContentValues();
+            contactValues.put(Contacts.DISPLAY_NAME, "");
+            contactId = db.insert(Tables.CONTACTS, Contacts.DISPLAY_NAME, contactValues);
+        }
+
+        updateContactAggregationData(db, rawContactId, candidates, values);
+        mOpenHelper.setContactId(rawContactId, contactId);
+
+        updateAggregateData(db, contactId, values);
+        updatePrimaries(db, contactId, rawContactId, newAgg);
+        mOpenHelper.updateContactVisible(contactId);
+
+    }
+
+    /**
+     * Computes match scores based on exceptions entered by the user: always match and never match.
+     * Returns the aggregate contact with the always match exception if any.
+     */
+    private long pickBestMatchBasedOnExceptions(SQLiteDatabase db, long rawContactId,
+            ContactMatcher matcher) {
+        final Cursor c = db.query(Tables.AGGREGATION_EXCEPTIONS_JOIN_RAW_CONTACTS_TWICE,
+                AGGREGATE_EXCEPTION_JOIN_CONTACT_TWICE_COLUMNS,
+                AggregationExceptionColumns.RAW_CONTACT_ID1 + "=" + rawContactId
+                        + " OR " + AggregationExceptionColumns.RAW_CONTACT_ID2 + "=" + rawContactId,
+                null, null, null, null);
+
+        try {
+            while (c.moveToNext()) {
+                int type = c.getInt(COL_TYPE);
+                long rawContactId1 = c.getLong(COL_RAW_CONTACT_ID1);
+                long contactId = -1;
+                if (rawContactId == rawContactId1) {
+                    if (!c.isNull(COL_CONTACT_ID2)) {
+                        contactId = c.getLong(COL_CONTACT_ID2);
+                    }
+                } else {
+                    if (!c.isNull(COL_CONTACT_ID1)) {
+                        contactId = c.getLong(COL_CONTACT_ID1);
+                    }
+                }
+                if (contactId != -1) {
+                    if (type == AggregationExceptions.TYPE_KEEP_IN) {
+                        return contactId;
+                    } else {
+                        matcher.keepOut(contactId);
+                    }
+                }
+            }
+        } finally {
+            c.close();
+        }
+
+        return -1;
+    }
+
+    /**
+     * Picks the best matching contact based on matches between data elements.  It considers
+     * name match to be primary and phone, email etc matches to be secondary.  A good primary
+     * match triggers aggregation, while a good secondary match only triggers aggregation in
+     * the absence of a strong primary mismatch.
+     * <p>
+     * Consider these examples:
+     * <p>
+     * John Doe with phone number 111-111-1111 and Jon Doe with phone number 111-111-1111 should
+     * be aggregated (same number, similar names).
+     * <p>
+     * John Doe with phone number 111-111-1111 and Deborah Doe with phone number 111-111-1111 should
+     * not be aggregated (same number, different names).
+     */
+    private long pickBestMatchBasedOnData(SQLiteDatabase db, long rawContactId,
+            MatchCandidateList candidates, ContactMatcher matcher) {
+
+        updateMatchScoresBasedOnDataMatches(db, rawContactId, MODE_AGGREGATION, candidates, matcher);
+
+        // See if we have already found a good match based on name matches alone
+        long bestMatch = matcher.pickBestMatch(ContactMatcher.SCORE_THRESHOLD_PRIMARY);
+        if (bestMatch == -1) {
+            // We haven't found a good match on name, see if we have any matches on phone, email etc
+            bestMatch = pickBestMatchBasedOnSecondaryData(db, candidates, matcher);
+        }
+
+        return bestMatch;
+    }
+
+    /**
+     * Picks the best matching contact based on secondary data matches.  The method loads
+     * structured names for all candidate contacts and recomputes match scores using approximate
+     * matching.
+     */
+    private long pickBestMatchBasedOnSecondaryData(SQLiteDatabase db,
+            MatchCandidateList candidates, ContactMatcher matcher) {
+        List<Long> secondaryContactIds = matcher.prepareSecondaryMatchCandidates(
+                ContactMatcher.SCORE_THRESHOLD_PRIMARY);
+        if (secondaryContactIds == null) {
+            return -1;
+        }
+
+        StringBuilder selection = new StringBuilder();
+        selection.append(RawContacts.CONTACT_ID).append(" IN (");
+        for (int i = 0; i < secondaryContactIds.size(); i++) {
+            if (i != 0) {
+                selection.append(',');
+            }
+            selection.append(secondaryContactIds.get(i));
+        }
+        selection.append(") AND " + MimetypesColumns.MIMETYPE + "='"
+                + StructuredName.CONTENT_ITEM_TYPE + "'");
+
+        final Cursor c = db.query(Tables.DATA_JOIN_MIMETYPE_RAW_CONTACTS,
+                DATA_JOIN_MIMETYPE_AND_CONTACT_COLUMNS,
+                selection.toString(), null, null, null, null);
+
+        MatchCandidateList nameCandidates = new MatchCandidateList();
+        try {
+            while (c.moveToNext()) {
+                String givenName = c.getString(COL_DATA_CONTACT_DATA1);
+                String familyName = c.getString(COL_DATA_CONTACT_DATA2);
+                long contactId = c.getLong(COL_DATA_CONTACT_CONTACT_ID);
+
+                nameCandidates.clear();
+                addMatchCandidatesStructuredName(givenName, familyName, MODE_INSERT_LOOKUP_DATA,
+                        nameCandidates);
+
+                // Note the N^2 complexity of the following fragment. This is not a huge concern
+                // since the number of candidates is very small and in general secondary hits
+                // in the absence of primary hits are rare.
+                for (int i = 0; i < candidates.mCount; i++) {
+                    NameMatchCandidate candidate = candidates.mList.get(i);
+
+                    // We only want to compare structured names to structured names
+                    // at this stage, we need to ignore all other sources of name lookup data.
+                    if (NameLookupType.isBasedOnStructuredName(candidate.mLookupType)) {
+                        for (int j = 0; j < nameCandidates.mCount; j++) {
+                            NameMatchCandidate nameCandidate = nameCandidates.mList.get(j);
+                            matcher.matchName(contactId,
+                                    nameCandidate.mLookupType, nameCandidate.mName,
+                                    candidate.mLookupType, candidate.mName, true);
+                        }
+                    }
+                }
+            }
+        } finally {
+            c.close();
+        }
+
+        return matcher.pickBestMatch(ContactMatcher.SCORE_THRESHOLD_SECONDARY);
+    }
+
+    /**
+     * Computes scores for contacts that have matching data rows.
+     */
+    private void updateMatchScoresBasedOnDataMatches(SQLiteDatabase db, long rawContactId,
+            int mode, MatchCandidateList candidates, ContactMatcher matcher) {
+
+        final Cursor c = db.query(Tables.DATA_JOIN_MIMETYPE_RAW_CONTACTS,
+                DATA_JOIN_MIMETYPE_COLUMNS,
+                Data.RAW_CONTACT_ID + "=" + rawContactId + " AND ("
+                        + MIMETYPE_SELECTION_IN_CLAUSE + ")",
+                null, null, null, null);
+
+        try {
+            while (c.moveToNext()) {
+                String mimeType = c.getString(COL_MIMETYPE);
+                String data1 = c.getString(COL_DATA1);
+                String data2 = c.getString(COL_DATA2);
+                if (mimeType.equals(CommonDataKinds.StructuredName.CONTENT_ITEM_TYPE)) {
+                    addMatchCandidatesStructuredName(data1, data2, mode, candidates);
+                } else if (mimeType.equals(CommonDataKinds.Email.CONTENT_ITEM_TYPE)) {
+                    addMatchCandidatesEmail(data2, mode, candidates);
+                    lookupEmailMatches(db, data2, matcher);
+                } else if (mimeType.equals(CommonDataKinds.Phone.CONTENT_ITEM_TYPE)) {
+                    lookupPhoneMatches(db, data2, matcher);
+                } else if (mimeType.equals(CommonDataKinds.Nickname.CONTENT_ITEM_TYPE)) {
+                    addMatchCandidatesNickname(data2, mode, candidates);
+                    lookupNicknameMatches(db, data2, matcher);
+                }
+            }
+        } finally {
+            c.close();
+        }
+
+        lookupNameMatches(db, candidates, matcher);
+
+        if (mode == MODE_SUGGESTIONS) {
+            lookupApproximateNameMatches(db, candidates, matcher);
+        }
+    }
+
+    /**
+     * Looks for matches based on the full name (first + last).
+     */
+    private void addMatchCandidatesStructuredName(String givenName, String familyName, int mode,
+            MatchCandidateList candidates) {
+        if (TextUtils.isEmpty(givenName)) {
+
+            // If neither the first nor last name are specified, we won't aggregate
+            if (TextUtils.isEmpty(familyName)) {
+                return;
+            }
+
+            addMatchCandidatesFamilyNameOnly(familyName, candidates);
+        } else if (TextUtils.isEmpty(familyName)) {
+            addMatchCandidatesGivenNameOnly(givenName, candidates);
+        } else {
+            addMatchCandidatesFullName(givenName, familyName, mode, candidates);
+        }
+    }
+
+    private void addMatchCandidatesGivenNameOnly(String givenName,
+            MatchCandidateList candidates) {
+        String givenNameN = NameNormalizer.normalize(givenName);
+        candidates.add(givenNameN, NameLookupType.GIVEN_NAME_ONLY);
+
+        String[] clusters = mOpenHelper.getCommonNicknameClusters(givenNameN);
+        if (clusters != null) {
+            for (int i = 0; i < clusters.length; i++) {
+                candidates.add(clusters[i], NameLookupType.GIVEN_NAME_ONLY_AS_NICKNAME);
+            }
+        }
+    }
+
+    private void addMatchCandidatesFamilyNameOnly(String familyName,
+            MatchCandidateList candidates) {
+        String familyNameN = NameNormalizer.normalize(familyName);
+        candidates.add(familyNameN, NameLookupType.FAMILY_NAME_ONLY);
+
+        // Take care of first and last names swapped
+        String[] clusters = mOpenHelper.getCommonNicknameClusters(familyNameN);
+        if (clusters != null) {
+            for (int i = 0; i < clusters.length; i++) {
+                candidates.add(clusters[i], NameLookupType.FAMILY_NAME_ONLY_AS_NICKNAME);
+            }
+        }
+    }
+
+    private void addMatchCandidatesFullName(String givenName, String familyName, int mode,
+            MatchCandidateList candidates) {
+        final String givenNameN = NameNormalizer.normalize(givenName);
+        final String[] givenNameNicknames = mOpenHelper.getCommonNicknameClusters(givenNameN);
+        final String familyNameN = NameNormalizer.normalize(familyName);
+        final String[] familyNameNicknames = mOpenHelper.getCommonNicknameClusters(familyNameN);
+        candidates.add(givenNameN + "." + familyNameN, NameLookupType.FULL_NAME);
+        if (givenNameNicknames != null) {
+            for (int i = 0; i < givenNameNicknames.length; i++) {
+                candidates.add(givenNameNicknames[i] + "." + familyNameN,
+                        NameLookupType.FULL_NAME_WITH_NICKNAME);
+            }
+        }
+        candidates.add(familyNameN + "." + givenNameN, NameLookupType.FULL_NAME_REVERSE);
+        if (familyNameNicknames != null) {
+            for (int i = 0; i < familyNameNicknames.length; i++) {
+                candidates.add(familyNameNicknames[i] + "." + givenNameN,
+                        NameLookupType.FULL_NAME_WITH_NICKNAME_REVERSE);
+            }
+        }
+        candidates.add(givenNameN + familyNameN, NameLookupType.FULL_NAME_CONCATENATED);
+        candidates.add(familyNameN + givenNameN, NameLookupType.FULL_NAME_REVERSE_CONCATENATED);
+
+        if (mode == MODE_AGGREGATION || mode == MODE_SUGGESTIONS) {
+            candidates.add(givenNameN, NameLookupType.GIVEN_NAME_ONLY);
+            if (givenNameNicknames != null) {
+                for (int i = 0; i < givenNameNicknames.length; i++) {
+                    candidates.add(givenNameNicknames[i],
+                            NameLookupType.GIVEN_NAME_ONLY_AS_NICKNAME);
+                }
+            }
+
+            candidates.add(familyNameN, NameLookupType.FAMILY_NAME_ONLY);
+            if (familyNameNicknames != null) {
+                for (int i = 0; i < familyNameNicknames.length; i++) {
+                    candidates.add(familyNameNicknames[i],
+                            NameLookupType.FAMILY_NAME_ONLY_AS_NICKNAME);
+                }
+            }
+        }
+    }
+
+    /**
+     * Extracts the user name portion from an email address and normalizes it so that it
+     * can be matched against names and nicknames.
+     */
+    private void addMatchCandidatesEmail(String email, int mode, MatchCandidateList candidates) {
+        Rfc822Token[] tokens = Rfc822Tokenizer.tokenize(email);
+        if (tokens.length == 0) {
+            return;
+        }
+
+        String address = tokens[0].getAddress();
+        int at = address.indexOf('@');
+        if (at != -1) {
+            address = address.substring(0, at);
+        }
+
+        candidates.add(NameNormalizer.normalize(address), NameLookupType.EMAIL_BASED_NICKNAME);
+    }
+
+
+    /**
+     * Normalizes the nickname and adds it to the list of candidates.
+     */
+    private void addMatchCandidatesNickname(String nickname, int mode,
+            MatchCandidateList candidates) {
+        candidates.add(NameNormalizer.normalize(nickname), NameLookupType.NICKNAME);
+    }
+
+    /**
+     * Given a list of {@link NameMatchCandidate}'s, finds all matches and computes their scores.
+     */
+    private void lookupNameMatches(SQLiteDatabase db, MatchCandidateList candidates,
+            ContactMatcher matcher) {
+
+        if (candidates.mCount == 0) {
+            return;
+        }
+
+        StringBuilder selection = new StringBuilder();
+        selection.append(NameLookupColumns.NORMALIZED_NAME);
+        selection.append(" IN (");
+        for (int i = 0; i < candidates.mCount; i++) {
+            DatabaseUtils.appendEscapedSQLString(selection, candidates.mList.get(i).mName);
+            selection.append(",");
+        }
+
+        // Yank the last comma
+        selection.setLength(selection.length() - 1);
+        selection.append(") AND ");
+        selection.append(RawContacts.CONTACT_ID);
+        selection.append(" NOT NULL");
+
+        matchAllCandidates(db, selection.toString(), candidates, matcher, false);
+    }
+
+    /**
+     * Loads name lookup rows for approximate name matching and updates match scores based on that
+     * data.
+     */
+    private void lookupApproximateNameMatches(SQLiteDatabase db, MatchCandidateList candidates,
+            ContactMatcher matcher) {
+        HashSet<String> firstLetters = new HashSet<String>();
+        for (int i = 0; i < candidates.mCount; i++) {
+            final NameMatchCandidate candidate = candidates.mList.get(i);
+            if (candidate.mName.length() >= 2) {
+                String firstLetter = candidate.mName.substring(0, 2);
+                if (!firstLetters.contains(firstLetter)) {
+                    firstLetters.add(firstLetter);
+                    final String selection = "(" + NameLookupColumns.NORMALIZED_NAME + " GLOB '"
+                            + firstLetter + "*') AND " + RawContacts.CONTACT_ID + " NOT NULL";
+                    matchAllCandidates(db, selection, candidates, matcher, true);
+                }
+            }
+        }
+    }
+
+    /**
+     * Loads all candidate rows from the name lookup table and updates match scores based
+     * on that data.
+     */
+    private void matchAllCandidates(SQLiteDatabase db, String selection,
+            MatchCandidateList candidates, ContactMatcher matcher, boolean approximate) {
+        final Cursor c = db.query(Tables.NAME_LOOKUP_JOIN_RAW_CONTACTS, NAME_LOOKUP_COLUMNS,
+                selection, null, null, null, null);
+
+        try {
+            while (c.moveToNext()) {
+                Long contactId = c.getLong(COL_NAME_LOOKUP_CONTACT_ID);
+                String name = c.getString(COL_NORMALIZED_NAME);
+                int nameType = c.getInt(COL_NAME_TYPE);
+
+                // Determine which candidate produced this match
+                for (int i = 0; i < candidates.mCount; i++) {
+                    NameMatchCandidate candidate = candidates.mList.get(i);
+                    matcher.matchName(contactId, candidate.mLookupType, candidate.mName,
+                            nameType, name, approximate);
+                }
+            }
+        } finally {
+            c.close();
+        }
+    }
+
+    private void lookupPhoneMatches(SQLiteDatabase db, String phoneNumber, ContactMatcher matcher) {
+        SQLiteQueryBuilder qb = new SQLiteQueryBuilder();
+        OpenHelper.buildPhoneLookupQuery(qb, phoneNumber);
+        Cursor c = qb.query(db, CONTACT_ID_COLUMNS,
+                RawContacts.CONTACT_ID + " NOT NULL", null, null, null, null);
+        try {
+            while (c.moveToNext()) {
+                long contactId = c.getLong(COL_CONTACT_ID);
+                matcher.updateScoreWithPhoneNumberMatch(contactId);
+            }
+        } finally {
+            c.close();
+        }
+    }
+
+    /**
+     * Finds exact email matches and updates their match scores.
+     */
+    private void lookupEmailMatches(SQLiteDatabase db, String address, ContactMatcher matcher) {
+        Cursor c = db.query(Tables.DATA_JOIN_MIMETYPE_RAW_CONTACTS, CONTACT_ID_COLUMNS,
+                Clauses.WHERE_EMAIL_MATCHES + " AND " + RawContacts.CONTACT_ID + " NOT NULL",
+                new String[]{address}, null, null, null);
+        try {
+            while (c.moveToNext()) {
+                long contactId = c.getLong(COL_CONTACT_ID);
+                matcher.updateScoreWithEmailMatch(contactId);
+            }
+        } finally {
+            c.close();
+        }
+    }
+
+    /**
+     * Finds exact nickname matches in the name lookup table and updates their match scores.
+     */
+    private void lookupNicknameMatches(SQLiteDatabase db, String nickname, ContactMatcher matcher) {
+        String normalized = NameNormalizer.normalize(nickname);
+        Cursor c = db.query(true, Tables.NAME_LOOKUP_JOIN_RAW_CONTACTS, CONTACT_ID_COLUMNS,
+                NameLookupColumns.NAME_TYPE + "=" + NameLookupType.NICKNAME + " AND "
+                        + NameLookupColumns.NORMALIZED_NAME + "='" + normalized + "' AND "
+                        + RawContacts.CONTACT_ID + " NOT NULL",
+                null, null, null, null, null);
+        try {
+            while (c.moveToNext()) {
+                long contactId = c.getLong(COL_CONTACT_ID);
+                matcher.updateScoreWithNicknameMatch(contactId);
+            }
+        } finally {
+            c.close();
+        }
+    }
+
+    /**
+     * Prepares the supplied contact for aggregation with other contacts by (re)computing
+     * match lookup keys.
+     */
+    private void updateContactAggregationData(SQLiteDatabase db, long rawContactId,
+            MatchCandidateList candidates, ContentValues values) {
+        candidates.clear();
+
+        final Cursor c = db.query(Tables.DATA_JOIN_MIMETYPES,
+                DATA_JOIN_MIMETYPE_COLUMNS,
+                DatabaseUtils.concatenateWhere(Data.RAW_CONTACT_ID + "=" + rawContactId,
+                        MIMETYPE_SELECTION_IN_CLAUSE),
+                null, null, null, null);
+
+        try {
+            while (c.moveToNext()) {
+                String mimeType = c.getString(COL_MIMETYPE);
+                String data1 = c.getString(COL_DATA1);
+                String data2 = c.getString(COL_DATA2);
+                if (mimeType.equals(CommonDataKinds.StructuredName.CONTENT_ITEM_TYPE)) {
+                    addMatchCandidatesStructuredName(data1, data2, MODE_INSERT_LOOKUP_DATA,
+                            candidates);
+                } else if (mimeType.equals(CommonDataKinds.Email.CONTENT_ITEM_TYPE)) {
+                    addMatchCandidatesEmail(data2, MODE_INSERT_LOOKUP_DATA, candidates);
+                } else if (mimeType.equals(CommonDataKinds.Nickname.CONTENT_ITEM_TYPE)) {
+                    addMatchCandidatesNickname(data2, MODE_INSERT_LOOKUP_DATA, candidates);
+                }
+            }
+        } finally {
+            c.close();
+        }
+
+        for (int i = 0; i < candidates.mCount; i++) {
+            NameMatchCandidate candidate = candidates.mList.get(i);
+            mOpenHelper.insertNameLookup(rawContactId, candidate.mLookupType, candidate.mName);
+        }
+    }
+
+    /**
+     * Updates aggregate-level data from constituent contacts.
+     */
+    private void updateAggregateData(final SQLiteDatabase db, long contactId,
+            final ContentValues values) {
+        updateDisplayName(db, contactId, values);
+        updateSendToVoicemailAndRingtone(db, contactId);
+        updatePhotoId(db, contactId, values);
+    }
+
+    /**
+     * Updates the contact record's {@link Contacts#DISPLAY_NAME} field. If none of the
+     * constituent raw contacts has a suitable name, leaves the aggregate contact record unchanged.
+     */
+    private void updateDisplayName(SQLiteDatabase db, long contactId, ContentValues values) {
+        String displayName = getBestDisplayName(db, contactId);
+
+        // If don't have anything to base the display name on, let's just leave what was in
+        // that field hoping that there was something there before and it is still valid.
+        if (displayName == null) {
+            return;
+        }
+
+        values.clear();
+        values.put(Contacts.DISPLAY_NAME, displayName);
+        db.update(Tables.CONTACTS, values, Contacts._ID + "=" + contactId, null);
+    }
+
+    private void updatePhotoId(SQLiteDatabase db, long contactId, ContentValues values) {
+        int photoId = choosePhotoId(db, contactId);
+
+        if (photoId == -1) {
+            return;
+        }
+
+        values.clear();
+        values.put(Contacts.PHOTO_ID, photoId);
+        db.update(Tables.CONTACTS, values, Contacts._ID + "=" + contactId, null);
+    }
+
+    /**
+     * Updates the various {@link ContactsColumns} primary values based on the
+     * newly joined {@link RawContacts} entry. If some aggregate primary values are
+     * unassigned, primary values from this contact will be promoted as the new
+     * super-primaries.
+     */
+    private void updatePrimaries(SQLiteDatabase db, long aggId, long rawContactId, boolean newAgg) {
+        Cursor cursor = null;
+
+        boolean hasOptimalPhone = false;
+        boolean hasFallbackPhone = false;
+        boolean hasOptimalEmail = false;
+        boolean hasFallbackEmail = false;
+
+        // Read currently recorded aggregate primary values
+        try {
+            cursor = db.query(Tables.CONTACTS, Projections.PROJ_CONTACT_PRIMARIES,
+                    Contacts._ID + "=" + aggId, null, null, null, null);
+            if (cursor.moveToNext()) {
+                hasOptimalPhone = (cursor.getLong(Projections.COL_OPTIMAL_PRIMARY_PHONE_ID) != 0);
+                hasFallbackPhone = (cursor.getLong(Projections.COL_FALLBACK_PRIMARY_PHONE_ID) != 0);
+                hasOptimalEmail = (cursor.getLong(Projections.COL_OPTIMAL_PRIMARY_EMAIL_ID) != 0);
+                hasFallbackEmail = (cursor.getLong(Projections.COL_FALLBACK_PRIMARY_EMAIL_ID) != 0);
+            }
+        } finally {
+            if (cursor != null) {
+                cursor.close();
+            }
+        }
+
+        long candidatePhone = 0;
+        long candidateEmail = 0;
+        boolean candidateIsRestricted = false;
+
+        // Find primary data items from newly-joined contact, returning one
+        // candidate for each mimetype.
+        try {
+            cursor = db.query(Tables.DATA_JOIN_PACKAGES_MIMETYPES_RAW_CONTACTS,
+                    Projections.PROJ_DATA,
+                    Data.RAW_CONTACT_ID + "=" + rawContactId + " AND " + Data.IS_PRIMARY + "=1 AND "
+                            + Projections.PRIMARY_MIME_CLAUSE, null, Data.MIMETYPE, null, null);
+            while (cursor.moveToNext()) {
+                final long dataId = cursor.getLong(Projections.COL_DATA_ID);
+                final String mimeType = cursor.getString(Projections.COL_DATA_MIMETYPE);
+
+                candidateIsRestricted = (cursor.getInt(Projections.COL_IS_RESTRICTED) == 1);
+
+                if (CommonDataKinds.Phone.CONTENT_ITEM_TYPE.equals(mimeType)) {
+                    candidatePhone = dataId;
+                } else if (CommonDataKinds.Email.CONTENT_ITEM_TYPE.equals(mimeType)) {
+                    candidateEmail = dataId;
+                }
+
+            }
+        } finally {
+            if (cursor != null) {
+                cursor.close();
+            }
+        }
+
+        final ContentValues values = new ContentValues();
+
+        // If a new contact, and single child is restricted, then mark
+        // contact as being protected by package. Otherwise set as null if
+        // multiple under contact or not restricted.
+        values.put(ContactsColumns.SINGLE_IS_RESTRICTED, (newAgg && candidateIsRestricted) ? 1
+                : 0);
+
+        // If newly joined contact has a primary phone number, consider
+        // promoting it up into aggregate as super-primary.
+        if (candidatePhone != 0) {
+            if (!hasOptimalPhone) {
+                values.put(ContactsColumns.OPTIMAL_PRIMARY_PHONE_ID, candidatePhone);
+                values.put(ContactsColumns.OPTIMAL_PRIMARY_PHONE_IS_RESTRICTED,
+                        candidateIsRestricted ? 1 : 0);
+            }
+
+            // Also promote to unrestricted value, if none provided yet.
+            if (!hasFallbackPhone && !candidateIsRestricted) {
+                values.put(ContactsColumns.FALLBACK_PRIMARY_PHONE_ID, candidatePhone);
+            }
+        }
+
+        // If newly joined contact has a primary email, consider promoting it up
+        // into aggregate as super-primary.
+        if (candidateEmail != 0) {
+            if (!hasOptimalEmail) {
+                values.put(ContactsColumns.OPTIMAL_PRIMARY_EMAIL_ID, candidateEmail);
+                values.put(ContactsColumns.OPTIMAL_PRIMARY_EMAIL_IS_RESTRICTED,
+                        candidateIsRestricted ? 1 : 0);
+            }
+
+            // Also promote to unrestricted value, if none provided yet.
+            if (!hasFallbackEmail && !candidateIsRestricted) {
+                values.put(ContactsColumns.FALLBACK_PRIMARY_EMAIL_ID, candidateEmail);
+            }
+        }
+
+        // Only write updated contact values if we made changes.
+        if (values.size() > 0) {
+            Log.d(TAG, "some sort of promotion is going on: " + values.toString());
+            db.update(Tables.CONTACTS, values, Contacts._ID + "=" + aggId, null);
+        }
+
+    }
+
+    /**
+     * Computes display name for the given contact.  Chooses a longer name over a shorter name
+     * and a mixed-case name over an all lowercase or uppercase name.
+     */
+    private String getBestDisplayName(SQLiteDatabase db, long contactId) {
+        String bestDisplayName = null;
+
+        final Cursor c = db.query(Tables.RAW_CONTACTS, new String[] {RawContactsColumns.DISPLAY_NAME},
+                RawContacts.CONTACT_ID + "=" + contactId, null, null, null, null);
+
+        try {
+            while (c.moveToNext()) {
+                String displayName = c.getString(0);
+                if (!TextUtils.isEmpty(displayName)) {
+                    if (bestDisplayName == null) {
+                        bestDisplayName = displayName;
+                    } else {
+                        if (NameNormalizer.compareComplexity(displayName, bestDisplayName) > 0) {
+                            bestDisplayName = displayName;
+                        }
+                    }
+                }
+            }
+        } finally {
+            c.close();
+        }
+        return bestDisplayName;
+    }
+
+    /**
+     * Iterates over the photos associated with contact defined by contactId, and chooses one
+     * to be associated with the contact. Initially this just chooses the first photo in a list
+     * sorted by account name.
+     */
+    private int choosePhotoId(SQLiteDatabase db, long contactId) {
+        int chosenPhotoId = -1;
+        String chosenAccount = null;
+
+        final Cursor c = db.query(Tables.DATA_JOIN_PACKAGES_MIMETYPES_RAW_CONTACTS_CONTACTS,
+                new String[] {"data._id AS _id", RawContacts.ACCOUNT_NAME},
+                DatabaseUtils.concatenateWhere(RawContacts.CONTACT_ID + "=" + contactId,
+                        Data.MIMETYPE + "='" + Photo.CONTENT_ITEM_TYPE + "'"),
+                null, null, null, null);
+
+        try {
+            while (c.moveToNext()) {
+                int photoId = c.getInt(0);
+                String account = c.getString(1);
+                if (chosenAccount == null) {
+                    chosenAccount = account;
+                    chosenPhotoId = photoId;
+                } else {
+                    if (account.compareToIgnoreCase(chosenAccount) < 0 ) {
+                        chosenAccount = account;
+                        chosenPhotoId = photoId;
+                    }
+                }
+            }
+        } finally {
+            c.close();
+        }
+        return chosenPhotoId;
+    }
+
+    /**
+     * Updates the contact's send-to-voicemail and custom-ringtone options based on
+     * constituent contacts' options.
+     */
+    private void updateSendToVoicemailAndRingtone(SQLiteDatabase db, long contactId) {
+        int totalContactCount = 0;
+        int contactSendToVoicemail = 0;
+        String contactCustomRingtone = null;
+        long contactLastTimeContacted = 0;
+        int contactTimesContacted = 0;
+        boolean contactStarred = false;
+
+        final Cursor c = db.query(Tables.RAW_CONTACTS, CONTACT_OPTIONS_COLUMNS,
+                RawContacts.CONTACT_ID + "=" + contactId, null, null, null, null);
+
+        try {
+            while (c.moveToNext()) {
+                totalContactCount++;
+                if (!c.isNull(COL_SEND_TO_VOICEMAIL)) {
+                    boolean sendToVoicemail = (c.getInt(COL_SEND_TO_VOICEMAIL) != 0);
+                    if (sendToVoicemail) {
+                        contactSendToVoicemail++;
+                    }
+                }
+
+                if (contactCustomRingtone == null && !c.isNull(COL_CUSTOM_RINGTONE)) {
+                    contactCustomRingtone = c.getString(COL_CUSTOM_RINGTONE);
+                }
+
+                long lastTimeContacted = c.getLong(COL_LAST_TIME_CONTACTED);
+                if (lastTimeContacted > contactLastTimeContacted) {
+                    contactLastTimeContacted = lastTimeContacted;
+                }
+
+                int timesContacted = c.getInt(COL_TIMES_CONTACTED);
+                if (timesContacted > contactTimesContacted) {
+                    contactTimesContacted = timesContacted;
+                }
+
+                contactStarred |= (c.getInt(COL_STARRED) != 0);
+            }
+        } finally {
+            c.close();
+        }
+
+        ContentValues values = new ContentValues(2);
+        values.put(Contacts.SEND_TO_VOICEMAIL, totalContactCount == contactSendToVoicemail);
+        values.put(Contacts.CUSTOM_RINGTONE, contactCustomRingtone);
+        values.put(Contacts.LAST_TIME_CONTACTED, contactLastTimeContacted);
+        values.put(Contacts.TIMES_CONTACTED, contactTimesContacted);
+        values.put(Contacts.STARRED, contactStarred);
+
+        db.update(Tables.CONTACTS, values, Contacts._ID + "=" + contactId, null);
+    }
+
+    /**
+     * Finds matching contacts and returns a cursor on those.
+     */
+    public Cursor queryAggregationSuggestions(long contactId, String[] projection,
+            HashMap<String, String> projectionMap, int maxSuggestions) {
+        final SQLiteDatabase db = mOpenHelper.getReadableDatabase();
+
+        Cursor c;
+
+        // If this method is called in the middle of aggregation pass, we want to pause the
+        // aggregation, but not kill it.
+        db.beginTransaction();
+        try {
+            List<MatchScore> bestMatches = findMatchingContacts(db, contactId, maxSuggestions);
+            c = queryMatchingContacts(db, contactId, projection, projectionMap, bestMatches);
+            db.setTransactionSuccessful();
+        } finally {
+            db.endTransaction();
+        }
+        return c;
+    }
+
+    /**
+     * Loads contacts with specified IDs and returns them in the order of IDs in the
+     * supplied list.
+     */
+    private Cursor queryMatchingContacts(final SQLiteDatabase db, long contactId,
+            String[] projection, HashMap<String, String> projectionMap,
+            List<MatchScore> bestMatches) {
+
+        StringBuilder selection = new StringBuilder();
+        selection.append(Contacts._ID);
+        selection.append(" IN (");
+        for (int i = 0; i < bestMatches.size(); i++) {
+            MatchScore matchScore = bestMatches.get(i);
+            if (i != 0) {
+                selection.append(",");
+            }
+            selection.append(matchScore.getContactId());
+        }
+        selection.append(")");
+
+        final SQLiteQueryBuilder qb = new SQLiteQueryBuilder();
+        qb.setTables(Tables.CONTACTS);
+        qb.setProjectionMap(projectionMap);
+
+        final Cursor cursor = qb.query(db, projection, selection.toString(), null, null, null,
+                Contacts._ID);
+
+        ArrayList<Long> sortedContactIds = new ArrayList<Long>(bestMatches.size());
+        for (MatchScore matchScore : bestMatches) {
+            sortedContactIds.add(matchScore.getContactId());
+        }
+
+        Collections.sort(sortedContactIds);
+
+        int[] positionMap = new int[bestMatches.size()];
+        for (int i = 0; i < positionMap.length; i++) {
+            long id = bestMatches.get(i).getContactId();
+            positionMap[i] = sortedContactIds.indexOf(id);
+        }
+
+        return new ReorderingCursorWrapper(cursor, positionMap);
+    }
+
+    /**
+     * Finds contacts with data matches and returns a list of {@link MatchScore}'s in the
+     * descending order of match score.
+     */
+    private List<MatchScore> findMatchingContacts(final SQLiteDatabase db,
+            long contactId, int maxSuggestions) {
+
+        MatchCandidateList candidates = new MatchCandidateList();
+        ContactMatcher matcher = new ContactMatcher();
+
+        // Don't aggregate a contact with itself
+        matcher.keepOut(contactId);
+
+        final Cursor c = db.query(Tables.RAW_CONTACTS, CONTACT_ID_COLUMN,
+                RawContacts.CONTACT_ID + "=" + contactId, null, null, null, null);
+        try {
+            while (c.moveToNext()) {
+                long rawContactId = c.getLong(0);
+                updateMatchScoresBasedOnDataMatches(db, rawContactId, MODE_SUGGESTIONS, candidates,
+                        matcher);
+            }
+        } finally {
+            c.close();
+        }
+
+        List<MatchScore> matches = matcher.pickBestMatches(maxSuggestions,
+                ContactMatcher.SCORE_THRESHOLD_SUGGEST);
+
+        // TODO: remove the debug logging
+        Log.i(TAG, "MATCHES: " + matches);
+        return matches;
+    }
+
+    /**
+     * Various database projections used internally.
+     */
+    private interface Projections {
+        static final String[] PROJ_CONTACT_PRIMARIES = new String[] {
+                ContactsColumns.OPTIMAL_PRIMARY_PHONE_ID,
+                ContactsColumns.FALLBACK_PRIMARY_PHONE_ID,
+                ContactsColumns.OPTIMAL_PRIMARY_EMAIL_ID,
+                ContactsColumns.FALLBACK_PRIMARY_EMAIL_ID,
+                ContactsColumns.SINGLE_IS_RESTRICTED,
+        };
+
+        static final int COL_OPTIMAL_PRIMARY_PHONE_ID = 0;
+        static final int COL_FALLBACK_PRIMARY_PHONE_ID = 1;
+        static final int COL_OPTIMAL_PRIMARY_EMAIL_ID = 2;
+        static final int COL_FALLBACK_PRIMARY_EMAIL_ID = 3;
+        static final int COL_SINGLE_IS_RESTRICTED = 4;
+
+        static final String[] PROJ_DATA = new String[] {
+                Tables.DATA + "." + Data._ID,
+                Data.MIMETYPE,
+                RawContacts.IS_RESTRICTED,
+        };
+
+        static final int COL_DATA_ID = 0;
+        static final int COL_DATA_MIMETYPE = 1;
+        static final int COL_IS_RESTRICTED = 2;
+
+        static final String PRIMARY_MIME_CLAUSE = "(" + Data.MIMETYPE + "=\""
+                + CommonDataKinds.Phone.CONTENT_ITEM_TYPE + "\" OR " + Data.MIMETYPE + "=\""
+                + CommonDataKinds.Email.CONTENT_ITEM_TYPE + "\")";
+    }
+}
diff --git a/src/com/android/providers/contacts/ContactMatcher.java b/src/com/android/providers/contacts/ContactMatcher.java
new file mode 100644
index 0000000..6ab98dd
--- /dev/null
+++ b/src/com/android/providers/contacts/ContactMatcher.java
@@ -0,0 +1,471 @@
+/*
+ * 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.OpenHelper.NameLookupType;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.List;
+
+/**
+ * Logic for matching contacts' data and accumulating match scores.
+ */
+public class ContactMatcher {
+
+    // Best possible match score
+    public static final int MAX_SCORE = 100;
+
+    // Suggest to aggregate contacts if their match score is equal or greater than this threshold
+    public static final int SCORE_THRESHOLD_SUGGEST = 50;
+
+    // Automatically aggregate contacts if their match score is equal or greater than this threshold
+    public static final int SCORE_THRESHOLD_PRIMARY = 70;
+
+    // Automatically aggregate contacts if the match score is equal or greater than this threshold
+    // and there is a secondary match (phone number, email etc).
+    public static final int SCORE_THRESHOLD_SECONDARY = 50;
+
+    // Score for missing data (as opposed to present data but a bad match)
+    private static final int NO_DATA_SCORE = -1;
+
+    // Score for matching phone numbers
+    private static final int PHONE_MATCH_SCORE = 71;
+
+    // Score for matching email addresses
+    private static final int EMAIL_MATCH_SCORE = 71;
+
+    // Score for matching nickname
+    private static final int NICKNAME_MATCH_SCORE = 71;
+
+    // Minimum edit distance between two names to be considered an approximate match
+    public static final float APPROXIMATE_MATCH_THRESHOLD = 0.7f;
+
+    // Maximum number of characters in a name to be considered by the matching algorithm.
+    private static final int MAX_MATCHED_NAME_LENGTH = 12;
+
+    // Scores a multiplied by this number to allow room for "fractional" scores
+    private static final int SCORE_SCALE = 1000;
+
+
+    /**
+     * Name matching scores: a matrix by name type vs. candidate lookup type.
+     * For example, if the name type is "full name" while we are looking for a
+     * "full name", the score may be 99. If we are looking for a "nickname" but
+     * find "first name", the score may be 50 (see specific scores defined
+     * below.)
+     * <p>
+     * For approximate matching, we have a range of scores, let's say 40-70.  Depending one how
+     * similar the two strings are, the score will be somewhere between 40 and 70, with the exact
+     * match producing the score of 70.  The score may also be 0 if the similarity (distance)
+     * between the strings is below the threshold.
+     * <p>
+     * We use the Jaro-Winkler algorithm, which is particularly suited for
+     * name matching. See {@link JaroWinklerDistance}.
+     */
+    private static int[] sMinScore =
+            new int[NameLookupType.TYPE_COUNT * NameLookupType.TYPE_COUNT];
+    private static int[] sMaxScore =
+            new int[NameLookupType.TYPE_COUNT * NameLookupType.TYPE_COUNT];
+
+    /*
+     * Note: the reverse names ({@link NameLookupType#FULL_NAME_REVERSE},
+     * {@link NameLookupType#FULL_NAME_REVERSE_CONCATENATED} may appear to be redundant. They are
+     * not!  They are useful in three-way aggregation cases when we have, for example, both
+     * John Smith and Smith John.  A third contact with the name John Smith should be aggregated
+     * with the former rather than the latter.  This is why "reverse" matches have slightly lower
+     * scores than direct matches.
+     */
+    static {
+        setScoreRange(NameLookupType.FULL_NAME,
+                NameLookupType.FULL_NAME, 99, 99);
+        setScoreRange(NameLookupType.FULL_NAME,
+                NameLookupType.FULL_NAME_REVERSE, 90, 90);
+
+        setScoreRange(NameLookupType.FULL_NAME_REVERSE,
+                NameLookupType.FULL_NAME, 90, 90);
+        setScoreRange(NameLookupType.FULL_NAME_REVERSE,
+                NameLookupType.FULL_NAME_REVERSE, 99, 99);
+
+        setScoreRange(NameLookupType.FULL_NAME_CONCATENATED,
+                NameLookupType.FULL_NAME_CONCATENATED, 40, 80);
+        setScoreRange(NameLookupType.FULL_NAME_CONCATENATED,
+                NameLookupType.FULL_NAME_REVERSE_CONCATENATED, 30, 70);
+        setScoreRange(NameLookupType.FULL_NAME_CONCATENATED,
+                NameLookupType.EMAIL_BASED_NICKNAME, 30, 60);
+        setScoreRange(NameLookupType.FULL_NAME_CONCATENATED,
+                NameLookupType.NICKNAME, 30, 60);
+
+        setScoreRange(NameLookupType.FULL_NAME_REVERSE_CONCATENATED,
+                NameLookupType.FULL_NAME_CONCATENATED, 30, 70);
+        setScoreRange(NameLookupType.FULL_NAME_REVERSE_CONCATENATED,
+                NameLookupType.FULL_NAME_REVERSE_CONCATENATED, 40, 80);
+
+        setScoreRange(NameLookupType.FULL_NAME_WITH_NICKNAME,
+                NameLookupType.FULL_NAME_WITH_NICKNAME, 75, 75);
+        setScoreRange(NameLookupType.FULL_NAME_WITH_NICKNAME_REVERSE,
+                NameLookupType.FULL_NAME_WITH_NICKNAME_REVERSE, 73, 73);
+
+        setScoreRange(NameLookupType.FAMILY_NAME_ONLY,
+                NameLookupType.FAMILY_NAME_ONLY, 45, 75);
+        setScoreRange(NameLookupType.FAMILY_NAME_ONLY,
+                NameLookupType.FULL_NAME_CONCATENATED, 32, 72);
+        setScoreRange(NameLookupType.FAMILY_NAME_ONLY,
+                NameLookupType.FULL_NAME_REVERSE_CONCATENATED, 30, 70);
+        setScoreRange(NameLookupType.FAMILY_NAME_ONLY,
+                NameLookupType.EMAIL_BASED_NICKNAME, 30, 60);
+        setScoreRange(NameLookupType.FAMILY_NAME_ONLY,
+                NameLookupType.NICKNAME, 30, 60);
+
+        setScoreRange(NameLookupType.FAMILY_NAME_ONLY_AS_NICKNAME,
+                NameLookupType.FAMILY_NAME_ONLY_AS_NICKNAME, 71, 71);
+        setScoreRange(NameLookupType.FAMILY_NAME_ONLY_AS_NICKNAME,
+                NameLookupType.GIVEN_NAME_ONLY_AS_NICKNAME, 70, 70);
+
+        setScoreRange(NameLookupType.GIVEN_NAME_ONLY,
+                NameLookupType.GIVEN_NAME_ONLY, 40, 70);
+        setScoreRange(NameLookupType.GIVEN_NAME_ONLY,
+                NameLookupType.FULL_NAME_CONCATENATED, 32, 72);
+        setScoreRange(NameLookupType.GIVEN_NAME_ONLY,
+                NameLookupType.FULL_NAME_REVERSE_CONCATENATED, 30, 70);
+        setScoreRange(NameLookupType.GIVEN_NAME_ONLY,
+                NameLookupType.EMAIL_BASED_NICKNAME, 30, 60);
+        setScoreRange(NameLookupType.GIVEN_NAME_ONLY,
+                NameLookupType.NICKNAME, 30, 60);
+
+        setScoreRange(NameLookupType.GIVEN_NAME_ONLY_AS_NICKNAME,
+                NameLookupType.GIVEN_NAME_ONLY_AS_NICKNAME, 73, 73);
+        setScoreRange(NameLookupType.GIVEN_NAME_ONLY_AS_NICKNAME,
+                NameLookupType.FAMILY_NAME_ONLY_AS_NICKNAME, 70, 70);
+
+        setScoreRange(NameLookupType.EMAIL_BASED_NICKNAME,
+                NameLookupType.EMAIL_BASED_NICKNAME, 30, 60);
+        setScoreRange(NameLookupType.EMAIL_BASED_NICKNAME,
+                NameLookupType.GIVEN_NAME_ONLY, 30, 60);
+        setScoreRange(NameLookupType.EMAIL_BASED_NICKNAME,
+                NameLookupType.FAMILY_NAME_ONLY, 30, 60);
+        setScoreRange(NameLookupType.EMAIL_BASED_NICKNAME,
+                NameLookupType.FULL_NAME_CONCATENATED, 30, 60);
+        setScoreRange(NameLookupType.EMAIL_BASED_NICKNAME,
+                NameLookupType.FULL_NAME_REVERSE_CONCATENATED, 30, 60);
+        setScoreRange(NameLookupType.EMAIL_BASED_NICKNAME,
+                NameLookupType.NICKNAME, 30, 60);
+
+        setScoreRange(NameLookupType.NICKNAME,
+                NameLookupType.NICKNAME, 30, 60);
+        setScoreRange(NameLookupType.NICKNAME,
+                NameLookupType.GIVEN_NAME_ONLY, 30, 60);
+        setScoreRange(NameLookupType.NICKNAME,
+                NameLookupType.FAMILY_NAME_ONLY, 30, 60);
+        setScoreRange(NameLookupType.NICKNAME,
+                NameLookupType.FULL_NAME_CONCATENATED, 30, 60);
+        setScoreRange(NameLookupType.NICKNAME,
+                NameLookupType.FULL_NAME_REVERSE_CONCATENATED, 30, 60);
+        setScoreRange(NameLookupType.NICKNAME,
+                NameLookupType.EMAIL_BASED_NICKNAME, 30, 60);
+    }
+
+    /**
+     * Populates the cells of the score matrix and score span matrix
+     * corresponding to the {@code candidateNameType} and {@code nameType}.
+     */
+    private static void setScoreRange(int candidateNameType, int nameType, int scoreFrom, int scoreTo) {
+        int index = nameType * NameLookupType.TYPE_COUNT + candidateNameType;
+        sMinScore[index] = scoreFrom;
+        sMaxScore[index] = scoreTo;
+    }
+
+    /**
+     * Returns the lower range for the match score for the given {@code candidateNameType} and
+     * {@code nameType}.
+     */
+    private static int getMinScore(int candidateNameType, int nameType) {
+        int index = nameType * NameLookupType.TYPE_COUNT + candidateNameType;
+        return sMinScore[index];
+    }
+
+    /**
+     * Returns the upper range for the match score for the given {@code candidateNameType} and
+     * {@code nameType}.
+     */
+    private static int getMaxScore(int candidateNameType, int nameType) {
+        int index = nameType * NameLookupType.TYPE_COUNT + candidateNameType;
+        return sMaxScore[index];
+    }
+
+    /**
+     * Captures the max score and match count for a specific contact.  Used in an
+     * contactId - MatchScore map.
+     */
+    public static class MatchScore implements Comparable<MatchScore> {
+        private long mContactId;
+        private boolean mKeepIn;
+        private boolean mKeepOut;
+        private int mPrimaryScore;
+        private int mSecondaryScore;
+        private int mMatchCount;
+
+        public MatchScore(long contactId) {
+            this.mContactId = contactId;
+        }
+
+        public void reset(long contactId) {
+            this.mContactId = contactId;
+            mKeepIn = false;
+            mKeepOut = false;
+            mPrimaryScore = 0;
+            mSecondaryScore = 0;
+            mMatchCount = 0;
+        }
+
+        public long getContactId() {
+            return mContactId;
+        }
+
+        public void updatePrimaryScore(int score) {
+            if (score > mPrimaryScore) {
+                mPrimaryScore = score;
+            }
+            mMatchCount++;
+        }
+
+        public void updateSecondaryScore(int score) {
+            if (score > mSecondaryScore) {
+                mSecondaryScore = score;
+            }
+            mMatchCount++;
+        }
+
+        public void keepIn() {
+            mKeepIn = true;
+        }
+
+        public void keepOut() {
+            mKeepOut = true;
+        }
+
+        public int getScore() {
+            if (mKeepOut) {
+                return 0;
+            }
+
+            if (mKeepIn) {
+                return MAX_SCORE;
+            }
+
+            int score = (mPrimaryScore > mSecondaryScore ? mPrimaryScore : mSecondaryScore);
+
+            // Ensure that of two contacts with the same match score the one with more matching
+            // data elements wins.
+            return score * SCORE_SCALE + mMatchCount;
+        }
+
+        /**
+         * Descending order of match score.
+         */
+        public int compareTo(MatchScore another) {
+            return another.getScore() - getScore();
+        }
+
+        @Override
+        public String toString() {
+            return mContactId + ": " + mPrimaryScore + "/" + mSecondaryScore + "(" + mMatchCount
+                    + ")";
+        }
+    }
+
+    private final HashMap<Long, MatchScore> mScores = new HashMap<Long, MatchScore>();
+    private final ArrayList<MatchScore> mScoreList = new ArrayList<MatchScore>();
+    private int mScoreCount = 0;
+
+    private final JaroWinklerDistance mJaroWinklerDistance =
+            new JaroWinklerDistance(MAX_MATCHED_NAME_LENGTH);
+
+    private MatchScore getMatchingScore(long contactId) {
+        MatchScore matchingScore = mScores.get(contactId);
+        if (matchingScore == null) {
+            if (mScoreList.size() > mScoreCount) {
+                matchingScore = mScoreList.get(mScoreCount);
+                matchingScore.reset(contactId);
+            } else {
+                matchingScore = new MatchScore(contactId);
+                mScoreList.add(matchingScore);
+            }
+            mScoreCount++;
+            mScores.put(contactId, matchingScore);
+        }
+        return matchingScore;
+    }
+
+    /**
+     * Checks if there is a match and updates the overall score for the
+     * specified contact for a discovered match. The new score is determined
+     * by the prior score, by the type of name we were looking for, the type
+     * of name we found and, if the match is approximate, the distance between the candidate and
+     * actual name.
+     */
+    public void matchName(long contactId, int candidateNameType, String candidateName,
+            int nameType, String name, boolean approximate) {
+        int maxScore = getMaxScore(candidateNameType, nameType);
+        if (maxScore == 0) {
+            return;
+        }
+
+        if (candidateName.equals(name)) {
+            updatePrimaryScore(contactId, maxScore);
+            return;
+        }
+
+        if (!approximate) {
+            return;
+        }
+
+        int minScore = getMinScore(candidateNameType, nameType);
+        if (minScore == maxScore) {
+            return;
+        }
+
+        float distance = mJaroWinklerDistance.getDistance(
+                Hex.decodeHex(candidateName), Hex.decodeHex(name));
+
+        int score;
+        if (distance > APPROXIMATE_MATCH_THRESHOLD) {
+            float adjustedDistance = (distance - APPROXIMATE_MATCH_THRESHOLD)
+                    / (1f - APPROXIMATE_MATCH_THRESHOLD);
+            score = (int)(minScore +  (maxScore - minScore) * adjustedDistance);
+        } else {
+            score = 0;
+        }
+
+        updatePrimaryScore(contactId, score);
+    }
+
+    public void updateScoreWithPhoneNumberMatch(long contactId) {
+        updateSecondaryScore(contactId, PHONE_MATCH_SCORE);
+    }
+
+    public void updateScoreWithEmailMatch(long contactId) {
+        updateSecondaryScore(contactId, EMAIL_MATCH_SCORE);
+    }
+
+    public void updateScoreWithNicknameMatch(long contactId) {
+        updateSecondaryScore(contactId, NICKNAME_MATCH_SCORE);
+    }
+
+    private void updatePrimaryScore(long contactId, int score) {
+        getMatchingScore(contactId).updatePrimaryScore(score);
+    }
+
+    private void updateSecondaryScore(long contactId, int score) {
+        getMatchingScore(contactId).updateSecondaryScore(score);
+    }
+
+    public void keepIn(long contactId) {
+        getMatchingScore(contactId).keepIn();
+    }
+
+    public void keepOut(long contactId) {
+        getMatchingScore(contactId).keepOut();
+    }
+
+    public void clear() {
+        mScores.clear();
+        mScoreCount = 0;
+    }
+
+    /**
+     * Returns a list of IDs for contacts that are matched on secondary data elements
+     * (phone number, email address, nickname). We still need to obtain the approximate
+     * primary score for those contacts to determine if any of them should be contactd.
+     * <p>
+     * May return null.
+     */
+    public List<Long> prepareSecondaryMatchCandidates(int threshold) {
+        ArrayList<Long> contactIds = null;
+
+        for (int i = 0; i < mScoreCount; i++) {
+            MatchScore score = mScoreList.get(i);
+            if (score.mKeepOut) {
+                continue;
+            }
+
+            int s = score.mSecondaryScore;
+            if (s >= threshold) {
+                if (contactIds == null) {
+                    contactIds = new ArrayList<Long>();
+                }
+                contactIds.add(score.mContactId);
+                score.mPrimaryScore = NO_DATA_SCORE;
+            }
+        }
+        return contactIds;
+    }
+
+    /**
+     * Returns the contactId with the best match score over the specified threshold or -1
+     * if no such contact is found.
+     */
+    public long pickBestMatch(int threshold) {
+        long contactId = -1;
+        int maxScore = 0;
+        for (int i = 0; i < mScoreCount; i++) {
+            MatchScore score = mScoreList.get(i);
+            if (score.mKeepIn) {
+                return score.mContactId;
+            }
+
+            if (score.mKeepOut) {
+                continue;
+            }
+
+            int s = score.mPrimaryScore;
+            if (s == NO_DATA_SCORE) {
+                s = score.mSecondaryScore;
+            }
+
+            if (s >= threshold && s > maxScore) {
+                contactId = score.mContactId;
+                maxScore = s;
+            }
+        }
+        return contactId;
+    }
+
+    /**
+     * Returns up to {@code maxSuggestions} best scoring matches.
+     */
+    public List<MatchScore> pickBestMatches(int maxSuggestions, int threshold) {
+        int scaledThreshold = threshold * SCORE_SCALE;
+        List<MatchScore> matches = mScoreList.subList(0, mScoreCount);
+        Collections.sort(matches);
+        int count = 0;
+        for (int i = 0; i < mScoreCount; i++) {
+            MatchScore matchScore = matches.get(i);
+            if (matchScore.getScore() >= scaledThreshold) {
+                count++;
+            } else {
+                break;
+            }
+        }
+
+        if (count > maxSuggestions) {
+            count = maxSuggestions;
+        }
+
+        return matches.subList(0, count);
+    }
+}
diff --git a/src/com/android/providers/contacts/ContactsProvider.java b/src/com/android/providers/contacts/ContactsProvider.java
index 777aa61..a89b6db 100644
--- a/src/com/android/providers/contacts/ContactsProvider.java
+++ b/src/com/android/providers/contacts/ContactsProvider.java
@@ -44,10 +44,8 @@
 import android.os.MemoryFile;
 import android.os.ParcelFileDescriptor;
 import android.provider.CallLog;
-import android.provider.Contacts;
-import android.provider.LiveFolders;
-import android.provider.SyncConstValue;
 import android.provider.CallLog.Calls;
+import android.provider.Contacts;
 import android.provider.Contacts.ContactMethods;
 import android.provider.Contacts.Extensions;
 import android.provider.Contacts.GroupMembership;
@@ -61,22 +59,24 @@
 import android.provider.Contacts.Photos;
 import android.provider.Contacts.Presence;
 import android.provider.Contacts.PresenceColumns;
+import android.provider.LiveFolders;
+import android.provider.SyncConstValue;
+import android.provider.Calendar;
 import android.telephony.PhoneNumberUtils;
 import android.text.TextUtils;
 import android.util.Config;
 import android.util.Log;
-
-import com.google.android.collect.Maps;
-import com.google.android.collect.Sets;
+import android.accounts.Account;
 
 import com.android.internal.database.ArrayListCursor;
+import com.google.android.collect.Maps;
+import com.google.android.collect.Sets;
 
 import java.io.FileNotFoundException;
 import java.io.IOException;
 import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.HashSet;
-import java.util.Locale;
 import java.util.Map;
 import java.util.Set;
 
@@ -125,7 +125,7 @@
      * other methods (other than the DB layer) */
     private final ContentValues mValuesLocal = new ContentValues();
 
-    private String[] mAccounts = new String[0];
+    private Account[] mAccounts = new Account[0];
     private final Object mAccountsLock = new Object();
 
     private DatabaseUtils.InsertHelper mDeletedPeopleInserter;
@@ -134,7 +134,8 @@
     private int mIndexPeopleSyncTime;
     private int mIndexPeopleSyncVersion;
     private int mIndexPeopleSyncDirty;
-    private int mIndexPeopleSyncAccount;
+    private int mIndexPeopleSyncAccountName;
+    private int mIndexPeopleSyncAccountType;
     private int mIndexPeopleName;
     private int mIndexPeoplePhoneticName;
     private int mIndexPeopleNotes;
@@ -145,7 +146,8 @@
     private int mIndexPhotosSyncTime;
     private int mIndexPhotosSyncVersion;
     private int mIndexPhotosSyncDirty;
-    private int mIndexPhotosSyncAccount;
+    private int mIndexPhotosSyncAccountName;
+    private int mIndexPhotosSyncAccountType;
     private int mIndexPhotosExistsOnServer;
     private int mIndexPhotosSyncError;
     private DatabaseUtils.InsertHelper mContactMethodsInserter;
@@ -169,7 +171,8 @@
     private int mIndexExtensionsValue;
     private DatabaseUtils.InsertHelper mGroupMembershipInserter;
     private int mIndexGroupMembershipPersonId;
-    private int mIndexGroupMembershipGroupSyncAccount;
+    private int mIndexGroupMembershipGroupSyncAccountName;
+    private int mIndexGroupMembershipGroupSyncAccountType;
     private int mIndexGroupMembershipGroupSyncId;
     private DatabaseUtils.InsertHelper mCallsInserter;
     private DatabaseUtils.InsertHelper mPhonesInserter;
@@ -180,28 +183,8 @@
     private int mIndexPhonesNumberKey;
     private int mIndexPhonesIsPrimary;
 
-    private static HashMap<String, String> mSearchSuggestionsProjectionMap;
-    private static String mSearchSuggestionLanguage;
-    
     public ContactsProvider() {
         super(DATABASE_NAME, DATABASE_VERSION, Contacts.CONTENT_URI);
-        mSearchSuggestionLanguage = Locale.getDefault().getLanguage();
-        // Search suggestions projection map
-        mSearchSuggestionsProjectionMap = new HashMap<String, String>();
-        updateSuggestColumnTexts();
-        mSearchSuggestionsProjectionMap.put(SearchManager.SUGGEST_COLUMN_ICON_1,
-                "(CASE WHEN " + Photos.DATA + " IS NOT NULL"
-                + " THEN '" + People.CONTENT_URI + "/' || people._id ||"
-                        + " '/" + Photos.CONTENT_DIRECTORY + "/data'"
-                + " ELSE " + com.android.internal.R.drawable.ic_contact_picture
-                + " END) AS " + SearchManager.SUGGEST_COLUMN_ICON_1);
-        mSearchSuggestionsProjectionMap.put(SearchManager.SUGGEST_COLUMN_ICON_2,
-                PRESENCE_ICON_SQL + " AS " + SearchManager.SUGGEST_COLUMN_ICON_2);
-        mSearchSuggestionsProjectionMap.put(SearchManager.SUGGEST_COLUMN_INTENT_DATA_ID,
-                "people._id AS " + SearchManager.SUGGEST_COLUMN_INTENT_DATA_ID);
-        mSearchSuggestionsProjectionMap.put(SearchManager.SUGGEST_COLUMN_SHORTCUT_ID,
-                "people._id AS " + SearchManager.SUGGEST_COLUMN_SHORTCUT_ID);
-        mSearchSuggestionsProjectionMap.put(People._ID, "people._id AS " + People._ID);
     }
 
     @Override
@@ -223,7 +206,8 @@
         mIndexPeopleSyncTime = mPeopleInserter.getColumnIndex(People._SYNC_TIME);
         mIndexPeopleSyncVersion = mPeopleInserter.getColumnIndex(People._SYNC_VERSION);
         mIndexPeopleSyncDirty = mPeopleInserter.getColumnIndex(People._SYNC_DIRTY);
-        mIndexPeopleSyncAccount = mPeopleInserter.getColumnIndex(People._SYNC_ACCOUNT);
+        mIndexPeopleSyncAccountName = mPeopleInserter.getColumnIndex(People._SYNC_ACCOUNT);
+        mIndexPeopleSyncAccountType = mPeopleInserter.getColumnIndex(People._SYNC_ACCOUNT_TYPE);
         mIndexPeopleName = mPeopleInserter.getColumnIndex(People.NAME);
         mIndexPeoplePhoneticName = mPeopleInserter.getColumnIndex(People.PHONETIC_NAME);
         mIndexPeopleNotes = mPeopleInserter.getColumnIndex(People.NOTES);
@@ -236,26 +220,32 @@
         mIndexPhotosSyncTime = mPhotosInserter.getColumnIndex(Photos._SYNC_TIME);
         mIndexPhotosSyncVersion = mPhotosInserter.getColumnIndex(Photos._SYNC_VERSION);
         mIndexPhotosSyncDirty = mPhotosInserter.getColumnIndex(Photos._SYNC_DIRTY);
-        mIndexPhotosSyncAccount = mPhotosInserter.getColumnIndex(Photos._SYNC_ACCOUNT);
+        mIndexPhotosSyncAccountName = mPhotosInserter.getColumnIndex(Photos._SYNC_ACCOUNT);
+        mIndexPhotosSyncAccountType = mPhotosInserter.getColumnIndex(Photos._SYNC_ACCOUNT_TYPE);
         mIndexPhotosSyncError = mPhotosInserter.getColumnIndex(Photos.SYNC_ERROR);
         mIndexPhotosExistsOnServer = mPhotosInserter.getColumnIndex(Photos.EXISTS_ON_SERVER);
 
         mContactMethodsInserter = new DatabaseUtils.InsertHelper(db, sContactMethodsTable);
-        mIndexContactMethodsPersonId = mContactMethodsInserter.getColumnIndex(ContactMethods.PERSON_ID);
+        mIndexContactMethodsPersonId =
+                mContactMethodsInserter.getColumnIndex(ContactMethods.PERSON_ID);
         mIndexContactMethodsLabel = mContactMethodsInserter.getColumnIndex(ContactMethods.LABEL);
         mIndexContactMethodsKind = mContactMethodsInserter.getColumnIndex(ContactMethods.KIND);
         mIndexContactMethodsType = mContactMethodsInserter.getColumnIndex(ContactMethods.TYPE);
         mIndexContactMethodsData = mContactMethodsInserter.getColumnIndex(ContactMethods.DATA);
-        mIndexContactMethodsAuxData = mContactMethodsInserter.getColumnIndex(ContactMethods.AUX_DATA);
-        mIndexContactMethodsIsPrimary = mContactMethodsInserter.getColumnIndex(ContactMethods.ISPRIMARY);
+        mIndexContactMethodsAuxData =
+                mContactMethodsInserter.getColumnIndex(ContactMethods.AUX_DATA);
+        mIndexContactMethodsIsPrimary =
+                mContactMethodsInserter.getColumnIndex(ContactMethods.ISPRIMARY);
 
         mOrganizationsInserter = new DatabaseUtils.InsertHelper(db, sOrganizationsTable);
-        mIndexOrganizationsPersonId = mOrganizationsInserter.getColumnIndex(Organizations.PERSON_ID);
+        mIndexOrganizationsPersonId =
+                mOrganizationsInserter.getColumnIndex(Organizations.PERSON_ID);
         mIndexOrganizationsLabel = mOrganizationsInserter.getColumnIndex(Organizations.LABEL);
         mIndexOrganizationsType = mOrganizationsInserter.getColumnIndex(Organizations.TYPE);
         mIndexOrganizationsCompany = mOrganizationsInserter.getColumnIndex(Organizations.COMPANY);
         mIndexOrganizationsTitle = mOrganizationsInserter.getColumnIndex(Organizations.TITLE);
-        mIndexOrganizationsIsPrimary = mOrganizationsInserter.getColumnIndex(Organizations.ISPRIMARY);
+        mIndexOrganizationsIsPrimary =
+                mOrganizationsInserter.getColumnIndex(Organizations.ISPRIMARY);
 
         mExtensionsInserter = new DatabaseUtils.InsertHelper(db, sExtensionsTable);
         mIndexExtensionsPersonId = mExtensionsInserter.getColumnIndex(Extensions.PERSON_ID);
@@ -263,9 +253,14 @@
         mIndexExtensionsValue = mExtensionsInserter.getColumnIndex(Extensions.VALUE);
 
         mGroupMembershipInserter = new DatabaseUtils.InsertHelper(db, sGroupmembershipTable);
-        mIndexGroupMembershipPersonId = mGroupMembershipInserter.getColumnIndex(GroupMembership.PERSON_ID);
-        mIndexGroupMembershipGroupSyncAccount = mGroupMembershipInserter.getColumnIndex(GroupMembership.GROUP_SYNC_ACCOUNT);
-        mIndexGroupMembershipGroupSyncId = mGroupMembershipInserter.getColumnIndex(GroupMembership.GROUP_SYNC_ID);
+        mIndexGroupMembershipPersonId =
+                mGroupMembershipInserter.getColumnIndex(GroupMembership.PERSON_ID);
+        mIndexGroupMembershipGroupSyncAccountName =
+                mGroupMembershipInserter.getColumnIndex(GroupMembership.GROUP_SYNC_ACCOUNT);
+        mIndexGroupMembershipGroupSyncAccountType =
+                mGroupMembershipInserter.getColumnIndex(GroupMembership.GROUP_SYNC_ACCOUNT_TYPE);
+        mIndexGroupMembershipGroupSyncId =
+                mGroupMembershipInserter.getColumnIndex(GroupMembership.GROUP_SYNC_ID);
 
         mCallsInserter = new DatabaseUtils.InsertHelper(db, sCallsTable);
 
@@ -307,23 +302,9 @@
             // use new token format from 73
             db.execSQL("delete from peopleLookup");
             try {
-                // With longForQuery(), _TOKERNIZE() is called just once, toward the first entry
-                // in "people" table. This may be a bug. Instead, we use rawQuery() for now. 
-                // DatabaseUtils.longForQuery(db, query, null);
-
-                // Cursors objects are lazily executed. So we have to call some method which forces
-                // the cursor to run the query.
-                Cursor cursor =
-                    db.rawQuery("SELECT _TOKENIZE('peopleLookup', _id, name, ' ') from people",
-                            null);
-                try {
-                    int rows = cursor.getCount();
-                    Log.i(TAG, "Processed " + rows + " contacts.");
-                } finally {
-                    if (cursor != null) {
-                        cursor.close();
-                    }
-                }
+                DatabaseUtils.longForQuery(db,
+                        "SELECT _TOKENIZE('peopleLookup', _id, name, ' ') from people;",
+                        null);
             } catch (SQLiteDoneException ex) {
                 // it is ok to throw this, 
                 // it just means you don't have data in people table
@@ -385,52 +366,71 @@
             oldVersion = 80;
         }
 
-        // Because of historical reason, version 81 have two types.
-        // 1) One type already has "peopleLookupWithPhoneticName" table but does not have
-        // "peopleLookup" table with token_index.
-        // 2) Another type has "peopleLookup" table with token_index but does not have
-        // "peopleLookupWithPhoneticName" table.
-        // For simplicity, both databases are once dropped here.
-        // This is slow but should be done just once anyway...
-        if (oldVersion == 80 || oldVersion == 81) {
+        if (oldVersion == 80) {
+            db.execSQL("ALTER TABLE people ADD COLUMN _sync_account_type TEXT;");
+            db.execSQL("ALTER TABLE _deleted_people ADD COLUMN _sync_account_type TEXT;");
+            db.execSQL("ALTER TABLE groups ADD COLUMN _sync_account_type TEXT;");
+            db.execSQL("ALTER TABLE _deleted_groups ADD COLUMN _sync_account_type TEXT;");
+            db.execSQL("ALTER TABLE settings ADD COLUMN _sync_account_type TEXT;");
+            db.execSQL("ALTER TABLE photos ADD COLUMN _sync_account_type TEXT;");
+            db.execSQL("ALTER TABLE groupmembership ADD COLUMN _sync_account_type TEXT;");
+
+            db.execSQL("UPDATE people"
+                    + " SET _sync_account_type='com.google.GAIA'"
+                    + " WHERE _sync_account IS NOT NULL");
+            db.execSQL("UPDATE _deleted_people"
+                    + " SET _sync_account_type='com.google.GAIA'"
+                    + " WHERE _sync_account IS NOT NULL");
+            db.execSQL("UPDATE groups"
+                    + " SET _sync_account_type='com.google.GAIA'"
+                    + " WHERE _sync_account IS NOT NULL");
+            db.execSQL("UPDATE _deleted_groups"
+                    + " SET _sync_account_type='com.google.GAIA'"
+                    + " WHERE _sync_account IS NOT NULL");
+            db.execSQL("UPDATE settings"
+                    + " SET _sync_account_type='com.google.GAIA'"
+                    + " WHERE _sync_account IS NOT NULL");
+            db.execSQL("UPDATE photos"
+                    + " SET _sync_account_type='com.google.GAIA'"
+                    + " WHERE _sync_account IS NOT NULL");
+            db.execSQL("UPDATE groupmembership"
+                    + " SET _sync_account_type='com.google.GAIA'"
+                    + " WHERE _sync_account IS NOT NULL");
+
+            db.execSQL("CREATE INDEX groupTempIndex ON groups ("
+                    + Groups.NAME + ","  + Groups.SYSTEM_ID + "," + Groups._SYNC_ACCOUNT + ","
+                    + Groups._SYNC_ACCOUNT_TYPE + ");");
+
+            db.execSQL("DROP INDEX groupmembershipIndex3");
+            db.execSQL("CREATE INDEX groupmembershipIndex3 ON groupmembership "
+                    + "(group_sync_account_type, group_sync_account, group_sync_id);");
+
+            // Trigger to move an account_people row to _deleted_account_people when it is deleted
+            db.execSQL("DROP TRIGGER groups_to_deleted");
+            db.execSQL("CREATE TRIGGER groups_to_deleted DELETE ON groups " +
+                        "WHEN old._sync_id is not null " +
+                        "BEGIN " +
+                            "INSERT INTO _deleted_groups " +
+                                "(_sync_id, _sync_account, _sync_account_type, _sync_version) " +
+                                "VALUES (old._sync_id, old._sync_account, old._sync_account_type," +
+                                "old._sync_version);" +
+                        "END");
+
+            oldVersion++;
+        }
+
+        if (oldVersion == 81) {
             Log.i(TAG, "Upgrading contacts database from version " + oldVersion + " to " +
                     newVersion + ", which will preserve existing data");
-
-            recreatePeopleLookupTable(db);
-            try {
-                String query = "SELECT _TOKENIZE('peopleLookup', _id, name, ' ', 1) FROM people";
-                Cursor cursor = db.rawQuery(query, null);
-                try {
-                    int rows = cursor.getCount();
-                    Log.i(TAG, "Processed " + rows + " contacts.");
-                } finally {
-                    if (cursor != null) {
-                        cursor.close();
-                    }
-                }
-            } catch (SQLiteException e) {
-                Log.e(TAG, e.toString() + ": " + e.getMessage());
-            }
-            
-            recreatePeopleLookupWithPhoneticNameTable(db);
-            try {
-                String query = "SELECT _TOKENIZE('peopleLookupWithPhoneticName', _id, "
-                    + PHONETIC_LOOKUP_SQL_SIMPLE +
-                    ", ' ', 1) FROM people";
-                Cursor cursor = db.rawQuery(query, null);
-                try {
-                    int rows = cursor.getCount();
-                    Log.i(TAG, "Processed " + rows + " contacts.");
-                } finally {
-                    if (cursor != null) {
-                        cursor.close();
-                    }
-                }
-            } catch (SQLiteException e) {
-                Log.e(TAG, e.toString() + ": " + e.getMessage());
-            }
-            
-            oldVersion = 82;
+            // 81 adds the token_index column
+            db.execSQL("DELETE FROM peopleLookup");
+            db.execSQL("ALTER TABLE peopleLookup ADD token_index INTEGER;");
+            String[] tokenize = {"_TOKENIZE('peopleLookup', _id, name, ' ', 1)"};
+            Cursor cursor = db.query("people", tokenize, null, null, null, null, null);
+            int rows = cursor.getCount();
+            cursor.close();
+            Log.i(TAG, "Processed " + rows + " contacts.");
+            oldVersion = 81;
         }
 
         return upgradeWasLossless;
@@ -439,7 +439,6 @@
     protected void dropTables(SQLiteDatabase db) {
         db.execSQL("DROP TABLE IF EXISTS people");
         db.execSQL("DROP TABLE IF EXISTS peopleLookup");
-        db.execSQL("DROP TABLE IF EXISTS peopleLookupWithPhoneticName");
         db.execSQL("DROP TABLE IF EXISTS _deleted_people");
         db.execSQL("DROP TABLE IF EXISTS phones");
         db.execSQL("DROP TABLE IF EXISTS contact_methods");
@@ -454,74 +453,13 @@
         db.execSQL("DROP TABLE IF EXISTS settings");
     }
 
-    private void recreatePeopleLookupTable(SQLiteDatabase db) {
-        db.execSQL("DROP TABLE IF EXISTS peopleLookup");
-        db.execSQL("DROP INDEX IF EXISTS peopleLookupIndex");
-        db.execSQL("DROP TRIGGER IF EXISTS peopleLookup_update"); 
-        db.execSQL("DROP TRIGGER IF EXISTS peopleLookup_insert");
-
-        db.execSQL("CREATE TABLE peopleLookup (" +
-                "token TEXT," +
-                "source INTEGER REFERENCES people(_id)," +
-                "token_index INTEGER" +
-                ");");
-        db.execSQL("CREATE INDEX peopleLookupIndex ON peopleLookup (" +
-                "token," +
-                "source" +
-                ");");
-        
-        // Triggers to keep the peopleLookup table up to date
-        db.execSQL("CREATE TRIGGER peopleLookup_update UPDATE OF name ON people " +
-                    "BEGIN " +
-                        "DELETE FROM peopleLookup WHERE source = new._id;" +
-                        "SELECT _TOKENIZE('peopleLookup', new._id, new.name, ' ', 1);" +
-                    "END");
-        db.execSQL("CREATE TRIGGER peopleLookup_insert AFTER INSERT ON people " +
-                    "BEGIN " +
-                        "SELECT _TOKENIZE('peopleLookup', new._id, new.name, ' ', 1);" +
-                    "END");
-    }
-    
-    private void recreatePeopleLookupWithPhoneticNameTable(SQLiteDatabase db) {
-        db.execSQL("DROP TABLE IF EXISTS peopleLookupWithPhoneticName");
-        db.execSQL("DROP INDEX IF EXISTS peopleLookupwithPhoneticNameIndex");
-        db.execSQL("DROP TRIGGER IF EXISTS peopleLookupWithPhoneticName_update");
-        db.execSQL("DROP TRIGGER IF EXISTS peopleLookupWithPhoneticName_insert");
-
-        db.execSQL("CREATE TABLE peopleLookupWithPhoneticName (" +
-                "token TEXT," +
-                "source INTEGER REFERENCES people(_id)," +
-                "token_index INTEGER" +
-                ");");
-        db.execSQL("CREATE INDEX peopleLookupWithPhoneticNameIndex ON " +
-                "peopleLookupWithPhoneticName (" +
-                "token," +
-                "source" +
-                ");");
-
-        // Triggers to keep the peopleLookupWithPhoneticName table up to date
-        db.execSQL("CREATE TRIGGER peopleLookupWithPhoneticName_update UPDATE OF " +
-                    "name, phonetic_name ON people " +
-                    "BEGIN " +
-                        "DELETE FROM peopleLookupWithPhoneticName WHERE source = new._id;" +
-                        "SELECT _TOKENIZE('peopleLookupWithPhoneticName', new._id, " +
-                        PHONETIC_LOOKUP_SQL_SIMPLE_WITH_NEW +
-                        ", ' ', 1);" +
-                    "END");
-        db.execSQL("CREATE TRIGGER peopleLookupWithPhoneticName_insert AFTER INSERT ON people " +
-                    "BEGIN " +
-                        "SELECT _TOKENIZE('peopleLookupWithPhoneticName', new._id, " +
-                        PHONETIC_LOOKUP_SQL_SIMPLE_WITH_NEW +
-                        ", ' ', 1);" +
-                    "END");
-    }
-    
     @Override
     protected void bootstrapDatabase(SQLiteDatabase db) {
         super.bootstrapDatabase(db);
         db.execSQL("CREATE TABLE people (" +
                     People._ID + " INTEGER PRIMARY KEY AUTOINCREMENT," +
                     People._SYNC_ACCOUNT + " TEXT," + // From the sync source
+                    People._SYNC_ACCOUNT_TYPE + " TEXT," + // From the sync source
                     People._SYNC_ID + " TEXT," + // From the sync source
                     People._SYNC_TIME + " TEXT," + // From the sync source
                     People._SYNC_VERSION + " TEXT," + // From the sync source
@@ -560,6 +498,7 @@
         db.execSQL("CREATE TABLE groups (" +
                 Groups._ID + " INTEGER PRIMARY KEY AUTOINCREMENT," +
                 Groups._SYNC_ACCOUNT + " TEXT," + // From the sync source
+                Groups._SYNC_ACCOUNT_TYPE + " TEXT," + // From the sync source
                 Groups._SYNC_ID + " TEXT," + // From the sync source
                 Groups._SYNC_TIME + " TEXT," + // From the sync source
                 Groups._SYNC_VERSION + " TEXT," + // From the sync source
@@ -574,7 +513,8 @@
                 Groups.SHOULD_SYNC + " INTEGER NOT NULL DEFAULT 0," +
                 Groups.SYSTEM_ID + " TEXT," +
                 "UNIQUE(" +
-                Groups.NAME + ","  + Groups.SYSTEM_ID + "," + Groups._SYNC_ACCOUNT + ")" +
+                Groups.NAME + ","  + Groups.SYSTEM_ID + "," + Groups._SYNC_ACCOUNT + "," +
+                Groups._SYNC_ACCOUNT_TYPE + ")" +
                 ");");
 
         db.execSQL("CREATE INDEX groupsSyncDirtyIndex ON groups (" + Groups._SYNC_DIRTY + ");");
@@ -603,6 +543,7 @@
                 + Photos.DATA + " BLOB,"
                 + Photos.SYNC_ERROR + " TEXT,"
                 + Photos._SYNC_ACCOUNT + " TEXT,"
+                + Photos._SYNC_ACCOUNT_TYPE + " TEXT,"
                 + Photos._SYNC_ID + " TEXT,"
                 + Photos._SYNC_TIME + " TEXT,"
                 + Photos._SYNC_VERSION + " TEXT,"
@@ -627,6 +568,7 @@
                     "_sync_id TEXT," +
                     (isTemporary() ? "_sync_local_id INTEGER," : "") + // Used while syncing,
                     "_sync_account TEXT," +
+                    "_sync_account_type TEXT," +
                     "_sync_mark INTEGER)"); // Used to filter out new rows
 
         db.execSQL("CREATE TABLE _deleted_groups (" +
@@ -634,6 +576,7 @@
                     "_sync_id TEXT," +
                     (isTemporary() ? "_sync_local_id INTEGER," : "") + // Used while syncing,
                     "_sync_account TEXT," +
+                    "_sync_account_type TEXT," +
                     "_sync_mark INTEGER)"); // Used to filter out new rows
 
         db.execSQL("CREATE TABLE phones (" +
@@ -680,6 +623,7 @@
         db.execSQL("CREATE TABLE settings (" +
                     "_id INTEGER PRIMARY KEY," +
                     "_sync_account TEXT," +
+                    "_sync_account_type TEXT," +
                     "key STRING NOT NULL," +
                     "value STRING " +
                     ");");
@@ -712,18 +656,18 @@
                 "person INTEGER REFERENCES people(_id)," +
                 "group_id INTEGER REFERENCES groups(_id)," +
                 "group_sync_account STRING," +
+                "group_sync_account_type STRING," +
                 "group_sync_id STRING" +
                 ");");
         db.execSQL("CREATE INDEX groupmembershipIndex1 ON groupmembership (person, group_id);");
         db.execSQL("CREATE INDEX groupmembershipIndex2 ON groupmembership (group_id, person);");
         db.execSQL("CREATE INDEX groupmembershipIndex3 ON groupmembership "
-                + "(group_sync_account, group_sync_id);");
+                + "(group_sync_account, group_sync_account_type, group_sync_id);");
 
         // Trigger to completely remove a contacts data when they're deleted
         db.execSQL("CREATE TRIGGER contact_cleanup DELETE ON people " +
                     "BEGIN " +
                         "DELETE FROM peopleLookup WHERE source = old._id;" +
-                        "DELETE FROM peopleLookupWithPhoneticName WHERE source = old._id;" +
                         "DELETE FROM phones WHERE person = old._id;" +
                         "DELETE FROM contact_methods WHERE person = old._id;" +
                         "DELETE FROM organizations WHERE person = old._id;" +
@@ -743,14 +687,22 @@
                     "WHEN old._sync_id is not null " +
                     "BEGIN " +
                         "INSERT INTO _deleted_groups " +
-                            "(_sync_id, _sync_account, _sync_version) " +
-                            "VALUES (old._sync_id, old._sync_account, " +
+                            "(_sync_id, _sync_account, _sync_account_type, _sync_version) " +
+                            "VALUES (old._sync_id, old._sync_account, old._sync_account_type, " +
                             "old._sync_version);" +
                     "END");
 
-        recreatePeopleLookupTable(db);
-        recreatePeopleLookupWithPhoneticNameTable(db);
-        
+        // Triggers to keep the peopleLookup table up to date
+        db.execSQL("CREATE TRIGGER peopleLookup_update UPDATE OF name ON people " +
+                    "BEGIN " +
+                        "DELETE FROM peopleLookup WHERE source = new._id;" +
+                        "SELECT _TOKENIZE('peopleLookup', new._id, new.name, ' ', 1);" +
+                    "END");
+        db.execSQL("CREATE TRIGGER peopleLookup_insert AFTER INSERT ON people " +
+                    "BEGIN " +
+                        "SELECT _TOKENIZE('peopleLookup', new._id, new.name, ' ', 1);" +
+                    "END");
+
         // Triggers to set the _sync_dirty flag when a phone is changed,
         // inserted or deleted
         db.execSQL("CREATE TRIGGER phones_update UPDATE ON phones " +
@@ -887,10 +839,10 @@
                 + Presence.PERSON_ID + ");");
     }
 
-    private String buildPeopleLookupWhereClauseCommon(String filterParam, String tableName) {
-        StringBuilder filter = new StringBuilder("people._id IN (SELECT source FROM ");
-        filter.append(tableName);
-        filter.append(" WHERE token GLOB ");
+    @SuppressWarnings("deprecation")
+    private String buildPeopleLookupWhereClause(String filterParam) {
+        StringBuilder filter = new StringBuilder(
+                "people._id IN (SELECT source FROM peopleLookup WHERE token GLOB ");
         // NOTE: Query parameters won't work here since the SQL compiler
         // needs to parse the actual string to know that it can use the
         // index to do a prefix scan.
@@ -899,18 +851,7 @@
         filter.append(')');
         return filter.toString();
     }
-    
-    private String buildPeopleLookupWhereClause(String filterParam) {
-        return buildPeopleLookupWhereClauseCommon(filterParam, "peopleLookup");
-    }
 
-    private String buildPeopleLookupWhereClauseForSuggestion(String filterParam) {
-        return buildPeopleLookupWhereClauseCommon(filterParam,
-                usePhoneticNameForPeopleLookup()
-                        ? "peopleLookupWithPhoneticName"
-                        : "peopleLookup");
-    }
-    
     @Override
     public Cursor queryInternal(Uri url, String[] projectionIn,
             String selection, String[] selectionArgs, String sort) {
@@ -1079,7 +1020,7 @@
             }
             case SEARCH_SHORTCUT: {
                 qb.setTables(PEOPLE_PHONES_PHOTOS_ORGANIZATIONS_JOIN);
-                qb.setProjectionMap(getCurrentSearchSuggestionsProjectionMap());
+                qb.setProjectionMap(sSearchSuggestionsProjectionMap);
                 qb.appendWhere(SearchManager.SUGGEST_COLUMN_SHORTCUT_ID + "=");
                 qb.appendWhere(url.getPathSegments().get(1));
                 break;
@@ -1472,7 +1413,8 @@
         return "people._id IN (SELECT person FROM groupmembership JOIN groups " +
                 "ON (group_id=groups._id OR " +
                 "(group_sync_id = groups._sync_id AND " +
-                    "group_sync_account = groups._sync_account)) "+
+                    "group_sync_account = groups._sync_account AND " +
+                    "group_sync_account_type = groups._sync_account_type)) "+
                 "WHERE " + Groups.NAME + "="
                 + DatabaseUtils.sqlEscapeString(groupName) + ")";
     }
@@ -1511,17 +1453,6 @@
         }
     }
 
-    private HashMap<String, String> getCurrentSearchSuggestionsProjectionMap() {
-        String currentLanguage = Locale.getDefault().getLanguage();
-        synchronized (this) {
-            if (!currentLanguage.equals(mSearchSuggestionLanguage)) {
-                mSearchSuggestionLanguage = currentLanguage;
-                updateSuggestColumnTexts();
-            }
-        }
-        return mSearchSuggestionsProjectionMap; 
-    }
-    
     /**
      * Either sets up the query builder so we can run the proper query against the database
      * and returns null, or returns a cursor with the results already in it.
@@ -1532,7 +1463,7 @@
      */
     private Cursor handleSearchSuggestionsQuery(Uri url, SQLiteQueryBuilder qb) {
         qb.setTables(PEOPLE_PHONES_PHOTOS_ORGANIZATIONS_JOIN);
-        qb.setProjectionMap(getCurrentSearchSuggestionsProjectionMap());
+        qb.setProjectionMap(sSearchSuggestionsProjectionMap);
         if (url.getPathSegments().size() > 1) {
             // A search term was entered, use it to filter
 
@@ -1546,7 +1477,7 @@
             // match the query
             final String searchClause = url.getLastPathSegment();
             if (!TextUtils.isDigitsOnly(searchClause)) {
-                qb.appendWhere(buildPeopleLookupWhereClauseForSuggestion(searchClause));
+                qb.appendWhere(buildPeopleLookupWhereClause(searchClause));
             } else {
                 final String[] columnNames = new String[] {
                         "_id",
@@ -1699,18 +1630,19 @@
         return mime;
     }
 
-    private ContentValues queryAndroidStarredGroupId(String account) {
+    private ContentValues queryAndroidStarredGroupId(Account account) {
         String whereString;
         String[] whereArgs;
-        if (!TextUtils.isEmpty(account)) {
-            whereString = "_sync_account=? AND name=?";
-            whereArgs = new String[]{account, Groups.GROUP_ANDROID_STARRED};
+        if (account != null) {
+            whereString = "_sync_account=? AND _sync_account_type=? AND name=?";
+            whereArgs = new String[]{account.mName, account.mType, Groups.GROUP_ANDROID_STARRED};
         } else {
             whereString = "_sync_account is null AND name=?";
             whereArgs = new String[]{Groups.GROUP_ANDROID_STARRED};
         }
         Cursor cursor = getDatabase().query(sGroupsTable,
-                new String[]{Groups._ID, Groups._SYNC_ID, Groups._SYNC_ACCOUNT},
+                new String[]{Groups._ID, Groups._SYNC_ID, Groups._SYNC_ACCOUNT,
+                        Groups._SYNC_ACCOUNT_TYPE},
                 whereString, whereArgs, null, null, null);
         try {
             if (cursor.moveToNext()) {
@@ -1718,6 +1650,7 @@
                 result.put(Groups._ID, cursor.getLong(0));
                 result.put(Groups._SYNC_ID, cursor.getString(1));
                 result.put(Groups._SYNC_ACCOUNT, cursor.getString(2));
+                result.put(Groups._SYNC_ACCOUNT_TYPE, cursor.getString(3));
                 return result;
             }
             return null;
@@ -1783,9 +1716,11 @@
                 if (rowID > 0) {
                     resultUri = ContentUris.withAppendedId(Groups.CONTENT_URI, rowID);
                     if (!isTemporary() && newMap.containsKey(Groups.SHOULD_SYNC)) {
-                        final String account = newMap.getAsString(Groups._SYNC_ACCOUNT);
-                        if (!TextUtils.isEmpty(account)) {
+                        final String accountName = newMap.getAsString(Groups._SYNC_ACCOUNT);
+                        final String accountType = newMap.getAsString(Groups._SYNC_ACCOUNT_TYPE);
+                        if (!TextUtils.isEmpty(accountName) || !TextUtils.isEmpty(accountType)) {
                             final ContentResolver cr = getContext().getContentResolver();
+                            final Account account = new Account(accountName, accountType);
                             onLocalChangesForAccount(cr, account, false);
                         }
                     }
@@ -1804,7 +1739,12 @@
                 if (rowID > 0) {
                     resultUri = ContentUris.withAppendedId(People.CONTENT_URI, rowID);
                     if (!isTemporary()) {
-                        String account = mValues.getAsString(People._SYNC_ACCOUNT);
+                        String accountName = mValues.getAsString(People._SYNC_ACCOUNT);
+                        String accountType = mValues.getAsString(People._SYNC_ACCOUNT_TYPE);
+                        Account account = null;
+                        if (accountName != null || accountType != null) {
+                            account = new Account(accountName, accountType);
+                        }
                         Long starredValue = mValues.getAsLong(People.STARRED);
                         final String syncId = mValues.getAsString(People._SYNC_ID);
                         boolean isStarred = starredValue != null && starredValue != 0;
@@ -1813,7 +1753,8 @@
                         mDb.delete(sPhotosTable, "person=" + rowID, null);
                         mValues.clear();
                         mValues.put(Photos.PERSON_ID, rowID);
-                        mValues.put(Photos._SYNC_ACCOUNT, account);
+                        mValues.put(Photos._SYNC_ACCOUNT, accountName);
+                        mValues.put(Photos._SYNC_ACCOUNT_TYPE, accountType);
                         mValues.put(Photos._SYNC_ID, syncId);
                         mValues.put(Photos._SYNC_DIRTY, 0);
                         mPhotosInserter.insert(mValues);
@@ -1973,19 +1914,26 @@
     }
 
     @Override
-    protected void onAccountsChanged(String[] accountsArray) {
+    protected void onAccountsChanged(Account[] accountsArray) {
         super.onAccountsChanged(accountsArray);
         synchronized (mAccountsLock) {
-            mAccounts = new String[accountsArray.length];
+            mAccounts = new Account[accountsArray.length];
             System.arraycopy(accountsArray, 0, mAccounts, 0, mAccounts.length);
         }
     }
 
     private void ensureSyncAccountIsSet(ContentValues values) {
         synchronized (mAccountsLock) {
-            String account = values.getAsString(SyncConstValue._SYNC_ACCOUNT);
+            final String accountName = values.getAsString(SyncConstValue._SYNC_ACCOUNT);
+            final String accountType = values.getAsString(SyncConstValue._SYNC_ACCOUNT_TYPE);
+            Account account = null;
+            if (!TextUtils.isEmpty(accountName) || !TextUtils.isEmpty(accountType)) {
+                account = new Account(accountName, accountType);
+            }
             if (account == null && mAccounts.length > 0) {
-                values.put(SyncConstValue._SYNC_ACCOUNT, mAccounts[0]);
+                // TODO(fredq) change this to pick the account that is syncable for contacts
+                values.put(SyncConstValue._SYNC_ACCOUNT, mAccounts[0].mName);
+                values.put(SyncConstValue._SYNC_ACCOUNT_TYPE, mAccounts[0].mType);
             }
         }
     }
@@ -2008,21 +1956,28 @@
     }
 
     private Uri insertIntoGroupmembership(ContentValues values) {
-        String groupSyncAccount = values.getAsString(GroupMembership.GROUP_SYNC_ACCOUNT);
+        String groupSyncAccountName = values.getAsString(GroupMembership.GROUP_SYNC_ACCOUNT);
+        String groupSyncAccountType = values.getAsString(GroupMembership.GROUP_SYNC_ACCOUNT_TYPE);
         String groupSyncId = values.getAsString(GroupMembership.GROUP_SYNC_ID);
         final Long personId = values.getAsLong(GroupMembership.PERSON_ID);
         if (!values.containsKey(GroupMembership.GROUP_ID)) {
-            if (TextUtils.isEmpty(groupSyncAccount) || TextUtils.isEmpty(groupSyncId)) {
+            if (TextUtils.isEmpty(groupSyncAccountName) || TextUtils.isEmpty(groupSyncAccountType)
+                    || TextUtils.isEmpty(groupSyncId)) {
                 throw new IllegalArgumentException(
                         "insertIntoGroupmembership: no GROUP_ID wasn't specified and non-empty "
-                        + "GROUP_SYNC_ID and GROUP_SYNC_ACCOUNT fields weren't specifid, "
+                        + "GROUP_SYNC_ID and GROUP_SYNC_ACCOUNT and GROUP_SYNC_ACCOUNT_TYPE fields "
+                        + "weren't specifid, "
                         + values);
             }
             if (0 != DatabaseUtils.longForQuery(getDatabase(), ""
                     + "SELECT COUNT(*) "
                     + "FROM groupmembership "
-                    + "WHERE group_sync_id=? AND person=?",
-                    new String[]{groupSyncId, String.valueOf(personId)})) {
+                    + "WHERE group_sync_id=? "
+                    + "  AND group_sync_account=? "
+                    + "  AND group_sync_account_type=? "
+                    + "  AND person=?",
+                    new String[]{groupSyncId, groupSyncAccountName, groupSyncAccountType,
+                            String.valueOf(personId)})) {
                 final String errorMessage =
                         "insertIntoGroupmembership: a row with this server key already exists, "
                                 + values;
@@ -2031,10 +1986,12 @@
             }
         } else {
             long groupId = values.getAsLong(GroupMembership.GROUP_ID);
-            if (!TextUtils.isEmpty(groupSyncAccount) || !TextUtils.isEmpty(groupSyncId)) {
+            if (!TextUtils.isEmpty(groupSyncAccountName) || !TextUtils.isEmpty(groupSyncAccountType)
+                    || !TextUtils.isEmpty(groupSyncId)) {
                 throw new IllegalArgumentException(
                         "insertIntoGroupmembership: GROUP_ID was specified but "
-                        + "GROUP_SYNC_ID and GROUP_SYNC_ACCOUNT fields were also specifid, "
+                        + "GROUP_SYNC_ID and GROUP_SYNC_ACCOUNT and GROUP_SYNC_ACCOUNT_TYPE fields "
+                        + "were also specifid, "
                         + values);
             }
             if (0 != DatabaseUtils.longForQuery(getDatabase(),
@@ -2064,7 +2021,7 @@
         return ContentUris.withAppendedId(GroupMembership.CONTENT_URI, rowId);
     }
 
-    private void fixupGroupMembershipAfterPeopleUpdate(String account, long personId,
+    private void fixupGroupMembershipAfterPeopleUpdate(Account account, long personId,
             boolean makeStarred) {
         ContentValues starredGroupInfo = queryAndroidStarredGroupId(account);
         if (makeStarred) {
@@ -2073,17 +2030,22 @@
                 mValuesLocal.clear();
                 mValuesLocal.put(Groups.NAME, Groups.GROUP_ANDROID_STARRED);
                 mValuesLocal.put(Groups._SYNC_DIRTY, 1);
-                mValuesLocal.put(Groups._SYNC_ACCOUNT, account);
+                mValuesLocal.put(Groups._SYNC_ACCOUNT, account == null ? null : account.mName);
+                mValuesLocal.put(Groups._SYNC_ACCOUNT_TYPE, account == null ? null : account.mType);
                 long groupId = mGroupsInserter.insert(mValuesLocal);
                 starredGroupInfo = new ContentValues();
                 starredGroupInfo.put(Groups._ID, groupId);
-                starredGroupInfo.put(Groups._SYNC_ACCOUNT, account);
+                starredGroupInfo.put(Groups._SYNC_ACCOUNT,
+                        mValuesLocal.getAsString(Groups._SYNC_ACCOUNT));
+                starredGroupInfo.put(Groups._SYNC_ACCOUNT_TYPE,
+                        mValuesLocal.getAsString(Groups._SYNC_ACCOUNT_TYPE));
                 // don't put the _SYNC_ID in here since we don't know it yet
             }
 
             final Long groupId = starredGroupInfo.getAsLong(Groups._ID);
             final String syncId = starredGroupInfo.getAsString(Groups._SYNC_ID);
-            final String syncAccount = starredGroupInfo.getAsString(Groups._SYNC_ACCOUNT);
+            final String syncAccountName = starredGroupInfo.getAsString(Groups._SYNC_ACCOUNT);
+            final String syncAccountType = starredGroupInfo.getAsString(Groups._SYNC_ACCOUNT_TYPE);
 
             // check that either groupId is set or the syncId/Account is set
             final boolean hasSyncId = !TextUtils.isEmpty(syncId);
@@ -2098,17 +2060,21 @@
             mValuesLocal.put(GroupMembership.PERSON_ID, personId);
             mValuesLocal.put(GroupMembership.GROUP_ID, groupId);
             mValuesLocal.put(GroupMembership.GROUP_SYNC_ID, syncId);
-            mValuesLocal.put(GroupMembership.GROUP_SYNC_ACCOUNT, syncAccount);
+            mValuesLocal.put(GroupMembership.GROUP_SYNC_ACCOUNT, syncAccountName);
+            mValuesLocal.put(GroupMembership.GROUP_SYNC_ACCOUNT_TYPE, syncAccountType);
             mGroupMembershipInserter.insert(mValuesLocal);
         } else {
             if (starredGroupInfo != null) {
                 // delete the groupmembership rows for this person that match the starred group id
-                String syncAccount = starredGroupInfo.getAsString(Groups._SYNC_ACCOUNT);
+                String syncAccountName = starredGroupInfo.getAsString(Groups._SYNC_ACCOUNT);
+                String syncAccountType = starredGroupInfo.getAsString(Groups._SYNC_ACCOUNT_TYPE);
                 String syncId = starredGroupInfo.getAsString(Groups._SYNC_ID);
                 if (!TextUtils.isEmpty(syncId)) {
                     mDb.delete(sGroupmembershipTable,
-                            "person=? AND group_sync_id=? AND group_sync_account=?",
-                            new String[]{String.valueOf(personId), syncId, syncAccount});
+                            "person=? AND group_sync_id=? AND group_sync_account=?"
+                                    + " AND group_sync_account_type=?",
+                            new String[]{String.valueOf(personId), syncId,
+                                    syncAccountName, syncAccountType});
                 } else {
                     mDb.delete(sGroupmembershipTable, "person=? AND group_id=?",
                             new String[]{
@@ -2346,11 +2312,14 @@
         Cursor cursor = db.query(sPeopleTable, null, where, whereArgs, null, null, null);
         try {
             final int idxSyncId = cursor.getColumnIndexOrThrow(People._SYNC_ID);
-            final int idxSyncAccount = cursor.getColumnIndexOrThrow(People._SYNC_ACCOUNT);
+            final int idxSyncAccountName = cursor.getColumnIndexOrThrow(People._SYNC_ACCOUNT);
+            final int idxSyncAccountType = cursor.getColumnIndexOrThrow(People._SYNC_ACCOUNT_TYPE);
             final int idxSyncVersion = cursor.getColumnIndexOrThrow(People._SYNC_VERSION);
             final int dstIdxSyncId = mDeletedPeopleInserter.getColumnIndex(SyncConstValue._SYNC_ID);
-            final int dstIdxSyncAccount =
+            final int dstIdxSyncAccountName =
                     mDeletedPeopleInserter.getColumnIndex(SyncConstValue._SYNC_ACCOUNT);
+            final int dstIdxSyncAccountType =
+                    mDeletedPeopleInserter.getColumnIndex(SyncConstValue._SYNC_ACCOUNT_TYPE);
             final int dstIdxSyncVersion =
                     mDeletedPeopleInserter.getColumnIndex(SyncConstValue._SYNC_VERSION);
             while (cursor.moveToNext()) {
@@ -2359,7 +2328,10 @@
                 // insert into deleted table
                 mDeletedPeopleInserter.prepareForInsert();
                 mDeletedPeopleInserter.bind(dstIdxSyncId, syncId);
-                mDeletedPeopleInserter.bind(dstIdxSyncAccount, cursor.getString(idxSyncAccount));
+                mDeletedPeopleInserter.bind(dstIdxSyncAccountName,
+                        cursor.getString(idxSyncAccountName));
+                mDeletedPeopleInserter.bind(dstIdxSyncAccountType,
+                        cursor.getString(idxSyncAccountType));
                 mDeletedPeopleInserter.bind(dstIdxSyncVersion, cursor.getString(idxSyncVersion));
                 mDeletedPeopleInserter.execute();
             }
@@ -2372,27 +2344,31 @@
     }
 
     private int deleteFromGroups(String where, String[] whereArgs) {
-        HashSet<String> modifiedAccounts = Sets.newHashSet();
+        HashSet<Account> modifiedAccounts = Sets.newHashSet();
         Cursor cursor = getDatabase().query(sGroupsTable, null, where, whereArgs,
                 null, null, null);
         try {
             final int indexName = cursor.getColumnIndexOrThrow(Groups.NAME);
             final int indexSyncAccount = cursor.getColumnIndexOrThrow(Groups._SYNC_ACCOUNT);
+            final int indexSyncAccountType =
+                    cursor.getColumnIndexOrThrow(Groups._SYNC_ACCOUNT_TYPE);
             final int indexSyncId = cursor.getColumnIndexOrThrow(Groups._SYNC_ID);
             final int indexId = cursor.getColumnIndexOrThrow(Groups._ID);
             final int indexShouldSync = cursor.getColumnIndexOrThrow(Groups.SHOULD_SYNC);
             while (cursor.moveToNext()) {
                 String oldName = cursor.getString(indexName);
-                String syncAccount = cursor.getString(indexSyncAccount);
+                String syncAccountName = cursor.getString(indexSyncAccount);
+                String syncAccountType = cursor.getString(indexSyncAccountType);
                 String syncId = cursor.getString(indexSyncId);
                 boolean shouldSync = cursor.getLong(indexShouldSync) != 0;
                 long id = cursor.getLong(indexId);
                 fixupPeopleStarredOnGroupRename(oldName, null, id);
-                if (!TextUtils.isEmpty(syncAccount) && !TextUtils.isEmpty(syncId)) {
-                    fixupPeopleStarredOnGroupRename(oldName, null, syncAccount, syncId);
+                if (!TextUtils.isEmpty(syncAccountName) && !TextUtils.isEmpty(syncId)) {
+                    fixupPeopleStarredOnGroupRename(oldName, null,
+                            new Account(syncAccountName, syncAccountType), syncId);
                 }
-                if (!TextUtils.isEmpty(syncAccount) && shouldSync) {
-                    modifiedAccounts.add(syncAccount);
+                if (!TextUtils.isEmpty(syncAccountName) && shouldSync) {
+                    modifiedAccounts.add(new Account(syncAccountName, syncAccountType));
                 }
             }
         } finally {
@@ -2403,7 +2379,7 @@
         if (numRows > 0) {
             if (!isTemporary()) {
                 final ContentResolver cr = getContext().getContentResolver();
-                for (String account : modifiedAccounts) {
+                for (Account account : modifiedAccounts) {
                     onLocalChangesForAccount(cr, account, true);
                 }
             }
@@ -2418,7 +2394,7 @@
      * @param resolver the content resolver to use
      * @param account the account the changes are tied to
      */
-    protected void onLocalChangesForAccount(final ContentResolver resolver, String account,
+    protected void onLocalChangesForAccount(final ContentResolver resolver, Account account,
             boolean groupsModified) {
         // Do nothing
     }
@@ -2603,7 +2579,9 @@
                         Cursor c = mDb.query(sPeopleTable, null,
                                 where, whereArgs, null, null, null);
                         try {
-                            int indexAccount = c.getColumnIndexOrThrow(People._SYNC_ACCOUNT);
+                            int indexAccountName = c.getColumnIndexOrThrow(People._SYNC_ACCOUNT);
+                            int indexAccountType =
+                                    c.getColumnIndexOrThrow(People._SYNC_ACCOUNT_TYPE);
                             int indexId = c.getColumnIndexOrThrow(People._ID);
                             Long starredValue = values.getAsLong(People.STARRED);
                             Long primaryPhone = values.getAsLong(People.PRIMARY_PHONE_ID);
@@ -2613,7 +2591,13 @@
                             while (c.moveToNext()) {
                                 final long personId = c.getLong(indexId);
                                 if (hasStarred) {
-                                    fixupGroupMembershipAfterPeopleUpdate(c.getString(indexAccount),
+                                    final String accountName = c.getString(indexAccountName);
+                                    final String accountType = c.getString(indexAccountType);
+                                    final Account account =
+                                            (accountName != null || accountType != null)
+                                                    ? new Account(accountName, accountType)
+                                                    : null;
+                                    fixupGroupMembershipAfterPeopleUpdate(account,
                                             personId, starredValue != null && starredValue != 0);
                                 }
 
@@ -2654,18 +2638,21 @@
 
     private int updateSettings(ContentValues values) {
         final SQLiteDatabase db = getDatabase();
-        final String account = values.getAsString(Contacts.Settings._SYNC_ACCOUNT);
+        final String accountName = values.getAsString(Contacts.Settings._SYNC_ACCOUNT);
+        final String accountType = values.getAsString(Contacts.Settings._SYNC_ACCOUNT_TYPE);
         final String key = values.getAsString(Contacts.Settings.KEY);
         if (key == null) {
             throw new IllegalArgumentException("you must specify the key when updating settings");
         }
+        Account account = null;
+        if (accountName != null || accountType != null) {
+            account = new Account(accountName, accountType);
+        }
         if (account == null) {
             db.delete(sSettingsTable, "_sync_account IS NULL AND key=?", new String[]{key});
         } else {
-            if (TextUtils.isEmpty(account)) {
-                throw new IllegalArgumentException("account cannot be the empty string, " + values);
-            }
-            db.delete(sSettingsTable, "_sync_account=? AND key=?", new String[]{account, key});
+            db.delete(sSettingsTable, "_sync_account=? AND _sync_account_type=? AND key=?",
+                    new String[]{account.mName, account.mType, key});
         }
         long rowId = db.insert(sSettingsTable, Contacts.Settings.KEY, values);
         if (rowId < 0) {
@@ -2684,7 +2671,7 @@
             }
         }
 
-        Set<String> modifiedAccounts = Sets.newHashSet();
+        Set<Account> modifiedAccounts = Sets.newHashSet();
         final SQLiteDatabase db = getDatabase();
         if (values.containsKey(Groups.NAME) || values.containsKey(Groups.SHOULD_SYNC)) {
             String newName = values.getAsString(Groups.NAME);
@@ -2692,21 +2679,25 @@
             try {
                 final int indexName = cursor.getColumnIndexOrThrow(Groups.NAME);
                 final int indexSyncAccount = cursor.getColumnIndexOrThrow(Groups._SYNC_ACCOUNT);
+                final int indexSyncAccountType =
+                        cursor.getColumnIndexOrThrow(Groups._SYNC_ACCOUNT_TYPE);
                 final int indexSyncId = cursor.getColumnIndexOrThrow(Groups._SYNC_ID);
                 final int indexId = cursor.getColumnIndexOrThrow(Groups._ID);
                 while (cursor.moveToNext()) {
-                    String syncAccount = cursor.getString(indexSyncAccount);
+                    String accountName = cursor.getString(indexSyncAccount);
+                    String accountType = cursor.getString(indexSyncAccountType);
                     if (values.containsKey(Groups.NAME)) {
                         String oldName = cursor.getString(indexName);
                         String syncId = cursor.getString(indexSyncId);
                         long id = cursor.getLong(indexId);
                         fixupPeopleStarredOnGroupRename(oldName, newName, id);
-                        if (!TextUtils.isEmpty(syncAccount) && !TextUtils.isEmpty(syncId)) {
-                            fixupPeopleStarredOnGroupRename(oldName, newName, syncAccount, syncId);
+                        if (!TextUtils.isEmpty(accountName) && !TextUtils.isEmpty(syncId)) {
+                            fixupPeopleStarredOnGroupRename(oldName, newName,
+                                    new Account(accountName, accountType), syncId);
                         }
                     }
-                    if (!TextUtils.isEmpty(syncAccount) && values.containsKey(Groups.SHOULD_SYNC)) {
-                        modifiedAccounts.add(syncAccount);
+                    if (!TextUtils.isEmpty(accountName) && values.containsKey(Groups.SHOULD_SYNC)) {
+                        modifiedAccounts.add(new Account(accountName, accountType));
                     }
                 }
             } finally {
@@ -2718,7 +2709,7 @@
         if (numRows > 0) {
             if (!isTemporary()) {
                 final ContentResolver cr = getContext().getContentResolver();
-                for (String account : modifiedAccounts) {
+                for (Account account : modifiedAccounts) {
                     onLocalChangesForAccount(cr, account, true);
                 }
             }
@@ -2747,9 +2738,10 @@
     }
 
     void fixupPeopleStarredOnGroupRename(String oldName, String newName,
-            String syncAccount, String syncId) {
-        fixupPeopleStarredOnGroupRename(oldName, newName, "_sync_account=? AND _sync_id=?",
-                new String[]{syncAccount, syncId});
+            Account syncAccount, String syncId) {
+        fixupPeopleStarredOnGroupRename(oldName, newName,
+                "_sync_account=? AND _sync_account_type=? AND _sync_id=?",
+                new String[]{syncAccount.mName, syncAccount.mType, syncId});
     }
 
     void fixupPeopleStarredOnGroupRename(String oldName, String newName, long groupId) {
@@ -3106,14 +3098,24 @@
 
             // Copy the person
             mPeopleInserter.prepareForInsert();
-            DatabaseUtils.cursorStringToInsertHelper(diffsCursor, People._SYNC_ID, mPeopleInserter, mIndexPeopleSyncId);
-            DatabaseUtils.cursorStringToInsertHelper(diffsCursor, People._SYNC_TIME, mPeopleInserter, mIndexPeopleSyncTime);
-            DatabaseUtils.cursorStringToInsertHelper(diffsCursor, People._SYNC_VERSION, mPeopleInserter, mIndexPeopleSyncVersion);
-            DatabaseUtils.cursorStringToInsertHelper(diffsCursor, People._SYNC_DIRTY, mPeopleInserter, mIndexPeopleSyncDirty);
-            DatabaseUtils.cursorStringToInsertHelper(diffsCursor, People._SYNC_ACCOUNT, mPeopleInserter, mIndexPeopleSyncAccount);
-            DatabaseUtils.cursorStringToInsertHelper(diffsCursor, People.NAME, mPeopleInserter, mIndexPeopleName);
-            DatabaseUtils.cursorStringToInsertHelper(diffsCursor, People.PHONETIC_NAME, mPeopleInserter, mIndexPeoplePhoneticName);
-            DatabaseUtils.cursorStringToInsertHelper(diffsCursor, People.NOTES, mPeopleInserter, mIndexPeopleNotes);
+            DatabaseUtils.cursorStringToInsertHelper(diffsCursor,
+                    People._SYNC_ID, mPeopleInserter, mIndexPeopleSyncId);
+            DatabaseUtils.cursorStringToInsertHelper(diffsCursor,
+                    People._SYNC_TIME, mPeopleInserter, mIndexPeopleSyncTime);
+            DatabaseUtils.cursorStringToInsertHelper(diffsCursor,
+                    People._SYNC_VERSION, mPeopleInserter, mIndexPeopleSyncVersion);
+            DatabaseUtils.cursorStringToInsertHelper(diffsCursor,
+                    People._SYNC_DIRTY, mPeopleInserter, mIndexPeopleSyncDirty);
+            DatabaseUtils.cursorStringToInsertHelper(diffsCursor,
+                    People._SYNC_ACCOUNT, mPeopleInserter, mIndexPeopleSyncAccountName);
+            DatabaseUtils.cursorStringToInsertHelper(diffsCursor,
+                    People._SYNC_ACCOUNT_TYPE, mPeopleInserter, mIndexPeopleSyncAccountType);
+            DatabaseUtils.cursorStringToInsertHelper(diffsCursor,
+                    People.NAME, mPeopleInserter, mIndexPeopleName);
+            DatabaseUtils.cursorStringToInsertHelper(diffsCursor,
+                    People.PHONETIC_NAME, mPeopleInserter, mIndexPeoplePhoneticName);
+            DatabaseUtils.cursorStringToInsertHelper(diffsCursor,
+                    People.NOTES, mPeopleInserter, mIndexPeopleNotes);
             long localPersonID = mPeopleInserter.execute();
 
             Cursor c;
@@ -3133,7 +3135,9 @@
                     DatabaseUtils.cursorStringToInsertHelper(c, Photos._SYNC_VERSION,
                             mPhotosInserter, mIndexPhotosSyncVersion);
                     DatabaseUtils.cursorStringToInsertHelper(c, Photos._SYNC_ACCOUNT,
-                            mPhotosInserter, mIndexPhotosSyncAccount);
+                            mPhotosInserter, mIndexPhotosSyncAccountName);
+                    DatabaseUtils.cursorStringToInsertHelper(c, Photos._SYNC_ACCOUNT_TYPE,
+                            mPhotosInserter, mIndexPhotosSyncAccountType);
                     DatabaseUtils.cursorStringToInsertHelper(c, Photos.EXISTS_ON_SERVER,
                             mPhotosInserter, mIndexPhotosExistsOnServer);
                     mPhotosInserter.bind(mIndexPhotosSyncError, (String)null);
@@ -3209,11 +3213,13 @@
                     final int isPrimaryValue = c.getInt(primaryIndex);
                     mContactMethodsInserter.prepareForInsert();
                     mContactMethodsInserter.bind(mIndexContactMethodsPersonId, localPersonID);
-                    mContactMethodsInserter.bind(mIndexContactMethodsLabel, c.getString(labelIndex));
+                    mContactMethodsInserter.bind(mIndexContactMethodsLabel,
+                            c.getString(labelIndex));
                     mContactMethodsInserter.bind(mIndexContactMethodsKind, kind);
                     mContactMethodsInserter.bind(mIndexContactMethodsType, type);
                     mContactMethodsInserter.bind(mIndexContactMethodsData, c.getString(dataIndex));
-                    mContactMethodsInserter.bind(mIndexContactMethodsAuxData, c.getString(auxDataIndex));
+                    mContactMethodsInserter.bind(mIndexContactMethodsAuxData,
+                            c.getString(auxDataIndex));
                     mContactMethodsInserter.bind(mIndexContactMethodsIsPrimary, isPrimaryValue);
                     long rowId = mContactMethodsInserter.execute();
                     if ((kind == Contacts.KIND_EMAIL) && (isPrimaryValue != 0)) {
@@ -3258,7 +3264,8 @@
                     mOrganizationsInserter.bind(mIndexOrganizationsPersonId, localPersonID);
                     mOrganizationsInserter.bind(mIndexOrganizationsLabel, c.getString(labelIndex));
                     mOrganizationsInserter.bind(mIndexOrganizationsType, type);
-                    mOrganizationsInserter.bind(mIndexOrganizationsCompany, c.getString(companyIndex));
+                    mOrganizationsInserter.bind(mIndexOrganizationsCompany,
+                            c.getString(companyIndex));
                     mOrganizationsInserter.bind(mIndexOrganizationsTitle, c.getString(titleIndex));
                     mOrganizationsInserter.bind(mIndexOrganizationsIsPrimary, isPrimaryValue);
                     long rowId = mOrganizationsInserter.execute();
@@ -3291,14 +3298,20 @@
             c = doSubQuery(diffsDb, sGroupmembershipTable, null, diffsPersonID,
                     sGroupmembershipTable + "._id");
             try {
-                final int accountIndex =
+                final int accountNameIndex =
                     c.getColumnIndexOrThrow(GroupMembership.GROUP_SYNC_ACCOUNT);
+                final int accountTypeIndex =
+                    c.getColumnIndexOrThrow(GroupMembership.GROUP_SYNC_ACCOUNT_TYPE);
                 final int idIndex = c.getColumnIndexOrThrow(GroupMembership.GROUP_SYNC_ID);
                 while(c.moveToNext()) {
                     mGroupMembershipInserter.prepareForInsert();
                     mGroupMembershipInserter.bind(mIndexGroupMembershipPersonId, localPersonID);
-                    mGroupMembershipInserter.bind(mIndexGroupMembershipGroupSyncAccount, c.getString(accountIndex));
-                    mGroupMembershipInserter.bind(mIndexGroupMembershipGroupSyncId, c.getString(idIndex));
+                    mGroupMembershipInserter.bind(mIndexGroupMembershipGroupSyncAccountName,
+                            c.getString(accountNameIndex));
+                    mGroupMembershipInserter.bind(mIndexGroupMembershipGroupSyncAccountType,
+                            c.getString(accountTypeIndex));
+                    mGroupMembershipInserter.bind(mIndexGroupMembershipGroupSyncId,
+                            c.getString(idIndex));
                     mGroupMembershipInserter.execute();
                 }
             } finally {
@@ -3306,7 +3319,8 @@
             }
 
             // Copy all extensions rows
-            c = doSubQuery(diffsDb, sExtensionsTable, null, diffsPersonID, sExtensionsTable + "._id");
+            c = doSubQuery(diffsDb, sExtensionsTable, null, diffsPersonID,
+                    sExtensionsTable + "._id");
             try {
                 final int nameIndex = c.getColumnIndexOrThrow(Extensions.NAME);
                 final int valueIndex = c.getColumnIndexOrThrow(Extensions.VALUE);
@@ -3595,6 +3609,8 @@
                             DatabaseUtils.cursorStringToContentValues(cRemote,
                                     GroupMembership.GROUP_SYNC_ACCOUNT, mValues);
                             DatabaseUtils.cursorStringToContentValues(cRemote,
+                                    GroupMembership.GROUP_SYNC_ACCOUNT_TYPE, mValues);
+                            DatabaseUtils.cursorStringToContentValues(cRemote,
                                     GroupMembership.GROUP_SYNC_ID, mValues);
                             if (joinResult == CursorJoiner.Result.RIGHT) {
                                 mValues.put(GroupMembership.PERSON_ID, localPersonID);
@@ -3660,7 +3676,10 @@
                 if(cRemote.moveToNext()) {
                     mValues.clear();
                     DatabaseUtils.cursorStringToContentValues(cRemote, Photos._SYNC_ID, mValues);
-                    DatabaseUtils.cursorStringToContentValues(cRemote, Photos._SYNC_ACCOUNT, mValues);
+                    DatabaseUtils.cursorStringToContentValues(cRemote,
+                            Photos._SYNC_ACCOUNT, mValues);
+                    DatabaseUtils.cursorStringToContentValues(cRemote,
+                            Photos._SYNC_ACCOUNT_TYPE, mValues);
                     db.update(sPhotosTable, mValues, Photos.PERSON_ID + '=' + localPersonID, null);
                 }
             } finally {
@@ -3687,6 +3706,8 @@
             DatabaseUtils.cursorStringToContentValues(diffsCursor, People._SYNC_TIME, mValues);
             DatabaseUtils.cursorStringToContentValues(diffsCursor, People._SYNC_VERSION, mValues);
             DatabaseUtils.cursorStringToContentValues(diffsCursor, People._SYNC_ACCOUNT, mValues);
+            DatabaseUtils.cursorStringToContentValues(diffsCursor,
+                    People._SYNC_ACCOUNT_TYPE, mValues);
             DatabaseUtils.cursorStringToContentValues(diffsCursor, People.NAME, mValues);
             DatabaseUtils.cursorStringToContentValues(diffsCursor, People.PHONETIC_NAME, mValues);
             DatabaseUtils.cursorStringToContentValues(diffsCursor, People.NOTES, mValues);
@@ -3794,6 +3815,7 @@
             DatabaseUtils.cursorStringToContentValues(cursor, Groups._SYNC_TIME, mValues);
             DatabaseUtils.cursorStringToContentValues(cursor, Groups._SYNC_VERSION, mValues);
             DatabaseUtils.cursorStringToContentValues(cursor, Groups._SYNC_ACCOUNT, mValues);
+            DatabaseUtils.cursorStringToContentValues(cursor, Groups._SYNC_ACCOUNT_TYPE, mValues);
             DatabaseUtils.cursorStringToContentValues(cursor, Groups.NAME, mValues);
             DatabaseUtils.cursorStringToContentValues(cursor, Groups.NOTES, mValues);
             DatabaseUtils.cursorStringToContentValues(cursor, Groups.SYSTEM_ID, mValues);
@@ -3816,16 +3838,21 @@
                 // We may have just synced the metadata for a groups we previously marked for
                 // syncing.
                 final ContentResolver cr = getContext().getContentResolver();
-                final String account = mValues.getAsString(Groups._SYNC_ACCOUNT);
-                onLocalChangesForAccount(cr, account, false);
+                final String accountName = mValues.getAsString(Groups._SYNC_ACCOUNT);
+                final String accountType = mValues.getAsString(Groups._SYNC_ACCOUNT_TYPE);
+                onLocalChangesForAccount(cr, new Account(accountName, accountType), false);
             }
 
             String oldName = null;
             String newName = cursor.getString(cursor.getColumnIndexOrThrow(Groups.NAME));
-            String account = cursor.getString(cursor.getColumnIndexOrThrow(Groups._SYNC_ACCOUNT));
+            String accountName = cursor.getString(
+                    cursor.getColumnIndexOrThrow(Groups._SYNC_ACCOUNT));
+            String accountType = cursor.getString(
+                    cursor.getColumnIndexOrThrow(Groups._SYNC_ACCOUNT_TYPE));
             String syncId = cursor.getString(cursor.getColumnIndexOrThrow(Groups._SYNC_ID));
             // this must come after the insert, otherwise the join won't work
-            fixupPeopleStarredOnGroupRename(oldName, newName, account, syncId);
+            fixupPeopleStarredOnGroupRename(oldName, newName, new Account(accountName, accountType),
+                    syncId);
         }
 
         @Override
@@ -3846,16 +3873,21 @@
             String oldName = DatabaseUtils.stringForQuery(db,
                     "select name from groups where _id=" + localRowId, null);
             String newName = cursor.getString(cursor.getColumnIndexOrThrow(Groups.NAME));
-            String account = cursor.getString(cursor.getColumnIndexOrThrow(Groups._SYNC_ACCOUNT));
+            String accountName = cursor.getString(
+                    cursor.getColumnIndexOrThrow(Groups._SYNC_ACCOUNT));
+            String accountType = cursor.getString(
+                    cursor.getColumnIndexOrThrow(Groups._SYNC_ACCOUNT_TYPE));
             String syncId = cursor.getString(cursor.getColumnIndexOrThrow(Groups._SYNC_ID));
             // this can come before or after the delete
-            fixupPeopleStarredOnGroupRename(oldName, newName, account, syncId);
+            fixupPeopleStarredOnGroupRename(oldName, newName,
+                    new Account(accountName, accountType), syncId);
 
             mValues.clear();
             DatabaseUtils.cursorStringToContentValues(cursor, Groups._SYNC_ID, mValues);
             DatabaseUtils.cursorStringToContentValues(cursor, Groups._SYNC_TIME, mValues);
             DatabaseUtils.cursorStringToContentValues(cursor, Groups._SYNC_VERSION, mValues);
             DatabaseUtils.cursorStringToContentValues(cursor, Groups._SYNC_ACCOUNT, mValues);
+            DatabaseUtils.cursorStringToContentValues(cursor, Groups._SYNC_ACCOUNT_TYPE, mValues);
             DatabaseUtils.cursorStringToContentValues(cursor, Groups.NAME, mValues);
             DatabaseUtils.cursorStringToContentValues(cursor, Groups.NOTES, mValues);
             DatabaseUtils.cursorStringToContentValues(cursor, Groups.SYSTEM_ID, mValues);
@@ -3874,7 +3906,9 @@
                 c.moveToNext();
                 String oldName = c.getString(c.getColumnIndexOrThrow(Groups.NAME));
                 String newName = null;
-                String account = c.getString(c.getColumnIndexOrThrow(Groups._SYNC_ACCOUNT));
+                String accountName = c.getString(c.getColumnIndexOrThrow(Groups._SYNC_ACCOUNT));
+                String accountType = c.getString(
+                        c.getColumnIndexOrThrow(Groups._SYNC_ACCOUNT_TYPE));
                 String syncId = c.getString(c.getColumnIndexOrThrow(Groups._SYNC_ID));
                 String systemId = c.getString(c.getColumnIndexOrThrow(Groups.SYSTEM_ID));
                 if (!TextUtils.isEmpty(systemId)) {
@@ -3887,7 +3921,8 @@
                 }
 
                 // this must come before the delete, since the join won't work once this row is gone
-                fixupPeopleStarredOnGroupRename(oldName, newName, account, syncId);
+                fixupPeopleStarredOnGroupRename(oldName, newName,
+                        new Account(accountName, accountType), syncId);
             } finally {
                 c.close();
             }
@@ -4096,6 +4131,7 @@
     private static final HashMap<String, String> sPresenceProjectionMap;
     private static final HashMap<String, String> sEmailSearchProjectionMap;
     private static final HashMap<String, String> sOrganizationsProjectionMap;
+    private static final HashMap<String, String> sSearchSuggestionsProjectionMap;
     private static final HashMap<String, String> sGroupMembershipProjectionMap;
     private static final HashMap<String, String> sPhotosProjectionMap;
     private static final HashMap<String, String> sExtensionsProjectionMap;
@@ -4132,7 +4168,7 @@
             + "CASE WHEN (phonetic_name IS NOT NULL AND phonetic_name != '') "
                 + "THEN phonetic_name "
             + "ELSE "
-                + "(CASE WHEN (name is NOT NULL AND name != '') "
+                + "(CASE WHEN (name is NOT NULL AND name != '')"
                     + "THEN name "
                 + "ELSE "
                     + "(CASE WHEN primary_email IS NOT NULL THEN "
@@ -4149,9 +4185,6 @@
             + "END"
         + ")";
     
-    private static final String NAME_WHEN_SQL
-            = " WHEN name is NOT NULL ANd name != '' THEN name";
-    
     private static final String PRIMARY_ORGANIZATION_WHEN_SQL
             = " WHEN primary_organization is NOT NULL THEN "
             + "(SELECT company FROM organizations WHERE organizations._id = primary_organization)";
@@ -4205,92 +4238,6 @@
             + " THEN " + Presence.getPresenceIconResourceId(status);
     }
 
-
-    // This is similar to DISPLAY_NAME_SQL. Only difference is that this prioritize
-    // phonetic_name.
-    private static final String PHONETIC_LOOKUP_STRING_SQL = 
-        "GET_NORMALIZED_STRING("
-            + "CASE WHEN (phonetic_name IS NOT NULL AND phonetic_name != '') " 
-                + "THEN phonetic_name "
-            + "ELSE "
-                + "(CASE WHEN (name is NOT NULL AND name != '') "
-                    + "THEN name "
-                + "ELSE "
-                    + "(CASE WHEN primary_organization is NOT NULL THEN "
-                        + "(SELECT company FROM organizations WHERE "
-                            + "organizations._id = primary_organization) "
-                    + "ELSE "
-                        + "(CASE WHEN primary_phone IS NOT NULL THEN "
-                            +"(SELECT number FROM phones WHERE phones._id = primary_phone) "
-                        + "ELSE "
-                            + "(CASE WHEN primary_email IS NOT NULL THEN "
-                                + "(SELECT data FROM contact_methods WHERE "
-                                    + "contact_methods._id = primary_email) "
-                            + "ELSE "
-                                + "null "
-                            + "END) "
-                        + "END) "
-                    + "END) "
-                + "END) "
-            + "END)";
-
-    private static final String PHONETIC_SUGGEST_DESCRIPTION_SQL =
-        "(CASE"
-            + " WHEN (phonetic_name IS NOT NULL AND phonetic_name != '') THEN "
-            // PHONETIC_LOOKUP_STRING_SQL returns phonetic_name. try name, org, phone, email
-                + "(CASE"
-                    + NAME_WHEN_SQL
-                    + PRIMARY_ORGANIZATION_WHEN_SQL
-                    + PRIMARY_PHONE_WHEN_SQL
-                    + PRIMARY_EMAIL_WHEN_SQL
-                    + " ELSE null END)"
-            // PHONETIC_LOOKUP_STRING_SQL returns name, try org, phone, email
-            + " WHEN (name IS NOT NULL AND name != '') THEN "
-                + "(CASE"
-                    + PRIMARY_ORGANIZATION_WHEN_SQL
-                    + PRIMARY_PHONE_WHEN_SQL
-                    + PRIMARY_EMAIL_WHEN_SQL
-                    + " ELSE null END)"
-            // PHONETIC_LOOKUP_STRING_SQL returns org, try phone, email
-            + " WHEN primary_organization is NOT NULL THEN "
-                + "(CASE"
-                    + PRIMARY_PHONE_WHEN_SQL
-                    + PRIMARY_EMAIL_WHEN_SQL
-                    + " ELSE null END)"
-            // PHONETIC_LOOKUP_STRING_SQL returns phone, try email
-            + " WHEN primary_phone IS NOT NULL THEN "
-                + "(CASE"
-                    + PRIMARY_EMAIL_WHEN_SQL
-                    + " ELSE null END)"
-            // PHONETIC_LOOKUP_STRING_SQL returns email or NULL, return NULL
-        + " ELSE null END)";
-    
-    // "primary_organization" etc. are not considered here, since peopleLookup does not
-    // consider them either.
-    private static final String PHONETIC_LOOKUP_SQL_SIMPLE =
-        "GET_NORMALIZED_STRING("
-            + "CASE WHEN (phonetic_name IS NOT NULL AND phonetic_name != '') "
-                + "THEN phonetic_name "
-            + "ELSE "
-                + "(CASE WHEN (name is NOT NULL AND name != '') "
-                    + "THEN name "
-                + "ELSE "
-                    + "'' "
-                + "END) "
-            + "END)";
-    
-    private static final String PHONETIC_LOOKUP_SQL_SIMPLE_WITH_NEW =
-        "GET_NORMALIZED_STRING("
-            + "CASE WHEN (new.phonetic_name IS NOT NULL AND new.phonetic_name != '') "
-                + "THEN new.phonetic_name "
-            + "ELSE "
-                + "(CASE WHEN (new.name is NOT NULL AND new.name != '') "
-                    + "THEN new.name "
-                + "ELSE "
-                    + "'' "
-                + "END) "
-            + "END)";
-    
     private static final String[] sPhonesKeyColumns;
     private static final String[] sContactMethodsKeyColumns;
     private static final String[] sOrganizationsKeyColumns;
@@ -4312,28 +4259,6 @@
         return (sb == null) ? "" : sb.toString();
     }
 
-    /**
-     * @return true when phonetic_name should be considered when looking up people's names.
-     */
-    private synchronized boolean usePhoneticNameForPeopleLookup() {
-        return mSearchSuggestionLanguage.equals(Locale.JAPAN.getLanguage());
-    }
-    
-    private void updateSuggestColumnTexts() {
-        if (usePhoneticNameForPeopleLookup()) {
-            mSearchSuggestionsProjectionMap.put(SearchManager.SUGGEST_COLUMN_TEXT_1,
-                    PHONETIC_LOOKUP_STRING_SQL + " AS " + SearchManager.SUGGEST_COLUMN_TEXT_1);
-            mSearchSuggestionsProjectionMap.put(SearchManager.SUGGEST_COLUMN_TEXT_2,
-                    PHONETIC_SUGGEST_DESCRIPTION_SQL + " AS " + 
-                    SearchManager.SUGGEST_COLUMN_TEXT_2);
-        } else {
-            mSearchSuggestionsProjectionMap.put(SearchManager.SUGGEST_COLUMN_TEXT_1,
-                    DISPLAY_NAME_SQL + " AS " + SearchManager.SUGGEST_COLUMN_TEXT_1);
-            mSearchSuggestionsProjectionMap.put(SearchManager.SUGGEST_COLUMN_TEXT_2,
-                    SUGGEST_DESCRIPTION_SQL + " AS " + SearchManager.SUGGEST_COLUMN_TEXT_2);
-        }
-    }
-    
     static {
         // Contacts URI matching table
         UriMatcher matcher = sURIMatcher;
@@ -4463,6 +4388,7 @@
         syncColumns.put(SyncConstValue._SYNC_LOCAL_ID, SyncConstValue._SYNC_LOCAL_ID);
         syncColumns.put(SyncConstValue._SYNC_DIRTY, SyncConstValue._SYNC_DIRTY);
         syncColumns.put(SyncConstValue._SYNC_ACCOUNT, SyncConstValue._SYNC_ACCOUNT);
+        syncColumns.put(SyncConstValue._SYNC_ACCOUNT_TYPE, SyncConstValue._SYNC_ACCOUNT_TYPE);
 
         // Phones columns
         HashMap<String, String> phonesColumns = new HashMap<String, String>();
@@ -4491,8 +4417,10 @@
         // People with E-mail or IM projection map
         map = new HashMap<String, String>();
         map.put(People._ID, "people._id AS " + People._ID);
-        map.put(ContactMethods.DATA, "contact_methods." + ContactMethods.DATA + " AS " + ContactMethods.DATA);
-        map.put(ContactMethods.KIND, "contact_methods." + ContactMethods.KIND + " AS " + ContactMethods.KIND);
+        map.put(ContactMethods.DATA,
+                "contact_methods." + ContactMethods.DATA + " AS " + ContactMethods.DATA);
+        map.put(ContactMethods.KIND,
+                "contact_methods." + ContactMethods.KIND + " AS " + ContactMethods.KIND);
         map.putAll(peopleColumns);
         sPeopleWithEmailOrImProjectionMap = map;
         
@@ -4509,6 +4437,7 @@
         map.put(GroupMembership.PERSON_ID, GroupMembership.PERSON_ID);
         map.put(GroupMembership.GROUP_ID, "groups._id AS " + GroupMembership.GROUP_ID);
         map.put(GroupMembership.GROUP_SYNC_ACCOUNT, GroupMembership.GROUP_SYNC_ACCOUNT);
+        map.put(GroupMembership.GROUP_SYNC_ACCOUNT_TYPE, GroupMembership.GROUP_SYNC_ACCOUNT_TYPE);
         map.put(GroupMembership.GROUP_SYNC_ID, GroupMembership.GROUP_SYNC_ID);
         map.putAll(groupsColumns);
         sGroupMembershipProjectionMap = map;
@@ -4597,6 +4526,27 @@
         map.putAll(peopleColumns);
         sPresenceProjectionMap = map;
 
+        // Search suggestions projection map
+        map = new HashMap<String, String>();
+        map.put(SearchManager.SUGGEST_COLUMN_TEXT_1,
+                DISPLAY_NAME_SQL + " AS " + SearchManager.SUGGEST_COLUMN_TEXT_1);
+        map.put(SearchManager.SUGGEST_COLUMN_TEXT_2,
+                SUGGEST_DESCRIPTION_SQL + " AS " + SearchManager.SUGGEST_COLUMN_TEXT_2);
+        map.put(SearchManager.SUGGEST_COLUMN_ICON_1,
+                "(CASE WHEN " + Photos.DATA + " IS NOT NULL"
+                + " THEN '" + People.CONTENT_URI + "/' || people._id ||"
+                        + " '/" + Photos.CONTENT_DIRECTORY + "/data'"
+                + " ELSE " + com.android.internal.R.drawable.ic_contact_picture
+                + " END) AS " + SearchManager.SUGGEST_COLUMN_ICON_1);
+        map.put(SearchManager.SUGGEST_COLUMN_ICON_2,
+                PRESENCE_ICON_SQL + " AS " + SearchManager.SUGGEST_COLUMN_ICON_2);
+        map.put(SearchManager.SUGGEST_COLUMN_INTENT_DATA_ID,
+                "people._id AS " + SearchManager.SUGGEST_COLUMN_INTENT_DATA_ID);
+        map.put(SearchManager.SUGGEST_COLUMN_SHORTCUT_ID,
+                "people._id AS " + SearchManager.SUGGEST_COLUMN_SHORTCUT_ID);
+        map.put(People._ID, "people._id AS " + People._ID);
+        sSearchSuggestionsProjectionMap = map;
+
         // Photos projection map
         map = new HashMap<String, String>();
         map.put(Photos._ID, Photos._ID);
@@ -4628,18 +4578,22 @@
                 ContactMethods.DATA, ContactMethods.KIND);
         sOrganizationsKeyOrderBy = buildOrderBy(sOrganizationsTable, Organizations.COMPANY);
         sGroupmembershipKeyOrderBy =
-                buildOrderBy(sGroupmembershipTable, GroupMembership.GROUP_SYNC_ACCOUNT);
+                buildOrderBy(sGroupmembershipTable, GroupMembership.GROUP_SYNC_ACCOUNT_TYPE,
+                        GroupMembership.GROUP_SYNC_ACCOUNT);
 
         sPhonesKeyColumns = new String[]{Phones.NUMBER};
         sContactMethodsKeyColumns = new String[]{ContactMethods.DATA, ContactMethods.KIND};
         sOrganizationsKeyColumns = new String[]{Organizations.COMPANY};
-        sGroupmembershipKeyColumns = new String[]{GroupMembership.GROUP_SYNC_ACCOUNT};
+        sGroupmembershipKeyColumns = new String[]{GroupMembership.GROUP_SYNC_ACCOUNT,
+                GroupMembership.GROUP_SYNC_ACCOUNT_TYPE};
         sExtensionsKeyColumns = new String[]{Extensions.NAME};
 
         String groupJoinByLocalId = "groups._id=groupmembership.group_id";
         String groupJoinByServerId = "("
                 + "groups._sync_account=groupmembership.group_sync_account"
                 + " AND "
+                + "groups._sync_account_type=groupmembership.group_sync_account_type"
+                + " AND "
                 + "groups._sync_id=groupmembership.group_sync_id"
                 + ")";
         sGroupsJoinString = "(" + groupJoinByLocalId + " OR " + groupJoinByServerId + ")";
diff --git a/src/com/android/providers/contacts/ContactsProvider2.java b/src/com/android/providers/contacts/ContactsProvider2.java
new file mode 100644
index 0000000..d8af3da
--- /dev/null
+++ b/src/com/android/providers/contacts/ContactsProvider2.java
@@ -0,0 +1,2905 @@
+/*
+ * 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.internal.content.SyncStateContentProviderHelper;
+import com.android.providers.contacts.OpenHelper.AggregationExceptionColumns;
+import com.android.providers.contacts.OpenHelper.Clauses;
+import com.android.providers.contacts.OpenHelper.ContactsColumns;
+import com.android.providers.contacts.OpenHelper.DataColumns;
+import com.android.providers.contacts.OpenHelper.GroupsColumns;
+import com.android.providers.contacts.OpenHelper.MimetypesColumns;
+import com.android.providers.contacts.OpenHelper.PackagesColumns;
+import com.android.providers.contacts.OpenHelper.PhoneColumns;
+import com.android.providers.contacts.OpenHelper.PhoneLookupColumns;
+import com.android.providers.contacts.OpenHelper.RawContactsColumns;
+import com.android.providers.contacts.OpenHelper.Tables;
+import com.google.android.collect.Lists;
+
+import android.accounts.Account;
+import android.app.SearchManager;
+import android.content.ContentProvider;
+import android.content.ContentProviderOperation;
+import android.content.ContentProviderResult;
+import android.content.ContentUris;
+import android.content.ContentValues;
+import android.content.Context;
+import android.content.Entity;
+import android.content.EntityIterator;
+import android.content.OperationApplicationException;
+import android.content.UriMatcher;
+import android.content.pm.PackageManager;
+import android.database.Cursor;
+import android.database.DatabaseUtils;
+import android.database.sqlite.SQLiteCursor;
+import android.database.sqlite.SQLiteDatabase;
+import android.database.sqlite.SQLiteQueryBuilder;
+import android.database.sqlite.SQLiteStatement;
+import android.net.Uri;
+import android.os.Binder;
+import android.os.RemoteException;
+import android.provider.BaseColumns;
+import android.provider.ContactsContract;
+import android.provider.ContactsContract.AggregationExceptions;
+import android.provider.ContactsContract.CommonDataKinds;
+import android.provider.ContactsContract.Contacts;
+import android.provider.ContactsContract.Data;
+import android.provider.ContactsContract.Groups;
+import android.provider.ContactsContract.Presence;
+import android.provider.ContactsContract.RawContacts;
+import android.provider.ContactsContract.CommonDataKinds.BaseTypes;
+import android.provider.ContactsContract.CommonDataKinds.Email;
+import android.provider.ContactsContract.CommonDataKinds.GroupMembership;
+import android.provider.ContactsContract.CommonDataKinds.Im;
+import android.provider.ContactsContract.CommonDataKinds.Nickname;
+import android.provider.ContactsContract.CommonDataKinds.Organization;
+import android.provider.ContactsContract.CommonDataKinds.Phone;
+import android.provider.ContactsContract.CommonDataKinds.StructuredName;
+import android.provider.ContactsContract.CommonDataKinds.StructuredPostal;
+import android.provider.ContactsContract.Contacts.AggregationSuggestions;
+import android.telephony.PhoneNumberUtils;
+import android.text.TextUtils;
+import android.util.Log;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+
+/**
+ * Contacts content provider. The contract between this provider and applications
+ * is defined in {@link ContactsContract}.
+ */
+public class ContactsProvider2 extends ContentProvider {
+    // TODO: clean up debug tag and rename this class
+    private static final String TAG = "ContactsProvider ~~~~";
+
+    // TODO: carefully prevent all incoming nested queries; they can be gaping security holes
+    // TODO: check for restricted flag during insert(), update(), and delete() calls
+
+    /** Default for the maximum number of returned aggregation suggestions. */
+    private static final int DEFAULT_MAX_SUGGESTIONS = 5;
+
+    private static final UriMatcher sUriMatcher = new UriMatcher(UriMatcher.NO_MATCH);
+
+    private static final String STREQUENT_ORDER_BY = Contacts.STARRED + " DESC, "
+            + Contacts.TIMES_CONTACTED + " DESC, "
+            + Contacts.DISPLAY_NAME + " ASC";
+    private static final String STREQUENT_LIMIT =
+            "(SELECT COUNT(1) FROM " + Tables.CONTACTS + " WHERE "
+            + Contacts.STARRED + "=1) + 25";
+
+    private static final int CONTACTS = 1000;
+    private static final int CONTACTS_ID = 1001;
+    private static final int CONTACTS_DATA = 1002;
+    private static final int CONTACTS_SUMMARY = 1003;
+    private static final int CONTACTS_RAW_CONTACTS = 1004;
+    private static final int CONTACTS_SUMMARY_ID = 1005;
+    private static final int CONTACTS_SUMMARY_FILTER = 1006;
+    private static final int CONTACTS_SUMMARY_STREQUENT = 1007;
+    private static final int CONTACTS_SUMMARY_STREQUENT_FILTER = 1008;
+    private static final int CONTACTS_SUMMARY_GROUP = 1009;
+
+    private static final int RAW_CONTACTS = 2002;
+    private static final int RAW_CONTACTS_ID = 2003;
+    private static final int RAW_CONTACTS_DATA = 2004;
+    private static final int CONTACTS_FILTER_EMAIL = 2005;
+
+    private static final int DATA = 3000;
+    private static final int DATA_ID = 3001;
+    private static final int PHONES = 3002;
+    private static final int PHONES_FILTER = 3003;
+    private static final int POSTALS = 3004;
+
+    private static final int PHONE_LOOKUP = 4000;
+
+    private static final int AGGREGATION_EXCEPTIONS = 6000;
+    private static final int AGGREGATION_EXCEPTION_ID = 6001;
+
+    private static final int PRESENCE = 7000;
+    private static final int PRESENCE_ID = 7001;
+
+    private static final int AGGREGATION_SUGGESTIONS = 8000;
+
+    private static final int GROUPS = 10000;
+    private static final int GROUPS_ID = 10001;
+    private static final int GROUPS_SUMMARY = 10003;
+
+    private static final int SYNCSTATE = 11000;
+
+    private static final int SEARCH_SUGGESTIONS = 12001;
+    private static final int SEARCH_SHORTCUT = 12002;
+
+    private interface ContactsQuery {
+        public static final String TABLE = Tables.RAW_CONTACTS;
+
+        public static final String[] PROJECTION = new String[] {
+            RawContactsColumns.CONCRETE_ID,
+            RawContacts.ACCOUNT_NAME,
+            RawContacts.ACCOUNT_TYPE,
+        };
+
+        public static final int RAW_CONTACT_ID = 0;
+        public static final int ACCOUNT_NAME = 1;
+        public static final int ACCOUNT_TYPE = 2;
+    }
+
+    private interface DataRawContactsQuery {
+        public static final String TABLE = Tables.DATA_JOIN_MIMETYPE_RAW_CONTACTS;
+
+        public static final String[] PROJECTION = new String[] {
+            RawContactsColumns.CONCRETE_ID,
+            DataColumns.CONCRETE_ID,
+            RawContacts.CONTACT_ID,
+            RawContacts.IS_RESTRICTED,
+            Data.MIMETYPE,
+        };
+
+        public static final int RAW_CONTACT_ID = 0;
+        public static final int DATA_ID = 1;
+        public static final int CONTACT_ID = 2;
+        public static final int IS_RESTRICTED = 3;
+        public static final int MIMETYPE = 4;
+    }
+
+    private interface DataContactsQuery {
+        public static final String TABLE = Tables.DATA_JOIN_MIMETYPES_RAW_CONTACTS_CONTACTS;
+
+        public static final String[] PROJECTION = new String[] {
+            RawContactsColumns.CONCRETE_ID,
+            DataColumns.CONCRETE_ID,
+            ContactsColumns.CONCRETE_ID,
+            MimetypesColumns.CONCRETE_ID,
+            Phone.NUMBER,
+            Email.DATA,
+            ContactsColumns.OPTIMAL_PRIMARY_PHONE_ID,
+            ContactsColumns.FALLBACK_PRIMARY_PHONE_ID,
+            ContactsColumns.OPTIMAL_PRIMARY_EMAIL_ID,
+            ContactsColumns.FALLBACK_PRIMARY_EMAIL_ID,
+        };
+
+        public static final int RAW_CONTACT_ID = 0;
+        public static final int DATA_ID = 1;
+        public static final int CONTACT_ID = 2;
+        public static final int MIMETYPE_ID = 3;
+        public static final int PHONE_NUMBER = 4;
+        public static final int EMAIL_DATA = 5;
+        public static final int OPTIMAL_PHONE_ID = 6;
+        public static final int FALLBACK_PHONE_ID = 7;
+        public static final int OPTIMAL_EMAIL_ID = 8;
+        public static final int FALLBACK_EMAIL_ID = 9;
+
+    }
+
+    private interface DisplayNameQuery {
+        public static final String TABLE = Tables.DATA_JOIN_MIMETYPES;
+
+        public static final String[] COLUMNS = new String[] {
+            MimetypesColumns.MIMETYPE,
+            Data.IS_PRIMARY,
+            Data.DATA2,
+            StructuredName.DISPLAY_NAME,
+        };
+
+        public static final int MIMETYPE = 0;
+        public static final int IS_PRIMARY = 1;
+        public static final int DATA2 = 2;
+        public static final int DISPLAY_NAME = 3;
+    }
+
+    private interface DataQuery {
+        public static final String TABLE = Tables.DATA_JOIN_MIMETYPES;
+
+        public static final String[] COLUMNS = new String[] {
+            DataColumns.CONCRETE_ID,
+            MimetypesColumns.MIMETYPE,
+            Data.RAW_CONTACT_ID,
+            Data.IS_PRIMARY,
+            Data.DATA1,
+            Data.DATA2,
+            Data.DATA3,
+            Data.DATA4,
+            Data.DATA5,
+            Data.DATA6,
+            Data.DATA7,
+            Data.DATA8,
+            Data.DATA9,
+            Data.DATA10,
+            Data.DATA11,
+            Data.DATA12,
+            Data.DATA13,
+            Data.DATA14,
+            Data.DATA15,
+        };
+
+        public static final int ID = 0;
+        public static final int MIMETYPE = 1;
+        public static final int RAW_CONTACT_ID = 2;
+        public static final int IS_PRIMARY = 3;
+        public static final int DATA1 = 4;
+        public static final int DATA2 = 5;
+        public static final int DATA3 = 6;
+        public static final int DATA4 = 7;
+        public static final int DATA5 = 8;
+        public static final int DATA6 = 9;
+        public static final int DATA7 = 10;
+        public static final int DATA8 = 11;
+        public static final int DATA9 = 12;
+        public static final int DATA10 = 13;
+        public static final int DATA11 = 14;
+        public static final int DATA12 = 15;
+        public static final int DATA13 = 16;
+        public static final int DATA14 = 17;
+        public static final int DATA15 = 18;
+    }
+
+    private interface DataIdQuery {
+        String[] COLUMNS = { Data._ID };
+
+        int _ID = 0;
+    }
+
+    // Higher number represents higher priority in choosing what data to use for the display name
+    private static final int DISPLAY_NAME_PRIORITY_EMAIL = 1;
+    private static final int DISPLAY_NAME_PRIORITY_PHONE = 2;
+    private static final int DISPLAY_NAME_PRIORITY_ORGANIZATION = 3;
+    private static final int DISPLAY_NAME_PRIORITY_STRUCTURED_NAME = 4;
+
+    private static final HashMap<String, Integer> sDisplayNamePriorities;
+    static {
+        sDisplayNamePriorities = new HashMap<String, Integer>();
+        sDisplayNamePriorities.put(StructuredName.CONTENT_ITEM_TYPE,
+                DISPLAY_NAME_PRIORITY_STRUCTURED_NAME);
+        sDisplayNamePriorities.put(Organization.CONTENT_ITEM_TYPE,
+                DISPLAY_NAME_PRIORITY_ORGANIZATION);
+        sDisplayNamePriorities.put(Phone.CONTENT_ITEM_TYPE,
+                DISPLAY_NAME_PRIORITY_PHONE);
+        sDisplayNamePriorities.put(Email.CONTENT_ITEM_TYPE,
+                DISPLAY_NAME_PRIORITY_EMAIL);
+    }
+
+    /** Contains just the contacts columns */
+    private static final HashMap<String, String> sContactsProjectionMap;
+    /** Contains the contact columns along with primary phone */
+    private static final HashMap<String, String> sContactsSummaryProjectionMap;
+    /** Contains the data, contacts, and contact columns, for joined tables. */
+    private static final HashMap<String, String> sDataRawContactsContactProjectionMap;
+    /** Contains the data, contacts, group sourceid and contact columns, for joined tables. */
+    private static final HashMap<String, String> sDataRawContactsGroupsContactProjectionMap;
+    /** Contains the contacts, and raw contact columns, for joined tables. */
+    private static final HashMap<String, String> sRawContactsContactsProjectionMap;
+    /** Contains just the contacts columns */
+    private static final HashMap<String, String> sRawContactsProjectionMap;
+    /** Contains just the data columns */
+    private static final HashMap<String, String> sDataGroupsProjectionMap;
+    /** Contains the data and contacts columns, for joined tables */
+    private static final HashMap<String, String> sDataRawContactsGroupsProjectionMap;
+    /** Contains the data and contacts columns, for joined tables */
+    private static final HashMap<String, String> sDataRawContactsProjectionMap;
+    /** Contains the just the {@link Groups} columns */
+    private static final HashMap<String, String> sGroupsProjectionMap;
+    /** Contains {@link Groups} columns along with summary details */
+    private static final HashMap<String, String> sGroupsSummaryProjectionMap;
+    /** Contains the agg_exceptions columns */
+    private static final HashMap<String, String> sAggregationExceptionsProjectionMap;
+    /** Contains Presence columns */
+    private static final HashMap<String, String> sPresenceProjectionMap;
+
+    /** Sql select statement that returns the contact id associated with a data record. */
+    private static final String sNestedRawContactIdSelect;
+    /** Sql select statement that returns the mimetype id associated with a data record. */
+    private static final String sNestedMimetypeSelect;
+    /** Sql select statement that returns the contact id associated with a contact record. */
+    private static final String sNestedContactIdSelect;
+    /** Sql select statement that returns a list of contact ids associated with an contact record. */
+    private static final String sNestedContactIdListSelect;
+    /** Sql where statement used to match all the data records that need to be updated when a new
+     * "primary" is selected.*/
+    private static final String sSetPrimaryWhere;
+    /** Sql where statement used to match all the data records that need to be updated when a new
+     * "super primary" is selected.*/
+    private static final String sSetSuperPrimaryWhere;
+    /** Sql where statement for filtering on groups. */
+    private static final String sContactsInGroupSelect;
+    /** Precompiled sql statement for setting a data record to the primary. */
+    private SQLiteStatement mSetPrimaryStatement;
+    /** Precompiled sql statement for setting a data record to the super primary. */
+    private SQLiteStatement mSetSuperPrimaryStatement;
+    /** Precompiled sql statement for incrementing times contacted for an contact */
+    private SQLiteStatement mLastTimeContactedUpdate;
+    /** Precompiled sql statement for updating a contact display name */
+    private SQLiteStatement mContactDisplayNameUpdate;
+
+    static {
+        // Contacts URI matching table
+        final UriMatcher matcher = sUriMatcher;
+        matcher.addURI(ContactsContract.AUTHORITY, "contacts", CONTACTS);
+        matcher.addURI(ContactsContract.AUTHORITY, "contacts/#", CONTACTS_ID);
+        matcher.addURI(ContactsContract.AUTHORITY, "contacts/#/data", CONTACTS_DATA);
+        matcher.addURI(ContactsContract.AUTHORITY, "contacts/#/raw_contacts", CONTACTS_RAW_CONTACTS);
+        matcher.addURI(ContactsContract.AUTHORITY, "contacts_summary", CONTACTS_SUMMARY);
+        matcher.addURI(ContactsContract.AUTHORITY, "contacts_summary/#", CONTACTS_SUMMARY_ID);
+        matcher.addURI(ContactsContract.AUTHORITY, "contacts_summary/filter/*",
+                CONTACTS_SUMMARY_FILTER);
+        matcher.addURI(ContactsContract.AUTHORITY, "contacts_summary/strequent/",
+                CONTACTS_SUMMARY_STREQUENT);
+        matcher.addURI(ContactsContract.AUTHORITY, "contacts_summary/strequent/filter/*",
+                CONTACTS_SUMMARY_STREQUENT_FILTER);
+        matcher.addURI(ContactsContract.AUTHORITY, "contacts_summary/group/*",
+                CONTACTS_SUMMARY_GROUP);
+        matcher.addURI(ContactsContract.AUTHORITY, "contacts/#/suggestions",
+                AGGREGATION_SUGGESTIONS);
+        matcher.addURI(ContactsContract.AUTHORITY, "raw_contacts", RAW_CONTACTS);
+        matcher.addURI(ContactsContract.AUTHORITY, "raw_contacts/#", RAW_CONTACTS_ID);
+        matcher.addURI(ContactsContract.AUTHORITY, "raw_contacts/#/data", RAW_CONTACTS_DATA);
+        matcher.addURI(ContactsContract.AUTHORITY, "raw_contacts/filter_email/*",
+                CONTACTS_FILTER_EMAIL);
+
+        matcher.addURI(ContactsContract.AUTHORITY, "data", DATA);
+        matcher.addURI(ContactsContract.AUTHORITY, "data/#", DATA_ID);
+        matcher.addURI(ContactsContract.AUTHORITY, "data/phones", PHONES);
+        matcher.addURI(ContactsContract.AUTHORITY, "data/phones/filter/*", PHONES_FILTER);
+        matcher.addURI(ContactsContract.AUTHORITY, "data/postals", POSTALS);
+
+        matcher.addURI(ContactsContract.AUTHORITY, "groups", GROUPS);
+        matcher.addURI(ContactsContract.AUTHORITY, "groups/#", GROUPS_ID);
+        matcher.addURI(ContactsContract.AUTHORITY, "groups_summary", GROUPS_SUMMARY);
+
+        matcher.addURI(ContactsContract.AUTHORITY, SyncStateContentProviderHelper.PATH, SYNCSTATE);
+
+        matcher.addURI(ContactsContract.AUTHORITY, "phone_lookup/*", PHONE_LOOKUP);
+        matcher.addURI(ContactsContract.AUTHORITY, "aggregation_exceptions",
+                AGGREGATION_EXCEPTIONS);
+        matcher.addURI(ContactsContract.AUTHORITY, "aggregation_exceptions/*",
+                AGGREGATION_EXCEPTION_ID);
+
+        matcher.addURI(ContactsContract.AUTHORITY, "presence", PRESENCE);
+        matcher.addURI(ContactsContract.AUTHORITY, "presence/#", PRESENCE_ID);
+
+        matcher.addURI(ContactsContract.AUTHORITY, SearchManager.SUGGEST_URI_PATH_QUERY,
+                SEARCH_SUGGESTIONS);
+        matcher.addURI(ContactsContract.AUTHORITY, SearchManager.SUGGEST_URI_PATH_QUERY + "/*",
+                SEARCH_SUGGESTIONS);
+        matcher.addURI(ContactsContract.AUTHORITY, SearchManager.SUGGEST_URI_PATH_SHORTCUT + "/#",
+                SEARCH_SHORTCUT);
+
+        HashMap<String, String> columns;
+
+        // Contacts projection map
+        columns = new HashMap<String, String>();
+        columns.put(Contacts._ID, "contacts._id AS _id");
+        columns.put(Contacts.DISPLAY_NAME, ContactsColumns.CONCRETE_DISPLAY_NAME + " AS "
+                + Contacts.DISPLAY_NAME);
+        columns.put(Contacts.LAST_TIME_CONTACTED, ContactsColumns.CONCRETE_LAST_TIME_CONTACTED
+                + " AS " + Contacts.LAST_TIME_CONTACTED);
+        columns.put(Contacts.TIMES_CONTACTED, ContactsColumns.CONCRETE_TIMES_CONTACTED + " AS "
+                + Contacts.TIMES_CONTACTED);
+        columns.put(Contacts.STARRED, ContactsColumns.CONCRETE_STARRED + " AS "
+                + Contacts.STARRED);
+        columns.put(Contacts.IN_VISIBLE_GROUP, Contacts.IN_VISIBLE_GROUP);
+        columns.put(Contacts.PHOTO_ID, Contacts.PHOTO_ID);
+        columns.put(Contacts.PRIMARY_PHONE_ID, Contacts.PRIMARY_PHONE_ID);
+        columns.put(Contacts.PRIMARY_EMAIL_ID, Contacts.PRIMARY_EMAIL_ID);
+        columns.put(Contacts.CUSTOM_RINGTONE, ContactsColumns.CONCRETE_CUSTOM_RINGTONE + " AS "
+                + Contacts.CUSTOM_RINGTONE);
+        columns.put(Contacts.SEND_TO_VOICEMAIL, ContactsColumns.CONCRETE_SEND_TO_VOICEMAIL
+                + " AS " + Contacts.SEND_TO_VOICEMAIL);
+        columns.put(ContactsColumns.FALLBACK_PRIMARY_PHONE_ID,
+                ContactsColumns.FALLBACK_PRIMARY_PHONE_ID);
+        columns.put(ContactsColumns.FALLBACK_PRIMARY_EMAIL_ID,
+                ContactsColumns.FALLBACK_PRIMARY_EMAIL_ID);
+        sContactsProjectionMap = columns;
+
+        columns = new HashMap<String, String>();
+        columns.putAll(sContactsProjectionMap);
+
+        // Contacts primaries projection map. The overall presence status is
+        // the most-present value, as indicated by the largest value.
+        columns.put(Contacts.PRESENCE_STATUS, "MAX(" + Presence.PRESENCE_STATUS + ")");
+        columns.put(Contacts.PRIMARY_PHONE_TYPE, CommonDataKinds.Phone.TYPE);
+        columns.put(Contacts.PRIMARY_PHONE_LABEL, CommonDataKinds.Phone.LABEL);
+        columns.put(Contacts.PRIMARY_PHONE_NUMBER, CommonDataKinds.Phone.NUMBER);
+        sContactsSummaryProjectionMap = columns;
+
+        // RawContacts 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);
+        columns.put(RawContacts.ACCOUNT_NAME,
+                OpenHelper.RawContactsColumns.CONCRETE_ACCOUNT_NAME
+                        + " AS " + RawContacts.ACCOUNT_NAME);
+        columns.put(RawContacts.ACCOUNT_TYPE,
+                OpenHelper.RawContactsColumns.CONCRETE_ACCOUNT_TYPE
+                        + " AS " + RawContacts.ACCOUNT_TYPE);
+        columns.put(RawContacts.SOURCE_ID,
+                OpenHelper.RawContactsColumns.CONCRETE_SOURCE_ID
+                        + " AS " + RawContacts.SOURCE_ID);
+        columns.put(RawContacts.VERSION,
+                OpenHelper.RawContactsColumns.CONCRETE_VERSION
+                        + " AS " + RawContacts.VERSION);
+        columns.put(RawContacts.DIRTY,
+                OpenHelper.RawContactsColumns.CONCRETE_DIRTY
+                        + " AS " + RawContacts.DIRTY);
+        columns.put(RawContacts.DELETED,
+                OpenHelper.RawContactsColumns.CONCRETE_DELETED
+                        + " AS " + RawContacts.DELETED);
+        sRawContactsProjectionMap = columns;
+
+        columns = new HashMap<String, String>();
+        columns.putAll(sContactsProjectionMap);
+        columns.putAll(sRawContactsProjectionMap);
+        sRawContactsContactsProjectionMap = columns;
+
+        // Data projection map
+        columns = new HashMap<String, String>();
+        columns.put(Data._ID, Tables.DATA + "." + Data._ID + " AS _id");
+        columns.put(Data.RAW_CONTACT_ID, Data.RAW_CONTACT_ID);
+        columns.put(Data.RES_PACKAGE, PackagesColumns.PACKAGE + " AS " + Data.RES_PACKAGE);
+        columns.put(Data.MIMETYPE, Data.MIMETYPE);
+        columns.put(Data.IS_PRIMARY, Data.IS_PRIMARY);
+        columns.put(Data.IS_SUPER_PRIMARY, Data.IS_SUPER_PRIMARY);
+        columns.put(Data.DATA_VERSION, Data.DATA_VERSION);
+        columns.put(Data.DATA1, "data.data1 as data1");
+        columns.put(Data.DATA2, "data.data2 as data2");
+        columns.put(Data.DATA3, "data.data3 as data3");
+        columns.put(Data.DATA4, "data.data4 as data4");
+        columns.put(Data.DATA5, "data.data5 as data5");
+        columns.put(Data.DATA6, "data.data6 as data6");
+        columns.put(Data.DATA7, "data.data7 as data7");
+        columns.put(Data.DATA8, "data.data8 as data8");
+        columns.put(Data.DATA9, "data.data9 as data9");
+        columns.put(Data.DATA10, "data.data10 as data10");
+        columns.put(Data.DATA11, "data.data11 as data11");
+        columns.put(Data.DATA12, "data.data12 as data12");
+        columns.put(Data.DATA13, "data.data13 as data13");
+        columns.put(Data.DATA14, "data.data14 as data14");
+        columns.put(Data.DATA15, "data.data15 as data15");
+        columns.put(GroupMembership.GROUP_SOURCE_ID, GroupsColumns.CONCRETE_SOURCE_ID + " AS "
+                + GroupMembership.GROUP_SOURCE_ID);
+
+        // TODO: remove this projection
+        // Mappings used for backwards compatibility.
+        columns.put("number", Phone.NUMBER);
+        sDataGroupsProjectionMap = columns;
+
+        // Data, groups and contacts projection map for joins. _id comes from the data table
+        columns = new HashMap<String, String>();
+        columns.putAll(sRawContactsProjectionMap);
+        columns.putAll(sDataGroupsProjectionMap); // _id will be replaced with the one from data
+        columns.put(Data.RAW_CONTACT_ID, DataColumns.CONCRETE_RAW_CONTACT_ID);
+        sDataRawContactsGroupsProjectionMap = columns;
+
+        // Data and contacts projection map for joins. _id comes from the data table
+        columns = new HashMap<String, String>();
+        columns.putAll(sDataRawContactsGroupsProjectionMap);
+        columns.remove(GroupMembership.GROUP_SOURCE_ID);
+        sDataRawContactsProjectionMap = columns;
+
+        // Data and contacts projection map for joins. _id comes from the data table
+        columns = new HashMap<String, String>();
+        columns.putAll(sContactsProjectionMap);
+        columns.putAll(sRawContactsProjectionMap); //
+        columns.putAll(sDataGroupsProjectionMap); // _id will be replaced with the one from data
+        columns.put(Data.RAW_CONTACT_ID, DataColumns.CONCRETE_RAW_CONTACT_ID);
+        sDataRawContactsGroupsContactProjectionMap = columns;
+
+        // Data and contacts projection map for joins. _id comes from the data table
+        columns = new HashMap<String, String>();
+        columns.putAll(sDataRawContactsGroupsContactProjectionMap);
+        columns.remove(GroupMembership.GROUP_SOURCE_ID);
+        sDataRawContactsContactProjectionMap = columns;
+
+        // Groups projection map
+        columns = new HashMap<String, String>();
+        columns.put(Groups._ID, "groups._id AS _id");
+        columns.put(Groups.ACCOUNT_NAME, Groups.ACCOUNT_NAME);
+        columns.put(Groups.ACCOUNT_TYPE, Groups.ACCOUNT_TYPE);
+        columns.put(Groups.SOURCE_ID, Groups.SOURCE_ID);
+        columns.put(Groups.DIRTY, Groups.DIRTY);
+        columns.put(Groups.VERSION, Groups.VERSION);
+        columns.put(Groups.RES_PACKAGE, PackagesColumns.PACKAGE + " AS " + Groups.RES_PACKAGE);
+        columns.put(Groups.TITLE, Groups.TITLE);
+        columns.put(Groups.TITLE_RES, Groups.TITLE_RES);
+        columns.put(Groups.GROUP_VISIBLE, Groups.GROUP_VISIBLE);
+        sGroupsProjectionMap = columns;
+
+        // RawContacts and groups projection map
+        columns = new HashMap<String, String>();
+        columns.putAll(sGroupsProjectionMap);
+
+        columns.put(Groups.SUMMARY_COUNT, "(SELECT COUNT(DISTINCT " + ContactsColumns.CONCRETE_ID
+                + ") FROM " + Tables.DATA_JOIN_MIMETYPES_RAW_CONTACTS_CONTACTS + " WHERE "
+                + Clauses.MIMETYPE_IS_GROUP_MEMBERSHIP + " AND " + Clauses.BELONGS_TO_GROUP
+                + ") AS " + Groups.SUMMARY_COUNT);
+
+        columns.put(Groups.SUMMARY_WITH_PHONES, "(SELECT COUNT(DISTINCT "
+                + ContactsColumns.CONCRETE_ID + ") FROM "
+                + Tables.DATA_JOIN_MIMETYPES_RAW_CONTACTS_CONTACTS + " WHERE "
+                + Clauses.MIMETYPE_IS_GROUP_MEMBERSHIP + " AND " + Clauses.BELONGS_TO_GROUP
+                + " AND " + Clauses.HAS_PRIMARY_PHONE + ") AS " + Groups.SUMMARY_WITH_PHONES);
+
+        sGroupsSummaryProjectionMap = columns;
+
+        // Aggregate exception projection map
+        columns = new HashMap<String, String>();
+        columns.put(AggregationExceptionColumns._ID, Tables.AGGREGATION_EXCEPTIONS + "._id AS _id");
+        columns.put(AggregationExceptions.TYPE, AggregationExceptions.TYPE);
+        columns.put(AggregationExceptions.CONTACT_ID,
+                "raw_contacts1." + RawContacts.CONTACT_ID
+                + " AS " + AggregationExceptions.CONTACT_ID);
+        columns.put(AggregationExceptions.RAW_CONTACT_ID, AggregationExceptionColumns.RAW_CONTACT_ID2);
+        sAggregationExceptionsProjectionMap = columns;
+
+
+        columns = new HashMap<String, String>();
+        columns.put(Presence._ID, Presence._ID);
+        columns.put(Presence.RAW_CONTACT_ID, Presence.RAW_CONTACT_ID);
+        columns.put(Presence.DATA_ID, Presence.DATA_ID);
+        columns.put(Presence.IM_ACCOUNT, Presence.IM_ACCOUNT);
+        columns.put(Presence.IM_HANDLE, Presence.IM_HANDLE);
+        columns.put(Presence.IM_PROTOCOL, Presence.IM_PROTOCOL);
+        columns.put(Presence.PRESENCE_STATUS, Presence.PRESENCE_STATUS);
+        columns.put(Presence.PRESENCE_CUSTOM_STATUS, Presence.PRESENCE_CUSTOM_STATUS);
+        sPresenceProjectionMap = columns;
+
+        sNestedRawContactIdSelect = "SELECT " + Data.RAW_CONTACT_ID + " FROM " + Tables.DATA + " WHERE "
+                + Data._ID + "=?";
+        sNestedMimetypeSelect = "SELECT " + DataColumns.MIMETYPE_ID + " FROM " + Tables.DATA
+                + " WHERE " + Data._ID + "=?";
+        sNestedContactIdSelect = "SELECT " + RawContacts.CONTACT_ID + " FROM " + Tables.RAW_CONTACTS
+                + " WHERE " + RawContacts._ID + "=(" + sNestedRawContactIdSelect + ")";
+        sNestedContactIdListSelect = "SELECT " + RawContacts._ID + " FROM " + Tables.RAW_CONTACTS
+                + " WHERE " + RawContacts.CONTACT_ID + "=(" + sNestedContactIdSelect + ")";
+        sSetPrimaryWhere = Data.RAW_CONTACT_ID + "=(" + sNestedRawContactIdSelect + ") AND "
+                + DataColumns.MIMETYPE_ID + "=(" + sNestedMimetypeSelect + ")";
+        sSetSuperPrimaryWhere = Data.RAW_CONTACT_ID + " IN (" + sNestedContactIdListSelect + ") AND "
+                + DataColumns.MIMETYPE_ID + "=(" + sNestedMimetypeSelect + ")";
+        sContactsInGroupSelect = ContactsColumns.CONCRETE_ID + " IN (SELECT "
+                + RawContacts.CONTACT_ID + " FROM " + Tables.RAW_CONTACTS + " WHERE ("
+                + RawContactsColumns.CONCRETE_ID + " IN (SELECT " + Tables.DATA + "."
+                + Data.RAW_CONTACT_ID + " FROM " + Tables.DATA_JOIN_MIMETYPES + " WHERE ("
+                + Data.MIMETYPE + "='" + GroupMembership.CONTENT_ITEM_TYPE + "' AND "
+                + GroupMembership.GROUP_ROW_ID + "=(SELECT " + Tables.GROUPS + "."
+                + Groups._ID + " FROM " + Tables.GROUPS + " WHERE " + Groups.TITLE + "=?)))))";
+    }
+
+    /**
+     * Handles inserts and update for a specific Data type.
+     */
+    private abstract class DataRowHandler {
+
+        protected final String mMimetype;
+
+        public DataRowHandler(String mimetype) {
+            mMimetype = mimetype;
+        }
+
+        /**
+         * Inserts a row into the {@link Data} table.
+         */
+        public long insert(SQLiteDatabase db, long rawContactId, ContentValues values) {
+            final long dataId = db.insert(Tables.DATA, null, values);
+
+            Integer primary = values.getAsInteger(Data.IS_PRIMARY);
+            if (primary != null && primary != 0) {
+                setIsPrimary(dataId);
+            }
+
+            fixContactDisplayName(db, rawContactId);
+            return dataId;
+        }
+
+        /**
+         * Validates data and updates a {@link Data} row using the cursor, which contains
+         * the current data.
+         */
+        public void update(SQLiteDatabase db, ContentValues values, Cursor cursor) {
+            throw new UnsupportedOperationException();
+        }
+
+        public int delete(SQLiteDatabase db, Cursor c) {
+            long dataId = c.getLong(DataQuery.ID);
+            long rawContactId = c.getLong(DataQuery.RAW_CONTACT_ID);
+            boolean primary = c.getInt(DataQuery.IS_PRIMARY) != 0;
+            int count = db.delete(Tables.DATA, Data._ID + "=" + dataId, null);
+            if (count != 0 && primary) {
+                fixPrimary(db, rawContactId);
+                fixContactDisplayName(db, rawContactId);
+            }
+            return count;
+        }
+
+        private void fixPrimary(SQLiteDatabase db, long rawContactId) {
+            long newPrimaryId = findNewPrimaryDataId(db, rawContactId);
+            if (newPrimaryId != -1) {
+                ContactsProvider2.this.setIsPrimary(newPrimaryId);
+            }
+        }
+
+        protected long findNewPrimaryDataId(SQLiteDatabase db, long rawContactId) {
+            long primaryId = -1;
+            int primaryType = -1;
+            Cursor c = queryData(db, rawContactId);
+            try {
+                while (c.moveToNext()) {
+                    long dataId = c.getLong(DataQuery.ID);
+                    int type = c.getInt(DataQuery.DATA2);
+                    if (primaryType == -1 || getTypeRank(type) < getTypeRank(primaryType)) {
+                        primaryId = dataId;
+                        primaryType = type;
+                    }
+                }
+            } finally {
+                c.close();
+            }
+            return primaryId;
+        }
+
+        /**
+         * Returns the rank of a specific record type to be used in determining the primary
+         * row. Lower number represents higher priority.
+         */
+        protected int getTypeRank(int type) {
+            return 0;
+        }
+
+        protected Cursor queryData(SQLiteDatabase db, long rawContactId) {
+            // TODO Lookup integer mimetype IDs' instead of joining for speed
+            return db.query(DataQuery.TABLE, DataQuery.COLUMNS, Data.RAW_CONTACT_ID + "="
+                    + rawContactId + " AND " + MimetypesColumns.MIMETYPE + "='" + mMimetype + "'",
+                    null, null, null, null);
+        }
+
+        protected void fixContactDisplayName(SQLiteDatabase db, long rawContactId) {
+            if (!sDisplayNamePriorities.containsKey(mMimetype)) {
+                return;
+            }
+
+            String bestDisplayName = null;
+            Cursor c = db.query(DisplayNameQuery.TABLE, DisplayNameQuery.COLUMNS,
+                    Data.RAW_CONTACT_ID + "=" + rawContactId, null, null, null, null);
+            try {
+                int maxPriority = -1;
+                while (c.moveToNext()) {
+                    String mimeType = c.getString(DisplayNameQuery.MIMETYPE);
+                    boolean primary;
+                    String name;
+
+                    if (StructuredName.CONTENT_ITEM_TYPE.equals(mimeType)) {
+                        name = c.getString(DisplayNameQuery.DISPLAY_NAME);
+                        primary = true;
+                    } else {
+                        name = c.getString(DisplayNameQuery.DATA2);
+                        primary = (c.getInt(DisplayNameQuery.IS_PRIMARY) != 0);
+                    }
+
+                    if (primary && name != null) {
+                        Integer priority = sDisplayNamePriorities.get(mimeType);
+                        if (priority != null && priority > maxPriority) {
+                            maxPriority = priority;
+                            bestDisplayName = name;
+                        }
+                    }
+                }
+
+            } finally {
+                c.close();
+            }
+
+            ContactsProvider2.this.setDisplayName(rawContactId, bestDisplayName);
+        }
+    }
+
+    public class CustomDataRowHandler extends DataRowHandler {
+
+        public CustomDataRowHandler(String mimetype) {
+            super(mimetype);
+        }
+    }
+
+    public class StructuredNameRowHandler extends DataRowHandler {
+
+        private final NameSplitter mNameSplitter;
+
+        public StructuredNameRowHandler(NameSplitter nameSplitter) {
+            super(StructuredName.CONTENT_ITEM_TYPE);
+            mNameSplitter = nameSplitter;
+        }
+
+        @Override
+        public long insert(SQLiteDatabase db, long rawContactId, ContentValues values) {
+            fixStructuredNameComponents(values);
+            return super.insert(db, rawContactId, values);
+        }
+
+        @Override
+        public void update(SQLiteDatabase db, ContentValues values, Cursor cursor) {
+            // TODO Parse the full name if it has changed and replace pre-existing piece parts.
+        }
+
+        /**
+         * Parses the supplied display name, but only if the incoming values do not already contain
+         * structured name parts.  Also, if the display name is not provided, generate one by
+         * concatenating first name and last name
+         *
+         * TODO see if the order of first and last names needs to be conditionally reversed for
+         * some locales, e.g. China.
+         */
+        private void fixStructuredNameComponents(ContentValues values) {
+            String fullName = values.getAsString(StructuredName.DISPLAY_NAME);
+            if (!TextUtils.isEmpty(fullName)
+                    && TextUtils.isEmpty(values.getAsString(StructuredName.PREFIX))
+                    && TextUtils.isEmpty(values.getAsString(StructuredName.GIVEN_NAME))
+                    && TextUtils.isEmpty(values.getAsString(StructuredName.MIDDLE_NAME))
+                    && TextUtils.isEmpty(values.getAsString(StructuredName.FAMILY_NAME))
+                    && TextUtils.isEmpty(values.getAsString(StructuredName.SUFFIX))) {
+                NameSplitter.Name name = new NameSplitter.Name();
+                mNameSplitter.split(name, fullName);
+
+                values.put(StructuredName.PREFIX, name.getPrefix());
+                values.put(StructuredName.GIVEN_NAME, name.getGivenNames());
+                values.put(StructuredName.MIDDLE_NAME, name.getMiddleName());
+                values.put(StructuredName.FAMILY_NAME, name.getFamilyName());
+                values.put(StructuredName.SUFFIX, name.getSuffix());
+            }
+
+            if (TextUtils.isEmpty(fullName)) {
+                String givenName = values.getAsString(StructuredName.GIVEN_NAME);
+                String familyName = values.getAsString(StructuredName.FAMILY_NAME);
+                if (TextUtils.isEmpty(givenName)) {
+                    fullName = familyName;
+                } else if (TextUtils.isEmpty(familyName)) {
+                    fullName = givenName;
+                } else {
+                    fullName = givenName + " " + familyName;
+                }
+
+                if (!TextUtils.isEmpty(fullName)) {
+                    values.put(StructuredName.DISPLAY_NAME, fullName);
+                }
+            }
+        }
+    }
+
+    public class CommonDataRowHandler extends DataRowHandler {
+
+        private final String mTypeColumn;
+        private final String mLabelColumn;
+
+        public CommonDataRowHandler(String mimetype, String typeColumn, String labelColumn) {
+            super(mimetype);
+            mTypeColumn = typeColumn;
+            mLabelColumn = labelColumn;
+        }
+
+        @Override
+        public long insert(SQLiteDatabase db, long rawContactId, ContentValues values) {
+            int type;
+            String label;
+            if (values.containsKey(mTypeColumn)) {
+                type = values.getAsInteger(mTypeColumn);
+            } else {
+                type = BaseTypes.TYPE_CUSTOM;
+            }
+            if (values.containsKey(mLabelColumn)) {
+                label = values.getAsString(mLabelColumn);
+            } else {
+                label = null;
+            }
+
+            if (type != BaseTypes.TYPE_CUSTOM && label != null) {
+                throw new RuntimeException(mLabelColumn + " value can only be specified with "
+                        + mTypeColumn + "=" + BaseTypes.TYPE_CUSTOM + "(custom)");
+            }
+
+            if (type == BaseTypes.TYPE_CUSTOM && label == null) {
+                throw new RuntimeException(mLabelColumn + " value must be specified when "
+                        + mTypeColumn + "=" + BaseTypes.TYPE_CUSTOM + "(custom)");
+            }
+
+            return super.insert(db, rawContactId, values);
+        }
+
+        @Override
+        public void update(SQLiteDatabase db, ContentValues values, Cursor cursor) {
+            // TODO read the data and check the constraint
+        }
+    }
+
+    public class OrganizationDataRowHandler extends CommonDataRowHandler {
+
+        public OrganizationDataRowHandler() {
+            super(Organization.CONTENT_ITEM_TYPE, Organization.TYPE, Organization.LABEL);
+        }
+
+        @Override
+        public long insert(SQLiteDatabase db, long rawContactId, ContentValues values) {
+            long id = super.insert(db, rawContactId, values);
+            fixContactDisplayName(db, rawContactId);
+            return id;
+        }
+
+        @Override
+        protected int getTypeRank(int type) {
+            switch (type) {
+                case Organization.TYPE_WORK: return 0;
+                case Organization.TYPE_CUSTOM: return 1;
+                case Organization.TYPE_OTHER: return 2;
+                default: return 1000;
+            }
+        }
+    }
+
+    public class EmailDataRowHandler extends CommonDataRowHandler {
+
+        public EmailDataRowHandler() {
+            super(Email.CONTENT_ITEM_TYPE, Email.TYPE, Email.LABEL);
+        }
+
+        @Override
+        public long insert(SQLiteDatabase db, long rawContactId, ContentValues values) {
+            long id = super.insert(db, rawContactId, values);
+            fixContactDisplayName(db, rawContactId);
+            return id;
+        }
+
+        @Override
+        protected int getTypeRank(int type) {
+            switch (type) {
+                case Email.TYPE_HOME: return 0;
+                case Email.TYPE_WORK: return 1;
+                case Email.TYPE_CUSTOM: return 2;
+                case Email.TYPE_OTHER: return 3;
+                default: return 1000;
+            }
+        }
+    }
+
+    public class PhoneDataRowHandler extends CommonDataRowHandler {
+
+        public PhoneDataRowHandler() {
+            super(Phone.CONTENT_ITEM_TYPE, Phone.TYPE, Phone.LABEL);
+        }
+
+        @Override
+        public long insert(SQLiteDatabase db, long rawContactId, ContentValues values) {
+            ContentValues phoneValues = new ContentValues();
+            String number = values.getAsString(Phone.NUMBER);
+            String normalizedNumber = null;
+            if (number != null) {
+                normalizedNumber = PhoneNumberUtils.getStrippedReversed(number);
+                values.put(PhoneColumns.NORMALIZED_NUMBER, normalizedNumber);
+            }
+
+            long id = super.insert(db, rawContactId, values);
+
+            if (number != null) {
+                phoneValues.put(PhoneLookupColumns.RAW_CONTACT_ID, rawContactId);
+                phoneValues.put(PhoneLookupColumns.DATA_ID, id);
+                phoneValues.put(PhoneLookupColumns.NORMALIZED_NUMBER, normalizedNumber);
+                db.insert(Tables.PHONE_LOOKUP, null, phoneValues);
+            }
+
+            return id;
+        }
+
+        @Override
+        protected int getTypeRank(int type) {
+            switch (type) {
+                case Phone.TYPE_MOBILE: return 0;
+                case Phone.TYPE_WORK: return 1;
+                case Phone.TYPE_HOME: return 2;
+                case Phone.TYPE_PAGER: return 3;
+                case Phone.TYPE_CUSTOM: return 4;
+                case Phone.TYPE_OTHER: return 5;
+                case Phone.TYPE_FAX_WORK: return 6;
+                case Phone.TYPE_FAX_HOME: return 7;
+                default: return 1000;
+            }
+        }
+    }
+
+    private HashMap<String, DataRowHandler> mDataRowHandlers;
+    private final ContactAggregationScheduler mAggregationScheduler;
+    private OpenHelper mOpenHelper;
+
+    private ContactAggregator mContactAggregator;
+    private NameSplitter mNameSplitter;
+    private LegacyApiSupport mLegacyApiSupport;
+    private GlobalSearchSupport mGlobalSearchSupport;
+
+    private ContentValues mValues = new ContentValues();
+
+    public ContactsProvider2() {
+        this(new ContactAggregationScheduler());
+    }
+
+    /**
+     * Constructor for testing.
+     */
+    /* package */ ContactsProvider2(ContactAggregationScheduler scheduler) {
+        mAggregationScheduler = scheduler;
+    }
+
+    @Override
+    public boolean onCreate() {
+        final Context context = getContext();
+
+        mOpenHelper = getOpenHelper(context);
+        mGlobalSearchSupport = new GlobalSearchSupport(this);
+        mLegacyApiSupport = new LegacyApiSupport(context, mOpenHelper, this, mGlobalSearchSupport);
+        mContactAggregator = new ContactAggregator(context, mOpenHelper, mAggregationScheduler);
+
+        final SQLiteDatabase db = mOpenHelper.getReadableDatabase();
+        mSetPrimaryStatement = db.compileStatement(
+                "UPDATE " + Tables.DATA + " SET " + Data.IS_PRIMARY
+                + "=(_id=?) WHERE " + sSetPrimaryWhere);
+        mSetSuperPrimaryStatement = db.compileStatement(
+                "UPDATE " + Tables.DATA + " SET " + Data.IS_SUPER_PRIMARY
+                + "=(_id=?) WHERE " + sSetSuperPrimaryWhere);
+        mLastTimeContactedUpdate = db.compileStatement("UPDATE " + Tables.RAW_CONTACTS + " SET "
+                + RawContacts.TIMES_CONTACTED + "=" + RawContacts.TIMES_CONTACTED + "+1,"
+                + RawContacts.LAST_TIME_CONTACTED + "=? WHERE " + RawContacts.CONTACT_ID + "=?");
+
+        mContactDisplayNameUpdate = db.compileStatement("UPDATE " + Tables.RAW_CONTACTS + " SET "
+                + RawContactsColumns.DISPLAY_NAME + "=? WHERE " + RawContacts._ID + "=?");
+
+        mNameSplitter = new NameSplitter(
+                context.getString(com.android.internal.R.string.common_name_prefixes),
+                context.getString(com.android.internal.R.string.common_last_name_prefixes),
+                context.getString(com.android.internal.R.string.common_name_suffixes),
+                context.getString(com.android.internal.R.string.common_name_conjunctions));
+
+        mDataRowHandlers = new HashMap<String, DataRowHandler>();
+
+        mDataRowHandlers.put(Email.CONTENT_ITEM_TYPE, new EmailDataRowHandler());
+        mDataRowHandlers.put(Im.CONTENT_ITEM_TYPE,
+                new CommonDataRowHandler(Im.CONTENT_ITEM_TYPE, Im.TYPE, Im.LABEL));
+        mDataRowHandlers.put(Nickname.CONTENT_ITEM_TYPE, new CommonDataRowHandler(
+                StructuredPostal.CONTENT_ITEM_TYPE, StructuredPostal.TYPE, StructuredPostal.LABEL));
+        mDataRowHandlers.put(Organization.CONTENT_ITEM_TYPE, new OrganizationDataRowHandler());
+        mDataRowHandlers.put(Phone.CONTENT_ITEM_TYPE, new PhoneDataRowHandler());
+        mDataRowHandlers.put(Nickname.CONTENT_ITEM_TYPE, new CommonDataRowHandler(
+                Nickname.CONTENT_ITEM_TYPE, Nickname.TYPE, Nickname.LABEL));
+        mDataRowHandlers.put(StructuredName.CONTENT_ITEM_TYPE,
+                new StructuredNameRowHandler(mNameSplitter));
+
+        return (db != null);
+    }
+
+    /* Visible for testing */
+    protected OpenHelper getOpenHelper(final Context context) {
+        return OpenHelper.getInstance(context);
+    }
+
+    @Override
+    protected void finalize() throws Throwable {
+        if (mContactAggregator != null) {
+            mContactAggregator.quit();
+        }
+
+        super.finalize();
+    }
+
+    /**
+     * Wipes all data from the contacts database.
+     */
+    /* package */ void wipeData() {
+        mOpenHelper.wipeData();
+    }
+
+    /**
+     * 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);
+    }
+
+    @Override
+    public boolean isTemporary() {
+        return false;
+    }
+
+    private DataRowHandler getDataRowHandler(final String mimeType) {
+        DataRowHandler handler = mDataRowHandlers.get(mimeType);
+        if (handler == null) {
+            handler = new CustomDataRowHandler(mimeType);
+            mDataRowHandlers.put(mimeType, handler);
+        }
+        return handler;
+    }
+
+    @Override
+    public Uri insert(Uri uri, ContentValues values) {
+        final int match = sUriMatcher.match(uri);
+        long id = 0;
+
+        switch (match) {
+            case SYNCSTATE:
+                id = mOpenHelper.getSyncState().insert(mOpenHelper.getWritableDatabase(), values);
+                break;
+
+            case CONTACTS: {
+                insertContact(values);
+                break;
+            }
+
+            case RAW_CONTACTS: {
+                final Account account = readAccountFromQueryParams(uri);
+                id = insertRawContact(values, account);
+                break;
+            }
+
+            case RAW_CONTACTS_DATA: {
+                values.put(Data.RAW_CONTACT_ID, uri.getPathSegments().get(1));
+                id = insertData(values);
+                break;
+            }
+
+            case DATA: {
+                id = insertData(values);
+                break;
+            }
+
+            case GROUPS: {
+                final Account account = readAccountFromQueryParams(uri);
+                id = insertGroup(values, account);
+                break;
+            }
+
+            case PRESENCE: {
+                id = insertPresence(values);
+                break;
+            }
+
+            default:
+                return mLegacyApiSupport.insert(uri, values);
+        }
+
+        if (id < 0) {
+            return null;
+        }
+
+        final Uri result = ContentUris.withAppendedId(uri, id);
+        onChange(result);
+        return result;
+    }
+
+    /**
+     * If account is non-null then store it in the values. If the account is already
+     * specified in the values then it must be consistent with the account, if it is non-null.
+     * @param values the ContentValues to read from and update
+     * @param account the explicitly provided Account
+     * @return false if the accounts are inconsistent
+     */
+    private boolean resolveAccount(ContentValues values, Account account) {
+        // If either is specified then both must be specified.
+        final String accountName = values.getAsString(RawContacts.ACCOUNT_NAME);
+        final String accountType = values.getAsString(RawContacts.ACCOUNT_TYPE);
+        if (!TextUtils.isEmpty(accountName) || !TextUtils.isEmpty(accountType)) {
+            final Account valuesAccount = new Account(accountName, accountType);
+            if (account != null && !valuesAccount.equals(account)) {
+                return false;
+            }
+            account = valuesAccount;
+        }
+        if (account != null) {
+            values.put(RawContacts.ACCOUNT_NAME, account.mName);
+            values.put(RawContacts.ACCOUNT_TYPE, account.mType);
+        }
+        return true;
+    }
+
+    /**
+     * Inserts an item in the contacts table
+     *
+     * @param values the values for the new row
+     * @return the row ID of the newly created row
+     */
+    private long insertContact(ContentValues values) {
+        throw new UnsupportedOperationException("Aggregates are created automatically");
+    }
+
+    /**
+     * Inserts an item in the contacts table
+     *
+     * @param values the values for the new row
+     * @param account the account this contact should be associated with. may be null.
+     * @return the row ID of the newly created row
+     */
+    private long insertRawContact(ContentValues values, Account account) {
+        /*
+         * The contact record is inserted in the contacts table, but it needs to
+         * be processed by the aggregator before it will be returned by the
+         * "aggregates" queries.
+         */
+        final SQLiteDatabase db = mOpenHelper.getWritableDatabase();
+
+        ContentValues overriddenValues = new ContentValues(values);
+        overriddenValues.putNull(RawContacts.CONTACT_ID);
+        if (!resolveAccount(overriddenValues, account)) {
+            return -1;
+        }
+
+        return db.insert(Tables.RAW_CONTACTS, RawContacts.CONTACT_ID, overriddenValues);
+    }
+
+    /**
+     * Inserts an item in the data table
+     *
+     * @param values the values for the new row
+     * @return the row ID of the newly created row
+     */
+    private long insertData(ContentValues values) {
+        int aggregationMode = RawContacts.AGGREGATION_MODE_DISABLED;
+
+        final SQLiteDatabase db = mOpenHelper.getWritableDatabase();
+        long id = 0;
+        db.beginTransaction();
+        try {
+            mValues.clear();
+            mValues.putAll(values);
+
+            long rawContactId = mValues.getAsLong(Data.RAW_CONTACT_ID);
+
+            // Replace package with internal mapping
+            final String packageName = mValues.getAsString(Data.RES_PACKAGE);
+            if (packageName != null) {
+                mValues.put(DataColumns.PACKAGE_ID, mOpenHelper.getPackageId(packageName));
+            }
+            mValues.remove(Data.RES_PACKAGE);
+
+            // Replace mimetype with internal mapping
+            final String mimeType = mValues.getAsString(Data.MIMETYPE);
+            if (TextUtils.isEmpty(mimeType)) {
+                throw new RuntimeException(Data.MIMETYPE + " is required");
+            }
+
+            mValues.put(DataColumns.MIMETYPE_ID, mOpenHelper.getMimeTypeId(mimeType));
+            mValues.remove(Data.MIMETYPE);
+
+            if (GroupMembership.CONTENT_ITEM_TYPE.equals(mimeType)) {
+                boolean containsGroupSourceId = mValues.containsKey(GroupMembership.GROUP_SOURCE_ID);
+                boolean containsGroupId = mValues.containsKey(GroupMembership.GROUP_ROW_ID);
+                if (containsGroupSourceId && containsGroupId) {
+                    throw new IllegalArgumentException(
+                            "you are not allowed to set both the GroupMembership.GROUP_SOURCE_ID "
+                                    + "and GroupMembership.GROUP_ROW_ID");
+                }
+
+                if (!containsGroupSourceId && !containsGroupId) {
+                    throw new IllegalArgumentException(
+                            "you must set exactly one of GroupMembership.GROUP_SOURCE_ID "
+                                    + "and GroupMembership.GROUP_ROW_ID");
+                }
+
+                if (containsGroupSourceId) {
+                    final String sourceId = mValues.getAsString(GroupMembership.GROUP_SOURCE_ID);
+                    final long groupId = getOrMakeGroup(db, rawContactId, sourceId);
+                    mValues.remove(GroupMembership.GROUP_SOURCE_ID);
+                    mValues.put(GroupMembership.GROUP_ROW_ID, groupId);
+                }
+            }
+
+            id = getDataRowHandler(mimeType).insert(db, rawContactId, mValues);
+
+            aggregationMode = mContactAggregator.markContactForAggregation(rawContactId);
+
+            db.setTransactionSuccessful();
+        } finally {
+            db.endTransaction();
+        }
+
+        triggerAggregation(id, aggregationMode);
+        return id;
+    }
+
+    private void triggerAggregation(long rawContactId, int aggregationMode) {
+        switch (aggregationMode) {
+            case RawContacts.AGGREGATION_MODE_DEFAULT:
+                mContactAggregator.schedule();
+                break;
+
+            case RawContacts.AGGREGATION_MODE_IMMEDITATE:
+                mContactAggregator.aggregateContact(rawContactId);
+                break;
+
+            case RawContacts.AGGREGATION_MODE_DISABLED:
+                // Do nothing
+                break;
+        }
+    }
+
+    /**
+     * Returns the group id of the group with sourceId and the same account as rawContactId.
+     * If the group doesn't already exist then it is first created,
+     * @param db SQLiteDatabase to use for this operation
+     * @param rawContactId the contact this group is associated with
+     * @param sourceId the sourceIf of the group to query or create
+     * @return the group id of the existing or created group
+     * @throws IllegalArgumentException if the contact is not associated with an account
+     * @throws IllegalStateException if a group needs to be created but the creation failed
+     */
+    private long getOrMakeGroup(SQLiteDatabase db, long rawContactId, String sourceId) {
+        Account account = null;
+        Cursor c = db.query(ContactsQuery.TABLE, ContactsQuery.PROJECTION, RawContacts._ID + "="
+                + rawContactId, null, null, null, null);
+        try {
+            if (c.moveToNext()) {
+                final String accountName = c.getString(ContactsQuery.ACCOUNT_NAME);
+                final String accountType = c.getString(ContactsQuery.ACCOUNT_TYPE);
+                if (!TextUtils.isEmpty(accountName) && !TextUtils.isEmpty(accountType)) {
+                    account = new Account(accountName, accountType);
+                }
+            }
+        } finally {
+            c.close();
+        }
+        if (account == null) {
+            throw new IllegalArgumentException("if the groupmembership only "
+                    + "has a sourceid the the contact must be associate with "
+                    + "an account");
+        }
+
+        // look up the group that contains this sourceId and has the same account name and type
+        // as the contact refered to by rawContactId
+        c = db.query(Tables.GROUPS, new String[]{RawContacts._ID},
+                Clauses.GROUP_HAS_ACCOUNT_AND_SOURCE_ID,
+                new String[]{sourceId, account.mName, account.mType}, null, null, null);
+        try {
+            if (c.moveToNext()) {
+                return c.getLong(0);
+            } else {
+                ContentValues groupValues = new ContentValues();
+                groupValues.put(Groups.ACCOUNT_NAME, account.mName);
+                groupValues.put(Groups.ACCOUNT_TYPE, account.mType);
+                groupValues.put(Groups.SOURCE_ID, sourceId);
+                long groupId = db.insert(Tables.GROUPS, Groups.ACCOUNT_NAME, groupValues);
+                if (groupId < 0) {
+                    throw new IllegalStateException("unable to create a new group with "
+                            + "this sourceid: " + groupValues);
+                }
+                return groupId;
+            }
+        } finally {
+            c.close();
+        }
+    }
+
+    /**
+     * Delete data row by row so that fixing of primaries etc work correctly.
+     */
+    private int deleteData(String selection, String[] selectionArgs) {
+        SQLiteDatabase db = mOpenHelper.getWritableDatabase();
+        int count = 0;
+        db.beginTransaction();
+        try {
+
+            // Note that the query will return data according to the access restrictions,
+            // so we don't need to worry about deleting data we don't have permission to read.
+            Cursor c = query(Data.CONTENT_URI, DataIdQuery.COLUMNS, selection, selectionArgs, null);
+            try {
+                while(c.moveToNext()) {
+                    long dataId = c.getLong(DataIdQuery._ID);
+                    count += deleteData(dataId);
+                }
+            } finally {
+                c.close();
+            }
+            db.setTransactionSuccessful();
+        } finally {
+            db.endTransaction();
+        }
+
+        return count;
+    }
+
+    public int deleteData(long dataId, String[] allowedMimeTypes) {
+        SQLiteDatabase db = mOpenHelper.getWritableDatabase();
+        Cursor c = db.query(DataQuery.TABLE, DataQuery.COLUMNS,
+                DataColumns.CONCRETE_ID + "=" + dataId, null, null, null, null);
+        // TODO apply restrictions
+        try {
+            if (!c.moveToFirst()) {
+                return 0;
+            }
+
+            String mimeType = c.getString(DataQuery.MIMETYPE);
+            boolean valid = false;
+            for (int i = 0; i < allowedMimeTypes.length; i++) {
+                if (TextUtils.equals(mimeType, allowedMimeTypes[i])) {
+                    valid = true;
+                    break;
+                }
+            }
+
+            if (!valid) {
+                throw new RuntimeException("Data type mismatch: expected "
+                        + Lists.newArrayList(allowedMimeTypes));
+            }
+
+            return getDataRowHandler(mimeType).delete(db, c);
+        } finally {
+            c.close();
+        }
+    }
+
+    /**
+     * Delete the given {@link Data} row, fixing up any {@link Contacts}
+     * primaries that reference it.
+     */
+    private int deleteData(long dataId) {
+        final SQLiteDatabase db = mOpenHelper.getWritableDatabase();
+
+        final long mimePhone = mOpenHelper.getMimeTypeId(Phone.CONTENT_ITEM_TYPE);
+        final long mimeEmail = mOpenHelper.getMimeTypeId(Email.CONTENT_ITEM_TYPE);
+
+        // Check to see if the data about to be deleted was a super-primary on
+        // the parent aggregate, and set flags to fix-up once deleted.
+        long aggId = -1;
+        long mimeId = -1;
+        String dataRaw = null;
+        boolean fixOptimal = false;
+        boolean fixFallback = false;
+
+        Cursor cursor = null;
+        try {
+            cursor = db.query(DataContactsQuery.TABLE, DataContactsQuery.PROJECTION,
+                    DataColumns.CONCRETE_ID + "=" + dataId, null, null, null, null);
+            if (cursor.moveToFirst()) {
+                aggId = cursor.getLong(DataContactsQuery.CONTACT_ID);
+                mimeId = cursor.getLong(DataContactsQuery.MIMETYPE_ID);
+                if (mimeId == mimePhone) {
+                    dataRaw = cursor.getString(DataContactsQuery.PHONE_NUMBER);
+                    fixOptimal = (cursor.getLong(DataContactsQuery.OPTIMAL_PHONE_ID) == dataId);
+                    fixFallback = (cursor.getLong(DataContactsQuery.FALLBACK_PHONE_ID) == dataId);
+                } else if (mimeId == mimeEmail) {
+                    dataRaw = cursor.getString(DataContactsQuery.EMAIL_DATA);
+                    fixOptimal = (cursor.getLong(DataContactsQuery.OPTIMAL_EMAIL_ID) == dataId);
+                    fixFallback = (cursor.getLong(DataContactsQuery.FALLBACK_EMAIL_ID) == dataId);
+                }
+            }
+        } finally {
+            if (cursor != null) {
+                cursor.close();
+                cursor = null;
+            }
+        }
+
+        // Delete the requested data item.
+        int dataDeleted = db.delete(Tables.DATA, Data._ID + "=" + dataId, null);
+
+        // Fix-up any super-primary values that are now invalid.
+        if (fixOptimal || fixFallback) {
+            final ContentValues values = new ContentValues();
+            final StringBuilder scoreClause = new StringBuilder();
+
+            final String SCORE = "score";
+
+            // Build scoring clause that will first pick data items under the
+            // same aggregate that have identical values, otherwise fall back to
+            // normal primary scoring from the member contacts.
+            scoreClause.append("(CASE WHEN ");
+            if (mimeId == mimePhone) {
+                scoreClause.append(Phone.NUMBER);
+            } else if (mimeId == mimeEmail) {
+                scoreClause.append(Email.DATA);
+            }
+            scoreClause.append("=");
+            DatabaseUtils.appendEscapedSQLString(scoreClause, dataRaw);
+            scoreClause.append(" THEN 2 ELSE " + Data.IS_PRIMARY + " END) AS " + SCORE);
+
+            final String[] PROJ_PRIMARY = new String[] {
+                    DataColumns.CONCRETE_ID,
+                    RawContacts.IS_RESTRICTED,
+                    scoreClause.toString(),
+            };
+
+            final int COL_DATA_ID = 0;
+            final int COL_IS_RESTRICTED = 1;
+            final int COL_SCORE = 2;
+
+            cursor = db.query(Tables.DATA_JOIN_MIMETYPES_RAW_CONTACTS_CONTACTS, PROJ_PRIMARY,
+                    ContactsColumns.CONCRETE_ID + "=" + aggId + " AND " + DataColumns.MIMETYPE_ID
+                            + "=" + mimeId, null, null, null, SCORE);
+
+            if (fixOptimal) {
+                String colId = null;
+                String colIsRestricted = null;
+                if (mimeId == mimePhone) {
+                    colId = ContactsColumns.OPTIMAL_PRIMARY_PHONE_ID;
+                    colIsRestricted = ContactsColumns.OPTIMAL_PRIMARY_PHONE_IS_RESTRICTED;
+                } else if (mimeId == mimeEmail) {
+                    colId = ContactsColumns.OPTIMAL_PRIMARY_EMAIL_ID;
+                    colIsRestricted = ContactsColumns.OPTIMAL_PRIMARY_EMAIL_IS_RESTRICTED;
+                }
+
+                // Start by replacing with null, since fixOptimal told us that
+                // the previous aggregate values are bad.
+                values.putNull(colId);
+                values.putNull(colIsRestricted);
+
+                // When finding a new optimal primary, we only care about the
+                // highest scoring value, regardless of source.
+                if (cursor.moveToFirst()) {
+                    final long newOptimal = cursor.getLong(COL_DATA_ID);
+                    final long newIsRestricted = cursor.getLong(COL_IS_RESTRICTED);
+
+                    if (newOptimal != 0) {
+                        values.put(colId, newOptimal);
+                    }
+                    if (newIsRestricted != 0) {
+                        values.put(colIsRestricted, newIsRestricted);
+                    }
+                }
+            }
+
+            if (fixFallback) {
+                String colId = null;
+                if (mimeId == mimePhone) {
+                    colId = ContactsColumns.FALLBACK_PRIMARY_PHONE_ID;
+                } else if (mimeId == mimeEmail) {
+                    colId = ContactsColumns.FALLBACK_PRIMARY_EMAIL_ID;
+                }
+
+                // Start by replacing with null, since fixFallback told us that
+                // the previous aggregate values are bad.
+                values.putNull(colId);
+
+                // The best fallback value is the highest scoring data item that
+                // hasn't been restricted.
+                cursor.moveToPosition(-1);
+                while (cursor.moveToNext()) {
+                    final boolean isRestricted = (cursor.getInt(COL_IS_RESTRICTED) == 1);
+                    if (!isRestricted) {
+                        values.put(colId, cursor.getLong(COL_DATA_ID));
+                        break;
+                    }
+                }
+            }
+
+            // Push through any contact updates we have
+            if (values.size() > 0) {
+                db.update(Tables.CONTACTS, values, ContactsColumns.CONCRETE_ID + "=" + aggId,
+                        null);
+            }
+        }
+
+        return dataDeleted;
+    }
+
+    /**
+     * Inserts an item in the groups table
+     */
+    private long insertGroup(ContentValues values, Account account) {
+        final SQLiteDatabase db = mOpenHelper.getWritableDatabase();
+
+        ContentValues overriddenValues = new ContentValues(values);
+        if (!resolveAccount(overriddenValues, account)) {
+            return -1;
+        }
+
+        // Replace package with internal mapping
+        final String packageName = overriddenValues.getAsString(Groups.RES_PACKAGE);
+        if (packageName != null) {
+            overriddenValues.put(GroupsColumns.PACKAGE_ID, mOpenHelper.getPackageId(packageName));
+        }
+        overriddenValues.remove(Groups.RES_PACKAGE);
+
+        return db.insert(Tables.GROUPS, Groups.TITLE, overriddenValues);
+    }
+
+    /**
+     * Inserts a presence update.
+     */
+    public long insertPresence(ContentValues values) {
+        final SQLiteDatabase db = mOpenHelper.getWritableDatabase();
+        final String handle = values.getAsString(Presence.IM_HANDLE);
+        final String protocol = values.getAsString(Presence.IM_PROTOCOL);
+        if (TextUtils.isEmpty(handle) || TextUtils.isEmpty(protocol)) {
+            throw new IllegalArgumentException("IM_PROTOCOL and IM_HANDLE are required");
+        }
+
+        // TODO: generalize to allow other providers to match against email
+        boolean matchEmail = Im.PROTOCOL_GOOGLE_TALK == Integer.parseInt(protocol);
+
+        StringBuilder selection = new StringBuilder();
+        String[] selectionArgs;
+        if (matchEmail) {
+            selection.append("(" + Clauses.WHERE_IM_MATCHES + ") OR ("
+                    + Clauses.WHERE_EMAIL_MATCHES + ")");
+            selectionArgs = new String[] { protocol, handle, handle };
+        } else {
+            selection.append(Clauses.WHERE_IM_MATCHES);
+            selectionArgs = new String[] { protocol, handle };
+        }
+
+        if (values.containsKey(Presence.DATA_ID)) {
+            selection.append(" AND " + DataColumns.CONCRETE_ID + "=")
+                    .append(values.getAsLong(Presence.DATA_ID));
+        }
+
+        if (values.containsKey(Presence.RAW_CONTACT_ID)) {
+            selection.append(" AND " + DataColumns.CONCRETE_RAW_CONTACT_ID + "=")
+                    .append(values.getAsLong(Presence.RAW_CONTACT_ID));
+        }
+
+        selection.append(" AND ").append(getContactsRestrictionExceptions());
+
+        long dataId = -1;
+        long rawContactId = -1;
+
+        Cursor cursor = null;
+        try {
+            cursor = db.query(DataContactsQuery.TABLE, DataContactsQuery.PROJECTION,
+                    selection.toString(), selectionArgs, null, null, null);
+            if (cursor.moveToFirst()) {
+                dataId = cursor.getLong(DataContactsQuery.DATA_ID);
+                rawContactId = cursor.getLong(DataContactsQuery.RAW_CONTACT_ID);
+            } else {
+                // No contact found, return a null URI
+                return -1;
+            }
+        } finally {
+            if (cursor != null) {
+                cursor.close();
+            }
+        }
+
+        values.put(Presence.DATA_ID, dataId);
+        values.put(Presence.RAW_CONTACT_ID, rawContactId);
+
+        // Insert the presence update
+        long presenceId = db.replace(Tables.PRESENCE, null, values);
+        return presenceId;
+    }
+
+    @Override
+    public int delete(Uri uri, String selection, String[] selectionArgs) {
+        final SQLiteDatabase db = mOpenHelper.getWritableDatabase();
+        final int match = sUriMatcher.match(uri);
+        switch (match) {
+            case SYNCSTATE:
+                return mOpenHelper.getSyncState().delete(db, selection, selectionArgs);
+
+            case CONTACTS_ID: {
+                long contactId = ContentUris.parseId(uri);
+
+                // Remove references to the contact first
+                ContentValues values = new ContentValues();
+                values.putNull(RawContacts.CONTACT_ID);
+                db.update(Tables.RAW_CONTACTS, values,
+                        RawContacts.CONTACT_ID + "=" + contactId, null);
+
+                return db.delete(Tables.CONTACTS, BaseColumns._ID + "=" + contactId, null);
+            }
+
+            case RAW_CONTACTS_ID: {
+                return deleteRawContact(uri);
+            }
+
+            case DATA: {
+                return deleteData(selection, selectionArgs);
+            }
+
+            case DATA_ID: {
+                long dataId = ContentUris.parseId(uri);
+                return deleteData(dataId);
+            }
+
+            case GROUPS_ID: {
+                long groupId = ContentUris.parseId(uri);
+                final long groupMembershipMimetypeId = mOpenHelper
+                        .getMimeTypeId(GroupMembership.CONTENT_ITEM_TYPE);
+                int groupsDeleted = db.delete(Tables.GROUPS, Groups._ID + "=" + groupId, null);
+                int dataDeleted = db.delete(Tables.DATA, DataColumns.MIMETYPE_ID + "="
+                        + groupMembershipMimetypeId + " AND " + GroupMembership.GROUP_ROW_ID + "="
+                        + groupId, null);
+                mOpenHelper.updateAllVisible();
+                return groupsDeleted + dataDeleted;
+            }
+
+            case PRESENCE: {
+                return db.delete(Tables.PRESENCE, null, null);
+            }
+
+            default:
+                return mLegacyApiSupport.delete(uri, selection, selectionArgs);
+        }
+    }
+
+    private int deleteRawContact(Uri uri) {
+        boolean permanentDeletion = false;
+        String permanent = uri.getQueryParameter(RawContacts.DELETE_PERMANENTLY);
+        if (permanent != null && !"false".equals(permanent.toLowerCase())) {
+            permanentDeletion = true;
+        }
+
+        long rawContactId = ContentUris.parseId(uri);
+        return deleteRawContact(rawContactId, permanentDeletion);
+    }
+
+    public int deleteRawContact(long rawContactId, boolean permanently) {
+        final SQLiteDatabase db = mOpenHelper.getWritableDatabase();
+
+        // TODO delete aggregation exceptions
+        mOpenHelper.removeContactIfSingleton(rawContactId);
+        if (permanently) {
+            db.delete(Tables.PRESENCE, Presence.RAW_CONTACT_ID + "=" + rawContactId, null);
+            return db.delete(Tables.RAW_CONTACTS, RawContacts._ID + "=" + rawContactId, null);
+        } else {
+            mValues.clear();
+            mValues.put(RawContacts.DELETED, true);
+            mValues.put(RawContacts.AGGREGATION_MODE, RawContacts.AGGREGATION_MODE_DISABLED);
+            mValues.putNull(RawContacts.CONTACT_ID);
+            return updateRawContact(rawContactId, mValues, null, null);
+        }
+    }
+
+    private static Account readAccountFromQueryParams(Uri uri) {
+        final String name = uri.getQueryParameter(RawContacts.ACCOUNT_NAME);
+        final String type = uri.getQueryParameter(RawContacts.ACCOUNT_TYPE);
+        if (TextUtils.isEmpty(name) || TextUtils.isEmpty(type)) {
+            return null;
+        }
+        return new Account(name, type);
+    }
+
+
+    @Override
+    public int update(Uri uri, ContentValues values, String selection, String[] selectionArgs) {
+        final SQLiteDatabase db = mOpenHelper.getWritableDatabase();
+        int count = 0;
+
+        final int match = sUriMatcher.match(uri);
+        switch(match) {
+            case SYNCSTATE:
+                return mOpenHelper.getSyncState().update(db, values, selection, selectionArgs);
+
+            // TODO(emillar): We will want to disallow editing the contacts table at some point.
+            case CONTACTS: {
+                count = db.update(Tables.CONTACTS, values, selection, selectionArgs);
+                break;
+            }
+
+            case CONTACTS_ID: {
+                count = updateContactData(db, ContentUris.parseId(uri), values);
+                break;
+            }
+
+            case DATA: {
+                count = updateData(values, selection, selectionArgs);
+                break;
+            }
+
+            case DATA_ID: {
+                count = updateData(ContentUris.parseId(uri), values);
+                break;
+            }
+
+            case RAW_CONTACTS: {
+                count = db.update(Tables.RAW_CONTACTS, values, selection, selectionArgs);
+                break;
+            }
+
+            case RAW_CONTACTS_ID: {
+                long rawContactId = ContentUris.parseId(uri);
+                count = updateRawContact(rawContactId, values, selection, selectionArgs);
+                break;
+            }
+
+            case GROUPS: {
+                count = db.update(Tables.GROUPS, values, selection, selectionArgs);
+                mOpenHelper.updateAllVisible();
+                break;
+            }
+
+            case GROUPS_ID: {
+                long groupId = ContentUris.parseId(uri);
+                String selectionWithId = (Groups._ID + "=" + groupId + " ")
+                        + (selection == null ? "" : " AND " + selection);
+                count = db.update(Tables.GROUPS, values, selectionWithId, selectionArgs);
+
+                // If changing visibility, then update contacts
+                if (values.containsKey(Groups.GROUP_VISIBLE)) {
+                    mOpenHelper.updateAllVisible();
+                }
+
+                break;
+            }
+
+            case AGGREGATION_EXCEPTIONS: {
+                count = updateAggregationException(db, values);
+                break;
+            }
+
+            default:
+                return mLegacyApiSupport.update(uri, values, selection, selectionArgs);
+        }
+
+        if (count > 0) {
+            getContext().getContentResolver().notifyChange(uri, null);
+        }
+        return count;
+    }
+
+    private int updateRawContact(long rawContactId, ContentValues values, String selection,
+            String[] selectionArgs) {
+        final SQLiteDatabase db = mOpenHelper.getWritableDatabase();
+        String selectionWithId = (RawContacts._ID + " = " + rawContactId + " ")
+                + (selection == null ? "" : " AND " + selection);
+        return db.update(Tables.RAW_CONTACTS, values, selectionWithId, selectionArgs);
+    }
+
+    private int updateData(ContentValues values, String selection,
+            String[] selectionArgs) {
+        SQLiteDatabase db = mOpenHelper.getWritableDatabase();
+        int count = 0;
+        db.beginTransaction();
+        try {
+
+            // Note that the query will return data according to the access restrictions,
+            // so we don't need to worry about deleting data we don't have permission to read.
+            Cursor c = query(Data.CONTENT_URI, DataIdQuery.COLUMNS, selection, selectionArgs, null);
+            try {
+                while(c.moveToNext()) {
+                    long dataId = c.getLong(DataIdQuery._ID);
+                    count += updateData(dataId, values);
+                }
+            } finally {
+                c.close();
+            }
+            db.setTransactionSuccessful();
+        } finally {
+            db.endTransaction();
+        }
+
+        return count;
+    }
+
+    private int updateData(long dataId, ContentValues values) {
+        SQLiteDatabase db = mOpenHelper.getWritableDatabase();
+
+        mValues.clear();
+        mValues.putAll(values);
+        mValues.remove(Data._ID);
+        mValues.remove(Data.RAW_CONTACT_ID);
+        mValues.remove(Data.MIMETYPE);
+
+        String packageName = values.getAsString(Data.RES_PACKAGE);
+        if (packageName != null) {
+            mValues.remove(Data.RES_PACKAGE);
+            mValues.put(DataColumns.PACKAGE_ID, mOpenHelper.getPackageId(packageName));
+        }
+
+        boolean containsIsSuperPrimary = mValues.containsKey(Data.IS_SUPER_PRIMARY);
+        boolean containsIsPrimary = mValues.containsKey(Data.IS_PRIMARY);
+
+        // Remove primary or super primary values being set to 0. This is disallowed by the
+        // content provider.
+        if (containsIsSuperPrimary && mValues.getAsInteger(Data.IS_SUPER_PRIMARY) == 0) {
+            containsIsSuperPrimary = false;
+            mValues.remove(Data.IS_SUPER_PRIMARY);
+        }
+        if (containsIsPrimary && mValues.getAsInteger(Data.IS_PRIMARY) == 0) {
+            containsIsPrimary = false;
+            mValues.remove(Data.IS_PRIMARY);
+        }
+
+        if (containsIsSuperPrimary) {
+            setIsSuperPrimary(dataId);
+            setIsPrimary(dataId);
+
+            // Now that we've taken care of setting these, remove them from "values".
+            mValues.remove(Data.IS_SUPER_PRIMARY);
+            if (containsIsPrimary) {
+                mValues.remove(Data.IS_PRIMARY);
+            }
+        } else if (containsIsPrimary) {
+            setIsPrimary(dataId);
+
+            // Now that we've taken care of setting this, remove it from "values".
+            mValues.remove(Data.IS_PRIMARY);
+        }
+
+        if (mValues.size() > 0) {
+            return db.update(Tables.DATA, mValues, Data._ID + " = " + dataId, null);
+        }
+        return 0;
+    }
+
+    private int updateContactData(SQLiteDatabase db, long contactId, ContentValues values) {
+
+        // First update all constituent contacts
+        ContentValues optionValues = new ContentValues(5);
+        OpenHelper.copyStringValue(optionValues, RawContacts.CUSTOM_RINGTONE,
+                values, Contacts.CUSTOM_RINGTONE);
+        OpenHelper.copyLongValue(optionValues, RawContacts.SEND_TO_VOICEMAIL,
+                values, Contacts.SEND_TO_VOICEMAIL);
+        OpenHelper.copyLongValue(optionValues, RawContacts.LAST_TIME_CONTACTED,
+                values, Contacts.LAST_TIME_CONTACTED);
+        OpenHelper.copyLongValue(optionValues, RawContacts.TIMES_CONTACTED,
+                values, Contacts.TIMES_CONTACTED);
+        OpenHelper.copyLongValue(optionValues, RawContacts.STARRED,
+                values, Contacts.STARRED);
+
+        // Nothing to update - just return
+        if (optionValues.size() == 0) {
+            return 0;
+        }
+
+        db.update(Tables.RAW_CONTACTS, optionValues,
+                RawContacts.CONTACT_ID + "=" + contactId, null);
+        return db.update(Tables.CONTACTS, values, Contacts._ID + "=" + contactId, null);
+    }
+
+    public void updateContactTime(long contactId, long lastTimeContacted) {
+        mLastTimeContactedUpdate.bindLong(1, lastTimeContacted);
+        mLastTimeContactedUpdate.bindLong(2, contactId);
+        mLastTimeContactedUpdate.execute();
+    }
+
+    private static class RawContactPair {
+        final long rawContactId1;
+        final long rawContactId2;
+
+        /**
+         * Constructor that ensures that this.rawContactId1 &lt; this.rawContactId2
+         */
+        public RawContactPair(long rawContactId1, long rawContactId2) {
+            if (rawContactId1 < rawContactId2) {
+                this.rawContactId1 = rawContactId1;
+                this.rawContactId2 = rawContactId2;
+            } else {
+                this.rawContactId2 = rawContactId1;
+                this.rawContactId1 = rawContactId2;
+            }
+        }
+    }
+
+    private int updateAggregationException(SQLiteDatabase db, ContentValues values) {
+        int exceptionType = values.getAsInteger(AggregationExceptions.TYPE);
+        long contactId = values.getAsInteger(AggregationExceptions.CONTACT_ID);
+        long rawContactId = values.getAsInteger(AggregationExceptions.RAW_CONTACT_ID);
+
+        // First, we build a list of contactID-contactID pairs for the given contact and contact.
+        ArrayList<RawContactPair> pairs = new ArrayList<RawContactPair>();
+        Cursor c = db.query(ContactsQuery.TABLE, ContactsQuery.PROJECTION, RawContacts.CONTACT_ID
+                + "=" + contactId, null, null, null, null);
+        try {
+            while (c.moveToNext()) {
+                long aggregatedContactId = c.getLong(ContactsQuery.RAW_CONTACT_ID);
+                if (aggregatedContactId != rawContactId) {
+                    pairs.add(new RawContactPair(aggregatedContactId, rawContactId));
+                }
+            }
+        } finally {
+            c.close();
+        }
+
+        // Now we iterate through all contact pairs to see if we need to insert/delete/update
+        // the corresponding exception
+        ContentValues exceptionValues = new ContentValues(3);
+        exceptionValues.put(AggregationExceptions.TYPE, exceptionType);
+        for (RawContactPair pair : pairs) {
+            final String whereClause =
+                    AggregationExceptionColumns.RAW_CONTACT_ID1 + "=" + pair.rawContactId1 + " AND "
+                    + AggregationExceptionColumns.RAW_CONTACT_ID2 + "=" + pair.rawContactId2;
+            if (exceptionType == AggregationExceptions.TYPE_AUTOMATIC) {
+                db.delete(Tables.AGGREGATION_EXCEPTIONS, whereClause, null);
+            } else {
+                exceptionValues.put(AggregationExceptionColumns.RAW_CONTACT_ID1, pair.rawContactId1);
+                exceptionValues.put(AggregationExceptionColumns.RAW_CONTACT_ID2, pair.rawContactId2);
+                db.replace(Tables.AGGREGATION_EXCEPTIONS, AggregationExceptions._ID,
+                        exceptionValues);
+            }
+        }
+
+        int aggregationMode = mContactAggregator.markContactForAggregation(rawContactId);
+        if (aggregationMode != RawContacts.AGGREGATION_MODE_DISABLED) {
+            mContactAggregator.aggregateContact(db, rawContactId);
+            if (exceptionType == AggregationExceptions.TYPE_AUTOMATIC
+                    || exceptionType == AggregationExceptions.TYPE_KEEP_OUT) {
+                mContactAggregator.updateAggregateData(contactId);
+            }
+        }
+
+        // The return value is fake - we just confirm that we made a change, not count actual
+        // rows changed.
+        return 1;
+    }
+
+    /**
+     * Test if a {@link String} value appears in the given list.
+     */
+    private boolean isContained(String[] array, String value) {
+        if (array != null) {
+            for (String test : array) {
+                if (value.equals(test)) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+
+    /**
+     * Test if a {@link String} value appears in the given list, and add to the
+     * array if the value doesn't already appear.
+     */
+    private String[] assertContained(String[] array, String value) {
+        if (array == null) {
+            array = new String[] {value};
+        } else if (!isContained(array, value)) {
+            String[] newArray = new String[array.length + 1];
+            System.arraycopy(array, 0, newArray, 0, array.length);
+            newArray[array.length] = value;
+            array = newArray;
+        }
+        return array;
+    }
+
+    @Override
+    public Cursor query(Uri uri, String[] projection, String selection, String[] selectionArgs,
+            String sortOrder) {
+        final SQLiteDatabase db = mOpenHelper.getReadableDatabase();
+
+        SQLiteQueryBuilder qb = new SQLiteQueryBuilder();
+        String groupBy = null;
+        String limit = getLimit(uri);
+
+        String contactIdColName = Tables.CONTACTS + "." + Contacts._ID;
+
+        // TODO: Consider writing a test case for RestrictionExceptions when you
+        // write a new query() block to make sure it protects restricted data.
+        final int match = sUriMatcher.match(uri);
+        switch (match) {
+            case SYNCSTATE:
+                return mOpenHelper.getSyncState().query(db, projection, selection,  selectionArgs,
+                        sortOrder);
+
+            case CONTACTS: {
+                qb.setTables(Tables.CONTACTS);
+                applyAggregateRestrictionExceptions(qb);
+                applyAggregatePrimaryRestrictionExceptions(sContactsProjectionMap);
+                qb.setProjectionMap(sContactsProjectionMap);
+                break;
+            }
+
+            case CONTACTS_ID: {
+                long aggId = ContentUris.parseId(uri);
+                qb.setTables(Tables.CONTACTS);
+                qb.appendWhere(ContactsColumns.CONCRETE_ID + "=" + aggId + " AND ");
+                applyAggregateRestrictionExceptions(qb);
+                applyAggregatePrimaryRestrictionExceptions(sContactsProjectionMap);
+                qb.setProjectionMap(sContactsProjectionMap);
+                break;
+            }
+
+            case CONTACTS_SUMMARY: {
+                // TODO: join into social status tables
+                qb.setTables(Tables.CONTACTS_JOIN_PRESENCE_PRIMARY_PHONE);
+                applyAggregateRestrictionExceptions(qb);
+                applyAggregatePrimaryRestrictionExceptions(sContactsSummaryProjectionMap);
+                projection = assertContained(projection, Contacts.PRIMARY_PHONE_ID);
+                qb.setProjectionMap(sContactsSummaryProjectionMap);
+                groupBy = contactIdColName;
+                break;
+            }
+
+            case CONTACTS_SUMMARY_ID: {
+                // TODO: join into social status tables
+                long aggId = ContentUris.parseId(uri);
+                qb.setTables(Tables.CONTACTS_JOIN_PRESENCE_PRIMARY_PHONE);
+                qb.appendWhere(ContactsColumns.CONCRETE_ID + "=" + aggId + " AND ");
+                applyAggregateRestrictionExceptions(qb);
+                applyAggregatePrimaryRestrictionExceptions(sContactsSummaryProjectionMap);
+                projection = assertContained(projection, Contacts.PRIMARY_PHONE_ID);
+                qb.setProjectionMap(sContactsSummaryProjectionMap);
+                groupBy = contactIdColName;
+                break;
+            }
+
+            case CONTACTS_SUMMARY_FILTER: {
+                // TODO: filter query based on callingUid
+                qb.setTables(Tables.CONTACTS_JOIN_PRESENCE_PRIMARY_PHONE);
+                qb.setProjectionMap(sContactsSummaryProjectionMap);
+                if (uri.getPathSegments().size() > 2) {
+                    qb.appendWhere(buildContactLookupWhereClause(uri.getLastPathSegment()));
+                }
+                groupBy = contactIdColName;
+                break;
+            }
+
+            case CONTACTS_SUMMARY_STREQUENT_FILTER:
+            case CONTACTS_SUMMARY_STREQUENT: {
+                // Build the first query for starred
+                qb.setTables(Tables.CONTACTS_JOIN_PRESENCE_PRIMARY_PHONE);
+                qb.setProjectionMap(sContactsSummaryProjectionMap);
+                if (match == CONTACTS_SUMMARY_STREQUENT_FILTER
+                        && uri.getPathSegments().size() > 3) {
+                    qb.appendWhere(buildContactLookupWhereClause(uri.getLastPathSegment()));
+                }
+                final String starredQuery = qb.buildQuery(projection, Contacts.STARRED + "=1",
+                        null, contactIdColName, null, null,
+                        null /* limit */);
+
+                // Build the second query for frequent
+                qb = new SQLiteQueryBuilder();
+                qb.setTables(Tables.CONTACTS_JOIN_PRESENCE_PRIMARY_PHONE);
+                qb.setProjectionMap(sContactsSummaryProjectionMap);
+                if (match == CONTACTS_SUMMARY_STREQUENT_FILTER
+                        && uri.getPathSegments().size() > 3) {
+                    qb.appendWhere(buildContactLookupWhereClause(uri.getLastPathSegment()));
+                }
+                final String frequentQuery = qb.buildQuery(projection,
+                        Contacts.TIMES_CONTACTED + " > 0 AND (" + Contacts.STARRED
+                        + " = 0 OR " + Contacts.STARRED + " IS NULL)",
+                        null, contactIdColName, null, null, null);
+
+                // Put them together
+                final String query = qb.buildUnionQuery(new String[] {starredQuery, frequentQuery},
+                        STREQUENT_ORDER_BY, STREQUENT_LIMIT);
+                Cursor c = db.rawQueryWithFactory(null, query, null,
+                        Tables.CONTACTS_JOIN_PRESENCE_PRIMARY_PHONE);
+
+                if ((c != null) && !isTemporary()) {
+                    c.setNotificationUri(getContext().getContentResolver(),
+                            ContactsContract.AUTHORITY_URI);
+                }
+                return c;
+            }
+
+            case CONTACTS_SUMMARY_GROUP: {
+                qb.setTables(Tables.CONTACTS_JOIN_PRESENCE_PRIMARY_PHONE);
+                applyAggregateRestrictionExceptions(qb);
+                applyAggregatePrimaryRestrictionExceptions(sContactsSummaryProjectionMap);
+                projection = assertContained(projection, Contacts.PRIMARY_PHONE_ID);
+                qb.setProjectionMap(sContactsSummaryProjectionMap);
+                if (uri.getPathSegments().size() > 2) {
+                    qb.appendWhere(" AND " + sContactsInGroupSelect);
+                    selectionArgs = appendGroupArg(selectionArgs, uri.getLastPathSegment());
+                }
+                groupBy = contactIdColName;
+                break;
+            }
+
+            case CONTACTS_DATA: {
+                long aggId = Long.parseLong(uri.getPathSegments().get(1));
+                qb.setTables(Tables.DATA_JOIN_PACKAGES_MIMETYPES_RAW_CONTACTS_CONTACTS_GROUPS);
+                qb.setProjectionMap(sDataRawContactsGroupsContactProjectionMap);
+                qb.appendWhere(RawContacts.CONTACT_ID + "=" + aggId + " AND ");
+                applyDataRestrictionExceptions(qb);
+                break;
+            }
+
+            case CONTACTS_RAW_CONTACTS: {
+                long contactId = Long.parseLong(uri.getPathSegments().get(1));
+                qb.setTables(Tables.RAW_CONTACTS_JOIN_CONTACTS);
+                qb.setProjectionMap(sRawContactsContactsProjectionMap);
+                qb.appendWhere(RawContacts.CONTACT_ID + "=" + contactId + " AND ");
+                applyDataRestrictionExceptions(qb);
+                break;
+            }
+
+            case PHONES_FILTER: {
+                qb.setTables(Tables.DATA_JOIN_PACKAGES_MIMETYPES_RAW_CONTACTS_CONTACTS);
+                qb.setProjectionMap(sDataRawContactsContactProjectionMap);
+                qb.appendWhere(Data.MIMETYPE + " = '" + Phone.CONTENT_ITEM_TYPE + "'");
+                if (uri.getPathSegments().size() > 2) {
+                    qb.appendWhere(" AND " + buildContactLookupWhereClause(
+                            uri.getLastPathSegment()));
+                }
+                break;
+            }
+
+            case PHONES: {
+                qb.setTables(Tables.DATA_JOIN_PACKAGES_MIMETYPES_RAW_CONTACTS_CONTACTS);
+                qb.setProjectionMap(sDataRawContactsContactProjectionMap);
+                qb.appendWhere(Data.MIMETYPE + " = \"" + Phone.CONTENT_ITEM_TYPE + "\"");
+                break;
+            }
+
+            case POSTALS: {
+                qb.setTables(Tables.DATA_JOIN_PACKAGES_MIMETYPES_RAW_CONTACTS_CONTACTS);
+                qb.setProjectionMap(sDataRawContactsContactProjectionMap);
+                qb.appendWhere(Data.MIMETYPE + " = \"" + StructuredPostal.CONTENT_ITEM_TYPE + "\"");
+                break;
+            }
+
+            case RAW_CONTACTS: {
+                qb.setTables(Tables.RAW_CONTACTS);
+                qb.setProjectionMap(sRawContactsProjectionMap);
+                applyContactsRestrictionExceptions(qb);
+                break;
+            }
+
+            case RAW_CONTACTS_ID: {
+                long rawContactId = ContentUris.parseId(uri);
+                qb.setTables(Tables.RAW_CONTACTS);
+                qb.setProjectionMap(sRawContactsProjectionMap);
+                qb.appendWhere(RawContactsColumns.CONCRETE_ID + "=" + rawContactId + " AND ");
+                applyContactsRestrictionExceptions(qb);
+                break;
+            }
+
+            case RAW_CONTACTS_DATA: {
+                long rawContactId = Long.parseLong(uri.getPathSegments().get(1));
+                qb.setTables(Tables.DATA_JOIN_PACKAGES_MIMETYPES_RAW_CONTACTS_GROUPS);
+                qb.setProjectionMap(sDataRawContactsGroupsProjectionMap);
+                qb.appendWhere(Data.RAW_CONTACT_ID + "=" + rawContactId + " AND ");
+                applyDataRestrictionExceptions(qb);
+                break;
+            }
+
+            case CONTACTS_FILTER_EMAIL: {
+                // TODO: filter query based on callingUid
+                qb.setTables(Tables.DATA_JOIN_PACKAGES_MIMETYPES_RAW_CONTACTS_CONTACTS);
+                qb.setProjectionMap(sDataRawContactsProjectionMap);
+                qb.appendWhere(Data.MIMETYPE + "='" + CommonDataKinds.Email.CONTENT_ITEM_TYPE + "'");
+                qb.appendWhere(" AND " + CommonDataKinds.Email.DATA + "=");
+                qb.appendWhereEscapeString(uri.getPathSegments().get(2));
+                break;
+            }
+
+            case DATA: {
+                final String accountName = uri.getQueryParameter(RawContacts.ACCOUNT_NAME);
+                final String accountType = uri.getQueryParameter(RawContacts.ACCOUNT_TYPE);
+                if (!TextUtils.isEmpty(accountName)) {
+                    qb.appendWhere(RawContactsColumns.CONCRETE_ACCOUNT_NAME + "="
+                            + DatabaseUtils.sqlEscapeString(accountName) + " AND "
+                            + RawContactsColumns.CONCRETE_ACCOUNT_TYPE + "="
+                            + DatabaseUtils.sqlEscapeString(accountType) + " AND ");
+                }
+                qb.setTables(Tables.DATA_JOIN_PACKAGES_MIMETYPES_RAW_CONTACTS_GROUPS);
+                qb.setProjectionMap(sDataGroupsProjectionMap);
+                applyDataRestrictionExceptions(qb);
+                break;
+            }
+
+            case DATA_ID: {
+                qb.setTables(Tables.DATA_JOIN_PACKAGES_MIMETYPES_RAW_CONTACTS_GROUPS);
+                qb.setProjectionMap(sDataGroupsProjectionMap);
+                qb.appendWhere(DataColumns.CONCRETE_ID + "=" + ContentUris.parseId(uri) + " AND ");
+                applyDataRestrictionExceptions(qb);
+                break;
+            }
+
+            case PHONE_LOOKUP: {
+                // TODO: filter query based on callingUid
+                if (TextUtils.isEmpty(sortOrder)) {
+                    // Default the sort order to something reasonable so we get consistent
+                    // results when callers don't request an ordering
+                    sortOrder = Data.RAW_CONTACT_ID;
+                }
+
+                final String number = uri.getLastPathSegment();
+                OpenHelper.buildPhoneLookupQuery(qb, number);
+                qb.setProjectionMap(sDataRawContactsProjectionMap);
+                break;
+            }
+
+            case GROUPS: {
+                qb.setTables(Tables.GROUPS_JOIN_PACKAGES);
+                qb.setProjectionMap(sGroupsProjectionMap);
+                break;
+            }
+
+            case GROUPS_ID: {
+                long groupId = ContentUris.parseId(uri);
+                qb.setTables(Tables.GROUPS_JOIN_PACKAGES);
+                qb.setProjectionMap(sGroupsProjectionMap);
+                qb.appendWhere(GroupsColumns.CONCRETE_ID + "=" + groupId);
+                break;
+            }
+
+            case GROUPS_SUMMARY: {
+                qb.setTables(Tables.GROUPS_JOIN_PACKAGES_DATA_RAW_CONTACTS_CONTACTS);
+                qb.setProjectionMap(sGroupsSummaryProjectionMap);
+                groupBy = GroupsColumns.CONCRETE_ID;
+                break;
+            }
+
+            case AGGREGATION_EXCEPTIONS: {
+                qb.setTables(Tables.AGGREGATION_EXCEPTIONS_JOIN_RAW_CONTACTS);
+                qb.setProjectionMap(sAggregationExceptionsProjectionMap);
+                break;
+            }
+
+            case AGGREGATION_SUGGESTIONS: {
+                long contactId = Long.parseLong(uri.getPathSegments().get(1));
+
+                // TODO drop MAX_SUGGESTIONS in favor of LIMIT
+                final String maxSuggestionsParam =
+                        uri.getQueryParameter(AggregationSuggestions.MAX_SUGGESTIONS);
+
+                final int maxSuggestions;
+                if (maxSuggestionsParam != null) {
+                    maxSuggestions = Integer.parseInt(maxSuggestionsParam);
+                } else {
+                    maxSuggestions = DEFAULT_MAX_SUGGESTIONS;
+                }
+
+                return mContactAggregator.queryAggregationSuggestions(contactId, projection,
+                        sContactsProjectionMap, maxSuggestions);
+            }
+
+            case PRESENCE: {
+                qb.setTables(Tables.PRESENCE);
+                qb.setProjectionMap(sPresenceProjectionMap);
+                break;
+            }
+
+            case PRESENCE_ID: {
+                qb.setTables(Tables.PRESENCE);
+                qb.setProjectionMap(sPresenceProjectionMap);
+                qb.appendWhere(Presence._ID + "=" + ContentUris.parseId(uri));
+                break;
+            }
+
+            case SEARCH_SUGGESTIONS: {
+                return mGlobalSearchSupport.handleSearchSuggestionsQuery(db, uri, limit);
+            }
+
+            case SEARCH_SHORTCUT: {
+                // TODO
+                break;
+            }
+
+            default:
+                return mLegacyApiSupport.query(uri, projection, selection, selectionArgs,
+                        sortOrder, limit);
+        }
+
+        // Perform the query and set the notification uri
+        final Cursor c = qb.query(db, projection, selection, selectionArgs,
+                groupBy, null, sortOrder, limit);
+        if (c != null) {
+            c.setNotificationUri(getContext().getContentResolver(), ContactsContract.AUTHORITY_URI);
+        }
+        return c;
+    }
+
+    /**
+     * Gets the value of the "limit" URI query parameter.
+     *
+     * @return A string containing a non-negative integer, or <code>null</code> if
+     *         the parameter is not set, or is set to an invalid value.
+     */
+    private String getLimit(Uri url) {
+        String limitParam = url.getQueryParameter("limit");
+        if (limitParam == null) {
+            return null;
+        }
+        // make sure that the limit is a non-negative integer
+        try {
+            int l = Integer.parseInt(limitParam);
+            if (l < 0) {
+                Log.w(TAG, "Invalid limit parameter: " + limitParam);
+                return null;
+            }
+            return String.valueOf(l);
+        } catch (NumberFormatException ex) {
+            Log.w(TAG, "Invalid limit parameter: " + limitParam);
+            return null;
+        }
+    }
+
+    /**
+     * List of package names with access to {@link RawContacts#IS_RESTRICTED} data.
+     */
+    private static final String[] sAllowedPackages = new String[] {
+        "com.android.contacts",
+        "com.facebook",
+    };
+
+    /**
+     * Check if {@link Binder#getCallingUid()} should be allowed access to
+     * {@link RawContacts#IS_RESTRICTED} data.
+     */
+    private boolean hasRestrictedAccess() {
+        final PackageManager pm = getContext().getPackageManager();
+        final String[] callerPackages = pm.getPackagesForUid(Binder.getCallingUid());
+
+        // Has restricted access if caller matches any packages
+        for (String callerPackage : callerPackages) {
+            for (String allowedPackage : sAllowedPackages) {
+                if (allowedPackage.equals(callerPackage)) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+
+    /**
+     * Restrict selection of {@link Contacts} to only public ones, or those
+     * the caller has been granted an exception to.
+     */
+    private void applyAggregateRestrictionExceptions(SQLiteQueryBuilder qb) {
+        if (hasRestrictedAccess()) {
+            qb.appendWhere("1");
+        } else {
+            qb.appendWhere(ContactsColumns.SINGLE_IS_RESTRICTED + "=0");
+        }
+    }
+
+    /**
+     * Find any exceptions that have been granted to the calling process, and
+     * add projections to correctly select {@link Contacts#PRIMARY_PHONE_ID}
+     * and {@link Contacts#PRIMARY_EMAIL_ID}.
+     */
+    private void applyAggregatePrimaryRestrictionExceptions(HashMap<String, String> projection) {
+        String projectionPhone;
+        String projectionEmail;
+
+        if (hasRestrictedAccess()) {
+            // With restricted access, always give optimal values
+            projectionPhone = ContactsColumns.OPTIMAL_PRIMARY_PHONE_ID + " AS "
+                    + Contacts.PRIMARY_PHONE_ID;
+            projectionEmail = ContactsColumns.OPTIMAL_PRIMARY_EMAIL_ID + " AS "
+                    + Contacts.PRIMARY_EMAIL_ID;
+        } else {
+            // With general access, always give fallback values
+            projectionPhone = ContactsColumns.FALLBACK_PRIMARY_PHONE_ID + " AS "
+                    + Contacts.PRIMARY_PHONE_ID;
+            projectionEmail = ContactsColumns.FALLBACK_PRIMARY_EMAIL_ID + " AS "
+                    + Contacts.PRIMARY_EMAIL_ID;
+        }
+
+        projection.remove(Contacts.PRIMARY_PHONE_ID);
+        projection.put(Contacts.PRIMARY_PHONE_ID, projectionPhone);
+
+        projection.remove(Contacts.PRIMARY_EMAIL_ID);
+        projection.put(Contacts.PRIMARY_EMAIL_ID, projectionEmail);
+    }
+
+    /**
+     * Find any exceptions that have been granted to the
+     * {@link Binder#getCallingUid()}, and add a limiting clause to the given
+     * {@link SQLiteQueryBuilder} to hide restricted data.
+     */
+    private void applyContactsRestrictionExceptions(SQLiteQueryBuilder qb) {
+        qb.appendWhere(getContactsRestrictionExceptions());
+    }
+
+    String getContactsRestrictionExceptions() {
+        if (hasRestrictedAccess()) {
+            return "1";
+        } else {
+            return RawContacts.IS_RESTRICTED + "=0";
+        }
+    }
+
+    public String getContactsRestrictionExceptionAsNestedQuery(String contactIdColumn) {
+        if (hasRestrictedAccess()) {
+            return "1";
+        } else {
+            return "(SELECT " + RawContacts.IS_RESTRICTED + " FROM " + Tables.RAW_CONTACTS
+                    + " WHERE " + RawContactsColumns.CONCRETE_ID + "=" + contactIdColumn + ")=0";
+        }
+    }
+
+    /**
+     * Find any exceptions that have been granted to the
+     * {@link Binder#getCallingUid()}, and add a limiting clause to the given
+     * {@link SQLiteQueryBuilder} to hide restricted data.
+     */
+    void applyDataRestrictionExceptions(SQLiteQueryBuilder qb) {
+        applyContactsRestrictionExceptions(qb);
+    }
+
+    /**
+     * An implementation of EntityIterator that joins the contacts and data tables
+     * and consumes all the data rows for a contact in order to build the Entity for a contact.
+     */
+    private static class ContactsEntityIterator implements EntityIterator {
+        private final Cursor mEntityCursor;
+        private volatile boolean mIsClosed;
+
+        private static final String[] DATA_KEYS = new String[]{
+                "data1",
+                "data2",
+                "data3",
+                "data4",
+                "data5",
+                "data6",
+                "data7",
+                "data8",
+                "data9",
+                "data10",
+                "data11",
+                "data12",
+                "data13",
+                "data14",
+                "data15"};
+
+        private static final String[] PROJECTION = new String[]{
+                RawContacts.ACCOUNT_NAME,
+                RawContacts.ACCOUNT_TYPE,
+                RawContacts.SOURCE_ID,
+                RawContacts.VERSION,
+                RawContacts.DIRTY,
+                RawContacts.Data._ID,
+                RawContacts.Data.RES_PACKAGE,
+                RawContacts.Data.MIMETYPE,
+                RawContacts.Data.DATA1,
+                RawContacts.Data.DATA2,
+                RawContacts.Data.DATA3,
+                RawContacts.Data.DATA4,
+                RawContacts.Data.DATA5,
+                RawContacts.Data.DATA6,
+                RawContacts.Data.DATA7,
+                RawContacts.Data.DATA8,
+                RawContacts.Data.DATA9,
+                RawContacts.Data.DATA10,
+                RawContacts.Data.DATA11,
+                RawContacts.Data.DATA12,
+                RawContacts.Data.DATA13,
+                RawContacts.Data.DATA14,
+                RawContacts.Data.DATA15,
+                RawContacts.Data.RAW_CONTACT_ID,
+                RawContacts.Data.IS_PRIMARY,
+                RawContacts.Data.DATA_VERSION,
+                GroupMembership.GROUP_SOURCE_ID};
+
+        private static final int COLUMN_ACCOUNT_NAME = 0;
+        private static final int COLUMN_ACCOUNT_TYPE = 1;
+        private static final int COLUMN_SOURCE_ID = 2;
+        private static final int COLUMN_VERSION = 3;
+        private static final int COLUMN_DIRTY = 4;
+        private static final int COLUMN_DATA_ID = 5;
+        private static final int COLUMN_RES_PACKAGE = 6;
+        private static final int COLUMN_MIMETYPE = 7;
+        private static final int COLUMN_DATA1 = 8;
+        private static final int COLUMN_CONTACT_ID = 23;
+        private static final int COLUMN_IS_PRIMARY = 24;
+        private static final int COLUMN_DATA_VERSION = 25;
+        private static final int COLUMN_GROUP_SOURCE_ID = 26;
+
+        public ContactsEntityIterator(ContactsProvider2 provider, String contactsIdString, Uri uri,
+                String selection, String[] selectionArgs, String sortOrder) {
+            mIsClosed = false;
+
+            final String updatedSortOrder = (sortOrder == null)
+                    ? RawContacts.Data.RAW_CONTACT_ID
+                    : (RawContacts.Data.RAW_CONTACT_ID + "," + sortOrder);
+
+            final SQLiteDatabase db = provider.mOpenHelper.getReadableDatabase();
+            final SQLiteQueryBuilder qb = new SQLiteQueryBuilder();
+            qb.setTables(Tables.CONTACT_ENTITIES);
+            if (contactsIdString != null) {
+                qb.appendWhere(Data.RAW_CONTACT_ID + "=" + contactsIdString);
+            }
+            final String accountName = uri.getQueryParameter(RawContacts.ACCOUNT_NAME);
+            final String accountType = uri.getQueryParameter(RawContacts.ACCOUNT_TYPE);
+            if (!TextUtils.isEmpty(accountName)) {
+                qb.appendWhere(RawContacts.ACCOUNT_NAME + "="
+                        + DatabaseUtils.sqlEscapeString(accountName) + " AND "
+                        + RawContacts.ACCOUNT_TYPE + "="
+                        + DatabaseUtils.sqlEscapeString(accountType));
+            }
+            mEntityCursor = qb.query(db, PROJECTION, selection, selectionArgs,
+                    null, null, updatedSortOrder);
+            mEntityCursor.moveToFirst();
+        }
+
+        public void close() {
+            if (mIsClosed) {
+                throw new IllegalStateException("closing when already closed");
+            }
+            mIsClosed = true;
+            mEntityCursor.close();
+        }
+
+        public boolean hasNext() throws RemoteException {
+            if (mIsClosed) {
+                throw new IllegalStateException("calling hasNext() when the iterator is closed");
+            }
+
+            return !mEntityCursor.isAfterLast();
+        }
+
+        public Entity next() throws RemoteException {
+            if (mIsClosed) {
+                throw new IllegalStateException("calling next() when the iterator is closed");
+            }
+            if (!hasNext()) {
+                throw new IllegalStateException("you may only call next() if hasNext() is true");
+            }
+
+            final SQLiteCursor c = (SQLiteCursor) mEntityCursor;
+
+            final long rawContactId = c.getLong(COLUMN_CONTACT_ID);
+
+            // we expect the cursor is already at the row we need to read from
+            ContentValues contactValues = new ContentValues();
+            contactValues.put(RawContacts.ACCOUNT_NAME, c.getString(COLUMN_ACCOUNT_NAME));
+            contactValues.put(RawContacts.ACCOUNT_TYPE, c.getString(COLUMN_ACCOUNT_TYPE));
+            contactValues.put(RawContacts._ID, rawContactId);
+            contactValues.put(RawContacts.DIRTY, c.getLong(COLUMN_DIRTY));
+            contactValues.put(RawContacts.VERSION, c.getLong(COLUMN_VERSION));
+            contactValues.put(RawContacts.SOURCE_ID, c.getString(COLUMN_SOURCE_ID));
+            Entity contact = new Entity(contactValues);
+
+            // read data rows until the contact id changes
+            do {
+                if (rawContactId != c.getLong(COLUMN_CONTACT_ID)) {
+                    break;
+                }
+                // add the data to to the contact
+                ContentValues dataValues = new ContentValues();
+                dataValues.put(RawContacts.Data._ID, c.getString(COLUMN_DATA_ID));
+                dataValues.put(RawContacts.Data.RES_PACKAGE, c.getString(COLUMN_RES_PACKAGE));
+                dataValues.put(RawContacts.Data.MIMETYPE, c.getString(COLUMN_MIMETYPE));
+                dataValues.put(RawContacts.Data.IS_PRIMARY, c.getString(COLUMN_IS_PRIMARY));
+                dataValues.put(RawContacts.Data.DATA_VERSION, c.getLong(COLUMN_DATA_VERSION));
+                if (!c.isNull(COLUMN_GROUP_SOURCE_ID)) {
+                    dataValues.put(GroupMembership.GROUP_SOURCE_ID,
+                            c.getString(COLUMN_GROUP_SOURCE_ID));
+                }
+                dataValues.put(RawContacts.Data.DATA_VERSION, c.getLong(COLUMN_DATA_VERSION));
+                for (int i = 0; i < 10; i++) {
+                    final int columnIndex = i + COLUMN_DATA1;
+                    String key = DATA_KEYS[i];
+                    if (c.isNull(columnIndex)) {
+                        // don't put anything
+                    } else if (c.isLong(columnIndex)) {
+                        dataValues.put(key, c.getLong(columnIndex));
+                    } else if (c.isFloat(columnIndex)) {
+                        dataValues.put(key, c.getFloat(columnIndex));
+                    } else if (c.isString(columnIndex)) {
+                        dataValues.put(key, c.getString(columnIndex));
+                    } else if (c.isBlob(columnIndex)) {
+                        dataValues.put(key, c.getBlob(columnIndex));
+                    }
+                }
+                contact.addSubValue(Data.CONTENT_URI, dataValues);
+            } while (mEntityCursor.moveToNext());
+
+            return contact;
+        }
+    }
+
+    /**
+     * An implementation of EntityIterator that joins the contacts and data tables
+     * and consumes all the data rows for a contact in order to build the Entity for a contact.
+     */
+    private static class GroupsEntityIterator implements EntityIterator {
+        private final Cursor mEntityCursor;
+        private volatile boolean mIsClosed;
+
+        private static final String[] PROJECTION = new String[]{
+                Groups._ID,
+                Groups.ACCOUNT_NAME,
+                Groups.ACCOUNT_TYPE,
+                Groups.SOURCE_ID,
+                Groups.DIRTY,
+                Groups.VERSION,
+                Groups.RES_PACKAGE,
+                Groups.TITLE,
+                Groups.TITLE_RES,
+                Groups.GROUP_VISIBLE};
+
+        private static final int COLUMN_ID = 0;
+        private static final int COLUMN_ACCOUNT_NAME = 1;
+        private static final int COLUMN_ACCOUNT_TYPE = 2;
+        private static final int COLUMN_SOURCE_ID = 3;
+        private static final int COLUMN_DIRTY = 4;
+        private static final int COLUMN_VERSION = 5;
+        private static final int COLUMN_RES_PACKAGE = 6;
+        private static final int COLUMN_TITLE = 7;
+        private static final int COLUMN_TITLE_RES = 8;
+        private static final int COLUMN_GROUP_VISIBLE = 9;
+
+        public GroupsEntityIterator(ContactsProvider2 provider, String groupIdString, Uri uri,
+                String selection, String[] selectionArgs, String sortOrder) {
+            mIsClosed = false;
+
+            final String updatedSortOrder = (sortOrder == null)
+                    ? Groups._ID
+                    : (Groups._ID + "," + sortOrder);
+
+            final SQLiteDatabase db = provider.mOpenHelper.getReadableDatabase();
+            final SQLiteQueryBuilder qb = new SQLiteQueryBuilder();
+            qb.setTables(Tables.GROUPS_JOIN_PACKAGES);
+            qb.setProjectionMap(sGroupsProjectionMap);
+            if (groupIdString != null) {
+                qb.appendWhere(Groups._ID + "=" + groupIdString);
+            }
+            final String accountName = uri.getQueryParameter(Groups.ACCOUNT_NAME);
+            final String accountType = uri.getQueryParameter(Groups.ACCOUNT_TYPE);
+            if (!TextUtils.isEmpty(accountName)) {
+                qb.appendWhere(Groups.ACCOUNT_NAME + "="
+                        + DatabaseUtils.sqlEscapeString(accountName) + " AND "
+                        + Groups.ACCOUNT_TYPE + "="
+                        + DatabaseUtils.sqlEscapeString(accountType));
+            }
+            mEntityCursor = qb.query(db, PROJECTION, selection, selectionArgs,
+                    null, null, updatedSortOrder);
+            mEntityCursor.moveToFirst();
+        }
+
+        public void close() {
+            if (mIsClosed) {
+                throw new IllegalStateException("closing when already closed");
+            }
+            mIsClosed = true;
+            mEntityCursor.close();
+        }
+
+        public boolean hasNext() throws RemoteException {
+            if (mIsClosed) {
+                throw new IllegalStateException("calling hasNext() when the iterator is closed");
+            }
+
+            return !mEntityCursor.isAfterLast();
+        }
+
+        public Entity next() throws RemoteException {
+            if (mIsClosed) {
+                throw new IllegalStateException("calling next() when the iterator is closed");
+            }
+            if (!hasNext()) {
+                throw new IllegalStateException("you may only call next() if hasNext() is true");
+            }
+
+            final SQLiteCursor c = (SQLiteCursor) mEntityCursor;
+
+            final long groupId = c.getLong(COLUMN_ID);
+
+            // we expect the cursor is already at the row we need to read from
+            ContentValues groupValues = new ContentValues();
+            groupValues.put(Groups.ACCOUNT_NAME, c.getString(COLUMN_ACCOUNT_NAME));
+            groupValues.put(Groups.ACCOUNT_TYPE, c.getString(COLUMN_ACCOUNT_TYPE));
+            groupValues.put(Groups._ID, groupId);
+            groupValues.put(Groups.DIRTY, c.getLong(COLUMN_DIRTY));
+            groupValues.put(Groups.VERSION, c.getLong(COLUMN_VERSION));
+            groupValues.put(Groups.SOURCE_ID, c.getString(COLUMN_SOURCE_ID));
+            groupValues.put(Groups.RES_PACKAGE, c.getString(COLUMN_RES_PACKAGE));
+            groupValues.put(Groups.TITLE, c.getString(COLUMN_TITLE));
+            groupValues.put(Groups.TITLE_RES, c.getString(COLUMN_TITLE_RES));
+            groupValues.put(Groups.GROUP_VISIBLE, c.getLong(COLUMN_GROUP_VISIBLE));
+            Entity group = new Entity(groupValues);
+
+            mEntityCursor.moveToNext();
+
+            return group;
+        }
+    }
+
+    @Override
+    public EntityIterator queryEntities(Uri uri, String selection, String[] selectionArgs,
+            String sortOrder) {
+        final int match = sUriMatcher.match(uri);
+        switch (match) {
+            case RAW_CONTACTS:
+            case RAW_CONTACTS_ID:
+                String contactsIdString = null;
+                if (match == RAW_CONTACTS_ID) {
+                    contactsIdString = uri.getPathSegments().get(1);
+                }
+
+                return new ContactsEntityIterator(this, contactsIdString,
+                        uri, selection, selectionArgs, sortOrder);
+            case GROUPS:
+            case GROUPS_ID:
+                String idString = null;
+                if (match == GROUPS_ID) {
+                    idString = uri.getPathSegments().get(1);
+                }
+
+                return new GroupsEntityIterator(this, idString,
+                        uri, selection, selectionArgs, sortOrder);
+            default:
+                throw new UnsupportedOperationException("Unknown uri: " + uri);
+        }
+    }
+
+    @Override
+    public String getType(Uri uri) {
+        final int match = sUriMatcher.match(uri);
+        switch (match) {
+            case CONTACTS: return Contacts.CONTENT_TYPE;
+            case CONTACTS_ID: return Contacts.CONTENT_ITEM_TYPE;
+            case RAW_CONTACTS: return RawContacts.CONTENT_TYPE;
+            case RAW_CONTACTS_ID: return RawContacts.CONTENT_ITEM_TYPE;
+            case DATA_ID:
+                final SQLiteDatabase db = mOpenHelper.getReadableDatabase();
+                long dataId = ContentUris.parseId(uri);
+                return mOpenHelper.getDataMimeType(dataId);
+            case AGGREGATION_EXCEPTIONS: return AggregationExceptions.CONTENT_TYPE;
+            case AGGREGATION_EXCEPTION_ID: return AggregationExceptions.CONTENT_ITEM_TYPE;
+            case AGGREGATION_SUGGESTIONS: return Contacts.CONTENT_TYPE;
+            case SEARCH_SUGGESTIONS:
+                return SearchManager.SUGGEST_MIME_TYPE;
+            case SEARCH_SHORTCUT:
+                return SearchManager.SHORTCUT_MIME_TYPE;
+        }
+        throw new UnsupportedOperationException("Unknown uri: " + uri);
+    }
+
+    @Override
+    public ContentProviderResult[] applyBatch(ArrayList<ContentProviderOperation> operations)
+            throws OperationApplicationException {
+
+        final SQLiteDatabase db = mOpenHelper.getWritableDatabase();
+        db.beginTransaction();
+        try {
+            ContentProviderResult[] results = super.applyBatch(operations);
+            db.setTransactionSuccessful();
+            return results;
+        } finally {
+            db.endTransaction();
+        }
+    }
+
+    private void setDisplayName(long rawContactId, String displayName) {
+        if (displayName != null) {
+            mContactDisplayNameUpdate.bindString(1, displayName);
+        } else {
+            mContactDisplayNameUpdate.bindNull(1);
+        }
+        mContactDisplayNameUpdate.bindLong(2, rawContactId);
+        mContactDisplayNameUpdate.execute();
+    }
+
+    /*
+     * Sets the given dataId record in the "data" table to primary, and resets all data records of
+     * the same mimetype and under the same contact to not be primary.
+     *
+     * @param dataId the id of the data record to be set to primary.
+     */
+    private void setIsPrimary(long dataId) {
+        mSetPrimaryStatement.bindLong(1, dataId);
+        mSetPrimaryStatement.bindLong(2, dataId);
+        mSetPrimaryStatement.bindLong(3, dataId);
+        mSetPrimaryStatement.execute();
+    }
+
+    /*
+     * Sets the given dataId record in the "data" table to "super primary", and resets all data
+     * records of the same mimetype and under the same aggregate to not be "super primary".
+     *
+     * @param dataId the id of the data record to be set to primary.
+     */
+    private void setIsSuperPrimary(long dataId) {
+        mSetSuperPrimaryStatement.bindLong(1, dataId);
+        mSetSuperPrimaryStatement.bindLong(2, dataId);
+        mSetSuperPrimaryStatement.bindLong(3, dataId);
+        mSetSuperPrimaryStatement.execute();
+
+        // Find the parent aggregate and package for this new primary
+        final SQLiteDatabase db = mOpenHelper.getWritableDatabase();
+
+        long aggId = -1;
+        boolean isRestricted = false;
+        String mimeType = null;
+
+        Cursor cursor = null;
+        try {
+            cursor = db.query(DataRawContactsQuery.TABLE, DataRawContactsQuery.PROJECTION,
+                    DataColumns.CONCRETE_ID + "=" + dataId, null, null, null, null);
+            if (cursor.moveToFirst()) {
+                aggId = cursor.getLong(DataRawContactsQuery.CONTACT_ID);
+                isRestricted = (cursor.getInt(DataRawContactsQuery.IS_RESTRICTED) == 1);
+                mimeType = cursor.getString(DataRawContactsQuery.MIMETYPE);
+            }
+        } finally {
+            if (cursor != null) {
+                cursor.close();
+            }
+        }
+
+        // Bypass aggregate update if no parent found, or if we don't keep track
+        // of super-primary for this mimetype.
+        if (aggId == -1) {
+            return;
+        }
+
+        boolean isPhone = CommonDataKinds.Phone.CONTENT_ITEM_TYPE.equals(mimeType);
+        boolean isEmail = CommonDataKinds.Email.CONTENT_ITEM_TYPE.equals(mimeType);
+
+        // Record this value as the new primary for the parent aggregate
+        final ContentValues values = new ContentValues();
+        if (isPhone) {
+            values.put(ContactsColumns.OPTIMAL_PRIMARY_PHONE_ID, dataId);
+            values.put(ContactsColumns.OPTIMAL_PRIMARY_PHONE_IS_RESTRICTED, isRestricted);
+        } else if (isEmail) {
+            values.put(ContactsColumns.OPTIMAL_PRIMARY_EMAIL_ID, dataId);
+            values.put(ContactsColumns.OPTIMAL_PRIMARY_EMAIL_IS_RESTRICTED, isRestricted);
+        }
+
+        // If this data is unrestricted, then also set as fallback
+        if (!isRestricted && isPhone) {
+            values.put(ContactsColumns.FALLBACK_PRIMARY_PHONE_ID, dataId);
+        } else if (!isRestricted && isEmail) {
+            values.put(ContactsColumns.FALLBACK_PRIMARY_EMAIL_ID, dataId);
+        }
+
+        // Push update into contacts table, if needed
+        if (values.size() > 0) {
+            db.update(Tables.CONTACTS, values, Contacts._ID + "=" + aggId, null);
+        }
+    }
+
+    private String buildContactLookupWhereClause(String filterParam) {
+        StringBuilder filter = new StringBuilder();
+        filter.append(Tables.CONTACTS);
+        filter.append(".");
+        filter.append(Contacts._ID);
+        filter.append(" IN (SELECT ");
+        filter.append(RawContacts.CONTACT_ID);
+        filter.append(" FROM ");
+        filter.append(Tables.RAW_CONTACTS);
+        filter.append(" WHERE ");
+        filter.append(RawContacts._ID);
+        filter.append(" IN ");
+        appendRawContactsByFilterAsNestedQuery(filter, filterParam, null);
+        filter.append(")");
+        return filter.toString();
+    }
+
+    public String getRawContactsByFilterAsNestedQuery(String filterParam) {
+        StringBuilder sb = new StringBuilder();
+        appendRawContactsByFilterAsNestedQuery(sb, filterParam, null);
+        return sb.toString();
+    }
+
+    public void appendRawContactsByFilterAsNestedQuery(StringBuilder sb, String filterParam,
+            String limit) {
+        sb.append("(SELECT DISTINCT raw_contact_id FROM name_lookup WHERE normalized_name GLOB '");
+        sb.append(NameNormalizer.normalize(filterParam));
+        sb.append("*'");
+        if (limit != null) {
+            sb.append(" LIMIT ").append(limit);
+        }
+        sb.append(")");
+    }
+
+    private String[] appendGroupArg(String[] selectionArgs, String arg) {
+        if (selectionArgs == null) {
+            return new String[] {arg};
+        } else {
+            int newLength = selectionArgs.length + 1;
+            String[] newSelectionArgs = new String[newLength];
+            System.arraycopy(selectionArgs, 0, newSelectionArgs, 0, selectionArgs.length);
+            newSelectionArgs[newLength - 1] = arg;
+            return newSelectionArgs;
+        }
+    }
+}
diff --git a/src/com/android/providers/contacts/GlobalSearchSupport.java b/src/com/android/providers/contacts/GlobalSearchSupport.java
new file mode 100644
index 0000000..40e1089
--- /dev/null
+++ b/src/com/android/providers/contacts/GlobalSearchSupport.java
@@ -0,0 +1,327 @@
+/*
+ * 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.internal.database.ArrayListCursor;
+import com.android.providers.contacts.OpenHelper.ContactsColumns;
+import com.android.providers.contacts.OpenHelper.DataColumns;
+import com.android.providers.contacts.OpenHelper.MimetypesColumns;
+import com.android.providers.contacts.OpenHelper.RawContactsColumns;
+import com.android.providers.contacts.OpenHelper.Tables;
+
+import android.app.SearchManager;
+import android.content.ContentUris;
+import android.content.res.Resources;
+import android.database.Cursor;
+import android.database.sqlite.SQLiteDatabase;
+import android.net.Uri;
+import android.provider.Contacts.Intents;
+import android.provider.ContactsContract.Contacts;
+import android.provider.ContactsContract.Data;
+import android.provider.ContactsContract.Presence;
+import android.provider.ContactsContract.CommonDataKinds.Email;
+import android.provider.ContactsContract.CommonDataKinds.GroupMembership;
+import android.provider.ContactsContract.CommonDataKinds.Organization;
+import android.provider.ContactsContract.CommonDataKinds.Phone;
+import android.provider.ContactsContract.CommonDataKinds.Photo;
+import android.provider.ContactsContract.CommonDataKinds.StructuredName;
+import android.text.TextUtils;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.HashMap;
+
+/**
+ * Support for global search integration for Contacts.
+ */
+public class GlobalSearchSupport {
+
+    private static final String[] SEARCH_SUGGESTIONS_BASED_ON_PHONE_NUMBER_COLUMNS = {
+            "_id",
+            SearchManager.SUGGEST_COLUMN_TEXT_1,
+            SearchManager.SUGGEST_COLUMN_TEXT_2,
+            SearchManager.SUGGEST_COLUMN_ICON_1,
+            SearchManager.SUGGEST_COLUMN_INTENT_DATA,
+            SearchManager.SUGGEST_COLUMN_INTENT_ACTION,
+            SearchManager.SUGGEST_COLUMN_SHORTCUT_ID,
+    };
+
+    private static final String[] SEARCH_SUGGESTIONS_BASED_ON_NAME_COLUMNS = {
+            "_id",
+            SearchManager.SUGGEST_COLUMN_TEXT_1,
+            SearchManager.SUGGEST_COLUMN_TEXT_2,
+            SearchManager.SUGGEST_COLUMN_ICON_1,
+            SearchManager.SUGGEST_COLUMN_ICON_2,
+            SearchManager.SUGGEST_COLUMN_INTENT_DATA_ID,
+            SearchManager.SUGGEST_COLUMN_SHORTCUT_ID,
+    };
+
+    private interface SearchSuggestionQuery {
+        public static final String JOIN_RAW_CONTACTS =
+                " JOIN raw_contacts ON (data.raw_contact_id = raw_contacts._id) ";
+
+        public static final String JOIN_CONTACTS =
+                " JOIN contacts ON (raw_contacts.contact_id = contacts._id)";
+
+        public static final String JOIN_MIMETYPES =
+                " JOIN mimetypes ON (data.mimetype_id = mimetypes._id AND mimetypes.mimetype IN ('"
+                + StructuredName.CONTENT_ITEM_TYPE + "','" + Email.CONTENT_ITEM_TYPE + "','"
+                + Phone.CONTENT_ITEM_TYPE + "','" + Organization.CONTENT_ITEM_TYPE + "','"
+                + Photo.CONTENT_ITEM_TYPE + "','" + GroupMembership.CONTENT_ITEM_TYPE + "')) ";
+
+        public static final String TABLE = "data " + JOIN_RAW_CONTACTS + JOIN_MIMETYPES
+                + JOIN_CONTACTS;
+
+        public static final String PRESENCE_SQL = "(SELECT MAX(" + Presence.PRESENCE_STATUS
+                + ") FROM " + Tables.PRESENCE + " WHERE " + Tables.PRESENCE + "."
+                + Presence.RAW_CONTACT_ID + "=" + RawContactsColumns.CONCRETE_ID + ")";
+
+        public static final String[] COLUMNS = {
+            ContactsColumns.CONCRETE_ID + " AS " + Contacts._ID,
+            ContactsColumns.CONCRETE_DISPLAY_NAME + " AS " + Contacts.DISPLAY_NAME,
+            PRESENCE_SQL + " AS " + Contacts.PRESENCE_STATUS,
+            DataColumns.CONCRETE_ID + " AS data_id",
+            MimetypesColumns.MIMETYPE,
+            Data.IS_SUPER_PRIMARY,
+            Data.DATA2,
+        };
+
+        public static final int CONTACT_ID = 0;
+        public static final int DISPLAY_NAME = 1;
+        public static final int PRESENCE_STATUS = 2;
+        public static final int DATA_ID = 3;
+        public static final int MIMETYPE = 4;
+        public static final int IS_SUPER_PRIMARY = 5;
+        public static final int DATA2 = 6;
+    }
+
+    private static class SearchSuggestion {
+        String contactId;
+        boolean titleIsName;
+        String organization;
+        String email;
+        String phoneNumber;
+        String photoUri;
+        String normalizedName;
+        int presence = -1;
+        boolean processed;
+        String text1;
+        String text2;
+        String icon1;
+        String icon2;
+
+        public SearchSuggestion(long contactId) {
+            this.contactId = String.valueOf(contactId);
+        }
+
+        private void process() {
+            if (processed) {
+                return;
+            }
+
+            boolean hasOrganization = !TextUtils.isEmpty(organization);
+            boolean hasEmail = !TextUtils.isEmpty(email);
+            boolean hasPhone = !TextUtils.isEmpty(phoneNumber);
+
+            boolean titleIsOrganization = !titleIsName && hasOrganization;
+            boolean titleIsEmail = !titleIsName && !titleIsOrganization && hasEmail;
+            boolean titleIsPhone = !titleIsName && !titleIsOrganization && !titleIsEmail
+                    && hasPhone;
+
+            if (!titleIsOrganization && hasOrganization) {
+                text2 = organization;
+            } else if (!titleIsEmail && hasEmail) {
+                text2 = email;
+            } else if (!titleIsPhone && hasPhone) {
+                text2 = phoneNumber;
+            }
+
+            if (photoUri != null) {
+                icon1 = photoUri;
+            } else {
+                icon1 = String.valueOf(com.android.internal.R.drawable.ic_contact_picture);
+            }
+
+            if (presence != -1) {
+                icon2 = String.valueOf(Presence.getPresenceIconResourceId(presence));
+            }
+
+            processed = true;
+        }
+
+        public String getSortKey() {
+            if (normalizedName == null) {
+                process();
+                normalizedName = text1 == null ? "" : NameNormalizer.normalize(text1);
+            }
+            return normalizedName;
+        }
+
+        @SuppressWarnings({"unchecked"})
+        public ArrayList asList() {
+            process();
+
+            ArrayList<Object> list = new ArrayList<Object>();
+            list.add(contactId);
+            list.add(text1);
+            list.add(text2);
+            list.add(icon1);
+            list.add(icon2);
+            list.add(contactId);
+            list.add(contactId);
+            return list;
+        }
+    }
+
+    private final ContactsProvider2 mContactsProvider;
+
+    public GlobalSearchSupport(ContactsProvider2 contactsProvider) {
+        mContactsProvider = contactsProvider;
+    }
+
+    public Cursor handleSearchSuggestionsQuery(SQLiteDatabase db, Uri url, String limit) {
+        if (url.getPathSegments().size() <= 1) {
+            return null;
+        }
+
+        final String searchClause = url.getLastPathSegment();
+        if (TextUtils.isDigitsOnly(searchClause)) {
+            return buildCursorForSearchSuggestionsBasedOnPhoneNumber(searchClause);
+        } else {
+            return buildCursorForSearchSuggestionsBasedOnName(db, searchClause, limit);
+        }
+    }
+
+    private Cursor buildCursorForSearchSuggestionsBasedOnPhoneNumber(String searchClause) {
+        Resources r = mContactsProvider.getContext().getResources();
+        String s;
+        int i;
+
+        ArrayList<Object> dialNumber = new ArrayList<Object>();
+        dialNumber.add(0);  // _id
+        s = r.getString(com.android.internal.R.string.dial_number_using, searchClause);
+        i = s.indexOf('\n');
+        if (i < 0) {
+            dialNumber.add(s);
+            dialNumber.add("");
+        } else {
+            dialNumber.add(s.substring(0, i));
+            dialNumber.add(s.substring(i + 1));
+        }
+        dialNumber.add(String.valueOf(com.android.internal.R.drawable.call_contact));
+        dialNumber.add("tel:" + searchClause);
+        dialNumber.add(Intents.SEARCH_SUGGESTION_DIAL_NUMBER_CLICKED);
+        dialNumber.add(null);
+
+        ArrayList<Object> createContact = new ArrayList<Object>();
+        createContact.add(1);  // _id
+        s = r.getString(com.android.internal.R.string.create_contact_using, searchClause);
+        i = s.indexOf('\n');
+        if (i < 0) {
+            createContact.add(s);
+            createContact.add("");
+        } else {
+            createContact.add(s.substring(0, i));
+            createContact.add(s.substring(i + 1));
+        }
+        createContact.add(String.valueOf(com.android.internal.R.drawable.create_contact));
+        createContact.add("tel:" + searchClause);
+        createContact.add(Intents.SEARCH_SUGGESTION_CREATE_CONTACT_CLICKED);
+        createContact.add(SearchManager.SUGGEST_NEVER_MAKE_SHORTCUT);
+
+        @SuppressWarnings({"unchecked"}) ArrayList<ArrayList> rows = new ArrayList<ArrayList>();
+        rows.add(dialNumber);
+        rows.add(createContact);
+
+        return new ArrayListCursor(SEARCH_SUGGESTIONS_BASED_ON_PHONE_NUMBER_COLUMNS, rows);
+    }
+
+    private Cursor buildCursorForSearchSuggestionsBasedOnName(SQLiteDatabase db,
+            String searchClause, String limit) {
+        ArrayList<SearchSuggestion> suggestionList = new ArrayList<SearchSuggestion>();
+        HashMap<Long, SearchSuggestion> suggestionMap = new HashMap<Long, SearchSuggestion>();
+
+        StringBuilder selection = new StringBuilder();
+        selection.append(mContactsProvider.getContactsRestrictionExceptions());
+        selection.append(" AND " + DataColumns.CONCRETE_RAW_CONTACT_ID + " IN ");
+        mContactsProvider.appendRawContactsByFilterAsNestedQuery(selection, searchClause, limit);
+        selection.append(" AND " + Contacts.IN_VISIBLE_GROUP + "=1");
+
+        Cursor c = db.query(true, SearchSuggestionQuery.TABLE,
+                SearchSuggestionQuery.COLUMNS, selection.toString(), null, null, null, null, null);
+        try {
+            while (c.moveToNext()) {
+
+                long contactId = c.getLong(SearchSuggestionQuery.CONTACT_ID);
+                SearchSuggestion suggestion = suggestionMap.get(contactId);
+                if (suggestion == null) {
+                    suggestion = new SearchSuggestion(contactId);
+                    suggestionList.add(suggestion);
+                    suggestionMap.put(contactId, suggestion);
+                }
+
+                boolean isSuperPrimary = c.getInt(SearchSuggestionQuery.IS_SUPER_PRIMARY) != 0;
+                suggestion.text1 = c.getString(SearchSuggestionQuery.DISPLAY_NAME);
+
+                if (!c.isNull(SearchSuggestionQuery.PRESENCE_STATUS)) {
+                    suggestion.presence = c.getInt(SearchSuggestionQuery.PRESENCE_STATUS);
+                }
+
+                String mimetype = c.getString(SearchSuggestionQuery.MIMETYPE);
+                if (StructuredName.CONTENT_ITEM_TYPE.equals(mimetype)) {
+                    suggestion.titleIsName = true;
+                } else if (Photo.CONTENT_ITEM_TYPE.equals(mimetype)) {
+                    if (isSuperPrimary || suggestion.photoUri == null) {
+
+                        // TODO introduce a dedicated URI for contact photo: /contact/#/photo
+                        long dataId = c.getLong(SearchSuggestionQuery.DATA_ID);
+                        suggestion.photoUri =
+                                ContentUris.withAppendedId(Data.CONTENT_URI, dataId).toString();
+                    }
+                } else if (Organization.CONTENT_ITEM_TYPE.equals(mimetype)) {
+                    if (isSuperPrimary || suggestion.organization == null) {
+                        suggestion.organization = c.getString(SearchSuggestionQuery.DATA2);
+                    }
+                } else if (Email.CONTENT_ITEM_TYPE.equals(mimetype)) {
+                    if (isSuperPrimary || suggestion.email == null) {
+                        suggestion.email = c.getString(SearchSuggestionQuery.DATA2);
+                    }
+                } else if (Phone.CONTENT_ITEM_TYPE.equals(mimetype)) {
+                    if (isSuperPrimary || suggestion.phoneNumber == null) {
+                        suggestion.phoneNumber = c.getString(SearchSuggestionQuery.DATA2);
+                    }
+                }
+            }
+        } finally {
+            c.close();
+        }
+
+        Collections.sort(suggestionList, new Comparator<SearchSuggestion>() {
+            public int compare(SearchSuggestion row1, SearchSuggestion row2) {
+                return row1.getSortKey().compareTo(row2.getSortKey());
+            }
+        });
+
+        @SuppressWarnings({"unchecked"}) ArrayList<ArrayList> rows = new ArrayList<ArrayList>();
+        for (int i = 0; i < suggestionList.size(); i++) {
+            rows.add(suggestionList.get(i).asList());
+        }
+
+        return new ArrayListCursor(SEARCH_SUGGESTIONS_BASED_ON_NAME_COLUMNS, rows);
+    }
+}
diff --git a/src/com/android/providers/contacts/Hex.java b/src/com/android/providers/contacts/Hex.java
new file mode 100644
index 0000000..991f095
--- /dev/null
+++ b/src/com/android/providers/contacts/Hex.java
@@ -0,0 +1,121 @@
+/*
+ * 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;
+
+/**
+ * Basic hex operations: from byte array to string and vice versa.
+ *
+ * TODO: move to the framework and consider implementing as native code.
+ */
+public class Hex {
+
+    private static final char[] HEX_DIGITS = new char[]{
+            '0', '1', '2', '3', '4', '5', '6', '7',
+            '8', '9', 'A', 'B', 'C', 'D', 'E', 'F'
+    };
+
+    private static final char[] FIRST_CHAR = new char[256];
+    private static final char[] SECOND_CHAR = new char[256];
+    static {
+        for (int i = 0; i < 256; i++) {
+            FIRST_CHAR[i] = HEX_DIGITS[(i >> 4) & 0xF];
+            SECOND_CHAR[i] = HEX_DIGITS[i & 0xF];
+        }
+    }
+
+    private static final byte[] DIGITS = new byte['f'+1];
+    static {
+        for (int i = 0; i <= 'F'; i++) {
+            DIGITS[i] = -1;
+        }
+        for (byte i = 0; i < 10; i++) {
+            DIGITS['0' + i] = i;
+        }
+        for (byte i = 0; i < 6; i++) {
+            DIGITS['A' + i] = (byte)(10 + i);
+            DIGITS['a' + i] = (byte)(10 + i);
+        }
+    }
+
+    /**
+     * Quickly converts a byte array to a hexadecimal string representation.
+     *
+     * @param array byte array, possibly zero-terminated.
+     */
+    public static String encodeHex(byte[] array, boolean zeroTerminated) {
+        char[] cArray = new char[array.length * 2];
+
+        int j = 0;
+        for (int i = 0; i < array.length; i++) {
+            int index = array[i] & 0xFF;
+            if (index == 0 && zeroTerminated) {
+                break;
+            }
+
+            cArray[j++] = FIRST_CHAR[index];
+            cArray[j++] = SECOND_CHAR[index];
+        }
+
+        return new String(cArray, 0, j);
+    }
+
+    /**
+     * Quickly converts a hexadecimal string to a byte array.
+     */
+    public static byte[] decodeHex(String hexString) {
+        int length = hexString.length();
+
+        if ((length & 0x01) != 0) {
+            throw new IllegalArgumentException("Odd number of characters.");
+        }
+
+        boolean badHex = false;
+        byte[] out = new byte[length >> 1];
+        for (int i = 0, j = 0; j < length; i++) {
+            int c1 = hexString.charAt(j++);
+            if (c1 > 'f') {
+                badHex = true;
+                break;
+            }
+
+            final byte d1 = DIGITS[c1];
+            if (d1 == -1) {
+                badHex = true;
+                break;
+            }
+
+            int c2 = hexString.charAt(j++);
+            if (c2 > 'f') {
+                badHex = true;
+                break;
+            }
+
+            final byte d2 = DIGITS[c2];
+            if (d2 == -1) {
+                badHex = true;
+                break;
+            }
+
+            out[i] = (byte) (d1 << 4 | d2);
+        }
+
+        if (badHex) {
+            throw new IllegalArgumentException("Invalid hexadecimal digit: " + hexString);
+        }
+
+        return out;
+    }
+}
diff --git a/src/com/android/providers/contacts/JaroWinklerDistance.java b/src/com/android/providers/contacts/JaroWinklerDistance.java
new file mode 100644
index 0000000..730059d
--- /dev/null
+++ b/src/com/android/providers/contacts/JaroWinklerDistance.java
@@ -0,0 +1,140 @@
+/*
+ * 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 java.util.Arrays;
+
+/**
+ * A string distance calculator, particularly suited for name matching.
+ * <p>
+ * A detailed discussion of the topic of record linkage in general and name matching
+ * in particular can be found in this article:
+ * <blockquote>
+ * Winkler, W. E. (2006). "Overview of Record Linkage and Current Research Directions".
+ * Research Report Series, RRS.
+ * </blockquote>
+ */
+public class JaroWinklerDistance {
+
+    private static final float WINKLER_BONUS_THRESHOLD = 0.7f;
+
+    private final int mMaxLength;
+    private final boolean[] mMatchFlags1;
+    private final boolean[] mMatchFlags2;
+
+    /**
+     * Constructor.
+     *
+     * @param maxLength byte arrays are truncate if longer than this number
+     */
+    public JaroWinklerDistance(int maxLength) {
+        mMaxLength = maxLength;
+        mMatchFlags1 = new boolean[maxLength];
+        mMatchFlags2 = new boolean[maxLength];
+    }
+
+    /**
+     * Computes a string distance between two normalized strings passed as byte arrays.
+     */
+    public float getDistance(byte bytes1[], byte bytes2[]) {
+        byte[] array1, array2;
+
+        if (bytes1.length > bytes2.length) {
+            array2 = bytes1;
+            array1 = bytes2;
+        } else {
+            array2 = bytes2;
+            array1 = bytes1;
+        }
+
+        int length1 = array1.length;
+        if (length1 > mMaxLength) {
+            length1 = mMaxLength;
+        }
+
+        int length2 = array2.length;
+        if (length2 > mMaxLength) {
+            length2 = mMaxLength;
+        }
+
+        Arrays.fill(mMatchFlags1, 0, length1, false);
+        Arrays.fill(mMatchFlags2, 0, length2, false);
+
+        int range = length2 / 2 - 1;
+        if (range < 0) {
+            range = 0;
+        }
+
+        int matches = 0;
+        for (int i = 0; i < length1; i++) {
+            byte c1 = array1[i];
+
+            int from = i - range;
+            if (from < 0) {
+                from = 0;
+            }
+
+            int to = i + range + 1;
+            if (to > length2) {
+                to = length2;
+            }
+
+            for (int j = from; j < to; j++) {
+                if (!mMatchFlags2[j] && c1 == array2[j]) {
+                    mMatchFlags1[i] = mMatchFlags2[j] = true;
+                    matches++;
+                    break;
+                }
+            }
+        }
+
+        if (matches == 0) {
+            return 0f;
+        }
+
+        int transpositions = 0;
+        int j = 0;
+        for (int i = 0; i < length1; i++) {
+            if (mMatchFlags1[i]) {
+                while (!mMatchFlags2[j]) {
+                    j++;
+                }
+                if (array1[i] != array2[j]) {
+                    transpositions++;
+                }
+                j++;
+            }
+        }
+
+        float m = matches;
+        float jaro = ((m / length1 + m / length2 + (m - (transpositions / 2)) / m)) / 3;
+
+        if (jaro < WINKLER_BONUS_THRESHOLD) {
+            return jaro;
+        }
+
+        // Add Winkler bonus
+        int prefix = 0;
+        for (int i = 0; i < length1; i++) {
+            if (bytes1[i] != bytes2[i]) {
+                break;
+            }
+            prefix++;
+        }
+
+        return jaro + Math.min(0.1f, 1f / length2) * prefix * (1 - jaro);
+    }
+}
diff --git a/src/com/android/providers/contacts/LegacyApiSupport.java b/src/com/android/providers/contacts/LegacyApiSupport.java
new file mode 100644
index 0000000..af4a74e
--- /dev/null
+++ b/src/com/android/providers/contacts/LegacyApiSupport.java
@@ -0,0 +1,1336 @@
+/*
+ * 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.OpenHelper.DataColumns;
+import com.android.providers.contacts.OpenHelper.ExtensionsColumns;
+import com.android.providers.contacts.OpenHelper.GroupsColumns;
+import com.android.providers.contacts.OpenHelper.MimetypesColumns;
+import com.android.providers.contacts.OpenHelper.PhoneColumns;
+import com.android.providers.contacts.OpenHelper.RawContactsColumns;
+import com.android.providers.contacts.OpenHelper.Tables;
+
+import android.app.SearchManager;
+import android.content.ContentUris;
+import android.content.ContentValues;
+import android.content.Context;
+import android.content.UriMatcher;
+import android.database.Cursor;
+import android.database.DatabaseUtils;
+import android.database.sqlite.SQLiteDatabase;
+import android.database.sqlite.SQLiteQueryBuilder;
+import android.database.sqlite.SQLiteStatement;
+import android.net.Uri;
+import android.provider.ContactsContract;
+import android.provider.Contacts.ContactMethods;
+import android.provider.Contacts.People;
+import android.provider.ContactsContract.Data;
+import android.provider.ContactsContract.Groups;
+import android.provider.ContactsContract.Presence;
+import android.provider.ContactsContract.RawContacts;
+import android.provider.ContactsContract.CommonDataKinds.Email;
+import android.provider.ContactsContract.CommonDataKinds.GroupMembership;
+import android.provider.ContactsContract.CommonDataKinds.Im;
+import android.provider.ContactsContract.CommonDataKinds.Note;
+import android.provider.ContactsContract.CommonDataKinds.Organization;
+import android.provider.ContactsContract.CommonDataKinds.Phone;
+import android.provider.ContactsContract.CommonDataKinds.Photo;
+import android.provider.ContactsContract.CommonDataKinds.StructuredName;
+import android.provider.ContactsContract.CommonDataKinds.StructuredPostal;
+import android.util.Log;
+
+import java.util.HashMap;
+
+public class LegacyApiSupport implements OpenHelper.Delegate {
+
+    private static final UriMatcher sUriMatcher = new UriMatcher(UriMatcher.NO_MATCH);
+
+    private static final int PEOPLE = 1;
+    private static final int PEOPLE_ID = 2;
+    private static final int PEOPLE_UPDATE_CONTACT_TIME = 3;
+    private static final int ORGANIZATIONS = 4;
+    private static final int ORGANIZATIONS_ID = 5;
+    private static final int PEOPLE_CONTACTMETHODS = 6;
+    private static final int PEOPLE_CONTACTMETHODS_ID = 7;
+    private static final int CONTACTMETHODS = 8;
+    private static final int CONTACTMETHODS_ID = 9;
+    private static final int PEOPLE_PHONES = 10;
+    private static final int PEOPLE_PHONES_ID = 11;
+    private static final int PHONES = 12;
+    private static final int PHONES_ID = 13;
+    private static final int EXTENSIONS = 14;
+    private static final int EXTENSIONS_ID = 15;
+    private static final int PEOPLE_EXTENSIONS = 16;
+    private static final int PEOPLE_EXTENSIONS_ID = 17;
+    private static final int GROUPS = 18;
+    private static final int GROUPS_ID = 19;
+    private static final int GROUPMEMBERSHIP = 20;
+    private static final int GROUPMEMBERSHIP_ID = 21;
+    private static final int PEOPLE_GROUPMEMBERSHIP = 22;
+    private static final int PEOPLE_GROUPMEMBERSHIP_ID = 23;
+    private static final int PEOPLE_PHOTO = 24;
+    private static final int PHOTOS = 25;
+    private static final int PHOTOS_ID = 26;
+    private static final int PRESENCE = 27;
+    private static final int PRESENCE_ID = 28;
+    private static final int PEOPLE_FILTER = 29;
+    private static final int DELETED_PEOPLE = 30;
+    private static final int DELETED_GROUPS = 31;
+    private static final int SEARCH_SUGGESTIONS = 32;
+
+
+
+    private static final String PEOPLE_JOINS =
+            " LEFT OUTER JOIN data name ON (raw_contacts._id = name.raw_contact_id"
+            + " AND (SELECT mimetype FROM mimetypes WHERE mimetypes._id = name.mimetype_id)"
+                    + "='" + StructuredName.CONTENT_ITEM_TYPE + "')"
+            + " LEFT OUTER JOIN data organization ON (raw_contacts._id = organization.raw_contact_id"
+            + " AND (SELECT mimetype FROM mimetypes WHERE mimetypes._id = organization.mimetype_id)"
+                    + "='" + Organization.CONTENT_ITEM_TYPE + "' AND organization.is_primary)"
+            + " LEFT OUTER JOIN data email ON (raw_contacts._id = email.raw_contact_id"
+            + " AND (SELECT mimetype FROM mimetypes WHERE mimetypes._id = email.mimetype_id)"
+                    + "='" + Email.CONTENT_ITEM_TYPE + "' AND email.is_primary)"
+            + " LEFT OUTER JOIN data note ON (raw_contacts._id = note.raw_contact_id"
+            + " AND (SELECT mimetype FROM mimetypes WHERE mimetypes._id = note.mimetype_id)"
+                    + "='" + Note.CONTENT_ITEM_TYPE + "')"
+            + " LEFT OUTER JOIN data phone ON (raw_contacts._id = phone.raw_contact_id"
+            + " AND (SELECT mimetype FROM mimetypes WHERE mimetypes._id = phone.mimetype_id)"
+                    + "='" + Phone.CONTENT_ITEM_TYPE + "' AND phone.is_primary)";
+
+    public static final String DATA_JOINS =
+            " JOIN mimetypes ON (mimetypes._id = data.mimetype_id)"
+            + " JOIN raw_contacts ON (raw_contacts._id = data.raw_contact_id)"
+            + PEOPLE_JOINS;
+
+    public static final String PRESENCE_JOINS =
+            " LEFT OUTER JOIN presence ON ("
+            + " presence.presence_id = (SELECT max(presence_id) FROM presence"
+            + " WHERE view_v1_people._id = presence.raw_contact_id))";
+
+    private static final String PHONETIC_NAME_SQL = "trim(trim("
+            + "ifnull(name." + StructuredName.PHONETIC_GIVEN_NAME + ",' ')||' '||"
+            + "ifnull(name." + StructuredName.PHONETIC_MIDDLE_NAME + ",' '))||' '||"
+            + "ifnull(name." + StructuredName.PHONETIC_FAMILY_NAME + ",' ')) ";
+
+    private static final String CONTACT_METHOD_KIND_SQL =
+            "CAST ((CASE WHEN mimetype='" + Email.CONTENT_ITEM_TYPE + "'"
+                + " THEN " + android.provider.Contacts.KIND_EMAIL
+                + " ELSE"
+                    + " (CASE WHEN mimetype='" + Im.CONTENT_ITEM_TYPE +"'"
+                        + " THEN " + android.provider.Contacts.KIND_IM
+                        + " ELSE"
+                        + " (CASE WHEN mimetype='" + StructuredPostal.CONTENT_ITEM_TYPE + "'"
+                            + " THEN "  + android.provider.Contacts.KIND_POSTAL
+                            + " ELSE"
+                                + " NULL"
+                            + " END)"
+                        + " END)"
+                + " END) AS INTEGER)";
+
+    public interface LegacyTables {
+        public static final String PEOPLE = "view_v1_people";
+        public static final String PEOPLE_JOIN_PRESENCE = "view_v1_people" + PRESENCE_JOINS;
+        public static final String GROUPS = "view_v1_groups";
+        public static final String ORGANIZATIONS = "view_v1_organizations";
+        public static final String CONTACT_METHODS = "view_v1_contact_methods";
+        public static final String PHONES = "view_v1_phones";
+        public static final String EXTENSIONS = "view_v1_extensions";
+        public static final String GROUP_MEMBERSHIP = "view_v1_group_membership";
+        public static final String PHOTOS = "view_v1_photos";
+        public static final String PRESENCE_JOIN_CONTACTS = Tables.PRESENCE +
+                " LEFT OUTER JOIN " + Tables.RAW_CONTACTS
+                + " ON (" + Tables.PRESENCE + "." + Presence.RAW_CONTACT_ID + "="
+                + RawContactsColumns.CONCRETE_ID + ")";
+    }
+
+    private static final String[] ORGANIZATION_MIME_TYPES = new String[] {
+        Organization.CONTENT_ITEM_TYPE
+    };
+
+    private static final String[] CONTACT_METHOD_MIME_TYPES = new String[] {
+        Email.CONTENT_ITEM_TYPE,
+        Im.CONTENT_ITEM_TYPE,
+        StructuredPostal.CONTENT_ITEM_TYPE,
+    };
+
+    private static final String[] PHONE_MIME_TYPES = new String[] {
+        Phone.CONTENT_ITEM_TYPE
+    };
+
+    private interface PhotoQuery {
+        String[] COLUMNS = { Data._ID };
+
+        int _ID = 0;
+    }
+
+    /**
+     * A custom data row that is used to store legacy photo data fields no
+     * longer directly supported by the API.
+     */
+    private interface LegacyPhotoData {
+        public static final String CONTENT_ITEM_TYPE = "vnd.android.cursor.item/photo_v1_extras";
+
+        public static final String PHOTO_DATA_ID = Data.DATA1;
+        public static final String LOCAL_VERSION = Data.DATA2;
+        public static final String DOWNLOAD_REQUIRED = Data.DATA3;
+        public static final String EXISTS_ON_SERVER = Data.DATA4;
+        public static final String SYNC_ERROR = Data.DATA5;
+    }
+
+    public static final String LEGACY_PHOTO_JOIN =
+            " LEFT OUTER JOIN data legacy_photo ON (raw_contacts._id = legacy_photo.raw_contact_id"
+            + " AND (SELECT mimetype FROM mimetypes WHERE mimetypes._id = legacy_photo.mimetype_id)"
+                + "='" + LegacyPhotoData.CONTENT_ITEM_TYPE + "'"
+            + " AND " + DataColumns.CONCRETE_ID + " = legacy_photo." + LegacyPhotoData.PHOTO_DATA_ID
+            + ")";
+
+    private static final HashMap<String, String> sPeopleProjectionMap;
+    private static final HashMap<String, String> sOrganizationProjectionMap;
+    private static final HashMap<String, String> sContactMethodProjectionMap;
+    private static final HashMap<String, String> sPhoneProjectionMap;
+    private static final HashMap<String, String> sExtensionProjectionMap;
+    private static final HashMap<String, String> sGroupProjectionMap;
+    private static final HashMap<String, String> sGroupMembershipProjectionMap;
+    private static final HashMap<String, String> sPhotoProjectionMap;
+    private static final HashMap<String, String> sPresenceProjectionMap;
+
+    static {
+
+        // Contacts URI matching table
+        UriMatcher matcher = sUriMatcher;
+
+        String authority = android.provider.Contacts.AUTHORITY;
+        matcher.addURI(authority, "extensions", EXTENSIONS);
+        matcher.addURI(authority, "extensions/#", EXTENSIONS_ID);
+        matcher.addURI(authority, "groups", GROUPS);
+        matcher.addURI(authority, "groups/#", GROUPS_ID);
+//        matcher.addURI(authority, "groups/name/*/members", GROUP_NAME_MEMBERS);
+//        matcher.addURI(authority, "groups/name/*/members/filter/*",
+//                GROUP_NAME_MEMBERS_FILTER);
+//        matcher.addURI(authority, "groups/system_id/*/members", GROUP_SYSTEM_ID_MEMBERS);
+//        matcher.addURI(authority, "groups/system_id/*/members/filter/*",
+//                GROUP_SYSTEM_ID_MEMBERS_FILTER);
+        matcher.addURI(authority, "groupmembership", GROUPMEMBERSHIP);
+        matcher.addURI(authority, "groupmembership/#", GROUPMEMBERSHIP_ID);
+//        matcher.addURI(authority, "groupmembershipraw", GROUPMEMBERSHIP_RAW);
+        matcher.addURI(authority, "people", PEOPLE);
+//        matcher.addURI(authority, "people/strequent", PEOPLE_STREQUENT);
+//        matcher.addURI(authority, "people/strequent/filter/*", PEOPLE_STREQUENT_FILTER);
+        matcher.addURI(authority, "people/filter/*", PEOPLE_FILTER);
+//        matcher.addURI(authority, "people/with_phones_filter/*",
+//                PEOPLE_WITH_PHONES_FILTER);
+//        matcher.addURI(authority, "people/with_email_or_im_filter/*",
+//                PEOPLE_WITH_EMAIL_OR_IM_FILTER);
+        matcher.addURI(authority, "people/#", PEOPLE_ID);
+        matcher.addURI(authority, "people/#/extensions", PEOPLE_EXTENSIONS);
+        matcher.addURI(authority, "people/#/extensions/#", PEOPLE_EXTENSIONS_ID);
+        matcher.addURI(authority, "people/#/phones", PEOPLE_PHONES);
+        matcher.addURI(authority, "people/#/phones/#", PEOPLE_PHONES_ID);
+//        matcher.addURI(authority, "people/#/phones_with_presence",
+//                PEOPLE_PHONES_WITH_PRESENCE);
+        matcher.addURI(authority, "people/#/photo", PEOPLE_PHOTO);
+//        matcher.addURI(authority, "people/#/photo/data", PEOPLE_PHOTO_DATA);
+        matcher.addURI(authority, "people/#/contact_methods", PEOPLE_CONTACTMETHODS);
+//        matcher.addURI(authority, "people/#/contact_methods_with_presence",
+//                PEOPLE_CONTACTMETHODS_WITH_PRESENCE);
+        matcher.addURI(authority, "people/#/contact_methods/#", PEOPLE_CONTACTMETHODS_ID);
+//        matcher.addURI(authority, "people/#/organizations", PEOPLE_ORGANIZATIONS);
+//        matcher.addURI(authority, "people/#/organizations/#", PEOPLE_ORGANIZATIONS_ID);
+        matcher.addURI(authority, "people/#/groupmembership", PEOPLE_GROUPMEMBERSHIP);
+        matcher.addURI(authority, "people/#/groupmembership/#", PEOPLE_GROUPMEMBERSHIP_ID);
+//        matcher.addURI(authority, "people/raw", PEOPLE_RAW);
+//        matcher.addURI(authority, "people/owner", PEOPLE_OWNER);
+        matcher.addURI(authority, "people/#/update_contact_time",
+                PEOPLE_UPDATE_CONTACT_TIME);
+        matcher.addURI(authority, "deleted_people", DELETED_PEOPLE);
+        matcher.addURI(authority, "deleted_groups", DELETED_GROUPS);
+        matcher.addURI(authority, "phones", PHONES);
+//        matcher.addURI(authority, "phones_with_presence", PHONES_WITH_PRESENCE);
+//        matcher.addURI(authority, "phones/filter/*", PHONES_FILTER);
+//        matcher.addURI(authority, "phones/filter_name/*", PHONES_FILTER_NAME);
+//        matcher.addURI(authority, "phones/mobile_filter_name/*",
+//                PHONES_MOBILE_FILTER_NAME);
+        matcher.addURI(authority, "phones/#", PHONES_ID);
+        matcher.addURI(authority, "photos", PHOTOS);
+        matcher.addURI(authority, "photos/#", PHOTOS_ID);
+        matcher.addURI(authority, "contact_methods", CONTACTMETHODS);
+//        matcher.addURI(authority, "contact_methods/email", CONTACTMETHODS_EMAIL);
+//        matcher.addURI(authority, "contact_methods/email/*", CONTACTMETHODS_EMAIL_FILTER);
+        matcher.addURI(authority, "contact_methods/#", CONTACTMETHODS_ID);
+//        matcher.addURI(authority, "contact_methods/with_presence",
+//                CONTACTMETHODS_WITH_PRESENCE);
+        matcher.addURI(authority, "presence", PRESENCE);
+        matcher.addURI(authority, "presence/#", PRESENCE_ID);
+        matcher.addURI(authority, "organizations", ORGANIZATIONS);
+        matcher.addURI(authority, "organizations/#", ORGANIZATIONS_ID);
+//        matcher.addURI(authority, "voice_dialer_timestamp", VOICE_DIALER_TIMESTAMP);
+        matcher.addURI(authority, SearchManager.SUGGEST_URI_PATH_QUERY,
+                SEARCH_SUGGESTIONS);
+        matcher.addURI(authority, SearchManager.SUGGEST_URI_PATH_QUERY + "/*",
+                SEARCH_SUGGESTIONS);
+//        matcher.addURI(authority, SearchManager.SUGGEST_URI_PATH_SHORTCUT + "/#",
+//                SEARCH_SHORTCUT);
+//        matcher.addURI(authority, "settings", SETTINGS);
+//
+//        matcher.addURI(authority, "live_folders/people", LIVE_FOLDERS_PEOPLE);
+//        matcher.addURI(authority, "live_folders/people/*",
+//                LIVE_FOLDERS_PEOPLE_GROUP_NAME);
+//        matcher.addURI(authority, "live_folders/people_with_phones",
+//                LIVE_FOLDERS_PEOPLE_WITH_PHONES);
+//        matcher.addURI(authority, "live_folders/favorites",
+//                LIVE_FOLDERS_PEOPLE_FAVORITES);
+
+
+        HashMap<String, String> peopleProjectionMap = new HashMap<String, String>();
+        peopleProjectionMap.put(People.NAME, People.NAME);
+        peopleProjectionMap.put(People.DISPLAY_NAME, People.DISPLAY_NAME);
+        peopleProjectionMap.put(People.PHONETIC_NAME, People.PHONETIC_NAME);
+        peopleProjectionMap.put(People.NOTES, People.NOTES);
+        peopleProjectionMap.put(People.TIMES_CONTACTED, People.TIMES_CONTACTED);
+        peopleProjectionMap.put(People.LAST_TIME_CONTACTED, People.LAST_TIME_CONTACTED);
+        peopleProjectionMap.put(People.CUSTOM_RINGTONE, People.CUSTOM_RINGTONE);
+        peopleProjectionMap.put(People.SEND_TO_VOICEMAIL, People.SEND_TO_VOICEMAIL);
+        peopleProjectionMap.put(People.STARRED, People.STARRED);
+
+        sPeopleProjectionMap = new HashMap<String, String>(peopleProjectionMap);
+        sPeopleProjectionMap.put(People.PRIMARY_ORGANIZATION_ID, People.PRIMARY_ORGANIZATION_ID);
+        sPeopleProjectionMap.put(People.PRIMARY_EMAIL_ID, People.PRIMARY_EMAIL_ID);
+        sPeopleProjectionMap.put(People.PRIMARY_PHONE_ID, People.PRIMARY_PHONE_ID);
+        sPeopleProjectionMap.put(People.NUMBER, People.NUMBER);
+        sPeopleProjectionMap.put(People.TYPE, People.TYPE);
+        sPeopleProjectionMap.put(People.LABEL, People.LABEL);
+        sPeopleProjectionMap.put(People.NUMBER_KEY, People.NUMBER_KEY);
+        sPeopleProjectionMap.put(People.IM_PROTOCOL, People.IM_PROTOCOL);
+        sPeopleProjectionMap.put(People.IM_HANDLE, People.IM_HANDLE);
+        sPeopleProjectionMap.put(People.IM_ACCOUNT, People.IM_ACCOUNT);
+        sPeopleProjectionMap.put(People.PRESENCE_STATUS, People.PRESENCE_STATUS);
+        sPeopleProjectionMap.put(People.PRESENCE_CUSTOM_STATUS, People.PRESENCE_CUSTOM_STATUS);
+
+        sOrganizationProjectionMap = new HashMap<String, String>();
+        sOrganizationProjectionMap.put(android.provider.Contacts.Organizations.PERSON_ID,
+                android.provider.Contacts.Organizations.PERSON_ID);
+        sOrganizationProjectionMap.put(android.provider.Contacts.Organizations.ISPRIMARY,
+                android.provider.Contacts.Organizations.ISPRIMARY);
+        sOrganizationProjectionMap.put(android.provider.Contacts.Organizations.COMPANY,
+                android.provider.Contacts.Organizations.COMPANY);
+        sOrganizationProjectionMap.put(android.provider.Contacts.Organizations.TYPE,
+                android.provider.Contacts.Organizations.TYPE);
+        sOrganizationProjectionMap.put(android.provider.Contacts.Organizations.LABEL,
+                android.provider.Contacts.Organizations.LABEL);
+        sOrganizationProjectionMap.put(android.provider.Contacts.Organizations.TITLE,
+                android.provider.Contacts.Organizations.TITLE);
+
+        sContactMethodProjectionMap = new HashMap<String, String>(peopleProjectionMap);
+        sContactMethodProjectionMap.put(ContactMethods.PERSON_ID, ContactMethods.PERSON_ID);
+        sContactMethodProjectionMap.put(ContactMethods.KIND, ContactMethods.KIND);
+        sContactMethodProjectionMap.put(ContactMethods.ISPRIMARY, ContactMethods.ISPRIMARY);
+        sContactMethodProjectionMap.put(ContactMethods.TYPE, ContactMethods.TYPE);
+        sContactMethodProjectionMap.put(ContactMethods.DATA, ContactMethods.DATA);
+        sContactMethodProjectionMap.put(ContactMethods.LABEL, ContactMethods.LABEL);
+        sContactMethodProjectionMap.put(ContactMethods.AUX_DATA, ContactMethods.AUX_DATA);
+
+        sPhoneProjectionMap = new HashMap<String, String>(peopleProjectionMap);
+        sPhoneProjectionMap.put(android.provider.Contacts.Phones.PERSON_ID,
+                android.provider.Contacts.Phones.PERSON_ID);
+        sPhoneProjectionMap.put(android.provider.Contacts.Phones.ISPRIMARY,
+                android.provider.Contacts.Phones.ISPRIMARY);
+        sPhoneProjectionMap.put(android.provider.Contacts.Phones.NUMBER,
+                android.provider.Contacts.Phones.NUMBER);
+        sPhoneProjectionMap.put(android.provider.Contacts.Phones.TYPE,
+                android.provider.Contacts.Phones.TYPE);
+        sPhoneProjectionMap.put(android.provider.Contacts.Phones.LABEL,
+                android.provider.Contacts.Phones.LABEL);
+        sPhoneProjectionMap.put(android.provider.Contacts.Phones.NUMBER_KEY,
+                android.provider.Contacts.Phones.NUMBER_KEY);
+
+        sExtensionProjectionMap = new HashMap<String, String>();
+        sExtensionProjectionMap.put(android.provider.Contacts.Extensions.PERSON_ID,
+                android.provider.Contacts.Extensions.PERSON_ID);
+        sExtensionProjectionMap.put(android.provider.Contacts.Extensions.NAME,
+                android.provider.Contacts.Extensions.NAME);
+        sExtensionProjectionMap.put(android.provider.Contacts.Extensions.VALUE,
+                android.provider.Contacts.Extensions.VALUE);
+
+        sGroupProjectionMap = new HashMap<String, String>();
+        sGroupProjectionMap.put(android.provider.Contacts.Groups._ID,
+                android.provider.Contacts.Groups._ID);
+        sGroupProjectionMap.put(android.provider.Contacts.Groups.NAME,
+                android.provider.Contacts.Groups.NAME);
+        sGroupProjectionMap.put(android.provider.Contacts.Groups.NOTES,
+                android.provider.Contacts.Groups.NOTES);
+        sGroupProjectionMap.put(android.provider.Contacts.Groups.SYSTEM_ID,
+                android.provider.Contacts.Groups.SYSTEM_ID);
+
+        sGroupMembershipProjectionMap = new HashMap<String, String>();
+        sGroupMembershipProjectionMap.put(android.provider.Contacts.GroupMembership.PERSON_ID,
+                android.provider.Contacts.GroupMembership.PERSON_ID);
+        sGroupMembershipProjectionMap.put(android.provider.Contacts.GroupMembership.GROUP_ID,
+                android.provider.Contacts.GroupMembership.GROUP_ID);
+
+        sPhotoProjectionMap = new HashMap<String, String>();
+        sPhotoProjectionMap.put(android.provider.Contacts.Photos.PERSON_ID,
+                android.provider.Contacts.Photos.PERSON_ID);
+        sPhotoProjectionMap.put(android.provider.Contacts.Photos.DATA,
+                android.provider.Contacts.Photos.DATA);
+        sPhotoProjectionMap.put(android.provider.Contacts.Photos.LOCAL_VERSION,
+                android.provider.Contacts.Photos.LOCAL_VERSION);
+        sPhotoProjectionMap.put(android.provider.Contacts.Photos.DOWNLOAD_REQUIRED,
+                android.provider.Contacts.Photos.DOWNLOAD_REQUIRED);
+        sPhotoProjectionMap.put(android.provider.Contacts.Photos.EXISTS_ON_SERVER,
+                android.provider.Contacts.Photos.EXISTS_ON_SERVER);
+        sPhotoProjectionMap.put(android.provider.Contacts.Photos.SYNC_ERROR,
+                android.provider.Contacts.Photos.SYNC_ERROR);
+
+        sPresenceProjectionMap = new HashMap<String, String>();
+        sPresenceProjectionMap.put(android.provider.Contacts.Presence._ID,
+                Tables.PRESENCE + "." + Presence._ID
+                        + " AS " + android.provider.Contacts.Presence._ID);
+        sPresenceProjectionMap.put(android.provider.Contacts.Presence.PERSON_ID,
+                Tables.PRESENCE + "." + Presence.RAW_CONTACT_ID
+                        + " AS " + android.provider.Contacts.Presence.PERSON_ID);
+        sPresenceProjectionMap.put(android.provider.Contacts.Presence.IM_PROTOCOL,
+                Presence.IM_PROTOCOL
+                    + " AS " + android.provider.Contacts.Presence.IM_PROTOCOL);
+        sPresenceProjectionMap.put(android.provider.Contacts.Presence.IM_HANDLE,
+                Presence.IM_HANDLE
+                    + " AS " + android.provider.Contacts.Presence.IM_HANDLE);
+        sPresenceProjectionMap.put(android.provider.Contacts.Presence.IM_ACCOUNT,
+                Presence.IM_ACCOUNT
+                    + " AS " + android.provider.Contacts.Presence.IM_ACCOUNT);
+        sPresenceProjectionMap.put(android.provider.Contacts.Presence.PRESENCE_STATUS,
+                Presence.PRESENCE_STATUS
+                    + " AS " + android.provider.Contacts.Presence.PRESENCE_STATUS);
+        sPresenceProjectionMap.put(android.provider.Contacts.Presence.PRESENCE_CUSTOM_STATUS,
+                Presence.PRESENCE_CUSTOM_STATUS
+                    + " AS " + android.provider.Contacts.Presence.PRESENCE_CUSTOM_STATUS);
+    }
+
+    private final Context mContext;
+    private final OpenHelper mOpenHelper;
+    private final ContactsProvider2 mContactsProvider;
+    private final NameSplitter mPhoneticNameSplitter;
+    private final GlobalSearchSupport mGlobalSearchSupport;
+
+    /** Precompiled sql statement for incrementing times contacted for a contact */
+    private final SQLiteStatement mLastTimeContactedUpdate;
+
+    private final ContentValues mValues = new ContentValues();
+
+
+    public LegacyApiSupport(Context context, OpenHelper openHelper,
+            ContactsProvider2 contactsProvider, GlobalSearchSupport globalSearchSupport) {
+        mContext = context;
+        mContactsProvider = contactsProvider;
+        mOpenHelper = openHelper;
+        mGlobalSearchSupport = globalSearchSupport;
+        mOpenHelper.setDelegate(this);
+
+        mPhoneticNameSplitter = new NameSplitter("", "", "",
+                context.getString(com.android.internal.R.string.common_name_conjunctions));
+
+        SQLiteDatabase db = mOpenHelper.getReadableDatabase();
+        mLastTimeContactedUpdate = db.compileStatement("UPDATE " + Tables.RAW_CONTACTS + " SET "
+                + RawContacts.TIMES_CONTACTED + "="
+                + RawContacts.TIMES_CONTACTED + "+1,"
+                + RawContacts.LAST_TIME_CONTACTED + "=? WHERE "
+                + RawContacts._ID + "=?");
+    }
+
+
+    public void createDatabase(SQLiteDatabase db) {
+
+        db.execSQL("DROP VIEW IF EXISTS " + LegacyTables.PEOPLE + ";");
+        db.execSQL("CREATE VIEW " + LegacyTables.PEOPLE + " AS SELECT " +
+                RawContactsColumns.CONCRETE_ID
+                        + " AS " + android.provider.Contacts.People._ID + ", " +
+                "name." + StructuredName.DISPLAY_NAME
+                        + " AS " + People.NAME + ", " +
+                Tables.RAW_CONTACTS + "." + RawContactsColumns.DISPLAY_NAME
+                        + " AS " + People.DISPLAY_NAME + ", " +
+                PHONETIC_NAME_SQL
+                        + " AS " + People.PHONETIC_NAME + " , " +
+                "note." + Note.NOTE
+                        + " AS " + People.NOTES + ", " +
+                Tables.RAW_CONTACTS + "." + RawContacts.TIMES_CONTACTED
+                        + " AS " + People.TIMES_CONTACTED + ", " +
+                Tables.RAW_CONTACTS + "." + RawContacts.LAST_TIME_CONTACTED
+                        + " AS " + People.LAST_TIME_CONTACTED + ", " +
+                Tables.RAW_CONTACTS + "." + RawContacts.CUSTOM_RINGTONE
+                        + " AS " + People.CUSTOM_RINGTONE + ", " +
+                Tables.RAW_CONTACTS + "." + RawContacts.SEND_TO_VOICEMAIL
+                        + " AS " + People.SEND_TO_VOICEMAIL + ", " +
+                Tables.RAW_CONTACTS + "." + RawContacts.STARRED
+                        + " AS " + People.STARRED + ", " +
+                "organization." + Data._ID
+                        + " AS " + People.PRIMARY_ORGANIZATION_ID + ", " +
+                "email." + Data._ID
+                        + " AS " + People.PRIMARY_EMAIL_ID + ", " +
+                "phone." + Data._ID
+                        + " AS " + People.PRIMARY_PHONE_ID + ", " +
+                "phone." + Phone.NUMBER
+                        + " AS " + People.NUMBER + ", " +
+                "phone." + Phone.TYPE
+                        + " AS " + People.TYPE + ", " +
+                "phone." + Phone.LABEL
+                        + " AS " + People.LABEL + ", " +
+                "phone." + PhoneColumns.NORMALIZED_NUMBER
+                        + " AS " + People.NUMBER_KEY + ", " +
+                RawContacts.IS_RESTRICTED +
+                " FROM " + Tables.RAW_CONTACTS + PEOPLE_JOINS +
+                " WHERE " + Tables.RAW_CONTACTS + "." + RawContacts.DELETED + "=0" +
+        ";");
+
+        db.execSQL("DROP VIEW IF EXISTS " + LegacyTables.ORGANIZATIONS + ";");
+        db.execSQL("CREATE VIEW " + LegacyTables.ORGANIZATIONS + " AS SELECT " +
+                DataColumns.CONCRETE_ID
+                        + " AS " + android.provider.Contacts.Organizations._ID + ", " +
+                Data.RAW_CONTACT_ID
+                        + " AS " + android.provider.Contacts.Organizations.PERSON_ID + ", " +
+                Data.IS_PRIMARY
+                        + " AS " + android.provider.Contacts.Organizations.ISPRIMARY + ", " +
+                Organization.COMPANY
+                        + " AS " + android.provider.Contacts.Organizations.COMPANY + ", " +
+                Organization.TYPE
+                        + " AS " + android.provider.Contacts.Organizations.TYPE + ", " +
+                Organization.LABEL
+                        + " AS " + android.provider.Contacts.Organizations.LABEL + ", " +
+                Organization.TITLE
+                        + " AS " + android.provider.Contacts.Organizations.TITLE + ", " +
+                RawContacts.IS_RESTRICTED +
+                " FROM " + Tables.DATA_JOIN_MIMETYPE_RAW_CONTACTS +
+                " WHERE " + MimetypesColumns.CONCRETE_MIMETYPE + "='"
+                        + Organization.CONTENT_ITEM_TYPE + "'"
+                        + " AND " + Tables.RAW_CONTACTS + "." + RawContacts.DELETED + "=0" +
+        ";");
+
+        db.execSQL("DROP VIEW IF EXISTS " + LegacyTables.CONTACT_METHODS + ";");
+        db.execSQL("CREATE VIEW " + LegacyTables.CONTACT_METHODS + " AS SELECT " +
+                DataColumns.CONCRETE_ID
+                        + " AS " + ContactMethods._ID + ", " +
+                DataColumns.CONCRETE_RAW_CONTACT_ID
+                        + " AS " + ContactMethods.PERSON_ID + ", " +
+                CONTACT_METHOD_KIND_SQL
+                        + " AS " + ContactMethods.KIND + ", " +
+                DataColumns.CONCRETE_IS_PRIMARY
+                        + " AS " + ContactMethods.ISPRIMARY + ", " +
+                DataColumns.CONCRETE_DATA1
+                        + " AS " + ContactMethods.TYPE + ", " +
+                DataColumns.CONCRETE_DATA2
+                        + " AS " + ContactMethods.DATA + ", " +
+                DataColumns.CONCRETE_DATA3
+                        + " AS " + ContactMethods.LABEL + ", " +
+                DataColumns.CONCRETE_DATA14
+                        + " AS " + ContactMethods.AUX_DATA + ", " +
+                "name." + StructuredName.DISPLAY_NAME
+                        + " AS " + ContactMethods.NAME + ", " +
+                Tables.RAW_CONTACTS + "." + RawContactsColumns.DISPLAY_NAME
+                        + " AS " + ContactMethods.DISPLAY_NAME + ", " +
+                PHONETIC_NAME_SQL
+                        + " AS " + ContactMethods.PHONETIC_NAME + " , " +
+                "note." + Note.NOTE
+                        + " AS " + ContactMethods.NOTES + ", " +
+                Tables.RAW_CONTACTS + "." + RawContacts.TIMES_CONTACTED
+                        + " AS " + ContactMethods.TIMES_CONTACTED + ", " +
+                Tables.RAW_CONTACTS + "." + RawContacts.LAST_TIME_CONTACTED
+                        + " AS " + ContactMethods.LAST_TIME_CONTACTED + ", " +
+                Tables.RAW_CONTACTS + "." + RawContacts.CUSTOM_RINGTONE
+                        + " AS " + ContactMethods.CUSTOM_RINGTONE + ", " +
+                Tables.RAW_CONTACTS + "." + RawContacts.SEND_TO_VOICEMAIL
+                        + " AS " + ContactMethods.SEND_TO_VOICEMAIL + ", " +
+                Tables.RAW_CONTACTS + "." + RawContacts.STARRED
+                        + " AS " + ContactMethods.STARRED + ", " +
+                RawContacts.IS_RESTRICTED +
+                " FROM " + Tables.DATA + DATA_JOINS +
+                " WHERE " + ContactMethods.KIND + " IS NOT NULL"
+                    + " AND " + Tables.RAW_CONTACTS + "." + RawContacts.DELETED + "=0" +
+        ";");
+
+
+        db.execSQL("DROP VIEW IF EXISTS " + LegacyTables.PHONES + ";");
+        db.execSQL("CREATE VIEW " + LegacyTables.PHONES + " AS SELECT " +
+                DataColumns.CONCRETE_ID
+                        + " AS " + android.provider.Contacts.Phones._ID + ", " +
+                DataColumns.CONCRETE_RAW_CONTACT_ID
+                        + " AS " + android.provider.Contacts.Phones.PERSON_ID + ", " +
+                DataColumns.CONCRETE_IS_PRIMARY
+                        + " AS " + android.provider.Contacts.Phones.ISPRIMARY + ", " +
+                Tables.DATA + "." + Phone.NUMBER
+                        + " AS " + android.provider.Contacts.Phones.NUMBER + ", " +
+                Tables.DATA + "." + Phone.TYPE
+                        + " AS " + android.provider.Contacts.Phones.TYPE + ", " +
+                Tables.DATA + "." + Phone.LABEL
+                        + " AS " + android.provider.Contacts.Phones.LABEL + ", " +
+                PhoneColumns.CONCRETE_NORMALIZED_NUMBER
+                        + " AS " + android.provider.Contacts.Phones.NUMBER_KEY + ", " +
+                "name." + StructuredName.DISPLAY_NAME
+                        + " AS " + android.provider.Contacts.Phones.NAME + ", " +
+                Tables.RAW_CONTACTS + "." + RawContactsColumns.DISPLAY_NAME
+                        + " AS " + android.provider.Contacts.Phones.DISPLAY_NAME + ", " +
+                PHONETIC_NAME_SQL
+                        + " AS " + android.provider.Contacts.Phones.PHONETIC_NAME + " , " +
+                "note." + Note.NOTE
+                        + " AS " + android.provider.Contacts.Phones.NOTES + ", " +
+                Tables.RAW_CONTACTS + "." + RawContacts.TIMES_CONTACTED
+                        + " AS " + android.provider.Contacts.Phones.TIMES_CONTACTED + ", " +
+                Tables.RAW_CONTACTS + "." + RawContacts.LAST_TIME_CONTACTED
+                        + " AS " + android.provider.Contacts.Phones.LAST_TIME_CONTACTED + ", " +
+                Tables.RAW_CONTACTS + "." + RawContacts.CUSTOM_RINGTONE
+                        + " AS " + android.provider.Contacts.Phones.CUSTOM_RINGTONE + ", " +
+                Tables.RAW_CONTACTS + "." + RawContacts.SEND_TO_VOICEMAIL
+                        + " AS " + android.provider.Contacts.Phones.SEND_TO_VOICEMAIL + ", " +
+                Tables.RAW_CONTACTS + "." + RawContacts.STARRED
+                        + " AS " + android.provider.Contacts.Phones.STARRED + ", " +
+                RawContacts.IS_RESTRICTED +
+                " FROM " + Tables.DATA + DATA_JOINS +
+                " WHERE " + MimetypesColumns.CONCRETE_MIMETYPE + "='"
+                        + Phone.CONTENT_ITEM_TYPE + "'"
+                        + " AND " + Tables.RAW_CONTACTS + "." + RawContacts.DELETED + "=0" +
+        ";");
+
+        db.execSQL("DROP VIEW IF EXISTS " + LegacyTables.EXTENSIONS + ";");
+        db.execSQL("CREATE VIEW " + LegacyTables.EXTENSIONS + " AS SELECT " +
+                DataColumns.CONCRETE_ID
+                        + " AS " + android.provider.Contacts.Extensions._ID + ", " +
+                DataColumns.CONCRETE_RAW_CONTACT_ID
+                        + " AS " + android.provider.Contacts.Extensions.PERSON_ID + ", " +
+                ExtensionsColumns.NAME
+                        + " AS " + android.provider.Contacts.Extensions.NAME + ", " +
+                ExtensionsColumns.VALUE
+                        + " AS " + android.provider.Contacts.Extensions.VALUE + ", " +
+                RawContacts.IS_RESTRICTED +
+                " FROM " + Tables.DATA_JOIN_MIMETYPE_RAW_CONTACTS +
+                " WHERE " + MimetypesColumns.CONCRETE_MIMETYPE + "='"
+                        + android.provider.Contacts.Extensions.CONTENT_ITEM_TYPE + "'"
+                        + " AND " + Tables.RAW_CONTACTS + "." + RawContacts.DELETED + "=0" +
+        ";");
+
+        db.execSQL("DROP VIEW IF EXISTS " + LegacyTables.GROUPS + ";");
+        db.execSQL("CREATE VIEW " + LegacyTables.GROUPS + " AS SELECT " +
+                GroupsColumns.CONCRETE_ID + " AS " + android.provider.Contacts.Groups._ID + ", " +
+                Groups.TITLE + " AS " + android.provider.Contacts.Groups.NAME + ", " +
+                Groups.NOTES + " AS " + android.provider.Contacts.Groups.NOTES + " , " +
+                Groups.SYSTEM_ID + " AS " + android.provider.Contacts.Groups.SYSTEM_ID +
+                " FROM " + Tables.GROUPS +
+        ";");
+
+        db.execSQL("DROP VIEW IF EXISTS " + LegacyTables.GROUP_MEMBERSHIP + ";");
+        db.execSQL("CREATE VIEW " + LegacyTables.GROUP_MEMBERSHIP + " AS SELECT " +
+                DataColumns.CONCRETE_ID
+                        + " AS " + android.provider.Contacts.GroupMembership._ID + ", " +
+                DataColumns.CONCRETE_RAW_CONTACT_ID
+                        + " AS " + android.provider.Contacts.GroupMembership.PERSON_ID + ", " +
+                GroupMembership.GROUP_ROW_ID
+                        + " AS " + android.provider.Contacts.GroupMembership.GROUP_ID + ", " +
+                Groups.TITLE
+                        + " AS " + android.provider.Contacts.GroupMembership.NAME + ", " +
+                Groups.NOTES
+                        + " AS " + android.provider.Contacts.GroupMembership.NOTES + " , " +
+                Groups.SYSTEM_ID
+                        + " AS " + android.provider.Contacts.GroupMembership.SYSTEM_ID + ", " +
+                RawContacts.IS_RESTRICTED +
+                " FROM " + Tables.DATA_JOIN_PACKAGES_MIMETYPES_RAW_CONTACTS_GROUPS +
+                " WHERE " + MimetypesColumns.CONCRETE_MIMETYPE + "='"
+                        + GroupMembership.CONTENT_ITEM_TYPE + "'"
+                        + " AND " + Tables.RAW_CONTACTS + "." + RawContacts.DELETED + "=0" +
+        ";");
+
+        db.execSQL("DROP VIEW IF EXISTS " + LegacyTables.PHOTOS + ";");
+        db.execSQL("CREATE VIEW " + LegacyTables.PHOTOS + " AS SELECT " +
+                DataColumns.CONCRETE_ID
+                        + " AS " + android.provider.Contacts.Photos._ID + ", " +
+                DataColumns.CONCRETE_RAW_CONTACT_ID
+                        + " AS " + android.provider.Contacts.Photos.PERSON_ID + ", " +
+                Tables.DATA + "." + Photo.PHOTO
+                        + " AS " + android.provider.Contacts.Photos.DATA + ", " +
+                "legacy_photo." + LegacyPhotoData.EXISTS_ON_SERVER
+                        + " AS " + android.provider.Contacts.Photos.EXISTS_ON_SERVER + ", " +
+                "legacy_photo." + LegacyPhotoData.DOWNLOAD_REQUIRED
+                        + " AS " + android.provider.Contacts.Photos.DOWNLOAD_REQUIRED + ", " +
+                "legacy_photo." + LegacyPhotoData.LOCAL_VERSION
+                        + " AS " + android.provider.Contacts.Photos.LOCAL_VERSION + ", " +
+                "legacy_photo." + LegacyPhotoData.SYNC_ERROR
+                        + " AS " + android.provider.Contacts.Photos.SYNC_ERROR + ", " +
+                RawContacts.IS_RESTRICTED +
+                " FROM " + Tables.DATA + DATA_JOINS + LEGACY_PHOTO_JOIN +
+                " WHERE " + MimetypesColumns.CONCRETE_MIMETYPE + "='"
+                        + Photo.CONTENT_ITEM_TYPE + "'"
+                        + " AND " + Tables.RAW_CONTACTS + "." + RawContacts.DELETED + "=0" +
+        ";");
+    }
+
+    public Uri insert(Uri uri, ContentValues values) {
+        final int match = sUriMatcher.match(uri);
+        long id = 0;
+        switch (match) {
+            case PEOPLE:
+                id = insertPeople(values);
+                break;
+
+            case ORGANIZATIONS:
+                id = insertOrganization(values);
+                break;
+
+            case PEOPLE_CONTACTMETHODS: {
+                long rawContactId = Long.parseLong(uri.getPathSegments().get(1));
+                id = insertContactMethod(rawContactId, values);
+                break;
+            }
+
+            case CONTACTMETHODS: {
+                long rawContactId = getRequiredValue(values, ContactMethods.PERSON_ID);
+                id = insertContactMethod(rawContactId, values);
+                break;
+            }
+
+            case PHONES: {
+                long rawContactId = getRequiredValue(values,
+                        android.provider.Contacts.Phones.PERSON_ID);
+                id = insertPhone(rawContactId, values);
+                break;
+            }
+
+            case EXTENSIONS: {
+                long rawContactId = getRequiredValue(values,
+                        android.provider.Contacts.Extensions.PERSON_ID);
+                id = insertExtension(rawContactId, values);
+                break;
+            }
+
+            case GROUPS:
+                id = insertGroup(values);
+                break;
+
+            case GROUPMEMBERSHIP: {
+                long rawContactId = getRequiredValue(values,
+                        android.provider.Contacts.GroupMembership.PERSON_ID);
+                long groupId = getRequiredValue(values,
+                        android.provider.Contacts.GroupMembership.GROUP_ID);
+                id = insertGroupMembership(rawContactId, groupId);
+                break;
+            }
+
+            case PRESENCE: {
+                id = insertPresence(values);
+                break;
+            }
+
+            default:
+                throw new UnsupportedOperationException("Unknown uri: " + uri);
+        }
+
+        if (id < 0) {
+            return null;
+        }
+
+        final Uri result = ContentUris.withAppendedId(uri, id);
+        onChange(result);
+        return result;
+    }
+
+    private long getRequiredValue(ContentValues values, String column) {
+        if (!values.containsKey(column)) {
+            throw new RuntimeException("Required value: " + column);
+        }
+
+        return values.getAsLong(column);
+    }
+
+    private long insertPeople(ContentValues values) {
+        mValues.clear();
+
+        OpenHelper.copyStringValue(mValues, RawContacts.CUSTOM_RINGTONE,
+                values, People.CUSTOM_RINGTONE);
+        OpenHelper.copyLongValue(mValues, RawContacts.SEND_TO_VOICEMAIL,
+                values, People.SEND_TO_VOICEMAIL);
+        OpenHelper.copyLongValue(mValues, RawContacts.LAST_TIME_CONTACTED,
+                values, People.LAST_TIME_CONTACTED);
+        OpenHelper.copyLongValue(mValues, RawContacts.TIMES_CONTACTED,
+                values, People.TIMES_CONTACTED);
+        OpenHelper.copyLongValue(mValues, RawContacts.STARRED,
+                values, People.STARRED);
+        Uri contactUri = mContactsProvider.insert(RawContacts.CONTENT_URI, mValues);
+        long rawContactId = ContentUris.parseId(contactUri);
+
+        if (values.containsKey(People.NAME) || values.containsKey(People.PHONETIC_NAME)) {
+            mValues.clear();
+            mValues.put(ContactsContract.Data.RAW_CONTACT_ID, rawContactId);
+            mValues.put(ContactsContract.Data.MIMETYPE, StructuredName.CONTENT_ITEM_TYPE);
+            OpenHelper.copyStringValue(mValues, StructuredName.DISPLAY_NAME,
+                    values, People.NAME);
+            if (values.containsKey(People.PHONETIC_NAME)) {
+                String phoneticName = values.getAsString(People.PHONETIC_NAME);
+                NameSplitter.Name parsedName = new NameSplitter.Name();
+                mPhoneticNameSplitter.split(parsedName, phoneticName);
+                mValues.put(StructuredName.PHONETIC_GIVEN_NAME, parsedName.getGivenNames());
+                mValues.put(StructuredName.PHONETIC_MIDDLE_NAME, parsedName.getMiddleName());
+                mValues.put(StructuredName.PHONETIC_FAMILY_NAME, parsedName.getFamilyName());
+            }
+
+            mContactsProvider.insert(ContactsContract.Data.CONTENT_URI, mValues);
+        }
+
+        if (values.containsKey(People.NOTES)) {
+            mValues.clear();
+            mValues.put(Data.RAW_CONTACT_ID, rawContactId);
+            mValues.put(Data.MIMETYPE, Note.CONTENT_ITEM_TYPE);
+            OpenHelper.copyStringValue(mValues, Note.NOTE, values, People.NOTES);
+            mContactsProvider.insert(Data.CONTENT_URI, mValues);
+        }
+
+        // TODO instant aggregation
+        return rawContactId;
+    }
+
+    private long insertOrganization(ContentValues values) {
+        mValues.clear();
+
+        OpenHelper.copyLongValue(mValues, Data.RAW_CONTACT_ID,
+                values, android.provider.Contacts.Organizations.PERSON_ID);
+        mValues.put(Data.MIMETYPE, Organization.CONTENT_ITEM_TYPE);
+
+        OpenHelper.copyLongValue(mValues, Data.IS_PRIMARY,
+                values, android.provider.Contacts.Organizations.ISPRIMARY);
+
+        OpenHelper.copyStringValue(mValues, Organization.COMPANY,
+                values, android.provider.Contacts.Organizations.COMPANY);
+
+        // TYPE values happen to remain the same between V1 and V2 - can just copy the value
+        OpenHelper.copyLongValue(mValues, Organization.TYPE,
+                values, android.provider.Contacts.Organizations.TYPE);
+
+        OpenHelper.copyStringValue(mValues, Organization.LABEL,
+                values, android.provider.Contacts.Organizations.LABEL);
+        OpenHelper.copyStringValue(mValues, Organization.TITLE,
+                values, android.provider.Contacts.Organizations.TITLE);
+
+        Uri uri = mContactsProvider.insert(Data.CONTENT_URI, mValues);
+
+        return ContentUris.parseId(uri);
+    }
+
+    private long insertPhone(long rawContactId, ContentValues values) {
+        mValues.clear();
+
+        mValues.put(Data.RAW_CONTACT_ID, rawContactId);
+        mValues.put(Data.MIMETYPE, Phone.CONTENT_ITEM_TYPE);
+
+        OpenHelper.copyLongValue(mValues, Data.IS_PRIMARY,
+                values, android.provider.Contacts.Phones.ISPRIMARY);
+
+        OpenHelper.copyStringValue(mValues, Phone.NUMBER,
+                values, android.provider.Contacts.Phones.NUMBER);
+
+        // TYPE values happen to remain the same between V1 and V2 - can just copy the value
+        OpenHelper.copyLongValue(mValues, Phone.TYPE,
+                values, android.provider.Contacts.Phones.TYPE);
+
+        OpenHelper.copyStringValue(mValues, Phone.LABEL,
+                values, android.provider.Contacts.Phones.LABEL);
+
+        Uri uri = mContactsProvider.insert(Data.CONTENT_URI, mValues);
+
+        return ContentUris.parseId(uri);
+    }
+
+    private long insertContactMethod(long rawContactId, ContentValues values) {
+        Integer kind = values.getAsInteger(ContactMethods.KIND);
+        if (kind == null) {
+            throw new RuntimeException("Required value: " + ContactMethods.KIND);
+        }
+
+        mValues.clear();
+        mValues.put(Data.RAW_CONTACT_ID, rawContactId);
+
+        OpenHelper.copyLongValue(mValues, Data.IS_PRIMARY, values, ContactMethods.ISPRIMARY);
+
+        switch (kind) {
+            case android.provider.Contacts.KIND_EMAIL:
+                copyCommonFields(values, Email.CONTENT_ITEM_TYPE, Email.TYPE, Email.LABEL,
+                        Email.DATA, Data.DATA14);
+                break;
+
+            case android.provider.Contacts.KIND_IM:
+                copyCommonFields(values, Im.CONTENT_ITEM_TYPE, Im.TYPE, Im.LABEL,
+                        Email.DATA, Data.DATA14);
+                break;
+
+            case android.provider.Contacts.KIND_POSTAL:
+                copyCommonFields(values, StructuredPostal.CONTENT_ITEM_TYPE, StructuredPostal.TYPE,
+                        StructuredPostal.LABEL, StructuredPostal.FORMATTED_ADDRESS, Data.DATA14);
+                break;
+        }
+
+        Uri uri = mContactsProvider.insert(Data.CONTENT_URI, mValues);
+        return ContentUris.parseId(uri);
+    }
+
+    private void copyCommonFields(ContentValues values, String mimeType, String typeColumn,
+            String labelColumn, String dataColumn, String auxDataColumn) {
+        mValues.put(Data.MIMETYPE, mimeType);
+        OpenHelper.copyLongValue(mValues, typeColumn, values, ContactMethods.TYPE);
+        OpenHelper.copyStringValue(mValues, labelColumn, values, ContactMethods.LABEL);
+        OpenHelper.copyStringValue(mValues, dataColumn, values, ContactMethods.DATA);
+        OpenHelper.copyStringValue(mValues, auxDataColumn, values, ContactMethods.AUX_DATA);
+    }
+
+    private long insertExtension(long rawContactId, ContentValues values) {
+        mValues.clear();
+
+        mValues.put(Data.RAW_CONTACT_ID, rawContactId);
+        mValues.put(Data.MIMETYPE, android.provider.Contacts.Extensions.CONTENT_ITEM_TYPE);
+
+        OpenHelper.copyStringValue(mValues, ExtensionsColumns.NAME,
+                values, android.provider.Contacts.People.Extensions.NAME);
+        OpenHelper.copyStringValue(mValues, ExtensionsColumns.VALUE,
+                values, android.provider.Contacts.People.Extensions.VALUE);
+
+        Uri uri = mContactsProvider.insert(Data.CONTENT_URI, mValues);
+        return ContentUris.parseId(uri);
+    }
+
+    private long insertGroup(ContentValues values) {
+        mValues.clear();
+
+        OpenHelper.copyStringValue(mValues, Groups.TITLE,
+                values, android.provider.Contacts.Groups.NAME);
+        OpenHelper.copyStringValue(mValues, Groups.NOTES,
+                values, android.provider.Contacts.Groups.NOTES);
+        OpenHelper.copyStringValue(mValues, Groups.SYSTEM_ID,
+                values, android.provider.Contacts.Groups.SYSTEM_ID);
+
+        Uri uri = mContactsProvider.insert(Groups.CONTENT_URI, mValues);
+        return ContentUris.parseId(uri);
+    }
+
+    private long insertGroupMembership(long rawContactId, long groupId) {
+        mValues.clear();
+
+        mValues.put(Data.MIMETYPE, GroupMembership.CONTENT_ITEM_TYPE);
+        mValues.put(GroupMembership.RAW_CONTACT_ID, rawContactId);
+        mValues.put(GroupMembership.GROUP_ROW_ID, groupId);
+
+        Uri uri = mContactsProvider.insert(Data.CONTENT_URI, mValues);
+        return ContentUris.parseId(uri);
+    }
+
+    private long insertPresence(ContentValues values) {
+        mValues.clear();
+
+        OpenHelper.copyLongValue(mValues, Presence._ID,
+                values, android.provider.Contacts.Presence._ID);
+        OpenHelper.copyLongValue(mValues, Presence.RAW_CONTACT_ID,
+                values, android.provider.Contacts.Presence.PERSON_ID);
+        OpenHelper.copyStringValue(mValues, Presence.IM_PROTOCOL,
+                values, android.provider.Contacts.Presence.IM_PROTOCOL);
+        OpenHelper.copyStringValue(mValues, Presence.IM_HANDLE,
+                values, android.provider.Contacts.Presence.IM_HANDLE);
+        OpenHelper.copyStringValue(mValues, Presence.IM_ACCOUNT,
+                values, android.provider.Contacts.Presence.IM_ACCOUNT);
+        OpenHelper.copyLongValue(mValues, Presence.PRESENCE_STATUS,
+                values, android.provider.Contacts.Presence.PRESENCE_STATUS);
+        OpenHelper.copyStringValue(mValues, Presence.PRESENCE_CUSTOM_STATUS,
+                values, android.provider.Contacts.Presence.PRESENCE_CUSTOM_STATUS);
+
+        return mContactsProvider.insertPresence(mValues);
+    }
+
+    public int update(Uri uri, ContentValues values, String selection, String[] selectionArgs) {
+        final int match = sUriMatcher.match(uri);
+        int count = 0;
+        switch(match) {
+            case PEOPLE_UPDATE_CONTACT_TIME:
+                count = updateContactTime(uri, values);
+                break;
+
+            case PEOPLE_PHOTO: {
+                long rawContactId = Long.parseLong(uri.getPathSegments().get(1));
+                return updatePhoto(rawContactId, values);
+            }
+
+            case PHOTOS:
+                // TODO
+                break;
+
+            case PHOTOS_ID:
+                // TODO
+                break;
+
+
+            default:
+                throw new UnsupportedOperationException("Unknown uri: " + uri);
+        }
+
+        if (count > 0) {
+            mContext.getContentResolver().notifyChange(uri, null);
+        }
+        return count;
+    }
+
+
+    private int updateContactTime(Uri uri, ContentValues values) {
+
+        // TODO check sanctions
+
+        long lastTimeContacted;
+        if (values.containsKey(People.LAST_TIME_CONTACTED)) {
+            lastTimeContacted = values.getAsLong(People.LAST_TIME_CONTACTED);
+        } else {
+            lastTimeContacted = System.currentTimeMillis();
+        }
+
+        long rawContactId = Long.parseLong(uri.getPathSegments().get(1));
+        long contactId = mOpenHelper.getContactId(rawContactId);
+        if (contactId != 0) {
+            mContactsProvider.updateContactTime(contactId, lastTimeContacted);
+        } else {
+            mLastTimeContactedUpdate.bindLong(1, lastTimeContacted);
+            mLastTimeContactedUpdate.bindLong(2, rawContactId);
+            mLastTimeContactedUpdate.execute();
+        }
+        return 1;
+    }
+
+    private int updatePhoto(long rawContactId, ContentValues values) {
+
+        // TODO check sanctions
+
+        int count;
+
+        long dataId = -1;
+        Cursor c = mContactsProvider.query(Data.CONTENT_URI, PhotoQuery.COLUMNS,
+                Data.RAW_CONTACT_ID + "=" + rawContactId + " AND "
+                        + Data.MIMETYPE + "=" + mOpenHelper.getMimeTypeId(Photo.CONTENT_ITEM_TYPE),
+                null, null);
+        try {
+            if (c.moveToFirst()) {
+                dataId = c.getLong(PhotoQuery._ID);
+            }
+        } finally {
+            c.close();
+        }
+
+        mValues.clear();
+        byte[] bytes = values.getAsByteArray(android.provider.Contacts.Photos.DATA);
+        mValues.put(Photo.PHOTO, bytes);
+
+        if (dataId == -1) {
+            mValues.put(Data.MIMETYPE, Photo.CONTENT_ITEM_TYPE);
+            mValues.put(Data.RAW_CONTACT_ID, rawContactId);
+            Uri dataUri = mContactsProvider.insert(Data.CONTENT_URI, mValues);
+            dataId = ContentUris.parseId(dataUri);
+            count = 1;
+        } else {
+            Uri dataUri = ContentUris.withAppendedId(Data.CONTENT_URI, dataId);
+            count = mContactsProvider.update(dataUri, mValues, null, null);
+        }
+
+        mValues.clear();
+        OpenHelper.copyStringValue(mValues, LegacyPhotoData.LOCAL_VERSION,
+                values, android.provider.Contacts.Photos.LOCAL_VERSION);
+        OpenHelper.copyStringValue(mValues, LegacyPhotoData.DOWNLOAD_REQUIRED,
+                values, android.provider.Contacts.Photos.DOWNLOAD_REQUIRED);
+        OpenHelper.copyStringValue(mValues, LegacyPhotoData.EXISTS_ON_SERVER,
+                values, android.provider.Contacts.Photos.EXISTS_ON_SERVER);
+        OpenHelper.copyStringValue(mValues, LegacyPhotoData.SYNC_ERROR,
+                values, android.provider.Contacts.Photos.SYNC_ERROR);
+
+        int updated = mContactsProvider.update(Data.CONTENT_URI, mValues,
+                Data.MIMETYPE + "='" + LegacyPhotoData.CONTENT_ITEM_TYPE + "'"
+                        + " AND " + Data.RAW_CONTACT_ID + "=" + rawContactId
+                        + " AND " + LegacyPhotoData.PHOTO_DATA_ID + "=" + dataId, null);
+        if (updated == 0) {
+            mValues.put(Data.RAW_CONTACT_ID, rawContactId);
+            mValues.put(Data.MIMETYPE, LegacyPhotoData.CONTENT_ITEM_TYPE);
+            mValues.put(LegacyPhotoData.PHOTO_DATA_ID, dataId);
+            mContactsProvider.insert(Data.CONTENT_URI, mValues);
+        }
+
+        return count;
+    }
+
+    public int delete(Uri uri, String selection, String[] selectionArgs) {
+        final int match = sUriMatcher.match(uri);
+        int count = 0;
+        switch (match) {
+            case PEOPLE_ID:
+                count = mContactsProvider.deleteRawContact(ContentUris.parseId(uri), false);
+                break;
+
+            case ORGANIZATIONS_ID:
+                count = mContactsProvider.deleteData(ContentUris.parseId(uri),
+                        ORGANIZATION_MIME_TYPES);
+                break;
+
+            case CONTACTMETHODS_ID:
+                count = mContactsProvider.deleteData(ContentUris.parseId(uri),
+                        CONTACT_METHOD_MIME_TYPES);
+                break;
+
+            case PHONES_ID:
+                count = mContactsProvider.deleteData(ContentUris.parseId(uri),
+                        PHONE_MIME_TYPES);
+                break;
+
+            default:
+                throw new UnsupportedOperationException("Unknown uri: " + uri);
+        }
+
+        return count;
+    }
+
+    public Cursor query(Uri uri, String[] projection, String selection, String[] selectionArgs,
+            String sortOrder, String limit) {
+        final SQLiteDatabase db = mOpenHelper.getReadableDatabase();
+        SQLiteQueryBuilder qb = new SQLiteQueryBuilder();
+        String groupBy = null;
+
+        final int match = sUriMatcher.match(uri);
+        switch (match) {
+            case PEOPLE: {
+                qb.setTables(LegacyTables.PEOPLE_JOIN_PRESENCE);
+                qb.setProjectionMap(sPeopleProjectionMap);
+                break;
+            }
+
+            case PEOPLE_ID:
+                qb.setTables(LegacyTables.PEOPLE_JOIN_PRESENCE);
+                qb.setProjectionMap(sPeopleProjectionMap);
+                qb.appendWhere(People._ID + "=");
+                qb.appendWhere(uri.getPathSegments().get(1));
+                break;
+
+            case PEOPLE_FILTER: {
+                qb.setTables(LegacyTables.PEOPLE_JOIN_PRESENCE);
+                qb.setProjectionMap(sPeopleProjectionMap);
+                String filterParam = uri.getPathSegments().get(2);
+                qb.appendWhere(People._ID + " IN "
+                        + mContactsProvider.getRawContactsByFilterAsNestedQuery(filterParam));
+                break;
+            }
+
+            case ORGANIZATIONS:
+                qb.setTables(LegacyTables.ORGANIZATIONS);
+                qb.setProjectionMap(sOrganizationProjectionMap);
+                mContactsProvider.applyDataRestrictionExceptions(qb);
+                break;
+
+            case ORGANIZATIONS_ID:
+                qb.setTables(LegacyTables.ORGANIZATIONS);
+                qb.setProjectionMap(sOrganizationProjectionMap);
+                mContactsProvider.applyDataRestrictionExceptions(qb);
+                qb.appendWhere(" AND " + android.provider.Contacts.Organizations._ID + "=");
+                qb.appendWhere(uri.getPathSegments().get(1));
+                break;
+
+            case CONTACTMETHODS:
+                qb.setTables(LegacyTables.CONTACT_METHODS);
+                qb.setProjectionMap(sContactMethodProjectionMap);
+                mContactsProvider.applyDataRestrictionExceptions(qb);
+                break;
+
+            case CONTACTMETHODS_ID:
+                qb.setTables(LegacyTables.CONTACT_METHODS);
+                qb.setProjectionMap(sContactMethodProjectionMap);
+                mContactsProvider.applyDataRestrictionExceptions(qb);
+                qb.appendWhere(" AND " + ContactMethods._ID + "=");
+                qb.appendWhere(uri.getPathSegments().get(1));
+                break;
+
+            case PEOPLE_CONTACTMETHODS:
+                qb.setTables(LegacyTables.CONTACT_METHODS);
+                qb.setProjectionMap(sContactMethodProjectionMap);
+                mContactsProvider.applyDataRestrictionExceptions(qb);
+                qb.appendWhere(" AND " + ContactMethods.PERSON_ID + "=");
+                qb.appendWhere(uri.getPathSegments().get(1));
+                qb.appendWhere(" AND " + ContactMethods.KIND + " IS NOT NULL");
+                break;
+
+            case PEOPLE_CONTACTMETHODS_ID:
+                qb.setTables(LegacyTables.CONTACT_METHODS);
+                qb.setProjectionMap(sContactMethodProjectionMap);
+                mContactsProvider.applyDataRestrictionExceptions(qb);
+                qb.appendWhere(" AND " + ContactMethods.PERSON_ID + "=");
+                qb.appendWhere(uri.getPathSegments().get(1));
+                qb.appendWhere(" AND " + ContactMethods._ID + "=");
+                qb.appendWhere(uri.getPathSegments().get(3));
+                qb.appendWhere(" AND " + ContactMethods.KIND + " IS NOT NULL");
+                break;
+
+            case PHONES:
+                qb.setTables(LegacyTables.PHONES);
+                qb.setProjectionMap(sPhoneProjectionMap);
+                mContactsProvider.applyDataRestrictionExceptions(qb);
+                break;
+
+            case PHONES_ID:
+                qb.setTables(LegacyTables.PHONES);
+                qb.setProjectionMap(sPhoneProjectionMap);
+                mContactsProvider.applyDataRestrictionExceptions(qb);
+                qb.appendWhere(" AND " + android.provider.Contacts.Phones._ID + "=");
+                qb.appendWhere(uri.getPathSegments().get(1));
+                break;
+
+            case PEOPLE_PHONES:
+                qb.setTables(LegacyTables.PHONES);
+                qb.setProjectionMap(sPhoneProjectionMap);
+                mContactsProvider.applyDataRestrictionExceptions(qb);
+                qb.appendWhere(" AND " + android.provider.Contacts.Phones.PERSON_ID + "=");
+                qb.appendWhere(uri.getPathSegments().get(1));
+                break;
+
+            case PEOPLE_PHONES_ID:
+                qb.setTables(LegacyTables.PHONES);
+                qb.setProjectionMap(sPhoneProjectionMap);
+                mContactsProvider.applyDataRestrictionExceptions(qb);
+                qb.appendWhere(" AND " + android.provider.Contacts.Phones.PERSON_ID + "=");
+                qb.appendWhere(uri.getPathSegments().get(1));
+                qb.appendWhere(" AND " + android.provider.Contacts.Phones._ID + "=");
+                qb.appendWhere(uri.getPathSegments().get(3));
+                break;
+
+            case EXTENSIONS:
+                qb.setTables(LegacyTables.EXTENSIONS);
+                qb.setProjectionMap(sExtensionProjectionMap);
+                mContactsProvider.applyDataRestrictionExceptions(qb);
+                break;
+
+            case EXTENSIONS_ID:
+                qb.setTables(LegacyTables.EXTENSIONS);
+                qb.setProjectionMap(sExtensionProjectionMap);
+                mContactsProvider.applyDataRestrictionExceptions(qb);
+                qb.appendWhere(" AND " + android.provider.Contacts.Extensions._ID + "=");
+                qb.appendWhere(uri.getPathSegments().get(1));
+                break;
+
+            case PEOPLE_EXTENSIONS:
+                qb.setTables(LegacyTables.EXTENSIONS);
+                qb.setProjectionMap(sExtensionProjectionMap);
+                mContactsProvider.applyDataRestrictionExceptions(qb);
+                qb.appendWhere(" AND " + android.provider.Contacts.Extensions.PERSON_ID + "=");
+                qb.appendWhere(uri.getPathSegments().get(1));
+                break;
+
+            case PEOPLE_EXTENSIONS_ID:
+                qb.setTables(LegacyTables.EXTENSIONS);
+                qb.setProjectionMap(sExtensionProjectionMap);
+                mContactsProvider.applyDataRestrictionExceptions(qb);
+                qb.appendWhere(" AND " + android.provider.Contacts.Extensions.PERSON_ID + "=");
+                qb.appendWhere(uri.getPathSegments().get(1));
+                qb.appendWhere(" AND " + android.provider.Contacts.Extensions._ID + "=");
+                qb.appendWhere(uri.getPathSegments().get(3));
+                break;
+
+            case GROUPS:
+                qb.setTables(LegacyTables.GROUPS);
+                qb.setProjectionMap(sGroupProjectionMap);
+                break;
+
+            case GROUPS_ID:
+                qb.setTables(LegacyTables.GROUPS);
+                qb.setProjectionMap(sGroupProjectionMap);
+                qb.appendWhere(android.provider.Contacts.Groups._ID + "=");
+                qb.appendWhere(uri.getPathSegments().get(1));
+                break;
+
+            case GROUPMEMBERSHIP:
+                qb.setTables(LegacyTables.GROUP_MEMBERSHIP);
+                qb.setProjectionMap(sGroupMembershipProjectionMap);
+                mContactsProvider.applyDataRestrictionExceptions(qb);
+                break;
+
+            case GROUPMEMBERSHIP_ID:
+                qb.setTables(LegacyTables.GROUP_MEMBERSHIP);
+                qb.setProjectionMap(sGroupMembershipProjectionMap);
+                mContactsProvider.applyDataRestrictionExceptions(qb);
+                qb.appendWhere(" AND " + android.provider.Contacts.GroupMembership._ID + "=");
+                qb.appendWhere(uri.getPathSegments().get(1));
+                break;
+
+            case PEOPLE_GROUPMEMBERSHIP:
+                qb.setTables(LegacyTables.GROUP_MEMBERSHIP);
+                qb.setProjectionMap(sGroupMembershipProjectionMap);
+                mContactsProvider.applyDataRestrictionExceptions(qb);
+                qb.appendWhere(" AND " + android.provider.Contacts.GroupMembership.PERSON_ID + "=");
+                qb.appendWhere(uri.getPathSegments().get(1));
+                break;
+
+            case PEOPLE_GROUPMEMBERSHIP_ID:
+                qb.setTables(LegacyTables.GROUP_MEMBERSHIP);
+                qb.setProjectionMap(sGroupMembershipProjectionMap);
+                mContactsProvider.applyDataRestrictionExceptions(qb);
+                qb.appendWhere(" AND " + android.provider.Contacts.GroupMembership.PERSON_ID + "=");
+                qb.appendWhere(uri.getPathSegments().get(1));
+                qb.appendWhere(" AND " + android.provider.Contacts.GroupMembership._ID + "=");
+                qb.appendWhere(uri.getPathSegments().get(3));
+                break;
+
+            case PEOPLE_PHOTO:
+                qb.setTables(LegacyTables.PHOTOS);
+                qb.setProjectionMap(sPhotoProjectionMap);
+                mContactsProvider.applyDataRestrictionExceptions(qb);
+                qb.appendWhere(" AND " + android.provider.Contacts.Photos.PERSON_ID + "=");
+                qb.appendWhere(uri.getPathSegments().get(1));
+                limit = "1";
+                break;
+
+            case PRESENCE:
+                qb.setTables(Tables.PRESENCE);
+                qb.setProjectionMap(sPresenceProjectionMap);
+                qb.appendWhere(mContactsProvider.getContactsRestrictionExceptionAsNestedQuery(
+                        android.provider.Contacts.Presence.PERSON_ID));
+                break;
+
+            case PRESENCE_ID:
+                qb.setTables(Tables.PRESENCE);
+                qb.setProjectionMap(sPresenceProjectionMap);
+                qb.appendWhere(mContactsProvider.getContactsRestrictionExceptionAsNestedQuery(
+                        android.provider.Contacts.Presence.PERSON_ID));
+                qb.appendWhere(" AND " + android.provider.Contacts.Presence._ID + "=");
+                qb.appendWhere(uri.getPathSegments().get(1));
+                break;
+
+            case SEARCH_SUGGESTIONS:
+
+                // No legacy compatibility for search suggestions
+                return mGlobalSearchSupport.handleSearchSuggestionsQuery(db, uri, limit);
+
+            case DELETED_PEOPLE:
+            case DELETED_GROUPS:
+                throw new UnsupportedOperationException();
+
+            default:
+                throw new IllegalArgumentException("Unknown URL " + uri);
+        }
+
+        // Perform the query and set the notification uri
+        final Cursor c = qb.query(db, projection, selection, selectionArgs,
+                groupBy, null, sortOrder, limit);
+        if (c != null) {
+            c.setNotificationUri(mContext.getContentResolver(), RawContacts.CONTENT_URI);
+        }
+        DatabaseUtils.dumpCursor(c);
+        return c;
+    }
+
+    /**
+     * Called when a change has been made.
+     *
+     * @param uri the uri that the change was made to
+     */
+    private void onChange(Uri uri) {
+        mContext.getContentResolver().notifyChange(android.provider.Contacts.CONTENT_URI, null);
+    }
+}
diff --git a/src/com/android/providers/contacts/NameNormalizer.java b/src/com/android/providers/contacts/NameNormalizer.java
new file mode 100644
index 0000000..eca40fc
--- /dev/null
+++ b/src/com/android/providers/contacts/NameNormalizer.java
@@ -0,0 +1,83 @@
+/*
+ * 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.ibm.icu4jni.text.CollationAttribute;
+import com.ibm.icu4jni.text.Collator;
+import com.ibm.icu4jni.text.RuleBasedCollator;
+
+/**
+ * Converts a name to a normalized form by removing all non-letter characters and normalizing
+ * UNICODE according to http://unicode.org/unicode/reports/tr15
+ */
+public class NameNormalizer {
+
+    private static final RuleBasedCollator sCompressingCollator;
+    static {
+        sCompressingCollator = (RuleBasedCollator)Collator.getInstance(null);
+        sCompressingCollator.setStrength(Collator.PRIMARY);
+        sCompressingCollator.setDecomposition(Collator.CANONICAL_DECOMPOSITION);
+    }
+
+    private static final RuleBasedCollator sComplexityCollator;
+    static {
+        sComplexityCollator = (RuleBasedCollator)Collator.getInstance(null);
+        sComplexityCollator.setStrength(Collator.TERTIARY);
+        sComplexityCollator.setAttribute(CollationAttribute.CASE_FIRST,
+                CollationAttribute.VALUE_LOWER_FIRST);
+    }
+
+    /**
+     * Converts the supplied name to a string that can be used to perform approximate matching
+     * of names.  It ignores non-letter characters and removes accents.
+     */
+    public static String normalize(String name) {
+        return Hex.encodeHex(sCompressingCollator.getSortKey(lettersOnly(name)), true);
+    }
+
+    /**
+     * Compares "complexity" of two names, which is determined by the presence
+     * of mixed case characters, accents and, if all else is equal, length.
+     */
+    public static int compareComplexity(String name1, String name2) {
+        int diff = sComplexityCollator.compare(lettersOnly(name1), lettersOnly(name2));
+        if (diff != 0) {
+            return diff;
+        }
+
+        return name1.length() - name2.length();
+    }
+
+    /**
+     * Returns a string containing just the letters from the original string.
+     */
+    private static String lettersOnly(String name) {
+        char[] letters = name.toCharArray();
+        int length = 0;
+        for (int i = 0; i < letters.length; i++) {
+            final char c = letters[i];
+            if (Character.isLetter(c)) {
+                letters[length++] = c;
+            }
+        }
+
+        if (length != letters.length) {
+            return new String(letters, 0, length);
+        }
+
+        return name;
+    }
+}
diff --git a/src/com/android/providers/contacts/NameSplitter.java b/src/com/android/providers/contacts/NameSplitter.java
new file mode 100644
index 0000000..aad3bc5
--- /dev/null
+++ b/src/com/android/providers/contacts/NameSplitter.java
@@ -0,0 +1,297 @@
+/*
+ * 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 java.util.HashSet;
+import java.util.StringTokenizer;
+
+/**
+ * The purpose of this class is to split a full name into given names and last
+ * name. The logic only supports having a single last name. If the full name has
+ * multiple last names the output will be incorrect.
+ * <p>
+ * Core algorithm:
+ * <ol>
+ * <li>Remove the suffixes (III, Ph.D., M.D.).</li>
+ * <li>Remove the prefixes (Mr., Pastor, Reverend, Sir).</li>
+ * <li>Assign the last remaining token as the last name.</li>
+ * <li>If the previous word to the last name is one from LASTNAME_PREFIXES, use
+ * this word also as the last name.</li>
+ * <li>Assign the rest of the words as the "given names".</li>
+ * </ol>
+ */
+public class NameSplitter {
+
+    private final HashSet<String> mPrefixesSet;
+    private final HashSet<String> mSuffixesSet;
+    private final int mMaxSuffixLength;
+    private final HashSet<String> mLastNamePrefixesSet;
+    private final HashSet<String> mConjuctions;
+
+    public static class Name {
+        private String prefix;
+        private String givenNames;
+        private String middleName;
+        private String familyName;
+        private String suffix;
+
+        public String getPrefix() {
+            return prefix;
+        }
+
+        public String getGivenNames() {
+            return givenNames;
+        }
+
+        public String getMiddleName() {
+            return middleName;
+        }
+
+        public String getFamilyName() {
+            return familyName;
+        }
+
+        public String getSuffix() {
+            return suffix;
+        }
+    }
+
+    private static class NameTokenizer extends StringTokenizer {
+        private static final int MAX_TOKENS = 10;
+        private final String[] mTokens;
+        private int mDotBitmask;
+        private int mStartPointer;
+        private int mEndPointer;
+
+        public NameTokenizer(String fullName) {
+            super(fullName, " .,", true);
+
+            mTokens = new String[MAX_TOKENS];
+
+            // Iterate over tokens, skipping over empty ones and marking tokens that
+            // are followed by dots.
+            while (hasMoreTokens() && mEndPointer < MAX_TOKENS) {
+                final String token = nextToken();
+                if (token.length() > 0) {
+                    final char c = token.charAt(0);
+                    if (c == ' ' || c == ',') {
+                        continue;
+                    }
+                }
+
+                if (mEndPointer > 0 && token.charAt(0) == '.') {
+                    mDotBitmask |= (1 << (mEndPointer - 1));
+                } else {
+                    mTokens[mEndPointer] = token;
+                    mEndPointer++;
+                }
+            }
+        }
+
+        /**
+         * Returns true if the token is followed by a dot in the original full name.
+         */
+        public boolean hasDot(int index) {
+            return (mDotBitmask & (1 << index)) != 0;
+        }
+    }
+
+    /**
+     * Constructor.
+     *
+     * @param commonPrefixes comma-separated list of common prefixes,
+     *            e.g. "Mr, Ms, Mrs"
+     * @param commonLastNamePrefixes comma-separated list of common last name prefixes,
+     *           e.g. "d', st, st., von"
+     * @param commonSuffixes comma-separated list of common suffixes,
+     *            e.g. "Jr, M.D., MD, D.D.S."
+     * @param commonConjunctions comma-separated list of common conjuctions,
+     *            e.g. "AND, Or"
+     */
+    public NameSplitter(String commonPrefixes, String commonLastNamePrefixes,
+            String commonSuffixes, String commonConjunctions) {
+        mPrefixesSet = convertToSet(commonPrefixes);
+        mLastNamePrefixesSet = convertToSet(commonLastNamePrefixes);
+        mSuffixesSet = convertToSet(commonSuffixes);
+        mConjuctions = convertToSet(commonConjunctions);
+
+        int maxLength = 0;
+        for (String suffix : mSuffixesSet) {
+            if (suffix.length() > maxLength) {
+                maxLength = suffix.length();
+            }
+        }
+
+        mMaxSuffixLength = maxLength;
+    }
+
+    /**
+     * Converts a comma-separated list of Strings to a set of Strings. Trims strings
+     * and converts them to upper case.
+     */
+    private static HashSet<String> convertToSet(String strings) {
+        HashSet<String> set = new HashSet<String>();
+        if (strings != null) {
+            String[] split = strings.split(",");
+            for (int i = 0; i < split.length; i++) {
+                set.add(split[i].trim().toUpperCase());
+            }
+        }
+        return set;
+    }
+
+    /**
+     * Parses a full name and returns parsed components in the Name object.
+     */
+    public void split(Name name, String fullName) {
+        if (fullName == null) {
+            return;
+        }
+
+        NameTokenizer tokens = new NameTokenizer(fullName);
+        parsePrefix(name, tokens);
+        parseSuffix(name, tokens);
+        parseLastName(name, tokens);
+        parseMiddleName(name, tokens);
+        parseGivenNames(name, tokens);
+    }
+
+    /**
+     * Parses the first word from the name if it is a prefix.
+     */
+    private void parsePrefix(Name name, NameTokenizer tokens) {
+        if (tokens.mStartPointer == tokens.mEndPointer) {
+            return;
+        }
+
+        String firstToken = tokens.mTokens[tokens.mStartPointer];
+        if (mPrefixesSet.contains(firstToken.toUpperCase())) {
+            name.prefix = firstToken;
+            tokens.mStartPointer++;
+        }
+    }
+
+    /**
+     * Parses the last word(s) from the name if it is a suffix.
+     */
+    private void parseSuffix(Name name, NameTokenizer tokens) {
+        if (tokens.mStartPointer == tokens.mEndPointer) {
+            return;
+        }
+
+        String lastToken = tokens.mTokens[tokens.mEndPointer - 1];
+        if (lastToken.length() > mMaxSuffixLength) {
+            return;
+        }
+
+        String normalized = lastToken.toUpperCase();
+        if (mSuffixesSet.contains(normalized)) {
+            name.suffix = lastToken;
+            tokens.mEndPointer--;
+            return;
+        }
+
+        if (tokens.hasDot(tokens.mEndPointer - 1)) {
+            lastToken += '.';
+        }
+        normalized += ".";
+
+        // Take care of suffixes like M.D. and D.D.S.
+        int pos = tokens.mEndPointer - 1;
+        while (normalized.length() <= mMaxSuffixLength) {
+
+            if (mSuffixesSet.contains(normalized)) {
+                name.suffix = lastToken;
+                tokens.mEndPointer = pos;
+                return;
+            }
+
+            if (pos == tokens.mStartPointer) {
+                break;
+            }
+
+            pos--;
+            if (tokens.hasDot(pos)) {
+                lastToken = tokens.mTokens[pos] + "." + lastToken;
+            } else {
+                lastToken = tokens.mTokens[pos] + " " + lastToken;
+            }
+
+            normalized = tokens.mTokens[pos].toUpperCase() + "." + normalized;
+        }
+    }
+
+    private void parseLastName(Name name, NameTokenizer tokens) {
+        if (tokens.mStartPointer == tokens.mEndPointer) {
+            return;
+        }
+
+        name.familyName = tokens.mTokens[tokens.mEndPointer - 1];
+        tokens.mEndPointer--;
+
+        // Take care of last names like "D'Onofrio" and "von Cliburn"
+        if ((tokens.mEndPointer - tokens.mStartPointer) > 0) {
+            String lastNamePrefix = tokens.mTokens[tokens.mEndPointer - 1];
+            final String normalized = lastNamePrefix.toUpperCase();
+            if (mLastNamePrefixesSet.contains(normalized)
+                    || mLastNamePrefixesSet.contains(normalized + ".")) {
+                if (tokens.hasDot(tokens.mEndPointer - 1)) {
+                    lastNamePrefix += '.';
+                }
+                name.familyName = lastNamePrefix + " " + name.familyName;
+                tokens.mEndPointer--;
+            }
+        }
+    }
+
+
+    private void parseMiddleName(Name name, NameTokenizer tokens) {
+        if (tokens.mStartPointer == tokens.mEndPointer) {
+            return;
+        }
+
+        if ((tokens.mEndPointer - tokens.mStartPointer) > 1) {
+            if ((tokens.mEndPointer - tokens.mStartPointer) == 2
+                    || !mConjuctions.contains(tokens.mTokens[tokens.mEndPointer - 2].
+                            toUpperCase())) {
+                name.middleName = tokens.mTokens[tokens.mEndPointer - 1];
+                tokens.mEndPointer--;
+            }
+        }
+    }
+
+    private void parseGivenNames(Name name, NameTokenizer tokens) {
+        if (tokens.mStartPointer == tokens.mEndPointer) {
+            return;
+        }
+
+        if ((tokens.mEndPointer - tokens.mStartPointer) == 1) {
+            name.givenNames = tokens.mTokens[tokens.mStartPointer];
+        } else {
+            StringBuilder sb = new StringBuilder();
+            for (int i = tokens.mStartPointer; i < tokens.mEndPointer; i++) {
+                if (i != tokens.mStartPointer) {
+                    sb.append(' ');
+                }
+                sb.append(tokens.mTokens[i]);
+                if (tokens.hasDot(i)) {
+                    sb.append('.');
+                }
+            }
+            name.givenNames = sb.toString();
+        }
+    }
+}
diff --git a/src/com/android/providers/contacts/OpenHelper.java b/src/com/android/providers/contacts/OpenHelper.java
new file mode 100644
index 0000000..01c41d4
--- /dev/null
+++ b/src/com/android/providers/contacts/OpenHelper.java
@@ -0,0 +1,1178 @@
+/*
+ * 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.internal.content.SyncStateContentProviderHelper;
+
+import android.content.ContentValues;
+import android.content.Context;
+import android.content.pm.ApplicationInfo;
+import android.content.pm.PackageManager;
+import android.content.pm.PackageManager.NameNotFoundException;
+import android.database.Cursor;
+import android.database.DatabaseUtils;
+import android.database.sqlite.SQLiteDatabase;
+import android.database.sqlite.SQLiteDoneException;
+import android.database.sqlite.SQLiteException;
+import android.database.sqlite.SQLiteOpenHelper;
+import android.database.sqlite.SQLiteQueryBuilder;
+import android.database.sqlite.SQLiteStatement;
+import android.provider.BaseColumns;
+import android.provider.CallLog.Calls;
+import android.provider.ContactsContract.AggregationExceptions;
+import android.provider.ContactsContract.Contacts;
+import android.provider.ContactsContract.Data;
+import android.provider.ContactsContract.Groups;
+import android.provider.ContactsContract.Presence;
+import android.provider.ContactsContract.RawContacts;
+import android.provider.ContactsContract.CommonDataKinds.Email;
+import android.provider.ContactsContract.CommonDataKinds.GroupMembership;
+import android.provider.ContactsContract.CommonDataKinds.Im;
+import android.provider.ContactsContract.CommonDataKinds.Phone;
+import android.provider.SocialContract.Activities;
+import android.telephony.PhoneNumberUtils;
+import android.util.Log;
+
+import java.util.HashMap;
+
+/**
+ * Database open helper for contacts and social activity data. Designed as a
+ * singleton to make sure that all {@link android.content.ContentProvider} users get the same
+ * reference. Provides handy methods for maintaining package and mime-type
+ * lookup tables.
+ */
+/* package */ class OpenHelper extends SQLiteOpenHelper {
+    private static final String TAG = "OpenHelper";
+
+    private static final int DATABASE_VERSION = 58;
+    private static final String DATABASE_NAME = "contacts2.db";
+    private static final String DATABASE_PRESENCE = "presence_db";
+
+    public interface Delegate {
+        void createDatabase(SQLiteDatabase db);
+    }
+
+    public interface Tables {
+        public static final String ACCOUNTS = "accounts";
+        public static final String CONTACTS = "contacts";
+        public static final String RAW_CONTACTS = "raw_contacts";
+        public static final String PACKAGES = "packages";
+        public static final String MIMETYPES = "mimetypes";
+        public static final String PHONE_LOOKUP = "phone_lookup";
+        public static final String NAME_LOOKUP = "name_lookup";
+        public static final String AGGREGATION_EXCEPTIONS = "agg_exceptions";
+        public static final String DATA = "data";
+        public static final String GROUPS = "groups";
+        public static final String PRESENCE = "presence";
+        public static final String NICKNAME_LOOKUP = "nickname_lookup";
+        public static final String CALLS = "calls";
+        public static final String CONTACT_ENTITIES = "contact_entities_view";
+
+        public static final String CONTACTS_JOIN_PRESENCE_PRIMARY_PHONE = "contacts "
+                + "LEFT OUTER JOIN raw_contacts ON (contacts._id = raw_contacts.contact_id) "
+                + "LEFT OUTER JOIN presence ON (raw_contacts._id = presence.raw_contact_id) "
+                + "LEFT OUTER JOIN data ON (primary_phone_id = data._id)";
+
+        public static final String DATA_JOIN_MIMETYPES = "data "
+                + "LEFT OUTER JOIN mimetypes ON (data.mimetype_id = mimetypes._id)";
+
+        public static final String DATA_JOIN_MIMETYPE_RAW_CONTACTS = "data "
+                + "JOIN mimetypes ON (data.mimetype_id = mimetypes._id) "
+                + "JOIN raw_contacts ON (data.raw_contact_id = raw_contacts._id)";
+
+        public static final String DATA_JOIN_RAW_CONTACTS_GROUPS = "data "
+                + "LEFT OUTER JOIN raw_contacts ON (data.raw_contact_id = raw_contacts._id)"
+                + "LEFT OUTER JOIN groups ON (groups._id = data." + GroupMembership.GROUP_ROW_ID
+                + ")";
+
+        public static final String DATA_JOIN_PACKAGES_MIMETYPES_RAW_CONTACTS = "data "
+                + "LEFT OUTER JOIN packages ON (data.package_id = packages._id) "
+                + "LEFT OUTER JOIN mimetypes ON (data.mimetype_id = mimetypes._id) "
+                + "LEFT OUTER JOIN raw_contacts ON (data.raw_contact_id = raw_contacts._id)";
+
+        public static final String DATA_JOIN_PACKAGES_MIMETYPES_RAW_CONTACTS_CONTACTS = "data "
+                + "LEFT OUTER JOIN packages ON (data.package_id = packages._id) "
+                + "LEFT OUTER JOIN mimetypes ON (data.mimetype_id = mimetypes._id) "
+                + "LEFT OUTER JOIN raw_contacts ON (data.raw_contact_id = raw_contacts._id) "
+                + "LEFT OUTER JOIN contacts ON (raw_contacts.contact_id = contacts._id)";
+
+        public static final String RAW_CONTACTS_JOIN_CONTACTS = "raw_contacts "
+                + "LEFT OUTER JOIN contacts ON (raw_contacts.contact_id = contacts._id)";
+
+        public static final String DATA_JOIN_MIMETYPES_RAW_CONTACTS_CONTACTS = "data "
+                + "LEFT OUTER JOIN mimetypes ON (data.mimetype_id = mimetypes._id) "
+                + "LEFT OUTER JOIN raw_contacts ON (data.raw_contact_id = raw_contacts._id) "
+                + "LEFT OUTER JOIN contacts ON (raw_contacts.contact_id = contacts._id)";
+
+        public static final String DATA_INNER_JOIN_MIMETYPES_RAW_CONTACTS_CONTACTS = "data "
+                + "JOIN mimetypes ON (data.mimetype_id = mimetypes._id) "
+                + "JOIN raw_contacts ON (data.raw_contact_id = raw_contacts._id) "
+                + "JOIN contacts ON (raw_contacts.contact_id = contacts._id)";
+
+        public static final String DATA_JOIN_PACKAGES_MIMETYPES_RAW_CONTACTS_CONTACTS_GROUPS =
+                "data "
+                + "LEFT OUTER JOIN packages ON (data.package_id = packages._id) "
+                + "LEFT OUTER JOIN mimetypes ON (data.mimetype_id = mimetypes._id) "
+                + "LEFT OUTER JOIN groups "
+                + "  ON (mimetypes.mimetype='" + GroupMembership.CONTENT_ITEM_TYPE + "' "
+                + "      AND groups._id = data." + GroupMembership.GROUP_ROW_ID + ") "
+                + "LEFT OUTER JOIN raw_contacts ON (data.raw_contact_id = raw_contacts._id) "
+                + "LEFT OUTER JOIN contacts ON (raw_contacts.contact_id = contacts._id)";
+
+        public static final String DATA_JOIN_PACKAGES_MIMETYPES_RAW_CONTACTS_GROUPS = "data "
+                + "LEFT OUTER JOIN packages ON (data.package_id = packages._id) "
+                + "LEFT OUTER JOIN mimetypes ON (data.mimetype_id = mimetypes._id) "
+                + "LEFT OUTER JOIN raw_contacts ON (data.raw_contact_id = raw_contacts._id) "
+                + "LEFT OUTER JOIN groups "
+                + "  ON (mimetypes.mimetype='" + GroupMembership.CONTENT_ITEM_TYPE + "' "
+                + "      AND groups._id = data." + GroupMembership.GROUP_ROW_ID + ") ";
+
+        public static final String GROUPS_JOIN_PACKAGES = "groups "
+                + "LEFT OUTER JOIN packages ON (groups.package_id = packages._id)";
+
+        public static final String GROUPS_JOIN_PACKAGES_DATA_RAW_CONTACTS_CONTACTS = "groups "
+                + "LEFT OUTER JOIN packages ON (groups.package_id = packages._id) "
+                + "LEFT OUTER JOIN data "
+                + "  ON (groups._id = data." + GroupMembership.GROUP_ROW_ID + ") "
+                + "LEFT OUTER JOIN raw_contacts ON (data.raw_contact_id = raw_contacts._id) "
+                + "LEFT OUTER JOIN contacts ON (raw_contacts.contact_id = contacts._id)";
+
+        public static final String ACTIVITIES = "activities";
+
+        public static final String ACTIVITIES_JOIN_MIMETYPES = "activities "
+                + "LEFT OUTER JOIN mimetypes ON (activities.mimetype_id = mimetypes._id)";
+
+        public static final String ACTIVITIES_JOIN_PACKAGES_MIMETYPES_RAW_CONTACTS_CONTACTS =
+                "activities "
+                + "LEFT OUTER JOIN packages ON (activities.package_id = packages._id) "
+                + "LEFT OUTER JOIN mimetypes ON (activities.mimetype_id = mimetypes._id) "
+                + "LEFT OUTER JOIN raw_contacts ON (activities.author_contact_id = " +
+                		"raw_contacts._id) "
+                + "LEFT OUTER JOIN contacts ON (raw_contacts.contact_id = contacts._id)";
+
+        public static final String NAME_LOOKUP_JOIN_RAW_CONTACTS = "name_lookup "
+                + "INNER JOIN raw_contacts ON (name_lookup.raw_contact_id = raw_contacts._id)";
+
+        public static final String AGGREGATION_EXCEPTIONS_JOIN_RAW_CONTACTS = "agg_exceptions "
+                + "INNER JOIN raw_contacts raw_contacts1 "
+                + "ON (agg_exceptions.raw_contact_id1 = raw_contacts1._id) ";
+
+        public static final String AGGREGATION_EXCEPTIONS_JOIN_RAW_CONTACTS_TWICE =
+                "agg_exceptions "
+                + "INNER JOIN raw_contacts raw_contacts1 "
+                + "ON (agg_exceptions.raw_contact_id1 = raw_contacts1._id) "
+                + "INNER JOIN raw_contacts raw_contacts2 "
+                + "ON (agg_exceptions.raw_contact_id2 = raw_contacts2._id) ";
+    }
+
+    public interface Clauses {
+        public static final String WHERE_IM_MATCHES = MimetypesColumns.MIMETYPE + "=" + Im.MIMETYPE
+                + " AND " + Im.PROTOCOL + "=? AND " + Im.DATA + "=?";
+
+        public static final String WHERE_EMAIL_MATCHES = MimetypesColumns.MIMETYPE + "="
+                + Email.MIMETYPE + " AND " + Email.DATA + "=?";
+
+        public static final String MIMETYPE_IS_GROUP_MEMBERSHIP = MimetypesColumns.CONCRETE_MIMETYPE
+                + "='" + GroupMembership.CONTENT_ITEM_TYPE + "'";
+
+        public static final String BELONGS_TO_GROUP = DataColumns.CONCRETE_GROUP_ID + "="
+                + GroupsColumns.CONCRETE_ID;
+
+        public static final String HAS_PRIMARY_PHONE = "("
+                + ContactsColumns.OPTIMAL_PRIMARY_PHONE_ID + " IS NOT NULL OR "
+                + ContactsColumns.FALLBACK_PRIMARY_PHONE_ID + " IS NOT NULL)";
+
+        // TODO: add in check against package_visible
+        public static final String IN_VISIBLE_GROUP = "SELECT MIN(COUNT(" + DataColumns.CONCRETE_ID
+                + "),1) FROM " + Tables.DATA_JOIN_RAW_CONTACTS_GROUPS + " WHERE "
+                + DataColumns.MIMETYPE_ID + "=? AND " + RawContacts.CONTACT_ID + "="
+                + ContactsColumns.CONCRETE_ID + " AND " + Groups.GROUP_VISIBLE + "=1";
+
+        public static final String GROUP_HAS_ACCOUNT_AND_SOURCE_ID =
+                Groups.SOURCE_ID + "=? AND "
+                        + Groups.ACCOUNT_NAME + "=? AND "
+                        + Groups.ACCOUNT_TYPE + "=?";
+    }
+
+    public interface ContactsColumns {
+        public static final String OPTIMAL_PRIMARY_PHONE_ID = "optimal_phone_id";
+        public static final String OPTIMAL_PRIMARY_PHONE_IS_RESTRICTED =
+                "optimal_phone_is_restricted";
+        public static final String FALLBACK_PRIMARY_PHONE_ID = "fallback_phone_id";
+
+        public static final String OPTIMAL_PRIMARY_EMAIL_ID = "optimal_email_id";
+        public static final String OPTIMAL_PRIMARY_EMAIL_IS_RESTRICTED =
+                "optimal_email_is_restricted";
+        public static final String FALLBACK_PRIMARY_EMAIL_ID = "fallback_email_id";
+
+        public static final String SINGLE_IS_RESTRICTED = "single_is_restricted";
+
+        public static final String CONCRETE_ID = Tables.CONTACTS + "." + BaseColumns._ID;
+        public static final String CONCRETE_DISPLAY_NAME = Tables.CONTACTS + "."
+                + Contacts.DISPLAY_NAME;
+
+        public static final String CONCRETE_TIMES_CONTACTED = Tables.CONTACTS + "."
+                + Contacts.TIMES_CONTACTED;
+        public static final String CONCRETE_LAST_TIME_CONTACTED = Tables.CONTACTS + "."
+                + Contacts.LAST_TIME_CONTACTED;
+        public static final String CONCRETE_STARRED = Tables.CONTACTS + "." + Contacts.STARRED;
+        public static final String CONCRETE_CUSTOM_RINGTONE = Tables.CONTACTS + "."
+                + Contacts.CUSTOM_RINGTONE;
+        public static final String CONCRETE_SEND_TO_VOICEMAIL = Tables.CONTACTS + "."
+                + Contacts.SEND_TO_VOICEMAIL;
+    }
+
+    public interface RawContactsColumns {
+        public static final String CONCRETE_ID =
+                Tables.RAW_CONTACTS + "." + BaseColumns._ID;
+        public static final String CONCRETE_ACCOUNT_NAME =
+                Tables.RAW_CONTACTS + "." + RawContacts.ACCOUNT_NAME;
+        public static final String CONCRETE_ACCOUNT_TYPE =
+                Tables.RAW_CONTACTS + "." + RawContacts.ACCOUNT_TYPE;
+        public static final String CONCRETE_SOURCE_ID =
+                Tables.RAW_CONTACTS + "." + RawContacts.SOURCE_ID;
+        public static final String CONCRETE_VERSION =
+                Tables.RAW_CONTACTS + "." + RawContacts.VERSION;
+        public static final String CONCRETE_DIRTY =
+                Tables.RAW_CONTACTS + "." + RawContacts.DIRTY;
+        public static final String CONCRETE_DELETED =
+                Tables.RAW_CONTACTS + "." + RawContacts.DELETED;
+        public static final String DISPLAY_NAME = "display_name";
+    }
+
+    public interface DataColumns {
+        public static final String PACKAGE_ID = "package_id";
+        public static final String MIMETYPE_ID = "mimetype_id";
+
+        public static final String CONCRETE_ID = Tables.DATA + "." + BaseColumns._ID;
+        public static final String CONCRETE_MIMETYPE_ID = Tables.DATA + "." + MIMETYPE_ID;
+        public static final String CONCRETE_RAW_CONTACT_ID = Tables.DATA + "."
+                + Data.RAW_CONTACT_ID;
+        public static final String CONCRETE_GROUP_ID = Tables.DATA + "."
+                + GroupMembership.GROUP_ROW_ID;
+
+        public static final String CONCRETE_DATA1 = Tables.DATA + "." + Data.DATA1;
+        public static final String CONCRETE_DATA2 = Tables.DATA + "." + Data.DATA2;
+        public static final String CONCRETE_DATA3 = Tables.DATA + "." + Data.DATA3;
+        public static final String CONCRETE_DATA4 = Tables.DATA + "." + Data.DATA4;
+        public static final String CONCRETE_DATA5 = Tables.DATA + "." + Data.DATA5;
+        public static final String CONCRETE_DATA6 = Tables.DATA + "." + Data.DATA6;
+        public static final String CONCRETE_DATA7 = Tables.DATA + "." + Data.DATA7;
+        public static final String CONCRETE_DATA8 = Tables.DATA + "." + Data.DATA8;
+        public static final String CONCRETE_DATA9 = Tables.DATA + "." + Data.DATA9;
+        public static final String CONCRETE_DATA10 = Tables.DATA + "." + Data.DATA10;
+        public static final String CONCRETE_DATA11 = Tables.DATA + "." + Data.DATA11;
+        public static final String CONCRETE_DATA12 = Tables.DATA + "." + Data.DATA12;
+        public static final String CONCRETE_DATA13 = Tables.DATA + "." + Data.DATA13;
+        public static final String CONCRETE_DATA14 = Tables.DATA + "." + Data.DATA14;
+        public static final String CONCRETE_DATA15 = Tables.DATA + "." + Data.DATA15;
+        public static final String CONCRETE_IS_PRIMARY = Tables.DATA + "." + Data.IS_PRIMARY;
+        public static final String CONCRETE_PACKAGE_ID = Tables.DATA + "." + PACKAGE_ID;
+    }
+
+    // Used only for legacy API support
+    public interface ExtensionsColumns {
+        public static final String NAME = Data.DATA1;
+        public static final String VALUE = Data.DATA2;
+    }
+
+    public interface GroupMembershipColumns {
+        public static final String RAW_CONTACT_ID = Data.RAW_CONTACT_ID;
+        public static final String GROUP_ROW_ID = GroupMembership.GROUP_ROW_ID;
+    }
+
+    public interface PhoneColumns {
+        public static final String NORMALIZED_NUMBER = Data.DATA4;
+        public static final String CONCRETE_NORMALIZED_NUMBER = DataColumns.CONCRETE_DATA4;
+    }
+
+    public interface GroupsColumns {
+        public static final String PACKAGE_ID = "package_id";
+
+        public static final String CONCRETE_ID = Tables.GROUPS + "." + BaseColumns._ID;
+        public static final String CONCRETE_SOURCE_ID = Tables.GROUPS + "." + Groups.SOURCE_ID;
+}
+
+    public interface ActivitiesColumns {
+        public static final String PACKAGE_ID = "package_id";
+        public static final String MIMETYPE_ID = "mimetype_id";
+    }
+
+    public interface PhoneLookupColumns {
+        public static final String _ID = BaseColumns._ID;
+        public static final String DATA_ID = "data_id";
+        public static final String RAW_CONTACT_ID = "raw_contact_id";
+        public static final String NORMALIZED_NUMBER = "normalized_number";
+    }
+
+    public interface NameLookupColumns {
+        public static final String _ID = BaseColumns._ID;
+        public static final String RAW_CONTACT_ID = "raw_contact_id";
+        public static final String NORMALIZED_NAME = "normalized_name";
+        public static final String NAME_TYPE = "name_type";
+    }
+
+    public final static class NameLookupType {
+        public static final int FULL_NAME = 0;
+        public static final int FULL_NAME_CONCATENATED = 1;
+        public static final int FULL_NAME_REVERSE = 2;
+        public static final int FULL_NAME_REVERSE_CONCATENATED = 3;
+        public static final int FULL_NAME_WITH_NICKNAME = 4;
+        public static final int FULL_NAME_WITH_NICKNAME_REVERSE = 5;
+        public static final int GIVEN_NAME_ONLY = 6;
+        public static final int GIVEN_NAME_ONLY_AS_NICKNAME = 7;
+        public static final int FAMILY_NAME_ONLY = 8;
+        public static final int FAMILY_NAME_ONLY_AS_NICKNAME = 9;
+        public static final int NICKNAME = 10;
+        public static final int EMAIL_BASED_NICKNAME = 11;
+
+        // This is the highest name lookup type code plus one
+        public static final int TYPE_COUNT = 12;
+
+        public static boolean isBasedOnStructuredName(int nameLookupType) {
+            return nameLookupType != NameLookupType.EMAIL_BASED_NICKNAME
+                    && nameLookupType != NameLookupType.NICKNAME;
+        }
+    }
+
+    public interface PackagesColumns {
+        public static final String _ID = BaseColumns._ID;
+        public static final String PACKAGE = "package";
+
+        public static final String CONCRETE_ID = Tables.PACKAGES + "." + _ID;
+    }
+
+    public interface MimetypesColumns {
+        public static final String _ID = BaseColumns._ID;
+        public static final String MIMETYPE = "mimetype";
+
+        public static final String CONCRETE_ID = Tables.MIMETYPES + "." + BaseColumns._ID;
+        public static final String CONCRETE_MIMETYPE = Tables.MIMETYPES + "." + MIMETYPE;
+    }
+
+    public interface AggregationExceptionColumns {
+        public static final String _ID = BaseColumns._ID;
+        public static final String RAW_CONTACT_ID1 = "raw_contact_id1";
+        public static final String RAW_CONTACT_ID2 = "raw_contact_id2";
+    }
+
+    public interface NicknameLookupColumns {
+        public static final String NAME = "name";
+        public static final String CLUSTER = "cluster";
+    }
+
+    private static final String[] NICKNAME_LOOKUP_COLUMNS = new String[] {
+        NicknameLookupColumns.CLUSTER
+    };
+
+    private static final int COL_NICKNAME_LOOKUP_CLUSTER = 0;
+
+    /** In-memory cache of previously found mimetype mappings */
+    private final HashMap<String, Long> mMimetypeCache = new HashMap<String, Long>();
+    /** In-memory cache of previously found package name mappings */
+    private final HashMap<String, Long> mPackageCache = new HashMap<String, Long>();
+
+
+    /** Compiled statements for querying and inserting mappings */
+    private SQLiteStatement mMimetypeQuery;
+    private SQLiteStatement mPackageQuery;
+    private SQLiteStatement mContactIdQuery;
+    private SQLiteStatement mAggregationModeQuery;
+    private SQLiteStatement mContactIdUpdate;
+    private SQLiteStatement mMimetypeInsert;
+    private SQLiteStatement mPackageInsert;
+    private SQLiteStatement mNameLookupInsert;
+
+    private SQLiteStatement mDataMimetypeQuery;
+    private SQLiteStatement mActivitiesMimetypeQuery;
+
+    private final Context mContext;
+    private final SyncStateContentProviderHelper mSyncState;
+    private HashMap<String, String[]> mNicknameClusterCache;
+
+    /** Compiled statements for updating {@link Contacts#IN_VISIBLE_GROUP}. */
+    private SQLiteStatement mVisibleAllUpdate;
+    private SQLiteStatement mVisibleSpecificUpdate;
+
+    private Delegate mDelegate;
+
+    private static OpenHelper sSingleton = null;
+
+    public static synchronized OpenHelper getInstance(Context context) {
+        if (sSingleton == null) {
+            sSingleton = new OpenHelper(context);
+        }
+        return sSingleton;
+    }
+
+    /**
+     * Private constructor, callers except unit tests should obtain an instance through
+     * {@link #getInstance(android.content.Context)} instead.
+     */
+    /* package */ OpenHelper(Context context) {
+        super(context, DATABASE_NAME, null, DATABASE_VERSION);
+        Log.i(TAG, "Creating OpenHelper");
+
+        mContext = context;
+        mSyncState = new SyncStateContentProviderHelper();
+    }
+
+    public Delegate getDelegate() {
+        return mDelegate;
+    }
+
+    public void setDelegate(Delegate delegate) {
+        mDelegate = delegate;
+    }
+
+    @Override
+    public void onOpen(SQLiteDatabase db) {
+        mSyncState.onDatabaseOpened(db);
+
+        // Create compiled statements for package and mimetype lookups
+        mMimetypeQuery = db.compileStatement("SELECT " + MimetypesColumns._ID + " FROM "
+                + Tables.MIMETYPES + " WHERE " + MimetypesColumns.MIMETYPE + "=?");
+        mPackageQuery = db.compileStatement("SELECT " + PackagesColumns._ID + " FROM "
+                + Tables.PACKAGES + " WHERE " + PackagesColumns.PACKAGE + "=?");
+        mContactIdQuery = db.compileStatement("SELECT " + RawContacts.CONTACT_ID + " FROM "
+                + Tables.RAW_CONTACTS + " WHERE " + RawContacts._ID + "=?");
+        mContactIdUpdate = db.compileStatement("UPDATE " + Tables.RAW_CONTACTS + " SET "
+                + RawContacts.CONTACT_ID + "=?" + " WHERE " + RawContacts._ID + "=?");
+        mAggregationModeQuery = db.compileStatement("SELECT " + RawContacts.AGGREGATION_MODE
+                + " FROM " + Tables.RAW_CONTACTS + " WHERE " + RawContacts._ID + "=?");
+        mMimetypeInsert = db.compileStatement("INSERT INTO " + Tables.MIMETYPES + "("
+                + MimetypesColumns.MIMETYPE + ") VALUES (?)");
+        mPackageInsert = db.compileStatement("INSERT INTO " + Tables.PACKAGES + "("
+                + PackagesColumns.PACKAGE + ") VALUES (?)");
+
+        mDataMimetypeQuery = db.compileStatement("SELECT " + MimetypesColumns.MIMETYPE + " FROM "
+                + Tables.DATA_JOIN_MIMETYPES + " WHERE " + Tables.DATA + "." + Data._ID + "=?");
+        mActivitiesMimetypeQuery = db.compileStatement("SELECT " + MimetypesColumns.MIMETYPE
+                + " FROM " + Tables.ACTIVITIES_JOIN_MIMETYPES + " WHERE " + Tables.ACTIVITIES + "."
+                + Activities._ID + "=?");
+        mNameLookupInsert = db.compileStatement("INSERT INTO " + Tables.NAME_LOOKUP + "("
+                + NameLookupColumns.RAW_CONTACT_ID + "," + NameLookupColumns.NAME_TYPE + ","
+                + NameLookupColumns.NORMALIZED_NAME + ") VALUES (?,?,?)");
+
+        final String visibleUpdate = "UPDATE " + Tables.CONTACTS + " SET "
+                + Contacts.IN_VISIBLE_GROUP + "= (" + Clauses.IN_VISIBLE_GROUP + ")";
+
+        mVisibleAllUpdate = db.compileStatement(visibleUpdate);
+        mVisibleSpecificUpdate = db.compileStatement(visibleUpdate + " WHERE "
+                + ContactsColumns.CONCRETE_ID + "=?");
+
+        // Make sure we have an in-memory presence table
+        final String tableName = DATABASE_PRESENCE + "." + Tables.PRESENCE;
+        final String indexName = DATABASE_PRESENCE + ".presenceIndex";
+
+        db.execSQL("ATTACH DATABASE ':memory:' AS " + DATABASE_PRESENCE + ";");
+        db.execSQL("CREATE TABLE IF NOT EXISTS " + tableName + " ("+
+                Presence._ID + " INTEGER PRIMARY KEY," +
+                Presence.RAW_CONTACT_ID + " INTEGER REFERENCES raw_contacts(_id)," +
+                Presence.DATA_ID + " INTEGER REFERENCES data(_id)," +
+                Presence.IM_PROTOCOL + " TEXT," +
+                Presence.IM_HANDLE + " TEXT," +
+                Presence.IM_ACCOUNT + " TEXT," +
+                Presence.PRESENCE_STATUS + " INTEGER," +
+                Presence.PRESENCE_CUSTOM_STATUS + " TEXT," +
+                "UNIQUE(" + Presence.IM_PROTOCOL + ", " + Presence.IM_HANDLE + ", "
+                        + Presence.IM_ACCOUNT + ")" +
+        ");");
+
+        db.execSQL("CREATE INDEX IF NOT EXISTS " + indexName + " ON " + Tables.PRESENCE + " ("
+                + Presence.RAW_CONTACT_ID + ");");
+    }
+
+    @Override
+    public void onCreate(SQLiteDatabase db) {
+        Log.i(TAG, "Bootstrapping database");
+
+        mSyncState.createDatabase(db);
+
+        // One row per group of contacts corresponding to the same person
+        db.execSQL("CREATE TABLE " + Tables.CONTACTS + " (" +
+                BaseColumns._ID + " INTEGER PRIMARY KEY AUTOINCREMENT," +
+                Contacts.DISPLAY_NAME + " TEXT," +
+                Contacts.PHOTO_ID + " INTEGER REFERENCES data(_id)," +
+                Contacts.CUSTOM_RINGTONE + " TEXT," +
+                Contacts.SEND_TO_VOICEMAIL + " INTEGER NOT NULL DEFAULT 0," +
+                Contacts.TIMES_CONTACTED + " INTEGER NOT NULL DEFAULT 0," +
+                Contacts.LAST_TIME_CONTACTED + " INTEGER," +
+                Contacts.STARRED + " INTEGER NOT NULL DEFAULT 0," +
+                Contacts.IN_VISIBLE_GROUP + " INTEGER NOT NULL DEFAULT 1," +
+                ContactsColumns.OPTIMAL_PRIMARY_PHONE_ID + " INTEGER REFERENCES data(_id)," +
+                ContactsColumns.OPTIMAL_PRIMARY_PHONE_IS_RESTRICTED + " INTEGER DEFAULT 0," +
+                ContactsColumns.FALLBACK_PRIMARY_PHONE_ID + " INTEGER REFERENCES data(_id)," +
+                ContactsColumns.OPTIMAL_PRIMARY_EMAIL_ID + " INTEGER REFERENCES data(_id)," +
+                ContactsColumns.OPTIMAL_PRIMARY_EMAIL_IS_RESTRICTED + " INTEGER DEFAULT 0," +
+                ContactsColumns.FALLBACK_PRIMARY_EMAIL_ID + " INTEGER REFERENCES data(_id)," +
+                ContactsColumns.SINGLE_IS_RESTRICTED + " INTEGER REFERENCES package(_id)" +
+        ");");
+
+        // Contacts table
+        db.execSQL("CREATE TABLE " + Tables.RAW_CONTACTS + " (" +
+                RawContacts._ID + " INTEGER PRIMARY KEY AUTOINCREMENT," +
+                RawContacts.IS_RESTRICTED + " INTEGER DEFAULT 0," +
+                RawContacts.ACCOUNT_NAME + " STRING DEFAULT NULL, " +
+                RawContacts.ACCOUNT_TYPE + " STRING DEFAULT NULL, " +
+                RawContacts.SOURCE_ID + " TEXT," +
+                RawContacts.VERSION + " INTEGER NOT NULL DEFAULT 1," +
+                RawContacts.DIRTY + " INTEGER NOT NULL DEFAULT 1," +
+                RawContacts.DELETED + " INTEGER NOT NULL DEFAULT 0," +
+                RawContacts.CONTACT_ID + " INTEGER," +
+                RawContacts.AGGREGATION_MODE + " INTEGER NOT NULL DEFAULT " +
+                        RawContacts.AGGREGATION_MODE_DEFAULT + "," +
+                RawContacts.CUSTOM_RINGTONE + " TEXT," +
+                RawContacts.SEND_TO_VOICEMAIL + " INTEGER NOT NULL DEFAULT 0," +
+                RawContacts.TIMES_CONTACTED + " INTEGER NOT NULL DEFAULT 0," +
+                RawContacts.LAST_TIME_CONTACTED + " INTEGER," +
+                RawContacts.STARRED + " INTEGER NOT NULL DEFAULT 0," +
+                RawContactsColumns.DISPLAY_NAME + " TEXT" +
+        ");");
+
+        // Package name mapping table
+        db.execSQL("CREATE TABLE " + Tables.PACKAGES + " (" +
+                PackagesColumns._ID + " INTEGER PRIMARY KEY AUTOINCREMENT," +
+                PackagesColumns.PACKAGE + " TEXT NOT NULL" +
+        ");");
+
+        // Mimetype mapping table
+        db.execSQL("CREATE TABLE " + Tables.MIMETYPES + " (" +
+                MimetypesColumns._ID + " INTEGER PRIMARY KEY AUTOINCREMENT," +
+                MimetypesColumns.MIMETYPE + " TEXT NOT NULL" +
+        ");");
+
+        // Public generic data table
+        db.execSQL("CREATE TABLE " + Tables.DATA + " (" +
+                Data._ID + " INTEGER PRIMARY KEY AUTOINCREMENT," +
+                DataColumns.PACKAGE_ID + " INTEGER REFERENCES package(_id)," +
+                DataColumns.MIMETYPE_ID + " INTEGER REFERENCES mimetype(_id) NOT NULL," +
+                Data.RAW_CONTACT_ID + " INTEGER NOT NULL," +
+                Data.IS_PRIMARY + " INTEGER NOT NULL DEFAULT 0," +
+                Data.IS_SUPER_PRIMARY + " INTEGER NOT NULL DEFAULT 0," +
+                Data.DATA_VERSION + " INTEGER NOT NULL DEFAULT 0," +
+                Data.DATA1 + " TEXT," +
+                Data.DATA2 + " TEXT," +
+                Data.DATA3 + " TEXT," +
+                Data.DATA4 + " TEXT," +
+                Data.DATA5 + " TEXT," +
+                Data.DATA6 + " TEXT," +
+                Data.DATA7 + " TEXT," +
+                Data.DATA8 + " TEXT," +
+                Data.DATA9 + " TEXT," +
+                Data.DATA10 + " TEXT," +
+                Data.DATA11 + " TEXT," +
+                Data.DATA12 + " TEXT," +
+                Data.DATA13 + " TEXT," +
+                Data.DATA14 + " TEXT," +
+                Data.DATA15 + " TEXT" +
+        ");");
+
+        /**
+         * Automatically delete Data rows when a raw contact is deleted.
+         */
+        db.execSQL("CREATE TRIGGER " + Tables.RAW_CONTACTS + "_deleted "
+                + "   BEFORE DELETE ON " + Tables.RAW_CONTACTS
+                + " BEGIN "
+                + "   DELETE FROM " + Tables.DATA
+                + "     WHERE " + Data.RAW_CONTACT_ID + "=OLD." + RawContacts._ID + ";"
+                + "   DELETE FROM " + Tables.PHONE_LOOKUP
+                + "     WHERE " + PhoneLookupColumns.RAW_CONTACT_ID + "=OLD." + RawContacts._ID + ";"
+                + " END");
+
+        /**
+         * Triggers that set {@link RawContacts#DIRTY} and update {@link RawContacts#VERSION}
+         * when the contact is marked for deletion or any time a data row is inserted, updated
+         * or deleted.
+         */
+        db.execSQL("CREATE TRIGGER " + Tables.RAW_CONTACTS + "_marked_deleted "
+                + "   BEFORE UPDATE ON " + Tables.RAW_CONTACTS
+                + " BEGIN "
+                + "   UPDATE " + Tables.RAW_CONTACTS
+                + "     SET "
+                +         RawContacts.VERSION + "=OLD." + RawContacts.VERSION + "+1, "
+                +         RawContacts.DIRTY + "=1"
+                + "     WHERE " + RawContacts._ID + "=OLD." + RawContacts._ID
+                + "       AND NEW." + RawContacts.DELETED + "!= OLD." + RawContacts.DELETED + ";"
+                + " END");
+
+        db.execSQL("CREATE TRIGGER " + Tables.DATA + "_updated AFTER UPDATE ON " + Tables.DATA
+                + " BEGIN "
+                + "   UPDATE " + Tables.DATA
+                + "     SET " + Data.DATA_VERSION + "=OLD." + Data.DATA_VERSION + "+1 "
+                + "     WHERE " + Data._ID + "=OLD." + Data._ID + ";"
+                + "   UPDATE " + Tables.RAW_CONTACTS
+                + "     SET " + RawContacts.DIRTY + "=1, "
+                + "         " +	RawContacts.VERSION + "=" + RawContacts.VERSION + "+1 "
+                + "     WHERE " + RawContacts._ID + "=OLD." + Data.RAW_CONTACT_ID + ";"
+                + " END");
+
+        db.execSQL("CREATE TRIGGER " + Tables.DATA + "_inserted BEFORE INSERT ON " + Tables.DATA
+                + " BEGIN "
+                + "   UPDATE " + Tables.RAW_CONTACTS
+                + "     SET " + RawContacts.DIRTY + "=1, "
+                + "         " + RawContacts.VERSION + "=" + RawContacts.VERSION + "+1 "
+                + "     WHERE " + RawContacts._ID + "=NEW." + Data.RAW_CONTACT_ID + ";"
+                + " END");
+
+        db.execSQL("CREATE TRIGGER " + Tables.DATA + "_deleted BEFORE DELETE ON " + Tables.DATA
+                + " BEGIN "
+                + "   UPDATE " + Tables.RAW_CONTACTS
+                + "     SET " + RawContacts.DIRTY + "=1,"
+                + "         " + RawContacts.VERSION + "=" + RawContacts.VERSION + "+1 "
+                + "     WHERE " + RawContacts._ID + "=OLD." + Data.RAW_CONTACT_ID + ";"
+                + "   DELETE FROM " + Tables.PHONE_LOOKUP
+                + "     WHERE " + PhoneLookupColumns.DATA_ID + "=OLD." + Data._ID + ";"
+                + " END");
+
+        // Private phone numbers table used for lookup
+        db.execSQL("CREATE TABLE " + Tables.PHONE_LOOKUP + " (" +
+                PhoneLookupColumns._ID + " INTEGER PRIMARY KEY," +
+                PhoneLookupColumns.DATA_ID + " INTEGER REFERENCES data(_id) NOT NULL," +
+                PhoneLookupColumns.RAW_CONTACT_ID
+                        + " INTEGER REFERENCES raw_contacts(_id) NOT NULL," +
+                PhoneLookupColumns.NORMALIZED_NUMBER + " TEXT NOT NULL" +
+        ");");
+
+        db.execSQL("CREATE INDEX phone_lookup_index ON " + Tables.PHONE_LOOKUP + " (" +
+                PhoneLookupColumns.NORMALIZED_NUMBER + " ASC, " +
+                PhoneLookupColumns.RAW_CONTACT_ID + ", " +
+                PhoneLookupColumns.DATA_ID +
+        ");");
+
+        // Private name/nickname table used for lookup
+        db.execSQL("CREATE TABLE " + Tables.NAME_LOOKUP + " (" +
+                NameLookupColumns._ID + " INTEGER PRIMARY KEY AUTOINCREMENT," +
+                NameLookupColumns.RAW_CONTACT_ID
+                        + " INTEGER REFERENCES raw_contacts(_id) NOT NULL," +
+                NameLookupColumns.NORMALIZED_NAME + " TEXT," +
+                NameLookupColumns.NAME_TYPE + " INTEGER" +
+        ");");
+
+        db.execSQL("CREATE INDEX name_lookup_index ON " + Tables.NAME_LOOKUP + " (" +
+                NameLookupColumns.NORMALIZED_NAME + " ASC, " +
+                NameLookupColumns.NAME_TYPE + " ASC, " +
+                NameLookupColumns.RAW_CONTACT_ID +
+        ");");
+
+        db.execSQL("CREATE TABLE " + Tables.NICKNAME_LOOKUP + " (" +
+                NicknameLookupColumns.NAME + " TEXT," +
+                NicknameLookupColumns.CLUSTER + " TEXT" +
+        ");");
+
+        db.execSQL("CREATE UNIQUE INDEX nickname_lookup_index ON " + Tables.NICKNAME_LOOKUP + " (" +
+                NicknameLookupColumns.NAME + ", " +
+                NicknameLookupColumns.CLUSTER +
+        ");");
+
+        // Groups table
+        db.execSQL("CREATE TABLE " + Tables.GROUPS + " (" +
+                Groups._ID + " INTEGER PRIMARY KEY AUTOINCREMENT," +
+                GroupsColumns.PACKAGE_ID + " INTEGER REFERENCES package(_id)," +
+                Groups.ACCOUNT_NAME + " STRING DEFAULT NULL, " +
+                Groups.ACCOUNT_TYPE + " STRING DEFAULT NULL, " +
+                Groups.SOURCE_ID + " TEXT," +
+                Groups.VERSION + " INTEGER NOT NULL DEFAULT 1," +
+                Groups.DIRTY + " INTEGER NOT NULL DEFAULT 1," +
+                Groups.TITLE + " TEXT," +
+                Groups.TITLE_RES + " INTEGER," +
+                Groups.NOTES + " TEXT," +
+                Groups.SYSTEM_ID + " TEXT," +
+                Groups.GROUP_VISIBLE + " INTEGER" +
+        ");");
+
+        db.execSQL("CREATE TRIGGER " + Tables.GROUPS + "_updated1 "
+                + "   BEFORE UPDATE ON " + Tables.GROUPS
+                + " BEGIN "
+                + "   UPDATE " + Tables.GROUPS
+                + "     SET "
+                +         Groups.VERSION + "=OLD." + Groups.VERSION + "+1, "
+                +         Groups.DIRTY + "=1"
+                + "     WHERE " + Groups._ID + "=OLD." + Groups._ID + ";"
+                + " END");
+
+        db.execSQL("CREATE TABLE IF NOT EXISTS " + Tables.AGGREGATION_EXCEPTIONS + " (" +
+                AggregationExceptionColumns._ID + " INTEGER PRIMARY KEY AUTOINCREMENT," +
+                AggregationExceptions.TYPE + " INTEGER NOT NULL, " +
+                AggregationExceptionColumns.RAW_CONTACT_ID1
+                        + " INTEGER REFERENCES raw_contacts(_id), " +
+                AggregationExceptionColumns.RAW_CONTACT_ID2
+                        + " INTEGER REFERENCES raw_contacts(_id)" +
+        ");");
+
+        db.execSQL("CREATE UNIQUE INDEX IF NOT EXISTS aggregation_exception_index1 ON " +
+                Tables.AGGREGATION_EXCEPTIONS + " (" +
+                AggregationExceptionColumns.RAW_CONTACT_ID1 + ", " +
+                AggregationExceptionColumns.RAW_CONTACT_ID2 +
+        ");");
+
+        db.execSQL("CREATE UNIQUE INDEX IF NOT EXISTS aggregation_exception_index2 ON " +
+                Tables.AGGREGATION_EXCEPTIONS + " (" +
+                AggregationExceptionColumns.RAW_CONTACT_ID2 + ", " +
+                AggregationExceptionColumns.RAW_CONTACT_ID1 +
+        ");");
+
+        // The table for recent calls is here so we can do table joins
+        // on people, phones, and calls all in one place.
+        db.execSQL("CREATE TABLE " + Tables.CALLS + " (" +
+                Calls._ID + " INTEGER PRIMARY KEY AUTOINCREMENT," +
+                Calls.NUMBER + " TEXT," +
+                Calls.DATE + " INTEGER," +
+                Calls.DURATION + " INTEGER," +
+                Calls.TYPE + " INTEGER," +
+                Calls.NEW + " INTEGER," +
+                Calls.CACHED_NAME + " TEXT," +
+                Calls.CACHED_NUMBER_TYPE + " INTEGER," +
+                Calls.CACHED_NUMBER_LABEL + " TEXT" +
+        ");");
+
+        // Activities table
+        db.execSQL("CREATE TABLE " + Tables.ACTIVITIES + " (" +
+                Activities._ID + " INTEGER PRIMARY KEY AUTOINCREMENT," +
+                ActivitiesColumns.PACKAGE_ID + " INTEGER REFERENCES package(_id)," +
+                ActivitiesColumns.MIMETYPE_ID + " INTEGER REFERENCES mimetype(_id) NOT NULL," +
+                Activities.RAW_ID + " TEXT," +
+                Activities.IN_REPLY_TO + " TEXT," +
+                Activities.AUTHOR_CONTACT_ID +  " INTEGER REFERENCES raw_contacts(_id)," +
+                Activities.TARGET_CONTACT_ID + " INTEGER REFERENCES raw_contacts(_id)," +
+                Activities.PUBLISHED + " INTEGER NOT NULL," +
+                Activities.THREAD_PUBLISHED + " INTEGER NOT NULL," +
+                Activities.TITLE + " TEXT NOT NULL," +
+                Activities.SUMMARY + " TEXT," +
+                Activities.LINK + " TEXT, " +
+                Activities.THUMBNAIL + " BLOB" +
+        ");");
+
+        db.execSQL("CREATE VIEW " + Tables.CONTACT_ENTITIES + " AS SELECT "
+                + RawContactsColumns.CONCRETE_ACCOUNT_NAME + " AS " + RawContacts.ACCOUNT_NAME + ","
+                + RawContactsColumns.CONCRETE_ACCOUNT_TYPE + " AS " + RawContacts.ACCOUNT_TYPE + ","
+                + RawContactsColumns.CONCRETE_SOURCE_ID + " AS " + RawContacts.SOURCE_ID + ","
+                + RawContactsColumns.CONCRETE_VERSION + " AS " + RawContacts.VERSION + ","
+                + RawContactsColumns.CONCRETE_DIRTY + " AS " + RawContacts.DIRTY + ","
+                + PackagesColumns.PACKAGE + " AS " + Data.RES_PACKAGE + ","
+                + RawContacts.CONTACT_ID + ", "
+                + Data.MIMETYPE + ", "
+                + Data.DATA1 + ", "
+                + Data.DATA2 + ", "
+                + Data.DATA3 + ", "
+                + Data.DATA4 + ", "
+                + Data.DATA5 + ", "
+                + Data.DATA6 + ", "
+                + Data.DATA7 + ", "
+                + Data.DATA8 + ", "
+                + Data.DATA9 + ", "
+                + Data.DATA10 + ", "
+                + Data.DATA11 + ", "
+                + Data.DATA12 + ", "
+                + Data.DATA13 + ", "
+                + Data.DATA14 + ", "
+                + Data.DATA15 + ", "
+                + Data.RAW_CONTACT_ID + ", "
+                + Data.IS_PRIMARY + ", "
+                + Data.DATA_VERSION + ", "
+                + DataColumns.CONCRETE_ID + " AS " + RawContacts._ID + ","
+                + Tables.GROUPS + "." + Groups.SOURCE_ID + " AS " + GroupMembership.GROUP_SOURCE_ID
+                + " FROM " + Tables.DATA
+                + " LEFT OUTER JOIN " + Tables.PACKAGES + " ON ("
+                +   DataColumns.CONCRETE_PACKAGE_ID + "=" + PackagesColumns.CONCRETE_ID + ")"
+                + " LEFT OUTER JOIN " + Tables.MIMETYPES + " ON ("
+                +   DataColumns.CONCRETE_MIMETYPE_ID + "=" + MimetypesColumns.CONCRETE_ID + ")"
+                + " LEFT OUTER JOIN " + Tables.RAW_CONTACTS + " ON ("
+                +   DataColumns.CONCRETE_RAW_CONTACT_ID + "=" + RawContactsColumns.CONCRETE_ID + ")"
+                + " LEFT OUTER JOIN " + Tables.GROUPS + " ON ("
+                +   MimetypesColumns.CONCRETE_MIMETYPE + "='" + GroupMembership.CONTENT_ITEM_TYPE
+                +   "' AND " + GroupsColumns.CONCRETE_ID + "=" + DataColumns.CONCRETE_DATA1 + ")");
+
+        loadNicknameLookupTable(db);
+        if (mDelegate != null) {
+            mDelegate.createDatabase(db);
+        }
+    }
+
+    @Override
+    public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
+        Log.i(TAG, "Upgrading from version " + oldVersion + " to " + newVersion
+                + ", data will be lost!");
+
+        db.execSQL("DROP TABLE IF EXISTS " + Tables.ACCOUNTS + ";");
+        db.execSQL("DROP TABLE IF EXISTS " + Tables.CONTACTS + ";");
+        db.execSQL("DROP TABLE IF EXISTS " + Tables.RAW_CONTACTS + ";");
+        db.execSQL("DROP TABLE IF EXISTS " + Tables.PACKAGES + ";");
+        db.execSQL("DROP TABLE IF EXISTS " + Tables.MIMETYPES + ";");
+        db.execSQL("DROP TABLE IF EXISTS " + Tables.DATA + ";");
+        db.execSQL("DROP TABLE IF EXISTS " + Tables.PHONE_LOOKUP + ";");
+        db.execSQL("DROP TABLE IF EXISTS " + Tables.NAME_LOOKUP + ";");
+        db.execSQL("DROP TABLE IF EXISTS " + Tables.NICKNAME_LOOKUP + ";");
+        db.execSQL("DROP TABLE IF EXISTS " + Tables.GROUPS + ";");
+        db.execSQL("DROP TABLE IF EXISTS " + Tables.ACTIVITIES + ";");
+        db.execSQL("DROP TABLE IF EXISTS " + Tables.CALLS);
+
+        db.execSQL("DROP VIEW IF EXISTS " + Tables.CONTACT_ENTITIES + ";");
+
+        // TODO: we should not be dropping agg_exceptions and contact_options. In case that table's
+        // schema changes, we should try to preserve the data, because it was entered by the user
+        // and has never been synched to the server.
+        db.execSQL("DROP TABLE IF EXISTS " + Tables.AGGREGATION_EXCEPTIONS + ";");
+
+        onCreate(db);
+
+        // TODO: eventually when this supports upgrades we should do something like the following:
+//        if (!upgradeDatabase(db, oldVersion, newVersion)) {
+//            mSyncState.discardSyncData(db, null /* all accounts */);
+//            ContentResolver.requestSync(null /* all accounts */,
+//                    mContentUri.getAuthority(), new Bundle());
+//        }
+    }
+
+    /**
+     * Wipes all data except mime type and package lookup tables.
+     */
+    public void wipeData() {
+        SQLiteDatabase db = getWritableDatabase();
+        db.execSQL("DELETE FROM " + Tables.CONTACTS + ";");
+        db.execSQL("DELETE FROM " + Tables.RAW_CONTACTS + ";");
+        db.execSQL("DELETE FROM " + Tables.DATA + ";");
+        db.execSQL("DELETE FROM " + Tables.PHONE_LOOKUP + ";");
+        db.execSQL("DELETE FROM " + Tables.NAME_LOOKUP + ";");
+        db.execSQL("DELETE FROM " + Tables.GROUPS + ";");
+        db.execSQL("DELETE FROM " + Tables.AGGREGATION_EXCEPTIONS + ";");
+        db.execSQL("DELETE FROM " + Tables.ACTIVITIES + ";");
+        db.execSQL("DELETE FROM " + Tables.CALLS);
+
+        // Note: we are not removing reference data from Tables.NICKNAME_LOOKUP
+
+        db.execSQL("VACUUM;");
+    }
+
+    /**
+     * Return the {@link ApplicationInfo#uid} for the given package name.
+     */
+    public static int getUidForPackageName(PackageManager pm, String packageName) {
+        try {
+            ApplicationInfo clientInfo = pm.getApplicationInfo(packageName, 0 /* no flags */);
+            return clientInfo.uid;
+        } catch (NameNotFoundException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    /**
+     * Perform an internal string-to-integer lookup using the compiled
+     * {@link SQLiteStatement} provided, using the in-memory cache to speed up
+     * lookups. If a mapping isn't found in cache or database, it will be
+     * created. All new, uncached answers are added to the cache automatically.
+     *
+     * @param query Compiled statement used to query for the mapping.
+     * @param insert Compiled statement used to insert a new mapping when no
+     *            existing one is found in cache or from query.
+     * @param value Value to find mapping for.
+     * @param cache In-memory cache of previous answers.
+     * @return An unique integer mapping for the given value.
+     */
+    private synchronized long getCachedId(SQLiteStatement query, SQLiteStatement insert,
+            String value, HashMap<String, Long> cache) {
+        // Try an in-memory cache lookup
+        if (cache.containsKey(value)) {
+            return cache.get(value);
+        }
+
+        long id = -1;
+        try {
+            // Try searching database for mapping
+            DatabaseUtils.bindObjectToProgram(query, 1, value);
+            id = query.simpleQueryForLong();
+        } catch (SQLiteDoneException e) {
+            // Nothing found, so try inserting new mapping
+            DatabaseUtils.bindObjectToProgram(insert, 1, value);
+            id = insert.executeInsert();
+        }
+
+        if (id != -1) {
+            // Cache and return the new answer
+            cache.put(value, id);
+            return id;
+        } else {
+            // Otherwise throw if no mapping found or created
+            throw new IllegalStateException("Couldn't find or create internal "
+                    + "lookup table entry for value " + value);
+        }
+    }
+
+    /**
+     * Convert a package name into an integer, using {@link Tables#PACKAGES} for
+     * lookups and possible allocation of new IDs as needed.
+     */
+    public long getPackageId(String packageName) {
+        // Make sure compiled statements are ready by opening database
+        getReadableDatabase();
+        return getCachedId(mPackageQuery, mPackageInsert, packageName, mPackageCache);
+    }
+
+    /**
+     * Convert a mimetype into an integer, using {@link Tables#MIMETYPES} for
+     * lookups and possible allocation of new IDs as needed.
+     */
+    public long getMimeTypeId(String mimetype) {
+        // Make sure compiled statements are ready by opening database
+        getReadableDatabase();
+        return getCachedId(mMimetypeQuery, mMimetypeInsert, mimetype, mMimetypeCache);
+    }
+
+    /**
+     * Find the mimetype for the given {@link Data#_ID}.
+     */
+    public String getDataMimeType(long dataId) {
+        // Make sure compiled statements are ready by opening database
+        getReadableDatabase();
+        try {
+            // Try database query to find mimetype
+            DatabaseUtils.bindObjectToProgram(mDataMimetypeQuery, 1, dataId);
+            String mimetype = mDataMimetypeQuery.simpleQueryForString();
+            return mimetype;
+        } catch (SQLiteDoneException e) {
+            // No valid mapping found, so return null
+            return null;
+        }
+    }
+
+    /**
+     * Find the mime-type for the given {@link Activities#_ID}.
+     */
+    public String getActivityMimeType(long activityId) {
+        // Make sure compiled statements are ready by opening database
+        getReadableDatabase();
+        try {
+            // Try database query to find mimetype
+            DatabaseUtils.bindObjectToProgram(mActivitiesMimetypeQuery, 1, activityId);
+            String mimetype = mActivitiesMimetypeQuery.simpleQueryForString();
+            return mimetype;
+        } catch (SQLiteDoneException e) {
+            // No valid mapping found, so return null
+            return null;
+        }
+    }
+
+    /**
+     * Update {@link Contacts#IN_VISIBLE_GROUP} for all contacts.
+     */
+    public void updateAllVisible() {
+        final long groupMembershipMimetypeId = getMimeTypeId(GroupMembership.CONTENT_ITEM_TYPE);
+        mVisibleAllUpdate.bindLong(1, groupMembershipMimetypeId);
+        mVisibleAllUpdate.execute();
+    }
+
+    /**
+     * Update {@link Contacts#IN_VISIBLE_GROUP} for a specific contact.
+     */
+    public void updateContactVisible(long aggId) {
+        final long groupMembershipMimetypeId = getMimeTypeId(GroupMembership.CONTENT_ITEM_TYPE);
+        mVisibleSpecificUpdate.bindLong(1, groupMembershipMimetypeId);
+        mVisibleSpecificUpdate.bindLong(2, aggId);
+        mVisibleSpecificUpdate.execute();
+    }
+
+    /**
+     * Updates the contact ID for the specified contact.
+     */
+    public void setContactId(long rawContactId, long contactId) {
+        getWritableDatabase();
+        DatabaseUtils.bindObjectToProgram(mContactIdUpdate, 1, contactId);
+        DatabaseUtils.bindObjectToProgram(mContactIdUpdate, 2, rawContactId);
+        mContactIdUpdate.execute();
+    }
+
+    /**
+     * Returns contact ID for the given contact or zero if it is NULL.
+     */
+    public long getContactId(long rawContactId) {
+        getReadableDatabase();
+        try {
+            DatabaseUtils.bindObjectToProgram(mContactIdQuery, 1, rawContactId);
+            return mContactIdQuery.simpleQueryForLong();
+        } catch (SQLiteDoneException e) {
+            // No valid mapping found, so return -1
+            return 0;
+        }
+    }
+
+    public int getAggregationMode(long rawContactId) {
+        getReadableDatabase();
+        try {
+            DatabaseUtils.bindObjectToProgram(mAggregationModeQuery, 1, rawContactId);
+            return (int)mAggregationModeQuery.simpleQueryForLong();
+        } catch (SQLiteDoneException e) {
+            // No valid row found, so return "disabled"
+            return RawContacts.AGGREGATION_MODE_DISABLED;
+        }
+    }
+
+    /**
+     * Inserts a record in the {@link Tables#NAME_LOOKUP} table.
+     */
+    public void insertNameLookup(long rawContactId, int lookupType, String name) {
+        getWritableDatabase();
+        DatabaseUtils.bindObjectToProgram(mNameLookupInsert, 1, rawContactId);
+        DatabaseUtils.bindObjectToProgram(mNameLookupInsert, 2, lookupType);
+        DatabaseUtils.bindObjectToProgram(mNameLookupInsert, 3, name);
+        mNameLookupInsert.executeInsert();
+    }
+
+    public static void buildPhoneLookupQuery(SQLiteQueryBuilder qb, final String number) {
+        final String normalizedNumber = PhoneNumberUtils.toCallerIDMinMatch(number);
+        final StringBuilder tables = new StringBuilder();
+        tables.append(Tables.RAW_CONTACTS + ", (SELECT data_id FROM phone_lookup "
+                + "WHERE (phone_lookup.normalized_number GLOB '");
+        tables.append(normalizedNumber);
+        tables.append("*')) AS lookup, " + Tables.DATA_JOIN_MIMETYPES);
+        qb.setTables(tables.toString());
+        qb.appendWhere("lookup.data_id=data._id AND data.raw_contact_id=raw_contacts._id AND ");
+        qb.appendWhere("PHONE_NUMBERS_EQUAL(data." + Phone.NUMBER + ", ");
+        qb.appendWhereEscapeString(number);
+        qb.appendWhere(")");
+    }
+
+
+    /**
+     * Loads common nickname mappings into the database.
+     */
+    private void loadNicknameLookupTable(SQLiteDatabase db) {
+        String[] strings = mContext.getResources().getStringArray(
+                com.android.internal.R.array.common_nicknames);
+        if (strings == null || strings.length == 0) {
+            return;
+        }
+
+        SQLiteStatement nicknameLookupInsert = db.compileStatement("INSERT INTO "
+                + Tables.NICKNAME_LOOKUP + "(" + NicknameLookupColumns.NAME + ","
+                + NicknameLookupColumns.CLUSTER + ") VALUES (?,?)");
+
+        for (int clusterId = 0; clusterId < strings.length; clusterId++) {
+            String[] names = strings[clusterId].split(",");
+            for (int j = 0; j < names.length; j++) {
+                String name = NameNormalizer.normalize(names[j]);
+                try {
+                    DatabaseUtils.bindObjectToProgram(nicknameLookupInsert, 1, name);
+                    DatabaseUtils.bindObjectToProgram(nicknameLookupInsert, 2,
+                            String.valueOf(clusterId));
+                    nicknameLookupInsert.executeInsert();
+                } catch (SQLiteException e) {
+
+                    // Print the exception and keep going - this is not a fatal error
+                    Log.e(TAG, "Cannot insert nickname: " + names[j], e);
+                }
+            }
+        }
+    }
+
+    /**
+     * Returns common nickname cluster IDs for a given name. For example, it
+     * will return the same value for "Robert", "Bob" and "Rob". Some names belong to multiple
+     * clusters, e.g. Leo could be Leonard or Leopold.
+     *
+     * May return null.
+     *
+     * @param normalizedName A normalized first name, see {@link NameNormalizer#normalize}.
+     */
+    public String[] getCommonNicknameClusters(String normalizedName) {
+        if (mNicknameClusterCache == null) {
+            mNicknameClusterCache = new HashMap<String, String[]>();
+        }
+
+        synchronized (mNicknameClusterCache) {
+            if (mNicknameClusterCache.containsKey(normalizedName)) {
+                return mNicknameClusterCache.get(normalizedName);
+            }
+        }
+
+        String[] clusters = null;
+        SQLiteDatabase db = getReadableDatabase();
+
+        Cursor cursor = db.query(Tables.NICKNAME_LOOKUP, NICKNAME_LOOKUP_COLUMNS,
+                NicknameLookupColumns.NAME + "=?", new String[] { normalizedName },
+                null, null, null);
+        try {
+            int count = cursor.getCount();
+            if (count > 0) {
+                clusters = new String[count];
+                for (int i = 0; i < count; i++) {
+                    cursor.moveToNext();
+                    clusters[i] = cursor.getString(COL_NICKNAME_LOOKUP_CLUSTER);
+                }
+            }
+        } finally {
+            cursor.close();
+        }
+
+        synchronized (mNicknameClusterCache) {
+            mNicknameClusterCache.put(normalizedName, clusters);
+        }
+
+        return clusters;
+    }
+
+    public static void copyStringValue(ContentValues toValues, String toKey,
+            ContentValues fromValues, String fromKey) {
+        if (fromValues.containsKey(fromKey)) {
+            toValues.put(toKey, fromValues.getAsString(fromKey));
+        }
+    }
+
+    public static void copyLongValue(ContentValues toValues, String toKey,
+            ContentValues fromValues, String fromKey) {
+        if (fromValues.containsKey(fromKey)) {
+            long longValue;
+            Object value = fromValues.get(fromKey);
+            if (value instanceof Boolean) {
+                if ((Boolean)value) {
+                    longValue = 1;
+                } else {
+                    longValue = 0;
+                }
+            } else {
+                longValue = ((Number) value).longValue();
+            }
+            toValues.put(toKey, longValue);
+        }
+    }
+
+    public SyncStateContentProviderHelper getSyncState() {
+        return mSyncState;
+    }
+
+    /**
+     * Delete the aggregate contact if it has no constituent raw contacts other
+     * than the supplied one.
+     */
+    public void removeContactIfSingleton(long rawContactId) {
+        SQLiteDatabase db = getWritableDatabase();
+
+        // Obtain contact ID from the supplied raw contact ID
+        String contactIdFromRawContactId = "(SELECT " + RawContacts.CONTACT_ID + " FROM "
+                + Tables.RAW_CONTACTS + " WHERE " + RawContacts._ID + "=" + rawContactId + ")";
+
+        // Find other raw contacts in the same aggregate contact
+        String otherRawContacts = "(SELECT contacts1." + RawContacts._ID + " FROM "
+                + Tables.RAW_CONTACTS + " contacts1 JOIN " + Tables.RAW_CONTACTS + " contacts2 ON ("
+                + "contacts1." + RawContacts.CONTACT_ID + "=contacts2." + RawContacts.CONTACT_ID
+                + ") WHERE contacts1." + RawContacts._ID + "!=" + rawContactId + ""
+                + " AND contacts2." + RawContacts._ID + "=" + rawContactId + ")";
+
+        db.execSQL("DELETE FROM " + Tables.CONTACTS
+                + " WHERE " + Contacts._ID + "=" + contactIdFromRawContactId
+                + " AND NOT EXISTS " + otherRawContacts + ";");
+    }
+}
diff --git a/src/com/android/providers/contacts/ReorderingCursorWrapper.java b/src/com/android/providers/contacts/ReorderingCursorWrapper.java
new file mode 100644
index 0000000..5d7983a
--- /dev/null
+++ b/src/com/android/providers/contacts/ReorderingCursorWrapper.java
@@ -0,0 +1,94 @@
+/*
+ * 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 android.database.AbstractCursor;
+import android.database.Cursor;
+
+/**
+ * Cursor wrapper that reorders rows according to supplied specific position mapping.
+ */
+public class ReorderingCursorWrapper extends AbstractCursor {
+
+    private final Cursor mCursor;
+    private final int[] mPositionMap;
+
+    /**
+     * Constructor.
+     *
+     * @param cursor wrapped cursor
+     * @param positionMap maps wrapper cursor positions to wrapped cursor positions
+     *            so that positionMap[wrapperPosition] == wrappedPosition
+     */
+    public ReorderingCursorWrapper(Cursor cursor, int[] positionMap) {
+        if (cursor.getCount() != positionMap.length) {
+            throw new IllegalArgumentException("Cursor and position map have different sizes.");
+        }
+
+        mCursor = cursor;
+        mPositionMap = positionMap;
+    }
+
+    @Override
+    public boolean onMove(int oldPosition, int newPosition) {
+        return mCursor.moveToPosition(mPositionMap[newPosition]);
+    }
+
+    @Override
+    public String[] getColumnNames() {
+        return mCursor.getColumnNames();
+    }
+
+    @Override
+    public int getCount() {
+        return mCursor.getCount();
+    }
+
+    @Override
+    public double getDouble(int column) {
+        return mCursor.getDouble(column);
+    }
+
+    @Override
+    public float getFloat(int column) {
+        return mCursor.getFloat(column);
+    }
+
+    @Override
+    public int getInt(int column) {
+        return mCursor.getInt(column);
+    }
+
+    @Override
+    public long getLong(int column) {
+        return mCursor.getLong(column);
+    }
+
+    @Override
+    public short getShort(int column) {
+        return mCursor.getShort(column);
+    }
+
+    @Override
+    public String getString(int column) {
+        return mCursor.getString(column);
+    }
+
+    @Override
+    public boolean isNull(int column) {
+        return mCursor.isNull(column);
+    }
+}
\ No newline at end of file
diff --git a/src/com/android/providers/contacts/SocialProvider.java b/src/com/android/providers/contacts/SocialProvider.java
new file mode 100644
index 0000000..a5ea0c9
--- /dev/null
+++ b/src/com/android/providers/contacts/SocialProvider.java
@@ -0,0 +1,404 @@
+/*
+ * 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.OpenHelper.ActivitiesColumns;
+import com.android.providers.contacts.OpenHelper.PackagesColumns;
+import com.android.providers.contacts.OpenHelper.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, 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 OpenHelper mOpenHelper;
+
+    /** {@inheritDoc} */
+    @Override
+    public boolean onCreate() {
+        final Context context = getContext();
+        mOpenHelper = OpenHelper.getInstance(context);
+
+        // TODO remove this, it's here to force opening the database on boot for testing
+        mOpenHelper.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 = mOpenHelper.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, mOpenHelper.getPackageId(packageName));
+            }
+            values.remove(Activities.RES_PACKAGE);
+
+            final String mimeType = values.getAsString(Activities.MIMETYPE);
+            values.put(ActivitiesColumns.MIMETYPE_ID, mOpenHelper.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 = mOpenHelper.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 = mOpenHelper.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 = mOpenHelper.getReadableDatabase();
+                long activityId = ContentUris.parseId(uri);
+                return mOpenHelper.getActivityMimeType(activityId);
+            case CONTACT_STATUS_ID:
+                return Contacts.CONTENT_ITEM_TYPE;
+        }
+        throw new UnsupportedOperationException("Unknown uri: " + uri);
+    }
+}
diff --git a/tests/Android.mk b/tests/Android.mk
new file mode 100644
index 0000000..ec48f5a
--- /dev/null
+++ b/tests/Android.mk
@@ -0,0 +1,17 @@
+LOCAL_PATH:= $(call my-dir)
+include $(CLEAR_VARS)
+
+# We only want this apk build for tests.
+LOCAL_MODULE_TAGS := tests
+
+# Only compile source java files in this apk.
+LOCAL_SRC_FILES := $(call all-java-files-under, src)
+
+LOCAL_PACKAGE_NAME := ContactsProviderTests
+
+LOCAL_JAVA_LIBRARIES := android.test.runner
+
+LOCAL_INSTRUMENTATION_FOR := ContactsProvider
+LOCAL_CERTIFICATE := shared
+
+include $(BUILD_PACKAGE)
diff --git a/tests/AndroidManifest.xml b/tests/AndroidManifest.xml
new file mode 100644
index 0000000..5063a7d
--- /dev/null
+++ b/tests/AndroidManifest.xml
@@ -0,0 +1,40 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Copyright (C) 2008 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.
+-->
+
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+        package="com.android.providers.contacts.tests"
+        android:sharedUserId="android.uid.shared">
+
+    <uses-permission android:name="android.permission.READ_CONTACTS" />
+    <uses-permission android:name="android.permission.WRITE_CONTACTS" />
+
+    <application>
+        <uses-library android:name="android.test.runner" />
+    </application>
+
+    <!--
+    The test delcared in this instrumentation will be run along with tests declared by
+    all other applications via the command: "adb shell itr".
+    The "itr" command will find all tests declared by all applications. If you want to run just these
+    tests on their own then use the command:
+    "adb shell am instrument -w com.android.providers.contacts.tests/android.test.InstrumentationTestRunner"
+    -->
+    <instrumentation android:name="android.test.InstrumentationTestRunner"
+        android:targetPackage="com.android.providers.contacts"
+        android:label="Contacts Provider Tests">
+    </instrumentation>
+
+</manifest>
diff --git a/tests/src/com/android/providers/contacts/BaseContactsProvider2Test.java b/tests/src/com/android/providers/contacts/BaseContactsProvider2Test.java
new file mode 100644
index 0000000..cc27428
--- /dev/null
+++ b/tests/src/com/android/providers/contacts/BaseContactsProvider2Test.java
@@ -0,0 +1,600 @@
+/*
+ * 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 static com.android.providers.contacts.ContactsActor.PACKAGE_GREY;
+
+import android.accounts.Account;
+import android.content.ContentProvider;
+import android.content.ContentUris;
+import android.content.ContentValues;
+import android.content.Context;
+import android.content.Entity;
+import android.content.res.Resources;
+import android.database.Cursor;
+import android.net.Uri;
+import android.provider.ContactsContract;
+import android.provider.ContactsContract.AggregationExceptions;
+import android.provider.ContactsContract.Contacts;
+import android.provider.ContactsContract.Data;
+import android.provider.ContactsContract.Groups;
+import android.provider.ContactsContract.Presence;
+import android.provider.ContactsContract.RawContacts;
+import android.provider.ContactsContract.CommonDataKinds.Email;
+import android.provider.ContactsContract.CommonDataKinds.GroupMembership;
+import android.provider.ContactsContract.CommonDataKinds.Im;
+import android.provider.ContactsContract.CommonDataKinds.Nickname;
+import android.provider.ContactsContract.CommonDataKinds.Phone;
+import android.provider.ContactsContract.CommonDataKinds.Photo;
+import android.provider.ContactsContract.CommonDataKinds.StructuredName;
+import android.test.AndroidTestCase;
+import android.test.mock.MockContentResolver;
+import android.test.suitebuilder.annotation.LargeTest;
+
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Comparator;
+import java.util.Map;
+import java.util.Set;
+
+/**
+ * A common superclass for {@link ContactsProvider2}-related tests.
+ */
+@LargeTest
+public abstract class BaseContactsProvider2Test extends AndroidTestCase {
+
+    protected static final String PACKAGE = "ContactsProvider2Test";
+
+    protected ContactsActor mActor;
+    protected MockContentResolver mResolver;
+    protected Account mAccount = new Account("account1", "account type1");
+
+    protected final static Long NO_LONG = new Long(0);
+    protected final static String NO_STRING = new String("");
+    protected final static Account NO_ACCOUNT = new Account("a", "b");
+
+    protected Class<? extends ContentProvider> getProviderClass() {
+        return SynchronousContactsProvider2.class;
+    }
+
+    protected String getAuthority() {
+        return ContactsContract.AUTHORITY;
+    }
+
+    @Override
+    protected void setUp() throws Exception {
+        super.setUp();
+
+        mActor = new ContactsActor(getContext(), PACKAGE_GREY, getProviderClass(), getAuthority());
+        mResolver = mActor.resolver;
+        if (mActor.provider instanceof SynchronousContactsProvider2) {
+            ((SynchronousContactsProvider2) mActor.provider)
+                    .getOpenHelper(mActor.context).wipeData();
+        }
+    }
+
+    public Context getMockContext() {
+        return mActor.context;
+    }
+
+    public void addAuthority(String authority) {
+        mActor.addAuthority(authority);
+    }
+
+    public ContentProvider addProvider(Class<? extends ContentProvider> providerClass,
+            String authority) throws Exception {
+        return mActor.addProvider(providerClass, authority);
+    }
+
+    protected Uri maybeAddAccountQueryParameters(Uri uri, Account account) {
+        if (account == null) {
+            return uri;
+        }
+        return uri.buildUpon()
+                .appendQueryParameter(RawContacts.ACCOUNT_NAME, account.mName)
+                .appendQueryParameter(RawContacts.ACCOUNT_TYPE, account.mType)
+                .build();
+    }
+
+    protected long createRawContact() {
+        return createRawContact(null);
+    }
+
+    protected long createRawContactWithName() {
+        long rawContactId = createRawContact(null);
+        insertStructuredName(rawContactId, "John", "Doe");
+        return rawContactId;
+    }
+
+    protected long createRawContact(Account account, String... extras) {
+        ContentValues values = new ContentValues();
+        for (int i = 0; i < extras.length; ) {
+            values.put(extras[i], extras[i + 1]);
+            i += 2;
+        }
+        final Uri uri = maybeAddAccountQueryParameters(RawContacts.CONTENT_URI, account);
+        Uri contactUri = mResolver.insert(uri, values);
+        return ContentUris.parseId(contactUri);
+    }
+
+    protected long createGroup(Account account, String sourceId, String title) {
+        ContentValues values = new ContentValues();
+        values.put(Groups.SOURCE_ID, sourceId);
+        values.put(Groups.TITLE, title);
+        values.put(Groups.GROUP_VISIBLE, 1);
+        final Uri uri = maybeAddAccountQueryParameters(Groups.CONTENT_URI, account);
+        return ContentUris.parseId(mResolver.insert(uri, values));
+    }
+
+    protected Uri insertStructuredName(long rawContactId, String givenName, String familyName) {
+        ContentValues values = new ContentValues();
+        StringBuilder sb = new StringBuilder();
+        if (givenName != null) {
+            sb.append(givenName);
+        }
+        if (givenName != null && familyName != null) {
+            sb.append(" ");
+        }
+        if (familyName != null) {
+            sb.append(familyName);
+        }
+        values.put(StructuredName.DISPLAY_NAME, sb.toString());
+        values.put(StructuredName.GIVEN_NAME, givenName);
+        values.put(StructuredName.FAMILY_NAME, familyName);
+
+        return insertStructuredName(rawContactId, values);
+    }
+
+    protected Uri insertStructuredName(long rawContactId, ContentValues values) {
+        values.put(Data.RAW_CONTACT_ID, rawContactId);
+        values.put(Data.MIMETYPE, StructuredName.CONTENT_ITEM_TYPE);
+        Uri resultUri = mResolver.insert(Data.CONTENT_URI, values);
+        return resultUri;
+    }
+
+    protected Uri insertPhoneNumber(long rawContactId, String phoneNumber) {
+        ContentValues values = new ContentValues();
+        values.put(Data.RAW_CONTACT_ID, rawContactId);
+        values.put(Data.MIMETYPE, Phone.CONTENT_ITEM_TYPE);
+        values.put(Phone.NUMBER, phoneNumber);
+        values.put(Phone.TYPE, Phone.TYPE_HOME);
+
+        Uri resultUri = mResolver.insert(Data.CONTENT_URI, values);
+        return resultUri;
+    }
+
+    protected Uri insertEmail(long rawContactId, String email) {
+        ContentValues values = new ContentValues();
+        values.put(Data.RAW_CONTACT_ID, rawContactId);
+        values.put(Data.MIMETYPE, Email.CONTENT_ITEM_TYPE);
+        values.put(Email.DATA, email);
+        values.put(Email.TYPE, Email.TYPE_HOME);
+
+        Uri resultUri = mResolver.insert(Data.CONTENT_URI, values);
+        return resultUri;
+    }
+
+    protected Uri insertNickname(long rawContactId, String nickname) {
+        ContentValues values = new ContentValues();
+        values.put(Data.RAW_CONTACT_ID, rawContactId);
+        values.put(Data.MIMETYPE, Nickname.CONTENT_ITEM_TYPE);
+        values.put(Nickname.NAME, nickname);
+        values.put(Nickname.TYPE, Nickname.TYPE_OTHER_NAME);
+
+        Uri resultUri = mResolver.insert(Data.CONTENT_URI, values);
+        return resultUri;
+    }
+
+    protected Uri insertPhoto(long rawContactId) {
+        ContentValues values = new ContentValues();
+        values.put(Data.RAW_CONTACT_ID, rawContactId);
+        values.put(Data.MIMETYPE, Photo.CONTENT_ITEM_TYPE);
+
+        Uri resultUri = mResolver.insert(Data.CONTENT_URI, values);
+        return resultUri;
+    }
+
+    protected Uri insertGroupMembership(long rawContactId, String sourceId) {
+        ContentValues values = new ContentValues();
+        values.put(Data.RAW_CONTACT_ID, rawContactId);
+        values.put(Data.MIMETYPE, GroupMembership.CONTENT_ITEM_TYPE);
+        values.put(GroupMembership.GROUP_SOURCE_ID, sourceId);
+        return mResolver.insert(Data.CONTENT_URI, values);
+    }
+
+    protected Uri insertGroupMembership(long rawContactId, Long groupId) {
+        ContentValues values = new ContentValues();
+        values.put(Data.RAW_CONTACT_ID, rawContactId);
+        values.put(Data.MIMETYPE, GroupMembership.CONTENT_ITEM_TYPE);
+        values.put(GroupMembership.GROUP_ROW_ID, groupId);
+        return mResolver.insert(Data.CONTENT_URI, values);
+    }
+
+    protected Uri insertPresence(int protocol, String handle, int presence) {
+        ContentValues values = new ContentValues();
+        values.put(Presence.IM_PROTOCOL, protocol);
+        values.put(Presence.IM_HANDLE, handle);
+        values.put(Presence.PRESENCE_STATUS, presence);
+
+        Uri resultUri = mResolver.insert(Presence.CONTENT_URI, values);
+        return resultUri;
+    }
+
+    protected Uri insertImHandle(long rawContactId, int protocol, String handle) {
+        ContentValues values = new ContentValues();
+        values.put(Data.RAW_CONTACT_ID, rawContactId);
+        values.put(Data.MIMETYPE, Im.CONTENT_ITEM_TYPE);
+        values.put(Im.PROTOCOL, protocol);
+        values.put(Im.DATA, handle);
+        values.put(Im.TYPE, Im.TYPE_HOME);
+
+        Uri resultUri = mResolver.insert(Data.CONTENT_URI, values);
+        return resultUri;
+    }
+
+    protected void setContactAccountName(long rawContactId, String accountName) {
+        ContentValues values = new ContentValues();
+        values.put(RawContacts.ACCOUNT_NAME, accountName);
+
+        mResolver.update(ContentUris.withAppendedId(
+                RawContacts.CONTENT_URI, rawContactId), values, null, null);
+    }
+
+    protected void setAggregationException(int type, long contactId, long rawContactId) {
+        ContentValues values = new ContentValues();
+        values.put(AggregationExceptions.CONTACT_ID, contactId);
+        values.put(AggregationExceptions.RAW_CONTACT_ID, rawContactId);
+        values.put(AggregationExceptions.TYPE, type);
+        mResolver.update(AggregationExceptions.CONTENT_URI, values, null, null);
+    }
+
+    protected Cursor queryRawContact(long rawContactId) {
+        return mResolver.query(ContentUris.withAppendedId(RawContacts.CONTENT_URI, rawContactId), null,
+                null, null, null);
+    }
+
+    protected Cursor queryContact(long contactId) {
+        return mResolver.query(ContentUris.withAppendedId(Contacts.CONTENT_URI, contactId),
+                null, null, null, null);
+    }
+
+    protected Cursor queryContactSummary(long contactId, String[] projection) {
+        return mResolver.query(ContentUris.withAppendedId(Contacts.CONTENT_SUMMARY_URI,
+                contactId), projection, null, null, null);
+    }
+
+    protected Cursor queryContactSummary() {
+        return mResolver.query(Contacts.CONTENT_SUMMARY_URI, null, null, null, null);
+    }
+
+    protected long queryContactId(long rawContactId) {
+        Cursor c = queryRawContact(rawContactId);
+        assertTrue(c.moveToFirst());
+        long contactId = c.getLong(c.getColumnIndex(RawContacts.CONTACT_ID));
+        c.close();
+        return contactId;
+    }
+
+    protected long queryPhotoId(long contactId) {
+        Cursor c = queryContact(contactId);
+        assertTrue(c.moveToFirst());
+        long photoId = c.getInt(c.getColumnIndex(Contacts.PHOTO_ID));
+        c.close();
+        return photoId;
+    }
+
+    protected String queryDisplayName(long contactId) {
+        Cursor c = queryContact(contactId);
+        assertTrue(c.moveToFirst());
+        String displayName = c.getString(c.getColumnIndex(Contacts.DISPLAY_NAME));
+        c.close();
+        return displayName;
+    }
+
+    protected void assertAggregated(long rawContactId1, long rawContactId2) {
+        long contactId1 = queryContactId(rawContactId1);
+        long contactId2 = queryContactId(rawContactId2);
+        assertTrue(contactId1 == contactId2);
+    }
+
+    protected void assertAggregated(long rawContactId1, long rawContactId2,
+            String expectedDisplayName) {
+        long contactId1 = queryContactId(rawContactId1);
+        long contactId2 = queryContactId(rawContactId2);
+        assertTrue(contactId1 == contactId2);
+
+        String displayName = queryDisplayName(contactId1);
+        assertEquals(expectedDisplayName, displayName);
+    }
+
+    protected void assertNotAggregated(long rawContactId1, long rawContactId2) {
+        long contactId1 = queryContactId(rawContactId1);
+        long contactId2 = queryContactId(rawContactId2);
+        assertTrue(contactId1 != contactId2);
+    }
+
+    protected void assertStructuredName(long rawContactId, String prefix, String givenName,
+            String middleName, String familyName, String suffix) {
+        Uri uri =
+                Uri.withAppendedPath(ContentUris.withAppendedId(RawContacts.CONTENT_URI, rawContactId),
+                RawContacts.Data.CONTENT_DIRECTORY);
+
+        final String[] projection = new String[] {
+                StructuredName.PREFIX, StructuredName.GIVEN_NAME, StructuredName.MIDDLE_NAME,
+                StructuredName.FAMILY_NAME, StructuredName.SUFFIX
+        };
+
+        Cursor c = mResolver.query(uri, projection, Data.MIMETYPE + "='"
+                + StructuredName.CONTENT_ITEM_TYPE + "'", null, null);
+
+        assertTrue(c.moveToFirst());
+        assertEquals(prefix, c.getString(0));
+        assertEquals(givenName, c.getString(1));
+        assertEquals(middleName, c.getString(2));
+        assertEquals(familyName, c.getString(3));
+        assertEquals(suffix, c.getString(4));
+        c.close();
+    }
+
+    protected long assertSingleGroup(Long rowId, Account account, String sourceId, String title) {
+        Cursor c = mResolver.query(Groups.CONTENT_URI, null, null, null, null);
+        try {
+            assertTrue(c.moveToNext());
+            long actualRowId = assertGroup(c, rowId, account, sourceId, title);
+            assertFalse(c.moveToNext());
+            return actualRowId;
+        } finally {
+            c.close();
+        }
+    }
+
+    protected long assertSingleGroupMembership(Long rowId, Long rawContactId, Long groupRowId,
+            String sourceId) {
+        Cursor c = mResolver.query(ContactsContract.Data.CONTENT_URI, null, null, null, null);
+        try {
+            assertTrue(c.moveToNext());
+            long actualRowId = assertGroupMembership(c, rowId, rawContactId, groupRowId, sourceId);
+            assertFalse(c.moveToNext());
+            return actualRowId;
+        } finally {
+            c.close();
+        }
+    }
+
+    protected long assertGroupMembership(Cursor c, Long rowId, Long rawContactId, Long groupRowId,
+            String sourceId) {
+        assertNullOrEquals(c, rowId, Data._ID);
+        assertNullOrEquals(c, rawContactId, GroupMembership.RAW_CONTACT_ID);
+        assertNullOrEquals(c, groupRowId, GroupMembership.GROUP_ROW_ID);
+        assertNullOrEquals(c, sourceId, GroupMembership.GROUP_SOURCE_ID);
+        return c.getLong(c.getColumnIndexOrThrow("_id"));
+    }
+
+    protected long assertGroup(Cursor c, Long rowId, Account account, String sourceId, String title) {
+        assertNullOrEquals(c, rowId, Groups._ID);
+        assertNullOrEquals(c, account);
+        assertNullOrEquals(c, sourceId, Groups.SOURCE_ID);
+        assertNullOrEquals(c, title, Groups.TITLE);
+        return c.getLong(c.getColumnIndexOrThrow("_id"));
+    }
+
+    private void assertNullOrEquals(Cursor c, Account account) {
+        if (account == NO_ACCOUNT) {
+            return;
+        }
+        if (account == null) {
+            assertTrue(c.isNull(c.getColumnIndexOrThrow(Groups.ACCOUNT_NAME)));
+            assertTrue(c.isNull(c.getColumnIndexOrThrow(Groups.ACCOUNT_TYPE)));
+        } else {
+            assertEquals(account.mName, c.getString(c.getColumnIndexOrThrow(Groups.ACCOUNT_NAME)));
+            assertEquals(account.mType, c.getString(c.getColumnIndexOrThrow(Groups.ACCOUNT_TYPE)));
+        }
+    }
+
+    private void assertNullOrEquals(Cursor c, Long value, String columnName) {
+        if (value != NO_LONG) {
+            if (value == null) assertTrue(c.isNull(c.getColumnIndexOrThrow(columnName)));
+            else assertEquals((long) value, c.getLong(c.getColumnIndexOrThrow(columnName)));
+        }
+    }
+
+    private void assertNullOrEquals(Cursor c, String value, String columnName) {
+        if (value != NO_STRING) {
+            if (value == null) assertTrue(c.isNull(c.getColumnIndexOrThrow(columnName)));
+            else assertEquals(value, c.getString(c.getColumnIndexOrThrow(columnName)));
+        }
+    }
+
+    protected void assertDataRow(ContentValues actual, String expectedMimetype,
+            Object... expectedArguments) {
+        assertEquals(actual.toString(), expectedMimetype, actual.getAsString(Data.MIMETYPE));
+        for (int i = 0; i < expectedArguments.length; i += 2) {
+            String columnName = (String) expectedArguments[i];
+            Object expectedValue = expectedArguments[i + 1];
+            if (expectedValue instanceof Uri) {
+                expectedValue = ContentUris.parseId((Uri) expectedValue);
+            }
+            if (expectedValue == null) {
+                assertNull(actual.toString(), actual.get(columnName));
+            }
+            if (expectedValue instanceof Long) {
+                assertEquals("mismatch at " + columnName + " from " + actual.toString(),
+                        expectedValue, actual.getAsLong(columnName));
+            } else if (expectedValue instanceof Integer) {
+                assertEquals("mismatch at " + columnName + " from " + actual.toString(),
+                        expectedValue, actual.getAsInteger(columnName));
+            } else if (expectedValue instanceof String) {
+                assertEquals("mismatch at " + columnName + " from " + actual.toString(),
+                        expectedValue, actual.getAsString(columnName));
+            } else {
+                assertEquals("mismatch at " + columnName + " from " + actual.toString(),
+                        expectedValue, actual.get(columnName));
+            }
+        }
+    }
+
+    protected static class IdComparator implements Comparator<ContentValues> {
+        public int compare(ContentValues o1, ContentValues o2) {
+            long id1 = o1.getAsLong(ContactsContract.Data._ID);
+            long id2 = o2.getAsLong(ContactsContract.Data._ID);
+            if (id1 == id2) return 0;
+            return (id1 < id2) ? -1 : 1;
+        }
+    }
+
+    protected ContentValues[] asSortedContentValuesArray(
+            ArrayList<Entity.NamedContentValues> subValues) {
+        ContentValues[] result = new ContentValues[subValues.size()];
+        int i = 0;
+        for (Entity.NamedContentValues subValue : subValues) {
+            result[i] = subValue.values;
+            i++;
+        }
+        Arrays.sort(result, new IdComparator());
+        return result;
+    }
+
+    protected void assertDirty(Uri uri, boolean state) {
+        Cursor c = mResolver.query(uri, new String[]{"dirty"}, null, null, null);
+        assertTrue(c.moveToNext());
+        assertEquals(state, c.getLong(0) != 0);
+        assertFalse(c.moveToNext());
+    }
+
+    protected long getVersion(Uri uri) {
+        Cursor c = mResolver.query(uri, new String[]{"version"}, null, null, null);
+        assertTrue(c.moveToNext());
+        long version = c.getLong(0);
+        assertFalse(c.moveToNext());
+        return version;
+    }
+
+    protected void clearDirty(Uri uri) {
+        ContentValues values = new ContentValues();
+        values.put("dirty", 0);
+        mResolver.update(uri, values, null, null);
+    }
+
+    protected void assertStoredValues(Uri rowUri, String column, String expectedValue) {
+        String value = getStoredValue(rowUri, column);
+        assertEquals("Column value " + column, expectedValue, value);
+    }
+
+    protected String getStoredValue(Uri rowUri, String column) {
+        String value;
+        Cursor c = mResolver.query(rowUri, new String[] { column }, null, null, null);
+        try {
+            c.moveToFirst();
+            value = c.getString(c.getColumnIndex(column));
+        } finally {
+            c.close();
+        }
+        return value;
+    }
+
+    protected void assertStoredValues(Uri rowUri, ContentValues expectedValues) {
+        Cursor c = mResolver.query(rowUri, null, null, null, null);
+        try {
+            assertEquals("Record count", 1, c.getCount());
+            c.moveToFirst();
+            assertCursorValues(c, expectedValues);
+        } finally {
+            c.close();
+        }
+    }
+
+    /**
+     * Constructs a selection (where clause) out of all supplied values, uses it
+     * to query the provider and verifies that a single row is returned and it
+     * has the same values as requested.
+     */
+    protected void assertSelection(Uri uri, ContentValues values, String idColumn, long id) {
+        StringBuilder sb = new StringBuilder();
+        ArrayList<String> selectionArgs = new ArrayList<String>(values.size());
+        if (idColumn != null) {
+            sb.append(idColumn).append("=").append(id);
+        }
+        Set<Map.Entry<String, Object>> entries = values.valueSet();
+        for (Map.Entry<String, Object> entry : entries) {
+            String column = entry.getKey();
+            Object value = entry.getValue();
+            if (sb.length() != 0) {
+                sb.append(" AND ");
+            }
+            sb.append(column);
+            if (value == null) {
+                sb.append(" IS NULL");
+            } else {
+                sb.append("=?");
+                selectionArgs.add(String.valueOf(value));
+            }
+        }
+
+        Cursor c = mResolver.query(uri, null, sb.toString(), selectionArgs.toArray(new String[0]),
+                null);
+        try {
+            assertEquals("Record count", 1, c.getCount());
+            c.moveToFirst();
+            assertCursorValues(c, values);
+        } finally {
+            c.close();
+        }
+    }
+
+    protected void assertCursorValues(Cursor cursor, ContentValues expectedValues) {
+        Set<Map.Entry<String, Object>> entries = expectedValues.valueSet();
+        for (Map.Entry<String, Object> entry : entries) {
+            String column = entry.getKey();
+            int index = cursor.getColumnIndex(column);
+            assertTrue("No such column: " + column, index != -1);
+            Object expectedValue = expectedValues.get(column);
+            String value;
+            if (expectedValue instanceof byte[]) {
+                expectedValue = Hex.encodeHex((byte[])expectedValue, false);
+                value = Hex.encodeHex(cursor.getBlob(index), false);
+            } else {
+                expectedValue = expectedValues.getAsString(column);
+                value = cursor.getString(index);
+            }
+            assertEquals("Column value " + column, expectedValue, value);
+        }
+    }
+
+    protected int getCount(Uri uri, String selection, String[] selectionArgs) {
+        Cursor c = mResolver.query(uri, null, selection, selectionArgs, null);
+        try {
+            return c.getCount();
+        } finally {
+            c.close();
+        }
+    }
+
+    protected byte[] loadTestPhoto() throws IOException {
+        final Resources resources = getContext().getResources();
+        InputStream is =
+                resources.openRawResource(com.android.internal.R.drawable.ic_contact_picture);
+        ByteArrayOutputStream os = new ByteArrayOutputStream();
+        byte[] buffer = new byte[1000];
+        int count;
+        while((count = is.read(buffer)) != -1) {
+            os.write(buffer, 0, count);
+        }
+        return os.toByteArray();
+    }
+}
diff --git a/tests/src/com/android/providers/contacts/CallLogProviderTest.java b/tests/src/com/android/providers/contacts/CallLogProviderTest.java
new file mode 100644
index 0000000..75ebda9
--- /dev/null
+++ b/tests/src/com/android/providers/contacts/CallLogProviderTest.java
@@ -0,0 +1,168 @@
+/*
+ * 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.internal.telephony.CallerInfo;
+import com.android.internal.telephony.Connection;
+
+import android.content.ContentProvider;
+import android.content.ContentUris;
+import android.content.ContentValues;
+import android.content.Context;
+import android.database.Cursor;
+import android.net.Uri;
+import android.provider.CallLog;
+import android.provider.ContactsContract;
+import android.provider.CallLog.Calls;
+import android.provider.Contacts.ContactMethods;
+import android.test.suitebuilder.annotation.LargeTest;
+
+/**
+ * Unit tests for {@link CallLogProvider}.
+ *
+ * Run the test like this:
+ * <code>
+ * adb shell am instrument -w \
+ *         com.android.providers.contacts.tests/android.test.InstrumentationTestRunner
+ * </code>
+ */
+@LargeTest
+public class CallLogProviderTest extends BaseContactsProvider2Test {
+
+    private static final boolean USE_LEGACY_PROVIDER = false;
+
+    @Override
+    protected Class<? extends ContentProvider> getProviderClass() {
+       return USE_LEGACY_PROVIDER ? ContactsProvider.class : ContactsProvider2.class;
+    }
+
+    @Override
+    protected String getAuthority() {
+        return ContactsContract.AUTHORITY;
+    }
+
+    @Override
+    protected void setUp() throws Exception {
+        super.setUp();
+        if (USE_LEGACY_PROVIDER) {
+            addAuthority(CallLog.AUTHORITY);
+        } else {
+            addProvider(TestCallLogProvider.class, CallLog.AUTHORITY);
+        }
+    }
+
+    public void testInsert() {
+        ContentValues values = new ContentValues();
+        putCallValues(values);
+        Uri uri = mResolver.insert(Calls.CONTENT_URI, values);
+        assertStoredValues(uri, values);
+        assertSelection(uri, values, Calls._ID, ContentUris.parseId(uri));
+    }
+
+    public void testUpdate() {
+        ContentValues values = new ContentValues();
+        putCallValues(values);
+        Uri uri = mResolver.insert(Calls.CONTENT_URI, values);
+
+        values.clear();
+        values.put(Calls.TYPE, Calls.OUTGOING_TYPE);
+        values.put(Calls.NUMBER, "1-800-263-7643");
+        values.put(Calls.DATE, 2000);
+        values.put(Calls.DURATION, 40);
+        values.put(Calls.CACHED_NAME, "1-800-GOOG-411");
+        values.put(Calls.CACHED_NUMBER_TYPE, ContactMethods.TYPE_CUSTOM);
+        values.put(Calls.CACHED_NUMBER_LABEL, "Directory");
+
+        int count = mResolver.update(uri, values, null, null);
+        assertEquals(1, count);
+        assertStoredValues(uri, values);
+    }
+
+    public void testDelete() {
+        ContentValues values = new ContentValues();
+        putCallValues(values);
+        Uri uri = mResolver.insert(Calls.CONTENT_URI, values);
+        try {
+            mResolver.delete(uri, null, null);
+            fail();
+        } catch (UnsupportedOperationException ex) {
+            // Expected
+        }
+
+        int count = mResolver.delete(Calls.CONTENT_URI, Calls._ID + "="
+                + ContentUris.parseId(uri), null);
+        assertEquals(1, count);
+        assertEquals(0, getCount(uri, null, null));
+    }
+
+    public void testCallLogFilter() {
+        ContentValues values = new ContentValues();
+        putCallValues(values);
+        mResolver.insert(Calls.CONTENT_URI, values);
+
+        Uri filterUri = Uri.withAppendedPath(Calls.CONTENT_FILTER_URI, "1-800-4664-411");
+        Cursor c = mResolver.query(filterUri, null, null, null, null);
+        assertEquals(1, c.getCount());
+        c.moveToFirst();
+        assertCursorValues(c, values);
+        c.close();
+
+        filterUri = Uri.withAppendedPath(Calls.CONTENT_FILTER_URI, "1-888-4664-411");
+        c = mResolver.query(filterUri, null, null, null, null);
+        assertEquals(0, c.getCount());
+        c.close();
+    }
+
+    public void testAddCall() {
+        CallerInfo ci = new CallerInfo();
+        ci.name = "1-800-GOOG-411";
+        ci.numberType = ContactMethods.TYPE_CUSTOM;
+        ci.numberLabel = "Directory";
+        Uri uri = Calls.addCall(ci, getMockContext(), "1-800-263-7643",
+                Connection.PRESENTATION_ALLOWED, Calls.OUTGOING_TYPE, 2000, 40);
+
+        ContentValues values = new ContentValues();
+        values.put(Calls.TYPE, Calls.OUTGOING_TYPE);
+        values.put(Calls.NUMBER, "1-800-263-7643");
+        values.put(Calls.DATE, 2000);
+        values.put(Calls.DURATION, 40);
+        values.put(Calls.CACHED_NAME, "1-800-GOOG-411");
+        values.put(Calls.CACHED_NUMBER_TYPE, ContactMethods.TYPE_CUSTOM);
+        values.put(Calls.CACHED_NUMBER_LABEL, "Directory");
+        assertStoredValues(uri, values);
+    }
+
+    private void putCallValues(ContentValues values) {
+        values.put(Calls.TYPE, Calls.INCOMING_TYPE);
+        values.put(Calls.NUMBER, "1-800-4664-411");
+        values.put(Calls.DATE, 1000);
+        values.put(Calls.DURATION, 30);
+        values.put(Calls.NEW, 1);
+    }
+
+    public static class TestCallLogProvider extends CallLogProvider {
+        private static OpenHelper mOpenHelper;
+
+        @Override
+        protected OpenHelper getOpenHelper(final Context context) {
+            if (mOpenHelper == null) {
+                mOpenHelper = new OpenHelper(context);
+            }
+            return mOpenHelper;
+        }
+    }
+}
+
diff --git a/tests/src/com/android/providers/contacts/ContactAggregationSchedulerTest.java b/tests/src/com/android/providers/contacts/ContactAggregationSchedulerTest.java
new file mode 100644
index 0000000..1a98d2a
--- /dev/null
+++ b/tests/src/com/android/providers/contacts/ContactAggregationSchedulerTest.java
@@ -0,0 +1,119 @@
+/*
+ * 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 android.test.suitebuilder.annotation.SmallTest;
+
+import junit.framework.TestCase;
+
+/**
+ * Tests from {@link ContactAggregationScheduler}.
+ */
+@SmallTest
+public class ContactAggregationSchedulerTest extends TestCase {
+
+    private TestContactAggregationScheduler mScheduler;
+
+    @Override
+    protected void setUp() throws Exception {
+        mScheduler = new TestContactAggregationScheduler();
+    }
+
+    public void testScheduleInitial() {
+        mScheduler.schedule();
+        assertEquals(1, mScheduler.mRunDelayed);
+    }
+
+    public void testScheduleTwiceRapidly() {
+        mScheduler.schedule();
+
+        mScheduler.mTime += ContactAggregationScheduler.AGGREGATION_DELAY / 2;
+        mScheduler.schedule();
+        assertEquals(2, mScheduler.mRunDelayed);
+    }
+
+    public void testScheduleTwiceExceedingMaxDelay() {
+        mScheduler.schedule();
+
+        mScheduler.mTime += ContactAggregationScheduler.MAX_AGGREGATION_DELAY + 100;
+        mScheduler.schedule();
+        assertEquals(1, mScheduler.mRunDelayed);
+    }
+
+    public void testScheduleWhileRunning() {
+        mScheduler.setAggregator(new ContactAggregationScheduler.Aggregator() {
+            boolean mInterruptCalled;
+
+            public void interrupt() {
+                mInterruptCalled = true;
+            }
+
+            public void run() {
+                mScheduler.schedule();
+                assertTrue(mInterruptCalled);
+            }
+        });
+
+        mScheduler.run();
+        assertEquals(1, mScheduler.mRunDelayed);
+    }
+
+    public void testScheduleWhileRunningExceedingMaxDelay() {
+        mScheduler.schedule();
+
+        mScheduler.mTime += ContactAggregationScheduler.MAX_AGGREGATION_DELAY + 100;
+
+        mScheduler.setAggregator(new ContactAggregationScheduler.Aggregator() {
+            boolean mInterruptCalled;
+
+            public void interrupt() {
+                mInterruptCalled = true;
+            }
+
+            public void run() {
+                mScheduler.schedule();
+                assertFalse(mInterruptCalled);
+            }
+        });
+
+        mScheduler.run();
+        assertEquals(2, mScheduler.mRunDelayed);
+    }
+
+    private static class TestContactAggregationScheduler extends ContactAggregationScheduler {
+
+        long mTime = 1000;
+        int mRunDelayed;
+
+        @Override
+        public void start() {
+        }
+
+        @Override
+        public void stop() {
+        }
+
+        @Override
+        long currentTime() {
+            return mTime;
+        }
+
+        @Override
+        void runDelayed() {
+            mRunDelayed++;
+        }
+    }
+}
diff --git a/tests/src/com/android/providers/contacts/ContactAggregatorTest.java b/tests/src/com/android/providers/contacts/ContactAggregatorTest.java
new file mode 100644
index 0000000..06dc197
--- /dev/null
+++ b/tests/src/com/android/providers/contacts/ContactAggregatorTest.java
@@ -0,0 +1,563 @@
+/*
+ * 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 android.content.ContentUris;
+import android.database.Cursor;
+import android.net.Uri;
+import android.provider.ContactsContract.Contacts;
+import android.provider.ContactsContract.AggregationExceptions;
+import android.test.suitebuilder.annotation.LargeTest;
+
+/**
+ * Unit tests for {@link ContactAggregator}.
+ *
+ * Run the test like this:
+ * <code>
+ * adb shell am instrument -w \
+ *         com.android.providers.contacts.tests/android.test.InstrumentationTestRunner
+ * </code>
+ */
+@LargeTest
+public class ContactAggregatorTest extends BaseContactsProvider2Test {
+
+    private static final String[] AGGREGATION_EXCEPTION_PROJECTION = new String[] {
+            AggregationExceptions.TYPE,
+            AggregationExceptions.CONTACT_ID,
+            AggregationExceptions.RAW_CONTACT_ID
+    };
+
+    public void testCrudAggregationExceptions() throws Exception {
+        long rawContactId1 = createRawContact();
+        long contactId = queryContactId(rawContactId1);
+        long rawContactId2 = createRawContact();
+
+        setAggregationException(AggregationExceptions.TYPE_KEEP_IN, contactId, rawContactId2);
+
+        // Refetch the row we have just inserted
+        Cursor c = mResolver.query(AggregationExceptions.CONTENT_URI,
+                AGGREGATION_EXCEPTION_PROJECTION, AggregationExceptions.CONTACT_ID + "="
+                        + contactId, null, null);
+
+        assertTrue(c.moveToFirst());
+        assertEquals(AggregationExceptions.TYPE_KEEP_IN, c.getInt(0));
+        assertEquals(contactId, c.getLong(1));
+        assertEquals(rawContactId2, c.getLong(2));
+        assertFalse(c.moveToNext());
+        c.close();
+
+        // Change from TYPE_KEEP_IN to TYPE_KEEP_OUT
+        setAggregationException(AggregationExceptions.TYPE_KEEP_OUT, contactId, rawContactId2);
+
+        c = mResolver.query(AggregationExceptions.CONTENT_URI,
+                AGGREGATION_EXCEPTION_PROJECTION, AggregationExceptions.CONTACT_ID + "="
+                        + contactId, null, null);
+
+        assertTrue(c.moveToFirst());
+        assertEquals(AggregationExceptions.TYPE_KEEP_OUT, c.getInt(0));
+        assertEquals(contactId, c.getLong(1));
+        assertEquals(rawContactId2, c.getLong(2));
+        assertFalse(c.moveToNext());
+        c.close();
+
+        // Delete the rule
+        setAggregationException(AggregationExceptions.TYPE_AUTOMATIC, contactId, rawContactId2);
+
+        // Verify that the row is gone
+        c = mResolver.query(AggregationExceptions.CONTENT_URI,
+                AGGREGATION_EXCEPTION_PROJECTION, AggregationExceptions.CONTACT_ID + "="
+                        + contactId, null, null);
+        assertFalse(c.moveToFirst());
+        c.close();
+    }
+
+    public void testAggregationCreatesNewAggregate() {
+        long rawContactId = createRawContact();
+
+        Uri resultUri = insertStructuredName(rawContactId, "Johna", "Smitha");
+
+        // Parse the URI and confirm that it contains an ID
+        assertTrue(ContentUris.parseId(resultUri) != 0);
+
+        long contactId = queryContactId(rawContactId);
+        assertTrue(contactId != 0);
+
+        String displayName = queryDisplayName(contactId);
+        assertEquals("Johna Smitha", displayName);
+    }
+
+    public void testAggregationOfExactFullNameMatch() {
+        long rawContactId1 = createRawContact();
+        insertStructuredName(rawContactId1, "Johnb", "Smithb");
+
+        long rawContactId2 = createRawContact();
+        insertStructuredName(rawContactId2, "Johnb", "Smithb");
+
+        assertAggregated(rawContactId1, rawContactId2, "Johnb Smithb");
+    }
+
+    public void testAggregationOfCaseInsensitiveFullNameMatch() {
+        long rawContactId1 = createRawContact();
+        insertStructuredName(rawContactId1, "Johnc", "Smithc");
+
+        long rawContactId2 = createRawContact();
+        insertStructuredName(rawContactId2, "Johnc", "smithc");
+
+        assertAggregated(rawContactId1, rawContactId2, "Johnc Smithc");
+    }
+
+    public void testAggregationOfLastNameMatch() {
+        long rawContactId1 = createRawContact();
+        insertStructuredName(rawContactId1, null, "Johnd");
+
+        long rawContactId2 = createRawContact();
+        insertStructuredName(rawContactId2, null, "johnd");
+
+        assertAggregated(rawContactId1, rawContactId2, "Johnd");
+    }
+
+    public void testNonAggregationOfFirstNameMatch() {
+        long rawContactId1 = createRawContact();
+        insertStructuredName(rawContactId1, "Johne", "Smithe");
+
+        long rawContactId2 = createRawContact();
+        insertStructuredName(rawContactId2, "Johne", null);
+
+        assertNotAggregated(rawContactId1, rawContactId2);
+    }
+
+    // TODO: should this be allowed to match?
+    public void testNonAggregationOfLastNameMatch() {
+        long rawContactId1 = createRawContact();
+        insertStructuredName(rawContactId1, "Johnf", "Smithf");
+
+        long rawContactId2 = createRawContact();
+        insertStructuredName(rawContactId2, null, "Smithf");
+
+        assertNotAggregated(rawContactId1, rawContactId2);
+    }
+
+    public void testAggregationOfConcatenatedFullNameMatch() {
+        long rawContactId1 = createRawContact();
+        insertStructuredName(rawContactId1, "Johng", "Smithg");
+
+        long rawContactId2 = createRawContact();
+        insertStructuredName(rawContactId2, "johngsmithg", null);
+
+        assertAggregated(rawContactId1, rawContactId2, "Johng Smithg");
+    }
+
+    public void testAggregationOfNormalizedFullNameMatch() {
+        long rawContactId1 = createRawContact();
+        insertStructuredName(rawContactId1, "H\u00e9l\u00e8ne", "Bj\u00f8rn");
+
+        long rawContactId2 = createRawContact();
+        insertStructuredName(rawContactId2, "helene bjorn", null);
+
+        assertAggregated(rawContactId1, rawContactId2, "H\u00e9l\u00e8ne Bj\u00f8rn");
+    }
+
+    public void testAggregationBasedOnPhoneNumberNoNameData() {
+        long rawContactId1 = createRawContact();
+        insertPhoneNumber(rawContactId1, "(888)555-1231");
+
+        long rawContactId2 = createRawContact();
+        insertPhoneNumber(rawContactId2, "1(888)555-1231");
+
+        assertAggregated(rawContactId1, rawContactId2);
+    }
+
+    public void testAggregationBasedOnPhoneNumberWhenTargetAggregateHasNoName() {
+        long rawContactId1 = createRawContact();
+        insertPhoneNumber(rawContactId1, "(888)555-1232");
+
+        long rawContactId2 = createRawContact();
+        insertStructuredName(rawContactId2, "Johnl", "Smithl");
+        insertPhoneNumber(rawContactId2, "1(888)555-1232");
+
+        assertAggregated(rawContactId1, rawContactId2);
+    }
+
+    public void testAggregationBasedOnPhoneNumberWhenNewContactHasNoName() {
+        long rawContactId1 = createRawContact();
+        insertStructuredName(rawContactId1, "Johnm", "Smithm");
+        insertPhoneNumber(rawContactId1, "(888)555-1233");
+
+        long rawContactId2 = createRawContact();
+        insertPhoneNumber(rawContactId2, "1(888)555-1233");
+
+        assertAggregated(rawContactId1, rawContactId2);
+    }
+
+    public void testAggregationBasedOnPhoneNumberWithSimilarNames() {
+        long rawContactId1 = createRawContact();
+        insertStructuredName(rawContactId1, "Ogre", "Hunter");
+        insertPhoneNumber(rawContactId1, "(888)555-1234");
+
+        long rawContactId2 = createRawContact();
+        insertStructuredName(rawContactId2, "Opra", "Humper");
+        insertPhoneNumber(rawContactId2, "1(888)555-1234");
+
+        assertAggregated(rawContactId1, rawContactId2);
+    }
+
+    public void testAggregationBasedOnPhoneNumberWithDifferentNames() {
+        long rawContactId1 = createRawContact();
+        insertStructuredName(rawContactId1, "Baby", "Bear");
+        insertPhoneNumber(rawContactId1, "(888)555-1235");
+
+        long rawContactId2 = createRawContact();
+        insertStructuredName(rawContactId2, "Blind", "Mouse");
+        insertPhoneNumber(rawContactId2, "1(888)555-1235");
+
+        assertNotAggregated(rawContactId1, rawContactId2);
+    }
+
+    public void testAggregationBasedOnEmailNoNameData() {
+        long rawContactId1 = createRawContact();
+        insertEmail(rawContactId1, "lightning@android.com");
+
+        long rawContactId2 = createRawContact();
+        insertEmail(rawContactId2, "lightning@android.com");
+
+        assertAggregated(rawContactId1, rawContactId2);
+    }
+
+    public void testAggregationBasedOnEmailWhenTargetAggregateHasNoName() {
+        long rawContactId1 = createRawContact();
+        insertEmail(rawContactId1, "mcqueen@android.com");
+
+        long rawContactId2 = createRawContact();
+        insertStructuredName(rawContactId2, "Lightning", "McQueen");
+        insertEmail(rawContactId2, "mcqueen@android.com");
+
+        assertAggregated(rawContactId1, rawContactId2);
+    }
+
+    public void testAggregationBasedOnEmailWhenNewContactHasNoName() {
+        long rawContactId1 = createRawContact();
+        insertStructuredName(rawContactId1, "Doc", "Hudson");
+        insertEmail(rawContactId1, "doc@android.com");
+
+        long rawContactId2 = createRawContact();
+        insertEmail(rawContactId2, "doc@android.com");
+
+        assertAggregated(rawContactId1, rawContactId2);
+    }
+
+    public void testAggregationBasedOnEmailWithSimilarNames() {
+        long rawContactId1 = createRawContact();
+        insertStructuredName(rawContactId1, "Sally", "Carrera");
+        insertEmail(rawContactId1, "sally@android.com");
+
+        long rawContactId2 = createRawContact();
+        insertStructuredName(rawContactId2, "Sallie", "Carerra");
+        insertEmail(rawContactId2, "sally@android.com");
+
+        assertAggregated(rawContactId1, rawContactId2);
+    }
+
+    public void testAggregationBasedOnEmailWithDifferentNames() {
+        long rawContactId1 = createRawContact();
+        insertStructuredName(rawContactId1, "Chick", "Hicks");
+        insertEmail(rawContactId1, "hicky@android.com");
+
+        long rawContactId2 = createRawContact();
+        insertStructuredName(rawContactId2, "Luigi", "Guido");
+        insertEmail(rawContactId2, "hicky@android.com");
+
+        assertNotAggregated(rawContactId1, rawContactId2);
+    }
+
+    public void testAggregationByCommonNicknameWithLastName() {
+        long rawContactId1 = createRawContact();
+        insertStructuredName(rawContactId1, "Bill", "Gore");
+
+        long rawContactId2 = createRawContact();
+        insertStructuredName(rawContactId2, "William", "Gore");
+
+        assertAggregated(rawContactId1, rawContactId2, "William Gore");
+    }
+
+    public void testAggregationByCommonNicknameOnly() {
+        long rawContactId1 = createRawContact();
+        insertStructuredName(rawContactId1, "Lawrence", null);
+
+        long rawContactId2 = createRawContact();
+        insertStructuredName(rawContactId2, "Larry", null);
+
+        assertAggregated(rawContactId1, rawContactId2, "Lawrence");
+    }
+
+    public void testAggregationByNicknameNoStructuredName() {
+        long rawContactId1 = createRawContact();
+        insertNickname(rawContactId1, "Frozone");
+
+        long rawContactId2 = createRawContact();
+        insertNickname(rawContactId2, "Frozone");
+
+        assertAggregated(rawContactId1, rawContactId2);
+    }
+
+    public void testAggregationByNicknameWithSimilarNames() {
+        long rawContactId1 = createRawContact();
+        insertStructuredName(rawContactId1, "Buddy", "Pine");
+        insertNickname(rawContactId1, "Syndrome");
+
+        long rawContactId2 = createRawContact();
+        insertStructuredName(rawContactId2, "Body", "Pane");
+        insertNickname(rawContactId2, "Syndrome");
+
+        assertAggregated(rawContactId1, rawContactId2);
+    }
+
+    public void testAggregationByNicknameWithDifferentNames() {
+        long rawContactId1 = createRawContact();
+        insertStructuredName(rawContactId1, "Helen", "Parr");
+        insertNickname(rawContactId1, "Elastigirl");
+
+        long rawContactId2 = createRawContact();
+        insertStructuredName(rawContactId2, "Shawn", "Johnson");
+        insertNickname(rawContactId2, "Elastigirl");
+
+        assertNotAggregated(rawContactId1, rawContactId2);
+    }
+
+    public void testAggregationExceptionKeepIn() {
+        long rawContactId1 = createRawContact();
+        insertStructuredName(rawContactId1, "Johnk", "Smithk");
+
+        long rawContactId2 = createRawContact();
+        insertStructuredName(rawContactId2, "Johnkx", "Smithkx");
+
+        long contactId1 = queryContactId(rawContactId1);
+        long contactId2 = queryContactId(rawContactId2);
+
+        setAggregationException(AggregationExceptions.TYPE_KEEP_IN,
+                queryContactId(rawContactId1), rawContactId2);
+
+        assertAggregated(rawContactId1, rawContactId2, "Johnkx Smithkx");
+
+        // Assert that the empty aggregate got removed
+        long newContactId1 = queryContactId(rawContactId1);
+        if (contactId1 != newContactId1) {
+            Cursor cursor = queryContact(contactId1);
+            assertFalse(cursor.moveToFirst());
+            cursor.close();
+        } else {
+            Cursor cursor = queryContact(contactId2);
+            assertFalse(cursor.moveToFirst());
+            cursor.close();
+        }
+    }
+
+    public void testAggregationExceptionKeepOut() {
+        long rawContactId1 = createRawContact();
+        insertStructuredName(rawContactId1, "Johnh", "Smithh");
+
+        long rawContactId2 = createRawContact();
+        insertStructuredName(rawContactId2, "Johnh", "Smithh");
+
+        setAggregationException(AggregationExceptions.TYPE_KEEP_OUT,
+                queryContactId(rawContactId1), rawContactId2);
+
+        assertNotAggregated(rawContactId1, rawContactId2);
+    }
+
+    public void testAggregationExceptionKeepOutCheckUpdatesDisplayName() {
+        long rawContactId1 = createRawContact();
+        insertStructuredName(rawContactId1, "Johni", "Smithi");
+
+        long rawContactId2 = createRawContact();
+        insertStructuredName(rawContactId2, "Johnj", "Smithj");
+
+        setAggregationException(AggregationExceptions.TYPE_KEEP_IN,
+                queryContactId(rawContactId1), rawContactId2);
+
+        assertAggregated(rawContactId1, rawContactId2, "Johnj Smithj");
+
+        setAggregationException(AggregationExceptions.TYPE_KEEP_OUT,
+                queryContactId(rawContactId1), rawContactId2);
+
+        assertNotAggregated(rawContactId1, rawContactId2);
+
+        String displayName1 = queryDisplayName(queryContactId(rawContactId1));
+        assertEquals("Johni Smithi", displayName1);
+
+        String displayName2 = queryDisplayName(queryContactId(rawContactId2));
+        assertEquals("Johnj Smithj", displayName2);
+    }
+
+    public void testAggregationSuggestionsBasedOnName() {
+        long rawContactId1 = createRawContact();
+        insertStructuredName(rawContactId1, "Duane", null);
+
+        // Exact name match
+        long rawContactId2 = createRawContact();
+        insertStructuredName(rawContactId2, "Duane", null);
+        setAggregationException(AggregationExceptions.TYPE_KEEP_OUT,
+                queryContactId(rawContactId1), rawContactId2);
+
+        // Edit distance == 0.84
+        long rawContactId3 = createRawContact();
+        insertStructuredName(rawContactId3, "Dwayne", null);
+
+        // Edit distance == 0.6
+        long rawContactId4 = createRawContact();
+        insertStructuredName(rawContactId4, "Donny", null);
+
+        long contactId1 = queryContactId(rawContactId1);
+        long contactId2 = queryContactId(rawContactId2);
+        long contactId3 = queryContactId(rawContactId3);
+
+        assertSuggestions(contactId1, contactId2, contactId3);
+    }
+
+    public void testAggregationSuggestionsBasedOnPhoneNumber() {
+
+        // Create two contacts that would not be aggregated because of name mismatch
+        long rawContactId1 = createRawContact();
+        insertStructuredName(rawContactId1, "Lord", "Farquaad");
+        insertPhoneNumber(rawContactId1, "(888)555-1236");
+
+        long rawContactId2 = createRawContact();
+        insertStructuredName(rawContactId2, "Talking", "Donkey");
+        insertPhoneNumber(rawContactId2, "1(888)555-1236");
+
+        long contactId1 = queryContactId(rawContactId1);
+        long contactId2 = queryContactId(rawContactId2);
+        assertTrue(contactId1 != contactId2);
+
+        assertSuggestions(contactId1, contactId2);
+    }
+
+    public void testAggregationSuggestionsBasedOnEmailAddress() {
+
+        // Create two contacts that would not be aggregated because of name mismatch
+        long rawContactId1 = createRawContact();
+        insertStructuredName(rawContactId1, "Carl", "Fredricksen");
+        insertEmail(rawContactId1, "up@android.com");
+
+        long rawContactId2 = createRawContact();
+        insertStructuredName(rawContactId2, "Charles", "Muntz");
+        insertEmail(rawContactId2, "up@android.com");
+
+        long contactId1 = queryContactId(rawContactId1);
+        long contactId2 = queryContactId(rawContactId2);
+        assertTrue(contactId1 != contactId2);
+
+        assertSuggestions(contactId1, contactId2);
+    }
+
+    public void testAggregationSuggestionsBasedOnEmailAddressApproximateMatch() {
+
+        // Create two contacts that would not be aggregated because of name mismatch
+        long rawContactId1 = createRawContact();
+        insertStructuredName(rawContactId1, "Bob", null);
+        insertEmail(rawContactId1, "incredible2004@android.com");
+
+        long rawContactId2 = createRawContact();
+        insertStructuredName(rawContactId2, "Lucius", "Best");
+        insertEmail(rawContactId2, "incrediball@androidd.com");
+
+        long contactId1 = queryContactId(rawContactId1);
+        long contactId2 = queryContactId(rawContactId2);
+        assertTrue(contactId1 != contactId2);
+
+        assertSuggestions(contactId1, contactId2);
+    }
+
+    public void testAggregationSuggestionsBasedOnNickname() {
+        long rawContactId1 = createRawContact();
+        insertStructuredName(rawContactId1, "Peter", "Parker");
+        insertNickname(rawContactId1, "Spider-Man");
+
+        long rawContactId2 = createRawContact();
+        insertStructuredName(rawContactId2, "Manny", "Spider");
+
+        long contactId1 = queryContactId(rawContactId1);
+        setAggregationException(AggregationExceptions.TYPE_KEEP_OUT, contactId1, rawContactId2);
+
+        long contactId2 = queryContactId(rawContactId2);
+        assertSuggestions(contactId1, contactId2);
+    }
+
+    public void testAggregationSuggestionsBasedOnNicknameMatchingName() {
+        long rawContactId1 = createRawContact();
+        insertStructuredName(rawContactId1, "Clark", "Kent");
+        insertNickname(rawContactId1, "Superman");
+
+        long rawContactId2 = createRawContact();
+        insertStructuredName(rawContactId2, "Roy", "Williams");
+        insertNickname(rawContactId2, "superman");
+
+        long contactId1 = queryContactId(rawContactId1);
+        setAggregationException(AggregationExceptions.TYPE_KEEP_OUT, contactId1, rawContactId2);
+
+        long contactId2 = queryContactId(rawContactId2);
+        assertSuggestions(contactId1, contactId2);
+    }
+
+    public void testAggregationSuggestionsBasedOnCommonNickname() {
+        long rawContactId1 = createRawContact();
+        insertStructuredName(rawContactId1, "Dick", "Cherry");
+
+        long rawContactId2 = createRawContact();
+        insertStructuredName(rawContactId2, "Richard", "Cherry");
+
+        long contactId1 = queryContactId(rawContactId1);
+        setAggregationException(AggregationExceptions.TYPE_KEEP_OUT, contactId1, rawContactId2);
+
+        long contactId2 = queryContactId(rawContactId2);
+        assertSuggestions(contactId1, contactId2);
+    }
+
+    public void testChoosePhoto() {
+        long rawContactId1 = createRawContact();
+        setContactAccountName(rawContactId1, "donut");
+        long donutId = ContentUris.parseId(insertPhoto(rawContactId1));
+        long contactId = queryContactId(rawContactId1);
+
+        long rawContactId2 = createRawContact();
+        setAggregationException(AggregationExceptions.TYPE_KEEP_IN, contactId, rawContactId2);
+        setContactAccountName(rawContactId2, "cupcake");
+        long cupcakeId = ContentUris.parseId(insertPhoto(rawContactId2));
+
+        long rawContactId3 = createRawContact();
+        setAggregationException(AggregationExceptions.TYPE_KEEP_IN, contactId, rawContactId3);
+        setContactAccountName(rawContactId3, "flan");
+        long flanId = ContentUris.parseId(insertPhoto(rawContactId3));
+
+        assertEquals(cupcakeId, queryPhotoId(queryContactId(rawContactId2)));
+    }
+
+    private void assertSuggestions(long contactId, long... suggestions) {
+        final Uri aggregateUri = ContentUris.withAppendedId(Contacts.CONTENT_URI, contactId);
+        Uri uri = Uri.withAppendedPath(aggregateUri,
+                Contacts.AggregationSuggestions.CONTENT_DIRECTORY);
+        final Cursor cursor = mResolver.query(uri, new String[] { Contacts._ID },
+                null, null, null);
+
+        assertEquals(suggestions.length, cursor.getCount());
+
+        for (int i = 0; i < suggestions.length; i++) {
+            cursor.moveToNext();
+            assertEquals(suggestions[i], cursor.getLong(0));
+        }
+
+        cursor.close();
+    }
+}
diff --git a/tests/src/com/android/providers/contacts/ContactsActor.java b/tests/src/com/android/providers/contacts/ContactsActor.java
new file mode 100644
index 0000000..eed7b43
--- /dev/null
+++ b/tests/src/com/android/providers/contacts/ContactsActor.java
@@ -0,0 +1,313 @@
+/*
+ * 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 android.content.ContentProvider;
+import android.content.ContentResolver;
+import android.content.ContentUris;
+import android.content.ContentValues;
+import android.content.Context;
+import android.content.pm.ApplicationInfo;
+import android.content.pm.PackageManager;
+import android.content.res.Resources;
+import android.database.Cursor;
+import android.net.Uri;
+import android.os.Binder;
+import android.provider.BaseColumns;
+import android.provider.ContactsContract;
+import android.provider.Contacts.Phones;
+import android.provider.ContactsContract.CommonDataKinds;
+import android.provider.ContactsContract.Contacts;
+import android.provider.ContactsContract.Data;
+import android.provider.ContactsContract.RawContacts;
+import android.test.IsolatedContext;
+import android.test.RenamingDelegatingContext;
+import android.test.mock.MockContentResolver;
+import android.test.mock.MockContext;
+import android.test.mock.MockPackageManager;
+
+import java.util.HashMap;
+
+/**
+ * Helper class that encapsulates an "actor" which is owned by a specific
+ * package name. It correctly maintains a wrapped {@link Context} and an
+ * attached {@link MockContentResolver}. Multiple actors can be used to test
+ * security scenarios between multiple packages.
+ */
+public class ContactsActor {
+    private static final String FILENAME_PREFIX = "test.";
+
+    public static final String PACKAGE_GREY = "edu.example.grey";
+    public static final String PACKAGE_RED = "net.example.red";
+    public static final String PACKAGE_GREEN = "com.example.green";
+    public static final String PACKAGE_BLUE = "org.example.blue";
+
+    public Context context;
+    public String packageName;
+    public MockContentResolver resolver;
+    public ContentProvider provider;
+
+    private IsolatedContext mProviderContext;
+
+    /**
+     * Create an "actor" using the given parent {@link Context} and the specific
+     * package name. Internally, all {@link Context} method calls are passed to
+     * a new instance of {@link RestrictionMockContext}, which stubs out the
+     * security infrastructure.
+     */
+    public ContactsActor(Context overallContext, String packageName,
+            Class<? extends ContentProvider> providerClass, String authority) throws Exception {
+        resolver = new MockContentResolver();
+        context = new RestrictionMockContext(overallContext, packageName, resolver);
+        this.packageName = packageName;
+
+        RenamingDelegatingContext targetContextWrapper = new RenamingDelegatingContext(context,
+                overallContext, FILENAME_PREFIX);
+        mProviderContext = new IsolatedContext(resolver, targetContextWrapper);
+        provider = addProvider(providerClass, authority);
+    }
+
+    public void addAuthority(String authority) {
+        resolver.addProvider(authority, provider);
+    }
+
+    public ContentProvider addProvider(Class<? extends ContentProvider> providerClass,
+            String authority) throws Exception {
+        ContentProvider provider = providerClass.newInstance();
+        provider.attachInfo(mProviderContext, null);
+        resolver.addProvider(authority, provider);
+        return provider;
+    }
+
+    /**
+     * Mock {@link Context} that reports specific well-known values for testing
+     * data protection. The creator can override the owner package name, and
+     * force the {@link PackageManager} to always return a well-known package
+     * list for any call to {@link PackageManager#getPackagesForUid(int)}.
+     * <p>
+     * For example, the creator could request that the {@link Context} lives in
+     * package name "com.example.red", and also cause the {@link PackageManager}
+     * to report that no UID contains that package name.
+     */
+    private static class RestrictionMockContext extends MockContext {
+        private final Context mOverallContext;
+        private final String mReportedPackageName;
+        private final RestrictionMockPackageManager mPackageManager;
+        private final ContentResolver mResolver;
+
+        /**
+         * Create a {@link Context} under the given package name.
+         */
+        public RestrictionMockContext(Context overallContext, String reportedPackageName,
+                ContentResolver resolver) {
+            mOverallContext = overallContext;
+            mReportedPackageName = reportedPackageName;
+            mResolver = resolver;
+            mPackageManager = new RestrictionMockPackageManager();
+            mPackageManager.addPackage(1000, PACKAGE_GREY);
+            mPackageManager.addPackage(2000, PACKAGE_RED);
+            mPackageManager.addPackage(3000, PACKAGE_GREEN);
+            mPackageManager.addPackage(4000, PACKAGE_BLUE);
+        }
+
+        @Override
+        public String getPackageName() {
+            return mReportedPackageName;
+        }
+
+        @Override
+        public PackageManager getPackageManager() {
+            return mPackageManager;
+        }
+
+        @Override
+        public Resources getResources() {
+            return mOverallContext.getResources();
+        }
+
+        @Override
+        public ContentResolver getContentResolver() {
+            return mResolver;
+        }
+    }
+
+    /**
+     * Mock {@link PackageManager} that knows about a specific set of packages
+     * to help test security models. Because {@link Binder#getCallingUid()}
+     * can't be mocked, you'll have to find your mock-UID manually using your
+     * {@link Context#getPackageName()}.
+     */
+    private static class RestrictionMockPackageManager extends MockPackageManager {
+        private final HashMap<Integer, String> mForward = new HashMap<Integer, String>();
+        private final HashMap<String, Integer> mReverse = new HashMap<String, Integer>();
+
+        /**
+         * Add a UID-to-package mapping, which is then stored internally.
+         */
+        public void addPackage(int packageUid, String packageName) {
+            mForward.put(packageUid, packageName);
+            mReverse.put(packageName, packageUid);
+        }
+
+        @Override
+        public String[] getPackagesForUid(int uid) {
+            return new String[] { mForward.get(uid) };
+        }
+
+        @Override
+        public ApplicationInfo getApplicationInfo(String packageName, int flags) {
+            ApplicationInfo info = new ApplicationInfo();
+            Integer uid = mReverse.get(packageName);
+            info.uid = (uid != null) ? uid : -1;
+            return info;
+        }
+    }
+
+    public long createContact(boolean isRestricted, String name) {
+        long contactId = createContact(isRestricted);
+        createName(contactId, name);
+        return contactId;
+    }
+
+    public long createContact(boolean isRestricted) {
+        final ContentValues values = new ContentValues();
+        if (isRestricted) {
+            values.put(RawContacts.IS_RESTRICTED, 1);
+        }
+
+        Uri contactUri = resolver.insert(RawContacts.CONTENT_URI, values);
+        return ContentUris.parseId(contactUri);
+    }
+
+    public long createName(long contactId, String name) {
+        final ContentValues values = new ContentValues();
+        values.put(Data.RAW_CONTACT_ID, contactId);
+        values.put(Data.IS_PRIMARY, 1);
+        values.put(Data.IS_SUPER_PRIMARY, 1);
+        values.put(Data.MIMETYPE, CommonDataKinds.StructuredName.CONTENT_ITEM_TYPE);
+        values.put(CommonDataKinds.StructuredName.FAMILY_NAME, name);
+        Uri insertUri = Uri.withAppendedPath(ContentUris.withAppendedId(RawContacts.CONTENT_URI,
+                contactId), RawContacts.Data.CONTENT_DIRECTORY);
+        Uri dataUri = resolver.insert(insertUri, values);
+        return ContentUris.parseId(dataUri);
+    }
+
+    public long createPhone(long contactId, String phoneNumber) {
+        final ContentValues values = new ContentValues();
+        values.put(Data.RAW_CONTACT_ID, contactId);
+        values.put(Data.IS_PRIMARY, 1);
+        values.put(Data.IS_SUPER_PRIMARY, 1);
+        values.put(Data.MIMETYPE, Phones.CONTENT_ITEM_TYPE);
+        values.put(ContactsContract.CommonDataKinds.Phone.TYPE,
+                ContactsContract.CommonDataKinds.Phone.TYPE_HOME);
+        values.put(ContactsContract.CommonDataKinds.Phone.NUMBER, phoneNumber);
+        Uri insertUri = Uri.withAppendedPath(ContentUris.withAppendedId(RawContacts.CONTENT_URI,
+                contactId), RawContacts.Data.CONTENT_DIRECTORY);
+        Uri dataUri = resolver.insert(insertUri, values);
+        return ContentUris.parseId(dataUri);
+    }
+
+    public void updateException(String packageProvider, String packageClient, boolean allowAccess) {
+        throw new UnsupportedOperationException("RestrictionExceptions are hard-coded");
+    }
+
+    public long getContactForRawContact(long rawContactId) {
+        Uri contactUri = ContentUris.withAppendedId(RawContacts.CONTENT_URI, rawContactId);
+        final Cursor cursor = resolver.query(contactUri, Projections.PROJ_RAW_CONTACTS, null,
+                null, null);
+        if (!cursor.moveToFirst()) {
+            cursor.close();
+            throw new RuntimeException("Contact didn't have an aggregate");
+        }
+        final long aggId = cursor.getLong(Projections.COL_CONTACTS_ID);
+        cursor.close();
+        return aggId;
+    }
+
+    public int getDataCountForContact(long contactId) {
+        Uri contactUri = Uri.withAppendedPath(ContentUris.withAppendedId(Contacts.CONTENT_URI,
+                contactId), Contacts.Data.CONTENT_DIRECTORY);
+        final Cursor cursor = resolver.query(contactUri, Projections.PROJ_ID, null, null,
+                null);
+        final int count = cursor.getCount();
+        cursor.close();
+        return count;
+    }
+
+    public void setSuperPrimaryPhone(long dataId) {
+        final ContentValues values = new ContentValues();
+        values.put(Data.IS_PRIMARY, 1);
+        values.put(Data.IS_SUPER_PRIMARY, 1);
+        Uri updateUri = ContentUris.withAppendedId(Data.CONTENT_URI, dataId);
+        resolver.update(updateUri, values, null, null);
+    }
+
+    public long getPrimaryPhoneId(long contactId) {
+        Uri contactUri = ContentUris.withAppendedId(Contacts.CONTENT_URI, contactId);
+        final Cursor cursor = resolver.query(contactUri, Projections.PROJ_CONTACTS, null,
+                null, null);
+        long primaryPhoneId = -1;
+        if (cursor.moveToFirst()) {
+            primaryPhoneId = cursor.getLong(Projections.COL_CONTACTS_PRIMARY_PHONE_ID);
+        }
+        cursor.close();
+        return primaryPhoneId;
+    }
+
+    public long createGroup(String groupName) {
+        final ContentValues values = new ContentValues();
+        values.put(ContactsContract.Groups.RES_PACKAGE, packageName);
+        values.put(ContactsContract.Groups.TITLE, groupName);
+        Uri groupUri = resolver.insert(ContactsContract.Groups.CONTENT_URI, values);
+        return ContentUris.parseId(groupUri);
+    }
+
+    public long createGroupMembership(long rawContactId, long groupId) {
+        final ContentValues values = new ContentValues();
+        values.put(Data.RAW_CONTACT_ID, rawContactId);
+        values.put(Data.MIMETYPE, CommonDataKinds.GroupMembership.CONTENT_ITEM_TYPE);
+        values.put(CommonDataKinds.GroupMembership.GROUP_ROW_ID, groupId);
+        Uri insertUri = Uri.withAppendedPath(ContentUris.withAppendedId(RawContacts.CONTENT_URI,
+                rawContactId), RawContacts.Data.CONTENT_DIRECTORY);
+        Uri dataUri = resolver.insert(insertUri, values);
+        return ContentUris.parseId(dataUri);
+    }
+
+    /**
+     * Various internal database projections.
+     */
+    private interface Projections {
+        static final String[] PROJ_ID = new String[] {
+                BaseColumns._ID,
+        };
+
+        static final int COL_ID = 0;
+
+        static final String[] PROJ_RAW_CONTACTS = new String[] {
+                RawContacts.CONTACT_ID
+        };
+
+        static final int COL_CONTACTS_ID = 0;
+
+        static final String[] PROJ_CONTACTS = new String[] {
+                Contacts.PRIMARY_PHONE_ID
+        };
+
+        static final int COL_CONTACTS_PRIMARY_PHONE_ID = 0;
+
+    }
+}
diff --git a/tests/src/com/android/providers/contacts/ContactsProvider2Test.java b/tests/src/com/android/providers/contacts/ContactsProvider2Test.java
new file mode 100644
index 0000000..f6d5bd7
--- /dev/null
+++ b/tests/src/com/android/providers/contacts/ContactsProvider2Test.java
@@ -0,0 +1,471 @@
+/*
+ * 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.internal.util.ArrayUtils;
+
+import android.content.ContentUris;
+import android.content.ContentValues;
+import android.content.Entity;
+import android.content.EntityIterator;
+import android.database.Cursor;
+import android.net.Uri;
+import android.os.RemoteException;
+import android.provider.ContactsContract;
+import android.provider.ContactsContract.AggregationExceptions;
+import android.provider.ContactsContract.Contacts;
+import android.provider.ContactsContract.Data;
+import android.provider.ContactsContract.Presence;
+import android.provider.ContactsContract.RawContacts;
+import android.provider.ContactsContract.CommonDataKinds.Email;
+import android.provider.ContactsContract.CommonDataKinds.GroupMembership;
+import android.provider.ContactsContract.CommonDataKinds.Im;
+import android.provider.ContactsContract.CommonDataKinds.Phone;
+import android.provider.ContactsContract.CommonDataKinds.StructuredName;
+import android.test.suitebuilder.annotation.LargeTest;
+
+/**
+ * Unit tests for {@link ContactsProvider2}.
+ *
+ * Run the test like this:
+ * <code>
+ * adb shell am instrument -w \
+ *         com.android.providers.contacts.tests/android.test.InstrumentationTestRunner
+ * </code>
+ */
+@LargeTest
+public class ContactsProvider2Test extends BaseContactsProvider2Test {
+
+    public void testDisplayNameParsingWhenPartsUnspecified() {
+        long rawContactId = createRawContact();
+        ContentValues values = new ContentValues();
+        values.put(StructuredName.DISPLAY_NAME, "Mr.John Kevin von Smith, Jr.");
+        insertStructuredName(rawContactId, values);
+
+        assertStructuredName(rawContactId, "Mr", "John", "Kevin", "von Smith", "Jr");
+    }
+
+    public void testDisplayNameParsingWhenPartsSpecified() {
+        long rawContactId = createRawContact();
+        ContentValues values = new ContentValues();
+        values.put(StructuredName.DISPLAY_NAME, "Mr.John Kevin von Smith, Jr.");
+        values.put(StructuredName.FAMILY_NAME, "Johnson");
+        insertStructuredName(rawContactId, values);
+
+        assertStructuredName(rawContactId, null, null, null, "Johnson", null);
+    }
+
+    public void testSendToVoicemailDefault() {
+        long rawContactId = createRawContactWithName();
+        long contactId = queryContactId(rawContactId);
+
+        Cursor c = queryContact(contactId);
+        assertTrue(c.moveToNext());
+        int sendToVoicemail = c.getInt(c.getColumnIndex(Contacts.SEND_TO_VOICEMAIL));
+        assertEquals(0, sendToVoicemail);
+        c.close();
+    }
+
+    public void testSetSendToVoicemailAndRingtone() {
+        long rawContactId = createRawContactWithName();
+        long contactId = queryContactId(rawContactId);
+
+        updateSendToVoicemailAndRingtone(contactId, true, "foo");
+        assertSendToVoicemailAndRingtone(contactId, true, "foo");
+    }
+
+    public void testSendToVoicemailAndRingtoneAfterAggregation() {
+        long rawContactId1 = createRawContactWithName();
+        long contactId1 = queryContactId(rawContactId1);
+        updateSendToVoicemailAndRingtone(contactId1, true, "foo");
+
+        long rawContactId2 = createRawContactWithName();
+        long contactId2 = queryContactId(rawContactId2);
+        updateSendToVoicemailAndRingtone(contactId2, true, "bar");
+
+        // Aggregate them
+        setAggregationException(AggregationExceptions.TYPE_KEEP_IN, contactId1, rawContactId2);
+
+        // Both contacts had "send to VM", the contact now has the same value
+        assertSendToVoicemailAndRingtone(contactId1, true, "foo,bar"); // Either foo or bar
+    }
+
+    public void testDoNotSendToVoicemailAfterAggregation() {
+        long rawContactId1 = createRawContactWithName();
+        long contactId1 = queryContactId(rawContactId1);
+        updateSendToVoicemailAndRingtone(contactId1, true, null);
+
+        long rawContactId2 = createRawContactWithName();
+        long contactId2 = queryContactId(rawContactId2);
+        updateSendToVoicemailAndRingtone(contactId2, false, null);
+
+        // Aggregate them
+        setAggregationException(AggregationExceptions.TYPE_KEEP_IN, contactId1, rawContactId2);
+
+        // Since one of the contacts had "don't send to VM" that setting wins for the aggregate
+        assertSendToVoicemailAndRingtone(contactId1, false, null);
+    }
+
+    public void testSetSendToVoicemailAndRingtonePreservedAfterJoinAndSplit() {
+        long rawContactId1 = createRawContactWithName();
+        long contactId1 = queryContactId(rawContactId1);
+        updateSendToVoicemailAndRingtone(contactId1, true, "foo");
+
+        long rawContactId2 = createRawContactWithName();
+        long contactId2 = queryContactId(rawContactId2);
+        updateSendToVoicemailAndRingtone(contactId2, false, "bar");
+
+        // Aggregate them
+        setAggregationException(AggregationExceptions.TYPE_KEEP_IN, contactId1, rawContactId2);
+
+        // Split them
+        setAggregationException(AggregationExceptions.TYPE_KEEP_OUT, contactId1, rawContactId2);
+
+        assertSendToVoicemailAndRingtone(contactId1, true, "foo");
+        assertSendToVoicemailAndRingtone(queryContactId(rawContactId2), false, "bar");
+    }
+
+    public void testSinglePresenceRowPerContact() {
+        int protocol1 = Im.PROTOCOL_GOOGLE_TALK;
+        String handle1 = "test@gmail.com";
+
+        long rawContactId1 = createRawContact();
+        insertImHandle(rawContactId1, protocol1, handle1);
+
+        insertPresence(protocol1, handle1, Presence.AVAILABLE);
+        insertPresence(protocol1, handle1, Presence.AWAY);
+        insertPresence(protocol1, handle1, Presence.INVISIBLE);
+
+        Cursor c = queryContactSummary(queryContactId(rawContactId1),
+                new String[] {Presence.PRESENCE_STATUS});
+        assertEquals(c.getCount(), 1);
+
+        c.moveToFirst();
+        assertEquals(c.getInt(0), Presence.AVAILABLE);
+
+    }
+
+    private void updateSendToVoicemailAndRingtone(long contactId, boolean sendToVoicemail,
+            String ringtone) {
+        ContentValues values = new ContentValues();
+        values.put(Contacts.SEND_TO_VOICEMAIL, sendToVoicemail);
+        if (ringtone != null) {
+            values.put(Contacts.CUSTOM_RINGTONE, ringtone);
+        }
+
+        final Uri uri = ContentUris.withAppendedId(Contacts.CONTENT_URI, contactId);
+        int count = mResolver.update(uri, values, null, null);
+        assertEquals(1, count);
+    }
+
+    private void assertSendToVoicemailAndRingtone(long contactId, boolean expectedSendToVoicemail,
+            String expectedRingtone) {
+        Cursor c = queryContact(contactId);
+        assertTrue(c.moveToNext());
+        int sendToVoicemail = c.getInt(c.getColumnIndex(Contacts.SEND_TO_VOICEMAIL));
+        assertEquals(expectedSendToVoicemail ? 1 : 0, sendToVoicemail);
+        String ringtone = c.getString(c.getColumnIndex(Contacts.CUSTOM_RINGTONE));
+        if (expectedRingtone == null) {
+            assertNull(ringtone);
+        } else {
+            assertTrue(ArrayUtils.contains(expectedRingtone.split(","), ringtone));
+        }
+        c.close();
+    }
+
+    public void testGroupCreationAfterMembershipInsert() {
+        long rawContactId1 = createRawContact(mAccount);
+        Uri groupMembershipUri = insertGroupMembership(rawContactId1, "gsid1");
+
+        long groupId = assertSingleGroup(NO_LONG, mAccount, "gsid1", null);
+        assertSingleGroupMembership(ContentUris.parseId(groupMembershipUri),
+                rawContactId1, groupId, "gsid1");
+    }
+
+    public void testGroupReuseAfterMembershipInsert() {
+        long rawContactId1 = createRawContact(mAccount);
+        long groupId1 = createGroup(mAccount, "gsid1", "title1");
+        Uri groupMembershipUri = insertGroupMembership(rawContactId1, "gsid1");
+
+        assertSingleGroup(groupId1, mAccount, "gsid1", "title1");
+        assertSingleGroupMembership(ContentUris.parseId(groupMembershipUri),
+                rawContactId1, groupId1, "gsid1");
+    }
+
+    public void testGroupInsertFailureOnGroupIdConflict() {
+        long rawContactId1 = createRawContact(mAccount);
+        long groupId1 = createGroup(mAccount, "gsid1", "title1");
+
+        ContentValues values = new ContentValues();
+        values.put(GroupMembership.RAW_CONTACT_ID, rawContactId1);
+        values.put(GroupMembership.MIMETYPE, GroupMembership.CONTENT_ITEM_TYPE);
+        values.put(GroupMembership.GROUP_SOURCE_ID, "gsid1");
+        values.put(GroupMembership.GROUP_ROW_ID, groupId1);
+        try {
+            mResolver.insert(Data.CONTENT_URI, values);
+            fail("the insert was expected to fail, but it succeeded");
+        } catch (IllegalArgumentException e) {
+            // this was expected
+        }
+    }
+
+    public void testContentEntityIterator() throws RemoteException {
+        // create multiple contacts and check that the selected ones are returned
+        long id;
+
+        long groupId1 = createGroup(mAccount, "gsid1", "title1");
+        long groupId2 = createGroup(mAccount, "gsid2", "title2");
+
+        long c0 = id = createRawContact(mAccount, RawContacts.SOURCE_ID, "c0");
+        Uri id_0_0 = insertGroupMembership(id, "gsid1");
+        Uri id_0_1 = insertEmail(id, "c0@email.com");
+        Uri id_0_2 = insertPhoneNumber(id, "5551212c0");
+
+        long c1 = id = createRawContact(mAccount, RawContacts.SOURCE_ID, "c1");
+        Uri id_1_0 = insertGroupMembership(id, "gsid1");
+        Uri id_1_1 = insertGroupMembership(id, "gsid2");
+        Uri id_1_2 = insertEmail(id, "c1@email.com");
+        Uri id_1_3 = insertPhoneNumber(id, "5551212c1");
+
+        long c2 = id = createRawContact(mAccount, RawContacts.SOURCE_ID, "c2");
+        Uri id_2_0 = insertGroupMembership(id, "gsid1");
+        Uri id_2_1 = insertEmail(id, "c2@email.com");
+        Uri id_2_2 = insertPhoneNumber(id, "5551212c2");
+
+        long c3 = id = createRawContact(mAccount);
+        Uri id_3_0 = insertGroupMembership(id, groupId2);
+        Uri id_3_1 = insertEmail(id, "c3@email.com");
+        Uri id_3_2 = insertPhoneNumber(id, "5551212c3");
+
+        EntityIterator iterator = mResolver.queryEntities(
+                maybeAddAccountQueryParameters(RawContacts.CONTENT_URI, mAccount),
+                RawContacts.SOURCE_ID + " in ('c1', 'c2', 'c3')", null, null);
+        Entity entity;
+        ContentValues[] subValues;
+        entity = iterator.next();
+        assertEquals(c1, (long) entity.getEntityValues().getAsLong(RawContacts._ID));
+        subValues = asSortedContentValuesArray(entity.getSubValues());
+        assertEquals(4, subValues.length);
+        assertDataRow(subValues[0], GroupMembership.CONTENT_ITEM_TYPE,
+                Data._ID, id_1_0,
+                GroupMembership.GROUP_ROW_ID, groupId1,
+                GroupMembership.GROUP_SOURCE_ID, "gsid1");
+        assertDataRow(subValues[1], GroupMembership.CONTENT_ITEM_TYPE,
+                Data._ID, id_1_1,
+                GroupMembership.GROUP_ROW_ID, groupId2,
+                GroupMembership.GROUP_SOURCE_ID, "gsid2");
+        assertDataRow(subValues[2], Email.CONTENT_ITEM_TYPE,
+                Data._ID, id_1_2,
+                Email.DATA, "c1@email.com");
+        assertDataRow(subValues[3], Phone.CONTENT_ITEM_TYPE,
+                Data._ID, id_1_3,
+                Email.DATA, "5551212c1");
+
+        entity = iterator.next();
+        assertEquals(c2, (long) entity.getEntityValues().getAsLong(RawContacts._ID));
+        subValues = asSortedContentValuesArray(entity.getSubValues());
+        assertEquals(3, subValues.length);
+        assertDataRow(subValues[0], GroupMembership.CONTENT_ITEM_TYPE,
+                Data._ID, id_2_0,
+                GroupMembership.GROUP_ROW_ID, groupId1,
+                GroupMembership.GROUP_SOURCE_ID, "gsid1");
+        assertDataRow(subValues[1], Email.CONTENT_ITEM_TYPE,
+                Data._ID, id_2_1,
+                Email.DATA, "c2@email.com");
+        assertDataRow(subValues[2], Phone.CONTENT_ITEM_TYPE,
+                Data._ID, id_2_2,
+                Email.DATA, "5551212c2");
+
+        entity = iterator.next();
+        assertEquals(c3, (long) entity.getEntityValues().getAsLong(RawContacts._ID));
+        subValues = asSortedContentValuesArray(entity.getSubValues());
+        assertEquals(3, subValues.length);
+        assertDataRow(subValues[0], GroupMembership.CONTENT_ITEM_TYPE,
+                Data._ID, id_3_0,
+                GroupMembership.GROUP_ROW_ID, groupId2,
+                GroupMembership.GROUP_SOURCE_ID, "gsid2");
+        assertDataRow(subValues[1], Email.CONTENT_ITEM_TYPE,
+                Data._ID, id_3_1,
+                Email.DATA, "c3@email.com");
+        assertDataRow(subValues[2], Phone.CONTENT_ITEM_TYPE,
+                Data._ID, id_3_2,
+                Email.DATA, "5551212c3");
+
+        assertFalse(iterator.hasNext());
+    }
+
+    public void testDataCreateUpdateDeleteByMimeType() throws Exception {
+        long rawContactId = createRawContact();
+
+        ContentValues values = new ContentValues();
+        values.put(Data.RAW_CONTACT_ID, rawContactId);
+        values.put(Data.MIMETYPE, "testmimetype");
+        values.put(Data.RES_PACKAGE, "oldpackage");
+        values.put(Data.IS_PRIMARY, 1);
+        values.put(Data.IS_SUPER_PRIMARY, 1);
+        values.put(Data.DATA1, "old1");
+        values.put(Data.DATA2, "old2");
+        values.put(Data.DATA3, "old3");
+        values.put(Data.DATA4, "old4");
+        values.put(Data.DATA5, "old5");
+        values.put(Data.DATA6, "old6");
+        values.put(Data.DATA7, "old7");
+        values.put(Data.DATA8, "old8");
+        values.put(Data.DATA9, "old9");
+        values.put(Data.DATA10, "old10");
+        values.put(Data.DATA11, "old11");
+        values.put(Data.DATA12, "old12");
+        values.put(Data.DATA13, "old13");
+        values.put(Data.DATA14, "old14");
+        values.put(Data.DATA15, "old15");
+        Uri uri = mResolver.insert(Data.CONTENT_URI, values);
+        assertStoredValues(uri, values);
+
+        values.clear();
+        values.put(Data.RES_PACKAGE, "newpackage");
+        values.put(Data.IS_PRIMARY, 0);
+        values.put(Data.IS_SUPER_PRIMARY, 0);
+        values.put(Data.DATA1, "new1");
+        values.put(Data.DATA2, "new2");
+        values.put(Data.DATA3, "new3");
+        values.put(Data.DATA4, "new4");
+        values.put(Data.DATA5, "new5");
+        values.put(Data.DATA6, "new6");
+        values.put(Data.DATA7, "new7");
+        values.put(Data.DATA8, "new8");
+        values.put(Data.DATA9, "new9");
+        values.put(Data.DATA10, "new10");
+        values.put(Data.DATA11, "new11");
+        values.put(Data.DATA12, "new12");
+        values.put(Data.DATA13, "new13");
+        values.put(Data.DATA14, "new14");
+        values.put(Data.DATA15, "new15");
+        mResolver.update(Data.CONTENT_URI, values, Data.RAW_CONTACT_ID + "=" + rawContactId +
+                " AND " + Data.MIMETYPE + "='testmimetype'", null);
+
+        // Should not be able to change IS_PRIMARY and IS_SUPER_PRIMARY by the above update
+        values.put(Data.IS_PRIMARY, 1);
+        values.put(Data.IS_SUPER_PRIMARY, 1);
+        assertStoredValues(uri, values);
+
+        int count = mResolver.delete(Data.CONTENT_URI, Data.RAW_CONTACT_ID + "=" + rawContactId
+                + " AND " + Data.MIMETYPE + "='testmimetype'", null);
+        assertEquals(1, count);
+        assertEquals(0, getCount(Data.CONTENT_URI, Data.RAW_CONTACT_ID + "=" + rawContactId
+                        + " AND " + Data.MIMETYPE + "='testmimetype'", null));
+    }
+
+    public void testRawContactDeletion() {
+        long rawContactId = createRawContact();
+        Uri uri = ContentUris.withAppendedId(RawContacts.CONTENT_URI, rawContactId);
+
+        insertImHandle(rawContactId, Im.PROTOCOL_GOOGLE_TALK, "deleteme@android.com");
+        insertPresence(Im.PROTOCOL_GOOGLE_TALK, "deleteme@android.com", Presence.AVAILABLE);
+        assertEquals(1, getCount(Uri.withAppendedPath(uri, RawContacts.Data.CONTENT_DIRECTORY),
+                null, null));
+        assertEquals(1, getCount(Presence.CONTENT_URI, Presence.RAW_CONTACT_ID + "=" + rawContactId,
+                null));
+
+        mResolver.delete(uri, null, null);
+
+        assertStoredValues(uri, RawContacts.DELETED, "1");
+
+        Uri permanentDeletionUri = uri.buildUpon().appendQueryParameter(
+                RawContacts.DELETE_PERMANENTLY, "true").build();
+        mResolver.delete(permanentDeletionUri, null, null);
+        assertEquals(0, getCount(uri, null, null));
+        assertEquals(0, getCount(Uri.withAppendedPath(uri, RawContacts.Data.CONTENT_DIRECTORY),
+                null, null));
+        assertEquals(0, getCount(Presence.CONTENT_URI, Presence.RAW_CONTACT_ID + "=" + rawContactId,
+                null));
+    }
+
+    public void testRawContactDirtySetOnChange() {
+        Uri uri = ContentUris.withAppendedId(ContactsContract.RawContacts.CONTENT_URI,
+                createRawContact(mAccount));
+        assertDirty(uri, true);
+        clearDirty(uri);
+        assertDirty(uri, false);
+    }
+
+    public void testRawContactDirtyAndVersion() {
+        final long rawContactId = createRawContact(mAccount);
+        Uri uri = ContentUris.withAppendedId(ContactsContract.RawContacts.CONTENT_URI, rawContactId);
+        assertDirty(uri, true);
+        long version = getVersion(uri);
+
+        ContentValues values = new ContentValues();
+        values.put(ContactsContract.RawContacts.DIRTY, 0);
+        values.put(ContactsContract.RawContacts.SEND_TO_VOICEMAIL, 1);
+        values.put(ContactsContract.RawContacts.AGGREGATION_MODE,
+                RawContacts.AGGREGATION_MODE_IMMEDITATE);
+        values.put(ContactsContract.RawContacts.STARRED, 1);
+        assertEquals(1, mResolver.update(uri, values, null, null));
+        assertEquals(version, getVersion(uri));
+
+        assertDirty(uri, false);
+
+        Uri emailUri = insertEmail(rawContactId, "goo@woo.com");
+        assertDirty(uri, true);
+        ++version;
+        assertEquals(version, getVersion(uri));
+        clearDirty(uri);
+
+        values = new ContentValues();
+        values.put(Email.DATA, "goo@hoo.com");
+        mResolver.update(emailUri, values, null, null);
+        assertDirty(uri, true);
+        ++version;
+        assertEquals(version, getVersion(uri));
+        clearDirty(uri);
+
+        mResolver.delete(emailUri, null, null);
+        assertDirty(uri, true);
+        ++version;
+        assertEquals(version, getVersion(uri));
+    }
+
+    public void testRawContactClearDirty() {
+        final long rawContactId = createRawContact(mAccount);
+        Uri uri = ContentUris.withAppendedId(ContactsContract.RawContacts.CONTENT_URI,
+                rawContactId);
+        long version = getVersion(uri);
+        insertEmail(rawContactId, "goo@woo.com");
+        assertDirty(uri, true);
+        version++;
+        assertEquals(version, getVersion(uri));
+
+        clearDirty(uri);
+        assertDirty(uri, false);
+        assertEquals(version, getVersion(uri));
+    }
+
+    public void testRawContactDeletionSetsDirty() {
+        final long rawContactId = createRawContact(mAccount);
+        Uri uri = ContentUris.withAppendedId(ContactsContract.RawContacts.CONTENT_URI,
+                rawContactId);
+        long version = getVersion(uri);
+        clearDirty(uri);
+        assertDirty(uri, false);
+
+        mResolver.delete(uri, null, null);
+        assertStoredValues(uri, RawContacts.DELETED, "1");
+        assertDirty(uri, true);
+        version++;
+        assertEquals(version, getVersion(uri));
+    }
+}
+
diff --git a/tests/src/com/android/providers/contacts/GlobalSearchSupportTest.java b/tests/src/com/android/providers/contacts/GlobalSearchSupportTest.java
new file mode 100644
index 0000000..8921d41
--- /dev/null
+++ b/tests/src/com/android/providers/contacts/GlobalSearchSupportTest.java
@@ -0,0 +1,245 @@
+/*
+ * 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 android.app.SearchManager;
+import android.content.ContentUris;
+import android.content.ContentValues;
+import android.database.Cursor;
+import android.database.DatabaseUtils;
+import android.net.Uri;
+import android.provider.ContactsContract;
+import android.provider.Contacts.Intents;
+import android.provider.ContactsContract.Data;
+import android.provider.ContactsContract.Presence;
+import android.provider.ContactsContract.RawContacts;
+import android.provider.ContactsContract.CommonDataKinds.Email;
+import android.provider.ContactsContract.CommonDataKinds.Im;
+import android.provider.ContactsContract.CommonDataKinds.Organization;
+import android.provider.ContactsContract.CommonDataKinds.Phone;
+import android.provider.ContactsContract.CommonDataKinds.Photo;
+import android.test.suitebuilder.annotation.LargeTest;
+
+import java.io.IOException;
+
+/**
+ * Unit tests for {@link GlobalSearchSupport}.
+ *
+ * Run the test like this:
+ * <code>
+ * adb shell am instrument -w \
+ *         com.android.providers.contacts.tests/android.test.InstrumentationTestRunner
+ * </code>
+ */
+@LargeTest
+public class GlobalSearchSupportTest extends BaseContactsProvider2Test {
+    public void testSearchSuggestionsNotInVisibleGroup() throws Exception {
+        long rawContactId = createRawContact();
+        insertStructuredName(rawContactId, "Deer", "Dough");
+
+        Uri searchUri = new Uri.Builder().scheme("content").authority(ContactsContract.AUTHORITY)
+                .appendPath(SearchManager.SUGGEST_URI_PATH_QUERY).appendPath("D").build();
+
+        // If the contact is not in the "my contacts" group, nothing should be found
+        Cursor c = mResolver.query(searchUri, null, null, null, null);
+        assertEquals(0, c.getCount());
+        c.close();
+    }
+
+    public void testSearchSuggestionsByName() throws Exception {
+        long groupId = createGroup(mAccount, "gsid1", "title1");
+
+        assertSearchSuggestion(groupId,
+                true,  // name
+                true,  // photo
+                false, // organization
+                false, // phone
+                false, // email
+                "D",   // query
+                true,  // expect icon URI
+                null, "Deer Dough", null);
+
+        assertSearchSuggestion(groupId,
+                true,  // name
+                true,  // photo
+                true,  // organization
+                false, // phone
+                false, // email
+                "D",   // query
+                true,  // expect icon URI
+                null, "Deer Dough", "Google");
+
+        assertSearchSuggestion(groupId,
+                true,  // name
+                true,  // photo
+                false, // organization
+                true,  // phone
+                false, // email
+                "D",   // query
+                true,  // expect icon URI
+                null, "Deer Dough", "1-800-4664-411");
+
+        assertSearchSuggestion(groupId,
+                true,  // name
+                true,  // photo
+                false, // organization
+                false, // phone
+                true,  // email
+                "D",   // query
+                true,  // expect icon URI
+                String.valueOf(Presence.getPresenceIconResourceId(Presence.OFFLINE)),
+                "Deer Dough", "foo@acme.com");
+
+        assertSearchSuggestion(groupId,
+                true,  // name
+                false, // photo
+                true,  // organization
+                false, // phone
+                false, // email
+                "D",   // query
+                false, // expect icon URI
+                null, "Deer Dough", "Google");
+    }
+
+    private void assertSearchSuggestion(long groupId, boolean name, boolean photo,
+            boolean organization, boolean phone, boolean email, String query,
+            boolean expectIcon1Uri, String expectedIcon2, String expectedText1, String expectedText2)
+            throws IOException {
+        ContentValues values = new ContentValues();
+
+        long rawContactId = createRawContact();
+        insertGroupMembership(rawContactId, groupId);
+
+        if (name) {
+            insertStructuredName(rawContactId, "Deer", "Dough");
+        }
+
+        final Uri rawContactUri = ContentUris.withAppendedId(RawContacts.CONTENT_URI, rawContactId);
+        if (photo) {
+            values.clear();
+            byte[] photoData = loadTestPhoto();
+            values.put(Data.RAW_CONTACT_ID, rawContactId);
+            values.put(Data.MIMETYPE, Photo.CONTENT_ITEM_TYPE);
+            values.put(Photo.PHOTO, photoData);
+            mResolver.insert(Data.CONTENT_URI, values);
+        }
+
+        if (organization) {
+            values.clear();
+            values.put(Data.RAW_CONTACT_ID, rawContactId);
+            values.put(Data.MIMETYPE, Organization.CONTENT_ITEM_TYPE);
+            values.put(Organization.TYPE, Organization.TYPE_WORK);
+            values.put(Organization.COMPANY, "Google");
+            mResolver.insert(Data.CONTENT_URI, values);
+        }
+
+        if (email) {
+            values.clear();
+            values.put(Data.RAW_CONTACT_ID, rawContactId);
+            values.put(Data.MIMETYPE, Email.CONTENT_ITEM_TYPE);
+            values.put(Email.TYPE, Email.TYPE_WORK);
+            values.put(Email.DATA, "foo@acme.com");
+            mResolver.insert(Data.CONTENT_URI, values);
+
+            int protocol = Im.PROTOCOL_GOOGLE_TALK;
+
+            values.clear();
+            values.put(Presence.IM_PROTOCOL, protocol);
+            values.put(Presence.IM_HANDLE, "foo@acme.com");
+            values.put(Presence.IM_ACCOUNT, "foo");
+            values.put(Presence.PRESENCE_STATUS, Presence.OFFLINE);
+            values.put(Presence.PRESENCE_CUSTOM_STATUS, "Coding for Android");
+            mResolver.insert(Presence.CONTENT_URI, values);
+        }
+
+        if (phone) {
+            values.clear();
+            values.put(Data.RAW_CONTACT_ID, rawContactId);
+            values.put(Data.MIMETYPE, Phone.CONTENT_ITEM_TYPE);
+            values.put(Data.IS_PRIMARY, 1);
+            values.put(Phone.TYPE, Phone.TYPE_HOME);
+            values.put(Phone.NUMBER, "1-800-4664-411");
+            mResolver.insert(Data.CONTENT_URI, values);
+        }
+
+        long contactId = queryContactId(rawContactId);
+        Uri searchUri = new Uri.Builder().scheme("content").authority(ContactsContract.AUTHORITY)
+                .appendPath(SearchManager.SUGGEST_URI_PATH_QUERY).appendPath(query).build();
+
+        Cursor c = mResolver.query(searchUri, null, null, null, null);
+        assertEquals(1, c.getCount());
+        c.moveToFirst();
+        values.clear();
+
+        // SearchManager does not declare a constant for _id
+        values.put("_id", contactId);
+        values.put(SearchManager.SUGGEST_COLUMN_TEXT_1, expectedText1);
+        values.put(SearchManager.SUGGEST_COLUMN_TEXT_2, expectedText2);
+
+        String icon1 = c.getString(c.getColumnIndex(SearchManager.SUGGEST_COLUMN_ICON_1));
+        if (expectIcon1Uri) {
+            assertTrue(icon1.startsWith("content:"));
+        } else {
+            assertEquals(String.valueOf(com.android.internal.R.drawable.ic_contact_picture), icon1);
+        }
+
+        values.put(SearchManager.SUGGEST_COLUMN_ICON_2, expectedIcon2);
+        values.put(SearchManager.SUGGEST_COLUMN_INTENT_DATA_ID, contactId);
+        values.put(SearchManager.SUGGEST_COLUMN_SHORTCUT_ID, contactId);
+        assertCursorValues(c, values);
+        c.close();
+
+        // Cleanup
+        mResolver.delete(rawContactUri, null, null);
+    }
+
+    public void testSearchSuggestionsByPhoneNumber() throws Exception {
+        ContentValues values = new ContentValues();
+
+        Uri searchUri = new Uri.Builder().scheme("content").authority(ContactsContract.AUTHORITY)
+                .appendPath(SearchManager.SUGGEST_URI_PATH_QUERY).appendPath("12345").build();
+
+        Cursor c = mResolver.query(searchUri, null, null, null, null);
+        DatabaseUtils.dumpCursor(c);
+        assertEquals(2, c.getCount());
+        c.moveToFirst();
+
+        values.put(SearchManager.SUGGEST_COLUMN_TEXT_1, "Dial number");
+        values.put(SearchManager.SUGGEST_COLUMN_TEXT_2, "using 12345");
+        values.put(SearchManager.SUGGEST_COLUMN_ICON_1,
+                String.valueOf(com.android.internal.R.drawable.call_contact));
+        values.put(SearchManager.SUGGEST_COLUMN_INTENT_ACTION,
+                Intents.SEARCH_SUGGESTION_DIAL_NUMBER_CLICKED);
+        values.put(SearchManager.SUGGEST_COLUMN_INTENT_DATA, "tel:12345");
+        values.putNull(SearchManager.SUGGEST_COLUMN_SHORTCUT_ID);
+        assertCursorValues(c, values);
+
+        c.moveToNext();
+        values.clear();
+        values.put(SearchManager.SUGGEST_COLUMN_TEXT_1, "Create contact");
+        values.put(SearchManager.SUGGEST_COLUMN_TEXT_2, "using 12345");
+        values.put(SearchManager.SUGGEST_COLUMN_ICON_1,
+                String.valueOf(com.android.internal.R.drawable.create_contact));
+        values.put(SearchManager.SUGGEST_COLUMN_INTENT_ACTION,
+                Intents.SEARCH_SUGGESTION_CREATE_CONTACT_CLICKED);
+        values.put(SearchManager.SUGGEST_COLUMN_INTENT_DATA, "tel:12345");
+        values.put(SearchManager.SUGGEST_COLUMN_SHORTCUT_ID,
+                SearchManager.SUGGEST_NEVER_MAKE_SHORTCUT);
+        assertCursorValues(c, values);
+        c.close();
+    }
+}
+
diff --git a/tests/src/com/android/providers/contacts/GroupsTest.java b/tests/src/com/android/providers/contacts/GroupsTest.java
new file mode 100644
index 0000000..38715b5
--- /dev/null
+++ b/tests/src/com/android/providers/contacts/GroupsTest.java
@@ -0,0 +1,181 @@
+/*
+ * 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 android.content.ContentUris;
+import android.content.ContentValues;
+import android.database.Cursor;
+import android.net.Uri;
+import android.provider.ContactsContract.Groups;
+import android.provider.ContactsContract.CommonDataKinds.GroupMembership;
+import android.test.suitebuilder.annotation.LargeTest;
+
+/**
+ * Unit tests for {@link Groups} and {@link GroupMembership}.
+ *
+ * Run the test like this:
+ * <code>
+ * adb shell am instrument -w \
+ *         com.android.providers.contacts.tests/android.test.InstrumentationTestRunner
+ * </code>
+ */
+@LargeTest
+public class GroupsTest extends BaseContactsProvider2Test {
+
+    private static final String GROUP_GREY = "Grey";
+    private static final String GROUP_RED = "Red";
+    private static final String GROUP_GREEN = "Green";
+    private static final String GROUP_BLUE = "Blue";
+
+    private static final String PERSON_ALPHA = "Alpha";
+    private static final String PERSON_BRAVO = "Bravo";
+    private static final String PERSON_CHARLIE = "Charlie";
+    private static final String PERSON_DELTA = "Delta";
+
+    private static final String PHONE_ALPHA = "555-1111";
+    private static final String PHONE_BRAVO_1 = "555-2222";
+    private static final String PHONE_BRAVO_2 = "555-3333";
+    private static final String PHONE_CHARLIE_1 = "555-4444";
+    private static final String PHONE_CHARLIE_2 = "555-5555";
+
+    public void testGroupSummary() {
+
+        // Clear any existing data before starting
+        // TODO make the provider wipe data automatically
+        ((SynchronousContactsProvider2)mActor.provider).wipeData();
+
+        // Create a handful of groups
+        long groupGrey = mActor.createGroup(GROUP_GREY);
+        long groupRed = mActor.createGroup(GROUP_RED);
+        long groupGreen = mActor.createGroup(GROUP_GREEN);
+        long groupBlue = mActor.createGroup(GROUP_BLUE);
+
+        // Create a handful of contacts
+        long contactAlpha = mActor.createContact(false, PERSON_ALPHA);
+        long contactBravo = mActor.createContact(false, PERSON_BRAVO);
+        long contactCharlie = mActor.createContact(false, PERSON_CHARLIE);
+        long contactCharlieDupe = mActor.createContact(false, PERSON_CHARLIE);
+        long contactDelta = mActor.createContact(false, PERSON_DELTA);
+
+        // Make sure that Charlie was aggregated
+        {
+            long aggCharlie = mActor.getContactForRawContact(contactCharlie);
+            long aggCharlieDupe = mActor.getContactForRawContact(contactCharlieDupe);
+            assertTrue("Didn't aggregate two contacts with identical names",
+                    (aggCharlie == aggCharlieDupe));
+        }
+
+        // Add phone numbers to specific contacts
+        mActor.createPhone(contactAlpha, PHONE_ALPHA);
+        mActor.createPhone(contactBravo, PHONE_BRAVO_1);
+        mActor.createPhone(contactBravo, PHONE_BRAVO_2);
+        mActor.createPhone(contactCharlie, PHONE_CHARLIE_1);
+        mActor.createPhone(contactCharlieDupe, PHONE_CHARLIE_2);
+
+        // Add contacts to various mixture of groups. Grey will have all
+        // contacts, Red only with phone numbers, Green with no phones, and Blue
+        // with no contacts at all.
+        mActor.createGroupMembership(contactAlpha, groupGrey);
+        mActor.createGroupMembership(contactBravo, groupGrey);
+        mActor.createGroupMembership(contactCharlie, groupGrey);
+        mActor.createGroupMembership(contactDelta, groupGrey);
+
+        mActor.createGroupMembership(contactAlpha, groupRed);
+        mActor.createGroupMembership(contactBravo, groupRed);
+        mActor.createGroupMembership(contactCharlie, groupRed);
+
+        mActor.createGroupMembership(contactDelta, groupGreen);
+
+        // Walk across groups summary cursor and verify returned counts.
+        final Cursor cursor = mActor.resolver.query(Groups.CONTENT_SUMMARY_URI,
+                Projections.PROJ_SUMMARY, null, null, null);
+
+        // Require that each group has a summary row
+        assertTrue("Didn't return summary for all groups", (cursor.getCount() == 4));
+
+        while (cursor.moveToNext()) {
+            final long groupId = cursor.getLong(Projections.COL_ID);
+            final int summaryCount = cursor.getInt(Projections.COL_SUMMARY_COUNT);
+            final int summaryWithPhones = cursor.getInt(Projections.COL_SUMMARY_WITH_PHONES);
+
+            if (groupId == groupGrey) {
+                // Grey should have four aggregates, three with phones.
+                assertTrue("Incorrect Grey count", (summaryCount == 4));
+                assertTrue("Incorrect Grey with phones count", (summaryWithPhones == 3));
+            } else if (groupId == groupRed) {
+                // Red should have 3 aggregates, all with phones.
+                assertTrue("Incorrect Red count", (summaryCount == 3));
+                assertTrue("Incorrect Red with phones count", (summaryWithPhones == 3));
+            } else if (groupId == groupGreen) {
+                // Green should have 1 aggregate, none with phones.
+                assertTrue("Incorrect Green count", (summaryCount == 1));
+                assertTrue("Incorrect Green with phones count", (summaryWithPhones == 0));
+            } else if (groupId == groupBlue) {
+                // Blue should have no contacts.
+                assertTrue("Incorrect Blue count", (summaryCount == 0));
+                assertTrue("Incorrect Blue with phones count", (summaryWithPhones == 0));
+            } else {
+                fail("Unrecognized group in summary cursor");
+            }
+        }
+
+    }
+
+    public void testGroupDirtySetOnChange() {
+        Uri uri = ContentUris.withAppendedId(Groups.CONTENT_URI,
+                createGroup(mAccount, "gsid1", "title1"));
+        assertDirty(uri, true);
+        clearDirty(uri);
+        assertDirty(uri, false);
+    }
+
+    public void testGroupDirtyClearedWhenSetExplicitly() {
+        Uri uri = ContentUris.withAppendedId(Groups.CONTENT_URI,
+                createGroup(mAccount, "gsid1", "title1"));
+        assertDirty(uri, true);
+
+        ContentValues values = new ContentValues();
+        values.put(Groups.DIRTY, 0);
+        values.put(Groups.NOTES, "other notes");
+        assertEquals(1, mResolver.update(uri, values, null, null));
+
+        assertDirty(uri, false);
+    }
+
+    public void testGroupVersionUpdates() {
+        Uri uri = ContentUris.withAppendedId(Groups.CONTENT_URI,
+                createGroup(mAccount, "gsid1", "title1"));
+        long version = getVersion(uri);
+        ContentValues values = new ContentValues();
+        values.put(Groups.TITLE, "title2");
+        mResolver.update(uri, values, null, null);
+        assertEquals(version + 1, getVersion(uri));
+    }
+
+    private interface Projections {
+        public static final String[] PROJ_SUMMARY = new String[] {
+            Groups._ID,
+            Groups.SUMMARY_COUNT,
+            Groups.SUMMARY_WITH_PHONES,
+        };
+
+        public static final int COL_ID = 0;
+        public static final int COL_SUMMARY_COUNT = 1;
+        public static final int COL_SUMMARY_WITH_PHONES = 2;
+    }
+
+}
diff --git a/tests/src/com/android/providers/contacts/JaroWinklerDistanceTest.java b/tests/src/com/android/providers/contacts/JaroWinklerDistanceTest.java
new file mode 100644
index 0000000..ad34bba
--- /dev/null
+++ b/tests/src/com/android/providers/contacts/JaroWinklerDistanceTest.java
@@ -0,0 +1,64 @@
+/*
+ * 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 android.test.suitebuilder.annotation.SmallTest;
+
+import junit.framework.TestCase;
+
+@SmallTest
+public class JaroWinklerDistanceTest extends TestCase {
+
+    private JaroWinklerDistance mJaroWinklerDistance;
+
+    @Override
+    protected void setUp() throws Exception {
+        super.setUp();
+
+        mJaroWinklerDistance = new JaroWinklerDistance(10);
+    }
+
+    public void testExactMatch() {
+        assertFloat(1, "Dwayne", "Dwayne");
+    }
+
+    public void testWinklerBonus() {
+        assertFloat(0.961f, "Martha", "Marhta");
+        assertFloat(0.840f, "Dwayne", "Duane");
+        assertFloat(0.813f, "DIXON", "DICKSONX");
+    }
+
+    public void testJaroDistance() {
+        assertFloat(0.600f, "Donny", "Duane");
+    }
+
+    public void testPoorMatch() {
+        assertFloat(0.467f, "Johny", "Duane");
+    }
+
+    public void testNoMatches() {
+        assertFloat(0, "Abcd", "Efgh");
+    }
+
+    private void assertFloat(float expected, String name1, String name2) {
+        byte[] s1 = Hex.decodeHex(NameNormalizer.normalize(name1));
+        byte[] s2 = Hex.decodeHex(NameNormalizer.normalize(name2));
+
+        float actual = mJaroWinklerDistance.getDistance(s1, s2);
+        assertTrue("Expected Jaro-Winkler distance: " + expected + ", actual: " + actual,
+                Math.abs(actual - expected) < 0.001);
+    }
+}
diff --git a/tests/src/com/android/providers/contacts/LegacyContactsProviderTest.java b/tests/src/com/android/providers/contacts/LegacyContactsProviderTest.java
new file mode 100644
index 0000000..870c7d2
--- /dev/null
+++ b/tests/src/com/android/providers/contacts/LegacyContactsProviderTest.java
@@ -0,0 +1,849 @@
+/*
+ * 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 android.app.SearchManager;
+import android.content.ContentProvider;
+import android.content.ContentUris;
+import android.content.ContentValues;
+import android.content.res.Resources;
+import android.database.Cursor;
+import android.net.Uri;
+import android.provider.Contacts;
+import android.provider.Contacts.ContactMethods;
+import android.provider.Contacts.Extensions;
+import android.provider.Contacts.GroupMembership;
+import android.provider.Contacts.Groups;
+import android.provider.Contacts.Intents;
+import android.provider.Contacts.Organizations;
+import android.provider.Contacts.People;
+import android.provider.Contacts.Phones;
+import android.provider.Contacts.Photos;
+import android.provider.Contacts.Presence;
+import android.test.suitebuilder.annotation.LargeTest;
+
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+
+/**
+ * Tests for legacy contacts APIs.
+ */
+@LargeTest
+public class LegacyContactsProviderTest extends BaseContactsProvider2Test {
+
+    private static final boolean USE_LEGACY_PROVIDER = false;
+
+    @Override
+    protected Class<? extends ContentProvider> getProviderClass() {
+       return USE_LEGACY_PROVIDER ? ContactsProvider.class : SynchronousContactsProvider2.class;
+    }
+
+    @Override
+    protected String getAuthority() {
+        return Contacts.AUTHORITY;
+    }
+
+    public void testPeopleInsert() {
+        ContentValues values = new ContentValues();
+        putContactValues(values);
+
+        Uri uri = mResolver.insert(People.CONTENT_URI, values);
+        assertStoredValues(uri, values);
+        assertSelection(People.CONTENT_URI, values, People._ID, ContentUris.parseId(uri));
+    }
+
+    public void testPeopleDelete() {
+        ContentValues values = new ContentValues();
+        values.put(People.NAME, "John Doe");
+        Uri personId = mResolver.insert(People.CONTENT_URI, values);
+        mResolver.delete(personId, null, null);
+
+        Cursor c = mResolver.query(personId, null, People.NAME + "='John Doe'" , null, null);
+        assertEquals("Record count after deletion", 0, c.getCount());
+        c.close();
+
+        try {
+            mResolver.query(People.DELETED_CONTENT_URI, null, null, null, null);
+        } catch (UnsupportedOperationException e) {
+            // Expected exception
+        }
+    }
+
+    public void testPeopleFilter() {
+        ContentValues values = new ContentValues();
+        values.put(People.NAME, "Deer Doe");
+        mResolver.insert(People.CONTENT_URI, values);
+
+        values.clear();
+        values.put(People.NAME, "Dear Dough");
+        mResolver.insert(People.CONTENT_URI, values);
+
+        values.clear();
+        values.put(People.NAME, "D.R. Dauwe");
+        mResolver.insert(People.CONTENT_URI, values);
+
+        assertFilteredContacts("d", "Deer Doe", "Dear Dough", "D.R. Dauwe");
+        assertFilteredContacts("de", "Deer Doe", "Dear Dough");
+        assertFilteredContacts("dee", "Deer Doe");
+        assertFilteredContacts("der");
+    }
+
+    public void testDefaultDisplayName() {
+        ContentValues values = new ContentValues();
+        values.put(People.NAME, "John Doe");
+        Uri personUri = mResolver.insert(People.CONTENT_URI, values);
+        assertStoredValues(personUri, People.DISPLAY_NAME, "John Doe");
+    }
+
+    public void testPrimaryOrganization() {
+        ContentValues values = new ContentValues();
+        final Uri personUri = mResolver.insert(People.CONTENT_URI, values);
+        long personId = ContentUris.parseId(personUri);
+
+        // Primary
+        values.clear();
+        values.put(Organizations.ISPRIMARY, 1);
+        values.put(Organizations.COMPANY, "Google");
+        values.put(Organizations.TYPE, Organizations.TYPE_WORK);
+        values.put(Organizations.PERSON_ID, personId);
+        Uri orgUri1 = mResolver.insert(Organizations.CONTENT_URI, values);
+
+        // Non-primary
+        values.clear();
+        values.put(Organizations.COMPANY, "Acme");
+        values.put(Organizations.TYPE, Organizations.TYPE_WORK);
+        values.put(Organizations.PERSON_ID, personId);
+        Uri orgUri2 = mResolver.insert(Organizations.CONTENT_URI, values);
+
+        values.clear();
+        values.put(People.PRIMARY_ORGANIZATION_ID, ContentUris.parseId(orgUri1));
+        values.put(People.DISPLAY_NAME, "Google");
+        assertStoredValues(personUri, values);
+
+        // Remove the original primary organization
+        mResolver.delete(orgUri1, null, null);
+
+        values.clear();
+        values.put(People.PRIMARY_ORGANIZATION_ID, ContentUris.parseId(orgUri2));
+        values.put(People.DISPLAY_NAME, "Acme");
+        assertStoredValues(personUri, values);
+
+        // Remove the remaining organization
+        mResolver.delete(orgUri2, null, null);
+
+        values.clear();
+        values.putNull(People.PRIMARY_ORGANIZATION_ID);
+        values.putNull(People.DISPLAY_NAME);
+        assertStoredValues(personUri, values);
+    }
+
+    public void testPrimaryPhone() {
+        ContentValues values = new ContentValues();
+        Uri personUri = mResolver.insert(People.CONTENT_URI, values);
+        long personId = ContentUris.parseId(personUri);
+
+        // Primary
+        values.clear();
+        values.put(Phones.ISPRIMARY, 1);
+        values.put(Phones.TYPE, Phones.TYPE_WORK);
+        values.put(Phones.PERSON_ID, personId);
+        values.put(Phones.NUMBER, "12345");
+        Uri phoneUri1 = mResolver.insert(Phones.CONTENT_URI, values);
+
+        // Non-primary
+        values.clear();
+        values.put(Phones.TYPE, Phones.TYPE_WORK);
+        values.put(Phones.PERSON_ID, personId);
+        values.put(Phones.NUMBER, "67890");
+        Uri phoneUri2 = mResolver.insert(Phones.CONTENT_URI, values);
+
+        values.clear();
+        values.put(People.PRIMARY_PHONE_ID, ContentUris.parseId(phoneUri1));
+        values.put(People.DISPLAY_NAME, "12345");
+        assertStoredValues(personUri, values);
+
+        // Remove the primary phone number
+        mResolver.delete(phoneUri1, null, null);
+
+        values.clear();
+        values.put(People.PRIMARY_PHONE_ID, ContentUris.parseId(phoneUri2));
+        values.put(People.DISPLAY_NAME, "67890");
+        assertStoredValues(personUri, values);
+
+        // Remove the remaining phone number
+        mResolver.delete(phoneUri2, null, null);
+
+        values.clear();
+        values.putNull(People.PRIMARY_PHONE_ID);
+        values.putNull(People.DISPLAY_NAME);
+        assertStoredValues(personUri, values);
+    }
+
+    public void testPrimaryEmail() {
+        ContentValues values = new ContentValues();
+        Uri personUri = mResolver.insert(People.CONTENT_URI, values);
+        long personId = ContentUris.parseId(personUri);
+
+        // Primary
+        values.clear();
+        values.put(ContactMethods.PERSON_ID, personId);
+        values.put(ContactMethods.KIND, Contacts.KIND_EMAIL);
+        values.put(ContactMethods.TYPE, ContactMethods.TYPE_HOME);
+        values.put(ContactMethods.DATA, "foo@acme.com");
+        values.put(ContactMethods.ISPRIMARY, 1);
+        Uri emailUri1 = mResolver.insert(ContactMethods.CONTENT_URI, values);
+
+        // Non-primary
+        values.clear();
+        values.put(ContactMethods.PERSON_ID, personId);
+        values.put(ContactMethods.KIND, Contacts.KIND_EMAIL);
+        values.put(ContactMethods.TYPE, ContactMethods.TYPE_WORK);
+        values.put(ContactMethods.DATA, "bar@acme.com");
+        Uri emailUri2 = mResolver.insert(ContactMethods.CONTENT_URI, values);
+
+        values.clear();
+        values.put(People.PRIMARY_EMAIL_ID, ContentUris.parseId(emailUri1));
+        values.put(People.DISPLAY_NAME, "foo@acme.com");
+        assertStoredValues(personUri, values);
+
+        // Remove the primary email
+        mResolver.delete(emailUri1, null, null);
+
+        values.clear();
+        values.put(People.PRIMARY_EMAIL_ID, ContentUris.parseId(emailUri2));
+        values.put(People.DISPLAY_NAME, "bar@acme.com");
+        assertStoredValues(personUri, values);
+
+        // Remove the remaining email
+        mResolver.delete(emailUri2, null, null);
+
+        values.clear();
+        values.putNull(People.PRIMARY_EMAIL_ID);
+        values.putNull(People.DISPLAY_NAME);
+        assertStoredValues(personUri, values);
+    }
+
+    public void testMarkAsContacted() {
+        ContentValues values = new ContentValues();
+        Uri personUri = mResolver.insert(People.CONTENT_URI, values);
+        long personId = ContentUris.parseId(personUri);
+
+        int timesContactedBefore =
+                Integer.parseInt(getStoredValue(personUri, People.TIMES_CONTACTED));
+        long timeBefore = System.currentTimeMillis();
+        People.markAsContacted(mResolver, personId);
+        long timeAfter = System.currentTimeMillis();
+
+        long lastContacted = Long.parseLong(getStoredValue(personUri, People.LAST_TIME_CONTACTED));
+        int timesContactedAfter =
+            Integer.parseInt(getStoredValue(personUri, People.TIMES_CONTACTED));
+
+        assertTrue(lastContacted >= timeBefore);
+        assertTrue(lastContacted <= timeAfter);
+        assertEquals(timesContactedAfter, timesContactedBefore + 1);
+    }
+
+    public void testOrganizationsInsert() {
+        ContentValues values = new ContentValues();
+        Uri personUri = mResolver.insert(People.CONTENT_URI, values);
+        long personId = ContentUris.parseId(personUri);
+
+        values.clear();
+        values.put(Organizations.COMPANY, "Sierra");
+        values.put(Organizations.PERSON_ID, personId);
+        values.put(Organizations.TYPE, Organizations.TYPE_CUSTOM);
+        values.put(Organizations.LABEL, "Club");
+        values.put(Organizations.TITLE, "Member");
+        values.put(Organizations.ISPRIMARY, 1);
+
+        Uri uri = mResolver.insert(Organizations.CONTENT_URI, values);
+        assertStoredValues(uri, values);
+        assertSelection(Organizations.CONTENT_URI, values,
+                Organizations._ID, ContentUris.parseId(uri));
+
+        assertPersonIdConstraint(Organizations.CONTENT_URI, Organizations.TYPE,
+                Organizations.TYPE_WORK);
+
+        assertTypeAndLabelConstraints(Organizations.CONTENT_URI, Organizations.PERSON_ID, personId,
+                Organizations.TYPE, Organizations.TYPE_CUSTOM, Organizations.TYPE_OTHER,
+                Organizations.LABEL);
+    }
+
+    public void testPhonesInsert() {
+        ContentValues values = new ContentValues();
+        putContactValues(values);
+        Uri personUri = mResolver.insert(People.CONTENT_URI, values);
+        long personId = ContentUris.parseId(personUri);
+
+        values.clear();
+        values.put(Phones.PERSON_ID, personId);
+        values.put(Phones.TYPE, Phones.TYPE_CUSTOM);
+        values.put(Phones.LABEL, "Directory");
+        values.put(Phones.NUMBER, "1-800-4664-411");
+        values.put(Phones.ISPRIMARY, 1);
+
+        Uri uri = mResolver.insert(Phones.CONTENT_URI, values);
+
+        // Adding another value to assert
+        values.put(Phones.NUMBER_KEY, "11446640081");
+
+        // The result is joined with People
+        putContactValues(values);
+        assertStoredValues(uri, values);
+        assertSelection(Phones.CONTENT_URI, values,
+                Phones._ID, ContentUris.parseId(uri));
+
+        // Access the phone through People
+        Uri twigUri = Uri.withAppendedPath(personUri, People.Phones.CONTENT_DIRECTORY);
+        assertStoredValues(twigUri, values);
+
+        // Now the person should be joined with Phone
+        values.clear();
+        putContactValues(values);
+        values.put(People.TYPE, Phones.TYPE_CUSTOM);
+        values.put(People.LABEL, "Directory");
+        values.put(People.NUMBER, "1-800-4664-411");
+        assertStoredValues(personUri, values);
+
+        assertPersonIdConstraint(Phones.CONTENT_URI, Phones.TYPE, Phones.TYPE_WORK);
+
+        assertTypeAndLabelConstraints(Phones.CONTENT_URI, Phones.PERSON_ID, personId, Phones.TYPE,
+                Phones.TYPE_CUSTOM, Phones.TYPE_OTHER, Phones.LABEL);
+    }
+
+    public void testEmailInsert() {
+        assertContactMethodInsert(Contacts.KIND_EMAIL, ContactMethods.TYPE_CUSTOM,
+                "Some other way", "foo@acme.com", null, true);
+    }
+
+    public void testImInsert() {
+        assertContactMethodInsert(Contacts.KIND_IM, ContactMethods.TYPE_CUSTOM, "Some other way",
+                "Foo", "Bar", true);
+    }
+
+    public void testPostalInsert() {
+        assertContactMethodInsert(Contacts.KIND_POSTAL, ContactMethods.TYPE_CUSTOM,
+                "Some other way", "Foo", "Bar", true);
+    }
+
+    private void assertContactMethodInsert(int kind, int type, String label, String data,
+            String auxData, boolean primary) {
+        ContentValues values = new ContentValues();
+        putContactValues(values);
+        final Uri personUri = mResolver.insert(People.CONTENT_URI, values);
+        long personId = ContentUris.parseId(personUri);
+
+        values.clear();
+        values.put(ContactMethods.PERSON_ID, personId);
+        values.put(ContactMethods.KIND, kind);
+        values.put(ContactMethods.TYPE, type);
+        values.put(ContactMethods.LABEL, label);
+        values.put(ContactMethods.DATA, data);
+        values.put(ContactMethods.AUX_DATA, auxData);
+        values.put(ContactMethods.ISPRIMARY, primary ? 1 : 0);
+
+        Uri uri = mResolver.insert(ContactMethods.CONTENT_URI, values);
+
+        // The result is joined with People
+        putContactValues(values);
+        assertStoredValues(uri, values);
+        assertSelection(ContactMethods.CONTENT_URI, values,
+                ContactMethods._ID, ContentUris.parseId(uri));
+
+        // Access the contact method through People
+        Uri twigUri = Uri.withAppendedPath(personUri, People.ContactMethods.CONTENT_DIRECTORY);
+        assertStoredValues(twigUri, values);
+
+        assertPersonIdConstraint(ContactMethods.CONTENT_URI, ContactMethods.TYPE,
+                ContactMethods.TYPE_WORK);
+
+        assertTypeAndLabelConstraints(ContactMethods.CONTENT_URI, ContactMethods.PERSON_ID,
+                personId, ContactMethods.TYPE, ContactMethods.TYPE_CUSTOM,
+                ContactMethods.TYPE_OTHER, ContactMethods.LABEL);
+    }
+
+    public void testExtensionsInsert() {
+        ContentValues values = new ContentValues();
+        final Uri personUri = mResolver.insert(People.CONTENT_URI, values);
+        long personId = ContentUris.parseId(personUri);
+
+        values.clear();
+        values.put(Extensions.PERSON_ID, personId);
+        values.put(Extensions.NAME, "Foo");
+        values.put(Extensions.VALUE, "Bar");
+
+        Uri uri = mResolver.insert(Extensions.CONTENT_URI, values);
+        assertStoredValues(uri, values);
+        assertSelection(Extensions.CONTENT_URI, values,
+                Extensions._ID, ContentUris.parseId(uri));
+
+        // Access the extensions through People
+        Uri twigUri = Uri.withAppendedPath(personUri, People.Extensions.CONTENT_DIRECTORY);
+        assertStoredValues(twigUri, values);
+    }
+
+    public void testGroupsInsert() {
+        ContentValues values = new ContentValues();
+        values.put(Groups.NAME, "Galois");
+        values.put(Groups.NOTES, "Abel");
+        values.put(Groups.SYSTEM_ID, "12345");
+
+        Uri groupUri = mResolver.insert(Groups.CONTENT_URI, values);
+        assertStoredValues(groupUri, values);
+    }
+
+    public void testGroupMembershipsInsert() {
+        ContentValues values = new ContentValues();
+        values.put(Groups.NAME, "Galois");
+        values.put(Groups.NOTES, "Abel");
+        Uri groupUri = mResolver.insert(Groups.CONTENT_URI, values);
+
+        values.clear();
+        values.put(People.NAME, "Klein");
+        Uri personUri = mResolver.insert(People.CONTENT_URI, values);
+
+        long groupId = ContentUris.parseId(groupUri);
+        long personId = ContentUris.parseId(personUri);
+
+        values.clear();
+        values.put(GroupMembership.GROUP_ID, groupId);
+        values.put(GroupMembership.PERSON_ID, personId);
+        Uri membershipUri = mResolver.insert(GroupMembership.CONTENT_URI, values);
+        assertStoredValues(membershipUri, values);
+        assertSelection(GroupMembership.CONTENT_URI, values,
+                GroupMembership._ID, ContentUris.parseId(membershipUri));
+
+        Uri personsGroupsUri = Uri.withAppendedPath(personUri, GroupMembership.CONTENT_DIRECTORY);
+        assertStoredValues(personsGroupsUri, values);
+    }
+
+    public void testAddToGroup() {
+        ContentValues values = new ContentValues();
+        Uri personUri = mResolver.insert(People.CONTENT_URI, values);
+        long personId = ContentUris.parseId(personUri);
+
+        values.clear();
+        values.put(Groups.NAME, "Galois");
+        Uri groupUri = mResolver.insert(Groups.CONTENT_URI, values);
+
+        People.addToGroup(mResolver, personId, "Galois");
+
+        values.clear();
+        values.put(GroupMembership.GROUP_ID, ContentUris.parseId(groupUri));
+        values.put(GroupMembership.PERSON_ID, personId);
+
+        Uri personsGroupsUri = Uri.withAppendedPath(personUri, GroupMembership.CONTENT_DIRECTORY);
+        assertStoredValues(personsGroupsUri, values);
+    }
+
+    public void testPresenceInsertMatchOnHandle() {
+        ContentValues values = new ContentValues();
+        putContactValues(values);
+        Uri personUri = mResolver.insert(People.CONTENT_URI, values);
+        long personId = ContentUris.parseId(personUri);
+
+        String encodedProtocol =
+                ContactMethods.encodePredefinedImProtocol(ContactMethods.PROTOCOL_GOOGLE_TALK);
+
+        values.clear();
+        values.put(ContactMethods.PERSON_ID, personId);
+        values.put(ContactMethods.KIND, Contacts.KIND_IM);
+        values.put(ContactMethods.TYPE, ContactMethods.TYPE_HOME);
+        values.put(ContactMethods.DATA, "Android");
+        values.put(ContactMethods.AUX_DATA, encodedProtocol);
+        mResolver.insert(ContactMethods.CONTENT_URI, values);
+
+        values.clear();
+        values.put(Presence.IM_PROTOCOL, encodedProtocol);
+        values.put(Presence.IM_HANDLE, "Android");
+        values.put(Presence.IM_ACCOUNT, "foo");
+        values.put(Presence.PRESENCE_STATUS, Presence.OFFLINE);
+        values.put(Presence.PRESENCE_CUSTOM_STATUS, "Coding for Android");
+
+        Uri presenceUri = mResolver.insert(Presence.CONTENT_URI, values);
+        assertSelection(Presence.CONTENT_URI, values,
+                Presence._ID, ContentUris.parseId(presenceUri));
+
+        values.put(Presence.PERSON_ID, personId);
+        assertStoredValues(presenceUri, values);
+
+        // Now the person should be joined with Presence
+        values.clear();
+        putContactValues(values);
+        values.put(People.IM_PROTOCOL, encodedProtocol);
+        values.put(People.IM_HANDLE, "Android");
+        values.put(People.IM_ACCOUNT, "foo");
+        values.put(People.PRESENCE_STATUS, Presence.OFFLINE);
+        values.put(People.PRESENCE_CUSTOM_STATUS, "Coding for Android");
+        assertStoredValues(personUri, values);
+    }
+
+    public void testPresenceInsertMatchOnEmail() {
+        ContentValues values = new ContentValues();
+        putContactValues(values);
+        Uri personUri = mResolver.insert(People.CONTENT_URI, values);
+        long personId = ContentUris.parseId(personUri);
+
+        String protocol =
+            ContactMethods.encodePredefinedImProtocol(ContactMethods.PROTOCOL_GOOGLE_TALK);
+
+        values.clear();
+        values.put(ContactMethods.PERSON_ID, personId);
+        values.put(ContactMethods.KIND, Contacts.KIND_EMAIL);
+        values.put(ContactMethods.TYPE, ContactMethods.TYPE_HOME);
+        values.put(ContactMethods.DATA, "Android@android.com");
+        mResolver.insert(ContactMethods.CONTENT_URI, values);
+
+        values.clear();
+        values.put(Presence.IM_PROTOCOL, protocol);
+        values.put(Presence.IM_HANDLE, "Android@android.com");
+        values.put(Presence.IM_ACCOUNT, "foo");
+        values.put(Presence.PRESENCE_STATUS, Presence.OFFLINE);
+        values.put(Presence.PRESENCE_CUSTOM_STATUS, "Coding for Android");
+
+        Uri presenceUri = mResolver.insert(Presence.CONTENT_URI, values);
+
+        // FIXME person_id was not available in legacy ContactsProvider
+        // values.put(Presence.PERSON_ID, personId);
+        assertStoredValues(presenceUri, values);
+        assertSelection(Presence.CONTENT_URI, values,
+                Presence._ID, ContentUris.parseId(presenceUri));
+
+        // Now the person should be joined with Presence
+        values.clear();
+        putContactValues(values);
+        values.put(People.IM_PROTOCOL, protocol);
+        values.put(People.IM_HANDLE, "Android@android.com");
+        values.put(People.IM_ACCOUNT, "foo");
+        values.put(People.PRESENCE_STATUS, Presence.OFFLINE);
+        values.put(People.PRESENCE_CUSTOM_STATUS, "Coding for Android");
+        assertStoredValues(personUri, values);
+    }
+
+    public void testPhotoUpdate() throws Exception {
+        byte[] photo = loadTestPhoto();
+
+        ContentValues values = new ContentValues();
+        Uri personUri = mResolver.insert(People.CONTENT_URI, values);
+
+        values.clear();
+        values.put(Photos.DATA, photo);
+        values.put(Photos.LOCAL_VERSION, "10");
+        // FIXME this column was unavailable for update in legacy ContactsProvider
+        // values.put(Photos.DOWNLOAD_REQUIRED, 1);
+        values.put(Photos.EXISTS_ON_SERVER, 1);
+        values.put(Photos.SYNC_ERROR, "404 does not exist");
+
+        Uri photoUri = Uri.withAppendedPath(personUri, Photos.CONTENT_DIRECTORY);
+        mResolver.update(photoUri, values, null, null);
+        assertStoredValues(photoUri, values);
+    }
+
+    /**
+     * Capturing the search suggestion requirements in test cases as a reference.
+     */
+    public void testSearchSuggestionsNotInMyContacts() throws Exception {
+
+        // We don't provide compatibility for search suggestions
+        if (!USE_LEGACY_PROVIDER) {
+            return;
+        }
+
+        ContentValues values = new ContentValues();
+        putContactValues(values);
+        mResolver.insert(People.CONTENT_URI, values);
+
+        Uri searchUri = new Uri.Builder().scheme("content").authority(Contacts.AUTHORITY)
+                .appendPath(SearchManager.SUGGEST_URI_PATH_QUERY).appendPath("D").build();
+
+        // If the contact is not in the "my contacts" group, nothing should be found
+        Cursor c = mResolver.query(searchUri, null, null, null, null);
+        assertEquals(0, c.getCount());
+        c.close();
+    }
+
+    /**
+     * Capturing the search suggestion requirements in test cases as a reference.
+     */
+    public void testSearchSuggestionsByName() throws Exception {
+
+        // We don't provide compatibility for search suggestions
+        if (!USE_LEGACY_PROVIDER) {
+            return;
+        }
+
+        assertSearchSuggestion(
+                true,  // name
+                true,  // photo
+                true,  // organization
+                false, // phone
+                false, // email
+                "D",   // query
+                true,  // expect icon URI
+                null, "Deer Dough", "Google");
+
+        assertSearchSuggestion(
+                true,  // name
+                true,  // photo
+                false, // organization
+                true,  // phone
+                false, // email
+                "D",   // query
+                true,  // expect icon URI
+                null, "Deer Dough", "1-800-4664-411");
+
+        assertSearchSuggestion(
+                true,  // name
+                true,  // photo
+                false, // organization
+                false, // phone
+                true,  // email
+                "D",   // query
+                true,  // expect icon URI
+                String.valueOf(Presence.getPresenceIconResourceId(Presence.OFFLINE)),
+                "Deer Dough", "foo@acme.com");
+
+        assertSearchSuggestion(
+                true,  // name
+                false, // photo
+                true,  // organization
+                false, // phone
+                false, // email
+                "D",   // query
+                false, // expect icon URI
+                null, "Deer Dough", "Google");
+    }
+
+    private void assertSearchSuggestion(boolean name, boolean photo, boolean organization,
+            boolean phone, boolean email, String query, boolean expectIcon1Uri, String expectedIcon2,
+            String expectedText1, String expectedText2) throws IOException {
+        ContentValues values = new ContentValues();
+
+        if (name) {
+            values.put(People.NAME, "Deer Dough");
+        }
+
+        final Uri personUri = mResolver.insert(People.CONTENT_URI, values);
+        long personId = ContentUris.parseId(personUri);
+
+        People.addToMyContactsGroup(mResolver, personId);
+
+        if (photo) {
+            values.clear();
+            byte[] photoData = loadTestPhoto();
+            values.put(Photos.DATA, photoData);
+            values.put(Photos.LOCAL_VERSION, "1");
+            values.put(Photos.EXISTS_ON_SERVER, 0);
+            Uri photoUri = Uri.withAppendedPath(personUri, Photos.CONTENT_DIRECTORY);
+            mResolver.update(photoUri, values, null, null);
+        }
+
+        if (organization) {
+            values.clear();
+            values.put(Organizations.ISPRIMARY, 1);
+            values.put(Organizations.COMPANY, "Google");
+            values.put(Organizations.TYPE, Organizations.TYPE_WORK);
+            values.put(Organizations.PERSON_ID, personId);
+            mResolver.insert(Organizations.CONTENT_URI, values);
+        }
+
+        if (email) {
+            values.clear();
+            values.put(ContactMethods.PERSON_ID, personId);
+            values.put(ContactMethods.KIND, Contacts.KIND_EMAIL);
+            values.put(ContactMethods.TYPE, ContactMethods.TYPE_HOME);
+            values.put(ContactMethods.DATA, "foo@acme.com");
+            values.put(ContactMethods.ISPRIMARY, 1);
+            mResolver.insert(ContactMethods.CONTENT_URI, values);
+
+
+            String protocol = ContactMethods
+                    .encodePredefinedImProtocol(ContactMethods.PROTOCOL_GOOGLE_TALK);
+            values.clear();
+            values.put(Presence.IM_PROTOCOL, protocol);
+            values.put(Presence.IM_HANDLE, "foo@acme.com");
+            values.put(Presence.IM_ACCOUNT, "foo");
+            values.put(Presence.PRESENCE_STATUS, Presence.OFFLINE);
+            values.put(Presence.PRESENCE_CUSTOM_STATUS, "Coding for Android");
+            mResolver.insert(Presence.CONTENT_URI, values);
+        }
+
+        if (phone) {
+            values.clear();
+            values.put(Phones.PERSON_ID, personId);
+            values.put(Phones.TYPE, Phones.TYPE_HOME);
+            values.put(Phones.NUMBER, "1-800-4664-411");
+            values.put(Phones.ISPRIMARY, 1);
+            mResolver.insert(Phones.CONTENT_URI, values);
+        }
+
+        Uri searchUri = new Uri.Builder().scheme("content").authority(Contacts.AUTHORITY)
+                .appendPath(SearchManager.SUGGEST_URI_PATH_QUERY).appendPath(query).build();
+
+        Cursor c = mResolver.query(searchUri, null, null, null, null);
+        assertEquals(1, c.getCount());
+        c.moveToFirst();
+        values.clear();
+
+        String icon1 = c.getString(c.getColumnIndex(SearchManager.SUGGEST_COLUMN_ICON_1));
+        if (expectIcon1Uri) {
+            assertTrue(icon1.startsWith("content:"));
+        } else {
+            assertEquals(String.valueOf(com.android.internal.R.drawable.ic_contact_picture), icon1);
+        }
+
+        // SearchManager does not declare a constant for _id
+        values.put("_id", personId);
+        values.put(SearchManager.SUGGEST_COLUMN_ICON_2, expectedIcon2);
+        values.put(SearchManager.SUGGEST_COLUMN_INTENT_DATA_ID, personId);
+        values.put(SearchManager.SUGGEST_COLUMN_SHORTCUT_ID, personId);
+        values.put(SearchManager.SUGGEST_COLUMN_TEXT_1, expectedText1);
+        values.put(SearchManager.SUGGEST_COLUMN_TEXT_2, expectedText2);
+        assertCursorValues(c, values);
+        c.close();
+
+        // Cleanup
+        mResolver.delete(personUri, null, null);
+    }
+
+    /**
+     * Capturing the search suggestion requirements in test cases as a reference.
+     */
+    public void testSearchSuggestionsByPhoneNumber() throws Exception {
+
+        // We don't provide compatibility for search suggestions
+        if (!USE_LEGACY_PROVIDER) {
+            return;
+        }
+
+        ContentValues values = new ContentValues();
+
+        Uri searchUri = new Uri.Builder().scheme("content").authority(Contacts.AUTHORITY)
+                .appendPath(SearchManager.SUGGEST_URI_PATH_QUERY).appendPath("12345").build();
+
+        Cursor c = mResolver.query(searchUri, null, null, null, null);
+        assertEquals(2, c.getCount());
+        c.moveToFirst();
+
+        values.put(SearchManager.SUGGEST_COLUMN_TEXT_1, "Execute");
+        values.put(SearchManager.SUGGEST_COLUMN_TEXT_2, "");
+        values.put(SearchManager.SUGGEST_COLUMN_ICON_1,
+                String.valueOf(com.android.internal.R.drawable.call_contact));
+        values.put(SearchManager.SUGGEST_COLUMN_INTENT_ACTION,
+                Intents.SEARCH_SUGGESTION_DIAL_NUMBER_CLICKED);
+        values.put(SearchManager.SUGGEST_COLUMN_INTENT_DATA, "tel:12345");
+        values.putNull(SearchManager.SUGGEST_COLUMN_SHORTCUT_ID);
+        assertCursorValues(c, values);
+
+        c.moveToNext();
+        values.clear();
+        values.put(SearchManager.SUGGEST_COLUMN_TEXT_1, "Dial number");
+        values.put(SearchManager.SUGGEST_COLUMN_TEXT_2, "using 12345");
+        values.put(SearchManager.SUGGEST_COLUMN_ICON_1,
+                String.valueOf(com.android.internal.R.drawable.create_contact));
+        values.put(SearchManager.SUGGEST_COLUMN_INTENT_ACTION,
+                Intents.SEARCH_SUGGESTION_CREATE_CONTACT_CLICKED);
+        values.put(SearchManager.SUGGEST_COLUMN_INTENT_DATA, "tel:12345");
+        values.put(SearchManager.SUGGEST_COLUMN_SHORTCUT_ID,
+                SearchManager.SUGGEST_NEVER_MAKE_SHORTCUT);
+        assertCursorValues(c, values);
+        c.close();
+    }
+
+    private void putContactValues(ContentValues values) {
+        // Populating only unhidden columns
+        values.put(People.NAME, "Deer Dough");
+        values.put(People.PHONETIC_NAME, "Dear Doe");
+        values.put(People.NOTES, "Cash Cow");
+        values.put(People.TIMES_CONTACTED, 3);
+        values.put(People.LAST_TIME_CONTACTED, 10);
+        values.put(People.CUSTOM_RINGTONE, "ringtone");
+        values.put(People.SEND_TO_VOICEMAIL, 1);
+        values.put(People.STARRED, 1);
+    }
+
+    private void assertFilteredContacts(String filter, String... expectedNames) {
+        Uri filterUri = Uri.withAppendedPath(People.CONTENT_FILTER_URI, filter);
+        Cursor c = mResolver.query(filterUri, null, null, null, null);
+        try {
+            assertEquals("Record count", expectedNames.length, c.getCount());
+            int column = c.getColumnIndex(People.NAME);
+            for (int i = 0; i < expectedNames.length; i++) {
+                c.moveToNext();
+                assertEquals(expectedNames[i], c.getString(column));
+            }
+        } finally {
+            c.close();
+        }
+    }
+
+    private void assertPersonIdConstraint(Uri uri, String typeColumn, int defaultType) {
+        ContentValues values = new ContentValues();
+        values.put(typeColumn, defaultType);
+        try {
+            mResolver.insert(uri, values);
+            fail("Inserted row without person ID");
+        } catch (Exception e) {
+            // Exception expected
+        }
+    }
+
+    private void assertTypeAndLabelConstraints(Uri uri, String personIdColumn, long personId,
+            String typeColumn, int defaultType, int otherType, String labelColumn) {
+        ContentValues values = new ContentValues();
+        values.put(personIdColumn, personId);
+        values.put(typeColumn, defaultType);
+        try {
+            mResolver.insert(uri, values);
+            fail("Inserted row with custom type but without label");
+        } catch (Exception e) {
+            // Exception expected
+        }
+
+        values.clear();
+        values.put(personIdColumn, personId);
+        try {
+            mResolver.insert(uri, values);
+            fail("Inserted row without either type or label");
+        } catch (Exception e) {
+            // Exception expected
+        }
+
+        values.clear();
+        values.put(personIdColumn, personId);
+        values.put(typeColumn, otherType);
+        values.put(labelColumn, "Foo");
+        try {
+            mResolver.insert(uri, values);
+            fail("Inserted row with both type and label");
+        } catch (Exception e) {
+            // Exception expected
+        }
+    }
+
+    @Override
+    protected void assertSelection(Uri uri, ContentValues values, String idColumn, long id) {
+        if (USE_LEGACY_PROVIDER) {
+            // A bug in the legacy ContactsProvider prevents us from using the
+            // _id column in selection.
+            super.assertSelection(uri, values, null, 0);
+        } else {
+            super.assertSelection(uri, values, idColumn, id);
+        }
+    }
+}
diff --git a/tests/src/com/android/providers/contacts/NameNormalizerTest.java b/tests/src/com/android/providers/contacts/NameNormalizerTest.java
new file mode 100644
index 0000000..08d873f
--- /dev/null
+++ b/tests/src/com/android/providers/contacts/NameNormalizerTest.java
@@ -0,0 +1,63 @@
+/*
+ * 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 android.test.suitebuilder.annotation.SmallTest;
+
+import junit.framework.TestCase;
+
+/**
+ * Unit tests for {@link NameNormalizer}.
+ */
+@SmallTest
+public class NameNormalizerTest extends TestCase {
+
+    public void testDifferent() {
+        final String name1 = NameNormalizer.normalize("Helene");
+        final String name2 = NameNormalizer.normalize("Francesca");
+        assertFalse(name2.equals(name1));
+    }
+
+    public void testAccents() {
+        final String name1 = NameNormalizer.normalize("Helene");
+        final String name2 = NameNormalizer.normalize("H\u00e9l\u00e8ne");
+        assertTrue(name2.equals(name1));
+    }
+
+    public void testMixedCase() {
+        final String name1 = NameNormalizer.normalize("Helene");
+        final String name2 = NameNormalizer.normalize("hELENE");
+        assertTrue(name2.equals(name1));
+    }
+
+    public void testNonLetters() {
+        final String name1 = NameNormalizer.normalize("h-e?l e+n=e");
+        final String name2 = NameNormalizer.normalize("helene");
+        assertTrue(name2.equals(name1));
+    }
+
+    public void testComplexityCase() {
+        assertTrue(NameNormalizer.compareComplexity("Helene", "helene") > 0);
+    }
+
+    public void testComplexityAccent() {
+        assertTrue(NameNormalizer.compareComplexity("H\u00e9lene", "Helene") > 0);
+    }
+
+    public void testComplexityLength() {
+        assertTrue(NameNormalizer.compareComplexity("helene2009", "helene") > 0);
+    }
+}
diff --git a/tests/src/com/android/providers/contacts/NameSplitterTest.java b/tests/src/com/android/providers/contacts/NameSplitterTest.java
new file mode 100644
index 0000000..91ce025
--- /dev/null
+++ b/tests/src/com/android/providers/contacts/NameSplitterTest.java
@@ -0,0 +1,131 @@
+/*
+ * 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 junit.framework.TestCase;
+
+import com.android.providers.contacts.NameSplitter.Name;
+
+import android.test.suitebuilder.annotation.SmallTest;
+
+/**
+ * Tests for {@link NameSplitter}.
+ */
+@SmallTest
+public class NameSplitterTest extends TestCase {
+    private NameSplitter mNameSplitter;
+    private Name mName;
+
+    @Override
+    protected void setUp() throws Exception {
+        super.setUp();
+
+        mNameSplitter = new NameSplitter("Mr, Ms, Mrs", "d', st, st., von", "Jr, M.D., MD, D.D.S.",
+                "&, AND");
+        mName = new Name();
+    }
+
+    public void testNull() {
+        assertSplitName(null, null, null, null, null, null);
+    }
+
+    public void testEmpty() {
+        assertSplitName("", null, null, null, null, null);
+    }
+
+    public void testSpaces() {
+        assertSplitName(" ", null, null, null, null, null);
+    }
+
+    public void testLastName() {
+        assertSplitName("Smith", null, null, null, "Smith", null);
+    }
+
+    public void testFirstLastName() {
+        assertSplitName("John Smith", null, "John", null, "Smith", null);
+    }
+
+    public void testFirstMiddleLastName() {
+        assertSplitName("John Edward Smith", null, "John", "Edward", "Smith", null);
+    }
+
+    public void testThreeNamesAndLastName() {
+        assertSplitName("John Edward Kevin Smith", null, "John Edward", "Kevin", "Smith", null);
+    }
+
+    public void testPrefixFirstLastName() {
+        assertSplitName("Mr. John Smith", "Mr", "John", null, "Smith", null);
+        assertSplitName("Mr.John Smith", "Mr", "John", null, "Smith", null);
+    }
+
+    public void testFirstLastNameSuffix() {
+        assertSplitName("John Smith Jr.", null, "John", null, "Smith", "Jr");
+    }
+
+    public void testFirstLastNameSuffixWithDot() {
+        assertSplitName("John Smith M.D.", null, "John", null, "Smith", "M.D.");
+        assertSplitName("John Smith D D S", null, "John", null, "Smith", "D D S");
+    }
+
+    public void testFirstSuffixLastName() {
+        assertSplitName("John von Smith", null, "John", null, "von Smith", null);
+    }
+
+    public void testFirstSuffixLastNameWithDot() {
+        assertSplitName("John St.Smith", null, "John", null, "St. Smith", null);
+    }
+
+    public void testPrefixFirstMiddleLast() {
+        assertSplitName("Mr. John Kevin Smith", "Mr", "John", "Kevin", "Smith", null);
+        assertSplitName("Mr.John Kevin Smith", "Mr", "John", "Kevin", "Smith", null);
+    }
+
+    public void testPrefixFirstMiddleLastSuffix() {
+        assertSplitName("Mr. John Kevin Smith Jr.", "Mr", "John", "Kevin", "Smith", "Jr");
+    }
+
+    public void testPrefixFirstMiddlePrefixLastSuffixWrongCapitalization() {
+        assertSplitName("MR. john keVin VON SmiTh JR.", "MR", "john", "keVin", "VON SmiTh", "JR");
+    }
+
+    public void testPrefixLastSuffix() {
+        assertSplitName("von Smith Jr.", null, null, null, "von Smith", "Jr");
+    }
+
+    public void testTwoNamesAndLastNameWithAmpersand() {
+        assertSplitName("John & Edward Smith", null, "John & Edward", null, "Smith", null);
+        assertSplitName("John and Edward Smith", null, "John and Edward", null, "Smith", null);
+    }
+
+    public void testWithMiddleInitialAndNoDot() {
+        assertSplitName("John E. Smith", null, "John", "E", "Smith", null);
+    }
+
+    public void testWithLongFirstNameAndDot() {
+        assertSplitName("John Ed. K. Smith", null, "John Ed.", "K", "Smith", null);
+      }
+
+    private void assertSplitName(String fullName, String prefix, String givenNames,
+            String middleName, String lastName, String suffix) {
+        mNameSplitter.split(mName, fullName);
+        assertEquals(prefix, mName.getPrefix());
+        assertEquals(givenNames, mName.getGivenNames());
+        assertEquals(middleName, mName.getMiddleName());
+        assertEquals(lastName, mName.getFamilyName());
+        assertEquals(suffix, mName.getSuffix());
+    }
+}
diff --git a/tests/src/com/android/providers/contacts/RestrictionExceptionsTest.java b/tests/src/com/android/providers/contacts/RestrictionExceptionsTest.java
new file mode 100644
index 0000000..1263fe7
--- /dev/null
+++ b/tests/src/com/android/providers/contacts/RestrictionExceptionsTest.java
@@ -0,0 +1,345 @@
+/*
+ * 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 static com.android.providers.contacts.ContactsActor.PACKAGE_BLUE;
+import static com.android.providers.contacts.ContactsActor.PACKAGE_GREEN;
+import static com.android.providers.contacts.ContactsActor.PACKAGE_GREY;
+import static com.android.providers.contacts.ContactsActor.PACKAGE_RED;
+
+import android.content.ContentUris;
+import android.content.Context;
+import android.database.Cursor;
+import android.net.Uri;
+import android.provider.BaseColumns;
+import android.provider.ContactsContract;
+import android.provider.ContactsContract.Contacts;
+import android.provider.ContactsContract.RawContacts;
+import android.provider.ContactsContract.Data;
+import android.test.AndroidTestCase;
+import android.test.suitebuilder.annotation.LargeTest;
+
+/**
+ * Unit tests for {@link RestrictionExceptions}.
+ *
+ * Run the test like this:
+ * <code>
+ * adb shell am instrument -w \
+ *         com.android.providers.contacts.tests/android.test.InstrumentationTestRunner
+ * </code>
+ */
+@LargeTest
+public class RestrictionExceptionsTest extends AndroidTestCase {
+    private static final String TAG = "RestrictionExceptionsTest";
+
+    private static ContactsActor mGrey;
+    private static ContactsActor mRed;
+    private static ContactsActor mGreen;
+    private static ContactsActor mBlue;
+
+    private static final String PHONE_GREY = "555-1111";
+    private static final String PHONE_RED = "555-2222";
+    private static final String PHONE_GREEN = "555-3333";
+    private static final String PHONE_BLUE = "555-4444";
+
+    private static final String GENERIC_NAME = "Smith";
+
+    public RestrictionExceptionsTest() {
+    }
+
+    @Override
+    protected void setUp() throws Exception {
+        super.setUp();
+
+        final Context overallContext = this.getContext();
+
+        // Build each of our specific actors in their own Contexts
+        mGrey = new ContactsActor(overallContext, PACKAGE_GREY,
+                SynchronousContactsProvider2.class, ContactsContract.AUTHORITY);
+        mRed = new ContactsActor(overallContext, PACKAGE_RED,
+                SynchronousContactsProvider2.class, ContactsContract.AUTHORITY);
+        mGreen = new ContactsActor(overallContext, PACKAGE_GREEN,
+                SynchronousContactsProvider2.class, ContactsContract.AUTHORITY);
+        mBlue = new ContactsActor(overallContext, PACKAGE_BLUE,
+                SynchronousContactsProvider2.class, ContactsContract.AUTHORITY);
+
+        // TODO make the provider wipe data automatically
+        ((SynchronousContactsProvider2)mGrey.provider).wipeData();
+    }
+
+    /**
+     * Create various contacts that are both open and restricted, and assert
+     * that both {@link Contacts#IS_RESTRICTED} and
+     * {@link RestrictionExceptions} are being applied correctly.
+     */
+    public void __testDataRestriction() {
+
+        // Grey creates an unprotected contact
+        long greyContact = mGrey.createContact(false);
+        long greyData = mGrey.createPhone(greyContact, PHONE_GREY);
+        long greyAgg = mGrey.getContactForRawContact(greyContact);
+
+        // Assert that both Grey and Blue can read contact
+        assertTrue("Owner of unrestricted contact unable to read",
+                (mGrey.getDataCountForContact(greyAgg) == 1));
+        assertTrue("Non-owner of unrestricted contact unable to read",
+                (mBlue.getDataCountForContact(greyAgg) == 1));
+
+        // Red grants protected access to itself
+        mRed.updateException(PACKAGE_RED, PACKAGE_RED, true);
+
+        // Red creates a protected contact
+        long redContact = mRed.createContact(true);
+        long redData = mRed.createPhone(redContact, PHONE_RED);
+        long redAgg = mRed.getContactForRawContact(redContact);
+
+        // Assert that only Red can read contact
+        assertTrue("Owner of restricted contact unable to read",
+                (mRed.getDataCountForContact(redAgg) == 1));
+        assertTrue("Non-owner of restricted contact able to read",
+                (mBlue.getDataCountForContact(redAgg) == 0));
+        assertTrue("Non-owner of restricted contact able to read",
+                (mGreen.getDataCountForContact(redAgg) == 0));
+
+        try {
+            // Blue tries to grant an exception for Red data, which should throw
+            // exception. If it somehow worked, fail this test.
+            mBlue.updateException(PACKAGE_RED, PACKAGE_BLUE, true);
+            fail("Non-owner able to grant restriction exception");
+
+        } catch (RuntimeException e) {
+        }
+
+        // Red grants exception to Blue for contact
+        mRed.updateException(PACKAGE_RED, PACKAGE_BLUE, true);
+
+        // Both Blue and Red can read Red contact, but still not Green
+        assertTrue("Owner of restricted contact unable to read",
+                (mRed.getDataCountForContact(redAgg) == 1));
+        assertTrue("Non-owner with restriction exception unable to read",
+                (mBlue.getDataCountForContact(redAgg) == 1));
+        assertTrue("Non-owner of restricted contact able to read",
+                (mGreen.getDataCountForContact(redAgg) == 0));
+
+        // Red revokes exception to Blue
+        mRed.updateException(PACKAGE_RED, PACKAGE_BLUE, false);
+
+        // Assert that only Red can read contact
+        assertTrue("Owner of restricted contact unable to read",
+                (mRed.getDataCountForContact(redAgg) == 1));
+        assertTrue("Non-owner of restricted contact able to read",
+                (mBlue.getDataCountForContact(redAgg) == 0));
+        assertTrue("Non-owner of restricted contact able to read",
+                (mGreen.getDataCountForContact(redAgg) == 0));
+
+    }
+
+    /**
+     * Create an aggregate that has multiple contacts with various levels of
+     * protected data, and ensure that {@link Contacts#CONTENT_SUMMARY_URI}
+     * details don't expose {@link Contacts#IS_RESTRICTED} data.
+     */
+    public void __testAggregateSummary() {
+
+        // Red grants exceptions to itself and Grey
+        mRed.updateException(PACKAGE_RED, PACKAGE_RED, true);
+        mRed.updateException(PACKAGE_RED, PACKAGE_GREY, true);
+
+        // Red creates a protected contact
+        long redContact = mRed.createContact(true);
+        long redName = mRed.createName(redContact, GENERIC_NAME);
+        long redPhone = mRed.createPhone(redContact, PHONE_RED);
+
+        // Blue grants exceptions to itself and Grey
+        mBlue.updateException(PACKAGE_BLUE, PACKAGE_BLUE, true);
+        mBlue.updateException(PACKAGE_BLUE, PACKAGE_GREY, true);
+
+        // Blue creates a protected contact
+        long blueContact = mBlue.createContact(true);
+        long blueName = mBlue.createName(blueContact, GENERIC_NAME);
+        long bluePhone = mBlue.createPhone(blueContact, PHONE_BLUE);
+
+        // Set the super-primary phone number to Red
+        mRed.setSuperPrimaryPhone(redPhone);
+
+        // Make sure both aggregates were joined
+        long singleAgg;
+        {
+            long redAgg = mRed.getContactForRawContact(redContact);
+            long blueAgg = mBlue.getContactForRawContact(blueContact);
+            assertTrue("Two contacts with identical name not aggregated correctly",
+                    (redAgg == blueAgg));
+            singleAgg = redAgg;
+        }
+
+        // Grey and Red querying summary should see Red phone. Blue shouldn't
+        // see any summary data, since it's own data is protected and it's not
+        // the super-primary. Green shouldn't know this aggregate exists.
+        assertTrue("Participant with restriction exception reading incorrect summary",
+                (mGrey.getPrimaryPhoneId(singleAgg) == redPhone));
+        assertTrue("Participant with super-primary restricted data reading incorrect summary",
+                (mRed.getPrimaryPhoneId(singleAgg) == redPhone));
+        assertTrue("Participant with non-super-primary restricted data reading incorrect summary",
+                (mBlue.getPrimaryPhoneId(singleAgg) == 0));
+        assertTrue("Non-participant able to discover aggregate existance",
+                (mGreen.getPrimaryPhoneId(singleAgg) == 0));
+
+        // Add an unprotected Grey contact into the mix
+        long greyContact = mGrey.createContact(false);
+        long greyName = mGrey.createName(greyContact, GENERIC_NAME);
+        long greyPhone = mGrey.createPhone(greyContact, PHONE_GREY);
+
+        // Set the super-primary phone number to Blue
+        mBlue.setSuperPrimaryPhone(bluePhone);
+
+        // Make sure all three aggregates were joined
+        {
+            long redAgg = mRed.getContactForRawContact(redContact);
+            long blueAgg = mBlue.getContactForRawContact(blueContact);
+            long greyAgg = mGrey.getContactForRawContact(greyContact);
+            assertTrue("Three contacts with identical name not aggregated correctly",
+                    (redAgg == blueAgg) && (blueAgg == greyAgg));
+            singleAgg = redAgg;
+        }
+
+        // Grey and Blue querying summary should see Blue phone. Red should see
+        // the Grey phone in its summary, since it's the unprotected fallback.
+        // Red doesn't see its own phone number because it's not super-primary,
+        // and is protected. Again, green shouldn't know this exists.
+        assertTrue("Participant with restriction exception reading incorrect summary",
+                (mGrey.getPrimaryPhoneId(singleAgg) == bluePhone));
+        assertTrue("Participant with non-super-primary restricted data reading incorrect summary",
+                (mRed.getPrimaryPhoneId(singleAgg) == greyPhone));
+        assertTrue("Participant with super-primary restricted data reading incorrect summary",
+                (mBlue.getPrimaryPhoneId(singleAgg) == bluePhone));
+        assertTrue("Non-participant couldn't find unrestricted primary through summary",
+                (mGreen.getPrimaryPhoneId(singleAgg) == greyPhone));
+
+    }
+
+    /**
+     * Create a contact that is completely restricted and isolated in its own
+     * aggregate, and make sure that another actor can't detect its existence.
+     */
+    public void __testRestrictionSilence() {
+        Cursor cursor;
+
+        // Green grants exception to itself
+        mGreen.updateException(PACKAGE_GREEN, PACKAGE_GREEN, true);
+
+        // Green creates a protected contact
+        long greenContact = mGreen.createContact(true);
+        long greenData = mGreen.createPhone(greenContact, PHONE_GREEN);
+        long greenAgg = mGreen.getContactForRawContact(greenContact);
+
+        // AGGREGATES
+        cursor = mRed.resolver
+                .query(Contacts.CONTENT_URI, Projections.PROJ_ID, null, null, null);
+        while (cursor.moveToNext()) {
+            assertTrue("Discovered restricted contact",
+                    (cursor.getLong(Projections.COL_ID) != greenAgg));
+        }
+        cursor.close();
+
+        // AGGREGATES_ID
+        cursor = mRed.resolver.query(ContentUris.withAppendedId(Contacts.CONTENT_URI, greenAgg),
+                Projections.PROJ_ID, null, null, null);
+        assertTrue("Discovered restricted contact", (cursor.getCount() == 0));
+        cursor.close();
+
+        // AGGREGATES_DATA
+        cursor = mRed.resolver.query(Uri.withAppendedPath(ContentUris.withAppendedId(
+                Contacts.CONTENT_URI, greenAgg), Contacts.Data.CONTENT_DIRECTORY),
+                Projections.PROJ_ID, null, null, null);
+        assertTrue("Discovered restricted contact", (cursor.getCount() == 0));
+        cursor.close();
+
+        // AGGREGATES_SUMMARY
+        cursor = mRed.resolver.query(Contacts.CONTENT_SUMMARY_URI, Projections.PROJ_ID, null,
+                null, null);
+        while (cursor.moveToNext()) {
+            assertTrue("Discovered restricted contact",
+                    (cursor.getLong(Projections.COL_ID) != greenAgg));
+        }
+        cursor.close();
+
+        // AGGREGATES_SUMMARY_ID
+        cursor = mRed.resolver.query(ContentUris.withAppendedId(Contacts.CONTENT_SUMMARY_URI,
+                greenAgg), Projections.PROJ_ID, null, null, null);
+        assertTrue("Discovered restricted contact", (cursor.getCount() == 0));
+        cursor.close();
+
+        // TODO: AGGREGATES_SUMMARY_FILTER
+        // TODO: =========================
+
+        // TODO: AGGREGATION_SUGGESTIONS
+        // TODO: =======================
+
+        // CONTACTS
+        cursor = mRed.resolver.query(RawContacts.CONTENT_URI, Projections.PROJ_ID,
+                null, null, null);
+        while (cursor.moveToNext()) {
+            assertTrue("Discovered restricted contact",
+                    (cursor.getLong(Projections.COL_ID) != greenContact));
+        }
+        cursor.close();
+
+        // CONTACTS_ID
+        cursor = mRed.resolver.query(ContentUris
+                .withAppendedId(RawContacts.CONTENT_URI, greenContact), Projections.PROJ_ID, null,
+                null, null);
+        assertTrue("Discovered restricted contact", (cursor.getCount() == 0));
+        cursor.close();
+
+        // CONTACTS_DATA
+        cursor = mRed.resolver.query(Uri.withAppendedPath(ContentUris.withAppendedId(
+                RawContacts.CONTENT_URI, greenContact), RawContacts.Data.CONTENT_DIRECTORY),
+                Projections.PROJ_ID, null, null, null);
+        assertTrue("Discovered restricted contact", (cursor.getCount() == 0));
+        cursor.close();
+
+        // TODO: CONTACTS_FILTER_EMAIL
+        // TODO: =====================
+
+        // DATA
+        cursor = mRed.resolver.query(Data.CONTENT_URI, Projections.PROJ_ID, null, null, null);
+        while (cursor.moveToNext()) {
+            assertTrue("Discovered restricted contact",
+                    (cursor.getLong(Projections.COL_ID) != greenData));
+        }
+        cursor.close();
+
+        // DATA_ID
+        cursor = mRed.resolver.query(ContentUris.withAppendedId(Data.CONTENT_URI, greenData),
+                Projections.PROJ_ID, null, null, null);
+        assertTrue("Discovered restricted contact", (cursor.getCount() == 0));
+        cursor.close();
+
+        // TODO: PHONE_LOOKUP
+        // TODO: ============
+
+    }
+
+    private interface Projections {
+        static final String[] PROJ_ID = new String[] {
+                BaseColumns._ID,
+        };
+
+        static final int COL_ID = 0;
+    }
+
+}
diff --git a/tests/src/com/android/providers/contacts/SynchronousContactsProvider2.java b/tests/src/com/android/providers/contacts/SynchronousContactsProvider2.java
new file mode 100644
index 0000000..fa3c2a6
--- /dev/null
+++ b/tests/src/com/android/providers/contacts/SynchronousContactsProvider2.java
@@ -0,0 +1,74 @@
+/*
+ * 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 android.content.Context;
+
+/**
+ * A version of {@link ContactsProvider2} class that performs aggregation
+ * synchronously and wipes all data at construction time.
+ */
+public class SynchronousContactsProvider2 extends ContactsProvider2 {
+    private static Boolean sDataWiped = false;
+    private static OpenHelper mOpenHelper;
+
+    public SynchronousContactsProvider2() {
+        super(new SynchronousAggregationScheduler());
+    }
+
+    @Override
+    protected OpenHelper getOpenHelper(final Context context) {
+        if (mOpenHelper == null) {
+            mOpenHelper = new OpenHelper(context);
+        }
+        return mOpenHelper;
+    }
+
+    @Override
+    public boolean onCreate() {
+        boolean created = super.onCreate();
+        synchronized (sDataWiped) {
+            if (!sDataWiped) {
+                sDataWiped = true;
+                wipeData();
+            }
+        }
+        return created;
+    }
+
+    private static class SynchronousAggregationScheduler extends ContactAggregationScheduler {
+
+        @Override
+        public void start() {
+        }
+
+        @Override
+        public void stop() {
+        }
+
+        @Override
+        long currentTime() {
+            return 0;
+        }
+
+        @Override
+        void runDelayed() {
+            super.run();
+        }
+
+    }
+}