Merge "Evaluating launch params with reusable task" (ccf1ac56) · Commits · e / os / android_frameworks_base

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

+23 −20

Original line number	Diff line number	Diff line
		@@ -73,6 +73,8 @@ import static com.android.server.wm.ActivityTaskManagerDebugConfig.POSTFIX_USER_
		import static com.android.server.wm.ActivityTaskManagerDebugConfig.TAG_ATM;
		import static com.android.server.wm.ActivityTaskManagerDebugConfig.TAG_WITH_CLASS_NAME;
		import static com.android.server.wm.ActivityTaskManagerService.ANIMATE;
		import static com.android.server.wm.LaunchParamsController.LaunchParamsModifier.PHASE_BOUNDS;
		import static com.android.server.wm.LaunchParamsController.LaunchParamsModifier.PHASE_DISPLAY;
		import static com.android.server.wm.TaskRecord.REPARENT_KEEP_STACK_AT_FRONT;
		import static com.android.server.wm.TaskRecord.REPARENT_MOVE_STACK_TO_FRONT;

		@@ -1339,6 +1341,21 @@ class ActivityStarter {
		voiceInteractor);
		final int preferredWindowingMode = mLaunchParams.mWindowingMode;

		computeLaunchingTaskFlags();

		computeSourceStack();

		mIntent.setFlags(mLaunchFlags);

		ActivityRecord reusedActivity = getReusableIntentActivity();

		mSupervisor.getLaunchParamsController().calculate(
		reusedActivity != null ? reusedActivity.getTaskRecord() : mInTask,
		r.info.windowLayout, r, sourceRecord, options, PHASE_BOUNDS, mLaunchParams);
		mPreferredDisplayId =
		mLaunchParams.hasPreferredDisplay() ? mLaunchParams.mPreferredDisplayId
		: DEFAULT_DISPLAY;

		// Do not start home activity if it cannot be launched on preferred display. We are not
		// doing this in ActivityStackSupervisor#canPlaceEntityOnDisplay because it might
		// fallback to launch on other displays.
		@@ -1348,14 +1365,6 @@ class ActivityStarter {
		return START_CANCELED;
		}

		computeLaunchingTaskFlags();

		computeSourceStack();

		mIntent.setFlags(mLaunchFlags);

		ActivityRecord reusedActivity = getReusableIntentActivity();

		if (reusedActivity != null) {
		// When the flags NEW_TASK and CLEAR_TASK are set, then the task gets reused but
		// still needs to be a lock task mode violation since the task gets cleared out and
		@@ -1651,14 +1660,13 @@ class ActivityStarter {

		mLaunchParams.reset();

		// Preferred display id is the only state we need for now and it could be updated again
		// after we located a reusable task (which might be resided in another display).
		mSupervisor.getLaunchParamsController().calculate(inTask, r.info.windowLayout, r,
		sourceRecord, options, mLaunchParams);

		if (mLaunchParams.hasPreferredDisplay()) {
		mPreferredDisplayId = mLaunchParams.mPreferredDisplayId;
		} else {
		mPreferredDisplayId = DEFAULT_DISPLAY;
		}
		sourceRecord, options, PHASE_DISPLAY, mLaunchParams);
		mPreferredDisplayId =
		mLaunchParams.hasPreferredDisplay() ? mLaunchParams.mPreferredDisplayId
		: DEFAULT_DISPLAY;

		mLaunchMode = r.launchMode;

		@@ -2502,14 +2510,9 @@ class ActivityStarter {

		if (((launchFlags & FLAG_ACTIVITY_LAUNCH_ADJACENT) == 0)
		\|\| mPreferredDisplayId != DEFAULT_DISPLAY) {
		// We don't pass in the default display id into the get launch stack call so it can do a
		// full resolution.
		mLaunchParams.mPreferredDisplayId =
		mPreferredDisplayId != DEFAULT_DISPLAY ? mPreferredDisplayId : INVALID_DISPLAY;
		final boolean onTop = aOptions == null \|\| !aOptions.getAvoidMoveToFront();
		final ActivityStack stack =
		mRootActivityContainer.getLaunchStack(r, aOptions, task, onTop, mLaunchParams);
		mLaunchParams.mPreferredDisplayId = mPreferredDisplayId;
		return stack;
		}
		// Otherwise handle adjacent launch.

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

+26 −5

Original line number	Diff line number	Diff line
		@@ -20,6 +20,7 @@ import static android.app.WindowConfiguration.WINDOWING_MODE_UNDEFINED;
		import static android.view.Display.DEFAULT_DISPLAY;
		import static android.view.Display.INVALID_DISPLAY;

		import static com.android.server.wm.LaunchParamsController.LaunchParamsModifier.PHASE_BOUNDS;
		import static com.android.server.wm.LaunchParamsController.LaunchParamsModifier.RESULT_CONTINUE;
		import static com.android.server.wm.LaunchParamsController.LaunchParamsModifier.RESULT_DONE;
		import static com.android.server.wm.LaunchParamsController.LaunchParamsModifier.RESULT_SKIP;
		@@ -74,7 +75,7 @@ class LaunchParamsController {
		* @param result The resulting params.
		*/
		void calculate(TaskRecord task, WindowLayout layout, ActivityRecord activity,
		ActivityRecord source, ActivityOptions options, LaunchParams result) {
		ActivityRecord source, ActivityOptions options, int phase, LaunchParams result) {
		result.reset();

		if (task != null \|\| activity != null) {
		@@ -89,7 +90,7 @@ class LaunchParamsController {
		mTmpResult.reset();
		final LaunchParamsModifier modifier = mModifiers.get(i);

		switch(modifier.onCalculate(task, layout, activity, source, options, mTmpCurrent,
		switch(modifier.onCalculate(task, layout, activity, source, options, phase, mTmpCurrent,
		mTmpResult)) {
		case RESULT_SKIP:
		// Do not apply any results when we are told to skip
		@@ -125,7 +126,7 @@ class LaunchParamsController {

		boolean layoutTask(TaskRecord task, WindowLayout layout, ActivityRecord activity,
		ActivityRecord source, ActivityOptions options) {
		calculate(task, layout, activity, source, options, mTmpParams);
		calculate(task, layout, activity, source, options, PHASE_BOUNDS, mTmpParams);

		// No changes, return.
		if (mTmpParams.isEmpty()) {
		@@ -259,6 +260,25 @@ class LaunchParamsController {
		*/
		int RESULT_CONTINUE = 2;

		@Retention(RetentionPolicy.SOURCE)
		@IntDef({PHASE_DISPLAY, PHASE_WINDOWING_MODE, PHASE_BOUNDS})
		@interface Phase {}

		/**
		* Stops once we are done with preferred display calculation.
		*/
		int PHASE_DISPLAY = 0;

		/**
		* Stops once we are done with windowing mode calculation.
		*/
		int PHASE_WINDOWING_MODE = 1;

		/**
		* Stops once we are done with window bounds calculation.
		*/
		int PHASE_BOUNDS = 2;

		/**
		* Returns the launch params that the provided activity launch params should be overridden
		* to. {@link LaunchParamsModifier} can use this for various purposes, including: 1)
		@@ -277,6 +297,7 @@ class LaunchParamsController {
		* launched should have this be non-null.
		* @param source the Activity that launched a new task. Could be {@code null}.
		* @param options {@link ActivityOptions} used to start the activity with.
		* @param phase the calculation phase, see {@link LaunchParamsModifier.Phase}
		* @param currentParams launching params after the process of last {@link
		* LaunchParamsModifier}.
		* @param outParams the result params to be set.
		@@ -284,7 +305,7 @@ class LaunchParamsController {
		*/
		@Result
		int onCalculate(TaskRecord task, WindowLayout layout, ActivityRecord activity,
		ActivityRecord source, ActivityOptions options, LaunchParams currentParams,
		LaunchParams outParams);
		ActivityRecord source, ActivityOptions options, @Phase int phase,
		LaunchParams currentParams, LaunchParams outParams);
		}
		}

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

+21 −17

Original line number	Diff line number	Diff line
		@@ -1615,17 +1615,7 @@ class RootActivityContainer extends ConfigurationContainer
		return candidateTask.getStack();
		}

		// Return the topmost valid stack on the display.
		for (int i = activityDisplay.getChildCount() - 1; i >= 0; --i) {
		final ActivityStack stack = activityDisplay.getChildAt(i);
		if (isValidLaunchStack(stack, r)) {
		return stack;
		}
		}

		// If there is no valid stack on the external display - check if new dynamic stack will do.
		if (displayId != DEFAULT_DISPLAY) {
		final int windowingMode;
		int windowingMode;
		if (launchParams != null) {
		// When launch params is not null, we always defer to its windowing mode. Sometimes
		// it could be unspecified, which indicates it should inherit windowing mode from
		@@ -1635,13 +1625,25 @@ class RootActivityContainer extends ConfigurationContainer
		windowingMode = options != null ? options.getLaunchWindowingMode()
		: r.getWindowingMode();
		}
		windowingMode = activityDisplay.validateWindowingMode(windowingMode, r, candidateTask,
		r.getActivityType());

		// Return the topmost valid stack on the display.
		for (int i = activityDisplay.getChildCount() - 1; i >= 0; --i) {
		final ActivityStack stack = activityDisplay.getChildAt(i);
		if (isValidLaunchStack(stack, r, windowingMode)) {
		return stack;
		}
		}

		// If there is no valid stack on the external display - check if new dynamic stack will do.
		if (displayId != DEFAULT_DISPLAY) {
		final int activityType =
		options != null && options.getLaunchActivityType() != ACTIVITY_TYPE_UNDEFINED
		? options.getLaunchActivityType() : r.getActivityType();
		return activityDisplay.createStack(windowingMode, activityType, true /onTop/);
		}

		Slog.w(TAG, "getValidLaunchStackOnDisplay: can't launch on displayId " + displayId);
		return null;
		}

		@@ -1653,7 +1655,7 @@ class RootActivityContainer extends ConfigurationContainer
		}

		// TODO: Can probably be consolidated into getLaunchStack()...
		private boolean isValidLaunchStack(ActivityStack stack, ActivityRecord r) {
		private boolean isValidLaunchStack(ActivityStack stack, ActivityRecord r, int windowingMode) {
		switch (stack.getActivityType()) {
		case ACTIVITY_TYPE_HOME: return r.isActivityTypeHome();
		case ACTIVITY_TYPE_RECENTS: return r.isActivityTypeRecents();
		@@ -1661,11 +1663,13 @@ class RootActivityContainer extends ConfigurationContainer
		}
		// There is a 1-to-1 relationship between stack and task when not in
		// primary split-windowing mode.
		if (stack.getWindowingMode() != WINDOWING_MODE_SPLIT_SCREEN_PRIMARY) {
		return false;
		} else {
		return r.supportsSplitScreenWindowingMode();
		if (stack.getWindowingMode() == WINDOWING_MODE_SPLIT_SCREEN_PRIMARY
		&& r.supportsSplitScreenWindowingMode()
		&& (windowingMode == WINDOWING_MODE_SPLIT_SCREEN_PRIMARY
		\|\| windowingMode == WINDOWING_MODE_UNDEFINED)) {
		return true;
		}
		return false;
		}

		int resolveActivityType(@Nullable ActivityRecord r, @Nullable ActivityOptions options,

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

+26 −9

Original line number	Diff line number	Diff line
		@@ -51,6 +51,7 @@ import android.util.Slog;
		import android.view.Gravity;
		import android.view.View;

		import com.android.internal.annotations.VisibleForTesting;
		import com.android.server.wm.LaunchParamsController.LaunchParams;
		import com.android.server.wm.LaunchParamsController.LaunchParamsModifier;

		@@ -102,19 +103,27 @@ class TaskLaunchParamsModifier implements LaunchParamsModifier {
		mSupervisor = supervisor;
		}

		@VisibleForTesting
		int onCalculate(TaskRecord task, ActivityInfo.WindowLayout layout, ActivityRecord activity,
		ActivityRecord source, ActivityOptions options, LaunchParams currentParams,
		LaunchParams outParams) {
		return onCalculate(task, layout, activity, source, options, PHASE_BOUNDS, currentParams,
		outParams);
		}

		@Override
		public int onCalculate(TaskRecord task, ActivityInfo.WindowLayout layout,
		ActivityRecord activity, ActivityRecord source, ActivityOptions options,
		LaunchParams currentParams, LaunchParams outParams) {
		int phase, LaunchParams currentParams, LaunchParams outParams) {
		initLogBuilder(task, activity);
		final int result = calculate(task, layout, activity, source, options, currentParams,
		final int result = calculate(task, layout, activity, source, options, phase, currentParams,
		outParams);
		outputLog();
		return result;
		}

		private int calculate(TaskRecord task, ActivityInfo.WindowLayout layout,
		ActivityRecord activity, ActivityRecord source, ActivityOptions options,
		ActivityRecord activity, ActivityRecord source, ActivityOptions options, int phase,
		LaunchParams currentParams, LaunchParams outParams) {
		final ActivityRecord root;
		if (task != null) {
		@@ -145,6 +154,10 @@ class TaskLaunchParamsModifier implements LaunchParamsModifier {
		+ display.getWindowingMode());
		}

		if (phase == PHASE_DISPLAY) {
		return RESULT_CONTINUE;
		}

		// STEP 2: Resolve launch windowing mode.
		// STEP 2.1: Determine if any parameter has specified initial bounds. That might be the
		// launch bounds from activity options, or size/gravity passed in layout. It also treats the
		@@ -247,6 +260,10 @@ class TaskLaunchParamsModifier implements LaunchParamsModifier {
		outParams.mWindowingMode = launchMode == display.getWindowingMode()
		? WINDOWING_MODE_UNDEFINED : launchMode;

		if (phase == PHASE_WINDOWING_MODE) {
		return RESULT_CONTINUE;
		}

		// STEP 3: Determine final launch bounds based on resolved windowing mode and activity
		// requested orientation. We set bounds to empty for fullscreen mode and keep bounds as is
		// for all other windowing modes that's not freeform mode. One can read comments in
		@@ -288,12 +305,6 @@ class TaskLaunchParamsModifier implements LaunchParamsModifier {
		displayId = optionLaunchId;
		}

		if (displayId == INVALID_DISPLAY && source != null) {
		final int sourceDisplayId = source.getDisplayId();
		if (DEBUG) appendLog("display-from-source=" + sourceDisplayId);
		displayId = sourceDisplayId;
		}

		ActivityStack stack =
		(displayId == INVALID_DISPLAY && task != null) ? task.getStack() : null;
		if (stack != null) {
		@@ -301,6 +312,12 @@ class TaskLaunchParamsModifier implements LaunchParamsModifier {
		displayId = stack.mDisplayId;
		}

		if (displayId == INVALID_DISPLAY && source != null) {
		final int sourceDisplayId = source.getDisplayId();
		if (DEBUG) appendLog("display-from-source=" + sourceDisplayId);
		displayId = sourceDisplayId;
		}

		if (displayId != INVALID_DISPLAY
		&& mSupervisor.mRootActivityContainer.getActivityDisplay(displayId) == null) {
		displayId = currentParams.mPreferredDisplayId;

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

+3 −3

Original line number	Diff line number	Diff line
		@@ -414,10 +414,10 @@ public class ActivityStarterTests extends ActivityTestsBase {
		.setActivityOptions(new SafeActivityOptions(options))
		.execute();

		// verify that values are passed to the modifier. Values are passed twice -- once for
		// verify that values are passed to the modifier. Values are passed thrice -- two for
		// setting initial state, another when task is created.
		verify(modifier, times(2)).onCalculate(any(), eq(windowLayout), any(), any(), eq(options),
		any(), any());
		verify(modifier, times(3)).onCalculate(any(), eq(windowLayout), any(), any(), eq(options),
		anyInt(), any(), any());
		}

		/**