/* * Copyright (C) 2010 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.example.android.samplesync.platform; import com.example.android.samplesync.Constants; import com.example.android.samplesync.R; import com.example.android.samplesync.client.RawContact; import android.accounts.Account; import android.content.ContentResolver; import android.content.ContentUris; import android.content.ContentValues; import android.content.Context; import android.database.Cursor; import android.net.Uri; import android.provider.ContactsContract; import android.provider.ContactsContract.CommonDataKinds.Email; import android.provider.ContactsContract.CommonDataKinds.Im; import android.provider.ContactsContract.CommonDataKinds.Phone; import android.provider.ContactsContract.CommonDataKinds.Photo; import android.provider.ContactsContract.CommonDataKinds.StructuredName; import android.provider.ContactsContract.Contacts; import android.provider.ContactsContract.Data; import android.provider.ContactsContract.Groups; import android.provider.ContactsContract.RawContacts; import android.provider.ContactsContract.Settings; import android.provider.ContactsContract.StatusUpdates; import android.util.Log; import java.util.ArrayList; import java.util.List; /** * Class for managing contacts sync related mOperations */ public class ContactManager { /** * Custom IM protocol used when storing status messages. */ public static final String CUSTOM_IM_PROTOCOL = "SampleSyncAdapter"; private static final String TAG = "ContactManager"; public static final String SAMPLE_GROUP_NAME = "Sample Group"; public static long ensureSampleGroupExists(Context context, Account account) { final ContentResolver resolver = context.getContentResolver(); // Lookup the sample group long groupId = 0; final Cursor cursor = resolver.query(Groups.CONTENT_URI, new String[] { Groups._ID }, Groups.ACCOUNT_NAME + "=? AND " + Groups.ACCOUNT_TYPE + "=? AND " + Groups.TITLE + "=?", new String[] { account.name, account.type, SAMPLE_GROUP_NAME }, null); if (cursor != null) { try { if (cursor.moveToFirst()) { groupId = cursor.getLong(0); } } finally { cursor.close(); } } if (groupId == 0) { // Sample group doesn't exist yet, so create it final ContentValues contentValues = new ContentValues(); contentValues.put(Groups.ACCOUNT_NAME, account.name); contentValues.put(Groups.ACCOUNT_TYPE, account.type); contentValues.put(Groups.TITLE, SAMPLE_GROUP_NAME); contentValues.put(Groups.GROUP_IS_READ_ONLY, true); final Uri newGroupUri = resolver.insert(Groups.CONTENT_URI, contentValues); groupId = ContentUris.parseId(newGroupUri); } return groupId; } /** * Take a list of updated contacts and apply those changes to the * contacts database. Typically this list of contacts would have been * returned from the server, and we want to apply those changes locally. * * @param context The context of Authenticator Activity * @param account The username for the account * @param rawContacts The list of contacts to update * @param lastSyncMarker The previous server sync-state * @return the server syncState that should be used in our next * sync request. */ public static synchronized long updateContacts(Context context, String account, List rawContacts, long groupId, long lastSyncMarker) { long currentSyncMarker = lastSyncMarker; final ContentResolver resolver = context.getContentResolver(); final BatchOperation batchOperation = new BatchOperation(context, resolver); final List newUsers = new ArrayList(); Log.d(TAG, "In SyncContacts"); for (final RawContact rawContact : rawContacts) { // The server returns a syncState (x) value with each contact record. // The syncState is sequential, so higher values represent more recent // changes than lower values. We keep track of the highest value we // see, and consider that a "high water mark" for the changes we've // received from the server. That way, on our next sync, we can just // ask for changes that have occurred since that most-recent change. if (rawContact.getSyncState() > currentSyncMarker) { currentSyncMarker = rawContact.getSyncState(); } // If the server returned a clientId for this user, then it's likely // that the user was added here, and was just pushed to the server // for the first time. In that case, we need to update the main // row for this contact so that the RawContacts.SOURCE_ID value // contains the correct serverId. final long rawContactId; final boolean updateServerId; if (rawContact.getRawContactId() > 0) { rawContactId = rawContact.getRawContactId(); updateServerId = true; } else { long serverContactId = rawContact.getServerContactId(); rawContactId = lookupRawContact(resolver, serverContactId); updateServerId = false; } if (rawContactId != 0) { if (!rawContact.isDeleted()) { updateContact(context, resolver, rawContact, updateServerId, true, true, true, rawContactId, batchOperation); } else { deleteContact(context, rawContactId, batchOperation); } } else { Log.d(TAG, "In addContact"); if (!rawContact.isDeleted()) { newUsers.add(rawContact); addContact(context, account, rawContact, groupId, true, batchOperation); } } // A sync adapter should batch operations on multiple contacts, // because it will make a dramatic performance difference. // (UI updates, etc) if (batchOperation.size() >= 50) { batchOperation.execute(); } } batchOperation.execute(); return currentSyncMarker; } /** * Return a list of the local contacts that have been marked as * "dirty", and need syncing to the SampleSync server. * * @param context The context of Authenticator Activity * @param account The account that we're interested in syncing * @return a list of Users that are considered "dirty" */ public static List getDirtyContacts(Context context, Account account) { Log.i(TAG, "*** Looking for local dirty contacts"); List dirtyContacts = new ArrayList(); final ContentResolver resolver = context.getContentResolver(); final Cursor c = resolver.query(DirtyQuery.CONTENT_URI, DirtyQuery.PROJECTION, DirtyQuery.SELECTION, new String[] {account.name}, null); try { while (c.moveToNext()) { final long rawContactId = c.getLong(DirtyQuery.COLUMN_RAW_CONTACT_ID); final long serverContactId = c.getLong(DirtyQuery.COLUMN_SERVER_ID); final boolean isDirty = "1".equals(c.getString(DirtyQuery.COLUMN_DIRTY)); final boolean isDeleted = "1".equals(c.getString(DirtyQuery.COLUMN_DELETED)); // The system actually keeps track of a change version number for // each contact. It may be something you're interested in for your // client-server sync protocol. We're not using it in this example, // other than to log it. final long version = c.getLong(DirtyQuery.COLUMN_VERSION); Log.i(TAG, "Dirty Contact: " + Long.toString(rawContactId)); Log.i(TAG, "Contact Version: " + Long.toString(version)); if (isDeleted) { Log.i(TAG, "Contact is marked for deletion"); RawContact rawContact = RawContact.createDeletedContact(rawContactId, serverContactId); dirtyContacts.add(rawContact); } else if (isDirty) { RawContact rawContact = getRawContact(context, rawContactId); Log.i(TAG, "Contact Name: " + rawContact.getBestName()); dirtyContacts.add(rawContact); } } } finally { if (c != null) { c.close(); } } return dirtyContacts; } /** * Update the status messages for a list of users. This is typically called * for contacts we've just added to the system, since we can't monkey with * the contact's status until they have a profileId. * * @param context The context of Authenticator Activity * @param rawContacts The list of users we want to update */ public static void updateStatusMessages(Context context, List rawContacts) { final ContentResolver resolver = context.getContentResolver(); final BatchOperation batchOperation = new BatchOperation(context, resolver); for (RawContact rawContact : rawContacts) { updateContactStatus(context, rawContact, batchOperation); } batchOperation.execute(); } /** * After we've finished up a sync operation, we want to clean up the sync-state * so that we're ready for the next time. This involves clearing out the 'dirty' * flag on the synced contacts - but we also have to finish the DELETE operation * on deleted contacts. When the user initially deletes them on the client, they're * marked for deletion - but they're not actually deleted until we delete them * again, and include the ContactsContract.CALLER_IS_SYNCADAPTER parameter to * tell the contacts provider that we're really ready to let go of this contact. * * @param context The context of Authenticator Activity * @param dirtyContacts The list of contacts that we're cleaning up */ public static void clearSyncFlags(Context context, List dirtyContacts) { Log.i(TAG, "*** Clearing Sync-related Flags"); final ContentResolver resolver = context.getContentResolver(); final BatchOperation batchOperation = new BatchOperation(context, resolver); for (RawContact rawContact : dirtyContacts) { if (rawContact.isDeleted()) { Log.i(TAG, "Deleting contact: " + Long.toString(rawContact.getRawContactId())); deleteContact(context, rawContact.getRawContactId(), batchOperation); } else if (rawContact.isDirty()) { Log.i(TAG, "Clearing dirty flag for: " + rawContact.getBestName()); clearDirtyFlag(context, rawContact.getRawContactId(), batchOperation); } } batchOperation.execute(); } /** * Adds a single contact to the platform contacts provider. * This can be used to respond to a new contact found as part * of sync information returned from the server, or because a * user added a new contact. * * @param context the Authenticator Activity context * @param accountName the account the contact belongs to * @param rawContact the sample SyncAdapter User object * @param groupId the id of the sample group * @param inSync is the add part of a client-server sync? * @param batchOperation allow us to batch together multiple operations * into a single provider call */ public static void addContact(Context context, String accountName, RawContact rawContact, long groupId, boolean inSync, BatchOperation batchOperation) { // Put the data in the contacts provider final ContactOperations contactOp = ContactOperations.createNewContact( context, rawContact.getServerContactId(), accountName, inSync, batchOperation); contactOp.addName(rawContact.getFullName(), rawContact.getFirstName(), rawContact.getLastName()) .addEmail(rawContact.getEmail()) .addPhone(rawContact.getCellPhone(), Phone.TYPE_MOBILE) .addPhone(rawContact.getHomePhone(), Phone.TYPE_HOME) .addPhone(rawContact.getOfficePhone(), Phone.TYPE_WORK) .addGroupMembership(groupId) .addAvatar(rawContact.getAvatarUrl()); // If we have a serverId, then go ahead and create our status profile. // Otherwise skip it - and we'll create it after we sync-up to the // server later on. if (rawContact.getServerContactId() > 0) { contactOp.addProfileAction(rawContact.getServerContactId()); } } /** * Updates a single contact to the platform contacts provider. * This method can be used to update a contact from a sync * operation or as a result of a user editing a contact * record. * * This operation is actually relatively complex. We query * the database to find all the rows of info that already * exist for this Contact. For rows that exist (and thus we're * modifying existing fields), we create an update operation * to change that field. But for fields we're adding, we create * "add" operations to create new rows for those fields. * * @param context the Authenticator Activity context * @param resolver the ContentResolver to use * @param rawContact the sample SyncAdapter contact object * @param updateStatus should we update this user's status * @param updateAvatar should we update this user's avatar image * @param inSync is the update part of a client-server sync? * @param rawContactId the unique Id for this rawContact in contacts * provider * @param batchOperation allow us to batch together multiple operations * into a single provider call */ public static void updateContact(Context context, ContentResolver resolver, RawContact rawContact, boolean updateServerId, boolean updateStatus, boolean updateAvatar, boolean inSync, long rawContactId, BatchOperation batchOperation) { boolean existingCellPhone = false; boolean existingHomePhone = false; boolean existingWorkPhone = false; boolean existingEmail = false; boolean existingAvatar = false; final Cursor c = resolver.query(DataQuery.CONTENT_URI, DataQuery.PROJECTION, DataQuery.SELECTION, new String[] {String.valueOf(rawContactId)}, null); final ContactOperations contactOp = ContactOperations.updateExistingContact(context, rawContactId, inSync, batchOperation); try { // Iterate over the existing rows of data, and update each one // with the information we received from the server. while (c.moveToNext()) { final long id = c.getLong(DataQuery.COLUMN_ID); final String mimeType = c.getString(DataQuery.COLUMN_MIMETYPE); final Uri uri = ContentUris.withAppendedId(Data.CONTENT_URI, id); if (mimeType.equals(StructuredName.CONTENT_ITEM_TYPE)) { contactOp.updateName(uri, c.getString(DataQuery.COLUMN_GIVEN_NAME), c.getString(DataQuery.COLUMN_FAMILY_NAME), c.getString(DataQuery.COLUMN_FULL_NAME), rawContact.getFirstName(), rawContact.getLastName(), rawContact.getFullName()); } else if (mimeType.equals(Phone.CONTENT_ITEM_TYPE)) { final int type = c.getInt(DataQuery.COLUMN_PHONE_TYPE); if (type == Phone.TYPE_MOBILE) { existingCellPhone = true; contactOp.updatePhone(c.getString(DataQuery.COLUMN_PHONE_NUMBER), rawContact.getCellPhone(), uri); } else if (type == Phone.TYPE_HOME) { existingHomePhone = true; contactOp.updatePhone(c.getString(DataQuery.COLUMN_PHONE_NUMBER), rawContact.getHomePhone(), uri); } else if (type == Phone.TYPE_WORK) { existingWorkPhone = true; contactOp.updatePhone(c.getString(DataQuery.COLUMN_PHONE_NUMBER), rawContact.getOfficePhone(), uri); } } else if (mimeType.equals(Email.CONTENT_ITEM_TYPE)) { existingEmail = true; contactOp.updateEmail(rawContact.getEmail(), c.getString(DataQuery.COLUMN_EMAIL_ADDRESS), uri); } else if (mimeType.equals(Photo.CONTENT_ITEM_TYPE)) { existingAvatar = true; contactOp.updateAvatar(rawContact.getAvatarUrl(), uri); } } // while } finally { c.close(); } // Add the cell phone, if present and not updated above if (!existingCellPhone) { contactOp.addPhone(rawContact.getCellPhone(), Phone.TYPE_MOBILE); } // Add the home phone, if present and not updated above if (!existingHomePhone) { contactOp.addPhone(rawContact.getHomePhone(), Phone.TYPE_HOME); } // Add the work phone, if present and not updated above if (!existingWorkPhone) { contactOp.addPhone(rawContact.getOfficePhone(), Phone.TYPE_WORK); } // Add the email address, if present and not updated above if (!existingEmail) { contactOp.addEmail(rawContact.getEmail()); } // Add the avatar if we didn't update the existing avatar if (!existingAvatar) { contactOp.addAvatar(rawContact.getAvatarUrl()); } // If we need to update the serverId of the contact record, take // care of that. This will happen if the contact is created on the // client, and then synced to the server. When we get the updated // record back from the server, we can set the SOURCE_ID property // on the contact, so we can (in the future) lookup contacts by // the serverId. if (updateServerId) { Uri uri = ContentUris.withAppendedId(RawContacts.CONTENT_URI, rawContactId); contactOp.updateServerId(rawContact.getServerContactId(), uri); } // If we don't have a status profile, then create one. This could // happen for contacts that were created on the client - we don't // create the status profile until after the first sync... final long serverId = rawContact.getServerContactId(); final long profileId = lookupProfile(resolver, serverId); if (profileId <= 0) { contactOp.addProfileAction(serverId); } } /** * When we first add a sync adapter to the system, the contacts from that * sync adapter will be hidden unless they're merged/grouped with an existing * contact. But typically we want to actually show those contacts, so we * need to mess with the Settings table to get them to show up. * * @param context the Authenticator Activity context * @param account the Account who's visibility we're changing * @param visible true if we want the contacts visible, false for hidden */ public static void setAccountContactsVisibility(Context context, Account account, boolean visible) { ContentValues values = new ContentValues(); values.put(RawContacts.ACCOUNT_NAME, account.name); values.put(RawContacts.ACCOUNT_TYPE, Constants.ACCOUNT_TYPE); values.put(Settings.UNGROUPED_VISIBLE, visible ? 1 : 0); context.getContentResolver().insert(Settings.CONTENT_URI, values); } /** * Return a User object with data extracted from a contact stored * in the local contacts database. * * Because a contact is actually stored over several rows in the * database, our query will return those multiple rows of information. * We then iterate over the rows and build the User structure from * what we find. * * @param context the Authenticator Activity context * @param rawContactId the unique ID for the local contact * @return a User object containing info on that contact */ private static RawContact getRawContact(Context context, long rawContactId) { String firstName = null; String lastName = null; String fullName = null; String cellPhone = null; String homePhone = null; String workPhone = null; String email = null; long serverId = -1; final ContentResolver resolver = context.getContentResolver(); final Cursor c = resolver.query(DataQuery.CONTENT_URI, DataQuery.PROJECTION, DataQuery.SELECTION, new String[] {String.valueOf(rawContactId)}, null); try { while (c.moveToNext()) { final long id = c.getLong(DataQuery.COLUMN_ID); final String mimeType = c.getString(DataQuery.COLUMN_MIMETYPE); final long tempServerId = c.getLong(DataQuery.COLUMN_SERVER_ID); if (tempServerId > 0) { serverId = tempServerId; } final Uri uri = ContentUris.withAppendedId(Data.CONTENT_URI, id); if (mimeType.equals(StructuredName.CONTENT_ITEM_TYPE)) { lastName = c.getString(DataQuery.COLUMN_FAMILY_NAME); firstName = c.getString(DataQuery.COLUMN_GIVEN_NAME); fullName = c.getString(DataQuery.COLUMN_FULL_NAME); } else if (mimeType.equals(Phone.CONTENT_ITEM_TYPE)) { final int type = c.getInt(DataQuery.COLUMN_PHONE_TYPE); if (type == Phone.TYPE_MOBILE) { cellPhone = c.getString(DataQuery.COLUMN_PHONE_NUMBER); } else if (type == Phone.TYPE_HOME) { homePhone = c.getString(DataQuery.COLUMN_PHONE_NUMBER); } else if (type == Phone.TYPE_WORK) { workPhone = c.getString(DataQuery.COLUMN_PHONE_NUMBER); } } else if (mimeType.equals(Email.CONTENT_ITEM_TYPE)) { email = c.getString(DataQuery.COLUMN_EMAIL_ADDRESS); } } // while } finally { c.close(); } // Now that we've extracted all the information we care about, // create the actual User object. RawContact rawContact = RawContact.create(fullName, firstName, lastName, cellPhone, workPhone, homePhone, email, null, false, rawContactId, serverId); return rawContact; } /** * Update the status message associated with the specified user. The status * message would be something that is likely to be used by IM or social * networking sync providers, and less by a straightforward contact provider. * But it's a useful demo to see how it's done. * * @param context the Authenticator Activity context * @param rawContact the contact whose status we should update * @param batchOperation allow us to batch together multiple operations */ private static void updateContactStatus(Context context, RawContact rawContact, BatchOperation batchOperation) { final ContentValues values = new ContentValues(); final ContentResolver resolver = context.getContentResolver(); final long userId = rawContact.getServerContactId(); final String username = rawContact.getUserName(); final String status = rawContact.getStatus(); // Look up the user's sample SyncAdapter data row final long profileId = lookupProfile(resolver, userId); // Insert the activity into the stream if (profileId > 0) { values.put(StatusUpdates.DATA_ID, profileId); values.put(StatusUpdates.STATUS, status); values.put(StatusUpdates.PROTOCOL, Im.PROTOCOL_CUSTOM); values.put(StatusUpdates.CUSTOM_PROTOCOL, CUSTOM_IM_PROTOCOL); values.put(StatusUpdates.IM_ACCOUNT, username); values.put(StatusUpdates.IM_HANDLE, userId); values.put(StatusUpdates.STATUS_RES_PACKAGE, context.getPackageName()); values.put(StatusUpdates.STATUS_ICON, R.drawable.icon); values.put(StatusUpdates.STATUS_LABEL, R.string.label); batchOperation.add(ContactOperations.newInsertCpo(StatusUpdates.CONTENT_URI, false, true).withValues(values).build()); } } /** * Clear the local system 'dirty' flag for a contact. * * @param context the Authenticator Activity context * @param rawContactId the id of the contact update * @param batchOperation allow us to batch together multiple operations */ private static void clearDirtyFlag(Context context, long rawContactId, BatchOperation batchOperation) { final ContactOperations contactOp = ContactOperations.updateExistingContact(context, rawContactId, true, batchOperation); final Uri uri = ContentUris.withAppendedId(RawContacts.CONTENT_URI, rawContactId); contactOp.updateDirtyFlag(false, uri); } /** * Deletes a contact from the platform contacts provider. This method is used * both for contacts that were deleted locally and then that deletion was synced * to the server, and for contacts that were deleted on the server and the * deletion was synced to the client. * * @param context the Authenticator Activity context * @param rawContactId the unique Id for this rawContact in contacts * provider */ private static void deleteContact(Context context, long rawContactId, BatchOperation batchOperation) { batchOperation.add(ContactOperations.newDeleteCpo( ContentUris.withAppendedId(RawContacts.CONTENT_URI, rawContactId), true, true).build()); } /** * Returns the RawContact id for a sample SyncAdapter contact, or 0 if the * sample SyncAdapter user isn't found. * * @param resolver the content resolver to use * @param serverContactId the sample SyncAdapter user ID to lookup * @return the RawContact id, or 0 if not found */ private static long lookupRawContact(ContentResolver resolver, long serverContactId) { long rawContactId = 0; final Cursor c = resolver.query( UserIdQuery.CONTENT_URI, UserIdQuery.PROJECTION, UserIdQuery.SELECTION, new String[] {String.valueOf(serverContactId)}, null); try { if ((c != null) && c.moveToFirst()) { rawContactId = c.getLong(UserIdQuery.COLUMN_RAW_CONTACT_ID); } } finally { if (c != null) { c.close(); } } return rawContactId; } /** * Returns the Data id for a sample SyncAdapter contact's profile row, or 0 * if the sample SyncAdapter user isn't found. * * @param resolver a content resolver * @param userId the sample SyncAdapter user ID to lookup * @return the profile Data row id, or 0 if not found */ private static long lookupProfile(ContentResolver resolver, long userId) { long profileId = 0; final Cursor c = resolver.query(Data.CONTENT_URI, ProfileQuery.PROJECTION, ProfileQuery.SELECTION, new String[] {String.valueOf(userId)}, null); try { if ((c != null) && c.moveToFirst()) { profileId = c.getLong(ProfileQuery.COLUMN_ID); } } finally { if (c != null) { c.close(); } } return profileId; } final public static class EditorQuery { private EditorQuery() { } public static final String[] PROJECTION = new String[] { RawContacts.ACCOUNT_NAME, Data._ID, RawContacts.Entity.DATA_ID, Data.MIMETYPE, Data.DATA1, Data.DATA2, Data.DATA3, Data.DATA15, Data.SYNC1 }; public static final int COLUMN_ACCOUNT_NAME = 0; public static final int COLUMN_RAW_CONTACT_ID = 1; public static final int COLUMN_DATA_ID = 2; public static final int COLUMN_MIMETYPE = 3; public static final int COLUMN_DATA1 = 4; public static final int COLUMN_DATA2 = 5; public static final int COLUMN_DATA3 = 6; public static final int COLUMN_DATA15 = 7; public static final int COLUMN_SYNC1 = 8; public static final int COLUMN_PHONE_NUMBER = COLUMN_DATA1; public static final int COLUMN_PHONE_TYPE = COLUMN_DATA2; public static final int COLUMN_EMAIL_ADDRESS = COLUMN_DATA1; public static final int COLUMN_EMAIL_TYPE = COLUMN_DATA2; public static final int COLUMN_FULL_NAME = COLUMN_DATA1; public static final int COLUMN_GIVEN_NAME = COLUMN_DATA2; public static final int COLUMN_FAMILY_NAME = COLUMN_DATA3; public static final int COLUMN_AVATAR_IMAGE = COLUMN_DATA15; public static final int COLUMN_SYNC_DIRTY = COLUMN_SYNC1; public static final String SELECTION = Data.RAW_CONTACT_ID + "=?"; } /** * Constants for a query to find a contact given a sample SyncAdapter user * ID. */ final private static class ProfileQuery { private ProfileQuery() { } public final static String[] PROJECTION = new String[] {Data._ID}; public final static int COLUMN_ID = 0; public static final String SELECTION = Data.MIMETYPE + "='" + SampleSyncAdapterColumns.MIME_PROFILE + "' AND " + SampleSyncAdapterColumns.DATA_PID + "=?"; } /** * Constants for a query to find a contact given a sample SyncAdapter user * ID. */ final private static class UserIdQuery { private UserIdQuery() { } public final static String[] PROJECTION = new String[] { RawContacts._ID, RawContacts.CONTACT_ID }; public final static int COLUMN_RAW_CONTACT_ID = 0; public final static int COLUMN_LINKED_CONTACT_ID = 1; public final static Uri CONTENT_URI = RawContacts.CONTENT_URI; public static final String SELECTION = RawContacts.ACCOUNT_TYPE + "='" + Constants.ACCOUNT_TYPE + "' AND " + RawContacts.SOURCE_ID + "=?"; } /** * Constants for a query to find SampleSyncAdapter contacts that are * in need of syncing to the server. This should cover new, edited, * and deleted contacts. */ final private static class DirtyQuery { private DirtyQuery() { } public final static String[] PROJECTION = new String[] { RawContacts._ID, RawContacts.SOURCE_ID, RawContacts.DIRTY, RawContacts.DELETED, RawContacts.VERSION }; public final static int COLUMN_RAW_CONTACT_ID = 0; public final static int COLUMN_SERVER_ID = 1; public final static int COLUMN_DIRTY = 2; public final static int COLUMN_DELETED = 3; public final static int COLUMN_VERSION = 4; public static final Uri CONTENT_URI = RawContacts.CONTENT_URI.buildUpon() .appendQueryParameter(ContactsContract.CALLER_IS_SYNCADAPTER, "true") .build(); public static final String SELECTION = RawContacts.DIRTY + "=1 AND " + RawContacts.ACCOUNT_TYPE + "='" + Constants.ACCOUNT_TYPE + "' AND " + RawContacts.ACCOUNT_NAME + "=?"; } /** * Constants for a query to get contact data for a given rawContactId */ final private static class DataQuery { private DataQuery() { } public static final String[] PROJECTION = new String[] {Data._ID, RawContacts.SOURCE_ID, Data.MIMETYPE, Data.DATA1, Data.DATA2, Data.DATA3, Data.DATA15, Data.SYNC1}; public static final int COLUMN_ID = 0; public static final int COLUMN_SERVER_ID = 1; public static final int COLUMN_MIMETYPE = 2; public static final int COLUMN_DATA1 = 3; public static final int COLUMN_DATA2 = 4; public static final int COLUMN_DATA3 = 5; public static final int COLUMN_DATA15 = 6; public static final int COLUMN_SYNC1 = 7; public static final Uri CONTENT_URI = Data.CONTENT_URI; public static final int COLUMN_PHONE_NUMBER = COLUMN_DATA1; public static final int COLUMN_PHONE_TYPE = COLUMN_DATA2; public static final int COLUMN_EMAIL_ADDRESS = COLUMN_DATA1; public static final int COLUMN_EMAIL_TYPE = COLUMN_DATA2; public static final int COLUMN_FULL_NAME = COLUMN_DATA1; public static final int COLUMN_GIVEN_NAME = COLUMN_DATA2; public static final int COLUMN_FAMILY_NAME = COLUMN_DATA3; public static final int COLUMN_AVATAR_IMAGE = COLUMN_DATA15; public static final int COLUMN_SYNC_DIRTY = COLUMN_SYNC1; public static final String SELECTION = Data.RAW_CONTACT_ID + "=?"; } /** * Constants for a query to read basic contact columns */ final public static class ContactQuery { private ContactQuery() { } public static final String[] PROJECTION = new String[] {Contacts._ID, Contacts.DISPLAY_NAME}; public static final int COLUMN_ID = 0; public static final int COLUMN_DISPLAY_NAME = 1; } }