resolved conflicts for merge of 694c1d2b to lmp-mr1-dev (9ef94019) · Commits · e / os / android_frameworks_base

core/java/android/app/ActivityManagerInternal.java

+2 −2

Original line number	Diff line number	Diff line
		@@ -23,8 +23,8 @@ package android.app;
		*/
		public abstract class ActivityManagerInternal {
		// Called by the power manager.
		public abstract void goingToSleep();
		public abstract void wakingUp();
		public abstract void onWakefulnessChanged(int wakefulness);

		public abstract int startIsolatedProcess(String entryPoint, String[] mainArgs,
		String processName, String abiOverride, int uid, Runnable crashHandler);
		}

core/java/android/os/PowerManagerInternal.java

+52 −0

Original line number	Diff line number	Diff line
		@@ -24,6 +24,58 @@ import android.view.Display;
		* @hide Only for use within the system server.
		*/
		public abstract class PowerManagerInternal {
		/**
		* Wakefulness: The device is asleep. It can only be awoken by a call to wakeUp().
		* The screen should be off or in the process of being turned off by the display controller.
		* The device typically passes through the dozing state first.
		*/
		public static final int WAKEFULNESS_ASLEEP = 0;

		/**
		* Wakefulness: The device is fully awake. It can be put to sleep by a call to goToSleep().
		* When the user activity timeout expires, the device may start dreaming or go to sleep.
		*/
		public static final int WAKEFULNESS_AWAKE = 1;

		/**
		* Wakefulness: The device is dreaming. It can be awoken by a call to wakeUp(),
		* which ends the dream. The device goes to sleep when goToSleep() is called, when
		* the dream ends or when unplugged.
		* User activity may brighten the screen but does not end the dream.
		*/
		public static final int WAKEFULNESS_DREAMING = 2;

		/**
		* Wakefulness: The device is dozing. It is almost asleep but is allowing a special
		* low-power "doze" dream to run which keeps the display on but lets the application
		* processor be suspended. It can be awoken by a call to wakeUp() which ends the dream.
		* The device fully goes to sleep if the dream cannot be started or ends on its own.
		*/
		public static final int WAKEFULNESS_DOZING = 3;

		public static String wakefulnessToString(int wakefulness) {
		switch (wakefulness) {
		case WAKEFULNESS_ASLEEP:
		return "Asleep";
		case WAKEFULNESS_AWAKE:
		return "Awake";
		case WAKEFULNESS_DREAMING:
		return "Dreaming";
		case WAKEFULNESS_DOZING:
		return "Dozing";
		default:
		return Integer.toString(wakefulness);
		}
		}

		/**
		* Returns true if the wakefulness state represents an interactive state
		* as defined by {@link android.os.PowerManager#isInteractive}.
		*/
		public static boolean isInteractive(int wakefulness) {
		return wakefulness == WAKEFULNESS_AWAKE \|\| wakefulness == WAKEFULNESS_DREAMING;
		}

		/**
		* Used by the window manager to override the screen brightness based on the
		* current foreground activity.

services/core/java/com/android/server/am/ActivityManagerService.java

+55 −52

Original line number	Diff line number	Diff line
		@@ -173,6 +173,7 @@ import android.os.Looper;
		import android.os.Message;
		import android.os.Parcel;
		import android.os.ParcelFileDescriptor;
		import android.os.PowerManagerInternal;
		import android.os.Process;
		import android.os.RemoteCallbackList;
		import android.os.RemoteException;
		@@ -958,9 +959,9 @@ public final class ActivityManagerService extends ActivityManagerNative
		private boolean mRunningVoice = false;

		/**
		* State of external calls telling us if the device is asleep.
		* State of external calls telling us if the device is awake or asleep.
		*/
		private boolean mWentToSleep = false;
		private int mWakefulness = PowerManagerInternal.WAKEFULNESS_AWAKE;

		static final int LOCK_SCREEN_HIDDEN = 0;
		static final int LOCK_SCREEN_LEAVING = 1;
		@@ -6061,6 +6062,7 @@ public final class ActivityManagerService extends ActivityManagerNative
		mWindowManager.keyguardWaitingForActivityDrawn();
		if (mLockScreenShown == LOCK_SCREEN_SHOWN) {
		mLockScreenShown = LOCK_SCREEN_LEAVING;
		updateSleepIfNeededLocked();
		}
		}
		} finally {
		@@ -9925,23 +9927,25 @@ public final class ActivityManagerService extends ActivityManagerNative
		return mSleeping;
		}

		void goingToSleep() {
		void onWakefulnessChanged(int wakefulness) {
		synchronized(this) {
		mWentToSleep = true;
		goToSleepIfNeededLocked();
		mWakefulness = wakefulness;
		updateSleepIfNeededLocked();
		}
		}

		void finishRunningVoiceLocked() {
		if (mRunningVoice) {
		mRunningVoice = false;
		goToSleepIfNeededLocked();
		updateSleepIfNeededLocked();
		}
		}

		void goToSleepIfNeededLocked() {
		if (mWentToSleep && !mRunningVoice) {
		if (!mSleeping) {
		void updateSleepIfNeededLocked() {
		if (mSleeping && !shouldSleepLocked()) {
		mSleeping = false;
		mStackSupervisor.comeOutOfSleepIfNeededLocked();
		} else if (!mSleeping && shouldSleepLocked()) {
		mSleeping = true;
		mStackSupervisor.goingToSleepLocked();

		@@ -9952,6 +9956,27 @@ public final class ActivityManagerService extends ActivityManagerNative
		mHandler.sendMessageDelayed(nmsg, POWER_CHECK_DELAY);
		}
		}

		private boolean shouldSleepLocked() {
		// Resume applications while running a voice interactor.
		if (mRunningVoice) {
		return false;
		}

		switch (mWakefulness) {
		case PowerManagerInternal.WAKEFULNESS_AWAKE:
		case PowerManagerInternal.WAKEFULNESS_DREAMING:
		// If we're interactive but applications are already paused then defer
		// resuming them until the lock screen is hidden.
		return mSleeping && mLockScreenShown != LOCK_SCREEN_HIDDEN;
		case PowerManagerInternal.WAKEFULNESS_DOZING:
		// If we're dozing then pause applications whenever the lock screen is shown.
		return mLockScreenShown != LOCK_SCREEN_HIDDEN;
		case PowerManagerInternal.WAKEFULNESS_ASLEEP:
		default:
		// If we're asleep then pause applications unconditionally.
		return true;
		}
		}

		void notifyTaskPersisterLocked(TaskRecord task, boolean flush) {
		@@ -10016,31 +10041,16 @@ public final class ActivityManagerService extends ActivityManagerNative
		}

		void logLockScreen(String msg) {
		if (DEBUG_LOCKSCREEN) Slog.d(TAG, Debug.getCallers(2) + ":" + msg +
		" mLockScreenShown=" + lockScreenShownToString() + " mWentToSleep=" +
		mWentToSleep + " mSleeping=" + mSleeping);
		}

		void comeOutOfSleepIfNeededLocked() {
		if ((!mWentToSleep && mLockScreenShown == LOCK_SCREEN_HIDDEN) \|\| mRunningVoice) {
		if (mSleeping) {
		mSleeping = false;
		mStackSupervisor.comeOutOfSleepIfNeededLocked();
		}
		}
		}

		void wakingUp() {
		synchronized(this) {
		mWentToSleep = false;
		comeOutOfSleepIfNeededLocked();
		}
		if (DEBUG_LOCKSCREEN) Slog.d(TAG, Debug.getCallers(2) + ":" + msg
		+ " mLockScreenShown=" + lockScreenShownToString() + " mWakefulness="
		+ PowerManagerInternal.wakefulnessToString(mWakefulness)
		+ " mSleeping=" + mSleeping);
		}

		void startRunningVoiceLocked() {
		if (!mRunningVoice) {
		mRunningVoice = true;
		comeOutOfSleepIfNeededLocked();
		updateSleepIfNeededLocked();
		}
		}

		@@ -10060,7 +10070,7 @@ public final class ActivityManagerService extends ActivityManagerNative
		try {
		if (DEBUG_LOCKSCREEN) logLockScreen(" shown=" + shown);
		mLockScreenShown = shown ? LOCK_SCREEN_SHOWN : LOCK_SCREEN_HIDDEN;
		comeOutOfSleepIfNeededLocked();
		updateSleepIfNeededLocked();
		} finally {
		Binder.restoreCallingIdentity(ident);
		}
		@@ -12830,14 +12840,12 @@ public final class ActivityManagerService extends ActivityManagerNative
		}
		}
		if (dumpPackage == null) {
		if (mSleeping \|\| mWentToSleep \|\| mLockScreenShown != LOCK_SCREEN_HIDDEN) {
		pw.println(" mSleeping=" + mSleeping + " mWentToSleep=" + mWentToSleep
		+ " mLockScreenShown " + lockScreenShownToString());
		}
		if (mShuttingDown \|\| mRunningVoice) {
		pw.println(" mWakefulness="
		+ PowerManagerInternal.wakefulnessToString(mWakefulness));
		pw.println(" mSleeping=" + mSleeping + " mLockScreenShown="
		+ lockScreenShownToString());
		pw.print(" mShuttingDown=" + mShuttingDown + " mRunningVoice=" + mRunningVoice);
		}
		}
		if (mDebugApp != null \|\| mOrigDebugApp != null \|\| mDebugTransient
		\|\| mOrigWaitForDebugger) {
		if (dumpPackage == null \|\| dumpPackage.equals(mDebugApp)
		@@ -19204,13 +19212,8 @@ public final class ActivityManagerService extends ActivityManagerNative

		private final class LocalService extends ActivityManagerInternal {
		@Override
		public void goingToSleep() {
		ActivityManagerService.this.goingToSleep();
		}

		@Override
		public void wakingUp() {
		ActivityManagerService.this.wakingUp();
		public void onWakefulnessChanged(int wakefulness) {
		ActivityManagerService.this.onWakefulnessChanged(wakefulness);
		}

		@Override

services/core/java/com/android/server/am/ActivityStack.java

+1 −1

Original line number	Diff line number	Diff line
		@@ -1477,7 +1477,7 @@ final class ActivityStack {
		mStackSupervisor.inResumeTopActivity = true;
		if (mService.mLockScreenShown == ActivityManagerService.LOCK_SCREEN_LEAVING) {
		mService.mLockScreenShown = ActivityManagerService.LOCK_SCREEN_HIDDEN;
		mService.comeOutOfSleepIfNeededLocked();
		mService.updateSleepIfNeededLocked();
		}
		result = resumeTopActivityInnerLocked(prev, options);
		} finally {

services/core/java/com/android/server/power/Notifier.java

+77 −55

Original line number	Diff line number	Diff line
		@@ -38,6 +38,7 @@ import android.os.Handler;
		import android.os.Looper;
		import android.os.Message;
		import android.os.PowerManager;
		import android.os.PowerManagerInternal;
		import android.os.Process;
		import android.os.RemoteException;
		import android.os.SystemClock;
		@@ -70,9 +71,9 @@ final class Notifier {

		private static final boolean DEBUG = false;

		private static final int POWER_STATE_UNKNOWN = 0;
		private static final int POWER_STATE_AWAKE = 1;
		private static final int POWER_STATE_ASLEEP = 2;
		private static final int INTERACTIVE_STATE_UNKNOWN = 0;
		private static final int INTERACTIVE_STATE_AWAKE = 1;
		private static final int INTERACTIVE_STATE_ASLEEP = 2;

		private static final int MSG_USER_ACTIVITY = 1;
		private static final int MSG_BROADCAST = 2;
		@@ -92,17 +93,17 @@ final class Notifier {
		private final Intent mScreenOnIntent;
		private final Intent mScreenOffIntent;

		// The current power state.
		private int mActualPowerState;
		private int mLastGoToSleepReason;
		// The current interactive state.
		private int mActualInteractiveState;
		private int mLastReason;

		// True if there is a pending transition that needs to be reported.
		private boolean mPendingWakeUpBroadcast;
		private boolean mPendingGoToSleepBroadcast;

		// The currently broadcasted power state. This reflects what other parts of the
		// The currently broadcasted interactive state. This reflects what other parts of the
		// system have observed.
		private int mBroadcastedPowerState;
		private int mBroadcastedInteractiveState;
		private boolean mBroadcastInProgress;
		private long mBroadcastStartTime;

		@@ -236,62 +237,83 @@ final class Notifier {
		}

		/**
		* Notifies that the device is changing interactive state.
		* Notifies that the device is changing wakefulness.
		*/
		public void onInteractiveStateChangeStarted(boolean interactive, final int reason) {
		public void onWakefulnessChangeStarted(int wakefulness, int reason) {
		if (DEBUG) {
		Slog.d(TAG, "onInteractiveChangeStarted: interactive=" + interactive
		Slog.d(TAG, "onWakefulnessChangeStarted: wakefulness=" + wakefulness
		+ ", reason=" + reason);
		}

		// We handle interactive state changes once they start so that the system can
		// set everything up or the user to begin interacting with applications.
		final boolean interactive = PowerManagerInternal.isInteractive(wakefulness);
		if (interactive) {
		handleWakefulnessChange(wakefulness, interactive, reason);
		} else {
		mLastReason = reason;
		}

		// Start input as soon as we start waking up or going to sleep.
		mInputManagerInternal.setInteractive(interactive);
		}

		/**
		* Notifies that the device has finished changing wakefulness.
		*/
		public void onWakefulnessChangeFinished(int wakefulness) {
		if (DEBUG) {
		Slog.d(TAG, "onWakefulnessChangeFinished: wakefulness=" + wakefulness);
		}

		// Handle interactive state changes once they are finished so that the system can
		// finish pending transitions (such as turning the screen off) before causing
		// applications to change state visibly.
		final boolean interactive = PowerManagerInternal.isInteractive(wakefulness);
		if (!interactive) {
		handleWakefulnessChange(wakefulness, interactive, mLastReason);
		}
		}

		private void handleWakefulnessChange(final int wakefulness, boolean interactive,
		final int reason) {
		// Tell the activity manager about changes in wakefulness, not just interactivity.
		// It needs more granularity than other components.
		mHandler.post(new Runnable() {
		@Override
		public void run() {
		mActivityManagerInternal.onWakefulnessChanged(wakefulness);
		}
		});

		// Handle changes in the overall interactive state.
		boolean interactiveChanged = false;
		synchronized (mLock) {
		// Broadcast interactive state changes.
		if (interactive) {
		// Waking up...
		if (mActualPowerState != POWER_STATE_AWAKE) {
		mActualPowerState = POWER_STATE_AWAKE;
		interactiveChanged = (mActualInteractiveState != INTERACTIVE_STATE_AWAKE);
		if (interactiveChanged) {
		mActualInteractiveState = INTERACTIVE_STATE_AWAKE;
		mPendingWakeUpBroadcast = true;
		mHandler.post(new Runnable() {
		@Override
		public void run() {
		EventLog.writeEvent(EventLogTags.POWER_SCREEN_STATE, 1, 0, 0, 0);
		mPolicy.wakingUp();
		mActivityManagerInternal.wakingUp();
		}
		});
		updatePendingBroadcastLocked();
		}
		} else {
		// Going to sleep...
		mLastGoToSleepReason = reason;
		}
		}

		mInputManagerInternal.setInteractive(interactive);

		if (interactive) {
		try {
		mBatteryStats.noteInteractive(true);
		} catch (RemoteException ex) { }
		}
		}

		/**
		* Notifies that the device has finished changing interactive state.
		*/
		public void onInteractiveStateChangeFinished(boolean interactive) {
		if (DEBUG) {
		Slog.d(TAG, "onInteractiveChangeFinished");
		}

		synchronized (mLock) {
		if (!interactive) {
		// Finished going to sleep...
		// This is a good time to make transitions that we don't want the user to see,
		// such as bringing the key guard to focus. There's no guarantee for this,
		// however because the user could turn the device on again at any time.
		// Some things may need to be protected by other mechanisms that defer screen on.
		if (mActualPowerState != POWER_STATE_ASLEEP) {
		mActualPowerState = POWER_STATE_ASLEEP;
		interactiveChanged = (mActualInteractiveState != INTERACTIVE_STATE_ASLEEP);
		if (interactiveChanged) {
		mActualInteractiveState = INTERACTIVE_STATE_ASLEEP;
		mPendingGoToSleepBroadcast = true;
		if (mUserActivityPending) {
		mUserActivityPending = false;
		@@ -301,7 +323,7 @@ final class Notifier {
		@Override
		public void run() {
		int why = WindowManagerPolicy.OFF_BECAUSE_OF_USER;
		switch (mLastGoToSleepReason) {
		switch (reason) {
		case PowerManager.GO_TO_SLEEP_REASON_DEVICE_ADMIN:
		why = WindowManagerPolicy.OFF_BECAUSE_OF_ADMIN;
		break;
		@@ -311,7 +333,6 @@ final class Notifier {
		}
		EventLog.writeEvent(EventLogTags.POWER_SCREEN_STATE, 0, why, 0, 0);
		mPolicy.goingToSleep(why);
		mActivityManagerInternal.goingToSleep();
		}
		});
		updatePendingBroadcastLocked();
		@@ -319,9 +340,10 @@ final class Notifier {
		}
		}

		if (!interactive) {
		// Notify battery stats.
		if (interactiveChanged) {
		try {
		mBatteryStats.noteInteractive(false);
		mBatteryStats.noteInteractive(interactive);
		} catch (RemoteException ex) { }
		}
		}
		@@ -366,9 +388,9 @@ final class Notifier {

		private void updatePendingBroadcastLocked() {
		if (!mBroadcastInProgress
		&& mActualPowerState != POWER_STATE_UNKNOWN
		&& mActualInteractiveState != INTERACTIVE_STATE_UNKNOWN
		&& (mPendingWakeUpBroadcast \|\| mPendingGoToSleepBroadcast
		\|\| mActualPowerState != mBroadcastedPowerState)) {
		\|\| mActualInteractiveState != mBroadcastedInteractiveState)) {
		mBroadcastInProgress = true;
		mSuspendBlocker.acquire();
		Message msg = mHandler.obtainMessage(MSG_BROADCAST);
		@@ -396,16 +418,16 @@ final class Notifier {
		private void sendNextBroadcast() {
		final int powerState;
		synchronized (mLock) {
		if (mBroadcastedPowerState == POWER_STATE_UNKNOWN) {
		if (mBroadcastedInteractiveState == INTERACTIVE_STATE_UNKNOWN) {
		// Broadcasted power state is unknown. Send wake up.
		mPendingWakeUpBroadcast = false;
		mBroadcastedPowerState = POWER_STATE_AWAKE;
		} else if (mBroadcastedPowerState == POWER_STATE_AWAKE) {
		mBroadcastedInteractiveState = INTERACTIVE_STATE_AWAKE;
		} else if (mBroadcastedInteractiveState == INTERACTIVE_STATE_AWAKE) {
		// Broadcasted power state is awake. Send asleep if needed.
		if (mPendingWakeUpBroadcast \|\| mPendingGoToSleepBroadcast
		\|\| mActualPowerState == POWER_STATE_ASLEEP) {
		\|\| mActualInteractiveState == INTERACTIVE_STATE_ASLEEP) {
		mPendingGoToSleepBroadcast = false;
		mBroadcastedPowerState = POWER_STATE_ASLEEP;
		mBroadcastedInteractiveState = INTERACTIVE_STATE_ASLEEP;
		} else {
		finishPendingBroadcastLocked();
		return;
		@@ -413,9 +435,9 @@ final class Notifier {
		} else {
		// Broadcasted power state is asleep. Send awake if needed.
		if (mPendingWakeUpBroadcast \|\| mPendingGoToSleepBroadcast
		\|\| mActualPowerState == POWER_STATE_AWAKE) {
		\|\| mActualInteractiveState == INTERACTIVE_STATE_AWAKE) {
		mPendingWakeUpBroadcast = false;
		mBroadcastedPowerState = POWER_STATE_AWAKE;
		mBroadcastedInteractiveState = INTERACTIVE_STATE_AWAKE;
		} else {
		finishPendingBroadcastLocked();
		return;
		@@ -423,12 +445,12 @@ final class Notifier {
		}

		mBroadcastStartTime = SystemClock.uptimeMillis();
		powerState = mBroadcastedPowerState;
		powerState = mBroadcastedInteractiveState;
		}

		EventLog.writeEvent(EventLogTags.POWER_SCREEN_BROADCAST_SEND, 1);

		if (powerState == POWER_STATE_AWAKE) {
		if (powerState == INTERACTIVE_STATE_AWAKE) {
		sendWakeUpBroadcast();
		} else {
		sendGoToSleepBroadcast();