/* * 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.PackageManager; import android.os.Parcel; import android.os.Parcelable; import android.text.TextUtils; import android.util.ArrayMap; import android.util.Log; import android.util.LongSparseArray; import com.android.internal.app.procstats.ProcessState; import com.android.internal.app.procstats.ProcessStats; import com.android.internal.app.procstats.ServiceState; 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; public CharSequence mLabel; final ArrayList<String> mPackages = new ArrayList<>(); final long mBgDuration; final long mAvgBgMem; final long mMaxBgMem; final double mBgWeight; final long mRunDuration; final long mAvgRunMem; final long mMaxRunMem; final double mRunWeight; String mBestTargetPackage; ArrayMap<String, ArrayList<Service>> mServices = new ArrayMap<>(1); public ProcStatsEntry(ProcessState proc, String packageName, ProcessStats.ProcessDataCollection tmpBgTotals, ProcessStats.ProcessDataCollection tmpRunTotals, boolean useUss) { proc.computeProcessData(tmpBgTotals, 0); proc.computeProcessData(tmpRunTotals, 0); mPackage = proc.getPackage(); mUid = proc.getUid(); mName = proc.getName(); mPackages.add(packageName); mBgDuration = tmpBgTotals.totalTime; mAvgBgMem = useUss ? tmpBgTotals.avgUss : tmpBgTotals.avgPss; mMaxBgMem = useUss ? tmpBgTotals.maxUss : tmpBgTotals.maxPss; mBgWeight = mAvgBgMem * (double) mBgDuration; mRunDuration = tmpRunTotals.totalTime; mAvgRunMem = useUss ? tmpRunTotals.avgUss : tmpRunTotals.avgPss; mMaxRunMem = useUss ? tmpRunTotals.maxUss : tmpRunTotals.maxPss; mRunWeight = mAvgRunMem * (double) mRunDuration; if (DEBUG) Log.d(TAG, "New proc entry " + proc.getName() + ": dur=" + mBgDuration + " avgpss=" + mAvgBgMem + " weight=" + mBgWeight); } public ProcStatsEntry(String pkgName, int uid, String procName, long duration, long mem, long memDuration) { mPackage = pkgName; mUid = uid; mName = procName; mBgDuration = mRunDuration = duration; mAvgBgMem = mMaxBgMem = mAvgRunMem = mMaxRunMem = mem; mBgWeight = mRunWeight = ((double)memDuration) * mem; if (DEBUG) Log.d(TAG, "New proc entry " + procName + ": dur=" + mBgDuration + " avgpss=" + mAvgBgMem + " weight=" + mBgWeight); } public ProcStatsEntry(Parcel in) { mPackage = in.readString(); mUid = in.readInt(); mName = in.readString(); in.readStringList(mPackages); mBgDuration = in.readLong(); mAvgBgMem = in.readLong(); mMaxBgMem = in.readLong(); mBgWeight = in.readDouble(); mRunDuration = in.readLong(); mAvgRunMem = in.readLong(); mMaxRunMem = in.readLong(); mRunWeight = in.readDouble(); 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 bgTotals, ProcessStats.ProcessDataCollection runTotals, Comparator<ProcStatsEntry> compare, boolean useUss) { mBestTargetPackage = null; if (mPackages.size() == 1) { if (DEBUG) Log.d(TAG, "Eval pkg of " + mName + ": single pkg " + mPackages.get(0)); mBestTargetPackage = mPackages.get(0); return; } // If one of the packages is the framework itself, that wins. // See if there is one significant package that was running here. for (int ipkg=0; ipkg<mPackages.size(); ipkg++) { if ("android".equals(mPackages.get(ipkg))) { mBestTargetPackage = mPackages.get(ipkg); return; } } // Collect information about each package running in the process. ArrayList<ProcStatsEntry> subProcs = new ArrayList<>(); for (int ipkg=0; ipkg<mPackages.size(); ipkg++) { LongSparseArray<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; } 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, bgTotals, runTotals, useUss)); } } if (subProcs.size() > 1) { Collections.sort(subProcs, compare); if (subProcs.get(0).mRunWeight > (subProcs.get(1).mRunWeight *3)) { if (DEBUG) Log.d(TAG, "Eval pkg of " + mName + ": best pkg " + subProcs.get(0).mPackage + " weight " + subProcs.get(0).mRunWeight + " better than " + subProcs.get(1).mPackage + " weight " + subProcs.get(1).mRunWeight); 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. double maxWeight = subProcs.get(0).mRunWeight; long bestRunTime = -1; boolean bestPersistent = false; for (int i=0; i<subProcs.size(); i++) { final ProcStatsEntry subProc = subProcs.get(i); if (subProc.mRunWeight < (maxWeight/2)) { if (DEBUG) Log.d(TAG, "Eval pkg of " + mName + ": pkg " + subProc.mPackage + " weight " + subProc.mRunWeight + " too small"); continue; } try { ApplicationInfo ai = pm.getApplicationInfo(subProc.mPackage, 0); if (ai.icon == 0) { if (DEBUG) Log.d(TAG, "Eval pkg of " + mName + ": pkg " + subProc.mPackage + " has no icon"); continue; } if ((ai.flags&ApplicationInfo.FLAG_PERSISTENT) != 0) { long thisRunTime = subProc.mRunDuration; if (!bestPersistent || thisRunTime > bestRunTime) { if (DEBUG) Log.d(TAG, "Eval pkg of " + mName + ": pkg " + subProc.mPackage + " new best pers run time " + thisRunTime); bestRunTime = thisRunTime; bestPersistent = true; } else { if (DEBUG) Log.d(TAG, "Eval pkg of " + mName + ": pkg " + subProc.mPackage + " pers run time " + thisRunTime + " not as good as last " + bestRunTime); } continue; } else if (bestPersistent) { if (DEBUG) Log.d(TAG, "Eval pkg of " + mName + ": pkg " + subProc.mPackage + " is not persistent"); continue; } } catch (PackageManager.NameNotFoundException e) { if (DEBUG) Log.d(TAG, "Eval pkg of " + mName + ": pkg " + subProc.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(subProc.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 " + subProc.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 " + subProc.mPackage + " new best run time " + thisRunTime); mBestTargetPackage = subProc.mPackage; bestRunTime = thisRunTime; } else { if (DEBUG) Log.d(TAG, "Eval pkg of " + mName + ": pkg " + subProc.mPackage + " run time " + thisRunTime + " not as good as last " + bestRunTime); } } // Final fallback, just pick the first subProc. if (TextUtils.isEmpty(mBestTargetPackage)) { mBestTargetPackage = subProcs.get(0).mPackage; } } else if (subProcs.size() == 1) { mBestTargetPackage = subProcs.get(0).mPackage; } } public void addService(ServiceState svc) { ArrayList<Service> services = mServices.get(svc.getPackage()); if (services == null) { services = new ArrayList<Service>(); mServices.put(svc.getPackage(), 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(mBgDuration); dest.writeLong(mAvgBgMem); dest.writeLong(mMaxBgMem); dest.writeDouble(mBgWeight); dest.writeLong(mRunDuration); dest.writeLong(mAvgRunMem); dest.writeLong(mMaxRunMem); dest.writeDouble(mRunWeight); 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 int getUid() { return mUid; } 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(ServiceState service) { mPackage = service.getPackage(); mName = service.getName(); mProcess = service.getProcessName(); mDuration = service.dumpTime(null, null, 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]; } }; } }