/*
* Copyright (C) 2011 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.contacts.activities;
import android.app.Activity;
import android.app.Dialog;
import android.app.ProgressDialog;
import android.content.AsyncQueryHandler;
import android.content.ContentProviderOperation;
import android.content.ContentProviderResult;
import android.content.ContentResolver;
import android.content.ContentUris;
import android.content.Context;
import android.content.Intent;
import android.content.OperationApplicationException;
import android.database.Cursor;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.net.Uri;
import android.net.Uri.Builder;
import android.os.AsyncTask;
import android.os.Bundle;
import android.os.RemoteException;
import android.provider.ContactsContract;
import android.provider.ContactsContract.CommonDataKinds.Email;
import android.provider.ContactsContract.CommonDataKinds.Im;
import android.provider.ContactsContract.CommonDataKinds.Nickname;
import android.provider.ContactsContract.CommonDataKinds.Phone;
import android.provider.ContactsContract.CommonDataKinds.Photo;
import android.provider.ContactsContract.CommonDataKinds.StructuredName;
import android.provider.ContactsContract.CommonDataKinds.StructuredPostal;
import android.provider.ContactsContract.Contacts;
import android.provider.ContactsContract.Data;
import android.provider.ContactsContract.RawContacts;
import android.provider.ContactsContract.RawContactsEntity;
import android.telephony.PhoneNumberUtils;
import android.text.TextUtils;
import android.util.Log;
import android.view.LayoutInflater;
import android.view.View;
import android.view.View.OnClickListener;
import android.view.ViewGroup;
import android.widget.ImageView;
import android.widget.TextView;
import android.widget.Toast;
import com.android.contacts.R;
import com.android.contacts.editor.Editor;
import com.android.contacts.editor.EditorUiUtils;
import com.android.contacts.editor.ViewIdGenerator;
import com.android.contacts.common.ContactPhotoManager;
import com.android.contacts.common.ContactPhotoManager.DefaultImageRequest;
import com.android.contacts.common.model.AccountTypeManager;
import com.android.contacts.common.model.RawContact;
import com.android.contacts.common.model.RawContactDelta;
import com.android.contacts.common.model.ValuesDelta;
import com.android.contacts.common.model.RawContactDeltaList;
import com.android.contacts.common.model.RawContactModifier;
import com.android.contacts.common.model.account.AccountType;
import com.android.contacts.common.model.account.AccountWithDataSet;
import com.android.contacts.common.model.dataitem.DataKind;
import com.android.contacts.util.DialogManager;
import com.android.contacts.common.util.EmptyService;
import java.lang.ref.WeakReference;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
/**
* This is a dialog-themed activity for confirming the addition of a detail to an existing contact
* (once the user has selected this contact from a list of all contacts). The incoming intent
* must have an extra with max 1 phone or email specified, using
* {@link android.provider.ContactsContract.Intents.Insert#PHONE} with type
* {@link android.provider.ContactsContract.Intents.Insert#PHONE_TYPE} or
* {@link android.provider.ContactsContract.Intents.Insert#EMAIL} with type
* {@link android.provider.ContactsContract.Intents.Insert#EMAIL_TYPE} intent keys.
*
* If the selected contact doesn't contain editable raw_contacts, it'll create a new raw_contact
* on the first editable account found, and the data will be added to this raw_contact. The newly
* created raw_contact will be joined with the selected contact with aggregation-exceptions.
*
* TODO: Don't open this activity if there's no editable accounts.
* If there's no editable accounts on the system, we'll set {@link #mIsReadOnly} and the dialog
* just says "contact is not editable". It's slightly misleading because this really means
* "there's no editable accounts", but in this case we shouldn't show the contact picker in the
* first place.
* Note when there's no accounts, it *is* okay to show the picker / dialog, because the local-only
* contacts are writable.
*/
public class ConfirmAddDetailActivity extends Activity implements
DialogManager.DialogShowingViewActivity {
private static final String TAG = "ConfirmAdd"; // The class name is too long to be a tag.
private static final boolean VERBOSE_LOGGING = Log.isLoggable(TAG, Log.VERBOSE);
private LayoutInflater mInflater;
private View mRootView;
private TextView mDisplayNameView;
private TextView mReadOnlyWarningView;
private ImageView mPhotoView;
private ViewGroup mEditorContainerView;
private static WeakReference<ProgressDialog> sProgressDialog;
private AccountTypeManager mAccountTypeManager;
private ContentResolver mContentResolver;
private AccountType mEditableAccountType;
private Uri mContactUri;
private long mContactId;
private String mDisplayName;
private String mLookupKey;
private boolean mIsReadOnly;
private QueryHandler mQueryHandler;
/** {@link RawContactDeltaList} for the entire selected contact. */
private RawContactDeltaList mEntityDeltaList;
/** {@link RawContactDeltaList} for the editable account */
private RawContactDelta mRawContactDelta;
private String mMimetype = Phone.CONTENT_ITEM_TYPE;
/**
* DialogManager may be needed if the user wants to apply a "custom" label to the contact detail
*/
private final DialogManager mDialogManager = new DialogManager(this);
/**
* PhotoQuery contains the projection used for retrieving the name and photo
* ID of a contact.
*/
private interface ContactQuery {
final String[] COLUMNS = new String[] {
Contacts._ID,
Contacts.LOOKUP_KEY,
Contacts.PHOTO_ID,
Contacts.DISPLAY_NAME,
};
final int _ID = 0;
final int LOOKUP_KEY = 1;
final int PHOTO_ID = 2;
final int DISPLAY_NAME = 3;
}
/**
* PhotoQuery contains the projection used for retrieving the raw bytes of
* the contact photo.
*/
private interface PhotoQuery {
final String[] COLUMNS = new String[] {
Photo.PHOTO
};
final int PHOTO = 0;
}
/**
* ExtraInfoQuery contains the projection used for retrieving the extra info
* on a contact (only needed if someone else exists with the same name as
* this contact).
*/
private interface ExtraInfoQuery {
final String[] COLUMNS = new String[] {
RawContacts.CONTACT_ID,
Data.MIMETYPE,
Data.DATA1,
};
final int CONTACT_ID = 0;
final int MIMETYPE = 1;
final int DATA1 = 2;
}
/**
* List of mimetypes to use in order of priority to display for a contact in
* a disambiguation case. For example, if the contact does not have a
* nickname, use the email field, and etc.
*/
private static final String[] MIME_TYPE_PRIORITY_LIST = new String[] {
Nickname.CONTENT_ITEM_TYPE, Email.CONTENT_ITEM_TYPE, Im.CONTENT_ITEM_TYPE,
StructuredPostal.CONTENT_ITEM_TYPE, Phone.CONTENT_ITEM_TYPE };
private static final int TOKEN_CONTACT_INFO = 0;
private static final int TOKEN_PHOTO_QUERY = 1;
private static final int TOKEN_DISAMBIGUATION_QUERY = 2;
private static final int TOKEN_EXTRA_INFO_QUERY = 3;
private final OnClickListener mDetailsButtonClickListener = new OnClickListener() {
@Override
public void onClick(View v) {
if (mIsReadOnly) {
onSaveCompleted(true);
} else {
doSaveAction();
}
}
};
private final OnClickListener mDoneButtonClickListener = new OnClickListener() {
@Override
public void onClick(View v) {
doSaveAction();
}
};
private final OnClickListener mCancelButtonClickListener = new OnClickListener() {
@Override
public void onClick(View v) {
setResult(RESULT_CANCELED);
finish();
}
};
@Override
protected void onCreate(Bundle icicle) {
super.onCreate(icicle);
mInflater = (LayoutInflater) getSystemService(Context.LAYOUT_INFLATER_SERVICE);
mContentResolver = getContentResolver();
final Intent intent = getIntent();
mContactUri = intent.getData();
if (mContactUri == null) {
setResult(RESULT_CANCELED);
finish();
}
Bundle extras = intent.getExtras();
if (extras != null) {
if (extras.containsKey(ContactsContract.Intents.Insert.PHONE)) {
mMimetype = Phone.CONTENT_ITEM_TYPE;
} else if (extras.containsKey(ContactsContract.Intents.Insert.EMAIL)) {
mMimetype = Email.CONTENT_ITEM_TYPE;
} else {
throw new IllegalStateException("Error: No valid mimetype found in intent extras");
}
}
mAccountTypeManager = AccountTypeManager.getInstance(this);
setContentView(R.layout.confirm_add_detail_activity);
mRootView = findViewById(R.id.root_view);
mReadOnlyWarningView = (TextView) findViewById(R.id.read_only_warning);
// Setup "header" (containing contact info) to save the detail and then go to the editor
findViewById(R.id.open_details_push_layer).setOnClickListener(mDetailsButtonClickListener);
// Setup "done" button to save the detail to the contact and exit.
findViewById(R.id.btn_done).setOnClickListener(mDoneButtonClickListener);
// Setup "cancel" button to return to previous activity.
findViewById(R.id.btn_cancel).setOnClickListener(mCancelButtonClickListener);
// Retrieve references to all the Views in the dialog activity.
mDisplayNameView = (TextView) findViewById(R.id.name);
mPhotoView = (ImageView) findViewById(R.id.photo);
mPhotoView.setImageDrawable(ContactPhotoManager.getDefaultAvatarDrawableForContact(
getResources(), false, null));
mEditorContainerView = (ViewGroup) findViewById(R.id.editor_container);
resetAsyncQueryHandler();
startContactQuery(mContactUri);
new QueryEntitiesTask(this).execute(intent);
}
@Override
public DialogManager getDialogManager() {
return mDialogManager;
}
@Override
protected Dialog onCreateDialog(int id, Bundle args) {
if (DialogManager.isManagedId(id)) return mDialogManager.onCreateDialog(id, args);
// Nobody knows about the Dialog
Log.w(TAG, "Unknown dialog requested, id: " + id + ", args: " + args);
return null;
}
/**
* Reset the query handler by creating a new QueryHandler instance.
*/
private void resetAsyncQueryHandler() {
// the api AsyncQueryHandler.cancelOperation() doesn't really work. Since we really
// need the old async queries to be cancelled, let's do it the hard way.
mQueryHandler = new QueryHandler(mContentResolver);
}
/**
* Internal method to query contact by Uri.
*
* @param contactUri the contact uri
*/
private void startContactQuery(Uri contactUri) {
mQueryHandler.startQuery(TOKEN_CONTACT_INFO, contactUri, contactUri, ContactQuery.COLUMNS,
null, null, null);
}
/**
* Internal method to query contact photo by photo id and uri.
*
* @param photoId the photo id.
* @param lookupKey the lookup uri.
*/
private void startPhotoQuery(long photoId, Uri lookupKey) {
mQueryHandler.startQuery(TOKEN_PHOTO_QUERY, lookupKey,
ContentUris.withAppendedId(Data.CONTENT_URI, photoId),
PhotoQuery.COLUMNS, null, null, null);
}
/**
* Internal method to query for contacts with a given display name.
*
* @param contactDisplayName the display name to look for.
*/
private void startDisambiguationQuery(String contactDisplayName) {
// Apply a limit of 1 result to the query because we only need to
// determine whether or not at least one other contact has the same
// name. We don't need to find ALL other contacts with the same name.
final Builder builder = Contacts.CONTENT_URI.buildUpon();
builder.appendQueryParameter("limit", String.valueOf(1));
final Uri uri = builder.build();
final String displayNameSelection;
final String[] selectionArgs;
if (TextUtils.isEmpty(contactDisplayName)) {
displayNameSelection = Contacts.DISPLAY_NAME_PRIMARY + " IS NULL";
selectionArgs = new String[] { String.valueOf(mContactId) };
} else {
displayNameSelection = Contacts.DISPLAY_NAME_PRIMARY + " = ?";
selectionArgs = new String[] { contactDisplayName, String.valueOf(mContactId) };
}
mQueryHandler.startQuery(TOKEN_DISAMBIGUATION_QUERY, null, uri,
new String[] { Contacts._ID } /* unused projection but a valid one was needed */,
displayNameSelection + " AND " + Contacts.PHOTO_ID + " IS NULL AND "
+ Contacts._ID + " <> ?", selectionArgs, null);
}
/**
* Internal method to query for extra data fields for this contact.
*/
private void startExtraInfoQuery() {
mQueryHandler.startQuery(TOKEN_EXTRA_INFO_QUERY, null, Data.CONTENT_URI,
ExtraInfoQuery.COLUMNS, RawContacts.CONTACT_ID + " = ?",
new String[] { String.valueOf(mContactId) }, null);
}
private static class QueryEntitiesTask extends AsyncTask<Intent, Void, RawContactDeltaList> {
private ConfirmAddDetailActivity activityTarget;
private String mSelection;
public QueryEntitiesTask(ConfirmAddDetailActivity target) {
activityTarget = target;
}
@Override
protected RawContactDeltaList doInBackground(Intent... params) {
final Intent intent = params[0];
final ContentResolver resolver = activityTarget.getContentResolver();
// Handle both legacy and new authorities
final Uri data = intent.getData();
final String authority = data.getAuthority();
final String mimeType = intent.resolveType(resolver);
mSelection = "0";
String selectionArg = null;
if (ContactsContract.AUTHORITY.equals(authority)) {
if (Contacts.CONTENT_ITEM_TYPE.equals(mimeType)) {
// Handle selected aggregate
final long contactId = ContentUris.parseId(data);
selectionArg = String.valueOf(contactId);
mSelection = RawContacts.CONTACT_ID + "=?";
} else if (RawContacts.CONTENT_ITEM_TYPE.equals(mimeType)) {
final long rawContactId = ContentUris.parseId(data);
final long contactId = queryForContactId(resolver, rawContactId);
selectionArg = String.valueOf(contactId);
mSelection = RawContacts.CONTACT_ID + "=?";
}
} else if (android.provider.Contacts.AUTHORITY.equals(authority)) {
final long rawContactId = ContentUris.parseId(data);
selectionArg = String.valueOf(rawContactId);
mSelection = Data.RAW_CONTACT_ID + "=?";
}
// Note that this query does not need to concern itself with whether the contact is
// the user's profile, since the profile does not show up in the picker.
return RawContactDeltaList.fromQuery(RawContactsEntity.CONTENT_URI,
activityTarget.getContentResolver(), mSelection,
new String[] { selectionArg }, null);
}
private static long queryForContactId(ContentResolver resolver, long rawContactId) {
Cursor contactIdCursor = null;
long contactId = -1;
try {
contactIdCursor = resolver.query(RawContacts.CONTENT_URI,
new String[] { RawContacts.CONTACT_ID },
RawContacts._ID + "=?", new String[] { String.valueOf(rawContactId) },
null);
if (contactIdCursor != null && contactIdCursor.moveToFirst()) {
contactId = contactIdCursor.getLong(0);
}
} finally {
if (contactIdCursor != null) {
contactIdCursor.close();
}
}
return contactId;
}
@Override
protected void onPostExecute(RawContactDeltaList entityList) {
if (activityTarget.isFinishing()) {
return;
}
if ((entityList == null) || (entityList.size() == 0)) {
Log.e(TAG, "Contact not found.");
activityTarget.finish();
return;
}
activityTarget.setEntityDeltaList(entityList);
}
}
private class QueryHandler extends AsyncQueryHandler {
public QueryHandler(ContentResolver cr) {
super(cr);
}
@Override
protected void onQueryComplete(int token, Object cookie, Cursor cursor) {
try {
if (this != mQueryHandler) {
Log.d(TAG, "onQueryComplete: discard result, the query handler is reset!");
return;
}
if (ConfirmAddDetailActivity.this.isFinishing()) {
return;
}
switch (token) {
case TOKEN_PHOTO_QUERY: {
// Set the photo
Bitmap photoBitmap = null;
if (cursor != null && cursor.moveToFirst()
&& !cursor.isNull(PhotoQuery.PHOTO)) {
byte[] photoData = cursor.getBlob(PhotoQuery.PHOTO);
photoBitmap = BitmapFactory.decodeByteArray(photoData, 0,
photoData.length, null);
}
if (photoBitmap != null) {
mPhotoView.setImageBitmap(photoBitmap);
}
break;
}
case TOKEN_CONTACT_INFO: {
// Set the contact's name
if (cursor != null && cursor.moveToFirst()) {
// Get the cursor values
mDisplayName = cursor.getString(ContactQuery.DISPLAY_NAME);
mLookupKey = cursor.getString(ContactQuery.LOOKUP_KEY);
setDefaultContactImage(mDisplayName, mLookupKey);
final long photoId = cursor.getLong(ContactQuery.PHOTO_ID);
// If there is no photo ID, then do a disambiguation
// query because other contacts could have the same
// name as this contact.
if (photoId == 0) {
mContactId = cursor.getLong(ContactQuery._ID);
startDisambiguationQuery(mDisplayName);
} else if (TextUtils.isEmpty(mLookupKey)) {
finish();
return;
} else {
// Otherwise do the photo query.
Uri lookupUri = Contacts.getLookupUri(mContactId, mLookupKey);
startPhotoQuery(photoId, lookupUri);
// Display the name because there is no
// disambiguation query.
setDisplayName();
showDialogContent();
}
}
break;
}
case TOKEN_DISAMBIGUATION_QUERY: {
// If a cursor was returned with more than 0 results,
// then at least one other contact exists with the same
// name as this contact. Extra info on this contact must
// be displayed to disambiguate the contact, so retrieve
// those additional fields. Otherwise, no other contacts
// with this name exists, so do nothing further.
if (cursor != null && cursor.getCount() > 0) {
startExtraInfoQuery();
} else {
// If there are no other contacts with this name,
// then display the name.
setDisplayName();
showDialogContent();
}
break;
}
case TOKEN_EXTRA_INFO_QUERY: {
// This case should only occur if there are one or more
// other contacts with the same contact name.
if (cursor != null && cursor.moveToFirst()) {
HashMap<String, String> hashMapCursorData = new
HashMap<String, String>();
// Convert the cursor data into a hashmap of
// (mimetype, data value) pairs. If a contact has
// multiple values with the same mimetype, it's fine
// to override that hashmap entry because we only
// need one value of that type.
while (!cursor.isAfterLast()) {
final String mimeType = cursor.getString(ExtraInfoQuery.MIMETYPE);
if (!TextUtils.isEmpty(mimeType)) {
String value = cursor.getString(ExtraInfoQuery.DATA1);
if (!TextUtils.isEmpty(value)) {
// As a special case, phone numbers
// should be formatted in a specific way.
if (Phone.CONTENT_ITEM_TYPE.equals(mimeType)) {
value = PhoneNumberUtils.formatNumber(value);
}
hashMapCursorData.put(mimeType, value);
}
}
cursor.moveToNext();
}
// Find the first non-empty field according to the
// mimetype priority list and display this under the
// contact's display name to disambiguate the contact.
for (String mimeType : MIME_TYPE_PRIORITY_LIST) {
if (hashMapCursorData.containsKey(mimeType)) {
setDisplayName();
setExtraInfoField(hashMapCursorData.get(mimeType));
break;
}
}
showDialogContent();
}
break;
}
}
} finally {
if (cursor != null) {
cursor.close();
}
}
}
}
private void setEntityDeltaList(RawContactDeltaList entityList) {
if (entityList == null) {
throw new IllegalStateException();
}
if (VERBOSE_LOGGING) {
Log.v(TAG, "setEntityDeltaList: " + entityList);
}
mEntityDeltaList = entityList;
// Find the editable raw_contact.
mRawContactDelta = mEntityDeltaList.getFirstWritableRawContact(this);
// If no editable raw_contacts are found, create one.
if (mRawContactDelta == null) {
mRawContactDelta = addEditableRawContact(this, mEntityDeltaList);
if ((mRawContactDelta != null) && VERBOSE_LOGGING) {
Log.v(TAG, "setEntityDeltaList: created editable raw_contact " + entityList);
}
}
if (mRawContactDelta == null) {
// Selected contact is read-only, and there's no editable account.
mIsReadOnly = true;
mEditableAccountType = null;
} else {
mIsReadOnly = false;
mEditableAccountType = mRawContactDelta.getRawContactAccountType(this);
// Handle any incoming values that should be inserted
final Bundle extras = getIntent().getExtras();
if (extras != null && extras.size() > 0) {
// If there are any intent extras, add them as additional fields in the
// RawContactDelta.
RawContactModifier.parseExtras(this, mEditableAccountType, mRawContactDelta,
extras);
}
}
bindEditor();
}
/**
* Create an {@link RawContactDelta} for a raw_contact on the first editable account found, and add
* to the list. Also copy the structured name from an existing (read-only) raw_contact to the
* new one, if any of the read-only contacts has a name.
*/
private static RawContactDelta addEditableRawContact(Context context,
RawContactDeltaList entityDeltaList) {
// First, see if there's an editable account.
final AccountTypeManager accounts = AccountTypeManager.getInstance(context);
final List<AccountWithDataSet> editableAccounts = accounts.getAccounts(true);
if (editableAccounts.size() == 0) {
// No editable account type found. The dialog will be read-only mode.
return null;
}
final AccountWithDataSet editableAccount = editableAccounts.get(0);
final AccountType accountType = accounts.getAccountType(
editableAccount.type, editableAccount.dataSet);
// Create a new RawContactDelta for the new raw_contact.
final RawContact rawContact = new RawContact();
rawContact.setAccount(editableAccount);
final RawContactDelta entityDelta = new RawContactDelta(ValuesDelta.fromAfter(
rawContact.getValues()));
// Then, copy the structure name from an existing (read-only) raw_contact.
for (RawContactDelta entity : entityDeltaList) {
final ArrayList<ValuesDelta> readOnlyNames =
entity.getMimeEntries(StructuredName.CONTENT_ITEM_TYPE);
if ((readOnlyNames != null) && (readOnlyNames.size() > 0)) {
final ValuesDelta readOnlyName = readOnlyNames.get(0);
final ValuesDelta newName = RawContactModifier.ensureKindExists(entityDelta,
accountType, StructuredName.CONTENT_ITEM_TYPE);
// Copy all the data fields.
newName.copyStructuredNameFieldsFrom(readOnlyName);
break;
}
}
// Add the new RawContactDelta to the list.
entityDeltaList.add(entityDelta);
return entityDelta;
}
/**
* Rebuild the editor to match our underlying {@link #mEntityDeltaList} object.
*/
private void bindEditor() {
if (mEntityDeltaList == null) {
throw new IllegalStateException();
}
// If no valid raw contact (to insert the data) was found, we won't have an editable
// account type to use. In this case, display an error message and hide the "OK" button.
if (mIsReadOnly) {
mReadOnlyWarningView.setText(getString(R.string.contact_read_only));
mReadOnlyWarningView.setVisibility(View.VISIBLE);
mEditorContainerView.setVisibility(View.GONE);
findViewById(R.id.btn_done).setVisibility(View.GONE);
// Nothing more to be done, just show the UI
showDialogContent();
return;
}
// Otherwise display an editor that allows the user to add the data to this raw contact.
for (DataKind kind : mEditableAccountType.getSortedDataKinds()) {
// Skip kind that are not editable
if (!kind.editable) continue;
if (mMimetype.equals(kind.mimeType)) {
final ArrayList<ValuesDelta> deltas = mRawContactDelta.getMimeEntries(mMimetype);
if (deltas != null) {
for (ValuesDelta valuesDelta : deltas) {
// Skip entries that aren't visible
if (!valuesDelta.isVisible()) continue;
if (valuesDelta.isInsert()) {
inflateEditorView(kind, valuesDelta, mRawContactDelta);
return;
}
}
}
}
}
}
/**
* Creates an EditorView for the given entry. This function must be used while constructing
* the views corresponding to the the object-model. The resulting EditorView is also added
* to the end of mEditors
*/
private void inflateEditorView(DataKind dataKind, ValuesDelta valuesDelta, RawContactDelta state) {
final int layoutResId = EditorUiUtils.getLayoutResourceId(dataKind.mimeType);
final View view = mInflater.inflate(layoutResId, mEditorContainerView,
false);
if (view instanceof Editor) {
Editor editor = (Editor) view;
// Don't allow deletion of the field because there is only 1 detail in this editor.
editor.setDeletable(false);
editor.setValues(dataKind, valuesDelta, state, false, new ViewIdGenerator());
}
mEditorContainerView.addView(view);
}
/**
* Set the display name to the correct TextView. Don't do this until it is
* certain there is no need for a disambiguation field (otherwise the screen
* will flicker because the name will be centered and then moved upwards).
*/
private void setDisplayName() {
mDisplayNameView.setText(mDisplayName);
}
/**
* Set the TextView (for extra contact info) with the given value and make the
* TextView visible.
*/
private void setExtraInfoField(String value) {
TextView extraTextView = (TextView) findViewById(R.id.extra_info);
extraTextView.setVisibility(View.VISIBLE);
extraTextView.setText(value);
}
private void setDefaultContactImage(String displayName, String lookupKey) {
mPhotoView.setImageDrawable(ContactPhotoManager.getDefaultAvatarDrawableForContact(
getResources(), false,
new DefaultImageRequest(displayName, lookupKey, false /* isCircular */)));
}
/**
* Shows all the contents of the dialog to the user at one time. This should only be called
* once all the queries have completed, otherwise the screen will flash as additional data
* comes in.
*/
private void showDialogContent() {
mRootView.setVisibility(View.VISIBLE);
}
/**
* Saves or creates the contact based on the mode, and if successful
* finishes the activity.
*/
private void doSaveAction() {
final PersistTask task = new PersistTask(this, mAccountTypeManager);
task.execute(mEntityDeltaList);
}
/**
* Background task for persisting edited contact data, using the changes
* defined by a set of {@link RawContactDelta}. This task starts
* {@link EmptyService} to make sure the background thread can finish
* persisting in cases where the system wants to reclaim our process.
*/
private static class PersistTask extends AsyncTask<RawContactDeltaList, Void, Integer> {
// In the future, use ContactSaver instead of WeakAsyncTask because of
// the danger of the activity being null during a save action
private static final int PERSIST_TRIES = 3;
private static final int RESULT_UNCHANGED = 0;
private static final int RESULT_SUCCESS = 1;
private static final int RESULT_FAILURE = 2;
private ConfirmAddDetailActivity activityTarget;
private AccountTypeManager mAccountTypeManager;
public PersistTask(ConfirmAddDetailActivity target, AccountTypeManager accountTypeManager) {
activityTarget = target;
mAccountTypeManager = accountTypeManager;
}
@Override
protected void onPreExecute() {
sProgressDialog = new WeakReference<ProgressDialog>(ProgressDialog.show(activityTarget,
null, activityTarget.getText(R.string.savingContact)));
// Before starting this task, start an empty service to protect our
// process from being reclaimed by the system.
final Context context = activityTarget;
context.startService(new Intent(context, EmptyService.class));
}
@Override
protected Integer doInBackground(RawContactDeltaList... params) {
final Context context = activityTarget;
final ContentResolver resolver = context.getContentResolver();
RawContactDeltaList state = params[0];
if (state == null) {
return RESULT_FAILURE;
}
// Trim any empty fields, and RawContacts, before persisting
RawContactModifier.trimEmpty(state, mAccountTypeManager);
// Attempt to persist changes
int tries = 0;
Integer result = RESULT_FAILURE;
while (tries++ < PERSIST_TRIES) {
try {
// Build operations and try applying
// Note: In case we've created a new raw_contact because the selected contact
// is read-only, buildDiff() will create aggregation exceptions to join
// the new one to the existing contact.
final ArrayList<ContentProviderOperation> diff = state.buildDiff();
ContentProviderResult[] results = null;
if (!diff.isEmpty()) {
results = resolver.applyBatch(ContactsContract.AUTHORITY, diff);
}
result = (diff.size() > 0) ? RESULT_SUCCESS : RESULT_UNCHANGED;
break;
} catch (RemoteException e) {
// Something went wrong, bail without success
Log.e(TAG, "Problem persisting user edits", e);
break;
} catch (OperationApplicationException e) {
// Version consistency failed, bail without success
Log.e(TAG, "Version consistency failed", e);
break;
}
}
return result;
}
/** {@inheritDoc} */
@Override
protected void onPostExecute(Integer result) {
final Context context = activityTarget;
dismissProgressDialog();
// Show a toast message based on the success or failure of the save action.
if (result == RESULT_SUCCESS) {
Toast.makeText(context, R.string.contactSavedToast, Toast.LENGTH_SHORT).show();
} else if (result == RESULT_FAILURE) {
Toast.makeText(context, R.string.contactSavedErrorToast, Toast.LENGTH_LONG).show();
}
// Stop the service that was protecting us
context.stopService(new Intent(context, EmptyService.class));
activityTarget.onSaveCompleted(result != RESULT_FAILURE);
}
}
@Override
protected void onStop() {
super.onStop();
// Dismiss the progress dialog here to prevent leaking the window on orientation change.
dismissProgressDialog();
}
/**
* Dismiss the progress dialog (check if it is null because it is a {@link WeakReference}).
*/
private static void dismissProgressDialog() {
ProgressDialog dialog = (sProgressDialog == null) ? null : sProgressDialog.get();
if (dialog != null) {
dialog.dismiss();
}
sProgressDialog = null;
}
/**
* This method is intended to be executed after the background task for saving edited info has
* finished. The method sets the activity result (and intent if applicable) and finishes the
* activity.
* @param success is true if the save task completed successfully, or false otherwise.
*/
private void onSaveCompleted(boolean success) {
if (success) {
Intent intent = new Intent(Intent.ACTION_VIEW, mContactUri);
setResult(RESULT_OK, intent);
} else {
setResult(RESULT_CANCELED);
}
finish();
}
}