The Android Open Source Project | 7aa0e4c | 2009-03-03 19:32:21 -0800 | [diff] [blame] | 1 | /* |
Dmitri Plotnikov | fcfdffb | 2010-07-15 18:00:55 -0700 | [diff] [blame] | 2 | * Copyright (C) 2010 The Android Open Source Project |
The Android Open Source Project | 7aa0e4c | 2009-03-03 19:32:21 -0800 | [diff] [blame] | 3 | * |
| 4 | * Licensed under the Apache License, Version 2.0 (the "License"); |
| 5 | * you may not use this file except in compliance with the License. |
| 6 | * You may obtain a copy of the License at |
| 7 | * |
| 8 | * http://www.apache.org/licenses/LICENSE-2.0 |
| 9 | * |
| 10 | * Unless required by applicable law or agreed to in writing, software |
| 11 | * distributed under the License is distributed on an "AS IS" BASIS, |
| 12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| 13 | * See the License for the specific language governing permissions and |
| 14 | * limitations under the License. |
| 15 | */ |
| 16 | |
Dmitri Plotnikov | 27834b2 | 2010-07-01 14:10:08 -0700 | [diff] [blame] | 17 | package com.android.contacts.activities; |
The Android Open Source Project | 7aa0e4c | 2009-03-03 19:32:21 -0800 | [diff] [blame] | 18 | |
Chiao Cheng | e0b2f1e | 2012-06-12 13:07:56 -0700 | [diff] [blame] | 19 | import android.app.Fragment; |
| 20 | import android.app.FragmentManager; |
| 21 | import android.app.FragmentTransaction; |
Jay Shrauner | d391f84 | 2014-11-26 11:14:24 -0800 | [diff] [blame] | 22 | import android.content.ActivityNotFoundException; |
Brian Attwell | 20510ec | 2015-02-27 16:10:45 -0800 | [diff] [blame] | 23 | import android.content.ContentUris; |
Brian Attwell | 73a6764 | 2014-12-18 20:40:58 -0800 | [diff] [blame] | 24 | import android.content.Context; |
Chiao Cheng | e0b2f1e | 2012-06-12 13:07:56 -0700 | [diff] [blame] | 25 | import android.content.Intent; |
Wenyi Wang | 2f09e60 | 2015-10-28 11:34:23 -0700 | [diff] [blame] | 26 | import android.content.pm.PackageManager; |
| 27 | import android.content.pm.ResolveInfo; |
Chiao Cheng | e0b2f1e | 2012-06-12 13:07:56 -0700 | [diff] [blame] | 28 | import android.graphics.Rect; |
| 29 | import android.net.Uri; |
Wenyi Wang | 1fc3ef4 | 2016-01-14 18:21:40 -0800 | [diff] [blame] | 30 | import android.os.Build; |
Chiao Cheng | e0b2f1e | 2012-06-12 13:07:56 -0700 | [diff] [blame] | 31 | import android.os.Bundle; |
Chiao Cheng | e0b2f1e | 2012-06-12 13:07:56 -0700 | [diff] [blame] | 32 | import android.os.Parcelable; |
Chiao Cheng | 9f0a1c7 | 2013-04-19 10:57:26 -0700 | [diff] [blame] | 33 | import android.os.UserManager; |
Chiao Cheng | e0b2f1e | 2012-06-12 13:07:56 -0700 | [diff] [blame] | 34 | import android.preference.PreferenceActivity; |
| 35 | import android.provider.ContactsContract; |
| 36 | import android.provider.ContactsContract.Contacts; |
| 37 | import android.provider.ContactsContract.ProviderStatus; |
Ricky Wai | ed5202a | 2015-11-17 18:06:33 +0000 | [diff] [blame] | 38 | import android.provider.ContactsContract.QuickContact; |
Chiao Cheng | e0b2f1e | 2012-06-12 13:07:56 -0700 | [diff] [blame] | 39 | import android.provider.Settings; |
| 40 | import android.support.v13.app.FragmentPagerAdapter; |
| 41 | import android.support.v4.view.PagerAdapter; |
| 42 | import android.support.v4.view.ViewPager; |
Wenyi Wang | e7fd1ad | 2016-01-06 14:12:10 -0800 | [diff] [blame] | 43 | import android.support.v7.widget.Toolbar; |
Fabrice Di Meglio | 7d3b915 | 2013-04-04 19:49:34 -0700 | [diff] [blame] | 44 | import android.text.TextUtils; |
Chiao Cheng | e0b2f1e | 2012-06-12 13:07:56 -0700 | [diff] [blame] | 45 | import android.util.Log; |
| 46 | import android.view.KeyCharacterMap; |
| 47 | import android.view.KeyEvent; |
| 48 | import android.view.Menu; |
| 49 | import android.view.MenuInflater; |
| 50 | import android.view.MenuItem; |
Chiao Cheng | e0b2f1e | 2012-06-12 13:07:56 -0700 | [diff] [blame] | 51 | import android.view.View; |
| 52 | import android.view.ViewGroup; |
Paul Soulos | 2b9563d | 2014-05-27 16:21:23 -0700 | [diff] [blame] | 53 | import android.widget.ImageButton; |
Jay Shrauner | d391f84 | 2014-11-26 11:14:24 -0800 | [diff] [blame] | 54 | import android.widget.Toast; |
Chiao Cheng | e0b2f1e | 2012-06-12 13:07:56 -0700 | [diff] [blame] | 55 | |
Wenyi Wang | e7fd1ad | 2016-01-06 14:12:10 -0800 | [diff] [blame] | 56 | import com.android.contacts.AppCompatContactsActivity; |
Dmitri Plotnikov | 27834b2 | 2010-07-01 14:10:08 -0700 | [diff] [blame] | 57 | import com.android.contacts.R; |
Makoto Onuki | 4d788fc | 2011-07-12 10:00:10 -0700 | [diff] [blame] | 58 | import com.android.contacts.activities.ActionBarAdapter.TabState; |
Yorke Lee | cd321f6 | 2013-10-28 15:20:15 -0700 | [diff] [blame] | 59 | import com.android.contacts.common.ContactsUtils; |
Brian Attwell | bdd3264 | 2015-05-08 17:03:15 -0700 | [diff] [blame] | 60 | import com.android.contacts.common.activity.RequestPermissionsActivity; |
Chiao Cheng | c8dd78c | 2012-10-31 15:31:33 -0700 | [diff] [blame] | 61 | import com.android.contacts.common.dialog.ClearFrequentsDialog; |
Chiao Cheng | 051f41d | 2012-12-04 15:42:42 -0800 | [diff] [blame] | 62 | import com.android.contacts.common.interactions.ImportExportDialogFragment; |
Chiao Cheng | 821a657 | 2012-12-04 17:42:52 -0800 | [diff] [blame] | 63 | import com.android.contacts.common.list.ContactEntryListFragment; |
Chiao Cheng | a0233a0 | 2012-11-01 16:41:08 -0700 | [diff] [blame] | 64 | import com.android.contacts.common.list.ContactListFilter; |
Chiao Cheng | 0d5588d | 2012-11-26 15:34:14 -0800 | [diff] [blame] | 65 | import com.android.contacts.common.list.ContactListFilterController; |
Chiao Cheng | e776d03 | 2012-11-05 16:28:36 -0800 | [diff] [blame] | 66 | import com.android.contacts.common.list.ContactTileAdapter.DisplayType; |
Chiao Cheng | a0233a0 | 2012-11-01 16:41:08 -0700 | [diff] [blame] | 67 | import com.android.contacts.common.list.DirectoryListLoader; |
Brian Attwell | 3c763b3 | 2014-07-21 14:25:28 -0700 | [diff] [blame] | 68 | import com.android.contacts.common.list.ViewPagerTabs; |
Walter Jang | a84fe61 | 2016-01-13 16:49:04 -0800 | [diff] [blame] | 69 | import com.android.contacts.common.logging.Logger; |
| 70 | import com.android.contacts.common.logging.ScreenEvent; |
Wenyi Wang | 86f2a86 | 2015-12-30 16:54:51 -0800 | [diff] [blame] | 71 | import com.android.contacts.common.preference.ContactsPreferenceActivity; |
guanxiongliu | f597ec6 | 2016-01-25 19:49:42 -0800 | [diff] [blame] | 72 | import com.android.contacts.common.preference.DisplayOptionsPreferenceFragment; |
Chiao Cheng | 30868d4 | 2012-11-28 17:45:57 -0800 | [diff] [blame] | 73 | import com.android.contacts.common.util.AccountFilterUtil; |
guanxiongliu | f597ec6 | 2016-01-25 19:49:42 -0800 | [diff] [blame] | 74 | import com.android.contacts.common.util.Constants; |
guanxiongliu | 5d7bb26 | 2016-01-29 16:43:45 -0800 | [diff] [blame] | 75 | import com.android.contacts.common.util.ImplicitIntentsUtil; |
Paul Soulos | 2b9563d | 2014-05-27 16:21:23 -0700 | [diff] [blame] | 76 | import com.android.contacts.common.util.ViewUtil; |
guanxiongliu | 5d7bb26 | 2016-01-29 16:43:45 -0800 | [diff] [blame] | 77 | import com.android.contacts.common.widget.FloatingActionButtonController; |
guanxiongliu | f597ec6 | 2016-01-25 19:49:42 -0800 | [diff] [blame] | 78 | import com.android.contacts.editor.EditorIntents; |
| 79 | import com.android.contacts.interactions.ContactDeletionInteraction; |
| 80 | import com.android.contacts.interactions.ContactMultiDeletionInteraction; |
| 81 | import com.android.contacts.interactions.ContactMultiDeletionInteraction.MultiContactDeleteListener; |
| 82 | import com.android.contacts.interactions.JoinContactsDialogFragment; |
| 83 | import com.android.contacts.interactions.JoinContactsDialogFragment.JoinContactsListener; |
| 84 | import com.android.contacts.list.ContactTileListFragment; |
| 85 | import com.android.contacts.list.ContactsIntentResolver; |
| 86 | import com.android.contacts.list.ContactsRequest; |
| 87 | import com.android.contacts.list.ContactsUnavailableFragment; |
| 88 | import com.android.contacts.list.MultiSelectContactsListFragment; |
| 89 | import com.android.contacts.list.MultiSelectContactsListFragment.OnCheckBoxListActionListener; |
| 90 | import com.android.contacts.list.OnContactBrowserActionListener; |
| 91 | import com.android.contacts.list.OnContactsUnavailableActionListener; |
| 92 | import com.android.contacts.list.ProviderStatusWatcher; |
| 93 | import com.android.contacts.list.ProviderStatusWatcher.ProviderStatusListener; |
Brian Attwell | 8a6f4ad | 2014-06-06 21:54:53 -0700 | [diff] [blame] | 94 | import com.android.contacts.quickcontact.QuickContactActivity; |
Daniel Lehmann | 3391dbe | 2010-07-12 09:50:22 -0700 | [diff] [blame] | 95 | import com.android.contacts.util.DialogManager; |
guanxiongliu | f597ec6 | 2016-01-25 19:49:42 -0800 | [diff] [blame] | 96 | import com.android.contacts.util.PhoneCapabilityTester; |
Brian Attwell | 56bcc2f | 2015-02-12 23:45:27 +0000 | [diff] [blame] | 97 | import com.android.contactsbind.HelpUtils; |
Tadashi G. Takaoka | 57cf30f | 2009-09-21 19:54:39 +0900 | [diff] [blame] | 98 | |
Brian Attwell | 20510ec | 2015-02-27 16:10:45 -0800 | [diff] [blame] | 99 | import java.util.List; |
Fabrice Di Meglio | 7d3b915 | 2013-04-04 19:49:34 -0700 | [diff] [blame] | 100 | import java.util.Locale; |
Makoto Onuki | 6d9befe | 2011-07-17 11:00:12 -0700 | [diff] [blame] | 101 | import java.util.concurrent.atomic.AtomicInteger; |
Dmitri Plotnikov | caf0bc7 | 2010-09-03 15:16:21 -0700 | [diff] [blame] | 102 | |
The Android Open Source Project | 7aa0e4c | 2009-03-03 19:32:21 -0800 | [diff] [blame] | 103 | /** |
Brian Attwell | 2c1bfd0 | 2014-06-04 18:18:35 -0700 | [diff] [blame] | 104 | * Displays a list to browse contacts. |
The Android Open Source Project | 7aa0e4c | 2009-03-03 19:32:21 -0800 | [diff] [blame] | 105 | */ |
Wenyi Wang | e7fd1ad | 2016-01-06 14:12:10 -0800 | [diff] [blame] | 106 | public class PeopleActivity extends AppCompatContactsActivity implements |
Paul Soulos | 2b9563d | 2014-05-27 16:21:23 -0700 | [diff] [blame] | 107 | View.OnCreateContextMenuListener, |
| 108 | View.OnClickListener, |
| 109 | ActionBarAdapter.Listener, |
Dmitri Plotnikov | 6e850a0 | 2010-10-28 10:46:21 -0700 | [diff] [blame] | 110 | DialogManager.DialogShowingViewActivity, |
Paul Soulos | 2b9563d | 2014-05-27 16:21:23 -0700 | [diff] [blame] | 111 | ContactListFilterController.ContactListFilterListener, |
Brian Attwell | d2962a3 | 2015-03-02 14:48:50 -0800 | [diff] [blame] | 112 | ProviderStatusListener, |
Brian Attwell | d3946ca | 2015-03-03 11:13:49 -0800 | [diff] [blame] | 113 | MultiContactDeleteListener, |
| 114 | JoinContactsListener { |
Dmitri Plotnikov | 57d27da | 2009-09-28 18:06:11 -0700 | [diff] [blame] | 115 | |
Dave Santoro | 5e684a4 | 2011-06-10 13:23:35 -0700 | [diff] [blame] | 116 | private static final String TAG = "PeopleActivity"; |
The Android Open Source Project | 7aa0e4c | 2009-03-03 19:32:21 -0800 | [diff] [blame] | 117 | |
Makoto Onuki | 9ae6041 | 2012-07-19 15:56:41 -0700 | [diff] [blame] | 118 | private static final String ENABLE_DEBUG_OPTIONS_HIDDEN_CODE = "debug debug!"; |
| 119 | |
Katherine Kuan | 5c3a0a1 | 2011-11-07 15:43:04 -0800 | [diff] [blame] | 120 | // These values needs to start at 2. See {@link ContactEntryListFragment}. |
Brian Attwell | 2c1bfd0 | 2014-06-04 18:18:35 -0700 | [diff] [blame] | 121 | private static final int SUBACTIVITY_ACCOUNT_FILTER = 2; |
Katherine Kuan | c6b8afe | 2011-06-22 19:03:50 -0700 | [diff] [blame] | 122 | |
Daisuke Miyakawa | 34b901c | 2011-10-18 14:33:41 -0700 | [diff] [blame] | 123 | private final DialogManager mDialogManager = new DialogManager(this); |
Daniel Lehmann | 3391dbe | 2010-07-12 09:50:22 -0700 | [diff] [blame] | 124 | |
Dmitri Plotnikov | ac0f783 | 2010-04-22 13:26:52 -0700 | [diff] [blame] | 125 | private ContactsIntentResolver mIntentResolver; |
Dmitri Plotnikov | fcfdffb | 2010-07-15 18:00:55 -0700 | [diff] [blame] | 126 | private ContactsRequest mRequest; |
| 127 | |
Dmitri Plotnikov | fcfdffb | 2010-07-15 18:00:55 -0700 | [diff] [blame] | 128 | private ActionBarAdapter mActionBarAdapter; |
Brian Attwell | 865847b | 2015-04-20 14:40:17 -0700 | [diff] [blame] | 129 | private FloatingActionButtonController mFloatingActionButtonController; |
| 130 | private View mFloatingActionButtonContainer; |
| 131 | private boolean wasLastFabAnimationScaleIn = false; |
Dmitri Plotnikov | fcfdffb | 2010-07-15 18:00:55 -0700 | [diff] [blame] | 132 | |
Frank Sposaro | 7979ea2 | 2011-07-14 16:46:07 -0700 | [diff] [blame] | 133 | private ContactTileListFragment.Listener mFavoritesFragmentListener = |
Daisuke Miyakawa | ee17947 | 2011-06-25 11:23:01 -0700 | [diff] [blame] | 134 | new StrequentContactListFragmentListener(); |
| 135 | |
Dmitri Plotnikov | 15ccbb4 | 2010-10-05 17:29:07 -0700 | [diff] [blame] | 136 | private ContactListFilterController mContactListFilterController; |
Dmitri Plotnikov | 3c69e21 | 2010-09-27 11:43:39 -0700 | [diff] [blame] | 137 | |
Dmitri Plotnikov | 8b82646 | 2010-11-17 14:52:24 -0800 | [diff] [blame] | 138 | private ContactsUnavailableFragment mContactsUnavailableFragment; |
Makoto Onuki | c2bd613 | 2012-04-27 16:14:51 -0700 | [diff] [blame] | 139 | private ProviderStatusWatcher mProviderStatusWatcher; |
Brian Attwell | c3d202c | 2015-01-08 15:01:03 -0800 | [diff] [blame] | 140 | private Integer mProviderStatus; |
Dmitri Plotnikov | 8b82646 | 2010-11-17 14:52:24 -0800 | [diff] [blame] | 141 | |
Dmitri Plotnikov | 0cd0130 | 2010-12-17 18:41:57 -0800 | [diff] [blame] | 142 | private boolean mOptionsMenuContactsAvailable; |
Dmitri Plotnikov | 0cd0130 | 2010-12-17 18:41:57 -0800 | [diff] [blame] | 143 | |
Daisuke Miyakawa | 95c5c2a | 2011-07-08 10:33:21 -0700 | [diff] [blame] | 144 | /** |
| 145 | * Showing a list of Contacts. Also used for showing search results in search mode. |
| 146 | */ |
Brian Attwell | 20510ec | 2015-02-27 16:10:45 -0800 | [diff] [blame] | 147 | private MultiSelectContactsListFragment mAllFragment; |
Frank Sposaro | 7979ea2 | 2011-07-14 16:46:07 -0700 | [diff] [blame] | 148 | private ContactTileListFragment mFavoritesFragment; |
Katherine Kuan | b5760b9 | 2011-06-01 16:19:40 -0700 | [diff] [blame] | 149 | |
Brian Attwell | 2c1bfd0 | 2014-06-04 18:18:35 -0700 | [diff] [blame] | 150 | /** ViewPager for swipe */ |
Makoto Onuki | 250ce43 | 2011-07-12 18:26:45 -0700 | [diff] [blame] | 151 | private ViewPager mTabPager; |
Brian Attwell | 3c763b3 | 2014-07-21 14:25:28 -0700 | [diff] [blame] | 152 | private ViewPagerTabs mViewPagerTabs; |
Makoto Onuki | 250ce43 | 2011-07-12 18:26:45 -0700 | [diff] [blame] | 153 | private TabPagerAdapter mTabPagerAdapter; |
Brian Attwell | 3c763b3 | 2014-07-21 14:25:28 -0700 | [diff] [blame] | 154 | private String[] mTabTitles; |
Makoto Onuki | 2e17730 | 2011-08-15 14:06:55 -0700 | [diff] [blame] | 155 | private final TabPagerListener mTabPagerListener = new TabPagerListener(); |
Katherine Kuan | 58fc577 | 2011-07-04 10:08:32 -0700 | [diff] [blame] | 156 | |
Makoto Onuki | 9ae6041 | 2012-07-19 15:56:41 -0700 | [diff] [blame] | 157 | private boolean mEnableDebugMenuOptions; |
| 158 | |
Makoto Onuki | 417ca49 | 2011-07-14 19:06:35 -0700 | [diff] [blame] | 159 | /** |
| 160 | * True if this activity instance is a re-created one. i.e. set true after orientation change. |
| 161 | * This is set in {@link #onCreate} for later use in {@link #onStart}. |
| 162 | */ |
| 163 | private boolean mIsRecreatedInstance; |
| 164 | |
| 165 | /** |
| 166 | * If {@link #configureFragments(boolean)} is already called. Used to avoid calling it twice |
| 167 | * in {@link #onStart}. |
| 168 | * (This initialization only needs to be done once in onStart() when the Activity was just |
| 169 | * created from scratch -- i.e. onCreate() was just called) |
| 170 | */ |
| 171 | private boolean mFragmentInitialized; |
| 172 | |
Katherine Kuan | be79b8f | 2011-11-09 20:54:43 -0800 | [diff] [blame] | 173 | /** |
Paul Sliwowski | 32791d4 | 2013-09-11 15:25:43 -0700 | [diff] [blame] | 174 | * This is to disable {@link #onOptionsItemSelected} when we trying to stop the activity. |
| 175 | */ |
| 176 | private boolean mDisableOptionItemSelected; |
| 177 | |
Makoto Onuki | 6d9befe | 2011-07-17 11:00:12 -0700 | [diff] [blame] | 178 | /** Sequential ID assigned to each instance; used for logging */ |
| 179 | private final int mInstanceId; |
| 180 | private static final AtomicInteger sNextInstanceId = new AtomicInteger(); |
| 181 | |
Katherine Kuan | 9856fce | 2011-06-01 10:24:09 -0700 | [diff] [blame] | 182 | public PeopleActivity() { |
Makoto Onuki | 6d9befe | 2011-07-17 11:00:12 -0700 | [diff] [blame] | 183 | mInstanceId = sNextInstanceId.getAndIncrement(); |
Dmitri Plotnikov | 1540674 | 2010-05-07 09:22:49 -0700 | [diff] [blame] | 184 | mIntentResolver = new ContactsIntentResolver(this); |
Makoto Onuki | c2bd613 | 2012-04-27 16:14:51 -0700 | [diff] [blame] | 185 | mProviderStatusWatcher = ProviderStatusWatcher.getInstance(this); |
Dmitri Plotnikov | 6178cb4 | 2010-04-20 11:26:05 -0700 | [diff] [blame] | 186 | } |
| 187 | |
Makoto Onuki | 6d9befe | 2011-07-17 11:00:12 -0700 | [diff] [blame] | 188 | @Override |
| 189 | public String toString() { |
| 190 | // Shown on logcat |
| 191 | return String.format("%s@%d", getClass().getSimpleName(), mInstanceId); |
| 192 | } |
| 193 | |
Dmitri Plotnikov | 8b82646 | 2010-11-17 14:52:24 -0800 | [diff] [blame] | 194 | public boolean areContactsAvailable() { |
Wenyi Wang | 2f09e60 | 2015-10-28 11:34:23 -0700 | [diff] [blame] | 195 | return (mProviderStatus != null) && mProviderStatus.equals(ProviderStatus.STATUS_NORMAL); |
Dmitri Plotnikov | 8b82646 | 2010-11-17 14:52:24 -0800 | [diff] [blame] | 196 | } |
| 197 | |
Makoto Onuki | 6f74c0f | 2011-09-27 13:47:15 -0700 | [diff] [blame] | 198 | private boolean areGroupWritableAccountsAvailable() { |
| 199 | return ContactsUtils.areGroupWritableAccountsAvailable(this); |
| 200 | } |
Isaac Katzenelson | 49917b3 | 2011-07-19 17:02:30 -0700 | [diff] [blame] | 201 | |
Makoto Onuki | 50445e9 | 2011-07-12 10:28:12 -0700 | [diff] [blame] | 202 | /** |
| 203 | * Initialize fragments that are (or may not be) in the layout. |
| 204 | * |
| 205 | * For the fragments that are in the layout, we initialize them in |
Makoto Onuki | 417ca49 | 2011-07-14 19:06:35 -0700 | [diff] [blame] | 206 | * {@link #createViewsAndFragments(Bundle)} after inflating the layout. |
Makoto Onuki | 50445e9 | 2011-07-12 10:28:12 -0700 | [diff] [blame] | 207 | * |
Brian Attwell | 2c1bfd0 | 2014-06-04 18:18:35 -0700 | [diff] [blame] | 208 | * However, the {@link ContactsUnavailableFragment} is a special fragment which may not |
| 209 | * be in the layout, so we have to do the initialization here. |
| 210 | * |
| 211 | * The ContactsUnavailableFragment is always created at runtime. |
Makoto Onuki | 50445e9 | 2011-07-12 10:28:12 -0700 | [diff] [blame] | 212 | */ |
The Android Open Source Project | 7aa0e4c | 2009-03-03 19:32:21 -0800 | [diff] [blame] | 213 | @Override |
Dmitri Plotnikov | 92a6fdf | 2010-07-09 13:19:33 -0700 | [diff] [blame] | 214 | public void onAttachFragment(Fragment fragment) { |
Brian Attwell | 2c1bfd0 | 2014-06-04 18:18:35 -0700 | [diff] [blame] | 215 | if (fragment instanceof ContactsUnavailableFragment) { |
Dmitri Plotnikov | 8b82646 | 2010-11-17 14:52:24 -0800 | [diff] [blame] | 216 | mContactsUnavailableFragment = (ContactsUnavailableFragment)fragment; |
Dmitri Plotnikov | 8b82646 | 2010-11-17 14:52:24 -0800 | [diff] [blame] | 217 | mContactsUnavailableFragment.setOnContactsUnavailableActionListener( |
| 218 | new ContactsUnavailableFragmentListener()); |
Dmitri Plotnikov | 92a6fdf | 2010-07-09 13:19:33 -0700 | [diff] [blame] | 219 | } |
| 220 | } |
| 221 | |
| 222 | @Override |
Dmitri Plotnikov | 08e1c4e | 2010-07-02 17:57:51 -0700 | [diff] [blame] | 223 | protected void onCreate(Bundle savedState) { |
Makoto Onuki | 49627cc | 2011-08-28 13:56:48 -0700 | [diff] [blame] | 224 | if (Log.isLoggable(Constants.PERFORMANCE_TAG, Log.DEBUG)) { |
| 225 | Log.d(Constants.PERFORMANCE_TAG, "PeopleActivity.onCreate start"); |
| 226 | } |
Dmitri Plotnikov | 08e1c4e | 2010-07-02 17:57:51 -0700 | [diff] [blame] | 227 | super.onCreate(savedState); |
The Android Open Source Project | 7aa0e4c | 2009-03-03 19:32:21 -0800 | [diff] [blame] | 228 | |
Brian Attwell | bdd3264 | 2015-05-08 17:03:15 -0700 | [diff] [blame] | 229 | if (RequestPermissionsActivity.startPermissionActivity(this)) { |
| 230 | return; |
| 231 | } |
| 232 | |
Makoto Onuki | 6d9befe | 2011-07-17 11:00:12 -0700 | [diff] [blame] | 233 | if (!processIntent(false)) { |
Makoto Onuki | 417ca49 | 2011-07-14 19:06:35 -0700 | [diff] [blame] | 234 | finish(); |
| 235 | return; |
| 236 | } |
Daisuke Miyakawa | a012aec | 2011-10-16 10:24:43 -0700 | [diff] [blame] | 237 | mContactListFilterController = ContactListFilterController.getInstance(this); |
Katherine Kuan | be79b8f | 2011-11-09 20:54:43 -0800 | [diff] [blame] | 238 | mContactListFilterController.checkFilterValidity(false); |
Daisuke Miyakawa | a012aec | 2011-10-16 10:24:43 -0700 | [diff] [blame] | 239 | mContactListFilterController.addListener(this); |
| 240 | |
Makoto Onuki | c2bd613 | 2012-04-27 16:14:51 -0700 | [diff] [blame] | 241 | mProviderStatusWatcher.addListener(this); |
| 242 | |
Makoto Onuki | 417ca49 | 2011-07-14 19:06:35 -0700 | [diff] [blame] | 243 | mIsRecreatedInstance = (savedState != null); |
| 244 | createViewsAndFragments(savedState); |
Andrew Lee | 4b1af3f | 2014-04-23 10:23:55 -0700 | [diff] [blame] | 245 | |
Makoto Onuki | 49627cc | 2011-08-28 13:56:48 -0700 | [diff] [blame] | 246 | if (Log.isLoggable(Constants.PERFORMANCE_TAG, Log.DEBUG)) { |
| 247 | Log.d(Constants.PERFORMANCE_TAG, "PeopleActivity.onCreate finish"); |
| 248 | } |
Sai Cheemalapati | 5b22108 | 2014-06-27 14:45:43 -0700 | [diff] [blame] | 249 | getWindow().setBackgroundDrawable(null); |
Dmitri Plotnikov | fa49a66 | 2011-01-13 11:04:56 -0800 | [diff] [blame] | 250 | } |
| 251 | |
| 252 | @Override |
| 253 | protected void onNewIntent(Intent intent) { |
| 254 | setIntent(intent); |
Makoto Onuki | 6d9befe | 2011-07-17 11:00:12 -0700 | [diff] [blame] | 255 | if (!processIntent(true)) { |
Makoto Onuki | 417ca49 | 2011-07-14 19:06:35 -0700 | [diff] [blame] | 256 | finish(); |
| 257 | return; |
| 258 | } |
| 259 | mActionBarAdapter.initialize(null, mRequest); |
| 260 | |
Katherine Kuan | be79b8f | 2011-11-09 20:54:43 -0800 | [diff] [blame] | 261 | mContactListFilterController.checkFilterValidity(false); |
Katherine Kuan | be79b8f | 2011-11-09 20:54:43 -0800 | [diff] [blame] | 262 | |
Makoto Onuki | 417ca49 | 2011-07-14 19:06:35 -0700 | [diff] [blame] | 263 | // Re-configure fragments. |
| 264 | configureFragments(true /* from request */); |
Brian Attwell | 9cfa24c | 2015-05-04 12:31:37 -0700 | [diff] [blame] | 265 | initializeFabVisibility(); |
Makoto Onuki | 417ca49 | 2011-07-14 19:06:35 -0700 | [diff] [blame] | 266 | invalidateOptionsMenuIfNeeded(); |
Dmitri Plotnikov | fa49a66 | 2011-01-13 11:04:56 -0800 | [diff] [blame] | 267 | } |
| 268 | |
Makoto Onuki | 417ca49 | 2011-07-14 19:06:35 -0700 | [diff] [blame] | 269 | /** |
| 270 | * Resolve the intent and initialize {@link #mRequest}, and launch another activity if redirect |
| 271 | * is needed. |
| 272 | * |
Makoto Onuki | 6d9befe | 2011-07-17 11:00:12 -0700 | [diff] [blame] | 273 | * @param forNewIntent set true if it's called from {@link #onNewIntent(Intent)}. |
Makoto Onuki | 417ca49 | 2011-07-14 19:06:35 -0700 | [diff] [blame] | 274 | * @return {@code true} if {@link PeopleActivity} should continue running. {@code false} |
| 275 | * if it shouldn't, in which case the caller should finish() itself and shouldn't do |
| 276 | * farther initialization. |
| 277 | */ |
Makoto Onuki | 6d9befe | 2011-07-17 11:00:12 -0700 | [diff] [blame] | 278 | private boolean processIntent(boolean forNewIntent) { |
Dmitri Plotnikov | 1ce1e7c | 2010-05-13 16:41:00 -0700 | [diff] [blame] | 279 | // Extract relevant information from the intent |
| 280 | mRequest = mIntentResolver.resolveIntent(getIntent()); |
Makoto Onuki | ea14605 | 2011-07-25 10:34:15 -0700 | [diff] [blame] | 281 | if (Log.isLoggable(TAG, Log.DEBUG)) { |
Makoto Onuki | 6d9befe | 2011-07-17 11:00:12 -0700 | [diff] [blame] | 282 | Log.d(TAG, this + " processIntent: forNewIntent=" + forNewIntent |
| 283 | + " intent=" + getIntent() + " request=" + mRequest); |
| 284 | } |
Dmitri Plotnikov | 1ce1e7c | 2010-05-13 16:41:00 -0700 | [diff] [blame] | 285 | if (!mRequest.isValid()) { |
| 286 | setResult(RESULT_CANCELED); |
Makoto Onuki | 417ca49 | 2011-07-14 19:06:35 -0700 | [diff] [blame] | 287 | return false; |
Dmitri Plotnikov | 59fb48e | 2010-04-26 17:09:19 -0700 | [diff] [blame] | 288 | } |
| 289 | |
Brian Attwell | 2c1bfd0 | 2014-06-04 18:18:35 -0700 | [diff] [blame] | 290 | if (mRequest.getActionCode() == ContactsRequest.ACTION_VIEW_CONTACT) { |
Brian Attwell | c6100ff | 2015-02-19 21:35:36 -0800 | [diff] [blame] | 291 | final Intent intent = ImplicitIntentsUtil.composeQuickContactIntent( |
| 292 | mRequest.getContactUri(), QuickContactActivity.MODE_FULLY_EXPANDED); |
| 293 | ImplicitIntentsUtil.startActivityInApp(this, intent); |
Makoto Onuki | 417ca49 | 2011-07-14 19:06:35 -0700 | [diff] [blame] | 294 | return false; |
Dmitri Plotnikov | 27b97bc | 2010-10-07 18:06:09 -0700 | [diff] [blame] | 295 | } |
Makoto Onuki | 417ca49 | 2011-07-14 19:06:35 -0700 | [diff] [blame] | 296 | return true; |
| 297 | } |
| 298 | |
| 299 | private void createViewsAndFragments(Bundle savedState) { |
| 300 | setContentView(R.layout.people_activity); |
| 301 | |
| 302 | final FragmentManager fragmentManager = getFragmentManager(); |
| 303 | |
| 304 | // Hide all tabs (the current tab will later be reshown once a tab is selected) |
| 305 | final FragmentTransaction transaction = fragmentManager.beginTransaction(); |
| 306 | |
Brian Attwell | 3c763b3 | 2014-07-21 14:25:28 -0700 | [diff] [blame] | 307 | mTabTitles = new String[TabState.COUNT]; |
| 308 | mTabTitles[TabState.FAVORITES] = getString(R.string.favorites_tab_label); |
| 309 | mTabTitles[TabState.ALL] = getString(R.string.all_contacts_tab_label); |
Brian Attwell | 2c1bfd0 | 2014-06-04 18:18:35 -0700 | [diff] [blame] | 310 | mTabPager = getView(R.id.tab_pager); |
| 311 | mTabPagerAdapter = new TabPagerAdapter(); |
| 312 | mTabPager.setAdapter(mTabPagerAdapter); |
| 313 | mTabPager.setOnPageChangeListener(mTabPagerListener); |
Makoto Onuki | 417ca49 | 2011-07-14 19:06:35 -0700 | [diff] [blame] | 314 | |
Wenyi Wang | e7fd1ad | 2016-01-06 14:12:10 -0800 | [diff] [blame] | 315 | // Configure toolbar and toolbar tabs. If in landscape mode, we configure tabs differently. |
Brian Attwell | 3c763b3 | 2014-07-21 14:25:28 -0700 | [diff] [blame] | 316 | final Toolbar toolbar = getView(R.id.toolbar); |
Wenyi Wang | e7fd1ad | 2016-01-06 14:12:10 -0800 | [diff] [blame] | 317 | setSupportActionBar(toolbar); |
Brian Attwell | 3c763b3 | 2014-07-21 14:25:28 -0700 | [diff] [blame] | 318 | final ViewPagerTabs portraitViewPagerTabs |
| 319 | = (ViewPagerTabs) findViewById(R.id.lists_pager_header); |
| 320 | ViewPagerTabs landscapeViewPagerTabs = null; |
| 321 | if (portraitViewPagerTabs == null) { |
| 322 | landscapeViewPagerTabs = (ViewPagerTabs) getLayoutInflater().inflate( |
| 323 | R.layout.people_activity_tabs_lands, toolbar, /* attachToRoot = */ false); |
| 324 | mViewPagerTabs = landscapeViewPagerTabs; |
| 325 | } else { |
| 326 | mViewPagerTabs = portraitViewPagerTabs; |
| 327 | } |
| 328 | mViewPagerTabs.setViewPager(mTabPager); |
| 329 | |
Brian Attwell | 2c1bfd0 | 2014-06-04 18:18:35 -0700 | [diff] [blame] | 330 | final String FAVORITE_TAG = "tab-pager-favorite"; |
| 331 | final String ALL_TAG = "tab-pager-all"; |
Makoto Onuki | 417ca49 | 2011-07-14 19:06:35 -0700 | [diff] [blame] | 332 | |
Brian Attwell | 2c1bfd0 | 2014-06-04 18:18:35 -0700 | [diff] [blame] | 333 | // Create the fragments and add as children of the view pager. |
| 334 | // The pager adapter will only change the visibility; it'll never create/destroy |
| 335 | // fragments. |
| 336 | // However, if it's after screen rotation, the fragments have been re-created by |
| 337 | // the fragment manager, so first see if there're already the target fragments |
| 338 | // existing. |
| 339 | mFavoritesFragment = (ContactTileListFragment) |
| 340 | fragmentManager.findFragmentByTag(FAVORITE_TAG); |
Brian Attwell | 20510ec | 2015-02-27 16:10:45 -0800 | [diff] [blame] | 341 | mAllFragment = (MultiSelectContactsListFragment) |
Brian Attwell | 2c1bfd0 | 2014-06-04 18:18:35 -0700 | [diff] [blame] | 342 | fragmentManager.findFragmentByTag(ALL_TAG); |
Makoto Onuki | 417ca49 | 2011-07-14 19:06:35 -0700 | [diff] [blame] | 343 | |
Brian Attwell | 2c1bfd0 | 2014-06-04 18:18:35 -0700 | [diff] [blame] | 344 | if (mFavoritesFragment == null) { |
| 345 | mFavoritesFragment = new ContactTileListFragment(); |
Brian Attwell | 20510ec | 2015-02-27 16:10:45 -0800 | [diff] [blame] | 346 | mAllFragment = new MultiSelectContactsListFragment(); |
Makoto Onuki | 417ca49 | 2011-07-14 19:06:35 -0700 | [diff] [blame] | 347 | |
Brian Attwell | 2c1bfd0 | 2014-06-04 18:18:35 -0700 | [diff] [blame] | 348 | transaction.add(R.id.tab_pager, mFavoritesFragment, FAVORITE_TAG); |
| 349 | transaction.add(R.id.tab_pager, mAllFragment, ALL_TAG); |
Makoto Onuki | 4d788fc | 2011-07-12 10:00:10 -0700 | [diff] [blame] | 350 | } |
Makoto Onuki | 417ca49 | 2011-07-14 19:06:35 -0700 | [diff] [blame] | 351 | |
| 352 | mFavoritesFragment.setListener(mFavoritesFragmentListener); |
| 353 | |
| 354 | mAllFragment.setOnContactListActionListener(new ContactBrowserActionListener()); |
Brian Attwell | 20510ec | 2015-02-27 16:10:45 -0800 | [diff] [blame] | 355 | mAllFragment.setCheckBoxListListener(new CheckBoxListListener()); |
Makoto Onuki | 417ca49 | 2011-07-14 19:06:35 -0700 | [diff] [blame] | 356 | |
Makoto Onuki | 417ca49 | 2011-07-14 19:06:35 -0700 | [diff] [blame] | 357 | // Hide all fragments for now. We adjust visibility when we get onSelectedTabChanged() |
| 358 | // from ActionBarAdapter. |
| 359 | transaction.hide(mFavoritesFragment); |
| 360 | transaction.hide(mAllFragment); |
Makoto Onuki | 417ca49 | 2011-07-14 19:06:35 -0700 | [diff] [blame] | 361 | |
Minh Pham | 4b25da7 | 2011-08-25 13:50:38 -0700 | [diff] [blame] | 362 | transaction.commitAllowingStateLoss(); |
Makoto Onuki | 417ca49 | 2011-07-14 19:06:35 -0700 | [diff] [blame] | 363 | fragmentManager.executePendingTransactions(); |
| 364 | |
Frank Sposaro | 0c07935 | 2011-07-19 13:09:04 -0700 | [diff] [blame] | 365 | // Setting Properties after fragment is created |
Brian Attwell | 2c1bfd0 | 2014-06-04 18:18:35 -0700 | [diff] [blame] | 366 | mFavoritesFragment.setDisplayType(DisplayType.STREQUENT); |
Frank Sposaro | 0c07935 | 2011-07-19 13:09:04 -0700 | [diff] [blame] | 367 | |
Wenyi Wang | e7fd1ad | 2016-01-06 14:12:10 -0800 | [diff] [blame] | 368 | mActionBarAdapter = new ActionBarAdapter(this, this, getSupportActionBar(), |
Brian Attwell | 3c763b3 | 2014-07-21 14:25:28 -0700 | [diff] [blame] | 369 | portraitViewPagerTabs, landscapeViewPagerTabs, toolbar); |
Makoto Onuki | 4d788fc | 2011-07-12 10:00:10 -0700 | [diff] [blame] | 370 | mActionBarAdapter.initialize(savedState, mRequest); |
| 371 | |
Brian Attwell | d41ab8a | 2014-08-07 11:08:55 -0700 | [diff] [blame] | 372 | // Add shadow under toolbar |
| 373 | ViewUtil.addRectangularOutlineProvider(findViewById(R.id.toolbar_parent), getResources()); |
| 374 | |
Brian Attwell | 865847b | 2015-04-20 14:40:17 -0700 | [diff] [blame] | 375 | // Configure floating action button |
| 376 | mFloatingActionButtonContainer = findViewById(R.id.floating_action_button_container); |
| 377 | final ImageButton floatingActionButton |
| 378 | = (ImageButton) findViewById(R.id.floating_action_button); |
Brian Attwell | 2c1bfd0 | 2014-06-04 18:18:35 -0700 | [diff] [blame] | 379 | floatingActionButton.setOnClickListener(this); |
Brian Attwell | 865847b | 2015-04-20 14:40:17 -0700 | [diff] [blame] | 380 | mFloatingActionButtonController = new FloatingActionButtonController(this, |
| 381 | mFloatingActionButtonContainer, floatingActionButton); |
Brian Attwell | 9cfa24c | 2015-05-04 12:31:37 -0700 | [diff] [blame] | 382 | initializeFabVisibility(); |
Paul Soulos | 2b9563d | 2014-05-27 16:21:23 -0700 | [diff] [blame] | 383 | |
Makoto Onuki | 417ca49 | 2011-07-14 19:06:35 -0700 | [diff] [blame] | 384 | invalidateOptionsMenuIfNeeded(); |
| 385 | } |
Dmitri Plotnikov | fa49a66 | 2011-01-13 11:04:56 -0800 | [diff] [blame] | 386 | |
Makoto Onuki | 417ca49 | 2011-07-14 19:06:35 -0700 | [diff] [blame] | 387 | @Override |
| 388 | protected void onStart() { |
| 389 | if (!mFragmentInitialized) { |
| 390 | mFragmentInitialized = true; |
| 391 | /* Configure fragments if we haven't. |
| 392 | * |
| 393 | * Note it's a one-shot initialization, so we want to do this in {@link #onCreate}. |
| 394 | * |
| 395 | * However, because this method may indirectly touch views in fragments but fragments |
| 396 | * created in {@link #configureContentView} using a {@link FragmentTransaction} will NOT |
| 397 | * have views until {@link Activity#onCreate} finishes (they would if they were inflated |
| 398 | * from a layout), we need to do it here in {@link #onStart()}. |
| 399 | * |
| 400 | * (When {@link Fragment#onCreateView} is called is different in the former case and |
| 401 | * in the latter case, unfortunately.) |
| 402 | * |
| 403 | * Also, we skip most of the work in it if the activity is a re-created one. |
| 404 | * (so the argument.) |
| 405 | */ |
| 406 | configureFragments(!mIsRecreatedInstance); |
Dmitri Plotnikov | fe42e55 | 2010-05-14 14:50:32 -0700 | [diff] [blame] | 407 | } |
Makoto Onuki | 417ca49 | 2011-07-14 19:06:35 -0700 | [diff] [blame] | 408 | super.onStart(); |
Dmitri Plotnikov | caf0bc7 | 2010-09-03 15:16:21 -0700 | [diff] [blame] | 409 | } |
| 410 | |
Dmitri Plotnikov | 6e850a0 | 2010-10-28 10:46:21 -0700 | [diff] [blame] | 411 | @Override |
Dmitri Plotnikov | 174fdc2 | 2010-10-29 13:55:01 -0700 | [diff] [blame] | 412 | protected void onPause() { |
Dmitri Plotnikov | fa49a66 | 2011-01-13 11:04:56 -0800 | [diff] [blame] | 413 | mOptionsMenuContactsAvailable = false; |
Makoto Onuki | c2bd613 | 2012-04-27 16:14:51 -0700 | [diff] [blame] | 414 | mProviderStatusWatcher.stop(); |
Dmitri Plotnikov | 174fdc2 | 2010-10-29 13:55:01 -0700 | [diff] [blame] | 415 | super.onPause(); |
| 416 | } |
| 417 | |
| 418 | @Override |
| 419 | protected void onResume() { |
| 420 | super.onResume(); |
Josh Gargus | 697ab26 | 2012-05-04 11:11:34 -0700 | [diff] [blame] | 421 | |
Makoto Onuki | c2bd613 | 2012-04-27 16:14:51 -0700 | [diff] [blame] | 422 | mProviderStatusWatcher.start(); |
Josh Gargus | 697ab26 | 2012-05-04 11:11:34 -0700 | [diff] [blame] | 423 | updateViewConfiguration(true); |
Makoto Onuki | 4d788fc | 2011-07-12 10:00:10 -0700 | [diff] [blame] | 424 | |
| 425 | // Re-register the listener, which may have been cleared when onSaveInstanceState was |
| 426 | // called. See also: onSaveInstanceState |
| 427 | mActionBarAdapter.setListener(this); |
Paul Sliwowski | 32791d4 | 2013-09-11 15:25:43 -0700 | [diff] [blame] | 428 | mDisableOptionItemSelected = false; |
Makoto Onuki | 2e17730 | 2011-08-15 14:06:55 -0700 | [diff] [blame] | 429 | if (mTabPager != null) { |
| 430 | mTabPager.setOnPageChangeListener(mTabPagerListener); |
| 431 | } |
Makoto Onuki | a4505fc | 2011-07-15 12:22:24 -0700 | [diff] [blame] | 432 | // Current tab may have changed since the last onSaveInstanceState(). Make sure |
| 433 | // the actual contents match the tab. |
| 434 | updateFragmentsVisibility(); |
Dmitri Plotnikov | 174fdc2 | 2010-10-29 13:55:01 -0700 | [diff] [blame] | 435 | } |
| 436 | |
| 437 | @Override |
Makoto Onuki | 4d788fc | 2011-07-12 10:00:10 -0700 | [diff] [blame] | 438 | protected void onDestroy() { |
Makoto Onuki | c2bd613 | 2012-04-27 16:14:51 -0700 | [diff] [blame] | 439 | mProviderStatusWatcher.removeListener(this); |
| 440 | |
Daisuke Miyakawa | b2a2318 | 2011-11-02 12:40:42 -0700 | [diff] [blame] | 441 | // Some of variables will be null if this Activity redirects Intent. |
| 442 | // See also onCreate() or other methods called during the Activity's initialization. |
Makoto Onuki | c1eed6d | 2011-07-14 12:24:02 -0700 | [diff] [blame] | 443 | if (mActionBarAdapter != null) { |
| 444 | mActionBarAdapter.setListener(null); |
| 445 | } |
Daisuke Miyakawa | b2a2318 | 2011-11-02 12:40:42 -0700 | [diff] [blame] | 446 | if (mContactListFilterController != null) { |
| 447 | mContactListFilterController.removeListener(this); |
| 448 | } |
| 449 | |
Makoto Onuki | 4d788fc | 2011-07-12 10:00:10 -0700 | [diff] [blame] | 450 | super.onDestroy(); |
| 451 | } |
| 452 | |
Dmitri Plotnikov | 955846e | 2010-11-11 22:31:28 -0800 | [diff] [blame] | 453 | private void configureFragments(boolean fromRequest) { |
Dmitri Plotnikov | 009676f | 2010-10-08 12:13:57 -0700 | [diff] [blame] | 454 | if (fromRequest) { |
Dmitri Plotnikov | 91ab5b4 | 2010-10-08 15:26:31 -0700 | [diff] [blame] | 455 | ContactListFilter filter = null; |
| 456 | int actionCode = mRequest.getActionCode(); |
Makoto Onuki | 53b427b | 2011-07-17 11:42:32 -0700 | [diff] [blame] | 457 | boolean searchMode = mRequest.isSearchMode(); |
Daniel Lehmann | 52aa32d | 2012-03-08 17:29:27 -0800 | [diff] [blame] | 458 | final int tabToOpen; |
Dmitri Plotnikov | 91ab5b4 | 2010-10-08 15:26:31 -0700 | [diff] [blame] | 459 | switch (actionCode) { |
| 460 | case ContactsRequest.ACTION_ALL_CONTACTS: |
Katherine Kuan | be18de0 | 2011-06-07 12:38:29 -0700 | [diff] [blame] | 461 | filter = ContactListFilter.createFilterWithType( |
| 462 | ContactListFilter.FILTER_TYPE_ALL_ACCOUNTS); |
Makoto Onuki | ea14605 | 2011-07-25 10:34:15 -0700 | [diff] [blame] | 463 | tabToOpen = TabState.ALL; |
Dmitri Plotnikov | 91ab5b4 | 2010-10-08 15:26:31 -0700 | [diff] [blame] | 464 | break; |
| 465 | case ContactsRequest.ACTION_CONTACTS_WITH_PHONES: |
Katherine Kuan | be18de0 | 2011-06-07 12:38:29 -0700 | [diff] [blame] | 466 | filter = ContactListFilter.createFilterWithType( |
Dmitri Plotnikov | 91ab5b4 | 2010-10-08 15:26:31 -0700 | [diff] [blame] | 467 | ContactListFilter.FILTER_TYPE_WITH_PHONE_NUMBERS_ONLY); |
Makoto Onuki | ea14605 | 2011-07-25 10:34:15 -0700 | [diff] [blame] | 468 | tabToOpen = TabState.ALL; |
Dmitri Plotnikov | 91ab5b4 | 2010-10-08 15:26:31 -0700 | [diff] [blame] | 469 | break; |
| 470 | |
Dmitri Plotnikov | 91ab5b4 | 2010-10-08 15:26:31 -0700 | [diff] [blame] | 471 | case ContactsRequest.ACTION_FREQUENT: |
| 472 | case ContactsRequest.ACTION_STREQUENT: |
Dmitri Plotnikov | 91ab5b4 | 2010-10-08 15:26:31 -0700 | [diff] [blame] | 473 | case ContactsRequest.ACTION_STARRED: |
Makoto Onuki | ea14605 | 2011-07-25 10:34:15 -0700 | [diff] [blame] | 474 | tabToOpen = TabState.FAVORITES; |
Dmitri Plotnikov | 91ab5b4 | 2010-10-08 15:26:31 -0700 | [diff] [blame] | 475 | break; |
Frank Sposaro | 9e095d2 | 2011-07-07 15:18:38 -0700 | [diff] [blame] | 476 | case ContactsRequest.ACTION_VIEW_CONTACT: |
Makoto Onuki | ea14605 | 2011-07-25 10:34:15 -0700 | [diff] [blame] | 477 | tabToOpen = TabState.ALL; |
| 478 | break; |
Daniel Lehmann | 52aa32d | 2012-03-08 17:29:27 -0800 | [diff] [blame] | 479 | default: |
| 480 | tabToOpen = -1; |
| 481 | break; |
Makoto Onuki | ea14605 | 2011-07-25 10:34:15 -0700 | [diff] [blame] | 482 | } |
Daniel Lehmann | 52aa32d | 2012-03-08 17:29:27 -0800 | [diff] [blame] | 483 | if (tabToOpen != -1) { |
Makoto Onuki | ea14605 | 2011-07-25 10:34:15 -0700 | [diff] [blame] | 484 | mActionBarAdapter.setCurrentTab(tabToOpen); |
Dmitri Plotnikov | 91ab5b4 | 2010-10-08 15:26:31 -0700 | [diff] [blame] | 485 | } |
| 486 | |
| 487 | if (filter != null) { |
| 488 | mContactListFilterController.setContactListFilter(filter, false); |
Makoto Onuki | 53b427b | 2011-07-17 11:42:32 -0700 | [diff] [blame] | 489 | searchMode = false; |
Dmitri Plotnikov | 009676f | 2010-10-08 12:13:57 -0700 | [diff] [blame] | 490 | } |
Dmitri Plotnikov | d959104 | 2010-11-23 09:25:03 -0800 | [diff] [blame] | 491 | |
| 492 | if (mRequest.getContactUri() != null) { |
Makoto Onuki | 53b427b | 2011-07-17 11:42:32 -0700 | [diff] [blame] | 493 | searchMode = false; |
Dmitri Plotnikov | d959104 | 2010-11-23 09:25:03 -0800 | [diff] [blame] | 494 | } |
| 495 | |
Makoto Onuki | 53b427b | 2011-07-17 11:42:32 -0700 | [diff] [blame] | 496 | mActionBarAdapter.setSearchMode(searchMode); |
Katherine Kuan | 0ff0e31 | 2011-06-08 17:43:51 -0700 | [diff] [blame] | 497 | configureContactListFragmentForRequest(); |
Dmitri Plotnikov | 08e1c4e | 2010-07-02 17:57:51 -0700 | [diff] [blame] | 498 | } |
| 499 | |
Katherine Kuan | 0ff0e31 | 2011-06-08 17:43:51 -0700 | [diff] [blame] | 500 | configureContactListFragment(); |
Dmitri Plotnikov | fa49a66 | 2011-01-13 11:04:56 -0800 | [diff] [blame] | 501 | |
Katherine Kuan | 8268bbe | 2011-06-10 17:48:21 -0700 | [diff] [blame] | 502 | invalidateOptionsMenuIfNeeded(); |
Dmitri Plotnikov | 92a6fdf | 2010-07-09 13:19:33 -0700 | [diff] [blame] | 503 | } |
| 504 | |
Brian Attwell | 865847b | 2015-04-20 14:40:17 -0700 | [diff] [blame] | 505 | private void initializeFabVisibility() { |
| 506 | final boolean hideFab = mActionBarAdapter.isSearchMode() |
| 507 | || mActionBarAdapter.isSelectionMode(); |
| 508 | mFloatingActionButtonContainer.setVisibility(hideFab ? View.GONE : View.VISIBLE); |
Brian Attwell | 9cfa24c | 2015-05-04 12:31:37 -0700 | [diff] [blame] | 509 | mFloatingActionButtonController.resetIn(); |
Brian Attwell | 865847b | 2015-04-20 14:40:17 -0700 | [diff] [blame] | 510 | wasLastFabAnimationScaleIn = !hideFab; |
| 511 | } |
| 512 | |
| 513 | private void showFabWithAnimation(boolean showFab) { |
| 514 | if (mFloatingActionButtonContainer == null) { |
| 515 | return; |
| 516 | } |
| 517 | if (showFab) { |
| 518 | if (!wasLastFabAnimationScaleIn) { |
| 519 | mFloatingActionButtonContainer.setVisibility(View.VISIBLE); |
| 520 | mFloatingActionButtonController.scaleIn(0); |
| 521 | } |
| 522 | wasLastFabAnimationScaleIn = true; |
| 523 | |
| 524 | } else { |
| 525 | if (wasLastFabAnimationScaleIn) { |
| 526 | mFloatingActionButtonContainer.setVisibility(View.VISIBLE); |
| 527 | mFloatingActionButtonController.scaleOut(); |
| 528 | } |
| 529 | wasLastFabAnimationScaleIn = false; |
| 530 | } |
| 531 | } |
| 532 | |
Dmitri Plotnikov | 6e850a0 | 2010-10-28 10:46:21 -0700 | [diff] [blame] | 533 | @Override |
Dmitri Plotnikov | 6e850a0 | 2010-10-28 10:46:21 -0700 | [diff] [blame] | 534 | public void onContactListFilterChanged() { |
Daisuke Miyakawa | 95c5c2a | 2011-07-08 10:33:21 -0700 | [diff] [blame] | 535 | if (mAllFragment == null || !mAllFragment.isAdded()) { |
Dmitri Plotnikov | 955846e | 2010-11-11 22:31:28 -0800 | [diff] [blame] | 536 | return; |
| 537 | } |
| 538 | |
Daisuke Miyakawa | 95c5c2a | 2011-07-08 10:33:21 -0700 | [diff] [blame] | 539 | mAllFragment.setFilter(mContactListFilterController.getFilter()); |
Dmitri Plotnikov | e898a9f | 2010-11-18 16:58:25 -0800 | [diff] [blame] | 540 | |
Katherine Kuan | 8268bbe | 2011-06-10 17:48:21 -0700 | [diff] [blame] | 541 | invalidateOptionsMenuIfNeeded(); |
Dmitri Plotnikov | 6e850a0 | 2010-10-28 10:46:21 -0700 | [diff] [blame] | 542 | } |
| 543 | |
Dmitri Plotnikov | fcfdffb | 2010-07-15 18:00:55 -0700 | [diff] [blame] | 544 | /** |
| 545 | * Handler for action bar actions. |
| 546 | */ |
Dmitri Plotnikov | fe42e55 | 2010-05-14 14:50:32 -0700 | [diff] [blame] | 547 | @Override |
Daniel Lehmann | 311882a | 2012-04-27 22:31:38 -0700 | [diff] [blame] | 548 | public void onAction(int action) { |
Katherine Kuan | b5760b9 | 2011-06-01 16:19:40 -0700 | [diff] [blame] | 549 | switch (action) { |
Brian Attwell | 20510ec | 2015-02-27 16:10:45 -0800 | [diff] [blame] | 550 | case ActionBarAdapter.Listener.Action.START_SELECTION_MODE: |
| 551 | mAllFragment.displayCheckBoxes(true); |
Walter Jang | a84fe61 | 2016-01-13 16:49:04 -0800 | [diff] [blame] | 552 | startSearchOrSelectionMode(); |
| 553 | break; |
Daniel Lehmann | 311882a | 2012-04-27 22:31:38 -0700 | [diff] [blame] | 554 | case ActionBarAdapter.Listener.Action.START_SEARCH_MODE: |
Walter Jang | a84fe61 | 2016-01-13 16:49:04 -0800 | [diff] [blame] | 555 | if (!mIsRecreatedInstance) { |
| 556 | Logger.getInstance().logScreenView( |
| 557 | ScreenEvent.SEARCH, this, ScreenEvent.TAG_SEARCH); |
| 558 | } |
| 559 | startSearchOrSelectionMode(); |
Brian Attwell | 865847b | 2015-04-20 14:40:17 -0700 | [diff] [blame] | 560 | break; |
| 561 | case ActionBarAdapter.Listener.Action.BEGIN_STOPPING_SEARCH_AND_SELECTION_MODE: |
| 562 | showFabWithAnimation(/* showFabWithAnimation = */ true); |
Katherine Kuan | b5760b9 | 2011-06-01 16:19:40 -0700 | [diff] [blame] | 563 | break; |
Brian Attwell | 20510ec | 2015-02-27 16:10:45 -0800 | [diff] [blame] | 564 | case ActionBarAdapter.Listener.Action.STOP_SEARCH_AND_SELECTION_MODE: |
Makoto Onuki | 1db00f6 | 2011-10-19 12:40:12 -0700 | [diff] [blame] | 565 | setQueryTextToFragment(""); |
Makoto Onuki | 4d788fc | 2011-07-12 10:00:10 -0700 | [diff] [blame] | 566 | updateFragmentsVisibility(); |
Makoto Onuki | 8811b7c | 2011-07-13 15:43:03 -0700 | [diff] [blame] | 567 | invalidateOptionsMenu(); |
Brian Attwell | 865847b | 2015-04-20 14:40:17 -0700 | [diff] [blame] | 568 | showFabWithAnimation(/* showFabWithAnimation = */ true); |
Katherine Kuan | 8268bbe | 2011-06-10 17:48:21 -0700 | [diff] [blame] | 569 | break; |
Daniel Lehmann | 311882a | 2012-04-27 22:31:38 -0700 | [diff] [blame] | 570 | case ActionBarAdapter.Listener.Action.CHANGE_SEARCH_QUERY: |
Makoto Onuki | 9ae6041 | 2012-07-19 15:56:41 -0700 | [diff] [blame] | 571 | final String queryString = mActionBarAdapter.getQueryString(); |
| 572 | setQueryTextToFragment(queryString); |
| 573 | updateDebugOptionsVisibility( |
| 574 | ENABLE_DEBUG_OPTIONS_HIDDEN_CODE.equals(queryString)); |
Katherine Kuan | b5760b9 | 2011-06-01 16:19:40 -0700 | [diff] [blame] | 575 | break; |
| 576 | default: |
| 577 | throw new IllegalStateException("Unkonwn ActionBarAdapter action: " + action); |
| 578 | } |
Dmitri Plotnikov | fe42e55 | 2010-05-14 14:50:32 -0700 | [diff] [blame] | 579 | } |
| 580 | |
Walter Jang | a84fe61 | 2016-01-13 16:49:04 -0800 | [diff] [blame] | 581 | private void startSearchOrSelectionMode() { |
| 582 | configureFragments(false /* from request */); |
| 583 | updateFragmentsVisibility(); |
| 584 | invalidateOptionsMenu(); |
| 585 | showFabWithAnimation(/* showFabWithAnimation = */ false); |
| 586 | } |
| 587 | |
Makoto Onuki | 4d788fc | 2011-07-12 10:00:10 -0700 | [diff] [blame] | 588 | @Override |
| 589 | public void onSelectedTabChanged() { |
| 590 | updateFragmentsVisibility(); |
| 591 | } |
| 592 | |
Brian Attwell | 6adbf1e | 2014-05-30 16:44:51 -0700 | [diff] [blame] | 593 | @Override |
| 594 | public void onUpButtonPressed() { |
| 595 | onBackPressed(); |
| 596 | } |
| 597 | |
Makoto Onuki | 9ae6041 | 2012-07-19 15:56:41 -0700 | [diff] [blame] | 598 | private void updateDebugOptionsVisibility(boolean visible) { |
| 599 | if (mEnableDebugMenuOptions != visible) { |
| 600 | mEnableDebugMenuOptions = visible; |
| 601 | invalidateOptionsMenu(); |
| 602 | } |
| 603 | } |
| 604 | |
Makoto Onuki | 4d788fc | 2011-07-12 10:00:10 -0700 | [diff] [blame] | 605 | /** |
| 606 | * Updates the fragment/view visibility according to the current mode, such as |
| 607 | * {@link ActionBarAdapter#isSearchMode()} and {@link ActionBarAdapter#getCurrentTab()}. |
| 608 | */ |
| 609 | private void updateFragmentsVisibility() { |
Daniel Lehmann | 52aa32d | 2012-03-08 17:29:27 -0800 | [diff] [blame] | 610 | int tab = mActionBarAdapter.getCurrentTab(); |
Makoto Onuki | 4d788fc | 2011-07-12 10:00:10 -0700 | [diff] [blame] | 611 | |
Brian Attwell | 20510ec | 2015-02-27 16:10:45 -0800 | [diff] [blame] | 612 | if (mActionBarAdapter.isSearchMode() || mActionBarAdapter.isSelectionMode()) { |
| 613 | mTabPagerAdapter.setTabsHidden(true); |
Brian Attwell | 2c1bfd0 | 2014-06-04 18:18:35 -0700 | [diff] [blame] | 614 | } else { |
Brian Attwell | 20510ec | 2015-02-27 16:10:45 -0800 | [diff] [blame] | 615 | // No smooth scrolling if quitting from the search/selection mode. |
| 616 | final boolean wereTabsHidden = mTabPagerAdapter.areTabsHidden() |
| 617 | || mActionBarAdapter.isSelectionMode(); |
| 618 | mTabPagerAdapter.setTabsHidden(false); |
Brian Attwell | 2c1bfd0 | 2014-06-04 18:18:35 -0700 | [diff] [blame] | 619 | if (mTabPager.getCurrentItem() != tab) { |
Brian Attwell | 20510ec | 2015-02-27 16:10:45 -0800 | [diff] [blame] | 620 | mTabPager.setCurrentItem(tab, !wereTabsHidden); |
Brian Attwell | 2c1bfd0 | 2014-06-04 18:18:35 -0700 | [diff] [blame] | 621 | } |
Makoto Onuki | 4d788fc | 2011-07-12 10:00:10 -0700 | [diff] [blame] | 622 | } |
Brian Attwell | d2962a3 | 2015-03-02 14:48:50 -0800 | [diff] [blame] | 623 | if (!mActionBarAdapter.isSelectionMode()) { |
| 624 | mAllFragment.displayCheckBoxes(false); |
| 625 | } |
Brian Attwell | 2c1bfd0 | 2014-06-04 18:18:35 -0700 | [diff] [blame] | 626 | invalidateOptionsMenu(); |
Isaac Katzenelson | 66606b6 | 2011-07-22 18:47:45 -0700 | [diff] [blame] | 627 | showEmptyStateForTab(tab); |
| 628 | } |
| 629 | |
Daniel Lehmann | 52aa32d | 2012-03-08 17:29:27 -0800 | [diff] [blame] | 630 | private void showEmptyStateForTab(int tab) { |
Isaac Katzenelson | 66606b6 | 2011-07-22 18:47:45 -0700 | [diff] [blame] | 631 | if (mContactsUnavailableFragment != null) { |
Brian Attwell | 9203788 | 2014-10-16 18:24:44 -0700 | [diff] [blame] | 632 | switch (getTabPositionForTextDirection(tab)) { |
Daniel Lehmann | 52aa32d | 2012-03-08 17:29:27 -0800 | [diff] [blame] | 633 | case TabState.FAVORITES: |
Wenyi Wang | b0cfae5 | 2015-09-28 17:17:40 -0700 | [diff] [blame] | 634 | mContactsUnavailableFragment.setTabInfo( |
| 635 | R.string.listTotalAllContactsZeroStarred, TabState.FAVORITES); |
Isaac Katzenelson | 66606b6 | 2011-07-22 18:47:45 -0700 | [diff] [blame] | 636 | break; |
Daniel Lehmann | 52aa32d | 2012-03-08 17:29:27 -0800 | [diff] [blame] | 637 | case TabState.ALL: |
Wenyi Wang | b0cfae5 | 2015-09-28 17:17:40 -0700 | [diff] [blame] | 638 | mContactsUnavailableFragment.setTabInfo(R.string.noContacts, TabState.ALL); |
Isaac Katzenelson | 66606b6 | 2011-07-22 18:47:45 -0700 | [diff] [blame] | 639 | break; |
| 640 | } |
Brian Attwell | 8d71f11 | 2014-07-23 18:13:27 -0700 | [diff] [blame] | 641 | // When using the mContactsUnavailableFragment the ViewPager doesn't contain two views. |
| 642 | // Therefore, we have to trick the ViewPagerTabs into thinking we have changed tabs |
| 643 | // when the mContactsUnavailableFragment changes. Otherwise the tab strip won't move. |
| 644 | mViewPagerTabs.onPageScrolled(tab, 0, 0); |
Isaac Katzenelson | 66606b6 | 2011-07-22 18:47:45 -0700 | [diff] [blame] | 645 | } |
Makoto Onuki | 4d788fc | 2011-07-12 10:00:10 -0700 | [diff] [blame] | 646 | } |
| 647 | |
Makoto Onuki | 250ce43 | 2011-07-12 18:26:45 -0700 | [diff] [blame] | 648 | private class TabPagerListener implements ViewPager.OnPageChangeListener { |
Chiao Cheng | 70f77ea | 2012-05-31 13:33:58 -0700 | [diff] [blame] | 649 | |
| 650 | // This package-protected constructor is here because of a possible compiler bug. |
| 651 | // PeopleActivity$1.class should be generated due to the private outer/inner class access |
| 652 | // needed here. But for some reason, PeopleActivity$1.class is missing. |
| 653 | // Since $1 class is needed as a jvm work around to get access to the inner class, |
| 654 | // changing the constructor to package-protected or public will solve the problem. |
| 655 | // To verify whether $1 class is needed, javap PeopleActivity$TabPagerListener and look for |
| 656 | // references to PeopleActivity$1. |
| 657 | // |
| 658 | // When the constructor is private and PeopleActivity$1.class is missing, proguard will |
| 659 | // correctly catch this and throw warnings and error out the build on user/userdebug builds. |
| 660 | // |
| 661 | // All private inner classes below also need this fix. |
| 662 | TabPagerListener() {} |
| 663 | |
Makoto Onuki | 250ce43 | 2011-07-12 18:26:45 -0700 | [diff] [blame] | 664 | @Override |
| 665 | public void onPageScrollStateChanged(int state) { |
Brian Attwell | 20510ec | 2015-02-27 16:10:45 -0800 | [diff] [blame] | 666 | if (!mTabPagerAdapter.areTabsHidden()) { |
Brian Attwell | 3c763b3 | 2014-07-21 14:25:28 -0700 | [diff] [blame] | 667 | mViewPagerTabs.onPageScrollStateChanged(state); |
| 668 | } |
Makoto Onuki | 250ce43 | 2011-07-12 18:26:45 -0700 | [diff] [blame] | 669 | } |
| 670 | |
| 671 | @Override |
| 672 | public void onPageScrolled(int position, float positionOffset, int positionOffsetPixels) { |
Brian Attwell | 20510ec | 2015-02-27 16:10:45 -0800 | [diff] [blame] | 673 | if (!mTabPagerAdapter.areTabsHidden()) { |
Brian Attwell | 3c763b3 | 2014-07-21 14:25:28 -0700 | [diff] [blame] | 674 | mViewPagerTabs.onPageScrolled(position, positionOffset, positionOffsetPixels); |
| 675 | } |
Makoto Onuki | 250ce43 | 2011-07-12 18:26:45 -0700 | [diff] [blame] | 676 | } |
| 677 | |
| 678 | @Override |
| 679 | public void onPageSelected(int position) { |
| 680 | // Make sure not in the search mode, in which case position != TabState.ordinal(). |
Brian Attwell | 20510ec | 2015-02-27 16:10:45 -0800 | [diff] [blame] | 681 | if (!mTabPagerAdapter.areTabsHidden()) { |
Daniel Lehmann | 52aa32d | 2012-03-08 17:29:27 -0800 | [diff] [blame] | 682 | mActionBarAdapter.setCurrentTab(position, false); |
Brian Attwell | 3c763b3 | 2014-07-21 14:25:28 -0700 | [diff] [blame] | 683 | mViewPagerTabs.onPageSelected(position); |
Daniel Lehmann | 52aa32d | 2012-03-08 17:29:27 -0800 | [diff] [blame] | 684 | showEmptyStateForTab(position); |
Makoto Onuki | 8811b7c | 2011-07-13 15:43:03 -0700 | [diff] [blame] | 685 | invalidateOptionsMenu(); |
Makoto Onuki | 250ce43 | 2011-07-12 18:26:45 -0700 | [diff] [blame] | 686 | } |
| 687 | } |
| 688 | } |
| 689 | |
| 690 | /** |
| 691 | * Adapter for the {@link ViewPager}. Unlike {@link FragmentPagerAdapter}, |
| 692 | * {@link #instantiateItem} returns existing fragments, and {@link #instantiateItem}/ |
| 693 | * {@link #destroyItem} show/hide fragments instead of attaching/detaching. |
| 694 | * |
| 695 | * In search mode, we always show the "all" fragment, and disable the swipe. We change the |
| 696 | * number of items to 1 to disable the swipe. |
| 697 | * |
| 698 | * TODO figure out a more straight way to disable swipe. |
| 699 | */ |
| 700 | private class TabPagerAdapter extends PagerAdapter { |
| 701 | private final FragmentManager mFragmentManager; |
| 702 | private FragmentTransaction mCurTransaction = null; |
| 703 | |
Brian Attwell | 20510ec | 2015-02-27 16:10:45 -0800 | [diff] [blame] | 704 | private boolean mAreTabsHiddenInTabPager; |
Makoto Onuki | 250ce43 | 2011-07-12 18:26:45 -0700 | [diff] [blame] | 705 | |
Makoto Onuki | 746316a | 2011-10-31 14:32:39 -0700 | [diff] [blame] | 706 | private Fragment mCurrentPrimaryItem; |
| 707 | |
Makoto Onuki | 250ce43 | 2011-07-12 18:26:45 -0700 | [diff] [blame] | 708 | public TabPagerAdapter() { |
| 709 | mFragmentManager = getFragmentManager(); |
| 710 | } |
| 711 | |
Brian Attwell | 20510ec | 2015-02-27 16:10:45 -0800 | [diff] [blame] | 712 | public boolean areTabsHidden() { |
| 713 | return mAreTabsHiddenInTabPager; |
Makoto Onuki | 250ce43 | 2011-07-12 18:26:45 -0700 | [diff] [blame] | 714 | } |
| 715 | |
Brian Attwell | 20510ec | 2015-02-27 16:10:45 -0800 | [diff] [blame] | 716 | public void setTabsHidden(boolean hideTabs) { |
| 717 | if (hideTabs == mAreTabsHiddenInTabPager) { |
Makoto Onuki | 250ce43 | 2011-07-12 18:26:45 -0700 | [diff] [blame] | 718 | return; |
| 719 | } |
Brian Attwell | 20510ec | 2015-02-27 16:10:45 -0800 | [diff] [blame] | 720 | mAreTabsHiddenInTabPager = hideTabs; |
Makoto Onuki | 250ce43 | 2011-07-12 18:26:45 -0700 | [diff] [blame] | 721 | notifyDataSetChanged(); |
| 722 | } |
| 723 | |
| 724 | @Override |
| 725 | public int getCount() { |
Brian Attwell | 20510ec | 2015-02-27 16:10:45 -0800 | [diff] [blame] | 726 | return mAreTabsHiddenInTabPager ? 1 : TabState.COUNT; |
Makoto Onuki | 250ce43 | 2011-07-12 18:26:45 -0700 | [diff] [blame] | 727 | } |
| 728 | |
| 729 | /** Gets called when the number of items changes. */ |
| 730 | @Override |
| 731 | public int getItemPosition(Object object) { |
Brian Attwell | 20510ec | 2015-02-27 16:10:45 -0800 | [diff] [blame] | 732 | if (mAreTabsHiddenInTabPager) { |
Makoto Onuki | 250ce43 | 2011-07-12 18:26:45 -0700 | [diff] [blame] | 733 | if (object == mAllFragment) { |
| 734 | return 0; // Only 1 page in search mode |
| 735 | } |
| 736 | } else { |
| 737 | if (object == mFavoritesFragment) { |
Brian Attwell | 962677f | 2014-09-26 12:29:07 -0700 | [diff] [blame] | 738 | return getTabPositionForTextDirection(TabState.FAVORITES); |
Makoto Onuki | 250ce43 | 2011-07-12 18:26:45 -0700 | [diff] [blame] | 739 | } |
| 740 | if (object == mAllFragment) { |
Brian Attwell | 962677f | 2014-09-26 12:29:07 -0700 | [diff] [blame] | 741 | return getTabPositionForTextDirection(TabState.ALL); |
Makoto Onuki | 250ce43 | 2011-07-12 18:26:45 -0700 | [diff] [blame] | 742 | } |
Makoto Onuki | 250ce43 | 2011-07-12 18:26:45 -0700 | [diff] [blame] | 743 | } |
| 744 | return POSITION_NONE; |
| 745 | } |
| 746 | |
| 747 | @Override |
Katherine Kuan | 9704544 | 2011-11-28 10:47:58 -0800 | [diff] [blame] | 748 | public void startUpdate(ViewGroup container) { |
Makoto Onuki | 250ce43 | 2011-07-12 18:26:45 -0700 | [diff] [blame] | 749 | } |
| 750 | |
| 751 | private Fragment getFragment(int position) { |
Brian Attwell | 962677f | 2014-09-26 12:29:07 -0700 | [diff] [blame] | 752 | position = getTabPositionForTextDirection(position); |
Brian Attwell | 20510ec | 2015-02-27 16:10:45 -0800 | [diff] [blame] | 753 | if (mAreTabsHiddenInTabPager) { |
Daniel Lehmann | 8d9ca01 | 2012-05-03 18:33:56 -0700 | [diff] [blame] | 754 | if (position != 0) { |
| 755 | // This has only been observed in monkey tests. |
| 756 | // Let's log this issue, but not crash |
| 757 | Log.w(TAG, "Request fragment at position=" + position + ", eventhough we " + |
| 758 | "are in search mode"); |
Makoto Onuki | 250ce43 | 2011-07-12 18:26:45 -0700 | [diff] [blame] | 759 | } |
Daniel Lehmann | 8d9ca01 | 2012-05-03 18:33:56 -0700 | [diff] [blame] | 760 | return mAllFragment; |
Makoto Onuki | 250ce43 | 2011-07-12 18:26:45 -0700 | [diff] [blame] | 761 | } else { |
Daniel Lehmann | 52aa32d | 2012-03-08 17:29:27 -0800 | [diff] [blame] | 762 | if (position == TabState.FAVORITES) { |
Makoto Onuki | 250ce43 | 2011-07-12 18:26:45 -0700 | [diff] [blame] | 763 | return mFavoritesFragment; |
Daniel Lehmann | 52aa32d | 2012-03-08 17:29:27 -0800 | [diff] [blame] | 764 | } else if (position == TabState.ALL) { |
Makoto Onuki | 250ce43 | 2011-07-12 18:26:45 -0700 | [diff] [blame] | 765 | return mAllFragment; |
Makoto Onuki | 250ce43 | 2011-07-12 18:26:45 -0700 | [diff] [blame] | 766 | } |
| 767 | } |
| 768 | throw new IllegalArgumentException("position: " + position); |
| 769 | } |
| 770 | |
| 771 | @Override |
Katherine Kuan | 9704544 | 2011-11-28 10:47:58 -0800 | [diff] [blame] | 772 | public Object instantiateItem(ViewGroup container, int position) { |
Makoto Onuki | 250ce43 | 2011-07-12 18:26:45 -0700 | [diff] [blame] | 773 | if (mCurTransaction == null) { |
| 774 | mCurTransaction = mFragmentManager.beginTransaction(); |
| 775 | } |
| 776 | Fragment f = getFragment(position); |
| 777 | mCurTransaction.show(f); |
Makoto Onuki | 746316a | 2011-10-31 14:32:39 -0700 | [diff] [blame] | 778 | |
Adam Powell | 9bd59f2 | 2011-11-07 14:02:10 -0800 | [diff] [blame] | 779 | // Non primary pages are not visible. |
| 780 | f.setUserVisibleHint(f == mCurrentPrimaryItem); |
Makoto Onuki | 250ce43 | 2011-07-12 18:26:45 -0700 | [diff] [blame] | 781 | return f; |
| 782 | } |
| 783 | |
| 784 | @Override |
Katherine Kuan | 9704544 | 2011-11-28 10:47:58 -0800 | [diff] [blame] | 785 | public void destroyItem(ViewGroup container, int position, Object object) { |
Makoto Onuki | 250ce43 | 2011-07-12 18:26:45 -0700 | [diff] [blame] | 786 | if (mCurTransaction == null) { |
| 787 | mCurTransaction = mFragmentManager.beginTransaction(); |
| 788 | } |
| 789 | mCurTransaction.hide((Fragment) object); |
| 790 | } |
| 791 | |
| 792 | @Override |
Katherine Kuan | 9704544 | 2011-11-28 10:47:58 -0800 | [diff] [blame] | 793 | public void finishUpdate(ViewGroup container) { |
Makoto Onuki | 250ce43 | 2011-07-12 18:26:45 -0700 | [diff] [blame] | 794 | if (mCurTransaction != null) { |
Minh Pham | 4b25da7 | 2011-08-25 13:50:38 -0700 | [diff] [blame] | 795 | mCurTransaction.commitAllowingStateLoss(); |
Makoto Onuki | 250ce43 | 2011-07-12 18:26:45 -0700 | [diff] [blame] | 796 | mCurTransaction = null; |
| 797 | mFragmentManager.executePendingTransactions(); |
| 798 | } |
| 799 | } |
| 800 | |
| 801 | @Override |
| 802 | public boolean isViewFromObject(View view, Object object) { |
| 803 | return ((Fragment) object).getView() == view; |
| 804 | } |
| 805 | |
| 806 | @Override |
Katherine Kuan | 9704544 | 2011-11-28 10:47:58 -0800 | [diff] [blame] | 807 | public void setPrimaryItem(ViewGroup container, int position, Object object) { |
Makoto Onuki | 746316a | 2011-10-31 14:32:39 -0700 | [diff] [blame] | 808 | Fragment fragment = (Fragment) object; |
| 809 | if (mCurrentPrimaryItem != fragment) { |
| 810 | if (mCurrentPrimaryItem != null) { |
Adam Powell | 9bd59f2 | 2011-11-07 14:02:10 -0800 | [diff] [blame] | 811 | mCurrentPrimaryItem.setUserVisibleHint(false); |
Makoto Onuki | 746316a | 2011-10-31 14:32:39 -0700 | [diff] [blame] | 812 | } |
| 813 | if (fragment != null) { |
Adam Powell | 9bd59f2 | 2011-11-07 14:02:10 -0800 | [diff] [blame] | 814 | fragment.setUserVisibleHint(true); |
Makoto Onuki | 746316a | 2011-10-31 14:32:39 -0700 | [diff] [blame] | 815 | } |
| 816 | mCurrentPrimaryItem = fragment; |
| 817 | } |
| 818 | } |
| 819 | |
| 820 | @Override |
Makoto Onuki | 250ce43 | 2011-07-12 18:26:45 -0700 | [diff] [blame] | 821 | public Parcelable saveState() { |
| 822 | return null; |
| 823 | } |
| 824 | |
| 825 | @Override |
| 826 | public void restoreState(Parcelable state, ClassLoader loader) { |
| 827 | } |
Brian Attwell | 3c763b3 | 2014-07-21 14:25:28 -0700 | [diff] [blame] | 828 | |
| 829 | @Override |
| 830 | public CharSequence getPageTitle(int position) { |
| 831 | return mTabTitles[position]; |
| 832 | } |
Makoto Onuki | 250ce43 | 2011-07-12 18:26:45 -0700 | [diff] [blame] | 833 | } |
| 834 | |
Makoto Onuki | 1db00f6 | 2011-10-19 12:40:12 -0700 | [diff] [blame] | 835 | private void setQueryTextToFragment(String query) { |
Daisuke Miyakawa | 95c5c2a | 2011-07-08 10:33:21 -0700 | [diff] [blame] | 836 | mAllFragment.setQueryString(query, true); |
Makoto Onuki | 1db00f6 | 2011-10-19 12:40:12 -0700 | [diff] [blame] | 837 | mAllFragment.setVisibleScrollbarEnabled(!mAllFragment.isSearchMode()); |
Katherine Kuan | 8268bbe | 2011-06-10 17:48:21 -0700 | [diff] [blame] | 838 | } |
| 839 | |
Katherine Kuan | 0ff0e31 | 2011-06-08 17:43:51 -0700 | [diff] [blame] | 840 | private void configureContactListFragmentForRequest() { |
Dmitri Plotnikov | fa49a66 | 2011-01-13 11:04:56 -0800 | [diff] [blame] | 841 | Uri contactUri = mRequest.getContactUri(); |
| 842 | if (contactUri != null) { |
Daisuke Miyakawa | 95c5c2a | 2011-07-08 10:33:21 -0700 | [diff] [blame] | 843 | mAllFragment.setSelectedContactUri(contactUri); |
Dmitri Plotnikov | fa49a66 | 2011-01-13 11:04:56 -0800 | [diff] [blame] | 844 | } |
Dmitri Plotnikov | 1ce1e7c | 2010-05-13 16:41:00 -0700 | [diff] [blame] | 845 | |
Daisuke Miyakawa | a012aec | 2011-10-16 10:24:43 -0700 | [diff] [blame] | 846 | mAllFragment.setFilter(mContactListFilterController.getFilter()); |
Makoto Onuki | 1db00f6 | 2011-10-19 12:40:12 -0700 | [diff] [blame] | 847 | setQueryTextToFragment(mActionBarAdapter.getQueryString()); |
Dmitri Plotnikov | 1ce1e7c | 2010-05-13 16:41:00 -0700 | [diff] [blame] | 848 | |
Dmitri Plotnikov | fa49a66 | 2011-01-13 11:04:56 -0800 | [diff] [blame] | 849 | if (mRequest.isDirectorySearchEnabled()) { |
Daisuke Miyakawa | 95c5c2a | 2011-07-08 10:33:21 -0700 | [diff] [blame] | 850 | mAllFragment.setDirectorySearchMode(DirectoryListLoader.SEARCH_MODE_DEFAULT); |
Dmitri Plotnikov | fa49a66 | 2011-01-13 11:04:56 -0800 | [diff] [blame] | 851 | } else { |
Daisuke Miyakawa | 95c5c2a | 2011-07-08 10:33:21 -0700 | [diff] [blame] | 852 | mAllFragment.setDirectorySearchMode(DirectoryListLoader.SEARCH_MODE_NONE); |
Dmitri Plotnikov | fa49a66 | 2011-01-13 11:04:56 -0800 | [diff] [blame] | 853 | } |
Dmitri Plotnikov | 08e1c4e | 2010-07-02 17:57:51 -0700 | [diff] [blame] | 854 | } |
| 855 | |
Katherine Kuan | 0ff0e31 | 2011-06-08 17:43:51 -0700 | [diff] [blame] | 856 | private void configureContactListFragment() { |
Daisuke Miyakawa | a012aec | 2011-10-16 10:24:43 -0700 | [diff] [blame] | 857 | // Filter may be changed when this Activity is in background. |
| 858 | mAllFragment.setFilter(mContactListFilterController.getFilter()); |
| 859 | |
Brian Attwell | 2c1bfd0 | 2014-06-04 18:18:35 -0700 | [diff] [blame] | 860 | mAllFragment.setVerticalScrollbarPosition(getScrollBarPosition()); |
| 861 | mAllFragment.setSelectionVisible(false); |
Dmitri Plotnikov | 1ce1e7c | 2010-05-13 16:41:00 -0700 | [diff] [blame] | 862 | } |
| 863 | |
Brian Attwell | 2c1bfd0 | 2014-06-04 18:18:35 -0700 | [diff] [blame] | 864 | private int getScrollBarPosition() { |
| 865 | return isRTL() ? View.SCROLLBAR_POSITION_LEFT : View.SCROLLBAR_POSITION_RIGHT; |
Chiao Cheng | e907838 | 2013-06-17 16:35:10 -0700 | [diff] [blame] | 866 | } |
| 867 | |
| 868 | private boolean isRTL() { |
| 869 | final Locale locale = Locale.getDefault(); |
| 870 | return TextUtils.getLayoutDirectionFromLocale(locale) == View.LAYOUT_DIRECTION_RTL; |
| 871 | } |
| 872 | |
Dmitri Plotnikov | 8b82646 | 2010-11-17 14:52:24 -0800 | [diff] [blame] | 873 | @Override |
| 874 | public void onProviderStatusChange() { |
Josh Gargus | 697ab26 | 2012-05-04 11:11:34 -0700 | [diff] [blame] | 875 | updateViewConfiguration(false); |
Dmitri Plotnikov | 8b82646 | 2010-11-17 14:52:24 -0800 | [diff] [blame] | 876 | } |
| 877 | |
Josh Gargus | 697ab26 | 2012-05-04 11:11:34 -0700 | [diff] [blame] | 878 | private void updateViewConfiguration(boolean forceUpdate) { |
Brian Attwell | c3d202c | 2015-01-08 15:01:03 -0800 | [diff] [blame] | 879 | int providerStatus = mProviderStatusWatcher.getProviderStatus(); |
Makoto Onuki | d8fa716 | 2012-05-16 13:45:48 -0700 | [diff] [blame] | 880 | if (!forceUpdate && (mProviderStatus != null) |
Brian Attwell | c3d202c | 2015-01-08 15:01:03 -0800 | [diff] [blame] | 881 | && (mProviderStatus.equals(providerStatus))) return; |
Dmitri Plotnikov | 8b82646 | 2010-11-17 14:52:24 -0800 | [diff] [blame] | 882 | mProviderStatus = providerStatus; |
| 883 | |
| 884 | View contactsUnavailableView = findViewById(R.id.contacts_unavailable_view); |
Dmitri Plotnikov | 8b82646 | 2010-11-17 14:52:24 -0800 | [diff] [blame] | 885 | |
Brian Attwell | c3d202c | 2015-01-08 15:01:03 -0800 | [diff] [blame] | 886 | if (mProviderStatus.equals(ProviderStatus.STATUS_NORMAL)) { |
Josh Gargus | b8f11b9 | 2011-11-17 18:32:44 -0800 | [diff] [blame] | 887 | // Ensure that the mTabPager is visible; we may have made it invisible below. |
Dmitri Plotnikov | c3f2a52 | 2010-11-17 18:36:17 -0800 | [diff] [blame] | 888 | contactsUnavailableView.setVisibility(View.GONE); |
Josh Gargus | b8f11b9 | 2011-11-17 18:32:44 -0800 | [diff] [blame] | 889 | if (mTabPager != null) { |
| 890 | mTabPager.setVisibility(View.VISIBLE); |
| 891 | } |
| 892 | |
Daisuke Miyakawa | 95c5c2a | 2011-07-08 10:33:21 -0700 | [diff] [blame] | 893 | if (mAllFragment != null) { |
| 894 | mAllFragment.setEnabled(true); |
Dmitri Plotnikov | 8b82646 | 2010-11-17 14:52:24 -0800 | [diff] [blame] | 895 | } |
Dmitri Plotnikov | 8b82646 | 2010-11-17 14:52:24 -0800 | [diff] [blame] | 896 | } else { |
guanxiongliu | 5d7bb26 | 2016-01-29 16:43:45 -0800 | [diff] [blame] | 897 | // Setting up the page so that the user can still use the app |
| 898 | // even without an account. |
Daisuke Miyakawa | 95c5c2a | 2011-07-08 10:33:21 -0700 | [diff] [blame] | 899 | if (mAllFragment != null) { |
| 900 | mAllFragment.setEnabled(false); |
Dmitri Plotnikov | 8b82646 | 2010-11-17 14:52:24 -0800 | [diff] [blame] | 901 | } |
| 902 | if (mContactsUnavailableFragment == null) { |
| 903 | mContactsUnavailableFragment = new ContactsUnavailableFragment(); |
Dmitri Plotnikov | 8b82646 | 2010-11-17 14:52:24 -0800 | [diff] [blame] | 904 | mContactsUnavailableFragment.setOnContactsUnavailableActionListener( |
| 905 | new ContactsUnavailableFragmentListener()); |
Dianne Hackborn | 3ed426c | 2011-01-17 12:30:32 -0800 | [diff] [blame] | 906 | getFragmentManager().beginTransaction() |
Dmitri Plotnikov | 8b82646 | 2010-11-17 14:52:24 -0800 | [diff] [blame] | 907 | .replace(R.id.contacts_unavailable_container, mContactsUnavailableFragment) |
Minh Pham | 4b25da7 | 2011-08-25 13:50:38 -0700 | [diff] [blame] | 908 | .commitAllowingStateLoss(); |
Dmitri Plotnikov | 8b82646 | 2010-11-17 14:52:24 -0800 | [diff] [blame] | 909 | } |
Makoto Onuki | d8fa716 | 2012-05-16 13:45:48 -0700 | [diff] [blame] | 910 | mContactsUnavailableFragment.updateStatus(mProviderStatus); |
Josh Gargus | b8f11b9 | 2011-11-17 18:32:44 -0800 | [diff] [blame] | 911 | |
| 912 | // Show the contactsUnavailableView, and hide the mTabPager so that we don't |
| 913 | // see it sliding in underneath the contactsUnavailableView at the edges. |
Dmitri Plotnikov | 8b82646 | 2010-11-17 14:52:24 -0800 | [diff] [blame] | 914 | contactsUnavailableView.setVisibility(View.VISIBLE); |
Josh Gargus | b8f11b9 | 2011-11-17 18:32:44 -0800 | [diff] [blame] | 915 | if (mTabPager != null) { |
| 916 | mTabPager.setVisibility(View.GONE); |
| 917 | } |
| 918 | |
Daniel Lehmann | 52aa32d | 2012-03-08 17:29:27 -0800 | [diff] [blame] | 919 | showEmptyStateForTab(mActionBarAdapter.getCurrentTab()); |
Dmitri Plotnikov | 8b82646 | 2010-11-17 14:52:24 -0800 | [diff] [blame] | 920 | } |
| 921 | |
Katherine Kuan | 8268bbe | 2011-06-10 17:48:21 -0700 | [diff] [blame] | 922 | invalidateOptionsMenuIfNeeded(); |
Dmitri Plotnikov | 8b82646 | 2010-11-17 14:52:24 -0800 | [diff] [blame] | 923 | } |
| 924 | |
Dmitri Plotnikov | 1ce1e7c | 2010-05-13 16:41:00 -0700 | [diff] [blame] | 925 | private final class ContactBrowserActionListener implements OnContactBrowserActionListener { |
Chiao Cheng | 70f77ea | 2012-05-31 13:33:58 -0700 | [diff] [blame] | 926 | ContactBrowserActionListener() {} |
Dmitri Plotnikov | d959104 | 2010-11-23 09:25:03 -0800 | [diff] [blame] | 927 | |
| 928 | @Override |
| 929 | public void onSelectionChange() { |
Brian Attwell | 2c1bfd0 | 2014-06-04 18:18:35 -0700 | [diff] [blame] | 930 | |
Dmitri Plotnikov | d959104 | 2010-11-23 09:25:03 -0800 | [diff] [blame] | 931 | } |
| 932 | |
Daniel Lehmann | e20d343 | 2010-10-10 18:37:51 -0700 | [diff] [blame] | 933 | @Override |
Ricky Wai | ed5202a | 2015-11-17 18:06:33 +0000 | [diff] [blame] | 934 | public void onViewContactAction(Uri contactLookupUri, boolean isEnterpriseContact) { |
| 935 | if (isEnterpriseContact) { |
| 936 | // No implicit intent as user may have a different contacts app in work profile. |
| 937 | QuickContact.showQuickContact(PeopleActivity.this, new Rect(), contactLookupUri, |
| 938 | QuickContactActivity.MODE_FULLY_EXPANDED, null); |
| 939 | } else { |
| 940 | final Intent intent = ImplicitIntentsUtil.composeQuickContactIntent( |
| 941 | contactLookupUri, |
| 942 | QuickContactActivity.MODE_FULLY_EXPANDED); |
| 943 | ImplicitIntentsUtil.startActivityInApp(PeopleActivity.this, intent); |
| 944 | } |
Dmitri Plotnikov | 1ce1e7c | 2010-05-13 16:41:00 -0700 | [diff] [blame] | 945 | } |
| 946 | |
Daniel Lehmann | e20d343 | 2010-10-10 18:37:51 -0700 | [diff] [blame] | 947 | @Override |
Dmitri Plotnikov | 1ce1e7c | 2010-05-13 16:41:00 -0700 | [diff] [blame] | 948 | public void onDeleteContactAction(Uri contactUri) { |
Katherine Kuan | 9856fce | 2011-06-01 10:24:09 -0700 | [diff] [blame] | 949 | ContactDeletionInteraction.start(PeopleActivity.this, contactUri, false); |
Dmitri Plotnikov | 1ce1e7c | 2010-05-13 16:41:00 -0700 | [diff] [blame] | 950 | } |
| 951 | |
Daniel Lehmann | e20d343 | 2010-10-10 18:37:51 -0700 | [diff] [blame] | 952 | @Override |
Dmitri Plotnikov | 1ce1e7c | 2010-05-13 16:41:00 -0700 | [diff] [blame] | 953 | public void onFinishAction() { |
| 954 | onBackPressed(); |
| 955 | } |
Dmitri Plotnikov | 6e850a0 | 2010-10-28 10:46:21 -0700 | [diff] [blame] | 956 | |
| 957 | @Override |
| 958 | public void onInvalidSelection() { |
Daisuke Miyakawa | b9225e3 | 2011-08-22 14:02:43 -0700 | [diff] [blame] | 959 | ContactListFilter filter; |
| 960 | ContactListFilter currentFilter = mAllFragment.getFilter(); |
| 961 | if (currentFilter != null |
| 962 | && currentFilter.filterType == ContactListFilter.FILTER_TYPE_SINGLE_CONTACT) { |
| 963 | filter = ContactListFilter.createFilterWithType( |
| 964 | ContactListFilter.FILTER_TYPE_ALL_ACCOUNTS); |
| 965 | mAllFragment.setFilter(filter); |
| 966 | } else { |
| 967 | filter = ContactListFilter.createFilterWithType( |
| 968 | ContactListFilter.FILTER_TYPE_SINGLE_CONTACT); |
| 969 | mAllFragment.setFilter(filter, false); |
| 970 | } |
Dmitri Plotnikov | d959104 | 2010-11-23 09:25:03 -0800 | [diff] [blame] | 971 | mContactListFilterController.setContactListFilter(filter, true); |
Dmitri Plotnikov | 6e850a0 | 2010-10-28 10:46:21 -0700 | [diff] [blame] | 972 | } |
Dmitri Plotnikov | 1ce1e7c | 2010-05-13 16:41:00 -0700 | [diff] [blame] | 973 | } |
| 974 | |
Brian Attwell | 20510ec | 2015-02-27 16:10:45 -0800 | [diff] [blame] | 975 | private final class CheckBoxListListener implements OnCheckBoxListActionListener { |
| 976 | @Override |
| 977 | public void onStartDisplayingCheckBoxes() { |
Brian Attwell | 865847b | 2015-04-20 14:40:17 -0700 | [diff] [blame] | 978 | mActionBarAdapter.setSelectionMode(true); |
| 979 | invalidateOptionsMenu(); |
Brian Attwell | 20510ec | 2015-02-27 16:10:45 -0800 | [diff] [blame] | 980 | } |
| 981 | |
| 982 | @Override |
| 983 | public void onSelectedContactIdsChanged() { |
| 984 | mActionBarAdapter.setSelectionCount(mAllFragment.getSelectedContactIds().size()); |
| 985 | invalidateOptionsMenu(); |
| 986 | } |
Brian Attwell | 8f8937f | 2015-03-05 14:07:43 -0800 | [diff] [blame] | 987 | |
| 988 | @Override |
| 989 | public void onStopDisplayingCheckBoxes() { |
| 990 | mActionBarAdapter.setSelectionMode(false); |
| 991 | } |
Brian Attwell | 20510ec | 2015-02-27 16:10:45 -0800 | [diff] [blame] | 992 | } |
| 993 | |
Dmitri Plotnikov | 8b82646 | 2010-11-17 14:52:24 -0800 | [diff] [blame] | 994 | private class ContactsUnavailableFragmentListener |
| 995 | implements OnContactsUnavailableActionListener { |
Chiao Cheng | 70f77ea | 2012-05-31 13:33:58 -0700 | [diff] [blame] | 996 | ContactsUnavailableFragmentListener() {} |
Dmitri Plotnikov | 8b82646 | 2010-11-17 14:52:24 -0800 | [diff] [blame] | 997 | |
| 998 | @Override |
| 999 | public void onCreateNewContactAction() { |
Brian Attwell | c6100ff | 2015-02-19 21:35:36 -0800 | [diff] [blame] | 1000 | ImplicitIntentsUtil.startActivityInApp(PeopleActivity.this, |
Walter Jang | 5a7a23b | 2015-03-06 10:54:26 -0800 | [diff] [blame] | 1001 | EditorIntents.createCompactInsertContactIntent()); |
Dmitri Plotnikov | 8b82646 | 2010-11-17 14:52:24 -0800 | [diff] [blame] | 1002 | } |
| 1003 | |
| 1004 | @Override |
| 1005 | public void onAddAccountAction() { |
guanxiongliu | 5d7bb26 | 2016-01-29 16:43:45 -0800 | [diff] [blame] | 1006 | final Intent intent = ImplicitIntentsUtil.getIntentForAddingAccount(); |
Brian Attwell | c6100ff | 2015-02-19 21:35:36 -0800 | [diff] [blame] | 1007 | ImplicitIntentsUtil.startActivityOutsideApp(PeopleActivity.this, intent); |
Dmitri Plotnikov | 8b82646 | 2010-11-17 14:52:24 -0800 | [diff] [blame] | 1008 | } |
| 1009 | |
| 1010 | @Override |
| 1011 | public void onImportContactsFromFileAction() { |
Wenyi Wang | 9379f4a | 2015-09-25 10:30:19 -0700 | [diff] [blame] | 1012 | showImportExportDialogFragment(); |
Dmitri Plotnikov | 8b82646 | 2010-11-17 14:52:24 -0800 | [diff] [blame] | 1013 | } |
Dmitri Plotnikov | 8b82646 | 2010-11-17 14:52:24 -0800 | [diff] [blame] | 1014 | } |
| 1015 | |
Daisuke Miyakawa | ee17947 | 2011-06-25 11:23:01 -0700 | [diff] [blame] | 1016 | private final class StrequentContactListFragmentListener |
Frank Sposaro | 7979ea2 | 2011-07-14 16:46:07 -0700 | [diff] [blame] | 1017 | implements ContactTileListFragment.Listener { |
Chiao Cheng | 70f77ea | 2012-05-31 13:33:58 -0700 | [diff] [blame] | 1018 | StrequentContactListFragmentListener() {} |
| 1019 | |
Daisuke Miyakawa | ee17947 | 2011-06-25 11:23:01 -0700 | [diff] [blame] | 1020 | @Override |
Katherine Kuan | 7a700cf | 2011-10-27 15:49:18 -0700 | [diff] [blame] | 1021 | public void onContactSelected(Uri contactUri, Rect targetRect) { |
Brian Attwell | c6100ff | 2015-02-19 21:35:36 -0800 | [diff] [blame] | 1022 | final Intent intent = ImplicitIntentsUtil.composeQuickContactIntent(contactUri, |
| 1023 | QuickContactActivity.MODE_FULLY_EXPANDED); |
| 1024 | ImplicitIntentsUtil.startActivityInApp(PeopleActivity.this, intent); |
Daisuke Miyakawa | ee17947 | 2011-06-25 11:23:01 -0700 | [diff] [blame] | 1025 | } |
Josh Gargus | 4e05a29 | 2012-01-03 15:49:08 -0800 | [diff] [blame] | 1026 | |
| 1027 | @Override |
| 1028 | public void onCallNumberDirectly(String phoneNumber) { |
| 1029 | // No need to call phone number directly from People app. |
| 1030 | Log.w(TAG, "unexpected invocation of onCallNumberDirectly()"); |
| 1031 | } |
Daisuke Miyakawa | ee17947 | 2011-06-25 11:23:01 -0700 | [diff] [blame] | 1032 | } |
| 1033 | |
The Android Open Source Project | 7aa0e4c | 2009-03-03 19:32:21 -0800 | [diff] [blame] | 1034 | @Override |
| 1035 | public boolean onCreateOptionsMenu(Menu menu) { |
Makoto Onuki | 946070f | 2011-08-09 18:15:33 -0700 | [diff] [blame] | 1036 | if (!areContactsAvailable()) { |
| 1037 | // If contacts aren't available, hide all menu items. |
| 1038 | return false; |
| 1039 | } |
Jeff Sharkey | d9798ae | 2009-08-24 20:46:23 -0700 | [diff] [blame] | 1040 | super.onCreateOptionsMenu(menu); |
| 1041 | |
Dmitri Plotnikov | d3758b0 | 2010-06-17 11:34:59 -0700 | [diff] [blame] | 1042 | MenuInflater inflater = getMenuInflater(); |
Daisuke Miyakawa | 18e0cab | 2011-11-21 13:06:10 -0800 | [diff] [blame] | 1043 | inflater.inflate(R.menu.people_options, menu); |
Katherine Kuan | 971116e | 2011-07-04 15:14:35 -0700 | [diff] [blame] | 1044 | |
Katherine Kuan | b5760b9 | 2011-06-01 16:19:40 -0700 | [diff] [blame] | 1045 | return true; |
Jeff Sharkey | d9798ae | 2009-08-24 20:46:23 -0700 | [diff] [blame] | 1046 | } |
Jeff Sharkey | 3f0b7b8 | 2009-08-12 11:28:53 -0700 | [diff] [blame] | 1047 | |
Katherine Kuan | 8268bbe | 2011-06-10 17:48:21 -0700 | [diff] [blame] | 1048 | private void invalidateOptionsMenuIfNeeded() { |
Dmitri Plotnikov | 0cd0130 | 2010-12-17 18:41:57 -0800 | [diff] [blame] | 1049 | if (isOptionsMenuChanged()) { |
Katherine Kuan | 8268bbe | 2011-06-10 17:48:21 -0700 | [diff] [blame] | 1050 | invalidateOptionsMenu(); |
Dmitri Plotnikov | 0cd0130 | 2010-12-17 18:41:57 -0800 | [diff] [blame] | 1051 | } |
| 1052 | } |
| 1053 | |
| 1054 | public boolean isOptionsMenuChanged() { |
| 1055 | if (mOptionsMenuContactsAvailable != areContactsAvailable()) { |
| 1056 | return true; |
| 1057 | } |
| 1058 | |
Daisuke Miyakawa | 95c5c2a | 2011-07-08 10:33:21 -0700 | [diff] [blame] | 1059 | if (mAllFragment != null && mAllFragment.isOptionsMenuChanged()) { |
Dmitri Plotnikov | 0cd0130 | 2010-12-17 18:41:57 -0800 | [diff] [blame] | 1060 | return true; |
| 1061 | } |
| 1062 | |
Dmitri Plotnikov | 0cd0130 | 2010-12-17 18:41:57 -0800 | [diff] [blame] | 1063 | return false; |
| 1064 | } |
| 1065 | |
| 1066 | @Override |
Jeff Sharkey | d9798ae | 2009-08-24 20:46:23 -0700 | [diff] [blame] | 1067 | public boolean onPrepareOptionsMenu(Menu menu) { |
Dmitri Plotnikov | 0cd0130 | 2010-12-17 18:41:57 -0800 | [diff] [blame] | 1068 | mOptionsMenuContactsAvailable = areContactsAvailable(); |
| 1069 | if (!mOptionsMenuContactsAvailable) { |
Dmitri Plotnikov | 8b82646 | 2010-11-17 14:52:24 -0800 | [diff] [blame] | 1070 | return false; |
| 1071 | } |
| 1072 | |
Maurice Chu | 2fc4de3 | 2012-04-23 17:05:45 -0700 | [diff] [blame] | 1073 | // Get references to individual menu items in the menu |
Isaac Katzenelson | 789bc59 | 2011-07-20 16:00:21 -0700 | [diff] [blame] | 1074 | final MenuItem contactsFilterMenu = menu.findItem(R.id.menu_contacts_filter); |
Maurice Chu | 2fc4de3 | 2012-04-23 17:05:45 -0700 | [diff] [blame] | 1075 | final MenuItem clearFrequentsMenu = menu.findItem(R.id.menu_clear_frequents); |
Brian Attwell | 8bb3d1e | 2014-05-15 21:55:02 +0000 | [diff] [blame] | 1076 | final MenuItem helpMenu = menu.findItem(R.id.menu_help); |
Maurice Chu | 2fc4de3 | 2012-04-23 17:05:45 -0700 | [diff] [blame] | 1077 | |
Brian Attwell | 20510ec | 2015-02-27 16:10:45 -0800 | [diff] [blame] | 1078 | final boolean isSearchOrSelectionMode = mActionBarAdapter.isSearchMode() |
| 1079 | || mActionBarAdapter.isSelectionMode(); |
| 1080 | if (isSearchOrSelectionMode) { |
Isaac Katzenelson | 683b57e | 2011-07-20 17:06:11 -0700 | [diff] [blame] | 1081 | contactsFilterMenu.setVisible(false); |
Maurice Chu | 2fc4de3 | 2012-04-23 17:05:45 -0700 | [diff] [blame] | 1082 | clearFrequentsMenu.setVisible(false); |
Brian Attwell | 8bb3d1e | 2014-05-15 21:55:02 +0000 | [diff] [blame] | 1083 | helpMenu.setVisible(false); |
Katherine Kuan | 8268bbe | 2011-06-10 17:48:21 -0700 | [diff] [blame] | 1084 | } else { |
Brian Attwell | 9203788 | 2014-10-16 18:24:44 -0700 | [diff] [blame] | 1085 | switch (getTabPositionForTextDirection(mActionBarAdapter.getCurrentTab())) { |
Daniel Lehmann | 52aa32d | 2012-03-08 17:29:27 -0800 | [diff] [blame] | 1086 | case TabState.FAVORITES: |
Isaac Katzenelson | 683b57e | 2011-07-20 17:06:11 -0700 | [diff] [blame] | 1087 | contactsFilterMenu.setVisible(false); |
Maurice Chu | 2fc4de3 | 2012-04-23 17:05:45 -0700 | [diff] [blame] | 1088 | clearFrequentsMenu.setVisible(hasFrequents()); |
Isaac Katzenelson | 683b57e | 2011-07-20 17:06:11 -0700 | [diff] [blame] | 1089 | break; |
Daniel Lehmann | 52aa32d | 2012-03-08 17:29:27 -0800 | [diff] [blame] | 1090 | case TabState.ALL: |
Isaac Katzenelson | 683b57e | 2011-07-20 17:06:11 -0700 | [diff] [blame] | 1091 | contactsFilterMenu.setVisible(true); |
Maurice Chu | 2fc4de3 | 2012-04-23 17:05:45 -0700 | [diff] [blame] | 1092 | clearFrequentsMenu.setVisible(false); |
Katherine Kuan | 8268bbe | 2011-06-10 17:48:21 -0700 | [diff] [blame] | 1093 | break; |
Katherine Kuan | 8268bbe | 2011-06-10 17:48:21 -0700 | [diff] [blame] | 1094 | } |
Brian Attwell | 56bcc2f | 2015-02-12 23:45:27 +0000 | [diff] [blame] | 1095 | helpMenu.setVisible(HelpUtils.isHelpAndFeedbackAvailable()); |
Katherine Kuan | 8268bbe | 2011-06-10 17:48:21 -0700 | [diff] [blame] | 1096 | } |
Brian Attwell | 20510ec | 2015-02-27 16:10:45 -0800 | [diff] [blame] | 1097 | final boolean showMiscOptions = !isSearchOrSelectionMode; |
Makoto Onuki | af0a9d4 | 2011-08-09 17:58:41 -0700 | [diff] [blame] | 1098 | makeMenuItemVisible(menu, R.id.menu_search, showMiscOptions); |
| 1099 | makeMenuItemVisible(menu, R.id.menu_import_export, showMiscOptions); |
| 1100 | makeMenuItemVisible(menu, R.id.menu_accounts, showMiscOptions); |
Wenyi Wang | 5fe9557 | 2016-02-10 16:20:40 -0800 | [diff] [blame^] | 1101 | // TODO make menu_blocked_numbers visible by using UI in framework |
| 1102 | makeMenuItemVisible(menu, R.id.menu_blocked_numbers, false); |
Makoto Onuki | af0a9d4 | 2011-08-09 17:58:41 -0700 | [diff] [blame] | 1103 | makeMenuItemVisible(menu, R.id.menu_settings, |
| 1104 | showMiscOptions && !ContactsPreferenceActivity.isEmpty(this)); |
Dmitri Plotnikov | a053d61 | 2010-11-23 13:31:10 -0800 | [diff] [blame] | 1105 | |
Brian Attwell | 20510ec | 2015-02-27 16:10:45 -0800 | [diff] [blame] | 1106 | final boolean showSelectedContactOptions = mActionBarAdapter.isSelectionMode() |
| 1107 | && mAllFragment.getSelectedContactIds().size() != 0; |
| 1108 | makeMenuItemVisible(menu, R.id.menu_share, showSelectedContactOptions); |
| 1109 | makeMenuItemVisible(menu, R.id.menu_delete, showSelectedContactOptions); |
Wenyi Wang | 687d218 | 2015-10-28 17:03:18 -0700 | [diff] [blame] | 1110 | final boolean showLinkContactsOptions = mActionBarAdapter.isSelectionMode() |
| 1111 | && mAllFragment.getSelectedContactIds().size() > 1; |
| 1112 | makeMenuItemVisible(menu, R.id.menu_join, showLinkContactsOptions); |
Brian Attwell | 20510ec | 2015-02-27 16:10:45 -0800 | [diff] [blame] | 1113 | |
Makoto Onuki | 9ae6041 | 2012-07-19 15:56:41 -0700 | [diff] [blame] | 1114 | // Debug options need to be visible even in search mode. |
Wenyi Wang | 2f09e60 | 2015-10-28 11:34:23 -0700 | [diff] [blame] | 1115 | makeMenuItemVisible(menu, R.id.export_database, mEnableDebugMenuOptions && |
| 1116 | hasExportIntentHandler()); |
Makoto Onuki | 9ae6041 | 2012-07-19 15:56:41 -0700 | [diff] [blame] | 1117 | |
Dmitri Plotnikov | 0cd0130 | 2010-12-17 18:41:57 -0800 | [diff] [blame] | 1118 | return true; |
| 1119 | } |
| 1120 | |
Wenyi Wang | 2f09e60 | 2015-10-28 11:34:23 -0700 | [diff] [blame] | 1121 | private boolean hasExportIntentHandler() { |
| 1122 | final Intent intent = new Intent(); |
| 1123 | intent.setAction("com.android.providers.contacts.DUMP_DATABASE"); |
| 1124 | final List<ResolveInfo> receivers = getPackageManager().queryIntentActivities(intent, |
| 1125 | PackageManager.MATCH_DEFAULT_ONLY); |
| 1126 | return receivers != null && receivers.size() > 0; |
| 1127 | } |
| 1128 | |
Maurice Chu | 2fc4de3 | 2012-04-23 17:05:45 -0700 | [diff] [blame] | 1129 | /** |
| 1130 | * Returns whether there are any frequently contacted people being displayed |
| 1131 | * @return |
| 1132 | */ |
| 1133 | private boolean hasFrequents() { |
Brian Attwell | 2c1bfd0 | 2014-06-04 18:18:35 -0700 | [diff] [blame] | 1134 | return mFavoritesFragment.hasFrequents(); |
Maurice Chu | 2fc4de3 | 2012-04-23 17:05:45 -0700 | [diff] [blame] | 1135 | } |
| 1136 | |
Makoto Onuki | af0a9d4 | 2011-08-09 17:58:41 -0700 | [diff] [blame] | 1137 | private void makeMenuItemVisible(Menu menu, int itemId, boolean visible) { |
Brian Attwell | d3946ca | 2015-03-03 11:13:49 -0800 | [diff] [blame] | 1138 | final MenuItem item = menu.findItem(itemId); |
Makoto Onuki | af0a9d4 | 2011-08-09 17:58:41 -0700 | [diff] [blame] | 1139 | if (item != null) { |
| 1140 | item.setVisible(visible); |
| 1141 | } |
| 1142 | } |
| 1143 | |
Brian Attwell | d3946ca | 2015-03-03 11:13:49 -0800 | [diff] [blame] | 1144 | private void makeMenuItemEnabled(Menu menu, int itemId, boolean visible) { |
| 1145 | final MenuItem item = menu.findItem(itemId); |
| 1146 | if (item != null) { |
| 1147 | item.setEnabled(visible); |
| 1148 | } |
| 1149 | } |
| 1150 | |
The Android Open Source Project | 7aa0e4c | 2009-03-03 19:32:21 -0800 | [diff] [blame] | 1151 | @Override |
| 1152 | public boolean onOptionsItemSelected(MenuItem item) { |
Paul Sliwowski | 32791d4 | 2013-09-11 15:25:43 -0700 | [diff] [blame] | 1153 | if (mDisableOptionItemSelected) { |
| 1154 | return false; |
| 1155 | } |
| 1156 | |
The Android Open Source Project | 7aa0e4c | 2009-03-03 19:32:21 -0800 | [diff] [blame] | 1157 | switch (item.getItemId()) { |
Makoto Onuki | e0c66af | 2011-07-13 14:24:03 -0700 | [diff] [blame] | 1158 | case android.R.id.home: { |
| 1159 | // The home icon on the action bar is pressed |
| 1160 | if (mActionBarAdapter.isUpShowing()) { |
| 1161 | // "UP" icon press -- should be treated as "back". |
| 1162 | onBackPressed(); |
| 1163 | } |
| 1164 | return true; |
| 1165 | } |
Dmitri Plotnikov | c85ad18 | 2010-09-17 18:12:49 -0700 | [diff] [blame] | 1166 | case R.id.menu_settings: { |
Wenyi Wang | 86f2a86 | 2015-12-30 16:54:51 -0800 | [diff] [blame] | 1167 | startActivity(new Intent(this, ContactsPreferenceActivity.class)); |
The Android Open Source Project | 7aa0e4c | 2009-03-03 19:32:21 -0800 | [diff] [blame] | 1168 | return true; |
Jeff Sharkey | d9798ae | 2009-08-24 20:46:23 -0700 | [diff] [blame] | 1169 | } |
Katherine Kuan | b5760b9 | 2011-06-01 16:19:40 -0700 | [diff] [blame] | 1170 | case R.id.menu_contacts_filter: { |
Josh Gargus | b655345 | 2012-01-04 14:50:56 -0800 | [diff] [blame] | 1171 | AccountFilterUtil.startAccountFilterActivityForResult( |
| 1172 | this, SUBACTIVITY_ACCOUNT_FILTER, |
| 1173 | mContactListFilterController.getFilter()); |
Katherine Kuan | b5760b9 | 2011-06-01 16:19:40 -0700 | [diff] [blame] | 1174 | return true; |
| 1175 | } |
Jeff Sharkey | d9798ae | 2009-08-24 20:46:23 -0700 | [diff] [blame] | 1176 | case R.id.menu_search: { |
Dmitri Plotnikov | 8e86b75 | 2010-02-22 17:47:57 -0800 | [diff] [blame] | 1177 | onSearchRequested(); |
The Android Open Source Project | 7aa0e4c | 2009-03-03 19:32:21 -0800 | [diff] [blame] | 1178 | return true; |
Jeff Sharkey | d9798ae | 2009-08-24 20:46:23 -0700 | [diff] [blame] | 1179 | } |
Brian Attwell | 20510ec | 2015-02-27 16:10:45 -0800 | [diff] [blame] | 1180 | case R.id.menu_share: |
| 1181 | shareSelectedContacts(); |
| 1182 | return true; |
Brian Attwell | d3946ca | 2015-03-03 11:13:49 -0800 | [diff] [blame] | 1183 | case R.id.menu_join: |
| 1184 | joinSelectedContacts(); |
| 1185 | return true; |
Brian Attwell | d2962a3 | 2015-03-02 14:48:50 -0800 | [diff] [blame] | 1186 | case R.id.menu_delete: |
| 1187 | deleteSelectedContacts(); |
| 1188 | return true; |
Jeff Sharkey | 49d17b3 | 2009-09-07 02:14:21 -0700 | [diff] [blame] | 1189 | case R.id.menu_import_export: { |
Wenyi Wang | 9379f4a | 2015-09-25 10:30:19 -0700 | [diff] [blame] | 1190 | showImportExportDialogFragment(); |
Jeff Sharkey | d9798ae | 2009-08-24 20:46:23 -0700 | [diff] [blame] | 1191 | return true; |
| 1192 | } |
Maurice Chu | 2fc4de3 | 2012-04-23 17:05:45 -0700 | [diff] [blame] | 1193 | case R.id.menu_clear_frequents: { |
| 1194 | ClearFrequentsDialog.show(getFragmentManager()); |
| 1195 | return true; |
| 1196 | } |
Brian Attwell | 56bcc2f | 2015-02-12 23:45:27 +0000 | [diff] [blame] | 1197 | case R.id.menu_help: |
| 1198 | HelpUtils.launchHelpAndFeedbackForMainScreen(this); |
| 1199 | return true; |
Jeff Sharkey | d9798ae | 2009-08-24 20:46:23 -0700 | [diff] [blame] | 1200 | case R.id.menu_accounts: { |
| 1201 | final Intent intent = new Intent(Settings.ACTION_SYNC_SETTINGS); |
Dmitri Plotnikov | fe42e55 | 2010-05-14 14:50:32 -0700 | [diff] [blame] | 1202 | intent.putExtra(Settings.EXTRA_AUTHORITIES, new String[] { |
Jeff Sharkey | d9798ae | 2009-08-24 20:46:23 -0700 | [diff] [blame] | 1203 | ContactsContract.AUTHORITY |
| 1204 | }); |
Dmitri Plotnikov | 1fbcbd1 | 2011-01-16 18:09:09 -0800 | [diff] [blame] | 1205 | intent.setFlags(Intent.FLAG_ACTIVITY_CLEAR_WHEN_TASK_RESET); |
Brian Attwell | c6100ff | 2015-02-19 21:35:36 -0800 | [diff] [blame] | 1206 | ImplicitIntentsUtil.startActivityInAppIfPossible(this, intent); |
Jeff Sharkey | d9798ae | 2009-08-24 20:46:23 -0700 | [diff] [blame] | 1207 | return true; |
| 1208 | } |
Wenyi Wang | 1fc3ef4 | 2016-01-14 18:21:40 -0800 | [diff] [blame] | 1209 | case R.id.menu_blocked_numbers: { |
Wenyi Wang | 1fc3ef4 | 2016-01-14 18:21:40 -0800 | [diff] [blame] | 1210 | return true; |
| 1211 | } |
Makoto Onuki | 9ae6041 | 2012-07-19 15:56:41 -0700 | [diff] [blame] | 1212 | case R.id.export_database: { |
| 1213 | final Intent intent = new Intent("com.android.providers.contacts.DUMP_DATABASE"); |
| 1214 | intent.setFlags(Intent.FLAG_ACTIVITY_CLEAR_WHEN_TASK_RESET); |
Brian Attwell | c6100ff | 2015-02-19 21:35:36 -0800 | [diff] [blame] | 1215 | ImplicitIntentsUtil.startActivityOutsideApp(this, intent); |
Makoto Onuki | 9ae6041 | 2012-07-19 15:56:41 -0700 | [diff] [blame] | 1216 | return true; |
| 1217 | } |
The Android Open Source Project | 7aa0e4c | 2009-03-03 19:32:21 -0800 | [diff] [blame] | 1218 | } |
| 1219 | return false; |
| 1220 | } |
| 1221 | |
Wenyi Wang | 9379f4a | 2015-09-25 10:30:19 -0700 | [diff] [blame] | 1222 | private void showImportExportDialogFragment(){ |
| 1223 | final boolean isOnFavoriteTab = mTabPagerAdapter.mCurrentPrimaryItem == mFavoritesFragment; |
| 1224 | if (isOnFavoriteTab) { |
| 1225 | ImportExportDialogFragment.show(getFragmentManager(), areContactsAvailable(), |
| 1226 | PeopleActivity.class, ImportExportDialogFragment.EXPORT_MODE_FAVORITES); |
| 1227 | } else { |
| 1228 | ImportExportDialogFragment.show(getFragmentManager(), areContactsAvailable(), |
| 1229 | PeopleActivity.class, ImportExportDialogFragment.EXPORT_MODE_ALL_CONTACTS); |
| 1230 | } |
| 1231 | } |
| 1232 | |
Dmitri Plotnikov | 8e86b75 | 2010-02-22 17:47:57 -0800 | [diff] [blame] | 1233 | @Override |
Makoto Onuki | 53b427b | 2011-07-17 11:42:32 -0700 | [diff] [blame] | 1234 | public boolean onSearchRequested() { // Search key pressed. |
Brian Attwell | 20510ec | 2015-02-27 16:10:45 -0800 | [diff] [blame] | 1235 | if (!mActionBarAdapter.isSelectionMode()) { |
| 1236 | mActionBarAdapter.setSearchMode(true); |
| 1237 | } |
Makoto Onuki | 53b427b | 2011-07-17 11:42:32 -0700 | [diff] [blame] | 1238 | return true; |
Dmitri Plotnikov | db3d143 | 2010-02-09 17:45:47 -0800 | [diff] [blame] | 1239 | } |
| 1240 | |
Brian Attwell | 20510ec | 2015-02-27 16:10:45 -0800 | [diff] [blame] | 1241 | /** |
| 1242 | * Share all contacts that are currently selected in mAllFragment. This method is pretty |
| 1243 | * inefficient for handling large numbers of contacts. I don't expect this to be a problem. |
| 1244 | */ |
| 1245 | private void shareSelectedContacts() { |
| 1246 | final StringBuilder uriListBuilder = new StringBuilder(); |
Brian Attwell | 20510ec | 2015-02-27 16:10:45 -0800 | [diff] [blame] | 1247 | for (Long contactId : mAllFragment.getSelectedContactIds()) { |
Brian Attwell | 20510ec | 2015-02-27 16:10:45 -0800 | [diff] [blame] | 1248 | final Uri contactUri = ContentUris.withAppendedId(Contacts.CONTENT_URI, contactId); |
| 1249 | final Uri lookupUri = Contacts.getLookupUri(getContentResolver(), contactUri); |
Jay Shrauner | 5b69125 | 2015-08-24 16:26:39 -0700 | [diff] [blame] | 1250 | if (lookupUri == null) { |
| 1251 | continue; |
| 1252 | } |
| 1253 | final List<String> pathSegments = lookupUri.getPathSegments(); |
| 1254 | if (pathSegments.size() < 2) { |
| 1255 | continue; |
| 1256 | } |
| 1257 | final String lookupKey = pathSegments.get(pathSegments.size() - 2); |
| 1258 | if (uriListBuilder.length() > 0) { |
| 1259 | uriListBuilder.append(':'); |
| 1260 | } |
| 1261 | uriListBuilder.append(Uri.encode(lookupKey)); |
| 1262 | } |
| 1263 | if (uriListBuilder.length() == 0) { |
| 1264 | return; |
Brian Attwell | 20510ec | 2015-02-27 16:10:45 -0800 | [diff] [blame] | 1265 | } |
| 1266 | final Uri uri = Uri.withAppendedPath( |
| 1267 | Contacts.CONTENT_MULTI_VCARD_URI, |
| 1268 | Uri.encode(uriListBuilder.toString())); |
| 1269 | final Intent intent = new Intent(Intent.ACTION_SEND); |
| 1270 | intent.setType(Contacts.CONTENT_VCARD_TYPE); |
| 1271 | intent.putExtra(Intent.EXTRA_STREAM, uri); |
| 1272 | ImplicitIntentsUtil.startActivityOutsideApp(this, intent); |
| 1273 | } |
Walter Jang | a84fe61 | 2016-01-13 16:49:04 -0800 | [diff] [blame] | 1274 | |
Brian Attwell | d3946ca | 2015-03-03 11:13:49 -0800 | [diff] [blame] | 1275 | private void joinSelectedContacts() { |
| 1276 | JoinContactsDialogFragment.start(this, mAllFragment.getSelectedContactIds()); |
| 1277 | } |
| 1278 | |
| 1279 | @Override |
| 1280 | public void onContactsJoined() { |
Brian Attwell | 1154bba | 2015-03-03 14:59:05 -0800 | [diff] [blame] | 1281 | mActionBarAdapter.setSelectionMode(false); |
Brian Attwell | d3946ca | 2015-03-03 11:13:49 -0800 | [diff] [blame] | 1282 | } |
| 1283 | |
Brian Attwell | d2962a3 | 2015-03-02 14:48:50 -0800 | [diff] [blame] | 1284 | private void deleteSelectedContacts() { |
| 1285 | ContactMultiDeletionInteraction.start(PeopleActivity.this, |
| 1286 | mAllFragment.getSelectedContactIds()); |
| 1287 | } |
| 1288 | |
| 1289 | @Override |
| 1290 | public void onDeletionFinished() { |
Brian Attwell | 1154bba | 2015-03-03 14:59:05 -0800 | [diff] [blame] | 1291 | mActionBarAdapter.setSelectionMode(false); |
Brian Attwell | d2962a3 | 2015-03-02 14:48:50 -0800 | [diff] [blame] | 1292 | } |
| 1293 | |
Jeff Sharkey | 49d17b3 | 2009-09-07 02:14:21 -0700 | [diff] [blame] | 1294 | @Override |
Dmitri Plotnikov | d3758b0 | 2010-06-17 11:34:59 -0700 | [diff] [blame] | 1295 | protected void onActivityResult(int requestCode, int resultCode, Intent data) { |
| 1296 | switch (requestCode) { |
Daisuke Miyakawa | 34b901c | 2011-10-18 14:33:41 -0700 | [diff] [blame] | 1297 | case SUBACTIVITY_ACCOUNT_FILTER: { |
| 1298 | AccountFilterUtil.handleAccountFilterResult( |
| 1299 | mContactListFilterController, resultCode, data); |
Katherine Kuan | 495db43 | 2011-07-06 18:58:46 -0700 | [diff] [blame] | 1300 | break; |
| 1301 | } |
Dmitri Plotnikov | d3758b0 | 2010-06-17 11:34:59 -0700 | [diff] [blame] | 1302 | |
Daniel Lehmann | 7aa9b28 | 2010-07-27 20:33:27 -0700 | [diff] [blame] | 1303 | // TODO: Using the new startActivityWithResultFromFragment API this should not be needed |
| 1304 | // anymore |
Dmitri Plotnikov | e8a9517 | 2010-06-23 16:18:10 -0700 | [diff] [blame] | 1305 | case ContactEntryListFragment.ACTIVITY_REQUEST_CODE_PICKER: |
Dmitri Plotnikov | d3758b0 | 2010-06-17 11:34:59 -0700 | [diff] [blame] | 1306 | if (resultCode == RESULT_OK) { |
Daisuke Miyakawa | 95c5c2a | 2011-07-08 10:33:21 -0700 | [diff] [blame] | 1307 | mAllFragment.onPickerResult(data); |
Dmitri Plotnikov | d3758b0 | 2010-06-17 11:34:59 -0700 | [diff] [blame] | 1308 | } |
| 1309 | |
| 1310 | // TODO fix or remove multipicker code |
| 1311 | // else if (resultCode == RESULT_CANCELED && mMode == MODE_PICK_MULTIPLE_PHONES) { |
Dmitri Plotnikov | 1ce1e7c | 2010-05-13 16:41:00 -0700 | [diff] [blame] | 1312 | // // Finish the activity if the sub activity was canceled as back key is used |
| 1313 | // // to confirm user selection in MODE_PICK_MULTIPLE_PHONES. |
| 1314 | // finish(); |
| 1315 | // } |
| 1316 | // break; |
Dmitri Plotnikov | d3758b0 | 2010-06-17 11:34:59 -0700 | [diff] [blame] | 1317 | } |
| 1318 | } |
The Android Open Source Project | 7aa0e4c | 2009-03-03 19:32:21 -0800 | [diff] [blame] | 1319 | |
| 1320 | @Override |
The Android Open Source Project | 7aa0e4c | 2009-03-03 19:32:21 -0800 | [diff] [blame] | 1321 | public boolean onKeyDown(int keyCode, KeyEvent event) { |
Dmitri Plotnikov | 1ce1e7c | 2010-05-13 16:41:00 -0700 | [diff] [blame] | 1322 | // TODO move to the fragment |
Dmitri Plotnikov | db3d143 | 2010-02-09 17:45:47 -0800 | [diff] [blame] | 1323 | |
Brian Attwell | 20510ec | 2015-02-27 16:10:45 -0800 | [diff] [blame] | 1324 | // Bring up the search UI if the user starts typing |
| 1325 | final int unicodeChar = event.getUnicodeChar(); |
| 1326 | if ((unicodeChar != 0) |
| 1327 | // If COMBINING_ACCENT is set, it's not a unicode character. |
| 1328 | && ((unicodeChar & KeyCharacterMap.COMBINING_ACCENT) == 0) |
| 1329 | && !Character.isWhitespace(unicodeChar)) { |
| 1330 | if (mActionBarAdapter.isSelectionMode()) { |
| 1331 | // Ignore keyboard input when in selection mode. |
| 1332 | return true; |
The Android Open Source Project | 7aa0e4c | 2009-03-03 19:32:21 -0800 | [diff] [blame] | 1333 | } |
Brian Attwell | 20510ec | 2015-02-27 16:10:45 -0800 | [diff] [blame] | 1334 | String query = new String(new int[]{unicodeChar}, 0, 1); |
| 1335 | if (!mActionBarAdapter.isSearchMode()) { |
| 1336 | mActionBarAdapter.setSearchMode(true); |
| 1337 | mActionBarAdapter.setQueryString(query); |
| 1338 | return true; |
Daniel Lehmann | 7bb2add | 2010-07-14 21:15:17 -0700 | [diff] [blame] | 1339 | } |
The Android Open Source Project | 7aa0e4c | 2009-03-03 19:32:21 -0800 | [diff] [blame] | 1340 | } |
| 1341 | |
| 1342 | return super.onKeyDown(keyCode, event); |
| 1343 | } |
| 1344 | |
Dmitri Plotnikov | ab4d29f | 2010-10-28 12:43:54 -0700 | [diff] [blame] | 1345 | @Override |
| 1346 | public void onBackPressed() { |
Jay Shrauner | 7712aef | 2015-09-25 14:14:28 -0700 | [diff] [blame] | 1347 | if (!isSafeToCommitTransactions()) { |
Jay Shrauner | c3fdc8f | 2015-09-16 10:29:52 -0700 | [diff] [blame] | 1348 | return; |
| 1349 | } |
| 1350 | |
Brian Attwell | 20510ec | 2015-02-27 16:10:45 -0800 | [diff] [blame] | 1351 | if (mActionBarAdapter.isSelectionMode()) { |
| 1352 | mActionBarAdapter.setSelectionMode(false); |
| 1353 | mAllFragment.displayCheckBoxes(false); |
| 1354 | } else if (mActionBarAdapter.isSearchMode()) { |
Dmitri Plotnikov | ab4d29f | 2010-10-28 12:43:54 -0700 | [diff] [blame] | 1355 | mActionBarAdapter.setSearchMode(false); |
Walter Jang | a84fe61 | 2016-01-13 16:49:04 -0800 | [diff] [blame] | 1356 | |
| 1357 | if (mAllFragment.wasSearchResultClicked()) { |
| 1358 | mAllFragment.resetSearchResultClicked(); |
| 1359 | } else { |
| 1360 | Logger.getInstance().logScreenView( |
| 1361 | ScreenEvent.SEARCH_EXIT, this, ScreenEvent.TAG_SEARCH_EXIT); |
| 1362 | Logger.getInstance().logSearchEventImpl(mAllFragment.createSearchState()); |
| 1363 | } |
Dmitri Plotnikov | ab4d29f | 2010-10-28 12:43:54 -0700 | [diff] [blame] | 1364 | } else { |
| 1365 | super.onBackPressed(); |
| 1366 | } |
| 1367 | } |
| 1368 | |
Dmitri Plotnikov | 08e1c4e | 2010-07-02 17:57:51 -0700 | [diff] [blame] | 1369 | @Override |
| 1370 | protected void onSaveInstanceState(Bundle outState) { |
| 1371 | super.onSaveInstanceState(outState); |
Makoto Onuki | 4d788fc | 2011-07-12 10:00:10 -0700 | [diff] [blame] | 1372 | mActionBarAdapter.onSaveInstanceState(outState); |
Makoto Onuki | 4d788fc | 2011-07-12 10:00:10 -0700 | [diff] [blame] | 1373 | |
| 1374 | // Clear the listener to make sure we don't get callbacks after onSaveInstanceState, |
| 1375 | // in order to avoid doing fragment transactions after it. |
| 1376 | // TODO Figure out a better way to deal with the issue. |
Paul Sliwowski | 32791d4 | 2013-09-11 15:25:43 -0700 | [diff] [blame] | 1377 | mDisableOptionItemSelected = true; |
Makoto Onuki | 4d788fc | 2011-07-12 10:00:10 -0700 | [diff] [blame] | 1378 | mActionBarAdapter.setListener(null); |
Makoto Onuki | 2e17730 | 2011-08-15 14:06:55 -0700 | [diff] [blame] | 1379 | if (mTabPager != null) { |
| 1380 | mTabPager.setOnPageChangeListener(null); |
| 1381 | } |
Dmitri Plotnikov | 08e1c4e | 2010-07-02 17:57:51 -0700 | [diff] [blame] | 1382 | } |
| 1383 | |
Dmitri Plotnikov | fa49a66 | 2011-01-13 11:04:56 -0800 | [diff] [blame] | 1384 | @Override |
Daniel Lehmann | 09d66a3 | 2012-04-13 19:14:39 -0700 | [diff] [blame] | 1385 | protected void onRestoreInstanceState(Bundle savedInstanceState) { |
| 1386 | super.onRestoreInstanceState(savedInstanceState); |
| 1387 | // In our own lifecycle, the focus is saved and restore but later taken away by the |
| 1388 | // ViewPager. As a hack, we force focus on the SearchView if we know that we are searching. |
| 1389 | // This fixes the keyboard going away on screen rotation |
| 1390 | if (mActionBarAdapter.isSearchMode()) { |
| 1391 | mActionBarAdapter.setFocusOnSearchView(); |
| 1392 | } |
| 1393 | } |
| 1394 | |
| 1395 | @Override |
Daniel Lehmann | 3391dbe | 2010-07-12 09:50:22 -0700 | [diff] [blame] | 1396 | public DialogManager getDialogManager() { |
| 1397 | return mDialogManager; |
| 1398 | } |
Dmitri Plotnikov | ab75f82 | 2011-01-10 11:21:59 -0800 | [diff] [blame] | 1399 | |
Paul Soulos | 2b9563d | 2014-05-27 16:21:23 -0700 | [diff] [blame] | 1400 | @Override |
| 1401 | public void onClick(View view) { |
| 1402 | switch (view.getId()) { |
| 1403 | case R.id.floating_action_button: |
| 1404 | Intent intent = new Intent(Intent.ACTION_INSERT, Contacts.CONTENT_URI); |
| 1405 | Bundle extras = getIntent().getExtras(); |
| 1406 | if (extras != null) { |
| 1407 | intent.putExtras(extras); |
| 1408 | } |
Jay Shrauner | d391f84 | 2014-11-26 11:14:24 -0800 | [diff] [blame] | 1409 | try { |
Brian Attwell | c6100ff | 2015-02-19 21:35:36 -0800 | [diff] [blame] | 1410 | ImplicitIntentsUtil.startActivityInApp(PeopleActivity.this, intent); |
Jay Shrauner | d391f84 | 2014-11-26 11:14:24 -0800 | [diff] [blame] | 1411 | } catch (ActivityNotFoundException ex) { |
| 1412 | Toast.makeText(PeopleActivity.this, R.string.missing_app, |
| 1413 | Toast.LENGTH_SHORT).show(); |
| 1414 | } |
Paul Soulos | 2b9563d | 2014-05-27 16:21:23 -0700 | [diff] [blame] | 1415 | break; |
| 1416 | default: |
| 1417 | Log.wtf(TAG, "Unexpected onClick event from " + view); |
| 1418 | } |
| 1419 | } |
Brian Attwell | 962677f | 2014-09-26 12:29:07 -0700 | [diff] [blame] | 1420 | |
| 1421 | /** |
| 1422 | * Returns the tab position adjusted for the text direction. |
| 1423 | */ |
| 1424 | private int getTabPositionForTextDirection(int position) { |
| 1425 | if (isRTL()) { |
| 1426 | return TabState.COUNT - 1 - position; |
| 1427 | } |
| 1428 | return position; |
| 1429 | } |
The Android Open Source Project | 7aa0e4c | 2009-03-03 19:32:21 -0800 | [diff] [blame] | 1430 | } |