/*
 * Copyright (C) 2013 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.applications;

import android.app.ActivityManager;
import android.content.Context;
import android.content.pm.PackageManager;
import android.os.Bundle;
import android.os.ParcelFileDescriptor;
import android.os.RemoteException;
import android.os.ServiceManager;
import android.os.SystemClock;
import android.os.UserManager;
import android.preference.Preference;
import android.preference.PreferenceFragment;
import android.preference.PreferenceGroup;
import android.preference.PreferenceScreen;
import android.text.format.Formatter;
import android.util.Log;
import android.util.SparseArray;
import android.util.TimeUtils;
import android.view.Menu;
import android.view.MenuInflater;
import android.view.MenuItem;
import android.view.SubMenu;
import com.android.internal.app.IProcessStats;
import com.android.internal.app.ProcessMap;
import com.android.internal.app.ProcessStats;
import com.android.internal.util.MemInfoReader;
import com.android.settings.R;
import com.android.settings.SettingsActivity;
import com.android.settings.Utils;

import java.io.IOException;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;

public class ProcessStatsUi extends PreferenceFragment
        implements LinearColorBar.OnRegionTappedListener {
    static final String TAG = "ProcessStatsUi";
    static final boolean DEBUG = false;

    private static final String KEY_APP_LIST = "app_list";
    private static final String KEY_MEM_STATUS = "mem_status";

    private static final int NUM_DURATIONS = 4;

    private static final int MENU_STATS_REFRESH = Menu.FIRST;
    private static final int MENU_DURATION = Menu.FIRST + 1;
    private static final int MENU_SHOW_SYSTEM = MENU_DURATION + NUM_DURATIONS;
    private static final int MENU_USE_USS = MENU_SHOW_SYSTEM + 1;
    private static final int MENU_TYPE_BACKGROUND = MENU_USE_USS + 1;
    private static final int MENU_TYPE_FOREGROUND = MENU_TYPE_BACKGROUND + 1;
    private static final int MENU_TYPE_CACHED = MENU_TYPE_FOREGROUND + 1;
    private static final int MENU_HELP = MENU_TYPE_CACHED + 1;

    static final int MAX_ITEMS_TO_LIST = 60;

    final static Comparator<ProcStatsEntry> sEntryCompare = new Comparator<ProcStatsEntry>() {
        @Override
        public int compare(ProcStatsEntry lhs, ProcStatsEntry rhs) {
            if (lhs.mWeight < rhs.mWeight) {
                return 1;
            } else if (lhs.mWeight > rhs.mWeight) {
                return -1;
            } else if (lhs.mDuration < rhs.mDuration) {
                return 1;
            } else if (lhs.mDuration > rhs.mDuration) {
                return -1;
            }
            return 0;
        }
    };

    private static ProcessStats sStatsXfer;

    IProcessStats mProcessStats;
    UserManager mUm;
    ProcessStats mStats;
    int mMemState;

    private long mDuration;
    private long mLastDuration;
    private boolean mShowSystem;
    private boolean mUseUss;
    private int mStatsType;
    private int mMemRegion;

    private MenuItem[] mDurationMenus = new MenuItem[NUM_DURATIONS];
    private MenuItem mShowSystemMenu;
    private MenuItem mUseUssMenu;
    private MenuItem mTypeBackgroundMenu;
    private MenuItem mTypeForegroundMenu;
    private MenuItem mTypeCachedMenu;

    private PreferenceGroup mAppListGroup;
    private Preference mMemStatusPref;

    long mMaxWeight;
    long mTotalTime;

    long[] mMemTimes = new long[ProcessStats.ADJ_MEM_FACTOR_COUNT];
    double[] mMemStateWeights = new double[ProcessStats.STATE_COUNT];
    double mMemCachedWeight;
    double mMemFreeWeight;
    double mMemZRamWeight;
    double mMemKernelWeight;
    double mMemNativeWeight;
    double mMemTotalWeight;

    // The actual duration value to use for each duration option.  Note these
    // are lower than the actual duration, since our durations are computed in
    // batches of 3 hours so we want to allow the time we use to be slightly
    // smaller than the actual time selected instead of bumping up to 3 hours
    // beyond it.
    private static final long DURATION_QUANTUM = ProcessStats.COMMIT_PERIOD;
    private static long[] sDurations = new long[] {
        3*60*60*1000 - DURATION_QUANTUM/2, 6*60*60*1000 - DURATION_QUANTUM/2,
        12*60*60*1000 - DURATION_QUANTUM/2, 24*60*60*1000 - DURATION_QUANTUM/2
    };
    private static int[] sDurationLabels = new int[] {
            R.string.menu_duration_3h, R.string.menu_duration_6h,
            R.string.menu_duration_12h, R.string.menu_duration_1d
    };

    @Override
    public void onCreate(Bundle icicle) {
        super.onCreate(icicle);

        if (icicle != null) {
            mStats = sStatsXfer;
        }

        addPreferencesFromResource(R.xml.process_stats_summary);
        mProcessStats = IProcessStats.Stub.asInterface(
                ServiceManager.getService(ProcessStats.SERVICE_NAME));
        mUm = (UserManager)getActivity().getSystemService(Context.USER_SERVICE);
        mAppListGroup = (PreferenceGroup) findPreference(KEY_APP_LIST);
        mMemStatusPref = mAppListGroup.findPreference(KEY_MEM_STATUS);
        mDuration = icicle != null ? icicle.getLong("duration", sDurations[0]) : sDurations[0];
        mShowSystem = icicle != null ? icicle.getBoolean("show_system") : false;
        mUseUss = icicle != null ? icicle.getBoolean("use_uss") : false;
        mStatsType = icicle != null ? icicle.getInt("stats_type", MENU_TYPE_BACKGROUND)
                : MENU_TYPE_BACKGROUND;
        mMemRegion = icicle != null ? icicle.getInt("mem_region", LinearColorBar.REGION_GREEN)
                : LinearColorBar.REGION_GREEN;
        setHasOptionsMenu(true);
    }

    @Override
    public void onResume() {
        super.onResume();
        refreshStats();
    }

    @Override
    public void onPause() {
        super.onPause();
    }

    @Override
    public void onSaveInstanceState(Bundle outState) {
        super.onSaveInstanceState(outState);
        outState.putLong("duration", mDuration);
        outState.putBoolean("show_system", mShowSystem);
        outState.putBoolean("use_uss", mUseUss);
        outState.putInt("stats_type", mStatsType);
        outState.putInt("mem_region", mMemRegion);
    }

    @Override
    public void onDestroy() {
        super.onDestroy();
        if (getActivity().isChangingConfigurations()) {
            sStatsXfer = mStats;
        }
    }

    @Override
    public boolean onPreferenceTreeClick(PreferenceScreen preferenceScreen, Preference preference) {
        if (preference instanceof LinearColorPreference) {
            Bundle args = new Bundle();
            args.putLongArray(ProcessStatsMemDetail.EXTRA_MEM_TIMES, mMemTimes);
            args.putDoubleArray(ProcessStatsMemDetail.EXTRA_MEM_STATE_WEIGHTS, mMemStateWeights);
            args.putDouble(ProcessStatsMemDetail.EXTRA_MEM_CACHED_WEIGHT, mMemCachedWeight);
            args.putDouble(ProcessStatsMemDetail.EXTRA_MEM_FREE_WEIGHT, mMemFreeWeight);
            args.putDouble(ProcessStatsMemDetail.EXTRA_MEM_ZRAM_WEIGHT, mMemZRamWeight);
            args.putDouble(ProcessStatsMemDetail.EXTRA_MEM_KERNEL_WEIGHT, mMemKernelWeight);
            args.putDouble(ProcessStatsMemDetail.EXTRA_MEM_NATIVE_WEIGHT, mMemNativeWeight);
            args.putDouble(ProcessStatsMemDetail.EXTRA_MEM_TOTAL_WEIGHT, mMemTotalWeight);
            args.putBoolean(ProcessStatsMemDetail.EXTRA_USE_USS, mUseUss);
            args.putLong(ProcessStatsMemDetail.EXTRA_TOTAL_TIME, mTotalTime);
            ((SettingsActivity) getActivity()).startPreferencePanel(
                    ProcessStatsMemDetail.class.getName(), args, R.string.mem_details_title,
                    null, null, 0);
            return true;
        }

        if (!(preference instanceof ProcessStatsPreference)) {
            return false;
        }

        ProcessStatsPreference pgp = (ProcessStatsPreference) preference;
        Bundle args = new Bundle();
        args.putParcelable(ProcessStatsDetail.EXTRA_ENTRY, pgp.getEntry());
        args.putBoolean(ProcessStatsDetail.EXTRA_USE_USS, mUseUss);
        args.putLong(ProcessStatsDetail.EXTRA_MAX_WEIGHT, mMaxWeight);
        args.putLong(ProcessStatsDetail.EXTRA_TOTAL_TIME, mTotalTime);
        ((SettingsActivity) getActivity()).startPreferencePanel(
                ProcessStatsDetail.class.getName(), args, R.string.details_title, null, null, 0);

        return super.onPreferenceTreeClick(preferenceScreen, preference);
    }

    @Override
    public void onCreateOptionsMenu(Menu menu, MenuInflater inflater) {
        MenuItem refresh = menu.add(0, MENU_STATS_REFRESH, 0, R.string.menu_stats_refresh)
                .setIcon(R.drawable.ic_menu_refresh_holo_dark)
                .setAlphabeticShortcut('r');
        refresh.setShowAsAction(MenuItem.SHOW_AS_ACTION_IF_ROOM |
                MenuItem.SHOW_AS_ACTION_WITH_TEXT);
        SubMenu subMenu = menu.addSubMenu(R.string.menu_proc_stats_duration);
        for (int i=0; i<NUM_DURATIONS; i++) {
            mDurationMenus[i] = subMenu.add(0, MENU_DURATION+i, 0, sDurationLabels[i])
                            .setCheckable(true);
        }
        mShowSystemMenu = menu.add(0, MENU_SHOW_SYSTEM, 0, R.string.menu_show_system)
                .setAlphabeticShortcut('s')
                .setCheckable(true);
        mUseUssMenu = menu.add(0, MENU_USE_USS, 0, R.string.menu_use_uss)
                .setAlphabeticShortcut('u')
                .setCheckable(true);
        subMenu = menu.addSubMenu(R.string.menu_proc_stats_type);
        mTypeBackgroundMenu = subMenu.add(0, MENU_TYPE_BACKGROUND, 0,
                R.string.menu_proc_stats_type_background)
                .setAlphabeticShortcut('b')
                .setCheckable(true);
        mTypeForegroundMenu = subMenu.add(0, MENU_TYPE_FOREGROUND, 0,
                R.string.menu_proc_stats_type_foreground)
                .setAlphabeticShortcut('f')
                .setCheckable(true);
        mTypeCachedMenu = subMenu.add(0, MENU_TYPE_CACHED, 0,
                R.string.menu_proc_stats_type_cached)
                .setCheckable(true);

        updateMenus();

        /*
        String helpUrl;
        if (!TextUtils.isEmpty(helpUrl = getResources().getString(R.string.help_url_battery))) {
            final MenuItem help = menu.add(0, MENU_HELP, 0, R.string.help_label);
            HelpUtils.prepareHelpMenuItem(getActivity(), help, helpUrl);
        }
        */
    }

    void updateMenus() {
        int closestIndex = 0;
        long closestDelta = Math.abs(sDurations[0]-mDuration);
        for (int i=1; i<NUM_DURATIONS; i++) {
            long delta = Math.abs(sDurations[i]-mDuration);
            if (delta < closestDelta) {
                closestDelta = delta;
                closestIndex = i;
            }
        }
        for (int i=0; i<NUM_DURATIONS; i++) {
            if (mDurationMenus[i] != null) {
                mDurationMenus[i].setChecked(i == closestIndex);
            }
        }
        mDuration = sDurations[closestIndex];
        if (mShowSystemMenu != null) {
            mShowSystemMenu.setChecked(mShowSystem);
            mShowSystemMenu.setEnabled(mStatsType == MENU_TYPE_BACKGROUND);
        }
        if (mUseUssMenu != null) {
            mUseUssMenu.setChecked(mUseUss);
        }
        if (mTypeBackgroundMenu != null) {
            mTypeBackgroundMenu.setChecked(mStatsType == MENU_TYPE_BACKGROUND);
        }
        if (mTypeForegroundMenu != null) {
            mTypeForegroundMenu.setChecked(mStatsType == MENU_TYPE_FOREGROUND);
        }
        if (mTypeCachedMenu != null) {
            mTypeCachedMenu.setChecked(mStatsType == MENU_TYPE_CACHED);
        }
    }

    @Override
    public boolean onOptionsItemSelected(MenuItem item) {
        final int id = item.getItemId();
        switch (id) {
            case MENU_STATS_REFRESH:
                mStats = null;
                refreshStats();
                return true;
            case MENU_SHOW_SYSTEM:
                mShowSystem = !mShowSystem;
                refreshStats();
                return true;
            case MENU_USE_USS:
                mUseUss = !mUseUss;
                refreshStats();
                return true;
            case MENU_TYPE_BACKGROUND:
            case MENU_TYPE_FOREGROUND:
            case MENU_TYPE_CACHED:
                mStatsType = item.getItemId();
                refreshStats();
                return true;
            default:
                if (id >= MENU_DURATION && id < (MENU_DURATION+NUM_DURATIONS)) {
                    mDuration = sDurations[id-MENU_DURATION];
                    refreshStats();
                }
                return false;
        }
    }

    @Override
    public void onRegionTapped(int region) {
        if (mMemRegion != region) {
            mMemRegion = region;
            refreshStats();
        }
    }

    private void addNotAvailableMessage() {
        Preference notAvailable = new Preference(getActivity());
        notAvailable.setTitle(R.string.power_usage_not_available);
        mAppListGroup.addPreference(notAvailable);
    }

    public static final int[] BACKGROUND_AND_SYSTEM_PROC_STATES = new int[] {
            ProcessStats.STATE_PERSISTENT, ProcessStats.STATE_IMPORTANT_FOREGROUND,
            ProcessStats.STATE_IMPORTANT_BACKGROUND, ProcessStats.STATE_BACKUP,
            ProcessStats.STATE_HEAVY_WEIGHT, ProcessStats.STATE_SERVICE,
            ProcessStats.STATE_SERVICE_RESTARTING, ProcessStats.STATE_RECEIVER
    };

    public static final int[] FOREGROUND_PROC_STATES = new int[] {
            ProcessStats.STATE_TOP
    };

    public static final int[] CACHED_PROC_STATES = new int[] {
            ProcessStats.STATE_CACHED_ACTIVITY, ProcessStats.STATE_CACHED_ACTIVITY_CLIENT,
            ProcessStats.STATE_CACHED_EMPTY
    };

    public static final int[] RED_MEM_STATES = new int[] {
            ProcessStats.ADJ_MEM_FACTOR_CRITICAL
    };

    public static final int[] YELLOW_MEM_STATES = new int[] {
            ProcessStats.ADJ_MEM_FACTOR_CRITICAL, ProcessStats.ADJ_MEM_FACTOR_LOW,
            ProcessStats.ADJ_MEM_FACTOR_MODERATE
    };

    private String makeDuration(long time) {
        StringBuilder sb = new StringBuilder(32);
        TimeUtils.formatDuration(time, sb);
        return sb.toString();
    }

    private void refreshStats() {
        updateMenus();

        if (mStats == null || mLastDuration != mDuration) {
            load();
        }

        int[] stats;
        int statsLabel;
        if (mStatsType == MENU_TYPE_FOREGROUND) {
            stats = FOREGROUND_PROC_STATES;
            statsLabel = R.string.process_stats_type_foreground;
        } else if (mStatsType == MENU_TYPE_CACHED) {
            stats = CACHED_PROC_STATES;
            statsLabel = R.string.process_stats_type_cached;
        } else {
            stats = mShowSystem ? BACKGROUND_AND_SYSTEM_PROC_STATES
                    : ProcessStats.BACKGROUND_PROC_STATES;
            statsLabel = R.string.process_stats_type_background;
        }

        mAppListGroup.removeAll();
        mAppListGroup.setOrderingAsAdded(false);

        final long elapsedTime = mStats.mTimePeriodEndRealtime-mStats.mTimePeriodStartRealtime;

        mMemStatusPref.setOrder(-2);
        mAppListGroup.addPreference(mMemStatusPref);
        String durationString = Utils.formatElapsedTime(getActivity(), elapsedTime, false);
        CharSequence memString;
        CharSequence[] memStatesStr = getResources().getTextArray(R.array.ram_states);
        if (mMemState >= 0 && mMemState < memStatesStr.length) {
            memString = memStatesStr[mMemState];
        } else {
            memString = "?";
        }
        mMemStatusPref.setTitle(getActivity().getString(R.string.process_stats_total_duration,
                getActivity().getString(statsLabel), durationString));
        mMemStatusPref.setSummary(getActivity().getString(R.string.process_stats_memory_status,
                        memString));
        /*
        mMemStatusPref.setTitle(DateFormat.format(DateFormat.getBestDateTimePattern(
                getActivity().getResources().getConfiguration().locale,
                "MMMM dd, yyyy h:mm a"), mStats.mTimePeriodStartClock));
        */
        /*
        BatteryHistoryPreference hist = new BatteryHistoryPreference(getActivity(), mStats);
        hist.setOrder(-1);
        mAppListGroup.addPreference(hist);
        */

        long now = SystemClock.uptimeMillis();

        final PackageManager pm = getActivity().getPackageManager();

        mTotalTime = ProcessStats.dumpSingleTime(null, null, mStats.mMemFactorDurations,
                mStats.mMemFactor, mStats.mStartTime, now);
        if (DEBUG) Log.d(TAG, "Total time of stats: " + makeDuration(mTotalTime));

        for (int i=0; i<mMemTimes.length; i++) {
            mMemTimes[i] = 0;
        }
        for (int iscreen=0; iscreen<ProcessStats.ADJ_COUNT; iscreen+=ProcessStats.ADJ_SCREEN_MOD) {
            for (int imem=0; imem<ProcessStats.ADJ_MEM_FACTOR_COUNT; imem++) {
                int state = imem+iscreen;
                mMemTimes[imem] += mStats.mMemFactorDurations[state];
            }
        }

        long memTotalTime;
        int[] memStates;

        LinearColorPreference colors = new LinearColorPreference(getActivity());
        colors.setOrder(-1);
        switch (mMemRegion) {
            case LinearColorBar.REGION_RED:
                memTotalTime = mMemTimes[ProcessStats.ADJ_MEM_FACTOR_CRITICAL];
                memStates = RED_MEM_STATES;
                break;
            case LinearColorBar.REGION_YELLOW:
                memTotalTime = mMemTimes[ProcessStats.ADJ_MEM_FACTOR_CRITICAL]
                        + mMemTimes[ProcessStats.ADJ_MEM_FACTOR_LOW]
                        + mMemTimes[ProcessStats.ADJ_MEM_FACTOR_MODERATE];
                memStates = YELLOW_MEM_STATES;
                break;
            default:
                memTotalTime = mTotalTime;
                memStates = ProcessStats.ALL_MEM_ADJ;
                break;
        }
        colors.setColoredRegions(LinearColorBar.REGION_RED);

        // Compute memory badness for chart color.
        int[] badColors = com.android.settings.Utils.BADNESS_COLORS;
        long timeGood = mMemTimes[ProcessStats.ADJ_MEM_FACTOR_NORMAL];
        timeGood += (mMemTimes[ProcessStats.ADJ_MEM_FACTOR_MODERATE]*2)/3;
        timeGood += mMemTimes[ProcessStats.ADJ_MEM_FACTOR_LOW]/3;
        float memBadness = ((float)timeGood)/mTotalTime;
        int badnessColor = badColors[1 + Math.round(memBadness*(badColors.length-2))];
        colors.setColors(badnessColor, badnessColor, badnessColor);

        // We are now going to scale the mMemTimes to match the total elapsed time.
        // These are in uptime, so they will often be smaller than the elapsed time,
        // but if the user taps on the bar we want to show the times to them.  It is confusing
        // to see them be smaller than what we told them the measured duration is, so just
        // scaling them up with make things look reasonable with them none the wiser.
        for (int i=0; i<ProcessStats.ADJ_MEM_FACTOR_COUNT; i++) {
            mMemTimes[i] = (long)((mMemTimes[i]*(double)elapsedTime)/mTotalTime);
        }

        ProcessStats.TotalMemoryUseCollection totalMem = new ProcessStats.TotalMemoryUseCollection(
                ProcessStats.ALL_SCREEN_ADJ, memStates);
        mStats.computeTotalMemoryUse(totalMem, now);
        double freeWeight = totalMem.sysMemFreeWeight + totalMem.sysMemCachedWeight;
        double usedWeight = totalMem.sysMemKernelWeight + totalMem.sysMemNativeWeight
                + totalMem.sysMemZRamWeight;
        double backgroundWeight = 0, persBackgroundWeight = 0;
        mMemCachedWeight = totalMem.sysMemCachedWeight;
        mMemFreeWeight = totalMem.sysMemFreeWeight;
        mMemZRamWeight = totalMem.sysMemZRamWeight;
        mMemKernelWeight = totalMem.sysMemKernelWeight;
        mMemNativeWeight = totalMem.sysMemNativeWeight;
        for (int i=0; i<ProcessStats.STATE_COUNT; i++) {
            if (i == ProcessStats.STATE_SERVICE_RESTARTING) {
                // These don't really run.
                mMemStateWeights[i] = 0;
            } else {
                mMemStateWeights[i] = totalMem.processStateWeight[i];
                if (i >= ProcessStats.STATE_HOME) {
                    freeWeight += totalMem.processStateWeight[i];
                } else {
                    usedWeight += totalMem.processStateWeight[i];
                }
                if (i >= ProcessStats.STATE_IMPORTANT_FOREGROUND) {
                    backgroundWeight += totalMem.processStateWeight[i];
                    persBackgroundWeight += totalMem.processStateWeight[i];
                }
                if (i == ProcessStats.STATE_PERSISTENT) {
                    persBackgroundWeight += totalMem.processStateWeight[i];
                }
            }
        }
        if (DEBUG) {
            Log.i(TAG, "Used RAM: " + Formatter.formatShortFileSize(getActivity(),
                    (long)((usedWeight * 1024) / memTotalTime)));
            Log.i(TAG, "Free RAM: " + Formatter.formatShortFileSize(getActivity(),
                    (long)((freeWeight * 1024) / memTotalTime)));
            Log.i(TAG, "Total RAM: " + Formatter.formatShortFileSize(getActivity(),
                    (long)(((freeWeight+usedWeight) * 1024) / memTotalTime)));
            Log.i(TAG, "Background+Cached RAM: " + Formatter.formatShortFileSize(getActivity(),
                    (long)((backgroundWeight * 1024) / memTotalTime)));
        }
        mMemTotalWeight = freeWeight + usedWeight;

        // For computing the ratio to show, we want to count the baseline cached RAM we
        // need (at which point we start killing processes) as used RAM, so that if we
        // reach the point of thrashing due to no RAM for any background processes we
        // report that as RAM being full.  To do this, we need to first convert the weights
        // back to actual RAM...  and since the RAM values we compute here won't exactly
        // match the real physical RAM, scale those to the actual physical RAM.  No problem!
        double usedRam = (usedWeight*1024)/memTotalTime;
        double freeRam = (freeWeight*1024)/memTotalTime;
        double totalRam = usedRam + freeRam;
        MemInfoReader memReader = new MemInfoReader();
        memReader.readMemInfo();
        double realTotalRam = memReader.getTotalSize();
        double totalScale = realTotalRam / totalRam;
        double realUsedRam = usedRam * totalScale;
        double realFreeRam = freeRam * totalScale;
        if (DEBUG) {
            Log.i(TAG, "Scaled Used RAM: " + Formatter.formatShortFileSize(getActivity(),
                    (long)realUsedRam));
            Log.i(TAG, "Scaled Free RAM: " + Formatter.formatShortFileSize(getActivity(),
                    (long)realFreeRam));
        }
        ActivityManager.MemoryInfo memInfo = new ActivityManager.MemoryInfo();
        ((ActivityManager)getActivity().getSystemService(Context.ACTIVITY_SERVICE)).getMemoryInfo(
                memInfo);
        if (memInfo.hiddenAppThreshold >= realFreeRam) {
            realUsedRam = realFreeRam;
            realFreeRam = 0;
        } else {
            realUsedRam += memInfo.hiddenAppThreshold;
            realFreeRam -= memInfo.hiddenAppThreshold;
        }
        if (DEBUG) {
            Log.i(TAG, "Adj Scaled Used RAM: " + Formatter.formatShortFileSize(getActivity(),
                    (long)realUsedRam));
            Log.i(TAG, "Adj Scaled Free RAM: " + Formatter.formatShortFileSize(getActivity(),
                    (long)realFreeRam));
        }

        float usedRatio = (float)(realUsedRam/(realFreeRam+realUsedRam));
        colors.setRatios(usedRatio, 0, 1-usedRatio);

        if (false) {
            colors.setOnRegionTappedListener(this);
            switch (mMemRegion) {
                case LinearColorBar.REGION_RED:
                    colors.setColoredRegions(LinearColorBar.REGION_RED);
                    memTotalTime = mMemTimes[ProcessStats.ADJ_MEM_FACTOR_CRITICAL];
                    memStates = RED_MEM_STATES;
                    break;
                case LinearColorBar.REGION_YELLOW:
                    colors.setColoredRegions(LinearColorBar.REGION_RED
                            | LinearColorBar.REGION_YELLOW);
                    memTotalTime = mMemTimes[ProcessStats.ADJ_MEM_FACTOR_CRITICAL]
                            + mMemTimes[ProcessStats.ADJ_MEM_FACTOR_LOW]
                            + mMemTimes[ProcessStats.ADJ_MEM_FACTOR_MODERATE];
                    memStates = YELLOW_MEM_STATES;
                    break;
                default:
                    colors.setColoredRegions(LinearColorBar.REGION_ALL);
                    memTotalTime = mTotalTime;
                    memStates = ProcessStats.ALL_MEM_ADJ;
                    break;
            }
            colors.setRatios(mMemTimes[ProcessStats.ADJ_MEM_FACTOR_CRITICAL] / (float)mTotalTime,
                    (mMemTimes[ProcessStats.ADJ_MEM_FACTOR_LOW]
                            + mMemTimes[ProcessStats.ADJ_MEM_FACTOR_MODERATE]) / (float)mTotalTime,
                    mMemTimes[ProcessStats.ADJ_MEM_FACTOR_NORMAL] / (float)mTotalTime);
        }

        mAppListGroup.addPreference(colors);

        ProcessStats.ProcessDataCollection totals = new ProcessStats.ProcessDataCollection(
                ProcessStats.ALL_SCREEN_ADJ, memStates, stats);

        ArrayList<ProcStatsEntry> entries = new ArrayList<ProcStatsEntry>();

        /*
        ArrayList<ProcessStats.ProcessState> rawProcs = mStats.collectProcessesLocked(
                ProcessStats.ALL_SCREEN_ADJ, ProcessStats.ALL_MEM_ADJ,
                ProcessStats.BACKGROUND_PROC_STATES, now, null);
        for (int i=0, N=(rawProcs != null ? rawProcs.size() : 0); i<N; i++) {
            procs.add(new ProcStatsEntry(rawProcs.get(i), totals));
        }
        */

        if (DEBUG) Log.d(TAG, "-------------------- PULLING PROCESSES");

        final ProcessMap<ProcStatsEntry> entriesMap = new ProcessMap<ProcStatsEntry>();
        for (int ipkg=0, N=mStats.mPackages.getMap().size(); ipkg<N; ipkg++) {
            final SparseArray<SparseArray<ProcessStats.PackageState>> pkgUids
                    = mStats.mPackages.getMap().valueAt(ipkg);
            for (int iu=0; iu<pkgUids.size(); iu++) {
                final SparseArray<ProcessStats.PackageState> vpkgs = pkgUids.valueAt(iu);
                for (int iv=0; iv<vpkgs.size(); iv++) {
                    final ProcessStats.PackageState st = vpkgs.valueAt(iv);
                    for (int iproc=0; iproc<st.mProcesses.size(); iproc++) {
                        final ProcessStats.ProcessState pkgProc = st.mProcesses.valueAt(iproc);
                        final ProcessStats.ProcessState proc = mStats.mProcesses.get(pkgProc.mName,
                                pkgProc.mUid);
                        if (proc == null) {
                            Log.w(TAG, "No process found for pkg " + st.mPackageName
                                    + "/" + st.mUid + " proc name " + pkgProc.mName);
                            continue;
                        }
                        ProcStatsEntry ent = entriesMap.get(proc.mName, proc.mUid);
                        if (ent == null) {
                            ent = new ProcStatsEntry(proc, st.mPackageName, totals, mUseUss,
                                    mStatsType == MENU_TYPE_BACKGROUND);
                            if (ent.mDuration > 0) {
                                if (DEBUG) Log.d(TAG, "Adding proc " + proc.mName + "/"
                                        + proc.mUid + ": time=" + makeDuration(ent.mDuration) + " ("
                                        + ((((double)ent.mDuration) / memTotalTime) * 100) + "%)"
                                        + " pss=" + ent.mAvgPss);
                                entriesMap.put(proc.mName, proc.mUid, ent);
                                entries.add(ent);
                            }
                        }  else {
                            ent.addPackage(st.mPackageName);
                        }
                    }
                }
            }
        }

        if (DEBUG) Log.d(TAG, "-------------------- MAPPING SERVICES");

        // Add in service info.
        if (mStatsType == MENU_TYPE_BACKGROUND) {
            for (int ip=0, N=mStats.mPackages.getMap().size(); ip<N; ip++) {
                SparseArray<SparseArray<ProcessStats.PackageState>> uids
                        = mStats.mPackages.getMap().valueAt(ip);
                for (int iu=0; iu<uids.size(); iu++) {
                    SparseArray<ProcessStats.PackageState> vpkgs = uids.valueAt(iu);
                    for (int iv=0; iv<vpkgs.size(); iv++) {
                        ProcessStats.PackageState ps = vpkgs.valueAt(iv);
                        for (int is=0, NS=ps.mServices.size(); is<NS; is++) {
                            ProcessStats.ServiceState ss = ps.mServices.valueAt(is);
                            if (ss.mProcessName != null) {
                                ProcStatsEntry ent = entriesMap.get(ss.mProcessName, uids.keyAt(iu));
                                if (ent != null) {
                                    if (DEBUG) Log.d(TAG, "Adding service " + ps.mPackageName
                                            + "/" + ss.mName + "/" + uids.keyAt(iu) + " to proc "
                                            + ss.mProcessName);
                                    ent.addService(ss);
                                } else {
                                    Log.w(TAG, "No process " + ss.mProcessName + "/" + uids.keyAt(iu)
                                            + " for service " + ss.mName);
                                }
                            }
                        }
                    }
                }
            }
        }

        /*
        SparseArray<ArrayMap<String, ProcStatsEntry>> processes
                = new SparseArray<ArrayMap<String, ProcStatsEntry>>();
        for (int ip=0, N=mStats.mProcesses.getMap().size(); ip<N; ip++) {
            SparseArray<ProcessStats.ProcessState> uids = mStats.mProcesses.getMap().valueAt(ip);
            for (int iu=0; iu<uids.size(); iu++) {
                ProcessStats.ProcessState st = uids.valueAt(iu);
                ProcStatsEntry ent = new ProcStatsEntry(st, totals, mUseUss,
                        mStatsType == MENU_TYPE_BACKGROUND);
                if (ent.mDuration > 0) {
                    if (DEBUG) Log.d(TAG, "Adding proc " + st.mName + "/" + st.mUid + ": time="
                            + makeDuration(ent.mDuration) + " ("
                            + ((((double)ent.mDuration) / memTotalTime) * 100) + "%)");
                    procs.add(ent);
                    ArrayMap<String, ProcStatsEntry> uidProcs = processes.get(ent.mUid);
                    if (uidProcs == null) {
                        uidProcs = new ArrayMap<String, ProcStatsEntry>();
                        processes.put(ent.mUid, uidProcs);
                    }
                    uidProcs.put(ent.mName, ent);
                }
            }
        }
        */

        Collections.sort(entries, sEntryCompare);

        long maxWeight = 1;
        for (int i=0, N=(entries != null ? entries.size() : 0); i<N; i++) {
            ProcStatsEntry proc = entries.get(i);
            if (maxWeight < proc.mWeight) {
                maxWeight = proc.mWeight;
            }
        }
        if (mStatsType == MENU_TYPE_BACKGROUND) {
            mMaxWeight = (long)(mShowSystem ? persBackgroundWeight : backgroundWeight);
            if (mMaxWeight < maxWeight) {
                mMaxWeight = maxWeight;
            }
            if (DEBUG) {
                Log.i(TAG, "Bar max RAM: " + Formatter.formatShortFileSize(getActivity(),
                        (mMaxWeight * 1024) / memTotalTime));
            }
        } else {
            mMaxWeight = maxWeight;
        }

        if (DEBUG) Log.d(TAG, "-------------------- BUILDING UI");

        // Find where we should stop.  Because we have two properties we are looking at,
        // we need to go from the back looking for the first place either holds.
        int end = entries != null ? entries.size()-1 : -1;
        while (end >= 0) {
            ProcStatsEntry proc = entries.get(end);
            final double percentOfWeight = (((double)proc.mWeight) / mMaxWeight) * 100;
            final double percentOfTime = (((double)proc.mDuration) / memTotalTime) * 100;
            if (percentOfWeight >= 1 || percentOfTime >= 25) {
                break;
            }
            end--;
        }
        for (int i=0; i<=end; i++) {
            ProcStatsEntry proc = entries.get(i);
            final double percentOfWeight = (((double)proc.mWeight) / mMaxWeight) * 100;
            final double percentOfTime = (((double)proc.mDuration) / memTotalTime) * 100;
            ProcessStatsPreference pref = new ProcessStatsPreference(getActivity());
            pref.init(null, proc);
            proc.evaluateTargetPackage(pm, mStats, totals, sEntryCompare, mUseUss,
                    mStatsType == MENU_TYPE_BACKGROUND);
            proc.retrieveUiData(pm);
            pref.setTitle(proc.mUiLabel);
            if (proc.mUiTargetApp != null) {
                pref.setIcon(proc.mUiTargetApp.loadIcon(pm));
            }
            pref.setOrder(i);
            pref.setPercent(percentOfWeight, percentOfTime);
            mAppListGroup.addPreference(pref);
            if (mStatsType == MENU_TYPE_BACKGROUND) {
                if (DEBUG) {
                    Log.i(TAG, "App " + proc.mUiLabel + ": weightedRam="
                            + Formatter.formatShortFileSize(getActivity(),
                                    (proc.mWeight * 1024) / memTotalTime)
                            + ", avgRam=" + Formatter.formatShortFileSize(getActivity(),
                                    (proc.mAvgPss*1024)));
                }

            }
            if (mAppListGroup.getPreferenceCount() > (MAX_ITEMS_TO_LIST+1)) {
                if (DEBUG) Log.d(TAG, "Done with UI, hit item limit!");
                break;
            }
        }
    }

    private void load() {
        try {
            mLastDuration = mDuration;
            mMemState = mProcessStats.getCurrentMemoryState();
            ParcelFileDescriptor pfd = mProcessStats.getStatsOverTime(mDuration);
            mStats = new ProcessStats(false);
            InputStream is = new ParcelFileDescriptor.AutoCloseInputStream(pfd);
            mStats.read(is);
            try {
                is.close();
            } catch (IOException e) {
            }
            if (mStats.mReadError != null) {
                Log.w(TAG, "Failure reading process stats: " + mStats.mReadError);
            }
        } catch (RemoteException e) {
            Log.e(TAG, "RemoteException:", e);
        }
    }
}