Fork ContactAggregator to AbstractContactAggregator to keep file hsitory.
Bug:20055573
Change-Id: I42c85df36f039b59707101660441243fb90baca2
diff --git a/src/com/android/providers/contacts/aggregation/AbstractContactAggregator.java b/src/com/android/providers/contacts/aggregation/AbstractContactAggregator.java
new file mode 100644
index 0000000..5b407a6
--- /dev/null
+++ b/src/com/android/providers/contacts/aggregation/AbstractContactAggregator.java
@@ -0,0 +1,2805 @@
+/*
+ * Copyright (C) 2015 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.aggregation;
+
+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.AggregationExceptions;
+import android.provider.ContactsContract.CommonDataKinds.Email;
+import android.provider.ContactsContract.CommonDataKinds.Identity;
+import android.provider.ContactsContract.CommonDataKinds.Phone;
+import android.provider.ContactsContract.CommonDataKinds.Photo;
+import android.provider.ContactsContract.Contacts;
+import android.provider.ContactsContract.Contacts.AggregationSuggestions;
+import android.provider.ContactsContract.Data;
+import android.provider.ContactsContract.DisplayNameSources;
+import android.provider.ContactsContract.FullNameStyle;
+import android.provider.ContactsContract.PhotoFiles;
+import android.provider.ContactsContract.PinnedPositions;
+import android.provider.ContactsContract.RawContacts;
+import android.provider.ContactsContract.StatusUpdates;
+import android.text.TextUtils;
+import android.util.EventLog;
+import android.util.Log;
+
+import com.android.internal.annotations.VisibleForTesting;
+import com.android.providers.contacts.ContactLookupKey;
+import com.android.providers.contacts.ContactsDatabaseHelper;
+import com.android.providers.contacts.ContactsDatabaseHelper.AccountsColumns;
+import com.android.providers.contacts.ContactsDatabaseHelper.AggregatedPresenceColumns;
+import com.android.providers.contacts.ContactsDatabaseHelper.ContactsColumns;
+import com.android.providers.contacts.ContactsDatabaseHelper.DataColumns;
+import com.android.providers.contacts.ContactsDatabaseHelper.NameLookupColumns;
+import com.android.providers.contacts.ContactsDatabaseHelper.NameLookupType;
+import com.android.providers.contacts.ContactsDatabaseHelper.PhoneLookupColumns;
+import com.android.providers.contacts.ContactsDatabaseHelper.PresenceColumns;
+import com.android.providers.contacts.ContactsDatabaseHelper.RawContactsColumns;
+import com.android.providers.contacts.ContactsDatabaseHelper.StatusUpdatesColumns;
+import com.android.providers.contacts.ContactsDatabaseHelper.Tables;
+import com.android.providers.contacts.ContactsDatabaseHelper.Views;
+import com.android.providers.contacts.ContactsProvider2;
+import com.android.providers.contacts.NameLookupBuilder;
+import com.android.providers.contacts.NameNormalizer;
+import com.android.providers.contacts.NameSplitter;
+import com.android.providers.contacts.PhotoPriorityResolver;
+import com.android.providers.contacts.ReorderingCursorWrapper;
+import com.android.providers.contacts.TransactionContext;
+import com.android.providers.contacts.aggregation.util.CommonNicknameCache;
+import com.android.providers.contacts.aggregation.util.ContactAggregatorHelper;
+import com.android.providers.contacts.aggregation.util.ContactMatcher;
+import com.android.providers.contacts.aggregation.util.ContactMatcher.MatchScore;
+import com.android.providers.contacts.database.ContactsTableUtil;
+import com.android.providers.contacts.util.Clock;
+
+import com.google.android.collect.Maps;
+import com.google.android.collect.Sets;
+import com.google.common.collect.Multimap;
+import com.google.common.collect.HashMultimap;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Locale;
+import java.util.Set;
+
+/**
+ * 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.
+ */
+public class AbstractContactAggregator {
+
+ private static final String TAG = "ContactAggregator";
+
+ private static final boolean DEBUG_LOGGING = Log.isLoggable(TAG, Log.DEBUG);
+ private static final boolean VERBOSE_LOGGING = Log.isLoggable(TAG, Log.VERBOSE);
+
+ private static final String STRUCTURED_NAME_BASED_LOOKUP_SQL =
+ NameLookupColumns.NAME_TYPE + " IN ("
+ + NameLookupType.NAME_EXACT + ","
+ + NameLookupType.NAME_VARIANT + ","
+ + NameLookupType.NAME_COLLATION_KEY + ")";
+
+
+ /**
+ * SQL statement that sets the {@link ContactsColumns#LAST_STATUS_UPDATE_ID} column
+ * on the contact to point to the latest social status update.
+ */
+ private static final String UPDATE_LAST_STATUS_UPDATE_ID_SQL =
+ "UPDATE " + Tables.CONTACTS +
+ " SET " + ContactsColumns.LAST_STATUS_UPDATE_ID + "=" +
+ "(SELECT " + DataColumns.CONCRETE_ID +
+ " FROM " + Tables.STATUS_UPDATES +
+ " JOIN " + Tables.DATA +
+ " ON (" + StatusUpdatesColumns.DATA_ID + "="
+ + DataColumns.CONCRETE_ID + ")" +
+ " JOIN " + Tables.RAW_CONTACTS +
+ " ON (" + DataColumns.CONCRETE_RAW_CONTACT_ID + "="
+ + RawContactsColumns.CONCRETE_ID + ")" +
+ " WHERE " + RawContacts.CONTACT_ID + "=?" +
+ " ORDER BY " + StatusUpdates.STATUS_TIMESTAMP + " DESC,"
+ + StatusUpdates.STATUS +
+ " LIMIT 1)" +
+ " WHERE " + ContactsColumns.CONCRETE_ID + "=?";
+
+ // From system/core/logcat/event-log-tags
+ // aggregator [time, count] will be logged for each aggregator cycle.
+ // For the query (as opposed to the merge), count will be negative
+ public static final int LOG_SYNC_CONTACTS_AGGREGATION = 2747;
+
+ // If we encounter more than this many contacts with matching names, aggregate only this many
+ private static final int PRIMARY_HIT_LIMIT = 15;
+ private static final String PRIMARY_HIT_LIMIT_STRING = String.valueOf(PRIMARY_HIT_LIMIT);
+
+ // If we encounter more than this many contacts with matching phone number or email,
+ // don't attempt to aggregate - this is likely an error or a shared corporate data element.
+ private static final int SECONDARY_HIT_LIMIT = 20;
+ private static final String SECONDARY_HIT_LIMIT_STRING = String.valueOf(SECONDARY_HIT_LIMIT);
+
+ // If we encounter no less than this many raw contacts in the best matching contact during
+ // aggregation, don't attempt to aggregate - this is likely an error or a shared corporate
+ // data element.
+ @VisibleForTesting
+ static final int AGGREGATION_CONTACT_SIZE_LIMIT = 50;
+
+ // If we encounter more than this many contacts with matching name during aggregation
+ // suggestion lookup, ignore the remaining results.
+ private static final int FIRST_LETTER_SUGGESTION_HIT_LIMIT = 100;
+
+ // Return code for the canJoinIntoContact method.
+ private static final int JOIN = 1;
+ private static final int KEEP_SEPARATE = 0;
+ private static final int RE_AGGREGATE = -1;
+
+ private final ContactsProvider2 mContactsProvider;
+ private final ContactsDatabaseHelper mDbHelper;
+ private PhotoPriorityResolver mPhotoPriorityResolver;
+ private final NameSplitter mNameSplitter;
+ private final CommonNicknameCache mCommonNicknameCache;
+
+ private boolean mEnabled = true;
+
+ /** Precompiled sql statement for setting an aggregated presence */
+ private SQLiteStatement mAggregatedPresenceReplace;
+ private SQLiteStatement mPresenceContactIdUpdate;
+ private SQLiteStatement mRawContactCountQuery;
+ private SQLiteStatement mAggregatedPresenceDelete;
+ private SQLiteStatement mMarkForAggregation;
+ private SQLiteStatement mPhotoIdUpdate;
+ private SQLiteStatement mDisplayNameUpdate;
+ private SQLiteStatement mLookupKeyUpdate;
+ private SQLiteStatement mStarredUpdate;
+ private SQLiteStatement mPinnedUpdate;
+ private SQLiteStatement mContactIdAndMarkAggregatedUpdate;
+ private SQLiteStatement mContactIdUpdate;
+ private SQLiteStatement mMarkAggregatedUpdate;
+ private SQLiteStatement mContactUpdate;
+ private SQLiteStatement mContactInsert;
+ private SQLiteStatement mResetPinnedForRawContact;
+
+ private HashMap<Long, Integer> mRawContactsMarkedForAggregation = Maps.newHashMap();
+
+ private String[] mSelectionArgs1 = new String[1];
+ private String[] mSelectionArgs2 = new String[2];
+
+ private long mMimeTypeIdIdentity;
+ private long mMimeTypeIdEmail;
+ private long mMimeTypeIdPhoto;
+ private long mMimeTypeIdPhone;
+ private String mRawContactsQueryByRawContactId;
+ private String mRawContactsQueryByContactId;
+ private StringBuilder mSb = new StringBuilder();
+ private MatchCandidateList mCandidates = new MatchCandidateList();
+ private ContactMatcher mMatcher = new ContactMatcher();
+ private DisplayNameCandidate mDisplayNameCandidate = new DisplayNameCandidate();
+
+ /**
+ * Parameter for the suggestion lookup query.
+ */
+ public static final class AggregationSuggestionParameter {
+ public final String kind;
+ public final String value;
+
+ public AggregationSuggestionParameter(String kind, String value) {
+ this.kind = kind;
+ this.value = value;
+ }
+ }
+
+ /**
+ * 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;
+ }
+
+ public boolean isEmpty() {
+ return mCount == 0;
+ }
+ }
+
+ /**
+ * A convenience class used in the algorithm that figures out which of available
+ * display names to use for an aggregate contact.
+ */
+ private static class DisplayNameCandidate {
+ long rawContactId;
+ String displayName;
+ int displayNameSource;
+ boolean isNameSuperPrimary;
+ boolean writableAccount;
+
+ public DisplayNameCandidate() {
+ clear();
+ }
+
+ public void clear() {
+ rawContactId = -1;
+ displayName = null;
+ displayNameSource = DisplayNameSources.UNDEFINED;
+ isNameSuperPrimary = false;
+ writableAccount = false;
+ }
+ }
+
+ /**
+ * Constructor.
+ */
+ public ContactAggregator(ContactsProvider2 contactsProvider,
+ ContactsDatabaseHelper contactsDatabaseHelper,
+ PhotoPriorityResolver photoPriorityResolver, NameSplitter nameSplitter,
+ CommonNicknameCache commonNicknameCache) {
+ mContactsProvider = contactsProvider;
+ mDbHelper = contactsDatabaseHelper;
+ mPhotoPriorityResolver = photoPriorityResolver;
+ mNameSplitter = nameSplitter;
+ mCommonNicknameCache = commonNicknameCache;
+
+ SQLiteDatabase db = mDbHelper.getReadableDatabase();
+
+ // Since we have no way of determining which custom status was set last,
+ // we'll just pick one randomly. We are using MAX as an approximation of randomness
+ final String replaceAggregatePresenceSql =
+ "INSERT OR REPLACE INTO " + Tables.AGGREGATED_PRESENCE + "("
+ + AggregatedPresenceColumns.CONTACT_ID + ", "
+ + StatusUpdates.PRESENCE + ", "
+ + StatusUpdates.CHAT_CAPABILITY + ")"
+ + " SELECT " + PresenceColumns.CONTACT_ID + ","
+ + StatusUpdates.PRESENCE + ","
+ + StatusUpdates.CHAT_CAPABILITY
+ + " FROM " + Tables.PRESENCE
+ + " WHERE "
+ + " (" + StatusUpdates.PRESENCE
+ + " * 10 + " + StatusUpdates.CHAT_CAPABILITY + ")"
+ + " = (SELECT "
+ + "MAX (" + StatusUpdates.PRESENCE
+ + " * 10 + " + StatusUpdates.CHAT_CAPABILITY + ")"
+ + " FROM " + Tables.PRESENCE
+ + " WHERE " + PresenceColumns.CONTACT_ID
+ + "=?)"
+ + " AND " + PresenceColumns.CONTACT_ID
+ + "=?;";
+ mAggregatedPresenceReplace = db.compileStatement(replaceAggregatePresenceSql);
+
+ mRawContactCountQuery = db.compileStatement(
+ "SELECT COUNT(" + RawContacts._ID + ")" +
+ " FROM " + Tables.RAW_CONTACTS +
+ " WHERE " + RawContacts.CONTACT_ID + "=?"
+ + " AND " + RawContacts._ID + "<>?");
+
+ mAggregatedPresenceDelete = db.compileStatement(
+ "DELETE FROM " + Tables.AGGREGATED_PRESENCE +
+ " WHERE " + AggregatedPresenceColumns.CONTACT_ID + "=?");
+
+ mMarkForAggregation = db.compileStatement(
+ "UPDATE " + Tables.RAW_CONTACTS +
+ " SET " + RawContactsColumns.AGGREGATION_NEEDED + "=1" +
+ " WHERE " + RawContacts._ID + "=?"
+ + " AND " + RawContactsColumns.AGGREGATION_NEEDED + "=0");
+
+ mPhotoIdUpdate = db.compileStatement(
+ "UPDATE " + Tables.CONTACTS +
+ " SET " + Contacts.PHOTO_ID + "=?," + Contacts.PHOTO_FILE_ID + "=? " +
+ " WHERE " + Contacts._ID + "=?");
+
+ mDisplayNameUpdate = db.compileStatement(
+ "UPDATE " + Tables.CONTACTS +
+ " SET " + Contacts.NAME_RAW_CONTACT_ID + "=? " +
+ " WHERE " + Contacts._ID + "=?");
+
+ mLookupKeyUpdate = db.compileStatement(
+ "UPDATE " + Tables.CONTACTS +
+ " SET " + Contacts.LOOKUP_KEY + "=? " +
+ " WHERE " + Contacts._ID + "=?");
+
+ mStarredUpdate = db.compileStatement("UPDATE " + Tables.CONTACTS + " SET "
+ + Contacts.STARRED + "=(SELECT (CASE WHEN COUNT(" + RawContacts.STARRED
+ + ")=0 THEN 0 ELSE 1 END) FROM " + Tables.RAW_CONTACTS + " WHERE "
+ + RawContacts.CONTACT_ID + "=" + ContactsColumns.CONCRETE_ID + " AND "
+ + RawContacts.STARRED + "=1)" + " WHERE " + Contacts._ID + "=?");
+
+ mPinnedUpdate = db.compileStatement("UPDATE " + Tables.CONTACTS + " SET "
+ + Contacts.PINNED + " = IFNULL((SELECT MIN(" + RawContacts.PINNED + ") FROM "
+ + Tables.RAW_CONTACTS + " WHERE " + RawContacts.CONTACT_ID + "="
+ + ContactsColumns.CONCRETE_ID + " AND " + RawContacts.PINNED + ">"
+ + PinnedPositions.UNPINNED + ")," + PinnedPositions.UNPINNED + ") "
+ + "WHERE " + Contacts._ID + "=?");
+
+ mContactIdAndMarkAggregatedUpdate = db.compileStatement(
+ "UPDATE " + Tables.RAW_CONTACTS +
+ " SET " + RawContacts.CONTACT_ID + "=?, "
+ + RawContactsColumns.AGGREGATION_NEEDED + "=0" +
+ " WHERE " + RawContacts._ID + "=?");
+
+ mContactIdUpdate = db.compileStatement(
+ "UPDATE " + Tables.RAW_CONTACTS +
+ " SET " + RawContacts.CONTACT_ID + "=?" +
+ " WHERE " + RawContacts._ID + "=?");
+
+ mMarkAggregatedUpdate = db.compileStatement(
+ "UPDATE " + Tables.RAW_CONTACTS +
+ " SET " + RawContactsColumns.AGGREGATION_NEEDED + "=0" +
+ " WHERE " + RawContacts._ID + "=?");
+
+ mPresenceContactIdUpdate = db.compileStatement(
+ "UPDATE " + Tables.PRESENCE +
+ " SET " + PresenceColumns.CONTACT_ID + "=?" +
+ " WHERE " + PresenceColumns.RAW_CONTACT_ID + "=?");
+
+ mContactUpdate = db.compileStatement(ContactReplaceSqlStatement.UPDATE_SQL);
+ mContactInsert = db.compileStatement(ContactReplaceSqlStatement.INSERT_SQL);
+
+ mResetPinnedForRawContact = db.compileStatement(
+ "UPDATE " + Tables.RAW_CONTACTS +
+ " SET " + RawContacts.PINNED + "=" + PinnedPositions.UNPINNED +
+ " WHERE " + RawContacts._ID + "=?");
+
+ mMimeTypeIdEmail = mDbHelper.getMimeTypeId(Email.CONTENT_ITEM_TYPE);
+ mMimeTypeIdIdentity = mDbHelper.getMimeTypeId(Identity.CONTENT_ITEM_TYPE);
+ mMimeTypeIdPhoto = mDbHelper.getMimeTypeId(Photo.CONTENT_ITEM_TYPE);
+ mMimeTypeIdPhone = mDbHelper.getMimeTypeId(Phone.CONTENT_ITEM_TYPE);
+
+ // Query used to retrieve data from raw contacts to populate the corresponding aggregate
+ mRawContactsQueryByRawContactId = String.format(Locale.US,
+ RawContactsQuery.SQL_FORMAT_BY_RAW_CONTACT_ID,
+ mDbHelper.getMimeTypeIdForStructuredName(), mMimeTypeIdPhoto, mMimeTypeIdPhone);
+
+ mRawContactsQueryByContactId = String.format(Locale.US,
+ RawContactsQuery.SQL_FORMAT_BY_CONTACT_ID,
+ mDbHelper.getMimeTypeIdForStructuredName(), mMimeTypeIdPhoto, mMimeTypeIdPhone);
+ }
+
+ public void setEnabled(boolean enabled) {
+ mEnabled = enabled;
+ }
+
+ public boolean isEnabled() {
+ return mEnabled;
+ }
+
+ private interface AggregationQuery {
+ String SQL =
+ "SELECT " + RawContacts._ID + "," + RawContacts.CONTACT_ID +
+ ", " + RawContactsColumns.ACCOUNT_ID +
+ " FROM " + Tables.RAW_CONTACTS +
+ " WHERE " + RawContacts._ID + " IN(";
+
+ int _ID = 0;
+ int CONTACT_ID = 1;
+ int ACCOUNT_ID = 2;
+ }
+
+ /**
+ * Aggregate all raw contacts that were marked for aggregation in the current transaction.
+ * Call just before committing the transaction.
+ */
+ public void aggregateInTransaction(TransactionContext txContext, SQLiteDatabase db) {
+ final int markedCount = mRawContactsMarkedForAggregation.size();
+ if (markedCount == 0) {
+ return;
+ }
+
+ final long start = System.currentTimeMillis();
+ if (DEBUG_LOGGING) {
+ Log.d(TAG, "aggregateInTransaction for " + markedCount + " contacts");
+ }
+
+ EventLog.writeEvent(LOG_SYNC_CONTACTS_AGGREGATION, start, -markedCount);
+
+ int index = 0;
+
+ // We don't use the cached string builder (namely mSb) here, as this string can be very
+ // long when upgrading (where we re-aggregate all visible contacts) and StringBuilder won't
+ // shrink the internal storage.
+ // Note: don't use selection args here. We just include all IDs directly in the selection,
+ // because there's a limit for the number of parameters in a query.
+ final StringBuilder sbQuery = new StringBuilder();
+ sbQuery.append(AggregationQuery.SQL);
+ for (long rawContactId : mRawContactsMarkedForAggregation.keySet()) {
+ if (index > 0) {
+ sbQuery.append(',');
+ }
+ sbQuery.append(rawContactId);
+ index++;
+ }
+
+ sbQuery.append(')');
+
+ final long[] rawContactIds;
+ final long[] contactIds;
+ final long[] accountIds;
+ final int actualCount;
+ final Cursor c = db.rawQuery(sbQuery.toString(), null);
+ try {
+ actualCount = c.getCount();
+ rawContactIds = new long[actualCount];
+ contactIds = new long[actualCount];
+ accountIds = new long[actualCount];
+
+ index = 0;
+ while (c.moveToNext()) {
+ rawContactIds[index] = c.getLong(AggregationQuery._ID);
+ contactIds[index] = c.getLong(AggregationQuery.CONTACT_ID);
+ accountIds[index] = c.getLong(AggregationQuery.ACCOUNT_ID);
+ index++;
+ }
+ } finally {
+ c.close();
+ }
+
+ if (DEBUG_LOGGING) {
+ Log.d(TAG, "aggregateInTransaction: initial query done.");
+ }
+
+ for (int i = 0; i < actualCount; i++) {
+ aggregateContact(txContext, db, rawContactIds[i], accountIds[i], contactIds[i],
+ mCandidates, mMatcher);
+ }
+
+ long elapsedTime = System.currentTimeMillis() - start;
+ EventLog.writeEvent(LOG_SYNC_CONTACTS_AGGREGATION, elapsedTime, actualCount);
+
+ if (DEBUG_LOGGING) {
+ Log.d(TAG, "Contact aggregation complete: " + actualCount +
+ (actualCount == 0 ? "" : ", " + (elapsedTime / actualCount)
+ + " ms per raw contact"));
+ }
+ }
+
+ @SuppressWarnings("deprecation")
+ public void triggerAggregation(TransactionContext txContext, long rawContactId) {
+ if (!mEnabled) {
+ return;
+ }
+
+ int aggregationMode = mDbHelper.getAggregationMode(rawContactId);
+ switch (aggregationMode) {
+ case RawContacts.AGGREGATION_MODE_DISABLED:
+ break;
+
+ case RawContacts.AGGREGATION_MODE_DEFAULT: {
+ markForAggregation(rawContactId, aggregationMode, false);
+ break;
+ }
+
+ case RawContacts.AGGREGATION_MODE_SUSPENDED: {
+ long contactId = mDbHelper.getContactId(rawContactId);
+
+ if (contactId != 0) {
+ updateAggregateData(txContext, contactId);
+ }
+ break;
+ }
+
+ case RawContacts.AGGREGATION_MODE_IMMEDIATE: {
+ aggregateContact(txContext, mDbHelper.getWritableDatabase(), rawContactId);
+ break;
+ }
+ }
+ }
+
+ public void clearPendingAggregations() {
+ // HashMap woulnd't shrink the internal table once expands it, so let's just re-create
+ // a new one instead of clear()ing it.
+ mRawContactsMarkedForAggregation = Maps.newHashMap();
+ }
+
+ public void markNewForAggregation(long rawContactId, int aggregationMode) {
+ mRawContactsMarkedForAggregation.put(rawContactId, aggregationMode);
+ }
+
+ public void markForAggregation(long rawContactId, int aggregationMode, boolean force) {
+ final int effectiveAggregationMode;
+ if (!force && mRawContactsMarkedForAggregation.containsKey(rawContactId)) {
+ // As per ContactsContract documentation, default aggregation mode
+ // does not override a previously set mode
+ if (aggregationMode == RawContacts.AGGREGATION_MODE_DEFAULT) {
+ effectiveAggregationMode = mRawContactsMarkedForAggregation.get(rawContactId);
+ } else {
+ effectiveAggregationMode = aggregationMode;
+ }
+ } else {
+ mMarkForAggregation.bindLong(1, rawContactId);
+ mMarkForAggregation.execute();
+ effectiveAggregationMode = aggregationMode;
+ }
+
+ mRawContactsMarkedForAggregation.put(rawContactId, effectiveAggregationMode);
+ }
+
+ private static class RawContactIdAndAggregationModeQuery {
+ public static final String TABLE = Tables.RAW_CONTACTS;
+
+ public static final String[] COLUMNS = { RawContacts._ID, RawContacts.AGGREGATION_MODE };
+
+ public static final String SELECTION = RawContacts.CONTACT_ID + "=?";
+
+ public static final int _ID = 0;
+ public static final int AGGREGATION_MODE = 1;
+ }
+
+ /**
+ * Marks all constituent raw contacts of an aggregated contact for re-aggregation.
+ */
+ private void markContactForAggregation(SQLiteDatabase db, long contactId) {
+ mSelectionArgs1[0] = String.valueOf(contactId);
+ Cursor cursor = db.query(RawContactIdAndAggregationModeQuery.TABLE,
+ RawContactIdAndAggregationModeQuery.COLUMNS,
+ RawContactIdAndAggregationModeQuery.SELECTION, mSelectionArgs1, null, null, null);
+ try {
+ if (cursor.moveToFirst()) {
+ long rawContactId = cursor.getLong(RawContactIdAndAggregationModeQuery._ID);
+ int aggregationMode = cursor.getInt(
+ RawContactIdAndAggregationModeQuery.AGGREGATION_MODE);
+ // Don't re-aggregate AGGREGATION_MODE_SUSPENDED / AGGREGATION_MODE_DISABLED.
+ // (Also just ignore deprecated AGGREGATION_MODE_IMMEDIATE)
+ if (aggregationMode == RawContacts.AGGREGATION_MODE_DEFAULT) {
+ markForAggregation(rawContactId, aggregationMode, true);
+ }
+ }
+ } finally {
+ cursor.close();
+ }
+ }
+
+ /**
+ * Mark all visible contacts for re-aggregation.
+ *
+ * - Set {@link RawContactsColumns#AGGREGATION_NEEDED} For all visible raw_contacts with
+ * {@link RawContacts#AGGREGATION_MODE_DEFAULT}.
+ * - Also put them into {@link #mRawContactsMarkedForAggregation}.
+ */
+ public int markAllVisibleForAggregation(SQLiteDatabase db) {
+ final long start = System.currentTimeMillis();
+
+ // Set AGGREGATION_NEEDED for all visible raw_cotnacts with AGGREGATION_MODE_DEFAULT.
+ // (Don't re-aggregate AGGREGATION_MODE_SUSPENDED / AGGREGATION_MODE_DISABLED)
+ db.execSQL("UPDATE " + Tables.RAW_CONTACTS + " SET " +
+ RawContactsColumns.AGGREGATION_NEEDED + "=1" +
+ " WHERE " + RawContacts.CONTACT_ID + " IN " + Tables.DEFAULT_DIRECTORY +
+ " AND " + RawContacts.AGGREGATION_MODE + "=" + RawContacts.AGGREGATION_MODE_DEFAULT
+ );
+
+ final int count;
+ final Cursor cursor = db.rawQuery("SELECT " + RawContacts._ID +
+ " FROM " + Tables.RAW_CONTACTS +
+ " WHERE " + RawContactsColumns.AGGREGATION_NEEDED + "=1", null);
+ try {
+ count = cursor.getCount();
+ cursor.moveToPosition(-1);
+ while (cursor.moveToNext()) {
+ final long rawContactId = cursor.getLong(0);
+ mRawContactsMarkedForAggregation.put(rawContactId,
+ RawContacts.AGGREGATION_MODE_DEFAULT);
+ }
+ } finally {
+ cursor.close();
+ }
+
+ final long end = System.currentTimeMillis();
+ Log.i(TAG, "Marked all visible contacts for aggregation: " + count + " raw contacts, " +
+ (end - start) + " ms");
+ return count;
+ }
+
+ /**
+ * Creates a new contact based on the given raw contact. Does not perform aggregation. Returns
+ * the ID of the contact that was created.
+ */
+ public long onRawContactInsert(
+ TransactionContext txContext, SQLiteDatabase db, long rawContactId) {
+ long contactId = insertContact(db, rawContactId);
+ setContactId(rawContactId, contactId);
+ mDbHelper.updateContactVisible(txContext, contactId);
+ return contactId;
+ }
+
+ protected long insertContact(SQLiteDatabase db, long rawContactId) {
+ mSelectionArgs1[0] = String.valueOf(rawContactId);
+ computeAggregateData(db, mRawContactsQueryByRawContactId, mSelectionArgs1, mContactInsert);
+ return mContactInsert.executeInsert();
+ }
+
+ private static final class RawContactIdAndAccountQuery {
+ public static final String TABLE = Tables.RAW_CONTACTS;
+
+ public static final String[] COLUMNS = {
+ RawContacts.CONTACT_ID,
+ RawContactsColumns.ACCOUNT_ID
+ };
+
+ public static final String SELECTION = RawContacts._ID + "=?";
+
+ public static final int CONTACT_ID = 0;
+ public static final int ACCOUNT_ID = 1;
+ }
+
+ public void aggregateContact(
+ TransactionContext txContext, SQLiteDatabase db, long rawContactId) {
+ if (!mEnabled) {
+ return;
+ }
+
+ MatchCandidateList candidates = new MatchCandidateList();
+ ContactMatcher matcher = new ContactMatcher();
+
+ long contactId = 0;
+ long accountId = 0;
+ mSelectionArgs1[0] = String.valueOf(rawContactId);
+ Cursor cursor = db.query(RawContactIdAndAccountQuery.TABLE,
+ RawContactIdAndAccountQuery.COLUMNS, RawContactIdAndAccountQuery.SELECTION,
+ mSelectionArgs1, null, null, null);
+ try {
+ if (cursor.moveToFirst()) {
+ contactId = cursor.getLong(RawContactIdAndAccountQuery.CONTACT_ID);
+ accountId = cursor.getLong(RawContactIdAndAccountQuery.ACCOUNT_ID);
+ }
+ } finally {
+ cursor.close();
+ }
+
+ aggregateContact(txContext, db, rawContactId, accountId, contactId,
+ candidates, matcher);
+ }
+
+ public void updateAggregateData(TransactionContext txContext, long contactId) {
+ if (!mEnabled) {
+ return;
+ }
+
+ final SQLiteDatabase db = mDbHelper.getWritableDatabase();
+ computeAggregateData(db, contactId, mContactUpdate);
+ mContactUpdate.bindLong(ContactReplaceSqlStatement.CONTACT_ID, contactId);
+ mContactUpdate.execute();
+
+ mDbHelper.updateContactVisible(txContext, contactId);
+ updateAggregatedStatusUpdate(contactId);
+ }
+
+ private void updateAggregatedStatusUpdate(long contactId) {
+ mAggregatedPresenceReplace.bindLong(1, contactId);
+ mAggregatedPresenceReplace.bindLong(2, contactId);
+ mAggregatedPresenceReplace.execute();
+ updateLastStatusUpdateId(contactId);
+ }
+
+ /**
+ * Adjusts the reference to the latest status update for the specified contact.
+ */
+ public void updateLastStatusUpdateId(long contactId) {
+ String contactIdString = String.valueOf(contactId);
+ mDbHelper.getWritableDatabase().execSQL(UPDATE_LAST_STATUS_UPDATE_ID_SQL,
+ new String[]{contactIdString, contactIdString});
+ }
+
+ /**
+ * 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.
+ */
+ private synchronized void aggregateContact(TransactionContext txContext, SQLiteDatabase db,
+ long rawContactId, long accountId, long currentContactId, MatchCandidateList candidates,
+ ContactMatcher matcher) {
+
+ if (VERBOSE_LOGGING) {
+ Log.v(TAG, "aggregateContact: rid=" + rawContactId + " cid=" + currentContactId);
+ }
+
+ int aggregationMode = RawContacts.AGGREGATION_MODE_DEFAULT;
+
+ Integer aggModeObject = mRawContactsMarkedForAggregation.remove(rawContactId);
+ if (aggModeObject != null) {
+ aggregationMode = aggModeObject;
+ }
+
+ long contactId = -1; // Best matching contact ID.
+ boolean needReaggregate = false;
+
+ final Set<Long> rawContactIdsInSameAccount = new HashSet<Long>();
+ final Set<Long> rawContactIdsInOtherAccount = new HashSet<Long>();
+ if (aggregationMode == RawContacts.AGGREGATION_MODE_DEFAULT) {
+ candidates.clear();
+ matcher.clear();
+
+ contactId = pickBestMatchBasedOnExceptions(db, rawContactId, matcher);
+ if (contactId == -1) {
+
+ // If this is a newly inserted contact or a visible contact, look for
+ // data matches.
+ if (currentContactId == 0
+ || mDbHelper.isContactInDefaultDirectory(db, currentContactId)) {
+ contactId = pickBestMatchBasedOnData(db, rawContactId, candidates, matcher);
+ }
+
+ // If we found an best matched contact, find out if the raw contact can be joined
+ // into it
+ if (contactId != -1 && contactId != currentContactId) {
+ // List all raw contact ID and their account ID mappings in contact
+ // [contactId] excluding raw_contact [rawContactId].
+
+ // Based on the mapping, create two sets of raw contact IDs in
+ // [rawContactAccountId] and not in [rawContactAccountId]. We don't always
+ // need them, so lazily initialize them.
+ mSelectionArgs2[0] = String.valueOf(contactId);
+ mSelectionArgs2[1] = String.valueOf(rawContactId);
+ final Cursor rawContactsToAccountsCursor = db.rawQuery(
+ "SELECT " + RawContacts._ID + ", " + RawContactsColumns.ACCOUNT_ID +
+ " FROM " + Tables.RAW_CONTACTS +
+ " WHERE " + RawContacts.CONTACT_ID + "=?" +
+ " AND " + RawContacts._ID + "!=?",
+ mSelectionArgs2);
+ try {
+ rawContactsToAccountsCursor.moveToPosition(-1);
+ while (rawContactsToAccountsCursor.moveToNext()) {
+ final long rcId = rawContactsToAccountsCursor.getLong(0);
+ final long rc_accountId = rawContactsToAccountsCursor.getLong(1);
+ if (rc_accountId == accountId) {
+ rawContactIdsInSameAccount.add(rcId);
+ } else {
+ rawContactIdsInOtherAccount.add(rcId);
+ }
+ }
+ } finally {
+ rawContactsToAccountsCursor.close();
+ }
+ final int actionCode;
+ final int totalNumOfRawContactsInCandidate = rawContactIdsInSameAccount.size()
+ + rawContactIdsInOtherAccount.size();
+ if (totalNumOfRawContactsInCandidate >= AGGREGATION_CONTACT_SIZE_LIMIT) {
+ if (VERBOSE_LOGGING) {
+ Log.v(TAG, "Too many raw contacts (" + totalNumOfRawContactsInCandidate
+ + ") in the best matching contact, so skip aggregation");
+ }
+ actionCode = KEEP_SEPARATE;
+ } else {
+ actionCode = canJoinIntoContact(db, rawContactId,
+ rawContactIdsInSameAccount, rawContactIdsInOtherAccount);
+ }
+ if (actionCode == KEEP_SEPARATE) {
+ contactId = -1;
+ } else if (actionCode == RE_AGGREGATE) {
+ needReaggregate = true;
+ }
+ }
+ }
+ } else if (aggregationMode == RawContacts.AGGREGATION_MODE_DISABLED) {
+ return;
+ }
+
+ // # of raw_contacts in the [currentContactId] contact excluding the [rawContactId]
+ // raw_contact.
+ long currentContactContentsCount = 0;
+
+ if (currentContactId != 0) {
+ mRawContactCountQuery.bindLong(1, currentContactId);
+ mRawContactCountQuery.bindLong(2, rawContactId);
+ currentContactContentsCount = mRawContactCountQuery.simpleQueryForLong();
+ }
+
+ // If there are no other raw contacts in the current aggregate, we might as well reuse it.
+ // Also, if the aggregation mode is SUSPENDED, we must reuse the same aggregate.
+ if (contactId == -1
+ && currentContactId != 0
+ && (currentContactContentsCount == 0
+ || aggregationMode == RawContacts.AGGREGATION_MODE_SUSPENDED)) {
+ contactId = currentContactId;
+ }
+
+ if (contactId == currentContactId) {
+ // Aggregation unchanged
+ markAggregated(rawContactId);
+ if (VERBOSE_LOGGING) {
+ Log.v(TAG, "Aggregation unchanged");
+ }
+ } else if (contactId == -1) {
+ // create new contact for [rawContactId]
+ createContactForRawContacts(db, txContext, Sets.newHashSet(rawContactId), null);
+ if (currentContactContentsCount > 0) {
+ updateAggregateData(txContext, currentContactId);
+ }
+ if (VERBOSE_LOGGING) {
+ Log.v(TAG, "create new contact for rid=" + rawContactId);
+ }
+ } else if (needReaggregate) {
+ // re-aggregate
+ final Set<Long> allRawContactIdSet = new HashSet<Long>();
+ allRawContactIdSet.addAll(rawContactIdsInSameAccount);
+ allRawContactIdSet.addAll(rawContactIdsInOtherAccount);
+ // If there is no other raw contacts aggregated with the given raw contact currently,
+ // we might as well reuse it.
+ currentContactId = (currentContactId != 0 && currentContactContentsCount == 0)
+ ? currentContactId : 0;
+ reAggregateRawContacts(txContext, db, contactId, currentContactId, rawContactId,
+ allRawContactIdSet);
+ if (VERBOSE_LOGGING) {
+ Log.v(TAG, "Re-aggregating rid=" + rawContactId + " and cid=" + contactId);
+ }
+ } else {
+ // Joining with an existing aggregate
+ if (currentContactContentsCount == 0) {
+ // Delete a previous aggregate if it only contained this raw contact
+ ContactsTableUtil.deleteContact(db, currentContactId);
+
+ mAggregatedPresenceDelete.bindLong(1, currentContactId);
+ mAggregatedPresenceDelete.execute();
+ }
+
+ clearSuperPrimarySetting(db, contactId, rawContactId);
+ setContactIdAndMarkAggregated(rawContactId, contactId);
+ computeAggregateData(db, contactId, mContactUpdate);
+ mContactUpdate.bindLong(ContactReplaceSqlStatement.CONTACT_ID, contactId);
+ mContactUpdate.execute();
+ mDbHelper.updateContactVisible(txContext, contactId);
+ updateAggregatedStatusUpdate(contactId);
+ // Make sure the raw contact does not contribute to the current contact
+ if (currentContactId != 0) {
+ updateAggregateData(txContext, currentContactId);
+ }
+ if (VERBOSE_LOGGING) {
+ Log.v(TAG, "Join rid=" + rawContactId + " with cid=" + contactId);
+ }
+ }
+ }
+
+ /**
+ * Find out which mime-types are shared by raw contact of {@code rawContactId} and raw contacts
+ * of {@code contactId}. Clear the is_super_primary settings for these mime-types.
+ */
+ private void clearSuperPrimarySetting(SQLiteDatabase db, long contactId, long rawContactId) {
+ final String[] args = {String.valueOf(contactId), String.valueOf(rawContactId)};
+
+ // Find out which mime-types exist with is_super_primary=true on both the raw contact of
+ // rawContactId and raw contacts of contactId
+ int index = 0;
+ final StringBuilder mimeTypeCondition = new StringBuilder();
+ mimeTypeCondition.append(" AND " + DataColumns.MIMETYPE_ID + " IN (");
+
+ final Cursor c = db.rawQuery(
+ "SELECT DISTINCT(a." + DataColumns.MIMETYPE_ID + ")" +
+ " FROM (SELECT " + DataColumns.MIMETYPE_ID + " FROM " + Tables.DATA + " WHERE " +
+ Data.IS_SUPER_PRIMARY + " =1 AND " +
+ Data.RAW_CONTACT_ID + " IN (SELECT " + RawContacts._ID + " FROM " +
+ Tables.RAW_CONTACTS + " WHERE " + RawContacts.CONTACT_ID + "=?1)) AS a" +
+ " JOIN (SELECT " + DataColumns.MIMETYPE_ID + " FROM " + Tables.DATA + " WHERE " +
+ Data.IS_SUPER_PRIMARY + " =1 AND " +
+ Data.RAW_CONTACT_ID + "=?2) AS b" +
+ " ON a." + DataColumns.MIMETYPE_ID + "=b." + DataColumns.MIMETYPE_ID,
+ args);
+ try {
+ c.moveToPosition(-1);
+ while (c.moveToNext()) {
+ if (index > 0) {
+ mimeTypeCondition.append(',');
+ }
+ mimeTypeCondition.append(c.getLong((0)));
+ index++;
+ }
+ } finally {
+ c.close();
+ }
+
+ if (index == 0) {
+ return;
+ }
+
+ // Clear is_super_primary setting for all the mime-types with is_super_primary=true
+ // in both raw contact of rawContactId and raw contacts of contactId
+ String superPrimaryUpdateSql = "UPDATE " + Tables.DATA +
+ " SET " + Data.IS_SUPER_PRIMARY + "=0" +
+ " WHERE (" + Data.RAW_CONTACT_ID +
+ " IN (SELECT " + RawContacts._ID + " FROM " + Tables.RAW_CONTACTS +
+ " WHERE " + RawContacts.CONTACT_ID + "=?1)" +
+ " OR " + Data.RAW_CONTACT_ID + "=?2)";
+
+ mimeTypeCondition.append(')');
+ superPrimaryUpdateSql += mimeTypeCondition.toString();
+ db.execSQL(superPrimaryUpdateSql, args);
+ }
+
+ /**
+ * @return JOIN if the raw contact of {@code rawContactId} can be joined into the existing
+ * contact of {@code contactId}. KEEP_SEPARATE if the raw contact of {@code rawContactId}
+ * cannot be joined into the existing contact of {@code contactId}. RE_AGGREGATE if raw contact
+ * of {@code rawContactId} and all the raw contacts of contact of {@code contactId} need to be
+ * re-aggregated.
+ *
+ * If contact of {@code contactId} doesn't contain any raw contacts from the same account as
+ * raw contact of {@code rawContactId}, join raw contact with contact if there is no identity
+ * mismatch between them on the same namespace, otherwise, keep them separate.
+ *
+ * If contact of {@code contactId} contains raw contacts from the same account as raw contact of
+ * {@code rawContactId}, join raw contact with contact if there's at least one raw contact in
+ * those raw contacts that shares at least one email address, phone number, or identity;
+ * otherwise, re-aggregate raw contact and all the raw contacts of contact.
+ */
+ private int canJoinIntoContact(SQLiteDatabase db, long rawContactId,
+ Set<Long> rawContactIdsInSameAccount, Set<Long> rawContactIdsInOtherAccount ) {
+
+ if (rawContactIdsInSameAccount.isEmpty()) {
+ final String rid = String.valueOf(rawContactId);
+ final String ridsInOtherAccts = TextUtils.join(",", rawContactIdsInOtherAccount);
+ // If there is no identity match between raw contact of [rawContactId] and
+ // any raw contact in other accounts on the same namespace, and there is at least
+ // one identity mismatch exist, keep raw contact separate from contact.
+ if (DatabaseUtils.longForQuery(db, buildIdentityMatchingSql(rid, ridsInOtherAccts,
+ /* isIdentityMatching =*/ true, /* countOnly =*/ true), null) == 0 &&
+ DatabaseUtils.longForQuery(db, buildIdentityMatchingSql(rid, ridsInOtherAccts,
+ /* isIdentityMatching =*/ false, /* countOnly =*/ true), null) > 0) {
+ if (VERBOSE_LOGGING) {
+ Log.v(TAG, "canJoinIntoContact: no duplicates, but has no matching identity " +
+ "and has mis-matching identity on the same namespace between rid=" +
+ rid + " and ridsInOtherAccts=" + ridsInOtherAccts);
+ }
+ return KEEP_SEPARATE; // has identity and identity doesn't match
+ } else {
+ if (VERBOSE_LOGGING) {
+ Log.v(TAG, "canJoinIntoContact: can join the first raw contact from the same " +
+ "account without any identity mismatch.");
+ }
+ return JOIN; // no identity or identity match
+ }
+ }
+ if (VERBOSE_LOGGING) {
+ Log.v(TAG, "canJoinIntoContact: " + rawContactIdsInSameAccount.size() +
+ " duplicate(s) found");
+ }
+
+
+ final Set<Long> rawContactIdSet = new HashSet<Long>();
+ rawContactIdSet.add(rawContactId);
+ if (rawContactIdsInSameAccount.size() > 0 &&
+ isDataMaching(db, rawContactIdSet, rawContactIdsInSameAccount)) {
+ if (VERBOSE_LOGGING) {
+ Log.v(TAG, "canJoinIntoContact: join if there is a data matching found in the " +
+ "same account");
+ }
+ return JOIN;
+ } else {
+ if (VERBOSE_LOGGING) {
+ Log.v(TAG, "canJoinIntoContact: re-aggregate rid=" + rawContactId +
+ " with its best matching contact to connected component");
+ }
+ return RE_AGGREGATE;
+ }
+ }
+
+ private interface RawContactMatchingSelectionStatement {
+ String SELECT_COUNT = "SELECT count(*) " ;
+ String SELECT_ID = "SELECT d1." + Data.RAW_CONTACT_ID + ",d2." + Data.RAW_CONTACT_ID ;
+ }
+
+ /**
+ * Build sql to check if there is any identity match/mis-match between two sets of raw contact
+ * ids on the same namespace.
+ */
+ private String buildIdentityMatchingSql(String rawContactIdSet1, String rawContactIdSet2,
+ boolean isIdentityMatching, boolean countOnly) {
+ final String identityType = String.valueOf(mMimeTypeIdIdentity);
+ final String matchingOperator = (isIdentityMatching) ? "=" : "!=";
+ final String sql =
+ " FROM " + Tables.DATA + " AS d1" +
+ " JOIN " + Tables.DATA + " AS d2" +
+ " ON (d1." + Identity.IDENTITY + matchingOperator +
+ " d2." + Identity.IDENTITY + " AND" +
+ " d1." + Identity.NAMESPACE + " = d2." + Identity.NAMESPACE + " )" +
+ " WHERE d1." + DataColumns.MIMETYPE_ID + " = " + identityType +
+ " AND d2." + DataColumns.MIMETYPE_ID + " = " + identityType +
+ " AND d1." + Data.RAW_CONTACT_ID + " IN (" + rawContactIdSet1 + ")" +
+ " AND d2." + Data.RAW_CONTACT_ID + " IN (" + rawContactIdSet2 + ")";
+ return (countOnly) ? RawContactMatchingSelectionStatement.SELECT_COUNT + sql :
+ RawContactMatchingSelectionStatement.SELECT_ID + sql;
+ }
+
+ private String buildEmailMatchingSql(String rawContactIdSet1, String rawContactIdSet2,
+ boolean countOnly) {
+ final String emailType = String.valueOf(mMimeTypeIdEmail);
+ final String sql =
+ " FROM " + Tables.DATA + " AS d1" +
+ " JOIN " + Tables.DATA + " AS d2" +
+ " ON lower(d1." + Email.ADDRESS + ")= lower(d2." + Email.ADDRESS + ")" +
+ " WHERE d1." + DataColumns.MIMETYPE_ID + " = " + emailType +
+ " AND d2." + DataColumns.MIMETYPE_ID + " = " + emailType +
+ " AND d1." + Data.RAW_CONTACT_ID + " IN (" + rawContactIdSet1 + ")" +
+ " AND d2." + Data.RAW_CONTACT_ID + " IN (" + rawContactIdSet2 + ")";
+ return (countOnly) ? RawContactMatchingSelectionStatement.SELECT_COUNT + sql :
+ RawContactMatchingSelectionStatement.SELECT_ID + sql;
+ }
+
+ private String buildPhoneMatchingSql(String rawContactIdSet1, String rawContactIdSet2,
+ boolean countOnly) {
+ // It's a bit tricker because it has to be consistent with
+ // updateMatchScoresBasedOnPhoneMatches().
+ final String phoneType = String.valueOf(mMimeTypeIdPhone);
+ final String sql =
+ " FROM " + Tables.PHONE_LOOKUP + " AS p1" +
+ " JOIN " + Tables.DATA + " AS d1 ON " +
+ "(d1." + Data._ID + "=p1." + PhoneLookupColumns.DATA_ID + ")" +
+ " JOIN " + Tables.PHONE_LOOKUP + " AS p2 ON (p1." + PhoneLookupColumns.MIN_MATCH +
+ "=p2." + PhoneLookupColumns.MIN_MATCH + ")" +
+ " JOIN " + Tables.DATA + " AS d2 ON " +
+ "(d2." + Data._ID + "=p2." + PhoneLookupColumns.DATA_ID + ")" +
+ " WHERE d1." + DataColumns.MIMETYPE_ID + " = " + phoneType +
+ " AND d2." + DataColumns.MIMETYPE_ID + " = " + phoneType +
+ " AND d1." + Data.RAW_CONTACT_ID + " IN (" + rawContactIdSet1 + ")" +
+ " AND d2." + Data.RAW_CONTACT_ID + " IN (" + rawContactIdSet2 + ")" +
+ " AND PHONE_NUMBERS_EQUAL(d1." + Phone.NUMBER + ",d2." + Phone.NUMBER + "," +
+ String.valueOf(mDbHelper.getUseStrictPhoneNumberComparisonParameter()) +
+ ")";
+ return (countOnly) ? RawContactMatchingSelectionStatement.SELECT_COUNT + sql :
+ RawContactMatchingSelectionStatement.SELECT_ID + sql;
+ }
+
+ private String buildExceptionMatchingSql(String rawContactIdSet1, String rawContactIdSet2) {
+ return "SELECT " + AggregationExceptions.RAW_CONTACT_ID1 + ", " +
+ AggregationExceptions.RAW_CONTACT_ID2 +
+ " FROM " + Tables.AGGREGATION_EXCEPTIONS +
+ " WHERE " + AggregationExceptions.RAW_CONTACT_ID1 + " IN (" +
+ rawContactIdSet1 + ")" +
+ " AND " + AggregationExceptions.RAW_CONTACT_ID2 + " IN (" + rawContactIdSet2 + ")" +
+ " AND " + AggregationExceptions.TYPE + "=" +
+ AggregationExceptions.TYPE_KEEP_TOGETHER ;
+ }
+
+ private boolean isFirstColumnGreaterThanZero(SQLiteDatabase db, String query) {
+ return DatabaseUtils.longForQuery(db, query, null) > 0;
+ }
+
+ /**
+ * If there's any identity, email address or a phone number matching between two raw contact
+ * sets.
+ */
+ private boolean isDataMaching(SQLiteDatabase db, Set<Long> rawContactIdSet1,
+ Set<Long> rawContactIdSet2) {
+ final String rawContactIds1 = TextUtils.join(",", rawContactIdSet1);
+ final String rawContactIds2 = TextUtils.join(",", rawContactIdSet2);
+ // First, check for the identity
+ if (isFirstColumnGreaterThanZero(db, buildIdentityMatchingSql(
+ rawContactIds1, rawContactIds2, /* isIdentityMatching =*/ true,
+ /* countOnly =*/true))) {
+ if (VERBOSE_LOGGING) {
+ Log.v(TAG, "canJoinIntoContact: identity match found between " + rawContactIds1 +
+ " and " + rawContactIds2);
+ }
+ return true;
+ }
+
+ // Next, check for the email address.
+ if (isFirstColumnGreaterThanZero(db,
+ buildEmailMatchingSql(rawContactIds1, rawContactIds2, true))) {
+ if (VERBOSE_LOGGING) {
+ Log.v(TAG, "canJoinIntoContact: email match found between " + rawContactIds1 +
+ " and " + rawContactIds2);
+ }
+ return true;
+ }
+
+ // Lastly, the phone number.
+ if (isFirstColumnGreaterThanZero(db,
+ buildPhoneMatchingSql(rawContactIds1, rawContactIds2, true))) {
+ if (VERBOSE_LOGGING) {
+ Log.v(TAG, "canJoinIntoContact: phone match found between " + rawContactIds1 +
+ " and " + rawContactIds2);
+ }
+ return true;
+ }
+ return false;
+ }
+
+ /**
+ * Re-aggregate rawContact of {@code rawContactId} and all the raw contacts of
+ * {@code existingRawContactIds} into connected components. This only happens when a given
+ * raw contacts cannot be joined with its best matching contacts directly.
+ *
+ * Two raw contacts are considered connected if they share at least one email address, phone
+ * number or identity. Create new contact for each connected component except the very first
+ * one that doesn't contain rawContactId of {@code rawContactId}.
+ */
+ private void reAggregateRawContacts(TransactionContext txContext, SQLiteDatabase db,
+ long contactId, long currentContactId, long rawContactId,
+ Set<Long> existingRawContactIds) {
+ // Find the connected component based on the aggregation exceptions or
+ // identity/email/phone matching for all the raw contacts of [contactId] and the give
+ // raw contact.
+ final Set<Long> allIds = new HashSet<Long>();
+ allIds.add(rawContactId);
+ allIds.addAll(existingRawContactIds);
+ final Set<Set<Long>> connectedRawContactSets = findConnectedRawContacts(db, allIds);
+
+ if (connectedRawContactSets.size() == 1) {
+ // If everything is connected, create one contact with [contactId]
+ createContactForRawContacts(db, txContext, connectedRawContactSets.iterator().next(),
+ contactId);
+ } else {
+ for (Set<Long> connectedRawContactIds : connectedRawContactSets) {
+ if (connectedRawContactIds.contains(rawContactId)) {
+ // crate contact for connect component containing [rawContactId], reuse
+ // [currentContactId] if possible.
+ createContactForRawContacts(db, txContext, connectedRawContactIds,
+ currentContactId == 0 ? null : currentContactId);
+ connectedRawContactSets.remove(connectedRawContactIds);
+ break;
+ }
+ }
+ // Create new contact for each connected component except the last one. The last one
+ // will reuse [contactId]. Only the last one can reuse [contactId] when all other raw
+ // contacts has already been assigned new contact Id, so that the contact aggregation
+ // stats could be updated correctly.
+ int index = connectedRawContactSets.size();
+ for (Set<Long> connectedRawContactIds : connectedRawContactSets) {
+ if (index > 1) {
+ createContactForRawContacts(db, txContext, connectedRawContactIds, null);
+ index--;
+ } else {
+ createContactForRawContacts(db, txContext, connectedRawContactIds, contactId);
+ }
+ }
+ }
+ }
+
+ /**
+ * Partition the given raw contact Ids to connected component based on aggregation exception,
+ * identity matching, email matching or phone matching.
+ */
+ private Set<Set<Long>> findConnectedRawContacts(SQLiteDatabase db, Set<Long> rawContactIdSet) {
+ // Connections between two raw contacts
+ final Multimap<Long, Long> matchingRawIdPairs = HashMultimap.create();
+ String rawContactIds = TextUtils.join(",", rawContactIdSet);
+ findIdPairs(db, buildExceptionMatchingSql(rawContactIds, rawContactIds),
+ matchingRawIdPairs);
+ findIdPairs(db, buildIdentityMatchingSql(rawContactIds, rawContactIds,
+ /* isIdentityMatching =*/ true, /* countOnly =*/false), matchingRawIdPairs);
+ findIdPairs(db, buildEmailMatchingSql(rawContactIds, rawContactIds, /* countOnly =*/false),
+ matchingRawIdPairs);
+ findIdPairs(db, buildPhoneMatchingSql(rawContactIds, rawContactIds, /* countOnly =*/false),
+ matchingRawIdPairs);
+
+ return ContactAggregatorHelper.findConnectedComponents(rawContactIdSet, matchingRawIdPairs);
+ }
+
+ /**
+ * Given a query which will return two non-null IDs in the first two columns as results, this
+ * method will put two entries into the given result map for each pair of different IDs, one
+ * keyed by each ID.
+ */
+ private void findIdPairs(SQLiteDatabase db, String query, Multimap<Long, Long> results) {
+ Cursor cursor = db.rawQuery(query, null);
+ try {
+ cursor.moveToPosition(-1);
+ while (cursor.moveToNext()) {
+ long idA = cursor.getLong(0);
+ long idB = cursor.getLong(1);
+ if (idA != idB) {
+ results.put(idA, idB);
+ results.put(idB, idA);
+ }
+ }
+ } finally {
+ cursor.close();
+ }
+ }
+
+ /**
+ * Creates a new Contact for a given set of the raw contacts of {@code rawContactIds} if the
+ * given contactId is null. Otherwise, regroup them into contact with {@code contactId}.
+ */
+ private void createContactForRawContacts(SQLiteDatabase db, TransactionContext txContext,
+ Set<Long> rawContactIds, Long contactId) {
+ if (rawContactIds.isEmpty()) {
+ // No raw contact id is provided.
+ return;
+ }
+
+ // If contactId is not provided, generates a new one.
+ if (contactId == null) {
+ mSelectionArgs1[0]= String.valueOf(rawContactIds.iterator().next());
+ computeAggregateData(db, mRawContactsQueryByRawContactId, mSelectionArgs1,
+ mContactInsert);
+ contactId = mContactInsert.executeInsert();
+ }
+ for (Long rawContactId : rawContactIds) {
+ // Regrouped contacts should automatically be unpinned.
+ unpinRawContact(rawContactId);
+ setContactIdAndMarkAggregated(rawContactId, contactId);
+ setPresenceContactId(rawContactId, contactId);
+ }
+ updateAggregateData(txContext, contactId);
+ }
+
+ private static class RawContactIdQuery {
+ public static final String TABLE = Tables.RAW_CONTACTS;
+ public static final String[] COLUMNS = { RawContacts._ID };
+ public static final String SELECTION = RawContacts.CONTACT_ID + "=?";
+ public static final int RAW_CONTACT_ID = 0;
+ }
+
+ /**
+ * Ensures that automatic aggregation rules are followed after a contact
+ * becomes visible or invisible. Specifically, consider this case: there are
+ * three contacts named Foo. Two of them come from account A1 and one comes
+ * from account A2. The aggregation rules say that in this case none of the
+ * three Foo's should be aggregated: two of them are in the same account, so
+ * they don't get aggregated; the third has two affinities, so it does not
+ * join either of them.
+ * <p>
+ * Consider what happens if one of the "Foo"s from account A1 becomes
+ * invisible. Nothing stands in the way of aggregating the other two
+ * anymore, so they should get joined.
+ * <p>
+ * What if the invisible "Foo" becomes visible after that? We should split the
+ * aggregate between the other two.
+ */
+ public void updateAggregationAfterVisibilityChange(long contactId) {
+ SQLiteDatabase db = mDbHelper.getWritableDatabase();
+ boolean visible = mDbHelper.isContactInDefaultDirectory(db, contactId);
+ if (visible) {
+ markContactForAggregation(db, contactId);
+ } else {
+ // Find all contacts that _could be_ aggregated with this one and
+ // rerun aggregation for all of them
+ mSelectionArgs1[0] = String.valueOf(contactId);
+ Cursor cursor = db.query(RawContactIdQuery.TABLE, RawContactIdQuery.COLUMNS,
+ RawContactIdQuery.SELECTION, mSelectionArgs1, null, null, null);
+ try {
+ while (cursor.moveToNext()) {
+ long rawContactId = cursor.getLong(RawContactIdQuery.RAW_CONTACT_ID);
+ mMatcher.clear();
+
+ updateMatchScoresBasedOnIdentityMatch(db, rawContactId, mMatcher);
+ updateMatchScoresBasedOnNameMatches(db, rawContactId, mMatcher);
+ List<MatchScore> bestMatches =
+ mMatcher.pickBestMatches(ContactMatcher.SCORE_THRESHOLD_PRIMARY);
+ for (MatchScore matchScore : bestMatches) {
+ markContactForAggregation(db, matchScore.getContactId());
+ }
+
+ mMatcher.clear();
+ updateMatchScoresBasedOnEmailMatches(db, rawContactId, mMatcher);
+ updateMatchScoresBasedOnPhoneMatches(db, rawContactId, mMatcher);
+ bestMatches =
+ mMatcher.pickBestMatches(ContactMatcher.SCORE_THRESHOLD_SECONDARY);
+ for (MatchScore matchScore : bestMatches) {
+ markContactForAggregation(db, matchScore.getContactId());
+ }
+ }
+ } finally {
+ cursor.close();
+ }
+ }
+ }
+
+ /**
+ * Updates the contact ID for the specified contact.
+ */
+ protected void setContactId(long rawContactId, long contactId) {
+ mContactIdUpdate.bindLong(1, contactId);
+ mContactIdUpdate.bindLong(2, rawContactId);
+ mContactIdUpdate.execute();
+ }
+
+ /**
+ * Marks the specified raw contact ID as aggregated
+ */
+ private void markAggregated(long rawContactId) {
+ mMarkAggregatedUpdate.bindLong(1, rawContactId);
+ mMarkAggregatedUpdate.execute();
+ }
+
+ /**
+ * Updates the contact ID for the specified contact and marks the raw contact as aggregated.
+ */
+ private void setContactIdAndMarkAggregated(long rawContactId, long contactId) {
+ mContactIdAndMarkAggregatedUpdate.bindLong(1, contactId);
+ mContactIdAndMarkAggregatedUpdate.bindLong(2, rawContactId);
+ mContactIdAndMarkAggregatedUpdate.execute();
+ }
+
+ private void setPresenceContactId(long rawContactId, long contactId) {
+ mPresenceContactIdUpdate.bindLong(1, contactId);
+ mPresenceContactIdUpdate.bindLong(2, rawContactId);
+ mPresenceContactIdUpdate.execute();
+ }
+
+ private void unpinRawContact(long rawContactId) {
+ mResetPinnedForRawContact.bindLong(1, rawContactId);
+ mResetPinnedForRawContact.execute();
+ }
+
+ interface AggregateExceptionPrefetchQuery {
+ String TABLE = Tables.AGGREGATION_EXCEPTIONS;
+
+ String[] COLUMNS = {
+ AggregationExceptions.RAW_CONTACT_ID1,
+ AggregationExceptions.RAW_CONTACT_ID2,
+ };
+
+ int RAW_CONTACT_ID1 = 0;
+ int RAW_CONTACT_ID2 = 1;
+ }
+
+ // A set of raw contact IDs for which there are aggregation exceptions
+ private final HashSet<Long> mAggregationExceptionIds = new HashSet<Long>();
+ private boolean mAggregationExceptionIdsValid;
+
+ public void invalidateAggregationExceptionCache() {
+ mAggregationExceptionIdsValid = false;
+ }
+
+ /**
+ * Finds all raw contact IDs for which there are aggregation exceptions. The list of
+ * ids is used as an optimization in aggregation: there is no point to run a query against
+ * the agg_exceptions table if it is known that there are no records there for a given
+ * raw contact ID.
+ */
+ private void prefetchAggregationExceptionIds(SQLiteDatabase db) {
+ mAggregationExceptionIds.clear();
+ final Cursor c = db.query(AggregateExceptionPrefetchQuery.TABLE,
+ AggregateExceptionPrefetchQuery.COLUMNS,
+ null, null, null, null, null);
+
+ try {
+ while (c.moveToNext()) {
+ long rawContactId1 = c.getLong(AggregateExceptionPrefetchQuery.RAW_CONTACT_ID1);
+ long rawContactId2 = c.getLong(AggregateExceptionPrefetchQuery.RAW_CONTACT_ID2);
+ mAggregationExceptionIds.add(rawContactId1);
+ mAggregationExceptionIds.add(rawContactId2);
+ }
+ } finally {
+ c.close();
+ }
+
+ mAggregationExceptionIdsValid = true;
+ }
+
+ interface AggregateExceptionQuery {
+ String TABLE = Tables.AGGREGATION_EXCEPTIONS
+ + " JOIN raw_contacts raw_contacts1 "
+ + " ON (agg_exceptions.raw_contact_id1 = raw_contacts1._id) "
+ + " JOIN raw_contacts raw_contacts2 "
+ + " ON (agg_exceptions.raw_contact_id2 = raw_contacts2._id) ";
+
+ String[] COLUMNS = {
+ AggregationExceptions.TYPE,
+ AggregationExceptions.RAW_CONTACT_ID1,
+ "raw_contacts1." + RawContacts.CONTACT_ID,
+ "raw_contacts1." + RawContactsColumns.AGGREGATION_NEEDED,
+ "raw_contacts2." + RawContacts.CONTACT_ID,
+ "raw_contacts2." + RawContactsColumns.AGGREGATION_NEEDED,
+ };
+
+ int TYPE = 0;
+ int RAW_CONTACT_ID1 = 1;
+ int CONTACT_ID1 = 2;
+ int AGGREGATION_NEEDED_1 = 3;
+ int CONTACT_ID2 = 4;
+ int AGGREGATION_NEEDED_2 = 5;
+ }
+
+ /**
+ * 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) {
+ if (!mAggregationExceptionIdsValid) {
+ prefetchAggregationExceptionIds(db);
+ }
+
+ // If there are no aggregation exceptions involving this raw contact, there is no need to
+ // run a query and we can just return -1, which stands for "nothing found"
+ if (!mAggregationExceptionIds.contains(rawContactId)) {
+ return -1;
+ }
+
+ final Cursor c = db.query(AggregateExceptionQuery.TABLE,
+ AggregateExceptionQuery.COLUMNS,
+ AggregationExceptions.RAW_CONTACT_ID1 + "=" + rawContactId
+ + " OR " + AggregationExceptions.RAW_CONTACT_ID2 + "=" + rawContactId,
+ null, null, null, null);
+
+ try {
+ while (c.moveToNext()) {
+ int type = c.getInt(AggregateExceptionQuery.TYPE);
+ long rawContactId1 = c.getLong(AggregateExceptionQuery.RAW_CONTACT_ID1);
+ long contactId = -1;
+ if (rawContactId == rawContactId1) {
+ if (c.getInt(AggregateExceptionQuery.AGGREGATION_NEEDED_2) == 0
+ && !c.isNull(AggregateExceptionQuery.CONTACT_ID2)) {
+ contactId = c.getLong(AggregateExceptionQuery.CONTACT_ID2);
+ }
+ } else {
+ if (c.getInt(AggregateExceptionQuery.AGGREGATION_NEEDED_1) == 0
+ && !c.isNull(AggregateExceptionQuery.CONTACT_ID1)) {
+ contactId = c.getLong(AggregateExceptionQuery.CONTACT_ID1);
+ }
+ }
+ if (contactId != -1) {
+ if (type == AggregationExceptions.TYPE_KEEP_TOGETHER) {
+ matcher.keepIn(contactId);
+ } else {
+ matcher.keepOut(contactId);
+ }
+ }
+ }
+ } finally {
+ c.close();
+ }
+
+ return matcher.pickBestMatch(ContactMatcher.MAX_SCORE, true);
+ }
+
+ /**
+ * 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) {
+
+ // Find good matches based on name alone
+ long bestMatch = updateMatchScoresBasedOnDataMatches(db, rawContactId, matcher);
+ if (bestMatch == ContactMatcher.MULTIPLE_MATCHES) {
+ // We found multiple matches on the name - do not aggregate because of the ambiguity
+ return -1;
+ } else 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, rawContactId, candidates, matcher);
+ if (bestMatch == ContactMatcher.MULTIPLE_MATCHES) {
+ return -1;
+ }
+ }
+
+ 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,
+ long rawContactId, MatchCandidateList candidates, ContactMatcher matcher) {
+ List<Long> secondaryContactIds = matcher.prepareSecondaryMatchCandidates(
+ ContactMatcher.SCORE_THRESHOLD_PRIMARY);
+ if (secondaryContactIds == null || secondaryContactIds.size() > SECONDARY_HIT_LIMIT) {
+ return -1;
+ }
+
+ loadNameMatchCandidates(db, rawContactId, candidates, true);
+
+ mSb.setLength(0);
+ mSb.append(RawContacts.CONTACT_ID).append(" IN (");
+ for (int i = 0; i < secondaryContactIds.size(); i++) {
+ if (i != 0) {
+ mSb.append(',');
+ }
+ mSb.append(secondaryContactIds.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.
+ mSb.append(") AND " + STRUCTURED_NAME_BASED_LOOKUP_SQL);
+
+ matchAllCandidates(db, mSb.toString(), candidates, matcher,
+ ContactMatcher.MATCHING_ALGORITHM_CONSERVATIVE, null);
+
+ return matcher.pickBestMatch(ContactMatcher.SCORE_THRESHOLD_SECONDARY, false);
+ }
+
+ private interface NameLookupQuery {
+ String TABLE = Tables.NAME_LOOKUP;
+
+ String SELECTION = NameLookupColumns.RAW_CONTACT_ID + "=?";
+ String SELECTION_STRUCTURED_NAME_BASED =
+ SELECTION + " AND " + STRUCTURED_NAME_BASED_LOOKUP_SQL;
+
+ String[] COLUMNS = new String[] {
+ NameLookupColumns.NORMALIZED_NAME,
+ NameLookupColumns.NAME_TYPE
+ };
+
+ int NORMALIZED_NAME = 0;
+ int NAME_TYPE = 1;
+ }
+
+ private void loadNameMatchCandidates(SQLiteDatabase db, long rawContactId,
+ MatchCandidateList candidates, boolean structuredNameBased) {
+ candidates.clear();
+ mSelectionArgs1[0] = String.valueOf(rawContactId);
+ Cursor c = db.query(NameLookupQuery.TABLE, NameLookupQuery.COLUMNS,
+ structuredNameBased
+ ? NameLookupQuery.SELECTION_STRUCTURED_NAME_BASED
+ : NameLookupQuery.SELECTION,
+ mSelectionArgs1, null, null, null);
+ try {
+ while (c.moveToNext()) {
+ String normalizedName = c.getString(NameLookupQuery.NORMALIZED_NAME);
+ int type = c.getInt(NameLookupQuery.NAME_TYPE);
+ candidates.add(normalizedName, type);
+ }
+ } finally {
+ c.close();
+ }
+ }
+
+ /**
+ * Computes scores for contacts that have matching data rows.
+ */
+ private long updateMatchScoresBasedOnDataMatches(SQLiteDatabase db, long rawContactId,
+ ContactMatcher matcher) {
+
+ updateMatchScoresBasedOnIdentityMatch(db, rawContactId, matcher);
+ updateMatchScoresBasedOnNameMatches(db, rawContactId, matcher);
+ long bestMatch = matcher.pickBestMatch(ContactMatcher.SCORE_THRESHOLD_PRIMARY, false);
+ if (bestMatch != -1) {
+ return bestMatch;
+ }
+
+ updateMatchScoresBasedOnEmailMatches(db, rawContactId, matcher);
+ updateMatchScoresBasedOnPhoneMatches(db, rawContactId, matcher);
+
+ return -1;
+ }
+
+ private interface IdentityLookupMatchQuery {
+ final String TABLE = Tables.DATA + " dataA"
+ + " JOIN " + Tables.DATA + " dataB" +
+ " ON (dataA." + Identity.NAMESPACE + "=dataB." + Identity.NAMESPACE +
+ " AND dataA." + Identity.IDENTITY + "=dataB." + Identity.IDENTITY + ")"
+ + " JOIN " + Tables.RAW_CONTACTS +
+ " ON (dataB." + Data.RAW_CONTACT_ID + " = "
+ + Tables.RAW_CONTACTS + "." + RawContacts._ID + ")";
+
+ final String SELECTION = "dataA." + Data.RAW_CONTACT_ID + "=?1"
+ + " AND dataA." + DataColumns.MIMETYPE_ID + "=?2"
+ + " AND dataA." + Identity.NAMESPACE + " NOT NULL"
+ + " AND dataA." + Identity.IDENTITY + " NOT NULL"
+ + " AND dataB." + DataColumns.MIMETYPE_ID + "=?2"
+ + " AND " + RawContactsColumns.AGGREGATION_NEEDED + "=0"
+ + " AND " + RawContacts.CONTACT_ID + " IN " + Tables.DEFAULT_DIRECTORY;
+
+ final String[] COLUMNS = new String[] {
+ RawContacts.CONTACT_ID
+ };
+
+ int CONTACT_ID = 0;
+ }
+
+ /**
+ * Finds contacts with exact identity matches to the the specified raw contact.
+ */
+ private void updateMatchScoresBasedOnIdentityMatch(SQLiteDatabase db, long rawContactId,
+ ContactMatcher matcher) {
+ mSelectionArgs2[0] = String.valueOf(rawContactId);
+ mSelectionArgs2[1] = String.valueOf(mMimeTypeIdIdentity);
+ Cursor c = db.query(IdentityLookupMatchQuery.TABLE, IdentityLookupMatchQuery.COLUMNS,
+ IdentityLookupMatchQuery.SELECTION,
+ mSelectionArgs2, RawContacts.CONTACT_ID, null, null);
+ try {
+ while (c.moveToNext()) {
+ final long contactId = c.getLong(IdentityLookupMatchQuery.CONTACT_ID);
+ matcher.matchIdentity(contactId);
+ }
+ } finally {
+ c.close();
+ }
+
+ }
+
+ private interface NameLookupMatchQuery {
+ String TABLE = Tables.NAME_LOOKUP + " nameA"
+ + " JOIN " + Tables.NAME_LOOKUP + " nameB" +
+ " ON (" + "nameA." + NameLookupColumns.NORMALIZED_NAME + "="
+ + "nameB." + NameLookupColumns.NORMALIZED_NAME + ")"
+ + " JOIN " + Tables.RAW_CONTACTS +
+ " ON (nameB." + NameLookupColumns.RAW_CONTACT_ID + " = "
+ + Tables.RAW_CONTACTS + "." + RawContacts._ID + ")";
+
+ String SELECTION = "nameA." + NameLookupColumns.RAW_CONTACT_ID + "=?"
+ + " AND " + RawContactsColumns.AGGREGATION_NEEDED + "=0"
+ + " AND " + RawContacts.CONTACT_ID + " IN " + Tables.DEFAULT_DIRECTORY;
+
+ String[] COLUMNS = new String[] {
+ RawContacts.CONTACT_ID,
+ "nameA." + NameLookupColumns.NORMALIZED_NAME,
+ "nameA." + NameLookupColumns.NAME_TYPE,
+ "nameB." + NameLookupColumns.NAME_TYPE,
+ };
+
+ int CONTACT_ID = 0;
+ int NAME = 1;
+ int NAME_TYPE_A = 2;
+ int NAME_TYPE_B = 3;
+ }
+
+ /**
+ * Finds contacts with names matching the name of the specified raw contact.
+ */
+ private void updateMatchScoresBasedOnNameMatches(SQLiteDatabase db, long rawContactId,
+ ContactMatcher matcher) {
+ mSelectionArgs1[0] = String.valueOf(rawContactId);
+ Cursor c = db.query(NameLookupMatchQuery.TABLE, NameLookupMatchQuery.COLUMNS,
+ NameLookupMatchQuery.SELECTION,
+ mSelectionArgs1, null, null, null, PRIMARY_HIT_LIMIT_STRING);
+ try {
+ while (c.moveToNext()) {
+ long contactId = c.getLong(NameLookupMatchQuery.CONTACT_ID);
+ String name = c.getString(NameLookupMatchQuery.NAME);
+ int nameTypeA = c.getInt(NameLookupMatchQuery.NAME_TYPE_A);
+ int nameTypeB = c.getInt(NameLookupMatchQuery.NAME_TYPE_B);
+ matcher.matchName(contactId, nameTypeA, name,
+ nameTypeB, name, ContactMatcher.MATCHING_ALGORITHM_EXACT);
+ if (nameTypeA == NameLookupType.NICKNAME &&
+ nameTypeB == NameLookupType.NICKNAME) {
+ matcher.updateScoreWithNicknameMatch(contactId);
+ }
+ }
+ } finally {
+ c.close();
+ }
+ }
+
+ private interface NameLookupMatchQueryWithParameter {
+ String TABLE = Tables.NAME_LOOKUP
+ + " JOIN " + Tables.RAW_CONTACTS +
+ " ON (" + NameLookupColumns.RAW_CONTACT_ID + " = "
+ + Tables.RAW_CONTACTS + "." + RawContacts._ID + ")";
+
+ String[] COLUMNS = new String[] {
+ RawContacts.CONTACT_ID,
+ NameLookupColumns.NORMALIZED_NAME,
+ NameLookupColumns.NAME_TYPE,
+ };
+
+ int CONTACT_ID = 0;
+ int NAME = 1;
+ int NAME_TYPE = 2;
+ }
+
+ private final class NameLookupSelectionBuilder extends NameLookupBuilder {
+
+ private final MatchCandidateList mNameLookupCandidates;
+
+ private StringBuilder mSelection = new StringBuilder(
+ NameLookupColumns.NORMALIZED_NAME + " IN(");
+
+
+ public NameLookupSelectionBuilder(NameSplitter splitter, MatchCandidateList candidates) {
+ super(splitter);
+ this.mNameLookupCandidates = candidates;
+ }
+
+ @Override
+ protected String[] getCommonNicknameClusters(String normalizedName) {
+ return mCommonNicknameCache.getCommonNicknameClusters(normalizedName);
+ }
+
+ @Override
+ protected void insertNameLookup(
+ long rawContactId, long dataId, int lookupType, String string) {
+ mNameLookupCandidates.add(string, lookupType);
+ DatabaseUtils.appendEscapedSQLString(mSelection, string);
+ mSelection.append(',');
+ }
+
+ public boolean isEmpty() {
+ return mNameLookupCandidates.isEmpty();
+ }
+
+ public String getSelection() {
+ mSelection.setLength(mSelection.length() - 1); // Strip last comma
+ mSelection.append(')');
+ return mSelection.toString();
+ }
+
+ public int getLookupType(String name) {
+ for (int i = 0; i < mNameLookupCandidates.mCount; i++) {
+ if (mNameLookupCandidates.mList.get(i).mName.equals(name)) {
+ return mNameLookupCandidates.mList.get(i).mLookupType;
+ }
+ }
+ throw new IllegalStateException();
+ }
+ }
+
+ /**
+ * Finds contacts with names matching the specified name.
+ */
+ private void updateMatchScoresBasedOnNameMatches(SQLiteDatabase db, String query,
+ MatchCandidateList candidates, ContactMatcher matcher) {
+ candidates.clear();
+ NameLookupSelectionBuilder builder = new NameLookupSelectionBuilder(
+ mNameSplitter, candidates);
+ builder.insertNameLookup(0, 0, query, FullNameStyle.UNDEFINED);
+ if (builder.isEmpty()) {
+ return;
+ }
+
+ Cursor c = db.query(NameLookupMatchQueryWithParameter.TABLE,
+ NameLookupMatchQueryWithParameter.COLUMNS, builder.getSelection(), null, null, null,
+ null, PRIMARY_HIT_LIMIT_STRING);
+ try {
+ while (c.moveToNext()) {
+ long contactId = c.getLong(NameLookupMatchQueryWithParameter.CONTACT_ID);
+ String name = c.getString(NameLookupMatchQueryWithParameter.NAME);
+ int nameTypeA = builder.getLookupType(name);
+ int nameTypeB = c.getInt(NameLookupMatchQueryWithParameter.NAME_TYPE);
+ matcher.matchName(contactId, nameTypeA, name, nameTypeB, name,
+ ContactMatcher.MATCHING_ALGORITHM_EXACT);
+ if (nameTypeA == NameLookupType.NICKNAME && nameTypeB == NameLookupType.NICKNAME) {
+ matcher.updateScoreWithNicknameMatch(contactId);
+ }
+ }
+ } finally {
+ c.close();
+ }
+ }
+
+ private interface EmailLookupQuery {
+ String TABLE = Tables.DATA + " dataA"
+ + " JOIN " + Tables.DATA + " dataB" +
+ " ON lower(" + "dataA." + Email.DATA + ")=lower(dataB." + Email.DATA + ")"
+ + " JOIN " + Tables.RAW_CONTACTS +
+ " ON (dataB." + Data.RAW_CONTACT_ID + " = "
+ + Tables.RAW_CONTACTS + "." + RawContacts._ID + ")";
+
+ String SELECTION = "dataA." + Data.RAW_CONTACT_ID + "=?1"
+ + " AND dataA." + DataColumns.MIMETYPE_ID + "=?2"
+ + " AND dataA." + Email.DATA + " NOT NULL"
+ + " AND dataB." + DataColumns.MIMETYPE_ID + "=?2"
+ + " AND " + RawContactsColumns.AGGREGATION_NEEDED + "=0"
+ + " AND " + RawContacts.CONTACT_ID + " IN " + Tables.DEFAULT_DIRECTORY;
+
+ String[] COLUMNS = new String[] {
+ RawContacts.CONTACT_ID
+ };
+
+ int CONTACT_ID = 0;
+ }
+
+ private void updateMatchScoresBasedOnEmailMatches(SQLiteDatabase db, long rawContactId,
+ ContactMatcher matcher) {
+ mSelectionArgs2[0] = String.valueOf(rawContactId);
+ mSelectionArgs2[1] = String.valueOf(mMimeTypeIdEmail);
+ Cursor c = db.query(EmailLookupQuery.TABLE, EmailLookupQuery.COLUMNS,
+ EmailLookupQuery.SELECTION,
+ mSelectionArgs2, null, null, null, SECONDARY_HIT_LIMIT_STRING);
+ try {
+ while (c.moveToNext()) {
+ long contactId = c.getLong(EmailLookupQuery.CONTACT_ID);
+ matcher.updateScoreWithEmailMatch(contactId);
+ }
+ } finally {
+ c.close();
+ }
+ }
+
+ private interface PhoneLookupQuery {
+ String TABLE = Tables.PHONE_LOOKUP + " phoneA"
+ + " JOIN " + Tables.DATA + " dataA"
+ + " ON (dataA." + Data._ID + "=phoneA." + PhoneLookupColumns.DATA_ID + ")"
+ + " JOIN " + Tables.PHONE_LOOKUP + " phoneB"
+ + " ON (phoneA." + PhoneLookupColumns.MIN_MATCH + "="
+ + "phoneB." + PhoneLookupColumns.MIN_MATCH + ")"
+ + " JOIN " + Tables.DATA + " dataB"
+ + " ON (dataB." + Data._ID + "=phoneB." + PhoneLookupColumns.DATA_ID + ")"
+ + " JOIN " + Tables.RAW_CONTACTS
+ + " ON (dataB." + Data.RAW_CONTACT_ID + " = "
+ + Tables.RAW_CONTACTS + "." + RawContacts._ID + ")";
+
+ String SELECTION = "dataA." + Data.RAW_CONTACT_ID + "=?"
+ + " AND PHONE_NUMBERS_EQUAL(dataA." + Phone.NUMBER + ", "
+ + "dataB." + Phone.NUMBER + ",?)"
+ + " AND " + RawContactsColumns.AGGREGATION_NEEDED + "=0"
+ + " AND " + RawContacts.CONTACT_ID + " IN " + Tables.DEFAULT_DIRECTORY;
+
+ String[] COLUMNS = new String[] {
+ RawContacts.CONTACT_ID
+ };
+
+ int CONTACT_ID = 0;
+ }
+
+ private void updateMatchScoresBasedOnPhoneMatches(SQLiteDatabase db, long rawContactId,
+ ContactMatcher matcher) {
+ mSelectionArgs2[0] = String.valueOf(rawContactId);
+ mSelectionArgs2[1] = mDbHelper.getUseStrictPhoneNumberComparisonParameter();
+ Cursor c = db.query(PhoneLookupQuery.TABLE, PhoneLookupQuery.COLUMNS,
+ PhoneLookupQuery.SELECTION,
+ mSelectionArgs2, null, null, null, SECONDARY_HIT_LIMIT_STRING);
+ try {
+ while (c.moveToNext()) {
+ long contactId = c.getLong(PhoneLookupQuery.CONTACT_ID);
+ matcher.updateScoreWithPhoneNumberMatch(contactId);
+ }
+ } finally {
+ c.close();
+ }
+ }
+
+ /**
+ * 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 "
+ + "(" + NameLookupColumns.NAME_TYPE + " IN("
+ + NameLookupType.NAME_COLLATION_KEY + ","
+ + NameLookupType.EMAIL_BASED_NICKNAME + ","
+ + NameLookupType.NICKNAME + ")) AND "
+ + RawContacts.CONTACT_ID + " IN " + Tables.DEFAULT_DIRECTORY;
+ matchAllCandidates(db, selection, candidates, matcher,
+ ContactMatcher.MATCHING_ALGORITHM_APPROXIMATE,
+ String.valueOf(FIRST_LETTER_SUGGESTION_HIT_LIMIT));
+ }
+ }
+ }
+ }
+
+ private interface ContactNameLookupQuery {
+ String TABLE = Tables.NAME_LOOKUP_JOIN_RAW_CONTACTS;
+
+ String[] COLUMNS = new String[] {
+ RawContacts.CONTACT_ID,
+ NameLookupColumns.NORMALIZED_NAME,
+ NameLookupColumns.NAME_TYPE
+ };
+
+ int CONTACT_ID = 0;
+ int NORMALIZED_NAME = 1;
+ int NAME_TYPE = 2;
+ }
+
+ /**
+ * 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, int algorithm, String limit) {
+ final Cursor c = db.query(ContactNameLookupQuery.TABLE, ContactNameLookupQuery.COLUMNS,
+ selection, null, null, null, null, limit);
+
+ try {
+ while (c.moveToNext()) {
+ Long contactId = c.getLong(ContactNameLookupQuery.CONTACT_ID);
+ String name = c.getString(ContactNameLookupQuery.NORMALIZED_NAME);
+ int nameType = c.getInt(ContactNameLookupQuery.NAME_TYPE);
+
+ // 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);
+ matcher.matchName(contactId, candidate.mLookupType, candidate.mName,
+ nameType, name, algorithm);
+ }
+ }
+ } finally {
+ c.close();
+ }
+ }
+
+ private interface RawContactsQuery {
+ String SQL_FORMAT_HAS_SUPER_PRIMARY_NAME =
+ " EXISTS(SELECT 1 " +
+ " FROM " + Tables.DATA + " d " +
+ " WHERE d." + DataColumns.MIMETYPE_ID + "=%d " +
+ " AND d." + Data.RAW_CONTACT_ID + "=" + RawContactsColumns.CONCRETE_ID +
+ " AND d." + Data.IS_SUPER_PRIMARY + "=1)";
+
+ String SQL_FORMAT =
+ "SELECT "
+ + RawContactsColumns.CONCRETE_ID + ","
+ + RawContactsColumns.DISPLAY_NAME + ","
+ + RawContactsColumns.DISPLAY_NAME_SOURCE + ","
+ + AccountsColumns.CONCRETE_ACCOUNT_TYPE + ","
+ + AccountsColumns.CONCRETE_ACCOUNT_NAME + ","
+ + AccountsColumns.CONCRETE_DATA_SET + ","
+ + RawContacts.SOURCE_ID + ","
+ + RawContacts.CUSTOM_RINGTONE + ","
+ + RawContacts.SEND_TO_VOICEMAIL + ","
+ + RawContacts.LAST_TIME_CONTACTED + ","
+ + RawContacts.TIMES_CONTACTED + ","
+ + RawContacts.STARRED + ","
+ + RawContacts.PINNED + ","
+ + DataColumns.CONCRETE_ID + ","
+ + DataColumns.CONCRETE_MIMETYPE_ID + ","
+ + Data.IS_SUPER_PRIMARY + ","
+ + Photo.PHOTO_FILE_ID + ","
+ + SQL_FORMAT_HAS_SUPER_PRIMARY_NAME +
+ " FROM " + Tables.RAW_CONTACTS +
+ " JOIN " + Tables.ACCOUNTS + " ON ("
+ + AccountsColumns.CONCRETE_ID + "=" + RawContactsColumns.CONCRETE_ACCOUNT_ID
+ + ")" +
+ " LEFT OUTER JOIN " + Tables.DATA +
+ " ON (" + DataColumns.CONCRETE_RAW_CONTACT_ID + "=" + RawContactsColumns.CONCRETE_ID
+ + " AND ((" + DataColumns.MIMETYPE_ID + "=%d"
+ + " AND " + Photo.PHOTO + " NOT NULL)"
+ + " OR (" + DataColumns.MIMETYPE_ID + "=%d"
+ + " AND " + Phone.NUMBER + " NOT NULL)))";
+
+ String SQL_FORMAT_BY_RAW_CONTACT_ID = SQL_FORMAT +
+ " WHERE " + RawContactsColumns.CONCRETE_ID + "=?";
+
+ String SQL_FORMAT_BY_CONTACT_ID = SQL_FORMAT +
+ " WHERE " + RawContacts.CONTACT_ID + "=?"
+ + " AND " + RawContacts.DELETED + "=0";
+
+ int RAW_CONTACT_ID = 0;
+ int DISPLAY_NAME = 1;
+ int DISPLAY_NAME_SOURCE = 2;
+ int ACCOUNT_TYPE = 3;
+ int ACCOUNT_NAME = 4;
+ int DATA_SET = 5;
+ int SOURCE_ID = 6;
+ int CUSTOM_RINGTONE = 7;
+ int SEND_TO_VOICEMAIL = 8;
+ int LAST_TIME_CONTACTED = 9;
+ int TIMES_CONTACTED = 10;
+ int STARRED = 11;
+ int PINNED = 12;
+ int DATA_ID = 13;
+ int MIMETYPE_ID = 14;
+ int IS_SUPER_PRIMARY = 15;
+ int PHOTO_FILE_ID = 16;
+ int HAS_SUPER_PRIMARY_NAME = 17;
+ }
+
+ private interface ContactReplaceSqlStatement {
+ String UPDATE_SQL =
+ "UPDATE " + Tables.CONTACTS +
+ " SET "
+ + Contacts.NAME_RAW_CONTACT_ID + "=?, "
+ + Contacts.PHOTO_ID + "=?, "
+ + Contacts.PHOTO_FILE_ID + "=?, "
+ + Contacts.SEND_TO_VOICEMAIL + "=?, "
+ + Contacts.CUSTOM_RINGTONE + "=?, "
+ + Contacts.LAST_TIME_CONTACTED + "=?, "
+ + Contacts.TIMES_CONTACTED + "=?, "
+ + Contacts.STARRED + "=?, "
+ + Contacts.PINNED + "=?, "
+ + Contacts.HAS_PHONE_NUMBER + "=?, "
+ + Contacts.LOOKUP_KEY + "=?, "
+ + Contacts.CONTACT_LAST_UPDATED_TIMESTAMP + "=? " +
+ " WHERE " + Contacts._ID + "=?";
+
+ String INSERT_SQL =
+ "INSERT INTO " + Tables.CONTACTS + " ("
+ + Contacts.NAME_RAW_CONTACT_ID + ", "
+ + Contacts.PHOTO_ID + ", "
+ + Contacts.PHOTO_FILE_ID + ", "
+ + Contacts.SEND_TO_VOICEMAIL + ", "
+ + Contacts.CUSTOM_RINGTONE + ", "
+ + Contacts.LAST_TIME_CONTACTED + ", "
+ + Contacts.TIMES_CONTACTED + ", "
+ + Contacts.STARRED + ", "
+ + Contacts.PINNED + ", "
+ + Contacts.HAS_PHONE_NUMBER + ", "
+ + Contacts.LOOKUP_KEY + ", "
+ + Contacts.CONTACT_LAST_UPDATED_TIMESTAMP
+ + ") " +
+ " VALUES (?,?,?,?,?,?,?,?,?,?,?,?)";
+
+ int NAME_RAW_CONTACT_ID = 1;
+ int PHOTO_ID = 2;
+ int PHOTO_FILE_ID = 3;
+ int SEND_TO_VOICEMAIL = 4;
+ int CUSTOM_RINGTONE = 5;
+ int LAST_TIME_CONTACTED = 6;
+ int TIMES_CONTACTED = 7;
+ int STARRED = 8;
+ int PINNED = 9;
+ int HAS_PHONE_NUMBER = 10;
+ int LOOKUP_KEY = 11;
+ int CONTACT_LAST_UPDATED_TIMESTAMP = 12;
+ int CONTACT_ID = 13;
+ }
+
+ /**
+ * Computes aggregate-level data for the specified aggregate contact ID.
+ */
+ private void computeAggregateData(SQLiteDatabase db, long contactId,
+ SQLiteStatement statement) {
+ mSelectionArgs1[0] = String.valueOf(contactId);
+ computeAggregateData(db, mRawContactsQueryByContactId, mSelectionArgs1, statement);
+ }
+
+ /**
+ * Indicates whether the given photo entry and priority gives this photo a higher overall
+ * priority than the current best photo entry and priority.
+ */
+ private boolean hasHigherPhotoPriority(PhotoEntry photoEntry, int priority,
+ PhotoEntry bestPhotoEntry, int bestPriority) {
+ int photoComparison = photoEntry.compareTo(bestPhotoEntry);
+ return photoComparison < 0 || photoComparison == 0 && priority > bestPriority;
+ }
+
+ /**
+ * Computes aggregate-level data from constituent raw contacts.
+ */
+ private void computeAggregateData(final SQLiteDatabase db, String sql, String[] sqlArgs,
+ SQLiteStatement statement) {
+ long currentRawContactId = -1;
+ long bestPhotoId = -1;
+ long bestPhotoFileId = 0;
+ PhotoEntry bestPhotoEntry = null;
+ boolean foundSuperPrimaryPhoto = false;
+ int photoPriority = -1;
+ int totalRowCount = 0;
+ int contactSendToVoicemail = 0;
+ String contactCustomRingtone = null;
+ long contactLastTimeContacted = 0;
+ int contactTimesContacted = 0;
+ int contactStarred = 0;
+ int contactPinned = Integer.MAX_VALUE;
+ int hasPhoneNumber = 0;
+ StringBuilder lookupKey = new StringBuilder();
+
+ mDisplayNameCandidate.clear();
+
+ Cursor c = db.rawQuery(sql, sqlArgs);
+ try {
+ while (c.moveToNext()) {
+ long rawContactId = c.getLong(RawContactsQuery.RAW_CONTACT_ID);
+ if (rawContactId != currentRawContactId) {
+ currentRawContactId = rawContactId;
+ totalRowCount++;
+
+ // Assemble sub-account.
+ String accountType = c.getString(RawContactsQuery.ACCOUNT_TYPE);
+ String dataSet = c.getString(RawContactsQuery.DATA_SET);
+ String accountWithDataSet = (!TextUtils.isEmpty(dataSet))
+ ? accountType + "/" + dataSet
+ : accountType;
+
+ // Display name
+ String displayName = c.getString(RawContactsQuery.DISPLAY_NAME);
+ int displayNameSource = c.getInt(RawContactsQuery.DISPLAY_NAME_SOURCE);
+ int isNameSuperPrimary = c.getInt(RawContactsQuery.HAS_SUPER_PRIMARY_NAME);
+ processDisplayNameCandidate(rawContactId, displayName, displayNameSource,
+ mContactsProvider.isWritableAccountWithDataSet(accountWithDataSet),
+ isNameSuperPrimary != 0);
+
+ // Contact options
+ if (!c.isNull(RawContactsQuery.SEND_TO_VOICEMAIL)) {
+ boolean sendToVoicemail =
+ (c.getInt(RawContactsQuery.SEND_TO_VOICEMAIL) != 0);
+ if (sendToVoicemail) {
+ contactSendToVoicemail++;
+ }
+ }
+
+ if (contactCustomRingtone == null
+ && !c.isNull(RawContactsQuery.CUSTOM_RINGTONE)) {
+ contactCustomRingtone = c.getString(RawContactsQuery.CUSTOM_RINGTONE);
+ }
+
+ long lastTimeContacted = c.getLong(RawContactsQuery.LAST_TIME_CONTACTED);
+ if (lastTimeContacted > contactLastTimeContacted) {
+ contactLastTimeContacted = lastTimeContacted;
+ }
+
+ int timesContacted = c.getInt(RawContactsQuery.TIMES_CONTACTED);
+ if (timesContacted > contactTimesContacted) {
+ contactTimesContacted = timesContacted;
+ }
+
+ if (c.getInt(RawContactsQuery.STARRED) != 0) {
+ contactStarred = 1;
+ }
+
+ // contactPinned should be the lowest value of its constituent raw contacts,
+ // excluding negative integers
+ final int rawContactPinned = c.getInt(RawContactsQuery.PINNED);
+ if (rawContactPinned > PinnedPositions.UNPINNED) {
+ contactPinned = Math.min(contactPinned, rawContactPinned);
+ }
+
+ appendLookupKey(
+ lookupKey,
+ accountWithDataSet,
+ c.getString(RawContactsQuery.ACCOUNT_NAME),
+ rawContactId,
+ c.getString(RawContactsQuery.SOURCE_ID),
+ displayName);
+ }
+
+ if (!c.isNull(RawContactsQuery.DATA_ID)) {
+ long dataId = c.getLong(RawContactsQuery.DATA_ID);
+ long photoFileId = c.getLong(RawContactsQuery.PHOTO_FILE_ID);
+ int mimetypeId = c.getInt(RawContactsQuery.MIMETYPE_ID);
+ boolean superPrimary = c.getInt(RawContactsQuery.IS_SUPER_PRIMARY) != 0;
+ if (mimetypeId == mMimeTypeIdPhoto) {
+ if (!foundSuperPrimaryPhoto) {
+ // Lookup the metadata for the photo, if available. Note that data set
+ // does not come into play here, since accounts are looked up in the
+ // account manager in the priority resolver.
+ PhotoEntry photoEntry = getPhotoMetadata(db, photoFileId);
+ String accountType = c.getString(RawContactsQuery.ACCOUNT_TYPE);
+ int priority = mPhotoPriorityResolver.getPhotoPriority(accountType);
+ if (superPrimary || hasHigherPhotoPriority(
+ photoEntry, priority, bestPhotoEntry, photoPriority)) {
+ bestPhotoEntry = photoEntry;
+ photoPriority = priority;
+ bestPhotoId = dataId;
+ bestPhotoFileId = photoFileId;
+ foundSuperPrimaryPhoto |= superPrimary;
+ }
+ }
+ } else if (mimetypeId == mMimeTypeIdPhone) {
+ hasPhoneNumber = 1;
+ }
+ }
+ }
+ } finally {
+ c.close();
+ }
+
+ if (contactPinned == Integer.MAX_VALUE) {
+ contactPinned = PinnedPositions.UNPINNED;
+ }
+
+ statement.bindLong(ContactReplaceSqlStatement.NAME_RAW_CONTACT_ID,
+ mDisplayNameCandidate.rawContactId);
+
+ if (bestPhotoId != -1) {
+ statement.bindLong(ContactReplaceSqlStatement.PHOTO_ID, bestPhotoId);
+ } else {
+ statement.bindNull(ContactReplaceSqlStatement.PHOTO_ID);
+ }
+
+ if (bestPhotoFileId != 0) {
+ statement.bindLong(ContactReplaceSqlStatement.PHOTO_FILE_ID, bestPhotoFileId);
+ } else {
+ statement.bindNull(ContactReplaceSqlStatement.PHOTO_FILE_ID);
+ }
+
+ statement.bindLong(ContactReplaceSqlStatement.SEND_TO_VOICEMAIL,
+ totalRowCount == contactSendToVoicemail ? 1 : 0);
+ DatabaseUtils.bindObjectToProgram(statement, ContactReplaceSqlStatement.CUSTOM_RINGTONE,
+ contactCustomRingtone);
+ statement.bindLong(ContactReplaceSqlStatement.LAST_TIME_CONTACTED,
+ contactLastTimeContacted);
+ statement.bindLong(ContactReplaceSqlStatement.TIMES_CONTACTED,
+ contactTimesContacted);
+ statement.bindLong(ContactReplaceSqlStatement.STARRED,
+ contactStarred);
+ statement.bindLong(ContactReplaceSqlStatement.PINNED,
+ contactPinned);
+ statement.bindLong(ContactReplaceSqlStatement.HAS_PHONE_NUMBER,
+ hasPhoneNumber);
+ statement.bindString(ContactReplaceSqlStatement.LOOKUP_KEY,
+ Uri.encode(lookupKey.toString()));
+ statement.bindLong(ContactReplaceSqlStatement.CONTACT_LAST_UPDATED_TIMESTAMP,
+ Clock.getInstance().currentTimeMillis());
+ }
+
+ /**
+ * Builds a lookup key using the given data.
+ */
+ protected void appendLookupKey(StringBuilder sb, String accountTypeWithDataSet,
+ String accountName, long rawContactId, String sourceId, String displayName) {
+ ContactLookupKey.appendToLookupKey(sb, accountTypeWithDataSet, accountName, rawContactId,
+ sourceId, displayName);
+ }
+
+ /**
+ * Uses the supplied values to determine if they represent a "better" display name
+ * for the aggregate contact currently evaluated. If so, it updates
+ * {@link #mDisplayNameCandidate} with the new values.
+ */
+ private void processDisplayNameCandidate(long rawContactId, String displayName,
+ int displayNameSource, boolean writableAccount, boolean isNameSuperPrimary) {
+
+ boolean replace = false;
+ if (mDisplayNameCandidate.rawContactId == -1) {
+ // No previous values available
+ replace = true;
+ } else if (!TextUtils.isEmpty(displayName)) {
+ if (isNameSuperPrimary) {
+ // A super primary name is better than any other name
+ replace = true;
+ } else if (mDisplayNameCandidate.isNameSuperPrimary == isNameSuperPrimary) {
+ if (mDisplayNameCandidate.displayNameSource < displayNameSource) {
+ // New values come from an superior source, e.g. structured name vs phone number
+ replace = true;
+ } else if (mDisplayNameCandidate.displayNameSource == displayNameSource) {
+ if (!mDisplayNameCandidate.writableAccount && writableAccount) {
+ replace = true;
+ } else if (mDisplayNameCandidate.writableAccount == writableAccount) {
+ if (NameNormalizer.compareComplexity(displayName,
+ mDisplayNameCandidate.displayName) > 0) {
+ // New name is more complex than the previously found one
+ replace = true;
+ }
+ }
+ }
+ }
+ }
+
+ if (replace) {
+ mDisplayNameCandidate.rawContactId = rawContactId;
+ mDisplayNameCandidate.displayName = displayName;
+ mDisplayNameCandidate.displayNameSource = displayNameSource;
+ mDisplayNameCandidate.isNameSuperPrimary = isNameSuperPrimary;
+ mDisplayNameCandidate.writableAccount = writableAccount;
+ }
+ }
+
+ private interface PhotoIdQuery {
+ final String[] COLUMNS = new String[] {
+ AccountsColumns.CONCRETE_ACCOUNT_TYPE,
+ DataColumns.CONCRETE_ID,
+ Data.IS_SUPER_PRIMARY,
+ Photo.PHOTO_FILE_ID,
+ };
+
+ int ACCOUNT_TYPE = 0;
+ int DATA_ID = 1;
+ int IS_SUPER_PRIMARY = 2;
+ int PHOTO_FILE_ID = 3;
+ }
+
+ public void updatePhotoId(SQLiteDatabase db, long rawContactId) {
+
+ long contactId = mDbHelper.getContactId(rawContactId);
+ if (contactId == 0) {
+ return;
+ }
+
+ long bestPhotoId = -1;
+ long bestPhotoFileId = 0;
+ int photoPriority = -1;
+
+ long photoMimeType = mDbHelper.getMimeTypeId(Photo.CONTENT_ITEM_TYPE);
+
+ String tables = Tables.RAW_CONTACTS
+ + " JOIN " + Tables.ACCOUNTS + " ON ("
+ + AccountsColumns.CONCRETE_ID + "=" + RawContactsColumns.CONCRETE_ACCOUNT_ID
+ + ")"
+ + " JOIN " + Tables.DATA + " ON("
+ + DataColumns.CONCRETE_RAW_CONTACT_ID + "=" + RawContactsColumns.CONCRETE_ID
+ + " AND (" + DataColumns.MIMETYPE_ID + "=" + photoMimeType + " AND "
+ + Photo.PHOTO + " NOT NULL))";
+
+ mSelectionArgs1[0] = String.valueOf(contactId);
+ final Cursor c = db.query(tables, PhotoIdQuery.COLUMNS,
+ RawContacts.CONTACT_ID + "=?", mSelectionArgs1, null, null, null);
+ try {
+ PhotoEntry bestPhotoEntry = null;
+ while (c.moveToNext()) {
+ long dataId = c.getLong(PhotoIdQuery.DATA_ID);
+ long photoFileId = c.getLong(PhotoIdQuery.PHOTO_FILE_ID);
+ boolean superPrimary = c.getInt(PhotoIdQuery.IS_SUPER_PRIMARY) != 0;
+ PhotoEntry photoEntry = getPhotoMetadata(db, photoFileId);
+
+ // Note that data set does not come into play here, since accounts are looked up in
+ // the account manager in the priority resolver.
+ String accountType = c.getString(PhotoIdQuery.ACCOUNT_TYPE);
+ int priority = mPhotoPriorityResolver.getPhotoPriority(accountType);
+ if (superPrimary || hasHigherPhotoPriority(
+ photoEntry, priority, bestPhotoEntry, photoPriority)) {
+ bestPhotoEntry = photoEntry;
+ photoPriority = priority;
+ bestPhotoId = dataId;
+ bestPhotoFileId = photoFileId;
+ if (superPrimary) {
+ break;
+ }
+ }
+ }
+ } finally {
+ c.close();
+ }
+
+ if (bestPhotoId == -1) {
+ mPhotoIdUpdate.bindNull(1);
+ } else {
+ mPhotoIdUpdate.bindLong(1, bestPhotoId);
+ }
+
+ if (bestPhotoFileId == 0) {
+ mPhotoIdUpdate.bindNull(2);
+ } else {
+ mPhotoIdUpdate.bindLong(2, bestPhotoFileId);
+ }
+
+ mPhotoIdUpdate.bindLong(3, contactId);
+ mPhotoIdUpdate.execute();
+ }
+
+ private interface PhotoFileQuery {
+ final String[] COLUMNS = new String[] {
+ PhotoFiles.HEIGHT,
+ PhotoFiles.WIDTH,
+ PhotoFiles.FILESIZE
+ };
+
+ int HEIGHT = 0;
+ int WIDTH = 1;
+ int FILESIZE = 2;
+ }
+
+ private class PhotoEntry implements Comparable<PhotoEntry> {
+ // Pixel count (width * height) for the image.
+ final int pixelCount;
+
+ // File size (in bytes) of the image. Not populated if the image is a thumbnail.
+ final int fileSize;
+
+ private PhotoEntry(int pixelCount, int fileSize) {
+ this.pixelCount = pixelCount;
+ this.fileSize = fileSize;
+ }
+
+ @Override
+ public int compareTo(PhotoEntry pe) {
+ if (pe == null) {
+ return -1;
+ }
+ if (pixelCount == pe.pixelCount) {
+ return pe.fileSize - fileSize;
+ } else {
+ return pe.pixelCount - pixelCount;
+ }
+ }
+ }
+
+ private PhotoEntry getPhotoMetadata(SQLiteDatabase db, long photoFileId) {
+ if (photoFileId == 0) {
+ // Assume standard thumbnail size. Don't bother getting a file size for priority;
+ // we should fall back to photo priority resolver if all we have are thumbnails.
+ int thumbDim = mContactsProvider.getMaxThumbnailDim();
+ return new PhotoEntry(thumbDim * thumbDim, 0);
+ } else {
+ Cursor c = db.query(Tables.PHOTO_FILES, PhotoFileQuery.COLUMNS, PhotoFiles._ID + "=?",
+ new String[]{String.valueOf(photoFileId)}, null, null, null);
+ try {
+ if (c.getCount() == 1) {
+ c.moveToFirst();
+ int pixelCount =
+ c.getInt(PhotoFileQuery.HEIGHT) * c.getInt(PhotoFileQuery.WIDTH);
+ return new PhotoEntry(pixelCount, c.getInt(PhotoFileQuery.FILESIZE));
+ }
+ } finally {
+ c.close();
+ }
+ }
+ return new PhotoEntry(0, 0);
+ }
+
+ private interface DisplayNameQuery {
+ String SQL_HAS_SUPER_PRIMARY_NAME =
+ " EXISTS(SELECT 1 " +
+ " FROM " + Tables.DATA + " d " +
+ " WHERE d." + DataColumns.MIMETYPE_ID + "=? " +
+ " AND d." + Data.RAW_CONTACT_ID + "=" + Views.RAW_CONTACTS
+ + "." + RawContacts._ID +
+ " AND d." + Data.IS_SUPER_PRIMARY + "=1)";
+
+ String SQL =
+ "SELECT "
+ + RawContacts._ID + ","
+ + RawContactsColumns.DISPLAY_NAME + ","
+ + RawContactsColumns.DISPLAY_NAME_SOURCE + ","
+ + SQL_HAS_SUPER_PRIMARY_NAME + ","
+ + RawContacts.SOURCE_ID + ","
+ + RawContacts.ACCOUNT_TYPE_AND_DATA_SET +
+ " FROM " + Views.RAW_CONTACTS +
+ " WHERE " + RawContacts.CONTACT_ID + "=? ";
+
+ int _ID = 0;
+ int DISPLAY_NAME = 1;
+ int DISPLAY_NAME_SOURCE = 2;
+ int HAS_SUPER_PRIMARY_NAME = 3;
+ int SOURCE_ID = 4;
+ int ACCOUNT_TYPE_AND_DATA_SET = 5;
+ }
+
+ public void updateDisplayNameForRawContact(SQLiteDatabase db, long rawContactId) {
+ long contactId = mDbHelper.getContactId(rawContactId);
+ if (contactId == 0) {
+ return;
+ }
+
+ updateDisplayNameForContact(db, contactId);
+ }
+
+ public void updateDisplayNameForContact(SQLiteDatabase db, long contactId) {
+ boolean lookupKeyUpdateNeeded = false;
+
+ mDisplayNameCandidate.clear();
+
+ mSelectionArgs2[0] = String.valueOf(mDbHelper.getMimeTypeIdForStructuredName());
+ mSelectionArgs2[1] = String.valueOf(contactId);
+ final Cursor c = db.rawQuery(DisplayNameQuery.SQL, mSelectionArgs2);
+ try {
+ while (c.moveToNext()) {
+ long rawContactId = c.getLong(DisplayNameQuery._ID);
+ String displayName = c.getString(DisplayNameQuery.DISPLAY_NAME);
+ int displayNameSource = c.getInt(DisplayNameQuery.DISPLAY_NAME_SOURCE);
+ int isNameSuperPrimary = c.getInt(DisplayNameQuery.HAS_SUPER_PRIMARY_NAME);
+ String accountTypeAndDataSet = c.getString(
+ DisplayNameQuery.ACCOUNT_TYPE_AND_DATA_SET);
+ processDisplayNameCandidate(rawContactId, displayName, displayNameSource,
+ mContactsProvider.isWritableAccountWithDataSet(accountTypeAndDataSet),
+ isNameSuperPrimary != 0);
+
+ // If the raw contact has no source id, the lookup key is based on the display
+ // name, so the lookup key needs to be updated.
+ lookupKeyUpdateNeeded |= c.isNull(DisplayNameQuery.SOURCE_ID);
+ }
+ } finally {
+ c.close();
+ }
+
+ if (mDisplayNameCandidate.rawContactId != -1) {
+ mDisplayNameUpdate.bindLong(1, mDisplayNameCandidate.rawContactId);
+ mDisplayNameUpdate.bindLong(2, contactId);
+ mDisplayNameUpdate.execute();
+ }
+
+ if (lookupKeyUpdateNeeded) {
+ updateLookupKeyForContact(db, contactId);
+ }
+ }
+
+
+ /**
+ * Updates the {@link Contacts#HAS_PHONE_NUMBER} flag for the aggregate contact containing the
+ * specified raw contact.
+ */
+ public void updateHasPhoneNumber(SQLiteDatabase db, long rawContactId) {
+
+ long contactId = mDbHelper.getContactId(rawContactId);
+ if (contactId == 0) {
+ return;
+ }
+
+ final SQLiteStatement hasPhoneNumberUpdate = db.compileStatement(
+ "UPDATE " + Tables.CONTACTS +
+ " SET " + Contacts.HAS_PHONE_NUMBER + "="
+ + "(SELECT (CASE WHEN COUNT(*)=0 THEN 0 ELSE 1 END)"
+ + " FROM " + Tables.DATA_JOIN_RAW_CONTACTS
+ + " WHERE " + DataColumns.MIMETYPE_ID + "=?"
+ + " AND " + Phone.NUMBER + " NOT NULL"
+ + " AND " + RawContacts.CONTACT_ID + "=?)" +
+ " WHERE " + Contacts._ID + "=?");
+ try {
+ hasPhoneNumberUpdate.bindLong(1, mDbHelper.getMimeTypeId(Phone.CONTENT_ITEM_TYPE));
+ hasPhoneNumberUpdate.bindLong(2, contactId);
+ hasPhoneNumberUpdate.bindLong(3, contactId);
+ hasPhoneNumberUpdate.execute();
+ } finally {
+ hasPhoneNumberUpdate.close();
+ }
+ }
+
+ private interface LookupKeyQuery {
+ String TABLE = Views.RAW_CONTACTS;
+ String[] COLUMNS = new String[] {
+ RawContacts._ID,
+ RawContactsColumns.DISPLAY_NAME,
+ RawContacts.ACCOUNT_TYPE_AND_DATA_SET,
+ RawContacts.ACCOUNT_NAME,
+ RawContacts.SOURCE_ID,
+ };
+
+ int ID = 0;
+ int DISPLAY_NAME = 1;
+ int ACCOUNT_TYPE_AND_DATA_SET = 2;
+ int ACCOUNT_NAME = 3;
+ int SOURCE_ID = 4;
+ }
+
+ public void updateLookupKeyForRawContact(SQLiteDatabase db, long rawContactId) {
+ long contactId = mDbHelper.getContactId(rawContactId);
+ if (contactId == 0) {
+ return;
+ }
+
+ updateLookupKeyForContact(db, contactId);
+ }
+
+ private void updateLookupKeyForContact(SQLiteDatabase db, long contactId) {
+ String lookupKey = computeLookupKeyForContact(db, contactId);
+
+ if (lookupKey == null) {
+ mLookupKeyUpdate.bindNull(1);
+ } else {
+ mLookupKeyUpdate.bindString(1, Uri.encode(lookupKey));
+ }
+ mLookupKeyUpdate.bindLong(2, contactId);
+
+ mLookupKeyUpdate.execute();
+ }
+
+ protected String computeLookupKeyForContact(SQLiteDatabase db, long contactId) {
+ StringBuilder sb = new StringBuilder();
+ mSelectionArgs1[0] = String.valueOf(contactId);
+ final Cursor c = db.query(LookupKeyQuery.TABLE, LookupKeyQuery.COLUMNS,
+ RawContacts.CONTACT_ID + "=?", mSelectionArgs1, null, null, RawContacts._ID);
+ try {
+ while (c.moveToNext()) {
+ ContactLookupKey.appendToLookupKey(sb,
+ c.getString(LookupKeyQuery.ACCOUNT_TYPE_AND_DATA_SET),
+ c.getString(LookupKeyQuery.ACCOUNT_NAME),
+ c.getLong(LookupKeyQuery.ID),
+ c.getString(LookupKeyQuery.SOURCE_ID),
+ c.getString(LookupKeyQuery.DISPLAY_NAME));
+ }
+ } finally {
+ c.close();
+ }
+ return sb.length() == 0 ? null : sb.toString();
+ }
+
+ /**
+ * Execute {@link SQLiteStatement} that will update the
+ * {@link Contacts#STARRED} flag for the given {@link RawContacts#_ID}.
+ */
+ public void updateStarred(long rawContactId) {
+ long contactId = mDbHelper.getContactId(rawContactId);
+ if (contactId == 0) {
+ return;
+ }
+
+ mStarredUpdate.bindLong(1, contactId);
+ mStarredUpdate.execute();
+ }
+
+ /**
+ * Execute {@link SQLiteStatement} that will update the
+ * {@link Contacts#PINNED} flag for the given {@link RawContacts#_ID}.
+ */
+ public void updatePinned(long rawContactId) {
+ long contactId = mDbHelper.getContactId(rawContactId);
+ if (contactId == 0) {
+ return;
+ }
+ mPinnedUpdate.bindLong(1, contactId);
+ mPinnedUpdate.execute();
+ }
+
+ /**
+ * Finds matching contacts and returns a cursor on those.
+ */
+ public Cursor queryAggregationSuggestions(SQLiteQueryBuilder qb,
+ String[] projection, long contactId, int maxSuggestions, String filter,
+ ArrayList<AggregationSuggestionParameter> parameters) {
+ final SQLiteDatabase db = mDbHelper.getReadableDatabase();
+ db.beginTransaction();
+ try {
+ List<MatchScore> bestMatches = findMatchingContacts(db, contactId, parameters);
+ return queryMatchingContacts(qb, db, projection, bestMatches, maxSuggestions, filter);
+ } finally {
+ db.endTransaction();
+ }
+ }
+
+ private interface ContactIdQuery {
+ String[] COLUMNS = new String[] {
+ Contacts._ID
+ };
+
+ int _ID = 0;
+ }
+
+ /**
+ * Loads contacts with specified IDs and returns them in the order of IDs in the
+ * supplied list.
+ */
+ private Cursor queryMatchingContacts(SQLiteQueryBuilder qb, SQLiteDatabase db,
+ String[] projection, List<MatchScore> bestMatches, int maxSuggestions, String filter) {
+ StringBuilder sb = new StringBuilder();
+ sb.append(Contacts._ID);
+ sb.append(" IN (");
+ for (int i = 0; i < bestMatches.size(); i++) {
+ MatchScore matchScore = bestMatches.get(i);
+ if (i != 0) {
+ sb.append(",");
+ }
+ sb.append(matchScore.getContactId());
+ }
+ sb.append(")");
+
+ if (!TextUtils.isEmpty(filter)) {
+ sb.append(" AND " + Contacts._ID + " IN ");
+ mContactsProvider.appendContactFilterAsNestedQuery(sb, filter);
+ }
+
+ // Run a query and find ids of best matching contacts satisfying the filter (if any)
+ HashSet<Long> foundIds = new HashSet<Long>();
+ Cursor cursor = db.query(qb.getTables(), ContactIdQuery.COLUMNS, sb.toString(),
+ null, null, null, null);
+ try {
+ while(cursor.moveToNext()) {
+ foundIds.add(cursor.getLong(ContactIdQuery._ID));
+ }
+ } finally {
+ cursor.close();
+ }
+
+ // Exclude all contacts that did not match the filter
+ Iterator<MatchScore> iter = bestMatches.iterator();
+ while (iter.hasNext()) {
+ long id = iter.next().getContactId();
+ if (!foundIds.contains(id)) {
+ iter.remove();
+ }
+ }
+
+ // Limit the number of returned suggestions
+ final List<MatchScore> limitedMatches;
+ if (bestMatches.size() > maxSuggestions) {
+ limitedMatches = bestMatches.subList(0, maxSuggestions);
+ } else {
+ limitedMatches = bestMatches;
+ }
+
+ // Build an in-clause with the remaining contact IDs
+ sb.setLength(0);
+ sb.append(Contacts._ID);
+ sb.append(" IN (");
+ for (int i = 0; i < limitedMatches.size(); i++) {
+ MatchScore matchScore = limitedMatches.get(i);
+ if (i != 0) {
+ sb.append(",");
+ }
+ sb.append(matchScore.getContactId());
+ }
+ sb.append(")");
+
+ // Run the final query with the required projection and contact IDs found by the first query
+ cursor = qb.query(db, projection, sb.toString(), null, null, null, Contacts._ID);
+
+ // Build a sorted list of discovered IDs
+ ArrayList<Long> sortedContactIds = new ArrayList<Long>(limitedMatches.size());
+ for (MatchScore matchScore : limitedMatches) {
+ sortedContactIds.add(matchScore.getContactId());
+ }
+
+ Collections.sort(sortedContactIds);
+
+ // Map cursor indexes according to the descending order of match scores
+ int[] positionMap = new int[limitedMatches.size()];
+ for (int i = 0; i < positionMap.length; i++) {
+ long id = limitedMatches.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.
+ * @param parameters
+ */
+ private List<MatchScore> findMatchingContacts(final SQLiteDatabase db, long contactId,
+ ArrayList<AggregationSuggestionParameter> parameters) {
+
+ MatchCandidateList candidates = new MatchCandidateList();
+ ContactMatcher matcher = new ContactMatcher();
+
+ // Don't aggregate a contact with itself
+ matcher.keepOut(contactId);
+
+ if (parameters == null || parameters.size() == 0) {
+ final Cursor c = db.query(RawContactIdQuery.TABLE, RawContactIdQuery.COLUMNS,
+ RawContacts.CONTACT_ID + "=" + contactId, null, null, null, null);
+ try {
+ while (c.moveToNext()) {
+ long rawContactId = c.getLong(RawContactIdQuery.RAW_CONTACT_ID);
+ updateMatchScoresForSuggestionsBasedOnDataMatches(db, rawContactId, candidates,
+ matcher);
+ }
+ } finally {
+ c.close();
+ }
+ } else {
+ updateMatchScoresForSuggestionsBasedOnDataMatches(db, candidates,
+ matcher, parameters);
+ }
+
+ return matcher.pickBestMatches(ContactMatcher.SCORE_THRESHOLD_SUGGEST);
+ }
+
+ /**
+ * Computes scores for contacts that have matching data rows.
+ */
+ private void updateMatchScoresForSuggestionsBasedOnDataMatches(SQLiteDatabase db,
+ long rawContactId, MatchCandidateList candidates, ContactMatcher matcher) {
+
+ updateMatchScoresBasedOnIdentityMatch(db, rawContactId, matcher);
+ updateMatchScoresBasedOnNameMatches(db, rawContactId, matcher);
+ updateMatchScoresBasedOnEmailMatches(db, rawContactId, matcher);
+ updateMatchScoresBasedOnPhoneMatches(db, rawContactId, matcher);
+ loadNameMatchCandidates(db, rawContactId, candidates, false);
+ lookupApproximateNameMatches(db, candidates, matcher);
+ }
+
+ private void updateMatchScoresForSuggestionsBasedOnDataMatches(SQLiteDatabase db,
+ MatchCandidateList candidates, ContactMatcher matcher,
+ ArrayList<AggregationSuggestionParameter> parameters) {
+ for (AggregationSuggestionParameter parameter : parameters) {
+ if (AggregationSuggestions.PARAMETER_MATCH_NAME.equals(parameter.kind)) {
+ updateMatchScoresBasedOnNameMatches(db, parameter.value, candidates, matcher);
+ }
+
+ // TODO: add support for other parameter kinds
+ }
+ }
+}