Merge "Keep the focus on the primary when launch ActivityEmbedding placeholder" into tm-dev
diff --git a/core/java/android/window/WindowContainerTransaction.java b/core/java/android/window/WindowContainerTransaction.java
index 79dac19..7dc039d 100644
--- a/core/java/android/window/WindowContainerTransaction.java
+++ b/core/java/android/window/WindowContainerTransaction.java
@@ -650,6 +650,26 @@
}
/**
+ * Requests focus on the top running Activity in the given TaskFragment. This will only take
+ * effect if there is no focus, or if the current focus is in the same Task as the requested
+ * TaskFragment.
+ * @param fragmentToken client assigned unique token to create TaskFragment with specified in
+ * {@link TaskFragmentCreationParams#getFragmentToken()}.
+ * @hide
+ */
+ @NonNull
+ public WindowContainerTransaction requestFocusOnTaskFragment(@NonNull IBinder fragmentToken) {
+ final HierarchyOp hierarchyOp =
+ new HierarchyOp.Builder(
+ HierarchyOp.HIERARCHY_OP_TYPE_REQUEST_FOCUS_ON_TASK_FRAGMENT)
+ .setContainer(fragmentToken)
+ .build();
+ mHierarchyOps.add(hierarchyOp);
+ return this;
+
+ }
+
+ /**
* When this {@link WindowContainerTransaction} failed to finish on the server side, it will
* trigger callback with this {@param errorCallbackToken}.
* @param errorCallbackToken client provided token that will be passed back as parameter in
@@ -1057,6 +1077,7 @@
public static final int HIERARCHY_OP_TYPE_RESTORE_TRANSIENT_ORDER = 15;
public static final int HIERARCHY_OP_TYPE_ADD_RECT_INSETS_PROVIDER = 16;
public static final int HIERARCHY_OP_TYPE_REMOVE_INSETS_PROVIDER = 17;
+ public static final int HIERARCHY_OP_TYPE_REQUEST_FOCUS_ON_TASK_FRAGMENT = 18;
// The following key(s) are for use with mLaunchOptions:
// When launching a task (eg. from recents), this is the taskId to be launched.
@@ -1368,6 +1389,8 @@
case HIERARCHY_OP_TYPE_REMOVE_INSETS_PROVIDER:
return "{removeLocalInsetsProvider: container=" + mContainer
+ " insetsType=" + Arrays.toString(mInsetsTypes) + "}";
+ case HIERARCHY_OP_TYPE_REQUEST_FOCUS_ON_TASK_FRAGMENT:
+ return "{requestFocusOnTaskFragment: container=" + mContainer + "}";
default:
return "{mType=" + mType + " container=" + mContainer + " reparent=" + mReparent
+ " mToTop=" + mToTop
diff --git a/libs/WindowManager/Jetpack/src/androidx/window/extensions/embedding/SplitController.java b/libs/WindowManager/Jetpack/src/androidx/window/extensions/embedding/SplitController.java
index 9f33cbc..2328f76 100644
--- a/libs/WindowManager/Jetpack/src/androidx/window/extensions/embedding/SplitController.java
+++ b/libs/WindowManager/Jetpack/src/androidx/window/extensions/embedding/SplitController.java
@@ -112,9 +112,10 @@
*/
public void startActivityToSide(@NonNull Activity launchingActivity, @NonNull Intent intent,
@Nullable Bundle options, @NonNull SplitRule sideRule,
- @Nullable Consumer<Exception> failureCallback) {
+ @Nullable Consumer<Exception> failureCallback, boolean isPlaceholder) {
try {
- mPresenter.startActivityToSide(launchingActivity, intent, options, sideRule);
+ mPresenter.startActivityToSide(launchingActivity, intent, options, sideRule,
+ isPlaceholder);
} catch (Exception e) {
if (failureCallback != null) {
failureCallback.accept(e);
@@ -710,8 +711,8 @@
}
// TODO(b/190433398): Handle failed request
- startActivityToSide(activity, placeholderRule.getPlaceholderIntent(), null,
- placeholderRule, null);
+ startActivityToSide(activity, placeholderRule.getPlaceholderIntent(), null /* options */,
+ placeholderRule, null /* failureCallback */, true /* isPlaceholder */);
return true;
}
diff --git a/libs/WindowManager/Jetpack/src/androidx/window/extensions/embedding/SplitPresenter.java b/libs/WindowManager/Jetpack/src/androidx/window/extensions/embedding/SplitPresenter.java
index 716a087..ee5a322 100644
--- a/libs/WindowManager/Jetpack/src/androidx/window/extensions/embedding/SplitPresenter.java
+++ b/libs/WindowManager/Jetpack/src/androidx/window/extensions/embedding/SplitPresenter.java
@@ -217,12 +217,13 @@
* @param launchingActivity An activity that should be in the primary container. If it is not
* currently in an existing container, a new one will be created and
* the activity will be re-parented to it.
- * @param activityIntent The intent to start the new activity.
- * @param activityOptions The options to apply to new activity start.
- * @param rule The split rule to be applied to the container.
+ * @param activityIntent The intent to start the new activity.
+ * @param activityOptions The options to apply to new activity start.
+ * @param rule The split rule to be applied to the container.
+ * @param isPlaceholder Whether the launch is a placeholder.
*/
void startActivityToSide(@NonNull Activity launchingActivity, @NonNull Intent activityIntent,
- @Nullable Bundle activityOptions, @NonNull SplitRule rule) {
+ @Nullable Bundle activityOptions, @NonNull SplitRule rule, boolean isPlaceholder) {
final Rect parentBounds = getParentContainerBounds(launchingActivity);
final Rect primaryRectBounds = getBoundsForPosition(POSITION_START, parentBounds, rule,
isLtr(launchingActivity, rule));
@@ -244,6 +245,10 @@
startActivityToSide(wct, primaryContainer.getTaskFragmentToken(), primaryRectBounds,
launchingActivity, secondaryContainer.getTaskFragmentToken(), secondaryRectBounds,
activityIntent, activityOptions, rule);
+ if (isPlaceholder) {
+ // When placeholder is launched in split, we should keep the focus on the primary.
+ wct.requestFocusOnTaskFragment(primaryContainer.getTaskFragmentToken());
+ }
applyTransaction(wct);
primaryContainer.setLastRequestedBounds(primaryRectBounds);
@@ -272,14 +277,21 @@
isLtr);
final Rect secondaryRectBounds = getBoundsForPosition(POSITION_END, parentBounds, rule,
isLtr);
+ final TaskFragmentContainer secondaryContainer = splitContainer.getSecondaryContainer();
+ // Whether the placeholder is becoming side-by-side with the primary from fullscreen.
+ final boolean isPlaceholderBecomingSplit = splitContainer.isPlaceholderContainer()
+ && secondaryContainer.areLastRequestedBoundsEqual(null /* bounds */)
+ && !secondaryRectBounds.isEmpty();
// If the task fragments are not registered yet, the positions will be updated after they
// are created again.
resizeTaskFragmentIfRegistered(wct, primaryContainer, primaryRectBounds);
- final TaskFragmentContainer secondaryContainer = splitContainer.getSecondaryContainer();
resizeTaskFragmentIfRegistered(wct, secondaryContainer, secondaryRectBounds);
-
setAdjacentTaskFragments(wct, primaryContainer, secondaryContainer, rule);
+ if (isPlaceholderBecomingSplit) {
+ // When placeholder is shown in split, we should keep the focus on the primary.
+ wct.requestFocusOnTaskFragment(primaryContainer.getTaskFragmentToken());
+ }
}
private void setAdjacentTaskFragments(@NonNull WindowContainerTransaction wct,
diff --git a/services/core/java/com/android/server/wm/WindowOrganizerController.java b/services/core/java/com/android/server/wm/WindowOrganizerController.java
index efed92d..7de8ed5 100644
--- a/services/core/java/com/android/server/wm/WindowOrganizerController.java
+++ b/services/core/java/com/android/server/wm/WindowOrganizerController.java
@@ -30,6 +30,7 @@
import static android.window.WindowContainerTransaction.HierarchyOp.HIERARCHY_OP_TYPE_REPARENT;
import static android.window.WindowContainerTransaction.HierarchyOp.HIERARCHY_OP_TYPE_REPARENT_ACTIVITY_TO_TASK_FRAGMENT;
import static android.window.WindowContainerTransaction.HierarchyOp.HIERARCHY_OP_TYPE_REPARENT_CHILDREN;
+import static android.window.WindowContainerTransaction.HierarchyOp.HIERARCHY_OP_TYPE_REQUEST_FOCUS_ON_TASK_FRAGMENT;
import static android.window.WindowContainerTransaction.HierarchyOp.HIERARCHY_OP_TYPE_RESTORE_TRANSIENT_ORDER;
import static android.window.WindowContainerTransaction.HierarchyOp.HIERARCHY_OP_TYPE_SET_ADJACENT_ROOTS;
import static android.window.WindowContainerTransaction.HierarchyOp.HIERARCHY_OP_TYPE_SET_ADJACENT_TASK_FRAGMENTS;
@@ -775,6 +776,29 @@
}
break;
}
+ case HIERARCHY_OP_TYPE_REQUEST_FOCUS_ON_TASK_FRAGMENT: {
+ final TaskFragment tf = mLaunchTaskFragments.get(hop.getContainer());
+ if (tf == null || !tf.isAttached()) {
+ Slog.e(TAG, "Attempt to operate on detached container: " + tf);
+ break;
+ }
+ final ActivityRecord curFocus = tf.getDisplayContent().mFocusedApp;
+ if (curFocus != null && curFocus.getTaskFragment() == tf) {
+ Slog.d(TAG, "The requested TaskFragment already has the focus.");
+ break;
+ }
+ if (curFocus != null && curFocus.getTask() != tf.getTask()) {
+ Slog.d(TAG, "The Task of the requested TaskFragment doesn't have focus.");
+ break;
+ }
+ final ActivityRecord targetFocus = tf.getTopResumedActivity();
+ if (targetFocus == null) {
+ Slog.d(TAG, "There is no resumed activity in the requested TaskFragment.");
+ break;
+ }
+ tf.getDisplayContent().setFocusedApp(targetFocus);
+ break;
+ }
default: {
// The other operations may change task order so they are skipped while in lock
// task mode. The above operations are still allowed because they don't move
@@ -1318,6 +1342,7 @@
case HIERARCHY_OP_TYPE_START_ACTIVITY_IN_TASK_FRAGMENT:
case HIERARCHY_OP_TYPE_REPARENT_ACTIVITY_TO_TASK_FRAGMENT:
case HIERARCHY_OP_TYPE_SET_ADJACENT_TASK_FRAGMENTS:
+ case HIERARCHY_OP_TYPE_REQUEST_FOCUS_ON_TASK_FRAGMENT:
// We are allowing organizer to start/reparent activity to a TaskFragment it
// created, or set two TaskFragments adjacent to each other. Nothing to check
// here because the TaskFragment may not be created yet, but will be created in
diff --git a/services/tests/wmtests/src/com/android/server/wm/TaskFragmentOrganizerControllerTest.java b/services/tests/wmtests/src/com/android/server/wm/TaskFragmentOrganizerControllerTest.java
index 4425962..7a70474 100644
--- a/services/tests/wmtests/src/com/android/server/wm/TaskFragmentOrganizerControllerTest.java
+++ b/services/tests/wmtests/src/com/android/server/wm/TaskFragmentOrganizerControllerTest.java
@@ -522,6 +522,55 @@
}
@Test
+ public void testApplyTransaction_requestFocusOnTaskFragment() {
+ mOrganizer.applyTransaction(mTransaction);
+ mController.registerOrganizer(mIOrganizer);
+ final Task task = createTask(mDisplayContent);
+ final IBinder token0 = new Binder();
+ final TaskFragment tf0 = new TaskFragmentBuilder(mAtm)
+ .setParentTask(task)
+ .setFragmentToken(token0)
+ .setOrganizer(mOrganizer)
+ .createActivityCount(1)
+ .build();
+ final IBinder token1 = new Binder();
+ final TaskFragment tf1 = new TaskFragmentBuilder(mAtm)
+ .setParentTask(task)
+ .setFragmentToken(token1)
+ .setOrganizer(mOrganizer)
+ .createActivityCount(1)
+ .build();
+ mAtm.mWindowOrganizerController.mLaunchTaskFragments.put(token0, tf0);
+ mAtm.mWindowOrganizerController.mLaunchTaskFragments.put(token1, tf1);
+ final ActivityRecord activity0 = tf0.getTopMostActivity();
+ final ActivityRecord activity1 = tf1.getTopMostActivity();
+
+ // No effect if the current focus is in a different Task.
+ final ActivityRecord activityInOtherTask = createActivityRecord(mDefaultDisplay);
+ mDisplayContent.setFocusedApp(activityInOtherTask);
+ mTransaction.requestFocusOnTaskFragment(token0);
+ mAtm.mWindowOrganizerController.applyTransaction(mTransaction);
+
+ assertEquals(activityInOtherTask, mDisplayContent.mFocusedApp);
+
+ // No effect if there is no resumed activity in the request TaskFragment.
+ activity0.setState(ActivityRecord.State.PAUSED, "test");
+ activity1.setState(ActivityRecord.State.RESUMED, "test");
+ mDisplayContent.setFocusedApp(activity1);
+ mAtm.mWindowOrganizerController.applyTransaction(mTransaction);
+
+ assertEquals(activity1, mDisplayContent.mFocusedApp);
+
+ // Set focus to the request TaskFragment when the current focus is in the same Task, and it
+ // has a resumed activity.
+ activity0.setState(ActivityRecord.State.RESUMED, "test");
+ mDisplayContent.setFocusedApp(activity1);
+ mAtm.mWindowOrganizerController.applyTransaction(mTransaction);
+
+ assertEquals(activity0, mDisplayContent.mFocusedApp);
+ }
+
+ @Test
public void testTaskFragmentInPip_startActivityInTaskFragment() {
setupTaskFragmentInPip();
final ActivityRecord activity = mTaskFragment.getTopMostActivity();