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

Commit ef931eee authored by Wale Ogunwale's avatar Wale Ogunwale Committed by Automerger Merge Worker
Browse files

Merge "Allow CTS test to control organized tasks" into rvc-dev am: 201af507

Change-Id: I379c4fd14c2b3ffb71bed90eab2aa68bc641cc9f
parents bff61b89 201af507
Loading
Loading
Loading
Loading
+5 −0
Original line number Original line Diff line number Diff line
@@ -505,6 +505,11 @@ package android.app {
    method public boolean isStatusBarExpansionDisabled();
    method public boolean isStatusBarExpansionDisabled();
  }
  }


  public class TaskInfo {
    method @NonNull public android.content.res.Configuration getConfiguration();
    method @NonNull public android.window.WindowContainerToken getToken();
  }

  public class TimePickerDialog extends android.app.AlertDialog implements android.content.DialogInterface.OnClickListener android.widget.TimePicker.OnTimeChangedListener {
  public class TimePickerDialog extends android.app.AlertDialog implements android.content.DialogInterface.OnClickListener android.widget.TimePicker.OnTimeChangedListener {
    method public android.widget.TimePicker getTimePicker();
    method public android.widget.TimePicker getTimePicker();
  }
  }
+15 −0
Original line number Original line Diff line number Diff line
@@ -20,6 +20,7 @@ import static android.content.pm.ActivityInfo.RESIZE_MODE_UNRESIZEABLE;


import android.annotation.NonNull;
import android.annotation.NonNull;
import android.annotation.Nullable;
import android.annotation.Nullable;
import android.annotation.TestApi;
import android.compat.annotation.UnsupportedAppUsage;
import android.compat.annotation.UnsupportedAppUsage;
import android.content.ComponentName;
import android.content.ComponentName;
import android.content.Intent;
import android.content.Intent;
@@ -196,6 +197,20 @@ public class TaskInfo {
        return resizeMode != RESIZE_MODE_UNRESIZEABLE;
        return resizeMode != RESIZE_MODE_UNRESIZEABLE;
    }
    }


    /** @hide */
    @NonNull
    @TestApi
    public WindowContainerToken getToken() {
        return token;
    }

    /** @hide */
    @NonNull
    @TestApi
    public Configuration getConfiguration() {
        return configuration;
    }

    /**
    /**
     * Reads the TaskInfo from a parcel.
     * Reads the TaskInfo from a parcel.
     */
     */
+12 −19
Original line number Original line Diff line number Diff line
@@ -4435,21 +4435,22 @@ class Task extends WindowContainer<WindowContainer> {
        // Let the old organizer know it has lost control.
        // Let the old organizer know it has lost control.
        sendTaskVanished();
        sendTaskVanished();
        mTaskOrganizer = organizer;
        mTaskOrganizer = organizer;
        sendTaskAppeared();
        onTaskOrganizerChanged();
        return true;
    }


    void taskOrganizerUnregistered() {
        if (mTaskOrganizer != null) {
        mTaskOrganizer = null;
            sendTaskAppeared();
        } else {
            // No longer managed by any organizer.
            mTaskAppearedSent = false;
            mTaskAppearedSent = false;
            mLastTaskOrganizerWindowingMode = -1;
            mLastTaskOrganizerWindowingMode = -1;
        onTaskOrganizerChanged();
            setForceHidden(FLAG_FORCE_HIDDEN_FOR_TASK_ORG, false /* set */);
            if (mCreatedByOrganizer) {
            if (mCreatedByOrganizer) {
                removeImmediately();
                removeImmediately();
            }
            }
        }
        }


        return true;
    }

    /**
    /**
     * Called when the task state changes (ie. from windowing mode change) an the task organizer
     * Called when the task state changes (ie. from windowing mode change) an the task organizer
     * state should also be updated.
     * state should also be updated.
@@ -4484,14 +4485,6 @@ class Task extends WindowContainer<WindowContainer> {
        return result;
        return result;
    }
    }


    private void onTaskOrganizerChanged() {
        if (mTaskOrganizer == null) {
            // If this task is no longer controlled by a task organizer, then reset the force hidden
            // state
            setForceHidden(FLAG_FORCE_HIDDEN_FOR_TASK_ORG, false /* set */);
        }
    }

    @Override
    @Override
    void setSurfaceControl(SurfaceControl sc) {
    void setSurfaceControl(SurfaceControl sc) {
        super.setSurfaceControl(sc);
        super.setSurfaceControl(sc);
+22 −19
Original line number Original line Diff line number Diff line
@@ -218,20 +218,26 @@ class TaskOrganizerController extends ITaskOrganizerController.Stub {
        }
        }


        void dispose() {
        void dispose() {
            releaseTasks();
            // Move organizer from managing specific windowing modes
            for (int i = mTaskOrganizersForWindowingMode.size() - 1; i >= 0; --i) {
            for (int i = mTaskOrganizersForWindowingMode.size() - 1; i >= 0; --i) {
                mTaskOrganizersForWindowingMode.valueAt(i).remove(mOrganizer.getBinder());
                mTaskOrganizersForWindowingMode.valueAt(i).remove(mOrganizer.getBinder());
            }
            }
        }


        private void releaseTasks() {
            // Update tasks currently managed by this organizer to the next one available if
            for (int i = mOrganizedTasks.size() - 1; i >= 0; i--) {
            // possible.
                final Task t = mOrganizedTasks.get(i);
            while (!mOrganizedTasks.isEmpty()) {
                final Task t = mOrganizedTasks.get(0);
                t.updateTaskOrganizerState(true /* forceUpdate */);
                if (mOrganizedTasks.contains(t)) {
                    removeTask(t);
                    removeTask(t);
                t.taskOrganizerUnregistered();
                }
                }
            }
            }


            // Remove organizer state after removing tasks so we get a chance to send
            // onTaskVanished.
            mTaskOrganizerStates.remove(asBinder());
        }

        void unlinkDeath() {
        void unlinkDeath() {
            mOrganizer.getBinder().unlinkToDeath(mDeathRecipient, 0);
            mOrganizer.getBinder().unlinkToDeath(mDeathRecipient, 0);
        }
        }
@@ -313,17 +319,12 @@ class TaskOrganizerController extends ITaskOrganizerController.Stub {
                            new TaskOrganizerState(organizer, uid));
                            new TaskOrganizerState(organizer, uid));
                }
                }


                if (orgs.size() == 1) {
                    // Only in the case where this is the root task organizer for the given
                    // windowing mode, we add report all existing tasks in that mode to the new
                    // task organizer.
                mService.mRootWindowContainer.forAllTasks((task) -> {
                mService.mRootWindowContainer.forAllTasks((task) -> {
                    if (task.getWindowingMode() == windowingMode) {
                    if (task.getWindowingMode() == windowingMode) {
                        task.updateTaskOrganizerState(true /* forceUpdate */);
                        task.updateTaskOrganizerState(true /* forceUpdate */);
                    }
                    }
                });
                });
            }
            }
            }
        } finally {
        } finally {
            Binder.restoreCallingIdentity(origId);
            Binder.restoreCallingIdentity(origId);
        }
        }
@@ -335,7 +336,7 @@ class TaskOrganizerController extends ITaskOrganizerController.Stub {
        final long origId = Binder.clearCallingIdentity();
        final long origId = Binder.clearCallingIdentity();
        try {
        try {
            synchronized (mGlobalLock) {
            synchronized (mGlobalLock) {
                final TaskOrganizerState state = mTaskOrganizerStates.remove(organizer.asBinder());
                final TaskOrganizerState state = mTaskOrganizerStates.get(organizer.asBinder());
                if (state == null) {
                if (state == null) {
                    return;
                    return;
                }
                }
@@ -367,8 +368,10 @@ class TaskOrganizerController extends ITaskOrganizerController.Stub {


    void onTaskVanished(ITaskOrganizer organizer, Task task) {
    void onTaskVanished(ITaskOrganizer organizer, Task task) {
        final TaskOrganizerState state = mTaskOrganizerStates.get(organizer.asBinder());
        final TaskOrganizerState state = mTaskOrganizerStates.get(organizer.asBinder());
        if (state != null) {
            state.removeTask(task);
            state.removeTask(task);
        }
        }
    }


    @Override
    @Override
    public RunningTaskInfo createRootTask(int displayId, int windowingMode) {
    public RunningTaskInfo createRootTask(int displayId, int windowingMode) {
+13 −5
Original line number Original line Diff line number Diff line
@@ -81,7 +81,7 @@ import java.util.List;
 * Test class for {@link ITaskOrganizer} and {@link android.window.ITaskOrganizerController}.
 * Test class for {@link ITaskOrganizer} and {@link android.window.ITaskOrganizerController}.
 *
 *
 * Build/Install/Run:
 * Build/Install/Run:
 *  atest WmTests:TaskOrganizerTests
 *  atest WmTests:WindowOrganizerTests
 */
 */
@SmallTest
@SmallTest
@Presubmit
@Presubmit
@@ -264,15 +264,22 @@ public class WindowOrganizerTests extends WindowTestsBase {
        // newly entering the windowing mode.
        // newly entering the windowing mode.
        final ITaskOrganizer organizer2 = registerMockOrganizer(WINDOWING_MODE_MULTI_WINDOW);
        final ITaskOrganizer organizer2 = registerMockOrganizer(WINDOWING_MODE_MULTI_WINDOW);
        stack2.setWindowingMode(WINDOWING_MODE_MULTI_WINDOW);
        stack2.setWindowingMode(WINDOWING_MODE_MULTI_WINDOW);
        verify(organizer2).onTaskAppeared(any());
        // One each for task and task2
        verify(organizer2, times(2)).onTaskAppeared(any());
        verify(organizer2, times(0)).onTaskVanished(any());
        // One for task
        verify(organizer).onTaskVanished(any());
        assertTrue(stack2.isOrganized());
        assertTrue(stack2.isOrganized());


        // Now we unregister the second one, the first one should automatically be reregistered
        // Now we unregister the second one, the first one should automatically be reregistered
        // so we verify that it's now seeing changes.
        // so we verify that it's now seeing changes.
        mWm.mAtmService.mTaskOrganizerController.unregisterTaskOrganizer(organizer2);
        mWm.mAtmService.mTaskOrganizerController.unregisterTaskOrganizer(organizer2);
        verify(organizer, times(3)).onTaskAppeared(any());
        verify(organizer2, times(2)).onTaskVanished(any());


        stack3.setWindowingMode(WINDOWING_MODE_MULTI_WINDOW);
        stack3.setWindowingMode(WINDOWING_MODE_MULTI_WINDOW);
        verify(organizer, times(2)).onTaskAppeared(any());
        verify(organizer, times(4)).onTaskAppeared(any());
        verify(organizer2, times(2)).onTaskVanished(any());
        assertTrue(stack3.isOrganized());
        assertTrue(stack3.isOrganized());
    }
    }


@@ -902,12 +909,13 @@ public class WindowOrganizerTests extends WindowTestsBase {
        task.setHasBeenVisible(true);
        task.setHasBeenVisible(true);
        verify(organizer, times(1)).onTaskAppeared(any());
        verify(organizer, times(1)).onTaskAppeared(any());


        task.taskOrganizerUnregistered();
        task.setTaskOrganizer(null);
        verify(organizer, times(1)).onTaskVanished(any());
        task.setTaskOrganizer(organizer);
        task.setTaskOrganizer(organizer);
        verify(organizer, times(2)).onTaskAppeared(any());
        verify(organizer, times(2)).onTaskAppeared(any());


        task.removeImmediately();
        task.removeImmediately();
        verify(organizer).onTaskVanished(any());
        verify(organizer, times(2)).onTaskVanished(any());
    }
    }


    @Test
    @Test