| /* |
| * Copyright (C) 2010 The Android Open Source Project |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| package com.android.contacts.activities; |
| |
| import com.android.contacts.ContactLoader; |
| import com.android.contacts.ContactSaveService; |
| import com.android.contacts.ContactsActivity; |
| import com.android.contacts.ContactsUtils; |
| import com.android.contacts.R; |
| import com.android.contacts.activities.ActionBarAdapter.TabState; |
| import com.android.contacts.detail.ContactDetailFragment; |
| import com.android.contacts.detail.ContactDetailLayoutController; |
| import com.android.contacts.detail.ContactDetailUpdatesFragment; |
| import com.android.contacts.detail.ContactLoaderFragment; |
| import com.android.contacts.detail.ContactLoaderFragment.ContactLoaderFragmentListener; |
| import com.android.contacts.group.GroupBrowseListFragment; |
| import com.android.contacts.group.GroupBrowseListFragment.OnGroupBrowserActionListener; |
| import com.android.contacts.group.GroupDetailFragment; |
| import com.android.contacts.interactions.ContactDeletionInteraction; |
| import com.android.contacts.interactions.ImportExportDialogFragment; |
| import com.android.contacts.interactions.PhoneNumberInteraction; |
| import com.android.contacts.list.ContactBrowseListFragment; |
| import com.android.contacts.list.ContactEntryListFragment; |
| import com.android.contacts.list.ContactListFilter; |
| import com.android.contacts.list.ContactListFilterController; |
| import com.android.contacts.list.ContactTileAdapter.DisplayType; |
| import com.android.contacts.list.ContactTileFrequentFragment; |
| import com.android.contacts.list.ContactTileListFragment; |
| import com.android.contacts.list.ContactsIntentResolver; |
| import com.android.contacts.list.ContactsRequest; |
| import com.android.contacts.list.ContactsUnavailableFragment; |
| import com.android.contacts.list.DefaultContactBrowseListFragment; |
| import com.android.contacts.list.DirectoryListLoader; |
| import com.android.contacts.list.OnContactBrowserActionListener; |
| import com.android.contacts.list.OnContactsUnavailableActionListener; |
| import com.android.contacts.list.ProviderStatusLoader; |
| import com.android.contacts.list.ProviderStatusLoader.ProviderStatusListener; |
| import com.android.contacts.model.AccountTypeManager; |
| import com.android.contacts.model.AccountWithDataSet; |
| import com.android.contacts.preference.ContactsPreferenceActivity; |
| import com.android.contacts.preference.DisplayOptionsPreferenceFragment; |
| import com.android.contacts.util.AccountFilterUtil; |
| import com.android.contacts.util.AccountPromptUtils; |
| import com.android.contacts.util.AccountSelectionUtil; |
| import com.android.contacts.util.AccountsListAdapter; |
| import com.android.contacts.util.AccountsListAdapter.AccountListFilter; |
| import com.android.contacts.util.Constants; |
| import com.android.contacts.util.DialogManager; |
| import com.android.contacts.util.PhoneCapabilityTester; |
| |
| import android.app.Fragment; |
| import android.app.FragmentManager; |
| import android.app.FragmentTransaction; |
| import android.content.ActivityNotFoundException; |
| import android.content.ContentValues; |
| import android.content.Intent; |
| import android.graphics.Rect; |
| import android.net.Uri; |
| import android.os.Bundle; |
| import android.os.Handler; |
| import android.os.Parcelable; |
| import android.preference.PreferenceActivity; |
| import android.provider.ContactsContract; |
| import android.provider.ContactsContract.Contacts; |
| import android.provider.ContactsContract.Intents; |
| import android.provider.ContactsContract.ProviderStatus; |
| import android.provider.ContactsContract.QuickContact; |
| import android.provider.Settings; |
| import android.support.v13.app.FragmentPagerAdapter; |
| import android.support.v4.view.PagerAdapter; |
| import android.support.v4.view.ViewPager; |
| import android.util.Log; |
| import android.view.KeyEvent; |
| import android.view.Menu; |
| import android.view.MenuInflater; |
| import android.view.MenuItem; |
| import android.view.View; |
| import android.view.View.OnClickListener; |
| import android.widget.AdapterView; |
| import android.widget.AdapterView.OnItemClickListener; |
| import android.widget.ListPopupWindow; |
| import android.widget.Toast; |
| |
| import java.util.ArrayList; |
| import java.util.List; |
| import java.util.concurrent.atomic.AtomicInteger; |
| |
| /** |
| * Displays a list to browse contacts. For xlarge screens, this also displays a detail-pane on |
| * the right. |
| */ |
| public class PeopleActivity extends ContactsActivity |
| implements View.OnCreateContextMenuListener, ActionBarAdapter.Listener, |
| DialogManager.DialogShowingViewActivity, |
| ContactListFilterController.ContactListFilterListener, ProviderStatusListener { |
| |
| private static final String TAG = "PeopleActivity"; |
| |
| // These values needs to start at 2. See {@link ContactEntryListFragment}. |
| private static final int SUBACTIVITY_NEW_CONTACT = 2; |
| private static final int SUBACTIVITY_EDIT_CONTACT = 3; |
| private static final int SUBACTIVITY_NEW_GROUP = 4; |
| private static final int SUBACTIVITY_EDIT_GROUP = 5; |
| private static final int SUBACTIVITY_ACCOUNT_FILTER = 6; |
| |
| private final DialogManager mDialogManager = new DialogManager(this); |
| |
| private ContactsIntentResolver mIntentResolver; |
| private ContactsRequest mRequest; |
| |
| private ActionBarAdapter mActionBarAdapter; |
| |
| private ContactDetailFragment mContactDetailFragment; |
| private ContactDetailUpdatesFragment mContactDetailUpdatesFragment; |
| |
| private ContactLoaderFragment mContactDetailLoaderFragment; |
| private final ContactDetailLoaderFragmentListener mContactDetailLoaderFragmentListener = |
| new ContactDetailLoaderFragmentListener(); |
| |
| private GroupDetailFragment mGroupDetailFragment; |
| private final GroupDetailFragmentListener mGroupDetailFragmentListener = |
| new GroupDetailFragmentListener(); |
| |
| private ContactTileListFragment.Listener mFavoritesFragmentListener = |
| new StrequentContactListFragmentListener(); |
| |
| private ContactListFilterController mContactListFilterController; |
| |
| private ContactsUnavailableFragment mContactsUnavailableFragment; |
| private ProviderStatusLoader mProviderStatusLoader; |
| private int mProviderStatus = -1; |
| |
| private boolean mOptionsMenuContactsAvailable; |
| |
| /** |
| * Showing a list of Contacts. Also used for showing search results in search mode. |
| */ |
| private DefaultContactBrowseListFragment mAllFragment; |
| private ContactTileListFragment mFavoritesFragment; |
| private ContactTileFrequentFragment mFrequentFragment; |
| private GroupBrowseListFragment mGroupsFragment; |
| |
| private View mFavoritesView; |
| private View mBrowserView; |
| private View mDetailsView; |
| |
| private View mAddGroupImageView; |
| |
| /** ViewPager for swipe, used only on the phone (i.e. one-pane mode) */ |
| private ViewPager mTabPager; |
| private TabPagerAdapter mTabPagerAdapter; |
| private final TabPagerListener mTabPagerListener = new TabPagerListener(); |
| |
| private ContactDetailLayoutController mContactDetailLayoutController; |
| |
| private final Handler mHandler = new Handler(); |
| |
| /** |
| * True if this activity instance is a re-created one. i.e. set true after orientation change. |
| * This is set in {@link #onCreate} for later use in {@link #onStart}. |
| */ |
| private boolean mIsRecreatedInstance; |
| |
| /** |
| * If {@link #configureFragments(boolean)} is already called. Used to avoid calling it twice |
| * in {@link #onStart}. |
| * (This initialization only needs to be done once in onStart() when the Activity was just |
| * created from scratch -- i.e. onCreate() was just called) |
| */ |
| private boolean mFragmentInitialized; |
| |
| /** |
| * Whether or not the current contact filter is valid or not. We need to do a check on |
| * start of the app to verify that the user is not in single contact mode. If so, we should |
| * dynamically change the filter, unless the incoming intent specifically requested a contact |
| * that should be displayed in that mode. |
| */ |
| private boolean mCurrentFilterIsValid; |
| |
| /** Sequential ID assigned to each instance; used for logging */ |
| private final int mInstanceId; |
| private static final AtomicInteger sNextInstanceId = new AtomicInteger(); |
| |
| public PeopleActivity() { |
| mInstanceId = sNextInstanceId.getAndIncrement(); |
| mIntentResolver = new ContactsIntentResolver(this); |
| mProviderStatusLoader = new ProviderStatusLoader(this); |
| } |
| |
| @Override |
| public String toString() { |
| // Shown on logcat |
| return String.format("%s@%d", getClass().getSimpleName(), mInstanceId); |
| } |
| |
| public boolean areContactsAvailable() { |
| return mProviderStatus == ProviderStatus.STATUS_NORMAL; |
| } |
| |
| private boolean areContactWritableAccountsAvailable() { |
| return ContactsUtils.areContactWritableAccountsAvailable(this); |
| } |
| |
| private boolean areGroupWritableAccountsAvailable() { |
| return ContactsUtils.areGroupWritableAccountsAvailable(this); |
| } |
| |
| /** |
| * Initialize fragments that are (or may not be) in the layout. |
| * |
| * For the fragments that are in the layout, we initialize them in |
| * {@link #createViewsAndFragments(Bundle)} after inflating the layout. |
| * |
| * However, there are special fragments which may not be in the layout, so we have to do the |
| * initialization here. |
| * The target fragments are: |
| * - {@link ContactDetailFragment} and {@link ContactDetailUpdatesFragment}: They may not be |
| * in the layout depending on the configuration. (i.e. portrait) |
| * - {@link ContactsUnavailableFragment}: We always create it at runtime. |
| */ |
| @Override |
| public void onAttachFragment(Fragment fragment) { |
| if (fragment instanceof ContactDetailFragment) { |
| mContactDetailFragment = (ContactDetailFragment) fragment; |
| } else if (fragment instanceof ContactDetailUpdatesFragment) { |
| mContactDetailUpdatesFragment = (ContactDetailUpdatesFragment) fragment; |
| } else if (fragment instanceof ContactsUnavailableFragment) { |
| mContactsUnavailableFragment = (ContactsUnavailableFragment)fragment; |
| mContactsUnavailableFragment.setProviderStatusLoader(mProviderStatusLoader); |
| mContactsUnavailableFragment.setOnContactsUnavailableActionListener( |
| new ContactsUnavailableFragmentListener()); |
| } |
| } |
| |
| @Override |
| protected void onCreate(Bundle savedState) { |
| if (Log.isLoggable(Constants.PERFORMANCE_TAG, Log.DEBUG)) { |
| Log.d(Constants.PERFORMANCE_TAG, "PeopleActivity.onCreate start"); |
| } |
| super.onCreate(savedState); |
| |
| if (!processIntent(false)) { |
| finish(); |
| return; |
| } |
| |
| mContactListFilterController = ContactListFilterController.getInstance(this); |
| mContactListFilterController.checkFilterValidity(false); |
| mContactListFilterController.addListener(this); |
| |
| mIsRecreatedInstance = (savedState != null); |
| createViewsAndFragments(savedState); |
| if (Log.isLoggable(Constants.PERFORMANCE_TAG, Log.DEBUG)) { |
| Log.d(Constants.PERFORMANCE_TAG, "PeopleActivity.onCreate finish"); |
| } |
| } |
| |
| @Override |
| protected void onNewIntent(Intent intent) { |
| setIntent(intent); |
| if (!processIntent(true)) { |
| finish(); |
| return; |
| } |
| mActionBarAdapter.initialize(null, mRequest); |
| |
| mContactListFilterController.checkFilterValidity(false); |
| mCurrentFilterIsValid = true; |
| |
| // Re-configure fragments. |
| configureFragments(true /* from request */); |
| invalidateOptionsMenuIfNeeded(); |
| } |
| |
| /** |
| * Resolve the intent and initialize {@link #mRequest}, and launch another activity if redirect |
| * is needed. |
| * |
| * @param forNewIntent set true if it's called from {@link #onNewIntent(Intent)}. |
| * @return {@code true} if {@link PeopleActivity} should continue running. {@code false} |
| * if it shouldn't, in which case the caller should finish() itself and shouldn't do |
| * farther initialization. |
| */ |
| private boolean processIntent(boolean forNewIntent) { |
| // Extract relevant information from the intent |
| mRequest = mIntentResolver.resolveIntent(getIntent()); |
| if (Log.isLoggable(TAG, Log.DEBUG)) { |
| Log.d(TAG, this + " processIntent: forNewIntent=" + forNewIntent |
| + " intent=" + getIntent() + " request=" + mRequest); |
| } |
| if (!mRequest.isValid()) { |
| setResult(RESULT_CANCELED); |
| return false; |
| } |
| |
| Intent redirect = mRequest.getRedirectIntent(); |
| if (redirect != null) { |
| // Need to start a different activity |
| startActivity(redirect); |
| return false; |
| } |
| |
| if (mRequest.getActionCode() == ContactsRequest.ACTION_VIEW_CONTACT |
| && !PhoneCapabilityTester.isUsingTwoPanes(this)) { |
| redirect = new Intent(this, ContactDetailActivity.class); |
| redirect.setAction(Intent.ACTION_VIEW); |
| redirect.setData(mRequest.getContactUri()); |
| startActivity(redirect); |
| return false; |
| } |
| setTitle(mRequest.getActivityTitle()); |
| return true; |
| } |
| |
| private void createViewsAndFragments(Bundle savedState) { |
| setContentView(R.layout.people_activity); |
| |
| final FragmentManager fragmentManager = getFragmentManager(); |
| |
| // Hide all tabs (the current tab will later be reshown once a tab is selected) |
| final FragmentTransaction transaction = fragmentManager.beginTransaction(); |
| |
| // Prepare the fragments which are used both on 1-pane and on 2-pane. |
| boolean isUsingTwoPanes = PhoneCapabilityTester.isUsingTwoPanes(this); |
| if (isUsingTwoPanes) { |
| mFavoritesFragment = getFragment(R.id.favorites_fragment); |
| mAllFragment = getFragment(R.id.all_fragment); |
| mGroupsFragment = getFragment(R.id.groups_fragment); |
| } else { |
| mTabPager = getView(R.id.tab_pager); |
| mTabPagerAdapter = new TabPagerAdapter(); |
| mTabPager.setAdapter(mTabPagerAdapter); |
| mTabPager.setOnPageChangeListener(mTabPagerListener); |
| |
| final String FAVORITE_TAG = "tab-pager-favorite"; |
| final String ALL_TAG = "tab-pager-all"; |
| final String GROUPS_TAG = "tab-pager-groups"; |
| |
| // Create the fragments and add as children of the view pager. |
| // The pager adapter will only change the visibility; it'll never create/destroy |
| // fragments. |
| // However, if it's after screen rotation, the fragments have been re-created by |
| // the fragment manager, so first see if there're already the target fragments |
| // existing. |
| mFavoritesFragment = (ContactTileListFragment) |
| fragmentManager.findFragmentByTag(FAVORITE_TAG); |
| mAllFragment = (DefaultContactBrowseListFragment) |
| fragmentManager.findFragmentByTag(ALL_TAG); |
| mGroupsFragment = (GroupBrowseListFragment) |
| fragmentManager.findFragmentByTag(GROUPS_TAG); |
| |
| if (mFavoritesFragment == null) { |
| mFavoritesFragment = new ContactTileListFragment(); |
| mAllFragment = new DefaultContactBrowseListFragment(); |
| mGroupsFragment = new GroupBrowseListFragment(); |
| |
| transaction.add(R.id.tab_pager, mFavoritesFragment, FAVORITE_TAG); |
| transaction.add(R.id.tab_pager, mAllFragment, ALL_TAG); |
| transaction.add(R.id.tab_pager, mGroupsFragment, GROUPS_TAG); |
| } |
| } |
| |
| mFavoritesFragment.setListener(mFavoritesFragmentListener); |
| |
| mAllFragment.setOnContactListActionListener(new ContactBrowserActionListener()); |
| |
| mGroupsFragment.setListener(new GroupBrowserActionListener()); |
| |
| // Hide all fragments for now. We adjust visibility when we get onSelectedTabChanged() |
| // from ActionBarAdapter. |
| transaction.hide(mFavoritesFragment); |
| transaction.hide(mAllFragment); |
| transaction.hide(mGroupsFragment); |
| |
| if (isUsingTwoPanes) { |
| // Prepare 2-pane only fragments/views... |
| |
| // Container views for fragments |
| mFavoritesView = getView(R.id.favorites_view); |
| mDetailsView = getView(R.id.details_view); |
| mBrowserView = getView(R.id.browse_view); |
| |
| // 2-pane only fragments |
| mFrequentFragment = getFragment(R.id.frequent_fragment); |
| mFrequentFragment.setListener(mFavoritesFragmentListener); |
| mFrequentFragment.setDisplayType(DisplayType.FREQUENT_ONLY); |
| mFrequentFragment.enableQuickContact(true); |
| |
| mContactDetailLoaderFragment = getFragment(R.id.contact_detail_loader_fragment); |
| mContactDetailLoaderFragment.setListener(mContactDetailLoaderFragmentListener); |
| |
| mGroupDetailFragment = getFragment(R.id.group_detail_fragment); |
| mGroupDetailFragment.setListener(mGroupDetailFragmentListener); |
| mGroupDetailFragment.setQuickContact(true); |
| |
| if (mContactDetailFragment != null) { |
| transaction.hide(mContactDetailFragment); |
| } |
| transaction.hide(mGroupDetailFragment); |
| |
| // Configure contact details |
| mContactDetailLayoutController = new ContactDetailLayoutController(this, savedState, |
| getFragmentManager(), findViewById(R.id.contact_detail_container), |
| new ContactDetailFragmentListener()); |
| } |
| transaction.commitAllowingStateLoss(); |
| fragmentManager.executePendingTransactions(); |
| |
| // Setting Properties after fragment is created |
| if (PhoneCapabilityTester.isUsingTwoPanes(this)) { |
| mFavoritesFragment.enableQuickContact(true); |
| mFavoritesFragment.setDisplayType(DisplayType.STARRED_ONLY); |
| } else { |
| mFavoritesFragment.setDisplayType(DisplayType.STREQUENT); |
| } |
| |
| // Configure action bar |
| mActionBarAdapter = new ActionBarAdapter(this, this, getActionBar(), isUsingTwoPanes); |
| mActionBarAdapter.initialize(savedState, mRequest); |
| |
| invalidateOptionsMenuIfNeeded(); |
| } |
| |
| @Override |
| protected void onStart() { |
| if (!mFragmentInitialized) { |
| mFragmentInitialized = true; |
| /* Configure fragments if we haven't. |
| * |
| * Note it's a one-shot initialization, so we want to do this in {@link #onCreate}. |
| * |
| * However, because this method may indirectly touch views in fragments but fragments |
| * created in {@link #configureContentView} using a {@link FragmentTransaction} will NOT |
| * have views until {@link Activity#onCreate} finishes (they would if they were inflated |
| * from a layout), we need to do it here in {@link #onStart()}. |
| * |
| * (When {@link Fragment#onCreateView} is called is different in the former case and |
| * in the latter case, unfortunately.) |
| * |
| * Also, we skip most of the work in it if the activity is a re-created one. |
| * (so the argument.) |
| */ |
| configureFragments(!mIsRecreatedInstance); |
| } else if (PhoneCapabilityTester.isUsingTwoPanes(this) && !mCurrentFilterIsValid) { |
| // We only want to do the filter check in onStart for wide screen devices where it |
| // is often possible to get into single contact mode. Only do this check if |
| // the filter hasn't already been set properly (i.e. onCreate or onActivityResult). |
| |
| // Since there is only one {@link ContactListFilterController} across multiple |
| // activity instances, make sure the filter controller is in sync withthe current |
| // contact list fragment filter. |
| // TODO: Clean this up. Perhaps change {@link ContactListFilterController} to not be a |
| // singleton? |
| mContactListFilterController.setContactListFilter(mAllFragment.getFilter(), true); |
| mContactListFilterController.checkFilterValidity(true); |
| mCurrentFilterIsValid = true; |
| } |
| super.onStart(); |
| } |
| |
| @Override |
| protected void onPause() { |
| mOptionsMenuContactsAvailable = false; |
| |
| mProviderStatus = -1; |
| mProviderStatusLoader.setProviderStatusListener(null); |
| super.onPause(); |
| } |
| |
| @Override |
| protected void onResume() { |
| super.onResume(); |
| mProviderStatusLoader.setProviderStatusListener(this); |
| showContactsUnavailableFragmentIfNecessary(); |
| |
| // Re-register the listener, which may have been cleared when onSaveInstanceState was |
| // called. See also: onSaveInstanceState |
| mActionBarAdapter.setListener(this); |
| if (mTabPager != null) { |
| mTabPager.setOnPageChangeListener(mTabPagerListener); |
| } |
| // Current tab may have changed since the last onSaveInstanceState(). Make sure |
| // the actual contents match the tab. |
| updateFragmentsVisibility(); |
| } |
| |
| @Override |
| protected void onStop() { |
| super.onStop(); |
| mCurrentFilterIsValid = false; |
| } |
| |
| @Override |
| protected void onDestroy() { |
| // Some of variables will be null if this Activity redirects Intent. |
| // See also onCreate() or other methods called during the Activity's initialization. |
| if (mActionBarAdapter != null) { |
| mActionBarAdapter.setListener(null); |
| } |
| if (mContactListFilterController != null) { |
| mContactListFilterController.removeListener(this); |
| } |
| |
| super.onDestroy(); |
| } |
| |
| private void configureFragments(boolean fromRequest) { |
| if (fromRequest) { |
| ContactListFilter filter = null; |
| int actionCode = mRequest.getActionCode(); |
| boolean searchMode = mRequest.isSearchMode(); |
| TabState tabToOpen = null; |
| switch (actionCode) { |
| case ContactsRequest.ACTION_ALL_CONTACTS: |
| filter = ContactListFilter.createFilterWithType( |
| ContactListFilter.FILTER_TYPE_ALL_ACCOUNTS); |
| tabToOpen = TabState.ALL; |
| break; |
| case ContactsRequest.ACTION_CONTACTS_WITH_PHONES: |
| filter = ContactListFilter.createFilterWithType( |
| ContactListFilter.FILTER_TYPE_WITH_PHONE_NUMBERS_ONLY); |
| tabToOpen = TabState.ALL; |
| break; |
| |
| case ContactsRequest.ACTION_FREQUENT: |
| case ContactsRequest.ACTION_STREQUENT: |
| case ContactsRequest.ACTION_STARRED: |
| tabToOpen = TabState.FAVORITES; |
| break; |
| case ContactsRequest.ACTION_VIEW_CONTACT: |
| // We redirect this intent to the detail activity on 1-pane, so we don't get |
| // here. It's only for 2-pane. |
| tabToOpen = TabState.ALL; |
| break; |
| case ContactsRequest.ACTION_GROUP: |
| tabToOpen = TabState.GROUPS; |
| break; |
| } |
| if (tabToOpen != null) { |
| mActionBarAdapter.setCurrentTab(tabToOpen); |
| } |
| |
| if (filter != null) { |
| mContactListFilterController.setContactListFilter(filter, false); |
| searchMode = false; |
| } |
| |
| if (mRequest.getContactUri() != null) { |
| searchMode = false; |
| } |
| |
| mActionBarAdapter.setSearchMode(searchMode); |
| configureContactListFragmentForRequest(); |
| } |
| |
| configureContactListFragment(); |
| configureGroupListFragment(); |
| |
| invalidateOptionsMenuIfNeeded(); |
| } |
| |
| @Override |
| public void onContactListFilterChanged() { |
| if (mAllFragment == null || !mAllFragment.isAdded()) { |
| return; |
| } |
| |
| mAllFragment.setFilter(mContactListFilterController.getFilter()); |
| |
| invalidateOptionsMenuIfNeeded(); |
| } |
| |
| private void setupContactDetailFragment(final Uri contactLookupUri) { |
| mContactDetailLoaderFragment.loadUri(contactLookupUri); |
| invalidateOptionsMenuIfNeeded(); |
| } |
| |
| private void setupGroupDetailFragment(Uri groupUri) { |
| mGroupDetailFragment.loadGroup(groupUri); |
| invalidateOptionsMenuIfNeeded(); |
| } |
| |
| /** |
| * Handler for action bar actions. |
| */ |
| @Override |
| public void onAction(Action action) { |
| switch (action) { |
| case START_SEARCH_MODE: |
| // Tell the fragments that we're in the search mode |
| configureFragments(false /* from request */); |
| updateFragmentsVisibility(); |
| invalidateOptionsMenu(); |
| break; |
| case STOP_SEARCH_MODE: |
| setQueryTextToFragment(""); |
| updateFragmentsVisibility(); |
| invalidateOptionsMenu(); |
| break; |
| case CHANGE_SEARCH_QUERY: |
| setQueryTextToFragment(mActionBarAdapter.getQueryString()); |
| break; |
| default: |
| throw new IllegalStateException("Unkonwn ActionBarAdapter action: " + action); |
| } |
| } |
| |
| @Override |
| public void onSelectedTabChanged() { |
| updateFragmentsVisibility(); |
| } |
| |
| /** |
| * Updates the fragment/view visibility according to the current mode, such as |
| * {@link ActionBarAdapter#isSearchMode()} and {@link ActionBarAdapter#getCurrentTab()}. |
| */ |
| private void updateFragmentsVisibility() { |
| TabState tab = mActionBarAdapter.getCurrentTab(); |
| |
| // We use ViewPager on 1-pane. |
| if (!PhoneCapabilityTester.isUsingTwoPanes(this)) { |
| if (mActionBarAdapter.isSearchMode()) { |
| mTabPagerAdapter.setSearchMode(true); |
| } else { |
| // No smooth scrolling if quitting from the search mode. |
| final boolean wasSearchMode = mTabPagerAdapter.isSearchMode(); |
| mTabPagerAdapter.setSearchMode(false); |
| int tabIndex = tab.ordinal(); |
| if (mTabPager.getCurrentItem() != tabIndex) { |
| mTabPager.setCurrentItem(tabIndex, !wasSearchMode); |
| } |
| } |
| invalidateOptionsMenu(); |
| showEmptyStateForTab(tab); |
| if (tab == TabState.GROUPS) { |
| mGroupsFragment.setAddAccountsVisibility(!areGroupWritableAccountsAvailable()); |
| } |
| return; |
| } |
| |
| // for the tablet... |
| |
| // If in search mode, we use the all list + contact details to show the result. |
| if (mActionBarAdapter.isSearchMode()) { |
| tab = TabState.ALL; |
| } |
| switch (tab) { |
| case FAVORITES: |
| mFavoritesView.setVisibility(View.VISIBLE); |
| mBrowserView.setVisibility(View.GONE); |
| mDetailsView.setVisibility(View.GONE); |
| break; |
| case GROUPS: |
| mFavoritesView.setVisibility(View.GONE); |
| mBrowserView.setVisibility(View.VISIBLE); |
| mDetailsView.setVisibility(View.VISIBLE); |
| mGroupsFragment.setAddAccountsVisibility(!areGroupWritableAccountsAvailable()); |
| break; |
| case ALL: |
| mFavoritesView.setVisibility(View.GONE); |
| mBrowserView.setVisibility(View.VISIBLE); |
| mDetailsView.setVisibility(View.VISIBLE); |
| break; |
| } |
| FragmentManager fragmentManager = getFragmentManager(); |
| FragmentTransaction ft = fragmentManager.beginTransaction(); |
| |
| // Note mContactDetailLoaderFragment is an invisible fragment, but we still have to show/ |
| // hide it so its options menu will be shown/hidden. |
| switch (tab) { |
| case FAVORITES: |
| showFragment(ft, mFavoritesFragment); |
| showFragment(ft, mFrequentFragment); |
| hideFragment(ft, mAllFragment); |
| hideFragment(ft, mContactDetailLoaderFragment); |
| hideFragment(ft, mContactDetailFragment); |
| hideFragment(ft, mGroupsFragment); |
| hideFragment(ft, mGroupDetailFragment); |
| break; |
| case ALL: |
| hideFragment(ft, mFavoritesFragment); |
| hideFragment(ft, mFrequentFragment); |
| showFragment(ft, mAllFragment); |
| showFragment(ft, mContactDetailLoaderFragment); |
| showFragment(ft, mContactDetailFragment); |
| hideFragment(ft, mGroupsFragment); |
| hideFragment(ft, mGroupDetailFragment); |
| break; |
| case GROUPS: |
| hideFragment(ft, mFavoritesFragment); |
| hideFragment(ft, mFrequentFragment); |
| hideFragment(ft, mAllFragment); |
| hideFragment(ft, mContactDetailLoaderFragment); |
| hideFragment(ft, mContactDetailFragment); |
| showFragment(ft, mGroupsFragment); |
| showFragment(ft, mGroupDetailFragment); |
| break; |
| } |
| if (!ft.isEmpty()) { |
| ft.commitAllowingStateLoss(); |
| fragmentManager.executePendingTransactions(); |
| // When switching tabs, we need to invalidate options menu, but executing a |
| // fragment transaction does it implicitly. We don't have to call invalidateOptionsMenu |
| // manually. |
| } |
| showEmptyStateForTab(tab); |
| } |
| |
| private void showEmptyStateForTab(TabState tab) { |
| if (mContactsUnavailableFragment != null) { |
| switch (tab) { |
| case FAVORITES: |
| mContactsUnavailableFragment.setMessageText( |
| R.string.listTotalAllContactsZeroStarred, -1); |
| break; |
| case GROUPS: |
| mContactsUnavailableFragment.setMessageText(R.string.noGroups, |
| areGroupWritableAccountsAvailable() ? -1 : R.string.noAccounts); |
| break; |
| case ALL: |
| mContactsUnavailableFragment.setMessageText(R.string.noContacts, -1); |
| break; |
| } |
| } |
| } |
| |
| private class TabPagerListener implements ViewPager.OnPageChangeListener { |
| @Override |
| public void onPageScrollStateChanged(int state) { |
| } |
| |
| @Override |
| public void onPageScrolled(int position, float positionOffset, int positionOffsetPixels) { |
| } |
| |
| @Override |
| public void onPageSelected(int position) { |
| // Make sure not in the search mode, in which case position != TabState.ordinal(). |
| if (!mTabPagerAdapter.isSearchMode()) { |
| TabState selectedTab = TabState.fromInt(position); |
| mActionBarAdapter.setCurrentTab(selectedTab, false); |
| showEmptyStateForTab(selectedTab); |
| if (selectedTab == TabState.GROUPS) { |
| mGroupsFragment.setAddAccountsVisibility(!areGroupWritableAccountsAvailable()); |
| } |
| invalidateOptionsMenu(); |
| } |
| } |
| } |
| |
| /** |
| * Adapter for the {@link ViewPager}. Unlike {@link FragmentPagerAdapter}, |
| * {@link #instantiateItem} returns existing fragments, and {@link #instantiateItem}/ |
| * {@link #destroyItem} show/hide fragments instead of attaching/detaching. |
| * |
| * In search mode, we always show the "all" fragment, and disable the swipe. We change the |
| * number of items to 1 to disable the swipe. |
| * |
| * TODO figure out a more straight way to disable swipe. |
| */ |
| private class TabPagerAdapter extends PagerAdapter { |
| private final FragmentManager mFragmentManager; |
| private FragmentTransaction mCurTransaction = null; |
| |
| private boolean mTabPagerAdapterSearchMode; |
| |
| private Fragment mCurrentPrimaryItem; |
| |
| public TabPagerAdapter() { |
| mFragmentManager = getFragmentManager(); |
| } |
| |
| public boolean isSearchMode() { |
| return mTabPagerAdapterSearchMode; |
| } |
| |
| public void setSearchMode(boolean searchMode) { |
| if (searchMode == mTabPagerAdapterSearchMode) { |
| return; |
| } |
| mTabPagerAdapterSearchMode = searchMode; |
| notifyDataSetChanged(); |
| } |
| |
| @Override |
| public int getCount() { |
| return mTabPagerAdapterSearchMode ? 1 : TabState.values().length; |
| } |
| |
| /** Gets called when the number of items changes. */ |
| @Override |
| public int getItemPosition(Object object) { |
| if (mTabPagerAdapterSearchMode) { |
| if (object == mAllFragment) { |
| return 0; // Only 1 page in search mode |
| } |
| } else { |
| if (object == mFavoritesFragment) { |
| return TabState.FAVORITES.ordinal(); |
| } |
| if (object == mAllFragment) { |
| return TabState.ALL.ordinal(); |
| } |
| if (object == mGroupsFragment) { |
| return TabState.GROUPS.ordinal(); |
| } |
| } |
| return POSITION_NONE; |
| } |
| |
| @Override |
| public void startUpdate(View container) { |
| } |
| |
| private Fragment getFragment(int position) { |
| if (mTabPagerAdapterSearchMode) { |
| if (position == 0) { |
| return mAllFragment; |
| } |
| } else { |
| if (position == TabState.FAVORITES.ordinal()) { |
| return mFavoritesFragment; |
| } else if (position == TabState.ALL.ordinal()) { |
| return mAllFragment; |
| } else if (position == TabState.GROUPS.ordinal()) { |
| return mGroupsFragment; |
| } |
| } |
| throw new IllegalArgumentException("position: " + position); |
| } |
| |
| @Override |
| public Object instantiateItem(View container, int position) { |
| if (mCurTransaction == null) { |
| mCurTransaction = mFragmentManager.beginTransaction(); |
| } |
| Fragment f = getFragment(position); |
| mCurTransaction.show(f); |
| |
| // Non primary pages are not visible. |
| f.setUserVisibleHint(f == mCurrentPrimaryItem); |
| return f; |
| } |
| |
| @Override |
| public void destroyItem(View container, int position, Object object) { |
| if (mCurTransaction == null) { |
| mCurTransaction = mFragmentManager.beginTransaction(); |
| } |
| mCurTransaction.hide((Fragment) object); |
| } |
| |
| @Override |
| public void finishUpdate(View container) { |
| if (mCurTransaction != null) { |
| mCurTransaction.commitAllowingStateLoss(); |
| mCurTransaction = null; |
| mFragmentManager.executePendingTransactions(); |
| } |
| } |
| |
| @Override |
| public boolean isViewFromObject(View view, Object object) { |
| return ((Fragment) object).getView() == view; |
| } |
| |
| @Override |
| public void setPrimaryItem(View container, int position, Object object) { |
| Fragment fragment = (Fragment) object; |
| if (mCurrentPrimaryItem != fragment) { |
| if (mCurrentPrimaryItem != null) { |
| mCurrentPrimaryItem.setUserVisibleHint(false); |
| } |
| if (fragment != null) { |
| fragment.setUserVisibleHint(true); |
| } |
| mCurrentPrimaryItem = fragment; |
| } |
| } |
| |
| @Override |
| public Parcelable saveState() { |
| return null; |
| } |
| |
| @Override |
| public void restoreState(Parcelable state, ClassLoader loader) { |
| } |
| } |
| |
| private void setQueryTextToFragment(String query) { |
| mAllFragment.setQueryString(query, true); |
| mAllFragment.setVisibleScrollbarEnabled(!mAllFragment.isSearchMode()); |
| } |
| |
| private void configureContactListFragmentForRequest() { |
| Uri contactUri = mRequest.getContactUri(); |
| if (contactUri != null) { |
| // For an incoming request, explicitly require a selection if we are on 2-pane UI, |
| // (i.e. even if we view the same selected contact, the contact may no longer be |
| // in the list, so we must refresh the list). |
| if (PhoneCapabilityTester.isUsingTwoPanes(this)) { |
| mAllFragment.setSelectionRequired(true); |
| } |
| mAllFragment.setSelectedContactUri(contactUri); |
| } |
| |
| mAllFragment.setFilter(mContactListFilterController.getFilter()); |
| setQueryTextToFragment(mActionBarAdapter.getQueryString()); |
| |
| if (mRequest.isDirectorySearchEnabled()) { |
| mAllFragment.setDirectorySearchMode(DirectoryListLoader.SEARCH_MODE_DEFAULT); |
| } else { |
| mAllFragment.setDirectorySearchMode(DirectoryListLoader.SEARCH_MODE_NONE); |
| } |
| } |
| |
| private void configureContactListFragment() { |
| // Filter may be changed when this Activity is in background. |
| mAllFragment.setFilter(mContactListFilterController.getFilter()); |
| |
| final boolean useTwoPane = PhoneCapabilityTester.isUsingTwoPanes(this); |
| mAllFragment.setVerticalScrollbarPosition( |
| useTwoPane |
| ? View.SCROLLBAR_POSITION_LEFT |
| : View.SCROLLBAR_POSITION_RIGHT); |
| mAllFragment.setSelectionVisible(useTwoPane); |
| mAllFragment.setQuickContactEnabled(!useTwoPane); |
| } |
| |
| private void configureGroupListFragment() { |
| final boolean useTwoPane = PhoneCapabilityTester.isUsingTwoPanes(this); |
| mGroupsFragment.setVerticalScrollbarPosition( |
| useTwoPane |
| ? View.SCROLLBAR_POSITION_LEFT |
| : View.SCROLLBAR_POSITION_RIGHT); |
| mGroupsFragment.setSelectionVisible(useTwoPane); |
| } |
| |
| @Override |
| public void onProviderStatusChange() { |
| showContactsUnavailableFragmentIfNecessary(); |
| } |
| |
| private void showContactsUnavailableFragmentIfNecessary() { |
| int providerStatus = mProviderStatusLoader.getProviderStatus(); |
| if (providerStatus == mProviderStatus) { |
| return; |
| } |
| |
| mProviderStatus = providerStatus; |
| |
| View contactsUnavailableView = findViewById(R.id.contacts_unavailable_view); |
| View mainView = findViewById(R.id.main_view); |
| |
| if (mProviderStatus == ProviderStatus.STATUS_NORMAL) { |
| contactsUnavailableView.setVisibility(View.GONE); |
| if (mainView != null) { |
| mainView.setVisibility(View.VISIBLE); |
| } |
| if (mAllFragment != null) { |
| mAllFragment.setEnabled(true); |
| } |
| } else { |
| // If there are no accounts on the device and we should show the "no account" prompt |
| // (based on {@link SharedPreferences}), then launch the account setup activity so the |
| // user can sign-in or create an account. |
| if (!areContactWritableAccountsAvailable() && |
| AccountPromptUtils.shouldShowAccountPrompt(this)) { |
| AccountPromptUtils.launchAccountPrompt(this); |
| return; |
| } |
| |
| // Otherwise, continue setting up the page so that the user can still use the app |
| // without an account. |
| if (mAllFragment != null) { |
| mAllFragment.setEnabled(false); |
| } |
| if (mContactsUnavailableFragment == null) { |
| mContactsUnavailableFragment = new ContactsUnavailableFragment(); |
| mContactsUnavailableFragment.setProviderStatusLoader(mProviderStatusLoader); |
| mContactsUnavailableFragment.setOnContactsUnavailableActionListener( |
| new ContactsUnavailableFragmentListener()); |
| getFragmentManager().beginTransaction() |
| .replace(R.id.contacts_unavailable_container, mContactsUnavailableFragment) |
| .commitAllowingStateLoss(); |
| } else { |
| mContactsUnavailableFragment.update(); |
| } |
| contactsUnavailableView.setVisibility(View.VISIBLE); |
| if (mainView != null) { |
| mainView.setVisibility(View.INVISIBLE); |
| } |
| |
| TabState tab = mActionBarAdapter.getCurrentTab(); |
| showEmptyStateForTab(tab); |
| } |
| |
| invalidateOptionsMenuIfNeeded(); |
| } |
| |
| private final class ContactBrowserActionListener implements OnContactBrowserActionListener { |
| |
| @Override |
| public void onSelectionChange() { |
| if (PhoneCapabilityTester.isUsingTwoPanes(PeopleActivity.this)) { |
| setupContactDetailFragment(mAllFragment.getSelectedContactUri()); |
| } |
| } |
| |
| @Override |
| public void onViewContactAction(Uri contactLookupUri) { |
| if (PhoneCapabilityTester.isUsingTwoPanes(PeopleActivity.this)) { |
| setupContactDetailFragment(contactLookupUri); |
| } else { |
| Intent intent = new Intent(Intent.ACTION_VIEW, contactLookupUri); |
| // In search mode, the "up" affordance in the contact detail page should return the |
| // user to the search results, so finish the activity when that button is selected. |
| if (mActionBarAdapter.isSearchMode()) { |
| intent.putExtra( |
| ContactDetailActivity.INTENT_KEY_FINISH_ACTIVITY_ON_UP_SELECTED, true); |
| } |
| startActivity(intent); |
| } |
| } |
| |
| @Override |
| public void onCreateNewContactAction() { |
| Intent intent = new Intent(Intent.ACTION_INSERT, Contacts.CONTENT_URI); |
| Bundle extras = getIntent().getExtras(); |
| if (extras != null) { |
| intent.putExtras(extras); |
| } |
| startActivity(intent); |
| } |
| |
| @Override |
| public void onEditContactAction(Uri contactLookupUri) { |
| Intent intent = new Intent(Intent.ACTION_EDIT, contactLookupUri); |
| Bundle extras = getIntent().getExtras(); |
| if (extras != null) { |
| intent.putExtras(extras); |
| } |
| intent.putExtra( |
| ContactEditorActivity.INTENT_KEY_FINISH_ACTIVITY_ON_SAVE_COMPLETED, true); |
| startActivityForResult(intent, SUBACTIVITY_EDIT_CONTACT); |
| } |
| |
| @Override |
| public void onAddToFavoritesAction(Uri contactUri) { |
| ContentValues values = new ContentValues(1); |
| values.put(Contacts.STARRED, 1); |
| getContentResolver().update(contactUri, values, null, null); |
| } |
| |
| @Override |
| public void onRemoveFromFavoritesAction(Uri contactUri) { |
| ContentValues values = new ContentValues(1); |
| values.put(Contacts.STARRED, 0); |
| getContentResolver().update(contactUri, values, null, null); |
| } |
| |
| @Override |
| public void onCallContactAction(Uri contactUri) { |
| PhoneNumberInteraction.startInteractionForPhoneCall(PeopleActivity.this, contactUri); |
| } |
| |
| @Override |
| public void onSmsContactAction(Uri contactUri) { |
| PhoneNumberInteraction.startInteractionForTextMessage(PeopleActivity.this, contactUri); |
| } |
| |
| @Override |
| public void onDeleteContactAction(Uri contactUri) { |
| ContactDeletionInteraction.start(PeopleActivity.this, contactUri, false); |
| } |
| |
| @Override |
| public void onFinishAction() { |
| onBackPressed(); |
| } |
| |
| @Override |
| public void onInvalidSelection() { |
| ContactListFilter filter; |
| ContactListFilter currentFilter = mAllFragment.getFilter(); |
| if (currentFilter != null |
| && currentFilter.filterType == ContactListFilter.FILTER_TYPE_SINGLE_CONTACT) { |
| filter = ContactListFilter.createFilterWithType( |
| ContactListFilter.FILTER_TYPE_ALL_ACCOUNTS); |
| mAllFragment.setFilter(filter); |
| } else { |
| filter = ContactListFilter.createFilterWithType( |
| ContactListFilter.FILTER_TYPE_SINGLE_CONTACT); |
| mAllFragment.setFilter(filter, false); |
| } |
| mContactListFilterController.setContactListFilter(filter, true); |
| } |
| } |
| |
| private class ContactDetailLoaderFragmentListener implements ContactLoaderFragmentListener { |
| @Override |
| public void onContactNotFound() { |
| // Nothing needs to be done here |
| } |
| |
| @Override |
| public void onDetailsLoaded(final ContactLoader.Result result) { |
| if (result == null) { |
| // Nothing is loaded. Show empty state. |
| mContactDetailLayoutController.showEmptyState(); |
| return; |
| } |
| // Since {@link FragmentTransaction}s cannot be done in the onLoadFinished() of the |
| // {@link LoaderCallbacks}, then post this {@link Runnable} to the {@link Handler} |
| // on the main thread to execute later. |
| mHandler.post(new Runnable() { |
| @Override |
| public void run() { |
| // If the activity is destroyed (or will be destroyed soon), don't update the UI |
| if (isFinishing()) { |
| return; |
| } |
| mContactDetailLayoutController.setContactData(result); |
| } |
| }); |
| } |
| |
| @Override |
| public void onEditRequested(Uri contactLookupUri) { |
| Intent intent = new Intent(Intent.ACTION_EDIT, contactLookupUri); |
| intent.putExtra( |
| ContactEditorActivity.INTENT_KEY_FINISH_ACTIVITY_ON_SAVE_COMPLETED, true); |
| startActivityForResult(intent, SUBACTIVITY_EDIT_CONTACT); |
| } |
| |
| @Override |
| public void onDeleteRequested(Uri contactUri) { |
| ContactDeletionInteraction.start(PeopleActivity.this, contactUri, false); |
| } |
| } |
| |
| public class ContactDetailFragmentListener implements ContactDetailFragment.Listener { |
| @Override |
| public void onItemClicked(Intent intent) { |
| if (intent == null) { |
| return; |
| } |
| try { |
| startActivity(intent); |
| } catch (ActivityNotFoundException e) { |
| Log.e(TAG, "No activity found for intent: " + intent); |
| } |
| } |
| |
| @Override |
| public void onCreateRawContactRequested(ArrayList<ContentValues> values, |
| AccountWithDataSet account) { |
| Toast.makeText(PeopleActivity.this, R.string.toast_making_personal_copy, |
| Toast.LENGTH_LONG).show(); |
| Intent serviceIntent = ContactSaveService.createNewRawContactIntent( |
| PeopleActivity.this, values, account, |
| PeopleActivity.class, Intent.ACTION_VIEW); |
| startService(serviceIntent); |
| } |
| } |
| |
| private class ContactsUnavailableFragmentListener |
| implements OnContactsUnavailableActionListener { |
| |
| @Override |
| public void onCreateNewContactAction() { |
| startActivity(new Intent(Intent.ACTION_INSERT, Contacts.CONTENT_URI)); |
| } |
| |
| @Override |
| public void onAddAccountAction() { |
| Intent intent = new Intent(Settings.ACTION_ADD_ACCOUNT); |
| intent.setFlags(Intent.FLAG_ACTIVITY_CLEAR_WHEN_TASK_RESET); |
| intent.putExtra(Settings.EXTRA_AUTHORITIES, |
| new String[] { ContactsContract.AUTHORITY }); |
| startActivity(intent); |
| } |
| |
| @Override |
| public void onImportContactsFromFileAction() { |
| ImportExportDialogFragment.show(getFragmentManager()); |
| } |
| |
| @Override |
| public void onFreeInternalStorageAction() { |
| startActivity(new Intent(Settings.ACTION_MANAGE_APPLICATIONS_SETTINGS)); |
| } |
| } |
| |
| private final class StrequentContactListFragmentListener |
| implements ContactTileListFragment.Listener { |
| @Override |
| public void onContactSelected(Uri contactUri, Rect targetRect) { |
| if (PhoneCapabilityTester.isUsingTwoPanes(PeopleActivity.this)) { |
| QuickContact.showQuickContact(PeopleActivity.this, targetRect, contactUri, 0, null); |
| } else { |
| startActivity(new Intent(Intent.ACTION_VIEW, contactUri)); |
| } |
| } |
| } |
| |
| private final class GroupBrowserActionListener implements OnGroupBrowserActionListener { |
| |
| @Override |
| public void onViewGroupAction(Uri groupUri) { |
| if (PhoneCapabilityTester.isUsingTwoPanes(PeopleActivity.this)) { |
| setupGroupDetailFragment(groupUri); |
| } else { |
| Intent intent = new Intent(PeopleActivity.this, GroupDetailActivity.class); |
| intent.setData(groupUri); |
| startActivity(intent); |
| } |
| } |
| } |
| |
| private class GroupDetailFragmentListener implements GroupDetailFragment.Listener { |
| @Override |
| public void onGroupSizeUpdated(String size) { |
| // Nothing needs to be done here because the size will be displayed in the detail |
| // fragment |
| } |
| |
| @Override |
| public void onGroupTitleUpdated(String title) { |
| // Nothing needs to be done here because the title will be displayed in the detail |
| // fragment |
| } |
| |
| @Override |
| public void onAccountTypeUpdated(String accountTypeString, String dataSet) { |
| // Nothing needs to be done here because the group source will be displayed in the |
| // detail fragment |
| } |
| |
| @Override |
| public void onEditRequested(Uri groupUri) { |
| final Intent intent = new Intent(PeopleActivity.this, GroupEditorActivity.class); |
| intent.setData(groupUri); |
| intent.setAction(Intent.ACTION_EDIT); |
| startActivityForResult(intent, SUBACTIVITY_EDIT_GROUP); |
| } |
| |
| @Override |
| public void onContactSelected(Uri contactUri) { |
| // Nothing needs to be done here because either quickcontact will be displayed |
| // or activity will take care of selection |
| } |
| } |
| |
| public void startActivityAndForwardResult(final Intent intent) { |
| intent.setFlags(Intent.FLAG_ACTIVITY_FORWARD_RESULT); |
| |
| // Forward extras to the new activity |
| Bundle extras = getIntent().getExtras(); |
| if (extras != null) { |
| intent.putExtras(extras); |
| } |
| startActivity(intent); |
| finish(); |
| } |
| |
| @Override |
| public boolean onCreateOptionsMenu(Menu menu) { |
| if (!areContactsAvailable()) { |
| // If contacts aren't available, hide all menu items. |
| return false; |
| } |
| super.onCreateOptionsMenu(menu); |
| |
| MenuInflater inflater = getMenuInflater(); |
| inflater.inflate(R.menu.actions, menu); |
| |
| // On narrow screens we specify a NEW group button in the {@link ActionBar}, so that |
| // it can be in the overflow menu. On wide screens, we use a custom view because we need |
| // its location for anchoring the account-selector popup. |
| final MenuItem addGroup = menu.findItem(R.id.menu_custom_add_group); |
| if (addGroup != null) { |
| mAddGroupImageView = getLayoutInflater().inflate( |
| R.layout.add_group_menu_item, null, false); |
| mAddGroupImageView.setOnClickListener(new OnClickListener() { |
| @Override |
| public void onClick(View v) { |
| createNewGroupWithAccountDisambiguation(); |
| } |
| }); |
| addGroup.setActionView(mAddGroupImageView); |
| } |
| return true; |
| } |
| |
| private void invalidateOptionsMenuIfNeeded() { |
| if (isOptionsMenuChanged()) { |
| invalidateOptionsMenu(); |
| } |
| } |
| |
| public boolean isOptionsMenuChanged() { |
| if (mOptionsMenuContactsAvailable != areContactsAvailable()) { |
| return true; |
| } |
| |
| if (mAllFragment != null && mAllFragment.isOptionsMenuChanged()) { |
| return true; |
| } |
| |
| if (mContactDetailLoaderFragment != null && |
| mContactDetailLoaderFragment.isOptionsMenuChanged()) { |
| return true; |
| } |
| |
| if (mGroupDetailFragment != null && mGroupDetailFragment.isOptionsMenuChanged()) { |
| return true; |
| } |
| |
| return false; |
| } |
| |
| @Override |
| public boolean onPrepareOptionsMenu(Menu menu) { |
| mOptionsMenuContactsAvailable = areContactsAvailable(); |
| if (!mOptionsMenuContactsAvailable) { |
| return false; |
| } |
| |
| final MenuItem addContactMenu = menu.findItem(R.id.menu_add_contact); |
| final MenuItem contactsFilterMenu = menu.findItem(R.id.menu_contacts_filter); |
| |
| MenuItem addGroupMenu = menu.findItem(R.id.menu_add_group); |
| if (addGroupMenu == null) { |
| addGroupMenu = menu.findItem(R.id.menu_custom_add_group); |
| } |
| |
| final boolean isSearchMode = mActionBarAdapter.isSearchMode(); |
| if (isSearchMode) { |
| addContactMenu.setVisible(false); |
| addGroupMenu.setVisible(false); |
| contactsFilterMenu.setVisible(false); |
| } else { |
| switch (mActionBarAdapter.getCurrentTab()) { |
| case FAVORITES: |
| addContactMenu.setVisible(false); |
| addGroupMenu.setVisible(false); |
| contactsFilterMenu.setVisible(false); |
| break; |
| case ALL: |
| addContactMenu.setVisible(true); |
| addGroupMenu.setVisible(false); |
| contactsFilterMenu.setVisible(true); |
| break; |
| case GROUPS: |
| // Do not display the "new group" button if no accounts are available |
| if (areGroupWritableAccountsAvailable()) { |
| addGroupMenu.setVisible(true); |
| } else { |
| addGroupMenu.setVisible(false); |
| } |
| addContactMenu.setVisible(false); |
| contactsFilterMenu.setVisible(false); |
| break; |
| } |
| } |
| final boolean showMiscOptions = !isSearchMode; |
| makeMenuItemVisible(menu, R.id.menu_search, showMiscOptions); |
| makeMenuItemVisible(menu, R.id.menu_import_export, showMiscOptions); |
| makeMenuItemVisible(menu, R.id.menu_accounts, showMiscOptions); |
| makeMenuItemVisible(menu, R.id.menu_settings, |
| showMiscOptions && !ContactsPreferenceActivity.isEmpty(this)); |
| |
| return true; |
| } |
| |
| private void makeMenuItemVisible(Menu menu, int itemId, boolean visible) { |
| MenuItem item =menu.findItem(itemId); |
| if (item != null) { |
| item.setVisible(visible); |
| } |
| } |
| |
| @Override |
| public boolean onOptionsItemSelected(MenuItem item) { |
| switch (item.getItemId()) { |
| case android.R.id.home: { |
| // The home icon on the action bar is pressed |
| if (mActionBarAdapter.isUpShowing()) { |
| // "UP" icon press -- should be treated as "back". |
| onBackPressed(); |
| } |
| return true; |
| } |
| case R.id.menu_settings: { |
| final Intent intent = new Intent(this, ContactsPreferenceActivity.class); |
| // as there is only one section right now, make sure it is selected |
| // on small screens, this also hides the section selector |
| // Due to b/5045558, this code unfortunately only works properly on phones |
| boolean settingsAreMultiPane = getResources().getBoolean( |
| com.android.internal.R.bool.preferences_prefer_dual_pane); |
| if (!settingsAreMultiPane) { |
| intent.putExtra(PreferenceActivity.EXTRA_SHOW_FRAGMENT, |
| DisplayOptionsPreferenceFragment.class.getName()); |
| intent.putExtra(PreferenceActivity.EXTRA_SHOW_FRAGMENT_TITLE, |
| R.string.preference_displayOptions); |
| } |
| startActivity(intent); |
| return true; |
| } |
| case R.id.menu_contacts_filter: { |
| AccountFilterUtil.startAccountFilterActivityForResult(this, |
| SUBACTIVITY_ACCOUNT_FILTER); |
| return true; |
| } |
| case R.id.menu_search: { |
| onSearchRequested(); |
| return true; |
| } |
| case R.id.menu_add_contact: { |
| final Intent intent = new Intent(Intent.ACTION_INSERT, Contacts.CONTENT_URI); |
| // On 2-pane UI, we can let the editor activity finish itself and return |
| // to this activity to display the new contact. |
| if (PhoneCapabilityTester.isUsingTwoPanes(this)) { |
| intent.putExtra( |
| ContactEditorActivity.INTENT_KEY_FINISH_ACTIVITY_ON_SAVE_COMPLETED, true); |
| startActivityForResult(intent, SUBACTIVITY_NEW_CONTACT); |
| } else { |
| // Otherwise, on 1-pane UI, we need the editor to launch the view contact |
| // intent itself. |
| startActivity(intent); |
| } |
| return true; |
| } |
| case R.id.menu_add_group: { |
| createNewGroupWithAccountDisambiguation(); |
| return true; |
| } |
| case R.id.menu_import_export: { |
| ImportExportDialogFragment.show(getFragmentManager()); |
| return true; |
| } |
| case R.id.menu_accounts: { |
| final Intent intent = new Intent(Settings.ACTION_SYNC_SETTINGS); |
| intent.putExtra(Settings.EXTRA_AUTHORITIES, new String[] { |
| ContactsContract.AUTHORITY |
| }); |
| intent.setFlags(Intent.FLAG_ACTIVITY_CLEAR_WHEN_TASK_RESET); |
| startActivity(intent); |
| return true; |
| } |
| } |
| return false; |
| } |
| |
| private void createNewGroupWithAccountDisambiguation() { |
| final List<AccountWithDataSet> accounts = |
| AccountTypeManager.getInstance(this).getAccounts(true); |
| if (accounts.size() <= 1 || mAddGroupImageView == null) { |
| // No account to choose or no control to anchor the popup-menu to |
| // ==> just go straight to the editor which will disambig if necessary |
| final Intent intent = new Intent(this, GroupEditorActivity.class); |
| intent.setAction(Intent.ACTION_INSERT); |
| startActivityForResult(intent, SUBACTIVITY_NEW_GROUP); |
| return; |
| } |
| |
| final ListPopupWindow popup = new ListPopupWindow(this, null); |
| popup.setWidth(getResources().getDimensionPixelSize(R.dimen.account_selector_popup_width)); |
| popup.setAnchorView(mAddGroupImageView); |
| // Create a list adapter with all writeable accounts (assume that the writeable accounts all |
| // allow group creation). |
| final AccountsListAdapter adapter = new AccountsListAdapter(this, |
| AccountListFilter.ACCOUNTS_GROUP_WRITABLE); |
| popup.setAdapter(adapter); |
| popup.setOnItemClickListener(new OnItemClickListener() { |
| @Override |
| public void onItemClick(AdapterView<?> parent, View view, int position, long id) { |
| popup.dismiss(); |
| AccountWithDataSet account = adapter.getItem(position); |
| final Intent intent = new Intent(PeopleActivity.this, GroupEditorActivity.class); |
| intent.setAction(Intent.ACTION_INSERT); |
| intent.putExtra(Intents.Insert.ACCOUNT, account); |
| intent.putExtra(Intents.Insert.DATA_SET, account.dataSet); |
| startActivityForResult(intent, SUBACTIVITY_NEW_GROUP); |
| } |
| }); |
| popup.setModal(true); |
| popup.show(); |
| } |
| |
| @Override |
| public boolean onSearchRequested() { // Search key pressed. |
| mActionBarAdapter.setSearchMode(true); |
| return true; |
| } |
| |
| @Override |
| protected void onActivityResult(int requestCode, int resultCode, Intent data) { |
| switch (requestCode) { |
| case SUBACTIVITY_ACCOUNT_FILTER: { |
| AccountFilterUtil.handleAccountFilterResult( |
| mContactListFilterController, resultCode, data); |
| break; |
| } |
| |
| case SUBACTIVITY_NEW_CONTACT: |
| case SUBACTIVITY_EDIT_CONTACT: { |
| if (resultCode == RESULT_OK && PhoneCapabilityTester.isUsingTwoPanes(this)) { |
| mRequest.setActionCode(ContactsRequest.ACTION_VIEW_CONTACT); |
| mAllFragment.setSelectionRequired(true); |
| mAllFragment.reloadDataAndSetSelectedUri(data.getData()); |
| // Suppress IME if in search mode |
| if (mActionBarAdapter != null) { |
| mActionBarAdapter.clearFocusOnSearchView(); |
| } |
| // No need to change the contact filter |
| mCurrentFilterIsValid = true; |
| } |
| break; |
| } |
| |
| case SUBACTIVITY_NEW_GROUP: |
| case SUBACTIVITY_EDIT_GROUP: { |
| if (resultCode == RESULT_OK && PhoneCapabilityTester.isUsingTwoPanes(this)) { |
| mRequest.setActionCode(ContactsRequest.ACTION_GROUP); |
| mGroupsFragment.setSelectedUri(data.getData()); |
| } |
| break; |
| } |
| |
| // TODO: Using the new startActivityWithResultFromFragment API this should not be needed |
| // anymore |
| case ContactEntryListFragment.ACTIVITY_REQUEST_CODE_PICKER: |
| if (resultCode == RESULT_OK) { |
| mAllFragment.onPickerResult(data); |
| } |
| |
| // TODO fix or remove multipicker code |
| // else if (resultCode == RESULT_CANCELED && mMode == MODE_PICK_MULTIPLE_PHONES) { |
| // // Finish the activity if the sub activity was canceled as back key is used |
| // // to confirm user selection in MODE_PICK_MULTIPLE_PHONES. |
| // finish(); |
| // } |
| // break; |
| } |
| } |
| |
| @Override |
| public boolean onKeyDown(int keyCode, KeyEvent event) { |
| // TODO move to the fragment |
| switch (keyCode) { |
| // case KeyEvent.KEYCODE_CALL: { |
| // if (callSelection()) { |
| // return true; |
| // } |
| // break; |
| // } |
| |
| case KeyEvent.KEYCODE_DEL: { |
| if (deleteSelection()) { |
| return true; |
| } |
| break; |
| } |
| default: { |
| // Bring up the search UI if the user starts typing |
| final int unicodeChar = event.getUnicodeChar(); |
| if (unicodeChar != 0 && !Character.isWhitespace(unicodeChar)) { |
| String query = new String(new int[]{ unicodeChar }, 0, 1); |
| if (!mActionBarAdapter.isSearchMode()) { |
| mActionBarAdapter.setQueryString(query); |
| mActionBarAdapter.setSearchMode(true); |
| return true; |
| } |
| } |
| } |
| } |
| |
| return super.onKeyDown(keyCode, event); |
| } |
| |
| @Override |
| public void onBackPressed() { |
| if (mActionBarAdapter.isSearchMode()) { |
| mActionBarAdapter.setSearchMode(false); |
| } else { |
| super.onBackPressed(); |
| } |
| } |
| |
| private boolean deleteSelection() { |
| // TODO move to the fragment |
| // if (mActionCode == ContactsRequest.ACTION_DEFAULT) { |
| // final int position = mListView.getSelectedItemPosition(); |
| // if (position != ListView.INVALID_POSITION) { |
| // Uri contactUri = getContactUri(position); |
| // if (contactUri != null) { |
| // doContactDelete(contactUri); |
| // return true; |
| // } |
| // } |
| // } |
| return false; |
| } |
| |
| @Override |
| protected void onSaveInstanceState(Bundle outState) { |
| super.onSaveInstanceState(outState); |
| mActionBarAdapter.onSaveInstanceState(outState); |
| if (mContactDetailLayoutController != null) { |
| mContactDetailLayoutController.onSaveInstanceState(outState); |
| } |
| |
| // Clear the listener to make sure we don't get callbacks after onSaveInstanceState, |
| // in order to avoid doing fragment transactions after it. |
| // TODO Figure out a better way to deal with the issue. |
| mActionBarAdapter.setListener(null); |
| if (mTabPager != null) { |
| mTabPager.setOnPageChangeListener(null); |
| } |
| } |
| |
| @Override |
| public DialogManager getDialogManager() { |
| return mDialogManager; |
| } |
| |
| // Visible for testing |
| public ContactBrowseListFragment getListFragment() { |
| return mAllFragment; |
| } |
| |
| // Visible for testing |
| public ContactDetailFragment getDetailFragment() { |
| return mContactDetailFragment; |
| } |
| } |
