services/core/java/com/android/server/wm/RecentsAnimation.java - platform/frameworks/base - Git at Google

 /*
  * Copyright (C) 2018 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *      http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */

 package com.android.server.wm;

 import static android.app.ActivityManager.START_TASK_TO_FRONT;
 import static android.app.WindowConfiguration.ACTIVITY_TYPE_HOME;
 import static android.app.WindowConfiguration.ACTIVITY_TYPE_RECENTS;
 import static android.app.WindowConfiguration.WINDOWING_MODE_UNDEFINED;
 import static android.content.Intent.FLAG_ACTIVITY_NEW_TASK;
 import static android.content.Intent.FLAG_ACTIVITY_NO_ANIMATION;
 import static android.os.Trace.TRACE_TAG_ACTIVITY_MANAGER;
 import static android.view.WindowManager.TRANSIT_NONE;

 import static com.android.server.wm.ActivityStackSupervisor.PRESERVE_WINDOWS;
 import static com.android.server.wm.BoundsAnimationController.BOUNDS;
 import static com.android.server.wm.BoundsAnimationController.FADE_IN;
 import static com.android.server.wm.RecentsAnimationController.REORDER_KEEP_IN_PLACE;
 import static com.android.server.wm.RecentsAnimationController.REORDER_MOVE_TO_ORIGINAL_POSITION;
 import static com.android.server.wm.RecentsAnimationController.REORDER_MOVE_TO_TOP;
 import static com.android.server.wm.WindowManagerDebugConfig.DEBUG_RECENTS_ANIMATIONS;

 import android.app.ActivityOptions;
 import android.app.IAssistDataReceiver;
 import android.content.ComponentName;
 import android.content.Intent;
 import android.os.RemoteException;
 import android.os.Trace;
 import android.util.Slog;
 import android.view.IRecentsAnimationRunner;

 import com.android.server.wm.RecentsAnimationController.RecentsAnimationCallbacks;

 /**
  * Manages the recents animation, including the reordering of the stacks for the transition and
  * cleanup. See {@link com.android.server.wm.RecentsAnimationController}.
  */
 class RecentsAnimation implements RecentsAnimationCallbacks,
         ActivityDisplay.OnStackOrderChangedListener {
     private static final String TAG = RecentsAnimation.class.getSimpleName();
     private static final boolean DEBUG = DEBUG_RECENTS_ANIMATIONS;

     private final ActivityTaskManagerService mService;
     private final ActivityStackSupervisor mStackSupervisor;
     private final ActivityStartController mActivityStartController;
     private final WindowManagerService mWindowManager;
     private final ActivityDisplay mDefaultDisplay;
     private final int mCallingPid;

     /**
      * The activity which has been launched behind. We need to remember the activity because the
      * target stack may have other activities, then we are able to restore the launch-behind state
      * for the exact activity.
      */
     private ActivityRecord mLaunchedTargetActivity;
     private int mTargetActivityType;

     // The stack to restore the target stack behind when the animation is finished
     private ActivityStack mRestoreTargetBehindStack;

     RecentsAnimation(ActivityTaskManagerService atm, ActivityStackSupervisor stackSupervisor,
             ActivityStartController activityStartController, WindowManagerService wm,
             int callingPid) {
         mService = atm;
         mStackSupervisor = stackSupervisor;
         mDefaultDisplay = mService.mRootActivityContainer.getDefaultDisplay();
         mActivityStartController = activityStartController;
         mWindowManager = wm;
         mCallingPid = callingPid;
     }

     void startRecentsActivity(Intent intent, IRecentsAnimationRunner recentsAnimationRunner,
             ComponentName recentsComponent, int recentsUid,
             @Deprecated IAssistDataReceiver assistDataReceiver) {
         if (DEBUG) Slog.d(TAG, "startRecentsActivity(): intent=" + intent
                 + " assistDataReceiver=" + assistDataReceiver);
         Trace.traceBegin(TRACE_TAG_ACTIVITY_MANAGER, "RecentsAnimation#startRecentsActivity");

         // TODO(multi-display) currently only support recents animation in default display.
         final DisplayContent dc =
                 mService.mRootActivityContainer.getDefaultDisplay().mDisplayContent;
         if (!mWindowManager.canStartRecentsAnimation()) {
             notifyAnimationCancelBeforeStart(recentsAnimationRunner);
             if (DEBUG) Slog.d(TAG, "Can't start recents animation, nextAppTransition="
                         + dc.mAppTransition.getAppTransition());
             return;
         }

         // If the activity is associated with the recents stack, then try and get that first
         final int userId = mService.getCurrentUserId();
         mTargetActivityType = intent.getComponent() != null
                 && recentsComponent.equals(intent.getComponent())
                         ? ACTIVITY_TYPE_RECENTS
                         : ACTIVITY_TYPE_HOME;
         ActivityStack targetStack = mDefaultDisplay.getStack(WINDOWING_MODE_UNDEFINED,
                 mTargetActivityType);
         ActivityRecord targetActivity = getTargetActivity(targetStack, intent.getComponent(),
                 userId);
         final boolean hasExistingActivity = targetActivity != null;
         if (hasExistingActivity) {
             final ActivityDisplay display = targetActivity.getDisplay();
             mRestoreTargetBehindStack = display.getStackAbove(targetStack);
             if (mRestoreTargetBehindStack == null) {
                 notifyAnimationCancelBeforeStart(recentsAnimationRunner);
                 if (DEBUG) Slog.d(TAG, "No stack above target stack=" + targetStack);
                 return;
             }
         }

         // Send launch hint if we are actually launching the target. If it's already visible
         // (shouldn't happen in general) we don't need to send it.
         if (targetActivity == null || !targetActivity.visible) {
             mService.mRootActivityContainer.sendPowerHintForLaunchStartIfNeeded(
                     true /* forceSend */, targetActivity);
         }

         mStackSupervisor.getActivityMetricsLogger().notifyActivityLaunching(intent);

         mService.mH.post(() -> mService.mAmInternal.setRunningRemoteAnimation(mCallingPid, true));

         mWindowManager.deferSurfaceLayout();
         try {
             if (hasExistingActivity) {
                 // Move the recents activity into place for the animation if it is not top most
                 mDefaultDisplay.moveStackBehindBottomMostVisibleStack(targetStack);
                 if (DEBUG) Slog.d(TAG, "Moved stack=" + targetStack + " behind stack="
                             + mDefaultDisplay.getStackAbove(targetStack));

                 // If there are multiple tasks in the target stack (ie. the home stack, with 3p
                 // and default launchers coexisting), then move the task to the top as a part of
                 // moving the stack to the front
                 if (targetStack.topTask() != targetActivity.getTaskRecord()) {
                     targetStack.addTask(targetActivity.getTaskRecord(), true /* toTop */,
                             "startRecentsActivity");
                 }
             } else {
                 // No recents activity, create the new recents activity bottom most
                 ActivityOptions options = ActivityOptions.makeBasic();
                 options.setLaunchActivityType(mTargetActivityType);
                 options.setAvoidMoveToFront();
                 intent.addFlags(FLAG_ACTIVITY_NEW_TASK | FLAG_ACTIVITY_NO_ANIMATION);

                 mActivityStartController
                         .obtainStarter(intent, "startRecentsActivity_noTargetActivity")
                         .setCallingUid(recentsUid)
                         .setCallingPackage(recentsComponent.getPackageName())
                         .setActivityOptions(SafeActivityOptions.fromBundle(options.toBundle()))
                         .setMayWait(userId)
                         .execute();

                 // Move the recents activity into place for the animation
                 targetStack = mDefaultDisplay.getStack(WINDOWING_MODE_UNDEFINED,
                         mTargetActivityType);
                 targetActivity = getTargetActivity(targetStack, intent.getComponent(), userId);
                 mDefaultDisplay.moveStackBehindBottomMostVisibleStack(targetStack);
                 if (DEBUG) {
                     Slog.d(TAG, "Moved stack=" + targetStack + " behind stack="
                             + mDefaultDisplay.getStackAbove(targetStack));
                 }

                 mWindowManager.prepareAppTransition(TRANSIT_NONE, false);
                 mWindowManager.executeAppTransition();

                 // TODO: Maybe wait for app to draw in this particular case?

                 if (DEBUG) Slog.d(TAG, "Started intent=" + intent);
             }

             // Mark the target activity as launch-behind to bump its visibility for the
             // duration of the gesture that is driven by the recents component
             targetActivity.mLaunchTaskBehind = true;
             mLaunchedTargetActivity = targetActivity;

             // Fetch all the surface controls and pass them to the client to get the animation
             // started. Cancel any existing recents animation running synchronously (do not hold the
             // WM lock)
             mWindowManager.cancelRecentsAnimationSynchronously(REORDER_MOVE_TO_ORIGINAL_POSITION,
                     "startRecentsActivity");
             mWindowManager.initializeRecentsAnimation(mTargetActivityType, recentsAnimationRunner,
                     this, mDefaultDisplay.mDisplayId,
                     mStackSupervisor.mRecentTasks.getRecentTaskIds());

             // If we updated the launch-behind state, update the visibility of the activities after
             // we fetch the visible tasks to be controlled by the animation
             mService.mRootActivityContainer.ensureActivitiesVisible(null, 0, PRESERVE_WINDOWS);

             mStackSupervisor.getActivityMetricsLogger().notifyActivityLaunched(START_TASK_TO_FRONT,
                     targetActivity);

             // Register for stack order changes
             mDefaultDisplay.registerStackOrderChangedListener(this);
         } catch (Exception e) {
             Slog.e(TAG, "Failed to start recents activity", e);
             throw e;
         } finally {
             mWindowManager.continueSurfaceLayout();
             Trace.traceEnd(TRACE_TAG_ACTIVITY_MANAGER);
         }
     }

     private void finishAnimation(@RecentsAnimationController.ReorderMode int reorderMode,
             boolean sendUserLeaveHint) {
         synchronized (mService.mGlobalLock) {
             if (DEBUG) Slog.d(TAG, "onAnimationFinished(): controller="
                     + mWindowManager.getRecentsAnimationController()
                     + " reorderMode=" + reorderMode);

             // Unregister for stack order changes
             mDefaultDisplay.unregisterStackOrderChangedListener(this);

             final RecentsAnimationController controller =
                     mWindowManager.getRecentsAnimationController();
             if (controller == null) return;

             // Just to be sure end the launch hint in case the target activity was never launched.
             // However, if we're keeping the activity and making it visible, we can leave it on.
             if (reorderMode != REORDER_KEEP_IN_PLACE) {
                 mService.mRootActivityContainer.sendPowerHintForLaunchEndIfNeeded();
             }

             // Once the target is shown, prevent spurious background app switches
             if (reorderMode == REORDER_MOVE_TO_TOP) {
                 mService.stopAppSwitches();
             }

             mService.mH.post(
                     () -> mService.mAmInternal.setRunningRemoteAnimation(mCallingPid, false));

             mWindowManager.inSurfaceTransaction(() -> {
                 Trace.traceBegin(TRACE_TAG_ACTIVITY_MANAGER,
                         "RecentsAnimation#onAnimationFinished_inSurfaceTransaction");
                 mWindowManager.deferSurfaceLayout();
                 try {
                     mWindowManager.cleanupRecentsAnimation(reorderMode);

                     final ActivityStack targetStack = mDefaultDisplay.getStack(
                             WINDOWING_MODE_UNDEFINED, mTargetActivityType);
                     // Prefer to use the original target activity instead of top activity because
                     // we may have moved another task to top (starting 3p launcher).
                     final ActivityRecord targetActivity = targetStack != null
                             ? targetStack.isInStackLocked(mLaunchedTargetActivity)
                             : null;
                     if (DEBUG) Slog.d(TAG, "onAnimationFinished(): targetStack=" + targetStack
                             + " targetActivity=" + targetActivity
                             + " mRestoreTargetBehindStack=" + mRestoreTargetBehindStack);
                     if (targetActivity == null) {
                         return;
                     }

                     // Restore the launched-behind state
                     targetActivity.mLaunchTaskBehind = false;

                     if (reorderMode == REORDER_MOVE_TO_TOP) {
                         // Bring the target stack to the front
                         mStackSupervisor.mNoAnimActivities.add(targetActivity);

                         if (sendUserLeaveHint) {
                             // Setting this allows the previous app to PiP.
                             mStackSupervisor.mUserLeaving = true;
                             targetStack.moveTaskToFrontLocked(targetActivity.getTaskRecord(),
                                     true /* noAnimation */, null /* activityOptions */,
                                     targetActivity.appTimeTracker,
                                     "RecentsAnimation.onAnimationFinished()");
                         } else {
                             targetStack.moveToFront("RecentsAnimation.onAnimationFinished()");
                         }

                         if (DEBUG) {
                             final ActivityStack topStack = getTopNonAlwaysOnTopStack();
                             if (topStack != targetStack) {
                                 Slog.w(TAG, "Expected target stack=" + targetStack
                                         + " to be top most but found stack=" + topStack);
                             }
                         }
                     } else if (reorderMode == REORDER_MOVE_TO_ORIGINAL_POSITION){
                         // Restore the target stack to its previous position
                         final ActivityDisplay display = targetActivity.getDisplay();
                         display.moveStackBehindStack(targetStack, mRestoreTargetBehindStack);
                         if (DEBUG) {
                             final ActivityStack aboveTargetStack =
                                     mDefaultDisplay.getStackAbove(targetStack);
                             if (mRestoreTargetBehindStack != null
                                     && aboveTargetStack != mRestoreTargetBehindStack) {
                                 Slog.w(TAG, "Expected target stack=" + targetStack
                                         + " to restored behind stack=" + mRestoreTargetBehindStack
                                         + " but it is behind stack=" + aboveTargetStack);
                             }
                         }
                     } else {
                         // If there is no recents screenshot animation, we can update the visibility
                         // of target stack immediately because it is visually invisible and the
                         // launch-behind state is restored. That also prevents the next transition
                         // type being disturbed if the visibility is updated after setting the next
                         // transition (the target activity will be one of closing apps).
                         if (!controller.shouldCancelWithDeferredScreenshot()
                                 && !targetStack.isFocusedStackOnDisplay()) {
                             targetStack.ensureActivitiesVisibleLocked(null /* starting */,
                                     0 /* starting */, false /* preserveWindows */);
                         }
                         // Keep target stack in place, nothing changes, so ignore the transition
                         // logic below
                         return;
                     }

                     mWindowManager.prepareAppTransition(TRANSIT_NONE, false);
                     mService.mRootActivityContainer.ensureActivitiesVisible(null, 0, false);
                     mService.mRootActivityContainer.resumeFocusedStacksTopActivities();

                     // No reason to wait for the pausing activity in this case, as the hiding of
                     // surfaces needs to be done immediately.
                     mWindowManager.executeAppTransition();

                     // After reordering the stacks, reset the minimized state. At this point, either
                     // the target activity is now top-most and we will stay minimized (if in
                     // split-screen), or we will have returned to the app, and the minimized state
                     // should be reset
                     mWindowManager.checkSplitScreenMinimizedChanged(true /* animate */);
                 } catch (Exception e) {
                     Slog.e(TAG, "Failed to clean up recents activity", e);
                     throw e;
                 } finally {
                     mWindowManager.continueSurfaceLayout();
                     Trace.traceEnd(TRACE_TAG_ACTIVITY_MANAGER);
                 }
             });
         }
     }

     @Override
     public void onAnimationFinished(@RecentsAnimationController.ReorderMode int reorderMode,
             boolean runSychronously, boolean sendUserLeaveHint) {
         if (runSychronously) {
             finishAnimation(reorderMode, sendUserLeaveHint);
         } else {
             mService.mH.post(() -> finishAnimation(reorderMode, sendUserLeaveHint));
         }
     }

     @Override
     public void onStackOrderChanged(ActivityStack stack) {
         if (DEBUG) Slog.d(TAG, "onStackOrderChanged(): stack=" + stack);
         if (mDefaultDisplay.getIndexOf(stack) == -1 || !stack.shouldBeVisible(null)) {
             // The stack is not visible, so ignore this change
             return;
         }
         final RecentsAnimationController controller =
                 mWindowManager.getRecentsAnimationController();
         if (controller == null) {
             return;
         }

         final DisplayContent dc =
                 mService.mRootActivityContainer.getDefaultDisplay().mDisplayContent;
         dc.mBoundsAnimationController.setAnimationType(
                 controller.shouldCancelWithDeferredScreenshot() ? FADE_IN : BOUNDS);

         // Cancel running recents animation and screenshot previous task when the next
         // transition starts in below cases:
         // 1) The next launching task is not in recents animation task.
         // 2) The next task is home activity. (i.e. pressing home key to back home in recents).
         if ((!controller.isAnimatingTask(stack.getTaskStack().getTopChild())
                 || controller.isTargetApp(stack.getTopActivity().mAppWindowToken))
                 && controller.shouldCancelWithDeferredScreenshot()) {
             controller.cancelOnNextTransitionStart();
         } else {
             // Just cancel directly to unleash from launcher when the next launching task is the
             // current top task.
             mWindowManager.cancelRecentsAnimationSynchronously(REORDER_KEEP_IN_PLACE,
                     "stackOrderChanged");
         }
     }

     /**
      * Called only when the animation should be canceled prior to starting.
      */
     private void notifyAnimationCancelBeforeStart(IRecentsAnimationRunner recentsAnimationRunner) {
         try {
             recentsAnimationRunner.onAnimationCanceled(false /* deferredWithScreenshot */);
         } catch (RemoteException e) {
             Slog.e(TAG, "Failed to cancel recents animation before start", e);
         }
     }

     /**
      * @return The top stack that is not always-on-top.
      */
     private ActivityStack getTopNonAlwaysOnTopStack() {
         for (int i = mDefaultDisplay.getChildCount() - 1; i >= 0; i--) {
             final ActivityStack s = mDefaultDisplay.getChildAt(i);
             if (s.getWindowConfiguration().isAlwaysOnTop()) {
                 continue;
             }
             return s;
         }
         return null;
     }

     /**
      * @return the top activity in the {@param targetStack} matching the {@param component}, or just
      * the top activity of the top task if no task matches the component.
      */
     private ActivityRecord getTargetActivity(ActivityStack targetStack, ComponentName component,
             int userId) {
         if (targetStack == null) {
             return null;
         }

         for (int i = targetStack.getChildCount() - 1; i >= 0; i--) {
             final TaskRecord task = targetStack.getChildAt(i);
             if (task.userId == userId && task.getBaseIntent().getComponent().equals(component)) {
                 return task.getTopActivity();
             }
         }
         return null;
     }
 }
	/*
	* Copyright (C) 2018 The Android Open Source Project
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	package com.android.server.wm;

	import static android.app.ActivityManager.START_TASK_TO_FRONT;
	import static android.app.WindowConfiguration.ACTIVITY_TYPE_HOME;
	import static android.app.WindowConfiguration.ACTIVITY_TYPE_RECENTS;
	import static android.app.WindowConfiguration.WINDOWING_MODE_UNDEFINED;
	import static android.content.Intent.FLAG_ACTIVITY_NEW_TASK;
	import static android.content.Intent.FLAG_ACTIVITY_NO_ANIMATION;
	import static android.os.Trace.TRACE_TAG_ACTIVITY_MANAGER;
	import static android.view.WindowManager.TRANSIT_NONE;

	import static com.android.server.wm.ActivityStackSupervisor.PRESERVE_WINDOWS;
	import static com.android.server.wm.BoundsAnimationController.BOUNDS;
	import static com.android.server.wm.BoundsAnimationController.FADE_IN;
	import static com.android.server.wm.RecentsAnimationController.REORDER_KEEP_IN_PLACE;
	import static com.android.server.wm.RecentsAnimationController.REORDER_MOVE_TO_ORIGINAL_POSITION;
	import static com.android.server.wm.RecentsAnimationController.REORDER_MOVE_TO_TOP;
	import static com.android.server.wm.WindowManagerDebugConfig.DEBUG_RECENTS_ANIMATIONS;

	import android.app.ActivityOptions;
	import android.app.IAssistDataReceiver;
	import android.content.ComponentName;
	import android.content.Intent;
	import android.os.RemoteException;
	import android.os.Trace;
	import android.util.Slog;
	import android.view.IRecentsAnimationRunner;

	import com.android.server.wm.RecentsAnimationController.RecentsAnimationCallbacks;

	/**
	* Manages the recents animation, including the reordering of the stacks for the transition and
	* cleanup. See {@link com.android.server.wm.RecentsAnimationController}.
	*/
	class RecentsAnimation implements RecentsAnimationCallbacks,
	ActivityDisplay.OnStackOrderChangedListener {
	private static final String TAG = RecentsAnimation.class.getSimpleName();
	private static final boolean DEBUG = DEBUG_RECENTS_ANIMATIONS;

	private final ActivityTaskManagerService mService;
	private final ActivityStackSupervisor mStackSupervisor;
	private final ActivityStartController mActivityStartController;
	private final WindowManagerService mWindowManager;
	private final ActivityDisplay mDefaultDisplay;
	private final int mCallingPid;

	/**
	* The activity which has been launched behind. We need to remember the activity because the
	* target stack may have other activities, then we are able to restore the launch-behind state
	* for the exact activity.
	*/
	private ActivityRecord mLaunchedTargetActivity;
	private int mTargetActivityType;

	// The stack to restore the target stack behind when the animation is finished
	private ActivityStack mRestoreTargetBehindStack;

	RecentsAnimation(ActivityTaskManagerService atm, ActivityStackSupervisor stackSupervisor,
	ActivityStartController activityStartController, WindowManagerService wm,
	int callingPid) {
	mService = atm;
	mStackSupervisor = stackSupervisor;
	mDefaultDisplay = mService.mRootActivityContainer.getDefaultDisplay();
	mActivityStartController = activityStartController;
	mWindowManager = wm;
	mCallingPid = callingPid;
	}

	void startRecentsActivity(Intent intent, IRecentsAnimationRunner recentsAnimationRunner,
	ComponentName recentsComponent, int recentsUid,
	@Deprecated IAssistDataReceiver assistDataReceiver) {
	if (DEBUG) Slog.d(TAG, "startRecentsActivity(): intent=" + intent
	+ " assistDataReceiver=" + assistDataReceiver);
	Trace.traceBegin(TRACE_TAG_ACTIVITY_MANAGER, "RecentsAnimation#startRecentsActivity");

	// TODO(multi-display) currently only support recents animation in default display.
	final DisplayContent dc =
	mService.mRootActivityContainer.getDefaultDisplay().mDisplayContent;
	if (!mWindowManager.canStartRecentsAnimation()) {
	notifyAnimationCancelBeforeStart(recentsAnimationRunner);
	if (DEBUG) Slog.d(TAG, "Can't start recents animation, nextAppTransition="
	+ dc.mAppTransition.getAppTransition());
	return;
	}

	// If the activity is associated with the recents stack, then try and get that first
	final int userId = mService.getCurrentUserId();
	mTargetActivityType = intent.getComponent() != null
	&& recentsComponent.equals(intent.getComponent())
	? ACTIVITY_TYPE_RECENTS
	: ACTIVITY_TYPE_HOME;
	ActivityStack targetStack = mDefaultDisplay.getStack(WINDOWING_MODE_UNDEFINED,
	mTargetActivityType);
	ActivityRecord targetActivity = getTargetActivity(targetStack, intent.getComponent(),
	userId);
	final boolean hasExistingActivity = targetActivity != null;
	if (hasExistingActivity) {
	final ActivityDisplay display = targetActivity.getDisplay();
	mRestoreTargetBehindStack = display.getStackAbove(targetStack);
	if (mRestoreTargetBehindStack == null) {
	notifyAnimationCancelBeforeStart(recentsAnimationRunner);
	if (DEBUG) Slog.d(TAG, "No stack above target stack=" + targetStack);
	return;
	}
	}

	// Send launch hint if we are actually launching the target. If it's already visible
	// (shouldn't happen in general) we don't need to send it.
	if (targetActivity == null \|\| !targetActivity.visible) {
	mService.mRootActivityContainer.sendPowerHintForLaunchStartIfNeeded(
	true /* forceSend */, targetActivity);
	}

	mStackSupervisor.getActivityMetricsLogger().notifyActivityLaunching(intent);

	mService.mH.post(() -> mService.mAmInternal.setRunningRemoteAnimation(mCallingPid, true));

	mWindowManager.deferSurfaceLayout();
	try {
	if (hasExistingActivity) {
	// Move the recents activity into place for the animation if it is not top most
	mDefaultDisplay.moveStackBehindBottomMostVisibleStack(targetStack);
	if (DEBUG) Slog.d(TAG, "Moved stack=" + targetStack + " behind stack="
	+ mDefaultDisplay.getStackAbove(targetStack));

	// If there are multiple tasks in the target stack (ie. the home stack, with 3p
	// and default launchers coexisting), then move the task to the top as a part of
	// moving the stack to the front
	if (targetStack.topTask() != targetActivity.getTaskRecord()) {
	targetStack.addTask(targetActivity.getTaskRecord(), true /* toTop */,
	"startRecentsActivity");
	}
	} else {
	// No recents activity, create the new recents activity bottom most
	ActivityOptions options = ActivityOptions.makeBasic();
	options.setLaunchActivityType(mTargetActivityType);
	options.setAvoidMoveToFront();
	intent.addFlags(FLAG_ACTIVITY_NEW_TASK \| FLAG_ACTIVITY_NO_ANIMATION);

	mActivityStartController
	.obtainStarter(intent, "startRecentsActivity_noTargetActivity")
	.setCallingUid(recentsUid)
	.setCallingPackage(recentsComponent.getPackageName())
	.setActivityOptions(SafeActivityOptions.fromBundle(options.toBundle()))
	.setMayWait(userId)
	.execute();

	// Move the recents activity into place for the animation
	targetStack = mDefaultDisplay.getStack(WINDOWING_MODE_UNDEFINED,
	mTargetActivityType);
	targetActivity = getTargetActivity(targetStack, intent.getComponent(), userId);
	mDefaultDisplay.moveStackBehindBottomMostVisibleStack(targetStack);
	if (DEBUG) {
	Slog.d(TAG, "Moved stack=" + targetStack + " behind stack="
	+ mDefaultDisplay.getStackAbove(targetStack));
	}

	mWindowManager.prepareAppTransition(TRANSIT_NONE, false);
	mWindowManager.executeAppTransition();

	// TODO: Maybe wait for app to draw in this particular case?

	if (DEBUG) Slog.d(TAG, "Started intent=" + intent);
	}

	// Mark the target activity as launch-behind to bump its visibility for the
	// duration of the gesture that is driven by the recents component
	targetActivity.mLaunchTaskBehind = true;
	mLaunchedTargetActivity = targetActivity;

	// Fetch all the surface controls and pass them to the client to get the animation
	// started. Cancel any existing recents animation running synchronously (do not hold the
	// WM lock)
	mWindowManager.cancelRecentsAnimationSynchronously(REORDER_MOVE_TO_ORIGINAL_POSITION,
	"startRecentsActivity");
	mWindowManager.initializeRecentsAnimation(mTargetActivityType, recentsAnimationRunner,
	this, mDefaultDisplay.mDisplayId,
	mStackSupervisor.mRecentTasks.getRecentTaskIds());

	// If we updated the launch-behind state, update the visibility of the activities after
	// we fetch the visible tasks to be controlled by the animation
	mService.mRootActivityContainer.ensureActivitiesVisible(null, 0, PRESERVE_WINDOWS);

	mStackSupervisor.getActivityMetricsLogger().notifyActivityLaunched(START_TASK_TO_FRONT,
	targetActivity);

	// Register for stack order changes
	mDefaultDisplay.registerStackOrderChangedListener(this);
	} catch (Exception e) {
	Slog.e(TAG, "Failed to start recents activity", e);
	throw e;
	} finally {
	mWindowManager.continueSurfaceLayout();
	Trace.traceEnd(TRACE_TAG_ACTIVITY_MANAGER);
	}
	}

	private void finishAnimation(@RecentsAnimationController.ReorderMode int reorderMode,
	boolean sendUserLeaveHint) {
	synchronized (mService.mGlobalLock) {
	if (DEBUG) Slog.d(TAG, "onAnimationFinished(): controller="
	+ mWindowManager.getRecentsAnimationController()
	+ " reorderMode=" + reorderMode);

	// Unregister for stack order changes
	mDefaultDisplay.unregisterStackOrderChangedListener(this);

	final RecentsAnimationController controller =
	mWindowManager.getRecentsAnimationController();
	if (controller == null) return;

	// Just to be sure end the launch hint in case the target activity was never launched.
	// However, if we're keeping the activity and making it visible, we can leave it on.
	if (reorderMode != REORDER_KEEP_IN_PLACE) {
	mService.mRootActivityContainer.sendPowerHintForLaunchEndIfNeeded();
	}

	// Once the target is shown, prevent spurious background app switches
	if (reorderMode == REORDER_MOVE_TO_TOP) {
	mService.stopAppSwitches();
	}

	mService.mH.post(
	() -> mService.mAmInternal.setRunningRemoteAnimation(mCallingPid, false));

	mWindowManager.inSurfaceTransaction(() -> {
	Trace.traceBegin(TRACE_TAG_ACTIVITY_MANAGER,
	"RecentsAnimation#onAnimationFinished_inSurfaceTransaction");
	mWindowManager.deferSurfaceLayout();
	try {
	mWindowManager.cleanupRecentsAnimation(reorderMode);

	final ActivityStack targetStack = mDefaultDisplay.getStack(
	WINDOWING_MODE_UNDEFINED, mTargetActivityType);
	// Prefer to use the original target activity instead of top activity because
	// we may have moved another task to top (starting 3p launcher).
	final ActivityRecord targetActivity = targetStack != null
	? targetStack.isInStackLocked(mLaunchedTargetActivity)
	: null;
	if (DEBUG) Slog.d(TAG, "onAnimationFinished(): targetStack=" + targetStack
	+ " targetActivity=" + targetActivity
	+ " mRestoreTargetBehindStack=" + mRestoreTargetBehindStack);
	if (targetActivity == null) {
	return;
	}

	// Restore the launched-behind state
	targetActivity.mLaunchTaskBehind = false;

	if (reorderMode == REORDER_MOVE_TO_TOP) {
	// Bring the target stack to the front
	mStackSupervisor.mNoAnimActivities.add(targetActivity);

	if (sendUserLeaveHint) {
	// Setting this allows the previous app to PiP.
	mStackSupervisor.mUserLeaving = true;
	targetStack.moveTaskToFrontLocked(targetActivity.getTaskRecord(),
	true /* noAnimation /, null / activityOptions */,
	targetActivity.appTimeTracker,
	"RecentsAnimation.onAnimationFinished()");
	} else {
	targetStack.moveToFront("RecentsAnimation.onAnimationFinished()");
	}

	if (DEBUG) {
	final ActivityStack topStack = getTopNonAlwaysOnTopStack();
	if (topStack != targetStack) {
	Slog.w(TAG, "Expected target stack=" + targetStack
	+ " to be top most but found stack=" + topStack);
	}
	}
	} else if (reorderMode == REORDER_MOVE_TO_ORIGINAL_POSITION){
	// Restore the target stack to its previous position
	final ActivityDisplay display = targetActivity.getDisplay();
	display.moveStackBehindStack(targetStack, mRestoreTargetBehindStack);
	if (DEBUG) {
	final ActivityStack aboveTargetStack =
	mDefaultDisplay.getStackAbove(targetStack);
	if (mRestoreTargetBehindStack != null
	&& aboveTargetStack != mRestoreTargetBehindStack) {
	Slog.w(TAG, "Expected target stack=" + targetStack
	+ " to restored behind stack=" + mRestoreTargetBehindStack
	+ " but it is behind stack=" + aboveTargetStack);
	}
	}
	} else {
	// If there is no recents screenshot animation, we can update the visibility
	// of target stack immediately because it is visually invisible and the
	// launch-behind state is restored. That also prevents the next transition
	// type being disturbed if the visibility is updated after setting the next
	// transition (the target activity will be one of closing apps).
	if (!controller.shouldCancelWithDeferredScreenshot()
	&& !targetStack.isFocusedStackOnDisplay()) {
	targetStack.ensureActivitiesVisibleLocked(null /* starting */,
	0 /* starting /, false / preserveWindows */);
	}
	// Keep target stack in place, nothing changes, so ignore the transition
	// logic below
	return;
	}

	mWindowManager.prepareAppTransition(TRANSIT_NONE, false);
	mService.mRootActivityContainer.ensureActivitiesVisible(null, 0, false);
	mService.mRootActivityContainer.resumeFocusedStacksTopActivities();

	// No reason to wait for the pausing activity in this case, as the hiding of
	// surfaces needs to be done immediately.
	mWindowManager.executeAppTransition();

	// After reordering the stacks, reset the minimized state. At this point, either
	// the target activity is now top-most and we will stay minimized (if in
	// split-screen), or we will have returned to the app, and the minimized state
	// should be reset
	mWindowManager.checkSplitScreenMinimizedChanged(true /* animate */);
	} catch (Exception e) {
	Slog.e(TAG, "Failed to clean up recents activity", e);
	throw e;
	} finally {
	mWindowManager.continueSurfaceLayout();
	Trace.traceEnd(TRACE_TAG_ACTIVITY_MANAGER);
	}
	});
	}
	}

	@Override
	public void onAnimationFinished(@RecentsAnimationController.ReorderMode int reorderMode,
	boolean runSychronously, boolean sendUserLeaveHint) {
	if (runSychronously) {
	finishAnimation(reorderMode, sendUserLeaveHint);
	} else {
	mService.mH.post(() -> finishAnimation(reorderMode, sendUserLeaveHint));
	}
	}

	@Override
	public void onStackOrderChanged(ActivityStack stack) {
	if (DEBUG) Slog.d(TAG, "onStackOrderChanged(): stack=" + stack);
	if (mDefaultDisplay.getIndexOf(stack) == -1 \|\| !stack.shouldBeVisible(null)) {
	// The stack is not visible, so ignore this change
	return;
	}
	final RecentsAnimationController controller =
	mWindowManager.getRecentsAnimationController();
	if (controller == null) {
	return;
	}

	final DisplayContent dc =
	mService.mRootActivityContainer.getDefaultDisplay().mDisplayContent;
	dc.mBoundsAnimationController.setAnimationType(
	controller.shouldCancelWithDeferredScreenshot() ? FADE_IN : BOUNDS);

	// Cancel running recents animation and screenshot previous task when the next
	// transition starts in below cases:
	// 1) The next launching task is not in recents animation task.
	// 2) The next task is home activity. (i.e. pressing home key to back home in recents).
	if ((!controller.isAnimatingTask(stack.getTaskStack().getTopChild())
	\|\| controller.isTargetApp(stack.getTopActivity().mAppWindowToken))
	&& controller.shouldCancelWithDeferredScreenshot()) {
	controller.cancelOnNextTransitionStart();
	} else {
	// Just cancel directly to unleash from launcher when the next launching task is the
	// current top task.
	mWindowManager.cancelRecentsAnimationSynchronously(REORDER_KEEP_IN_PLACE,
	"stackOrderChanged");
	}
	}

	/**
	* Called only when the animation should be canceled prior to starting.
	*/
	private void notifyAnimationCancelBeforeStart(IRecentsAnimationRunner recentsAnimationRunner) {
	try {
	recentsAnimationRunner.onAnimationCanceled(false /* deferredWithScreenshot */);
	} catch (RemoteException e) {
	Slog.e(TAG, "Failed to cancel recents animation before start", e);
	}
	}

	/**
	* @return The top stack that is not always-on-top.
	*/
	private ActivityStack getTopNonAlwaysOnTopStack() {
	for (int i = mDefaultDisplay.getChildCount() - 1; i >= 0; i--) {
	final ActivityStack s = mDefaultDisplay.getChildAt(i);
	if (s.getWindowConfiguration().isAlwaysOnTop()) {
	continue;
	}
	return s;
	}
	return null;
	}

	/**
	* @return the top activity in the {@param targetStack} matching the {@param component}, or just
	* the top activity of the top task if no task matches the component.
	*/
	private ActivityRecord getTargetActivity(ActivityStack targetStack, ComponentName component,
	int userId) {
	if (targetStack == null) {
	return null;
	}

	for (int i = targetStack.getChildCount() - 1; i >= 0; i--) {
	final TaskRecord task = targetStack.getChildAt(i);
	if (task.userId == userId && task.getBaseIntent().getComponent().equals(component)) {
	return task.getTopActivity();
	}
	}
	return null;
	}
	}