Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit db0fa12b authored by Wale Ogunwale's avatar Wale Ogunwale
Browse files

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
parent c4033e7c

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

+41 −6
Original line number Diff line number Diff line
@@ -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<ActivityRecord> 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);

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

+4 −16
Original line number Diff line number Diff line
@@ -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);