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

Commit c96cfffa authored by Tony Huang's avatar Tony Huang
Browse files

Refactor TestSplitOrganizer and remove useless code 

Refactor TestSplitOrganizer to WINDOWING_MODE_MULTI_WINDOW and fix
related tests. And remove some tests and code if such behavior
should not apply to new split.

Bug: 199236198
Test: atest WmTests
Change-Id: I6461b1616f78e0396705c534e90b28374f3d9177
parent 45ed6b9c

services/core/java/com/android/server/wm/Task.java

+1 −19
Original line number Diff line number Diff line
@@ -4629,25 +4629,7 @@ class Task extends TaskFragment { 
    }



    void moveToFront(String reason, Task task) {

        if (inSplitScreenSecondaryWindowingMode()) {

            // If the root task is in split-screen secondary mode, we need to make sure we move the

            // primary split-screen root task forward in the case it is currently behind a

            // fullscreen root task so both halves of the split-screen appear on-top and the

            // fullscreen root task isn't cutting between them.

            // TODO(b/70677280): This is a workaround until we can fix as part of b/70677280.

            final TaskDisplayArea taskDisplayArea = getDisplayArea();

            final Task topFullScreenRootTask =

                    taskDisplayArea.getTopRootTaskInWindowingMode(WINDOWING_MODE_FULLSCREEN);

            if (topFullScreenRootTask != null) {

                final Task primarySplitScreenRootTask =

                        taskDisplayArea.getRootSplitScreenPrimaryTask();

                if (primarySplitScreenRootTask != null

                        && topFullScreenRootTask.compareTo(primarySplitScreenRootTask) > 0) {

                    primarySplitScreenRootTask.moveToFrontInner(reason + " splitScreenToTop",

                            null /* task */);

                }

            }

        } else if (mMoveAdjacentTogether && getAdjacentTaskFragment() != null) {

        if (mMoveAdjacentTogether && getAdjacentTaskFragment() != null) {

            final Task adjacentTask = getAdjacentTaskFragment().asTask();

            if (adjacentTask != null) {

                adjacentTask.moveToFrontInner(reason + " adjacentTaskToTop", null /* task */);

services/tests/wmtests/src/com/android/server/wm/ActivityStarterTests.java

+7 −50
Original line number Diff line number Diff line
@@ -31,7 +31,6 @@ import static android.app.ActivityManager.START_TASK_TO_FRONT; 
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.app.WindowConfiguration.WINDOWING_MODE_SPLIT_SCREEN_PRIMARY;

import static android.content.Intent.FLAG_ACTIVITY_CLEAR_TASK;

import static android.content.Intent.FLAG_ACTIVITY_LAUNCH_ADJACENT;

import static android.content.Intent.FLAG_ACTIVITY_NEW_TASK;
@@ -51,7 +50,6 @@ import static com.android.dx.mockito.inline.extended.ExtendedMockito.spy; 
import static com.android.dx.mockito.inline.extended.ExtendedMockito.spyOn;

import static com.android.dx.mockito.inline.extended.ExtendedMockito.times;

import static com.android.dx.mockito.inline.extended.ExtendedMockito.verify;

import static com.android.server.wm.ActivityTaskSupervisor.PRESERVE_WINDOWS;

import static com.android.server.wm.WindowContainer.POSITION_BOTTOM;

import static com.android.server.wm.WindowContainer.POSITION_TOP;
@@ -457,7 +455,7 @@ public class ActivityStarterTests extends WindowTestsBase { 
        final ActivityRecord splitSecondReusableActivity = activities.second;

        final ActivityRecord splitSecondTopActivity = new ActivityBuilder(mAtm).setCreateTask(true)

                .setParentTask(splitSecondReusableActivity.getRootTask()).build();

        assertTrue(splitSecondTopActivity.inSplitScreenSecondaryWindowingMode());

        assertTrue(splitSecondTopActivity.inMultiWindowMode());



        // Let primary stack has focus.

        splitPrimaryFocusActivity.moveFocusableActivityToTop("testSplitScreenTaskToFront");
@@ -476,13 +474,16 @@ public class ActivityStarterTests extends WindowTestsBase { 
        final TestSplitOrganizer splitOrg = new TestSplitOrganizer(mAtm);

        // The fullscreen windowing mode activity will be moved to split-secondary by

        // TestSplitOrganizer when a split-primary task appears.

        final ActivityRecord splitSecondActivity =

                new ActivityBuilder(mAtm).setCreateTask(true).build();

        final ActivityRecord splitPrimaryActivity = new TaskBuilder(mSupervisor)

                .setParentTaskFragment(splitOrg.mPrimary)

                .setCreateActivity(true)

                .build()

                .getTopMostActivity();

        final ActivityRecord splitSecondActivity = new TaskBuilder(mSupervisor)

                .setParentTaskFragment(splitOrg.mSecondary)

                .setCreateActivity(true)

                .build()

                .getTopMostActivity();

        splitPrimaryActivity.mVisibleRequested = splitSecondActivity.mVisibleRequested = true;



        assertEquals(splitOrg.mPrimary, splitPrimaryActivity.getRootTask());
@@ -1090,7 +1091,7 @@ public class ActivityStarterTests extends WindowTestsBase { 
        starter.setActivityOptions(options.toBundle())

                .setReason("testWindowingModeOptionsLaunchAdjacent")

                .setOutActivity(outActivity).execute();

        assertThat(outActivity[0].inSplitScreenSecondaryWindowingMode()).isTrue();

        assertThat(outActivity[0].inMultiWindowMode()).isTrue();

    }



    @Test
@@ -1107,50 +1108,6 @@ public class ActivityStarterTests extends WindowTestsBase { 
        verify(recentTasks, times(1)).add(any());

    }



    @Test

    public void testStartActivityInner_allSplitScreenPrimaryActivitiesVisible() {

        // Given

        final ActivityStarter starter = prepareStarter(0, false);



        starter.setReason("testAllSplitScreenPrimaryActivitiesAreResumed");



        final ActivityRecord targetRecord = new ActivityBuilder(mAtm).build();

        targetRecord.setFocusable(false);

        targetRecord.setVisibility(false);

        final ActivityRecord sourceRecord = new ActivityBuilder(mAtm).build();



        final Task stack = spy(

                mRootWindowContainer.getDefaultTaskDisplayArea()

                        .createRootTask(WINDOWING_MODE_SPLIT_SCREEN_PRIMARY, ACTIVITY_TYPE_STANDARD,

                                /* onTop */true));



        stack.addChild(targetRecord);



        doReturn(stack).when(mRootWindowContainer).getLaunchRootTask(any(), any(), any(), any(),

                anyBoolean(), any(), anyInt(), anyInt(), anyInt());



        starter.mStartActivity = new ActivityBuilder(mAtm).build();



        // When

        starter.startActivityInner(

                /* r */targetRecord,

                /* sourceRecord */ sourceRecord,

                /* voiceSession */null,

                /* voiceInteractor */ null,

                /* startFlags */ 0,

                /* doResume */true,

                /* options */null,

                /* inTask */null,

                /* inTaskFragment */ null,

                /* restrictedBgActivity */false,

                /* intentGrants */null);



        // Then

        verify(stack).ensureActivitiesVisible(null, 0, !PRESERVE_WINDOWS);

        verify(targetRecord).makeVisibleIfNeeded(null, true);

        assertTrue(targetRecord.mVisibleRequested);

    }



    @Test

    public void testStartActivityInner_inTaskFragment() {

        final ActivityStarter starter = prepareStarter(0, false);

services/tests/wmtests/src/com/android/server/wm/RootTaskTests.java

+24 −121
Original line number Diff line number Diff line
@@ -22,6 +22,7 @@ import static android.app.WindowConfiguration.ACTIVITY_TYPE_STANDARD; 
import static android.app.WindowConfiguration.ACTIVITY_TYPE_UNDEFINED;

import static android.app.WindowConfiguration.WINDOWING_MODE_FREEFORM;

import static android.app.WindowConfiguration.WINDOWING_MODE_FULLSCREEN;

import static android.app.WindowConfiguration.WINDOWING_MODE_MULTI_WINDOW;

import static android.app.WindowConfiguration.WINDOWING_MODE_PINNED;

import static android.app.WindowConfiguration.WINDOWING_MODE_SPLIT_SCREEN_PRIMARY;

import static android.app.WindowConfiguration.WINDOWING_MODE_SPLIT_SCREEN_SECONDARY;
@@ -240,7 +241,7 @@ public class RootTaskTests extends WindowTestsBase { 
        final WindowConfiguration windowConfiguration =

                task.getResolvedOverrideConfiguration().windowConfiguration;

        spyOn(windowConfiguration);

        doReturn(WINDOWING_MODE_SPLIT_SCREEN_SECONDARY)

        doReturn(WINDOWING_MODE_MULTI_WINDOW)

                .when(windowConfiguration).getWindowingMode();



        // Prevent adjust task dimensions
@@ -322,73 +323,13 @@ public class RootTaskTests extends WindowTestsBase { 
        assertEquals(r, destRootTask.getTopResumedActivity());

    }



    @Test

    public void testPrimarySplitScreenMoveToBack() {

        TestSplitOrganizer organizer = new TestSplitOrganizer(mAtm);

        // We're testing an edge case here where we have primary + fullscreen rather than secondary.

        organizer.setMoveToSecondaryOnEnter(false);



        // Create primary splitscreen root task.

        final Task primarySplitScreen = new TaskBuilder(mAtm.mTaskSupervisor)

                .setParentTaskFragment(organizer.mPrimary)

                .setOnTop(true)

                .build();



        // Assert windowing mode.

        assertEquals(WINDOWING_MODE_SPLIT_SCREEN_PRIMARY, primarySplitScreen.getWindowingMode());



        // Move primary to back.

        primarySplitScreen.moveToBack("testPrimarySplitScreenToFullscreenWhenMovedToBack",

                null /* task */);



        // Assert that root task is at the bottom.

        assertEquals(0, getTaskIndexOf(mDefaultTaskDisplayArea, primarySplitScreen));



        // Ensure no longer in splitscreen.

        assertEquals(WINDOWING_MODE_FULLSCREEN, primarySplitScreen.getWindowingMode());



        // Ensure that the override mode is restored to undefined

        assertEquals(WINDOWING_MODE_UNDEFINED,

                primarySplitScreen.getRequestedOverrideWindowingMode());

    }



    @Test

    public void testMoveToPrimarySplitScreenThenMoveToBack() {

        TestSplitOrganizer organizer = new TestSplitOrganizer(mAtm);

        // This time, start with a fullscreen activity root task.

        final Task primarySplitScreen = mDefaultTaskDisplayArea.createRootTask(

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



        primarySplitScreen.reparent(organizer.mPrimary, POSITION_TOP,

                false /*moveParents*/, "test");



        // Assert windowing mode.

        assertEquals(WINDOWING_MODE_SPLIT_SCREEN_PRIMARY, primarySplitScreen.getWindowingMode());



        // Move primary to back.

        primarySplitScreen.moveToBack("testPrimarySplitScreenToFullscreenWhenMovedToBack",

                null /* task */);



        // Assert that root task is at the bottom.

        assertEquals(primarySplitScreen, organizer.mSecondary.getChildAt(0));



        // Ensure that the override mode is restored to what it was (fullscreen)

        assertEquals(WINDOWING_MODE_UNDEFINED,

                primarySplitScreen.getRequestedOverrideWindowingMode());

    }



    @Test

    public void testSplitScreenMoveToBack() {

        TestSplitOrganizer organizer = new TestSplitOrganizer(mAtm);

        // Explicitly reparent task to primary split root to enter split mode, in which implies

        // primary on top and secondary containing the home task below another root task.

        final Task primaryTask = mDefaultTaskDisplayArea.createRootTask(

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

        final Task secondaryTask = mDefaultTaskDisplayArea.createRootTask(

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

        final Task primaryTask = organizer.createTaskToPrimary(true /* onTop */);

        final Task secondaryTask = organizer.createTaskToSecondary(true /* onTop */);

        final Task homeRoot = mDefaultTaskDisplayArea.getRootTask(

                WINDOWING_MODE_FULLSCREEN, ACTIVITY_TYPE_HOME);

        primaryTask.reparent(organizer.mPrimary, POSITION_TOP);

        mDefaultTaskDisplayArea.positionChildAt(POSITION_TOP, organizer.mPrimary,

                false /* includingParents */);
@@ -397,21 +338,26 @@ public class RootTaskTests extends WindowTestsBase { 


        // Assert that the primaryTask is now below home in its parent but primary is left alone.

        assertEquals(0, organizer.mPrimary.getChildCount());

        assertEquals(primaryTask, organizer.mSecondary.getChildAt(0));

        // Assert that root task is at the bottom.

        assertEquals(0, getTaskIndexOf(mDefaultTaskDisplayArea, primaryTask));

        assertEquals(1, organizer.mPrimary.compareTo(organizer.mSecondary));

        assertEquals(1, homeRoot.compareTo(primaryTask));

        assertEquals(homeRoot.getParent(), primaryTask.getParent());



        // Make sure windowing modes are correct

        assertEquals(WINDOWING_MODE_SPLIT_SCREEN_PRIMARY, organizer.mPrimary.getWindowingMode());

        assertEquals(WINDOWING_MODE_SPLIT_SCREEN_SECONDARY, primaryTask.getWindowingMode());

        assertEquals(WINDOWING_MODE_MULTI_WINDOW, organizer.mPrimary.getWindowingMode());

        assertEquals(WINDOWING_MODE_MULTI_WINDOW, secondaryTask.getWindowingMode());

        // Ensure no longer in splitscreen.

        assertEquals(WINDOWING_MODE_FULLSCREEN, primaryTask.getWindowingMode());

        // Ensure that the override mode is restored to undefined

        assertEquals(WINDOWING_MODE_UNDEFINED, primaryTask.getRequestedOverrideWindowingMode());



        // Move secondary to back via parent (should be equivalent)

        organizer.mSecondary.moveToBack("test", secondaryTask);



        // Assert that it is now in back but still in secondary split

        // Assert that it is now in back and left in secondary split

        assertEquals(0, organizer.mSecondary.getChildCount());

        assertEquals(1, homeRoot.compareTo(primaryTask));

        assertEquals(secondaryTask, organizer.mSecondary.getChildAt(0));

        assertEquals(1, primaryTask.compareTo(secondaryTask));

        assertEquals(homeRoot.getParent(), secondaryTask.getParent());

    }
@@ -423,7 +369,7 @@ public class RootTaskTests extends WindowTestsBase { 
                .setTask(rootHomeTask)

                .build();

        final Task secondaryRootTask = mAtm.mTaskOrganizerController.createRootTask(

                rootHomeTask.getDisplayContent(), WINDOWING_MODE_SPLIT_SCREEN_SECONDARY, null);

                rootHomeTask.getDisplayContent(), WINDOWING_MODE_MULTI_WINDOW, null);



        rootHomeTask.reparent(secondaryRootTask, POSITION_TOP);

        assertEquals(secondaryRootTask, rootHomeTask.getParent());
@@ -581,6 +527,7 @@ public class RootTaskTests extends WindowTestsBase { 
        assertTrue(pinnedRootTask.shouldBeVisible(null /* starting */));

    }



    // TODO(b/199236198): check this is unnecessary or need to migrate after remove legacy split.

    @Test

    public void testShouldBeVisible_SplitScreen() {

        // task not supporting split should be fullscreen for this test.
@@ -700,30 +647,23 @@ public class RootTaskTests extends WindowTestsBase { 


    @Test

    public void testGetVisibility_MultiLevel() {

        final Task homeRootTask = createTaskForShouldBeVisibleTest(mDefaultTaskDisplayArea,

                WINDOWING_MODE_UNDEFINED, ACTIVITY_TYPE_HOME, true /* onTop */);

        TestSplitOrganizer organizer = new TestSplitOrganizer(mAtm);

        final Task splitPrimary = createTaskForShouldBeVisibleTest(mDefaultTaskDisplayArea,

                WINDOWING_MODE_SPLIT_SCREEN_PRIMARY, ACTIVITY_TYPE_UNDEFINED, true /* onTop */);

        // Creating as two-level tasks so home task can be reparented to split-secondary root task.

                WINDOWING_MODE_UNDEFINED, ACTIVITY_TYPE_UNDEFINED, true /* onTop */);

        final Task splitSecondary = createTaskForShouldBeVisibleTest(mDefaultTaskDisplayArea,

                WINDOWING_MODE_SPLIT_SCREEN_SECONDARY, ACTIVITY_TYPE_UNDEFINED, true /* onTop */,

                true /* twoLevelTask */);

                WINDOWING_MODE_UNDEFINED, ACTIVITY_TYPE_UNDEFINED, true /* onTop */);



        doReturn(false).when(homeRootTask).isTranslucent(any());

        doReturn(false).when(splitPrimary).isTranslucent(any());

        doReturn(false).when(splitSecondary).isTranslucent(any());



        // Re-parent home to split secondary.

        homeRootTask.reparent(splitSecondary, POSITION_TOP);

        // Current tasks should be visible.

        // Re-parent tasks to split.

        organizer.putTaskToPrimary(splitPrimary, true /* onTop */);

        organizer.putTaskToSecondary(splitSecondary, true /* onTop */);

        // Reparented tasks should be visible.

        assertEquals(TASK_FRAGMENT_VISIBILITY_VISIBLE,

                splitPrimary.getVisibility(null /* starting */));

        assertEquals(TASK_FRAGMENT_VISIBILITY_VISIBLE,

                splitSecondary.getVisibility(null /* starting */));

        // Home task should still be visible even though it is a child of another visible task.

        assertEquals(TASK_FRAGMENT_VISIBILITY_VISIBLE,

                homeRootTask.getVisibility(null /* starting */));





        // Add fullscreen translucent task that partially occludes split tasks

        final Task translucentRootTask = createStandardRootTaskForVisibilityTest(
@@ -736,19 +676,12 @@ public class RootTaskTests extends WindowTestsBase { 
                splitPrimary.getVisibility(null /* starting */));

        assertEquals(TASK_FRAGMENT_VISIBILITY_VISIBLE_BEHIND_TRANSLUCENT,

                splitSecondary.getVisibility(null /* starting */));

        // Home task should be visible behind translucent since its parent is visible behind

        // translucent.

        assertEquals(TASK_FRAGMENT_VISIBILITY_VISIBLE_BEHIND_TRANSLUCENT,

                homeRootTask.getVisibility(null /* starting */));





        // Hide split-secondary

        splitSecondary.setForceHidden(FLAG_FORCE_HIDDEN_FOR_TASK_ORG, true /* set */);

        organizer.mSecondary.setForceHidden(FLAG_FORCE_HIDDEN_FOR_TASK_ORG, true /* set */);

        // Home split secondary and home task should be invisible.

        assertEquals(TASK_FRAGMENT_VISIBILITY_INVISIBLE,

                splitSecondary.getVisibility(null /* starting */));

        assertEquals(TASK_FRAGMENT_VISIBILITY_INVISIBLE,

                homeRootTask.getVisibility(null /* starting */));

    }



    @Test
@@ -1094,36 +1027,6 @@ public class RootTaskTests extends WindowTestsBase { 
        assertEquals(pinnedRootTask, getRootTaskAbove(alwaysOnTopRootTask2));

    }



    @Test

    public void testSplitScreenMoveToFront() {

        final Task splitScreenPrimary = createTaskForShouldBeVisibleTest(mDefaultTaskDisplayArea,

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

        final Task splitScreenSecondary = createTaskForShouldBeVisibleTest(mDefaultTaskDisplayArea,

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

        final Task assistantRootTask = createTaskForShouldBeVisibleTest(mDefaultTaskDisplayArea,

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



        doReturn(false).when(splitScreenPrimary).isTranslucent(any());

        doReturn(false).when(splitScreenSecondary).isTranslucent(any());

        doReturn(false).when(assistantRootTask).isTranslucent(any());



        assertFalse(splitScreenPrimary.shouldBeVisible(null /* starting */));

        assertFalse(splitScreenSecondary.shouldBeVisible(null /* starting */));

        assertTrue(assistantRootTask.shouldBeVisible(null /* starting */));



        splitScreenSecondary.moveToFront("testSplitScreenMoveToFront");



        if (isAssistantOnTop()) {

            assertFalse(splitScreenPrimary.shouldBeVisible(null /* starting */));

            assertFalse(splitScreenSecondary.shouldBeVisible(null /* starting */));

            assertTrue(assistantRootTask.shouldBeVisible(null /* starting */));

        } else {

            assertTrue(splitScreenPrimary.shouldBeVisible(null /* starting */));

            assertTrue(splitScreenSecondary.shouldBeVisible(null /* starting */));

            assertFalse(assistantRootTask.shouldBeVisible(null /* starting */));

        }

    }



    private Task createStandardRootTaskForVisibilityTest(int windowingMode,

            boolean translucent) {

        final Task rootTask = createTaskForShouldBeVisibleTest(mDefaultTaskDisplayArea,

services/tests/wmtests/src/com/android/server/wm/SizeCompatTests.java

+7 −7
Original line number Diff line number Diff line
@@ -16,7 +16,7 @@ 


package com.android.server.wm;



import static android.app.WindowConfiguration.WINDOWING_MODE_SPLIT_SCREEN_PRIMARY;

import static android.app.WindowConfiguration.WINDOWING_MODE_MULTI_WINDOW;

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

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

import static android.content.pm.ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE;
@@ -937,8 +937,8 @@ public class SizeCompatTests extends WindowTestsBase { 
        mTask.reparent(organizer.mPrimary, POSITION_TOP,

                false /*moveParents*/, "test");

        organizer.mPrimary.setBounds(0, 0, 1000, 1400);

        assertEquals(WINDOWING_MODE_SPLIT_SCREEN_PRIMARY, mTask.getWindowingMode());

        assertEquals(WINDOWING_MODE_SPLIT_SCREEN_PRIMARY, activity.getWindowingMode());

        assertEquals(WINDOWING_MODE_MULTI_WINDOW, mTask.getWindowingMode());

        assertEquals(WINDOWING_MODE_MULTI_WINDOW, activity.getWindowingMode());



        // Resizable activity is sandboxed due to config being enabled.

        assertActivityMaxBoundsSandboxed(activity);
@@ -1828,8 +1828,8 @@ public class SizeCompatTests extends WindowTestsBase { 
        mTask.reparent(organizer.mPrimary, POSITION_TOP,

                false /*moveParents*/, "test");

        organizer.mPrimary.setBounds(0, 0, 1000, 1400);

        assertEquals(WINDOWING_MODE_SPLIT_SCREEN_PRIMARY, mTask.getWindowingMode());

        assertEquals(WINDOWING_MODE_SPLIT_SCREEN_PRIMARY, mActivity.getWindowingMode());

        assertEquals(WINDOWING_MODE_MULTI_WINDOW, mTask.getWindowingMode());

        assertEquals(WINDOWING_MODE_MULTI_WINDOW, mActivity.getWindowingMode());



        // Non-resizable activity in size compat mode

        assertScaled();
@@ -1868,8 +1868,8 @@ public class SizeCompatTests extends WindowTestsBase { 
        mTask.reparent(organizer.mPrimary, POSITION_TOP,

                false /*moveParents*/, "test");

        organizer.mPrimary.setBounds(0, 0, 1000, 1400);

        assertEquals(WINDOWING_MODE_SPLIT_SCREEN_PRIMARY, mTask.getWindowingMode());

        assertEquals(WINDOWING_MODE_SPLIT_SCREEN_PRIMARY, mActivity.getWindowingMode());

        assertEquals(WINDOWING_MODE_MULTI_WINDOW, mTask.getWindowingMode());

        assertEquals(WINDOWING_MODE_MULTI_WINDOW, mActivity.getWindowingMode());



        // Non-resizable activity in size compat mode

        assertScaled();

services/tests/wmtests/src/com/android/server/wm/WindowTestsBase.java

+36 −50

File changed.

Preview size limit exceeded, changes collapsed.