/*
 * Copyright (C) 2014 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.tv.settings.device;

import android.app.ActivityManager;
import android.app.AlertDialog;
import android.app.Dialog;
import android.app.DialogFragment;
import android.app.Fragment;
import android.app.FragmentManager;
import android.content.Context;
import android.content.DialogInterface;
import android.content.Intent;
import android.content.pm.PackageInfo;
import android.content.pm.PackageManager;
import android.content.res.Resources;
import android.os.AsyncTask;
import android.os.Bundle;
import android.os.Environment;
import android.os.storage.DiskInfo;
import android.os.storage.StorageEventListener;
import android.os.storage.StorageManager;
import android.os.storage.VolumeInfo;
import android.os.storage.VolumeRecord;
import android.support.annotation.Nullable;
import android.text.TextUtils;
import android.text.format.Formatter;
import android.util.ArrayMap;
import android.util.Log;
import android.widget.Toast;

import com.android.settingslib.deviceinfo.StorageMeasurement;
import com.android.settingslib.deviceinfo.StorageMeasurement.MeasurementDetails;
import com.android.settingslib.deviceinfo.StorageMeasurement.MeasurementReceiver;
import com.android.tv.settings.R;
import com.android.tv.settings.device.apps.AppsActivity;
import com.android.tv.settings.device.storage.ForgetPrivateStepFragment;
import com.android.tv.settings.device.storage.FormatActivity;
import com.android.tv.settings.device.storage.MigrateStorageActivity;
import com.android.tv.settings.device.storage.NewStorageActivity;
import com.android.tv.settings.device.storage.UnmountActivity;
import com.android.tv.settings.dialog.Layout;
import com.android.tv.settings.dialog.Layout.Action;
import com.android.tv.settings.dialog.Layout.Header;
import com.android.tv.settings.dialog.Layout.Static;
import com.android.tv.settings.dialog.Layout.Status;
import com.android.tv.settings.dialog.Layout.StringGetter;
import com.android.tv.settings.dialog.SettingsLayoutActivity;

import java.io.File;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * Activity to view storage consumption and factory reset device.
 */
public class StorageResetActivity extends SettingsLayoutActivity
        implements  ForgetPrivateStepFragment.Callback {

    private static final String TAG = "StorageResetActivity";
    private static final long SIZE_CALCULATING = -1;
    private static final int ACTION_RESET_DEVICE = 1;
    private static final int ACTION_CANCEL = 2;
    private static final int ACTION_CLEAR_CACHE = 3;
    private static final int ACTION_EJECT_PRIVATE = 4;
    private static final int ACTION_EJECT_PUBLIC = 5;
    private static final int ACTION_ERASE_PRIVATE = 6;
    private static final int ACTION_ERASE_PUBLIC = 7;
    private static final int ACTION_FORGET = 8;

    /**
     * Support for shutdown-after-reset. If our launch intent has a true value for
     * the boolean extra under the following key, then include it in the intent we
     * use to trigger a factory reset. This will cause us to shut down instead of
     * restart after the reset.
     */
    private static final String SHUTDOWN_INTENT_EXTRA = "shutdown";

    private static final String FORGET_DIALOG_BACKSTACK_TAG = "forgetDialog";

    private class SizeStringGetter extends StringGetter {
        private long mSize = SIZE_CALCULATING;

        @Override
        public String get() {
            return String.format(getString(R.string.storage_size), formatSize(mSize));
        }

        public void setSize(long size) {
            mSize = size;
            refreshView();
        }
    }

    private StorageManager mStorageManager;

    private final Map<String, StorageLayoutGetter> mStorageLayoutGetters = new ArrayMap<>();
    private final Map<String, StorageLayoutGetter> mMissingStorageLayoutGetters = new ArrayMap<>();

    private final StorageEventListener mStorageListener = new StorageEventListener() {
        @Override
        public void onVolumeStateChanged(VolumeInfo vol, int oldState, int newState) {
            switch(vol.getType()) {
                case VolumeInfo.TYPE_PRIVATE:
                case VolumeInfo.TYPE_PUBLIC:
                    mStorageHeadersGetter.refreshView();
                    StorageLayoutGetter getter = mStorageLayoutGetters.get(vol.getDiskId());
                    if (getter != null) {
                        getter.onVolumeUpdated();
                    }
                    break;
                default:
                    break;
            }
        }
    };


    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);

        mStorageManager = getSystemService(StorageManager.class);
        mStorageHeadersGetter.refreshView();

    }

    @Override
    protected void onResume() {
        super.onResume();
        mStorageManager.registerListener(mStorageListener);
        for (StorageLayoutGetter getter : mStorageLayoutGetters.values()) {
            getter.startListening();
        }
    }

    @Override
    protected void onPause() {
        mStorageManager.unregisterListener(mStorageListener);
        for (StorageLayoutGetter getter : mStorageLayoutGetters.values()) {
            getter.stopListening();
        }
        super.onPause();
    }

    @Override
    public Layout createLayout() {
        return new Layout().breadcrumb(getString(R.string.header_category_device))
                .add(new Header.Builder(getResources())
                        .icon(R.drawable.ic_settings_storage)
                        .title(R.string.device_storage_reset)
                        .build()
                        .add(mStorageHeadersGetter)
                        .add(new Static.Builder(getResources())
                                .title(R.string.storage_reset_section)
                                .build())
                        .add(createResetHeaders())
                );
    }

    private final Layout.LayoutGetter mStorageHeadersGetter = new Layout.LayoutGetter() {
        @Override
        public Layout get() {
            final Resources res = getResources();
            final Layout layout = new Layout();
            if (mStorageManager == null) {
                return layout;
            }
            final List<VolumeInfo> volumes = mStorageManager.getVolumes();
            Collections.sort(volumes, VolumeInfo.getDescriptionComparator());

            final List<VolumeInfo> privateVolumes = new ArrayList<>(volumes.size());
            final List<VolumeInfo> publicVolumes = new ArrayList<>(volumes.size());

            // Find mounted volumes
            for (final VolumeInfo vol : volumes) {
                if (vol.getType() == VolumeInfo.TYPE_PRIVATE) {
                    privateVolumes.add(vol);
                } else if (vol.getType() == VolumeInfo.TYPE_PUBLIC) {
                    publicVolumes.add(vol);
                } else {
                    Log.d(TAG, "Skipping volume " + vol.toString());
                }
            }

            // Find missing private filesystems
            final List<VolumeRecord> volumeRecords = mStorageManager.getVolumeRecords();
            final List<String> privateMissingFsUuids = new ArrayList<>(volumeRecords.size());

            for (final VolumeRecord record : volumeRecords) {
                if (record.getType() == VolumeInfo.TYPE_PRIVATE
                        && mStorageManager.findVolumeByUuid(record.getFsUuid()) == null) {
                    privateMissingFsUuids.add(record.getFsUuid());
                }
            }

            // Find unreadable disks
            final List<DiskInfo> disks = mStorageManager.getDisks();
            final List<String> unsupportedDiskIds = new ArrayList<>(disks.size());
            for (final DiskInfo disk : disks) {
                if (disk.volumeCount == 0 && disk.size > 0) {
                    unsupportedDiskIds.add(disk.getId());
                }
            }

            // Add device section if needed
            if (privateVolumes.size() + privateMissingFsUuids.size() > 0) {
                layout.add(new Static.Builder(res)
                        .title(R.string.storage_device_storage_section)
                        .build());
            }

            // Add private headers
            for (final VolumeInfo vol : privateVolumes) {
                layout.add(getVolumeHeader(res, vol));
            }
            for (final String fsUuid : privateMissingFsUuids) {
                layout.add(getMissingVolumeHeader(res, fsUuid));
            }

            // Add removable section if needed
            if (publicVolumes.size() + unsupportedDiskIds.size() > 0) {
                layout.add(new Static.Builder(res)
                        .title(R.string.storage_removable_storage_section)
                        .build());
            }

            // Add public headers
            for (final VolumeInfo vol : publicVolumes) {
                layout.add(getVolumeHeader(res, vol));
            }
            for (final String diskId : unsupportedDiskIds) {
                layout.add(getUnsupportedDiskAction(res, diskId));
            }
            return layout;
        }

        private Header getVolumeHeader(Resources res, VolumeInfo vol) {
            final String diskId = vol.getDiskId();
            final String fsUuid = vol.getFsUuid();
            StorageLayoutGetter storageGetter = mStorageLayoutGetters.get(diskId);
            if (storageGetter == null) {
                storageGetter = new StorageLayoutGetter(diskId, fsUuid);
                mStorageLayoutGetters.put(diskId, storageGetter);
                if (isResumed()) {
                    storageGetter.startListening();
                }
            }
            return new Header.Builder(res)
                    .title(mStorageManager.getBestVolumeDescription(vol))
                    .description(getSize(vol))
                    .build().add(storageGetter);
        }

        private Header getMissingVolumeHeader(Resources res, String fsUuid) {
            StorageLayoutGetter storageGetter = mMissingStorageLayoutGetters.get(fsUuid);
            if (storageGetter == null) {
                storageGetter = new StorageLayoutGetter(null, fsUuid);
                mMissingStorageLayoutGetters.put(fsUuid, storageGetter);
            }
            final VolumeRecord volumeRecord = mStorageManager.findRecordByUuid(fsUuid);
            return new Header.Builder(res)
                    .title(volumeRecord.getNickname())
                    .description(R.string.storage_not_connected)
                    .build().add(storageGetter);
        }

        private Action getUnsupportedDiskAction(Resources res, String diskId) {
            final DiskInfo info = mStorageManager.findDiskById(diskId);
            return new Action.Builder(res,
                    NewStorageActivity.getNewStorageLaunchIntent(StorageResetActivity.this, null,
                            diskId))
                    .title(info.getDescription())
                    .build();
        }

        private String getSize(VolumeInfo vol) {
            final File path = vol.getPath();
            if (vol.isMountedReadable() && path != null) {
                return String.format(getString(R.string.storage_size),
                        formatSize(path.getTotalSpace()));
            } else {
                return null;
            }
        }
    };

    private class StorageLayoutGetter extends Layout.LayoutGetter {

        private final String mDiskId;
        private final String mFsUuid;

        private StorageMeasurement mMeasure;
        private final SizeStringGetter mAppsSize = new SizeStringGetter();
        private final SizeStringGetter mDcimSize = new SizeStringGetter();
        private final SizeStringGetter mMusicSize = new SizeStringGetter();
        private final SizeStringGetter mDownloadsSize = new SizeStringGetter();
        private final SizeStringGetter mCacheSize = new SizeStringGetter();
        private final SizeStringGetter mMiscSize = new SizeStringGetter();
        private final SizeStringGetter mAvailSize = new SizeStringGetter();

        private final MeasurementReceiver mReceiver = new MeasurementReceiver() {

            private MeasurementDetails mLastMeasurementDetails = null;

            @Override
            public void onDetailsChanged(MeasurementDetails details) {
                mLastMeasurementDetails = details;
                updateDetails(mLastMeasurementDetails);
            }
        };

        public StorageLayoutGetter(String diskId, String fsUuid) {
            mDiskId = diskId;
            mFsUuid = fsUuid;
        }

        @Override
        public Layout get() {
            final Resources res = getResources();
            final Layout layout = new Layout();

            VolumeInfo volume = getVolumeInfo();

            if (volume == null) {
                final VolumeRecord volumeRecord = !TextUtils.isEmpty(mFsUuid) ?
                        mStorageManager.findRecordByUuid(mFsUuid) : null;
                if (volumeRecord == null || volumeRecord.getType() == VolumeInfo.TYPE_PUBLIC) {
                    layout
                            .add(new Status.Builder(res)
                                    .title(R.string.storage_not_connected)
                                    .build());
                } else {
                    addPrivateMissingHeaders(layout, mFsUuid);
                }
            } else if (volume.getType() == VolumeInfo.TYPE_PRIVATE) {
                if (volume.getState() == VolumeInfo.STATE_UNMOUNTED) {
                    addPrivateMissingHeaders(layout, mFsUuid);
                } else {
                    addPrivateStorageHeaders(layout, volume);
                }
            } else {
                if (volume.getState() == VolumeInfo.STATE_UNMOUNTED) {
                    addPublicUnmountedHeaders(layout, volume);
                } else {
                    final Bundle data = new Bundle(2);
                    data.putString(VolumeInfo.EXTRA_VOLUME_ID, volume.getId());
                    data.putString(DiskInfo.EXTRA_DISK_ID, mDiskId);
                    layout
                            .add(new Action.Builder(res, ACTION_EJECT_PUBLIC)
                                    .title(R.string.storage_eject)
                                    .data(data)
                                    .build())
                            .add(new Action.Builder(res, ACTION_ERASE_PUBLIC)
                                    .title(R.string.storage_format_for_private)
                                    .data(data)
                                    .build())
                            .add(new Status.Builder(res)
                                    .title(R.string.storage_media_misc_usage)
                                    .icon(R.drawable.storage_indicator_misc)
                                    .description(mMiscSize)
                                    .build())
                            .add(new Status.Builder(res)
                                    .title(R.string.storage_available)
                                    .icon(R.drawable.storage_indicator_available)
                                    .description(mAvailSize)
                                    .build());
                }
            }
            return layout;
        }

        private @Nullable VolumeInfo getVolumeInfo() {
            if (TextUtils.isEmpty(mFsUuid) && TextUtils.isEmpty(mDiskId)) {
                // Means private internal
                return mStorageManager.findVolumeById(VolumeInfo.ID_PRIVATE_INTERNAL);
            }

            if (!TextUtils.isEmpty(mFsUuid)) {
                final VolumeInfo volume = mStorageManager.findVolumeByUuid(mFsUuid);
                if (volume != null) {
                    return volume;
                }
            }

            if (!TextUtils.isEmpty(mDiskId)) {
                final List<VolumeInfo> volumes = mStorageManager.getVolumes();
                for (final VolumeInfo v : volumes) {
                    if (TextUtils.equals(v.getDiskId(), mDiskId)) {
                        return v;
                    }
                }
            }

            return null;
        }

        private void addPublicUnmountedHeaders(Layout layout, VolumeInfo volume) {
            final Resources res = getResources();
            final String volumeDescription = mStorageManager.getBestVolumeDescription(volume);

            layout
                    .add(new Status.Builder(res)
                            .title(getString(R.string.storage_unmount_success,
                                    volumeDescription))
                            .enabled(false)
                            .build());
        }

        private void addPrivateMissingHeaders(Layout layout, String fsUuid) {
            final Resources res = getResources();
            final Bundle data = new Bundle(1);
            data.putString(VolumeRecord.EXTRA_FS_UUID, fsUuid);
            final VolumeRecord volumeRecord = mStorageManager.findRecordByUuid(fsUuid);

            layout
                    .add(new Layout.WallOfText.Builder(res)
                            .title(getString(R.string.storage_forget_wall_of_text,
                                    volumeRecord.getNickname()))
                            .build())
                    .add(new Action.Builder(res, ACTION_FORGET)
                            .title(getString(R.string.storage_forget))
                            .data(data)
                            .build());
        }

        private void addPrivateStorageHeaders(Layout layout, VolumeInfo volume) {
            final Resources res = getResources();
            final Bundle data = new Bundle(2);
            final String volumeId = volume.getId();
            data.putString(VolumeInfo.EXTRA_VOLUME_ID, volumeId);
            data.putString(DiskInfo.EXTRA_DISK_ID, mDiskId);

            final String volumeUuid = volume.getFsUuid();
            final String volumeDescription = mStorageManager.getBestVolumeDescription(volume);

            boolean showMigrate = false;
            final VolumeInfo currentExternal = getPackageManager().getPrimaryStorageCurrentVolume();
            if (!TextUtils.equals(currentExternal.getId(), volumeId)) {
                final List<VolumeInfo> candidates =
                        getPackageManager().getPrimaryStorageCandidateVolumes();
                for (final VolumeInfo candidate : candidates) {
                    if (TextUtils.equals(candidate.getId(), volumeId)) {
                        showMigrate = true;
                        break;
                    }
                }
            }

            if (showMigrate) {
                layout
                        .add(new Action.Builder(res, MigrateStorageActivity.getLaunchIntent(
                                        StorageResetActivity.this, volumeId, true))
                                .title(R.string.storage_migrate)
                                .data(data)
                                .build());
            }

            if (!VolumeInfo.ID_PRIVATE_INTERNAL.equals(volumeId)) {
                layout
                        .add(new Action.Builder(res, ACTION_EJECT_PRIVATE)
                                .title(R.string.storage_eject)
                                .data(data)
                                .build())
                        .add(new Action.Builder(res, ACTION_ERASE_PRIVATE)
                                .title(R.string.storage_format)
                                .data(data)
                                .build());
            }
            layout
                    .add(new Action.Builder(res,
                            new Intent(StorageResetActivity.this, AppsActivity.class)
                                    .putExtra(AppsActivity.EXTRA_VOLUME_UUID, volumeUuid)
                                    .putExtra(AppsActivity.EXTRA_VOLUME_NAME,
                                            volumeDescription))
                            .title(R.string.storage_apps_usage)
                            .icon(R.drawable.storage_indicator_apps)
                            .description(mAppsSize)
                            .build())
                    .add(new Status.Builder(res)
                            .title(R.string.storage_dcim_usage)
                            .icon(R.drawable.storage_indicator_dcim)
                            .description(mDcimSize)
                            .build())
                    .add(new Status.Builder(res)
                            .title(R.string.storage_music_usage)
                            .icon(R.drawable.storage_indicator_music)
                            .description(mMusicSize)
                            .build())
                    .add(new Status.Builder(res)
                            .title(R.string.storage_downloads_usage)
                            .icon(R.drawable.storage_indicator_downloads)
                            .description(mDownloadsSize)
                            .build())
                    .add(new Action.Builder(res, ACTION_CLEAR_CACHE)
                            .title(R.string.storage_media_cache_usage)
                            .icon(R.drawable.storage_indicator_cache)
                            .description(mCacheSize)
                            .build())
                    .add(new Status.Builder(res)
                            .title(R.string.storage_media_misc_usage)
                            .icon(R.drawable.storage_indicator_misc)
                            .description(mMiscSize)
                            .build())
                    .add(new Status.Builder(res)
                            .title(R.string.storage_available)
                            .icon(R.drawable.storage_indicator_available)
                            .description(mAvailSize)
                            .build());
        }

        public void onVolumeUpdated() {
            stopListening();
            startListening();
            refreshView();
        }

        public void startListening() {
            VolumeInfo volume = getVolumeInfo();

            if (volume != null && volume.isMountedReadable()) {
                final VolumeInfo sharedVolume = mStorageManager.findEmulatedForPrivate(volume);
                mMeasure = new StorageMeasurement(StorageResetActivity.this, volume,
                        sharedVolume);
                mMeasure.setReceiver(mReceiver);
                mMeasure.forceMeasure();
            }
        }

        public void stopListening() {
            if (mMeasure != null) {
                mMeasure.onDestroy();
            }
        }

        private void updateDetails(MeasurementDetails details) {
            final int currentUser = ActivityManager.getCurrentUser();
            final long dcimSize = totalValues(details.mediaSize.get(currentUser),
                    Environment.DIRECTORY_DCIM,
                    Environment.DIRECTORY_MOVIES, Environment.DIRECTORY_PICTURES);

            final long musicSize = totalValues(details.mediaSize.get(currentUser),
                    Environment.DIRECTORY_MUSIC,
                    Environment.DIRECTORY_ALARMS, Environment.DIRECTORY_NOTIFICATIONS,
                    Environment.DIRECTORY_RINGTONES, Environment.DIRECTORY_PODCASTS);

            final long downloadsSize = totalValues(details.mediaSize.get(currentUser),
                    Environment.DIRECTORY_DOWNLOADS);

            mAvailSize.setSize(details.availSize);
            mAppsSize.setSize(details.appsSize.get(currentUser));
            mDcimSize.setSize(dcimSize);
            mMusicSize.setSize(musicSize);
            mDownloadsSize.setSize(downloadsSize);
            mCacheSize.setSize(details.cacheSize);
            mMiscSize.setSize(details.miscSize.get(currentUser));
        }
    }

    private Header createResetHeaders() {
        final Resources res = getResources();
        return new Header.Builder(res)
                .title(R.string.device_reset)
                .build()
                .add(new Header.Builder(res)
                        .title(R.string.device_reset)
                        .build()
                        .add(new Action.Builder(res, ACTION_RESET_DEVICE)
                                .title(R.string.confirm_factory_reset_device)
                                .build()
                        )
                        .add(new Action.Builder(res, Action.ACTION_BACK)
                                .title(R.string.title_cancel)
                                .defaultSelection()
                                .build())
                )
                .add(new Action.Builder(res, Action.ACTION_BACK)
                        .title(R.string.title_cancel)
                        .defaultSelection()
                        .build());
    }

    @Override
    public void onActionClicked(Action action) {
        switch (action.getId()) {
            case ACTION_RESET_DEVICE:
                if (!ActivityManager.isUserAMonkey()) {
                    Intent resetIntent = new Intent("android.intent.action.MASTER_CLEAR");
                    if (getIntent().getBooleanExtra(SHUTDOWN_INTENT_EXTRA, false)) {
                        resetIntent.putExtra(SHUTDOWN_INTENT_EXTRA, true);
                    }
                    sendBroadcast(resetIntent);
                }
                break;
            case ACTION_CANCEL:
                goBackToTitle(getString(R.string.device_storage_reset));
                break;
            case ACTION_CLEAR_CACHE:
                final DialogFragment fragment = ConfirmClearCacheFragment.newInstance();
                fragment.show(getFragmentManager(), null);
                break;
            case ACTION_EJECT_PUBLIC:
                onBackPressed();
                onRequestUnmount(action.getData().getString(VolumeInfo.EXTRA_VOLUME_ID));
                break;
            case ACTION_EJECT_PRIVATE:
                onBackPressed();
                onRequestUnmount(action.getData().getString(VolumeInfo.EXTRA_VOLUME_ID));
                break;
            case ACTION_ERASE_PUBLIC: {
                // When we erase a public volume, we're intending to use it as a private volume,
                // so launch the format-as-private wizard.
                startActivity(FormatActivity.getFormatAsPrivateIntent(this,
                        action.getData().getString(DiskInfo.EXTRA_DISK_ID)));
                break;
            }
            case ACTION_ERASE_PRIVATE: {
                // When we erase a private volume, we're intending to use it as a public volume,
                // so launch the format-as-public wizard.
                startActivity(FormatActivity.getFormatAsPublicIntent(this,
                        action.getData().getString(DiskInfo.EXTRA_DISK_ID)));
            }
                break;
            case ACTION_FORGET:
                final Fragment f =
                        ForgetPrivateStepFragment.newInstance(
                                action.getData().getString(VolumeRecord.EXTRA_FS_UUID));
                getFragmentManager().beginTransaction()
                        .replace(android.R.id.content, f)
                        .addToBackStack(FORGET_DIALOG_BACKSTACK_TAG)
                        .commit();
                break;
            default:
                final Intent intent = action.getIntent();
                if (intent != null) {
                    startActivity(intent);
                }
        }
    }

    private static long totalValues(HashMap<String, Long> map, String... keys) {
        long total = 0;
        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 current user " +
                    ActivityManager.getCurrentUser());
        }
        return total;
    }

    private String formatSize(long size) {
        return (size == SIZE_CALCULATING) ? getString(R.string.storage_calculating_size)
                : Formatter.formatShortFileSize(this, size);
    }

    public void onRequestUnmount(String volumeId) {
        final VolumeInfo volumeInfo = mStorageManager.findVolumeById(volumeId);
        if (volumeInfo == null) {
            Toast.makeText(this, getString(R.string.storage_unmount_failure_cant_find),
                    Toast.LENGTH_SHORT).show();
            return;
        }
        final String description = mStorageManager.getBestVolumeDescription(volumeInfo);
        final Intent intent = UnmountActivity.getIntent(this, volumeId, description);
        startActivity(intent);
    }

    /**
     * Dialog to request user confirmation before clearing all cache data.
     */
    public static class ConfirmClearCacheFragment extends DialogFragment {
        public static ConfirmClearCacheFragment newInstance() {
            return new ConfirmClearCacheFragment();
        }

        @Override
        public Dialog onCreateDialog(Bundle savedInstanceState) {
            final Context context = getActivity();

            final AlertDialog.Builder builder = new AlertDialog.Builder(context);
            builder.setTitle(R.string.device_storage_clear_cache_title);
            builder.setMessage(getString(R.string.device_storage_clear_cache_message));

            builder.setPositiveButton(android.R.string.ok, new DialogInterface.OnClickListener() {
                @Override
                public void onClick(DialogInterface dialog, int which) {
                    final PackageManager pm = context.getPackageManager();
                    final List<PackageInfo> infos = pm.getInstalledPackages(0);
                    for (PackageInfo info : infos) {
                        pm.deleteApplicationCacheFiles(info.packageName, null);
                    }
                }
            });
            builder.setNegativeButton(android.R.string.cancel, null);

            return builder.create();
        }
    }

    public static class MountTask extends AsyncTask<Void, Void, Exception> {
        private final Context mContext;
        private final StorageManager mStorageManager;
        private final String mVolumeId;
        private final String mDescription;

        public MountTask(Context context, VolumeInfo volume) {
            mContext = context.getApplicationContext();
            mStorageManager = mContext.getSystemService(StorageManager.class);
            mVolumeId = volume.getId();
            mDescription = mStorageManager.getBestVolumeDescription(volume);
        }

        @Override
        protected Exception doInBackground(Void... params) {
            try {
                mStorageManager.mount(mVolumeId);
                return null;
            } catch (Exception e) {
                return e;
            }
        }

        @Override
        protected void onPostExecute(Exception e) {
            if (e == null) {
                Toast.makeText(mContext, mContext.getString(R.string.storage_mount_success,
                        mDescription), Toast.LENGTH_SHORT).show();
            } else {
                Log.e(TAG, "Failed to mount " + mVolumeId, e);
                Toast.makeText(mContext, mContext.getString(R.string.storage_mount_failure,
                        mDescription), Toast.LENGTH_SHORT).show();
            }
        }
    }

    @Override
    public void onRequestForget(String fsUuid) {
        mStorageManager.forgetVolume(fsUuid);
        getFragmentManager().popBackStack(FORGET_DIALOG_BACKSTACK_TAG,
                FragmentManager.POP_BACK_STACK_INCLUSIVE);
    }

    @Override
    public void onCancelForgetDialog() {
        getFragmentManager().popBackStack(FORGET_DIALOG_BACKSTACK_TAG,
                FragmentManager.POP_BACK_STACK_INCLUSIVE);
    }
}