fixes more error
This commit is contained in:
1 parent
2e4a2330d3
commit
76aa855f1e
1419 files changed
+238037
-44
No files matched your search
@@ -0,0 +1,449 @@
|
||||
/*
|
||||
* 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;
|
||||
}
|
||||
}
|
||||
Reference in new issue
Block a user