settings/deviceinfo/StorageMeasurement.java

/*
 * 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.settings.deviceinfo;

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.os.Bundle;
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.StatFs;
import android.os.storage.StorageVolume;
import android.util.Log;

import com.android.internal.app.IMediaContainerService;

import java.io.File;
import java.lang.ref.WeakReference;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

/**
 * Measure the memory for various systems.
 *
 * TODO: This class should ideally have less knowledge about what the context
 * it's measuring is. In the future, reduce the amount of stuff it needs to
 * know about by just keeping an array of measurement types of the following
 * properties:
 *
 *   Filesystem stats (using StatFs)
 *   Directory measurements (using DefaultContainerService.measureDir)
 *   Application measurements (using PackageManager)
 *
 * Then the calling application would just specify the type and an argument.
 * This class would keep track of it while the calling application would
 * decide on how to use it.
 */
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);

    public static final String TOTAL_SIZE = "total_size";

    public static final String AVAIL_SIZE = "avail_size";

    public static final String APPS_USED = "apps_used";

    public static final String DOWNLOADS_SIZE = "downloads_size";

    public static final String MISC_SIZE = "misc_size";

    public static final String MEDIA_SIZES = "media_sizes";

    private static final String DEFAULT_CONTAINER_PACKAGE = "com.android.defcontainer";

    private static final ComponentName DEFAULT_CONTAINER_COMPONENT = new ComponentName(
            DEFAULT_CONTAINER_PACKAGE, "com.android.defcontainer.DefaultContainerService");

    private final MeasurementHandler mHandler;

    private static Map<StorageVolume, StorageMeasurement> sInstances =
        new ConcurrentHashMap<StorageVolume, StorageMeasurement>();
    private static StorageMeasurement sInternalInstance;

    private volatile WeakReference<MeasurementReceiver> mReceiver;

    private long mTotalSize;
    private long mAvailSize;
    private long mAppsSize;
    private long mDownloadsSize;
    private long mMiscSize;
    private long[] mMediaSizes = new long[StorageVolumePreferenceCategory.sMediaCategories.length];

    final private StorageVolume mStorageVolume;
    final private boolean mIsPrimary;
    final private boolean mIsInternal;

    List<FileInfo> mFileInfoForMisc;

    public interface MeasurementReceiver {
        public void updateApproximate(Bundle bundle);
        public void updateExact(Bundle bundle);
    }

    private StorageMeasurement(Context context, StorageVolume storageVolume, boolean isPrimary) {
        mStorageVolume = storageVolume;
        mIsInternal = storageVolume == null;
        mIsPrimary = !mIsInternal && isPrimary;

        // Start the thread that will measure the disk usage.
        final HandlerThread handlerThread = new HandlerThread("MemoryMeasurement");
        handlerThread.start();
        mHandler = new MeasurementHandler(context, handlerThread.getLooper());
    }

    /**
     * Get the singleton of the StorageMeasurement class. The application
     * context is used to avoid leaking activities.
     * @param storageVolume The {@link StorageVolume} that will be measured
     * @param isPrimary true when this storage volume is the primary volume
     */
    public static StorageMeasurement getInstance(Context context, StorageVolume storageVolume,
            boolean isPrimary) {
        if (storageVolume == null) {
            if (sInternalInstance == null) {
                sInternalInstance =
                    new StorageMeasurement(context.getApplicationContext(), storageVolume, isPrimary);
            }
            return sInternalInstance;
        }
        if (sInstances.containsKey(storageVolume)) {
            return sInstances.get(storageVolume);
        } else {
            StorageMeasurement storageMeasurement =
                new StorageMeasurement(context.getApplicationContext(), storageVolume, isPrimary);
            sInstances.put(storageVolume, storageMeasurement);
            return storageMeasurement;
        }
    }

    public void setReceiver(MeasurementReceiver receiver) {
        if (mReceiver == null || mReceiver.get() == null) {
            mReceiver = new WeakReference<MeasurementReceiver>(receiver);
        }
    }

    public void measure() {
        if (!mHandler.hasMessages(MeasurementHandler.MSG_MEASURE)) {
            mHandler.sendEmptyMessage(MeasurementHandler.MSG_MEASURE);
        }
    }

    public void cleanUp() {
        mReceiver = null;
        mHandler.removeMessages(MeasurementHandler.MSG_MEASURE);
        mHandler.sendEmptyMessage(MeasurementHandler.MSG_DISCONNECT);
    }

    public void invalidate() {
        mHandler.sendEmptyMessage(MeasurementHandler.MSG_INVALIDATE);
    }

    private void sendInternalApproximateUpdate() {
        MeasurementReceiver receiver = (mReceiver != null) ? mReceiver.get() : null;
        if (receiver == null) {
            return;
        }

        Bundle bundle = new Bundle();
        bundle.putLong(TOTAL_SIZE, mTotalSize);
        bundle.putLong(AVAIL_SIZE, mAvailSize);

        receiver.updateApproximate(bundle);
    }

    private void sendExactUpdate() {
        MeasurementReceiver receiver = (mReceiver != null) ? mReceiver.get() : null;
        if (receiver == null) {
            if (LOGV) {
                Log.i(TAG, "measurements dropped because receiver is null! wasted effort");
            }
            return;
        }

        Bundle bundle = new Bundle();
        bundle.putLong(TOTAL_SIZE, mTotalSize);
        bundle.putLong(AVAIL_SIZE, mAvailSize);
        bundle.putLong(APPS_USED, mAppsSize);
        bundle.putLong(DOWNLOADS_SIZE, mDownloadsSize);
        bundle.putLong(MISC_SIZE, mMiscSize);
        bundle.putLongArray(MEDIA_SIZES, mMediaSizes);

        receiver.updateExact(bundle);
    }

    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 volatile boolean mMeasured = false;

        private StatsObserver mStatsObserver;

        private final WeakReference<Context> mContext;

        final private ServiceConnection mDefContainerConn = new ServiceConnection() {
            public void onServiceConnected(ComponentName name, IBinder service) {
                final IMediaContainerService imcs = IMediaContainerService.Stub
                .asInterface(service);
                mDefaultContainer = imcs;
                mBound = true;
                sendMessage(obtainMessage(MSG_CONNECTED, imcs));
            }

            public void onServiceDisconnected(ComponentName name) {
                mBound = false;
                removeMessages(MSG_CONNECTED);
            }
        };

        public MeasurementHandler(Context context, Looper looper) {
            super(looper);
            mContext = new WeakReference<Context>(context);
        }

        @Override
        public void handleMessage(Message msg) {
            switch (msg.what) {
                case MSG_MEASURE: {
                    if (mMeasured) {
                        sendExactUpdate();
                        break;
                    }

                    final Context context = (mContext != null) ? mContext.get() : null;
                    if (context == null) {
                        return;
                    }

                    measureApproximateStorage();

                    synchronized (mLock) {
                        if (mBound) {
                            removeMessages(MSG_DISCONNECT);
                            sendMessage(obtainMessage(MSG_CONNECTED, mDefaultContainer));
                        } else {
                            Intent service = new Intent().setComponent(DEFAULT_CONTAINER_COMPONENT);
                            context.bindService(service, mDefContainerConn,
                                    Context.BIND_AUTO_CREATE);
                        }
                    }
                    break;
                }
                case MSG_CONNECTED: {
                    IMediaContainerService imcs = (IMediaContainerService) msg.obj;
                    measureExactStorage(imcs);
                    break;
                }
                case MSG_DISCONNECT: {
                    synchronized (mLock) {
                        if (mBound) {
                            final Context context = (mContext != null) ? mContext.get() : null;
                            if (context == null) {
                                return;
                            }

                            mBound = false;
                            context.unbindService(mDefContainerConn);
                        }
                    }
                    break;
                }
                case MSG_COMPLETED: {
                    mMeasured = true;
                    sendExactUpdate();
                    break;
                }
                case MSG_INVALIDATE: {
                    mMeasured = false;
                    break;
                }
            }
        }

        /**
         * Request measurement of each package.
         *
         * @param pm PackageManager instance to query
         */
        public void requestQueuedMeasurementsLocked(PackageManager pm) {
            final String[] appsList = mStatsObserver.getAppsList();
            final int N = appsList.length;
            for (int i = 0; i < N; i++) {
                pm.getPackageSizeInfo(appsList[i], mStatsObserver);
            }
        }

        private class StatsObserver extends IPackageStatsObserver.Stub {
            private long mAppsSizeForThisStatsObserver = 0;
            private final List<String> mAppsList = new ArrayList<String>();

            public void onGetStatsCompleted(PackageStats stats, boolean succeeded) {
                if (!mStatsObserver.equals(this)) {
                    // this callback's class object is no longer in use. ignore this callback.
                    return;
                }

                if (succeeded) {
                    if (mIsInternal) {
                        mAppsSizeForThisStatsObserver += stats.codeSize + stats.dataSize;
                    } else if (!Environment.isExternalStorageEmulated()) {
                        mAppsSizeForThisStatsObserver += stats.externalObbSize +
                                stats.externalCodeSize + stats.externalDataSize +
                                stats.externalCacheSize + stats.externalMediaSize;
                    } else {
                        mAppsSizeForThisStatsObserver += stats.codeSize + stats.dataSize +
                                stats.externalCodeSize + stats.externalDataSize +
                                stats.externalCacheSize + stats.externalMediaSize +
                                stats.externalObbSize;
                    }
                }

                synchronized (mAppsList) {
                    mAppsList.remove(stats.packageName);
                    if (mAppsList.size() > 0) return;
                }

                mAppsSize = mAppsSizeForThisStatsObserver;
                onInternalMeasurementComplete();
            }

            public void queuePackageMeasurementLocked(String packageName) {
                synchronized (mAppsList) {
                    mAppsList.add(packageName);
                }
            }

            public String[] getAppsList() {
                synchronized (mAppsList) {
                    return mAppsList.toArray(new String[mAppsList.size()]);
                }
            }
        }

        private void onInternalMeasurementComplete() {
            sendEmptyMessage(MSG_COMPLETED);
        }

        private void measureApproximateStorage() {
            final StatFs stat = new StatFs(mStorageVolume != null
                    ? mStorageVolume.getPath() : Environment.getDataDirectory().getPath());
            final long blockSize = stat.getBlockSize();
            final long totalBlocks = stat.getBlockCount();
            final long availableBlocks = stat.getAvailableBlocks();

            mTotalSize = totalBlocks * blockSize;
            mAvailSize = availableBlocks * blockSize;

            sendInternalApproximateUpdate();
        }

        private void measureExactStorage(IMediaContainerService imcs) {
            Context context = mContext != null ? mContext.get() : null;
            if (context == null) {
                return;
            }

            // Media
            for (int i = 0; i < StorageVolumePreferenceCategory.sMediaCategories.length; i++) {
                if (mIsPrimary) {
                    String[] dirs = StorageVolumePreferenceCategory.sMediaCategories[i].mDirPaths;
                    final int length = dirs.length;
                    mMediaSizes[i] = 0;
                    for (int d = 0; d < length; d++) {
                        final String path = dirs[d];
                        mMediaSizes[i] += getDirectorySize(imcs, path);
                    }
                } else {
                    // TODO Compute sizes using the MediaStore
                    mMediaSizes[i] = 0;
                }
            }

            /* Compute sizes using the media provider
            // Media sizes are measured by the MediaStore. Query database.
            ContentResolver contentResolver = context.getContentResolver();
            // TODO "external" as a static String from MediaStore?
            Uri audioUri = MediaStore.Files.getContentUri("external");
            final String[] projection =
                new String[] { "sum(" + MediaStore.Files.FileColumns.SIZE + ")" };
            final String selection =
                MediaStore.Files.FileColumns.STORAGE_ID + "=" +
                Integer.toString(mStorageVolume.getStorageId()) + " AND " +
                MediaStore.Files.FileColumns.MEDIA_TYPE + "=?";

            for (int i = 0; i < StorageVolumePreferenceCategory.sMediaCategories.length; i++) {
                mMediaSizes[i] = 0;
                int mediaType = StorageVolumePreferenceCategory.sMediaCategories[i].mediaType;
                Cursor c = null;
                try {
                    c = contentResolver.query(audioUri, projection, selection,
                            new String[] { Integer.toString(mediaType) } , null);

                    if (c != null && c.moveToNext()) {
                        long size = c.getLong(0);
                        mMediaSizes[i] = size;
                    }
                } finally {
                    if (c != null) c.close();
                }
            }
             */

            // Downloads (primary volume only)
            if (mIsPrimary) {
                final String downloadsPath = Environment.getExternalStoragePublicDirectory(
                        Environment.DIRECTORY_DOWNLOADS).getAbsolutePath();
                mDownloadsSize = getDirectorySize(imcs, downloadsPath);
            } else {
                mDownloadsSize = 0;
            }

            // Misc
            mMiscSize = 0;
            if (mIsPrimary) {
                measureSizesOfMisc(imcs);
            }

            // Apps
            // We have to get installd to measure the package sizes.
            PackageManager pm = context.getPackageManager();
            if (pm == null) {
                return;
            }
            final List<ApplicationInfo> apps;
            if (mIsPrimary || mIsInternal) {
                apps = pm.getInstalledApplications(PackageManager.GET_UNINSTALLED_PACKAGES |
                        PackageManager.GET_DISABLED_COMPONENTS);
            } else {
                // TODO also measure apps installed on the SD card
                apps = Collections.emptyList();
            }

            if (apps != null && apps.size() > 0) {
                // initiate measurement of all package sizes. need new StatsObserver object.
                mStatsObserver = new StatsObserver();
                synchronized (mStatsObserver.mAppsList) {
                    for (int i = 0; i < apps.size(); i++) {
                        final ApplicationInfo info = apps.get(i);
                        mStatsObserver.queuePackageMeasurementLocked(info.packageName);
                    }
                }

                requestQueuedMeasurementsLocked(pm);
                // Sending of the message back to the MeasurementReceiver is
                // completed in the PackageObserver
            } else {
                onInternalMeasurementComplete();
            }
        }
    }

    private long getDirectorySize(IMediaContainerService imcs, String dir) {
        try {
            return imcs.calculateDirectorySize(dir);
        } catch (Exception e) {
            Log.w(TAG, "Could not read memory from default container service for " + dir, e);
            return 0;
        }
    }

    long getMiscSize() {
        return mMiscSize;
    }

    private void measureSizesOfMisc(IMediaContainerService imcs) {
        File top = new File(mStorageVolume.getPath());
        mFileInfoForMisc = new ArrayList<FileInfo>();
        File[] files = top.listFiles();
        if (files == null) return;
        final int len = files.length;
        // Get sizes of all top level nodes except the ones already computed...
        long counter = 0;
        for (int i = 0; i < len; i++) {
            String path = files[i].getAbsolutePath();
            if (StorageVolumePreferenceCategory.sPathsExcludedForMisc.contains(path)) {
                continue;
            }
            if (files[i].isFile()) {
                final long fileSize = files[i].length();
                mFileInfoForMisc.add(new FileInfo(path, fileSize, counter++));
                mMiscSize += fileSize;
            } else if (files[i].isDirectory()) {
                final long dirSize = getDirectorySize(imcs, path);
                mFileInfoForMisc.add(new FileInfo(path, dirSize, counter++));
                mMiscSize += dirSize;
            } else {
                // Non directory, non file: not listed
            }
        }
        // sort the list of FileInfo objects collected above in descending order of their sizes
        Collections.sort(mFileInfoForMisc);
    }

    static class FileInfo implements Comparable<FileInfo> {
        final String mFileName;
        final long mSize;
        final long mId;

        FileInfo(String fileName, long size, long id) {
            mFileName = fileName;
            mSize = size;
            mId = id;
        }

        @Override
        public int compareTo(FileInfo that) {
            if (this == that || mSize == that.mSize) return 0;
            else return (mSize < that.mSize) ? 1 : -1; // for descending sort
        }

        @Override
        public String toString() {
            return mFileName  + " : " + mSize + ", id:" + mId;
        }
    }

    /**
     * TODO remove this method, only used because external SD Card needs a special treatment.
     */
    boolean isExternalSDCard() {
        return !mIsPrimary && !mIsInternal;
    }
}