diff options
12 files changed, 84 insertions, 164 deletions
diff --git a/config/boot-image-profile.txt b/config/boot-image-profile.txt index 4aaf72728cbf..e649c303541a 100644 --- a/config/boot-image-profile.txt +++ b/config/boot-image-profile.txt @@ -1515,7 +1515,6 @@ HSPLandroid/app/IActivityTaskManager$Stub$Proxy;->activityDestroyed(Landroid/os/ 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 2ca5b1d5c76f..c52bdc01860c 100644 --- a/core/java/android/app/ActivityThread.java +++ b/core/java/android/app/ActivityThread.java @@ -924,10 +924,6 @@ public final class ActivityThread extends ClientTransactionHandler { 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 @@ public final class ActivityThread extends ClientTransactionHandler { 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 @@ public final class ActivityThread extends ClientTransactionHandler { 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 @@ public final class ActivityThread extends ClientTransactionHandler { } } - // 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 e5c046c2376c..85fa7c1cdb54 100644 --- a/core/java/android/app/IActivityTaskManager.aidl +++ b/core/java/android/app/IActivityTaskManager.aidl @@ -141,7 +141,6 @@ interface IActivityTaskManager { 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 51a64fff7c45..c33c515f062c 100644 --- a/core/java/android/app/IApplicationThread.aidl +++ b/core/java/android/app/IApplicationThread.aidl @@ -91,7 +91,6 @@ oneway interface IApplicationThread { 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 d8b527c8a11a..c986db8b2a83 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 @@ public class ActivityThreadTest { 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 ecea9011e704..372b8c294702 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 @@ public class TransactionParcelTests { } @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 d1c8448f2a4a..6fd02350e472 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.Build.VERSION_CODES.O; 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 @@ final class ActivityRecord extends WindowToken implements WindowManagerService.A // 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 @@ final class ActivityRecord extends WindowToken implements WindowManagerService.A 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 @@ final class ActivityRecord extends WindowToken implements WindowManagerService.A 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 @@ final class ActivityRecord extends WindowToken implements WindowManagerService.A // 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 @@ final class ActivityRecord extends WindowToken implements WindowManagerService.A } mLastContainsDismissKeyguardWindow = containsDismissKeyguard; mLastContainsShowWhenLockedWindow = containsShowWhenLocked; + mLastContainsTurnScreenOnWindow = containsTurnScreenOnWindow(); } boolean containsDismissKeyguardWindow() { @@ -4362,6 +4362,15 @@ final class ActivityRecord extends WindowToken implements WindowManagerService.A || 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 @@ final class ActivityRecord extends WindowToken implements WindowManagerService.A 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. + // 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(); - // Exclude the case where this is the top activity in a pinned stack. final boolean isTopNotPinnedStack = stack.isAttached() && stack.getDisplay().isTopNotPinnedStack(stack); - // Now check whether it's really visible depending on Keyguard state, and update - // {@link ActivityStack} internal states. final boolean visibleIgnoringDisplayStatus = stack.checkKeyguardVisibility(this, visibleIgnoringKeyguard, isTop && isTopNotPinnedStack); - return visibleIgnoringDisplayStatus && !isDisplaySleeping; + + return visibleIgnoringDisplayStatus; } boolean shouldBeVisible() { @@ -4496,7 +4511,7 @@ final class ActivityRecord extends WindowToken implements WindowManagerService.A stack.mUndrawnActivitiesBelowTopTranslucent.add(this); } setVisibility(true); - sleeping = false; + mSetToSleep = false; app.postPendingUiCleanMsg(true); if (reportToClient) { mClientVisibilityDeferred = false; @@ -4506,7 +4521,6 @@ final class ActivityRecord extends WindowToken implements WindowManagerService.A } // 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 @@ final class ActivityRecord extends WindowToken implements WindowManagerService.A 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 @@ final class ActivityRecord extends WindowToken implements WindowManagerService.A } 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 942be8409db2..dbcc63086100 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 @@ class ActivityStack extends Task implements BoundsAnimationTarget { 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 @@ class ActivityStack extends Task implements BoundsAnimationTarget { 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 @@ class ActivityStack extends Task implements BoundsAnimationTarget { } 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 @@ class ActivityStack extends Task implements BoundsAnimationTarget { 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 @@ class ActivityStack extends Task implements BoundsAnimationTarget { // 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 @@ class ActivityStack extends Task implements BoundsAnimationTarget { 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 2c0f3e65f198..5235d7cef6e1 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 @@ public class ActivityStackSupervisor implements RecentTasks.Callbacks { * 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 @@ public class ActivityStackSupervisor implements RecentTasks.Callbacks { } 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 @@ public class ActivityStackSupervisor implements RecentTasks.Callbacks { } } - 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 @@ public class ActivityStackSupervisor implements RecentTasks.Callbacks { void removeHistoryRecords(WindowProcessController app) { removeHistoryRecords(mStoppingActivities, app, "mStoppingActivities"); - removeHistoryRecords(mGoingToSleepActivities, app, "mGoingToSleepActivities"); removeHistoryRecords(mFinishingActivities, app, "mFinishingActivities"); } @@ -2474,7 +2460,10 @@ public class ActivityStackSupervisor implements RecentTasks.Callbacks { 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 31b7c688d685..d743fbab56a9 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 @@ public class ActivityTaskManagerService extends IActivityTaskManager.Stub { 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 0b54245cd424..e6fd512df72c 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.Retention; 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 @@ class RootWindowContainer extends WindowContainer<DisplayContent> } } } - - 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 @@ class RootWindowContainer extends WindowContainer<DisplayContent> 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 5cf9c44ee9e4..186ff6b1515b 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 @@ public class WindowStateTests extends WindowTestsBase { 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 |