450 lines
19 KiB
Java
450 lines
19 KiB
Java
/*
|
|
* Copyright (C) 2021 The Android Open Source Project
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
|
|
package com.android.wm.shell.taskview;
|
|
|
|
import static android.view.WindowManager.TRANSIT_CHANGE;
|
|
import static android.view.WindowManager.TRANSIT_CLOSE;
|
|
import static android.view.WindowManager.TRANSIT_OPEN;
|
|
import static android.view.WindowManager.TRANSIT_TO_BACK;
|
|
import static android.view.WindowManager.TRANSIT_TO_FRONT;
|
|
|
|
import android.annotation.NonNull;
|
|
import android.annotation.Nullable;
|
|
import android.app.ActivityManager;
|
|
import android.graphics.Rect;
|
|
import android.os.IBinder;
|
|
import android.util.ArrayMap;
|
|
import android.util.Slog;
|
|
import android.view.SurfaceControl;
|
|
import android.view.WindowManager;
|
|
import android.window.TransitionInfo;
|
|
import android.window.TransitionRequestInfo;
|
|
import android.window.WindowContainerTransaction;
|
|
|
|
import androidx.annotation.VisibleForTesting;
|
|
|
|
import com.android.wm.shell.shared.TransitionUtil;
|
|
import com.android.wm.shell.transition.Transitions;
|
|
|
|
import java.util.ArrayList;
|
|
import java.util.Objects;
|
|
|
|
/**
|
|
* Handles Shell Transitions that involve TaskView tasks.
|
|
*/
|
|
public class TaskViewTransitions implements Transitions.TransitionHandler {
|
|
static final String TAG = "TaskViewTransitions";
|
|
|
|
private final ArrayMap<TaskViewTaskController, TaskViewRequestedState> mTaskViews =
|
|
new ArrayMap<>();
|
|
private final ArrayList<PendingTransition> mPending = new ArrayList<>();
|
|
private final Transitions mTransitions;
|
|
private final boolean[] mRegistered = new boolean[]{false};
|
|
|
|
/**
|
|
* TaskView makes heavy use of startTransition. Only one shell-initiated transition can be
|
|
* in-flight (collecting) at a time (because otherwise, the operations could get merged into
|
|
* a single transition). So, keep a queue here until we add a queue in server-side.
|
|
*/
|
|
@VisibleForTesting
|
|
static class PendingTransition {
|
|
final @WindowManager.TransitionType int mType;
|
|
final WindowContainerTransaction mWct;
|
|
final @NonNull TaskViewTaskController mTaskView;
|
|
IBinder mClaimed;
|
|
|
|
/**
|
|
* This is needed because arbitrary activity launches can still "intrude" into any
|
|
* transition since `startActivity` is a synchronous call. Once that is solved, we can
|
|
* remove this.
|
|
*/
|
|
final IBinder mLaunchCookie;
|
|
|
|
PendingTransition(@WindowManager.TransitionType int type,
|
|
@Nullable WindowContainerTransaction wct,
|
|
@NonNull TaskViewTaskController taskView,
|
|
@Nullable IBinder launchCookie) {
|
|
mType = type;
|
|
mWct = wct;
|
|
mTaskView = taskView;
|
|
mLaunchCookie = launchCookie;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Visibility and bounds state that has been requested for a {@link TaskViewTaskController}.
|
|
*/
|
|
private static class TaskViewRequestedState {
|
|
boolean mVisible;
|
|
Rect mBounds = new Rect();
|
|
}
|
|
|
|
public TaskViewTransitions(Transitions transitions) {
|
|
mTransitions = transitions;
|
|
// Defer registration until the first TaskView because we want this to be the "first" in
|
|
// priority when handling requests.
|
|
// TODO(210041388): register here once we have an explicit ordering mechanism.
|
|
}
|
|
|
|
void addTaskView(TaskViewTaskController tv) {
|
|
synchronized (mRegistered) {
|
|
if (!mRegistered[0]) {
|
|
mRegistered[0] = true;
|
|
mTransitions.addHandler(this);
|
|
}
|
|
}
|
|
mTaskViews.put(tv, new TaskViewRequestedState());
|
|
}
|
|
|
|
void removeTaskView(TaskViewTaskController tv) {
|
|
mTaskViews.remove(tv);
|
|
// Note: Don't unregister handler since this is a singleton with lifetime bound to Shell
|
|
}
|
|
|
|
boolean isEnabled() {
|
|
return mTransitions.isRegistered();
|
|
}
|
|
|
|
/**
|
|
* Looks through the pending transitions for a closing transaction that matches the provided
|
|
* `taskView`.
|
|
*
|
|
* @param taskView the pending transition should be for this.
|
|
*/
|
|
private PendingTransition findPendingCloseTransition(TaskViewTaskController taskView) {
|
|
for (int i = mPending.size() - 1; i >= 0; --i) {
|
|
if (mPending.get(i).mTaskView != taskView) continue;
|
|
if (TransitionUtil.isClosingType(mPending.get(i).mType)) {
|
|
return mPending.get(i);
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
/**
|
|
* Starts a transition outside of the handler associated with {@link TaskViewTransitions}.
|
|
*/
|
|
public void startInstantTransition(@WindowManager.TransitionType int type,
|
|
WindowContainerTransaction wct) {
|
|
mTransitions.startTransition(type, wct, null);
|
|
}
|
|
|
|
/**
|
|
* Looks through the pending transitions for a opening transaction that matches the provided
|
|
* `taskView`.
|
|
*
|
|
* @param taskView the pending transition should be for this.
|
|
*/
|
|
@VisibleForTesting
|
|
PendingTransition findPendingOpeningTransition(TaskViewTaskController taskView) {
|
|
for (int i = mPending.size() - 1; i >= 0; --i) {
|
|
if (mPending.get(i).mTaskView != taskView) continue;
|
|
if (TransitionUtil.isOpeningType(mPending.get(i).mType)) {
|
|
return mPending.get(i);
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
/**
|
|
* Looks through the pending transitions for one matching `taskView`.
|
|
*
|
|
* @param taskView the pending transition should be for this.
|
|
* @param type the type of transition it's looking for
|
|
*/
|
|
PendingTransition findPending(TaskViewTaskController taskView, int type) {
|
|
for (int i = mPending.size() - 1; i >= 0; --i) {
|
|
if (mPending.get(i).mTaskView != taskView) continue;
|
|
if (mPending.get(i).mType == type) {
|
|
return mPending.get(i);
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
private PendingTransition findPending(IBinder claimed) {
|
|
for (int i = 0; i < mPending.size(); ++i) {
|
|
if (mPending.get(i).mClaimed != claimed) continue;
|
|
return mPending.get(i);
|
|
}
|
|
return null;
|
|
}
|
|
|
|
/** @return whether there are pending transitions on TaskViews. */
|
|
public boolean hasPending() {
|
|
return !mPending.isEmpty();
|
|
}
|
|
|
|
@Override
|
|
public WindowContainerTransaction handleRequest(@NonNull IBinder transition,
|
|
@Nullable TransitionRequestInfo request) {
|
|
final ActivityManager.RunningTaskInfo triggerTask = request.getTriggerTask();
|
|
if (triggerTask == null) {
|
|
return null;
|
|
}
|
|
final TaskViewTaskController taskView = findTaskView(triggerTask);
|
|
if (taskView == null) return null;
|
|
// Opening types should all be initiated by shell
|
|
if (!TransitionUtil.isClosingType(request.getType())) return null;
|
|
PendingTransition pending = new PendingTransition(request.getType(), null,
|
|
taskView, null /* cookie */);
|
|
pending.mClaimed = transition;
|
|
mPending.add(pending);
|
|
return new WindowContainerTransaction();
|
|
}
|
|
|
|
private TaskViewTaskController findTaskView(ActivityManager.RunningTaskInfo taskInfo) {
|
|
for (int i = 0; i < mTaskViews.size(); ++i) {
|
|
if (mTaskViews.keyAt(i).getTaskInfo() == null) continue;
|
|
if (taskInfo.token.equals(mTaskViews.keyAt(i).getTaskInfo().token)) {
|
|
return mTaskViews.keyAt(i);
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
void startTaskView(@NonNull WindowContainerTransaction wct,
|
|
@NonNull TaskViewTaskController taskView, @NonNull IBinder launchCookie) {
|
|
updateVisibilityState(taskView, true /* visible */);
|
|
mPending.add(new PendingTransition(TRANSIT_OPEN, wct, taskView, launchCookie));
|
|
startNextTransition();
|
|
}
|
|
|
|
void closeTaskView(@NonNull WindowContainerTransaction wct,
|
|
@NonNull TaskViewTaskController taskView) {
|
|
updateVisibilityState(taskView, false /* visible */);
|
|
mPending.add(new PendingTransition(TRANSIT_CLOSE, wct, taskView, null /* cookie */));
|
|
startNextTransition();
|
|
}
|
|
|
|
/** Starts a new transition to make the given {@code taskView} visible. */
|
|
public void setTaskViewVisible(TaskViewTaskController taskView, boolean visible) {
|
|
setTaskViewVisible(taskView, visible, false /* reorder */);
|
|
}
|
|
|
|
/**
|
|
* Starts a new transition to make the given {@code taskView} visible and optionally change
|
|
* the task order.
|
|
*
|
|
* @param taskView the task view which the visibility is being changed for
|
|
* @param visible the new visibility of the task view
|
|
* @param reorder whether to reorder the task or not. If this is {@code true}, the task will be
|
|
* reordered as per the given {@code visible}. For {@code visible = true}, task
|
|
* will be reordered to top. For {@code visible = false}, task will be reordered
|
|
* to the bottom
|
|
*/
|
|
public void setTaskViewVisible(TaskViewTaskController taskView, boolean visible,
|
|
boolean reorder) {
|
|
if (mTaskViews.get(taskView) == null) return;
|
|
if (mTaskViews.get(taskView).mVisible == visible) return;
|
|
if (taskView.getTaskInfo() == null) {
|
|
// Nothing to update, task is not yet available
|
|
return;
|
|
}
|
|
mTaskViews.get(taskView).mVisible = visible;
|
|
final WindowContainerTransaction wct = new WindowContainerTransaction();
|
|
wct.setHidden(taskView.getTaskInfo().token, !visible /* hidden */);
|
|
wct.setBounds(taskView.getTaskInfo().token, mTaskViews.get(taskView).mBounds);
|
|
if (reorder) {
|
|
wct.reorder(taskView.getTaskInfo().token, visible /* onTop */);
|
|
}
|
|
PendingTransition pending = new PendingTransition(
|
|
visible ? TRANSIT_TO_FRONT : TRANSIT_TO_BACK, wct, taskView, null /* cookie */);
|
|
mPending.add(pending);
|
|
startNextTransition();
|
|
// visibility is reported in transition.
|
|
}
|
|
|
|
/** Starts a new transition to reorder the given {@code taskView}'s task. */
|
|
public void reorderTaskViewTask(TaskViewTaskController taskView, boolean onTop) {
|
|
if (mTaskViews.get(taskView) == null) return;
|
|
if (taskView.getTaskInfo() == null) {
|
|
// Nothing to update, task is not yet available
|
|
return;
|
|
}
|
|
final WindowContainerTransaction wct = new WindowContainerTransaction();
|
|
wct.reorder(taskView.getTaskInfo().token, onTop /* onTop */);
|
|
PendingTransition pending = new PendingTransition(
|
|
onTop ? TRANSIT_TO_FRONT : TRANSIT_TO_BACK, wct, taskView, null /* cookie */);
|
|
mPending.add(pending);
|
|
startNextTransition();
|
|
// visibility is reported in transition.
|
|
}
|
|
|
|
void updateBoundsState(TaskViewTaskController taskView, Rect boundsOnScreen) {
|
|
TaskViewRequestedState state = mTaskViews.get(taskView);
|
|
if (state == null) return;
|
|
state.mBounds.set(boundsOnScreen);
|
|
}
|
|
|
|
void updateVisibilityState(TaskViewTaskController taskView, boolean visible) {
|
|
TaskViewRequestedState state = mTaskViews.get(taskView);
|
|
if (state == null) return;
|
|
state.mVisible = visible;
|
|
}
|
|
|
|
void setTaskBounds(TaskViewTaskController taskView, Rect boundsOnScreen) {
|
|
TaskViewRequestedState state = mTaskViews.get(taskView);
|
|
if (state == null || Objects.equals(boundsOnScreen, state.mBounds)) {
|
|
return;
|
|
}
|
|
state.mBounds.set(boundsOnScreen);
|
|
if (!state.mVisible) {
|
|
// Task view isn't visible, the bounds will next visibility update.
|
|
return;
|
|
}
|
|
if (hasPending()) {
|
|
// There is already a transition in-flight, the window bounds will be set in
|
|
// prepareOpenAnimation.
|
|
return;
|
|
}
|
|
WindowContainerTransaction wct = new WindowContainerTransaction();
|
|
wct.setBounds(taskView.getTaskInfo().token, boundsOnScreen);
|
|
mPending.add(new PendingTransition(TRANSIT_CHANGE, wct, taskView, null /* cookie */));
|
|
startNextTransition();
|
|
}
|
|
|
|
private void startNextTransition() {
|
|
if (mPending.isEmpty()) return;
|
|
final PendingTransition pending = mPending.get(0);
|
|
if (pending.mClaimed != null) {
|
|
// Wait for this to start animating.
|
|
return;
|
|
}
|
|
pending.mClaimed = mTransitions.startTransition(pending.mType, pending.mWct, this);
|
|
}
|
|
|
|
@Override
|
|
public void onTransitionConsumed(@NonNull IBinder transition, boolean aborted,
|
|
@NonNull SurfaceControl.Transaction finishTransaction) {
|
|
if (!aborted) return;
|
|
final PendingTransition pending = findPending(transition);
|
|
if (pending == null) return;
|
|
mPending.remove(pending);
|
|
startNextTransition();
|
|
}
|
|
|
|
@Override
|
|
public boolean startAnimation(@NonNull IBinder transition,
|
|
@NonNull TransitionInfo info,
|
|
@NonNull SurfaceControl.Transaction startTransaction,
|
|
@NonNull SurfaceControl.Transaction finishTransaction,
|
|
@NonNull Transitions.TransitionFinishCallback finishCallback) {
|
|
PendingTransition pending = findPending(transition);
|
|
if (pending != null) {
|
|
mPending.remove(pending);
|
|
}
|
|
if (mTaskViews.isEmpty()) {
|
|
if (pending != null) {
|
|
Slog.e(TAG, "Pending taskview transition but no task-views");
|
|
}
|
|
return false;
|
|
}
|
|
boolean stillNeedsMatchingLaunch = pending != null && pending.mLaunchCookie != null;
|
|
int changesHandled = 0;
|
|
WindowContainerTransaction wct = null;
|
|
for (int i = 0; i < info.getChanges().size(); ++i) {
|
|
final TransitionInfo.Change chg = info.getChanges().get(i);
|
|
if (chg.getTaskInfo() == null) continue;
|
|
if (TransitionUtil.isClosingType(chg.getMode())) {
|
|
final boolean isHide = chg.getMode() == TRANSIT_TO_BACK;
|
|
TaskViewTaskController tv = findTaskView(chg.getTaskInfo());
|
|
if (tv == null && !isHide) {
|
|
// TaskView can be null when closing
|
|
changesHandled++;
|
|
continue;
|
|
}
|
|
if (tv == null) {
|
|
if (pending != null) {
|
|
Slog.w(TAG, "Found a non-TaskView task in a TaskView Transition. This "
|
|
+ "shouldn't happen, so there may be a visual artifact: "
|
|
+ chg.getTaskInfo().taskId);
|
|
}
|
|
continue;
|
|
}
|
|
if (isHide) {
|
|
if (pending != null && pending.mType == TRANSIT_TO_BACK) {
|
|
// TO_BACK is only used when setting the task view visibility immediately,
|
|
// so in that case we can also hide the surface immediately
|
|
startTransaction.hide(chg.getLeash());
|
|
}
|
|
tv.prepareHideAnimation(finishTransaction);
|
|
} else {
|
|
tv.prepareCloseAnimation();
|
|
}
|
|
changesHandled++;
|
|
} else if (TransitionUtil.isOpeningType(chg.getMode())) {
|
|
final boolean taskIsNew = chg.getMode() == TRANSIT_OPEN;
|
|
final TaskViewTaskController tv;
|
|
if (taskIsNew) {
|
|
if (pending == null
|
|
|| !chg.getTaskInfo().containsLaunchCookie(pending.mLaunchCookie)) {
|
|
Slog.e(TAG, "Found a launching TaskView in the wrong transition. All "
|
|
+ "TaskView launches should be initiated by shell and in their "
|
|
+ "own transition: " + chg.getTaskInfo().taskId);
|
|
continue;
|
|
}
|
|
stillNeedsMatchingLaunch = false;
|
|
tv = pending.mTaskView;
|
|
} else {
|
|
tv = findTaskView(chg.getTaskInfo());
|
|
if (tv == null) {
|
|
if (pending != null) {
|
|
Slog.w(TAG, "Found a non-TaskView task in a TaskView Transition. This "
|
|
+ "shouldn't happen, so there may be a visual artifact: "
|
|
+ chg.getTaskInfo().taskId);
|
|
}
|
|
continue;
|
|
}
|
|
}
|
|
if (wct == null) wct = new WindowContainerTransaction();
|
|
tv.prepareOpenAnimation(taskIsNew, startTransaction, finishTransaction,
|
|
chg.getTaskInfo(), chg.getLeash(), wct);
|
|
changesHandled++;
|
|
} else if (chg.getMode() == TRANSIT_CHANGE) {
|
|
TaskViewTaskController tv = findTaskView(chg.getTaskInfo());
|
|
if (tv == null) {
|
|
if (pending != null) {
|
|
Slog.w(TAG, "Found a non-TaskView task in a TaskView Transition. This "
|
|
+ "shouldn't happen, so there may be a visual artifact: "
|
|
+ chg.getTaskInfo().taskId);
|
|
}
|
|
continue;
|
|
}
|
|
startTransaction.reparent(chg.getLeash(), tv.getSurfaceControl());
|
|
finishTransaction.reparent(chg.getLeash(), tv.getSurfaceControl())
|
|
.setPosition(chg.getLeash(), 0, 0);
|
|
changesHandled++;
|
|
}
|
|
}
|
|
if (stillNeedsMatchingLaunch) {
|
|
Slog.w(TAG, "Expected a TaskView launch in this transition but didn't get one, "
|
|
+ "cleaning up the task view");
|
|
// Didn't find a task so the task must have never launched
|
|
pending.mTaskView.setTaskNotFound();
|
|
} else if (wct == null && pending == null && changesHandled != info.getChanges().size()) {
|
|
// Just some house-keeping, let another handler animate.
|
|
return false;
|
|
}
|
|
// No animation, just show it immediately.
|
|
startTransaction.apply();
|
|
finishCallback.onTransitionFinished(wct);
|
|
startNextTransition();
|
|
return true;
|
|
}
|
|
}
|