1 /* 2 * Copyright (C) 2016 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.deviceinfo; 18 19 import android.app.Activity; 20 import android.app.LoaderManager; 21 import android.app.usage.StorageStatsManager; 22 import android.content.Context; 23 import android.content.Loader; 24 import android.graphics.drawable.Drawable; 25 import android.os.Bundle; 26 import android.os.UserHandle; 27 import android.os.UserManager; 28 import android.os.storage.StorageManager; 29 import android.os.storage.VolumeInfo; 30 import android.provider.SearchIndexableResource; 31 import android.support.annotation.VisibleForTesting; 32 import android.util.SparseArray; 33 import android.view.View; 34 35 import com.android.internal.logging.nano.MetricsProto; 36 import com.android.settings.R; 37 import com.android.settings.Utils; 38 import com.android.settings.applications.PackageManagerWrapperImpl; 39 import com.android.settings.applications.UserManagerWrapper; 40 import com.android.settings.applications.UserManagerWrapperImpl; 41 import com.android.settings.core.PreferenceController; 42 import com.android.settings.dashboard.DashboardFragment; 43 import com.android.settings.deviceinfo.storage.AutomaticStorageManagementSwitchPreferenceController; 44 import com.android.settings.deviceinfo.storage.SecondaryUserController; 45 import com.android.settings.deviceinfo.storage.StorageAsyncLoader; 46 import com.android.settings.deviceinfo.storage.StorageItemPreferenceController; 47 import com.android.settings.deviceinfo.storage.StorageSummaryDonutPreferenceController; 48 import com.android.settings.deviceinfo.storage.UserIconLoader; 49 import com.android.settings.deviceinfo.storage.VolumeSizesLoader; 50 import com.android.settings.search.BaseSearchIndexProvider; 51 import com.android.settings.search.Indexable; 52 import com.android.settingslib.applications.StorageStatsSource; 53 import com.android.settingslib.deviceinfo.PrivateStorageInfo; 54 import com.android.settingslib.deviceinfo.StorageManagerVolumeProvider; 55 56 import java.util.ArrayList; 57 import java.util.Arrays; 58 import java.util.List; 59 60 public class StorageDashboardFragment extends DashboardFragment 61 implements LoaderManager.LoaderCallbacks<SparseArray<StorageAsyncLoader.AppsStorageResult>> { 62 private static final String TAG = "StorageDashboardFrag"; 63 private static final int STORAGE_JOB_ID = 0; 64 private static final int ICON_JOB_ID = 1; 65 private static final int VOLUME_SIZE_JOB_ID = 2; 66 private static final int OPTIONS_MENU_MIGRATE_DATA = 100; 67 68 private VolumeInfo mVolume; 69 private PrivateStorageInfo mStorageInfo; 70 private SparseArray<StorageAsyncLoader.AppsStorageResult> mAppsResult; 71 72 private StorageSummaryDonutPreferenceController mSummaryController; 73 private StorageItemPreferenceController mPreferenceController; 74 private PrivateVolumeOptionMenuController mOptionMenuController; 75 private List<PreferenceController> mSecondaryUsers; 76 77 @Override onCreate(Bundle icicle)78 public void onCreate(Bundle icicle) { 79 super.onCreate(icicle); 80 81 // Initialize the storage sizes that we can quickly calc. 82 final Activity activity = getActivity(); 83 StorageManager sm = activity.getSystemService(StorageManager.class); 84 mVolume = Utils.maybeInitializeVolume(sm, getArguments()); 85 if (mVolume == null) { 86 activity.finish(); 87 return; 88 } 89 90 initializeOptionsMenu(activity); 91 } 92 93 @VisibleForTesting initializeOptionsMenu(Activity activity)94 void initializeOptionsMenu(Activity activity) { 95 mOptionMenuController = new PrivateVolumeOptionMenuController( 96 activity, mVolume, new PackageManagerWrapperImpl(activity.getPackageManager())); 97 getLifecycle().addObserver(mOptionMenuController); 98 setHasOptionsMenu(true); 99 activity.invalidateOptionsMenu(); 100 } 101 102 @Override onViewCreated(View v, Bundle savedInstanceState)103 public void onViewCreated(View v, Bundle savedInstanceState) { 104 super.onViewCreated(v, savedInstanceState); 105 setLoading(true, false); 106 } 107 108 @Override onResume()109 public void onResume() { 110 super.onResume(); 111 getLoaderManager().restartLoader(STORAGE_JOB_ID, Bundle.EMPTY, this); 112 getLoaderManager().initLoader(ICON_JOB_ID, Bundle.EMPTY, new IconLoaderCallbacks()); 113 getLoaderManager().initLoader(VOLUME_SIZE_JOB_ID, Bundle.EMPTY, new VolumeSizeCallbacks()); 114 } 115 onReceivedSizes()116 private void onReceivedSizes() { 117 if (mStorageInfo == null || mAppsResult == null) { 118 return; 119 } 120 121 long privateUsedBytes = mStorageInfo.totalBytes - mStorageInfo.freeBytes; 122 mSummaryController.updateBytes(privateUsedBytes, mStorageInfo.totalBytes); 123 mPreferenceController.setVolume(mVolume); 124 mPreferenceController.setUsedSize(privateUsedBytes); 125 mPreferenceController.setTotalSize(mStorageInfo.totalBytes); 126 for (int i = 0, size = mSecondaryUsers.size(); i < size; i++) { 127 PreferenceController controller = mSecondaryUsers.get(i); 128 if (controller instanceof SecondaryUserController) { 129 SecondaryUserController userController = (SecondaryUserController) controller; 130 userController.setTotalSize(mStorageInfo.totalBytes); 131 } 132 } 133 134 mPreferenceController.onLoadFinished(mAppsResult, UserHandle.myUserId()); 135 updateSecondaryUserControllers(mSecondaryUsers, mAppsResult); 136 137 // setLoading always causes a flicker, so let's avoid doing it. 138 if (getView().findViewById(R.id.loading_container).getVisibility() == View.VISIBLE) { 139 setLoading(false, true); 140 } 141 } 142 143 @Override getMetricsCategory()144 public int getMetricsCategory() { 145 return MetricsProto.MetricsEvent.SETTINGS_STORAGE_CATEGORY; 146 } 147 148 @Override getLogTag()149 protected String getLogTag() { 150 return TAG; 151 } 152 153 @Override getPreferenceScreenResId()154 protected int getPreferenceScreenResId() { 155 return R.xml.storage_dashboard_fragment; 156 } 157 158 @Override getPreferenceControllers(Context context)159 protected List<PreferenceController> getPreferenceControllers(Context context) { 160 final List<PreferenceController> controllers = new ArrayList<>(); 161 mSummaryController = new StorageSummaryDonutPreferenceController(context); 162 controllers.add(mSummaryController); 163 164 StorageManager sm = context.getSystemService(StorageManager.class); 165 mPreferenceController = new StorageItemPreferenceController(context, this, 166 mVolume, new StorageManagerVolumeProvider(sm)); 167 controllers.add(mPreferenceController); 168 169 UserManagerWrapper userManager = 170 new UserManagerWrapperImpl(context.getSystemService(UserManager.class)); 171 mSecondaryUsers = SecondaryUserController.getSecondaryUserControllers(context, userManager); 172 controllers.addAll(mSecondaryUsers); 173 174 final AutomaticStorageManagementSwitchPreferenceController asmController = 175 new AutomaticStorageManagementSwitchPreferenceController( 176 context, mMetricsFeatureProvider, getFragmentManager()); 177 getLifecycle().addObserver(asmController); 178 controllers.add(asmController); 179 return controllers; 180 } 181 182 @VisibleForTesting setVolume(VolumeInfo info)183 protected void setVolume(VolumeInfo info) { 184 mVolume = info; 185 } 186 187 /** 188 * Updates the secondary user controller sizes. 189 */ updateSecondaryUserControllers(List<PreferenceController> controllers, SparseArray<StorageAsyncLoader.AppsStorageResult> stats)190 private void updateSecondaryUserControllers(List<PreferenceController> controllers, 191 SparseArray<StorageAsyncLoader.AppsStorageResult> stats) { 192 for (int i = 0, size = controllers.size(); i < size; i++) { 193 PreferenceController controller = controllers.get(i); 194 if (controller instanceof StorageAsyncLoader.ResultHandler) { 195 StorageAsyncLoader.ResultHandler userController = 196 (StorageAsyncLoader.ResultHandler) controller; 197 userController.handleResult(stats); 198 } 199 } 200 } 201 202 /** 203 * For Search. 204 */ 205 public static final Indexable.SearchIndexProvider SEARCH_INDEX_DATA_PROVIDER = 206 new BaseSearchIndexProvider() { 207 @Override 208 public List<SearchIndexableResource> getXmlResourcesToIndex( 209 Context context, boolean enabled) { 210 final SearchIndexableResource sir = new SearchIndexableResource(context); 211 sir.xmlResId = R.xml.storage_dashboard_fragment; 212 return Arrays.asList(sir); 213 } 214 215 @Override 216 public List<PreferenceController> getPreferenceControllers(Context context) { 217 final StorageManager sm = context.getSystemService(StorageManager.class); 218 final UserManagerWrapper userManager = 219 new UserManagerWrapperImpl(context.getSystemService(UserManager.class)); 220 final List<PreferenceController> controllers = new ArrayList<>(); 221 controllers.add(new StorageSummaryDonutPreferenceController(context)); 222 controllers.add(new StorageItemPreferenceController(context, null /* host */, 223 null /* volume */, new StorageManagerVolumeProvider(sm))); 224 controllers.addAll(SecondaryUserController.getSecondaryUserControllers( 225 context, userManager)); 226 return controllers; 227 } 228 229 }; 230 231 @Override onCreateLoader(int id, Bundle args)232 public Loader<SparseArray<StorageAsyncLoader.AppsStorageResult>> onCreateLoader(int id, 233 Bundle args) { 234 Context context = getContext(); 235 return new StorageAsyncLoader(context, 236 new UserManagerWrapperImpl(context.getSystemService(UserManager.class)), 237 mVolume.fsUuid, 238 new StorageStatsSource(context), 239 new PackageManagerWrapperImpl(context.getPackageManager())); 240 } 241 242 @Override onLoadFinished(Loader<SparseArray<StorageAsyncLoader.AppsStorageResult>> loader, SparseArray<StorageAsyncLoader.AppsStorageResult> data)243 public void onLoadFinished(Loader<SparseArray<StorageAsyncLoader.AppsStorageResult>> loader, 244 SparseArray<StorageAsyncLoader.AppsStorageResult> data) { 245 mAppsResult = data; 246 onReceivedSizes(); 247 } 248 249 @Override onLoaderReset(Loader<SparseArray<StorageAsyncLoader.AppsStorageResult>> loader)250 public void onLoaderReset(Loader<SparseArray<StorageAsyncLoader.AppsStorageResult>> loader) { 251 } 252 253 /** 254 * IconLoaderCallbacks exists because StorageDashboardFragment already implements 255 * LoaderCallbacks for a different type. 256 */ 257 public final class IconLoaderCallbacks 258 implements LoaderManager.LoaderCallbacks<SparseArray<Drawable>> { 259 @Override onCreateLoader(int id, Bundle args)260 public Loader<SparseArray<Drawable>> onCreateLoader(int id, Bundle args) { 261 return new UserIconLoader( 262 getContext(), 263 () -> UserIconLoader.loadUserIconsWithContext(getContext())); 264 } 265 266 @Override onLoadFinished( Loader<SparseArray<Drawable>> loader, SparseArray<Drawable> data)267 public void onLoadFinished( 268 Loader<SparseArray<Drawable>> loader, SparseArray<Drawable> data) { 269 mSecondaryUsers 270 .stream() 271 .filter(controller -> controller instanceof UserIconLoader.UserIconHandler) 272 .forEach( 273 controller -> 274 ((UserIconLoader.UserIconHandler) controller) 275 .handleUserIcons(data)); 276 } 277 278 @Override onLoaderReset(Loader<SparseArray<Drawable>> loader)279 public void onLoaderReset(Loader<SparseArray<Drawable>> loader) {} 280 } 281 282 public final class VolumeSizeCallbacks 283 implements LoaderManager.LoaderCallbacks<PrivateStorageInfo> { 284 @Override onCreateLoader(int id, Bundle args)285 public Loader<PrivateStorageInfo> onCreateLoader(int id, Bundle args) { 286 Context context = getContext(); 287 StorageManager sm = context.getSystemService(StorageManager.class); 288 StorageManagerVolumeProvider smvp = new StorageManagerVolumeProvider(sm); 289 final StorageStatsManager stats = context.getSystemService(StorageStatsManager.class); 290 return new VolumeSizesLoader(context, smvp, stats, mVolume); 291 } 292 293 @Override onLoaderReset(Loader<PrivateStorageInfo> loader)294 public void onLoaderReset(Loader<PrivateStorageInfo> loader) {} 295 296 @Override onLoadFinished( Loader<PrivateStorageInfo> loader, PrivateStorageInfo privateStorageInfo)297 public void onLoadFinished( 298 Loader<PrivateStorageInfo> loader, PrivateStorageInfo privateStorageInfo) { 299 if (privateStorageInfo == null) { 300 getActivity().finish(); 301 return; 302 } 303 304 mStorageInfo = privateStorageInfo; 305 onReceivedSizes(); 306 } 307 } 308 } 309