Merge "Remove obsolete test APIs of split screen" into sc-dev am: a77a0600cf (b335bf11) · Commits · e / os / android_frameworks_base

core/api/test-current.txt

+0 −3

Original line number	Diff line number	Diff line
		@@ -157,10 +157,7 @@ package android.app {
		method @RequiresPermission(android.Manifest.permission.MANAGE_ACTIVITY_TASKS) public void moveTaskToRootTask(int, int, boolean);
		method @RequiresPermission(android.Manifest.permission.MANAGE_ACTIVITY_TASKS) public void removeRootTasksInWindowingModes(@NonNull int[]);
		method @RequiresPermission(android.Manifest.permission.MANAGE_ACTIVITY_TASKS) public void removeRootTasksWithActivityTypes(@NonNull int[]);
		method @RequiresPermission(android.Manifest.permission.MANAGE_ACTIVITY_TASKS) public void resizePrimarySplitScreen(@NonNull android.graphics.Rect, @NonNull android.graphics.Rect);
		method @RequiresPermission(android.Manifest.permission.MANAGE_ACTIVITY_TASKS) public void resizeTask(int, android.graphics.Rect);
		method @RequiresPermission(android.Manifest.permission.MANAGE_ACTIVITY_TASKS) public boolean setTaskWindowingMode(int, int, boolean) throws java.lang.SecurityException;
		method @RequiresPermission(android.Manifest.permission.MANAGE_ACTIVITY_TASKS) public boolean setTaskWindowingModeSplitScreenPrimary(int, boolean);
		method @RequiresPermission(android.Manifest.permission.MANAGE_ACTIVITY_TASKS) public void startSystemLockTaskMode(int);
		method @RequiresPermission(android.Manifest.permission.MANAGE_ACTIVITY_TASKS) public void stopSystemLockTaskMode();
		method public static boolean supportsMultiWindow(android.content.Context);

core/java/android/app/ActivityTaskManager.java

+0 −45

Original line number	Diff line number	Diff line
		@@ -16,8 +16,6 @@

		package android.app;

		import static android.app.WindowConfiguration.WINDOWING_MODE_SPLIT_SCREEN_PRIMARY;

		import android.annotation.NonNull;
		import android.annotation.Nullable;
		import android.annotation.RequiresPermission;
		@@ -168,35 +166,6 @@ public class ActivityTaskManager {
		}
		};

		/**
		* Sets the windowing mode for a specific task. Only works on tasks of type
		* {@link WindowConfiguration#ACTIVITY_TYPE_STANDARD}
		* @param taskId The id of the task to set the windowing mode for.
		* @param windowingMode The windowing mode to set for the task.
		* @param toTop If the task should be moved to the top once the windowing mode changes.
		* @return Whether the task was successfully put into the specified windowing mode.
		*/
		@RequiresPermission(android.Manifest.permission.MANAGE_ACTIVITY_TASKS)
		public boolean setTaskWindowingMode(int taskId, int windowingMode, boolean toTop)
		throws SecurityException {
		try {
		return getService().setTaskWindowingMode(taskId, windowingMode, toTop);
		} catch (RemoteException e) {
		throw e.rethrowFromSystemServer();
		}
		}

		/**
		* Moves the input task to the primary-split-screen stack.
		* @param taskId Id of task to move.
		* @param toTop If the task and stack should be moved to the top.
		* @return Whether the task was successfully put into splitscreen.
		*/
		@RequiresPermission(android.Manifest.permission.MANAGE_ACTIVITY_TASKS)
		public boolean setTaskWindowingModeSplitScreenPrimary(int taskId, boolean toTop) {
		return setTaskWindowingMode(taskId, WINDOWING_MODE_SPLIT_SCREEN_PRIMARY, toTop);
		}

		/**
		* Removes root tasks in the windowing modes from the system if they are of activity type
		* ACTIVITY_TYPE_STANDARD or ACTIVITY_TYPE_UNDEFINED
		@@ -366,20 +335,6 @@ public class ActivityTaskManager {
		}
		}

		/**
		* Resize docked stack & its task to given stack & task bounds.
		* @param rootTaskBounds Bounds to resize stack.
		* @param taskBounds Bounds to resize task.
		*/
		@RequiresPermission(android.Manifest.permission.MANAGE_ACTIVITY_TASKS)
		public void resizePrimarySplitScreen(@NonNull Rect rootTaskBounds, @NonNull Rect taskBounds) {
		try {
		getService().resizePrimarySplitScreen(rootTaskBounds, taskBounds, null, null, null);
		} catch (RemoteException e) {
		throw e.rethrowFromSystemServer();
		}
		}

		/**
		* Clears launch params for the given package.
		* @param packageNames the names of the packages of which the launch params are to be cleared

core/java/android/app/IActivityTaskManager.aidl

+0 −34

Original line number	Diff line number	Diff line
		@@ -87,8 +87,6 @@ import java.util.List;
		// surface exposed.
		// TODO(b/174041603): Create a builder interface for things like startActivityXXX(...) to reduce
		// interface duplication.
		// TODO(b/174040691): Clean-up/remove all obsolete or unused interfaces like things that should be
		// going through task organizer now.
		interface IActivityTaskManager {
		int startActivity(in IApplicationThread caller, in String callingPackage,
		in String callingFeatureId, in Intent intent, in String resolvedType,
		@@ -206,15 +204,6 @@ interface IActivityTaskManager {
		boolean resizeTask(int taskId, in Rect bounds, int resizeMode);
		void moveRootTaskToDisplay(int taskId, int displayId);

		/**
		* Sets the windowing mode for a specific task. Only works on tasks of type
		* {@link WindowConfiguration#ACTIVITY_TYPE_STANDARD}
		* @param taskId The id of the task to set the windowing mode for.
		* @param windowingMode The windowing mode to set for the task.
		* @param toTop If the task should be moved to the top once the windowing mode changes.
		* @return Whether the task was successfully put into the specified windowing mode.
		*/
		boolean setTaskWindowingMode(int taskId, int windowingMode, boolean toTop);
		void moveTaskToRootTask(int taskId, int rootTaskId, boolean toTop);

		/**
		@@ -258,29 +247,6 @@ interface IActivityTaskManager {

		void suppressResizeConfigChanges(boolean suppress);

		/**
		* Resizes the docked stack, and all other stacks as the result of the dock stack bounds change.
		*
		* @param dockedBounds The bounds for the docked stack.
		* @param tempDockedTaskBounds The temporary bounds for the tasks in the docked stack, which
		* might be different from the stack bounds to allow more
		* flexibility while resizing, or {@code null} if they should be the
		* same as the stack bounds.
		* @param tempDockedTaskInsetBounds The temporary bounds for the tasks to calculate the insets.
		* When resizing, we usually "freeze" the layout of a task. To
		* achieve that, we also need to "freeze" the insets, which
		* gets achieved by changing task bounds but not bounds used
		* to calculate the insets in this transient state
		* @param tempOtherTaskBounds The temporary bounds for the tasks in all other stacks, or
		* {@code null} if they should be the same as the stack bounds.
		* @param tempOtherTaskInsetBounds Like {@code tempDockedTaskInsetBounds}, but for the other
		* stacks.
		* @throws RemoteException
		*/
		void resizePrimarySplitScreen(in Rect dockedBounds, in Rect tempDockedTaskBounds,
		in Rect tempDockedTaskInsetBounds,
		in Rect tempOtherTaskBounds, in Rect tempOtherTaskInsetBounds);

		/** Returns an interface enabling the management of window organizers. */
		IWindowOrganizerController getWindowOrganizerController();

libs/WindowManager/Shell/src/com/android/wm/shell/legacysplitscreen/LegacySplitScreenController.java

+11 −7

Original line number	Diff line number	Diff line
		@@ -21,6 +21,7 @@ import static android.app.WindowConfiguration.ACTIVITY_TYPE_HOME;
		import static android.app.WindowConfiguration.ACTIVITY_TYPE_RECENTS;
		import static android.app.WindowConfiguration.ACTIVITY_TYPE_UNDEFINED;
		import static android.app.WindowConfiguration.WINDOWING_MODE_SPLIT_SCREEN_PRIMARY;
		import static android.app.WindowConfiguration.WINDOWING_MODE_UNDEFINED;
		import static android.content.res.Configuration.ORIENTATION_LANDSCAPE;
		import static android.view.Display.DEFAULT_DISPLAY;

		@@ -41,8 +42,6 @@ import android.window.TaskOrganizer;
		import android.window.WindowContainerToken;
		import android.window.WindowContainerTransaction;

		import androidx.annotation.Nullable;

		import com.android.internal.policy.DividerSnapAlgorithm;
		import com.android.wm.shell.R;
		import com.android.wm.shell.ShellTaskOrganizer;
		@@ -63,7 +62,6 @@ import java.lang.ref.WeakReference;
		import java.util.ArrayList;
		import java.util.List;
		import java.util.concurrent.CopyOnWriteArrayList;
		import java.util.concurrent.TimeUnit;
		import java.util.function.BiConsumer;
		import java.util.function.Consumer;

		@@ -496,13 +494,15 @@ public class LegacySplitScreenController implements DisplayController.OnDisplays

		public boolean splitPrimaryTask() {
		try {
		if (ActivityTaskManager.getService().getLockTaskModeState() == LOCK_TASK_MODE_PINNED
		\|\| isSplitActive()) {
		if (ActivityTaskManager.getService().getLockTaskModeState() == LOCK_TASK_MODE_PINNED) {
		return false;
		}
		} catch (RemoteException e) {
		return false;
		}
		if (isSplitActive() \|\| mSplits.mPrimary == null) {
		return false;
		}

		// Try fetching the top running task.
		final List<RunningTaskInfo> runningTasks =
		@@ -523,8 +523,12 @@ public class LegacySplitScreenController implements DisplayController.OnDisplays
		return false;
		}

		return ActivityTaskManager.getInstance().setTaskWindowingModeSplitScreenPrimary(
		topRunningTask.taskId, true /* onTop */);
		final WindowContainerTransaction wct = new WindowContainerTransaction();
		// Clear out current windowing mode before reparenting to split task.
		wct.setWindowingMode(topRunningTask.token, WINDOWING_MODE_UNDEFINED);
		wct.reparent(topRunningTask.token, mSplits.mPrimary.token, true /* onTop */);
		mWindowManagerProxy.applySyncTransaction(wct);
		return true;
		}

		public void dismissSplitToPrimaryTask() {

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

+0 −150

Original line number	Diff line number	Diff line
		@@ -35,9 +35,7 @@ import static android.app.ActivityManagerInternal.ALLOW_NON_FULL;
		import static android.app.ActivityTaskManager.INVALID_TASK_ID;
		import static android.app.ActivityTaskManager.RESIZE_MODE_PRESERVE_WINDOW;
		import static android.app.WindowConfiguration.ACTIVITY_TYPE_DREAM;
		import static android.app.WindowConfiguration.WINDOWING_MODE_FULLSCREEN;
		import static android.app.WindowConfiguration.WINDOWING_MODE_PINNED;
		import static android.app.WindowConfiguration.WINDOWING_MODE_UNDEFINED;
		import static android.content.Intent.FLAG_ACTIVITY_EXCLUDE_FROM_RECENTS;
		import static android.content.Intent.FLAG_ACTIVITY_NEW_TASK;
		import static android.content.pm.ActivityInfo.RESIZE_MODE_UNRESIZEABLE;
		@@ -114,7 +112,6 @@ import static com.android.server.wm.RecentsAnimationController.REORDER_MOVE_TO_O
		import static com.android.server.wm.RootWindowContainer.MATCH_ATTACHED_TASK_ONLY;
		import static com.android.server.wm.RootWindowContainer.MATCH_ATTACHED_TASK_OR_RECENT_TASKS;
		import static com.android.server.wm.Task.REPARENT_KEEP_ROOT_TASK_AT_FRONT;
		import static com.android.server.wm.WindowContainer.POSITION_TOP;
		import static com.android.server.wm.WindowManagerService.UPDATE_FOCUS_NORMAL;

		import android.Manifest;
		@@ -147,7 +144,6 @@ import android.app.PictureInPictureParams;
		import android.app.ProfilerInfo;
		import android.app.RemoteAction;
		import android.app.WaitResult;
		import android.app.WindowConfiguration;
		import android.app.admin.DevicePolicyCache;
		import android.app.assist.AssistContent;
		import android.app.assist.AssistStructure;
		@@ -227,7 +223,6 @@ import android.view.WindowManager;
		import android.window.IWindowOrganizerController;
		import android.window.SplashScreenView.SplashScreenViewParcelable;
		import android.window.TaskSnapshot;
		import android.window.WindowContainerTransaction;

		import com.android.internal.R;
		import com.android.internal.annotations.VisibleForTesting;
		@@ -1897,57 +1892,6 @@ public class ActivityTaskManagerService extends IActivityTaskManager.Stub {
		return null;
		}

		@Override
		public boolean setTaskWindowingMode(int taskId, int windowingMode, boolean toTop) {
		enforceTaskPermission("setTaskWindowingMode()");
		synchronized (mGlobalLock) {
		final long ident = Binder.clearCallingIdentity();
		try {
		if (isInLockTaskMode() && windowingMode != WINDOWING_MODE_FULLSCREEN) {
		Slog.w(TAG, "setTaskWindowingMode: Is in lock task mode="
		+ getLockTaskModeState());
		return false;
		}

		if (WindowConfiguration.isSplitScreenWindowingMode(windowingMode)) {
		return setTaskWindowingModeSplitScreen(taskId, windowingMode, toTop);
		}
		final Task task = mRootWindowContainer.anyTaskForId(taskId,
		MATCH_ATTACHED_TASK_ONLY);
		if (task == null) {
		Slog.w(TAG, "setTaskWindowingMode: No task for id=" + taskId);
		return false;
		}

		ProtoLog.d(WM_DEBUG_TASKS, "setTaskWindowingMode: moving task=%d "
		+ "to windowingMode=%d toTop=%b", taskId, windowingMode, toTop);

		if (!task.isActivityTypeStandardOrUndefined()) {
		throw new IllegalArgumentException("setTaskWindowingMode: Attempt to move"
		+ " non-standard task " + taskId + " to windowing mode="
		+ windowingMode);
		}

		final Task rootTask = task.getRootTask();
		if (toTop) {
		rootTask.moveToFront("setTaskWindowingMode", task);
		}
		// Convert some windowing-mode changes into root-task reparents for split-screen.
		if (rootTask.inSplitScreenWindowingMode()) {
		rootTask.getDisplayArea().onSplitScreenModeDismissed();

		} else {
		rootTask.setWindowingMode(windowingMode);
		rootTask.mDisplayContent.ensureActivitiesVisible(null, 0, PRESERVE_WINDOWS,
		true /* notifyClients */);
		}
		return true;
		} finally {
		Binder.restoreCallingIdentity(ident);
		}
		}
		}

		/**
		* Sets the locusId for a particular activity.
		*
		@@ -2224,59 +2168,6 @@ public class ActivityTaskManagerService extends IActivityTaskManager.Stub {
		}
		}

		/**
		* Moves the specified task into a split-screen tile.
		*/
		private boolean setTaskWindowingModeSplitScreen(int taskId, int windowingMode, boolean toTop) {
		if (!WindowConfiguration.isSplitScreenWindowingMode(windowingMode)) {
		throw new IllegalArgumentException("Calling setTaskWindowingModeSplitScreen with non"
		+ "split-screen mode: " + windowingMode);
		}

		final Task task = mRootWindowContainer.anyTaskForId(taskId,
		MATCH_ATTACHED_TASK_ONLY);
		if (task == null) {
		Slog.w(TAG, "setTaskWindowingModeSplitScreenPrimary: No task for id=" + taskId);
		return false;
		}
		if (!task.isActivityTypeStandardOrUndefined()) {
		throw new IllegalArgumentException("setTaskWindowingMode: Attempt to move"
		+ " non-standard task " + taskId + " to split-screen windowing mode");
		}
		if (!task.supportsSplitScreenWindowingMode()) {
		return false;
		}

		final int prevMode = task.getWindowingMode();
		if (prevMode == windowingMode) {
		// The task is already in split-screen and with correct windowing mode.
		return true;
		}

		moveTaskToSplitScreenPrimaryTask(task, toTop);
		return prevMode != task.getWindowingMode();
		}

		void moveTaskToSplitScreenPrimaryTask(Task task, boolean toTop) {
		final TaskDisplayArea taskDisplayArea = task.getDisplayArea();
		final Task primarySplitTask = taskDisplayArea.getRootSplitScreenPrimaryTask();
		if (primarySplitTask == null) {
		throw new IllegalStateException("Can't enter split without associated organized task");
		}

		if (toTop) {
		taskDisplayArea.positionChildAt(POSITION_TOP, primarySplitTask,
		false /* includingParents */);
		}
		WindowContainerTransaction wct = new WindowContainerTransaction();
		// Clear out current windowing mode before reparenting to split taks.
		wct.setWindowingMode(
		task.getRootTask().mRemoteToken.toWindowContainerToken(), WINDOWING_MODE_UNDEFINED);
		wct.reparent(task.getRootTask().mRemoteToken.toWindowContainerToken(),
		primarySplitTask.mRemoteToken.toWindowContainerToken(), toTop);
		mWindowOrganizerController.applyTransaction(wct);
		}

		/**
		* Removes root tasks in the input windowing modes from the system if they are of activity type
		* ACTIVITY_TYPE_STANDARD or ACTIVITY_TYPE_UNDEFINED
		@@ -3400,47 +3291,6 @@ public class ActivityTaskManagerService extends IActivityTaskManager.Stub {
		return true;
		}

		// TODO(b/149338177): remove when CTS no-longer requires it
		@Override
		public void resizePrimarySplitScreen(Rect dockedBounds, Rect tempDockedTaskBounds,
		Rect tempDockedTaskInsetBounds,
		Rect tempOtherTaskBounds, Rect tempOtherTaskInsetBounds) {
		enforceTaskPermission("resizePrimarySplitScreen()");
		final long ident = Binder.clearCallingIdentity();
		try {
		synchronized (mGlobalLock) {
		final TaskDisplayArea tc = mRootWindowContainer.getDefaultTaskDisplayArea();
		final Task primary = tc.getRootSplitScreenPrimaryTask();
		final Task secondary = tc.getTask(t -> t.mCreatedByOrganizer && t.isRootTask()
		&& t.inSplitScreenSecondaryWindowingMode());
		if (primary == null \|\| secondary == null) {
		return;
		}
		final WindowContainerTransaction wct = new WindowContainerTransaction();
		final Rect primaryRect =
		tempDockedTaskInsetBounds != null ? tempDockedTaskInsetBounds
		: (tempDockedTaskBounds != null ? tempDockedTaskBounds
		: dockedBounds);
		wct.setBounds(primary.mRemoteToken.toWindowContainerToken(), primaryRect);
		Rect otherRect = tempOtherTaskInsetBounds != null ? tempOtherTaskInsetBounds
		: tempOtherTaskBounds;
		if (otherRect == null) {
		// Temporary estimation... again this is just for tests.
		otherRect = new Rect(secondary.getBounds());
		if (tc.getBounds().width() > tc.getBounds().height()) {
		otherRect.left = primaryRect.right + 6;
		} else {
		otherRect.top = primaryRect.bottom + 6;
		}
		}
		wct.setBounds(secondary.mRemoteToken.toWindowContainerToken(), otherRect);
		mWindowOrganizerController.applyTransaction(wct);
		}
		} finally {
		Binder.restoreCallingIdentity(ident);
		}
		}

		@Override
		public void setSplitScreenResizing(boolean resizing) {
		enforceTaskPermission("setSplitScreenResizing()");