Android/frameworks_base
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge "Remove unused recents freeform task code."

Browse Source
This commit is contained in:
TreeHugger Robot
2017-10-13 00:54:04 +00:00
committed by Android (Google) Code Review
parent 7376615ca6 247f1d4187
commit c3c2b28cb7
21 changed files with 79 additions and 948 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
packages/SystemUI/src/com/android/systemui/recents/Recents.java
View File

@@ -191,7 +191,7 @@ public class Recents extends SystemUI
@Override
public void start() {
sDebugFlags = new RecentsDebugFlags(mContext);
sDebugFlags = new RecentsDebugFlags();
sSystemServicesProxy = SystemServicesProxy.getInstance(mContext);
sConfiguration = new RecentsConfiguration(mContext);
sTaskLoader = new RecentsTaskLoader(mContext);

5
packages/SystemUI/src/com/android/systemui/recents/RecentsActivity.java
View File

@@ -79,7 +79,6 @@ import com.android.systemui.recents.events.ui.ShowApplicationInfoEvent;
import com.android.systemui.recents.events.ui.ShowIncompatibleAppOverlayEvent;
import com.android.systemui.recents.events.ui.StackViewScrolledEvent;
import com.android.systemui.recents.events.ui.TaskViewDismissedEvent;
import com.android.systemui.recents.events.ui.UpdateFreeformTaskViewVisibilityEvent;
import com.android.systemui.recents.events.ui.UserInteractionEvent;
import com.android.systemui.recents.events.ui.focus.DismissFocusedTaskViewEvent;
import com.android.systemui.recents.events.ui.focus.FocusNextTaskViewEvent;
@@ -714,15 +713,11 @@ public class RecentsActivity extends Activity implements ViewTreeObserver.OnPreD
}
public final void onBusEvent(EnterRecentsWindowLastAnimationFrameEvent event) {
EventBus.getDefault().send(new UpdateFreeformTaskViewVisibilityEvent(true));
mRecentsView.getViewTreeObserver().addOnPreDrawListener(this);
mRecentsView.invalidate();
}
public final void onBusEvent(ExitRecentsWindowFirstAnimationFrameEvent event) {
if (mRecentsView.isLastTaskLaunchedFreeform()) {
EventBus.getDefault().send(new UpdateFreeformTaskViewVisibilityEvent(false));
}
mRecentsView.getViewTreeObserver().addOnPreDrawListener(this);
mRecentsView.invalidate();
}

18
packages/SystemUI/src/com/android/systemui/recents/RecentsDebugFlags.java
View File

@@ -26,7 +26,7 @@ import com.android.systemui.tuner.TunerService;
/**
* Tunable debug flags
*/
public class RecentsDebugFlags implements TunerService.Tunable {
public class RecentsDebugFlags {
public static class Static {
// Enables debug drawing for the transition thumbnail
@@ -50,21 +50,12 @@ public class RecentsDebugFlags implements TunerService.Tunable {
public static final int MockTaskCount = 100;
}
/**
* We read the prefs once when we start the activity, then update them as the tuner changes
* the flags.
*/
public RecentsDebugFlags(Context context) {
// Register all our flags, this will also call onTuningChanged() for each key, which will
// initialize the current state of each flag
}
/**
* @return whether we are enabling fast toggling.
*/
public boolean isFastToggleRecentsEnabled() {
SystemServicesProxy ssp = Recents.getSystemServices();
if (ssp.hasFreeformWorkspaceSupport() || ssp.isTouchExplorationEnabled()) {
if (ssp.isTouchExplorationEnabled()) {
return false;
}
return Static.EnableFastToggleTimeout;
@@ -76,9 +67,4 @@ public class RecentsDebugFlags implements TunerService.Tunable {
public boolean isPagingEnabled() {
return Static.EnablePaging;
}
@Override
public void onTuningChanged(String key, String newValue) {
EventBus.getDefault().send(new DebugFlagsChangedEvent());
}
}

77
packages/SystemUI/src/com/android/systemui/recents/RecentsImpl.java
View File

@@ -746,8 +746,7 @@ public class RecentsImpl implements ActivityOptions.OnAnimationFinishedListener
stackLayout.getTaskStackBounds(displayRect, windowRect, systemInsets.top,
systemInsets.left, systemInsets.right, mTmpBounds);
stackLayout.reset();
stackLayout.initialize(displayRect, windowRect, mTmpBounds,
TaskStackLayoutAlgorithm.StackState.getStackStateForStack(stack));
stackLayout.initialize(displayRect, windowRect, mTmpBounds);
}
}
@@ -866,61 +865,29 @@ public class RecentsImpl implements ActivityOptions.OnAnimationFinishedListener
getThumbnailTransitionActivityOptions(ActivityManager.RunningTaskInfo runningTask,
Rect windowOverrideRect) {
final boolean isLowRamDevice = Recents.getConfiguration().isLowRamDevice;
if (runningTask != null
&& runningTask.configuration.windowConfiguration.getWindowingMode()
== WINDOWING_MODE_FREEFORM) {
ArrayList<AppTransitionAnimationSpec> specs = new ArrayList<>();
ArrayList<Task> tasks = mDummyStackView.getStack().getStackTasks();
TaskStackLayoutAlgorithm stackLayout = mDummyStackView.getStackAlgorithm();
TaskStackViewScroller stackScroller = mDummyStackView.getScroller();
mDummyStackView.updateLayoutAlgorithm(true /* boundScroll */);
mDummyStackView.updateToInitialState();
// Update the destination rect
Task toTask = new Task();
TaskViewTransform toTransform = getThumbnailTransitionTransform(mDummyStackView, toTask,
windowOverrideRect);
for (int i = tasks.size() - 1; i >= 0; i--) {
Task task = tasks.get(i);
if (task.isFreeformTask()) {
mTmpTransform = stackLayout.getStackTransformScreenCoordinates(task,
stackScroller.getStackScroll(), mTmpTransform, null,
windowOverrideRect);
GraphicBuffer thumbnail = drawThumbnailTransitionBitmap(task, mTmpTransform);
Rect toTaskRect = new Rect();
mTmpTransform.rect.round(toTaskRect);
specs.add(new AppTransitionAnimationSpec(task.key.id, thumbnail, toTaskRect));
}
}
AppTransitionAnimationSpec[] specsArray = new AppTransitionAnimationSpec[specs.size()];
specs.toArray(specsArray);
RectF toTaskRect = toTransform.rect;
AppTransitionAnimationSpecsFuture future =
new RecentsTransitionHelper(mContext).getAppTransitionFuture(
() -> {
Rect rect = new Rect();
toTaskRect.round(rect);
GraphicBuffer thumbnail = drawThumbnailTransitionBitmap(toTask,
toTransform);
return Lists.newArrayList(new AppTransitionAnimationSpec(
toTask.key.id, thumbnail, rect));
});
// For low end ram devices, wait for transition flag is reset when Recents entrance
// animation is complete instead of when the transition animation starts
return new Pair<>(ActivityOptions.makeThumbnailAspectScaleDownAnimation(mDummyStackView,
specsArray, mHandler, isLowRamDevice ? null : mResetToggleFlagListener, this),
null);
} else {
// Update the destination rect
Task toTask = new Task();
TaskViewTransform toTransform = getThumbnailTransitionTransform(mDummyStackView, toTask,
windowOverrideRect);
RectF toTaskRect = toTransform.rect;
AppTransitionAnimationSpecsFuture future =
new RecentsTransitionHelper(mContext).getAppTransitionFuture(
() -> {
Rect rect = new Rect();
toTaskRect.round(rect);
GraphicBuffer thumbnail = drawThumbnailTransitionBitmap(toTask,
toTransform);
return Lists.newArrayList(new AppTransitionAnimationSpec(
toTask.key.id, thumbnail, rect));
});
// For low end ram devices, wait for transition flag is reset when Recents entrance
// animation is complete instead of when the transition animation starts
return new Pair<>(ActivityOptions.makeMultiThumbFutureAspectScaleAnimation(mContext,
mHandler, future.getFuture(), isLowRamDevice ? null : mResetToggleFlagListener,
false /* scaleUp */), future);
}
// For low end ram devices, wait for transition flag is reset when Recents entrance
// animation is complete instead of when the transition animation starts
return new Pair<>(ActivityOptions.makeMultiThumbFutureAspectScaleAnimation(mContext,
mHandler, future.getFuture(), isLowRamDevice ? null : mResetToggleFlagListener,
false /* scaleUp */), future);
}
/**
@@ -935,7 +902,7 @@ public class RecentsImpl implements ActivityOptions.OnAnimationFinishedListener
runningTaskOut.copyFrom(launchTask);
} else {
// If no task is specified or we can not find the task just use the front most one
launchTask = stack.getStackFrontMostTask(true /* includeFreeform */);
launchTask = stack.getStackFrontMostTask();
runningTaskOut.copyFrom(launchTask);
}

31
packages/SystemUI/src/com/android/systemui/recents/events/ui/UpdateFreeformTaskViewVisibilityEvent.java
View File

@@ -1,31 +0,0 @@
/*
* Copyright (C) 2015 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.systemui.recents.events.ui;
import com.android.systemui.recents.events.EventBus;
/**
* This is sent to update the visibility of all visible freeform task views.
*/
public class UpdateFreeformTaskViewVisibilityEvent extends EventBus.Event {
public final boolean visible;
public UpdateFreeformTaskViewVisibilityEvent(boolean visible) {
this.visible = visible;
}
}

39
packages/SystemUI/src/com/android/systemui/recents/misc/NamedCounter.java
View File

@@ -1,39 +0,0 @@
/*
* Copyright (C) 2014 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.systemui.recents.misc;
/**
* Used to generate successive incremented names.
*/
public class NamedCounter {
int mCount;
String mPrefix = "";
String mSuffix = "";
public NamedCounter(String prefix, String suffix) {
mPrefix = prefix;
mSuffix = suffix;
}
/** Returns the next name. */
public String nextName() {
String name = mPrefix + mCount + mSuffix;
mCount++;
return name;
}
}

14
packages/SystemUI/src/com/android/systemui/recents/misc/SystemServicesProxy.java
View File

@@ -26,7 +26,6 @@ import static android.app.WindowConfiguration.WINDOWING_MODE_PINNED;
import static android.app.WindowConfiguration.WINDOWING_MODE_SPLIT_SCREEN_PRIMARY;
import static android.app.WindowConfiguration.WINDOWING_MODE_SPLIT_SCREEN_SECONDARY;
import static android.app.WindowConfiguration.WINDOWING_MODE_UNDEFINED;
import static android.provider.Settings.Global.DEVELOPMENT_ENABLE_FREEFORM_WINDOWS_SUPPORT;
import android.annotation.NonNull;
import android.annotation.Nullable;
@@ -46,7 +45,6 @@ import android.content.pm.ActivityInfo;
import android.content.pm.ApplicationInfo;
import android.content.pm.IPackageManager;
import android.content.pm.PackageManager;
import android.content.pm.ResolveInfo;
import android.content.res.Resources;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
@@ -143,7 +141,6 @@ public class SystemServicesProxy {
private int mCurrentUserId;
boolean mIsSafeMode;
boolean mHasFreeformWorkspaceSupport;
Bitmap mDummyIcon;
int mDummyThumbnailWidth;
@@ -318,10 +315,6 @@ public class SystemServicesProxy {
ServiceManager.checkService(DreamService.DREAM_SERVICE));
mDisplay = mWm.getDefaultDisplay();
mRecentsPackage = context.getPackageName();
mHasFreeformWorkspaceSupport =
mPm.hasSystemFeature(PackageManager.FEATURE_FREEFORM_WINDOW_MANAGEMENT) ||
Settings.Global.getInt(context.getContentResolver(),
DEVELOPMENT_ENABLE_FREEFORM_WINDOWS_SUPPORT, 0) != 0;
mIsSafeMode = mPm.isSafeMode();
mCurrentUserId = mAm.getCurrentUser();
@@ -529,13 +522,6 @@ public class SystemServicesProxy {
return stackVisibleNotOccluded;
}
/**
* Returns whether this device has freeform workspaces.
*/
public boolean hasFreeformWorkspaceSupport() {
return mHasFreeformWorkspaceSupport;
}
/**
* Returns whether this device is in the safe mode.
*/

3
packages/SystemUI/src/com/android/systemui/recents/model/RecentsTaskLoadPlan.java
View File

@@ -100,7 +100,6 @@ public class RecentsTaskLoadPlan {
*
* The tasks will be ordered by:
* - least-recent to most-recent stack tasks
* - least-recent to most-recent freeform tasks
*
* Note: Do not lock, since this can be calling back to the loader, which separately also drives
* this call (callers should synchronize on the loader before making this call).
@@ -155,7 +154,7 @@ public class RecentsTaskLoadPlan {
Task task = new Task(taskKey, icon,
thumbnail, title, titleDescription, dismissDescription, appInfoDescription,
activityColor, backgroundColor, isLaunchTarget, isStackTask, isSystemApp,
t.supportsSplitScreenMultiWindow, t.bounds, t.taskDescription, t.resizeMode,
t.supportsSplitScreenMultiWindow, t.taskDescription, t.resizeMode,
t.topActivity, isLocked);
allTasks.add(task);

21
packages/SystemUI/src/com/android/systemui/recents/model/Task.java
View File

@@ -144,12 +144,6 @@ public class Task {
@ViewDebug.ExportedProperty(category="recents")
public boolean useLightOnPrimaryColor;
/**
* The bounds of the task, used only if it is a freeform task.
*/
@ViewDebug.ExportedProperty(category="recents")
public Rect bounds;
/**
* The task description for this task, only used to reload task icons.
*/
@@ -188,7 +182,7 @@ public class Task {
public Task(TaskKey key, Drawable icon, ThumbnailData thumbnail, String title,
String titleDescription, String dismissDescription, String appInfoDescription,
int colorPrimary, int colorBackground, boolean isLaunchTarget, boolean isStackTask,
boolean isSystemApp, boolean isDockable, Rect bounds, TaskDescription taskDescription,
boolean isSystemApp, boolean isDockable, TaskDescription taskDescription,
int resizeMode, ComponentName topActivity, boolean isLocked) {
this.key = key;
this.icon = icon;
@@ -201,7 +195,6 @@ public class Task {
this.colorBackground = colorBackground;
this.useLightOnPrimaryColor = Utilities.computeContrastBetweenColors(this.colorPrimary,
Color.WHITE) > 3f;
this.bounds = bounds;
this.taskDescription = taskDescription;
this.isLaunchTarget = isLaunchTarget;
this.isStackTask = isStackTask;
@@ -226,7 +219,6 @@ public class Task {
this.colorPrimary = o.colorPrimary;
this.colorBackground = o.colorBackground;
this.useLightOnPrimaryColor = o.useLightOnPrimaryColor;
this.bounds = o.bounds;
this.taskDescription = o.taskDescription;
this.isLaunchTarget = o.isLaunchTarget;
this.isStackTask = o.isStackTask;
@@ -262,14 +254,6 @@ public class Task {
}
}
/**
* Returns whether this task is on the freeform task stack.
*/
public boolean isFreeformTask() {
SystemServicesProxy ssp = Recents.getSystemServices();
return ssp.hasFreeformWorkspaceSupport() && key.windowingMode == WINDOWING_MODE_FREEFORM;
}
/** Notifies the callback listeners that this task has been loaded */
public void notifyTaskDataLoaded(ThumbnailData thumbnailData, Drawable applicationIcon) {
this.icon = applicationIcon;
@@ -318,9 +302,6 @@ public class Task {
if (isLaunchTarget) {
writer.print(" launchTarget=Y");
}
if (isFreeformTask()) {
writer.print(" freeform=Y");
}
if (isLocked) {
writer.print(" locked=Y");
}

117
packages/SystemUI/src/com/android/systemui/recents/model/TaskStack.java
View File

@@ -18,8 +18,6 @@ package com.android.systemui.recents.model;
import static android.app.ActivityManager.DOCKED_STACK_CREATE_MODE_BOTTOM_OR_RIGHT;
import static android.app.ActivityManager.DOCKED_STACK_CREATE_MODE_TOP_OR_LEFT;
import static android.app.WindowConfiguration.WINDOWING_MODE_FREEFORM;
import static android.app.WindowConfiguration.WINDOWING_MODE_FULLSCREEN;
import static android.view.WindowManager.DOCKED_BOTTOM;
import static android.view.WindowManager.DOCKED_INVALID;
import static android.view.WindowManager.DOCKED_LEFT;
@@ -62,8 +60,6 @@ import java.io.PrintWriter;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
@@ -109,25 +105,6 @@ class FilteredTaskList {
updateFilteredTasks();
}
/**
* Moves the given task.
*/
public void setTaskWindowingMode(Task task, int insertIndex, int windowingMode) {
int taskIndex = indexOf(task);
if (taskIndex != insertIndex) {
mTasks.remove(taskIndex);
if (taskIndex < insertIndex) {
insertIndex--;
}
mTasks.add(insertIndex, task);
}
// Update the stack id now, after we've moved the task, and before we update the
// filtered tasks
task.setWindowingMode(windowingMode);
updateFilteredTasks();
}
/** Sets the list of tasks */
void set(List<Task> tasks) {
mTasks.clear();
@@ -533,19 +510,6 @@ public class TaskStack {
}
}
// A comparator that sorts tasks by their freeform state
private Comparator<Task> FREEFORM_COMPARATOR = new Comparator<Task>() {
@Override
public int compare(Task o1, Task o2) {
if (o1.isFreeformTask() && !o2.isFreeformTask()) {
return 1;
} else if (o2.isFreeformTask() && !o1.isFreeformTask()) {
return -1;
}
return Long.compare(o1.temporarySortIndexInStack, o2.temporarySortIndexInStack);
}
};
ArrayList<Task> mRawTaskList = new ArrayList<>();
FilteredTaskList mStackTaskList = new FilteredTaskList();
TaskStackCallbacks mCb;
@@ -565,27 +529,6 @@ public class TaskStack {
mCb = cb;
}
/** Sets the windowing mode for a given task. */
public void setTaskWindowingMode(Task task, int windowingMode) {
// Find the index to insert into
ArrayList<Task> taskList = mStackTaskList.getTasks();
int taskCount = taskList.size();
if (!task.isFreeformTask() && (windowingMode == WINDOWING_MODE_FREEFORM)) {
// Insert freeform tasks at the front
mStackTaskList.setTaskWindowingMode(task, taskCount, windowingMode);
} else if (task.isFreeformTask() && (windowingMode == WINDOWING_MODE_FULLSCREEN)) {
// Insert after the first stacked task
int insertIndex = 0;
for (int i = taskCount - 1; i >= 0; i--) {
if (!taskList.get(i).isFreeformTask()) {
insertIndex = i + 1;
break;
}
}
mStackTaskList.setTaskWindowingMode(task, insertIndex, windowingMode);
}
}
/**
* Removes a task from the stack, with an additional {@param animation} hint to the callbacks on
* how they should update themselves.
@@ -602,7 +545,7 @@ public class TaskStack {
boolean dismissRecentsIfAllRemoved) {
if (mStackTaskList.contains(t)) {
mStackTaskList.remove(t);
Task newFrontMostTask = getStackFrontMostTask(false /* includeFreeform */);
Task newFrontMostTask = getStackFrontMostTask();
if (mCb != null) {
// Notify that a task has been removed
mCb.onStackTaskRemoved(this, t, newFrontMostTask, animation,
@@ -686,14 +629,13 @@ public class TaskStack {
for (int i = allTasks.size() - 1; i >= 0; i--) {
allTasks.get(i).temporarySortIndexInStack = i;
}
Collections.sort(allTasks, FREEFORM_COMPARATOR);
mStackTaskList.set(allTasks);
mRawTaskList = allTasks;
// Only callback for the removed tasks after the stack has updated
int removedTaskCount = removedTasks.size();
Task newFrontMostTask = getStackFrontMostTask(false);
Task newFrontMostTask = getStackFrontMostTask();
for (int i = 0; i < removedTaskCount; i++) {
mCb.onStackTaskRemoved(this, removedTasks.get(i), newFrontMostTask,
AnimationProps.IMMEDIATE, false /* fromDockGesture */,
@@ -715,18 +657,12 @@ public class TaskStack {
/**
* Gets the front-most task in the stack.
*/
public Task getStackFrontMostTask(boolean includeFreeformTasks) {
public Task getStackFrontMostTask() {
ArrayList<Task> stackTasks = mStackTaskList.getTasks();
if (stackTasks.isEmpty()) {
return null;
}
for (int i = stackTasks.size() - 1; i >= 0; i--) {
Task task = stackTasks.get(i);
if (!task.isFreeformTask() || includeFreeformTasks) {
return task;
}
}
return null;
return stackTasks.get(stackTasks.size() - 1);
}
/** Gets the task keys */
@@ -748,22 +684,6 @@ public class TaskStack {
return mStackTaskList.getTasks();
}
/**
* Returns the set of "freeform" tasks in the stack.
*/
public ArrayList<Task> getFreeformTasks() {
ArrayList<Task> freeformTasks = new ArrayList<>();
ArrayList<Task> tasks = mStackTaskList.getTasks();
int taskCount = tasks.size();
for (int i = 0; i < taskCount; i++) {
Task task = tasks.get(i);
if (task.isFreeformTask()) {
freeformTasks.add(task);
}
}
return freeformTasks;
}
/**
* Computes a set of all the active and historical tasks.
*/
@@ -774,7 +694,7 @@ public class TaskStack {
}
/**
* Returns the number of stack and freeform tasks.
* Returns the number of stacktasks.
*/
public int getTaskCount() {
return mStackTaskList.size();
@@ -784,32 +704,7 @@ public class TaskStack {
* Returns the number of stack tasks.
*/
public int getStackTaskCount() {
ArrayList<Task> tasks = mStackTaskList.getTasks();
int stackCount = 0;
int taskCount = tasks.size();
for (int i = 0; i < taskCount; i++) {
Task task = tasks.get(i);
if (!task.isFreeformTask()) {
stackCount++;
}
}
return stackCount;
}
/**
* Returns the number of freeform tasks.
*/
public int getFreeformTaskCount() {
ArrayList<Task> tasks = mStackTaskList.getTasks();
int freeformCount = 0;
int taskCount = tasks.size();
for (int i = 0; i < taskCount; i++) {
Task task = tasks.get(i);
if (task.isFreeformTask()) {
freeformCount++;
}
}
return freeformCount;
return mStackTaskList.size();
}
/**

170
packages/SystemUI/src/com/android/systemui/recents/views/FreeformWorkspaceLayoutAlgorithm.java
View File

@@ -1,170 +0,0 @@
/*
* Copyright (C) 2014 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.systemui.recents.views;
import android.content.Context;
import android.graphics.RectF;
import android.util.ArrayMap;
import com.android.systemui.R;
import com.android.systemui.recents.model.Task;
import java.util.Collections;
import java.util.List;
/**
* The layout logic for the contents of the freeform workspace.
*/
public class FreeformWorkspaceLayoutAlgorithm {
// Optimization, allows for quick lookup of task -> rect
private ArrayMap<Task.TaskKey, RectF> mTaskRectMap = new ArrayMap<>();
private int mTaskPadding;
public FreeformWorkspaceLayoutAlgorithm(Context context) {
reloadOnConfigurationChange(context);
}
/**
* Reloads the layout for the current configuration.
*/
public void reloadOnConfigurationChange(Context context) {
// This is applied to the edges of each task
mTaskPadding = context.getResources().getDimensionPixelSize(
R.dimen.recents_freeform_layout_task_padding) / 2;
}
/**
* Updates the layout for each of the freeform workspace tasks. This is called after the stack
* layout is updated.
*/
public void update(List<Task> freeformTasks, TaskStackLayoutAlgorithm stackLayout) {
Collections.reverse(freeformTasks);
mTaskRectMap.clear();
int numFreeformTasks = stackLayout.mNumFreeformTasks;
if (!freeformTasks.isEmpty()) {
// Normalize the widths so that we can calculate the best layout below
int workspaceWidth = stackLayout.mFreeformRect.width();
int workspaceHeight = stackLayout.mFreeformRect.height();
float normalizedWorkspaceWidth = (float) workspaceWidth / workspaceHeight;
float normalizedWorkspaceHeight = 1f;
float[] normalizedTaskWidths = new float[numFreeformTasks];
for (int i = 0; i < numFreeformTasks; i++) {
Task task = freeformTasks.get(i);
float rowTaskWidth;
if (task.bounds != null) {
rowTaskWidth = (float) task.bounds.width() / task.bounds.height();
} else {
// If this is a stack task that was dragged into the freeform workspace, then
// the task will not yet have an associated bounds, so assume the full workspace
// width for the time being
rowTaskWidth = normalizedWorkspaceWidth;
}
// Bound the task width to the workspace width so that at the worst case, it will
// fit its own row
normalizedTaskWidths[i] = Math.min(rowTaskWidth, normalizedWorkspaceWidth);
}
// Determine the scale to best fit each of the tasks in the workspace
float rowScale = 0.85f;
float rowWidth = 0f;
float maxRowWidth = 0f;
int rowCount = 1;
for (int i = 0; i < numFreeformTasks;) {
float width = normalizedTaskWidths[i] * rowScale;
if (rowWidth + width > normalizedWorkspaceWidth) {
// That is too long for this row, create new row
if ((rowCount + 1) * rowScale > normalizedWorkspaceHeight) {
// The new row is too high, so we need to try fitting again. Update the
// scale to be the smaller of the scale needed to fit the task in the
// previous row, or the scale needed to fit the new row
rowScale = Math.min(normalizedWorkspaceWidth / (rowWidth + width),
normalizedWorkspaceHeight / (rowCount + 1));
rowCount = 1;
rowWidth = 0;
i = 0;
} else {
// The new row fits, so continue
rowWidth = width;
rowCount++;
i++;
}
} else {
// Task is OK in this row
rowWidth += width;
i++;
}
maxRowWidth = Math.max(rowWidth, maxRowWidth);
}
// Normalize each of the actual rects to that scale
float defaultRowLeft = ((1f - (maxRowWidth / normalizedWorkspaceWidth)) *
workspaceWidth) / 2f;
float rowLeft = defaultRowLeft;
float rowTop = ((1f - (rowScale * rowCount)) * workspaceHeight) / 2f;
float rowHeight = rowScale * workspaceHeight;
for (int i = 0; i < numFreeformTasks; i++) {
Task task = freeformTasks.get(i);
float width = rowHeight * normalizedTaskWidths[i];
if (rowLeft + width > workspaceWidth) {
// This goes on the next line
rowTop += rowHeight;
rowLeft = defaultRowLeft;
}
RectF rect = new RectF(rowLeft, rowTop, rowLeft + width, rowTop + rowHeight);
rect.inset(mTaskPadding, mTaskPadding);
rowLeft += width;
mTaskRectMap.put(task.key, rect);
}
}
}
/**
* Returns whether the transform is available for the given task.
*/
public boolean isTransformAvailable(Task task, TaskStackLayoutAlgorithm stackLayout) {
if (stackLayout.mNumFreeformTasks == 0 || task == null) {
return false;
}
return mTaskRectMap.containsKey(task.key);
}
/**
* Returns the transform for the given task. Any rect returned will be offset by the actual
* transform for the freeform workspace.
*/
public TaskViewTransform getTransform(Task task, TaskViewTransform transformOut,
TaskStackLayoutAlgorithm stackLayout) {
if (mTaskRectMap.containsKey(task.key)) {
final RectF ffRect = mTaskRectMap.get(task.key);
transformOut.scale = 1f;
transformOut.alpha = 1f;
transformOut.translationZ = stackLayout.mMaxTranslationZ;
transformOut.dimAlpha = 0f;
transformOut.viewOutlineAlpha = TaskStackLayoutAlgorithm.OUTLINE_ALPHA_MAX_VALUE;
transformOut.rect.set(ffRect);
transformOut.rect.offset(stackLayout.mFreeformRect.left, stackLayout.mFreeformRect.top);
transformOut.visible = true;
return transformOut;
}
return null;
}
}

34
packages/SystemUI/src/com/android/systemui/recents/views/RecentsTransitionHelper.java
View File

@@ -19,7 +19,6 @@ package com.android.systemui.recents.views;
import static android.app.WindowConfiguration.ACTIVITY_TYPE_ASSISTANT;
import static android.app.WindowConfiguration.ACTIVITY_TYPE_HOME;
import static android.app.WindowConfiguration.ACTIVITY_TYPE_RECENTS;
import static android.app.WindowConfiguration.WINDOWING_MODE_FREEFORM;
import static android.app.WindowConfiguration.WINDOWING_MODE_FULLSCREEN;
import static android.app.WindowConfiguration.WINDOWING_MODE_PINNED;
import static android.app.WindowConfiguration.WINDOWING_MODE_SPLIT_SCREEN_PRIMARY;
@@ -318,7 +317,6 @@ public class RecentsTransitionHelper {
// If this is a full screen stack, the transition will be towards the single, full screen
// task. We only need the transition spec for this task.
List<AppTransitionAnimationSpec> specs = new ArrayList<>();
// TODO: Sometimes targetStackId is not initialized after reboot, so we also have to
// check for INVALID_STACK_ID (now WINDOWING_MODE_UNDEFINED)
@@ -327,6 +325,7 @@ public class RecentsTransitionHelper {
|| windowingMode == WINDOWING_MODE_SPLIT_SCREEN_SECONDARY
|| activityType == ACTIVITY_TYPE_ASSISTANT
|| windowingMode == WINDOWING_MODE_UNDEFINED) {
List<AppTransitionAnimationSpec> specs = new ArrayList<>();
if (taskView == null) {
specs.add(composeOffscreenAnimationSpec(task, offscreenTaskRect));
} else {
@@ -340,34 +339,7 @@ public class RecentsTransitionHelper {
}
return specs;
}
// Otherwise, for freeform tasks, create a new animation spec for each task we have to
// launch
TaskStack stack = stackView.getStack();
ArrayList<Task> tasks = stack.getStackTasks();
int taskCount = tasks.size();
for (int i = taskCount - 1; i >= 0; i--) {
Task t = tasks.get(i);
if (t.isFreeformTask() || windowingMode == WINDOWING_MODE_FREEFORM) {
TaskView tv = stackView.getChildViewForTask(t);
if (tv == null) {
// TODO: Create a different animation task rect for this case (though it should
// never happen)
specs.add(composeOffscreenAnimationSpec(t, offscreenTaskRect));
} else {
mTmpTransform.fillIn(taskView);
stackLayout.transformToScreenCoordinates(mTmpTransform,
null /* windowOverrideRect */);
AppTransitionAnimationSpec spec = composeAnimationSpec(stackView, tv,
mTmpTransform, true /* addHeaderBitmap */);
if (spec != null) {
specs.add(spec);
}
}
}
}
return specs;
return Collections.emptyList();
}
/**
@@ -451,7 +423,7 @@ public class RecentsTransitionHelper {
// force the task thumbnail to full stackView height immediately causing the transition
// jarring.
if (!Recents.getConfiguration().isLowRamDevice && taskView.getTask() !=
stackView.getStack().getStackFrontMostTask(false /* includeFreeformTasks */)) {
stackView.getStack().getStackFrontMostTask()) {
taskRect.bottom = taskRect.top + stackView.getMeasuredHeight();
}
return new AppTransitionAnimationSpec(taskView.getTask().key.id, b, taskRect);

10
packages/SystemUI/src/com/android/systemui/recents/views/RecentsView.java
View File

@@ -110,7 +110,6 @@ public class RecentsView extends FrameLayout {
private final int mStackButtonShadowColor;
private boolean mAwaitingFirstLayout = true;
private boolean mLastTaskLaunchedWasFreeform;
@ViewDebug.ExportedProperty(category="recents")
Rect mSystemInsets = new Rect();
@@ -228,7 +227,6 @@ public class RecentsView extends FrameLayout {
// Reset the state
mAwaitingFirstLayout = !isResumingFromVisible;
mLastTaskLaunchedWasFreeform = false;
// Update the stack
mTaskStackView.onReload(isResumingFromVisible);
@@ -315,13 +313,6 @@ public class RecentsView extends FrameLayout {
}
}
/**
* Returns whether the last task launched was in the freeform stack or not.
*/
public boolean isLastTaskLaunchedFreeform() {
return mLastTaskLaunchedWasFreeform;
}
/** Launches the focused task from the first stack if possible */
public boolean launchFocusedTask(int logEvent) {
if (mTaskStackView != null) {
@@ -538,7 +529,6 @@ public class RecentsView extends FrameLayout {
/**** EventBus Events ****/
public final void onBusEvent(LaunchTaskEvent event) {
mLastTaskLaunchedWasFreeform = event.task.isFreeformTask();
mTransitionHelper.launchTaskFromRecents(getStack(), event.task, mTaskStackView,
event.taskView, event.screenPinningRequested, event.targetWindowingMode,
event.targetActivityType);

9
packages/SystemUI/src/com/android/systemui/recents/views/TaskStackAnimationHelper.java
View File

@@ -161,17 +161,12 @@ public class TaskStackAnimationHelper {
for (int i = taskViews.size() - 1; i >= 0; i--) {
TaskView tv = taskViews.get(i);
Task task = tv.getTask();
boolean hideTask = launchTargetTask != null &&
launchTargetTask.isFreeformTask() &&
task.isFreeformTask();
// Get the current transform for the task, which will be used to position it offscreen
stackLayout.getStackTransform(task, stackScroller.getStackScroll(), mTmpTransform,
null);
if (hideTask) {
tv.setVisibility(View.INVISIBLE);
} else if (launchState.launchedFromApp && !launchState.launchedViaDockGesture) {
if (launchState.launchedFromApp && !launchState.launchedViaDockGesture) {
if (task.isLaunchTarget) {
tv.onPrepareLaunchTargetForEnterAnimation();
} else if (isLowRamDevice && i >= taskViews.size() -
@@ -569,7 +564,7 @@ public class TaskStackAnimationHelper {
false /* ignoreTaskOverrides */, mTmpFinalTaskTransforms);
// Hide the front most task view until the scroll is complete
Task frontMostTask = newStack.getStackFrontMostTask(false /* includeFreeform */);
Task frontMostTask = newStack.getStackFrontMostTask();
final TaskView frontMostTaskView = mStackView.getChildViewForTask(frontMostTask);
final TaskViewTransform frontMostTransform = mTmpFinalTaskTransforms.get(
stackTasks.indexOf(frontMostTask));

144
packages/SystemUI/src/com/android/systemui/recents/views/TaskStackLayoutAlgorithm.java
View File

@@ -146,75 +146,6 @@ public class TaskStackLayoutAlgorithm {
void onFocusStateChanged(int prevFocusState, int curFocusState);
}
/**
* The various stack/freeform states.
*/
public static class StackState {
public static final StackState FREEFORM_ONLY = new StackState(1f, 255);
public static final StackState STACK_ONLY = new StackState(0f, 0);
public static final StackState SPLIT = new StackState(0.5f, 255);
public final float freeformHeightPct;
public final int freeformBackgroundAlpha;
/**
* @param freeformHeightPct the percentage of the stack height (not including paddings) to
* allocate to the freeform workspace
* @param freeformBackgroundAlpha the background alpha for the freeform workspace
*/
private StackState(float freeformHeightPct, int freeformBackgroundAlpha) {
this.freeformHeightPct = freeformHeightPct;
this.freeformBackgroundAlpha = freeformBackgroundAlpha;
}
/**
* Resolves the stack state for the layout given a task stack.
*/
public static StackState getStackStateForStack(TaskStack stack) {
SystemServicesProxy ssp = Recents.getSystemServices();
boolean hasFreeformWorkspaces = ssp.hasFreeformWorkspaceSupport();
int freeformCount = stack.getFreeformTaskCount();
int stackCount = stack.getStackTaskCount();
if (hasFreeformWorkspaces && stackCount > 0 && freeformCount > 0) {
return SPLIT;
} else if (hasFreeformWorkspaces && freeformCount > 0) {
return FREEFORM_ONLY;
} else {
return STACK_ONLY;
}
}
/**
* Computes the freeform and stack rect for this state.
*
* @param freeformRectOut the freeform rect to be written out
* @param stackRectOut the stack rect, we only write out the top of the stack
* @param taskStackBounds the full rect that the freeform rect can take up
*/
public void computeRects(Rect freeformRectOut, Rect stackRectOut,
Rect taskStackBounds, int topMargin, int freeformGap, int stackBottomOffset) {
// The freeform height is the visible height (not including system insets) - padding
// above freeform and below stack - gap between the freeform and stack
int availableHeight = taskStackBounds.height() - topMargin - stackBottomOffset;
int ffPaddedHeight = (int) (availableHeight * freeformHeightPct);
int ffHeight = Math.max(0, ffPaddedHeight - freeformGap);
freeformRectOut.set(taskStackBounds.left,
taskStackBounds.top + topMargin,
taskStackBounds.right,
taskStackBounds.top + topMargin + ffHeight);
stackRectOut.set(taskStackBounds.left,
taskStackBounds.top,
taskStackBounds.right,
taskStackBounds.bottom);
if (ffPaddedHeight > 0) {
stackRectOut.top += ffPaddedHeight;
} else {
stackRectOut.top += topMargin;
}
}
}
/**
* @return True if we should use the grid layout.
*/
@@ -234,15 +165,11 @@ public class TaskStackLayoutAlgorithm {
}
Context mContext;
private StackState mState = StackState.SPLIT;
private TaskStackLayoutAlgorithmCallbacks mCb;
// The task bounds (untransformed) for layout. This rect is anchored at mTaskRoot.
@ViewDebug.ExportedProperty(category="recents")
public Rect mTaskRect = new Rect();
// The freeform workspace bounds, inset by the top system insets and is a fixed height
@ViewDebug.ExportedProperty(category="recents")
public Rect mFreeformRect = new Rect();
// The stack bounds, inset from the top system insets, and runs to the bottom of the screen
@ViewDebug.ExportedProperty(category="recents")
public Rect mStackRect = new Rect();
@@ -268,10 +195,6 @@ public class TaskStackLayoutAlgorithm {
private int mBaseBottomMargin;
private int mMinMargin;
// The gap between the freeform and stack layouts
@ViewDebug.ExportedProperty(category="recents")
private int mFreeformStackGap;
// The initial offset that the focused task is from the top
@ViewDebug.ExportedProperty(category="recents")
private int mInitialTopOffset;
@@ -331,8 +254,6 @@ public class TaskStackLayoutAlgorithm {
// The last computed task counts
@ViewDebug.ExportedProperty(category="recents")
int mNumStackTasks;
@ViewDebug.ExportedProperty(category="recents")
int mNumFreeformTasks;
// The min/max z translations
@ViewDebug.ExportedProperty(category="recents")
@@ -344,8 +265,6 @@ public class TaskStackLayoutAlgorithm {
private SparseIntArray mTaskIndexMap = new SparseIntArray();
private SparseArray<Float> mTaskIndexOverrideMap = new SparseArray<>();
// The freeform workspace layout
FreeformWorkspaceLayoutAlgorithm mFreeformLayoutAlgorithm;
TaskGridLayoutAlgorithm mTaskGridLayoutAlgorithm;
TaskStackLowRamLayoutAlgorithm mTaskStackLowRamLayoutAlgorithm;
@@ -356,7 +275,6 @@ public class TaskStackLayoutAlgorithm {
public TaskStackLayoutAlgorithm(Context context, TaskStackLayoutAlgorithmCallbacks cb) {
mContext = context;
mCb = cb;
mFreeformLayoutAlgorithm = new FreeformWorkspaceLayoutAlgorithm(context);
mTaskGridLayoutAlgorithm = new TaskGridLayoutAlgorithm(context);
mTaskStackLowRamLayoutAlgorithm = new TaskStackLowRamLayoutAlgorithm(context);
reloadOnConfigurationChange(context);
@@ -393,7 +311,6 @@ public class TaskStackLayoutAlgorithm {
R.dimen.recents_layout_initial_bottom_offset_tablet,
R.dimen.recents_layout_initial_bottom_offset_tablet,
R.dimen.recents_layout_initial_bottom_offset_tablet);
mFreeformLayoutAlgorithm.reloadOnConfigurationChange(context);
mTaskGridLayoutAlgorithm.reloadOnConfigurationChange(context);
mTaskStackLowRamLayoutAlgorithm.reloadOnConfigurationChange(context);
mMinMargin = res.getDimensionPixelSize(R.dimen.recents_layout_min_margin);
@@ -408,8 +325,6 @@ public class TaskStackLayoutAlgorithm {
R.dimen.recents_layout_side_margin_tablet_xlarge,
R.dimen.recents_layout_side_margin_tablet);
mBaseBottomMargin = res.getDimensionPixelSize(R.dimen.recents_layout_bottom_margin);
mFreeformStackGap =
res.getDimensionPixelSize(R.dimen.recents_freeform_layout_bottom_margin);
mTitleBarHeight = getDimensionForDevice(mContext,
R.dimen.recents_task_view_header_height,
R.dimen.recents_task_view_header_height,
@@ -462,8 +377,7 @@ public class TaskStackLayoutAlgorithm {
* Computes the stack and task rects. The given task stack bounds already has the top/right
* insets and left/right padding already applied.
*/
public void initialize(Rect displayRect, Rect windowRect, Rect taskStackBounds,
StackState state) {
public void initialize(Rect displayRect, Rect windowRect, Rect taskStackBounds) {
Rect lastStackRect = new Rect(mStackRect);
int topMargin = getScaleForExtent(windowRect, displayRect, mBaseTopMargin, mMinMargin, HEIGHT);
@@ -474,10 +388,9 @@ public class TaskStackLayoutAlgorithm {
mInitialBottomOffset = mBaseInitialBottomOffset;
// Compute the stack bounds
mState = state;
mStackBottomOffset = mSystemInsets.bottom + bottomMargin;
state.computeRects(mFreeformRect, mStackRect, taskStackBounds, topMargin,
mFreeformStackGap, mStackBottomOffset);
mStackRect.set(taskStackBounds);
mStackRect.top += topMargin;
// The stack action button will take the full un-padded header space above the stack
mStackActionButtonRect.set(mStackRect.left, mStackRect.top - topMargin,
@@ -530,26 +443,20 @@ public class TaskStackLayoutAlgorithm {
if (tasks.isEmpty()) {
mFrontMostTaskP = 0;
mMinScrollP = mMaxScrollP = mInitialScrollP = 0;
mNumStackTasks = mNumFreeformTasks = 0;
mNumStackTasks = 0;
return;
}
// Filter the set of freeform and stack tasks
ArrayList<Task> freeformTasks = new ArrayList<>();
// Filter the set of stack tasks
ArrayList<Task> stackTasks = new ArrayList<>();
for (int i = 0; i < tasks.size(); i++) {
Task task = tasks.get(i);
if (ignoreTasksSet.contains(task.key)) {
continue;
}
if (task.isFreeformTask()) {
freeformTasks.add(task);
} else {
stackTasks.add(task);
}
stackTasks.add(task);
}
mNumStackTasks = stackTasks.size();
mNumFreeformTasks = freeformTasks.size();
// Put each of the tasks in the progress map at a fixed index (does not need to actually
// map to a scroll position, just by index)
@@ -559,11 +466,6 @@ public class TaskStackLayoutAlgorithm {
mTaskIndexMap.put(task.key.id, i);
}
// Update the freeform tasks
if (!freeformTasks.isEmpty()) {
mFreeformLayoutAlgorithm.update(freeformTasks, this);
}
// Calculate the min/max/initial scroll
Task launchTask = stack.getLaunchTarget();
int launchTaskIndex = launchTask != null
@@ -582,7 +484,7 @@ public class TaskStackLayoutAlgorithm {
} else {
mInitialScrollP = Utilities.clamp(launchTaskIndex - 1, mMinScrollP, mMaxScrollP);
}
} else if (!ssp.hasFreeformWorkspaceSupport() && mNumStackTasks == 1) {
} else if (mNumStackTasks == 1) {
// If there is one stack task, ignore the min/max/initial scroll positions
mMinScrollP = 0;
mMaxScrollP = 0;
@@ -793,13 +695,6 @@ public class TaskStackLayoutAlgorithm {
return mFrontOfStackTransform;
}
/**
* Returns the current stack state.
*/
public StackState getStackState() {
return mState;
}
/**
* Returns whether this stack layout has been initialized.
*/
@@ -825,30 +720,19 @@ public class TaskStackLayoutAlgorithm {
return new VisibilityReport(1, 1);
}
// Quick return when there are no stack tasks
if (mNumStackTasks == 0) {
return new VisibilityReport(mNumFreeformTasks > 0 ? Math.max(mNumFreeformTasks, 1) : 0,
mNumFreeformTasks > 0 ? Math.max(mNumFreeformTasks, 1) : 0);
}
// Otherwise, walk backwards in the stack and count the number of tasks and visible
// thumbnails and add that to the total freeform task count
// thumbnails and add that to the total task count
TaskViewTransform tmpTransform = new TaskViewTransform();
Range currentRange = getInitialFocusState() > 0f ? mFocusedRange : mUnfocusedRange;
currentRange.offset(mInitialScrollP);
int taskBarHeight = mContext.getResources().getDimensionPixelSize(
R.dimen.recents_task_view_header_height);
int numVisibleTasks = mNumFreeformTasks > 0 ? Math.max(mNumFreeformTasks, 1) : 0;
int numVisibleThumbnails = mNumFreeformTasks > 0 ? Math.max(mNumFreeformTasks, 0) : 0;
int numVisibleTasks = 0;
int numVisibleThumbnails = 0;
float prevScreenY = Integer.MAX_VALUE;
for (int i = tasks.size() - 1; i >= 0; i--) {
Task task = tasks.get(i);
// Skip freeform
if (task.isFreeformTask()) {
continue;
}
// Skip invisible
float taskProgress = getStackScrollForTask(task);
if (!currentRange.isInRange(taskProgress)) {
@@ -899,10 +783,7 @@ public class TaskStackLayoutAlgorithm {
public TaskViewTransform getStackTransform(Task task, float stackScroll, int focusState,
TaskViewTransform transformOut, TaskViewTransform frontTransform, boolean forceUpdate,
boolean ignoreTaskOverrides) {
if (mFreeformLayoutAlgorithm.isTransformAvailable(task, this)) {
mFreeformLayoutAlgorithm.getTransform(task, transformOut, this);
return transformOut;
} else if (useGridLayout()) {
if (useGridLayout()) {
int taskIndex = mTaskIndexMap.get(task.key.id);
int taskCount = mTaskIndexMap.size();
mTaskGridLayoutAlgorithm.getTransform(taskIndex, taskCount, transformOut, this);
@@ -1017,7 +898,7 @@ public class TaskStackLayoutAlgorithm {
float z;
float dimAlpha;
float viewOutlineAlpha;
if (!ssp.hasFreeformWorkspaceSupport() && mNumStackTasks == 1 && !ignoreSingleTaskCase) {
if (mNumStackTasks == 1 && !ignoreSingleTaskCase) {
// When there is exactly one task, then decouple the task from the stack and just move
// in screen space
float tmpP = (mMinScrollP - stackScroll) / mNumStackTasks;
@@ -1371,7 +1252,6 @@ public class TaskStackLayoutAlgorithm {
writer.print("insets="); writer.print(Utilities.dumpRect(mSystemInsets));
writer.print(" stack="); writer.print(Utilities.dumpRect(mStackRect));
writer.print(" task="); writer.print(Utilities.dumpRect(mTaskRect));
writer.print(" freeform="); writer.print(Utilities.dumpRect(mFreeformRect));
writer.print(" actionButton="); writer.print(Utilities.dumpRect(mStackActionButtonRect));
writer.println();

258
packages/SystemUI/src/com/android/systemui/recents/views/TaskStackView.java
View File

@@ -16,22 +16,15 @@
package com.android.systemui.recents.views;
import static android.app.WindowConfiguration.WINDOWING_MODE_FREEFORM;
import static android.app.WindowConfiguration.WINDOWING_MODE_FULLSCREEN;
import android.animation.Animator;
import android.animation.AnimatorListenerAdapter;
import android.animation.ObjectAnimator;
import android.animation.ValueAnimator;
import android.annotation.IntDef;
import android.content.ComponentName;
import android.content.Context;
import android.content.res.Configuration;
import android.content.res.Resources;
import android.graphics.Canvas;
import android.graphics.Rect;
import android.graphics.drawable.Drawable;
import android.graphics.drawable.GradientDrawable;
import android.os.Bundle;
import android.provider.Settings;
import android.util.ArrayMap;
@@ -83,13 +76,11 @@ import com.android.systemui.recents.events.ui.DismissAllTaskViewsEvent;
import com.android.systemui.recents.events.ui.DismissTaskViewEvent;
import com.android.systemui.recents.events.ui.RecentsGrowingEvent;
import com.android.systemui.recents.events.ui.TaskViewDismissedEvent;
import com.android.systemui.recents.events.ui.UpdateFreeformTaskViewVisibilityEvent;
import com.android.systemui.recents.events.ui.UserInteractionEvent;
import com.android.systemui.recents.events.ui.dragndrop.DragDropTargetChangedEvent;
import com.android.systemui.recents.events.ui.dragndrop.DragEndCancelledEvent;
import com.android.systemui.recents.events.ui.dragndrop.DragEndEvent;
import com.android.systemui.recents.events.ui.dragndrop.DragStartEvent;
import com.android.systemui.recents.events.ui.dragndrop.DragStartInitializeDropTargetsEvent;
import com.android.systemui.recents.events.ui.focus.DismissFocusedTaskViewEvent;
import com.android.systemui.recents.events.ui.focus.FocusNextTaskViewEvent;
import com.android.systemui.recents.events.ui.focus.FocusPreviousTaskViewEvent;
@@ -153,8 +144,6 @@ public class TaskStackView extends FrameLayout implements TaskStack.TaskStackCal
@ViewDebug.ExportedProperty(deepExport=true, prefix="touch_")
private TaskStackViewTouchHandler mTouchHandler;
private TaskStackAnimationHelper mAnimationHelper;
private GradientDrawable mFreeformWorkspaceBackground;
private ObjectAnimator mFreeformWorkspaceBackgroundAnimator;
private ViewPool<TaskView, Task> mViewPool;
private ArrayList<TaskView> mTaskViews = new ArrayList<>();
@@ -239,20 +228,6 @@ public class TaskStackView extends FrameLayout implements TaskStack.TaskStackCal
}
};
// The drop targets for a task drag
private DropTarget mFreeformWorkspaceDropTarget = new DropTarget() {
@Override
public boolean acceptsDrop(int x, int y, int width, int height, Rect insets,
boolean isCurrentTarget) {
// This drop target has a fixed bounds and should be checked last, so just fall through
// if it is the current target
if (!isCurrentTarget) {
return mLayoutAlgorithm.mFreeformRect.contains(x, y);
}
return false;
}
};
private DropTarget mStackDropTarget = new DropTarget() {
@Override
public boolean acceptsDrop(int x, int y, int width, int height, Rect insets,
@@ -312,17 +287,6 @@ public class TaskStackView extends FrameLayout implements TaskStack.TaskStackCal
}
});
setImportantForAccessibility(View.IMPORTANT_FOR_ACCESSIBILITY_YES);
if (ssp.hasFreeformWorkspaceSupport()) {
setWillNotDraw(false);
}
mFreeformWorkspaceBackground = (GradientDrawable) getContext().getDrawable(
R.drawable.recents_freeform_workspace_bg);
mFreeformWorkspaceBackground.setCallback(this);
if (ssp.hasFreeformWorkspaceSupport()) {
mFreeformWorkspaceBackground.setColor(
getContext().getColor(R.color.recents_freeform_workspace_bg_color));
}
}
@Override
@@ -359,12 +323,7 @@ public class TaskStackView extends FrameLayout implements TaskStack.TaskStackCal
readSystemFlags();
mTaskViewsClipDirty = true;
mUIDozeTrigger.stopDozing();
if (isResumingFromVisible) {
// Animate in the freeform workspace
int ffBgAlpha = mLayoutAlgorithm.getStackState().freeformBackgroundAlpha;
animateFreeformWorkspaceBackgroundAlpha(ffBgAlpha, new AnimationProps(150,
Interpolators.FAST_OUT_SLOW_IN));
} else {
if (!isResumingFromVisible) {
mStackScroller.reset();
mStableLayoutAlgorithm.reset();
mLayoutAlgorithm.reset();
@@ -422,23 +381,13 @@ public class TaskStackView extends FrameLayout implements TaskStack.TaskStackCal
/**
* Returns the front most task view.
*
* @param stackTasksOnly if set, will return the front most task view in the stack (by default
* the front most task view will be freeform since they are placed above
* stack tasks)
*/
private TaskView getFrontMostTaskView(boolean stackTasksOnly) {
private TaskView getFrontMostTaskView() {
List<TaskView> taskViews = getTaskViews();
int taskViewCount = taskViews.size();
for (int i = taskViewCount - 1; i >= 0; i--) {
TaskView tv = taskViews.get(i);
Task task = tv.getTask();
if (stackTasksOnly && task.isFreeformTask()) {
continue;
}
return tv;
if (taskViews.isEmpty()) {
return null;
}
return null;
return taskViews.get(taskViews.size() - 1);
}
/**
@@ -500,8 +449,6 @@ public class TaskStackView extends FrameLayout implements TaskStack.TaskStackCal
* visible range includes all tasks at the target stack scroll. This is useful for ensure that
* all views necessary for a transition or animation will be visible at the start.
*
* This call ignores freeform tasks.
*
* @param taskTransforms The set of task view transforms to reuse, this list will be sized to
* match the size of {@param tasks}
* @param tasks The set of tasks for which to generate transforms
@@ -554,12 +501,6 @@ public class TaskStackView extends FrameLayout implements TaskStack.TaskStackCal
continue;
}
// For freeform tasks, only calculate the stack transform and skip the calculation of
// the visible stack indices
if (task.isFreeformTask()) {
continue;
}
frontTransform = transform;
frontTransformAtTarget = transformAtTarget;
if (transform.visible) {
@@ -622,7 +563,7 @@ public class TaskStackView extends FrameLayout implements TaskStack.TaskStackCal
transform = mCurrentTaskTransforms.get(taskIndex);
}
if (task.isFreeformTask() || (transform != null && transform.visible)) {
if (transform != null && transform.visible) {
mTmpTaskViewMap.put(task.key, tv);
} else {
if (mTouchExplorationEnabled && Utilities.isDescendentAccessibilityFocused(tv)) {
@@ -643,24 +584,20 @@ public class TaskStackView extends FrameLayout implements TaskStack.TaskStackCal
continue;
}
// Skip the invisible non-freeform stack tasks
if (!task.isFreeformTask() && !transform.visible) {
// Skip the invisible stack tasks
if (!transform.visible) {
continue;
}
TaskView tv = mTmpTaskViewMap.get(task.key);
if (tv == null) {
tv = mViewPool.pickUpViewFromPool(task, task);
if (task.isFreeformTask()) {
updateTaskViewToTransform(tv, transform, AnimationProps.IMMEDIATE);
if (transform.rect.top <= mLayoutAlgorithm.mStackRect.top) {
updateTaskViewToTransform(tv, mLayoutAlgorithm.getBackOfStackTransform(),
AnimationProps.IMMEDIATE);
} else {
if (transform.rect.top <= mLayoutAlgorithm.mStackRect.top) {
updateTaskViewToTransform(tv, mLayoutAlgorithm.getBackOfStackTransform(),
AnimationProps.IMMEDIATE);
} else {
updateTaskViewToTransform(tv, mLayoutAlgorithm.getFrontOfStackTransform(),
AnimationProps.IMMEDIATE);
}
updateTaskViewToTransform(tv, mLayoutAlgorithm.getFrontOfStackTransform(),
AnimationProps.IMMEDIATE);
}
} else {
// Reattach it in the right z order
@@ -887,13 +824,6 @@ public class TaskStackView extends FrameLayout implements TaskStack.TaskStackCal
// Compute the min and max scroll values
mLayoutAlgorithm.update(mStack, mIgnoreTasks, launchState);
// Update the freeform workspace background
SystemServicesProxy ssp = Recents.getSystemServices();
if (ssp.hasFreeformWorkspaceSupport()) {
mTmpRect.set(mLayoutAlgorithm.mFreeformRect);
mFreeformWorkspaceBackground.setBounds(mTmpRect);
}
if (boundScrollToNewMinMax) {
mStackScroller.boundScroll();
}
@@ -906,8 +836,7 @@ public class TaskStackView extends FrameLayout implements TaskStack.TaskStackCal
mWindowRect.set(mStableWindowRect);
mStackBounds.set(mStableStackBounds);
mLayoutAlgorithm.setSystemInsets(mStableLayoutAlgorithm.mSystemInsets);
mLayoutAlgorithm.initialize(mDisplayRect, mWindowRect, mStackBounds,
TaskStackLayoutAlgorithm.StackState.getStackStateForStack(mStack));
mLayoutAlgorithm.initialize(mDisplayRect, mWindowRect, mStackBounds);
updateLayoutAlgorithm(true /* boundScroll */);
}
@@ -1028,21 +957,10 @@ public class TaskStackView extends FrameLayout implements TaskStack.TaskStackCal
if (focusedTask != null) {
if (stackTasksOnly) {
List<Task> tasks = mStack.getStackTasks();
if (focusedTask.isFreeformTask()) {
// Try and focus the front most stack task
TaskView tv = getFrontMostTaskView(stackTasksOnly);
if (tv != null) {
newIndex = mStack.indexOfStackTask(tv.getTask());
}
} else {
// Try the next task if it is a stack task
int tmpNewIndex = newIndex + (forward ? -1 : 1);
if (0 <= tmpNewIndex && tmpNewIndex < tasks.size()) {
Task t = tasks.get(tmpNewIndex);
if (!t.isFreeformTask()) {
newIndex = tmpNewIndex;
}
}
// Try the next task if it is a stack task
int tmpNewIndex = newIndex + (forward ? -1 : 1);
if (0 <= tmpNewIndex && tmpNewIndex < tasks.size()) {
newIndex = tmpNewIndex;
}
} else {
// No restrictions, lets just move to the new task (looping forward/backwards if
@@ -1127,7 +1045,7 @@ public class TaskStackView extends FrameLayout implements TaskStack.TaskStackCal
return tv.getTask();
}
}
TaskView frontTv = getFrontMostTaskView(true /* stackTasksOnly */);
TaskView frontTv = getFrontMostTaskView();
if (frontTv != null) {
return frontTv.getTask();
}
@@ -1278,10 +1196,8 @@ public class TaskStackView extends FrameLayout implements TaskStack.TaskStackCal
}
// Compute the rects in the stack algorithm
mStableLayoutAlgorithm.initialize(mDisplayRect, mStableWindowRect, mStableStackBounds,
TaskStackLayoutAlgorithm.StackState.getStackStateForStack(mStack));
mLayoutAlgorithm.initialize(mDisplayRect, mWindowRect, mStackBounds,
TaskStackLayoutAlgorithm.StackState.getStackStateForStack(mStack));
mStableLayoutAlgorithm.initialize(mDisplayRect, mStableWindowRect, mStableStackBounds);
mLayoutAlgorithm.initialize(mDisplayRect, mWindowRect, mStackBounds);
updateLayoutAlgorithm(false /* boundScroll */);
// If this is the first layout, then scroll to the front of the stack, then update the
@@ -1404,11 +1320,6 @@ public class TaskStackView extends FrameLayout implements TaskStack.TaskStackCal
// Setup the view for the enter animation
mAnimationHelper.prepareForEnterAnimation();
// Animate in the freeform workspace
int ffBgAlpha = mLayoutAlgorithm.getStackState().freeformBackgroundAlpha;
animateFreeformWorkspaceBackgroundAlpha(ffBgAlpha, new AnimationProps(150,
Interpolators.FAST_OUT_SLOW_IN));
// Set the task focused state without requesting view focus, and leave the focus animations
// until after the enter-animation
RecentsConfiguration config = Recents.getConfiguration();
@@ -1456,43 +1367,6 @@ public class TaskStackView extends FrameLayout implements TaskStack.TaskStackCal
return null;
}
@Override
protected void onDraw(Canvas canvas) {
super.onDraw(canvas);
// Draw the freeform workspace background
SystemServicesProxy ssp = Recents.getSystemServices();
if (ssp.hasFreeformWorkspaceSupport()) {
if (mFreeformWorkspaceBackground.getAlpha() > 0) {
mFreeformWorkspaceBackground.draw(canvas);
}
}
}
@Override
protected boolean verifyDrawable(Drawable who) {
if (who == mFreeformWorkspaceBackground) {
return true;
}
return super.verifyDrawable(who);
}
/**
* Launches the freeform tasks.
*/
public boolean launchFreeformTasks() {
ArrayList<Task> tasks = mStack.getFreeformTasks();
if (!tasks.isEmpty()) {
Task frontTask = tasks.get(tasks.size() - 1);
if (frontTask != null && frontTask.isFreeformTask()) {
EventBus.getDefault().send(new LaunchTaskEvent(getChildViewForTask(frontTask),
frontTask, null, false));
return true;
}
}
return false;
}
/**** TaskStackCallbacks Implementation ****/
@Override
@@ -1671,8 +1545,7 @@ public class TaskStackView extends FrameLayout implements TaskStack.TaskStackCal
}
// Restore the action button visibility if it is the front most task view
if (mScreenPinningEnabled && tv.getTask() ==
mStack.getStackFrontMostTask(false /* includeFreeform */)) {
if (mScreenPinningEnabled && tv.getTask() == mStack.getStackFrontMostTask()) {
tv.showActionButton(false /* fadeIn */, 0 /* fadeInDuration */);
}
}
@@ -1688,7 +1561,6 @@ public class TaskStackView extends FrameLayout implements TaskStack.TaskStackCal
// If the doze trigger has already fired, then update the state for this task view
if (mUIDozeTrigger.isAsleep() ||
Recents.getSystemServices().hasFreeformWorkspaceSupport() ||
useGridLayout() || Recents.getConfiguration().isLowRamDevice) {
tv.setNoUserInteractionState();
}
@@ -1820,7 +1692,7 @@ public class TaskStackView extends FrameLayout implements TaskStack.TaskStackCal
public final void onBusEvent(LaunchMostRecentTaskRequestEvent event) {
if (mStack.getTaskCount() > 0) {
Task mostRecentTask = mStack.getStackFrontMostTask(true /* includeFreefromTasks */);
Task mostRecentTask = mStack.getStackFrontMostTask();
launchTask(mostRecentTask);
}
}
@@ -1891,11 +1763,6 @@ public class TaskStackView extends FrameLayout implements TaskStack.TaskStackCal
// Start the task animations
mAnimationHelper.startExitToHomeAnimation(event.animated, event.getAnimationTrigger());
// Dismiss the freeform workspace background
int taskViewExitToHomeDuration = TaskStackAnimationHelper.EXIT_TO_HOME_TRANSLATION_DURATION;
animateFreeformWorkspaceBackgroundAlpha(0, new AnimationProps(taskViewExitToHomeDuration,
Interpolators.FAST_OUT_SLOW_IN));
// Dismiss the grid task view focus frame
if (mTaskViewFocusFrame != null) {
mTaskViewFocusFrame.moveGridTaskViewFocus(null);
@@ -2026,11 +1893,6 @@ public class TaskStackView extends FrameLayout implements TaskStack.TaskStackCal
// Ensure that the drag task is not animated
addIgnoreTask(event.task);
if (event.task.isFreeformTask()) {
// Animate to the front of the stack
mStackScroller.animateScroll(mLayoutAlgorithm.mInitialScrollP, null);
}
// Enlarge the dragged view slightly
float finalScale = event.taskView.getScaleX() * DRAG_SCALE_FACTOR;
mLayoutAlgorithm.getStackTransform(event.task, getScroller().getStackScroll(),
@@ -2042,14 +1904,6 @@ public class TaskStackView extends FrameLayout implements TaskStack.TaskStackCal
new AnimationProps(DRAG_SCALE_DURATION, Interpolators.FAST_OUT_SLOW_IN));
}
public final void onBusEvent(DragStartInitializeDropTargetsEvent event) {
SystemServicesProxy ssp = Recents.getSystemServices();
if (ssp.hasFreeformWorkspaceSupport()) {
event.handler.registerDropTargetForCurrentDrag(mStackDropTarget);
event.handler.registerDropTargetForCurrentDrag(mFreeformWorkspaceDropTarget);
}
}
public final void onBusEvent(DragDropTargetChangedEvent event) {
AnimationProps animation = new AnimationProps(SLOW_SYNC_STACK_DURATION,
Interpolators.FAST_OUT_SLOW_IN);
@@ -2069,8 +1923,7 @@ public class TaskStackView extends FrameLayout implements TaskStack.TaskStackCal
height, mDividerSize, systemInsets,
mLayoutAlgorithm, getResources(), mWindowRect));
mLayoutAlgorithm.setSystemInsets(systemInsets);
mLayoutAlgorithm.initialize(mDisplayRect, mWindowRect, mStackBounds,
TaskStackLayoutAlgorithm.StackState.getStackStateForStack(mStack));
mLayoutAlgorithm.initialize(mDisplayRect, mWindowRect, mStackBounds);
updateLayoutAlgorithm(true /* boundScroll */);
ignoreTaskOverrides = true;
} else {
@@ -2092,32 +1945,6 @@ public class TaskStackView extends FrameLayout implements TaskStack.TaskStackCal
return;
}
boolean isFreeformTask = event.task.isFreeformTask();
boolean hasChangedWindowingMode =
(!isFreeformTask && event.dropTarget == mFreeformWorkspaceDropTarget) ||
(isFreeformTask && event.dropTarget == mStackDropTarget);
if (hasChangedWindowingMode) {
// Move the task to the right position in the stack (ie. the front of the stack if
// freeform or the front of the stack if fullscreen). Note, we MUST move the tasks
// before we update their stack ids, otherwise, the keys will have changed.
if (event.dropTarget == mFreeformWorkspaceDropTarget) {
mStack.setTaskWindowingMode(event.task, WINDOWING_MODE_FREEFORM);
} else if (event.dropTarget == mStackDropTarget) {
mStack.setTaskWindowingMode(event.task, WINDOWING_MODE_FULLSCREEN);
}
updateLayoutAlgorithm(true /* boundScroll */);
// Move the task to the new stack in the system after the animation completes
event.addPostAnimationCallback(new Runnable() {
@Override
public void run() {
SystemServicesProxy ssp = Recents.getSystemServices();
ssp.setTaskWindowingMode(event.task.key.id, event.task.key.windowingMode);
}
});
}
// Restore the task, so that relayout will apply to it below
removeIgnoreTask(event.task);
@@ -2177,9 +2004,7 @@ public class TaskStackView extends FrameLayout implements TaskStack.TaskStackCal
// Add a runnable to the post animation ref counter to clear all the views
trigger.addLastDecrementRunnable(() -> {
// Start the dozer to trigger to trigger any UI that shows after a timeout
if (!Recents.getSystemServices().hasFreeformWorkspaceSupport()) {
mUIDozeTrigger.startDozing();
}
mUIDozeTrigger.startDozing();
// Update the focused state here -- since we only set the focused task without
// requesting view focus in onFirstLayout(), actually request view focus and
@@ -2202,18 +2027,6 @@ public class TaskStackView extends FrameLayout implements TaskStack.TaskStackCal
mStackReloaded = false;
}
public final void onBusEvent(UpdateFreeformTaskViewVisibilityEvent event) {
List<TaskView> taskViews = getTaskViews();
int taskViewCount = taskViews.size();
for (int i = 0; i < taskViewCount; i++) {
TaskView tv = taskViews.get(i);
Task task = tv.getTask();
if (task.isFreeformTask()) {
tv.setVisibility(event.visible ? View.VISIBLE : View.INVISIBLE);
}
}
}
public final void onBusEvent(final MultiWindowStateChangedEvent event) {
if (event.inMultiWindow || !event.showDeferredAnimation) {
setTasks(event.stack, true /* allowNotifyStackChanges */);
@@ -2314,27 +2127,6 @@ public class TaskStackView extends FrameLayout implements TaskStack.TaskStackCal
mLayoutAlgorithm.reloadOnConfigurationChange(getContext());
}
/**
* Starts an alpha animation on the freeform workspace background.
*/
private void animateFreeformWorkspaceBackgroundAlpha(int targetAlpha,
AnimationProps animation) {
if (mFreeformWorkspaceBackground.getAlpha() == targetAlpha) {
return;
}
Utilities.cancelAnimationWithoutCallbacks(mFreeformWorkspaceBackgroundAnimator);
mFreeformWorkspaceBackgroundAnimator = ObjectAnimator.ofInt(mFreeformWorkspaceBackground,
Utilities.DRAWABLE_ALPHA, mFreeformWorkspaceBackground.getAlpha(), targetAlpha);
mFreeformWorkspaceBackgroundAnimator.setStartDelay(
animation.getDuration(AnimationProps.ALPHA));
mFreeformWorkspaceBackgroundAnimator.setDuration(
animation.getDuration(AnimationProps.ALPHA));
mFreeformWorkspaceBackgroundAnimator.setInterpolator(
animation.getInterpolator(AnimationProps.ALPHA));
mFreeformWorkspaceBackgroundAnimator.start();
}
/**
* Returns the insert index for the task in the current set of task views. If the given task
* is already in the task view list, then this method returns the insert index assuming it

12
packages/SystemUI/src/com/android/systemui/recents/views/TaskStackViewTouchHandler.java
View File

@@ -403,18 +403,6 @@ class TaskStackViewTouchHandler implements SwipeHelper.Callback {
return;
}
// If tapping on the freeform workspace background, just launch the first freeform task
SystemServicesProxy ssp = Recents.getSystemServices();
if (ssp.hasFreeformWorkspaceSupport()) {
Rect freeformRect = mSv.mLayoutAlgorithm.mFreeformRect;
if (freeformRect.top <= y && y <= freeformRect.bottom) {
if (mSv.launchFreeformTasks()) {
// TODO: Animate Recents away as we launch the freeform tasks
return;
}
}
}
// The user intentionally tapped on the background, which is like a tap on the "desktop".
// Hide recents and transition to the launcher.
EventBus.getDefault().send(new HideRecentsEvent(false, true));

8
packages/SystemUI/src/com/android/systemui/recents/views/TaskView.java
View File

@@ -194,9 +194,7 @@ public class TaskView extends FixedSizeFrameLayout implements Task.TaskCallbacks
* Called from RecentsActivity when it is relaunched.
*/
void onReload(boolean isResumingFromVisible) {
if (!Recents.getSystemServices().hasFreeformWorkspaceSupport()) {
resetNoUserInteractionState();
}
resetNoUserInteractionState();
if (!isResumingFromVisible) {
resetViewProperties();
}
@@ -413,9 +411,7 @@ public class TaskView extends FixedSizeFrameLayout implements Task.TaskCallbacks
* view.
*/
boolean shouldClipViewInStack() {
// Never clip for freeform tasks or if invisible
if (mTask.isFreeformTask() || getVisibility() != View.VISIBLE ||
Recents.getConfiguration().isLowRamDevice) {
if (getVisibility() != View.VISIBLE || Recents.getConfiguration().isLowRamDevice) {
return false;
}
return mClipViewInStack;

41
packages/SystemUI/src/com/android/systemui/recents/views/TaskViewHeader.java
View File

@@ -17,7 +17,6 @@
package com.android.systemui.recents.views;
import static android.app.WindowConfiguration.ACTIVITY_TYPE_UNDEFINED;
import static android.app.WindowConfiguration.WINDOWING_MODE_FREEFORM;
import static android.app.WindowConfiguration.WINDOWING_MODE_FULLSCREEN;
import static android.app.WindowConfiguration.WINDOWING_MODE_UNDEFINED;
@@ -164,8 +163,6 @@ public class TaskViewHeader extends FrameLayout
float mDimAlpha;
Drawable mLightDismissDrawable;
Drawable mDarkDismissDrawable;
Drawable mLightFreeformIcon;
Drawable mDarkFreeformIcon;
Drawable mLightFullscreenIcon;
Drawable mDarkFullscreenIcon;
Drawable mLightInfoIcon;
@@ -215,8 +212,6 @@ public class TaskViewHeader extends FrameLayout
mHighlightHeight = res.getDimensionPixelSize(R.dimen.recents_task_view_highlight);
mTaskBarViewLightTextColor = context.getColor(R.color.recents_task_bar_light_text_color);
mTaskBarViewDarkTextColor = context.getColor(R.color.recents_task_bar_dark_text_color);
mLightFreeformIcon = context.getDrawable(R.drawable.recents_move_task_freeform_light);
mDarkFreeformIcon = context.getDrawable(R.drawable.recents_move_task_freeform_dark);
mLightFullscreenIcon = context.getDrawable(R.drawable.recents_move_task_fullscreen_light);
mDarkFullscreenIcon = context.getDrawable(R.drawable.recents_move_task_fullscreen_dark);
mLightInfoIcon = context.getDrawable(R.drawable.recents_info_light);
@@ -249,9 +244,6 @@ public class TaskViewHeader extends FrameLayout
mIconView.setOnLongClickListener(this);
mTitleView = findViewById(R.id.title);
mDismissButton = findViewById(R.id.dismiss_task);
if (ssp.hasFreeformWorkspaceSupport()) {
mMoveTaskButton = findViewById(R.id.move_task);
}
onConfigurationChanged();
}
@@ -341,20 +333,6 @@ public class TaskViewHeader extends FrameLayout
boolean showDismissIcon = true;
int rightInset = width - getMeasuredWidth();
if (mTask != null && mTask.isFreeformTask()) {
// For freeform tasks, we always show the app icon, and only show the title, move-task
// icon, and the dismiss icon if there is room
int appIconWidth = mIconView.getMeasuredWidth();
int titleWidth = (int) mTitleView.getPaint().measureText(mTask.title);
int dismissWidth = mDismissButton.getMeasuredWidth();
int moveTaskWidth = mMoveTaskButton != null
? mMoveTaskButton.getMeasuredWidth()
: 0;
showTitle = width >= (appIconWidth + dismissWidth + moveTaskWidth + titleWidth);
showMoveIcon = width >= (appIconWidth + dismissWidth + moveTaskWidth);
showDismissIcon = width >= (appIconWidth + dismissWidth);
}
mTitleView.setVisibility(showTitle ? View.VISIBLE : View.INVISIBLE);
if (mMoveTaskButton != null) {
mMoveTaskButton.setVisibility(showMoveIcon ? View.VISIBLE : View.INVISIBLE);
@@ -482,25 +460,6 @@ public class TaskViewHeader extends FrameLayout
mDismissButton.setClickable(false);
((RippleDrawable) mDismissButton.getBackground()).setForceSoftware(true);
// When freeform workspaces are enabled, then update the move-task button depending on the
// current task
if (mMoveTaskButton != null) {
if (t.isFreeformTask()) {
mTaskWindowingMode = WINDOWING_MODE_FULLSCREEN;
mMoveTaskButton.setImageDrawable(t.useLightOnPrimaryColor
? mLightFullscreenIcon
: mDarkFullscreenIcon);
} else {
mTaskWindowingMode = WINDOWING_MODE_FREEFORM;
mMoveTaskButton.setImageDrawable(t.useLightOnPrimaryColor
? mLightFreeformIcon
: mDarkFreeformIcon);
}
mMoveTaskButton.setOnClickListener(this);
mMoveTaskButton.setClickable(false);
((RippleDrawable) mMoveTaskButton.getBackground()).setForceSoftware(true);
}
if (Recents.getDebugFlags().isFastToggleRecentsEnabled()) {
if (mFocusTimerIndicator == null) {
mFocusTimerIndicator = (ProgressBar) Utilities.findViewStubById(this,

12
packages/SystemUI/src/com/android/systemui/recents/views/TaskViewThumbnail.java
View File

@@ -245,10 +245,6 @@ public class TaskViewThumbnail extends View {
public void updateThumbnailMatrix() {
mThumbnailScale = 1f;
if (mBitmapShader != null && mThumbnailData != null) {
// We consider this a stack task if it is not freeform (ie. has no bounds) or has been
// dragged into the stack from the freeform workspace
boolean isStackTask = !mTask.isFreeformTask() || mTask.bounds == null;
int xOffset, yOffset = 0;
if (mTaskViewRect.isEmpty()) {
// If we haven't measured , skip the thumbnail drawing and only draw the background
// color
@@ -266,7 +262,7 @@ public class TaskViewThumbnail extends View {
mThumbnailScale = (float) (mTaskViewRect.height() - mTitleBarHeight)
/ (float) mThumbnailRect.height();
}
} else if (isStackTask) {
} else {
float invThumbnailScale = 1f / mFullscreenThumbnailScale;
if (mDisplayOrientation == Configuration.ORIENTATION_PORTRAIT) {
if (mThumbnailData.orientation == Configuration.ORIENTATION_PORTRAIT) {
@@ -283,12 +279,6 @@ public class TaskViewThumbnail extends View {
// Otherwise, scale the screenshot to fit 1:1 in the current orientation
mThumbnailScale = invThumbnailScale;
}
} else {
// Otherwise, if this is a freeform task with task bounds, then scale the thumbnail
// to fit the entire bitmap into the task bounds
mThumbnailScale = Math.min(
(float) mTaskViewRect.width() / mThumbnailRect.width(),
(float) mTaskViewRect.height() / mThumbnailRect.height());
}
mMatrix.setTranslate(-mThumbnailData.insets.left * mFullscreenThumbnailScale,
-mThumbnailData.insets.top * mFullscreenThumbnailScale);

2
packages/SystemUI/src/com/android/systemui/recents/views/TaskViewTransform.java
View File

@@ -59,7 +59,7 @@ public class TaskViewTransform {
public boolean visible = false;
// This is a window-space rect used for positioning the task in the stack and freeform workspace
// This is a window-space rect used for positioning the task in the stack
public RectF rect = new RectF();
/**