Java tutorial
/* * Copyright (C) 2015 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License */ package com.android.contacts.editor; import com.android.contacts.common.logging.ScreenEvent.ScreenType; import com.google.common.collect.ImmutableList; import com.google.common.collect.Lists; import com.android.contacts.ContactSaveService; import com.android.contacts.GroupMetaDataLoader; import com.android.contacts.R; import com.android.contacts.activities.ContactEditorAccountsChangedActivity; import com.android.contacts.activities.ContactEditorBaseActivity; import com.android.contacts.activities.ContactEditorBaseActivity.ContactEditor; import com.android.contacts.common.model.AccountTypeManager; import com.android.contacts.common.model.Contact; import com.android.contacts.common.model.ContactLoader; import com.android.contacts.common.model.RawContact; import com.android.contacts.common.model.RawContactDelta; import com.android.contacts.common.model.RawContactDeltaList; import com.android.contacts.common.model.RawContactModifier; import com.android.contacts.common.model.ValuesDelta; import com.android.contacts.common.model.account.AccountType; import com.android.contacts.common.model.account.AccountWithDataSet; import com.android.contacts.common.util.ImplicitIntentsUtil; import com.android.contacts.common.util.MaterialColorMapUtils; import com.android.contacts.editor.AggregationSuggestionEngine.Suggestion; import com.android.contacts.list.UiIntentActions; import com.android.contacts.quickcontact.QuickContactActivity; import com.android.contacts.util.HelpUtils; import com.android.contacts.util.PhoneCapabilityTester; import com.android.contacts.util.UiClosables; import android.accounts.Account; import android.app.Activity; import android.app.Fragment; import android.app.LoaderManager; import android.content.ActivityNotFoundException; import android.content.ContentUris; import android.content.ContentValues; import android.content.Context; import android.content.CursorLoader; import android.content.Intent; import android.content.Loader; import android.database.Cursor; import android.media.RingtoneManager; import android.net.Uri; import android.os.Bundle; import android.os.SystemClock; import android.provider.ContactsContract; import android.provider.ContactsContract.CommonDataKinds.Email; import android.provider.ContactsContract.CommonDataKinds.Event; import android.provider.ContactsContract.CommonDataKinds.Organization; import android.provider.ContactsContract.CommonDataKinds.Phone; import android.provider.ContactsContract.CommonDataKinds.StructuredName; import android.provider.ContactsContract.CommonDataKinds.StructuredPostal; import android.provider.ContactsContract.Contacts; import android.provider.ContactsContract.Intents; import android.provider.ContactsContract.RawContacts; import android.util.Log; import android.view.LayoutInflater; import android.view.Menu; import android.view.MenuInflater; import android.view.MenuItem; import android.view.View; import android.view.ViewGroup; import android.widget.AdapterView; import android.widget.BaseAdapter; import android.widget.LinearLayout; import android.widget.ListPopupWindow; import android.widget.Toast; import java.util.ArrayList; import java.util.HashSet; import java.util.Iterator; import java.util.List; import java.util.Set; /** * Base Fragment for contact editors. */ abstract public class ContactEditorBaseFragment extends Fragment implements ContactEditor, SplitContactConfirmationDialogFragment.Listener, JoinContactConfirmationDialogFragment.Listener, AggregationSuggestionEngine.Listener, AggregationSuggestionView.Listener, CancelEditDialogFragment.Listener { static final String TAG = "ContactEditor"; protected static final int LOADER_CONTACT = 1; protected static final int LOADER_GROUPS = 2; private static final List<String> VALID_INTENT_ACTIONS = new ArrayList<String>() { { add(Intent.ACTION_EDIT); add(Intent.ACTION_INSERT); add(ContactEditorBaseActivity.ACTION_EDIT); add(ContactEditorBaseActivity.ACTION_INSERT); add(ContactEditorBaseActivity.ACTION_SAVE_COMPLETED); } }; private static final String KEY_ACTION = "action"; private static final String KEY_URI = "uri"; private static final String KEY_AUTO_ADD_TO_DEFAULT_GROUP = "autoAddToDefaultGroup"; private static final String KEY_DISABLE_DELETE_MENU_OPTION = "disableDeleteMenuOption"; private static final String KEY_NEW_LOCAL_PROFILE = "newLocalProfile"; private static final String KEY_MATERIAL_PALETTE = "materialPalette"; private static final String KEY_PHOTO_ID = "photoId"; private static final String KEY_VIEW_ID_GENERATOR = "viewidgenerator"; private static final String KEY_RAW_CONTACTS = "rawContacts"; private static final String KEY_EDIT_STATE = "state"; private static final String KEY_STATUS = "status"; private static final String KEY_HAS_NEW_CONTACT = "hasNewContact"; private static final String KEY_NEW_CONTACT_READY = "newContactDataReady"; private static final String KEY_IS_EDIT = "isEdit"; private static final String KEY_EXISTING_CONTACT_READY = "existingContactDataReady"; private static final String KEY_RAW_CONTACT_DISPLAY_ALONE_IS_READ_ONLY = "isReadOnly"; // Phone option menus private static final String KEY_SEND_TO_VOICE_MAIL_STATE = "sendToVoicemailState"; private static final String KEY_ARE_PHONE_OPTIONS_CHANGEABLE = "arePhoneOptionsChangable"; private static final String KEY_CUSTOM_RINGTONE = "customRingtone"; private static final String KEY_IS_USER_PROFILE = "isUserProfile"; private static final String KEY_ENABLED = "enabled"; // Aggregation PopupWindow private static final String KEY_AGGREGATION_SUGGESTIONS_RAW_CONTACT_ID = "aggregationSuggestionsRawContactId"; // Join Activity private static final String KEY_CONTACT_ID_FOR_JOIN = "contactidforjoin"; private static final String KEY_READ_ONLY_DISPLAY_NAME = "readOnlyDisplayName"; protected static final int REQUEST_CODE_JOIN = 0; protected static final int REQUEST_CODE_ACCOUNTS_CHANGED = 1; protected static final int REQUEST_CODE_PICK_RINGTONE = 2; private static final int CURRENT_API_VERSION = android.os.Build.VERSION.SDK_INT; /** * An intent extra that forces the editor to add the edited contact * to the default group (e.g. "My Contacts"). */ public static final String INTENT_EXTRA_ADD_TO_DEFAULT_DIRECTORY = "addToDefaultDirectory"; public static final String INTENT_EXTRA_NEW_LOCAL_PROFILE = "newLocalProfile"; public static final String INTENT_EXTRA_DISABLE_DELETE_MENU_OPTION = "disableDeleteMenuOption"; /** * Intent key to pass the photo palette primary color calculated by * {@link com.android.contacts.quickcontact.QuickContactActivity} to the editor and between * the compact and fully expanded editors. */ public static final String INTENT_EXTRA_MATERIAL_PALETTE_PRIMARY_COLOR = "material_palette_primary_color"; /** * Intent key to pass the photo palette secondary color calculated by * {@link com.android.contacts.quickcontact.QuickContactActivity} to the editor and between * the compact and fully expanded editors. */ public static final String INTENT_EXTRA_MATERIAL_PALETTE_SECONDARY_COLOR = "material_palette_secondary_color"; /** * Intent key to pass the ID of the photo to display on the editor. */ public static final String INTENT_EXTRA_PHOTO_ID = "photo_id"; /** * Intent key to pass the ID of the raw contact id that should be displayed in the full editor * by itself. */ public static final String INTENT_EXTRA_RAW_CONTACT_ID_TO_DISPLAY_ALONE = "raw_contact_id_to_display_alone"; /** * Intent key to pass the boolean value of if the raw contact id that should be displayed * in the full editor by itself is read-only. */ public static final String INTENT_EXTRA_RAW_CONTACT_DISPLAY_ALONE_IS_READ_ONLY = "raw_contact_display_alone_is_read_only"; /** * Intent extra to specify a {@link ContactEditor.SaveMode}. */ public static final String SAVE_MODE_EXTRA_KEY = "saveMode"; /** * Intent extra key for the contact ID to join the current contact to after saving. */ public static final String JOIN_CONTACT_ID_EXTRA_KEY = "joinContactId"; /** * Callbacks for Activities that host contact editors Fragments. */ public interface Listener { /** * Contact was not found, so somehow close this fragment. This is raised after a contact * is removed via Menu/Delete */ void onContactNotFound(); /** * Contact was split, so we can close now. * * @param newLookupUri The lookup uri of the new contact that should be shown to the user. * The editor tries best to chose the most natural contact here. */ void onContactSplit(Uri newLookupUri); /** * User has tapped Revert, close the fragment now. */ void onReverted(); /** * Contact was saved and the Fragment can now be closed safely. */ void onSaveFinished(Intent resultIntent); /** * User switched to editing a different contact (a suggestion from the * aggregation engine). */ void onEditOtherContactRequested(Uri contactLookupUri, ArrayList<ContentValues> contentValues); /** * Contact is being created for an external account that provides its own * new contact activity. */ void onCustomCreateContactActivityRequested(AccountWithDataSet account, Bundle intentExtras); /** * The edited raw contact belongs to an external account that provides * its own edit activity. * * @param redirect indicates that the current editor should be closed * before the custom editor is shown. */ void onCustomEditContactActivityRequested(AccountWithDataSet account, Uri rawContactUri, Bundle intentExtras, boolean redirect); /** * User has requested that contact be deleted. */ void onDeleteRequested(Uri contactUri); } /** * Adapter for aggregation suggestions displayed in a PopupWindow when * editor fields change. */ protected static final class AggregationSuggestionAdapter extends BaseAdapter { private final LayoutInflater mLayoutInflater; private final boolean mSetNewContact; private final AggregationSuggestionView.Listener mListener; private final List<AggregationSuggestionEngine.Suggestion> mSuggestions; public AggregationSuggestionAdapter(Activity activity, boolean setNewContact, AggregationSuggestionView.Listener listener, List<Suggestion> suggestions) { mLayoutInflater = activity.getLayoutInflater(); mSetNewContact = setNewContact; mListener = listener; mSuggestions = suggestions; } @Override public View getView(int position, View convertView, ViewGroup parent) { final Suggestion suggestion = (Suggestion) getItem(position); final AggregationSuggestionView suggestionView = (AggregationSuggestionView) mLayoutInflater .inflate(R.layout.aggregation_suggestions_item, null); suggestionView.setNewContact(mSetNewContact); suggestionView.setListener(mListener); suggestionView.bindSuggestion(suggestion); return suggestionView; } @Override public long getItemId(int position) { return position; } @Override public Object getItem(int position) { return mSuggestions.get(position); } @Override public int getCount() { return mSuggestions.size(); } } protected Context mContext; protected Listener mListener; // // Views // protected LinearLayout mContent; protected View mAggregationSuggestionView; protected ListPopupWindow mAggregationSuggestionPopup; // // Parameters passed in on {@link #load} // protected String mAction; protected Uri mLookupUri; protected Bundle mIntentExtras; protected boolean mAutoAddToDefaultGroup; protected boolean mDisableDeleteMenuOption; protected boolean mNewLocalProfile; protected MaterialColorMapUtils.MaterialPalette mMaterialPalette; protected long mPhotoId = -1; // // Helpers // protected ContactEditorUtils mEditorUtils; protected RawContactDeltaComparator mComparator; protected ViewIdGenerator mViewIdGenerator; private AggregationSuggestionEngine mAggregationSuggestionEngine; // // Loaded data // // Used to store existing contact data so it can be re-applied during a rebind call, // i.e. account switch. Only used in {@link ContactEditorFragment}. protected ImmutableList<RawContact> mRawContacts; protected Cursor mGroupMetaData; // // Editor state // protected RawContactDeltaList mState; protected int mStatus; protected long mRawContactIdToDisplayAlone = -1; protected boolean mRawContactDisplayAloneIsReadOnly = false; // Whether to show the new contact blank form and if it's corresponding delta is ready. protected boolean mHasNewContact; protected AccountWithDataSet mAccountWithDataSet; protected boolean mNewContactDataReady; protected boolean mNewContactAccountChanged; // Whether it's an edit of existing contact and if it's corresponding delta is ready. protected boolean mIsEdit; protected boolean mExistingContactDataReady; // Whether we are editing the "me" profile protected boolean mIsUserProfile; // Phone specific option menu items private boolean mSendToVoicemailState; private boolean mArePhoneOptionsChangable; private String mCustomRingtone; // Whether editor views and options menu items should be enabled private boolean mEnabled = true; // Aggregation PopupWindow private long mAggregationSuggestionsRawContactId; // Join Activity protected long mContactIdForJoin; // Used to pre-populate the editor with a display name when a user edits a read-only contact. protected String mReadOnlyDisplayName; // // Not saved/restored on rotates // // The name editor view for the new raw contact that was created so that the user can // edit a read-only contact (to which the new raw contact was joined) protected StructuredNameEditorView mReadOnlyNameEditorView; /** * The contact data loader listener. */ protected final LoaderManager.LoaderCallbacks<Contact> mContactLoaderListener = new LoaderManager.LoaderCallbacks<Contact>() { protected long mLoaderStartTime; @Override public Loader<Contact> onCreateLoader(int id, Bundle args) { mLoaderStartTime = SystemClock.elapsedRealtime(); return new ContactLoader(mContext, mLookupUri, true); } @Override public void onLoadFinished(Loader<Contact> loader, Contact contact) { final long loaderCurrentTime = SystemClock.elapsedRealtime(); Log.v(TAG, "Time needed for loading: " + (loaderCurrentTime - mLoaderStartTime)); if (!contact.isLoaded()) { // Item has been deleted. Close activity without saving again. Log.i(TAG, "No contact found. Closing activity"); mStatus = Status.CLOSING; if (mListener != null) mListener.onContactNotFound(); return; } mStatus = Status.EDITING; mLookupUri = contact.getLookupUri(); final long setDataStartTime = SystemClock.elapsedRealtime(); setState(contact); setStateForPhoneMenuItems(contact); final long setDataEndTime = SystemClock.elapsedRealtime(); Log.v(TAG, "Time needed for setting UI: " + (setDataEndTime - setDataStartTime)); } @Override public void onLoaderReset(Loader<Contact> loader) { } }; /** * The groups meta data loader listener. */ protected final LoaderManager.LoaderCallbacks<Cursor> mGroupsLoaderListener = new LoaderManager.LoaderCallbacks<Cursor>() { @Override public CursorLoader onCreateLoader(int id, Bundle args) { return new GroupMetaDataLoader(mContext, ContactsContract.Groups.CONTENT_URI); } @Override public void onLoadFinished(Loader<Cursor> loader, Cursor data) { mGroupMetaData = data; setGroupMetaData(); } @Override public void onLoaderReset(Loader<Cursor> loader) { } }; @Override public void onAttach(Activity activity) { super.onAttach(activity); mContext = activity; mEditorUtils = ContactEditorUtils.getInstance(mContext); mComparator = new RawContactDeltaComparator(mContext); } @Override public void onCreate(Bundle savedState) { if (savedState != null) { // Restore mUri before calling super.onCreate so that onInitializeLoaders // would already have a uri and an action to work with mAction = savedState.getString(KEY_ACTION); mLookupUri = savedState.getParcelable(KEY_URI); } super.onCreate(savedState); if (savedState == null) { mViewIdGenerator = new ViewIdGenerator(); } else { mViewIdGenerator = savedState.getParcelable(KEY_VIEW_ID_GENERATOR); mAutoAddToDefaultGroup = savedState.getBoolean(KEY_AUTO_ADD_TO_DEFAULT_GROUP); mDisableDeleteMenuOption = savedState.getBoolean(KEY_DISABLE_DELETE_MENU_OPTION); mNewLocalProfile = savedState.getBoolean(KEY_NEW_LOCAL_PROFILE); mMaterialPalette = savedState.getParcelable(KEY_MATERIAL_PALETTE); mPhotoId = savedState.getLong(KEY_PHOTO_ID); mRawContacts = ImmutableList.copyOf(savedState.<RawContact>getParcelableArrayList(KEY_RAW_CONTACTS)); // NOTE: mGroupMetaData is not saved/restored // Read state from savedState. No loading involved here mState = savedState.<RawContactDeltaList>getParcelable(KEY_EDIT_STATE); mStatus = savedState.getInt(KEY_STATUS); mRawContactDisplayAloneIsReadOnly = savedState.getBoolean(KEY_RAW_CONTACT_DISPLAY_ALONE_IS_READ_ONLY); mHasNewContact = savedState.getBoolean(KEY_HAS_NEW_CONTACT); mNewContactDataReady = savedState.getBoolean(KEY_NEW_CONTACT_READY); mIsEdit = savedState.getBoolean(KEY_IS_EDIT); mExistingContactDataReady = savedState.getBoolean(KEY_EXISTING_CONTACT_READY); mIsUserProfile = savedState.getBoolean(KEY_IS_USER_PROFILE); // Phone specific options menus mSendToVoicemailState = savedState.getBoolean(KEY_SEND_TO_VOICE_MAIL_STATE); mArePhoneOptionsChangable = savedState.getBoolean(KEY_ARE_PHONE_OPTIONS_CHANGEABLE); mCustomRingtone = savedState.getString(KEY_CUSTOM_RINGTONE); mEnabled = savedState.getBoolean(KEY_ENABLED); // Aggregation PopupWindow mAggregationSuggestionsRawContactId = savedState.getLong(KEY_AGGREGATION_SUGGESTIONS_RAW_CONTACT_ID); // Join Activity mContactIdForJoin = savedState.getLong(KEY_CONTACT_ID_FOR_JOIN); mReadOnlyDisplayName = savedState.getString(KEY_READ_ONLY_DISPLAY_NAME); } // mState can still be null because it may not have have finished loading before // onSaveInstanceState was called. if (mState == null) { mState = new RawContactDeltaList(); } } @Override public void onActivityCreated(Bundle savedInstanceState) { super.onActivityCreated(savedInstanceState); validateAction(mAction); if (mState.isEmpty()) { // The delta list may not have finished loading before orientation change happens. // In this case, there will be a saved state but deltas will be missing. Reload from // database. if (Intent.ACTION_EDIT.equals(mAction) || ContactEditorBaseActivity.ACTION_EDIT.equals(mAction)) { // Either // 1) orientation change but load never finished. // 2) not an orientation change so data needs to be loaded for first time. getLoaderManager().initLoader(LOADER_CONTACT, null, mContactLoaderListener); getLoaderManager().initLoader(LOADER_GROUPS, null, mGroupsLoaderListener); } } else { // Orientation change, we already have mState, it was loaded by onCreate bindEditors(); } // Handle initial actions only when existing state missing if (savedInstanceState == null) { final Account account = mIntentExtras == null ? null : (Account) mIntentExtras.getParcelable(Intents.Insert.EXTRA_ACCOUNT); final String dataSet = mIntentExtras == null ? null : mIntentExtras.getString(Intents.Insert.EXTRA_DATA_SET); if (account != null) { mAccountWithDataSet = new AccountWithDataSet(account.name, account.type, dataSet); } if (Intent.ACTION_EDIT.equals(mAction) || ContactEditorBaseActivity.ACTION_EDIT.equals(mAction)) { mIsEdit = true; } else if (Intent.ACTION_INSERT.equals(mAction) || ContactEditorBaseActivity.ACTION_INSERT.equals(mAction)) { mHasNewContact = true; if (mAccountWithDataSet != null) { createContact(mAccountWithDataSet); } else { // No Account specified. Let the user choose // Load Accounts async so that we can present them selectAccountAndCreateContact(); } } } } /** * Checks if the requested action is valid. * * @param action The action to test. * @throws IllegalArgumentException when the action is invalid. */ private static void validateAction(String action) { if (VALID_INTENT_ACTIONS.contains(action)) { return; } throw new IllegalArgumentException( "Unknown action " + action + "; Supported actions: " + VALID_INTENT_ACTIONS); } @Override public void onSaveInstanceState(Bundle outState) { outState.putString(KEY_ACTION, mAction); outState.putParcelable(KEY_URI, mLookupUri); outState.putBoolean(KEY_AUTO_ADD_TO_DEFAULT_GROUP, mAutoAddToDefaultGroup); outState.putBoolean(KEY_DISABLE_DELETE_MENU_OPTION, mDisableDeleteMenuOption); outState.putBoolean(KEY_NEW_LOCAL_PROFILE, mNewLocalProfile); if (mMaterialPalette != null) { outState.putParcelable(KEY_MATERIAL_PALETTE, mMaterialPalette); } outState.putLong(KEY_PHOTO_ID, mPhotoId); outState.putParcelable(KEY_VIEW_ID_GENERATOR, mViewIdGenerator); outState.putParcelableArrayList(KEY_RAW_CONTACTS, mRawContacts == null ? Lists.<RawContact>newArrayList() : Lists.newArrayList(mRawContacts)); // NOTE: mGroupMetaData is not saved if (hasValidState()) { // Store entities with modifications outState.putParcelable(KEY_EDIT_STATE, mState); } outState.putInt(KEY_STATUS, mStatus); outState.putBoolean(KEY_HAS_NEW_CONTACT, mHasNewContact); outState.putBoolean(KEY_NEW_CONTACT_READY, mNewContactDataReady); outState.putBoolean(KEY_IS_EDIT, mIsEdit); outState.putBoolean(KEY_EXISTING_CONTACT_READY, mExistingContactDataReady); outState.putBoolean(KEY_RAW_CONTACT_DISPLAY_ALONE_IS_READ_ONLY, mRawContactDisplayAloneIsReadOnly); outState.putBoolean(KEY_IS_USER_PROFILE, mIsUserProfile); // Phone specific options outState.putBoolean(KEY_SEND_TO_VOICE_MAIL_STATE, mSendToVoicemailState); outState.putBoolean(KEY_ARE_PHONE_OPTIONS_CHANGEABLE, mArePhoneOptionsChangable); outState.putString(KEY_CUSTOM_RINGTONE, mCustomRingtone); outState.putBoolean(KEY_ENABLED, mEnabled); // Aggregation PopupWindow outState.putLong(KEY_AGGREGATION_SUGGESTIONS_RAW_CONTACT_ID, mAggregationSuggestionsRawContactId); // Join Activity outState.putLong(KEY_CONTACT_ID_FOR_JOIN, mContactIdForJoin); outState.putString(KEY_READ_ONLY_DISPLAY_NAME, mReadOnlyDisplayName); super.onSaveInstanceState(outState); } @Override public void onStop() { super.onStop(); UiClosables.closeQuietly(mAggregationSuggestionPopup); } @Override public void onDestroy() { super.onDestroy(); if (mAggregationSuggestionEngine != null) { mAggregationSuggestionEngine.quit(); } } @Override public void onActivityResult(int requestCode, int resultCode, Intent data) { switch (requestCode) { case REQUEST_CODE_JOIN: { // Ignore failed requests if (resultCode != Activity.RESULT_OK) return; if (data != null) { final long contactId = ContentUris.parseId(data.getData()); if (hasPendingChanges()) { // Ask the user if they want to save changes before doing the join JoinContactConfirmationDialogFragment.show(this, contactId); } else { // Do the join immediately joinAggregate(contactId); } } break; } case REQUEST_CODE_ACCOUNTS_CHANGED: { // Bail if the account selector was not successful. if (resultCode != Activity.RESULT_OK) { if (mListener != null) { mListener.onReverted(); } return; } // If there's an account specified, use it. if (data != null) { AccountWithDataSet account = data.getParcelableExtra(Intents.Insert.EXTRA_ACCOUNT); if (account != null) { createContact(account); return; } } // If there isn't an account specified, then this is likely a phone-local // contact, so we should continue setting up the editor by automatically selecting // the most appropriate account. createContact(); break; } case REQUEST_CODE_PICK_RINGTONE: { if (data != null) { final Uri pickedUri = data.getParcelableExtra(RingtoneManager.EXTRA_RINGTONE_PICKED_URI); onRingtonePicked(pickedUri); } break; } } } private void onRingtonePicked(Uri pickedUri) { mCustomRingtone = EditorUiUtils.getRingtoneStringFromUri(pickedUri, CURRENT_API_VERSION); Intent intent = ContactSaveService.createSetRingtone(mContext, mLookupUri, mCustomRingtone); mContext.startService(intent); } // // Options menu // private void setStateForPhoneMenuItems(Contact contact) { if (contact != null) { mSendToVoicemailState = contact.isSendToVoicemail(); mCustomRingtone = contact.getCustomRingtone(); mArePhoneOptionsChangable = !contact.isDirectoryEntry() && PhoneCapabilityTester.isPhone(mContext); } } /** * Invalidates the options menu if we are still associated with an Activity. */ protected void invalidateOptionsMenu() { final Activity activity = getActivity(); if (activity != null) { activity.invalidateOptionsMenu(); } } @Override public void onCreateOptionsMenu(Menu menu, final MenuInflater inflater) { inflater.inflate(R.menu.edit_contact, menu); } @Override public void onPrepareOptionsMenu(Menu menu) { // This supports the keyboard shortcut to save changes to a contact but shouldn't be visible // because the custom action bar contains the "save" button now (not the overflow menu). // TODO: Find a better way to handle shortcuts, i.e. onKeyDown()? final MenuItem saveMenu = menu.findItem(R.id.menu_save); final MenuItem splitMenu = menu.findItem(R.id.menu_split); final MenuItem joinMenu = menu.findItem(R.id.menu_join); final MenuItem helpMenu = menu.findItem(R.id.menu_help); final MenuItem sendToVoiceMailMenu = menu.findItem(R.id.menu_send_to_voicemail); final MenuItem ringToneMenu = menu.findItem(R.id.menu_set_ringtone); final MenuItem deleteMenu = menu.findItem(R.id.menu_delete); // Set visibility of menus // help menu depending on whether this is inserting or editing if (isInsert(mAction) || mRawContactIdToDisplayAlone != -1) { HelpUtils.prepareHelpMenuItem(mContext, helpMenu, R.string.help_url_people_add); splitMenu.setVisible(false); joinMenu.setVisible(false); deleteMenu.setVisible(false); } else if (isEdit(mAction)) { HelpUtils.prepareHelpMenuItem(mContext, helpMenu, R.string.help_url_people_edit); splitMenu.setVisible(canUnlinkRawContacts()); // Cannot join a user profile joinMenu.setVisible(!isEditingUserProfile()); deleteMenu.setVisible(!mDisableDeleteMenuOption && !isEditingUserProfile()); } else { // something else, so don't show the help menu helpMenu.setVisible(false); } // Save menu is invisible when there's only one read only contact in the editor. saveMenu.setVisible(!mRawContactDisplayAloneIsReadOnly); if (mRawContactIdToDisplayAlone != -1 || mIsUserProfile) { sendToVoiceMailMenu.setVisible(false); ringToneMenu.setVisible(false); } else { // Hide telephony-related settings (ringtone, send to voicemail) // if we don't have a telephone or are editing a new contact. sendToVoiceMailMenu.setChecked(mSendToVoicemailState); sendToVoiceMailMenu.setVisible(mArePhoneOptionsChangable); ringToneMenu.setVisible(mArePhoneOptionsChangable); } int size = menu.size(); for (int i = 0; i < size; i++) { menu.getItem(i).setEnabled(mEnabled); } } @Override public boolean onOptionsItemSelected(MenuItem item) { final Activity activity = getActivity(); if (activity == null || activity.isFinishing() || activity.isDestroyed()) { // If we no longer are attached to a running activity want to // drain this event. return true; } switch (item.getItemId()) { case R.id.menu_save: return save(SaveMode.CLOSE); case R.id.menu_delete: if (mListener != null) mListener.onDeleteRequested(mLookupUri); return true; case R.id.menu_split: return doSplitContactAction(); case R.id.menu_join: return doJoinContactAction(); case R.id.menu_set_ringtone: doPickRingtone(); return true; case R.id.menu_send_to_voicemail: // Update state and save mSendToVoicemailState = !mSendToVoicemailState; item.setChecked(mSendToVoicemailState); final Intent intent = ContactSaveService.createSetSendToVoicemail(mContext, mLookupUri, mSendToVoicemailState); mContext.startService(intent); return true; } return false; } @Override public boolean revert() { if (mState.isEmpty() || !hasPendingChanges()) { onCancelEditConfirmed(); } else { CancelEditDialogFragment.show(this); } return true; } @Override public void onCancelEditConfirmed() { // When this Fragment is closed we don't want it to auto-save mStatus = Status.CLOSING; if (mListener != null) { mListener.onReverted(); } } @Override public void onSplitContactConfirmed(boolean hasPendingChanges) { if (mState.isEmpty()) { // This may happen when this Fragment is recreated by the system during users // confirming the split action (and thus this method is called just before onCreate()), // for example. Log.e(TAG, "mState became null during the user's confirming split action. " + "Cannot perform the save action."); return; } if (!hasPendingChanges && mHasNewContact) { // If the user didn't add anything new, we don't want to split out the newly created // raw contact into a name-only contact so remove them. final Iterator<RawContactDelta> iterator = mState.iterator(); while (iterator.hasNext()) { final RawContactDelta rawContactDelta = iterator.next(); if (rawContactDelta.getRawContactId() < 0) { iterator.remove(); } } } mState.markRawContactsForSplitting(); save(SaveMode.SPLIT); } private boolean doSplitContactAction() { if (!hasValidState()) return false; SplitContactConfirmationDialogFragment.show(this, hasPendingChanges()); return true; } private boolean doJoinContactAction() { if (!hasValidState() || mLookupUri == null) { return false; } // If we just started creating a new contact and haven't added any data, it's too // early to do a join if (mState.size() == 1 && mState.get(0).isContactInsert() && !hasPendingChanges()) { Toast.makeText(mContext, R.string.toast_join_with_empty_contact, Toast.LENGTH_LONG).show(); return true; } showJoinAggregateActivity(mLookupUri); return true; } @Override public void onJoinContactConfirmed(long joinContactId) { doSaveAction(SaveMode.JOIN, joinContactId); } private void doPickRingtone() { final Intent intent = new Intent(RingtoneManager.ACTION_RINGTONE_PICKER); // Allow user to pick 'Default' intent.putExtra(RingtoneManager.EXTRA_RINGTONE_SHOW_DEFAULT, true); // Show only ringtones intent.putExtra(RingtoneManager.EXTRA_RINGTONE_TYPE, RingtoneManager.TYPE_RINGTONE); // Allow the user to pick a silent ringtone intent.putExtra(RingtoneManager.EXTRA_RINGTONE_SHOW_SILENT, true); final Uri ringtoneUri = EditorUiUtils.getRingtoneUriFromString(mCustomRingtone, CURRENT_API_VERSION); // Put checkmark next to the current ringtone for this contact intent.putExtra(RingtoneManager.EXTRA_RINGTONE_EXISTING_URI, ringtoneUri); // Launch! try { startActivityForResult(intent, REQUEST_CODE_PICK_RINGTONE); } catch (ActivityNotFoundException ex) { Toast.makeText(mContext, R.string.missing_app, Toast.LENGTH_SHORT).show(); } } @Override public boolean save(int saveMode) { if (!hasValidState() || mStatus != Status.EDITING) { return false; } // If we are about to close the editor - there is no need to refresh the data if (saveMode == SaveMode.CLOSE || saveMode == SaveMode.COMPACT || saveMode == SaveMode.SPLIT) { getLoaderManager().destroyLoader(LOADER_CONTACT); } mStatus = Status.SAVING; if (!hasPendingChanges()) { if (mLookupUri == null && saveMode == SaveMode.RELOAD) { // We don't have anything to save and there isn't even an existing contact yet. // Nothing to do, simply go back to editing mode mStatus = Status.EDITING; return true; } onSaveCompleted(/* hadChanges =*/ false, saveMode, /* saveSucceeded =*/ mLookupUri != null, mLookupUri, /* joinContactId =*/ null); return true; } setEnabled(false); return doSaveAction(saveMode, /* joinContactId */ null); } /** * Persist the accumulated editor deltas. * * @param joinContactId the raw contact ID to join the contact being saved to after the save, * may be null. */ abstract protected boolean doSaveAction(int saveMode, Long joinContactId); protected boolean startSaveService(Context context, Intent intent, int saveMode) { final boolean result = ContactSaveService.startService(context, intent, saveMode); if (!result) { onCancelEditConfirmed(); } return result; } // // State accessor methods // /** * Check if our internal {@link #mState} is valid, usually checked before * performing user actions. */ protected boolean hasValidState() { return mState.size() > 0; } protected boolean isEditingUserProfile() { return mNewLocalProfile || mIsUserProfile; } /** * Whether the contact being edited spans multiple raw contacts. * The may also span multiple accounts. */ public boolean isEditingMultipleRawContacts() { return mState.size() > 1; } /** * Whether the contact being edited is composed of a single read-only raw contact * aggregated with a newly created writable raw contact. */ protected boolean isEditingReadOnlyRawContactWithNewContact() { return mHasNewContact && mState.size() == 2; } /** * Return true if there are any edits to the current contact which need to * be saved. */ protected boolean hasPendingRawContactChanges(Set<String> excludedMimeTypes) { final AccountTypeManager accountTypes = AccountTypeManager.getInstance(mContext); return RawContactModifier.hasChanges(mState, accountTypes, excludedMimeTypes); } /** * We allow unlinking only if there is more than one raw contact, it is not a user-profile, * and unlinking won't result in an empty contact. For the empty contact case, we only guard * against this when there is a single read-only contact in the aggregate. If the user * has joined >1 read-only contacts together, we allow them to unlink it, even if they have * never added their own information and unlinking will create a name only contact. */ protected boolean canUnlinkRawContacts() { return isEditingMultipleRawContacts() && !isEditingUserProfile() && !isEditingReadOnlyRawContactWithNewContact(); } /** * Determines if changes were made in the editor that need to be saved, while taking into * account that name changes are not real for read-only contacts. * See go/editing-read-only-contacts */ protected boolean hasPendingChanges() { if (mReadOnlyNameEditorView != null && mReadOnlyDisplayName != null) { // We created a new raw contact delta with a default display name. // We must test for pending changes while ignoring the default display name. final String displayName = mReadOnlyNameEditorView.getDisplayName(); if (mReadOnlyDisplayName.equals(displayName)) { final Set<String> excludedMimeTypes = new HashSet<>(); excludedMimeTypes.add(StructuredName.CONTENT_ITEM_TYPE); return hasPendingRawContactChanges(excludedMimeTypes); } return true; } return hasPendingRawContactChanges(/* excludedMimeTypes =*/ null); } /** * Whether editor inputs and the options menu should be enabled. */ protected boolean isEnabled() { return mEnabled; } /** * Returns the palette extra that was passed in. */ protected MaterialColorMapUtils.MaterialPalette getMaterialPalette() { return mMaterialPalette; } // // Account creation // private void selectAccountAndCreateContact() { // If this is a local profile, then skip the logic about showing the accounts changed // activity and create a phone-local contact. if (mNewLocalProfile) { createContact(null); return; } // If there is no default account or the accounts have changed such that we need to // prompt the user again, then launch the account prompt. if (mEditorUtils.shouldShowAccountChangedNotification()) { Intent intent = new Intent(mContext, ContactEditorAccountsChangedActivity.class); // Prevent a second instance from being started on rotates intent.setFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP); mStatus = Status.SUB_ACTIVITY; startActivityForResult(intent, REQUEST_CODE_ACCOUNTS_CHANGED); } else { // Otherwise, there should be a default account. Then either create a local contact // (if default account is null) or create a contact with the specified account. AccountWithDataSet defaultAccount = mEditorUtils.getDefaultAccount(); createContact(defaultAccount); } } /** * Create a contact by automatically selecting the first account. If there's no available * account, a device-local contact should be created. */ protected void createContact() { final List<AccountWithDataSet> accounts = AccountTypeManager.getInstance(mContext).getAccounts(true); // No Accounts available. Create a phone-local contact. if (accounts.isEmpty()) { createContact(null); return; } // We have an account switcher in "create-account" screen, so don't need to ask a user to // select an account here. createContact(accounts.get(0)); } /** * Shows account creation screen associated with a given account. * * @param account may be null to signal a device-local contact should be created. */ protected void createContact(AccountWithDataSet account) { final AccountTypeManager accountTypes = AccountTypeManager.getInstance(mContext); final AccountType accountType = accountTypes.getAccountTypeForAccount(account); if (accountType.getCreateContactActivityClassName() != null) { if (mListener != null) { mListener.onCustomCreateContactActivityRequested(account, mIntentExtras); } } else { setStateForNewContact(account, accountType, isEditingUserProfile()); } } // // Data binding // private void setState(Contact contact) { // If we have already loaded data, we do not want to change it here to not confuse the user if (!mState.isEmpty()) { Log.v(TAG, "Ignoring background change. This will have to be rebased later"); return; } // See if this edit operation needs to be redirected to a custom editor mRawContacts = contact.getRawContacts(); if (mRawContacts.size() == 1) { RawContact rawContact = mRawContacts.get(0); String type = rawContact.getAccountTypeString(); String dataSet = rawContact.getDataSet(); AccountType accountType = rawContact.getAccountType(mContext); if (accountType.getEditContactActivityClassName() != null && !accountType.areContactsWritable()) { if (mListener != null) { String name = rawContact.getAccountName(); long rawContactId = rawContact.getId(); mListener.onCustomEditContactActivityRequested(new AccountWithDataSet(name, type, dataSet), ContentUris.withAppendedId(RawContacts.CONTENT_URI, rawContactId), mIntentExtras, true); } return; } } String readOnlyDisplayName = null; // Check for writable raw contacts. If there are none, then we need to create one so user // can edit. For the user profile case, there is already an editable contact. if (!contact.isUserProfile() && !contact.isWritableContact(mContext)) { mHasNewContact = true; // This is potentially an asynchronous call and will add deltas to list. selectAccountAndCreateContact(); readOnlyDisplayName = contact.getDisplayName(); } else { mHasNewContact = false; } // This also adds deltas to list. If readOnlyDisplayName is null at this point it is // simply ignored later on by the editor. setStateForExistingContact(readOnlyDisplayName, contact.isUserProfile(), mRawContacts); } /** * Prepare {@link #mState} for a newly created phone-local contact. */ private void setStateForNewContact(AccountWithDataSet account, AccountType accountType, boolean isUserProfile) { setStateForNewContact(account, accountType, /* oldState =*/ null, /* oldAccountType =*/ null, isUserProfile); } /** * Prepare {@link #mState} for a newly created phone-local contact, migrating the state * specified by oldState and oldAccountType. */ protected void setStateForNewContact(AccountWithDataSet account, AccountType accountType, RawContactDelta oldState, AccountType oldAccountType, boolean isUserProfile) { mStatus = Status.EDITING; mState.add(createNewRawContactDelta(account, accountType, oldState, oldAccountType)); mIsUserProfile = isUserProfile; mNewContactDataReady = true; bindEditors(); } /** * Returns a {@link RawContactDelta} for a new contact suitable for addition into * {@link #mState}. * * If oldState and oldAccountType are specified, the state specified by those parameters * is migrated to the result {@link RawContactDelta}. */ private RawContactDelta createNewRawContactDelta(AccountWithDataSet account, AccountType accountType, RawContactDelta oldState, AccountType oldAccountType) { final RawContact rawContact = new RawContact(); if (account != null) { rawContact.setAccount(account); } else { rawContact.setAccountToLocal(); } final RawContactDelta result = new RawContactDelta(ValuesDelta.fromAfter(rawContact.getValues())); if (oldState == null) { // Parse any values from incoming intent RawContactModifier.parseExtras(mContext, accountType, result, mIntentExtras); } else { RawContactModifier.migrateStateForNewContact(mContext, oldState, result, oldAccountType, accountType); } // Ensure we have some default fields (if the account type does not support a field, // ensureKind will not add it, so it is safe to add e.g. Event) RawContactModifier.ensureKindExists(result, accountType, Phone.CONTENT_ITEM_TYPE); RawContactModifier.ensureKindExists(result, accountType, Email.CONTENT_ITEM_TYPE); RawContactModifier.ensureKindExists(result, accountType, Organization.CONTENT_ITEM_TYPE); RawContactModifier.ensureKindExists(result, accountType, Event.CONTENT_ITEM_TYPE); RawContactModifier.ensureKindExists(result, accountType, StructuredPostal.CONTENT_ITEM_TYPE); // Set the correct URI for saving the contact as a profile if (mNewLocalProfile) { result.setProfileQueryUri(); } return result; } /** * Prepare {@link #mState} for an existing contact. */ protected void setStateForExistingContact(String readOnlyDisplayName, boolean isUserProfile, ImmutableList<RawContact> rawContacts) { setEnabled(true); mReadOnlyDisplayName = readOnlyDisplayName; mState.addAll(rawContacts.iterator()); setIntentExtras(mIntentExtras); mIntentExtras = null; // For user profile, change the contacts query URI mIsUserProfile = isUserProfile; boolean localProfileExists = false; if (mIsUserProfile) { for (RawContactDelta rawContactDelta : mState) { // For profile contacts, we need a different query URI rawContactDelta.setProfileQueryUri(); // Try to find a local profile contact if (rawContactDelta.getValues().getAsString(RawContacts.ACCOUNT_TYPE) == null) { localProfileExists = true; } } // Editor should always present a local profile for editing if (!localProfileExists) { mState.add(createLocalRawContactDelta()); } } mExistingContactDataReady = true; bindEditors(); } /** * Returns a {@link RawContactDelta} for a local contact suitable for addition into * {@link #mState}. */ private static RawContactDelta createLocalRawContactDelta() { final RawContact rawContact = new RawContact(); rawContact.setAccountToLocal(); final RawContactDelta result = new RawContactDelta(ValuesDelta.fromAfter(rawContact.getValues())); result.setProfileQueryUri(); return result; } /** * Sets group metadata on all bound editors. */ abstract protected void setGroupMetaData(); /** * Bind editors using {@link #mState} and other members initialized from the loaded (or new) * Contact. */ abstract protected void bindEditors(); /** * Set the enabled state of editors. */ private void setEnabled(boolean enabled) { if (mEnabled != enabled) { mEnabled = enabled; // Enable/disable editors if (mContent != null) { int count = mContent.getChildCount(); for (int i = 0; i < count; i++) { mContent.getChildAt(i).setEnabled(enabled); } } // Enable/disable aggregation suggestion vies if (mAggregationSuggestionView != null) { LinearLayout itemList = (LinearLayout) mAggregationSuggestionView .findViewById(R.id.aggregation_suggestions); int count = itemList.getChildCount(); for (int i = 0; i < count; i++) { itemList.getChildAt(i).setEnabled(enabled); } } // Maybe invalidate the options menu final Activity activity = getActivity(); if (activity != null) activity.invalidateOptionsMenu(); } } /** * Removes a current editor ({@link #mState}) and rebinds new editor for a new account. * Some of old data are reused with new restriction enforced by the new account. * * @param oldState Old data being edited. * @param oldAccount Old account associated with oldState. * @param newAccount New account to be used. */ protected void rebindEditorsForNewContact(RawContactDelta oldState, AccountWithDataSet oldAccount, AccountWithDataSet newAccount) { AccountTypeManager accountTypes = AccountTypeManager.getInstance(mContext); AccountType oldAccountType = accountTypes.getAccountTypeForAccount(oldAccount); AccountType newAccountType = accountTypes.getAccountTypeForAccount(newAccount); if (newAccountType.getCreateContactActivityClassName() != null) { Log.w(TAG, "external activity called in rebind situation"); if (mListener != null) { mListener.onCustomCreateContactActivityRequested(newAccount, mIntentExtras); } } else { mExistingContactDataReady = false; mNewContactDataReady = false; mState = new RawContactDeltaList(); setStateForNewContact(newAccount, newAccountType, oldState, oldAccountType, isEditingUserProfile()); if (mIsEdit) { setStateForExistingContact(mReadOnlyDisplayName, isEditingUserProfile(), mRawContacts); } } } // // ContactEditor // @Override public void setListener(Listener listener) { mListener = listener; } @Override public void load(String action, Uri lookupUri, Bundle intentExtras) { mAction = action; mLookupUri = lookupUri; mIntentExtras = intentExtras; if (mIntentExtras != null) { mAutoAddToDefaultGroup = mIntentExtras.containsKey(INTENT_EXTRA_ADD_TO_DEFAULT_DIRECTORY); mNewLocalProfile = mIntentExtras.getBoolean(INTENT_EXTRA_NEW_LOCAL_PROFILE); mDisableDeleteMenuOption = mIntentExtras.getBoolean(INTENT_EXTRA_DISABLE_DELETE_MENU_OPTION); if (mIntentExtras.containsKey(INTENT_EXTRA_MATERIAL_PALETTE_PRIMARY_COLOR) && mIntentExtras.containsKey(INTENT_EXTRA_MATERIAL_PALETTE_SECONDARY_COLOR)) { mMaterialPalette = new MaterialColorMapUtils.MaterialPalette( mIntentExtras.getInt(INTENT_EXTRA_MATERIAL_PALETTE_PRIMARY_COLOR), mIntentExtras.getInt(INTENT_EXTRA_MATERIAL_PALETTE_SECONDARY_COLOR)); } // If the user selected a different photo, don't restore the one from the Intent if (mPhotoId < 0) { mPhotoId = mIntentExtras.getLong(INTENT_EXTRA_PHOTO_ID); } mRawContactIdToDisplayAlone = mIntentExtras.getLong(INTENT_EXTRA_RAW_CONTACT_ID_TO_DISPLAY_ALONE, -1); mRawContactDisplayAloneIsReadOnly = mIntentExtras .getBoolean(INTENT_EXTRA_RAW_CONTACT_DISPLAY_ALONE_IS_READ_ONLY); } } @Override public void setIntentExtras(Bundle extras) { if (extras == null || extras.size() == 0) { return; } final AccountTypeManager accountTypes = AccountTypeManager.getInstance(mContext); for (RawContactDelta state : mState) { final AccountType type = state.getAccountType(accountTypes); if (type.areContactsWritable()) { // Apply extras to the first writable raw contact only RawContactModifier.parseExtras(mContext, type, state, extras); break; } } } @Override public void onJoinCompleted(Uri uri) { onSaveCompleted(false, SaveMode.RELOAD, uri != null, uri, /* joinContactId */ null); } @Override public void onSaveCompleted(boolean hadChanges, int saveMode, boolean saveSucceeded, Uri contactLookupUri, Long joinContactId) { if (hadChanges) { if (saveSucceeded) { switch (saveMode) { case SaveMode.JOIN: break; case SaveMode.SPLIT: Toast.makeText(mContext, R.string.contactUnlinkedToast, Toast.LENGTH_SHORT).show(); break; default: Toast.makeText(mContext, R.string.contactSavedToast, Toast.LENGTH_SHORT).show(); } } else { Toast.makeText(mContext, R.string.contactSavedErrorToast, Toast.LENGTH_LONG).show(); } } switch (saveMode) { case SaveMode.CLOSE: { final Intent resultIntent; if (saveSucceeded && contactLookupUri != null) { final Uri lookupUri = maybeConvertToLegacyLookupUri(mContext, contactLookupUri, mLookupUri); resultIntent = ImplicitIntentsUtil.composeQuickContactIntent(lookupUri, QuickContactActivity.MODE_FULLY_EXPANDED); resultIntent.putExtra(QuickContactActivity.EXTRA_PREVIOUS_SCREEN_TYPE, ScreenType.EDITOR); } else { resultIntent = null; } // It is already saved, so prevent it from being saved again mStatus = Status.CLOSING; if (mListener != null) mListener.onSaveFinished(resultIntent); break; } case SaveMode.COMPACT: { // It is already saved, so prevent it from being saved again mStatus = Status.CLOSING; if (mListener != null) mListener.onSaveFinished(/* resultIntent= */ null); break; } case SaveMode.JOIN: if (saveSucceeded && contactLookupUri != null && joinContactId != null) { joinAggregate(joinContactId); } break; case SaveMode.RELOAD: if (saveSucceeded && contactLookupUri != null) { // If this was in INSERT, we are changing into an EDIT now. // If it already was an EDIT, we are changing to the new Uri now mState = new RawContactDeltaList(); load(Intent.ACTION_EDIT, contactLookupUri, null); mStatus = Status.LOADING; getLoaderManager().restartLoader(LOADER_CONTACT, null, mContactLoaderListener); } break; case SaveMode.SPLIT: mStatus = Status.CLOSING; if (mListener != null) { mListener.onContactSplit(contactLookupUri); } else { Log.d(TAG, "No listener registered, can not call onSplitFinished"); } break; } } /** * Shows a list of aggregates that can be joined into the currently viewed aggregate. * * @param contactLookupUri the fresh URI for the currently edited contact (after saving it) */ private void showJoinAggregateActivity(Uri contactLookupUri) { if (contactLookupUri == null || !isAdded()) { return; } mContactIdForJoin = ContentUris.parseId(contactLookupUri); final Intent intent = new Intent(UiIntentActions.PICK_JOIN_CONTACT_ACTION); intent.putExtra(UiIntentActions.TARGET_CONTACT_ID_EXTRA_KEY, mContactIdForJoin); startActivityForResult(intent, REQUEST_CODE_JOIN); } // // Aggregation PopupWindow // /** * Triggers an asynchronous search for aggregation suggestions. */ protected void acquireAggregationSuggestions(Context context, long rawContactId, ValuesDelta valuesDelta) { if (mAggregationSuggestionsRawContactId != rawContactId && mAggregationSuggestionView != null) { mAggregationSuggestionView.setVisibility(View.GONE); mAggregationSuggestionView = null; mAggregationSuggestionEngine.reset(); } mAggregationSuggestionsRawContactId = rawContactId; if (mAggregationSuggestionEngine == null) { mAggregationSuggestionEngine = new AggregationSuggestionEngine(context); mAggregationSuggestionEngine.setListener(this); mAggregationSuggestionEngine.start(); } mAggregationSuggestionEngine.setContactId(getContactId()); mAggregationSuggestionEngine.onNameChange(valuesDelta); } /** * Returns the contact ID for the currently edited contact or 0 if the contact is new. */ private long getContactId() { for (RawContactDelta rawContact : mState) { Long contactId = rawContact.getValues().getAsLong(RawContacts.CONTACT_ID); if (contactId != null) { return contactId; } } return 0; } @Override public void onAggregationSuggestionChange() { final Activity activity = getActivity(); if ((activity != null && activity.isFinishing()) || !isVisible() || mState.isEmpty() || mStatus != Status.EDITING) { return; } UiClosables.closeQuietly(mAggregationSuggestionPopup); if (mAggregationSuggestionEngine.getSuggestedContactCount() == 0) { return; } final View anchorView = getAggregationAnchorView(mAggregationSuggestionsRawContactId); if (anchorView == null) { return; // Raw contact deleted? } mAggregationSuggestionPopup = new ListPopupWindow(mContext, null); mAggregationSuggestionPopup.setAnchorView(anchorView); mAggregationSuggestionPopup.setWidth(anchorView.getWidth()); mAggregationSuggestionPopup.setInputMethodMode(ListPopupWindow.INPUT_METHOD_NOT_NEEDED); mAggregationSuggestionPopup.setAdapter(new AggregationSuggestionAdapter(getActivity(), mState.size() == 1 && mState.get(0).isContactInsert(), /* listener =*/ this, mAggregationSuggestionEngine.getSuggestions())); mAggregationSuggestionPopup.setOnItemClickListener(new AdapterView.OnItemClickListener() { @Override public void onItemClick(AdapterView<?> parent, View view, int position, long id) { final AggregationSuggestionView suggestionView = (AggregationSuggestionView) view; suggestionView.handleItemClickEvent(); UiClosables.closeQuietly(mAggregationSuggestionPopup); mAggregationSuggestionPopup = null; } }); mAggregationSuggestionPopup.show(); } /** * Returns the raw contact editor view for the given rawContactId that should be used as the * anchor for aggregation suggestions. */ abstract protected View getAggregationAnchorView(long rawContactId); /** * Whether the given raw contact ID matches the one used to last load aggregation * suggestions. */ protected boolean isAggregationSuggestionRawContactId(long rawContactId) { return mAggregationSuggestionsRawContactId == rawContactId; } @Override public void onJoinAction(long contactId, List<Long> rawContactIdList) { final long rawContactIds[] = new long[rawContactIdList.size()]; for (int i = 0; i < rawContactIds.length; i++) { rawContactIds[i] = rawContactIdList.get(i); } try { JoinSuggestedContactDialogFragment.show(this, rawContactIds); } catch (Exception ignored) { // No problem - the activity is no longer available to display the dialog } } /** * Joins the suggested contact (specified by the id's of constituent raw * contacts), save all changes, and stay in the editor. */ protected void doJoinSuggestedContact(long[] rawContactIds) { if (!hasValidState() || mStatus != Status.EDITING) { return; } mState.setJoinWithRawContacts(rawContactIds); save(SaveMode.RELOAD); } @Override public void onEditAction(Uri contactLookupUri) { SuggestionEditConfirmationDialogFragment.show(this, contactLookupUri); } /** * Abandons the currently edited contact and switches to editing the suggested * one, transferring all the data there */ protected void doEditSuggestedContact(Uri contactUri) { if (mListener != null) { // make sure we don't save this contact when closing down mStatus = Status.CLOSING; mListener.onEditOtherContactRequested(contactUri, mState.get(0).getContentValues()); } } // // Join Activity // /** * Performs aggregation with the contact selected by the user from suggestions or A-Z list. */ abstract protected void joinAggregate(long contactId); // // Utility methods // /** * Returns a legacy version of the given contactLookupUri if a legacy Uri was originally * passed to the contact editor. * * @param contactLookupUri The Uri to possibly convert to legacy format. * @param requestLookupUri The lookup Uri originally passed to the contact editor * (via Intent data), may be null. */ protected static Uri maybeConvertToLegacyLookupUri(Context context, Uri contactLookupUri, Uri requestLookupUri) { final String legacyAuthority = "contacts"; final String requestAuthority = requestLookupUri == null ? null : requestLookupUri.getAuthority(); if (legacyAuthority.equals(requestAuthority)) { // Build a legacy Uri if that is what was requested by caller final long contactId = ContentUris .parseId(Contacts.lookupContact(context.getContentResolver(), contactLookupUri)); final Uri legacyContentUri = Uri.parse("content://contacts/people"); return ContentUris.withAppendedId(legacyContentUri, contactId); } // Otherwise pass back a lookup-style Uri return contactLookupUri; } /** * Whether the argument Intent requested a contact insert action or not. */ protected static boolean isInsert(Intent intent) { return intent == null ? false : isInsert(intent.getAction()); } protected static boolean isInsert(String action) { return Intent.ACTION_INSERT.equals(action) || ContactEditorBaseActivity.ACTION_INSERT.equals(action); } protected static boolean isEdit(String action) { return Intent.ACTION_EDIT.equals(action) || ContactEditorBaseActivity.ACTION_EDIT.equals(action); } }