src/com/android/settings/applications/AppStorageSettings.java

   1 /*
   2  * Copyright (C) 2015 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 android.app.ActivityManager;
  20 import android.app.AlertDialog;
  21 import android.app.AppGlobals;
  22 import android.content.Context;
  23 import android.content.DialogInterface;
  24 import android.content.Intent;
  25 import android.content.UriPermission;
  26 import android.content.pm.ApplicationInfo;
  27 import android.content.pm.IPackageDataObserver;
  28 import android.content.pm.PackageManager;
  29 import android.content.pm.ProviderInfo;
  30 import android.os.Bundle;
  31 import android.os.Environment;
  32 import android.os.Handler;
  33 import android.os.Message;
  34 import android.os.RemoteException;
  35 import android.os.UserHandle;
  36 import android.os.storage.StorageManager;
  37 import android.os.storage.VolumeInfo;
  38 import android.support.v7.preference.Preference;
  39 import android.support.v7.preference.PreferenceCategory;
  40 import android.text.format.Formatter;
  41 import android.util.Log;
  42 import android.util.MutableInt;
  43 import android.view.View;
  44 import android.view.View.OnClickListener;
  45 import android.widget.Button;
  46
  47 import com.android.internal.logging.MetricsProto.MetricsEvent;
  48 import com.android.settings.R;
  49 import com.android.settings.Utils;
  50 import com.android.settings.deviceinfo.StorageWizardMoveConfirm;
  51 import com.android.settingslib.RestrictedLockUtils;
  52 import com.android.settingslib.applications.ApplicationsState;
  53 import com.android.settingslib.applications.ApplicationsState.AppEntry;
  54 import com.android.settingslib.applications.ApplicationsState.Callbacks;
  55
  56 import java.util.ArrayList;
  57 import java.util.Collections;
  58 import java.util.List;
  59 import java.util.Map;
  60 import java.util.Objects;
  61 import java.util.TreeMap;
  62
  63 import static android.content.pm.ApplicationInfo.FLAG_ALLOW_CLEAR_USER_DATA;
  64 import static android.content.pm.ApplicationInfo.FLAG_SYSTEM;
  65
  66 public class AppStorageSettings extends AppInfoWithHeader
  67         implements OnClickListener, Callbacks, DialogInterface.OnClickListener {
  68     private static final String TAG = AppStorageSettings.class.getSimpleName();
  69
  70     //internal constants used in Handler
  71     private static final int OP_SUCCESSFUL = 1;
  72     private static final int OP_FAILED = 2;
  73     private static final int MSG_CLEAR_USER_DATA = 1;
  74     private static final int MSG_CLEAR_CACHE = 3;
  75
  76     // invalid size value used initially and also when size retrieval through PackageManager
  77     // fails for whatever reason
  78     private static final int SIZE_INVALID = -1;
  79
  80     // Result code identifiers
  81     public static final int REQUEST_MANAGE_SPACE = 2;
  82
  83     private static final int DLG_CLEAR_DATA = DLG_BASE + 1;
  84     private static final int DLG_CANNOT_CLEAR_DATA = DLG_BASE + 2;
  85
  86     private static final String KEY_STORAGE_USED = "storage_used";
  87     private static final String KEY_CHANGE_STORAGE = "change_storage_button";
  88     private static final String KEY_STORAGE_SPACE = "storage_space";
  89     private static final String KEY_STORAGE_CATEGORY = "storage_category";
  90
  91     private static final String KEY_TOTAL_SIZE = "total_size";
  92     private static final String KEY_APP_SIZE = "app_size";
  93     private static final String KEY_EXTERNAL_CODE_SIZE = "external_code_size";
  94     private static final String KEY_DATA_SIZE = "data_size";
  95     private static final String KEY_EXTERNAL_DATA_SIZE = "external_data_size";
  96     private static final String KEY_CACHE_SIZE = "cache_size";
  97
  98     private static final String KEY_CLEAR_DATA = "clear_data_button";
  99     private static final String KEY_CLEAR_CACHE = "clear_cache_button";
 100
 101     private static final String KEY_URI_CATEGORY = "uri_category";
 102     private static final String KEY_CLEAR_URI = "clear_uri_button";
 103
 104     private Preference mTotalSize;
 105     private Preference mAppSize;
 106     private Preference mDataSize;
 107     private Preference mExternalCodeSize;
 108     private Preference mExternalDataSize;
 109
 110     // Views related to cache info
 111     private Preference mCacheSize;
 112     private Button mClearDataButton;
 113     private Button mClearCacheButton;
 114
 115     private Preference mStorageUsed;
 116     private Button mChangeStorageButton;
 117
 118     // Views related to URI permissions
 119     private Button mClearUriButton;
 120     private LayoutPreference mClearUri;
 121     private PreferenceCategory mUri;
 122
 123     private boolean mCanClearData = true;
 124     private boolean mHaveSizes = false;
 125
 126     private long mLastCodeSize = -1;
 127     private long mLastDataSize = -1;
 128     private long mLastExternalCodeSize = -1;
 129     private long mLastExternalDataSize = -1;
 130     private long mLastCacheSize = -1;
 131     private long mLastTotalSize = -1;
 132
 133     private ClearCacheObserver mClearCacheObserver;
 134     private ClearUserDataObserver mClearDataObserver;
 135
 136     // Resource strings
 137     private CharSequence mInvalidSizeStr;
 138     private CharSequence mComputingStr;
 139
 140     private VolumeInfo[] mCandidates;
 141     private AlertDialog.Builder mDialogBuilder;
 142
 143     @Override
 144     public void onCreate(Bundle savedInstanceState) {
 145         super.onCreate(savedInstanceState);
 146
 147         addPreferencesFromResource(R.xml.app_storage_settings);
 148         setupViews();
 149         initMoveDialog();
 150     }
 151
 152     @Override
 153     public void onResume() {
 154         super.onResume();
 155         mState.requestSize(mPackageName, mUserId);
 156     }
 157
 158     private void setupViews() {
 159         mComputingStr = getActivity().getText(R.string.computing_size);
 160         mInvalidSizeStr = getActivity().getText(R.string.invalid_size_value);
 161
 162         // Set default values on sizes
 163         mTotalSize = findPreference(KEY_TOTAL_SIZE);
 164         mAppSize =  findPreference(KEY_APP_SIZE);
 165         mDataSize =  findPreference(KEY_DATA_SIZE);
 166         mExternalCodeSize = findPreference(KEY_EXTERNAL_CODE_SIZE);
 167         mExternalDataSize = findPreference(KEY_EXTERNAL_DATA_SIZE);
 168
 169         if (Environment.isExternalStorageEmulated()) {
 170             PreferenceCategory category = (PreferenceCategory) findPreference(KEY_STORAGE_CATEGORY);
 171             category.removePreference(mExternalCodeSize);
 172             category.removePreference(mExternalDataSize);
 173         }
 174         mClearDataButton = (Button) ((LayoutPreference) findPreference(KEY_CLEAR_DATA))
 175                 .findViewById(R.id.button);
 176
 177         mStorageUsed = findPreference(KEY_STORAGE_USED);
 178         mChangeStorageButton = (Button) ((LayoutPreference) findPreference(KEY_CHANGE_STORAGE))
 179                 .findViewById(R.id.button);
 180         mChangeStorageButton.setText(R.string.change);
 181         mChangeStorageButton.setOnClickListener(this);
 182
 183         // Cache section
 184         mCacheSize = findPreference(KEY_CACHE_SIZE);
 185         mClearCacheButton = (Button) ((LayoutPreference) findPreference(KEY_CLEAR_CACHE))
 186                 .findViewById(R.id.button);
 187         mClearCacheButton.setText(R.string.clear_cache_btn_text);
 188
 189         // URI permissions section
 190         mUri = (PreferenceCategory) findPreference(KEY_URI_CATEGORY);
 191         mClearUri = (LayoutPreference) mUri.findPreference(KEY_CLEAR_URI);
 192         mClearUriButton = (Button) mClearUri.findViewById(R.id.button);
 193         mClearUriButton.setText(R.string.clear_uri_btn_text);
 194         mClearUriButton.setOnClickListener(this);
 195     }
 196
 197     @Override
 198     public void onClick(View v) {
 199         if (v == mClearCacheButton) {
 200             if (mAppsControlDisallowedAdmin != null && !mAppsControlDisallowedBySystem) {
 201                 RestrictedLockUtils.sendShowAdminSupportDetailsIntent(
 202                         getActivity(), mAppsControlDisallowedAdmin);
 203                 return;
 204             } else if (mClearCacheObserver == null) { // Lazy initialization of observer
 205                 mClearCacheObserver = new ClearCacheObserver();
 206             }
 207             mPm.deleteApplicationCacheFiles(mPackageName, mClearCacheObserver);
 208         } else if (v == mClearDataButton) {
 209             if (mAppsControlDisallowedAdmin != null && !mAppsControlDisallowedBySystem) {
 210                 RestrictedLockUtils.sendShowAdminSupportDetailsIntent(
 211                         getActivity(), mAppsControlDisallowedAdmin);
 212             } else if (mAppEntry.info.manageSpaceActivityName != null) {
 213                 if (!Utils.isMonkeyRunning()) {
 214                     Intent intent = new Intent(Intent.ACTION_DEFAULT);
 215                     intent.setClassName(mAppEntry.info.packageName,
 216                             mAppEntry.info.manageSpaceActivityName);
 217                     startActivityForResult(intent, REQUEST_MANAGE_SPACE);
 218                 }
 219             } else {
 220                 showDialogInner(DLG_CLEAR_DATA, 0);
 221             }
 222         } else if (v == mChangeStorageButton && mDialogBuilder != null && !isMoveInProgress()) {
 223             mDialogBuilder.show();
 224         } else if (v == mClearUriButton) {
 225             if (mAppsControlDisallowedAdmin != null && !mAppsControlDisallowedBySystem) {
 226                 RestrictedLockUtils.sendShowAdminSupportDetailsIntent(
 227                         getActivity(), mAppsControlDisallowedAdmin);
 228             } else {
 229                 clearUriPermissions();
 230             }
 231         }
 232     }
 233
 234     private boolean isMoveInProgress() {
 235         try {
 236             // TODO: define a cleaner API for this
 237             AppGlobals.getPackageManager().checkPackageStartable(mPackageName,
 238                     UserHandle.myUserId());
 239             return false;
 240         } catch (RemoteException | SecurityException e) {
 241             return true;
 242         }
 243     }
 244
 245     @Override
 246     public void onClick(DialogInterface dialog, int which) {
 247         final Context context = getActivity();
 248
 249         // If not current volume, kick off move wizard
 250         final VolumeInfo targetVol = mCandidates[which];
 251         final VolumeInfo currentVol = context.getPackageManager().getPackageCurrentVolume(
 252                 mAppEntry.info);
 253         if (!Objects.equals(targetVol, currentVol)) {
 254             final Intent intent = new Intent(context, StorageWizardMoveConfirm.class);
 255             intent.putExtra(VolumeInfo.EXTRA_VOLUME_ID, targetVol.getId());
 256             intent.putExtra(Intent.EXTRA_PACKAGE_NAME, mAppEntry.info.packageName);
 257             startActivity(intent);
 258         }
 259         dialog.dismiss();
 260     }
 261
 262     private String getSizeStr(long size) {
 263         if (size == SIZE_INVALID) {
 264             return mInvalidSizeStr.toString();
 265         }
 266         return Formatter.formatFileSize(getActivity(), size);
 267     }
 268
 269     private void refreshSizeInfo() {
 270         if (mAppEntry.size == ApplicationsState.SIZE_INVALID
 271                 || mAppEntry.size == ApplicationsState.SIZE_UNKNOWN) {
 272             mLastCodeSize = mLastDataSize = mLastCacheSize = mLastTotalSize = -1;
 273             if (!mHaveSizes) {
 274                 mAppSize.setSummary(mComputingStr);
 275                 mDataSize.setSummary(mComputingStr);
 276                 mCacheSize.setSummary(mComputingStr);
 277                 mTotalSize.setSummary(mComputingStr);
 278             }
 279             mClearDataButton.setEnabled(false);
 280             mClearCacheButton.setEnabled(false);
 281         } else {
 282             mHaveSizes = true;
 283             long codeSize = mAppEntry.codeSize;
 284             long dataSize = mAppEntry.dataSize;
 285             if (Environment.isExternalStorageEmulated()) {
 286                 codeSize += mAppEntry.externalCodeSize;
 287                 dataSize +=  mAppEntry.externalDataSize;
 288             } else {
 289                 if (mLastExternalCodeSize != mAppEntry.externalCodeSize) {
 290                     mLastExternalCodeSize = mAppEntry.externalCodeSize;
 291                     mExternalCodeSize.setSummary(getSizeStr(mAppEntry.externalCodeSize));
 292                 }
 293                 if (mLastExternalDataSize !=  mAppEntry.externalDataSize) {
 294                     mLastExternalDataSize =  mAppEntry.externalDataSize;
 295                     mExternalDataSize.setSummary(getSizeStr( mAppEntry.externalDataSize));
 296                 }
 297             }
 298             if (mLastCodeSize != codeSize) {
 299                 mLastCodeSize = codeSize;
 300                 mAppSize.setSummary(getSizeStr(codeSize));
 301             }
 302             if (mLastDataSize != dataSize) {
 303                 mLastDataSize = dataSize;
 304                 mDataSize.setSummary(getSizeStr(dataSize));
 305             }
 306             long cacheSize = mAppEntry.cacheSize + mAppEntry.externalCacheSize;
 307             if (mLastCacheSize != cacheSize) {
 308                 mLastCacheSize = cacheSize;
 309                 mCacheSize.setSummary(getSizeStr(cacheSize));
 310             }
 311             if (mLastTotalSize != mAppEntry.size) {
 312                 mLastTotalSize = mAppEntry.size;
 313                 mTotalSize.setSummary(getSizeStr(mAppEntry.size));
 314             }
 315
 316             if ((mAppEntry.dataSize+ mAppEntry.externalDataSize) <= 0 || !mCanClearData) {
 317                 mClearDataButton.setEnabled(false);
 318             } else {
 319                 mClearDataButton.setEnabled(true);
 320                 mClearDataButton.setOnClickListener(this);
 321             }
 322             if (cacheSize <= 0) {
 323                 mClearCacheButton.setEnabled(false);
 324             } else {
 325                 mClearCacheButton.setEnabled(true);
 326                 mClearCacheButton.setOnClickListener(this);
 327             }
 328         }
 329         if (mAppsControlDisallowedBySystem) {
 330             mClearCacheButton.setEnabled(false);
 331             mClearDataButton.setEnabled(false);
 332         }
 333     }
 334
 335     @Override
 336     protected boolean refreshUi() {
 337         retrieveAppEntry();
 338         if (mAppEntry == null) {
 339             return false;
 340         }
 341         refreshSizeInfo();
 342         refreshGrantedUriPermissions();
 343
 344         final VolumeInfo currentVol = getActivity().getPackageManager()
 345                 .getPackageCurrentVolume(mAppEntry.info);
 346         final StorageManager storage = getContext().getSystemService(StorageManager.class);
 347         mStorageUsed.setSummary(storage.getBestVolumeDescription(currentVol));
 348
 349         refreshButtons();
 350
 351         return true;
 352     }
 353
 354     private void refreshButtons() {
 355         initMoveDialog();
 356         initDataButtons();
 357     }
 358
 359     private void initDataButtons() {
 360         final boolean appHasSpaceManagementUI = mAppEntry.info.manageSpaceActivityName != null;
 361         final boolean appHasActiveAdmins = mDpm.packageHasActiveAdmins(mPackageName);
 362         // Check that SYSTEM_APP flag is set, and ALLOW_CLEAR_USER_DATA is not set.
 363         final boolean isNonClearableSystemApp =
 364                 (mAppEntry.info.flags & (FLAG_SYSTEM | FLAG_ALLOW_CLEAR_USER_DATA)) == FLAG_SYSTEM;
 365         final boolean appRestrictsClearingData = isNonClearableSystemApp || appHasActiveAdmins;
 366
 367         final Intent intent = new Intent(Intent.ACTION_DEFAULT);
 368         if (appHasSpaceManagementUI) {
 369             intent.setClassName(mAppEntry.info.packageName, mAppEntry.info.manageSpaceActivityName);
 370         }
 371         final boolean isManageSpaceActivityAvailable =
 372                 getPackageManager().resolveActivity(intent, 0) != null;
 373
 374         if ((!appHasSpaceManagementUI && appRestrictsClearingData)
 375                 || !isManageSpaceActivityAvailable) {
 376             mClearDataButton.setText(R.string.clear_user_data_text);
 377             mClearDataButton.setEnabled(false);
 378             mCanClearData = false;
 379         } else {
 380             if (appHasSpaceManagementUI) {
 381                 mClearDataButton.setText(R.string.manage_space_text);
 382             } else {
 383                 mClearDataButton.setText(R.string.clear_user_data_text);
 384             }
 385             mClearDataButton.setOnClickListener(this);
 386         }
 387
 388         if (mAppsControlDisallowedBySystem) {
 389             mClearDataButton.setEnabled(false);
 390         }
 391     }
 392
 393     private void initMoveDialog() {
 394         final Context context = getActivity();
 395         final StorageManager storage = context.getSystemService(StorageManager.class);
 396
 397         final List<VolumeInfo> candidates = context.getPackageManager()
 398                 .getPackageCandidateVolumes(mAppEntry.info);
 399         if (candidates.size() > 1) {
 400             Collections.sort(candidates, VolumeInfo.getDescriptionComparator());
 401
 402             CharSequence[] labels = new CharSequence[candidates.size()];
 403             int current = -1;
 404             for (int i = 0; i < candidates.size(); i++) {
 405                 final String volDescrip = storage.getBestVolumeDescription(candidates.get(i));
 406                 if (Objects.equals(volDescrip, mStorageUsed.getSummary())) {
 407                     current = i;
 408                 }
 409                 labels[i] = volDescrip;
 410             }
 411             mCandidates = candidates.toArray(new VolumeInfo[candidates.size()]);
 412             mDialogBuilder = new AlertDialog.Builder(getContext())
 413                     .setTitle(R.string.change_storage)
 414                     .setSingleChoiceItems(labels, current, this)
 415                     .setNegativeButton(R.string.cancel, null);
 416         } else {
 417             removePreference(KEY_STORAGE_USED);
 418             removePreference(KEY_CHANGE_STORAGE);
 419             removePreference(KEY_STORAGE_SPACE);
 420         }
 421     }
 422
 423     /*
 424      * Private method to initiate clearing user data when the user clicks the clear data
 425      * button for a system package
 426      */
 427     private void initiateClearUserData() {
 428         mClearDataButton.setEnabled(false);
 429         // Invoke uninstall or clear user data based on sysPackage
 430         String packageName = mAppEntry.info.packageName;
 431         Log.i(TAG, "Clearing user data for package : " + packageName);
 432         if (mClearDataObserver == null) {
 433             mClearDataObserver = new ClearUserDataObserver();
 434         }
 435         ActivityManager am = (ActivityManager)
 436                 getActivity().getSystemService(Context.ACTIVITY_SERVICE);
 437         boolean res = am.clearApplicationUserData(packageName, mClearDataObserver);
 438         if (!res) {
 439             // Clearing data failed for some obscure reason. Just log error for now
 440             Log.i(TAG, "Couldnt clear application user data for package:"+packageName);
 441             showDialogInner(DLG_CANNOT_CLEAR_DATA, 0);
 442         } else {
 443             mClearDataButton.setText(R.string.recompute_size);
 444         }
 445     }
 446
 447     /*
 448      * Private method to handle clear message notification from observer when
 449      * the async operation from PackageManager is complete
 450      */
 451     private void processClearMsg(Message msg) {
 452         int result = msg.arg1;
 453         String packageName = mAppEntry.info.packageName;
 454         mClearDataButton.setText(R.string.clear_user_data_text);
 455         if (result == OP_SUCCESSFUL) {
 456             Log.i(TAG, "Cleared user data for package : "+packageName);
 457             mState.requestSize(mPackageName, mUserId);
 458         } else {
 459             mClearDataButton.setEnabled(true);
 460         }
 461     }
 462
 463     private void refreshGrantedUriPermissions() {
 464         // Clear UI first (in case the activity has been resumed)
 465         removeUriPermissionsFromUi();
 466
 467         // Gets all URI permissions from am.
 468         ActivityManager am = (ActivityManager) getActivity().getSystemService(
 469                 Context.ACTIVITY_SERVICE);
 470         List<UriPermission> perms =
 471                 am.getGrantedUriPermissions(mAppEntry.info.packageName).getList();
 472
 473         if (perms.isEmpty()) {
 474             mClearUriButton.setVisibility(View.GONE);
 475             return;
 476         }
 477
 478         PackageManager pm = getActivity().getPackageManager();
 479
 480         // Group number of URIs by app.
 481         Map<CharSequence, MutableInt> uriCounters = new TreeMap<>();
 482         for (UriPermission perm : perms) {
 483             String authority = perm.getUri().getAuthority();
 484             ProviderInfo provider = pm.resolveContentProvider(authority, 0);
 485             CharSequence app = provider.applicationInfo.loadLabel(pm);
 486             MutableInt count = uriCounters.get(app);
 487             if (count == null) {
 488                 uriCounters.put(app, new MutableInt(1));
 489             } else {
 490                 count.value++;
 491             }
 492         }
 493
 494         // Dynamically add the preferences, one per app.
 495         int order = 0;
 496         for (Map.Entry<CharSequence, MutableInt> entry : uriCounters.entrySet()) {
 497             int numberResources = entry.getValue().value;
 498             Preference pref = new Preference(getPrefContext());
 499             pref.setTitle(entry.getKey());
 500             pref.setSummary(getPrefContext().getResources()
 501                     .getQuantityString(R.plurals.uri_permissions_text, numberResources,
 502                             numberResources));
 503             pref.setSelectable(false);
 504             pref.setLayoutResource(R.layout.horizontal_preference);
 505             pref.setOrder(order);
 506             Log.v(TAG, "Adding preference '" + pref + "' at order " + order);
 507             mUri.addPreference(pref);
 508         }
 509
 510         if (mAppsControlDisallowedBySystem) {
 511             mClearUriButton.setEnabled(false);
 512         }
 513
 514         mClearUri.setOrder(order);
 515         mClearUriButton.setVisibility(View.VISIBLE);
 516
 517     }
 518
 519     private void clearUriPermissions() {
 520         // Synchronously revoke the permissions.
 521         final ActivityManager am = (ActivityManager) getActivity().getSystemService(
 522                 Context.ACTIVITY_SERVICE);
 523         am.clearGrantedUriPermissions(mAppEntry.info.packageName);
 524
 525         // Update UI
 526         refreshGrantedUriPermissions();
 527     }
 528
 529     private void removeUriPermissionsFromUi() {
 530         // Remove all preferences but the clear button.
 531         int count = mUri.getPreferenceCount();
 532         for (int i = count - 1; i >= 0; i--) {
 533             Preference pref = mUri.getPreference(i);
 534             if (pref != mClearUri) {
 535                 mUri.removePreference(pref);
 536             }
 537         }
 538     }
 539
 540     @Override
 541     protected AlertDialog createDialog(int id, int errorCode) {
 542         switch (id) {
 543             case DLG_CLEAR_DATA:
 544                 return new AlertDialog.Builder(getActivity())
 545                         .setTitle(getActivity().getText(R.string.clear_data_dlg_title))
 546                         .setMessage(getActivity().getText(R.string.clear_data_dlg_text))
 547                         .setPositiveButton(R.string.dlg_ok, new DialogInterface.OnClickListener() {
 548                             public void onClick(DialogInterface dialog, int which) {
 549                                 // Clear user data here
 550                                 initiateClearUserData();
 551                             }
 552                         })
 553                         .setNegativeButton(R.string.dlg_cancel, null)
 554                         .create();
 555             case DLG_CANNOT_CLEAR_DATA:
 556                 return new AlertDialog.Builder(getActivity())
 557                         .setTitle(getActivity().getText(R.string.clear_failed_dlg_title))
 558                         .setMessage(getActivity().getText(R.string.clear_failed_dlg_text))
 559                         .setNeutralButton(R.string.dlg_ok, new DialogInterface.OnClickListener() {
 560                             public void onClick(DialogInterface dialog, int which) {
 561                                 mClearDataButton.setEnabled(false);
 562                                 //force to recompute changed value
 563                                 setIntentAndFinish(false, false);
 564                             }
 565                         })
 566                         .create();
 567         }
 568         return null;
 569     }
 570
 571     @Override
 572     public void onPackageSizeChanged(String packageName) {
 573         if (packageName.equals(mAppEntry.info.packageName)) {
 574             refreshSizeInfo();
 575         }
 576     }
 577
 578     private final Handler mHandler = new Handler() {
 579         public void handleMessage(Message msg) {
 580             if (getView() == null) {
 581                 return;
 582             }
 583             switch (msg.what) {
 584                 case MSG_CLEAR_USER_DATA:
 585                     processClearMsg(msg);
 586                     break;
 587                 case MSG_CLEAR_CACHE:
 588                     // Refresh size info
 589                     mState.requestSize(mPackageName, mUserId);
 590                     break;
 591             }
 592         }
 593     };
 594
 595     public static CharSequence getSummary(AppEntry appEntry, Context context) {
 596         if (appEntry.size == ApplicationsState.SIZE_INVALID
 597                 || appEntry.size == ApplicationsState.SIZE_UNKNOWN) {
 598             return context.getText(R.string.computing_size);
 599         } else {
 600             CharSequence storageType = context.getString(
 601                     (appEntry.info.flags & ApplicationInfo.FLAG_EXTERNAL_STORAGE) != 0
 602                     ? R.string.storage_type_external
 603                     : R.string.storage_type_internal);
 604             return context.getString(R.string.storage_summary_format,
 605                     getSize(appEntry, context), storageType);
 606         }
 607     }
 608
 609     private static CharSequence getSize(AppEntry appEntry, Context context) {
 610         long size = appEntry.size;
 611         if (size == SIZE_INVALID) {
 612             return context.getText(R.string.invalid_size_value);
 613         }
 614         return Formatter.formatFileSize(context, size);
 615     }
 616
 617     @Override
 618     protected int getMetricsCategory() {
 619         return MetricsEvent.APPLICATIONS_APP_STORAGE;
 620     }
 621
 622     class ClearCacheObserver extends IPackageDataObserver.Stub {
 623         public void onRemoveCompleted(final String packageName, final boolean succeeded) {
 624             final Message msg = mHandler.obtainMessage(MSG_CLEAR_CACHE);
 625             msg.arg1 = succeeded ? OP_SUCCESSFUL : OP_FAILED;
 626             mHandler.sendMessage(msg);
 627         }
 628     }
 629
 630     class ClearUserDataObserver extends IPackageDataObserver.Stub {
 631        public void onRemoveCompleted(final String packageName, final boolean succeeded) {
 632            final Message msg = mHandler.obtainMessage(MSG_CLEAR_USER_DATA);
 633            msg.arg1 = succeeded ? OP_SUCCESSFUL : OP_FAILED;
 634            mHandler.sendMessage(msg);
 635         }
 636     }
 637 }