Files
Flexera-Launcher/quickstep/src/com/android/quickstep/RemoteTargetGluer.java
T
Jerry Chang 85224ebd08 Consolidate recent animation in split screen with shell-transition
Also exclude corresponding parent task when wrapping up remote animation
target for recents animation.

Bug: 206487881
Test: manual check recent animation after split screen activated
Change-Id: I2e80eca1124d9a9e360513334211bde8a52575ea
2022-01-13 08:00:00 +00:00

217 lines
9.1 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.quickstep;
import android.content.Context;
import androidx.annotation.Nullable;
import com.android.launcher3.util.SplitConfigurationOptions.StagedSplitBounds;
import com.android.quickstep.util.AnimatorControllerWithResistance;
import com.android.quickstep.util.LauncherSplitScreenListener;
import com.android.quickstep.util.TaskViewSimulator;
import com.android.quickstep.util.TransformParams;
import com.android.systemui.shared.system.RemoteAnimationTargetCompat;
import java.util.ArrayList;
/**
* Glues together the necessary components to animate a remote target using a
* {@link TaskViewSimulator}
*/
public class RemoteTargetGluer {
private RemoteTargetHandle[] mRemoteTargetHandles;
private StagedSplitBounds mStagedSplitBounds;
/**
* Use this constructor if remote targets are split-screen independent
*/
public RemoteTargetGluer(Context context, BaseActivityInterface sizingStrategy,
RemoteAnimationTargets targets) {
mRemoteTargetHandles = createHandles(context, sizingStrategy, targets.apps.length);
}
/**
* Use this constructor if you want the number of handles created to match the number of active
* running tasks
*/
public RemoteTargetGluer(Context context, BaseActivityInterface sizingStrategy) {
int[] splitIds = LauncherSplitScreenListener.INSTANCE.getNoCreate()
.getRunningSplitTaskIds();
mRemoteTargetHandles = createHandles(context, sizingStrategy, splitIds.length == 2 ? 2 : 1);
}
private RemoteTargetHandle[] createHandles(Context context,
BaseActivityInterface sizingStrategy, int numHandles) {
RemoteTargetHandle[] handles = new RemoteTargetHandle[numHandles];
for (int i = 0; i < numHandles; i++) {
TaskViewSimulator tvs = new TaskViewSimulator(context, sizingStrategy);
TransformParams transformParams = new TransformParams();
handles[i] = new RemoteTargetHandle(tvs, transformParams);
}
return handles;
}
/**
* Pairs together {@link TaskViewSimulator}s and {@link TransformParams} into a
* {@link RemoteTargetHandle}
* Assigns only the apps associated with {@param targets} into their own TaskViewSimulators.
* Length of targets.apps should match that of {@link #mRemoteTargetHandles}.
*
* If split screen may be active when this is called, you might want to use
* {@link #assignTargetsForSplitScreen(RemoteAnimationTargets)}
*/
public RemoteTargetHandle[] assignTargets(RemoteAnimationTargets targets) {
for (int i = 0; i < mRemoteTargetHandles.length; i++) {
RemoteAnimationTargetCompat primaryTaskTarget = targets.apps[i];
mRemoteTargetHandles[i].mTransformParams.setTargetSet(
createRemoteAnimationTargetsForTarget(targets, null));
mRemoteTargetHandles[i].mTaskViewSimulator.setPreview(primaryTaskTarget, null);
}
return mRemoteTargetHandles;
}
/**
* Similar to {@link #assignTargets(RemoteAnimationTargets)}, except this matches the
* apps in targets.apps to that of the _active_ split screened tasks.
* See {@link #assignTargetsForSplitScreen(RemoteAnimationTargets, int[])}
*/
public RemoteTargetHandle[] assignTargetsForSplitScreen(RemoteAnimationTargets targets) {
int[] splitIds = LauncherSplitScreenListener.INSTANCE.getNoCreate()
.getRunningSplitTaskIds();
return assignTargetsForSplitScreen(targets, splitIds);
}
/**
* Assigns the provided splitIDs to the {@link #mRemoteTargetHandles}, with index 0 will being
* the left/top task, index 1 right/bottom
*/
public RemoteTargetHandle[] assignTargetsForSplitScreen(RemoteAnimationTargets targets,
int[] splitIds) {
RemoteAnimationTargetCompat topLeftTarget; // only one set if single/fullscreen task
RemoteAnimationTargetCompat bottomRightTarget;
if (mRemoteTargetHandles.length == 1) {
// If we're not in split screen, the splitIds count doesn't really matter since we
// should always hit this case.
mRemoteTargetHandles[0].mTransformParams.setTargetSet(targets);
if (targets.apps.length > 0) {
// Unclear why/when target.apps length == 0, but it sure does happen :(
topLeftTarget = targets.apps[0];
mRemoteTargetHandles[0].mTaskViewSimulator.setPreview(topLeftTarget, null);
}
} else {
// split screen
topLeftTarget = targets.findTask(splitIds[0]);
bottomRightTarget = targets.findTask(splitIds[1]);
// remoteTargetHandle[0] denotes topLeft task, so we pass in the bottomRight to exclude,
// vice versa
mStagedSplitBounds = new StagedSplitBounds(
topLeftTarget.startScreenSpaceBounds,
bottomRightTarget.startScreenSpaceBounds, splitIds[0], splitIds[1]);
mRemoteTargetHandles[0].mTransformParams.setTargetSet(
createRemoteAnimationTargetsForTarget(targets, bottomRightTarget));
mRemoteTargetHandles[0].mTaskViewSimulator.setPreview(topLeftTarget,
mStagedSplitBounds);
mRemoteTargetHandles[1].mTransformParams.setTargetSet(
createRemoteAnimationTargetsForTarget(targets, topLeftTarget));
mRemoteTargetHandles[1].mTaskViewSimulator.setPreview(bottomRightTarget,
mStagedSplitBounds);
}
return mRemoteTargetHandles;
}
/**
* Ensures that we aren't excluding ancillary targets such as home/recents
*
* @param targetToExclude Will be excluded from the resulting return value.
* Pass in {@code null} to not exclude anything
* @return RemoteAnimationTargets where all the app targets from the passed in
* {@param targets} are included except {@param targetToExclude}
*/
private RemoteAnimationTargets createRemoteAnimationTargetsForTarget(
RemoteAnimationTargets targets,
RemoteAnimationTargetCompat targetToExclude) {
ArrayList<RemoteAnimationTargetCompat> targetsWithoutExcluded =
new ArrayList<RemoteAnimationTargetCompat>();
for (RemoteAnimationTargetCompat targetCompat : targets.unfilteredApps) {
if (targetCompat == targetToExclude) {
continue;
}
if (targetToExclude != null
&& targetToExclude.taskInfo != null
&& targetCompat.taskInfo != null
&& targetToExclude.taskInfo.parentTaskId == targetCompat.taskInfo.taskId) {
// Also exclude corresponding parent task
continue;
}
targetsWithoutExcluded.add(targetCompat);
}
final RemoteAnimationTargetCompat[] filteredApps =
targetsWithoutExcluded.toArray(
new RemoteAnimationTargetCompat[targetsWithoutExcluded.size()]);
return new RemoteAnimationTargets(
filteredApps, targets.wallpapers, targets.nonApps, targets.targetMode);
}
public RemoteTargetHandle[] getRemoteTargetHandles() {
return mRemoteTargetHandles;
}
public StagedSplitBounds getStagedSplitBounds() {
return mStagedSplitBounds;
}
/**
* Container to keep together all the associated objects whose properties need to be updated to
* animate a single remote app target
*/
public static class RemoteTargetHandle {
private final TaskViewSimulator mTaskViewSimulator;
private final TransformParams mTransformParams;
@Nullable
private AnimatorControllerWithResistance mPlaybackController;
public RemoteTargetHandle(TaskViewSimulator taskViewSimulator,
TransformParams transformParams) {
mTransformParams = transformParams;
mTaskViewSimulator = taskViewSimulator;
}
public TaskViewSimulator getTaskViewSimulator() {
return mTaskViewSimulator;
}
public TransformParams getTransformParams() {
return mTransformParams;
}
@Nullable
public AnimatorControllerWithResistance getPlaybackController() {
return mPlaybackController;
}
public void setPlaybackController(
@Nullable AnimatorControllerWithResistance playbackController) {
mPlaybackController = playbackController;
}
}
}