Merge "Delete legacy transition code from StageTaskListener" into main (314441aa) · Commits · e / os / android_frameworks_base

libs/WindowManager/Shell/src/com/android/wm/shell/splitscreen/StageCoordinator.java

+0 −29

Original line number	Diff line number	Diff line
		@@ -1738,35 +1738,6 @@ public class StageCoordinator implements SplitLayout.SplitLayoutHandler,
		mLaunchAdjacentController.setLaunchAdjacentRoot(mSideStage.mRootTaskInfo.token);
		}

		/** Callback when split roots have child task appeared under it, this is a little different from
		* #onStageHasChildrenChanged because this would be called every time child task appeared.
		* NOTICE: This only be called on legacy transition. */
		@Override
		public void onChildTaskAppeared(StageTaskListener stageListener, int taskId) {
		ProtoLog.d(WM_SHELL_SPLIT_SCREEN, "onChildTaskAppeared: isMainStage=%b task=%d",
		stageListener == mMainStage, taskId);
		// Handle entering split screen while there is a split pair running in the background.
		if (stageListener == mSideStage && !isSplitScreenVisible() && isSplitActive()
		&& mSplitRequest == null) {
		final WindowContainerTransaction wct = new WindowContainerTransaction();
		prepareEnterSplitScreen(wct);
		mMainStage.evictAllChildren(wct);
		mSideStage.evictOtherChildren(wct, taskId);

		mSyncQueue.queue(wct);
		mSyncQueue.runInSync(t -> {
		if (mIsDropEntering) {
		updateSurfaceBounds(mSplitLayout, t, false /* applyResizingOffset */);
		mIsDropEntering = false;
		mSkipEvictingMainStageChildren = false;
		} else {
		mShowDecorImmediately = true;
		mSplitLayout.flingDividerToCenter(/finishCallback/ null);
		}
		});
		}
		}

		@Override
		public void onRootTaskVanished() {
		ProtoLog.d(WM_SHELL_SPLIT_SCREEN, "onRootTaskVanished");

libs/WindowManager/Shell/src/com/android/wm/shell/splitscreen/StageTaskListener.java

+1 −54

Original line number	Diff line number	Diff line
		@@ -22,20 +22,17 @@ import static android.app.WindowConfiguration.WINDOWING_MODE_UNDEFINED;
		import static android.content.res.Configuration.SMALLEST_SCREEN_WIDTH_DP_UNDEFINED;
		import static android.view.RemoteAnimationTarget.MODE_OPENING;

		import static com.android.wm.shell.protolog.ShellProtoLogGroup.WM_SHELL_SPLIT_SCREEN;
		import static com.android.wm.shell.shared.split.SplitScreenConstants.CONTROLLED_ACTIVITY_TYPES;
		import static com.android.wm.shell.shared.split.SplitScreenConstants.CONTROLLED_WINDOWING_MODES;
		import static com.android.wm.shell.shared.split.SplitScreenConstants.CONTROLLED_WINDOWING_MODES_WHEN_ACTIVE;
		import static com.android.wm.shell.protolog.ShellProtoLogGroup.WM_SHELL_SPLIT_SCREEN;
		import static com.android.wm.shell.transition.Transitions.ENABLE_SHELL_TRANSITIONS;

		import android.annotation.CallSuper;
		import android.annotation.Nullable;
		import android.app.ActivityManager;
		import android.content.Context;
		import android.graphics.Point;
		import android.graphics.Rect;
		import android.os.IBinder;
		import android.util.Slog;
		import android.util.SparseArray;
		import android.view.RemoteAnimationTarget;
		import android.view.SurfaceControl;
		@@ -77,7 +74,6 @@ public class StageTaskListener implements ShellTaskOrganizer.TaskListener {
		/** Callback interface for listening to changes in a split-screen stage. */
		public interface StageListenerCallbacks {
		void onRootTaskAppeared();
		void onChildTaskAppeared(StageTaskListener stageTaskListener, int taskId);

		void onStageHasChildrenChanged(StageTaskListener stageTaskListener);

		@@ -220,13 +216,6 @@ public class StageTaskListener implements ShellTaskOrganizer.TaskListener {
		mChildrenTaskInfo.put(taskId, taskInfo);
		mCallbacks.onChildTaskStatusChanged(this, taskId, true /* present */,
		taskInfo.isVisible && taskInfo.isVisibleRequested);
		if (ENABLE_SHELL_TRANSITIONS) {
		// Status is managed/synchronized by the transition lifecycle.
		return;
		}
		updateChildTaskSurface(taskInfo, leash, true /* firstAppeared */);
		mCallbacks.onChildTaskAppeared(this, taskId);
		sendStatusChanged();
		} else {
		throw new IllegalArgumentException(this + "\n Unknown task: " + taskInfo
		+ "\n mRootTaskInfo: " + mRootTaskInfo);
		@@ -240,14 +229,6 @@ public class StageTaskListener implements ShellTaskOrganizer.TaskListener {
		taskInfo.taskId, taskInfo.baseActivity);
		mWindowDecorViewModel.ifPresent(viewModel -> viewModel.onTaskInfoChanged(taskInfo));
		if (mRootTaskInfo.taskId == taskInfo.taskId) {
		// Inflates split decor view only when the root task is visible.
		if (!ENABLE_SHELL_TRANSITIONS && mRootTaskInfo.isVisible != taskInfo.isVisible) {
		if (taskInfo.isVisible) {
		mSplitDecorManager.inflate(mContext, mRootLeash);
		} else {
		mSyncQueue.runInSync(t -> mSplitDecorManager.release(t));
		}
		}
		mRootTaskInfo = taskInfo;
		} else if (taskInfo.parentTaskId == mRootTaskInfo.taskId) {
		if (!taskInfo.supportsMultiWindow
		@@ -265,19 +246,10 @@ public class StageTaskListener implements ShellTaskOrganizer.TaskListener {
		mChildrenTaskInfo.put(taskInfo.taskId, taskInfo);
		mCallbacks.onChildTaskStatusChanged(this, taskInfo.taskId, true /* present */,
		taskInfo.isVisible && taskInfo.isVisibleRequested);
		if (!ENABLE_SHELL_TRANSITIONS) {
		updateChildTaskSurface(
		taskInfo, mChildrenLeashes.get(taskInfo.taskId), false /* firstAppeared */);
		}
		} else {
		throw new IllegalArgumentException(this + "\n Unknown task: " + taskInfo
		+ "\n mRootTaskInfo: " + mRootTaskInfo);
		}
		if (ENABLE_SHELL_TRANSITIONS) {
		// Status is managed/synchronized by the transition lifecycle.
		return;
		}
		sendStatusChanged();
		}

		@Override
		@@ -302,11 +274,6 @@ public class StageTaskListener implements ShellTaskOrganizer.TaskListener {
		mChildrenLeashes.remove(taskId);
		mCallbacks.onChildTaskStatusChanged(this, taskId, false /* present */,
		taskInfo.isVisible);
		if (ENABLE_SHELL_TRANSITIONS) {
		// Status is managed/synchronized by the transition lifecycle.
		return;
		}
		sendStatusChanged();
		} else {
		throw new IllegalArgumentException(this + "\n Unknown task: " + taskInfo
		+ "\n mRootTaskInfo: " + mRootTaskInfo);
		@@ -468,26 +435,6 @@ public class StageTaskListener implements ShellTaskOrganizer.TaskListener {
		}
		}

		private void updateChildTaskSurface(ActivityManager.RunningTaskInfo taskInfo,
		SurfaceControl leash, boolean firstAppeared) {
		final Point taskPositionInParent = taskInfo.positionInParent;
		mSyncQueue.runInSync(t -> {
		// The task surface might be released before running in the sync queue for the case like
		// trampoline launch, so check if the surface is valid before processing it.
		if (!leash.isValid()) {
		Slog.w(TAG, "Skip updating invalid child task surface of task#" + taskInfo.taskId);
		return;
		}
		t.setCrop(leash, null);
		t.setPosition(leash, taskPositionInParent.x, taskPositionInParent.y);
		if (firstAppeared) {
		t.setAlpha(leash, 1f);
		t.setMatrix(leash, 1, 0, 0, 1);
		t.show(leash);
		}
		});
		}

		// ---------
		// Previously only used in MainStage
		boolean isActive() {