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

Commit 9fd095ba authored by Robert Carr's avatar Robert Carr
Browse files

TaskOrganizer: Control Root Task

Following Stacks becoming Tasks this seems to make more sense.

Bug: 147849315
Bug: 139371701
Test: TaskOrganizerTests
Change-Id: Idee35274d6ab4018b9bc4d43610fdb57db9d8956
parent 6871767a
Loading
Loading
Loading
Loading
+18 −27
Original line number Diff line number Diff line
@@ -660,6 +660,8 @@ class ActivityStack extends Task implements BoundsAnimationTarget {

        super.onConfigurationChanged(newParentConfig);

        updateTaskOrganizerState();

        // Only need to update surface size here since the super method will handle updating
        // surface position.
        updateSurfaceSize(getPendingTransaction());
@@ -762,6 +764,22 @@ class ActivityStack extends Task implements BoundsAnimationTarget {
        }
    }

    void updateTaskOrganizerState() {
        if (!isRootTask()) {
            return;
        }

        final int windowingMode = getWindowingMode();
        /*
         * Different windowing modes may be managed by different task organizers. If
         * getTaskOrganizer returns null, we still call setTaskOrganizer to
         * make sure we clear it.
         */
        final ITaskOrganizer org =
            mWmService.mAtmService.mTaskOrganizerController.getTaskOrganizer(windowingMode);
        setTaskOrganizer(org);
    }

    @Override
    public void setWindowingMode(int windowingMode) {
        // Calling Task#setWindowingMode() for leaf task since this is the a specialization of
@@ -774,15 +792,6 @@ class ActivityStack extends Task implements BoundsAnimationTarget {
        setWindowingMode(windowingMode, false /* animate */, false /* showRecents */,
                false /* enteringSplitScreenMode */, false /* deferEnsuringVisibility */,
                false /* creating */);
        windowingMode = getWindowingMode();
        /*
         * Different windowing modes may be managed by different task organizers. If
         * getTaskOrganizer returns null, we still call transferToTaskOrganizer to
         * make sure we clear it.
         */
        final ITaskOrganizer org =
            mWmService.mAtmService.mTaskOrganizerController.getTaskOrganizer(windowingMode);
        transferToTaskOrganizer(org);
    }

    /**
@@ -1583,24 +1592,6 @@ class ActivityStack extends Task implements BoundsAnimationTarget {
        return topActivity != null && topActivity.mVisibleRequested;
    }

    private static void transferSingleTaskToOrganizer(Task tr, ITaskOrganizer organizer) {
        tr.setTaskOrganizer(organizer);
    }

    /**
     * Transfer control of the leashes and IWindowContainers to the given ITaskOrganizer.
     * This will (or shortly there-after) invoke the taskAppeared callbacks.
     * If the tasks had a previous TaskOrganizer, setTaskOrganizer will take care of
     * emitting the taskVanished callbacks.
     */
    void transferToTaskOrganizer(ITaskOrganizer organizer) {
        final PooledConsumer c = PooledLambda.obtainConsumer(
                ActivityStack::transferSingleTaskToOrganizer,
                PooledLambda.__(Task.class), organizer);
        forAllTasks(c, true /* traverseTopToBottom */, this);
        c.recycle();
    }

    /**
     * Returns true if the stack should be visible.
     *
+2 −20
Original line number Diff line number Diff line
@@ -3864,9 +3864,8 @@ class Task extends WindowContainer<WindowContainer> {
    }

    boolean isControlledByTaskOrganizer() {
        // TODO(b/147849315): Clean-up relationship between task-org and task-hierarchy. Ideally
        //  we only give control of the root task.
        return getTopMostTask().mTaskOrganizer != null;
        final Task rootTask = getRootTask();
        return rootTask == this && rootTask.mTaskOrganizer != null;
    }

    @Override
@@ -3938,23 +3937,6 @@ class Task extends WindowContainer<WindowContainer> {
        super.getRelativeDisplayedPosition(outPos);
    }

    @Override
    public void setWindowingMode(int windowingMode) {
        super.setWindowingMode(windowingMode);
        windowingMode = getWindowingMode();

        // TODO(b/147849315): Clean-up relationship between task-org and task-hierarchy. Ideally
        //  we only give control of the root task.
        // Different windowing modes may be managed by different task organizers. If
        // getTaskOrganizer returns null, we still call transferToTaskOrganizer to make sure we
        // clear it.
        if (!isRootTask()) {
            final ITaskOrganizer org =
                    mAtmService.mTaskOrganizerController.getTaskOrganizer(windowingMode);
            setTaskOrganizer(org);
        }
    }

    /**
     * @return true if the task is currently focused.
     */
+6 −46
Original line number Diff line number Diff line
@@ -80,7 +80,6 @@ public class TaskOrganizerTests extends WindowTestsBase {

        task.setTaskOrganizer(organizer);
        verify(organizer).taskAppeared(any(), any());
        assertTrue(task.isControlledByTaskOrganizer());

        task.removeImmediately();
        verify(organizer).taskVanished(any());
@@ -106,48 +105,13 @@ public class TaskOrganizerTests extends WindowTestsBase {
        final Task task = createTaskInStack(stack, 0 /* userId */);
        final ITaskOrganizer organizer = makeAndRegisterMockOrganizer();

        task.setTaskOrganizer(organizer);
        verify(organizer).taskAppeared(any(), any());
        assertTrue(task.isControlledByTaskOrganizer());

        task.setTaskOrganizer(null);
        verify(organizer).taskVanished(any());
        assertFalse(task.isControlledByTaskOrganizer());
    }

    @Test
    public void testTransferStackToOrganizer() throws RemoteException {
        final ActivityStack stack = createTaskStackOnDisplay(mDisplayContent);
        final Task task = createTaskInStack(stack, 0 /* userId */);
        final Task task2 = createTaskInStack(stack, 0 /* userId */);
        final ITaskOrganizer organizer = makeAndRegisterMockOrganizer();

        stack.transferToTaskOrganizer(organizer);

        verify(organizer, times(2)).taskAppeared(any(), any());
        assertTrue(task.isControlledByTaskOrganizer());
        assertTrue(task2.isControlledByTaskOrganizer());

        stack.transferToTaskOrganizer(null);

        verify(organizer, times(2)).taskVanished(any());
        assertFalse(task.isControlledByTaskOrganizer());
        assertFalse(task2.isControlledByTaskOrganizer());
    }

    @Test
    public void testRegisterTaskOrganizerTaskWindowingModeChanges() throws RemoteException {
        final ITaskOrganizer organizer = makeAndRegisterMockOrganizer();

        final ActivityStack stack = createTaskStackOnDisplay(mDisplayContent);
        final Task task = createTaskInStack(stack, 0 /* userId */);
        task.setWindowingMode(WINDOWING_MODE_PINNED);
        stack.setTaskOrganizer(organizer);
        verify(organizer).taskAppeared(any(), any());
        assertTrue(task.isControlledByTaskOrganizer());
        assertTrue(stack.isControlledByTaskOrganizer());

        task.setWindowingMode(WINDOWING_MODE_FULLSCREEN);
        stack.setTaskOrganizer(null);
        verify(organizer).taskVanished(any());
        assertFalse(task.isControlledByTaskOrganizer());
        assertFalse(stack.isControlledByTaskOrganizer());
    }

    @Test
@@ -158,13 +122,9 @@ public class TaskOrganizerTests extends WindowTestsBase {
        final Task task = createTaskInStack(stack, 0 /* userId */);
        final Task task2 = createTaskInStack(stack, 0 /* userId */);
        stack.setWindowingMode(WINDOWING_MODE_PINNED);
        verify(organizer, times(2)).taskAppeared(any(), any());
        assertTrue(task.isControlledByTaskOrganizer());
        assertTrue(task2.isControlledByTaskOrganizer());
        verify(organizer, times(1)).taskAppeared(any(), any());

        stack.setWindowingMode(WINDOWING_MODE_FULLSCREEN);
        verify(organizer, times(2)).taskVanished(any());
        assertFalse(task.isControlledByTaskOrganizer());
        assertFalse(task2.isControlledByTaskOrganizer());
        verify(organizer, times(1)).taskVanished(any());
    }
}