1 /* 2 * Copyright (C) 2006 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 17 package com.android.settings.applications; 18 19 import static android.net.NetworkPolicyManager.POLICY_NONE; 20 import static android.net.NetworkPolicyManager.POLICY_REJECT_METERED_BACKGROUND; 21 22 import android.app.Activity; 23 import android.app.ActivityManager; 24 import android.app.AlertDialog; 25 import android.app.AppOpsManager; 26 import android.app.Fragment; 27 import android.app.INotificationManager; 28 import android.content.ComponentName; 29 import android.content.Context; 30 import android.content.DialogInterface; 31 import android.content.Intent; 32 import android.content.ServiceConnection; 33 import android.content.pm.ApplicationInfo; 34 import android.content.pm.IPackageManager; 35 import android.content.pm.PackageInfo; 36 import android.content.pm.PackageManager; 37 import android.net.NetworkPolicyManager; 38 import android.os.AsyncTask; 39 import android.os.Bundle; 40 import android.os.Environment; 41 import android.os.Handler; 42 import android.os.IBinder; 43 import android.os.RemoteException; 44 import android.os.ServiceManager; 45 import android.os.UserHandle; 46 import android.os.UserManager; 47 import android.preference.PreferenceFrameLayout; 48 import android.provider.Settings; 49 import android.support.v4.view.PagerAdapter; 50 import android.support.v4.view.PagerTabStrip; 51 import android.support.v4.view.ViewPager; 52 import android.util.Log; 53 import android.view.LayoutInflater; 54 import android.view.Menu; 55 import android.view.MenuInflater; 56 import android.view.MenuItem; 57 import android.view.View; 58 import android.view.ViewGroup; 59 import android.view.animation.AnimationUtils; 60 import android.widget.AbsListView; 61 import android.widget.AdapterView; 62 import android.widget.AdapterView.OnItemClickListener; 63 import android.widget.AdapterView.OnItemSelectedListener; 64 import android.widget.BaseAdapter; 65 import android.widget.Filter; 66 import android.widget.Filterable; 67 import android.widget.ListView; 68 import android.widget.Spinner; 69 70 import com.android.internal.app.IMediaContainerService; 71 import com.android.internal.content.PackageHelper; 72 import com.android.settings.R; 73 import com.android.settings.SettingsActivity; 74 import com.android.settings.UserSpinnerAdapter; 75 import com.android.settings.Settings.RunningServicesActivity; 76 import com.android.settings.Settings.StorageUseActivity; 77 import com.android.settings.applications.ApplicationsState.AppEntry; 78 import com.android.settings.deviceinfo.StorageMeasurement; 79 import com.android.settings.Utils; 80 81 import java.util.ArrayList; 82 import java.util.Comparator; 83 import java.util.List; 84 85 final class CanBeOnSdCardChecker { 86 final IPackageManager mPm; 87 int mInstallLocation; 88 89 CanBeOnSdCardChecker() { 90 mPm = IPackageManager.Stub.asInterface( 91 ServiceManager.getService("package")); 92 } 93 94 void init() { 95 try { 96 mInstallLocation = mPm.getInstallLocation(); 97 } catch (RemoteException e) { 98 Log.e("CanBeOnSdCardChecker", "Is Package Manager running?"); 99 return; 100 } 101 } 102 103 boolean check(ApplicationInfo info) { 104 boolean canBe = false; 105 if ((info.flags & ApplicationInfo.FLAG_EXTERNAL_STORAGE) != 0) { 106 canBe = true; 107 } else { 108 if ((info.flags & ApplicationInfo.FLAG_SYSTEM) == 0) { 109 if (info.installLocation == PackageInfo.INSTALL_LOCATION_PREFER_EXTERNAL || 110 info.installLocation == PackageInfo.INSTALL_LOCATION_AUTO) { 111 canBe = true; 112 } else if (info.installLocation 113 == PackageInfo.INSTALL_LOCATION_UNSPECIFIED) { 114 if (mInstallLocation == PackageHelper.APP_INSTALL_EXTERNAL) { 115 // For apps with no preference and the default value set 116 // to install on sdcard. 117 canBe = true; 118 } 119 } 120 } 121 } 122 return canBe; 123 } 124 } 125 126 interface AppClickListener { 127 void onItemClick(ManageApplications.TabInfo tab, AdapterView<?> parent, 128 View view, int position, long id); 129 } 130 131 /** 132 * Activity to pick an application that will be used to display installation information and 133 * options to uninstall/delete user data for system applications. This activity 134 * can be launched through Settings or via the ACTION_MANAGE_PACKAGE_STORAGE 135 * intent. 136 */ 137 public class ManageApplications extends Fragment implements 138 AppClickListener, DialogInterface.OnClickListener, 139 DialogInterface.OnDismissListener, OnItemSelectedListener { 140 141 static final String TAG = "ManageApplications"; 142 static final boolean DEBUG = false; 143 144 private static final String EXTRA_LIST_TYPE = "currentListType"; 145 private static final String EXTRA_SORT_ORDER = "sortOrder"; 146 private static final String EXTRA_SHOW_BACKGROUND = "showBackground"; 147 private static final String EXTRA_DEFAULT_LIST_TYPE = "defaultListType"; 148 private static final String EXTRA_RESET_DIALOG = "resetDialog"; 149 150 // attributes used as keys when passing values to InstalledAppDetails activity 151 public static final String APP_CHG = "chg"; 152 153 // constant value that can be used to check return code from sub activity. 154 private static final int INSTALLED_APP_DETAILS = 1; 155 156 public static final int SIZE_TOTAL = 0; 157 public static final int SIZE_INTERNAL = 1; 158 public static final int SIZE_EXTERNAL = 2; 159 160 // sort order that can be changed through the menu can be sorted alphabetically 161 // or size(descending) 162 private static final int MENU_OPTIONS_BASE = 0; 163 // Filter options used for displayed list of applications 164 public static final int FILTER_APPS_ALL = MENU_OPTIONS_BASE + 0; 165 public static final int FILTER_APPS_THIRD_PARTY = MENU_OPTIONS_BASE + 1; 166 public static final int FILTER_APPS_SDCARD = MENU_OPTIONS_BASE + 2; 167 public static final int FILTER_APPS_DISABLED = MENU_OPTIONS_BASE + 3; 168 169 public static final int SORT_ORDER_ALPHA = MENU_OPTIONS_BASE + 4; 170 public static final int SORT_ORDER_SIZE = MENU_OPTIONS_BASE + 5; 171 public static final int SHOW_RUNNING_SERVICES = MENU_OPTIONS_BASE + 6; 172 public static final int SHOW_BACKGROUND_PROCESSES = MENU_OPTIONS_BASE + 7; 173 public static final int RESET_APP_PREFERENCES = MENU_OPTIONS_BASE + 8; 174 // sort order 175 private int mSortOrder = SORT_ORDER_ALPHA; 176 177 private ApplicationsState mApplicationsState; 178 179 public static class TabInfo implements OnItemClickListener { 180 public final ManageApplications mOwner; 181 public final ApplicationsState mApplicationsState; 182 public final CharSequence mLabel; 183 public final int mListType; 184 public final int mFilter; 185 public final AppClickListener mClickListener; 186 public final CharSequence mInvalidSizeStr; 187 public final CharSequence mComputingSizeStr; 188 private final Bundle mSavedInstanceState; 189 190 public ApplicationsAdapter mApplications; 191 public LayoutInflater mInflater; 192 public View mRootView; 193 194 private IMediaContainerService mContainerService; 195 196 private View mLoadingContainer; 197 198 private View mListContainer; 199 200 // ListView used to display list 201 private ListView mListView; 202 // Custom view used to display running processes 203 private RunningProcessesView mRunningProcessesView; 204 205 //private LinearColorBar mColorBar; 206 //private TextView mStorageChartLabel; 207 //private TextView mUsedStorageText; 208 //private TextView mFreeStorageText; 209 private long mFreeStorage = 0, mAppStorage = 0, mTotalStorage = 0; 210 private long mLastUsedStorage, mLastAppStorage, mLastFreeStorage; 211 212 final Runnable mRunningProcessesAvail = new Runnable() { 213 public void run() { 214 handleRunningProcessesAvail(); 215 } 216 }; 217 218 public TabInfo(ManageApplications owner, ApplicationsState apps, 219 CharSequence label, int listType, AppClickListener clickListener, 220 Bundle savedInstanceState) { 221 mOwner = owner; 222 mApplicationsState = apps; 223 mLabel = label; 224 mListType = listType; 225 switch (listType) { 226 case LIST_TYPE_DOWNLOADED: mFilter = FILTER_APPS_THIRD_PARTY; break; 227 case LIST_TYPE_SDCARD: mFilter = FILTER_APPS_SDCARD; break; 228 case LIST_TYPE_DISABLED: mFilter = FILTER_APPS_DISABLED; break; 229 default: mFilter = FILTER_APPS_ALL; break; 230 } 231 mClickListener = clickListener; 232 mInvalidSizeStr = owner.getActivity().getText(R.string.invalid_size_value); 233 mComputingSizeStr = owner.getActivity().getText(R.string.computing_size); 234 mSavedInstanceState = savedInstanceState; 235 } 236 237 public void setContainerService(IMediaContainerService containerService) { 238 mContainerService = containerService; 239 updateStorageUsage(); 240 } 241 242 public View build(LayoutInflater inflater, ViewGroup contentParent, View contentChild) { 243 if (mRootView != null) { 244 return mRootView; 245 } 246 mInflater = inflater; 247 mRootView = inflater.inflate(mListType == LIST_TYPE_RUNNING 248 ? R.layout.manage_applications_running 249 : R.layout.manage_applications_apps, null); 250 mLoadingContainer = mRootView.findViewById(R.id.loading_container); 251 mLoadingContainer.setVisibility(View.VISIBLE); 252 mListContainer = mRootView.findViewById(R.id.list_container); 253 if (mListContainer != null) { 254 // Create adapter and list view here 255 View emptyView = mListContainer.findViewById(com.android.internal.R.id.empty); 256 ListView lv = (ListView) mListContainer.findViewById(android.R.id.list); 257 if (emptyView != null) { 258 lv.setEmptyView(emptyView); 259 } 260 lv.setOnItemClickListener(this); 261 lv.setSaveEnabled(true); 262 lv.setItemsCanFocus(true); 263 lv.setTextFilterEnabled(true); 264 mListView = lv; 265 mApplications = new ApplicationsAdapter(mApplicationsState, this, mFilter); 266 mListView.setAdapter(mApplications); 267 mListView.setRecyclerListener(mApplications); 268 //mColorBar = (LinearColorBar)mListContainer.findViewById(R.id.storage_color_bar); 269 //mStorageChartLabel = (TextView)mListContainer.findViewById(R.id.storageChartLabel); 270 //mUsedStorageText = (TextView)mListContainer.findViewById(R.id.usedStorageText); 271 //mFreeStorageText = (TextView)mListContainer.findViewById(R.id.freeStorageText); 272 Utils.prepareCustomPreferencesList(contentParent, contentChild, mListView, false); 273 if (mFilter == FILTER_APPS_SDCARD) { 274 //mStorageChartLabel.setText(mOwner.getActivity().getText( 275 // R.string.sd_card_storage)); 276 } else { 277 //mStorageChartLabel.setText(mOwner.getActivity().getText( 278 // R.string.internal_storage)); 279 } 280 applyCurrentStorage(); 281 } 282 mRunningProcessesView = (RunningProcessesView)mRootView.findViewById( 283 R.id.running_processes); 284 if (mRunningProcessesView != null) { 285 mRunningProcessesView.doCreate(mSavedInstanceState); 286 } 287 288 return mRootView; 289 } 290 291 public void detachView() { 292 if (mRootView != null) { 293 ViewGroup group = (ViewGroup)mRootView.getParent(); 294 if (group != null) { 295 group.removeView(mRootView); 296 } 297 } 298 } 299 300 public void resume(int sortOrder) { 301 if (mApplications != null) { 302 mApplications.resume(sortOrder); 303 } 304 if (mRunningProcessesView != null) { 305 boolean haveData = mRunningProcessesView.doResume(mOwner, mRunningProcessesAvail); 306 if (haveData) { 307 mRunningProcessesView.setVisibility(View.VISIBLE); 308 mLoadingContainer.setVisibility(View.INVISIBLE); 309 } else { 310 mLoadingContainer.setVisibility(View.VISIBLE); 311 } 312 } 313 } 314 315 public void pause() { 316 if (mApplications != null) { 317 mApplications.pause(); 318 } 319 if (mRunningProcessesView != null) { 320 mRunningProcessesView.doPause(); 321 } 322 } 323 324 public void release() { 325 if (mApplications != null) { 326 mApplications.release(); 327 } 328 } 329 330 void updateStorageUsage() { 331 // Make sure a callback didn't come at an inopportune time. 332 if (mOwner.getActivity() == null) return; 333 // Doesn't make sense for stuff that is not an app list. 334 if (mApplications == null) return; 335 336 mFreeStorage = 0; 337 mAppStorage = 0; 338 mTotalStorage = 0; 339 340 if (mFilter == FILTER_APPS_SDCARD) { 341 if (mContainerService != null) { 342 try { 343 final long[] stats = mContainerService.getFileSystemStats( 344 Environment.getExternalStorageDirectory().getPath()); 345 mTotalStorage = stats[0]; 346 mFreeStorage = stats[1]; 347 } catch (RemoteException e) { 348 Log.w(TAG, "Problem in container service", e); 349 } 350 } 351 352 if (mApplications != null) { 353 final int N = mApplications.getCount(); 354 for (int i=0; i<N; i++) { 355 ApplicationsState.AppEntry ae = mApplications.getAppEntry(i); 356 mAppStorage += ae.externalCodeSize + ae.externalDataSize 357 + ae.externalCacheSize; 358 } 359 } 360 } else { 361 if (mContainerService != null) { 362 try { 363 final long[] stats = mContainerService.getFileSystemStats( 364 Environment.getDataDirectory().getPath()); 365 mTotalStorage = stats[0]; 366 mFreeStorage = stats[1]; 367 } catch (RemoteException e) { 368 Log.w(TAG, "Problem in container service", e); 369 } 370 } 371 372 final boolean emulatedStorage = Environment.isExternalStorageEmulated(); 373 if (mApplications != null) { 374 final int N = mApplications.getCount(); 375 for (int i=0; i<N; i++) { 376 ApplicationsState.AppEntry ae = mApplications.getAppEntry(i); 377 mAppStorage += ae.codeSize + ae.dataSize; 378 if (emulatedStorage) { 379 mAppStorage += ae.externalCodeSize + ae.externalDataSize; 380 } 381 } 382 } 383 mFreeStorage += mApplicationsState.sumCacheSizes(); 384 } 385 386 applyCurrentStorage(); 387 } 388 389 void applyCurrentStorage() { 390 // If view hierarchy is not yet created, no views to update. 391 if (mRootView == null) { 392 return; 393 } 394 /* 395 if (mTotalStorage > 0) { 396 BidiFormatter bidiFormatter = BidiFormatter.getInstance(); 397 mColorBar.setRatios((mTotalStorage-mFreeStorage-mAppStorage)/(float)mTotalStorage, 398 mAppStorage/(float)mTotalStorage, mFreeStorage/(float)mTotalStorage); 399 long usedStorage = mTotalStorage - mFreeStorage; 400 if (mLastUsedStorage != usedStorage) { 401 mLastUsedStorage = usedStorage; 402 String sizeStr = bidiFormatter.unicodeWrap( 403 Formatter.formatShortFileSize(mOwner.getActivity(), usedStorage)); 404 mUsedStorageText.setText(mOwner.getActivity().getResources().getString( 405 R.string.service_foreground_processes, sizeStr)); 406 } 407 if (mLastFreeStorage != mFreeStorage) { 408 mLastFreeStorage = mFreeStorage; 409 String sizeStr = bidiFormatter.unicodeWrap( 410 Formatter.formatShortFileSize(mOwner.getActivity(), mFreeStorage)); 411 mFreeStorageText.setText(mOwner.getActivity().getResources().getString( 412 R.string.service_background_processes, sizeStr)); 413 } 414 } else { 415 mColorBar.setRatios(0, 0, 0); 416 if (mLastUsedStorage != -1) { 417 mLastUsedStorage = -1; 418 mUsedStorageText.setText(""); 419 } 420 if (mLastFreeStorage != -1) { 421 mLastFreeStorage = -1; 422 mFreeStorageText.setText(""); 423 } 424 } 425 */ 426 } 427 428 @Override 429 public void onItemClick(AdapterView<?> parent, View view, int position, long id) { 430 mClickListener.onItemClick(this, parent, view, position, id); 431 } 432 433 void handleRunningProcessesAvail() { 434 mLoadingContainer.startAnimation(AnimationUtils.loadAnimation( 435 mOwner.getActivity(), android.R.anim.fade_out)); 436 mRunningProcessesView.startAnimation(AnimationUtils.loadAnimation( 437 mOwner.getActivity(), android.R.anim.fade_in)); 438 mRunningProcessesView.setVisibility(View.VISIBLE); 439 mLoadingContainer.setVisibility(View.GONE); 440 } 441 } 442 private final ArrayList<TabInfo> mTabs = new ArrayList<TabInfo>(); 443 private int mNumTabs; 444 TabInfo mCurTab = null; 445 446 // Size resource used for packages whose size computation failed for some reason 447 CharSequence mInvalidSizeStr; 448 private CharSequence mComputingSizeStr; 449 450 // layout inflater object used to inflate views 451 private LayoutInflater mInflater; 452 453 private String mCurrentPkgName; 454 455 private Menu mOptionsMenu; 456 457 // These are for keeping track of activity and spinner switch state. 458 private boolean mActivityResumed; 459 460 private static final int LIST_TYPE_MISSING = -1; 461 static final int LIST_TYPE_DOWNLOADED = 0; 462 static final int LIST_TYPE_RUNNING = 1; 463 static final int LIST_TYPE_SDCARD = 2; 464 static final int LIST_TYPE_ALL = 3; 465 static final int LIST_TYPE_DISABLED = 4; 466 467 private boolean mShowBackground = false; 468 469 private int mDefaultListType = -1; 470 471 private ViewGroup mContentContainer; 472 private View mRootView; 473 private ViewPager mViewPager; 474 private ViewGroup mPinnedHeader; 475 private UserSpinnerAdapter mProfileSpinnerAdapter; 476 private Spinner mSpinner; 477 private Context mContext; 478 479 AlertDialog mResetDialog; 480 481 class MyPagerAdapter extends PagerAdapter 482 implements ViewPager.OnPageChangeListener { 483 int mCurPos = 0; 484 485 @Override 486 public int getCount() { 487 return mNumTabs; 488 } 489 490 @Override 491 public Object instantiateItem(ViewGroup container, int position) { 492 TabInfo tab = mTabs.get(position); 493 View root = tab.build(mInflater, mContentContainer, mRootView); 494 container.addView(root); 495 root.setTag(R.id.name, tab); 496 return root; 497 } 498 499 @Override 500 public void destroyItem(ViewGroup container, int position, Object object) { 501 container.removeView((View)object); 502 } 503 504 @Override 505 public boolean isViewFromObject(View view, Object object) { 506 return view == object; 507 } 508 509 @Override 510 public int getItemPosition(Object object) { 511 return super.getItemPosition(object); 512 //return ((TabInfo)((View)object).getTag(R.id.name)).mListType; 513 } 514 515 @Override 516 public CharSequence getPageTitle(int position) { 517 return mTabs.get(position).mLabel; 518 } 519 520 @Override 521 public void onPageScrolled(int position, float positionOffset, int positionOffsetPixels) { 522 } 523 524 @Override 525 public void onPageSelected(int position) { 526 mCurPos = position; 527 } 528 529 @Override 530 public void onPageScrollStateChanged(int state) { 531 if (state == ViewPager.SCROLL_STATE_IDLE) { 532 updateCurrentTab(mCurPos); 533 } 534 } 535 } 536 537 /* 538 * Custom adapter implementation for the ListView 539 * This adapter maintains a map for each displayed application and its properties 540 * An index value on each AppInfo object indicates the correct position or index 541 * in the list. If the list gets updated dynamically when the user is viewing the list of 542 * applications, we need to return the correct index of position. This is done by mapping 543 * the getId methods via the package name into the internal maps and indices. 544 * The order of applications in the list is mirrored in mAppLocalList 545 */ 546 static class ApplicationsAdapter extends BaseAdapter implements Filterable, 547 ApplicationsState.Callbacks, AbsListView.RecyclerListener { 548 private final ApplicationsState mState; 549 private final ApplicationsState.Session mSession; 550 private final TabInfo mTab; 551 private final Context mContext; 552 private final ArrayList<View> mActive = new ArrayList<View>(); 553 private final int mFilterMode; 554 private ArrayList<ApplicationsState.AppEntry> mBaseEntries; 555 private ArrayList<ApplicationsState.AppEntry> mEntries; 556 private boolean mResumed; 557 private int mLastSortMode=-1; 558 private boolean mWaitingForData; 559 private int mWhichSize = SIZE_TOTAL; 560 CharSequence mCurFilterPrefix; 561 562 private Filter mFilter = new Filter() { 563 @Override 564 protected FilterResults performFiltering(CharSequence constraint) { 565 ArrayList<ApplicationsState.AppEntry> entries 566 = applyPrefixFilter(constraint, mBaseEntries); 567 FilterResults fr = new FilterResults(); 568 fr.values = entries; 569 fr.count = entries.size(); 570 return fr; 571 } 572 573 @Override 574 protected void publishResults(CharSequence constraint, FilterResults results) { 575 mCurFilterPrefix = constraint; 576 mEntries = (ArrayList<ApplicationsState.AppEntry>)results.values; 577 notifyDataSetChanged(); 578 mTab.updateStorageUsage(); 579 } 580 }; 581 582 public ApplicationsAdapter(ApplicationsState state, TabInfo tab, int filterMode) { 583 mState = state; 584 mSession = state.newSession(this); 585 mTab = tab; 586 mContext = tab.mOwner.getActivity(); 587 mFilterMode = filterMode; 588 } 589 590 public void resume(int sort) { 591 if (DEBUG) Log.i(TAG, "Resume! mResumed=" + mResumed); 592 if (!mResumed) { 593 mResumed = true; 594 mSession.resume(); 595 mLastSortMode = sort; 596 rebuild(true); 597 } else { 598 rebuild(sort); 599 } 600 } 601 602 public void pause() { 603 if (mResumed) { 604 mResumed = false; 605 mSession.pause(); 606 } 607 } 608 609 public void release() { 610 mSession.release(); 611 } 612 613 public void rebuild(int sort) { 614 if (sort == mLastSortMode) { 615 return; 616 } 617 mLastSortMode = sort; 618 rebuild(true); 619 } 620 621 public void rebuild(boolean eraseold) { 622 if (DEBUG) Log.i(TAG, "Rebuilding app list..."); 623 ApplicationsState.AppFilter filterObj; 624 Comparator<AppEntry> comparatorObj; 625 boolean emulated = Environment.isExternalStorageEmulated(); 626 if (emulated) { 627 mWhichSize = SIZE_TOTAL; 628 } else { 629 mWhichSize = SIZE_INTERNAL; 630 } 631 switch (mFilterMode) { 632 case FILTER_APPS_THIRD_PARTY: 633 filterObj = ApplicationsState.THIRD_PARTY_FILTER; 634 break; 635 case FILTER_APPS_SDCARD: 636 filterObj = ApplicationsState.ON_SD_CARD_FILTER; 637 if (!emulated) { 638 mWhichSize = SIZE_EXTERNAL; 639 } 640 break; 641 case FILTER_APPS_DISABLED: 642 filterObj = ApplicationsState.DISABLED_FILTER; 643 break; 644 default: 645 filterObj = ApplicationsState.ALL_ENABLED_FILTER; 646 break; 647 } 648 switch (mLastSortMode) { 649 case SORT_ORDER_SIZE: 650 switch (mWhichSize) { 651 case SIZE_INTERNAL: 652 comparatorObj = ApplicationsState.INTERNAL_SIZE_COMPARATOR; 653 break; 654 case SIZE_EXTERNAL: 655 comparatorObj = ApplicationsState.EXTERNAL_SIZE_COMPARATOR; 656 break; 657 default: 658 comparatorObj = ApplicationsState.SIZE_COMPARATOR; 659 break; 660 } 661 break; 662 default: 663 comparatorObj = ApplicationsState.ALPHA_COMPARATOR; 664 break; 665 } 666 ArrayList<ApplicationsState.AppEntry> entries 667 = mSession.rebuild(filterObj, comparatorObj); 668 if (entries == null && !eraseold) { 669 // Don't have new list yet, but can continue using the old one. 670 return; 671 } 672 mBaseEntries = entries; 673 if (mBaseEntries != null) { 674 mEntries = applyPrefixFilter(mCurFilterPrefix, mBaseEntries); 675 } else { 676 mEntries = null; 677 } 678 notifyDataSetChanged(); 679 mTab.updateStorageUsage(); 680 681 if (entries == null) { 682 mWaitingForData = true; 683 mTab.mListContainer.setVisibility(View.INVISIBLE); 684 mTab.mLoadingContainer.setVisibility(View.VISIBLE); 685 } else { 686 mTab.mListContainer.setVisibility(View.VISIBLE); 687 mTab.mLoadingContainer.setVisibility(View.GONE); 688 } 689 } 690 691 ArrayList<ApplicationsState.AppEntry> applyPrefixFilter(CharSequence prefix, 692 ArrayList<ApplicationsState.AppEntry> origEntries) { 693 if (prefix == null || prefix.length() == 0) { 694 return origEntries; 695 } else { 696 String prefixStr = ApplicationsState.normalize(prefix.toString()); 697 final String spacePrefixStr = " " + prefixStr; 698 ArrayList<ApplicationsState.AppEntry> newEntries 699 = new ArrayList<ApplicationsState.AppEntry>(); 700 for (int i=0; i<origEntries.size(); i++) { 701 ApplicationsState.AppEntry entry = origEntries.get(i); 702 String nlabel = entry.getNormalizedLabel(); 703 if (nlabel.startsWith(prefixStr) || nlabel.indexOf(spacePrefixStr) != -1) { 704 newEntries.add(entry); 705 } 706 } 707 return newEntries; 708 } 709 } 710 711 @Override 712 public void onRunningStateChanged(boolean running) { 713 mTab.mOwner.getActivity().setProgressBarIndeterminateVisibility(running); 714 } 715 716 @Override 717 public void onRebuildComplete(ArrayList<AppEntry> apps) { 718 if (mTab.mLoadingContainer.getVisibility() == View.VISIBLE) { 719 mTab.mLoadingContainer.startAnimation(AnimationUtils.loadAnimation( 720 mContext, android.R.anim.fade_out)); 721 mTab.mListContainer.startAnimation(AnimationUtils.loadAnimation( 722 mContext, android.R.anim.fade_in)); 723 } 724 mTab.mListContainer.setVisibility(View.VISIBLE); 725 mTab.mLoadingContainer.setVisibility(View.GONE); 726 mWaitingForData = false; 727 mBaseEntries = apps; 728 mEntries = applyPrefixFilter(mCurFilterPrefix, mBaseEntries); 729 notifyDataSetChanged(); 730 mTab.updateStorageUsage(); 731 } 732 733 @Override 734 public void onPackageListChanged() { 735 rebuild(false); 736 } 737 738 @Override 739 public void onPackageIconChanged() { 740 // We ensure icons are loaded when their item is displayed, so 741 // don't care about icons loaded in the background. 742 } 743 744 @Override 745 public void onPackageSizeChanged(String packageName) { 746 for (int i=0; i<mActive.size(); i++) { 747 AppViewHolder holder = (AppViewHolder)mActive.get(i).getTag(); 748 if (holder.entry.info.packageName.equals(packageName)) { 749 synchronized (holder.entry) { 750 holder.updateSizeText(mTab.mInvalidSizeStr, mWhichSize); 751 } 752 if (holder.entry.info.packageName.equals(mTab.mOwner.mCurrentPkgName) 753 && mLastSortMode == SORT_ORDER_SIZE) { 754 // We got the size information for the last app the 755 // user viewed, and are sorting by size... they may 756 // have cleared data, so we immediately want to resort 757 // the list with the new size to reflect it to the user. 758 rebuild(false); 759 } 760 mTab.updateStorageUsage(); 761 return; 762 } 763 } 764 } 765 766 @Override 767 public void onAllSizesComputed() { 768 if (mLastSortMode == SORT_ORDER_SIZE) { 769 rebuild(false); 770 } 771 mTab.updateStorageUsage(); 772 } 773 774 public int getCount() { 775 return mEntries != null ? mEntries.size() : 0; 776 } 777 778 public Object getItem(int position) { 779 return mEntries.get(position); 780 } 781 782 public ApplicationsState.AppEntry getAppEntry(int position) { 783 return mEntries.get(position); 784 } 785 786 public long getItemId(int position) { 787 return mEntries.get(position).id; 788 } 789 790 public View getView(int position, View convertView, ViewGroup parent) { 791 // A ViewHolder keeps references to children views to avoid unnecessary calls 792 // to findViewById() on each row. 793 AppViewHolder holder = AppViewHolder.createOrRecycle(mTab.mInflater, convertView); 794 convertView = holder.rootView; 795 796 // Bind the data efficiently with the holder 797 ApplicationsState.AppEntry entry = mEntries.get(position); 798 synchronized (entry) { 799 holder.entry = entry; 800 if (entry.label != null) { 801 holder.appName.setText(entry.label); 802 } 803 mState.ensureIcon(entry); 804 if (entry.icon != null) { 805 holder.appIcon.setImageDrawable(entry.icon); 806 } 807 holder.updateSizeText(mTab.mInvalidSizeStr, mWhichSize); 808 if ((entry.info.flags&ApplicationInfo.FLAG_INSTALLED) == 0) { 809 holder.disabled.setVisibility(View.VISIBLE); 810 holder.disabled.setText(R.string.not_installed); 811 } else if (!entry.info.enabled) { 812 holder.disabled.setVisibility(View.VISIBLE); 813 holder.disabled.setText(R.string.disabled); 814 } else { 815 holder.disabled.setVisibility(View.GONE); 816 } 817 if (mFilterMode == FILTER_APPS_SDCARD) { 818 holder.checkBox.setVisibility(View.VISIBLE); 819 holder.checkBox.setChecked((entry.info.flags 820 & ApplicationInfo.FLAG_EXTERNAL_STORAGE) != 0); 821 } else { 822 holder.checkBox.setVisibility(View.GONE); 823 } 824 } 825 mActive.remove(convertView); 826 mActive.add(convertView); 827 return convertView; 828 } 829 830 @Override 831 public Filter getFilter() { 832 return mFilter; 833 } 834 835 @Override 836 public void onMovedToScrapHeap(View view) { 837 mActive.remove(view); 838 } 839 } 840 841 @Override 842 public void onCreate(Bundle savedInstanceState) { 843 super.onCreate(savedInstanceState); 844 845 setHasOptionsMenu(true); 846 847 mContext = getActivity(); 848 mApplicationsState = ApplicationsState.getInstance(getActivity().getApplication()); 849 Intent intent = getActivity().getIntent(); 850 String action = intent.getAction(); 851 int defaultListType = LIST_TYPE_DOWNLOADED; 852 String className = getArguments() != null 853 ? getArguments().getString("classname") : null; 854 if (className == null) { 855 className = intent.getComponent().getClassName(); 856 } 857 if (className.equals(RunningServicesActivity.class.getName()) 858 || className.endsWith(".RunningServices")) { 859 defaultListType = LIST_TYPE_RUNNING; 860 } else if (className.equals(StorageUseActivity.class.getName()) 861 || Intent.ACTION_MANAGE_PACKAGE_STORAGE.equals(action) 862 || className.endsWith(".StorageUse")) { 863 mSortOrder = SORT_ORDER_SIZE; 864 defaultListType = LIST_TYPE_ALL; 865 } else if (android.provider.Settings.ACTION_MANAGE_ALL_APPLICATIONS_SETTINGS.equals(action)) { 866 // Select the all-apps list, with the default sorting 867 defaultListType = LIST_TYPE_ALL; 868 } 869 870 if (savedInstanceState != null) { 871 mSortOrder = savedInstanceState.getInt(EXTRA_SORT_ORDER, mSortOrder); 872 int tmp = savedInstanceState.getInt(EXTRA_DEFAULT_LIST_TYPE, -1); 873 if (tmp != -1) defaultListType = tmp; 874 mShowBackground = savedInstanceState.getBoolean(EXTRA_SHOW_BACKGROUND, false); 875 } 876 877 mDefaultListType = defaultListType; 878 879 final Intent containerIntent = new Intent().setComponent( 880 StorageMeasurement.DEFAULT_CONTAINER_COMPONENT); 881 getActivity().bindService(containerIntent, mContainerConnection, Context.BIND_AUTO_CREATE); 882 883 mInvalidSizeStr = getActivity().getText(R.string.invalid_size_value); 884 mComputingSizeStr = getActivity().getText(R.string.computing_size); 885 886 TabInfo tab = new TabInfo(this, mApplicationsState, 887 getActivity().getString(R.string.filter_apps_third_party), 888 LIST_TYPE_DOWNLOADED, this, savedInstanceState); 889 mTabs.add(tab); 890 891 if (!Environment.isExternalStorageEmulated()) { 892 tab = new TabInfo(this, mApplicationsState, 893 getActivity().getString(R.string.filter_apps_onsdcard), 894 LIST_TYPE_SDCARD, this, savedInstanceState); 895 mTabs.add(tab); 896 } 897 898 tab = new TabInfo(this, mApplicationsState, 899 getActivity().getString(R.string.filter_apps_running), 900 LIST_TYPE_RUNNING, this, savedInstanceState); 901 mTabs.add(tab); 902 903 tab = new TabInfo(this, mApplicationsState, 904 getActivity().getString(R.string.filter_apps_all), 905 LIST_TYPE_ALL, this, savedInstanceState); 906 mTabs.add(tab); 907 908 tab = new TabInfo(this, mApplicationsState, 909 getActivity().getString(R.string.filter_apps_disabled), 910 LIST_TYPE_DISABLED, this, savedInstanceState); 911 mTabs.add(tab); 912 913 mNumTabs = mTabs.size(); 914 915 final UserManager um = (UserManager) mContext.getSystemService(Context.USER_SERVICE); 916 mProfileSpinnerAdapter = Utils.createUserSpinnerAdapter(um, mContext); 917 } 918 919 920 @Override 921 public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) { 922 // initialize the inflater 923 mInflater = inflater; 924 925 View rootView = mInflater.inflate(R.layout.manage_applications_content, 926 container, false); 927 mContentContainer = container; 928 mRootView = rootView; 929 mPinnedHeader = (ViewGroup) mRootView.findViewById(R.id.pinned_header); 930 if (mProfileSpinnerAdapter != null) { 931 mSpinner = (Spinner) inflater.inflate(R.layout.spinner_view, null); 932 mSpinner.setAdapter(mProfileSpinnerAdapter); 933 mSpinner.setOnItemSelectedListener(this); 934 mPinnedHeader.addView(mSpinner); 935 mPinnedHeader.setVisibility(View.VISIBLE); 936 } 937 mViewPager = (ViewPager) rootView.findViewById(R.id.pager); 938 MyPagerAdapter adapter = new MyPagerAdapter(); 939 mViewPager.setAdapter(adapter); 940 mViewPager.setOnPageChangeListener(adapter); 941 PagerTabStrip tabs = (PagerTabStrip) rootView.findViewById(R.id.tabs); 942 tabs.setTabIndicatorColorResource(R.color.theme_accent); 943 944 // We have to do this now because PreferenceFrameLayout looks at it 945 // only when the view is added. 946 if (container instanceof PreferenceFrameLayout) { 947 ((PreferenceFrameLayout.LayoutParams) rootView.getLayoutParams()).removeBorders = true; 948 } 949 950 if (savedInstanceState != null && savedInstanceState.getBoolean(EXTRA_RESET_DIALOG)) { 951 buildResetDialog(); 952 } 953 954 if (savedInstanceState == null) { 955 // First time init: make sure view pager is showing the correct tab. 956 int extraCurrentListType = getActivity().getIntent().getIntExtra(EXTRA_LIST_TYPE, 957 LIST_TYPE_MISSING); 958 int currentListType = (extraCurrentListType != LIST_TYPE_MISSING) 959 ? extraCurrentListType : mDefaultListType; 960 for (int i = 0; i < mNumTabs; i++) { 961 TabInfo tab = mTabs.get(i); 962 if (tab.mListType == currentListType) { 963 mViewPager.setCurrentItem(i); 964 break; 965 } 966 } 967 } 968 969 return rootView; 970 } 971 972 @Override 973 public void onStart() { 974 super.onStart(); 975 } 976 977 @Override 978 public void onResume() { 979 super.onResume(); 980 mActivityResumed = true; 981 updateCurrentTab(mViewPager.getCurrentItem()); 982 updateNumTabs(); 983 updateOptionsMenu(); 984 } 985 986 @Override 987 public void onSaveInstanceState(Bundle outState) { 988 super.onSaveInstanceState(outState); 989 outState.putInt(EXTRA_SORT_ORDER, mSortOrder); 990 if (mDefaultListType != -1) { 991 outState.putInt(EXTRA_DEFAULT_LIST_TYPE, mDefaultListType); 992 } 993 outState.putBoolean(EXTRA_SHOW_BACKGROUND, mShowBackground); 994 if (mResetDialog != null) { 995 outState.putBoolean(EXTRA_RESET_DIALOG, true); 996 } 997 } 998 999 @Override 1000 public void onPause() { 1001 super.onPause(); 1002 mActivityResumed = false; 1003 for (int i=0; i<mTabs.size(); i++) { 1004 mTabs.get(i).pause(); 1005 } 1006 } 1007 1008 @Override 1009 public void onStop() { 1010 super.onStop(); 1011 if (mResetDialog != null) { 1012 mResetDialog.dismiss(); 1013 mResetDialog = null; 1014 } 1015 } 1016 1017 @Override 1018 public void onDestroyView() { 1019 super.onDestroyView(); 1020 1021 // We are going to keep the tab data structures around, but they 1022 // are no longer attached to their view hierarchy. 1023 for (int i=0; i<mTabs.size(); i++) { 1024 mTabs.get(i).detachView(); 1025 mTabs.get(i).release(); 1026 } 1027 } 1028 1029 @Override 1030 public void onActivityResult(int requestCode, int resultCode, Intent data) { 1031 if (requestCode == INSTALLED_APP_DETAILS && mCurrentPkgName != null) { 1032 mApplicationsState.requestSize(mCurrentPkgName); 1033 } 1034 } 1035 1036 @Override 1037 public void onItemSelected(AdapterView<?> parent, View view, int position, long id) { 1038 UserHandle selectedUser = mProfileSpinnerAdapter.getUserHandle(position); 1039 if (selectedUser.getIdentifier() != UserHandle.myUserId()) { 1040 Intent intent = new Intent(Settings.ACTION_APPLICATION_SETTINGS); 1041 intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK); 1042 intent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TASK); 1043 int currentTab = mViewPager.getCurrentItem(); 1044 intent.putExtra(EXTRA_LIST_TYPE, mTabs.get(currentTab).mListType); 1045 mContext.startActivityAsUser(intent, selectedUser); 1046 // Go back to default selection, which is the first one; this makes sure that pressing 1047 // the back button takes you into a consistent state 1048 mSpinner.setSelection(0); 1049 } 1050 } 1051 1052 @Override 1053 public void onNothingSelected(AdapterView<?> parent) { 1054 // Nothing to do 1055 } 1056 1057 private void updateNumTabs() { 1058 int newNum = mApplicationsState.haveDisabledApps() ? mTabs.size() : (mTabs.size()-1); 1059 if (newNum != mNumTabs) { 1060 mNumTabs = newNum; 1061 if (mViewPager != null) { 1062 mViewPager.getAdapter().notifyDataSetChanged(); 1063 } 1064 } 1065 } 1066 1067 TabInfo tabForType(int type) { 1068 for (int i = 0; i < mTabs.size(); i++) { 1069 TabInfo tab = mTabs.get(i); 1070 if (tab.mListType == type) { 1071 return tab; 1072 } 1073 } 1074 return null; 1075 } 1076 1077 // utility method used to start sub activity 1078 private void startApplicationDetailsActivity() { 1079 // start new fragment to display extended information 1080 Bundle args = new Bundle(); 1081 args.putString(InstalledAppDetails.ARG_PACKAGE_NAME, mCurrentPkgName); 1082 1083 SettingsActivity sa = (SettingsActivity) getActivity(); 1084 sa.startPreferencePanel(InstalledAppDetails.class.getName(), args, 1085 R.string.application_info_label, null, this, INSTALLED_APP_DETAILS); 1086 } 1087 1088 @Override 1089 public void onCreateOptionsMenu(Menu menu, MenuInflater inflater) { 1090 mOptionsMenu = menu; 1091 // note: icons removed for now because the cause the new action 1092 // bar UI to be very confusing. 1093 menu.add(0, SORT_ORDER_ALPHA, 1, R.string.sort_order_alpha) 1094 //.setIcon(android.R.drawable.ic_menu_sort_alphabetically) 1095 .setShowAsAction(MenuItem.SHOW_AS_ACTION_NEVER); 1096 menu.add(0, SORT_ORDER_SIZE, 2, R.string.sort_order_size) 1097 //.setIcon(android.R.drawable.ic_menu_sort_by_size) 1098 .setShowAsAction(MenuItem.SHOW_AS_ACTION_NEVER); 1099 menu.add(0, SHOW_RUNNING_SERVICES, 3, R.string.show_running_services) 1100 .setShowAsAction(MenuItem.SHOW_AS_ACTION_IF_ROOM); 1101 menu.add(0, SHOW_BACKGROUND_PROCESSES, 3, R.string.show_background_processes) 1102 .setShowAsAction(MenuItem.SHOW_AS_ACTION_IF_ROOM); 1103 menu.add(0, RESET_APP_PREFERENCES, 4, R.string.reset_app_preferences) 1104 .setShowAsAction(MenuItem.SHOW_AS_ACTION_NEVER); 1105 updateOptionsMenu(); 1106 } 1107 1108 @Override 1109 public void onPrepareOptionsMenu(Menu menu) { 1110 updateOptionsMenu(); 1111 } 1112 1113 @Override 1114 public void onDestroyOptionsMenu() { 1115 mOptionsMenu = null; 1116 } 1117 1118 @Override 1119 public void onDestroy() { 1120 getActivity().unbindService(mContainerConnection); 1121 super.onDestroy(); 1122 } 1123 1124 void updateOptionsMenu() { 1125 if (mOptionsMenu == null) { 1126 return; 1127 } 1128 1129 /* 1130 * The running processes screen doesn't use the mApplicationsAdapter 1131 * so bringing up this menu in that case doesn't make any sense. 1132 */ 1133 if (mCurTab != null && mCurTab.mListType == LIST_TYPE_RUNNING) { 1134 TabInfo tab = tabForType(LIST_TYPE_RUNNING); 1135 boolean showingBackground = tab != null && tab.mRunningProcessesView != null 1136 ? tab.mRunningProcessesView.mAdapter.getShowBackground() : false; 1137 mOptionsMenu.findItem(SORT_ORDER_ALPHA).setVisible(false); 1138 mOptionsMenu.findItem(SORT_ORDER_SIZE).setVisible(false); 1139 mOptionsMenu.findItem(SHOW_RUNNING_SERVICES).setVisible(showingBackground); 1140 mOptionsMenu.findItem(SHOW_BACKGROUND_PROCESSES).setVisible(!showingBackground); 1141 mOptionsMenu.findItem(RESET_APP_PREFERENCES).setVisible(false); 1142 mShowBackground = showingBackground; 1143 } else { 1144 mOptionsMenu.findItem(SORT_ORDER_ALPHA).setVisible(mSortOrder != SORT_ORDER_ALPHA); 1145 mOptionsMenu.findItem(SORT_ORDER_SIZE).setVisible(mSortOrder != SORT_ORDER_SIZE); 1146 mOptionsMenu.findItem(SHOW_RUNNING_SERVICES).setVisible(false); 1147 mOptionsMenu.findItem(SHOW_BACKGROUND_PROCESSES).setVisible(false); 1148 mOptionsMenu.findItem(RESET_APP_PREFERENCES).setVisible(true); 1149 } 1150 } 1151 1152 void buildResetDialog() { 1153 if (mResetDialog == null) { 1154 AlertDialog.Builder builder = new AlertDialog.Builder(getActivity()); 1155 builder.setTitle(R.string.reset_app_preferences_title); 1156 builder.setMessage(R.string.reset_app_preferences_desc); 1157 builder.setPositiveButton(R.string.reset_app_preferences_button, this); 1158 builder.setNegativeButton(R.string.cancel, null); 1159 mResetDialog = builder.show(); 1160 mResetDialog.setOnDismissListener(this); 1161 } 1162 } 1163 1164 @Override 1165 public void onDismiss(DialogInterface dialog) { 1166 if (mResetDialog == dialog) { 1167 mResetDialog = null; 1168 } 1169 } 1170 1171 1172 @Override 1173 public void onClick(DialogInterface dialog, int which) { 1174 if (mResetDialog == dialog) { 1175 final PackageManager pm = getActivity().getPackageManager(); 1176 final IPackageManager mIPm = IPackageManager.Stub.asInterface( 1177 ServiceManager.getService("package")); 1178 final INotificationManager nm = INotificationManager.Stub.asInterface( 1179 ServiceManager.getService(Context.NOTIFICATION_SERVICE)); 1180 final NetworkPolicyManager npm = NetworkPolicyManager.from(getActivity()); 1181 final AppOpsManager aom = (AppOpsManager)getActivity().getSystemService( 1182 Context.APP_OPS_SERVICE); 1183 final Handler handler = new Handler(getActivity().getMainLooper()); 1184 (new AsyncTask<Void, Void, Void>() { 1185 @Override protected Void doInBackground(Void... params) { 1186 List<ApplicationInfo> apps = pm.getInstalledApplications( 1187 PackageManager.GET_DISABLED_COMPONENTS); 1188 for (int i=0; i<apps.size(); i++) { 1189 ApplicationInfo app = apps.get(i); 1190 try { 1191 if (DEBUG) Log.v(TAG, "Enabling notifications: " + app.packageName); 1192 nm.setNotificationsEnabledForPackage(app.packageName, app.uid, true); 1193 } catch (android.os.RemoteException ex) { 1194 } 1195 if (!app.enabled) { 1196 if (DEBUG) Log.v(TAG, "Enabling app: " + app.packageName); 1197 if (pm.getApplicationEnabledSetting(app.packageName) 1198 == PackageManager.COMPONENT_ENABLED_STATE_DISABLED_USER) { 1199 pm.setApplicationEnabledSetting(app.packageName, 1200 PackageManager.COMPONENT_ENABLED_STATE_DEFAULT, 1201 PackageManager.DONT_KILL_APP); 1202 } 1203 } 1204 } 1205 try { 1206 mIPm.resetPreferredActivities(UserHandle.myUserId()); 1207 } catch (RemoteException e) { 1208 } 1209 aom.resetAllModes(); 1210 final int[] restrictedUids = npm.getUidsWithPolicy( 1211 POLICY_REJECT_METERED_BACKGROUND); 1212 final int currentUserId = ActivityManager.getCurrentUser(); 1213 for (int uid : restrictedUids) { 1214 // Only reset for current user 1215 if (UserHandle.getUserId(uid) == currentUserId) { 1216 if (DEBUG) Log.v(TAG, "Clearing data policy: " + uid); 1217 npm.setUidPolicy(uid, POLICY_NONE); 1218 } 1219 } 1220 handler.post(new Runnable() { 1221 @Override public void run() { 1222 if (DEBUG) Log.v(TAG, "Done clearing"); 1223 if (getActivity() != null && mActivityResumed) { 1224 if (DEBUG) Log.v(TAG, "Updating UI!"); 1225 for (int i=0; i<mTabs.size(); i++) { 1226 TabInfo tab = mTabs.get(i); 1227 if (tab.mApplications != null) { 1228 tab.mApplications.pause(); 1229 } 1230 } 1231 if (mCurTab != null) { 1232 mCurTab.resume(mSortOrder); 1233 } 1234 } 1235 } 1236 }); 1237 return null; 1238 } 1239 }).execute(); 1240 } 1241 } 1242 1243 @Override 1244 public boolean onOptionsItemSelected(MenuItem item) { 1245 int menuId = item.getItemId(); 1246 if ((menuId == SORT_ORDER_ALPHA) || (menuId == SORT_ORDER_SIZE)) { 1247 mSortOrder = menuId; 1248 if (mCurTab != null && mCurTab.mApplications != null) { 1249 mCurTab.mApplications.rebuild(mSortOrder); 1250 } 1251 } else if (menuId == SHOW_RUNNING_SERVICES) { 1252 mShowBackground = false; 1253 if (mCurTab != null && mCurTab.mRunningProcessesView != null) { 1254 mCurTab.mRunningProcessesView.mAdapter.setShowBackground(false); 1255 } 1256 } else if (menuId == SHOW_BACKGROUND_PROCESSES) { 1257 mShowBackground = true; 1258 if (mCurTab != null && mCurTab.mRunningProcessesView != null) { 1259 mCurTab.mRunningProcessesView.mAdapter.setShowBackground(true); 1260 } 1261 } else if (menuId == RESET_APP_PREFERENCES) { 1262 buildResetDialog(); 1263 } else { 1264 // Handle the home button 1265 return false; 1266 } 1267 updateOptionsMenu(); 1268 return true; 1269 } 1270 1271 public void onItemClick(TabInfo tab, AdapterView<?> parent, View view, int position, 1272 long id) { 1273 if (tab.mApplications != null && tab.mApplications.getCount() > position) { 1274 ApplicationsState.AppEntry entry = tab.mApplications.getAppEntry(position); 1275 mCurrentPkgName = entry.info.packageName; 1276 startApplicationDetailsActivity(); 1277 } 1278 } 1279 1280 public void updateCurrentTab(int position) { 1281 TabInfo tab = mTabs.get(position); 1282 mCurTab = tab; 1283 1284 // Put things in the correct paused/resumed state. 1285 if (mActivityResumed) { 1286 mCurTab.build(mInflater, mContentContainer, mRootView); 1287 mCurTab.resume(mSortOrder); 1288 } else { 1289 mCurTab.pause(); 1290 } 1291 for (int i=0; i<mTabs.size(); i++) { 1292 TabInfo t = mTabs.get(i); 1293 if (t != mCurTab) { 1294 t.pause(); 1295 } 1296 } 1297 1298 mCurTab.updateStorageUsage(); 1299 updateOptionsMenu(); 1300 final Activity host = getActivity(); 1301 if (host != null) { 1302 host.invalidateOptionsMenu(); 1303 } 1304 } 1305 1306 private volatile IMediaContainerService mContainerService; 1307 1308 private final ServiceConnection mContainerConnection = new ServiceConnection() { 1309 @Override 1310 public void onServiceConnected(ComponentName name, IBinder service) { 1311 mContainerService = IMediaContainerService.Stub.asInterface(service); 1312 for (int i=0; i<mTabs.size(); i++) { 1313 mTabs.get(i).setContainerService(mContainerService); 1314 } 1315 } 1316 1317 @Override 1318 public void onServiceDisconnected(ComponentName name) { 1319 mContainerService = null; 1320 } 1321 }; 1322 } 1323
