Merge sleeping activities with visibility updates
Previously we were using a separate SLEEP message to communicate
with the client. The sleeping implementation on the client though
simply transitioned it between STARTED and STOPPED states.
This CL relies on visibility updates to communicate the sleeping
state. The "sleeping" status field is still used in the server-side
to record when device started going to sleep, and prevents any
activity that was launched before to influence the power state of
the device.
Bug: 137329632
Test: AM/WM CTS and unit tests
Change-Id: Idd7f5bf6730d3372168d862ef713a44f700430f1
diff --git a/config/boot-image-profile.txt b/config/boot-image-profile.txt
index 4aaf727..e649c30 100644
--- a/config/boot-image-profile.txt
+++ b/config/boot-image-profile.txt
@@ -1515,7 +1515,6 @@
HSPLandroid/app/IActivityTaskManager$Stub$Proxy;->activityIdle(Landroid/os/IBinder;Landroid/content/res/Configuration;Z)V
HSPLandroid/app/IActivityTaskManager$Stub$Proxy;->activityPaused(Landroid/os/IBinder;)V
HSPLandroid/app/IActivityTaskManager$Stub$Proxy;->activityResumed(Landroid/os/IBinder;)V
-HSPLandroid/app/IActivityTaskManager$Stub$Proxy;->activitySlept(Landroid/os/IBinder;)V
HSPLandroid/app/IActivityTaskManager$Stub$Proxy;->activityStopped(Landroid/os/IBinder;Landroid/os/Bundle;Landroid/os/PersistableBundle;Ljava/lang/CharSequence;)V
HSPLandroid/app/IActivityTaskManager$Stub$Proxy;->activityTopResumedStateLost()V
HSPLandroid/app/IActivityTaskManager$Stub$Proxy;->finishActivity(Landroid/os/IBinder;ILandroid/content/Intent;I)Z
diff --git a/core/java/android/app/ActivityThread.java b/core/java/android/app/ActivityThread.java
index 2ca5b1d..c52bdc0 100644
--- a/core/java/android/app/ActivityThread.java
+++ b/core/java/android/app/ActivityThread.java
@@ -924,10 +924,6 @@
private class ApplicationThread extends IApplicationThread.Stub {
private static final String DB_INFO_FORMAT = " %8s %8s %14s %14s %s";
- public final void scheduleSleeping(IBinder token, boolean sleeping) {
- sendMessage(H.SLEEPING, token, sleeping ? 1 : 0);
- }
-
public final void scheduleReceiver(Intent intent, ActivityInfo info,
CompatibilityInfo compatInfo, int resultCode, String data, Bundle extras,
boolean sync, int sendingUser, int processState) {
@@ -1855,7 +1851,6 @@
case SCHEDULE_CRASH: return "SCHEDULE_CRASH";
case DUMP_HEAP: return "DUMP_HEAP";
case DUMP_ACTIVITY: return "DUMP_ACTIVITY";
- case SLEEPING: return "SLEEPING";
case SET_CORE_SETTINGS: return "SET_CORE_SETTINGS";
case UPDATE_PACKAGE_COMPATIBILITY_INFO: return "UPDATE_PACKAGE_COMPATIBILITY_INFO";
case DUMP_PROVIDER: return "DUMP_PROVIDER";
@@ -1985,11 +1980,6 @@
case DUMP_PROVIDER:
handleDumpProvider((DumpComponentInfo)msg.obj);
break;
- case SLEEPING:
- Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "sleeping");
- handleSleeping((IBinder)msg.obj, msg.arg1 != 0);
- Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
- break;
case SET_CORE_SETTINGS:
Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "setCoreSettings");
handleSetCoreSettings((Bundle) msg.obj);
@@ -4855,41 +4845,6 @@
}
}
- // TODO: This method should be changed to use {@link #performStopActivityInner} to perform to
- // stop operation on the activity to reduce code duplication and the chance of fixing a bug in
- // one place and missing the other.
- private void handleSleeping(IBinder token, boolean sleeping) {
- ActivityClientRecord r = mActivities.get(token);
-
- if (r == null) {
- Log.w(TAG, "handleSleeping: no activity for token " + token);
- return;
- }
-
- if (sleeping) {
- if (!r.stopped && !r.isPreHoneycomb()) {
- callActivityOnStop(r, true /* saveState */, "sleeping");
- }
-
- // Make sure any pending writes are now committed.
- if (!r.isPreHoneycomb()) {
- QueuedWork.waitToFinish();
- }
-
- // Tell activity manager we slept.
- try {
- ActivityTaskManager.getService().activitySlept(r.token);
- } catch (RemoteException ex) {
- throw ex.rethrowFromSystemServer();
- }
- } else {
- if (r.stopped && r.activity.mVisibleFromServer) {
- r.activity.performRestart(true /* start */, "handleSleeping");
- r.setState(ON_START);
- }
- }
- }
-
private void handleSetCoreSettings(Bundle coreSettings) {
synchronized (mResourcesManager) {
mCoreSettings = coreSettings;
diff --git a/core/java/android/app/IActivityTaskManager.aidl b/core/java/android/app/IActivityTaskManager.aidl
index e5c046c..85fa7c1 100644
--- a/core/java/android/app/IActivityTaskManager.aidl
+++ b/core/java/android/app/IActivityTaskManager.aidl
@@ -141,7 +141,6 @@
in PersistableBundle persistentState, in CharSequence description);
oneway void activityDestroyed(in IBinder token);
void activityRelaunched(in IBinder token);
- oneway void activitySlept(in IBinder token);
int getFrontActivityScreenCompatMode();
void setFrontActivityScreenCompatMode(int mode);
String getCallingPackage(in IBinder token);
diff --git a/core/java/android/app/IApplicationThread.aidl b/core/java/android/app/IApplicationThread.aidl
index 51a64ff..c33c515 100644
--- a/core/java/android/app/IApplicationThread.aidl
+++ b/core/java/android/app/IApplicationThread.aidl
@@ -91,7 +91,6 @@
int resultCode, in String data, in Bundle extras, boolean ordered,
boolean sticky, int sendingUser, int processState);
void scheduleLowMemory();
- void scheduleSleeping(IBinder token, boolean sleeping);
void profilerControl(boolean start, in ProfilerInfo profilerInfo, int profileType);
void setSchedulingGroup(int group);
void scheduleCreateBackupAgent(in ApplicationInfo app, in CompatibilityInfo compatInfo,
diff --git a/core/tests/coretests/src/android/app/activity/ActivityThreadTest.java b/core/tests/coretests/src/android/app/activity/ActivityThreadTest.java
index d8b527c..c986db8 100644
--- a/core/tests/coretests/src/android/app/activity/ActivityThreadTest.java
+++ b/core/tests/coretests/src/android/app/activity/ActivityThreadTest.java
@@ -96,16 +96,6 @@
InstrumentationRegistry.getInstrumentation().waitForIdleSync();
}
- @Test
- public void testSleepAndStop() throws Exception {
- final Activity activity = mActivityTestRule.launchActivity(new Intent());
- final IApplicationThread appThread = activity.getActivityThread().getApplicationThread();
-
- appThread.scheduleSleeping(activity.getActivityToken(), true /* sleeping */);
- appThread.scheduleTransaction(newStopTransaction(activity));
- InstrumentationRegistry.getInstrumentation().waitForIdleSync();
- }
-
/** Verify that repeated resume requests to activity will be ignored. */
@Test
public void testRepeatedResume() throws Exception {
diff --git a/core/tests/coretests/src/android/app/servertransaction/TransactionParcelTests.java b/core/tests/coretests/src/android/app/servertransaction/TransactionParcelTests.java
index ecea901..372b8c2 100644
--- a/core/tests/coretests/src/android/app/servertransaction/TransactionParcelTests.java
+++ b/core/tests/coretests/src/android/app/servertransaction/TransactionParcelTests.java
@@ -448,10 +448,6 @@
}
@Override
- public void scheduleSleeping(IBinder iBinder, boolean b) throws RemoteException {
- }
-
- @Override
public void profilerControl(boolean b, ProfilerInfo profilerInfo, int i)
throws RemoteException {
}
diff --git a/services/core/java/com/android/server/wm/ActivityRecord.java b/services/core/java/com/android/server/wm/ActivityRecord.java
index d1c8448..6fd0235 100644
--- a/services/core/java/com/android/server/wm/ActivityRecord.java
+++ b/services/core/java/com/android/server/wm/ActivityRecord.java
@@ -94,7 +94,6 @@
import static android.os.Process.SYSTEM_UID;
import static android.os.Trace.TRACE_TAG_WINDOW_MANAGER;
import static android.view.Display.COLOR_MODE_DEFAULT;
-import static android.view.Display.DEFAULT_DISPLAY;
import static android.view.Display.INVALID_DISPLAY;
import static android.view.Surface.ROTATION_270;
import static android.view.Surface.ROTATION_90;
@@ -495,7 +494,7 @@
// process that it is hidden.
private boolean mLastDeferHidingClient; // If true we will defer setting mClientVisible to false
// and reporting to the client that it is hidden.
- boolean sleeping; // have we told the activity to sleep?
+ private boolean mSetToSleep; // have we told the activity to sleep?
boolean nowVisible; // is this activity's window visible?
boolean mDrawn; // is this activity's window drawn?
boolean mClientVisibilityDeferred;// was the visibility change message to client deferred?
@@ -613,6 +612,7 @@
private boolean mLastContainsShowWhenLockedWindow;
private boolean mLastContainsDismissKeyguardWindow;
+ private boolean mLastContainsTurnScreenOnWindow;
/**
* A flag to determine if this AR is in the process of closing or entering PIP. This is needed
@@ -895,7 +895,7 @@
pw.print(" finishing="); pw.println(finishing);
pw.print(prefix); pw.print("keysPaused="); pw.print(keysPaused);
pw.print(" inHistory="); pw.print(inHistory);
- pw.print(" sleeping="); pw.print(sleeping);
+ pw.print(" setToSleep="); pw.print(mSetToSleep);
pw.print(" idle="); pw.print(idle);
pw.print(" mStartingWindowState=");
pw.println(startingWindowStateToString(mStartingWindowState));
@@ -2661,7 +2661,6 @@
// Make sure the record is cleaned out of other places.
mStackSupervisor.mStoppingActivities.remove(this);
- mStackSupervisor.mGoingToSleepActivities.remove(this);
final ActivityStack stack = getRootTask();
final DisplayContent display = getDisplay();
@@ -3364,6 +3363,7 @@
}
mLastContainsDismissKeyguardWindow = containsDismissKeyguard;
mLastContainsShowWhenLockedWindow = containsShowWhenLocked;
+ mLastContainsTurnScreenOnWindow = containsTurnScreenOnWindow();
}
boolean containsDismissKeyguardWindow() {
@@ -4362,6 +4362,15 @@
|| state5 == mState;
}
+ /**
+ * Returns {@code true} if the Activity is in one of the specified states.
+ */
+ boolean isState(ActivityState state1, ActivityState state2, ActivityState state3,
+ ActivityState state4, ActivityState state5, ActivityState state6) {
+ return state1 == mState || state2 == mState || state3 == mState || state4 == mState
+ || state5 == mState || state6 == mState;
+ }
+
void destroySurfaces() {
destroySurfaces(false /*cleanupOnResume*/);
}
@@ -4451,20 +4460,26 @@
return false;
}
- // Whether the activity is on the sleeping display.
- // TODO(b/129750406): This should be applied for the default display, too.
- final boolean isDisplaySleeping = getDisplay().isSleeping()
- && getDisplayId() != DEFAULT_DISPLAY;
- // Whether this activity is the top activity of this stack.
- final boolean isTop = this == stack.getTopNonFinishingActivity();
- // Exclude the case where this is the top activity in a pinned stack.
- final boolean isTopNotPinnedStack = stack.isAttached()
- && stack.getDisplay().isTopNotPinnedStack(stack);
+ // Check if the activity is on a sleeping display, and if it can turn it ON.
+ if (getDisplay().isSleeping()) {
+ final boolean canTurnScreenOn = !mSetToSleep || canTurnScreenOn()
+ || canShowWhenLocked() || containsDismissKeyguardWindow();
+ if (!canTurnScreenOn) {
+ return false;
+ }
+ }
+
// Now check whether it's really visible depending on Keyguard state, and update
// {@link ActivityStack} internal states.
+ // Inform the method if this activity is the top activity of this stack, but exclude the
+ // case where this is the top activity in a pinned stack.
+ final boolean isTop = this == stack.getTopNonFinishingActivity();
+ final boolean isTopNotPinnedStack = stack.isAttached()
+ && stack.getDisplay().isTopNotPinnedStack(stack);
final boolean visibleIgnoringDisplayStatus = stack.checkKeyguardVisibility(this,
visibleIgnoringKeyguard, isTop && isTopNotPinnedStack);
- return visibleIgnoringDisplayStatus && !isDisplaySleeping;
+
+ return visibleIgnoringDisplayStatus;
}
boolean shouldBeVisible() {
@@ -4496,7 +4511,7 @@
stack.mUndrawnActivitiesBelowTopTranslucent.add(this);
}
setVisibility(true);
- sleeping = false;
+ mSetToSleep = false;
app.postPendingUiCleanMsg(true);
if (reportToClient) {
mClientVisibilityDeferred = false;
@@ -4506,7 +4521,6 @@
}
// The activity may be waiting for stop, but that is no longer appropriate for it.
mStackSupervisor.mStoppingActivities.remove(this);
- mStackSupervisor.mGoingToSleepActivities.remove(this);
} catch (Exception e) {
// Just skip on any failure; we'll make it visible when it next restarts.
Slog.w(TAG, "Exception thrown making visible: " + intent.getComponent(), e);
@@ -5452,25 +5466,8 @@
return mVisibleRequested || nowVisible || mState == PAUSING || mState == RESUMED;
}
- void setSleeping(boolean _sleeping) {
- setSleeping(_sleeping, false);
- }
-
- void setSleeping(boolean _sleeping, boolean force) {
- if (!force && sleeping == _sleeping) {
- return;
- }
- if (attachedToProcess()) {
- try {
- app.getThread().scheduleSleeping(appToken, _sleeping);
- if (_sleeping && !mStackSupervisor.mGoingToSleepActivities.contains(this)) {
- mStackSupervisor.mGoingToSleepActivities.add(this);
- }
- sleeping = _sleeping;
- } catch (RemoteException e) {
- Slog.w(TAG, "Exception thrown when sleeping: " + intent.getComponent(), e);
- }
- }
+ void setSleeping(boolean sleeping) {
+ mSetToSleep = sleeping;
}
static int getTaskForActivityLocked(IBinder token, boolean onlyRoot) {
@@ -7413,7 +7410,22 @@
}
boolean getTurnScreenOnFlag() {
- return mTurnScreenOn;
+ return mTurnScreenOn || containsTurnScreenOnWindow();
+ }
+
+ private boolean containsTurnScreenOnWindow() {
+ // When we are relaunching, it is possible for us to be unfrozen before our previous
+ // windows have been added back. Using the cached value ensures that our previous
+ // showWhenLocked preference is honored until relaunching is complete.
+ if (isRelaunching()) {
+ return mLastContainsTurnScreenOnWindow;
+ }
+ for (int i = mChildren.size() - 1; i >= 0; i--) {
+ if ((mChildren.get(i).mAttrs.flags & LayoutParams.FLAG_TURN_SCREEN_ON) != 0) {
+ return true;
+ }
+ }
+ return false;
}
/**
diff --git a/services/core/java/com/android/server/wm/ActivityStack.java b/services/core/java/com/android/server/wm/ActivityStack.java
index 942be84..dbcc630 100644
--- a/services/core/java/com/android/server/wm/ActivityStack.java
+++ b/services/core/java/com/android/server/wm/ActivityStack.java
@@ -1263,6 +1263,8 @@
void awakeFromSleepingLocked() {
// Ensure activities are no longer sleeping.
forAllActivities((Consumer<ActivityRecord>) (r) -> r.setSleeping(false));
+ ensureActivitiesVisible(null /* starting */, 0 /* configChanges */,
+ false /* preserveWindows */);
if (mPausingActivity != null) {
Slog.d(TAG, "awakeFromSleepingLocked: previously pausing activity didn't pause");
mPausingActivity.activityPaused(true);
@@ -1312,13 +1314,6 @@
mStackSupervisor.scheduleIdle();
shouldSleep = false;
}
-
- if (containsActivityFromStack(mStackSupervisor.mGoingToSleepActivities)) {
- // Still need to tell some activities to sleep; can't sleep yet.
- if (DEBUG_PAUSE) Slog.v(TAG_PAUSE, "Sleep still need to sleep "
- + mStackSupervisor.mGoingToSleepActivities.size() + " activities");
- shouldSleep = false;
- }
}
if (shouldSleep) {
@@ -1329,16 +1324,18 @@
}
void goToSleep() {
- // Ensure visibility without updating configuration, as activities are about to sleep.
- ensureActivitiesVisible(null /* starting */, 0 /* configChanges */, !PRESERVE_WINDOWS);
-
- // Make sure any paused or stopped but visible activities are now sleeping.
- // This ensures that the activity's onStop() is called.
+ // Make sure all visible activities are now sleeping. This will update the activity's
+ // visibility and onStop() will be called.
forAllActivities((r) -> {
- if (r.isState(STARTED, STOPPING, STOPPED, PAUSED, PAUSING)) {
+ if (r.isState(STARTED, RESUMED, PAUSING, PAUSED, STOPPING, STOPPED)) {
r.setSleeping(true);
}
});
+
+ // Ensure visibility after updating sleep states without updating configuration,
+ // as activities are about to be sent to sleep.
+ ensureActivitiesVisible(null /* starting */, 0 /* configChanges */,
+ !PRESERVE_WINDOWS);
}
private boolean containsActivityFromStack(List<ActivityRecord> rs) {
@@ -2040,8 +2037,17 @@
return false;
}
- // If we are sleeping, and there is no resumed activity, and the top
- // activity is paused, well that is the state we want.
+ // If we are currently pausing an activity, then don't do anything until that is done.
+ final boolean allPausedComplete = mRootWindowContainer.allPausedActivitiesComplete();
+ if (!allPausedComplete) {
+ if (DEBUG_SWITCH || DEBUG_PAUSE || DEBUG_STATES) {
+ Slog.v(TAG_PAUSE, "resumeTopActivityLocked: Skip resume: some activity pausing.");
+ }
+ return false;
+ }
+
+ // If we are sleeping, and there is no resumed activity, and the top activity is paused,
+ // well that is the state we want.
if (shouldSleepOrShutDownActivities()
&& mLastPausedActivity == next
&& mRootWindowContainer.allPausedActivitiesComplete()) {
@@ -2082,8 +2088,7 @@
// The activity may be waiting for stop, but that is no longer
// appropriate for it.
mStackSupervisor.mStoppingActivities.remove(next);
- mStackSupervisor.mGoingToSleepActivities.remove(next);
- next.sleeping = false;
+ next.setSleeping(false);
if (DEBUG_SWITCH) Slog.v(TAG_SWITCH, "Resuming " + next);
@@ -2352,7 +2357,7 @@
EventLogTags.writeWmResumeActivity(next.mUserId, System.identityHashCode(next),
next.getTask().mTaskId, next.shortComponentName);
- next.sleeping = false;
+ next.setSleeping(false);
mAtmService.getAppWarningsLocked().onResumeActivity(next);
next.app.setPendingUiCleanAndForceProcessStateUpTo(mAtmService.mTopProcessState);
next.clearOptionsLocked();
diff --git a/services/core/java/com/android/server/wm/ActivityStackSupervisor.java b/services/core/java/com/android/server/wm/ActivityStackSupervisor.java
index 2c0f3e6..5235d7c 100644
--- a/services/core/java/com/android/server/wm/ActivityStackSupervisor.java
+++ b/services/core/java/com/android/server/wm/ActivityStackSupervisor.java
@@ -285,9 +285,6 @@
* settle down before doing so. It contains ActivityRecord objects. */
final ArrayList<ActivityRecord> mFinishingActivities = new ArrayList<>();
- /** List of activities that are in the process of going to sleep. */
- final ArrayList<ActivityRecord> mGoingToSleepActivities = new ArrayList<>();
-
/** List of activities whose multi-window mode changed that we need to report to the
* application */
private final ArrayList<ActivityRecord> mMultiWindowModeChangedActivities = new ArrayList<>();
@@ -881,7 +878,7 @@
}
mService.getPackageManagerInternalLocked().notifyPackageUse(
r.intent.getComponent().getPackageName(), NOTIFY_PACKAGE_USE_ACTIVITY);
- r.sleeping = false;
+ r.setSleeping(false);
r.forceNewConfig = false;
mService.getAppWarningsLocked().onStartActivity(r);
r.compat = mService.compatibilityInfoForPackageLocked(r.info.applicationInfo);
@@ -1991,16 +1988,6 @@
}
}
- void activitySleptLocked(ActivityRecord r) {
- mGoingToSleepActivities.remove(r);
- final ActivityStack s = r.getRootTask();
- if (s != null) {
- s.checkReadyForSleep();
- } else {
- checkReadyForSleepLocked(true);
- }
- }
-
void checkReadyForSleepLocked(boolean allowDelay) {
if (!mService.isSleepingOrShuttingDownLocked()) {
// Do not care.
@@ -2137,7 +2124,6 @@
void removeHistoryRecords(WindowProcessController app) {
removeHistoryRecords(mStoppingActivities, app, "mStoppingActivities");
- removeHistoryRecords(mGoingToSleepActivities, app, "mGoingToSleepActivities");
removeHistoryRecords(mFinishingActivities, app, "mFinishingActivities");
}
@@ -2474,7 +2460,10 @@
if (r != null) {
r.finishRelaunching();
if (r.getRootTask().shouldSleepOrShutDownActivities()) {
- r.setSleeping(true, true);
+ // Activity is always relaunched to either resumed or paused state. If it was
+ // relaunched while hidden (by keyguard or smth else), it should be stopped.
+ r.getStack().ensureActivitiesVisible(null /* starting */, 0 /* configChanges */,
+ false /* preserveWindows */);
}
}
}
diff --git a/services/core/java/com/android/server/wm/ActivityTaskManagerService.java b/services/core/java/com/android/server/wm/ActivityTaskManagerService.java
index 31b7c68..d743fba 100644
--- a/services/core/java/com/android/server/wm/ActivityTaskManagerService.java
+++ b/services/core/java/com/android/server/wm/ActivityTaskManagerService.java
@@ -1825,21 +1825,6 @@
Binder.restoreCallingIdentity(origId);
}
- public final void activitySlept(IBinder token) {
- if (DEBUG_ALL) Slog.v(TAG, "Activity slept: token=" + token);
-
- final long origId = Binder.clearCallingIdentity();
-
- synchronized (mGlobalLock) {
- final ActivityRecord r = ActivityRecord.isInStackLocked(token);
- if (r != null) {
- mStackSupervisor.activitySleptLocked(r);
- }
- }
-
- Binder.restoreCallingIdentity(origId);
- }
-
@Override
public void setRequestedOrientation(IBinder token, int requestedOrientation) {
synchronized (mGlobalLock) {
diff --git a/services/core/java/com/android/server/wm/RootWindowContainer.java b/services/core/java/com/android/server/wm/RootWindowContainer.java
index 0b54245..e6fd512 100644
--- a/services/core/java/com/android/server/wm/RootWindowContainer.java
+++ b/services/core/java/com/android/server/wm/RootWindowContainer.java
@@ -164,7 +164,6 @@
import java.lang.annotation.RetentionPolicy;
import java.util.ArrayList;
import java.util.HashMap;
-import java.util.Iterator;
import java.util.List;
import java.util.Objects;
import java.util.Set;
@@ -2348,18 +2347,6 @@
}
}
}
-
- if (displayShouldSleep || mStackSupervisor.mGoingToSleepActivities.isEmpty()) {
- continue;
- }
- // The display is awake now, so clean up the going to sleep list.
- for (Iterator<ActivityRecord> it =
- mStackSupervisor.mGoingToSleepActivities.iterator(); it.hasNext(); ) {
- final ActivityRecord r = it.next();
- if (r.getDisplayId() == display.mDisplayId) {
- it.remove();
- }
- }
}
}
@@ -3578,9 +3565,6 @@
printed |= dumpHistoryList(fd, pw, mStackSupervisor.mStoppingActivities, " ",
"Stop", false, !dumpAll,
false, dumpPackage, true, " Activities waiting to stop:", null);
- printed |= dumpHistoryList(fd, pw, mStackSupervisor.mGoingToSleepActivities,
- " ", "Sleep", false, !dumpAll,
- false, dumpPackage, true, " Activities waiting to sleep:", null);
return printed;
}
diff --git a/services/tests/wmtests/src/com/android/server/wm/WindowStateTests.java b/services/tests/wmtests/src/com/android/server/wm/WindowStateTests.java
index 5cf9c44..186ff6b 100644
--- a/services/tests/wmtests/src/com/android/server/wm/WindowStateTests.java
+++ b/services/tests/wmtests/src/com/android/server/wm/WindowStateTests.java
@@ -323,11 +323,18 @@
WINDOWING_MODE_FULLSCREEN, ACTIVITY_TYPE_STANDARD);
final WindowState first = createWindow(null, TYPE_APPLICATION, activity, "first");
final WindowState second = createWindow(null, TYPE_APPLICATION, activity, "second");
- second.mAttrs.flags |= WindowManager.LayoutParams.FLAG_TURN_SCREEN_ON;
testPrepareWindowToDisplayDuringRelayout(first, false /* expectedWakeupCalled */,
true /* expectedCurrentLaunchCanTurnScreenOn */);
- testPrepareWindowToDisplayDuringRelayout(second, true /* expectedWakeupCalled */,
+ testPrepareWindowToDisplayDuringRelayout(second, false /* expectedWakeupCalled */,
+ true /* expectedCurrentLaunchCanTurnScreenOn */);
+
+ // Call prepareWindowToDisplayDuringRelayout for two windows from the same activity, one of
+ // which has FLAG_TURN_SCREEN_ON. The first processed one should trigger the wakeup.
+ second.mAttrs.flags |= WindowManager.LayoutParams.FLAG_TURN_SCREEN_ON;
+ testPrepareWindowToDisplayDuringRelayout(first, true /* expectedWakeupCalled */,
+ false /* expectedCurrentLaunchCanTurnScreenOn */);
+ testPrepareWindowToDisplayDuringRelayout(second, false /* expectedWakeupCalled */,
false /* expectedCurrentLaunchCanTurnScreenOn */);
// Call prepareWindowToDisplayDuringRelayout for two window that have FLAG_TURN_SCREEN_ON