Merge "Allow multiple adjacent TFs (6/n)" into main (7b103334) · Commits · e / os / android_frameworks_base

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

+48 −24

Original line number	Diff line number	Diff line
		@@ -34,6 +34,7 @@ import android.window.TaskSnapshot;

		import com.android.internal.annotations.VisibleForTesting;
		import com.android.server.wm.BaseAppSnapshotPersister.PersistInfoProvider;
		import com.android.window.flags.Flags;

		import java.io.File;
		import java.io.PrintWriter;
		@@ -498,50 +499,73 @@ class ActivitySnapshotController extends AbsAppSnapshotController<ActivityRecord
		}
		final TaskFragment currTF = currentActivity.getTaskFragment();
		final TaskFragment prevTF = initPrev.getTaskFragment();
		final TaskFragment prevAdjacentTF = prevTF != null
		? prevTF.getAdjacentTaskFragment() : null;
		if (currTF == prevTF && currTF != null \|\| prevAdjacentTF == null) {
		// Current activity and previous one is in the same task fragment, or
		// previous activity is not in a task fragment, or
		// previous activity's task fragment doesn't adjacent to any others.
		if (currTF == prevTF \|\| prevTF.asTask() != null \|\| !prevTF.hasAdjacentTaskFragment()) {
		// Current activity and the initPrev is in the same TaskFragment,
		// or initPrev activity is a direct child of Task,
		// or initPrev activity doesn't have an adjacent.
		// A
		// B
		if (!inTransition \|\| isInParticipant(initPrev, mTmpTransitionParticipants)) {
		result.add(initPrev);
		}
		return;
		}

		if (prevAdjacentTF == currTF) {
		if (currTF.isAdjacentTo(prevTF)) {
		// previous activity A is adjacent to current activity B.
		// Try to find anyone below previous activityA, which are C and D if exists.
		// A \| B
		// C (\| D)
		getActivityBelow(initPrev, inTransition, result);
		} else {
		// previous activity C isn't adjacent to current activity A.
		return;
		}

		// The initPrev activity has an adjacent that is different from current activity.
		// A
		// B \| C
		final Task prevAdjacentTask = prevAdjacentTF.getTask();
		if (prevAdjacentTask == currentTask) {
		final int currentIndex = currTF != null
		? currentTask.mChildren.indexOf(currTF)
		: currentTask.mChildren.indexOf(currentActivity);
		final int prevAdjacentIndex =
		prevAdjacentTask.mChildren.indexOf(prevAdjacentTF);
		// prevAdjacentTF already above currentActivity
		final int currentIndex = currTF.asTask() != null
		? currentTask.mChildren.indexOf(currentActivity)
		: currentTask.mChildren.indexOf(currTF);
		if (!Flags.allowMultipleAdjacentTaskFragments()) {
		final int prevAdjacentIndex = currentTask.mChildren.indexOf(
		prevTF.getAdjacentTaskFragment());
		if (prevAdjacentIndex > currentIndex) {
		// PrevAdjacentTF already above currentActivity
		return;
		}
		// Add both the one below, and its adjacent.
		if (!inTransition \|\| isInParticipant(initPrev, mTmpTransitionParticipants)) {
		result.add(initPrev);
		}
		final ActivityRecord prevAdjacentActivity = prevTF.getAdjacentTaskFragment()
		.getTopMostActivity();
		if (prevAdjacentActivity != null && (!inTransition
		\|\| isInParticipant(prevAdjacentActivity, mTmpTransitionParticipants))) {
		result.add(prevAdjacentActivity);
		}
		return;
		}

		final boolean hasAdjacentAboveCurrent = prevTF.forOtherAdjacentTaskFragments(
		prevAdjacentTF -> {
		final int prevAdjacentIndex = currentTask.mChildren.indexOf(prevAdjacentTF);
		return prevAdjacentIndex > currentIndex;
		});
		if (hasAdjacentAboveCurrent) {
		// PrevAdjacentTF already above currentActivity
		return;
		}
		// Add all adjacent top.
		if (!inTransition \|\| isInParticipant(initPrev, mTmpTransitionParticipants)) {
		result.add(initPrev);
		}
		// prevAdjacentTF is adjacent to another one
		prevTF.forOtherAdjacentTaskFragments(prevAdjacentTF -> {
		final ActivityRecord prevAdjacentActivity = prevAdjacentTF.getTopMostActivity();
		if (prevAdjacentActivity != null && (!inTransition
		\|\| isInParticipant(prevAdjacentActivity, mTmpTransitionParticipants))) {
		result.add(prevAdjacentActivity);
		}
		}
		});
		}

		static boolean isInParticipant(ActivityRecord ar,

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

+45 −13

Original line number	Diff line number	Diff line
		@@ -453,7 +453,7 @@ class BackNavigationController {
		outPrevActivities.add(prevActivity);
		return true;
		}
		if (currTF.getAdjacentTaskFragment() == null) {
		if (!currTF.hasAdjacentTaskFragment()) {
		final TaskFragment nextTF = findNextTaskFragment(currentTask, currTF);
		if (isSecondCompanionToFirst(currTF, nextTF)) {
		// TF is isStacked, search bottom activity from companion TF.
		@@ -476,7 +476,21 @@ class BackNavigationController {
		}
		} else {
		// If adjacent TF has companion to current TF, those two TF will be closed together.
		final TaskFragment adjacentTF = currTF.getAdjacentTaskFragment();
		final TaskFragment adjacentTF;
		if (Flags.allowMultipleAdjacentTaskFragments()) {
		if (currTF.getAdjacentTaskFragments().size() > 2) {
		throw new IllegalStateException(
		"Not yet support 3+ adjacent for non-Task TFs");
		}
		final TaskFragment[] tmpAdjacent = new TaskFragment[1];
		currTF.forOtherAdjacentTaskFragments(tf -> {
		tmpAdjacent[0] = tf;
		return true;
		});
		adjacentTF = tmpAdjacent[0];
		} else {
		adjacentTF = currTF.getAdjacentTaskFragment();
		}
		if (isSecondCompanionToFirst(currTF, adjacentTF)) {
		// The two TFs are adjacent (visually displayed side-by-side), search if any
		// activity below the lowest one.
		@@ -533,30 +547,48 @@ class BackNavigationController {
		return;
		}

		if (!prevTF.hasAdjacentTaskFragment()) {
		return;
		}
		if (!Flags.allowMultipleAdjacentTaskFragments()) {
		final TaskFragment prevTFAdjacent = prevTF.getAdjacentTaskFragment();
		if (prevTFAdjacent == null \|\| prevTFAdjacent.asTask() != null) {
		final ActivityRecord prevActivityAdjacent =
		prevTFAdjacent.getTopNonFinishingActivity();
		if (prevActivityAdjacent != null) {
		outPrevActivities.add(prevActivityAdjacent);
		}
		return;
		}
		prevTF.forOtherAdjacentTaskFragments(prevTFAdjacent -> {
		final ActivityRecord prevActivityAdjacent =
		prevTFAdjacent.getTopNonFinishingActivity();
		if (prevActivityAdjacent != null) {
		outPrevActivities.add(prevActivityAdjacent);
		}
		});
		}

		private static void findAdjacentActivityIfExist(@NonNull ActivityRecord mainActivity,
		@NonNull ArrayList<ActivityRecord> outList) {
		final TaskFragment mainTF = mainActivity.getTaskFragment();
		if (mainTF == null \|\| mainTF.getAdjacentTaskFragment() == null) {
		if (mainTF == null \|\| !mainTF.hasAdjacentTaskFragment()) {
		return;
		}
		if (!Flags.allowMultipleAdjacentTaskFragments()) {
		final TaskFragment adjacentTF = mainTF.getAdjacentTaskFragment();
		final ActivityRecord topActivity = adjacentTF.getTopNonFinishingActivity();
		if (topActivity == null) {
		if (topActivity != null) {
		outList.add(topActivity);
		}
		return;
		}
		mainTF.forOtherAdjacentTaskFragments(adjacentTF -> {
		final ActivityRecord topActivity = adjacentTF.getTopNonFinishingActivity();
		if (topActivity != null) {
		outList.add(topActivity);
		}
		});
		}

		private static boolean hasTranslucentActivity(@NonNull ActivityRecord currentActivity,
		@NonNull ArrayList<ActivityRecord> prevActivities) {