/*
* Copyright (C) 2011 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.settingslib.deviceinfo;
import android.app.ActivityManager;
import android.content.ComponentName;
import android.content.Context;
import android.content.Intent;
import android.content.ServiceConnection;
import android.content.pm.ApplicationInfo;
import android.content.pm.IPackageStatsObserver;
import android.content.pm.PackageManager;
import android.content.pm.PackageStats;
import android.content.pm.UserInfo;
import android.os.Environment;
import android.os.Handler;
import android.os.HandlerThread;
import android.os.IBinder;
import android.os.Looper;
import android.os.Message;
import android.os.UserHandle;
import android.os.UserManager;
import android.os.storage.StorageVolume;
import android.os.storage.VolumeInfo;
import android.util.Log;
import android.util.SparseArray;
import android.util.SparseLongArray;
import com.android.internal.app.IMediaContainerService;
import com.android.internal.util.ArrayUtils;
import com.google.android.collect.Sets;
import java.io.File;
import java.lang.ref.WeakReference;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Objects;
import java.util.Set;
/**
* Utility for measuring the disk usage of internal storage or a physical
* {@link StorageVolume}. Connects with a remote {@link IMediaContainerService}
* and delivers results to {@link MeasurementReceiver}.
*/
public class StorageMeasurement {
private static final String TAG = "StorageMeasurement";
private static final boolean LOCAL_LOGV = true;
static final boolean LOGV = LOCAL_LOGV && Log.isLoggable(TAG, Log.VERBOSE);
private static final String DEFAULT_CONTAINER_PACKAGE = "com.android.defcontainer";
public static final ComponentName DEFAULT_CONTAINER_COMPONENT = new ComponentName(
DEFAULT_CONTAINER_PACKAGE, "com.android.defcontainer.DefaultContainerService");
/** Media types to measure on external storage. */
private static final Set<String> sMeasureMediaTypes = Sets.newHashSet(
Environment.DIRECTORY_DCIM, Environment.DIRECTORY_MOVIES,
Environment.DIRECTORY_PICTURES, Environment.DIRECTORY_MUSIC,
Environment.DIRECTORY_ALARMS, Environment.DIRECTORY_NOTIFICATIONS,
Environment.DIRECTORY_RINGTONES, Environment.DIRECTORY_PODCASTS,
Environment.DIRECTORY_DOWNLOADS, Environment.DIRECTORY_ANDROID);
public static class MeasurementDetails {
public long totalSize;
public long availSize;
/**
* Total apps disk usage per profiles of the current user.
* <p>
* When measuring internal storage, this value includes the code size of
* all apps (regardless of install status for the given profile), and
* internal disk used by the profile's apps. When the device
* emulates external storage, this value also includes emulated storage
* used by the profile's apps.
* <p>
* When measuring a physical {@link StorageVolume}, this value includes
* usage by all apps on that volume and only for the primary profile.
* <p>
* Key is {@link UserHandle}.
*/
public SparseLongArray appsSize = new SparseLongArray();
/**
* Total cache disk usage by apps (over all users and profiles).
*/
public long cacheSize;
/**
* Total media disk usage, categorized by types such as
* {@link Environment#DIRECTORY_MUSIC} for every user profile of the current user.
* <p>
* When measuring internal storage, this reflects media on emulated
* storage for the respective profile.
* <p>
* When measuring a physical {@link StorageVolume}, this reflects media
* on that volume.
* <p>
* Key of the {@link SparseArray} is {@link UserHandle}.
*/
public SparseArray<HashMap<String, Long>> mediaSize = new SparseArray<>();
/**
* Misc external disk usage for the current user's profiles, unaccounted in
* {@link #mediaSize}. Key is {@link UserHandle}.
*/
public SparseLongArray miscSize = new SparseLongArray();
/**
* Total disk usage for users, which is only meaningful for emulated
* internal storage. Key is {@link UserHandle}.
*/
public SparseLongArray usersSize = new SparseLongArray();
}
public interface MeasurementReceiver {
void onDetailsChanged(MeasurementDetails details);
}
private WeakReference<MeasurementReceiver> mReceiver;
private final Context mContext;
private final VolumeInfo mVolume;
private final VolumeInfo mSharedVolume;
private final MainHandler mMainHandler;
private final MeasurementHandler mMeasurementHandler;
public StorageMeasurement(Context context, VolumeInfo volume, VolumeInfo sharedVolume) {
mContext = context.getApplicationContext();
mVolume = volume;
mSharedVolume = sharedVolume;
// Start the thread that will measure the disk usage.
final HandlerThread handlerThread = new HandlerThread("MemoryMeasurement");
handlerThread.start();
mMainHandler = new MainHandler();
mMeasurementHandler = new MeasurementHandler(handlerThread.getLooper());
}
public void setReceiver(MeasurementReceiver receiver) {
if (mReceiver == null || mReceiver.get() == null) {
mReceiver = new WeakReference<MeasurementReceiver>(receiver);
}
}
public void forceMeasure() {
invalidate();
measure();
}
public void measure() {
if (!mMeasurementHandler.hasMessages(MeasurementHandler.MSG_MEASURE)) {
mMeasurementHandler.sendEmptyMessage(MeasurementHandler.MSG_MEASURE);
}
}
public void onDestroy() {
mReceiver = null;
mMeasurementHandler.removeMessages(MeasurementHandler.MSG_MEASURE);
mMeasurementHandler.sendEmptyMessage(MeasurementHandler.MSG_DISCONNECT);
}
private void invalidate() {
mMeasurementHandler.sendEmptyMessage(MeasurementHandler.MSG_INVALIDATE);
}
private static class StatsObserver extends IPackageStatsObserver.Stub {
private final boolean mIsPrivate;
private final MeasurementDetails mDetails;
private final int mCurrentUser;
private final Message mFinished;
private int mRemaining;
public StatsObserver(boolean isPrivate, MeasurementDetails details, int currentUser,
List<UserInfo> profiles, Message finished, int remaining) {
mIsPrivate = isPrivate;
mDetails = details;
mCurrentUser = currentUser;
if (isPrivate) {
// Add the profile ids as keys to detail's app sizes.
for (UserInfo userInfo : profiles) {
mDetails.appsSize.put(userInfo.id, 0);
}
}
mFinished = finished;
mRemaining = remaining;
}
@Override
public void onGetStatsCompleted(PackageStats stats, boolean succeeded) {
synchronized (mDetails) {
if (succeeded) {
addStatsLocked(stats);
}
if (--mRemaining == 0) {
mFinished.sendToTarget();
}
}
}
private void addStatsLocked(PackageStats stats) {
if (mIsPrivate) {
long codeSize = stats.codeSize;
long dataSize = stats.dataSize;
long cacheSize = stats.cacheSize;
if (Environment.isExternalStorageEmulated()) {
// Include emulated storage when measuring internal. OBB is
// shared on emulated storage, so treat as code.
codeSize += stats.externalCodeSize + stats.externalObbSize;
dataSize += stats.externalDataSize + stats.externalMediaSize;
cacheSize += stats.externalCacheSize;
}
// Count code and data for current user's profiles (keys prepared in constructor)
addValueIfKeyExists(mDetails.appsSize, stats.userHandle, codeSize + dataSize);
// User summary only includes data (code is only counted once
// for the current user)
addValue(mDetails.usersSize, stats.userHandle, dataSize);
// Include cache for all users
mDetails.cacheSize += cacheSize;
} else {
// Physical storage; only count external sizes
addValue(mDetails.appsSize, mCurrentUser,
stats.externalCodeSize + stats.externalDataSize
+ stats.externalMediaSize + stats.externalObbSize);
mDetails.cacheSize += stats.externalCacheSize;
}
}
}
private class MainHandler extends Handler {
@Override
public void handleMessage(Message msg) {
final MeasurementDetails details = (MeasurementDetails) msg.obj;
final MeasurementReceiver receiver = (mReceiver != null) ? mReceiver.get() : null;
if (receiver != null) {
receiver.onDetailsChanged(details);
}
}
}
private class MeasurementHandler extends Handler {
public static final int MSG_MEASURE = 1;
public static final int MSG_CONNECTED = 2;
public static final int MSG_DISCONNECT = 3;
public static final int MSG_COMPLETED = 4;
public static final int MSG_INVALIDATE = 5;
private Object mLock = new Object();
private IMediaContainerService mDefaultContainer;
private volatile boolean mBound = false;
private MeasurementDetails mCached;
private final ServiceConnection mDefContainerConn = new ServiceConnection() {
@Override
public void onServiceConnected(ComponentName name, IBinder service) {
final IMediaContainerService imcs = IMediaContainerService.Stub.asInterface(
service);
mDefaultContainer = imcs;
mBound = true;
sendMessage(obtainMessage(MSG_CONNECTED, imcs));
}
@Override
public void onServiceDisconnected(ComponentName name) {
mBound = false;
removeMessages(MSG_CONNECTED);
}
};
public MeasurementHandler(Looper looper) {
super(looper);
}
@Override
public void handleMessage(Message msg) {
switch (msg.what) {
case MSG_MEASURE: {
if (mCached != null) {
mMainHandler.obtainMessage(0, mCached).sendToTarget();
break;
}
synchronized (mLock) {
if (mBound) {
removeMessages(MSG_DISCONNECT);
sendMessage(obtainMessage(MSG_CONNECTED, mDefaultContainer));
} else {
Intent service = new Intent().setComponent(DEFAULT_CONTAINER_COMPONENT);
mContext.bindServiceAsUser(service, mDefContainerConn,
Context.BIND_AUTO_CREATE, UserHandle.OWNER);
}
}
break;
}
case MSG_CONNECTED: {
final IMediaContainerService imcs = (IMediaContainerService) msg.obj;
measureExactStorage(imcs);
break;
}
case MSG_DISCONNECT: {
synchronized (mLock) {
if (mBound) {
mBound = false;
mContext.unbindService(mDefContainerConn);
}
}
break;
}
case MSG_COMPLETED: {
mCached = (MeasurementDetails) msg.obj;
mMainHandler.obtainMessage(0, mCached).sendToTarget();
break;
}
case MSG_INVALIDATE: {
mCached = null;
break;
}
}
}
}
private void measureExactStorage(IMediaContainerService imcs) {
final UserManager userManager = mContext.getSystemService(UserManager.class);
final PackageManager packageManager = mContext.getPackageManager();
final List<UserInfo> users = userManager.getUsers();
final List<UserInfo> currentProfiles = userManager.getEnabledProfiles(
ActivityManager.getCurrentUser());
final MeasurementDetails details = new MeasurementDetails();
final Message finished = mMeasurementHandler.obtainMessage(MeasurementHandler.MSG_COMPLETED,
details);
if (mVolume == null || !mVolume.isMountedReadable()) {
finished.sendToTarget();
return;
}
if (mSharedVolume != null && mSharedVolume.isMountedReadable()) {
for (UserInfo currentUserInfo : currentProfiles) {
final int userId = currentUserInfo.id;
final File basePath = mSharedVolume.getPathForUser(userId);
HashMap<String, Long> mediaMap = new HashMap<>(sMeasureMediaTypes.size());
details.mediaSize.put(userId, mediaMap);
// Measure media types for emulated storage, or for primary physical
// external volume
for (String type : sMeasureMediaTypes) {
final File path = new File(basePath, type);
final long size = getDirectorySize(imcs, path);
mediaMap.put(type, size);
}
// Measure misc files not counted under media
addValue(details.miscSize, userId, measureMisc(imcs, basePath));
}
if (mSharedVolume.getType() == VolumeInfo.TYPE_EMULATED) {
// Measure total emulated storage of all users; internal apps data
// will be spliced in later
for (UserInfo user : users) {
final File userPath = mSharedVolume.getPathForUser(user.id);
final long size = getDirectorySize(imcs, userPath);
addValue(details.usersSize, user.id, size);
}
}
}
final File file = mVolume.getPath();
if (file != null) {
details.totalSize = file.getTotalSpace();
details.availSize = file.getFreeSpace();
}
// Measure all apps hosted on this volume for all users
if (mVolume.getType() == VolumeInfo.TYPE_PRIVATE) {
final List<ApplicationInfo> apps = packageManager.getInstalledApplications(
PackageManager.GET_UNINSTALLED_PACKAGES
| PackageManager.GET_DISABLED_COMPONENTS);
final List<ApplicationInfo> volumeApps = new ArrayList<>();
for (ApplicationInfo app : apps) {
if (Objects.equals(app.volumeUuid, mVolume.getFsUuid())) {
volumeApps.add(app);
}
}
final int count = users.size() * volumeApps.size();
if (count == 0) {
finished.sendToTarget();
return;
}
final StatsObserver observer = new StatsObserver(true, details,
ActivityManager.getCurrentUser(), currentProfiles, finished, count);
for (UserInfo user : users) {
for (ApplicationInfo app : volumeApps) {
packageManager.getPackageSizeInfo(app.packageName, user.id, observer);
}
}
} else {
finished.sendToTarget();
return;
}
}
private static long getDirectorySize(IMediaContainerService imcs, File path) {
try {
final long size = imcs.calculateDirectorySize(path.toString());
Log.d(TAG, "getDirectorySize(" + path + ") returned " + size);
return size;
} catch (Exception e) {
Log.w(TAG, "Could not read memory from default container service for " + path, e);
return 0;
}
}
private long measureMisc(IMediaContainerService imcs, File dir) {
final File[] files = dir.listFiles();
if (ArrayUtils.isEmpty(files)) return 0;
// Get sizes of all top level nodes except the ones already computed
long miscSize = 0;
for (File file : files) {
final String name = file.getName();
if (sMeasureMediaTypes.contains(name)) {
continue;
}
if (file.isFile()) {
miscSize += file.length();
} else if (file.isDirectory()) {
miscSize += getDirectorySize(imcs, file);
}
}
return miscSize;
}
private static void addValue(SparseLongArray array, int key, long value) {
array.put(key, array.get(key) + value);
}
private static void addValueIfKeyExists(SparseLongArray array, int key, long value) {
final int index = array.indexOfKey(key);
if (index >= 0) {
array.put(key, array.valueAt(index) + value);
}
}
}