359 lines
15 KiB
Java
359 lines
15 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 android.util.SparseArray;
|
|
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++) {
|
|
SparseArray<ProcessStats.PackageState> vpkgs
|
|
= stats.mPackages.get(mPackages.get(ipkg), mUid);
|
|
for (int ivers=0; ivers<vpkgs.size(); ivers++) {
|
|
ProcessStats.PackageState pkgState = vpkgs.valueAt(ivers);
|
|
if (DEBUG) Log.d(TAG, "Eval pkg of " + mName + ", pkg "
|
|
+ pkgState + ":");
|
|
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];
|
|
}
|
|
};
|
|
}
|
|
}
|