Merge "Make TOP_SLEEPING procstate more like a cached process." (6348ddcd) · Commits · e / os / android_frameworks_base

api/current.txt

+2 −1

Original line number	Diff line number	Diff line
		@@ -3961,7 +3961,8 @@ package android.app {
		field public static final int IMPORTANCE_PERCEPTIBLE = 230; // 0xe6
		field public static final int IMPORTANCE_PERCEPTIBLE_PRE_26 = 130; // 0x82
		field public static final int IMPORTANCE_SERVICE = 300; // 0x12c
		field public static final int IMPORTANCE_TOP_SLEEPING = 150; // 0x96
		field public static final int IMPORTANCE_TOP_SLEEPING = 325; // 0x145
		field public static final deprecated int IMPORTANCE_TOP_SLEEPING_PRE_28 = 150; // 0x96
		field public static final int IMPORTANCE_VISIBLE = 200; // 0xc8
		field public static final int REASON_PROVIDER_IN_USE = 1; // 0x1
		field public static final int REASON_SERVICE_IN_USE = 2; // 0x2

core/java/android/app/ActivityManager.java

+40 −26

Original line number	Diff line number	Diff line
		@@ -458,16 +458,17 @@ public class ActivityManager {
		public static final int USER_OP_ERROR_RELATED_USERS_CANNOT_STOP = -4;

		/**
		* @hide
		* Process states, describing the kind of state a particular process is in.
		* When updating these, make sure to also check all related references to the
		* constant in code, and update these arrays:
		*
		* com.android.internal.app.procstats.ProcessState#PROCESS_STATE_TO_STATE
		* com.android.server.am.ProcessList#sProcStateToProcMem
		* com.android.server.am.ProcessList#sFirstAwakePssTimes
		* com.android.server.am.ProcessList#sSameAwakePssTimes
		* com.android.server.am.ProcessList#sTestFirstPssTimes
		* com.android.server.am.ProcessList#sTestSamePssTimes
		* @see com.android.internal.app.procstats.ProcessState#PROCESS_STATE_TO_STATE
		* @see com.android.server.am.ProcessList#sProcStateToProcMem
		* @see com.android.server.am.ProcessList#sFirstAwakePssTimes
		* @see com.android.server.am.ProcessList#sSameAwakePssTimes
		* @see com.android.server.am.ProcessList#sTestFirstPssTimes
		* @see com.android.server.am.ProcessList#sTestSamePssTimes
		*/

		/** @hide Not a real process state. */
		@@ -489,31 +490,31 @@ public class ActivityManager {
		/** @hide Process is hosting a foreground service. */
		public static final int PROCESS_STATE_FOREGROUND_SERVICE = 4;

		/** @hide Same as {@link #PROCESS_STATE_TOP} but while device is sleeping. */
		public static final int PROCESS_STATE_TOP_SLEEPING = 5;

		/** @hide Process is important to the user, and something they are aware of. */
		public static final int PROCESS_STATE_IMPORTANT_FOREGROUND = 6;
		public static final int PROCESS_STATE_IMPORTANT_FOREGROUND = 5;

		/** @hide Process is important to the user, but not something they are aware of. */
		public static final int PROCESS_STATE_IMPORTANT_BACKGROUND = 7;
		public static final int PROCESS_STATE_IMPORTANT_BACKGROUND = 6;

		/** @hide Process is in the background transient so we will try to keep running. */
		public static final int PROCESS_STATE_TRANSIENT_BACKGROUND = 8;
		public static final int PROCESS_STATE_TRANSIENT_BACKGROUND = 7;

		/** @hide Process is in the background running a backup/restore operation. */
		public static final int PROCESS_STATE_BACKUP = 9;
		public static final int PROCESS_STATE_BACKUP = 8;

		/** @hide Process is in the background running a service. Unlike oom_adj, this level
		* is used for both the normal running in background state and the executing
		* operations state. */
		public static final int PROCESS_STATE_SERVICE = 10;
		public static final int PROCESS_STATE_SERVICE = 9;

		/** @hide Process is in the background running a receiver. Note that from the
		* perspective of oom_adj, receivers run at a higher foreground level, but for our
		* prioritization here that is not necessary and putting them below services means
		* many fewer changes in some process states as they receive broadcasts. */
		public static final int PROCESS_STATE_RECEIVER = 11;
		public static final int PROCESS_STATE_RECEIVER = 10;

		/** @hide Same as {@link #PROCESS_STATE_TOP} but while device is sleeping. */
		public static final int PROCESS_STATE_TOP_SLEEPING = 11;

		/** @hide Process is in the background, but it can't restore its state so we want
		* to try to avoid killing it. */
		@@ -2897,13 +2898,13 @@ public class ActivityManager {
		public static final int IMPORTANCE_FOREGROUND_SERVICE = 125;

		/**
		* Constant for {@link #importance}: This process is running the foreground
		* UI, but the device is asleep so it is not visible to the user. This means
		* the user is not really aware of the process, because they can not see or
		* interact with it, but it is quite important because it what they expect to
		* return to once unlocking the device.
		* @deprecated Pre-{@link android.os.Build.VERSION_CODES#P} version of
		* {@link #IMPORTANCE_TOP_SLEEPING}. As of Android
		* {@link android.os.Build.VERSION_CODES#P}, this is considered much less
		* important since we want to reduce what apps can do when the screen is off.
		*/
		public static final int IMPORTANCE_TOP_SLEEPING = 150;
		@Deprecated
		public static final int IMPORTANCE_TOP_SLEEPING_PRE_28 = 150;

		/**
		* Constant for {@link #importance}: This process is running something
		@@ -2963,6 +2964,15 @@ public class ActivityManager {
		*/
		public static final int IMPORTANCE_SERVICE = 300;

		/**
		* Constant for {@link #importance}: This process is running the foreground
		* UI, but the device is asleep so it is not visible to the user. Though the
		* system will try hard to keep its process from being killed, in all other
		* ways we consider it a kind of cached process, with the limitations that go
		* along with that state: network access, running background services, etc.
		*/
		public static final int IMPORTANCE_TOP_SLEEPING = 325;

		/**
		* Constant for {@link #importance}: This process is running an
		* application that can not save its state, and thus can't be killed
		@@ -3008,14 +3018,14 @@ public class ActivityManager {
		return IMPORTANCE_CACHED;
		} else if (procState == PROCESS_STATE_HEAVY_WEIGHT) {
		return IMPORTANCE_CANT_SAVE_STATE;
		} else if (procState >= PROCESS_STATE_TOP_SLEEPING) {
		return IMPORTANCE_TOP_SLEEPING;
		} else if (procState >= PROCESS_STATE_SERVICE) {
		return IMPORTANCE_SERVICE;
		} else if (procState >= PROCESS_STATE_TRANSIENT_BACKGROUND) {
		return IMPORTANCE_PERCEPTIBLE;
		} else if (procState >= PROCESS_STATE_IMPORTANT_FOREGROUND) {
		return IMPORTANCE_VISIBLE;
		} else if (procState >= PROCESS_STATE_TOP_SLEEPING) {
		return IMPORTANCE_TOP_SLEEPING;
		} else if (procState >= PROCESS_STATE_FOREGROUND_SERVICE) {
		return IMPORTANCE_FOREGROUND_SERVICE;
		} else {
		@@ -3049,6 +3059,8 @@ public class ActivityManager {
		switch (importance) {
		case IMPORTANCE_PERCEPTIBLE:
		return IMPORTANCE_PERCEPTIBLE_PRE_26;
		case IMPORTANCE_TOP_SLEEPING:
		return IMPORTANCE_TOP_SLEEPING_PRE_28;
		case IMPORTANCE_CANT_SAVE_STATE:
		return IMPORTANCE_CANT_SAVE_STATE_PRE_26;
		}
		@@ -3062,16 +3074,18 @@ public class ActivityManager {
		return PROCESS_STATE_NONEXISTENT;
		} else if (importance >= IMPORTANCE_CACHED) {
		return PROCESS_STATE_HOME;
		} else if (importance == IMPORTANCE_CANT_SAVE_STATE) {
		} else if (importance >= IMPORTANCE_CANT_SAVE_STATE) {
		return PROCESS_STATE_HEAVY_WEIGHT;
		} else if (importance >= IMPORTANCE_TOP_SLEEPING) {
		return PROCESS_STATE_TOP_SLEEPING;
		} else if (importance >= IMPORTANCE_SERVICE) {
		return PROCESS_STATE_SERVICE;
		} else if (importance >= IMPORTANCE_PERCEPTIBLE) {
		return PROCESS_STATE_TRANSIENT_BACKGROUND;
		} else if (importance >= IMPORTANCE_VISIBLE) {
		return PROCESS_STATE_IMPORTANT_FOREGROUND;
		} else if (importance >= IMPORTANCE_TOP_SLEEPING) {
		return PROCESS_STATE_TOP_SLEEPING;
		} else if (importance >= IMPORTANCE_TOP_SLEEPING_PRE_28) {
		return PROCESS_STATE_FOREGROUND_SERVICE;
		} else if (importance >= IMPORTANCE_FOREGROUND_SERVICE) {
		return PROCESS_STATE_FOREGROUND_SERVICE;
		} else {

core/java/android/os/BatteryStats.java

+18 −10

Original line number	Diff line number	Diff line
		@@ -657,33 +657,41 @@ public abstract class BatteryStats implements Parcelable {
		* none in the "top" state.
		*/
		public static final int PROCESS_STATE_FOREGROUND_SERVICE = 1;
		/**
		* Time this uid has any process that is top while the device is sleeping, but none
		* in the "foreground service" or better state.
		*/
		public static final int PROCESS_STATE_TOP_SLEEPING = 2;
		/**
		* Time this uid has any process in an active foreground state, but none in the
		* "top sleeping" or better state.
		*/
		public static final int PROCESS_STATE_FOREGROUND = 3;
		public static final int PROCESS_STATE_FOREGROUND = 2;
		/**
		* Time this uid has any process in an active background state, but none in the
		* "foreground" or better state.
		*/
		public static final int PROCESS_STATE_BACKGROUND = 4;
		public static final int PROCESS_STATE_BACKGROUND = 3;
		/**
		* Time this uid has any process that is top while the device is sleeping, but not
		* active for any other reason. We kind-of consider it a kind of cached process
		* for execution restrictions.
		*/
		public static final int PROCESS_STATE_TOP_SLEEPING = 4;
		/**
		* Time this uid has any process that is in the background but it has an activity
		* marked as "can't save state". This is essentially a cached process, though the
		* system will try much harder than normal to avoid killing it.
		*/
		public static final int PROCESS_STATE_HEAVY_WEIGHT = 5;
		/**
		* Time this uid has any processes that are sitting around cached, not in one of the
		* other active states.
		*/
		public static final int PROCESS_STATE_CACHED = 5;
		public static final int PROCESS_STATE_CACHED = 6;
		/**
		* Total number of process states we track.
		*/
		public static final int NUM_PROCESS_STATE = 6;
		public static final int NUM_PROCESS_STATE = 7;

		static final String[] PROCESS_STATE_NAMES = {
		"Top", "Fg Service", "Top Sleeping", "Foreground", "Background", "Cached"
		"Top", "Fg Service", "Foreground", "Background", "Top Sleeping", "Heavy Weight",
		"Cached"
		};

		public abstract long getProcessStateTime(int state, long elapsedRealtimeUs, int which);

core/java/com/android/internal/app/procstats/ProcessState.java

+1 −1

Original line number	Diff line number	Diff line
		@@ -91,13 +91,13 @@ public final class ProcessState {
		STATE_TOP, // ActivityManager.PROCESS_STATE_TOP
		STATE_IMPORTANT_FOREGROUND, // ActivityManager.PROCESS_STATE_BOUND_FOREGROUND_SERVICE
		STATE_IMPORTANT_FOREGROUND, // ActivityManager.PROCESS_STATE_FOREGROUND_SERVICE
		STATE_TOP, // ActivityManager.PROCESS_STATE_TOP_SLEEPING
		STATE_IMPORTANT_FOREGROUND, // ActivityManager.PROCESS_STATE_IMPORTANT_FOREGROUND
		STATE_IMPORTANT_BACKGROUND, // ActivityManager.PROCESS_STATE_IMPORTANT_BACKGROUND
		STATE_IMPORTANT_BACKGROUND, // ActivityManager.PROCESS_STATE_TRANSIENT_BACKGROUND
		STATE_BACKUP, // ActivityManager.PROCESS_STATE_BACKUP
		STATE_SERVICE, // ActivityManager.PROCESS_STATE_SERVICE
		STATE_RECEIVER, // ActivityManager.PROCESS_STATE_RECEIVER
		STATE_TOP, // ActivityManager.PROCESS_STATE_TOP_SLEEPING
		STATE_HEAVY_WEIGHT, // ActivityManager.PROCESS_STATE_HEAVY_WEIGHT
		STATE_HOME, // ActivityManager.PROCESS_STATE_HOME
		STATE_LAST_ACTIVITY, // ActivityManager.PROCESS_STATE_LAST_ACTIVITY

core/java/com/android/internal/os/BatteryStatsImpl.java

+5 −3

Original line number	Diff line number	Diff line
		@@ -120,7 +120,7 @@ public class BatteryStatsImpl extends BatteryStats {
		private static final int MAGIC = 0xBA757475; // 'BATSTATS'

		// Current on-disk Parcel version
		private static final int VERSION = 170 + (USE_OLD_HISTORY ? 1000 : 0);
		private static final int VERSION = 171 + (USE_OLD_HISTORY ? 1000 : 0);

		// Maximum number of items we will record in the history.
		private static final int MAX_HISTORY_ITEMS;
		@@ -8678,13 +8678,15 @@ public class BatteryStatsImpl extends BatteryStats {
		} else if (procState <= ActivityManager.PROCESS_STATE_FOREGROUND_SERVICE) {
		// Persistent and other foreground states go here.
		uidRunningState = PROCESS_STATE_FOREGROUND_SERVICE;
		} else if (procState <= ActivityManager.PROCESS_STATE_TOP_SLEEPING) {
		uidRunningState = PROCESS_STATE_TOP_SLEEPING;
		} else if (procState <= ActivityManager.PROCESS_STATE_IMPORTANT_FOREGROUND) {
		// Persistent and other foreground states go here.
		uidRunningState = PROCESS_STATE_FOREGROUND;
		} else if (procState <= ActivityManager.PROCESS_STATE_RECEIVER) {
		uidRunningState = PROCESS_STATE_BACKGROUND;
		} else if (procState <= ActivityManager.PROCESS_STATE_TOP_SLEEPING) {
		uidRunningState = PROCESS_STATE_TOP_SLEEPING;
		} else if (procState <= ActivityManager.PROCESS_STATE_HEAVY_WEIGHT) {
		uidRunningState = PROCESS_STATE_HEAVY_WEIGHT;
		} else {
		uidRunningState = PROCESS_STATE_CACHED;
		}