| /* |
| * Copyright (C) 2015 The Android Open Source Project |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| package com.android.settings.deviceinfo; |
| |
| import android.app.AlertDialog; |
| import android.app.Dialog; |
| import android.app.Fragment; |
| import android.content.Context; |
| import android.content.DialogInterface; |
| import android.content.Intent; |
| import android.content.pm.IPackageDataObserver; |
| import android.content.pm.PackageInfo; |
| import android.content.pm.PackageManager; |
| import android.content.pm.UserInfo; |
| import android.os.Build; |
| import android.os.Bundle; |
| import android.os.Environment; |
| import android.os.UserHandle; |
| import android.os.UserManager; |
| import android.os.storage.StorageEventListener; |
| import android.os.storage.StorageManager; |
| import android.os.storage.VolumeInfo; |
| import android.os.storage.VolumeRecord; |
| import android.provider.DocumentsContract; |
| import android.support.v7.preference.Preference; |
| import android.support.v7.preference.PreferenceCategory; |
| import android.support.v7.preference.PreferenceGroup; |
| import android.support.v7.preference.PreferenceScreen; |
| import android.text.TextUtils; |
| import android.text.format.Formatter; |
| import android.text.format.Formatter.BytesResult; |
| import android.util.Log; |
| import android.view.LayoutInflater; |
| import android.view.Menu; |
| import android.view.MenuInflater; |
| import android.view.MenuItem; |
| import android.view.View; |
| import android.widget.EditText; |
| |
| import com.android.internal.logging.nano.MetricsProto.MetricsEvent; |
| import com.android.settings.R; |
| import com.android.settings.Settings.StorageUseActivity; |
| import com.android.settings.SettingsPreferenceFragment; |
| import com.android.settings.Utils; |
| import com.android.settings.applications.manageapplications.ManageApplications; |
| import com.android.settings.core.SubSettingLauncher; |
| import com.android.settings.core.instrumentation.InstrumentedDialogFragment; |
| import com.android.settings.deviceinfo.StorageSettings.MountTask; |
| import com.android.settingslib.deviceinfo.StorageMeasurement; |
| import com.android.settingslib.deviceinfo.StorageMeasurement.MeasurementDetails; |
| import com.android.settingslib.deviceinfo.StorageMeasurement.MeasurementReceiver; |
| |
| import com.google.android.collect.Lists; |
| |
| import java.util.HashMap; |
| import java.util.List; |
| import java.util.Objects; |
| |
| /** |
| * Panel showing summary and actions for a {@link VolumeInfo#TYPE_PRIVATE} |
| * storage volume. |
| */ |
| public class PrivateVolumeSettings extends SettingsPreferenceFragment { |
| // TODO: disable unmount when providing over MTP/PTP |
| // TODO: warn when mounted read-only |
| |
| private static final String TAG = "PrivateVolumeSettings"; |
| private static final boolean LOGV = false; |
| |
| private static final String TAG_RENAME = "rename"; |
| private static final String TAG_OTHER_INFO = "otherInfo"; |
| private static final String TAG_SYSTEM_INFO = "systemInfo"; |
| private static final String TAG_USER_INFO = "userInfo"; |
| private static final String TAG_CONFIRM_CLEAR_CACHE = "confirmClearCache"; |
| |
| private static final String EXTRA_VOLUME_SIZE = "volume_size"; |
| |
| private static final String AUTHORITY_MEDIA = "com.android.providers.media.documents"; |
| |
| private static final int[] ITEMS_NO_SHOW_SHARED = new int[] { |
| R.string.storage_detail_apps, |
| R.string.storage_detail_system, |
| }; |
| |
| private static final int[] ITEMS_SHOW_SHARED = new int[] { |
| R.string.storage_detail_apps, |
| R.string.storage_detail_images, |
| R.string.storage_detail_videos, |
| R.string.storage_detail_audio, |
| R.string.storage_detail_system, |
| R.string.storage_detail_other, |
| }; |
| |
| private StorageManager mStorageManager; |
| private UserManager mUserManager; |
| |
| private String mVolumeId; |
| private VolumeInfo mVolume; |
| private VolumeInfo mSharedVolume; |
| private long mTotalSize; |
| private long mSystemSize; |
| |
| private StorageMeasurement mMeasure; |
| |
| private UserInfo mCurrentUser; |
| |
| private StorageSummaryPreference mSummary; |
| private List<StorageItemPreference> mItemPreferencePool = Lists.newArrayList(); |
| private List<PreferenceCategory> mHeaderPreferencePool = Lists.newArrayList(); |
| private int mHeaderPoolIndex; |
| private int mItemPoolIndex; |
| |
| private Preference mExplore; |
| |
| private boolean mNeedsUpdate; |
| |
| private boolean isVolumeValid() { |
| return (mVolume != null) && (mVolume.getType() == VolumeInfo.TYPE_PRIVATE) |
| && mVolume.isMountedReadable(); |
| } |
| |
| public PrivateVolumeSettings() { |
| setRetainInstance(true); |
| } |
| |
| @Override |
| public int getMetricsCategory() { |
| return MetricsEvent.DEVICEINFO_STORAGE; |
| } |
| |
| @Override |
| public void onCreate(Bundle icicle) { |
| super.onCreate(icicle); |
| |
| final Context context = getActivity(); |
| |
| mUserManager = context.getSystemService(UserManager.class); |
| mStorageManager = context.getSystemService(StorageManager.class); |
| |
| mVolumeId = getArguments().getString(VolumeInfo.EXTRA_VOLUME_ID); |
| mVolume = mStorageManager.findVolumeById(mVolumeId); |
| |
| final long sharedDataSize = mVolume.getPath().getTotalSpace(); |
| mTotalSize = getArguments().getLong(EXTRA_VOLUME_SIZE, 0); |
| mSystemSize = mTotalSize - sharedDataSize; |
| if (LOGV) Log.v(TAG, |
| "onCreate() mTotalSize: " + mTotalSize + " sharedDataSize: " + sharedDataSize); |
| |
| if (mTotalSize <= 0) { |
| mTotalSize = sharedDataSize; |
| mSystemSize = 0; |
| } |
| |
| // Find the emulated shared storage layered above this private volume |
| mSharedVolume = mStorageManager.findEmulatedForPrivate(mVolume); |
| |
| mMeasure = new StorageMeasurement(context, mVolume, mSharedVolume); |
| mMeasure.setReceiver(mReceiver); |
| |
| if (!isVolumeValid()) { |
| getActivity().finish(); |
| return; |
| } |
| |
| addPreferencesFromResource(R.xml.device_info_storage_volume); |
| getPreferenceScreen().setOrderingAsAdded(true); |
| |
| mSummary = new StorageSummaryPreference(getPrefContext()); |
| mCurrentUser = mUserManager.getUserInfo(UserHandle.myUserId()); |
| |
| mExplore = buildAction(R.string.storage_menu_explore); |
| |
| mNeedsUpdate = true; |
| |
| setHasOptionsMenu(true); |
| } |
| |
| private void setTitle() { |
| getActivity().setTitle(mStorageManager.getBestVolumeDescription(mVolume)); |
| } |
| |
| private void update() { |
| if (!isVolumeValid()) { |
| getActivity().finish(); |
| return; |
| } |
| |
| setTitle(); |
| |
| // Valid options may have changed |
| getFragmentManager().invalidateOptionsMenu(); |
| |
| final Context context = getActivity(); |
| final PreferenceScreen screen = getPreferenceScreen(); |
| |
| screen.removeAll(); |
| |
| addPreference(screen, mSummary); |
| |
| List<UserInfo> allUsers = mUserManager.getUsers(); |
| final int userCount = allUsers.size(); |
| final boolean showHeaders = userCount > 1; |
| final boolean showShared = (mSharedVolume != null) && mSharedVolume.isMountedReadable(); |
| |
| mItemPoolIndex = 0; |
| mHeaderPoolIndex = 0; |
| |
| int addedUserCount = 0; |
| // Add current user and its profiles first |
| for (int userIndex = 0; userIndex < userCount; ++userIndex) { |
| final UserInfo userInfo = allUsers.get(userIndex); |
| if (Utils.isProfileOf(mCurrentUser, userInfo)) { |
| final PreferenceGroup details = showHeaders ? |
| addCategory(screen, userInfo.name) : screen; |
| addDetailItems(details, showShared, userInfo.id); |
| ++addedUserCount; |
| } |
| } |
| |
| // Add rest of users |
| if (userCount - addedUserCount > 0) { |
| PreferenceGroup otherUsers = addCategory(screen, |
| getText(R.string.storage_other_users)); |
| for (int userIndex = 0; userIndex < userCount; ++userIndex) { |
| final UserInfo userInfo = allUsers.get(userIndex); |
| if (!Utils.isProfileOf(mCurrentUser, userInfo)) { |
| addItem(otherUsers, /* titleRes */ 0, userInfo.name, userInfo.id); |
| } |
| } |
| } |
| |
| addItem(screen, R.string.storage_detail_cached, null, UserHandle.USER_NULL); |
| |
| if (showShared) { |
| addPreference(screen, mExplore); |
| } |
| |
| final long freeBytes = mVolume.getPath().getFreeSpace(); |
| final long usedBytes = mTotalSize - freeBytes; |
| |
| if (LOGV) Log.v(TAG, "update() freeBytes: " + freeBytes + " usedBytes: " + usedBytes); |
| |
| final BytesResult result = Formatter.formatBytes(getResources(), usedBytes, 0); |
| mSummary.setTitle(TextUtils.expandTemplate(getText(R.string.storage_size_large), |
| result.value, result.units)); |
| mSummary.setSummary(getString(R.string.storage_volume_used, |
| Formatter.formatFileSize(context, mTotalSize))); |
| mSummary.setPercent(usedBytes, mTotalSize); |
| |
| mMeasure.forceMeasure(); |
| mNeedsUpdate = false; |
| } |
| |
| private void addPreference(PreferenceGroup group, Preference pref) { |
| pref.setOrder(Preference.DEFAULT_ORDER); |
| group.addPreference(pref); |
| } |
| |
| private PreferenceCategory addCategory(PreferenceGroup group, CharSequence title) { |
| PreferenceCategory category; |
| if (mHeaderPoolIndex < mHeaderPreferencePool.size()) { |
| category = mHeaderPreferencePool.get(mHeaderPoolIndex); |
| } else { |
| category = new PreferenceCategory(getPrefContext()); |
| mHeaderPreferencePool.add(category); |
| } |
| category.setTitle(title); |
| category.removeAll(); |
| addPreference(group, category); |
| ++mHeaderPoolIndex; |
| return category; |
| } |
| |
| private void addDetailItems(PreferenceGroup category, boolean showShared, int userId) { |
| final int[] itemsToAdd = (showShared ? ITEMS_SHOW_SHARED : ITEMS_NO_SHOW_SHARED); |
| for (int i = 0; i < itemsToAdd.length; ++i) { |
| addItem(category, itemsToAdd[i], null, userId); |
| } |
| } |
| |
| private void addItem(PreferenceGroup group, int titleRes, CharSequence title, int userId) { |
| if (titleRes == R.string.storage_detail_system) { |
| if (mSystemSize <= 0) { |
| Log.w(TAG, "Skipping System storage because its size is " + mSystemSize); |
| return; |
| } |
| if (userId != UserHandle.myUserId()) { |
| // Only display system on current user. |
| return; |
| } |
| } |
| StorageItemPreference item; |
| if (mItemPoolIndex < mItemPreferencePool.size()) { |
| item = mItemPreferencePool.get(mItemPoolIndex); |
| } else { |
| item = buildItem(); |
| mItemPreferencePool.add(item); |
| } |
| if (title != null) { |
| item.setTitle(title); |
| item.setKey(title.toString()); |
| } else { |
| item.setTitle(titleRes); |
| item.setKey(Integer.toString(titleRes)); |
| } |
| item.setSummary(R.string.memory_calculating_size); |
| item.userHandle = userId; |
| addPreference(group, item); |
| ++mItemPoolIndex; |
| } |
| |
| private StorageItemPreference buildItem() { |
| final StorageItemPreference item = new StorageItemPreference(getPrefContext()); |
| item.setIcon(R.drawable.empty_icon); |
| return item; |
| } |
| |
| private Preference buildAction(int titleRes) { |
| final Preference pref = new Preference(getPrefContext()); |
| pref.setTitle(titleRes); |
| pref.setKey(Integer.toString(titleRes)); |
| return pref; |
| } |
| |
| static void setVolumeSize(Bundle args, long size) { |
| args.putLong(EXTRA_VOLUME_SIZE, size); |
| } |
| |
| @Override |
| public void onResume() { |
| super.onResume(); |
| |
| // Refresh to verify that we haven't been formatted away |
| mVolume = mStorageManager.findVolumeById(mVolumeId); |
| if (!isVolumeValid()) { |
| getActivity().finish(); |
| return; |
| } |
| |
| mStorageManager.registerListener(mStorageListener); |
| |
| if (mNeedsUpdate) { |
| update(); |
| } else { |
| setTitle(); |
| } |
| } |
| |
| @Override |
| public void onPause() { |
| super.onPause(); |
| mStorageManager.unregisterListener(mStorageListener); |
| } |
| |
| @Override |
| public void onDestroy() { |
| super.onDestroy(); |
| if (mMeasure != null) { |
| mMeasure.onDestroy(); |
| } |
| } |
| |
| @Override |
| public void onCreateOptionsMenu(Menu menu, MenuInflater inflater) { |
| super.onCreateOptionsMenu(menu, inflater); |
| inflater.inflate(R.menu.storage_volume, menu); |
| } |
| |
| @Override |
| public void onPrepareOptionsMenu(Menu menu) { |
| if (!isVolumeValid()) return; |
| |
| final MenuItem rename = menu.findItem(R.id.storage_rename); |
| final MenuItem mount = menu.findItem(R.id.storage_mount); |
| final MenuItem unmount = menu.findItem(R.id.storage_unmount); |
| final MenuItem format = menu.findItem(R.id.storage_format); |
| final MenuItem migrate = menu.findItem(R.id.storage_migrate); |
| final MenuItem manage = menu.findItem(R.id.storage_free); |
| |
| // Actions live in menu for non-internal private volumes; they're shown |
| // as preference items for public volumes. |
| if (VolumeInfo.ID_PRIVATE_INTERNAL.equals(mVolume.getId())) { |
| rename.setVisible(false); |
| mount.setVisible(false); |
| unmount.setVisible(false); |
| format.setVisible(false); |
| manage.setVisible(getResources().getBoolean( |
| R.bool.config_storage_manager_settings_enabled)); |
| } else { |
| rename.setVisible(mVolume.getType() == VolumeInfo.TYPE_PRIVATE); |
| mount.setVisible(mVolume.getState() == VolumeInfo.STATE_UNMOUNTED); |
| unmount.setVisible(mVolume.isMountedReadable()); |
| format.setVisible(true); |
| manage.setVisible(false); |
| } |
| |
| format.setTitle(R.string.storage_menu_format_public); |
| |
| // Only offer to migrate when not current storage |
| final VolumeInfo privateVol = getActivity().getPackageManager() |
| .getPrimaryStorageCurrentVolume(); |
| migrate.setVisible((privateVol != null) |
| && (privateVol.getType() == VolumeInfo.TYPE_PRIVATE) |
| && !Objects.equals(mVolume, privateVol)); |
| } |
| |
| @Override |
| public boolean onOptionsItemSelected(MenuItem item) { |
| final Context context = getActivity(); |
| final Bundle args = new Bundle(); |
| switch (item.getItemId()) { |
| case R.id.storage_rename: |
| RenameFragment.show(this, mVolume); |
| return true; |
| case R.id.storage_mount: |
| new MountTask(context, mVolume).execute(); |
| return true; |
| case R.id.storage_unmount: |
| args.putString(VolumeInfo.EXTRA_VOLUME_ID, mVolume.getId()); |
| new SubSettingLauncher(context) |
| .setDestination(PrivateVolumeUnmount.class.getCanonicalName()) |
| .setTitle(R.string.storage_menu_unmount) |
| .setSourceMetricsCategory(getMetricsCategory()) |
| .setArguments(args) |
| .launch(); |
| return true; |
| case R.id.storage_format: |
| args.putString(VolumeInfo.EXTRA_VOLUME_ID, mVolume.getId()); |
| new SubSettingLauncher(context) |
| .setDestination(PrivateVolumeFormat.class.getCanonicalName()) |
| .setTitle(R.string.storage_menu_format) |
| .setSourceMetricsCategory(getMetricsCategory()) |
| .setArguments(args) |
| .launch(); |
| return true; |
| case R.id.storage_migrate: |
| final Intent intent = new Intent(context, StorageWizardMigrateConfirm.class); |
| intent.putExtra(VolumeInfo.EXTRA_VOLUME_ID, mVolume.getId()); |
| startActivity(intent); |
| return true; |
| case R.id.storage_free: |
| final Intent deletion_helper_intent = |
| new Intent(StorageManager.ACTION_MANAGE_STORAGE); |
| startActivity(deletion_helper_intent); |
| return true; |
| } |
| return super.onOptionsItemSelected(item); |
| } |
| |
| @Override |
| public boolean onPreferenceTreeClick(Preference pref) { |
| // TODO: launch better intents for specific volume |
| |
| final int userId = (pref instanceof StorageItemPreference ? |
| ((StorageItemPreference) pref).userHandle : -1); |
| int itemTitleId; |
| try { |
| itemTitleId = Integer.parseInt(pref.getKey()); |
| } catch (NumberFormatException e) { |
| itemTitleId = 0; |
| } |
| Intent intent = null; |
| switch (itemTitleId) { |
| case R.string.storage_detail_apps: { |
| Bundle args = new Bundle(); |
| args.putString(ManageApplications.EXTRA_CLASSNAME, |
| StorageUseActivity.class.getName()); |
| args.putString(ManageApplications.EXTRA_VOLUME_UUID, mVolume.getFsUuid()); |
| args.putString(ManageApplications.EXTRA_VOLUME_NAME, mVolume.getDescription()); |
| args.putInt( |
| ManageApplications.EXTRA_STORAGE_TYPE, |
| ManageApplications.STORAGE_TYPE_LEGACY); |
| intent = new SubSettingLauncher(getActivity()) |
| .setDestination(ManageApplications.class.getName()) |
| .setArguments(args) |
| .setTitle(R.string.apps_storage) |
| .setSourceMetricsCategory(getMetricsCategory()) |
| .toIntent(); |
| |
| } break; |
| case R.string.storage_detail_images: { |
| intent = getIntentForStorage(AUTHORITY_MEDIA, "images_root"); |
| } break; |
| case R.string.storage_detail_videos: { |
| intent = getIntentForStorage(AUTHORITY_MEDIA, "videos_root"); |
| } break; |
| case R.string.storage_detail_audio: { |
| intent = getIntentForStorage(AUTHORITY_MEDIA, "audio_root"); |
| } break; |
| case R.string.storage_detail_system: { |
| SystemInfoFragment.show(this); |
| return true; |
| |
| } |
| case R.string.storage_detail_other: { |
| OtherInfoFragment.show(this, mStorageManager.getBestVolumeDescription(mVolume), |
| mSharedVolume, userId); |
| return true; |
| |
| } |
| case R.string.storage_detail_cached: { |
| ConfirmClearCacheFragment.show(this); |
| return true; |
| |
| } |
| case R.string.storage_menu_explore: { |
| intent = mSharedVolume.buildBrowseIntent(); |
| } break; |
| case 0: { |
| UserInfoFragment.show(this, pref.getTitle(), pref.getSummary()); |
| return true; |
| } |
| } |
| |
| if (intent != null) { |
| intent.putExtra(Intent.EXTRA_USER_ID, userId); |
| |
| Utils.launchIntent(this, intent); |
| return true; |
| } |
| return super.onPreferenceTreeClick(pref); |
| } |
| |
| private Intent getIntentForStorage(String authority, String root) { |
| Intent intent = new Intent(Intent.ACTION_VIEW); |
| intent.setDataAndType( |
| DocumentsContract.buildRootUri(authority, root), |
| DocumentsContract.Root.MIME_TYPE_ITEM); |
| intent.addCategory(Intent.CATEGORY_DEFAULT); |
| |
| return intent; |
| } |
| |
| private final MeasurementReceiver mReceiver = new MeasurementReceiver() { |
| @Override |
| public void onDetailsChanged(MeasurementDetails details) { |
| updateDetails(details); |
| } |
| }; |
| |
| private void updateDetails(MeasurementDetails details) { |
| StorageItemPreference otherItem = null; |
| long accountedSize = 0; |
| long totalMiscSize = 0; |
| long totalDownloadsSize = 0; |
| |
| for (int i = 0; i < mItemPoolIndex; ++i) { |
| StorageItemPreference item = mItemPreferencePool.get(i); |
| final int userId = item.userHandle; |
| int itemTitleId; |
| try { |
| itemTitleId = Integer.parseInt(item.getKey()); |
| } catch (NumberFormatException e) { |
| itemTitleId = 0; |
| } |
| switch (itemTitleId) { |
| case R.string.storage_detail_system: { |
| updatePreference(item, mSystemSize); |
| accountedSize += mSystemSize; |
| if (LOGV) Log.v(TAG, "mSystemSize: " + mSystemSize |
| + " accountedSize: " + accountedSize); |
| } break; |
| case R.string.storage_detail_apps: { |
| updatePreference(item, details.appsSize.get(userId)); |
| accountedSize += details.appsSize.get(userId); |
| if (LOGV) Log.v(TAG, "appsSize: " + details.appsSize.get(userId) |
| + " accountedSize: " + accountedSize); |
| } break; |
| case R.string.storage_detail_images: { |
| final long imagesSize = totalValues(details, userId, |
| Environment.DIRECTORY_DCIM, Environment.DIRECTORY_PICTURES); |
| updatePreference(item, imagesSize); |
| accountedSize += imagesSize; |
| if (LOGV) Log.v(TAG, "imagesSize: " + imagesSize |
| + " accountedSize: " + accountedSize); |
| } break; |
| case R.string.storage_detail_videos: { |
| final long videosSize = totalValues(details, userId, |
| Environment.DIRECTORY_MOVIES); |
| updatePreference(item, videosSize); |
| accountedSize += videosSize; |
| if (LOGV) Log.v(TAG, "videosSize: " + videosSize |
| + " accountedSize: " + accountedSize); |
| } break; |
| case R.string.storage_detail_audio: { |
| final long audioSize = totalValues(details, userId, |
| Environment.DIRECTORY_MUSIC, |
| Environment.DIRECTORY_ALARMS, Environment.DIRECTORY_NOTIFICATIONS, |
| Environment.DIRECTORY_RINGTONES, Environment.DIRECTORY_PODCASTS); |
| updatePreference(item, audioSize); |
| accountedSize += audioSize; |
| if (LOGV) Log.v(TAG, "audioSize: " + audioSize |
| + " accountedSize: " + accountedSize); |
| } break; |
| case R.string.storage_detail_other: { |
| final long downloadsSize = totalValues(details, userId, |
| Environment.DIRECTORY_DOWNLOADS); |
| final long miscSize = details.miscSize.get(userId); |
| totalDownloadsSize += downloadsSize; |
| totalMiscSize += miscSize; |
| accountedSize += miscSize + downloadsSize; |
| |
| if (LOGV) |
| Log.v(TAG, "miscSize for " + userId + ": " + miscSize + "(total: " |
| + totalMiscSize + ") \ndownloadsSize: " + downloadsSize + "(total: " |
| + totalDownloadsSize + ") accountedSize: " + accountedSize); |
| |
| // Cannot display 'Other' until all known items are accounted for. |
| otherItem = item; |
| } break; |
| case R.string.storage_detail_cached: { |
| updatePreference(item, details.cacheSize); |
| accountedSize += details.cacheSize; |
| if (LOGV) |
| Log.v(TAG, "cacheSize: " + details.cacheSize + " accountedSize: " |
| + accountedSize); |
| } break; |
| case 0: { |
| final long userSize = details.usersSize.get(userId); |
| updatePreference(item, userSize); |
| accountedSize += userSize; |
| if (LOGV) Log.v(TAG, "userSize: " + userSize |
| + " accountedSize: " + accountedSize); |
| } break; |
| } |
| } |
| if (otherItem != null) { |
| final long usedSize = mTotalSize - details.availSize; |
| final long unaccountedSize = usedSize - accountedSize; |
| final long otherSize = totalMiscSize + totalDownloadsSize + unaccountedSize; |
| Log.v(TAG, "Other items: \n\tmTotalSize: " + mTotalSize + " availSize: " |
| + details.availSize + " usedSize: " + usedSize + "\n\taccountedSize: " |
| + accountedSize + " unaccountedSize size: " + unaccountedSize |
| + "\n\ttotalMiscSize: " + totalMiscSize + " totalDownloadsSize: " |
| + totalDownloadsSize + "\n\tdetails: " + details); |
| updatePreference(otherItem, otherSize); |
| } |
| } |
| |
| private void updatePreference(StorageItemPreference pref, long size) { |
| pref.setStorageSize(size, mTotalSize); |
| } |
| |
| private static long totalValues(MeasurementDetails details, int userId, String... keys) { |
| long total = 0; |
| HashMap<String, Long> map = details.mediaSize.get(userId); |
| if (map != null) { |
| for (String key : keys) { |
| if (map.containsKey(key)) { |
| total += map.get(key); |
| } |
| } |
| } else { |
| Log.w(TAG, "MeasurementDetails mediaSize array does not have key for user " + userId); |
| } |
| return total; |
| } |
| |
| private final StorageEventListener mStorageListener = new StorageEventListener() { |
| @Override |
| public void onVolumeStateChanged(VolumeInfo vol, int oldState, int newState) { |
| if (Objects.equals(mVolume.getId(), vol.getId())) { |
| mVolume = vol; |
| update(); |
| } |
| } |
| |
| @Override |
| public void onVolumeRecordChanged(VolumeRecord rec) { |
| if (Objects.equals(mVolume.getFsUuid(), rec.getFsUuid())) { |
| mVolume = mStorageManager.findVolumeById(mVolumeId); |
| update(); |
| } |
| } |
| }; |
| |
| /** |
| * Dialog that allows editing of volume nickname. |
| */ |
| public static class RenameFragment extends InstrumentedDialogFragment { |
| public static void show(PrivateVolumeSettings parent, VolumeInfo vol) { |
| if (!parent.isAdded()) return; |
| |
| final RenameFragment dialog = new RenameFragment(); |
| dialog.setTargetFragment(parent, 0); |
| final Bundle args = new Bundle(); |
| args.putString(VolumeRecord.EXTRA_FS_UUID, vol.getFsUuid()); |
| dialog.setArguments(args); |
| dialog.show(parent.getFragmentManager(), TAG_RENAME); |
| } |
| |
| @Override |
| public int getMetricsCategory() { |
| return MetricsEvent.DIALOG_VOLUME_RENAME; |
| } |
| |
| @Override |
| public Dialog onCreateDialog(Bundle savedInstanceState) { |
| final Context context = getActivity(); |
| final StorageManager storageManager = context.getSystemService(StorageManager.class); |
| |
| final String fsUuid = getArguments().getString(VolumeRecord.EXTRA_FS_UUID); |
| final VolumeInfo vol = storageManager.findVolumeByUuid(fsUuid); |
| final VolumeRecord rec = storageManager.findRecordByUuid(fsUuid); |
| |
| final AlertDialog.Builder builder = new AlertDialog.Builder(context); |
| final LayoutInflater dialogInflater = LayoutInflater.from(builder.getContext()); |
| |
| final View view = dialogInflater.inflate(R.layout.dialog_edittext, null, false); |
| final EditText nickname = (EditText) view.findViewById(R.id.edittext); |
| nickname.setText(rec.getNickname()); |
| |
| builder.setTitle(R.string.storage_rename_title); |
| builder.setView(view); |
| |
| builder.setPositiveButton(R.string.save, |
| new DialogInterface.OnClickListener() { |
| @Override |
| public void onClick(DialogInterface dialog, int which) { |
| // TODO: move to background thread |
| storageManager.setVolumeNickname(fsUuid, |
| nickname.getText().toString()); |
| } |
| }); |
| builder.setNegativeButton(R.string.cancel, null); |
| |
| return builder.create(); |
| } |
| } |
| |
| public static class SystemInfoFragment extends InstrumentedDialogFragment { |
| public static void show(Fragment parent) { |
| if (!parent.isAdded()) return; |
| |
| final SystemInfoFragment dialog = new SystemInfoFragment(); |
| dialog.setTargetFragment(parent, 0); |
| dialog.show(parent.getFragmentManager(), TAG_SYSTEM_INFO); |
| } |
| |
| @Override |
| public int getMetricsCategory() { |
| return MetricsEvent.DIALOG_STORAGE_SYSTEM_INFO; |
| } |
| |
| @Override |
| public Dialog onCreateDialog(Bundle savedInstanceState) { |
| return new AlertDialog.Builder(getActivity()) |
| .setMessage(getContext().getString(R.string.storage_detail_dialog_system, |
| Build.VERSION.RELEASE)) |
| .setPositiveButton(android.R.string.ok, null) |
| .create(); |
| } |
| } |
| |
| public static class OtherInfoFragment extends InstrumentedDialogFragment { |
| public static void show(Fragment parent, String title, VolumeInfo sharedVol, int userId) { |
| if (!parent.isAdded()) return; |
| |
| final OtherInfoFragment dialog = new OtherInfoFragment(); |
| dialog.setTargetFragment(parent, 0); |
| final Bundle args = new Bundle(); |
| args.putString(Intent.EXTRA_TITLE, title); |
| |
| final Intent intent = sharedVol.buildBrowseIntent(); |
| intent.putExtra(Intent.EXTRA_USER_ID, userId); |
| args.putParcelable(Intent.EXTRA_INTENT, intent); |
| dialog.setArguments(args); |
| dialog.show(parent.getFragmentManager(), TAG_OTHER_INFO); |
| } |
| |
| @Override |
| public int getMetricsCategory() { |
| return MetricsEvent.DIALOG_STORAGE_OTHER_INFO; |
| } |
| |
| @Override |
| public Dialog onCreateDialog(Bundle savedInstanceState) { |
| final Context context = getActivity(); |
| |
| final String title = getArguments().getString(Intent.EXTRA_TITLE); |
| final Intent intent = getArguments().getParcelable(Intent.EXTRA_INTENT); |
| |
| final AlertDialog.Builder builder = new AlertDialog.Builder(context); |
| builder.setMessage( |
| TextUtils.expandTemplate(getText(R.string.storage_detail_dialog_other), title)); |
| |
| builder.setPositiveButton(R.string.storage_menu_explore, |
| new DialogInterface.OnClickListener() { |
| @Override |
| public void onClick(DialogInterface dialog, int which) { |
| Utils.launchIntent(OtherInfoFragment.this, intent); |
| } |
| }); |
| builder.setNegativeButton(android.R.string.cancel, null); |
| |
| return builder.create(); |
| } |
| } |
| |
| public static class UserInfoFragment extends InstrumentedDialogFragment { |
| public static void show(Fragment parent, CharSequence userLabel, CharSequence userSize) { |
| if (!parent.isAdded()) return; |
| |
| final UserInfoFragment dialog = new UserInfoFragment(); |
| dialog.setTargetFragment(parent, 0); |
| final Bundle args = new Bundle(); |
| args.putCharSequence(Intent.EXTRA_TITLE, userLabel); |
| args.putCharSequence(Intent.EXTRA_SUBJECT, userSize); |
| dialog.setArguments(args); |
| dialog.show(parent.getFragmentManager(), TAG_USER_INFO); |
| } |
| |
| @Override |
| public int getMetricsCategory() { |
| return MetricsEvent.DIALOG_STORAGE_USER_INFO; |
| } |
| |
| @Override |
| public Dialog onCreateDialog(Bundle savedInstanceState) { |
| final Context context = getActivity(); |
| |
| final CharSequence userLabel = getArguments().getCharSequence(Intent.EXTRA_TITLE); |
| final CharSequence userSize = getArguments().getCharSequence(Intent.EXTRA_SUBJECT); |
| |
| final AlertDialog.Builder builder = new AlertDialog.Builder(context); |
| builder.setMessage(TextUtils.expandTemplate( |
| getText(R.string.storage_detail_dialog_user), userLabel, userSize)); |
| |
| builder.setPositiveButton(android.R.string.ok, null); |
| |
| return builder.create(); |
| } |
| } |
| |
| /** |
| * Dialog to request user confirmation before clearing all cache data. |
| */ |
| public static class ConfirmClearCacheFragment extends InstrumentedDialogFragment { |
| public static void show(Fragment parent) { |
| if (!parent.isAdded()) return; |
| |
| final ConfirmClearCacheFragment dialog = new ConfirmClearCacheFragment(); |
| dialog.setTargetFragment(parent, 0); |
| dialog.show(parent.getFragmentManager(), TAG_CONFIRM_CLEAR_CACHE); |
| } |
| |
| @Override |
| public int getMetricsCategory() { |
| return MetricsEvent.DIALOG_STORAGE_CLEAR_CACHE; |
| } |
| |
| @Override |
| public Dialog onCreateDialog(Bundle savedInstanceState) { |
| final Context context = getActivity(); |
| |
| final AlertDialog.Builder builder = new AlertDialog.Builder(context); |
| builder.setTitle(R.string.memory_clear_cache_title); |
| builder.setMessage(getString(R.string.memory_clear_cache_message)); |
| |
| builder.setPositiveButton(android.R.string.ok, new DialogInterface.OnClickListener() { |
| @Override |
| public void onClick(DialogInterface dialog, int which) { |
| final PrivateVolumeSettings target = (PrivateVolumeSettings) getTargetFragment(); |
| final PackageManager pm = context.getPackageManager(); |
| final UserManager um = context.getSystemService(UserManager.class); |
| |
| for (int userId : um.getProfileIdsWithDisabled(context.getUserId())) { |
| final List<PackageInfo> infos = pm.getInstalledPackagesAsUser(0, userId); |
| final ClearCacheObserver observer = new ClearCacheObserver( |
| target, infos.size()); |
| for (PackageInfo info : infos) { |
| pm.deleteApplicationCacheFilesAsUser(info.packageName, userId, |
| observer); |
| } |
| } |
| } |
| }); |
| builder.setNegativeButton(android.R.string.cancel, null); |
| |
| return builder.create(); |
| } |
| } |
| |
| private static class ClearCacheObserver extends IPackageDataObserver.Stub { |
| private final PrivateVolumeSettings mTarget; |
| private int mRemaining; |
| |
| public ClearCacheObserver(PrivateVolumeSettings target, int remaining) { |
| mTarget = target; |
| mRemaining = remaining; |
| } |
| |
| @Override |
| public void onRemoveCompleted(final String packageName, final boolean succeeded) { |
| synchronized (this) { |
| if (--mRemaining == 0) { |
| mTarget.getActivity().runOnUiThread(new Runnable() { |
| @Override |
| public void run() { |
| mTarget.update(); |
| } |
| }); |
| } |
| } |
| } |
| } |
| } |
