/*
* Copyright (C) 2013 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.server.wm;
import static android.app.ActivityManager.RESIZE_MODE_SYSTEM_SCREEN_ROTATION;
import static android.app.ActivityManager.StackId.DOCKED_STACK_ID;
import static android.app.ActivityManager.StackId.PINNED_STACK_ID;
import static android.app.ActivityManager.StackId.FREEFORM_WORKSPACE_STACK_ID;
import static android.app.ActivityManager.StackId.HOME_STACK_ID;
import static android.content.pm.ActivityInfo.RESIZE_MODE_CROP_WINDOWS;
import static android.content.res.Configuration.ORIENTATION_LANDSCAPE;
import static com.android.server.wm.WindowManagerDebugConfig.DEBUG_RESIZE;
import static com.android.server.wm.WindowManagerDebugConfig.DEBUG_STACK;
import static com.android.server.wm.WindowManagerDebugConfig.TAG_WITH_CLASS_NAME;
import static com.android.server.wm.WindowManagerDebugConfig.TAG_WM;
import static com.android.server.wm.WindowManagerService.H.RESIZE_TASK;
import static android.view.WindowManager.LayoutParams.TYPE_BASE_APPLICATION;
import android.app.ActivityManager.StackId;
import android.content.pm.ActivityInfo;
import android.content.res.Configuration;
import android.graphics.Rect;
import android.util.EventLog;
import android.util.Slog;
import android.view.DisplayInfo;
import android.view.Surface;
import com.android.server.EventLogTags;
import java.io.PrintWriter;
import java.util.ArrayList;
class Task implements DimLayer.DimLayerUser {
static final String TAG = TAG_WITH_CLASS_NAME ? "Task" : TAG_WM;
// Return value from {@link setBounds} indicating no change was made to the Task bounds.
static final int BOUNDS_CHANGE_NONE = 0;
// Return value from {@link setBounds} indicating the position of the Task bounds changed.
static final int BOUNDS_CHANGE_POSITION = 1;
// Return value from {@link setBounds} indicating the size of the Task bounds changed.
static final int BOUNDS_CHANGE_SIZE = 1 << 1;
TaskStack mStack;
final AppTokenList mAppTokens = new AppTokenList();
final int mTaskId;
final int mUserId;
boolean mDeferRemoval = false;
final WindowManagerService mService;
// Content limits relative to the DisplayContent this sits in.
private Rect mBounds = new Rect();
final Rect mPreparedFrozenBounds = new Rect();
final Configuration mPreparedFrozenMergedConfig = new Configuration();
private Rect mPreScrollBounds = new Rect();
private boolean mScrollValid;
// Bounds used to calculate the insets.
private final Rect mTempInsetBounds = new Rect();
// Device rotation as of the last time {@link #mBounds} was set.
int mRotation;
// Whether mBounds is fullscreen
private boolean mFullscreen = true;
// Contains configurations settings that are different from the global configuration due to
// stack specific operations. E.g. {@link #setBounds}.
Configuration mOverrideConfig = Configuration.EMPTY;
// For comparison with DisplayContent bounds.
private Rect mTmpRect = new Rect();
// For handling display rotations.
private Rect mTmpRect2 = new Rect();
// Resize mode of the task. See {@link ActivityInfo#resizeMode}
private int mResizeMode;
// Whether the task is currently being drag-resized
private boolean mDragResizing;
private int mDragResizeMode;
private boolean mHomeTask;
Task(int taskId, TaskStack stack, int userId, WindowManagerService service, Rect bounds,
Configuration config) {
mTaskId = taskId;
mStack = stack;
mUserId = userId;
mService = service;
setBounds(bounds, config);
}
DisplayContent getDisplayContent() {
return mStack.getDisplayContent();
}
void addAppToken(int addPos, AppWindowToken wtoken, int resizeMode, boolean homeTask) {
final int lastPos = mAppTokens.size();
if (addPos >= lastPos) {
addPos = lastPos;
} else {
for (int pos = 0; pos < lastPos && pos < addPos; ++pos) {
if (mAppTokens.get(pos).removed) {
// addPos assumes removed tokens are actually gone.
++addPos;
}
}
}
mAppTokens.add(addPos, wtoken);
wtoken.mTask = this;
mDeferRemoval = false;
mResizeMode = resizeMode;
mHomeTask = homeTask;
}
private boolean hasWindowsAlive() {
for (int i = mAppTokens.size() - 1; i >= 0; i--) {
if (mAppTokens.get(i).hasWindowsAlive()) {
return true;
}
}
return false;
}
void removeLocked() {
if (hasWindowsAlive() && mStack.isAnimating()) {
if (DEBUG_STACK) Slog.i(TAG, "removeTask: deferring removing taskId=" + mTaskId);
mDeferRemoval = true;
return;
}
if (DEBUG_STACK) Slog.i(TAG, "removeTask: removing taskId=" + mTaskId);
EventLog.writeEvent(EventLogTags.WM_TASK_REMOVED, mTaskId, "removeTask");
mDeferRemoval = false;
DisplayContent content = getDisplayContent();
if (content != null) {
content.mDimLayerController.removeDimLayerUser(this);
}
mStack.removeTask(this);
mService.mTaskIdToTask.delete(mTaskId);
}
void moveTaskToStack(TaskStack stack, boolean toTop) {
if (stack == mStack) {
return;
}
if (DEBUG_STACK) Slog.i(TAG, "moveTaskToStack: removing taskId=" + mTaskId
+ " from stack=" + mStack);
EventLog.writeEvent(EventLogTags.WM_TASK_REMOVED, mTaskId, "moveTask");
if (mStack != null) {
mStack.removeTask(this);
}
stack.addTask(this, toTop);
}
void positionTaskInStack(TaskStack stack, int position, Rect bounds, Configuration config) {
if (mStack != null && stack != mStack) {
if (DEBUG_STACK) Slog.i(TAG, "positionTaskInStack: removing taskId=" + mTaskId
+ " from stack=" + mStack);
EventLog.writeEvent(EventLogTags.WM_TASK_REMOVED, mTaskId, "moveTask");
mStack.removeTask(this);
}
stack.positionTask(this, position, showForAllUsers());
resizeLocked(bounds, config, false /* force */);
for (int activityNdx = mAppTokens.size() - 1; activityNdx >= 0; --activityNdx) {
final ArrayList<WindowState> windows = mAppTokens.get(activityNdx).allAppWindows;
for (int winNdx = windows.size() - 1; winNdx >= 0; --winNdx) {
final WindowState win = windows.get(winNdx);
win.notifyMovedInStack();
}
}
}
boolean removeAppToken(AppWindowToken wtoken) {
boolean removed = mAppTokens.remove(wtoken);
if (mAppTokens.size() == 0) {
EventLog.writeEvent(EventLogTags.WM_TASK_REMOVED, mTaskId, "removeAppToken: last token");
if (mDeferRemoval) {
removeLocked();
}
}
wtoken.mTask = null;
/* Leave mTaskId for now, it might be useful for debug
wtoken.mTaskId = -1;
*/
return removed;
}
void setSendingToBottom(boolean toBottom) {
for (int appTokenNdx = 0; appTokenNdx < mAppTokens.size(); appTokenNdx++) {
mAppTokens.get(appTokenNdx).sendingToBottom = toBottom;
}
}
/** Set the task bounds. Passing in null sets the bounds to fullscreen. */
private int setBounds(Rect bounds, Configuration config) {
if (config == null) {
config = Configuration.EMPTY;
}
if (bounds == null && !Configuration.EMPTY.equals(config)) {
throw new IllegalArgumentException("null bounds but non empty configuration: "
+ config);
}
if (bounds != null && Configuration.EMPTY.equals(config)) {
throw new IllegalArgumentException("non null bounds, but empty configuration");
}
boolean oldFullscreen = mFullscreen;
int rotation = Surface.ROTATION_0;
final DisplayContent displayContent = mStack.getDisplayContent();
if (displayContent != null) {
displayContent.getLogicalDisplayRect(mTmpRect);
rotation = displayContent.getDisplayInfo().rotation;
mFullscreen = bounds == null;
if (mFullscreen) {
bounds = mTmpRect;
}
}
if (bounds == null) {
// Can't set to fullscreen if we don't have a display to get bounds from...
return BOUNDS_CHANGE_NONE;
}
if (mPreScrollBounds.equals(bounds) && oldFullscreen == mFullscreen && mRotation == rotation) {
return BOUNDS_CHANGE_NONE;
}
int boundsChange = BOUNDS_CHANGE_NONE;
if (mPreScrollBounds.left != bounds.left || mPreScrollBounds.top != bounds.top) {
boundsChange |= BOUNDS_CHANGE_POSITION;
}
if (mPreScrollBounds.width() != bounds.width() || mPreScrollBounds.height() != bounds.height()) {
boundsChange |= BOUNDS_CHANGE_SIZE;
}
mPreScrollBounds.set(bounds);
resetScrollLocked();
mRotation = rotation;
if (displayContent != null) {
displayContent.mDimLayerController.updateDimLayer(this);
}
mOverrideConfig = mFullscreen ? Configuration.EMPTY : config;
return boundsChange;
}
/**
* Sets the bounds used to calculate the insets. See
* {@link android.app.IActivityManager#resizeDockedStack} why this is needed.
*/
void setTempInsetBounds(Rect tempInsetBounds) {
if (tempInsetBounds != null) {
mTempInsetBounds.set(tempInsetBounds);
} else {
mTempInsetBounds.setEmpty();
}
}
/**
* Gets the bounds used to calculate the insets. See
* {@link android.app.IActivityManager#resizeDockedStack} why this is needed.
*/
void getTempInsetBounds(Rect out) {
out.set(mTempInsetBounds);
}
void setResizeable(int resizeMode) {
mResizeMode = resizeMode;
}
boolean isResizeable() {
return !mHomeTask
&& (ActivityInfo.isResizeableMode(mResizeMode) || mService.mForceResizableTasks);
}
boolean cropWindowsToStackBounds() {
return !mHomeTask && (isResizeable() || mResizeMode == RESIZE_MODE_CROP_WINDOWS);
}
boolean isHomeTask() {
return mHomeTask;
}
private boolean inCropWindowsResizeMode() {
return !mHomeTask && !isResizeable() && mResizeMode == RESIZE_MODE_CROP_WINDOWS;
}
boolean resizeLocked(Rect bounds, Configuration configuration, boolean forced) {
int boundsChanged = setBounds(bounds, configuration);
if (forced) {
boundsChanged |= BOUNDS_CHANGE_SIZE;
}
if (boundsChanged == BOUNDS_CHANGE_NONE) {
return false;
}
if ((boundsChanged & BOUNDS_CHANGE_SIZE) == BOUNDS_CHANGE_SIZE) {
resizeWindows();
} else {
moveWindows();
}
return true;
}
/**
* Prepares the task bounds to be frozen with the current size. See
* {@link AppWindowToken#freezeBounds}.
*/
void prepareFreezingBounds() {
mPreparedFrozenBounds.set(mBounds);
mPreparedFrozenMergedConfig.setTo(mService.mCurConfiguration);
mPreparedFrozenMergedConfig.updateFrom(mOverrideConfig);
}
/**
* Align the task to the adjusted bounds.
*
* @param adjustedBounds Adjusted bounds to which the task should be aligned.
* @param tempInsetBounds Insets bounds for the task.
* @param alignBottom True if the task's bottom should be aligned to the adjusted
* bounds's bottom; false if the task's top should be aligned
* the adjusted bounds's top.
*/
void alignToAdjustedBounds(
Rect adjustedBounds, Rect tempInsetBounds, boolean alignBottom) {
if (!isResizeable() || mOverrideConfig == Configuration.EMPTY) {
return;
}
getBounds(mTmpRect2);
if (alignBottom) {
int offsetY = adjustedBounds.bottom - mTmpRect2.bottom;
mTmpRect2.offset(0, offsetY);
} else {
mTmpRect2.offsetTo(adjustedBounds.left, adjustedBounds.top);
}
setTempInsetBounds(tempInsetBounds);
resizeLocked(mTmpRect2, mOverrideConfig, false /* forced */);
}
void resetScrollLocked() {
if (mScrollValid) {
mScrollValid = false;
applyScrollToAllWindows(0, 0);
}
mBounds.set(mPreScrollBounds);
}
void applyScrollToAllWindows(final int xOffset, final int yOffset) {
for (int activityNdx = mAppTokens.size() - 1; activityNdx >= 0; --activityNdx) {
final ArrayList<WindowState> windows = mAppTokens.get(activityNdx).allAppWindows;
for (int winNdx = windows.size() - 1; winNdx >= 0; --winNdx) {
final WindowState win = windows.get(winNdx);
win.mXOffset = xOffset;
win.mYOffset = yOffset;
}
}
}
void applyScrollToWindowIfNeeded(final WindowState win) {
if (mScrollValid) {
win.mXOffset = mBounds.left;
win.mYOffset = mBounds.top;
}
}
boolean scrollLocked(Rect bounds) {
// shift the task bound if it doesn't fully cover the stack area
mStack.getDimBounds(mTmpRect);
if (mService.mCurConfiguration.orientation == ORIENTATION_LANDSCAPE) {
if (bounds.left > mTmpRect.left) {
bounds.left = mTmpRect.left;
bounds.right = mTmpRect.left + mBounds.width();
} else if (bounds.right < mTmpRect.right) {
bounds.left = mTmpRect.right - mBounds.width();
bounds.right = mTmpRect.right;
}
} else {
if (bounds.top > mTmpRect.top) {
bounds.top = mTmpRect.top;
bounds.bottom = mTmpRect.top + mBounds.height();
} else if (bounds.bottom < mTmpRect.bottom) {
bounds.top = mTmpRect.bottom - mBounds.height();
bounds.bottom = mTmpRect.bottom;
}
}
// We can stop here if we're already scrolling and the scrolled bounds not changed.
if (mScrollValid && bounds.equals(mBounds)) {
return false;
}
// Normal setBounds() does not allow non-null bounds for fullscreen apps.
// We only change bounds for the scrolling case without change it size,
// on resizing path we should still want the validation.
mBounds.set(bounds);
mScrollValid = true;
applyScrollToAllWindows(bounds.left, bounds.top);
return true;
}
/** Return true if the current bound can get outputted to the rest of the system as-is. */
private boolean useCurrentBounds() {
final DisplayContent displayContent = mStack.getDisplayContent();
if (mFullscreen
|| !StackId.isTaskResizeableByDockedStack(mStack.mStackId)
|| displayContent == null
|| displayContent.getDockedStackVisibleForUserLocked() != null) {
return true;
}
return false;
}
/** Original bounds of the task if applicable, otherwise fullscreen rect. */
void getBounds(Rect out) {
if (useCurrentBounds()) {
// No need to adjust the output bounds if fullscreen or the docked stack is visible
// since it is already what we want to represent to the rest of the system.
out.set(mBounds);
return;
}
// The bounds has been adjusted to accommodate for a docked stack, but the docked stack is
// not currently visible. Go ahead a represent it as fullscreen to the rest of the system.
mStack.getDisplayContent().getLogicalDisplayRect(out);
}
/**
* Calculate the maximum visible area of this task. If the task has only one app,
* the result will be visible frame of that app. If the task has more than one apps,
* we search from top down if the next app got different visible area.
*
* This effort is to handle the case where some task (eg. GMail composer) might pop up
* a dialog that's different in size from the activity below, in which case we should
* be dimming the entire task area behind the dialog.
*
* @param out Rect containing the max visible bounds.
* @return true if the task has some visible app windows; false otherwise.
*/
boolean getMaxVisibleBounds(Rect out) {
boolean foundTop = false;
for (int i = mAppTokens.size() - 1; i >= 0; i--) {
final AppWindowToken token = mAppTokens.get(i);
// skip hidden (or about to hide) apps
if (token.mIsExiting || token.clientHidden || token.hiddenRequested) {
continue;
}
final WindowState win = token.findMainWindow();
if (win == null) {
continue;
}
if (!foundTop) {
out.set(win.mVisibleFrame);
foundTop = true;
continue;
}
if (win.mVisibleFrame.left < out.left) {
out.left = win.mVisibleFrame.left;
}
if (win.mVisibleFrame.top < out.top) {
out.top = win.mVisibleFrame.top;
}
if (win.mVisibleFrame.right > out.right) {
out.right = win.mVisibleFrame.right;
}
if (win.mVisibleFrame.bottom > out.bottom) {
out.bottom = win.mVisibleFrame.bottom;
}
}
return foundTop;
}
/** Bounds of the task to be used for dimming, as well as touch related tests. */
@Override
public void getDimBounds(Rect out) {
final DisplayContent displayContent = mStack.getDisplayContent();
// It doesn't matter if we in particular are part of the resize, since we couldn't have
// a DimLayer anyway if we weren't visible.
final boolean dockedResizing = displayContent != null ?
displayContent.mDividerControllerLocked.isResizing() : false;
if (useCurrentBounds()) {
if (inFreeformWorkspace() && getMaxVisibleBounds(out)) {
return;
}
if (!mFullscreen) {
// When minimizing the docked stack when going home, we don't adjust the task bounds
// so we need to intersect the task bounds with the stack bounds here.
//
// If we are Docked Resizing with snap points, the task bounds could be smaller than the stack
// bounds and so we don't even want to use them. Even if the app should not be resized the Dim
// should keep up with the divider.
if (dockedResizing) {
mStack.getBounds(out);
} else {
mStack.getBounds(mTmpRect);
mTmpRect.intersect(mBounds);
}
out.set(mTmpRect);
} else {
out.set(mBounds);
}
return;
}
// The bounds has been adjusted to accommodate for a docked stack, but the docked stack
// is not currently visible. Go ahead a represent it as fullscreen to the rest of the
// system.
displayContent.getLogicalDisplayRect(out);
}
void setDragResizing(boolean dragResizing, int dragResizeMode) {
if (mDragResizing != dragResizing) {
if (!DragResizeMode.isModeAllowedForStack(mStack.mStackId, dragResizeMode)) {
throw new IllegalArgumentException("Drag resize mode not allow for stack stackId="
+ mStack.mStackId + " dragResizeMode=" + dragResizeMode);
}
mDragResizing = dragResizing;
mDragResizeMode = dragResizeMode;
resetDragResizingChangeReported();
}
}
void resetDragResizingChangeReported() {
for (int activityNdx = mAppTokens.size() - 1; activityNdx >= 0; --activityNdx) {
final ArrayList<WindowState> windows = mAppTokens.get(activityNdx).allAppWindows;
for (int winNdx = windows.size() - 1; winNdx >= 0; --winNdx) {
final WindowState win = windows.get(winNdx);
win.resetDragResizingChangeReported();
}
}
}
boolean isDragResizing() {
return mDragResizing || (mStack != null && mStack.isDragResizing());
}
int getDragResizeMode() {
return mDragResizeMode;
}
/**
* Adds all of the tasks windows to {@link WindowManagerService#mWaitingForDrawn} if drag
* resizing state of the window has been changed.
*/
void addWindowsWaitingForDrawnIfResizingChanged() {
for (int activityNdx = mAppTokens.size() - 1; activityNdx >= 0; --activityNdx) {
final ArrayList<WindowState> windows = mAppTokens.get(activityNdx).allAppWindows;
for (int winNdx = windows.size() - 1; winNdx >= 0; --winNdx) {
final WindowState win = windows.get(winNdx);
if (win.isDragResizeChanged()) {
mService.mWaitingForDrawn.add(win);
}
}
}
}
void updateDisplayInfo(final DisplayContent displayContent) {
if (displayContent == null) {
return;
}
if (mFullscreen) {
setBounds(null, Configuration.EMPTY);
return;
}
final int newRotation = displayContent.getDisplayInfo().rotation;
if (mRotation == newRotation) {
return;
}
// Device rotation changed.
// - Reset the bounds to the pre-scroll bounds as whatever scrolling was done is no longer
// valid.
// - Rotate the bounds and notify activity manager if the task can be resized independently
// from its stack. The stack will take care of task rotation for the other case.
mTmpRect2.set(mPreScrollBounds);
if (!StackId.isTaskResizeAllowed(mStack.mStackId)) {
setBounds(mTmpRect2, mOverrideConfig);
return;
}
displayContent.rotateBounds(mRotation, newRotation, mTmpRect2);
if (setBounds(mTmpRect2, mOverrideConfig) != BOUNDS_CHANGE_NONE) {
// Post message to inform activity manager of the bounds change simulating a one-way
// call. We do this to prevent a deadlock between window manager lock and activity
// manager lock been held.
mService.mH.obtainMessage(RESIZE_TASK, mTaskId,
RESIZE_MODE_SYSTEM_SCREEN_ROTATION, mPreScrollBounds).sendToTarget();
}
}
void resizeWindows() {
final ArrayList<WindowState> resizingWindows = mService.mResizingWindows;
for (int activityNdx = mAppTokens.size() - 1; activityNdx >= 0; --activityNdx) {
final AppWindowToken atoken = mAppTokens.get(activityNdx);
// Some windows won't go through the resizing process, if they don't have a surface, so
// destroy all saved surfaces here.
atoken.destroySavedSurfaces();
final ArrayList<WindowState> windows = atoken.allAppWindows;
for (int winNdx = windows.size() - 1; winNdx >= 0; --winNdx) {
final WindowState win = windows.get(winNdx);
if (win.mHasSurface && !resizingWindows.contains(win)) {
if (DEBUG_RESIZE) Slog.d(TAG, "resizeWindows: Resizing " + win);
resizingWindows.add(win);
// If we are not drag resizing, force recreating of a new surface so updating
// the content and positioning that surface will be in sync.
//
// As we use this flag as a hint to freeze surface boundary updates,
// we'd like to only apply this to TYPE_BASE_APPLICATION,
// windows of TYPE_APPLICATION like dialogs, could appear
// to not be drag resizing while they resize, but we'd
// still like to manipulate their frame to update crop, etc...
//
// Anyway we don't need to synchronize position and content updates for these
// windows since they aren't at the base layer and could be moved around anyway.
if (!win.computeDragResizing() && win.mAttrs.type == TYPE_BASE_APPLICATION &&
!mStack.getBoundsAnimating() && !win.isGoneForLayoutLw() &&
!inPinnedWorkspace()) {
win.setResizedWhileNotDragResizing(true);
}
}
if (win.isGoneForLayoutLw()) {
win.mResizedWhileGone = true;
}
}
}
}
void moveWindows() {
for (int activityNdx = mAppTokens.size() - 1; activityNdx >= 0; --activityNdx) {
final ArrayList<WindowState> windows = mAppTokens.get(activityNdx).allAppWindows;
for (int winNdx = windows.size() - 1; winNdx >= 0; --winNdx) {
final WindowState win = windows.get(winNdx);
if (DEBUG_RESIZE) Slog.d(TAG, "moveWindows: Moving " + win);
win.mMovedByResize = true;
}
}
}
/**
* Cancels any running app transitions associated with the task.
*/
void cancelTaskWindowTransition() {
for (int activityNdx = mAppTokens.size() - 1; activityNdx >= 0; --activityNdx) {
mAppTokens.get(activityNdx).mAppAnimator.clearAnimation();
}
}
/**
* Cancels any running thumbnail transitions associated with the task.
*/
void cancelTaskThumbnailTransition() {
for (int activityNdx = mAppTokens.size() - 1; activityNdx >= 0; --activityNdx) {
mAppTokens.get(activityNdx).mAppAnimator.clearThumbnail();
}
}
boolean showForAllUsers() {
final int tokensCount = mAppTokens.size();
return (tokensCount != 0) && mAppTokens.get(tokensCount - 1).showForAllUsers;
}
boolean isVisibleForUser() {
for (int i = mAppTokens.size() - 1; i >= 0; i--) {
final AppWindowToken appToken = mAppTokens.get(i);
for (int j = appToken.allAppWindows.size() - 1; j >= 0; j--) {
WindowState window = appToken.allAppWindows.get(j);
if (!window.isHiddenFromUserLocked()) {
return true;
}
}
}
return false;
}
boolean isVisible() {
for (int i = mAppTokens.size() - 1; i >= 0; i--) {
final AppWindowToken appToken = mAppTokens.get(i);
if (appToken.isVisible()) {
return true;
}
}
return false;
}
boolean inHomeStack() {
return mStack != null && mStack.mStackId == HOME_STACK_ID;
}
boolean inFreeformWorkspace() {
return mStack != null && mStack.mStackId == FREEFORM_WORKSPACE_STACK_ID;
}
boolean inDockedWorkspace() {
return mStack != null && mStack.mStackId == DOCKED_STACK_ID;
}
boolean inPinnedWorkspace() {
return mStack != null && mStack.mStackId == PINNED_STACK_ID;
}
boolean isResizeableByDockedStack() {
final DisplayContent displayContent = getDisplayContent();
return displayContent != null && displayContent.getDockedStackLocked() != null
&& mStack != null && StackId.isTaskResizeableByDockedStack(mStack.mStackId);
}
boolean isFloating() {
return StackId.tasksAreFloating(mStack.mStackId);
}
/**
* Whether the task should be treated as if it's docked. Returns true if the task
* is currently in docked workspace, or it's side-by-side to a docked task.
*/
boolean isDockedInEffect() {
return inDockedWorkspace() || isResizeableByDockedStack();
}
boolean isTwoFingerScrollMode() {
return inCropWindowsResizeMode() && isDockedInEffect();
}
WindowState getTopVisibleAppMainWindow() {
final AppWindowToken token = getTopVisibleAppToken();
return token != null ? token.findMainWindow() : null;
}
AppWindowToken getTopVisibleAppToken() {
for (int i = mAppTokens.size() - 1; i >= 0; i--) {
final AppWindowToken token = mAppTokens.get(i);
// skip hidden (or about to hide) apps
if (!token.mIsExiting && !token.clientHidden && !token.hiddenRequested) {
return token;
}
}
return null;
}
AppWindowToken getTopAppToken() {
return mAppTokens.size() > 0 ? mAppTokens.get(mAppTokens.size() - 1) : null;
}
@Override
public boolean dimFullscreen() {
return isHomeTask() || isFullscreen();
}
boolean isFullscreen() {
if (useCurrentBounds()) {
return mFullscreen;
}
// The bounds has been adjusted to accommodate for a docked stack, but the docked stack
// is not currently visible. Go ahead a represent it as fullscreen to the rest of the
// system.
return true;
}
@Override
public DisplayInfo getDisplayInfo() {
return mStack.getDisplayContent().getDisplayInfo();
}
@Override
public String toString() {
return "{taskId=" + mTaskId + " appTokens=" + mAppTokens + " mdr=" + mDeferRemoval + "}";
}
@Override
public String toShortString() {
return "Task=" + mTaskId;
}
public void dump(String prefix, PrintWriter pw) {
final String doublePrefix = prefix + " ";
pw.println(prefix + "taskId=" + mTaskId);
pw.println(doublePrefix + "mFullscreen=" + mFullscreen);
pw.println(doublePrefix + "mBounds=" + mBounds.toShortString());
pw.println(doublePrefix + "mdr=" + mDeferRemoval);
pw.println(doublePrefix + "appTokens=" + mAppTokens);
pw.println(doublePrefix + "mTempInsetBounds=" + mTempInsetBounds.toShortString());
final String triplePrefix = doublePrefix + " ";
for (int i = mAppTokens.size() - 1; i >= 0; i--) {
final AppWindowToken wtoken = mAppTokens.get(i);
pw.println(triplePrefix + "Activity #" + i + " " + wtoken);
wtoken.dump(pw, triplePrefix);
}
}
}