Merge "Revert "Keep task hidden until task appeared"" into rvc-dev

core/java/android/window/TaskOrganizerTaskEmbedder.java

@@ -254,9 +254,7 @@ public class TaskOrganizerTaskEmbedder extends TaskEmbedder {
             mTaskToken = taskInfo.token;
             mTaskLeash = mTaskToken.getLeash();
             mTransaction.reparent(mTaskLeash, mSurfaceControl)
-                    .show(mTaskLeash)
+                    .show(mSurfaceControl).apply();
-                    .show(mSurfaceControl)
-                    .apply();
             if (mPendingNotifyBoundsChanged) {
                 // TODO: Either defer show or hide and synchronize show with the resize
                 notifyBoundsChanged();

packages/SystemUI/src/com/android/systemui/pip/PipAnimationController.java

@@ -319,7 +319,6 @@ public class PipAnimationController {
                     getSurfaceTransactionHelper()
                             .crop(tx, leash, getDestinationBounds())
                             .round(tx, leash, shouldApplyCornerRadius());
-                    tx.show(leash);
                     tx.apply();
                 }
             };
@@ -360,7 +359,6 @@ public class PipAnimationController {
                     getSurfaceTransactionHelper()
                             .alpha(tx, leash, 1f)
                             .round(tx, leash, shouldApplyCornerRadius());
-                    tx.show(leash);
                     tx.apply();
                 }
 

packages/SystemUI/tests/src/com/android/systemui/pip/PipAnimationControllerTest.java

@@ -51,6 +51,7 @@ public class PipAnimationControllerTest extends SysuiTestCase {
 
     private PipAnimationController mPipAnimationController;
 
+    @Mock
     private SurfaceControl mLeash;
 
     @Mock
@@ -60,10 +61,6 @@ public class PipAnimationControllerTest extends SysuiTestCase {
     public void setUp() throws Exception {
         mPipAnimationController = new PipAnimationController(
                 mContext, new PipSurfaceTransactionHelper(mContext));
-        mLeash = new SurfaceControl.Builder()
-                .setContainerLayer()
-                .setName("FakeLeash")
-                .build();
         MockitoAnnotations.initMocks(this);
     }
 

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

@@ -4131,17 +4131,6 @@ class Task extends WindowContainer<WindowContainer> {
         // Let the old organizer know it has lost control.
         sendTaskVanished();
         mTaskOrganizer = organizer;
-
-        // If the task is not yet visible when it is added to the task organizer, then we should
-        // hide it to allow the task organizer to show it when it is properly reparented. We skip
-        // this for tasks created by the organizer because they can synchronously update the leash
-        // before new children are added to the task.
-        if (!mCreatedByOrganizer && organizer != null
-                && (!getHasBeenVisible() || !hasVisibleChildren())) {
-            getPendingTransaction().hide(getSurfaceControl());
-            commitPendingTransaction();
-        }
-
         sendTaskAppeared();
         onTaskOrganizerChanged();
         return true;

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

@@ -25,7 +25,6 @@ import static com.android.server.wm.WindowOrganizerController.CONTROLLABLE_CONFI
 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;
@@ -39,7 +38,6 @@ import android.window.ITaskOrganizer;
 import android.window.ITaskOrganizerController;
 import android.window.WindowContainerToken;
 
-import com.android.internal.annotations.VisibleForTesting;
 import com.android.internal.util.ArrayUtils;
 
 import java.io.PrintWriter;
@@ -48,7 +46,6 @@ import java.util.HashMap;
 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
@@ -84,95 +81,17 @@ class TaskOrganizerController extends ITaskOrganizerController.Stub {
                 }
             }
         }
-    }
+    };
-
-    /**
-     * 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 TaskOrganizerCallbacks mOrganizer;
+        private final ITaskOrganizer mOrganizer;
         private final DeathRecipient mDeathRecipient;
         private final ArrayList<Task> mOrganizedTasks = new ArrayList<>();
         private final int mUid;
         private boolean mInterceptBackPressedOnTaskRoot;
 
         TaskOrganizerState(ITaskOrganizer organizer, int uid) {
-            final Consumer<Runnable> deferTaskOrgCallbacksConsumer =
+            mOrganizer = organizer;
-                    mDeferTaskOrgCallbacksConsumer != null
-                            ? mDeferTaskOrgCallbacksConsumer
-                            : mService.mWindowManager.mAnimator::addAfterPrepareSurfacesRunnable;
-            mOrganizer = new TaskOrganizerCallbacks(mService.mWindowManager, organizer,
-                    deferTaskOrgCallbacksConsumer);
             mDeathRecipient = new DeathRecipient(organizer);
             try {
                 organizer.asBinder().linkToDeath(mDeathRecipient, 0);
@@ -188,18 +107,26 @@ class TaskOrganizerController extends ITaskOrganizerController.Stub {
 
         void addTask(Task t) {
             mOrganizedTasks.add(t);
-            mOrganizer.onTaskAppeared(t);
+            try {
+                mOrganizer.onTaskAppeared(t.getTaskInfo());
+            } catch (Exception e) {
+                Slog.e(TAG, "Exception sending taskAppeared callback" + e);
+            }
         }
 
         void removeTask(Task t) {
+            try {
+                mOrganizer.onTaskVanished(t.getTaskInfo());
+            } catch (Exception e) {
+                Slog.e(TAG, "Exception sending taskVanished callback" + e);
+            }
             mOrganizedTasks.remove(t);
-            mOrganizer.onTaskVanished(t);
         }
 
         void dispose() {
             releaseTasks();
             for (int i = mTaskOrganizersForWindowingMode.size() - 1; i >= 0; --i) {
-                mTaskOrganizersForWindowingMode.valueAt(i).remove(mOrganizer.getBinder());
+                mTaskOrganizersForWindowingMode.valueAt(i).remove(mOrganizer.asBinder());
             }
         }
 
@@ -212,7 +139,7 @@ class TaskOrganizerController extends ITaskOrganizerController.Stub {
         }
 
         void unlinkDeath() {
-            mOrganizer.getBinder().unlinkToDeath(mDeathRecipient, 0);
+            mOrganizer.asBinder().unlinkToDeath(mDeathRecipient, 0);
         }
     }
 
@@ -222,10 +149,9 @@ class TaskOrganizerController extends ITaskOrganizerController.Stub {
     private final WeakHashMap<Task, RunningTaskInfo> mLastSentTaskInfos = new WeakHashMap<>();
     private final ArrayList<Task> mPendingTaskInfoChanges = new ArrayList<>();
 
-    private final ActivityTaskManagerService mService;
+    final ActivityTaskManagerService mService;
 
-    private RunningTaskInfo mTmpTaskInfo;
+    RunningTaskInfo mTmpTaskInfo;
-    private Consumer<Runnable> mDeferTaskOrgCallbacksConsumer;
 
     TaskOrganizerController(ActivityTaskManagerService atm) {
         mService = atm;
@@ -236,15 +162,6 @@ class TaskOrganizerController extends ITaskOrganizerController.Stub {
         mService.mAmInternal.enforceCallingPermission(MANAGE_ACTIVITY_STACKS, func);
     }
 
-    /**
-     * 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
@@ -336,7 +253,7 @@ class TaskOrganizerController extends ITaskOrganizerController.Stub {
         if (state == null) {
             return null;
         }
-        return state.mOrganizer.mTaskOrganizer;
+        return state.mOrganizer;
     }
 
     void onTaskAppeared(ITaskOrganizer organizer, Task task) {
@@ -441,10 +358,11 @@ class TaskOrganizerController extends ITaskOrganizerController.Stub {
         // change.
         mTmpTaskInfo = null;
 
-        if (task.isOrganized()) {
+        if (task.mTaskOrganizer != null) {
-            final TaskOrganizerState state = mTaskOrganizerStates.get(
+            try {
-                    task.mTaskOrganizer.asBinder());
+                task.mTaskOrganizer.onTaskInfoChanged(newInfo);
-            state.mOrganizer.onTaskInfoChanged(task, newInfo);
+            } catch (RemoteException e) {
+            }
         }
     }
 
@@ -603,7 +521,11 @@ class TaskOrganizerController extends ITaskOrganizerController.Stub {
             return false;
         }
 
-        state.mOrganizer.onBackPressedOnTaskRoot(task);
+        try {
+            state.mOrganizer.onBackPressedOnTaskRoot(task.getTaskInfo());
+        } catch (Exception e) {
+            Slog.e(TAG, "Exception sending interceptBackPressedOnTaskRoot callback" + e);
+        }
         return true;
     }
 
@@ -620,7 +542,7 @@ class TaskOrganizerController extends ITaskOrganizerController.Stub {
                 final TaskOrganizerState state =  mTaskOrganizerStates.get(taskOrgs.get(j));
                 final ArrayList<Task> tasks = state.mOrganizedTasks;
                 pw.print(innerPrefix + "    ");
-                pw.println(state.mOrganizer.mTaskOrganizer + " uid=" + state.mUid + ":");
+                pw.println(state.mOrganizer + " uid=" + state.mUid + ":");
                 for (int k = 0; k < tasks.size(); k++) {
                     pw.println(innerPrefix + "      " + tasks.get(k));
                 }

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

@@ -2207,11 +2207,6 @@ class WindowContainer<E extends WindowContainer> extends ConfigurationContainer<
 
     private Animation loadAnimation(WindowManager.LayoutParams lp, int transit, boolean enter,
                                     boolean isVoiceInteraction) {
-        if (isOrganized()) {
-            // Defer to the task organizer to run animations
-            return null;
-        }
-
         final DisplayContent displayContent = getDisplayContent();
         final DisplayInfo displayInfo = displayContent.getDisplayInfo();
         final int width = displayInfo.appWidth;

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

@@ -69,8 +69,6 @@ import android.window.WindowContainerTransaction;
 
 import androidx.test.filters.SmallTest;
 
-import org.junit.After;
-import org.junit.Before;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 
@@ -119,13 +117,6 @@ public class TaskOrganizerTests extends WindowTestsBase {
         return createTaskStackOnDisplay(mDisplayContent);
     }
 
-    @Before
-    public void setUp() {
-        // We defer callbacks since we need to adjust task surface visibility, but for these tests,
-        // just run the callbacks synchronously
-        mWm.mAtmService.mTaskOrganizerController.setDeferTaskOrgCallbacksConsumer((r) -> r.run());
-    }
-
     @Test
     public void testAppearVanish() throws RemoteException {
         final ActivityStack stack = createStack();