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

Commit 6004383e authored by Massimo Carli's avatar Massimo Carli
Browse files

[4/n] Create TaskAppearedListener and TaskInfoChangedListener

The TaskInfoChangedListener and TaskAppearedListener have been
added to allow Listeners to only observer TaskInfo changes for
a given Task without creating a TaskListener which is limited
by the WindowingMode.

Flag: EXEMPT Refactoring
Fix: 417649431
Test: atest WMShellUnitTests:ShellTaskOrganizerTests

Change-Id: I5656f20523170c25b37e01734a0dff887a7f6a98
parent 03fdfe5c
Loading
Loading
Loading
Loading
+89 −5
Original line number Diff line number Diff line
@@ -103,10 +103,9 @@ public class ShellTaskOrganizer extends TaskOrganizer {
    /**
     * Callbacks for when the tasks change in the system.
     */
    public interface TaskListener {
        default void onTaskAppeared(RunningTaskInfo taskInfo, SurfaceControl leash) {}
        default void onTaskInfoChanged(RunningTaskInfo taskInfo) {}
        default void onTaskVanished(RunningTaskInfo taskInfo) {}
    public interface TaskListener extends TaskVanishedListener, TaskAppearedListener,
            TaskInfoChangedListener {

        default void onBackPressedOnTaskRoot(RunningTaskInfo taskInfo) {}
        /** Whether this task listener supports compat UI. */
        default boolean supportCompatUI() {
@@ -133,9 +132,44 @@ public class ShellTaskOrganizer extends TaskOrganizer {
     * that is necessary.
     */
    public interface TaskVanishedListener {
        /**
         * Invoked when a Task is removed from Shell.
         *
         * @param taskInfo The RunningTaskInfo for the Task.
         */
        default void onTaskVanished(RunningTaskInfo taskInfo) {}
    }

    /**
     * Limited scope callback to notify when a task is added from the system. This signal is
     * not synchronized with anything (or any transition), and should not be used in cases where
     * that is necessary.
     */
    public interface TaskAppearedListener {
        /**
         * Invoked when a Task appears on Shell. Because the leash can be shared between different
         * implementations, it's important to not apply changes in the related callback.
         *
         * @param taskInfo The RunningTaskInfo for the Task.
         * @param leash    The leash for the Task which should not be changed through this callback.
         */
        default void onTaskAppeared(RunningTaskInfo taskInfo, SurfaceControl leash) {}
    }

    /**
     * Limited scope callback to notify when a task has updated. This signal is
     * not synchronized with anything (or any transition), and should not be used in cases where
     * that is necessary.
     */
    public interface TaskInfoChangedListener {
        /**
         * Invoked when a Task is updated on Shell.
         *
         * @param taskInfo The RunningTaskInfo for the Task.
         */
        default void onTaskInfoChanged(RunningTaskInfo taskInfo) {}
    }

    /**
     * Callbacks for events on a task with a locus id.
     */
@@ -185,10 +219,18 @@ public class ShellTaskOrganizer extends TaskOrganizer {
    private final CopyOnWriteArrayList<FocusListener> mFocusListeners =
            new CopyOnWriteArrayList<>();

    // Listeners that should be notified when a task is removed
    // Listeners that should be notified when a task is vanished.
    private final CopyOnWriteArrayList<TaskVanishedListener> mTaskVanishedListeners =
            new CopyOnWriteArrayList<>();

    // Listeners that should be notified when a task has appeared.
    private final CopyOnWriteArrayList<TaskAppearedListener> mTaskAppearedListeners =
            new CopyOnWriteArrayList<>();

    // Listeners that should be notified when a task is updated
    private final CopyOnWriteArrayList<TaskInfoChangedListener> mTaskInfoChangedListeners =
            new CopyOnWriteArrayList<>();

    private final Object mLock = new Object();
    private StartingWindowController mStartingWindow;

@@ -543,6 +585,42 @@ public class ShellTaskOrganizer extends TaskOrganizer {
        }
    }

    /**
     * Adds a listener to be notified when a task is appears.
     */
    public void addTaskAppearedListener(TaskAppearedListener listener) {
        synchronized (mLock) {
            mTaskAppearedListeners.add(listener);
        }
    }

    /**
     * Removes a task-appeared listener.
     */
    public void removeTaskAppearedListener(TaskAppearedListener listener) {
        synchronized (mLock) {
            mTaskAppearedListeners.remove(listener);
        }
    }

    /**
     * Adds a listener to be notified when a task is updated.
     */
    public void addTaskInfoChangedListener(TaskInfoChangedListener listener) {
        synchronized (mLock) {
            mTaskInfoChangedListeners.add(listener);
        }
    }

    /**
     * Removes a taskInfo-update listener.
     */
    public void removeTaskInfoChangedListener(TaskInfoChangedListener listener) {
        synchronized (mLock) {
            mTaskInfoChangedListeners.remove(listener);
        }
    }

    /**
     * Returns a surface which can be used to attach overlays to the home root task
     */
@@ -635,6 +713,9 @@ public class ShellTaskOrganizer extends TaskOrganizer {
        notifyLocusVisibilityIfNeeded(info.getTaskInfo());
        notifyCompatUI(info.getTaskInfo(), listener);
        mRecentTasks.ifPresent(recentTasks -> recentTasks.onTaskAdded(info.getTaskInfo()));
        for (TaskAppearedListener l : mTaskAppearedListeners) {
            l.onTaskAppeared(info.getTaskInfo(), info.getLeash());
        }
    }

    @Override
@@ -682,6 +763,9 @@ public class ShellTaskOrganizer extends TaskOrganizer {
                }
                mLastFocusedTaskInfo = taskInfo;
            }
            for (TaskInfoChangedListener l : mTaskInfoChangedListeners) {
                l.onTaskInfoChanged(taskInfo);
            }
        }
    }

+39 −0
Original line number Diff line number Diff line
@@ -701,6 +701,45 @@ public class ShellTaskOrganizerTests extends ShellTestCase {
        verify(mRecentTasksController).onTaskRunningInfoChanged(task2);
    }

    @Test
    public void testTaskAppearedListenerCallback() {
        final RunningTaskInfo task1 = createTaskInfo(/* taskId= */ 1, WINDOWING_MODE_FULLSCREEN);

        final RunningTaskInfo[] updatedTasks = new RunningTaskInfo[1];

        final ShellTaskOrganizer.TaskAppearedListener listener =
                new ShellTaskOrganizer.TaskAppearedListener() {
                    @Override
                    public void onTaskAppeared(RunningTaskInfo taskInfo, SurfaceControl leash) {
                        updatedTasks[0] = taskInfo;
                    }
                };

        mOrganizer.addTaskAppearedListener(listener);
        mOrganizer.onTaskAppeared(task1, /* leash= */ null);

        assertEquals(updatedTasks[0], task1);
    }

    @Test
    public void testTaskInfoChangedListenerCallback() {
        RunningTaskInfo task1 = createTaskInfo(/* taskId= */ 1, WINDOWING_MODE_FULLSCREEN);
        mOrganizer.onTaskAppeared(task1, /* leash= */ null);

        RunningTaskInfo[] vanishedTasks = new RunningTaskInfo[1];
        ShellTaskOrganizer.TaskInfoChangedListener listener =
                new ShellTaskOrganizer.TaskInfoChangedListener() {
                    @Override
                    public void onTaskInfoChanged(RunningTaskInfo taskInfo) {
                        vanishedTasks[0] = taskInfo;
                    }
                };
        mOrganizer.addTaskInfoChangedListener(listener);
        mOrganizer.onTaskInfoChanged(task1);

        assertEquals(vanishedTasks[0], task1);
    }

    @Test
    public void testTaskVanishedCallback() {
        RunningTaskInfo task1 = createTaskInfo(/* taskId= */ 1, WINDOWING_MODE_FULLSCREEN);