/*
* Copyright (C) 2009 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.android.providers.contacts;
import com.android.providers.contacts.ContactsDatabaseHelper.DataColumns;
import com.android.providers.contacts.ContactsDatabaseHelper.PhoneColumns;
import com.android.providers.contacts.ContactsDatabaseHelper.PhoneLookupColumns;
import com.android.providers.contacts.ContactsDatabaseHelper.RawContactsColumns;
import com.android.providers.contacts.ContactsDatabaseHelper.Tables;
import android.content.ContentResolver;
import android.content.ContentValues;
import android.content.Context;
import android.database.Cursor;
import android.database.DatabaseUtils;
import android.database.sqlite.SQLiteDatabase;
import android.database.sqlite.SQLiteException;
import android.database.sqlite.SQLiteStatement;
import android.provider.CallLog.Calls;
import android.provider.ContactsContract.Contacts;
import android.provider.ContactsContract.Data;
import android.provider.ContactsContract.Groups;
import android.provider.ContactsContract.RawContacts;
import android.provider.ContactsContract.CommonDataKinds.Email;
import android.provider.ContactsContract.CommonDataKinds.GroupMembership;
import android.provider.ContactsContract.CommonDataKinds.Im;
import android.provider.ContactsContract.CommonDataKinds.Note;
import android.provider.ContactsContract.CommonDataKinds.Organization;
import android.provider.ContactsContract.CommonDataKinds.Phone;
import android.provider.ContactsContract.CommonDataKinds.Photo;
import android.provider.ContactsContract.CommonDataKinds.StructuredName;
import android.provider.ContactsContract.CommonDataKinds.StructuredPostal;
import android.telephony.PhoneNumberUtils;
import android.text.TextUtils;
import android.util.Log;
import java.io.File;
public class LegacyContactImporter {
public static final String TAG = "LegacyContactImporter";
private static final int MAX_ATTEMPTS = 5;
private static final int DELAY_BETWEEN_ATTEMPTS = 2000;
public static final String DEFAULT_ACCOUNT_TYPE = "com.google";
private static final String DATABASE_NAME = "contacts.db";
private static final int INSERT_BATCH_SIZE = 200;
/**
* Estimated increase in database size after import.
*/
private static final long DATABASE_SIZE_MULTIPLIER = 4;
/**
* Estimated minimum database size in megabytes.
*/
private static final long DATABASE_MIN_SIZE = 5;
private final Context mContext;
private final ContactsProvider2 mContactsProvider;
private ContactsDatabaseHelper mDbHelper;
private ContentValues mValues = new ContentValues();
private ContentResolver mResolver;
private boolean mPhoneticNameAvailable = true;
private SQLiteDatabase mSourceDb;
private SQLiteDatabase mTargetDb;
private NameSplitter mNameSplitter;
private int mBatchCounter;
private int mContactCount;
private long mStructuredNameMimetypeId;
private long mNoteMimetypeId;
private long mOrganizationMimetypeId;
private long mPhoneMimetypeId;
private long mEmailMimetypeId;
private long mImMimetypeId;
private long mPostalMimetypeId;
private long mPhotoMimetypeId;
private long mGroupMembershipMimetypeId;
private long mEstimatedStorageRequirement = DATABASE_MIN_SIZE;
public LegacyContactImporter(Context context, ContactsProvider2 contactsProvider) {
mContext = context;
mContactsProvider = contactsProvider;
mResolver = mContactsProvider.getContext().getContentResolver();
}
public boolean importContacts() throws Exception {
String path = mContext.getDatabasePath(DATABASE_NAME).getPath();
File file = new File(path);
if (!file.exists()) {
Log.i(TAG, "Legacy contacts database does not exist at " + path);
return true;
}
Log.w(TAG, "Importing contacts from " + path);
for (int i = 0; i < MAX_ATTEMPTS; i++) {
try {
mSourceDb = SQLiteDatabase.openDatabase(path, null, SQLiteDatabase.OPEN_READONLY);
importContactsFromLegacyDb();
Log.i(TAG, "Imported legacy contacts: " + mContactCount);
mContactsProvider.notifyChange();
return true;
} catch (SQLiteException e) {
Log.e(TAG, "Database import exception. Will retry in " + DELAY_BETWEEN_ATTEMPTS
+ "ms", e);
// We could get a "database locked" exception here, in which
// case we should retry
Thread.sleep(DELAY_BETWEEN_ATTEMPTS);
} finally {
if (mSourceDb != null) {
mSourceDb.close();
}
}
}
long oldDatabaseSize = file.length();
mEstimatedStorageRequirement = oldDatabaseSize * DATABASE_SIZE_MULTIPLIER / 1024 / 1024;
if (mEstimatedStorageRequirement < DATABASE_MIN_SIZE) {
mEstimatedStorageRequirement = DATABASE_MIN_SIZE;
}
return false;
}
public long getEstimatedStorageRequirement() {
return mEstimatedStorageRequirement;
}
private void importContactsFromLegacyDb() {
int version = mSourceDb.getVersion();
// Upgrade to version 78 was the latest that wiped out data. Might as well follow suit
// and ignore earlier versions.
if (version < 78) {
return;
}
if (version < 80) {
mPhoneticNameAvailable = false;
}
mDbHelper = (ContactsDatabaseHelper)mContactsProvider.getDatabaseHelper();
mTargetDb = mDbHelper.getWritableDatabase();
mStructuredNameMimetypeId = mDbHelper.getMimeTypeId(StructuredName.CONTENT_ITEM_TYPE);
mNoteMimetypeId = mDbHelper.getMimeTypeId(Note.CONTENT_ITEM_TYPE);
mOrganizationMimetypeId = mDbHelper.getMimeTypeId(Organization.CONTENT_ITEM_TYPE);
mPhoneMimetypeId = mDbHelper.getMimeTypeId(Phone.CONTENT_ITEM_TYPE);
mEmailMimetypeId = mDbHelper.getMimeTypeId(Email.CONTENT_ITEM_TYPE);
mImMimetypeId = mDbHelper.getMimeTypeId(Im.CONTENT_ITEM_TYPE);
mPostalMimetypeId = mDbHelper.getMimeTypeId(StructuredPostal.CONTENT_ITEM_TYPE);
mPhotoMimetypeId = mDbHelper.getMimeTypeId(Photo.CONTENT_ITEM_TYPE);
mGroupMembershipMimetypeId =
mDbHelper.getMimeTypeId(GroupMembership.CONTENT_ITEM_TYPE);
mNameSplitter = mContactsProvider.getNameSplitter();
mTargetDb.beginTransaction();
try {
checkForImportFailureTest();
/*
* At this point there should be no data in the contacts provider, but in case
* some was inserted by mistake, we should remove it. The main reason for this
* is that we will be preserving original contact IDs and don't want to run into
* any collisions.
*/
mContactsProvider.wipeData();
importGroups();
importPeople();
importOrganizations();
importPhones();
importContactMethods();
importPhotos();
importGroupMemberships();
updateDisplayNamesAndLookupKeys();
// Deleted contacts should be inserted after everything else, because
// the legacy table does not provide an _ID field - the _ID field
// will be autoincremented
importDeletedPeople();
mDbHelper.updateAllVisible();
mTargetDb.setTransactionSuccessful();
} finally {
mTargetDb.endTransaction();
}
importCalls();
}
/**
* This is used for simulating an import failure. Insert a row into the "settings"
* table with key='TEST' and then proceed with the upgrade. Remove the record
* after verifying the failure handling.
*/
private void checkForImportFailureTest() {
long isTest = DatabaseUtils.longForQuery(mSourceDb,
"SELECT COUNT(*) FROM settings WHERE key='TEST'", null);
if (isTest != 0) {
throw new SQLiteException("Testing import failure.");
}
}
private interface GroupsQuery {
String TABLE = "groups";
String[] COLUMNS = {
"_id", "name", "notes", "should_sync", "system_id", "_sync_account", "_sync_id",
"_sync_dirty",
};
static int ID = 0;
static int NAME = 1;
static int NOTES = 2;
static int SHOULD_SYNC = 3; // TODO add this feature to Groups
static int SYSTEM_ID = 4;
static int _SYNC_ACCOUNT = 5;
static int _SYNC_ID = 6;
static int _SYNC_DIRTY = 7;
}
private interface GroupsInsert {
String INSERT_SQL = "INSERT INTO " + Tables.GROUPS + "(" +
Groups._ID + "," +
Groups.TITLE + "," +
Groups.NOTES + "," +
Groups.SYSTEM_ID + "," +
Groups.DIRTY + "," +
Groups.GROUP_VISIBLE + "," +
Groups.ACCOUNT_NAME + "," +
Groups.ACCOUNT_TYPE + "," +
Groups.SOURCE_ID +
") VALUES (?,?,?,?,?,?,?,?,?)";
int ID = 1;
int TITLE = 2;
int NOTES = 3;
int SYSTEM_ID = 4;
int DIRTY = 5;
int GROUP_VISIBLE = 6;
int ACCOUNT_NAME = 7;
int ACCOUNT_TYPE = 8;
int SOURCE_ID = 9;
}
private void importGroups() {
SQLiteStatement insert = mTargetDb.compileStatement(GroupsInsert.INSERT_SQL);
Cursor c = mSourceDb.query(GroupsQuery.TABLE, GroupsQuery.COLUMNS, null, null,
null, null, null);
try {
while (c.moveToNext()) {
insertGroup(c, insert);
}
} finally {
c.close();
insert.close();
}
}
private void insertGroup(Cursor c, SQLiteStatement insert) {
long id = c.getLong(GroupsQuery.ID);
insert.bindLong(GroupsInsert.ID, id);
bindString(insert, GroupsInsert.TITLE, c.getString(GroupsQuery.NAME));
bindString(insert, GroupsInsert.NOTES, c.getString(GroupsQuery.NOTES));
bindString(insert, GroupsInsert.SYSTEM_ID, c.getString(GroupsQuery.SYSTEM_ID));
insert.bindLong(GroupsInsert.DIRTY, c.getLong(GroupsQuery._SYNC_DIRTY));
insert.bindLong(GroupsInsert.GROUP_VISIBLE, 1);
String account = c.getString(GroupsQuery._SYNC_ACCOUNT);
if (!TextUtils.isEmpty(account)) {
bindString(insert, GroupsInsert.ACCOUNT_NAME, account);
bindString(insert, GroupsInsert.ACCOUNT_TYPE, DEFAULT_ACCOUNT_TYPE);
bindString(insert, GroupsInsert.SOURCE_ID, c.getString(GroupsQuery._SYNC_ID));
} else {
insert.bindNull(GroupsInsert.ACCOUNT_NAME);
insert.bindNull(GroupsInsert.ACCOUNT_TYPE);
insert.bindNull(GroupsInsert.SOURCE_ID);
}
insert(insert);
}
private interface PeopleQuery {
String TABLE = "people";
String NAME_SQL =
"(CASE WHEN (name IS NOT NULL AND name != '') "
+ "THEN name "
+ "ELSE "
+ "(CASE WHEN primary_organization is NOT NULL THEN "
+ "(SELECT company FROM organizations WHERE "
+ "organizations._id = primary_organization) "
+ "ELSE "
+ "(CASE WHEN primary_phone IS NOT NULL THEN "
+"(SELECT number FROM phones WHERE phones._id = primary_phone) "
+ "ELSE "
+ "(CASE WHEN primary_email IS NOT NULL THEN "
+ "(SELECT data FROM contact_methods WHERE "
+ "contact_methods._id = primary_email) "
+ "ELSE "
+ "null "
+ "END) "
+ "END) "
+ "END) "
+ "END) ";
String[] COLUMNS_WITH_DISPLAY_NAME_WITHOUT_PHONETIC_NAME = {
"_id", NAME_SQL, "notes", "times_contacted", "last_time_contacted", "starred",
"primary_phone", "primary_organization", "primary_email", "custom_ringtone",
"send_to_voicemail", "_sync_account", "_sync_id", "_sync_time", "_sync_local_id",
"_sync_dirty",
};
String[] COLUMNS_WITH_DISPLAY_NAME_WITH_PHONETIC_NAME = {
"_id", NAME_SQL, "notes", "times_contacted", "last_time_contacted", "starred",
"primary_phone", "primary_organization", "primary_email", "custom_ringtone",
"send_to_voicemail", "_sync_account", "_sync_id", "_sync_time", "_sync_local_id",
"_sync_dirty", "phonetic_name",
};
String[] COLUMNS_WITHOUT_PHONETIC_NAME = {
"_id", "name", "notes", "times_contacted", "last_time_contacted", "starred",
"primary_phone", "primary_organization", "primary_email", "custom_ringtone",
"send_to_voicemail", "_sync_account", "_sync_id", "_sync_time", "_sync_local_id",
"_sync_dirty",
};
String[] COLUMNS_WITH_PHONETIC_NAME = {
"_id", "name", "notes", "times_contacted", "last_time_contacted", "starred",
"primary_phone", "primary_organization", "primary_email", "custom_ringtone",
"send_to_voicemail", "_sync_account", "_sync_id", "_sync_time", "_sync_local_id",
"_sync_dirty", "phonetic_name",
};
static int _ID = 0;
static int NAME = 1;
static int NOTES = 2;
static int TIMES_CONTACTED = 3;
static int LAST_TIME_CONTACTED = 4;
static int STARRED = 5;
static int PRIMARY_PHONE = 6;
static int PRIMARY_ORGANIZATION = 7;
static int PRIMARY_EMAIL = 8;
static int CUSTOM_RINGTONE = 9;
static int SEND_TO_VOICEMAIL = 10;
static int _SYNC_ACCOUNT = 11;
static int _SYNC_ID = 12;
static int _SYNC_TIME = 13;
static int _SYNC_LOCAL_ID = 14;
static int _SYNC_DIRTY = 15;
static int PHONETIC_NAME = 16;
}
private interface RawContactsInsert {
String INSERT_SQL = "INSERT INTO " + Tables.RAW_CONTACTS + "(" +
RawContacts._ID + "," +
RawContacts.CONTACT_ID + "," +
RawContacts.CUSTOM_RINGTONE + "," +
RawContacts.DIRTY + "," +
RawContacts.LAST_TIME_CONTACTED + "," +
RawContacts.SEND_TO_VOICEMAIL + "," +
RawContacts.STARRED + "," +
RawContacts.TIMES_CONTACTED + "," +
RawContacts.SYNC1 + "," +
RawContacts.SYNC2 + "," +
RawContacts.ACCOUNT_NAME + "," +
RawContacts.ACCOUNT_TYPE + "," +
RawContacts.SOURCE_ID + "," +
RawContactsColumns.DISPLAY_NAME + "," +
RawContactsColumns.CONTACT_IN_VISIBLE_GROUP +
") VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)";
int ID = 1;
int CONTACT_ID = 2;
int CUSTOM_RINGTONE = 3;
int DIRTY = 4;
int LAST_TIME_CONTACTED = 5;
int SEND_TO_VOICEMAIL = 6;
int STARRED = 7;
int TIMES_CONTACTED = 8;
int SYNC1 = 9;
int SYNC2 = 10;
int ACCOUNT_NAME = 11;
int ACCOUNT_TYPE = 12;
int SOURCE_ID = 13;
int DISPLAY_NAME = 14;
int CONTACT_IN_VISIBLE_GROUP = 15;
}
private interface ContactsInsert {
String INSERT_SQL = "INSERT INTO " + Tables.CONTACTS + "(" +
Contacts._ID + "," +
Contacts.CUSTOM_RINGTONE + "," +
Contacts.LAST_TIME_CONTACTED + "," +
Contacts.SEND_TO_VOICEMAIL + "," +
Contacts.STARRED + "," +
Contacts.TIMES_CONTACTED + "," +
Contacts.NAME_RAW_CONTACT_ID + "," +
Contacts.IN_VISIBLE_GROUP +
") VALUES (?,?,?,?,?,?,?,?)";
int ID = 1;
int CUSTOM_RINGTONE = 2;
int LAST_TIME_CONTACTED = 3;
int SEND_TO_VOICEMAIL = 4;
int STARRED = 5;
int TIMES_CONTACTED = 6;
int NAME_RAW_CONTACT_ID = 7;
int IN_VISIBLE_GROUP = 8;
}
private interface StructuredNameInsert {
String INSERT_SQL = "INSERT INTO " + Tables.DATA + "(" +
Data.RAW_CONTACT_ID + "," +
DataColumns.MIMETYPE_ID + "," +
StructuredName.DISPLAY_NAME + "," +
StructuredName.PREFIX + "," +
StructuredName.GIVEN_NAME + "," +
StructuredName.MIDDLE_NAME + "," +
StructuredName.FAMILY_NAME + "," +
StructuredName.SUFFIX + "," +
StructuredName.FULL_NAME_STYLE + "," +
StructuredName.PHONETIC_FAMILY_NAME + "," +
StructuredName.PHONETIC_MIDDLE_NAME + "," +
StructuredName.PHONETIC_GIVEN_NAME + "," +
StructuredName.PHONETIC_NAME_STYLE +
") VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?)";
int RAW_CONTACT_ID = 1;
int MIMETYPE_ID = 2;
int DISPLAY_NAME = 3;
int PREFIX = 4;
int GIVEN_NAME = 5;
int MIDDLE_NAME = 6;
int FAMILY_NAME = 7;
int SUFFIX = 8;
int FULL_NAME_STYLE = 9;
int PHONETIC_FAMILY_NAME = 10;
int PHONETIC_MIDDLE_NAME = 11;
int PHONETIC_GIVEN_NAME = 12;
int PHONETIC_NAME_STYLE = 13;
}
private interface NoteInsert {
String INSERT_SQL = "INSERT INTO " + Tables.DATA + "(" +
Data.RAW_CONTACT_ID + "," +
DataColumns.MIMETYPE_ID + "," +
Note.NOTE +
") VALUES (?,?,?)";
int RAW_CONTACT_ID = 1;
int MIMETYPE_ID = 2;
int NOTE = 3;
}
private void importPeople() {
SQLiteStatement rawContactInsert = mTargetDb.compileStatement(RawContactsInsert.INSERT_SQL);
SQLiteStatement contactInsert = mTargetDb.compileStatement(ContactsInsert.INSERT_SQL);
SQLiteStatement structuredNameInsert =
mTargetDb.compileStatement(StructuredNameInsert.INSERT_SQL);
SQLiteStatement noteInsert = mTargetDb.compileStatement(NoteInsert.INSERT_SQL);
try {
String[] columns = mPhoneticNameAvailable
? PeopleQuery.COLUMNS_WITH_DISPLAY_NAME_WITH_PHONETIC_NAME
: PeopleQuery.COLUMNS_WITH_DISPLAY_NAME_WITHOUT_PHONETIC_NAME;
Cursor c = mSourceDb.query(PeopleQuery.TABLE, columns, "name IS NULL", null, null,
null, null);
try {
while (c.moveToNext()) {
insertRawContact(c, rawContactInsert);
insertContact(c, contactInsert);
insertNote(c, noteInsert);
mContactCount++;
}
} finally {
c.close();
}
columns = mPhoneticNameAvailable
? PeopleQuery.COLUMNS_WITH_PHONETIC_NAME
: PeopleQuery.COLUMNS_WITHOUT_PHONETIC_NAME;
c = mSourceDb.query(PeopleQuery.TABLE, columns, "name IS NOT NULL", null, null, null,
null);
try {
while (c.moveToNext()) {
long id = insertRawContact(c, rawContactInsert);
insertContact(c, contactInsert);
insertStructuredName(c, structuredNameInsert);
insertNote(c, noteInsert);
mContactCount++;
}
} finally {
c.close();
}
} finally {
rawContactInsert.close();
contactInsert.close();
structuredNameInsert.close();
noteInsert.close();
}
}
private long insertRawContact(Cursor c, SQLiteStatement insert) {
long id = c.getLong(PeopleQuery._ID);
insert.bindLong(RawContactsInsert.ID, id);
insert.bindLong(RawContactsInsert.CONTACT_ID, id);
bindString(insert, RawContactsInsert.CUSTOM_RINGTONE,
c.getString(PeopleQuery.CUSTOM_RINGTONE));
bindString(insert, RawContactsInsert.DIRTY,
c.getString(PeopleQuery._SYNC_DIRTY));
insert.bindLong(RawContactsInsert.LAST_TIME_CONTACTED,
c.getLong(PeopleQuery.LAST_TIME_CONTACTED));
insert.bindLong(RawContactsInsert.SEND_TO_VOICEMAIL,
c.getLong(PeopleQuery.SEND_TO_VOICEMAIL));
insert.bindLong(RawContactsInsert.STARRED,
c.getLong(PeopleQuery.STARRED));
insert.bindLong(RawContactsInsert.TIMES_CONTACTED,
c.getLong(PeopleQuery.TIMES_CONTACTED));
bindString(insert, RawContactsInsert.SYNC1,
c.getString(PeopleQuery._SYNC_TIME));
bindString(insert, RawContactsInsert.SYNC2,
c.getString(PeopleQuery._SYNC_LOCAL_ID));
bindString(insert, RawContactsInsert.DISPLAY_NAME,
c.getString(PeopleQuery.NAME));
insert.bindLong(RawContactsInsert.CONTACT_IN_VISIBLE_GROUP, 1);
String account = c.getString(PeopleQuery._SYNC_ACCOUNT);
if (!TextUtils.isEmpty(account)) {
bindString(insert, RawContactsInsert.ACCOUNT_NAME, account);
bindString(insert, RawContactsInsert.ACCOUNT_TYPE, DEFAULT_ACCOUNT_TYPE);
bindString(insert, RawContactsInsert.SOURCE_ID, c.getString(PeopleQuery._SYNC_ID));
} else {
insert.bindNull(RawContactsInsert.ACCOUNT_NAME);
insert.bindNull(RawContactsInsert.ACCOUNT_TYPE);
insert.bindNull(RawContactsInsert.SOURCE_ID);
}
insert(insert);
return id;
}
private void insertContact(Cursor c, SQLiteStatement insert) {
long id = c.getLong(PeopleQuery._ID);
insert.bindLong(ContactsInsert.ID, id);
bindString(insert, ContactsInsert.CUSTOM_RINGTONE,
c.getString(PeopleQuery.CUSTOM_RINGTONE));
insert.bindLong(ContactsInsert.LAST_TIME_CONTACTED,
c.getLong(PeopleQuery.LAST_TIME_CONTACTED));
insert.bindLong(ContactsInsert.SEND_TO_VOICEMAIL,
c.getLong(PeopleQuery.SEND_TO_VOICEMAIL));
insert.bindLong(ContactsInsert.STARRED,
c.getLong(PeopleQuery.STARRED));
insert.bindLong(ContactsInsert.TIMES_CONTACTED,
c.getLong(PeopleQuery.TIMES_CONTACTED));
insert.bindLong(ContactsInsert.NAME_RAW_CONTACT_ID, id);
insert.bindLong(ContactsInsert.IN_VISIBLE_GROUP, 1);
insert(insert);
}
private void insertStructuredName(Cursor c, SQLiteStatement insert) {
String name = c.getString(PeopleQuery.NAME);
if (TextUtils.isEmpty(name)) {
return;
}
long id = c.getLong(PeopleQuery._ID);
insert.bindLong(StructuredNameInsert.RAW_CONTACT_ID, id);
insert.bindLong(StructuredNameInsert.MIMETYPE_ID, mStructuredNameMimetypeId);
bindString(insert, StructuredNameInsert.DISPLAY_NAME, name);
NameSplitter.Name splitName = new NameSplitter.Name();
mNameSplitter.split(splitName, name);
bindString(insert, StructuredNameInsert.PREFIX,
splitName.getPrefix());
bindString(insert, StructuredNameInsert.GIVEN_NAME,
splitName.getGivenNames());
bindString(insert, StructuredNameInsert.MIDDLE_NAME,
splitName.getMiddleName());
bindString(insert, StructuredNameInsert.FAMILY_NAME,
splitName.getFamilyName());
bindString(insert, StructuredNameInsert.SUFFIX,
splitName.getSuffix());
final String joined = mNameSplitter.join(splitName, true);
bindString(insert, StructuredNameInsert.DISPLAY_NAME, joined);
if (mPhoneticNameAvailable) {
String phoneticName = c.getString(PeopleQuery.PHONETIC_NAME);
if (phoneticName != null) {
int index = phoneticName.indexOf(' ');
if (index == -1) {
splitName.phoneticFamilyName = phoneticName;
} else {
splitName.phoneticFamilyName = phoneticName.substring(0, index).trim();
splitName.phoneticGivenName = phoneticName.substring(index + 1).trim();
}
}
}
mNameSplitter.guessNameStyle(splitName);
int fullNameStyle = splitName.getFullNameStyle();
insert.bindLong(StructuredNameInsert.FULL_NAME_STYLE,
fullNameStyle);
bindString(insert, StructuredNameInsert.PHONETIC_FAMILY_NAME,
splitName.phoneticFamilyName);
bindString(insert, StructuredNameInsert.PHONETIC_MIDDLE_NAME,
splitName.phoneticMiddleName);
bindString(insert, StructuredNameInsert.PHONETIC_GIVEN_NAME,
splitName.phoneticGivenName);
insert.bindLong(StructuredNameInsert.PHONETIC_NAME_STYLE,
splitName.phoneticNameStyle);
long dataId = insert(insert);
mContactsProvider.insertNameLookupForStructuredName(id, dataId, name,
mNameSplitter.getAdjustedFullNameStyle(fullNameStyle));
if (splitName.phoneticFamilyName != null
|| splitName.phoneticMiddleName != null
|| splitName.phoneticGivenName != null) {
mContactsProvider.insertNameLookupForPhoneticName(id, dataId,
splitName.phoneticFamilyName,
splitName.phoneticMiddleName,
splitName.phoneticGivenName);
}
}
private void insertNote(Cursor c, SQLiteStatement insert) {
String notes = c.getString(PeopleQuery.NOTES);
if (TextUtils.isEmpty(notes)) {
return;
}
long id = c.getLong(PeopleQuery._ID);
insert.bindLong(NoteInsert.RAW_CONTACT_ID, id);
insert.bindLong(NoteInsert.MIMETYPE_ID, mNoteMimetypeId);
bindString(insert, NoteInsert.NOTE, notes);
insert(insert);
}
private interface OrganizationsQuery {
String TABLE = "organizations";
String[] COLUMNS = {
"person", "company", "title", "isprimary", "type", "label",
};
static int PERSON = 0;
static int COMPANY = 1;
static int TITLE = 2;
static int ISPRIMARY = 3;
static int TYPE = 4;
static int LABEL = 5;
}
private interface OrganizationInsert {
String INSERT_SQL = "INSERT INTO " + Tables.DATA + "(" +
Data.RAW_CONTACT_ID + "," +
DataColumns.MIMETYPE_ID + "," +
Data.IS_PRIMARY + "," +
Data.IS_SUPER_PRIMARY + "," +
Organization.COMPANY + "," +
Organization.TITLE + "," +
Organization.TYPE + "," +
Organization.LABEL +
") VALUES (?,?,?,?,?,?,?,?)";
int RAW_CONTACT_ID = 1;
int MIMETYPE_ID = 2;
int IS_PRIMARY = 3;
int IS_SUPER_PRIMARY = 4;
int COMPANY = 5;
int TITLE = 6;
int TYPE = 7;
int LABEL = 8;
}
private void importOrganizations() {
SQLiteStatement insert = mTargetDb.compileStatement(OrganizationInsert.INSERT_SQL);
Cursor c = mSourceDb.query(OrganizationsQuery.TABLE, OrganizationsQuery.COLUMNS, null, null,
null, null, null);
try {
while (c.moveToNext()) {
insertOrganization(c, insert);
}
} finally {
c.close();
insert.close();
}
}
private void insertOrganization(Cursor c, SQLiteStatement insert) {
long id = c.getLong(OrganizationsQuery.PERSON);
insert.bindLong(OrganizationInsert.RAW_CONTACT_ID, id);
insert.bindLong(OrganizationInsert.MIMETYPE_ID, mOrganizationMimetypeId);
bindString(insert, OrganizationInsert.IS_PRIMARY, c.getString(OrganizationsQuery.ISPRIMARY));
bindString(insert, OrganizationInsert.IS_SUPER_PRIMARY,
c.getString(OrganizationsQuery.ISPRIMARY));
bindString(insert, OrganizationInsert.COMPANY, c.getString(OrganizationsQuery.COMPANY));
bindString(insert, OrganizationInsert.TITLE, c.getString(OrganizationsQuery.TITLE));
bindString(insert, OrganizationInsert.TYPE, c.getString(OrganizationsQuery.TYPE));
bindString(insert, OrganizationInsert.LABEL, c.getString(OrganizationsQuery.LABEL));
insert(insert);
}
private interface ContactMethodsQuery {
String TABLE = "contact_methods";
String[] COLUMNS = {
"person", "kind", "data", "aux_data", "type", "label", "isprimary",
};
static int PERSON = 0;
static int KIND = 1;
static int DATA = 2;
static int AUX_DATA = 3;
static int TYPE = 4;
static int LABEL = 5;
static int ISPRIMARY = 6;
}
private interface EmailInsert {
String INSERT_SQL = "INSERT INTO " + Tables.DATA + "(" +
Data.RAW_CONTACT_ID + "," +
DataColumns.MIMETYPE_ID + "," +
Data.IS_PRIMARY + "," +
Data.IS_SUPER_PRIMARY + "," +
Email.DATA + "," +
Email.TYPE + "," +
Email.LABEL + "," +
Data.DATA14 +
") VALUES (?,?,?,?,?,?,?,?)";
int RAW_CONTACT_ID = 1;
int MIMETYPE_ID = 2;
int IS_PRIMARY = 3;
int IS_SUPER_PRIMARY = 4;
int DATA = 5;
int TYPE = 6;
int LABEL = 7;
int AUX_DATA = 8;
}
private interface ImInsert {
String INSERT_SQL = "INSERT INTO " + Tables.DATA + "(" +
Data.RAW_CONTACT_ID + "," +
DataColumns.MIMETYPE_ID + "," +
Data.IS_PRIMARY + "," +
Data.IS_SUPER_PRIMARY + "," +
Im.DATA + "," +
Im.TYPE + "," +
Im.LABEL + "," +
Data.DATA14 +
") VALUES (?,?,?,?,?,?,?,?)";
int RAW_CONTACT_ID = 1;
int MIMETYPE_ID = 2;
int IS_PRIMARY = 3;
int IS_SUPER_PRIMARY = 4;
int DATA = 5;
int TYPE = 6;
int LABEL = 7;
int AUX_DATA = 8;
}
private interface PostalInsert {
String INSERT_SQL = "INSERT INTO " + Tables.DATA + "(" +
Data.RAW_CONTACT_ID + "," +
DataColumns.MIMETYPE_ID + "," +
Data.IS_PRIMARY + "," +
Data.IS_SUPER_PRIMARY + "," +
StructuredPostal.FORMATTED_ADDRESS + "," +
StructuredPostal.TYPE + "," +
StructuredPostal.LABEL + "," +
Data.DATA14 +
") VALUES (?,?,?,?,?,?,?,?)";
int RAW_CONTACT_ID = 1;
int MIMETYPE_ID = 2;
int IS_PRIMARY = 3;
int IS_SUPER_PRIMARY = 4;
int DATA = 5;
int TYPE = 6;
int LABEL = 7;
int AUX_DATA = 8;
}
private void importContactMethods() {
SQLiteStatement emailInsert = mTargetDb.compileStatement(EmailInsert.INSERT_SQL);
SQLiteStatement imInsert = mTargetDb.compileStatement(ImInsert.INSERT_SQL);
SQLiteStatement postalInsert = mTargetDb.compileStatement(PostalInsert.INSERT_SQL);
Cursor c = mSourceDb.query(ContactMethodsQuery.TABLE, ContactMethodsQuery.COLUMNS, null,
null, null, null, null);
try {
while (c.moveToNext()) {
int kind = c.getInt(ContactMethodsQuery.KIND);
switch (kind) {
case android.provider.Contacts.KIND_EMAIL:
insertEmail(c, emailInsert);
break;
case android.provider.Contacts.KIND_IM:
insertIm(c, imInsert);
break;
case android.provider.Contacts.KIND_POSTAL:
insertPostal(c, postalInsert);
break;
}
}
} finally {
c.close();
emailInsert.close();
imInsert.close();
postalInsert.close();
}
}
private void insertEmail(Cursor c, SQLiteStatement insert) {
long personId = c.getLong(ContactMethodsQuery.PERSON);
String email = c.getString(ContactMethodsQuery.DATA);
insert.bindLong(EmailInsert.RAW_CONTACT_ID, personId);
insert.bindLong(EmailInsert.MIMETYPE_ID, mEmailMimetypeId);
bindString(insert, EmailInsert.IS_PRIMARY, c.getString(ContactMethodsQuery.ISPRIMARY));
bindString(insert, EmailInsert.IS_SUPER_PRIMARY, c.getString(ContactMethodsQuery.ISPRIMARY));
bindString(insert, EmailInsert.DATA, email);
bindString(insert, EmailInsert.AUX_DATA, c.getString(ContactMethodsQuery.AUX_DATA));
bindString(insert, EmailInsert.TYPE, c.getString(ContactMethodsQuery.TYPE));
bindString(insert, EmailInsert.LABEL, c.getString(ContactMethodsQuery.LABEL));
long dataId = insert(insert);
mContactsProvider.insertNameLookupForEmail(personId, dataId, email);
}
private void insertIm(Cursor c, SQLiteStatement insert) {
long personId = c.getLong(ContactMethodsQuery.PERSON);
insert.bindLong(ImInsert.RAW_CONTACT_ID, personId);
insert.bindLong(ImInsert.MIMETYPE_ID, mImMimetypeId);
bindString(insert, ImInsert.IS_PRIMARY, c.getString(ContactMethodsQuery.ISPRIMARY));
bindString(insert, ImInsert.IS_SUPER_PRIMARY, c.getString(ContactMethodsQuery.ISPRIMARY));
bindString(insert, ImInsert.DATA, c.getString(ContactMethodsQuery.DATA));
bindString(insert, ImInsert.AUX_DATA, c.getString(ContactMethodsQuery.AUX_DATA));
bindString(insert, ImInsert.TYPE, c.getString(ContactMethodsQuery.TYPE));
bindString(insert, ImInsert.LABEL, c.getString(ContactMethodsQuery.LABEL));
insert(insert);
}
private void insertPostal(Cursor c, SQLiteStatement insert) {
long personId = c.getLong(ContactMethodsQuery.PERSON);
insert.bindLong(PostalInsert.RAW_CONTACT_ID, personId);
insert.bindLong(PostalInsert.MIMETYPE_ID, mPostalMimetypeId);
bindString(insert, PostalInsert.IS_PRIMARY, c.getString(ContactMethodsQuery.ISPRIMARY));
bindString(insert, PostalInsert.IS_SUPER_PRIMARY,
c.getString(ContactMethodsQuery.ISPRIMARY));
bindString(insert, PostalInsert.DATA, c.getString(ContactMethodsQuery.DATA));
bindString(insert, PostalInsert.AUX_DATA, c.getString(ContactMethodsQuery.AUX_DATA));
bindString(insert, PostalInsert.TYPE, c.getString(ContactMethodsQuery.TYPE));
bindString(insert, PostalInsert.LABEL, c.getString(ContactMethodsQuery.LABEL));
insert(insert);
}
private interface PhonesQuery {
String TABLE = "phones";
String[] COLUMNS = {
"person", "type", "number", "label", "isprimary",
};
static int PERSON = 0;
static int TYPE = 1;
static int NUMBER = 2;
static int LABEL = 3;
static int ISPRIMARY = 4;
}
private interface PhoneInsert {
String INSERT_SQL = "INSERT INTO " + Tables.DATA + "(" +
Data.RAW_CONTACT_ID + "," +
DataColumns.MIMETYPE_ID + "," +
Data.IS_PRIMARY + "," +
Data.IS_SUPER_PRIMARY + "," +
Phone.NUMBER + "," +
Phone.TYPE + "," +
Phone.LABEL + "," +
PhoneColumns.NORMALIZED_NUMBER +
") VALUES (?,?,?,?,?,?,?,?)";
int RAW_CONTACT_ID = 1;
int MIMETYPE_ID = 2;
int IS_PRIMARY = 3;
int IS_SUPER_PRIMARY = 4;
int NUMBER = 5;
int TYPE = 6;
int LABEL = 7;
int NORMALIZED_NUMBER = 8;
}
private interface PhoneLookupInsert {
String INSERT_SQL = "INSERT INTO " + Tables.PHONE_LOOKUP + "(" +
PhoneLookupColumns.RAW_CONTACT_ID + "," +
PhoneLookupColumns.DATA_ID + "," +
PhoneLookupColumns.NORMALIZED_NUMBER + "," +
PhoneLookupColumns.MIN_MATCH +
") VALUES (?,?,?,?)";
int RAW_CONTACT_ID = 1;
int DATA_ID = 2;
int NORMALIZED_NUMBER = 3;
int MIN_MATCH = 4;
}
private interface HasPhoneNumberUpdate {
String UPDATE_SQL = "UPDATE " + Tables.CONTACTS +
" SET " + Contacts.HAS_PHONE_NUMBER + "=1 WHERE " + Contacts._ID + "=?";
int CONTACT_ID = 1;
}
private void importPhones() {
SQLiteStatement phoneInsert = mTargetDb.compileStatement(PhoneInsert.INSERT_SQL);
SQLiteStatement phoneLookupInsert =
mTargetDb.compileStatement(PhoneLookupInsert.INSERT_SQL);
SQLiteStatement hasPhoneUpdate =
mTargetDb.compileStatement(HasPhoneNumberUpdate.UPDATE_SQL);
Cursor c = mSourceDb.query(PhonesQuery.TABLE, PhonesQuery.COLUMNS, null, null,
null, null, null);
try {
while (c.moveToNext()) {
insertPhone(c, phoneInsert, phoneLookupInsert, hasPhoneUpdate);
}
} finally {
c.close();
phoneInsert.close();
phoneLookupInsert.close();
hasPhoneUpdate.close();
}
}
private void insertPhone(Cursor c, SQLiteStatement phoneInsert,
SQLiteStatement phoneLookupInsert, SQLiteStatement hasPhoneUpdate) {
long lastUpdatedContact = -1;
long id = c.getLong(PhonesQuery.PERSON);
String number = c.getString(PhonesQuery.NUMBER);
String normalizedNumber = null;
if (number != null) {
normalizedNumber = PhoneNumberUtils.getStrippedReversed(number);
}
phoneInsert.bindLong(PhoneInsert.RAW_CONTACT_ID, id);
phoneInsert.bindLong(PhoneInsert.MIMETYPE_ID, mPhoneMimetypeId);
bindString(phoneInsert, PhoneInsert.IS_PRIMARY, c.getString(PhonesQuery.ISPRIMARY));
bindString(phoneInsert, PhoneInsert.IS_SUPER_PRIMARY, c.getString(PhonesQuery.ISPRIMARY));
bindString(phoneInsert, PhoneInsert.NUMBER, number);
bindString(phoneInsert, PhoneInsert.TYPE, c.getString(PhonesQuery.TYPE));
bindString(phoneInsert, PhoneInsert.LABEL, c.getString(PhonesQuery.LABEL));
bindString(phoneInsert, PhoneInsert.NORMALIZED_NUMBER, normalizedNumber);
long dataId = insert(phoneInsert);
if (normalizedNumber != null) {
phoneLookupInsert.bindLong(PhoneLookupInsert.RAW_CONTACT_ID, id);
phoneLookupInsert.bindLong(PhoneLookupInsert.DATA_ID, dataId);
phoneLookupInsert.bindString(PhoneLookupInsert.NORMALIZED_NUMBER, normalizedNumber);
phoneLookupInsert.bindString(PhoneLookupInsert.MIN_MATCH,
PhoneNumberUtils.toCallerIDMinMatch(number));
insert(phoneLookupInsert);
if (lastUpdatedContact != id) {
lastUpdatedContact = id;
hasPhoneUpdate.bindLong(HasPhoneNumberUpdate.CONTACT_ID, id);
hasPhoneUpdate.execute();
}
}
}
private interface PhotosQuery {
String TABLE = "photos";
String[] COLUMNS = {
"person", "data", "_sync_id", "_sync_account"
};
static int PERSON = 0;
static int DATA = 1;
static int _SYNC_ID = 2;
static int _SYNC_ACCOUNT = 3;
}
private interface PhotoInsert {
String INSERT_SQL = "INSERT INTO " + Tables.DATA + "(" +
Data.RAW_CONTACT_ID + "," +
DataColumns.MIMETYPE_ID + "," +
Photo.PHOTO + "," +
Data.SYNC1 +
") VALUES (?,?,?,?)";
int RAW_CONTACT_ID = 1;
int MIMETYPE_ID = 2;
int PHOTO = 3;
int SYNC1 = 4;
}
private interface PhotoIdUpdate {
String UPDATE_SQL = "UPDATE " + Tables.CONTACTS +
" SET " + Contacts.PHOTO_ID + "=? WHERE " + Contacts._ID + "=?";
int PHOTO_ID = 1;
int CONTACT_ID = 2;
}
private void importPhotos() {
SQLiteStatement insert = mTargetDb.compileStatement(PhotoInsert.INSERT_SQL);
SQLiteStatement photoIdUpdate = mTargetDb.compileStatement(PhotoIdUpdate.UPDATE_SQL);
Cursor c = mSourceDb.query(PhotosQuery.TABLE, PhotosQuery.COLUMNS, null, null,
null, null, null);
try {
while (c.moveToNext()) {
insertPhoto(c, insert, photoIdUpdate);
}
} finally {
c.close();
insert.close();
photoIdUpdate.close();
}
}
private void insertPhoto(Cursor c, SQLiteStatement insert, SQLiteStatement photoIdUpdate) {
if (c.isNull(PhotosQuery.DATA)) {
return;
}
long personId = c.getLong(PhotosQuery.PERSON);
insert.bindLong(PhotoInsert.RAW_CONTACT_ID, personId);
insert.bindLong(PhotoInsert.MIMETYPE_ID, mPhotoMimetypeId);
insert.bindBlob(PhotoInsert.PHOTO, c.getBlob(PhotosQuery.DATA));
String account = c.getString(PhotosQuery._SYNC_ACCOUNT);
if (!TextUtils.isEmpty(account)) {
bindString(insert, PhotoInsert.SYNC1, c.getString(PhotosQuery._SYNC_ID));
} else {
insert.bindNull(PhotoInsert.SYNC1);
}
long rowId = insert(insert);
photoIdUpdate.bindLong(PhotoIdUpdate.PHOTO_ID, rowId);
photoIdUpdate.bindLong(PhotoIdUpdate.CONTACT_ID, personId);
photoIdUpdate.execute();
}
private interface GroupMembershipQuery {
String TABLE = "groupmembership";
String[] COLUMNS = {
"person", "group_id", "group_sync_account", "group_sync_id"
};
static int PERSON_ID = 0;
static int GROUP_ID = 1;
static int GROUP_SYNC_ACCOUNT = 2;
static int GROUP_SYNC_ID = 3;
}
private interface GroupMembershipInsert {
String INSERT_SQL = "INSERT INTO " + Tables.DATA + "(" +
Data.RAW_CONTACT_ID + "," +
DataColumns.MIMETYPE_ID + "," +
GroupMembership.GROUP_ROW_ID +
") VALUES (?,?,?)";
int RAW_CONTACT_ID = 1;
int MIMETYPE_ID = 2;
int GROUP_ROW_ID = 3;
}
private void importGroupMemberships() {
SQLiteStatement insert = mTargetDb.compileStatement(GroupMembershipInsert.INSERT_SQL);
Cursor c = mSourceDb.query(GroupMembershipQuery.TABLE, GroupMembershipQuery.COLUMNS, null,
null, null, null, null);
try {
while (c.moveToNext()) {
insertGroupMembership(c, insert);
}
} finally {
c.close();
insert.close();
}
}
private void insertGroupMembership(Cursor c, SQLiteStatement insert) {
long personId = c.getLong(GroupMembershipQuery.PERSON_ID);
long groupId = 0;
if (c.isNull(GroupMembershipQuery.GROUP_ID)) {
String account = c.getString(GroupMembershipQuery.GROUP_SYNC_ACCOUNT);
if (!TextUtils.isEmpty(account)) {
String syncId = c.getString(GroupMembershipQuery.GROUP_SYNC_ID);
Cursor cursor = mTargetDb.query(Tables.GROUPS,
new String[]{Groups._ID}, Groups.SOURCE_ID + "=?", new String[]{syncId},
null, null, null);
try {
if (cursor.moveToFirst()) {
groupId = cursor.getLong(0);
}
} finally {
cursor.close();
}
if (groupId == 0) {
ContentValues values = new ContentValues();
values.put(Groups.ACCOUNT_NAME, account);
values.put(Groups.ACCOUNT_TYPE, DEFAULT_ACCOUNT_TYPE);
values.put(Groups.GROUP_VISIBLE, true);
values.put(Groups.SOURCE_ID, syncId);
groupId = mTargetDb.insert(Tables.GROUPS, null, values);
}
}
} else {
groupId = c.getLong(GroupMembershipQuery.GROUP_ID);
}
insert.bindLong(GroupMembershipInsert.RAW_CONTACT_ID, personId);
insert.bindLong(GroupMembershipInsert.MIMETYPE_ID, mGroupMembershipMimetypeId);
insert.bindLong(GroupMembershipInsert.GROUP_ROW_ID, groupId);
insert(insert);
}
private interface CallsQuery {
String TABLE = "calls";
String[] COLUMNS = {
"_id", "number", "date", "duration", "type", "new", "name", "numbertype",
"numberlabel"
};
static int ID = 0;
static int NUMBER = 1;
static int DATE = 2;
static int DURATION = 3;
static int TYPE = 4;
static int NEW = 5;
static int NAME = 6;
static int NUMBER_TYPE = 7;
static int NUMBER_LABEL = 8;
}
private void importCalls() {
Cursor c = mSourceDb.query(CallsQuery.TABLE, CallsQuery.COLUMNS, null, null,
null, null, null);
try {
while (c.moveToNext()) {
insertCall(c);
}
} finally {
c.close();
}
}
private void insertCall(Cursor c) {
// Cannot use batch operations here, because call log is serviced by a separate provider
mValues.clear();
mValues.put(Calls._ID, c.getLong(CallsQuery.ID));
mValues.put(Calls.NUMBER, c.getString(CallsQuery.NUMBER));
mValues.put(Calls.DATE, c.getLong(CallsQuery.DATE));
mValues.put(Calls.DURATION, c.getLong(CallsQuery.DURATION));
mValues.put(Calls.NEW, c.getLong(CallsQuery.NEW));
mValues.put(Calls.TYPE, c.getLong(CallsQuery.TYPE));
mValues.put(Calls.CACHED_NAME, c.getString(CallsQuery.NAME));
mValues.put(Calls.CACHED_NUMBER_LABEL, c.getString(CallsQuery.NUMBER_LABEL));
mValues.put(Calls.CACHED_NUMBER_TYPE, c.getString(CallsQuery.NUMBER_TYPE));
// TODO: confirm that we can use the CallLogProvider at this point, that it is guaranteed
// to have been registered.
mResolver.insert(Calls.CONTENT_URI, mValues);
}
private void updateDisplayNamesAndLookupKeys() {
// Compute display names, sort keys, lookup key, etc. for all Raw Cont
Cursor cursor = mResolver.query(RawContacts.CONTENT_URI,
new String[] { RawContacts._ID }, null, null, null);
try {
while (cursor.moveToNext()) {
long rawContactId = cursor.getLong(0);
mContactsProvider.updateRawContactDisplayName(mTargetDb, rawContactId);
mContactsProvider.updateLookupKeyForRawContact(mTargetDb, rawContactId);
}
} finally {
cursor.close();
}
}
private interface DeletedPeopleQuery {
String TABLE = "_deleted_people";
String[] COLUMNS = {
"_sync_id", "_sync_account"
};
static int _SYNC_ID = 0;
static int _SYNC_ACCOUNT = 1;
}
private interface DeletedRawContactInsert {
String INSERT_SQL = "INSERT INTO " + Tables.RAW_CONTACTS + "(" +
RawContacts.ACCOUNT_NAME + "," +
RawContacts.ACCOUNT_TYPE + "," +
RawContacts.SOURCE_ID + "," +
RawContacts.DELETED + "," +
RawContacts.AGGREGATION_MODE +
") VALUES (?,?,?,?,?)";
int ACCOUNT_NAME = 1;
int ACCOUNT_TYPE = 2;
int SOURCE_ID = 3;
int DELETED = 4;
int AGGREGATION_MODE = 5;
}
private void importDeletedPeople() {
SQLiteStatement insert = mTargetDb.compileStatement(DeletedRawContactInsert.INSERT_SQL);
Cursor c = mSourceDb.query(DeletedPeopleQuery.TABLE, DeletedPeopleQuery.COLUMNS, null, null,
null, null, null);
try {
while (c.moveToNext()) {
insertDeletedPerson(c, insert);
}
} finally {
c.close();
insert.close();
}
}
private void insertDeletedPerson(Cursor c, SQLiteStatement insert) {
String account = c.getString(DeletedPeopleQuery._SYNC_ACCOUNT);
if (account == null) {
return;
}
insert.bindString(DeletedRawContactInsert.ACCOUNT_NAME, account);
insert.bindString(DeletedRawContactInsert.ACCOUNT_TYPE, DEFAULT_ACCOUNT_TYPE);
bindString(insert, DeletedRawContactInsert.SOURCE_ID,
c.getString(DeletedPeopleQuery._SYNC_ID));
insert.bindLong(DeletedRawContactInsert.DELETED, 1);
insert.bindLong(DeletedRawContactInsert.AGGREGATION_MODE,
RawContacts.AGGREGATION_MODE_DISABLED);
insert(insert);
}
private void bindString(SQLiteStatement insert, int index, String string) {
if (string == null) {
insert.bindNull(index);
} else {
insert.bindString(index, string);
}
}
private long insert(SQLiteStatement insertStatement) {
long rowId = insertStatement.executeInsert();
if (rowId == 0) {
throw new RuntimeException("Insert failed");
}
mBatchCounter++;
if (mBatchCounter >= INSERT_BATCH_SIZE) {
mTargetDb.setTransactionSuccessful();
mTargetDb.endTransaction();
mTargetDb.beginTransaction();
mBatchCounter = 0;
}
return rowId;
}
}