c891ce6565
Issue #17461567: java.lang.ArithmeticException: divide by zero when looking at Settings > Battery Yeah, let's not do that. Issue #17365562: Running services RAM totals are wrong Okay so like a few months ago, I had this vacation coming up, and it was around the feature complete (hahah) deadline, and I had to rush to get this in before I left. So I rushed. And, well, I forgot a few things. Here they are. We now show the right numbers and even update things correctly when you change what processes are being shown. Wow. Finally, fixed a few issues in the dev tools procstats UI. Change-Id: I8348a9c2ec3226a455c5c8465729e4487f324c8b
806 lines
35 KiB
Java
806 lines
35 KiB
Java
/*
|
|
* 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);
|
|
}
|
|
}
|
|
}
|