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 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();
/*
* 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();
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();
importGroups();
importPeople();
importOrganizations();
importPhones();
importContactMethods();
importPhotos();
importGroupMemberships();
// 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();
mTargetDb.endTransaction();
importCalls();
}
public void importContacts() throws Exception {
String path = mContext.getDatabasePath(DATABASE_NAME).getPath();
Log.w(TAG, "Importing contacts from " + path);
if (!new File(path).exists()) {
Log.i(TAG, "Legacy contacts database does not exist");
return;
}
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;
} 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();
}
}
}
}
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());
if (mPhoneticNameAvailable) {
// TODO: add the ability to insert an unstructured phonetic name
String phoneticName = c.getString(PeopleQuery.PHONETIC_NAME);
}
long dataId = insert(insert);
mContactsProvider.insertNameLookupForStructuredName(id, dataId, name);
}
private void updateDisplayNamesAndLookupKeys() {
// Compute display names, sort keys, lookup key, etc. for all Raw Cont
Cursor cursor =
mResolver.query(
FakeContract.RAW_CONTACTS_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 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.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);
}
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;
}
@Override
public void onReceive(Context context, Intent intent) {
// We are now running with the system up, but no apps started,
// so can do whatever cleanup after an upgrade that we want.
try {
long startTime = System.currentTimeMillis();
// Lookup the last known database version
final SharedPreferences prefs = context.getSharedPreferences(TAG, Context.MODE_PRIVATE);
final int prefDbVersion = prefs.getInt(PREF_DB_VERSION, 0);
final String curIcuVersion = ICU.getIcuVersion();
final String curOsVersion = getOsVersionString();
final String prefIcuVersion = prefs.getString(PREF_ICU_VERSION, "");
final String prefOsVersion = prefs.getString(PREF_OS_VERSION, "");
// If the version is old go ahead and attempt to create or upgrade the database.
if (prefDbVersion != ContactsDatabaseHelper.DATABASE_VERSION
|| !prefIcuVersion.equals(curIcuVersion)
|| !prefOsVersion.equals(curOsVersion)) {
// Store the current version so this receiver isn't run again until the database
// version number changes. This is intentionally done even before the upgrade path
// is attempted to be conservative. If the upgrade fails for some reason and we
// crash and burn we don't want to get into a loop doing so.
SharedPreferences.Editor editor = prefs.edit();
editor.putInt(PREF_DB_VERSION, ContactsDatabaseHelper.DATABASE_VERSION);
editor.putString(PREF_ICU_VERSION, curIcuVersion);
editor.putString(PREF_OS_VERSION, curOsVersion);
editor.commit();
// Ask for a reference to the database to force the helper to either
// create the database or open it up, performing any necessary upgrades
// in the process.
ContactsDatabaseHelper helper = ContactsDatabaseHelper.getInstance(context);
ProfileDatabaseHelper profileHelper = ProfileDatabaseHelper.getInstance(context);
CallLogDatabaseHelper calllogHelper = CallLogDatabaseHelper.getInstance(context);
Log.i(TAG, "Creating or opening contacts database");
helper.getWritableDatabase();
helper.clearDirectoryScanComplete();
profileHelper.getWritableDatabase();
calllogHelper.getWritableDatabase();
ContactsProvider2.updateLocaleOffline(context, helper, profileHelper);
// Log the total time taken for the receiver to perform the operation
EventLogTags.writeContactsUpgradeReceiver(System.currentTimeMillis() - startTime);
}
} catch (Throwable t) {
// Something has gone terribly wrong. Disable this receiver for good so we can't
// possibly end up in a reboot loop.
Log.wtf(TAG, "Error during upgrade attempt. Disabling receiver.", t);
context
.getPackageManager()
.setComponentEnabledSetting(
new ComponentName(context, getClass()),
PackageManager.COMPONENT_ENABLED_STATE_DISABLED,
PackageManager.DONT_KILL_APP);
}
}
public LegacyContactImporter(Context context, ContactsProvider2 contactsProvider) {
mContext = context;
mContactsProvider = contactsProvider;
mResolver = mContactsProvider.getContext().getContentResolver();
}