5635594c38
Also make us much better about determining which app to blame for a particular running process, organize the display of services by their owning app, apply some new heuristics for deciding what goes in the process list so that we can still display interesting processes when we haven't collected pss data for them yet, etc. Change-Id: I7e87225d3dabc66cf3ff020b5db48401b14aaf47
354 lines
14 KiB
Java
354 lines
14 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.content.pm.ApplicationInfo;
|
|
import android.content.pm.PackageInfo;
|
|
import android.content.pm.PackageManager;
|
|
import android.os.Parcel;
|
|
import android.os.Parcelable;
|
|
import android.util.ArrayMap;
|
|
import android.util.Log;
|
|
import com.android.internal.app.ProcessStats;
|
|
|
|
import java.util.ArrayList;
|
|
import java.util.Collections;
|
|
import java.util.Comparator;
|
|
|
|
public final class ProcStatsEntry implements Parcelable {
|
|
private static final String TAG = "ProcStatsEntry";
|
|
private static boolean DEBUG = ProcessStatsUi.DEBUG;
|
|
|
|
final String mPackage;
|
|
final int mUid;
|
|
final String mName;
|
|
final ArrayList<String> mPackages = new ArrayList<String>();
|
|
final long mDuration;
|
|
final long mAvgPss;
|
|
final long mMaxPss;
|
|
final long mAvgUss;
|
|
final long mMaxUss;
|
|
final long mWeight;
|
|
|
|
String mBestTargetPackage;
|
|
|
|
ArrayMap<String, ArrayList<Service>> mServices = new ArrayMap<String, ArrayList<Service>>(1);
|
|
|
|
public ApplicationInfo mUiTargetApp;
|
|
public String mUiLabel;
|
|
public String mUiBaseLabel;
|
|
public String mUiPackage;
|
|
|
|
public ProcStatsEntry(ProcessStats.ProcessState proc, String packageName,
|
|
ProcessStats.ProcessDataCollection tmpTotals, boolean useUss, boolean weightWithTime) {
|
|
ProcessStats.computeProcessData(proc, tmpTotals, 0);
|
|
mPackage = proc.mPackage;
|
|
mUid = proc.mUid;
|
|
mName = proc.mName;
|
|
mPackages.add(packageName);
|
|
mDuration = tmpTotals.totalTime;
|
|
mAvgPss = tmpTotals.avgPss;
|
|
mMaxPss = tmpTotals.maxPss;
|
|
mAvgUss = tmpTotals.avgUss;
|
|
mMaxUss = tmpTotals.maxUss;
|
|
mWeight = (weightWithTime ? mDuration : 1) * (useUss ? mAvgUss : mAvgPss);
|
|
if (DEBUG) Log.d(TAG, "New proc entry " + proc.mName + ": dur=" + mDuration
|
|
+ " avgpss=" + mAvgPss + " weight=" + mWeight);
|
|
}
|
|
|
|
public ProcStatsEntry(Parcel in) {
|
|
mPackage = in.readString();
|
|
mUid = in.readInt();
|
|
mName = in.readString();
|
|
in.readStringList(mPackages);
|
|
mDuration = in.readLong();
|
|
mAvgPss = in.readLong();
|
|
mMaxPss = in.readLong();
|
|
mAvgUss = in.readLong();
|
|
mMaxUss = in.readLong();
|
|
mWeight = in.readLong();
|
|
mBestTargetPackage = in.readString();
|
|
final int N = in.readInt();
|
|
if (N > 0) {
|
|
mServices.ensureCapacity(N);
|
|
for (int i=0; i<N; i++) {
|
|
String key = in.readString();
|
|
ArrayList<Service> value = new ArrayList<Service>();
|
|
in.readTypedList(value, Service.CREATOR);
|
|
mServices.append(key, value);
|
|
}
|
|
}
|
|
}
|
|
|
|
public void addPackage(String packageName) {
|
|
mPackages.add(packageName);
|
|
}
|
|
|
|
public void evaluateTargetPackage(PackageManager pm, ProcessStats stats,
|
|
ProcessStats.ProcessDataCollection totals, Comparator<ProcStatsEntry> compare,
|
|
boolean useUss, boolean weightWithTime) {
|
|
mBestTargetPackage = null;
|
|
if (mPackages.size() == 1) {
|
|
if (DEBUG) Log.d(TAG, "Eval pkg of " + mName + ": single pkg " + mPackages.get(0));
|
|
mBestTargetPackage = mPackages.get(0);
|
|
} else {
|
|
// See if there is one significant package that was running here.
|
|
ArrayList<ProcStatsEntry> subProcs = new ArrayList<ProcStatsEntry>();
|
|
for (int ipkg=0; ipkg<mPackages.size(); ipkg++) {
|
|
ProcessStats.PackageState pkgState = stats.mPackages.get(mPackages.get(ipkg), mUid);
|
|
if (DEBUG) Log.d(TAG, "Eval pkg of " + mName + ", pkg "
|
|
+ mPackages.get(ipkg) + ":");
|
|
if (pkgState == null) {
|
|
Log.w(TAG, "No package state found for " + mPackages.get(ipkg) + "/"
|
|
+ mUid + " in process " + mName);
|
|
continue;
|
|
}
|
|
ProcessStats.ProcessState pkgProc = pkgState.mProcesses.get(mName);
|
|
if (pkgProc == null) {
|
|
Log.w(TAG, "No process " + mName + " found in package state "
|
|
+ mPackages.get(ipkg) + "/" + mUid);
|
|
continue;
|
|
}
|
|
subProcs.add(new ProcStatsEntry(pkgProc, pkgState.mPackageName, totals, useUss,
|
|
weightWithTime));
|
|
}
|
|
if (subProcs.size() > 1) {
|
|
Collections.sort(subProcs, compare);
|
|
if (subProcs.get(0).mWeight > (subProcs.get(1).mWeight*3)) {
|
|
if (DEBUG) Log.d(TAG, "Eval pkg of " + mName + ": best pkg "
|
|
+ subProcs.get(0).mPackage + " weight " + subProcs.get(0).mWeight
|
|
+ " better than " + subProcs.get(1).mPackage
|
|
+ " weight " + subProcs.get(1).mWeight);
|
|
mBestTargetPackage = subProcs.get(0).mPackage;
|
|
return;
|
|
}
|
|
// Couldn't find one that is best by weight, let's decide on best another
|
|
// way: the one that has the longest running service, accounts for at least
|
|
// half of the maximum weight, and has specified an explicit app icon.
|
|
long maxWeight = subProcs.get(0).mWeight;
|
|
long bestRunTime = -1;
|
|
for (int i=0; i<subProcs.size(); i++) {
|
|
if (subProcs.get(i).mWeight < (maxWeight/2)) {
|
|
if (DEBUG) Log.d(TAG, "Eval pkg of " + mName + ": pkg "
|
|
+ subProcs.get(i).mPackage + " weight " + subProcs.get(i).mWeight
|
|
+ " too small");
|
|
continue;
|
|
}
|
|
try {
|
|
ApplicationInfo ai = pm.getApplicationInfo(subProcs.get(i).mPackage, 0);
|
|
if (ai.icon == 0) {
|
|
if (DEBUG) Log.d(TAG, "Eval pkg of " + mName + ": pkg "
|
|
+ subProcs.get(i).mPackage + " has no icon");
|
|
continue;
|
|
}
|
|
} catch (PackageManager.NameNotFoundException e) {
|
|
if (DEBUG) Log.d(TAG, "Eval pkg of " + mName + ": pkg "
|
|
+ subProcs.get(i).mPackage + " failed finding app info");
|
|
continue;
|
|
}
|
|
ArrayList<Service> subProcServices = null;
|
|
for (int isp=0, NSP=mServices.size(); isp<NSP; isp++) {
|
|
ArrayList<Service> subServices = mServices.valueAt(isp);
|
|
if (subServices.get(0).mPackage.equals(subProcs.get(i).mPackage)) {
|
|
subProcServices = subServices;
|
|
break;
|
|
}
|
|
}
|
|
long thisRunTime = 0;
|
|
if (subProcServices != null) {
|
|
for (int iss=0, NSS=subProcServices.size(); iss<NSS; iss++) {
|
|
Service service = subProcServices.get(iss);
|
|
if (service.mDuration > thisRunTime) {
|
|
if (DEBUG) Log.d(TAG, "Eval pkg of " + mName + ": pkg "
|
|
+ subProcs.get(i).mPackage + " service " + service.mName
|
|
+ " run time is " + service.mDuration);
|
|
thisRunTime = service.mDuration;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
if (thisRunTime > bestRunTime) {
|
|
if (DEBUG) Log.d(TAG, "Eval pkg of " + mName + ": pkg "
|
|
+ subProcs.get(i).mPackage + " new best run time " + thisRunTime);
|
|
mBestTargetPackage = subProcs.get(i).mPackage;
|
|
bestRunTime = thisRunTime;
|
|
} else {
|
|
if (DEBUG) Log.d(TAG, "Eval pkg of " + mName + ": pkg "
|
|
+ subProcs.get(i).mPackage + " run time " + thisRunTime
|
|
+ " not as good as last " + bestRunTime);
|
|
}
|
|
}
|
|
} else if (subProcs.size() == 1) {
|
|
mBestTargetPackage = subProcs.get(0).mPackage;
|
|
}
|
|
}
|
|
}
|
|
|
|
public void retrieveUiData(PackageManager pm) {
|
|
mUiTargetApp = null;
|
|
mUiLabel = mUiBaseLabel = mName;
|
|
mUiPackage = mBestTargetPackage;
|
|
if (mUiPackage != null) {
|
|
// Only one app associated with this process.
|
|
try {
|
|
mUiTargetApp = pm.getApplicationInfo(mUiPackage,
|
|
PackageManager.GET_DISABLED_COMPONENTS |
|
|
PackageManager.GET_DISABLED_UNTIL_USED_COMPONENTS |
|
|
PackageManager.GET_UNINSTALLED_PACKAGES);
|
|
String name = mUiBaseLabel = mUiTargetApp.loadLabel(pm).toString();
|
|
if (mName.equals(mUiPackage)) {
|
|
mUiLabel = name;
|
|
} else {
|
|
if (mName.startsWith(mUiPackage)) {
|
|
int off = mUiPackage.length();
|
|
if (mName.length() > off) {
|
|
off++;
|
|
}
|
|
mUiLabel = name + " (" + mName.substring(off) + ")";
|
|
} else {
|
|
mUiLabel = name + " (" + mName + ")";
|
|
}
|
|
}
|
|
} catch (PackageManager.NameNotFoundException e) {
|
|
}
|
|
}
|
|
if (mUiTargetApp == null) {
|
|
String[] packages = pm.getPackagesForUid(mUid);
|
|
if (packages != null) {
|
|
for (String curPkg : packages) {
|
|
try {
|
|
final PackageInfo pi = pm.getPackageInfo(curPkg,
|
|
PackageManager.GET_DISABLED_COMPONENTS |
|
|
PackageManager.GET_DISABLED_UNTIL_USED_COMPONENTS |
|
|
PackageManager.GET_UNINSTALLED_PACKAGES);
|
|
if (pi.sharedUserLabel != 0) {
|
|
mUiTargetApp = pi.applicationInfo;
|
|
final CharSequence nm = pm.getText(curPkg,
|
|
pi.sharedUserLabel, pi.applicationInfo);
|
|
if (nm != null) {
|
|
mUiBaseLabel = nm.toString();
|
|
mUiLabel = mUiBaseLabel + " (" + mName + ")";
|
|
} else {
|
|
mUiBaseLabel = mUiTargetApp.loadLabel(pm).toString();
|
|
mUiLabel = mUiBaseLabel + " (" + mName + ")";
|
|
}
|
|
break;
|
|
}
|
|
} catch (PackageManager.NameNotFoundException e) {
|
|
}
|
|
}
|
|
} else {
|
|
// no current packages for this uid, typically because of uninstall
|
|
Log.i(TAG, "No package for uid " + mUid);
|
|
}
|
|
}
|
|
}
|
|
|
|
public void addService(ProcessStats.ServiceState svc) {
|
|
ArrayList<Service> services = mServices.get(svc.mPackage);
|
|
if (services == null) {
|
|
services = new ArrayList<Service>();
|
|
mServices.put(svc.mPackage, services);
|
|
}
|
|
services.add(new Service(svc));
|
|
}
|
|
|
|
@Override
|
|
public int describeContents() {
|
|
return 0;
|
|
}
|
|
|
|
@Override
|
|
public void writeToParcel(Parcel dest, int flags) {
|
|
dest.writeString(mPackage);
|
|
dest.writeInt(mUid);
|
|
dest.writeString(mName);
|
|
dest.writeStringList(mPackages);
|
|
dest.writeLong(mDuration);
|
|
dest.writeLong(mAvgPss);
|
|
dest.writeLong(mMaxPss);
|
|
dest.writeLong(mAvgUss);
|
|
dest.writeLong(mMaxUss);
|
|
dest.writeLong(mWeight);
|
|
dest.writeString(mBestTargetPackage);
|
|
final int N = mServices.size();
|
|
dest.writeInt(N);
|
|
for (int i=0; i<N; i++) {
|
|
dest.writeString(mServices.keyAt(i));
|
|
dest.writeTypedList(mServices.valueAt(i));
|
|
}
|
|
}
|
|
|
|
public static final Parcelable.Creator<ProcStatsEntry> CREATOR
|
|
= new Parcelable.Creator<ProcStatsEntry>() {
|
|
public ProcStatsEntry createFromParcel(Parcel in) {
|
|
return new ProcStatsEntry(in);
|
|
}
|
|
|
|
public ProcStatsEntry[] newArray(int size) {
|
|
return new ProcStatsEntry[size];
|
|
}
|
|
};
|
|
|
|
public static final class Service implements Parcelable {
|
|
final String mPackage;
|
|
final String mName;
|
|
final String mProcess;
|
|
final long mDuration;
|
|
|
|
public Service(ProcessStats.ServiceState service) {
|
|
mPackage = service.mPackage;
|
|
mName = service.mName;
|
|
mProcess = service.mProcessName;
|
|
mDuration = ProcessStats.dumpSingleServiceTime(null, null, service,
|
|
ProcessStats.ServiceState.SERVICE_RUN,
|
|
ProcessStats.STATE_NOTHING, 0, 0);
|
|
}
|
|
|
|
public Service(Parcel in) {
|
|
mPackage = in.readString();
|
|
mName = in.readString();
|
|
mProcess = in.readString();
|
|
mDuration = in.readLong();
|
|
}
|
|
|
|
@Override
|
|
public int describeContents() {
|
|
return 0;
|
|
}
|
|
|
|
@Override
|
|
public void writeToParcel(Parcel dest, int flags) {
|
|
dest.writeString(mPackage);
|
|
dest.writeString(mName);
|
|
dest.writeString(mProcess);
|
|
dest.writeLong(mDuration);
|
|
}
|
|
|
|
public static final Parcelable.Creator<Service> CREATOR
|
|
= new Parcelable.Creator<Service>() {
|
|
public Service createFromParcel(Parcel in) {
|
|
return new Service(in);
|
|
}
|
|
|
|
public Service[] newArray(int size) {
|
|
return new Service[size];
|
|
}
|
|
};
|
|
}
|
|
}
|