DialtactsActivity.java revision 9c1e0653addc1fff03601289a9f9a57b1daeaf57
1/* 2 * Copyright (C) 2008 The Android Open Source Project 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 17package com.android.dialer; 18 19import android.app.ActionBar; 20import android.app.ActionBar.LayoutParams; 21import android.app.ActionBar.Tab; 22import android.app.ActionBar.TabListener; 23import android.app.Activity; 24import android.app.backup.BackupManager; 25import android.app.Fragment; 26import android.app.FragmentManager; 27import android.app.FragmentTransaction; 28import android.content.ActivityNotFoundException; 29import android.content.Context; 30import android.content.Intent; 31import android.content.SharedPreferences; 32import android.net.Uri; 33import android.os.Bundle; 34import android.os.RemoteException; 35import android.os.ServiceManager; 36import android.preference.PreferenceManager; 37import android.provider.CallLog.Calls; 38import android.provider.ContactsContract.Contacts; 39import android.provider.ContactsContract.Intents.UI; 40import android.support.v13.app.FragmentPagerAdapter; 41import android.support.v4.view.ViewPager; 42import android.support.v4.view.ViewPager.OnPageChangeListener; 43import android.text.TextUtils; 44import android.util.DisplayMetrics; 45import android.util.Log; 46import android.view.Menu; 47import android.view.MenuInflater; 48import android.view.MenuItem; 49import android.view.MenuItem.OnMenuItemClickListener; 50import android.view.View; 51import android.view.View.OnClickListener; 52import android.view.View.OnFocusChangeListener; 53import android.view.ViewConfiguration; 54import android.view.ViewGroup; 55import android.view.inputmethod.InputMethodManager; 56import android.widget.PopupMenu; 57import android.widget.SearchView; 58import android.widget.SearchView.OnCloseListener; 59import android.widget.SearchView.OnQueryTextListener; 60import android.widget.Toast; 61 62import com.android.contacts.common.CallUtil; 63import com.android.contacts.common.activity.TransactionSafeActivity; 64import com.android.contacts.common.list.ContactListFilterController; 65import com.android.contacts.common.list.ContactListFilterController.ContactListFilterListener; 66import com.android.contacts.common.list.ContactListItemView; 67import com.android.contacts.common.list.OnPhoneNumberPickerActionListener; 68import com.android.contacts.common.list.PhoneNumberPickerFragment; 69import com.android.contacts.common.util.AccountFilterUtil; 70import com.android.dialer.calllog.CallLogFragment; 71import com.android.dialer.dialpad.DialpadFragment; 72import com.android.dialer.interactions.PhoneNumberInteraction; 73import com.android.dialer.list.PhoneFavoriteFragment; 74import com.android.dialer.util.OrientationUtil; 75import com.android.internal.telephony.ITelephony; 76 77/** 78 * The dialer activity that has one tab with the virtual 12key 79 * dialer, a tab with recent calls in it, a tab with the contacts and 80 * a tab with the favorite. This is the container and the tabs are 81 * embedded using intents. 82 * The dialer tab's title is 'phone', a more common name (see strings.xml). 83 */ 84public class DialtactsActivity extends TransactionSafeActivity implements View.OnClickListener { 85 private static final String TAG = "DialtactsActivity"; 86 87 public static final boolean DEBUG = false; 88 89 /** Used to open Call Setting */ 90 private static final String PHONE_PACKAGE = "com.android.phone"; 91 private static final String CALL_SETTINGS_CLASS_NAME = 92 "com.android.phone.CallFeaturesSetting"; 93 94 /** @see #getCallOrigin() */ 95 private static final String CALL_ORIGIN_DIALTACTS = 96 "com.android.dialer.DialtactsActivity"; 97 98 /** 99 * Just for backward compatibility. Should behave as same as {@link Intent#ACTION_DIAL}. 100 */ 101 private static final String ACTION_TOUCH_DIALER = "com.android.phone.action.TOUCH_DIALER"; 102 103 /** Used both by {@link ActionBar} and {@link ViewPagerAdapter} */ 104 private static final int TAB_INDEX_DIALER = 0; 105 private static final int TAB_INDEX_CALL_LOG = 1; 106 private static final int TAB_INDEX_FAVORITES = 2; 107 108 private static final int TAB_INDEX_COUNT = 3; 109 110 private SharedPreferences mPrefs; 111 112 public static final String SHARED_PREFS_NAME = "com.android.dialer_preferences"; 113 114 /** Last manually selected tab index */ 115 private static final String PREF_LAST_MANUALLY_SELECTED_TAB = 116 "DialtactsActivity_last_manually_selected_tab"; 117 private static final int PREF_LAST_MANUALLY_SELECTED_TAB_DEFAULT = TAB_INDEX_DIALER; 118 119 private static final int SUBACTIVITY_ACCOUNT_FILTER = 1; 120 121 public class ViewPagerAdapter extends FragmentPagerAdapter { 122 public ViewPagerAdapter(FragmentManager fm) { 123 super(fm); 124 } 125 126 @Override 127 public Fragment getItem(int position) { 128 switch (position) { 129 case TAB_INDEX_DIALER: 130 return new DialpadFragment(); 131 case TAB_INDEX_CALL_LOG: 132 return new CallLogFragment(); 133 case TAB_INDEX_FAVORITES: 134 return new PhoneFavoriteFragment(); 135 } 136 throw new IllegalStateException("No fragment at position " + position); 137 } 138 139 @Override 140 public void setPrimaryItem(ViewGroup container, int position, Object object) { 141 // The parent's setPrimaryItem() also calls setMenuVisibility(), so we want to know 142 // when it happens. 143 if (DEBUG) { 144 Log.d(TAG, "FragmentPagerAdapter#setPrimaryItem(), position: " + position); 145 } 146 super.setPrimaryItem(container, position, object); 147 } 148 149 @Override 150 public int getCount() { 151 return TAB_INDEX_COUNT; 152 } 153 } 154 155 /** 156 * True when the app detects user's drag event. This variable should not become true when 157 * mUserTabClick is true. 158 * 159 * During user's drag or tab click, we shouldn't show fake buttons but just show real 160 * ActionBar at the bottom of the screen, for transition animation. 161 */ 162 boolean mDuringSwipe = false; 163 /** 164 * True when the app detects user's tab click (at the top of the screen). This variable should 165 * not become true when mDuringSwipe is true. 166 * 167 * During user's drag or tab click, we shouldn't show fake buttons but just show real 168 * ActionBar at the bottom of the screen, for transition animation. 169 */ 170 boolean mUserTabClick = false; 171 172 private class PageChangeListener implements OnPageChangeListener { 173 private int mCurrentPosition = -1; 174 /** 175 * Used during page migration, to remember the next position {@link #onPageSelected(int)} 176 * specified. 177 */ 178 private int mNextPosition = -1; 179 180 @Override 181 public void onPageScrolled( 182 int position, float positionOffset, int positionOffsetPixels) { 183 } 184 185 @Override 186 public void onPageSelected(int position) { 187 if (DEBUG) Log.d(TAG, "onPageSelected: position: " + position); 188 final ActionBar actionBar = getActionBar(); 189 if (mDialpadFragment != null) { 190 if (mDuringSwipe && position == TAB_INDEX_DIALER) { 191 // TODO: Figure out if we want this or not. Right now 192 // - with this call, both fake buttons and real action bar overlap 193 // - without this call, there's tiny flicker happening to search/menu buttons. 194 // If we can reduce the flicker without this call, it would be much better. 195 // updateFakeMenuButtonsVisibility(true); 196 } 197 } 198 199 if (mCurrentPosition == position) { 200 Log.w(TAG, "Previous position and next position became same (" + position + ")"); 201 } 202 203 actionBar.selectTab(actionBar.getTabAt(position)); 204 mNextPosition = position; 205 } 206 207 public void setCurrentPosition(int position) { 208 mCurrentPosition = position; 209 } 210 211 public int getCurrentPosition() { 212 return mCurrentPosition; 213 } 214 215 @Override 216 public void onPageScrollStateChanged(int state) { 217 switch (state) { 218 case ViewPager.SCROLL_STATE_IDLE: { 219 if (mNextPosition == -1) { 220 // This happens when the user drags the screen just after launching the 221 // application, and settle down the same screen without actually swiping it. 222 // At that moment mNextPosition is apparently -1 yet, and we expect it 223 // being updated by onPageSelected(), which is *not* called if the user 224 // settle down the exact same tab after the dragging. 225 if (DEBUG) { 226 Log.d(TAG, "Next position is not specified correctly. Use current tab (" 227 + mViewPager.getCurrentItem() + ")"); 228 } 229 mNextPosition = mViewPager.getCurrentItem(); 230 } 231 if (DEBUG) { 232 Log.d(TAG, "onPageScrollStateChanged() with SCROLL_STATE_IDLE. " 233 + "mCurrentPosition: " + mCurrentPosition 234 + ", mNextPosition: " + mNextPosition); 235 } 236 // Interpret IDLE as the end of migration (both swipe and tab click) 237 mDuringSwipe = false; 238 mUserTabClick = false; 239 240 updateFakeMenuButtonsVisibility(mNextPosition == TAB_INDEX_DIALER); 241 sendFragmentVisibilityChange(mCurrentPosition, false); 242 sendFragmentVisibilityChange(mNextPosition, true); 243 244 invalidateOptionsMenu(); 245 246 mCurrentPosition = mNextPosition; 247 break; 248 } 249 case ViewPager.SCROLL_STATE_DRAGGING: { 250 if (DEBUG) Log.d(TAG, "onPageScrollStateChanged() with SCROLL_STATE_DRAGGING"); 251 mDuringSwipe = true; 252 mUserTabClick = false; 253 break; 254 } 255 case ViewPager.SCROLL_STATE_SETTLING: { 256 if (DEBUG) Log.d(TAG, "onPageScrollStateChanged() with SCROLL_STATE_SETTLING"); 257 mDuringSwipe = true; 258 mUserTabClick = false; 259 break; 260 } 261 default: 262 break; 263 } 264 } 265 } 266 267 private String mFilterText; 268 269 /** Enables horizontal swipe between Fragments. */ 270 private ViewPager mViewPager; 271 private final PageChangeListener mPageChangeListener = new PageChangeListener(); 272 private DialpadFragment mDialpadFragment; 273 private CallLogFragment mCallLogFragment; 274 private PhoneFavoriteFragment mPhoneFavoriteFragment; 275 276 private View mSearchButton; 277 private View mMenuButton; 278 279 private final ContactListFilterListener mContactListFilterListener = 280 new ContactListFilterListener() { 281 @Override 282 public void onContactListFilterChanged() { 283 boolean doInvalidateOptionsMenu = false; 284 285 if (mPhoneFavoriteFragment != null && mPhoneFavoriteFragment.isAdded()) { 286 mPhoneFavoriteFragment.setFilter(mContactListFilterController.getFilter()); 287 doInvalidateOptionsMenu = true; 288 } 289 290 if (mSearchFragment != null && mSearchFragment.isAdded()) { 291 mSearchFragment.setFilter(mContactListFilterController.getFilter()); 292 doInvalidateOptionsMenu = true; 293 } else { 294 Log.w(TAG, "Search Fragment isn't available when ContactListFilter is changed"); 295 } 296 297 if (doInvalidateOptionsMenu) { 298 invalidateOptionsMenu(); 299 } 300 } 301 }; 302 303 private final TabListener mTabListener = new TabListener() { 304 @Override 305 public void onTabUnselected(Tab tab, FragmentTransaction ft) { 306 if (DEBUG) Log.d(TAG, "onTabUnselected(). tab: " + tab); 307 } 308 309 @Override 310 public void onTabSelected(Tab tab, FragmentTransaction ft) { 311 if (DEBUG) { 312 Log.d(TAG, "onTabSelected(). tab: " + tab + ", mDuringSwipe: " + mDuringSwipe); 313 } 314 // When the user swipes the screen horizontally, this method will be called after 315 // ViewPager.SCROLL_STATE_DRAGGING and ViewPager.SCROLL_STATE_SETTLING events, while 316 // when the user clicks a tab at the ActionBar at the top, this will be called before 317 // them. This logic interprets the order difference as a difference of the user action. 318 if (!mDuringSwipe) { 319 if (DEBUG) { 320 Log.d(TAG, "Tab select. from: " + mPageChangeListener.getCurrentPosition() 321 + ", to: " + tab.getPosition()); 322 } 323 if (mDialpadFragment != null) { 324 updateFakeMenuButtonsVisibility(tab.getPosition() == TAB_INDEX_DIALER); 325 } 326 mUserTabClick = true; 327 } 328 329 if (mViewPager.getCurrentItem() != tab.getPosition()) { 330 mViewPager.setCurrentItem(tab.getPosition(), true); 331 } 332 333 // During the call, we don't remember the tab position. 334 if (!DialpadFragment.phoneIsInUse()) { 335 // Remember this tab index. This function is also called, if the tab is set 336 // automatically in which case the setter (setCurrentTab) has to set this to its old 337 // value afterwards 338 mLastManuallySelectedFragment = tab.getPosition(); 339 } 340 } 341 342 @Override 343 public void onTabReselected(Tab tab, FragmentTransaction ft) { 344 if (DEBUG) Log.d(TAG, "onTabReselected"); 345 } 346 }; 347 348 /** 349 * Fragment for searching phone numbers. Unlike the other Fragments, this doesn't correspond 350 * to tab but is shown by a search action. 351 */ 352 private PhoneNumberPickerFragment mSearchFragment; 353 /** 354 * True when this Activity is in its search UI (with a {@link SearchView} and 355 * {@link PhoneNumberPickerFragment}). 356 */ 357 private boolean mInSearchUi; 358 private SearchView mSearchView; 359 360 private final OnClickListener mFilterOptionClickListener = new OnClickListener() { 361 @Override 362 public void onClick(View view) { 363 final PopupMenu popupMenu = new PopupMenu(DialtactsActivity.this, view); 364 final Menu menu = popupMenu.getMenu(); 365 popupMenu.inflate(R.menu.dialtacts_search_options); 366 final MenuItem filterOptionMenuItem = menu.findItem(R.id.filter_option); 367 filterOptionMenuItem.setOnMenuItemClickListener(mFilterOptionsMenuItemClickListener); 368 final MenuItem addContactOptionMenuItem = menu.findItem(R.id.add_contact); 369 addContactOptionMenuItem.setIntent( 370 new Intent(Intent.ACTION_INSERT, Contacts.CONTENT_URI)); 371 popupMenu.show(); 372 } 373 }; 374 375 /** 376 * The index of the Fragment (or, the tab) that has last been manually selected. 377 * This value does not keep track of programmatically set Tabs (e.g. Call Log after a Call) 378 */ 379 private int mLastManuallySelectedFragment; 380 381 private ContactListFilterController mContactListFilterController; 382 private OnMenuItemClickListener mFilterOptionsMenuItemClickListener = 383 new OnMenuItemClickListener() { 384 @Override 385 public boolean onMenuItemClick(MenuItem item) { 386 AccountFilterUtil.startAccountFilterActivityForResult( 387 DialtactsActivity.this, SUBACTIVITY_ACCOUNT_FILTER, 388 mContactListFilterController.getFilter()); 389 return true; 390 } 391 }; 392 393 private OnMenuItemClickListener mSearchMenuItemClickListener = 394 new OnMenuItemClickListener() { 395 @Override 396 public boolean onMenuItemClick(MenuItem item) { 397 enterSearchUi(); 398 return true; 399 } 400 }; 401 402 /** 403 * Listener used when one of phone numbers in search UI is selected. This will initiate a 404 * phone call using the phone number. 405 */ 406 private final OnPhoneNumberPickerActionListener mPhoneNumberPickerActionListener = 407 new OnPhoneNumberPickerActionListener() { 408 @Override 409 public void onPickPhoneNumberAction(Uri dataUri) { 410 // Specify call-origin so that users will see the previous tab instead of 411 // CallLog screen (search UI will be automatically exited). 412 PhoneNumberInteraction.startInteractionForPhoneCall( 413 DialtactsActivity.this, dataUri, getCallOrigin()); 414 } 415 416 @Override 417 public void onShortcutIntentCreated(Intent intent) { 418 Log.w(TAG, "Unsupported intent has come (" + intent + "). Ignoring."); 419 } 420 421 @Override 422 public void onHomeInActionBarSelected() { 423 exitSearchUi(); 424 } 425 }; 426 427 /** 428 * Listener used to send search queries to the phone search fragment. 429 */ 430 private final OnQueryTextListener mPhoneSearchQueryTextListener = 431 new OnQueryTextListener() { 432 @Override 433 public boolean onQueryTextSubmit(String query) { 434 View view = getCurrentFocus(); 435 if (view != null) { 436 hideInputMethod(view); 437 view.clearFocus(); 438 } 439 return true; 440 } 441 442 @Override 443 public boolean onQueryTextChange(String newText) { 444 // Show search result with non-empty text. Show a bare list otherwise. 445 if (mSearchFragment != null) { 446 mSearchFragment.setQueryString(newText, true); 447 } 448 return true; 449 } 450 }; 451 452 /** 453 * Listener used to handle the "close" button on the right side of {@link SearchView}. 454 * If some text is in the search view, this will clean it up. Otherwise this will exit 455 * the search UI and let users go back to usual Phone UI. 456 * 457 * This does _not_ handle back button. 458 */ 459 private final OnCloseListener mPhoneSearchCloseListener = 460 new OnCloseListener() { 461 @Override 462 public boolean onClose() { 463 if (!TextUtils.isEmpty(mSearchView.getQuery())) { 464 mSearchView.setQuery(null, true); 465 } 466 return true; 467 } 468 }; 469 470 private final View.OnLayoutChangeListener mFirstLayoutListener 471 = new View.OnLayoutChangeListener() { 472 @Override 473 public void onLayoutChange(View v, int left, int top, int right, int bottom, int oldLeft, 474 int oldTop, int oldRight, int oldBottom) { 475 v.removeOnLayoutChangeListener(this); // Unregister self. 476 addSearchFragment(); 477 } 478 }; 479 480 @Override 481 protected void onCreate(Bundle icicle) { 482 super.onCreate(icicle); 483 484 final Intent intent = getIntent(); 485 fixIntent(intent); 486 487 setContentView(R.layout.dialtacts_activity); 488 489 mContactListFilterController = ContactListFilterController.getInstance(this); 490 mContactListFilterController.addListener(mContactListFilterListener); 491 492 findViewById(R.id.dialtacts_frame).addOnLayoutChangeListener(mFirstLayoutListener); 493 494 mViewPager = (ViewPager) findViewById(R.id.pager); 495 mViewPager.setAdapter(new ViewPagerAdapter(getFragmentManager())); 496 mViewPager.setOnPageChangeListener(mPageChangeListener); 497 mViewPager.setOffscreenPageLimit(2); 498 499 // Do same width calculation as ActionBar does 500 DisplayMetrics dm = getResources().getDisplayMetrics(); 501 int minCellSize = getResources().getDimensionPixelSize(R.dimen.fake_menu_button_min_width); 502 int cellCount = dm.widthPixels / minCellSize; 503 int fakeMenuItemWidth = dm.widthPixels / cellCount; 504 if (DEBUG) Log.d(TAG, "The size of fake menu buttons (in pixel): " + fakeMenuItemWidth); 505 506 // Soft menu button should appear only when there's no hardware menu button. 507 mMenuButton = findViewById(R.id.overflow_menu); 508 if (mMenuButton != null) { 509 mMenuButton.setMinimumWidth(fakeMenuItemWidth); 510 if (ViewConfiguration.get(this).hasPermanentMenuKey()) { 511 // This is required for dialpad button's layout, so must not use GONE here. 512 mMenuButton.setVisibility(View.INVISIBLE); 513 } else { 514 mMenuButton.setOnClickListener(this); 515 } 516 } 517 mSearchButton = findViewById(R.id.searchButton); 518 if (mSearchButton != null) { 519 mSearchButton.setMinimumWidth(fakeMenuItemWidth); 520 mSearchButton.setOnClickListener(this); 521 } 522 523 // Setup the ActionBar tabs (the order matches the tab-index contants TAB_INDEX_*) 524 setupDialer(); 525 setupCallLog(); 526 setupFavorites(); 527 getActionBar().setNavigationMode(ActionBar.NAVIGATION_MODE_TABS); 528 getActionBar().setDisplayShowTitleEnabled(false); 529 getActionBar().setDisplayShowHomeEnabled(false); 530 531 // Load the last manually loaded tab 532 mPrefs = this.getSharedPreferences(SHARED_PREFS_NAME, Context.MODE_PRIVATE); 533 mLastManuallySelectedFragment = mPrefs.getInt(PREF_LAST_MANUALLY_SELECTED_TAB, 534 PREF_LAST_MANUALLY_SELECTED_TAB_DEFAULT); 535 if (mLastManuallySelectedFragment >= TAB_INDEX_COUNT) { 536 // Stored value may have exceeded the number of current tabs. Reset it. 537 mLastManuallySelectedFragment = PREF_LAST_MANUALLY_SELECTED_TAB_DEFAULT; 538 } 539 540 setCurrentTab(intent); 541 542 if (UI.FILTER_CONTACTS_ACTION.equals(intent.getAction()) 543 && icicle == null) { 544 setupFilterText(intent); 545 } 546 } 547 548 @Override 549 public void onStart() { 550 super.onStart(); 551 if (mPhoneFavoriteFragment != null) { 552 mPhoneFavoriteFragment.setFilter(mContactListFilterController.getFilter()); 553 } 554 if (mSearchFragment != null) { 555 mSearchFragment.setFilter(mContactListFilterController.getFilter()); 556 } 557 558 if (mDuringSwipe || mUserTabClick) { 559 if (DEBUG) Log.d(TAG, "reset buggy flag state.."); 560 mDuringSwipe = false; 561 mUserTabClick = false; 562 } 563 564 final int currentPosition = mPageChangeListener.getCurrentPosition(); 565 if (DEBUG) { 566 Log.d(TAG, "onStart(). current position: " + mPageChangeListener.getCurrentPosition() 567 + ". Reset all menu visibility state."); 568 } 569 updateFakeMenuButtonsVisibility(currentPosition == TAB_INDEX_DIALER && !mInSearchUi); 570 for (int i = 0; i < TAB_INDEX_COUNT; i++) { 571 sendFragmentVisibilityChange(i, i == currentPosition); 572 } 573 } 574 575 @Override 576 public void onDestroy() { 577 super.onDestroy(); 578 mContactListFilterController.removeListener(mContactListFilterListener); 579 } 580 581 @Override 582 public void onClick(View view) { 583 switch (view.getId()) { 584 case R.id.searchButton: { 585 enterSearchUi(); 586 break; 587 } 588 case R.id.overflow_menu: { 589 if (mDialpadFragment != null) { 590 PopupMenu popup = mDialpadFragment.constructPopupMenu(view); 591 if (popup != null) { 592 popup.show(); 593 } 594 } else { 595 Log.w(TAG, "DialpadFragment is null during onClick() event for " + view); 596 } 597 break; 598 } 599 default: { 600 Log.wtf(TAG, "Unexpected onClick event from " + view); 601 break; 602 } 603 } 604 } 605 606 /** 607 * Add search fragment. Note this is called during onLayout, so there's some restrictions, 608 * such as executePendingTransaction can't be used in it. 609 */ 610 private void addSearchFragment() { 611 // In order to take full advantage of "fragment deferred start", we need to create the 612 // search fragment after all other fragments are created. 613 // The other fragments are created by the ViewPager on the first onMeasure(). 614 // We use the first onLayout call, which is after onMeasure(). 615 616 // Just return if the fragment is already created, which happens after configuration 617 // changes. 618 if (mSearchFragment != null) return; 619 620 final FragmentTransaction ft = getFragmentManager().beginTransaction(); 621 final Fragment searchFragment = new PhoneNumberPickerFragment(); 622 623 searchFragment.setUserVisibleHint(false); 624 ft.add(R.id.dialtacts_frame, searchFragment); 625 ft.hide(searchFragment); 626 ft.commitAllowingStateLoss(); 627 } 628 629 private void prepareSearchView() { 630 final View searchViewLayout = 631 getLayoutInflater().inflate(R.layout.dialtacts_custom_action_bar, null); 632 mSearchView = (SearchView) searchViewLayout.findViewById(R.id.search_view); 633 mSearchView.setOnQueryTextListener(mPhoneSearchQueryTextListener); 634 mSearchView.setOnCloseListener(mPhoneSearchCloseListener); 635 // Since we're using a custom layout for showing SearchView instead of letting the 636 // search menu icon do that job, we need to manually configure the View so it looks 637 // "shown via search menu". 638 // - it should be iconified by default 639 // - it should not be iconified at this time 640 // See also comments for onActionViewExpanded()/onActionViewCollapsed() 641 mSearchView.setIconifiedByDefault(true); 642 mSearchView.setQueryHint(getString(R.string.hint_findContacts)); 643 mSearchView.setIconified(false); 644 mSearchView.setOnQueryTextFocusChangeListener(new OnFocusChangeListener() { 645 @Override 646 public void onFocusChange(View view, boolean hasFocus) { 647 if (hasFocus) { 648 showInputMethod(view.findFocus()); 649 } 650 } 651 }); 652 653 if (!ViewConfiguration.get(this).hasPermanentMenuKey()) { 654 // Filter option menu should be shown on the right side of SearchView. 655 final View filterOptionView = searchViewLayout.findViewById(R.id.search_option); 656 filterOptionView.setVisibility(View.VISIBLE); 657 filterOptionView.setOnClickListener(mFilterOptionClickListener); 658 } 659 660 getActionBar().setCustomView(searchViewLayout, 661 new LayoutParams(LayoutParams.MATCH_PARENT, LayoutParams.WRAP_CONTENT)); 662 } 663 664 @Override 665 public void onAttachFragment(Fragment fragment) { 666 // This method can be called before onCreate(), at which point we cannot rely on ViewPager. 667 // In that case, we will setup the "current position" soon after the ViewPager is ready. 668 final int currentPosition = mViewPager != null ? mViewPager.getCurrentItem() : -1; 669 670 if (fragment instanceof DialpadFragment) { 671 mDialpadFragment = (DialpadFragment) fragment; 672 } else if (fragment instanceof CallLogFragment) { 673 mCallLogFragment = (CallLogFragment) fragment; 674 } else if (fragment instanceof PhoneFavoriteFragment) { 675 mPhoneFavoriteFragment = (PhoneFavoriteFragment) fragment; 676 mPhoneFavoriteFragment.setListener(mPhoneFavoriteListener); 677 if (mContactListFilterController != null 678 && mContactListFilterController.getFilter() != null) { 679 mPhoneFavoriteFragment.setFilter(mContactListFilterController.getFilter()); 680 } 681 } else if (fragment instanceof PhoneNumberPickerFragment) { 682 mSearchFragment = (PhoneNumberPickerFragment) fragment; 683 mSearchFragment.setOnPhoneNumberPickerActionListener(mPhoneNumberPickerActionListener); 684 mSearchFragment.setQuickContactEnabled(true); 685 mSearchFragment.setDarkTheme(true); 686 mSearchFragment.setPhotoPosition(ContactListItemView.getDefaultPhotoPosition( 687 true /* opposite */)); 688 mSearchFragment.setUseCallableUri(true); 689 if (mContactListFilterController != null 690 && mContactListFilterController.getFilter() != null) { 691 mSearchFragment.setFilter(mContactListFilterController.getFilter()); 692 } 693 // Here we assume that we're not on the search mode, so let's hide the fragment. 694 // 695 // We get here either when the fragment is created (normal case), or after configuration 696 // changes. In the former case, we're not in search mode because we can only 697 // enter search mode if the fragment is created. (see enterSearchUi()) 698 // In the latter case we're not in search mode either because we don't retain 699 // mInSearchUi -- ideally we should but at this point it's not supported. 700 mSearchFragment.setUserVisibleHint(false); 701 // After configuration changes fragments will forget their "hidden" state, so make 702 // sure to hide it. 703 if (!mSearchFragment.isHidden()) { 704 final FragmentTransaction transaction = getFragmentManager().beginTransaction(); 705 transaction.hide(mSearchFragment); 706 transaction.commitAllowingStateLoss(); 707 } 708 } 709 } 710 711 @Override 712 protected void onPause() { 713 super.onPause(); 714 715 mPrefs.edit().putInt(PREF_LAST_MANUALLY_SELECTED_TAB, mLastManuallySelectedFragment) 716 .apply(); 717 requestBackup(); 718 } 719 720 private void requestBackup() { 721 final BackupManager bm = new BackupManager(this); 722 bm.dataChanged(); 723 } 724 725 private void fixIntent(Intent intent) { 726 // This should be cleaned up: the call key used to send an Intent 727 // that just said to go to the recent calls list. It now sends this 728 // abstract action, but this class hasn't been rewritten to deal with it. 729 if (Intent.ACTION_CALL_BUTTON.equals(intent.getAction())) { 730 intent.setDataAndType(Calls.CONTENT_URI, Calls.CONTENT_TYPE); 731 intent.putExtra("call_key", true); 732 setIntent(intent); 733 } 734 } 735 736 private void setupDialer() { 737 final Tab tab = getActionBar().newTab(); 738 tab.setContentDescription(R.string.dialerIconLabel); 739 tab.setTabListener(mTabListener); 740 tab.setIcon(R.drawable.ic_tab_dialer); 741 getActionBar().addTab(tab); 742 } 743 744 private void setupCallLog() { 745 final Tab tab = getActionBar().newTab(); 746 tab.setContentDescription(R.string.recentCallsIconLabel); 747 tab.setIcon(R.drawable.ic_tab_recent); 748 tab.setTabListener(mTabListener); 749 getActionBar().addTab(tab); 750 } 751 752 private void setupFavorites() { 753 final Tab tab = getActionBar().newTab(); 754 tab.setContentDescription(R.string.contactsFavoritesLabel); 755 tab.setIcon(R.drawable.ic_tab_all); 756 tab.setTabListener(mTabListener); 757 getActionBar().addTab(tab); 758 } 759 760 /** 761 * Returns true if the intent is due to hitting the green send key (hardware call button: 762 * KEYCODE_CALL) while in a call. 763 * 764 * @param intent the intent that launched this activity 765 * @param recentCallsRequest true if the intent is requesting to view recent calls 766 * @return true if the intent is due to hitting the green send key while in a call 767 */ 768 private boolean isSendKeyWhileInCall(final Intent intent, 769 final boolean recentCallsRequest) { 770 // If there is a call in progress go to the call screen 771 if (recentCallsRequest) { 772 final boolean callKey = intent.getBooleanExtra("call_key", false); 773 774 try { 775 ITelephony phone = ITelephony.Stub.asInterface(ServiceManager.checkService("phone")); 776 if (callKey && phone != null && phone.showCallScreen()) { 777 return true; 778 } 779 } catch (RemoteException e) { 780 Log.e(TAG, "Failed to handle send while in call", e); 781 } 782 } 783 784 return false; 785 } 786 787 /** 788 * Sets the current tab based on the intent's request type 789 * 790 * @param intent Intent that contains information about which tab should be selected 791 */ 792 private void setCurrentTab(Intent intent) { 793 // If we got here by hitting send and we're in call forward along to the in-call activity 794 boolean recentCallsRequest = Calls.CONTENT_TYPE.equals(intent.resolveType( 795 getContentResolver())); 796 if (isSendKeyWhileInCall(intent, recentCallsRequest)) { 797 finish(); 798 return; 799 } 800 801 // Remember the old manually selected tab index so that it can be restored if it is 802 // overwritten by one of the programmatic tab selections 803 final int savedTabIndex = mLastManuallySelectedFragment; 804 805 final int tabIndex; 806 if (DialpadFragment.phoneIsInUse() || isDialIntent(intent)) { 807 tabIndex = TAB_INDEX_DIALER; 808 } else if (recentCallsRequest) { 809 tabIndex = TAB_INDEX_CALL_LOG; 810 } else { 811 tabIndex = mLastManuallySelectedFragment; 812 } 813 814 final int previousItemIndex = mViewPager.getCurrentItem(); 815 mViewPager.setCurrentItem(tabIndex, false /* smoothScroll */); 816 if (previousItemIndex != tabIndex) { 817 sendFragmentVisibilityChange(previousItemIndex, false /* not visible */ ); 818 } 819 mPageChangeListener.setCurrentPosition(tabIndex); 820 sendFragmentVisibilityChange(tabIndex, true /* visible */ ); 821 822 // Restore to the previous manual selection 823 mLastManuallySelectedFragment = savedTabIndex; 824 mDuringSwipe = false; 825 mUserTabClick = false; 826 } 827 828 @Override 829 public void onNewIntent(Intent newIntent) { 830 setIntent(newIntent); 831 fixIntent(newIntent); 832 setCurrentTab(newIntent); 833 final String action = newIntent.getAction(); 834 if (UI.FILTER_CONTACTS_ACTION.equals(action)) { 835 setupFilterText(newIntent); 836 } 837 if (mInSearchUi || (mSearchFragment != null && mSearchFragment.isVisible())) { 838 exitSearchUi(); 839 } 840 841 if (mViewPager.getCurrentItem() == TAB_INDEX_DIALER) { 842 if (mDialpadFragment != null) { 843 mDialpadFragment.setStartedFromNewIntent(true); 844 } else { 845 Log.e(TAG, "DialpadFragment isn't ready yet when the tab is already selected."); 846 } 847 } else if (mViewPager.getCurrentItem() == TAB_INDEX_CALL_LOG) { 848 if (mCallLogFragment != null) { 849 mCallLogFragment.configureScreenFromIntent(newIntent); 850 } else { 851 Log.e(TAG, "CallLogFragment isn't ready yet when the tab is already selected."); 852 } 853 } 854 invalidateOptionsMenu(); 855 } 856 857 /** Returns true if the given intent contains a phone number to populate the dialer with */ 858 private boolean isDialIntent(Intent intent) { 859 final String action = intent.getAction(); 860 if (Intent.ACTION_DIAL.equals(action) || ACTION_TOUCH_DIALER.equals(action)) { 861 return true; 862 } 863 if (Intent.ACTION_VIEW.equals(action)) { 864 final Uri data = intent.getData(); 865 if (data != null && CallUtil.SCHEME_TEL.equals(data.getScheme())) { 866 return true; 867 } 868 } 869 return false; 870 } 871 872 /** 873 * Returns an appropriate call origin for this Activity. May return null when no call origin 874 * should be used (e.g. when some 3rd party application launched the screen. Call origin is 875 * for remembering the tab in which the user made a phone call, so the external app's DIAL 876 * request should not be counted.) 877 */ 878 public String getCallOrigin() { 879 return !isDialIntent(getIntent()) ? CALL_ORIGIN_DIALTACTS : null; 880 } 881 882 /** 883 * Retrieves the filter text stored in {@link #setupFilterText(Intent)}. 884 * This text originally came from a FILTER_CONTACTS_ACTION intent received 885 * by this activity. The stored text will then be cleared after after this 886 * method returns. 887 * 888 * @return The stored filter text 889 */ 890 public String getAndClearFilterText() { 891 String filterText = mFilterText; 892 mFilterText = null; 893 return filterText; 894 } 895 896 /** 897 * Stores the filter text associated with a FILTER_CONTACTS_ACTION intent. 898 * This is so child activities can check if they are supposed to display a filter. 899 * 900 * @param intent The intent received in {@link #onNewIntent(Intent)} 901 */ 902 private void setupFilterText(Intent intent) { 903 // If the intent was relaunched from history, don't apply the filter text. 904 if ((intent.getFlags() & Intent.FLAG_ACTIVITY_LAUNCHED_FROM_HISTORY) != 0) { 905 return; 906 } 907 String filter = intent.getStringExtra(UI.FILTER_TEXT_EXTRA_KEY); 908 if (filter != null && filter.length() > 0) { 909 mFilterText = filter; 910 } 911 } 912 913 @Override 914 public void onBackPressed() { 915 if (mInSearchUi) { 916 // We should let the user go back to usual screens with tabs. 917 exitSearchUi(); 918 } else if (isTaskRoot()) { 919 // Instead of stopping, simply push this to the back of the stack. 920 // This is only done when running at the top of the stack; 921 // otherwise, we have been launched by someone else so need to 922 // allow the user to go back to the caller. 923 moveTaskToBack(false); 924 } else { 925 super.onBackPressed(); 926 } 927 } 928 929 private final PhoneFavoriteFragment.Listener mPhoneFavoriteListener = 930 new PhoneFavoriteFragment.Listener() { 931 @Override 932 public void onContactSelected(Uri contactUri) { 933 PhoneNumberInteraction.startInteractionForPhoneCall( 934 DialtactsActivity.this, contactUri, getCallOrigin()); 935 } 936 937 @Override 938 public void onCallNumberDirectly(String phoneNumber) { 939 Intent intent = CallUtil.getCallIntent(phoneNumber, getCallOrigin()); 940 startActivity(intent); 941 } 942 }; 943 944 @Override 945 public boolean onCreateOptionsMenu(Menu menu) { 946 MenuInflater inflater = getMenuInflater(); 947 inflater.inflate(R.menu.dialtacts_options, menu); 948 949 // set up intents and onClick listeners 950 final MenuItem callSettingsMenuItem = menu.findItem(R.id.menu_call_settings); 951 final MenuItem searchMenuItem = menu.findItem(R.id.search_on_action_bar); 952 final MenuItem filterOptionMenuItem = menu.findItem(R.id.filter_option); 953 954 callSettingsMenuItem.setIntent(DialtactsActivity.getCallSettingsIntent()); 955 searchMenuItem.setOnMenuItemClickListener(mSearchMenuItemClickListener); 956 filterOptionMenuItem.setOnMenuItemClickListener(mFilterOptionsMenuItemClickListener); 957 958 return true; 959 } 960 961 @Override 962 public boolean onPrepareOptionsMenu(Menu menu) { 963 if (mInSearchUi) { 964 prepareOptionsMenuInSearchMode(menu); 965 } else { 966 // get reference to the currently selected tab 967 final Tab tab = getActionBar().getSelectedTab(); 968 if (tab != null) { 969 switch(tab.getPosition()) { 970 case TAB_INDEX_DIALER: 971 prepareOptionsMenuForDialerTab(menu); 972 break; 973 case TAB_INDEX_CALL_LOG: 974 prepareOptionsMenuForCallLogTab(menu); 975 break; 976 case TAB_INDEX_FAVORITES: 977 prepareOptionsMenuForFavoritesTab(menu); 978 break; 979 } 980 } 981 } 982 return true; 983 } 984 985 @Override 986 public boolean onOptionsItemSelected(MenuItem item) { 987 switch (item.getItemId()) { 988 case R.id.add_contact: 989 try { 990 startActivity(new Intent(Intent.ACTION_INSERT, Contacts.CONTENT_URI)); 991 } catch (ActivityNotFoundException e) { 992 Toast toast = Toast.makeText(this, R.string.add_contact_not_available, 993 Toast.LENGTH_SHORT); 994 toast.show(); 995 } 996 return true; 997 } 998 return super.onOptionsItemSelected(item); 999 } 1000 1001 private void prepareOptionsMenuInSearchMode(Menu menu) { 1002 // get references to menu items 1003 final MenuItem searchMenuItem = menu.findItem(R.id.search_on_action_bar); 1004 final MenuItem filterOptionMenuItem = menu.findItem(R.id.filter_option); 1005 final MenuItem addContactOptionMenuItem = menu.findItem(R.id.add_contact); 1006 final MenuItem callSettingsMenuItem = menu.findItem(R.id.menu_call_settings); 1007 final MenuItem emptyRightMenuItem = menu.findItem(R.id.empty_right_menu_item); 1008 1009 // prepare the menu items 1010 searchMenuItem.setVisible(false); 1011 filterOptionMenuItem.setVisible(ViewConfiguration.get(this).hasPermanentMenuKey()); 1012 addContactOptionMenuItem.setVisible(false); 1013 callSettingsMenuItem.setVisible(false); 1014 emptyRightMenuItem.setVisible(false); 1015 } 1016 1017 private void prepareOptionsMenuForDialerTab(Menu menu) { 1018 if (DEBUG) { 1019 Log.d(TAG, "onPrepareOptionsMenu(dialer). swipe: " + mDuringSwipe 1020 + ", user tab click: " + mUserTabClick); 1021 } 1022 1023 // get references to menu items 1024 final MenuItem searchMenuItem = menu.findItem(R.id.search_on_action_bar); 1025 final MenuItem filterOptionMenuItem = menu.findItem(R.id.filter_option); 1026 final MenuItem addContactOptionMenuItem = menu.findItem(R.id.add_contact); 1027 final MenuItem callSettingsMenuItem = menu.findItem(R.id.menu_call_settings); 1028 final MenuItem emptyRightMenuItem = menu.findItem(R.id.empty_right_menu_item); 1029 1030 // prepare the menu items 1031 filterOptionMenuItem.setVisible(false); 1032 addContactOptionMenuItem.setVisible(false); 1033 if (mDuringSwipe || mUserTabClick) { 1034 // During horizontal movement, the real ActionBar menu items are shown 1035 searchMenuItem.setVisible(true); 1036 callSettingsMenuItem.setVisible(true); 1037 // When there is a permanent menu key, there is no overflow icon on the right of 1038 // the action bar which would force the search menu item (if it is visible) to the 1039 // left. This is the purpose of showing the emptyRightMenuItem. 1040 emptyRightMenuItem.setVisible(ViewConfiguration.get(this).hasPermanentMenuKey()); 1041 } else { 1042 // This is when the user is looking at the dialer pad. In this case, the real 1043 // ActionBar is hidden and fake menu items are shown. 1044 // Except in landscape, in which case the real search menu item is shown. 1045 searchMenuItem.setVisible(OrientationUtil.isLandscape(this)); 1046 // If a permanent menu key is available, then we need to show the call settings item 1047 // so that the call settings item can be invoked by the permanent menu key. 1048 callSettingsMenuItem.setVisible(ViewConfiguration.get(this).hasPermanentMenuKey()); 1049 emptyRightMenuItem.setVisible(false); 1050 } 1051 } 1052 1053 private void prepareOptionsMenuForCallLogTab(Menu menu) { 1054 // get references to menu items 1055 final MenuItem searchMenuItem = menu.findItem(R.id.search_on_action_bar); 1056 final MenuItem filterOptionMenuItem = menu.findItem(R.id.filter_option); 1057 final MenuItem addContactOptionMenuItem = menu.findItem(R.id.add_contact); 1058 final MenuItem callSettingsMenuItem = menu.findItem(R.id.menu_call_settings); 1059 final MenuItem emptyRightMenuItem = menu.findItem(R.id.empty_right_menu_item); 1060 1061 // prepare the menu items 1062 searchMenuItem.setVisible(true); 1063 filterOptionMenuItem.setVisible(false); 1064 addContactOptionMenuItem.setVisible(false); 1065 callSettingsMenuItem.setVisible(true); 1066 emptyRightMenuItem.setVisible(ViewConfiguration.get(this).hasPermanentMenuKey()); 1067 } 1068 1069 private void prepareOptionsMenuForFavoritesTab(Menu menu) { 1070 // get references to menu items 1071 final MenuItem searchMenuItem = menu.findItem(R.id.search_on_action_bar); 1072 final MenuItem filterOptionMenuItem = menu.findItem(R.id.filter_option); 1073 final MenuItem addContactOptionMenuItem = menu.findItem(R.id.add_contact); 1074 final MenuItem callSettingsMenuItem = menu.findItem(R.id.menu_call_settings); 1075 final MenuItem emptyRightMenuItem = menu.findItem(R.id.empty_right_menu_item); 1076 1077 // prepare the menu items 1078 searchMenuItem.setVisible(true); 1079 filterOptionMenuItem.setVisible(true); 1080 addContactOptionMenuItem.setVisible(true); 1081 callSettingsMenuItem.setVisible(true); 1082 emptyRightMenuItem.setVisible(false); 1083 } 1084 1085 @Override 1086 public void startSearch(String initialQuery, boolean selectInitialQuery, 1087 Bundle appSearchData, boolean globalSearch) { 1088 if (mSearchFragment != null && mSearchFragment.isAdded() && !globalSearch) { 1089 if (mInSearchUi) { 1090 if (mSearchView.hasFocus()) { 1091 showInputMethod(mSearchView.findFocus()); 1092 } else { 1093 mSearchView.requestFocus(); 1094 } 1095 } else { 1096 enterSearchUi(); 1097 } 1098 } else { 1099 super.startSearch(initialQuery, selectInitialQuery, appSearchData, globalSearch); 1100 } 1101 } 1102 1103 /** 1104 * Hides every tab and shows search UI for phone lookup. 1105 */ 1106 private void enterSearchUi() { 1107 if (mSearchFragment == null) { 1108 // We add the search fragment dynamically in the first onLayoutChange() and 1109 // mSearchFragment is set sometime later when the fragment transaction is actually 1110 // executed, which means there's a window when users are able to hit the (physical) 1111 // search key but mSearchFragment is still null. 1112 // It's quite hard to handle this case right, so let's just ignore the search key 1113 // in this case. Users can just hit it again and it will work this time. 1114 return; 1115 } 1116 if (mSearchView == null) { 1117 prepareSearchView(); 1118 } 1119 1120 final ActionBar actionBar = getActionBar(); 1121 1122 final Tab tab = actionBar.getSelectedTab(); 1123 1124 // User can search during the call, but we don't want to remember the status. 1125 if (tab != null && !DialpadFragment.phoneIsInUse()) { 1126 mLastManuallySelectedFragment = tab.getPosition(); 1127 } 1128 1129 mSearchView.setQuery(null, true); 1130 1131 actionBar.setDisplayShowCustomEnabled(true); 1132 actionBar.setNavigationMode(ActionBar.NAVIGATION_MODE_STANDARD); 1133 actionBar.setDisplayShowHomeEnabled(true); 1134 actionBar.setDisplayHomeAsUpEnabled(true); 1135 1136 updateFakeMenuButtonsVisibility(false); 1137 1138 for (int i = 0; i < TAB_INDEX_COUNT; i++) { 1139 sendFragmentVisibilityChange(i, false /* not visible */ ); 1140 } 1141 1142 // Show the search fragment and hide everything else. 1143 mSearchFragment.setUserVisibleHint(true); 1144 final FragmentTransaction transaction = getFragmentManager().beginTransaction(); 1145 transaction.show(mSearchFragment); 1146 transaction.commitAllowingStateLoss(); 1147 mViewPager.setVisibility(View.GONE); 1148 1149 // We need to call this and onActionViewCollapsed() manually, since we are using a custom 1150 // layout instead of asking the search menu item to take care of SearchView. 1151 mSearchView.onActionViewExpanded(); 1152 mInSearchUi = true; 1153 } 1154 1155 private void showInputMethod(View view) { 1156 InputMethodManager imm = (InputMethodManager)getSystemService(Context.INPUT_METHOD_SERVICE); 1157 if (imm != null) { 1158 if (!imm.showSoftInput(view, 0)) { 1159 Log.w(TAG, "Failed to show soft input method."); 1160 } 1161 } 1162 } 1163 1164 private void hideInputMethod(View view) { 1165 InputMethodManager imm = (InputMethodManager)getSystemService(Context.INPUT_METHOD_SERVICE); 1166 if (imm != null && view != null) { 1167 imm.hideSoftInputFromWindow(view.getWindowToken(), 0); 1168 } 1169 } 1170 1171 /** 1172 * Goes back to usual Phone UI with tags. Previously selected Tag and associated Fragment 1173 * should be automatically focused again. 1174 */ 1175 private void exitSearchUi() { 1176 final ActionBar actionBar = getActionBar(); 1177 1178 // Hide the search fragment, if exists. 1179 if (mSearchFragment != null) { 1180 mSearchFragment.setUserVisibleHint(false); 1181 1182 final FragmentTransaction transaction = getFragmentManager().beginTransaction(); 1183 transaction.hide(mSearchFragment); 1184 transaction.commitAllowingStateLoss(); 1185 } 1186 1187 // We want to hide SearchView and show Tabs. Also focus on previously selected one. 1188 actionBar.setDisplayShowCustomEnabled(false); 1189 actionBar.setDisplayShowHomeEnabled(false); 1190 actionBar.setNavigationMode(ActionBar.NAVIGATION_MODE_TABS); 1191 1192 for (int i = 0; i < TAB_INDEX_COUNT; i++) { 1193 sendFragmentVisibilityChange(i, i == mViewPager.getCurrentItem()); 1194 } 1195 1196 // Before exiting the search screen, reset swipe state. 1197 mDuringSwipe = false; 1198 mUserTabClick = false; 1199 1200 mViewPager.setVisibility(View.VISIBLE); 1201 1202 hideInputMethod(getCurrentFocus()); 1203 1204 // Request to update option menu. 1205 invalidateOptionsMenu(); 1206 1207 // See comments in onActionViewExpanded() 1208 mSearchView.onActionViewCollapsed(); 1209 mInSearchUi = false; 1210 } 1211 1212 private Fragment getFragmentAt(int position) { 1213 switch (position) { 1214 case TAB_INDEX_DIALER: 1215 return mDialpadFragment; 1216 case TAB_INDEX_CALL_LOG: 1217 return mCallLogFragment; 1218 case TAB_INDEX_FAVORITES: 1219 return mPhoneFavoriteFragment; 1220 default: 1221 throw new IllegalStateException("Unknown fragment index: " + position); 1222 } 1223 } 1224 1225 private void sendFragmentVisibilityChange(int position, boolean visibility) { 1226 if (DEBUG) { 1227 Log.d(TAG, "sendFragmentVisibiltyChange(). position: " + position 1228 + ", visibility: " + visibility); 1229 } 1230 // Position can be -1 initially. See PageChangeListener. 1231 if (position >= 0) { 1232 final Fragment fragment = getFragmentAt(position); 1233 if (fragment != null) { 1234 fragment.setMenuVisibility(visibility); 1235 fragment.setUserVisibleHint(visibility); 1236 } 1237 } 1238 } 1239 1240 /** 1241 * Update visibility of the search button and menu button at the bottom. 1242 * They should be invisible when bottom ActionBar's real items are available, and be visible 1243 * otherwise. 1244 * 1245 * @param visible True when visible. 1246 */ 1247 private void updateFakeMenuButtonsVisibility(boolean visible) { 1248 // Note: Landscape mode does not have the fake menu and search buttons. 1249 if (DEBUG) { 1250 Log.d(TAG, "updateFakeMenuButtonVisibility(" + visible + ")"); 1251 } 1252 1253 if (mSearchButton != null) { 1254 if (visible) { 1255 mSearchButton.setVisibility(View.VISIBLE); 1256 } else { 1257 mSearchButton.setVisibility(View.INVISIBLE); 1258 } 1259 } 1260 if (mMenuButton != null) { 1261 if (visible && !ViewConfiguration.get(this).hasPermanentMenuKey()) { 1262 mMenuButton.setVisibility(View.VISIBLE); 1263 } else { 1264 mMenuButton.setVisibility(View.INVISIBLE); 1265 } 1266 } 1267 } 1268 1269 /** Returns an Intent to launch Call Settings screen */ 1270 public static Intent getCallSettingsIntent() { 1271 final Intent intent = new Intent(Intent.ACTION_MAIN); 1272 intent.setClassName(PHONE_PACKAGE, CALL_SETTINGS_CLASS_NAME); 1273 intent.setFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP); 1274 return intent; 1275 } 1276 1277 @Override 1278 protected void onActivityResult(int requestCode, int resultCode, Intent data) { 1279 if (resultCode != Activity.RESULT_OK) { 1280 return; 1281 } 1282 switch (requestCode) { 1283 case SUBACTIVITY_ACCOUNT_FILTER: { 1284 AccountFilterUtil.handleAccountFilterResult( 1285 mContactListFilterController, resultCode, data); 1286 } 1287 break; 1288 } 1289 } 1290} 1291