auto import from //depot/cupcake/@135843
diff --git a/services/java/com/android/server/am/ProcessRecord.java b/services/java/com/android/server/am/ProcessRecord.java
new file mode 100644
index 0000000..a1320df
--- /dev/null
+++ b/services/java/com/android/server/am/ProcessRecord.java
@@ -0,0 +1,224 @@
+/*
+ * Copyright (C) 2006 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.server.am;
+
+import com.android.internal.os.BatteryStatsImpl;
+import com.android.server.Watchdog;
+
+import android.app.ActivityManager;
+import android.app.Dialog;
+import android.app.IApplicationThread;
+import android.app.IInstrumentationWatcher;
+import android.content.ComponentName;
+import android.content.pm.ApplicationInfo;
+import android.os.Bundle;
+import android.os.IBinder;
+import android.os.RemoteException;
+
+import java.io.PrintWriter;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.HashSet;
+
+/**
+ * Full information about a particular process that
+ * is currently running.
+ */
+class ProcessRecord implements Watchdog.PssRequestor {
+ final BatteryStatsImpl.Uid.Proc batteryStats; // where to collect runtime statistics
+ final ApplicationInfo info; // all about the first app in the process
+ final String processName; // name of the process
+ // List of packages running in the process
+ final HashSet<String> pkgList = new HashSet();
+ IApplicationThread thread; // the actual proc... may be null only if
+ // 'persistent' is true (in which case we
+ // are in the process of launching the app)
+ int pid; // The process of this application; 0 if none
+ boolean starting; // True if the process is being started
+ int maxAdj; // Maximum OOM adjustment for this process
+ int hiddenAdj; // If hidden, this is the adjustment to use
+ int curRawAdj; // Current OOM unlimited adjustment for this process
+ int setRawAdj; // Last set OOM unlimited adjustment for this process
+ int curAdj; // Current OOM adjustment for this process
+ int setAdj; // Last set OOM adjustment for this process
+ boolean isForeground; // Is this app running the foreground UI?
+ boolean setIsForeground; // Running foreground UI when last set?
+ boolean foregroundServices; // Running any services that are foreground?
+ boolean bad; // True if disabled in the bad process list
+ IBinder forcingToForeground;// Token that is forcing this process to be foreground
+ int adjSeq; // Sequence id for identifying repeated trav
+ ComponentName instrumentationClass;// class installed to instrument app
+ String instrumentationProfileFile; // where to save profiling
+ IInstrumentationWatcher instrumentationWatcher; // who is waiting
+ Bundle instrumentationArguments;// as given to us
+ ComponentName instrumentationResultClass;// copy of instrumentationClass
+ BroadcastRecord curReceiver;// receiver currently running in the app
+ long lastRequestedGc; // When we last asked the app to do a gc
+ int lastPss; // Last pss size reported by app.
+
+ // contains HistoryRecord objects
+ final ArrayList activities = new ArrayList();
+ // all ServiceRecord running in this process
+ final HashSet services = new HashSet();
+ // services that are currently executing code (need to remain foreground).
+ final HashSet<ServiceRecord> executingServices
+ = new HashSet<ServiceRecord>();
+ // All ConnectionRecord this process holds
+ final HashSet<ConnectionRecord> connections
+ = new HashSet<ConnectionRecord>();
+ // all IIntentReceivers that are registered from this process.
+ final HashSet<ReceiverList> receivers = new HashSet<ReceiverList>();
+ // class (String) -> ContentProviderRecord
+ final HashMap pubProviders = new HashMap();
+ // All ContentProviderRecord process is using
+ final HashSet conProviders = new HashSet();
+
+ boolean persistent; // always keep this application running?
+ boolean crashing; // are we in the process of crashing?
+ Dialog crashDialog; // dialog being displayed due to crash.
+ boolean notResponding; // does the app have a not responding dialog?
+ Dialog anrDialog; // dialog being displayed due to app not resp.
+ boolean removed; // has app package been removed from device?
+ boolean debugging; // was app launched for debugging?
+ int persistentActivities; // number of activities that are persistent
+ boolean waitedForDebugger; // has process show wait for debugger dialog?
+ Dialog waitDialog; // current wait for debugger dialog
+
+ // These reports are generated & stored when an app gets into an error condition.
+ // They will be "null" when all is OK.
+ ActivityManager.ProcessErrorStateInfo crashingReport;
+ ActivityManager.ProcessErrorStateInfo notRespondingReport;
+
+ void dump(PrintWriter pw, String prefix) {
+ pw.println(prefix + this);
+ pw.println(prefix + "class=" + info.className);
+ pw.println(prefix+"manageSpaceActivityName="+info.manageSpaceActivityName);
+ pw.println(prefix + "dir=" + info.sourceDir + " publicDir=" + info.publicSourceDir
+ + " data=" + info.dataDir);
+ pw.println(prefix + "packageList=" + pkgList);
+ pw.println(prefix + "instrumentationClass=" + instrumentationClass
+ + " instrumentationProfileFile=" + instrumentationProfileFile);
+ pw.println(prefix + "instrumentationArguments=" + instrumentationArguments);
+ pw.println(prefix + "thread=" + thread + " curReceiver=" + curReceiver);
+ pw.println(prefix + "pid=" + pid + " starting=" + starting
+ + " lastPss=" + lastPss);
+ pw.println(prefix + "maxAdj=" + maxAdj + " hiddenAdj=" + hiddenAdj
+ + " curRawAdj=" + curRawAdj + " setRawAdj=" + setRawAdj
+ + " curAdj=" + curAdj + " setAdj=" + setAdj);
+ pw.println(prefix + "isForeground=" + isForeground
+ + " setIsForeground=" + setIsForeground
+ + " foregroundServices=" + foregroundServices
+ + " forcingToForeground=" + forcingToForeground);
+ pw.println(prefix + "persistent=" + persistent + " removed=" + removed
+ + " persistentActivities=" + persistentActivities);
+ pw.println(prefix + "debugging=" + debugging
+ + " crashing=" + crashing + " " + crashDialog
+ + " notResponding=" + notResponding + " " + anrDialog
+ + " bad=" + bad);
+ pw.println(prefix + "activities=" + activities);
+ pw.println(prefix + "services=" + services);
+ pw.println(prefix + "executingServices=" + executingServices);
+ pw.println(prefix + "connections=" + connections);
+ pw.println(prefix + "pubProviders=" + pubProviders);
+ pw.println(prefix + "conProviders=" + conProviders);
+ pw.println(prefix + "receivers=" + receivers);
+ }
+
+ ProcessRecord(BatteryStatsImpl.Uid.Proc _batteryStats, IApplicationThread _thread,
+ ApplicationInfo _info, String _processName) {
+ batteryStats = _batteryStats;
+ info = _info;
+ processName = _processName;
+ pkgList.add(_info.packageName);
+ thread = _thread;
+ maxAdj = ActivityManagerService.EMPTY_APP_ADJ;
+ hiddenAdj = ActivityManagerService.HIDDEN_APP_MIN_ADJ;
+ curRawAdj = setRawAdj = -100;
+ curAdj = setAdj = -100;
+ persistent = false;
+ removed = false;
+ persistentActivities = 0;
+ }
+
+ /**
+ * This method returns true if any of the activities within the process record are interesting
+ * to the user. See HistoryRecord.isInterestingToUserLocked()
+ */
+ public boolean isInterestingToUserLocked() {
+ final int size = activities.size();
+ for (int i = 0 ; i < size ; i++) {
+ HistoryRecord r = (HistoryRecord) activities.get(i);
+ if (r.isInterestingToUserLocked()) {
+ return true;
+ }
+ }
+ return false;
+ }
+
+ public void stopFreezingAllLocked() {
+ int i = activities.size();
+ while (i > 0) {
+ i--;
+ ((HistoryRecord)activities.get(i)).stopFreezingScreenLocked(true);
+ }
+ }
+
+ public void requestPss() {
+ IApplicationThread localThread = thread;
+ if (localThread != null) {
+ try {
+ localThread.requestPss();
+ } catch (RemoteException e) {
+ }
+ }
+ }
+
+ public String toString() {
+ return "ProcessRecord{"
+ + Integer.toHexString(System.identityHashCode(this))
+ + " " + pid + ":" + processName + "/" + info.uid + "}";
+ }
+
+ /*
+ * Return true if package has been added false if not
+ */
+ public boolean addPackage(String pkg) {
+ if (!pkgList.contains(pkg)) {
+ pkgList.add(pkg);
+ return true;
+ }
+ return false;
+ }
+
+ /*
+ * Delete all packages from list except the package indicated in info
+ */
+ public void resetPackageList() {
+ pkgList.clear();
+ pkgList.add(info.packageName);
+ }
+
+ public String[] getPackageList() {
+ int size = pkgList.size();
+ if (size == 0) {
+ return null;
+ }
+ String list[] = new String[size];
+ pkgList.toArray(list);
+ return list;
+ }
+}