Keep task hidden until task appeared
- If the task is previously not visible or has no visible children at
the point when we start controlling it in the task org, hide the task
until we send taskAppeared to ensure that the task org can reparent
and show it otherwise we could see a flash of the task.
This happens mainly from two cases:
- when starting a new task with a given win mode, we show it and wait
for first draw before notifying the task org
- when transitioning into pip from swipe up, the activity is hidden
and when it requests to enter pip is made visible again
Since we are hiding the task w/ the pending transaction, we also need
to defer all task org callbacks until that's applied to ensure proper
lifecycle of the calls.
- Also skip app transitions for task org tasks for now
This reverts commit d2fb07e4f632af9ab16667c58b1c1d40711f1544.
Bug: 152809695
Bug: 152134460
Test: Open a bubble, ensure that we don't see the task in fullscreen
first. Enter pip, ensure that we don't see flash of the task
before SysUI can fade it in.
Test: atest PipAnimationControllerTest
Test: atest TaskOrganizerTests
Test: atest SplitScreenTests
Change-Id: I9f1fc5931df1d69a7086c02b633347162cda94bf
diff --git a/services/core/java/com/android/server/wm/TaskOrganizerController.java b/services/core/java/com/android/server/wm/TaskOrganizerController.java
index 22702dd..243af14 100644
--- a/services/core/java/com/android/server/wm/TaskOrganizerController.java
+++ b/services/core/java/com/android/server/wm/TaskOrganizerController.java
@@ -25,6 +25,7 @@
import static com.android.server.wm.WindowOrganizerController.CONTROLLABLE_WINDOW_CONFIGS;
import android.annotation.Nullable;
+import android.app.ActivityManager;
import android.app.ActivityManager.RunningTaskInfo;
import android.app.WindowConfiguration;
import android.content.Intent;
@@ -38,6 +39,7 @@
import android.window.ITaskOrganizerController;
import android.window.WindowContainerToken;
+import com.android.internal.annotations.VisibleForTesting;
import com.android.internal.util.ArrayUtils;
import java.io.PrintWriter;
@@ -46,6 +48,7 @@
import java.util.LinkedList;
import java.util.List;
import java.util.WeakHashMap;
+import java.util.function.Consumer;
/**
* Stores the TaskOrganizers associated with a given windowing mode and
@@ -81,17 +84,95 @@
}
}
}
- };
+ }
+
+ /**
+ * A wrapper class around ITaskOrganizer to ensure that the calls are made in the right
+ * lifecycle order since we may be updating the visibility of task surface controls in a pending
+ * transaction before they are presented to the task org.
+ */
+ private class TaskOrganizerCallbacks {
+ final WindowManagerService mService;
+ final ITaskOrganizer mTaskOrganizer;
+ final Consumer<Runnable> mDeferTaskOrgCallbacksConsumer;
+
+ TaskOrganizerCallbacks(WindowManagerService wm, ITaskOrganizer taskOrg,
+ Consumer<Runnable> deferTaskOrgCallbacksConsumer) {
+ mService = wm;
+ mDeferTaskOrgCallbacksConsumer = deferTaskOrgCallbacksConsumer;
+ mTaskOrganizer = taskOrg;
+ }
+
+ IBinder getBinder() {
+ return mTaskOrganizer.asBinder();
+ }
+
+ void onTaskAppeared(Task task) {
+ final RunningTaskInfo taskInfo = task.getTaskInfo();
+ mDeferTaskOrgCallbacksConsumer.accept(() -> {
+ try {
+ mTaskOrganizer.onTaskAppeared(taskInfo);
+ } catch (RemoteException e) {
+ Slog.e(TAG, "Exception sending onTaskAppeared callback", e);
+ }
+ });
+ }
+
+
+ void onTaskVanished(Task task) {
+ final RunningTaskInfo taskInfo = task.getTaskInfo();
+ mDeferTaskOrgCallbacksConsumer.accept(() -> {
+ try {
+ mTaskOrganizer.onTaskVanished(taskInfo);
+ } catch (RemoteException e) {
+ Slog.e(TAG, "Exception sending onTaskVanished callback", e);
+ }
+ });
+ }
+
+ void onTaskInfoChanged(Task task, ActivityManager.RunningTaskInfo taskInfo) {
+ mDeferTaskOrgCallbacksConsumer.accept(() -> {
+ if (!task.isOrganized()) {
+ // This is safe to ignore if the task is no longer organized
+ return;
+ }
+ try {
+ mTaskOrganizer.onTaskInfoChanged(taskInfo);
+ } catch (RemoteException e) {
+ Slog.e(TAG, "Exception sending onTaskInfoChanged callback", e);
+ }
+ });
+ }
+
+ void onBackPressedOnTaskRoot(Task task) {
+ mDeferTaskOrgCallbacksConsumer.accept(() -> {
+ if (!task.isOrganized()) {
+ // This is safe to ignore if the task is no longer organized
+ return;
+ }
+ try {
+ mTaskOrganizer.onBackPressedOnTaskRoot(task.getTaskInfo());
+ } catch (Exception e) {
+ Slog.e(TAG, "Exception sending onBackPressedOnTaskRoot callback", e);
+ }
+ });
+ }
+ }
private class TaskOrganizerState {
- private final ITaskOrganizer mOrganizer;
+ private final TaskOrganizerCallbacks mOrganizer;
private final DeathRecipient mDeathRecipient;
private final ArrayList<Task> mOrganizedTasks = new ArrayList<>();
private final int mUid;
private boolean mInterceptBackPressedOnTaskRoot;
TaskOrganizerState(ITaskOrganizer organizer, int uid) {
- mOrganizer = organizer;
+ final Consumer<Runnable> deferTaskOrgCallbacksConsumer =
+ mDeferTaskOrgCallbacksConsumer != null
+ ? mDeferTaskOrgCallbacksConsumer
+ : mService.mWindowManager.mAnimator::addAfterPrepareSurfacesRunnable;
+ mOrganizer = new TaskOrganizerCallbacks(mService.mWindowManager, organizer,
+ deferTaskOrgCallbacksConsumer);
mDeathRecipient = new DeathRecipient(organizer);
try {
organizer.asBinder().linkToDeath(mDeathRecipient, 0);
@@ -114,7 +195,7 @@
if (t.taskAppearedReady()) {
try {
t.mTaskAppearedSent = true;
- mOrganizer.onTaskAppeared(t.getTaskInfo());
+ mOrganizer.onTaskAppeared(t);
} catch (Exception e) {
Slog.e(TAG, "Exception sending taskAppeared callback" + e);
}
@@ -125,7 +206,7 @@
if (t.mTaskAppearedSent) {
try {
t.mTaskAppearedSent = false;
- mOrganizer.onTaskVanished(t.getTaskInfo());
+ mOrganizer.onTaskVanished(t);
} catch (Exception e) {
Slog.e(TAG, "Exception sending taskVanished callback" + e);
}
@@ -136,7 +217,7 @@
void dispose() {
releaseTasks();
for (int i = mTaskOrganizersForWindowingMode.size() - 1; i >= 0; --i) {
- mTaskOrganizersForWindowingMode.valueAt(i).remove(mOrganizer.asBinder());
+ mTaskOrganizersForWindowingMode.valueAt(i).remove(mOrganizer.getBinder());
}
}
@@ -149,7 +230,7 @@
}
void unlinkDeath() {
- mOrganizer.asBinder().unlinkToDeath(mDeathRecipient, 0);
+ mOrganizer.getBinder().unlinkToDeath(mDeathRecipient, 0);
}
}
@@ -159,9 +240,10 @@
private final WeakHashMap<Task, RunningTaskInfo> mLastSentTaskInfos = new WeakHashMap<>();
private final ArrayList<Task> mPendingTaskInfoChanges = new ArrayList<>();
- final ActivityTaskManagerService mService;
+ private final ActivityTaskManagerService mService;
- RunningTaskInfo mTmpTaskInfo;
+ private RunningTaskInfo mTmpTaskInfo;
+ private Consumer<Runnable> mDeferTaskOrgCallbacksConsumer;
TaskOrganizerController(ActivityTaskManagerService atm) {
mService = atm;
@@ -173,6 +255,15 @@
}
/**
+ * Specifies the consumer to run to defer the task org callbacks. Can be overridden while
+ * testing to allow the callbacks to be sent synchronously.
+ */
+ @VisibleForTesting
+ public void setDeferTaskOrgCallbacksConsumer(Consumer<Runnable> consumer) {
+ mDeferTaskOrgCallbacksConsumer = consumer;
+ }
+
+ /**
* Register a TaskOrganizer to manage tasks as they enter the given windowing mode.
* If there was already a TaskOrganizer for this windowing mode it will be evicted
* but will continue to organize it's existing tasks.
@@ -263,7 +354,7 @@
if (state == null) {
return null;
}
- return state.mOrganizer;
+ return state.mOrganizer.mTaskOrganizer;
}
void onTaskAppeared(ITaskOrganizer organizer, Task task) {
@@ -368,11 +459,10 @@
// change.
mTmpTaskInfo = null;
- if (task.mTaskOrganizer != null) {
- try {
- task.mTaskOrganizer.onTaskInfoChanged(newInfo);
- } catch (RemoteException e) {
- }
+ if (task.isOrganized()) {
+ final TaskOrganizerState state = mTaskOrganizerStates.get(
+ task.mTaskOrganizer.asBinder());
+ state.mOrganizer.onTaskInfoChanged(task, newInfo);
}
}
@@ -531,11 +621,7 @@
return false;
}
- try {
- state.mOrganizer.onBackPressedOnTaskRoot(task.getTaskInfo());
- } catch (Exception e) {
- Slog.e(TAG, "Exception sending interceptBackPressedOnTaskRoot callback" + e);
- }
+ state.mOrganizer.onBackPressedOnTaskRoot(task);
return true;
}
@@ -552,7 +638,7 @@
final TaskOrganizerState state = mTaskOrganizerStates.get(taskOrgs.get(j));
final ArrayList<Task> tasks = state.mOrganizedTasks;
pw.print(innerPrefix + " ");
- pw.println(state.mOrganizer + " uid=" + state.mUid + ":");
+ pw.println(state.mOrganizer.mTaskOrganizer + " uid=" + state.mUid + ":");
for (int k = 0; k < tasks.size(); k++) {
pw.println(innerPrefix + " " + tasks.get(k));
}