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

Commit e10cea50 authored by Riddle Hsu's avatar Riddle Hsu
Browse files

Fix freeze wrong display when finishing activity 

- The next activity after finishing should only consider in the
  same display.
- Make topRunningActivity goes through focusable stacks in a display
  instead of only uses top focused. Because it was used for legacy
  hierarchy that application tasks are put in a single stack.
- Update display configuration when a display becomes not containing
  running activity after finishing current activity to restore the
  original orientation.

Bug: 117861386
Test: atest ActivityStackTests#testFinishCurrentActivity
Test: atest ActivityDisplayTests#testTopRunningActivity
Change-Id: I15cafff01cf528681de64cd1b7da0547654e1103
parent ec397364

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

+46 −0
Original line number Diff line number Diff line
@@ -873,6 +873,52 @@ class ActivityDisplay extends ConfigurationContainer<ActivityStack> 
        return null;

    }



    ActivityRecord topRunningActivity() {

        return topRunningActivity(false /* considerKeyguardState */);

    }



    /**

     * Returns the top running activity in the focused stack. In the case the focused stack has no

     * such activity, the next focusable stack on this display is returned.

     *

     * @param considerKeyguardState Indicates whether the locked state should be considered. if

     *                              {@code true} and the keyguard is locked, only activities that

     *                              can be shown on top of the keyguard will be considered.

     * @return The top running activity. {@code null} if none is available.

     */

    ActivityRecord topRunningActivity(boolean considerKeyguardState) {

        ActivityRecord topRunning = null;

        final ActivityStack focusedStack = getFocusedStack();

        if (focusedStack != null) {

            topRunning = focusedStack.topRunningActivityLocked();

        }



        // Look in other focusable stacks.

        if (topRunning == null) {

            for (int i = mStacks.size() - 1; i >= 0; --i) {

                final ActivityStack stack = mStacks.get(i);

                // Only consider focusable stacks other than the current focused one.

                if (stack == focusedStack || !stack.isFocusable()) {

                    continue;

                }

                topRunning = stack.topRunningActivityLocked();

                if (topRunning != null) {

                    break;

                }

            }

        }



        // This activity can be considered the top running activity if we are not considering

        // the locked state, the keyguard isn't locked, or we can show when locked.

        if (topRunning != null && considerKeyguardState

                && mSupervisor.getKeyguardController().isKeyguardLocked()

                && !topRunning.canShowWhenLocked()) {

            return null;

        }



        return topRunning;

    }



    int getIndexOf(ActivityStack stack) {

        return mStacks.indexOf(stack);

    }

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

+10 −8
Original line number Diff line number Diff line
@@ -3877,8 +3877,8 @@ class ActivityStack<T extends StackWindowController> extends ConfigurationContai 
        // The activity that we are finishing may be over the lock screen. In this case, we do not

        // want to consider activities that cannot be shown on the lock screen as running and should

        // proceed with finishing the activity if there is no valid next top running activity.

        final ActivityRecord next = mStackSupervisor.topRunningActivityLocked(

                true /* considerKeyguardState */);

        final ActivityDisplay display = getDisplay();

        final ActivityRecord next = display.topRunningActivity(true /* considerKeyguardState */);



        if (mode == FINISH_AFTER_VISIBLE && (r.visible || r.nowVisible)

                && next != null && !next.nowVisible) {
@@ -3902,23 +3902,25 @@ class ActivityStack<T extends StackWindowController> extends ConfigurationContai 
        if (DEBUG_STATES) Slog.v(TAG_STATES, "Moving to FINISHING: " + r);



        r.setState(FINISHING, "finishCurrentActivityLocked");

        final boolean finishingActivityInNonFocusedStack

                = r.getStack() != mStackSupervisor.getTopDisplayFocusedStack()

                && prevState == PAUSED && mode == FINISH_AFTER_VISIBLE;

        final boolean finishingInNonFocusedStackOrNoRunning = mode == FINISH_AFTER_VISIBLE

                && prevState == PAUSED && (r.getStack() != display.getFocusedStack()

                        || (next == null && display.topRunningActivity() == null));



        if (mode == FINISH_IMMEDIATELY

                || (prevState == PAUSED

                    && (mode == FINISH_AFTER_PAUSE || inPinnedWindowingMode()))

                || finishingActivityInNonFocusedStack

                || finishingInNonFocusedStackOrNoRunning

                || prevState == STOPPING

                || prevState == STOPPED

                || prevState == ActivityState.INITIALIZING) {

            r.makeFinishingLocked();

            boolean activityRemoved = destroyActivityLocked(r, true, "finish-imm:" + reason);



            if (finishingActivityInNonFocusedStack) {

            if (finishingInNonFocusedStackOrNoRunning) {

                // Finishing activity that was in paused state and it was in not currently focused

                // stack, need to make something visible in its place.

                // stack, need to make something visible in its place. Also if the display does not

                // have running activity, the configuration may need to be updated for restoring

                // original orientation of the display.

                mStackSupervisor.ensureVisibilityAndConfig(next, mDisplayId,

                        false /* markFrozenIfConfigChanged */, true /* deferResume */);

            }

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

+2 −62
Original line number Diff line number Diff line
@@ -1209,75 +1209,15 @@ public class ActivityStackSupervisor extends ConfigurationContainer implements D 
    }



    ActivityRecord topRunningActivityLocked() {

        return topRunningActivityLocked(false /* considerKeyguardState */);

    }



    /**

     * Returns the top running activity in the focused stack. In the case the focused stack has no

     * such activity, the next focusable stack on top of a display is returned.

     * @param considerKeyguardState Indicates whether the locked state should be considered. if

     *                            {@code true} and the keyguard is locked, only activities that

     *                            can be shown on top of the keyguard will be considered.

     * @return The top running activity. {@code null} if none is available.

     */

    ActivityRecord topRunningActivityLocked(boolean considerKeyguardState) {

        final ActivityStack focusedStack = getTopDisplayFocusedStack();

        ActivityRecord r = focusedStack.topRunningActivityLocked();

        if (r != null && isValidTopRunningActivity(r, considerKeyguardState)) {

            return r;

        }



        // Look in other non-focused and non-home stacks.

        for (int i = mActivityDisplays.size() - 1; i >= 0; --i) {

            final ActivityDisplay display = mActivityDisplays.get(i);



            // TODO: We probably want to consider the top fullscreen stack as we could have a pinned

            // stack on top.

            final ActivityStack topStack = display.getTopStack();



            // Only consider focusable top stacks other than the current focused one.

            if (topStack == null || !topStack.isFocusable() || topStack == focusedStack) {

                continue;

            }



            final ActivityRecord topActivity = topStack.topRunningActivityLocked();



            // Skip if no top activity.

            if (topActivity == null) {

                continue;

            }





            // This activity can be considered the top running activity if we are not

            // considering the locked state, the keyguard isn't locked, or we can show when

            // locked.

            if (isValidTopRunningActivity(topActivity, considerKeyguardState)) {

            final ActivityRecord topActivity = mActivityDisplays.get(i).topRunningActivity();

            if (topActivity != null) {

                return topActivity;

            }

        }



        return null;

    }



    /**

     * Verifies an {@link ActivityRecord} can be the top activity based on keyguard state and

     * whether we are considering it.

     */

    private boolean isValidTopRunningActivity(ActivityRecord record,

            boolean considerKeyguardState) {

        if (!considerKeyguardState) {

            return true;

        }



        final boolean keyguardLocked = getKeyguardController().isKeyguardLocked();



        if (!keyguardLocked) {

            return true;

        }



        return record.canShowWhenLocked();

    }



    @VisibleForTesting

    void getRunningTasks(int maxNum, List<RunningTaskInfo> list,

            @ActivityType int ignoreActivityType, @WindowingMode int ignoreWindowingMode,

services/tests/servicestests/src/com/android/server/am/ActivityDisplayTests.java

+56 −0
Original line number Diff line number Diff line
@@ -20,11 +20,14 @@ import static android.app.WindowConfiguration.ACTIVITY_TYPE_STANDARD; 
import static android.app.WindowConfiguration.WINDOWING_MODE_FULLSCREEN;

import static android.app.WindowConfiguration.WINDOWING_MODE_PINNED;

import static android.content.pm.ActivityInfo.FLAG_ALWAYS_FOCUSABLE;

import static android.content.pm.ActivityInfo.FLAG_SHOW_WHEN_LOCKED;



import static com.android.server.am.ActivityStackSupervisor.ON_TOP;



import static org.junit.Assert.assertEquals;

import static org.junit.Assert.assertNull;

import static org.junit.Assert.assertTrue;

import static org.mockito.Mockito.doReturn;



import android.platform.test.annotations.Presubmit;
@@ -131,4 +134,57 @@ public class ActivityDisplayTests extends ActivityTestsBase { 
        new ActivityBuilder(mService).setTask(fullscreenTask).build();

        return fullscreenStack;

    }



    /**

     * Verifies the correct activity is returned when querying the top running activity.

     */

    @Test

    public void testTopRunningActivity() {

        // Create stack to hold focus.

        final ActivityDisplay display = mSupervisor.getDefaultDisplay();

        final ActivityStack emptyStack = display.createStack(WINDOWING_MODE_FULLSCREEN,

                ACTIVITY_TYPE_STANDARD, true /* onTop */);



        final KeyguardController keyguard = mSupervisor.getKeyguardController();

        final ActivityStack stack = mSupervisor.getDefaultDisplay().createStack(

                WINDOWING_MODE_FULLSCREEN, ACTIVITY_TYPE_STANDARD, true /* onTop */);

        final ActivityRecord activity = new ActivityBuilder(mService).setCreateTask(true)

                .setStack(stack).build();



        // Make sure the top running activity is not affected when keyguard is not locked.

        assertTopRunningActivity(activity, display);



        // Check to make sure activity not reported when it cannot show on lock and lock is on.

        doReturn(true).when(keyguard).isKeyguardLocked();

        assertEquals(activity, display.topRunningActivity());

        assertNull(display.topRunningActivity(true /* considerKeyguardState */));



        // Change focus to stack with activity.

        stack.moveToFront("focusChangeToTestStack");

        assertEquals(stack, display.getFocusedStack());

        assertEquals(activity, display.topRunningActivity());

        assertNull(display.topRunningActivity(true /* considerKeyguardState */));



        // Add activity that should be shown on the keyguard.

        final ActivityRecord showWhenLockedActivity = new ActivityBuilder(mService)

                .setCreateTask(true)

                .setStack(stack)

                .setActivityFlags(FLAG_SHOW_WHEN_LOCKED)

                .build();



        // Ensure the show when locked activity is returned.

        assertTopRunningActivity(showWhenLockedActivity, display);



        // Change focus back to empty stack.

        emptyStack.moveToFront("focusChangeToEmptyStack");

        assertEquals(emptyStack, display.getFocusedStack());

        // If there is no running activity in focused stack, the running activity in next focusable

        // stack should be returned.

        assertTopRunningActivity(showWhenLockedActivity, display);

    }



    private static void assertTopRunningActivity(ActivityRecord top, ActivityDisplay display) {

        assertEquals(top, display.topRunningActivity());

        assertEquals(top, display.topRunningActivity(true /* considerKeyguardState */));

    }

}

services/tests/servicestests/src/com/android/server/am/ActivityStackSupervisorTests.java

+0 −57
Original line number Diff line number Diff line
@@ -25,7 +25,6 @@ import static android.app.WindowConfiguration.WINDOWING_MODE_FULLSCREEN_OR_SPLIT 
import static android.app.WindowConfiguration.WINDOWING_MODE_PINNED;

import static android.app.WindowConfiguration.WINDOWING_MODE_SPLIT_SCREEN_PRIMARY;

import static android.content.pm.ActivityInfo.FLAG_ALWAYS_FOCUSABLE;

import static android.content.pm.ActivityInfo.FLAG_SHOW_WHEN_LOCKED;



import static com.android.server.am.ActivityStack.REMOVE_TASK_MODE_DESTROYING;

import static com.android.server.am.ActivityStackSupervisor.MATCH_TASK_IN_STACKS_OR_RECENT_TASKS_AND_RESTORE;
@@ -306,62 +305,6 @@ public class ActivityStackSupervisorTests extends ActivityTestsBase { 
        assertFalse(pinnedStack.isFocusable());

    }



    /**

     * Verifies the correct activity is returned when querying the top running activity.

     */

    @Test

    public void testTopRunningActivity() throws Exception {

        // Create stack to hold focus

        final ActivityDisplay display = mService.mStackSupervisor.getDefaultDisplay();

        final ActivityStack emptyStack = display.createStack(WINDOWING_MODE_FULLSCREEN,

                ACTIVITY_TYPE_STANDARD, true /* onTop */);



        final KeyguardController keyguard = mSupervisor.getKeyguardController();

        final ActivityStack stack = mService.mStackSupervisor.getDefaultDisplay().createStack(

                WINDOWING_MODE_FULLSCREEN, ACTIVITY_TYPE_STANDARD, true /* onTop */);

        final ActivityRecord activity = new ActivityBuilder(mService).setCreateTask(true)

                .setStack(stack).build();



        // Make sure the top running activity is not affected when keyguard is not locked

        assertEquals(activity, mService.mStackSupervisor.topRunningActivityLocked());

        assertEquals(activity, mService.mStackSupervisor.topRunningActivityLocked(

                true /* considerKeyguardState */));



        // Check to make sure activity not reported when it cannot show on lock and lock is on.

        doReturn(true).when(keyguard).isKeyguardLocked();

        assertEquals(activity, mService.mStackSupervisor.topRunningActivityLocked());

        assertEquals(null, mService.mStackSupervisor.topRunningActivityLocked(

                true /* considerKeyguardState */));



        // Change focus to stack with activity.

        stack.moveToFront("focusChangeToTestStack");

        assertEquals(stack, display.getFocusedStack());

        assertEquals(activity, mService.mStackSupervisor.topRunningActivityLocked());

        assertEquals(null, mService.mStackSupervisor.topRunningActivityLocked(

                true /* considerKeyguardState */));



        // Add activity that should be shown on the keyguard.

        final ActivityRecord showWhenLockedActivity = new ActivityBuilder(mService)

                .setCreateTask(true)

                .setStack(stack)

                .setActivityFlags(FLAG_SHOW_WHEN_LOCKED)

                .build();



        // Ensure the show when locked activity is returned.

        assertEquals(showWhenLockedActivity, mService.mStackSupervisor.topRunningActivityLocked());

        assertEquals(showWhenLockedActivity, mService.mStackSupervisor.topRunningActivityLocked(

                true /* considerKeyguardState */));



        // Change focus back to empty stack

        emptyStack.moveToFront("focusChangeToEmptyStack");

        assertEquals(emptyStack, display.getFocusedStack());

        // Looking for running activity only in top and focused stack, so nothing should be returned

        // from empty stack.

        assertEquals(null, mService.mStackSupervisor.topRunningActivityLocked());

        assertEquals(null, mService.mStackSupervisor.topRunningActivityLocked(

                true /* considerKeyguardState */));

    }



    /**

     * Verify that split-screen primary stack will be chosen if activity is launched that targets

     * split-screen secondary, but a matching existing instance is found on top of split-screen