| /* |
| * Copyright (C) 2016 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.Activity; |
| import android.app.LoaderManager; |
| import android.app.usage.StorageStatsManager; |
| import android.content.Context; |
| import android.content.Loader; |
| import android.graphics.drawable.Drawable; |
| import android.os.Bundle; |
| import android.os.UserHandle; |
| import android.os.UserManager; |
| import android.os.storage.StorageManager; |
| import android.os.storage.VolumeInfo; |
| import android.provider.SearchIndexableResource; |
| import android.support.annotation.VisibleForTesting; |
| import android.util.SparseArray; |
| import android.view.View; |
| |
| import com.android.internal.logging.nano.MetricsProto; |
| import com.android.settings.R; |
| import com.android.settings.Utils; |
| import com.android.settings.applications.PackageManagerWrapperImpl; |
| import com.android.settings.applications.UserManagerWrapper; |
| import com.android.settings.applications.UserManagerWrapperImpl; |
| import com.android.settings.core.PreferenceController; |
| import com.android.settings.dashboard.DashboardFragment; |
| import com.android.settings.deviceinfo.storage.AutomaticStorageManagementSwitchPreferenceController; |
| import com.android.settings.deviceinfo.storage.SecondaryUserController; |
| import com.android.settings.deviceinfo.storage.StorageAsyncLoader; |
| import com.android.settings.deviceinfo.storage.StorageItemPreferenceController; |
| import com.android.settings.deviceinfo.storage.StorageSummaryDonutPreferenceController; |
| import com.android.settings.deviceinfo.storage.UserIconLoader; |
| import com.android.settings.deviceinfo.storage.VolumeSizesLoader; |
| import com.android.settings.search.BaseSearchIndexProvider; |
| import com.android.settings.search.Indexable; |
| import com.android.settingslib.applications.StorageStatsSource; |
| import com.android.settingslib.deviceinfo.PrivateStorageInfo; |
| import com.android.settingslib.deviceinfo.StorageManagerVolumeProvider; |
| |
| import java.util.ArrayList; |
| import java.util.Arrays; |
| import java.util.List; |
| |
| public class StorageDashboardFragment extends DashboardFragment |
| implements LoaderManager.LoaderCallbacks<SparseArray<StorageAsyncLoader.AppsStorageResult>> { |
| private static final String TAG = "StorageDashboardFrag"; |
| private static final int STORAGE_JOB_ID = 0; |
| private static final int ICON_JOB_ID = 1; |
| private static final int VOLUME_SIZE_JOB_ID = 2; |
| private static final int OPTIONS_MENU_MIGRATE_DATA = 100; |
| |
| private VolumeInfo mVolume; |
| private PrivateStorageInfo mStorageInfo; |
| private SparseArray<StorageAsyncLoader.AppsStorageResult> mAppsResult; |
| |
| private StorageSummaryDonutPreferenceController mSummaryController; |
| private StorageItemPreferenceController mPreferenceController; |
| private PrivateVolumeOptionMenuController mOptionMenuController; |
| private List<PreferenceController> mSecondaryUsers; |
| |
| @Override |
| public void onCreate(Bundle icicle) { |
| super.onCreate(icicle); |
| |
| // Initialize the storage sizes that we can quickly calc. |
| final Activity activity = getActivity(); |
| StorageManager sm = activity.getSystemService(StorageManager.class); |
| mVolume = Utils.maybeInitializeVolume(sm, getArguments()); |
| if (mVolume == null) { |
| activity.finish(); |
| return; |
| } |
| |
| initializeOptionsMenu(activity); |
| } |
| |
| @VisibleForTesting |
| void initializeOptionsMenu(Activity activity) { |
| mOptionMenuController = new PrivateVolumeOptionMenuController( |
| activity, mVolume, new PackageManagerWrapperImpl(activity.getPackageManager())); |
| getLifecycle().addObserver(mOptionMenuController); |
| setHasOptionsMenu(true); |
| activity.invalidateOptionsMenu(); |
| } |
| |
| @Override |
| public void onViewCreated(View v, Bundle savedInstanceState) { |
| super.onViewCreated(v, savedInstanceState); |
| setLoading(true, false); |
| } |
| |
| @Override |
| public void onResume() { |
| super.onResume(); |
| getLoaderManager().restartLoader(STORAGE_JOB_ID, Bundle.EMPTY, this); |
| getLoaderManager().initLoader(ICON_JOB_ID, Bundle.EMPTY, new IconLoaderCallbacks()); |
| getLoaderManager().initLoader(VOLUME_SIZE_JOB_ID, Bundle.EMPTY, new VolumeSizeCallbacks()); |
| } |
| |
| @Override |
| protected int getHelpResource() { |
| return R.string.help_url_storage_dashboard; |
| } |
| |
| private void onReceivedSizes() { |
| if (mStorageInfo == null || mAppsResult == null) { |
| return; |
| } |
| |
| long privateUsedBytes = mStorageInfo.totalBytes - mStorageInfo.freeBytes; |
| mSummaryController.updateBytes(privateUsedBytes, mStorageInfo.totalBytes); |
| mPreferenceController.setVolume(mVolume); |
| mPreferenceController.setUsedSize(privateUsedBytes); |
| mPreferenceController.setTotalSize(mStorageInfo.totalBytes); |
| for (int i = 0, size = mSecondaryUsers.size(); i < size; i++) { |
| PreferenceController controller = mSecondaryUsers.get(i); |
| if (controller instanceof SecondaryUserController) { |
| SecondaryUserController userController = (SecondaryUserController) controller; |
| userController.setTotalSize(mStorageInfo.totalBytes); |
| } |
| } |
| |
| mPreferenceController.onLoadFinished(mAppsResult, UserHandle.myUserId()); |
| updateSecondaryUserControllers(mSecondaryUsers, mAppsResult); |
| |
| // setLoading always causes a flicker, so let's avoid doing it. |
| if (getView().findViewById(R.id.loading_container).getVisibility() == View.VISIBLE) { |
| setLoading(false, true); |
| } |
| } |
| |
| @Override |
| public int getMetricsCategory() { |
| return MetricsProto.MetricsEvent.SETTINGS_STORAGE_CATEGORY; |
| } |
| |
| @Override |
| protected String getLogTag() { |
| return TAG; |
| } |
| |
| @Override |
| protected int getPreferenceScreenResId() { |
| return R.xml.storage_dashboard_fragment; |
| } |
| |
| @Override |
| protected List<PreferenceController> getPreferenceControllers(Context context) { |
| final List<PreferenceController> controllers = new ArrayList<>(); |
| mSummaryController = new StorageSummaryDonutPreferenceController(context); |
| controllers.add(mSummaryController); |
| |
| StorageManager sm = context.getSystemService(StorageManager.class); |
| mPreferenceController = new StorageItemPreferenceController(context, this, |
| mVolume, new StorageManagerVolumeProvider(sm)); |
| controllers.add(mPreferenceController); |
| |
| UserManagerWrapper userManager = |
| new UserManagerWrapperImpl(context.getSystemService(UserManager.class)); |
| mSecondaryUsers = SecondaryUserController.getSecondaryUserControllers(context, userManager); |
| controllers.addAll(mSecondaryUsers); |
| |
| final AutomaticStorageManagementSwitchPreferenceController asmController = |
| new AutomaticStorageManagementSwitchPreferenceController( |
| context, mMetricsFeatureProvider, getFragmentManager()); |
| getLifecycle().addObserver(asmController); |
| controllers.add(asmController); |
| return controllers; |
| } |
| |
| @VisibleForTesting |
| protected void setVolume(VolumeInfo info) { |
| mVolume = info; |
| } |
| |
| /** |
| * Updates the secondary user controller sizes. |
| */ |
| private void updateSecondaryUserControllers(List<PreferenceController> controllers, |
| SparseArray<StorageAsyncLoader.AppsStorageResult> stats) { |
| for (int i = 0, size = controllers.size(); i < size; i++) { |
| PreferenceController controller = controllers.get(i); |
| if (controller instanceof StorageAsyncLoader.ResultHandler) { |
| StorageAsyncLoader.ResultHandler userController = |
| (StorageAsyncLoader.ResultHandler) controller; |
| userController.handleResult(stats); |
| } |
| } |
| } |
| |
| /** |
| * For Search. |
| */ |
| public static final Indexable.SearchIndexProvider SEARCH_INDEX_DATA_PROVIDER = |
| new BaseSearchIndexProvider() { |
| @Override |
| public List<SearchIndexableResource> getXmlResourcesToIndex( |
| Context context, boolean enabled) { |
| final SearchIndexableResource sir = new SearchIndexableResource(context); |
| sir.xmlResId = R.xml.storage_dashboard_fragment; |
| return Arrays.asList(sir); |
| } |
| |
| @Override |
| public List<PreferenceController> getPreferenceControllers(Context context) { |
| final StorageManager sm = context.getSystemService(StorageManager.class); |
| final UserManagerWrapper userManager = |
| new UserManagerWrapperImpl(context.getSystemService(UserManager.class)); |
| final List<PreferenceController> controllers = new ArrayList<>(); |
| controllers.add(new StorageSummaryDonutPreferenceController(context)); |
| controllers.add(new StorageItemPreferenceController(context, null /* host */, |
| null /* volume */, new StorageManagerVolumeProvider(sm))); |
| controllers.addAll(SecondaryUserController.getSecondaryUserControllers( |
| context, userManager)); |
| return controllers; |
| } |
| |
| }; |
| |
| @Override |
| public Loader<SparseArray<StorageAsyncLoader.AppsStorageResult>> onCreateLoader(int id, |
| Bundle args) { |
| Context context = getContext(); |
| return new StorageAsyncLoader(context, |
| new UserManagerWrapperImpl(context.getSystemService(UserManager.class)), |
| mVolume.fsUuid, |
| new StorageStatsSource(context), |
| new PackageManagerWrapperImpl(context.getPackageManager())); |
| } |
| |
| @Override |
| public void onLoadFinished(Loader<SparseArray<StorageAsyncLoader.AppsStorageResult>> loader, |
| SparseArray<StorageAsyncLoader.AppsStorageResult> data) { |
| mAppsResult = data; |
| onReceivedSizes(); |
| } |
| |
| @Override |
| public void onLoaderReset(Loader<SparseArray<StorageAsyncLoader.AppsStorageResult>> loader) { |
| } |
| |
| /** |
| * IconLoaderCallbacks exists because StorageDashboardFragment already implements |
| * LoaderCallbacks for a different type. |
| */ |
| public final class IconLoaderCallbacks |
| implements LoaderManager.LoaderCallbacks<SparseArray<Drawable>> { |
| @Override |
| public Loader<SparseArray<Drawable>> onCreateLoader(int id, Bundle args) { |
| return new UserIconLoader( |
| getContext(), |
| () -> UserIconLoader.loadUserIconsWithContext(getContext())); |
| } |
| |
| @Override |
| public void onLoadFinished( |
| Loader<SparseArray<Drawable>> loader, SparseArray<Drawable> data) { |
| mSecondaryUsers |
| .stream() |
| .filter(controller -> controller instanceof UserIconLoader.UserIconHandler) |
| .forEach( |
| controller -> |
| ((UserIconLoader.UserIconHandler) controller) |
| .handleUserIcons(data)); |
| } |
| |
| @Override |
| public void onLoaderReset(Loader<SparseArray<Drawable>> loader) {} |
| } |
| |
| public final class VolumeSizeCallbacks |
| implements LoaderManager.LoaderCallbacks<PrivateStorageInfo> { |
| @Override |
| public Loader<PrivateStorageInfo> onCreateLoader(int id, Bundle args) { |
| Context context = getContext(); |
| StorageManager sm = context.getSystemService(StorageManager.class); |
| StorageManagerVolumeProvider smvp = new StorageManagerVolumeProvider(sm); |
| final StorageStatsManager stats = context.getSystemService(StorageStatsManager.class); |
| return new VolumeSizesLoader(context, smvp, stats, mVolume); |
| } |
| |
| @Override |
| public void onLoaderReset(Loader<PrivateStorageInfo> loader) {} |
| |
| @Override |
| public void onLoadFinished( |
| Loader<PrivateStorageInfo> loader, PrivateStorageInfo privateStorageInfo) { |
| if (privateStorageInfo == null) { |
| getActivity().finish(); |
| return; |
| } |
| |
| mStorageInfo = privateStorageInfo; |
| onReceivedSizes(); |
| } |
| } |
| } |