From db0fa12b736a6901075ae30c2c423a036d6b8139 Mon Sep 17 00:00:00 2001 From: Wale Ogunwale Date: Mon, 16 May 2016 15:12:03 -0700 Subject: [PATCH] Update configuration of all visible activities in a stack when resizing Previously we were only updating configuration for the top activity in the stack during resizing. This caused an activity behind the top translucent activity to continue to display in the old configuration and also get relaunched without window preservation when the top translucent activity is finished. We now make sure all activities at all below a translucent activity have their configuration updated during resizing. Bug: 28762547 Change-Id: I0926ac6db088cdf3f6a225c552dbfbe944830f68 --- .../com/android/server/am/ActivityStack.java | 47 ++++++++++++++++--- .../server/am/ActivityStackSupervisor.java | 20 ++------ 2 files changed, 45 insertions(+), 22 deletions(-) diff --git a/services/core/java/com/android/server/am/ActivityStack.java b/services/core/java/com/android/server/am/ActivityStack.java index 62d114d1257a1..1b4cfa2d08012 100644 --- a/services/core/java/com/android/server/am/ActivityStack.java +++ b/services/core/java/com/android/server/am/ActivityStack.java @@ -4383,14 +4383,49 @@ final class ActivityStack { } /** - * Make sure the given activity matches the current configuration. Returns - * false if the activity had to be destroyed. Returns true if the - * configuration is the same, or the activity will remain running as-is - * for whatever reason. Ensures the HistoryRecord is updated with the + * Ensures all visible activities at or below the input activity have the right configuration. + */ + void ensureVisibleActivitiesConfigurationLocked(ActivityRecord start, boolean preserveWindow) { + if (start == null || !start.visible) { + return; + } + + final TaskRecord startTask = start.task; + boolean behindFullscreen = false; + boolean updatedConfig = false; + + for (int taskIndex = mTaskHistory.indexOf(startTask); taskIndex >= 0; --taskIndex) { + final TaskRecord task = mTaskHistory.get(taskIndex); + final ArrayList activities = task.mActivities; + int activityIndex = + (start.task == task) ? activities.indexOf(start) : activities.size() - 1; + for (; activityIndex >= 0; --activityIndex) { + final ActivityRecord r = activities.get(activityIndex); + updatedConfig |= ensureActivityConfigurationLocked(r, 0, preserveWindow); + if (r.fullscreen) { + behindFullscreen = true; + break; + } + } + if (behindFullscreen) { + break; + } + } + if (updatedConfig) { + // Ensure the resumed state of the focus activity if we updated the confiugaration of + // any activity. + mStackSupervisor.resumeFocusedStackTopActivityLocked(); + } + } + + /** + * Make sure the given activity matches the current configuration. Returns false if the activity + * had to be destroyed. Returns true if the configuration is the same, or the activity will + * remain running as-is for whatever reason. Ensures the HistoryRecord is updated with the * correct configuration and all other bookkeeping is handled. */ - final boolean ensureActivityConfigurationLocked(ActivityRecord r, int globalChanges, - boolean preserveWindow) { + boolean ensureActivityConfigurationLocked( + ActivityRecord r, int globalChanges, boolean preserveWindow) { if (mConfigWillChange) { if (DEBUG_SWITCH || DEBUG_CONFIGURATION) Slog.v(TAG_CONFIGURATION, "Skipping config check (will change): " + r); diff --git a/services/core/java/com/android/server/am/ActivityStackSupervisor.java b/services/core/java/com/android/server/am/ActivityStackSupervisor.java index 4bf28b207f178..a0e2512570d7e 100644 --- a/services/core/java/com/android/server/am/ActivityStackSupervisor.java +++ b/services/core/java/com/android/server/am/ActivityStackSupervisor.java @@ -2014,8 +2014,8 @@ public final class ActivityStackSupervisor implements DisplayListener { try { resizeStackUncheckedLocked(stack, bounds, tempTaskBounds, tempTaskInsetBounds); if (!deferResume) { - ensureConfigurationAndResume( - stack, stack.topRunningActivityLocked(), preserveWindows); + stack.ensureVisibleActivitiesConfigurationLocked( + stack.topRunningActivityLocked(), preserveWindows); } } finally { mWindowManager.continueSurfaceLayout(); @@ -2091,18 +2091,6 @@ public final class ActivityStackSupervisor implements DisplayListener { stack.setBounds(bounds); } - private void ensureConfigurationAndResume(ActivityStack stack, ActivityRecord r, - boolean preserveWindows) { - if (r == null || !r.visible) { - return; - } - final boolean updated = stack.ensureActivityConfigurationLocked(r, 0, - preserveWindows); - if (!updated) { - resumeFocusedStackTopActivityLocked(); - } - } - void moveTasksToFullscreenStackLocked(int fromStackId, boolean onTop) { final ActivityStack stack = getStack(fromStackId); if (stack == null) { @@ -2204,7 +2192,7 @@ public final class ActivityStackSupervisor implements DisplayListener { } } } - ensureConfigurationAndResume(stack, r, preserveWindows); + stack.ensureVisibleActivitiesConfigurationLocked(r, preserveWindows); } finally { mAllowDockedStackResize = true; mWindowManager.continueSurfaceLayout(); @@ -2230,7 +2218,7 @@ public final class ActivityStackSupervisor implements DisplayListener { ActivityRecord r = stack.topRunningActivityLocked(); resizeStackUncheckedLocked(stack, pinnedBounds, tempPinnedTaskBounds, null); - ensureConfigurationAndResume(stack, r, false); + stack.ensureVisibleActivitiesConfigurationLocked(r, false); } finally { mWindowManager.continueSurfaceLayout(); Trace.traceEnd(TRACE_TAG_ACTIVITY_MANAGER);