2583fc1e06
- Move process stats from developer options to top level settings item. - Some minor UI changes to the top of the page - Major UI updates to detail page, now shows info with processes as pref categories and services as prefs, with a way to kill them (taken from Running Services page). - Some major refactorings in code, in attempt to make it more usable - Added color bar on per app basis to visualize the avg/max relationship - Updated the way avg is calculated across multiple entries in ProcStatsPackageEntry to be more accurate - Change the way max memory is calculated in ProcStatsPackageEntry to be less accurate but more useful Bug: 19443802 Change-Id: Ia6aaabe42c415c50997a09bfb814a6f6e5731772
432 lines
17 KiB
Java
432 lines
17 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.app.ActivityManager.RunningServiceInfo;
|
|
import android.app.AlertDialog;
|
|
import android.app.admin.DevicePolicyManager;
|
|
import android.content.ComponentName;
|
|
import android.content.Context;
|
|
import android.content.DialogInterface;
|
|
import android.content.Intent;
|
|
import android.content.pm.ApplicationInfo;
|
|
import android.content.pm.PackageManager;
|
|
import android.content.pm.PackageManager.NameNotFoundException;
|
|
import android.content.pm.ServiceInfo;
|
|
import android.graphics.drawable.ColorDrawable;
|
|
import android.os.Bundle;
|
|
import android.os.Process;
|
|
import android.preference.PreferenceCategory;
|
|
import android.text.format.Formatter;
|
|
import android.util.ArrayMap;
|
|
import android.util.Log;
|
|
import android.view.View;
|
|
import android.widget.Button;
|
|
import android.widget.TextView;
|
|
|
|
import com.android.internal.logging.MetricsLogger;
|
|
import com.android.settings.AppHeader;
|
|
import com.android.settings.CancellablePreference;
|
|
import com.android.settings.CancellablePreference.OnCancelListener;
|
|
import com.android.settings.R;
|
|
import com.android.settings.SettingsPreferenceFragment;
|
|
import com.android.settings.applications.ProcStatsEntry.Service;
|
|
|
|
import java.util.ArrayList;
|
|
import java.util.Collections;
|
|
import java.util.Comparator;
|
|
import java.util.HashMap;
|
|
import java.util.List;
|
|
|
|
public class ProcessStatsDetail extends SettingsPreferenceFragment
|
|
implements Button.OnClickListener {
|
|
|
|
private static final String TAG = "ProcessStatsDetail";
|
|
|
|
public static final int ACTION_FORCE_STOP = 1;
|
|
|
|
public static final String EXTRA_PACKAGE_ENTRY = "package_entry";
|
|
public static final String EXTRA_USE_USS = "use_uss";
|
|
public static final String EXTRA_WEIGHT_TO_RAM = "weight_to_ram";
|
|
public static final String EXTRA_TOTAL_TIME = "total_time";
|
|
public static final String EXTRA_MAX_MEMORY_USAGE = "max_memory_usage";
|
|
public static final String EXTRA_TOTAL_SCALE = "total_scale";
|
|
|
|
private static final String KEY_DETAILS_HEADER = "details_header";
|
|
|
|
private final ArrayMap<ComponentName, CancellablePreference> mServiceMap = new ArrayMap<>();
|
|
|
|
private PackageManager mPm;
|
|
private DevicePolicyManager mDpm;
|
|
|
|
private ProcStatsPackageEntry mApp;
|
|
private boolean mUseUss;
|
|
private double mWeightToRam;
|
|
private long mTotalTime;
|
|
private long mOnePercentTime;
|
|
|
|
private Button mForceStopButton;
|
|
private Button mReportButton;
|
|
|
|
private LinearColorBar mColorBar;
|
|
|
|
private float mMaxMemoryUsage;
|
|
|
|
private double mTotalScale;
|
|
|
|
@Override
|
|
public void onCreate(Bundle icicle) {
|
|
super.onCreate(icicle);
|
|
mPm = getActivity().getPackageManager();
|
|
mDpm = (DevicePolicyManager)getActivity().getSystemService(Context.DEVICE_POLICY_SERVICE);
|
|
final Bundle args = getArguments();
|
|
mApp = args.getParcelable(EXTRA_PACKAGE_ENTRY);
|
|
mApp.retrieveUiData(getActivity(), mPm);
|
|
mUseUss = args.getBoolean(EXTRA_USE_USS);
|
|
mWeightToRam = args.getDouble(EXTRA_WEIGHT_TO_RAM);
|
|
mTotalTime = args.getLong(EXTRA_TOTAL_TIME);
|
|
mMaxMemoryUsage = args.getFloat(EXTRA_MAX_MEMORY_USAGE);
|
|
mTotalScale = args.getDouble(EXTRA_TOTAL_SCALE);
|
|
mOnePercentTime = mTotalTime/100;
|
|
|
|
mServiceMap.clear();
|
|
createDetails();
|
|
}
|
|
|
|
@Override
|
|
public void onViewCreated(View view, Bundle savedInstanceState) {
|
|
super.onViewCreated(view, savedInstanceState);
|
|
|
|
AppHeader.createAppHeader(getActivity(),
|
|
mApp.mUiTargetApp != null ? mApp.mUiTargetApp.loadIcon(mPm) : new ColorDrawable(0),
|
|
mApp.mUiLabel, null);
|
|
}
|
|
|
|
@Override
|
|
protected int getMetricsCategory() {
|
|
return MetricsLogger.APPLICATIONS_PROCESS_STATS_DETAIL;
|
|
}
|
|
|
|
@Override
|
|
public void onResume() {
|
|
super.onResume();
|
|
checkForceStop();
|
|
|
|
updateRunningServices();
|
|
}
|
|
|
|
private void updateRunningServices() {
|
|
ActivityManager activityManager = (ActivityManager)
|
|
getActivity().getSystemService(Context.ACTIVITY_SERVICE);
|
|
List<RunningServiceInfo> runningServices =
|
|
activityManager.getRunningServices(Integer.MAX_VALUE);
|
|
|
|
// Set all services as not running, then turn back on the ones we find.
|
|
int N = mServiceMap.size();
|
|
for (int i = 0; i < N; i++) {
|
|
mServiceMap.valueAt(i).setCancellable(false);
|
|
}
|
|
|
|
N = runningServices.size();
|
|
for (int i = 0; i < N; i++) {
|
|
RunningServiceInfo runningService = runningServices.get(i);
|
|
if (!runningService.started && runningService.clientLabel == 0) {
|
|
continue;
|
|
}
|
|
if ((runningService.flags & RunningServiceInfo.FLAG_PERSISTENT_PROCESS) != 0) {
|
|
continue;
|
|
}
|
|
final ComponentName service = runningService.service;
|
|
CancellablePreference pref = mServiceMap.get(service);
|
|
if (pref != null) {
|
|
pref.setOnCancelListener(new OnCancelListener() {
|
|
@Override
|
|
public void onCancel(CancellablePreference preference) {
|
|
stopService(service.getPackageName(), service.getClassName());
|
|
}
|
|
});
|
|
pref.setCancellable(true);
|
|
}
|
|
}
|
|
}
|
|
|
|
private void createDetails() {
|
|
addPreferencesFromResource(R.xml.app_memory_settings);
|
|
|
|
fillProcessesSection();
|
|
|
|
LayoutPreference headerLayout = (LayoutPreference) findPreference(KEY_DETAILS_HEADER);
|
|
|
|
TextView avgUsed = (TextView) headerLayout.findViewById(R.id.memory_avg);
|
|
TextView maxUsed = (TextView) headerLayout.findViewById(R.id.memory_max);
|
|
avgUsed.setText(getString(R.string.memory_avg_desc,
|
|
Formatter.formatShortFileSize(getActivity(),
|
|
(long) (Math.max(mApp.mBgWeight, mApp.mRunWeight) * mWeightToRam))));
|
|
maxUsed.setText(getString(R.string.memory_max_desc,
|
|
Formatter.formatShortFileSize(getActivity(),
|
|
(long) (Math.max(mApp.mMaxBgMem, mApp.mMaxRunMem) * 1024 * mTotalScale))));
|
|
|
|
mForceStopButton = (Button) headerLayout.findViewById(R.id.right_button);
|
|
mReportButton = (Button) headerLayout.findViewById(R.id.left_button);
|
|
|
|
if (mApp.mEntries.get(0).mUid >= android.os.Process.FIRST_APPLICATION_UID) {
|
|
mForceStopButton.setEnabled(false);
|
|
mReportButton.setVisibility(View.INVISIBLE);
|
|
|
|
mForceStopButton.setText(R.string.force_stop);
|
|
mForceStopButton.setTag(ACTION_FORCE_STOP);
|
|
mForceStopButton.setOnClickListener(this);
|
|
} else {
|
|
mReportButton.setVisibility(View.GONE);
|
|
mForceStopButton.setVisibility(View.GONE);
|
|
}
|
|
|
|
// TODO: Find way to share this code with ProcessStatsPreference.
|
|
boolean statsForeground = mApp.mRunWeight > mApp.mBgWeight;
|
|
float mAvgRatio = (statsForeground ? mApp.mAvgRunMem : mApp.mAvgBgMem) / mMaxMemoryUsage;
|
|
float mMaxRatio = (statsForeground ? mApp.mMaxRunMem : mApp.mMaxBgMem) / mMaxMemoryUsage
|
|
- mAvgRatio;
|
|
float mRemainingRatio = 1 - mAvgRatio - mMaxRatio;
|
|
mColorBar = (LinearColorBar) headerLayout.findViewById(R.id.color_bar);
|
|
Context context = getActivity();
|
|
mColorBar.setColors(context.getColor(R.color.memory_avg_use),
|
|
context.getColor(R.color.memory_max_use),
|
|
context.getColor(R.color.memory_remaining));
|
|
mColorBar.setRatios(mAvgRatio, mMaxRatio, mRemainingRatio);
|
|
}
|
|
|
|
public void onClick(View v) {
|
|
doAction((Integer) v.getTag());
|
|
}
|
|
|
|
private void doAction(int action) {
|
|
switch (action) {
|
|
case ACTION_FORCE_STOP:
|
|
killProcesses();
|
|
break;
|
|
}
|
|
}
|
|
|
|
final static Comparator<ProcStatsEntry> sEntryCompare = new Comparator<ProcStatsEntry>() {
|
|
@Override
|
|
public int compare(ProcStatsEntry lhs, ProcStatsEntry rhs) {
|
|
if (lhs.mRunWeight < rhs.mRunWeight) {
|
|
return 1;
|
|
} else if (lhs.mRunWeight > rhs.mRunWeight) {
|
|
return -1;
|
|
}
|
|
return 0;
|
|
}
|
|
};
|
|
|
|
private void fillProcessesSection() {
|
|
final ArrayList<ProcStatsEntry> entries = new ArrayList<>();
|
|
for (int ie = 0; ie < mApp.mEntries.size(); ie++) {
|
|
ProcStatsEntry entry = mApp.mEntries.get(ie);
|
|
if (entry.mPackage.equals("os")) {
|
|
entry.mLabel = entry.mName;
|
|
} else {
|
|
if (mApp.mEntries.size() > 1) {
|
|
entry.mLabel = getString(R.string.process_format, (ie + 1));
|
|
} else {
|
|
entry.mLabel = getString(R.string.process);
|
|
}
|
|
}
|
|
entries.add(entry);
|
|
}
|
|
Collections.sort(entries, sEntryCompare);
|
|
for (int ie = 0; ie < entries.size(); ie++) {
|
|
ProcStatsEntry entry = entries.get(ie);
|
|
PreferenceCategory processPref = new PreferenceCategory(getActivity());
|
|
processPref.setLayoutResource(R.layout.process_preference_category);
|
|
processPref.setTitle(entry.mLabel);
|
|
|
|
long memoryUse = Math.max((long)(entry.mRunWeight * mWeightToRam),
|
|
(long)(entry.mBgWeight * mWeightToRam));
|
|
String memoryString = Formatter.formatShortFileSize(getActivity(), memoryUse);
|
|
CharSequence frequency = ProcStatsPackageEntry.getFrequency(entry.mRunDuration
|
|
/ (float)mTotalTime, getActivity());
|
|
processPref.setSummary(
|
|
getString(R.string.memory_use_running_format, memoryString, frequency));
|
|
getPreferenceScreen().addPreference(processPref);
|
|
fillServicesSection(entry, processPref);
|
|
}
|
|
}
|
|
|
|
final static Comparator<ProcStatsEntry.Service> sServiceCompare
|
|
= new Comparator<ProcStatsEntry.Service>() {
|
|
@Override
|
|
public int compare(ProcStatsEntry.Service lhs, ProcStatsEntry.Service rhs) {
|
|
if (lhs.mDuration < rhs.mDuration) {
|
|
return 1;
|
|
} else if (lhs.mDuration > rhs.mDuration) {
|
|
return -1;
|
|
}
|
|
return 0;
|
|
}
|
|
};
|
|
|
|
final static Comparator<PkgService> sServicePkgCompare = new Comparator<PkgService>() {
|
|
@Override
|
|
public int compare(PkgService lhs, PkgService rhs) {
|
|
if (lhs.mDuration < rhs.mDuration) {
|
|
return 1;
|
|
} else if (lhs.mDuration > rhs.mDuration) {
|
|
return -1;
|
|
}
|
|
return 0;
|
|
}
|
|
};
|
|
|
|
static class PkgService {
|
|
final ArrayList<ProcStatsEntry.Service> mServices = new ArrayList<>();
|
|
long mDuration;
|
|
}
|
|
|
|
private void fillServicesSection(ProcStatsEntry entry, PreferenceCategory processPref) {
|
|
final HashMap<String, PkgService> pkgServices = new HashMap<>();
|
|
final ArrayList<PkgService> pkgList = new ArrayList<>();
|
|
for (int ip = 0; ip < entry.mServices.size(); ip++) {
|
|
String pkg = entry.mServices.keyAt(ip);
|
|
PkgService psvc = null;
|
|
ArrayList<ProcStatsEntry.Service> services = entry.mServices.valueAt(ip);
|
|
for (int is=services.size()-1; is>=0; is--) {
|
|
ProcStatsEntry.Service pent = services.get(is);
|
|
if (pent.mDuration >= mOnePercentTime) {
|
|
if (psvc == null) {
|
|
psvc = pkgServices.get(pkg);
|
|
if (psvc == null) {
|
|
psvc = new PkgService();
|
|
pkgServices.put(pkg, psvc);
|
|
pkgList.add(psvc);
|
|
}
|
|
}
|
|
psvc.mServices.add(pent);
|
|
psvc.mDuration += pent.mDuration;
|
|
}
|
|
}
|
|
}
|
|
Collections.sort(pkgList, sServicePkgCompare);
|
|
for (int ip = 0; ip < pkgList.size(); ip++) {
|
|
ArrayList<ProcStatsEntry.Service> services = pkgList.get(ip).mServices;
|
|
Collections.sort(services, sServiceCompare);
|
|
for (int is=0; is<services.size(); is++) {
|
|
final ProcStatsEntry.Service service = services.get(is);
|
|
CharSequence label = getLabel(service);
|
|
CancellablePreference servicePref = new CancellablePreference(getActivity());
|
|
servicePref.setSelectable(false);
|
|
servicePref.setTitle(label);
|
|
servicePref.setSummary(ProcStatsPackageEntry.getFrequency(
|
|
service.mDuration / (float) mTotalTime, getActivity()));
|
|
processPref.addPreference(servicePref);
|
|
mServiceMap.put(new ComponentName(service.mPackage, service.mName), servicePref);
|
|
}
|
|
}
|
|
}
|
|
|
|
private CharSequence getLabel(Service service) {
|
|
// Try to get the service label, on the off chance that one exists.
|
|
try {
|
|
ServiceInfo serviceInfo = getPackageManager().getServiceInfo(
|
|
new ComponentName(service.mPackage, service.mName), 0);
|
|
if (serviceInfo.labelRes != 0) {
|
|
return serviceInfo.loadLabel(getPackageManager());
|
|
}
|
|
} catch (NameNotFoundException e) {
|
|
}
|
|
String label = service.mName;
|
|
int tail = label.lastIndexOf('.');
|
|
if (tail >= 0 && tail < (label.length()-1)) {
|
|
label = label.substring(tail+1);
|
|
}
|
|
return label;
|
|
}
|
|
|
|
private void stopService(String pkg, String name) {
|
|
try {
|
|
ApplicationInfo appInfo = getActivity().getPackageManager().getApplicationInfo(pkg, 0);
|
|
if ((appInfo.flags & ApplicationInfo.FLAG_SYSTEM) != 0) {
|
|
showStopServiceDialog(pkg, name);
|
|
return;
|
|
}
|
|
} catch (NameNotFoundException e) {
|
|
Log.e(TAG, "Can't find app " + pkg, e);
|
|
return;
|
|
}
|
|
doStopService(pkg, name);
|
|
}
|
|
|
|
private void showStopServiceDialog(final String pkg, final String name) {
|
|
new AlertDialog.Builder(getActivity())
|
|
.setTitle(R.string.runningservicedetails_stop_dlg_title)
|
|
.setMessage(R.string.runningservicedetails_stop_dlg_text)
|
|
.setPositiveButton(R.string.dlg_ok, new DialogInterface.OnClickListener() {
|
|
public void onClick(DialogInterface dialog, int which) {
|
|
doStopService(pkg, name);
|
|
}
|
|
})
|
|
.setNegativeButton(R.string.dlg_cancel, null)
|
|
.show();
|
|
}
|
|
|
|
private void doStopService(String pkg, String name) {
|
|
getActivity().stopService(new Intent().setClassName(pkg, name));
|
|
updateRunningServices();
|
|
}
|
|
|
|
private void killProcesses() {
|
|
ActivityManager am = (ActivityManager)getActivity().getSystemService(
|
|
Context.ACTIVITY_SERVICE);
|
|
for (int i=0; i< mApp.mEntries.size(); i++) {
|
|
ProcStatsEntry ent = mApp.mEntries.get(i);
|
|
for (int j=0; j<ent.mPackages.size(); j++) {
|
|
am.forceStopPackage(ent.mPackages.get(j));
|
|
}
|
|
}
|
|
checkForceStop();
|
|
}
|
|
|
|
private void checkForceStop() {
|
|
if (mApp.mEntries.get(0).mUid < Process.FIRST_APPLICATION_UID) {
|
|
mForceStopButton.setEnabled(false);
|
|
return;
|
|
}
|
|
boolean isStarted = false;
|
|
for (int i=0; i< mApp.mEntries.size(); i++) {
|
|
ProcStatsEntry ent = mApp.mEntries.get(i);
|
|
for (int j=0; j<ent.mPackages.size(); j++) {
|
|
String pkg = ent.mPackages.get(j);
|
|
if (mDpm.packageHasActiveAdmins(pkg)) {
|
|
mForceStopButton.setEnabled(false);
|
|
return;
|
|
}
|
|
try {
|
|
ApplicationInfo info = mPm.getApplicationInfo(pkg, 0);
|
|
if ((info.flags&ApplicationInfo.FLAG_STOPPED) == 0) {
|
|
isStarted = true;
|
|
}
|
|
} catch (PackageManager.NameNotFoundException e) {
|
|
}
|
|
}
|
|
}
|
|
if (isStarted) {
|
|
mForceStopButton.setEnabled(true);
|
|
}
|
|
}
|
|
}
|