diff options
Diffstat (limited to 'services/java/com/android')
9 files changed, 121 insertions, 61 deletions
diff --git a/services/java/com/android/server/am/ActivityManagerService.java b/services/java/com/android/server/am/ActivityManagerService.java index 52b933f..a3bb823 100644 --- a/services/java/com/android/server/am/ActivityManagerService.java +++ b/services/java/com/android/server/am/ActivityManagerService.java @@ -6265,13 +6265,16 @@ public final class ActivityManagerService extends ActivityManagerNative } @Override - public int createStack(int relativeStackId, int position, float weight) { + public int createStack(int taskId, int relativeStackId, int position, float weight) { synchronized (this) { if (mStackSupervisor.getStack(relativeStackId) == null) { return -1; } int stackId = mStackSupervisor.createStack(); mWindowManager.createStack(stackId, relativeStackId, position, weight); + if (taskId > 0) { + moveTaskToStack(taskId, stackId, true); + } return stackId; } } diff --git a/services/java/com/android/server/am/ActivityStackSupervisor.java b/services/java/com/android/server/am/ActivityStackSupervisor.java index 7b8ad43..8768688 100644 --- a/services/java/com/android/server/am/ActivityStackSupervisor.java +++ b/services/java/com/android/server/am/ActivityStackSupervisor.java @@ -236,13 +236,10 @@ public class ActivityStackSupervisor { final ActivityStack stack = task.stack; if (stack.removeTask(task) && !stack.isHomeStack()) { mStacks.remove(stack); - final int oldStackId = stack.mStackId; - final int newMainStackId = mService.mWindowManager.removeStack(oldStackId); - if (newMainStackId == HOME_STACK_ID) { - return; - } - if (mMainStack.mStackId == oldStackId) { - mMainStack = getStack(newMainStackId); + final int stackId = stack.mStackId; + final int nextStackId = mService.mWindowManager.removeStack(stackId); + if (mMainStack.mStackId == stackId) { + mMainStack = nextStackId == HOME_STACK_ID ? null : getStack(nextStackId); } } } @@ -1044,8 +1041,8 @@ public class ActivityStackSupervisor { if (!r.isHomeActivity) { if (mStacks.size() == 1) { // Time to create the first app stack. - int stackId = - mService.createStack(HOME_STACK_ID, StackBox.TASK_STACK_GOES_OVER, 1.0f); + int stackId = mService.createStack(-1, HOME_STACK_ID, + StackBox.TASK_STACK_GOES_OVER, 1.0f); mMainStack = getStack(stackId); } return mMainStack; diff --git a/services/java/com/android/server/wm/DisplayContent.java b/services/java/com/android/server/wm/DisplayContent.java index edf3d3b..915c696c 100644 --- a/services/java/com/android/server/wm/DisplayContent.java +++ b/services/java/com/android/server/wm/DisplayContent.java @@ -90,11 +90,12 @@ class DisplayContent { /** True when the home StackBox is at the top of mStackBoxes, false otherwise */ private TaskStack mHomeStack = null; - /** - * Sorted most recent at top, oldest at [0]. - */ + /** Save allocating when retrieving tasks */ ArrayList<Task> mTmpTasks = new ArrayList<Task>(); + /** Sorted most recent at top, oldest at [0]. */ + ArrayList<TaskStack> mStackHistory = new ArrayList<TaskStack>(); + /** * @param display May not be null. */ @@ -125,17 +126,23 @@ class DisplayContent { return mStackBoxes.get(0).mStack != mHomeStack; } + void moveStack(TaskStack stack, boolean toTop) { + mStackHistory.remove(stack); + mStackHistory.add(toTop ? mStackHistory.size() : 0, stack); + } + /** - * Retrieve the tasks on this display in stack order from the topmost TaskStack down. - * Note that the order of TaskStacks in the same StackBox is defined within StackBox. + * Retrieve the tasks on this display in stack order from the bottommost TaskStack up. * @return All the Tasks, in order, on this display. */ ArrayList<Task> getTasks() { mTmpTasks.clear(); - int numBoxes = mStackBoxes.size(); - for (int boxNdx = 0; boxNdx < numBoxes; ++boxNdx) { - mTmpTasks.addAll(mStackBoxes.get(boxNdx).getTasks()); + final int numStacks = mStackHistory.size(); + for (int stackNdx = 0; stackNdx < numStacks; ++stackNdx) { + mTmpTasks.addAll(mStackHistory.get(stackNdx).getTasks()); } + if (WindowManagerService.DEBUG_LAYERS) Slog.i(TAG, "getTasks: mStackHistory=" + + mStackHistory); return mTmpTasks; } @@ -221,6 +228,13 @@ class DisplayContent { return false; } + void addStackBox(StackBox box, boolean toTop) { + if (mStackBoxes.size() >= 2) { + throw new RuntimeException("addStackBox: Too many toplevel StackBoxes!"); + } + mStackBoxes.add(toTop ? mStackBoxes.size() : 0, box); + } + void removeStackBox(StackBox box) { if (DEBUG_STACK) Slog.d(TAG, "removeStackBox: box=" + box); final TaskStack stack = box.mStack; diff --git a/services/java/com/android/server/wm/InputMonitor.java b/services/java/com/android/server/wm/InputMonitor.java index d966001..cacc723 100644 --- a/services/java/com/android/server/wm/InputMonitor.java +++ b/services/java/com/android/server/wm/InputMonitor.java @@ -31,7 +31,6 @@ import android.view.InputChannel; import android.view.KeyEvent; import android.view.WindowManager; -import java.util.ArrayList; import java.util.Arrays; final class InputMonitor implements InputManagerService.WindowManagerCallbacks { @@ -68,6 +67,7 @@ final class InputMonitor implements InputManagerService.WindowManagerCallbacks { * * Called by the InputManager. */ + @Override public void notifyInputChannelBroken(InputWindowHandle inputWindowHandle) { if (inputWindowHandle == null) { return; @@ -87,6 +87,7 @@ final class InputMonitor implements InputManagerService.WindowManagerCallbacks { * * Called by the InputManager. */ + @Override public long notifyANR(InputApplicationHandle inputApplicationHandle, InputWindowHandle inputWindowHandle) { AppWindowToken appWindowToken = null; @@ -163,10 +164,20 @@ final class InputMonitor implements InputManagerService.WindowManagerCallbacks { } private void addInputWindowHandleLw(final InputWindowHandle inputWindowHandle, - final WindowState child, final int flags, final int type, + final WindowState child, int flags, final int type, final boolean isVisible, final boolean hasFocus, final boolean hasWallpaper) { // Add a window to our list of input windows. inputWindowHandle.name = child.toString(); + final boolean modal = (flags & (WindowManager.LayoutParams.FLAG_NOT_TOUCH_MODAL + | WindowManager.LayoutParams.FLAG_NOT_FOCUSABLE)) == 0; + if (modal && child.mAppToken != null) { + // Limit the outer touch to the activity stack region. + flags |= WindowManager.LayoutParams.FLAG_NOT_TOUCH_MODAL; + inputWindowHandle.touchableRegion.set(child.getStackBounds()); + } else { + // Not modal or full screen modal + child.getTouchableRegion(inputWindowHandle.touchableRegion); + } inputWindowHandle.layoutParamsFlags = flags; inputWindowHandle.layoutParamsType = type; inputWindowHandle.dispatchingTimeoutNanos = child.getInputDispatchingTimeoutNanos(); @@ -195,7 +206,6 @@ final class InputMonitor implements InputManagerService.WindowManagerCallbacks { inputWindowHandle.scaleFactor = 1; } - child.getTouchableRegion(inputWindowHandle.touchableRegion); addInputWindowHandleLw(inputWindowHandle); } @@ -259,10 +269,10 @@ final class InputMonitor implements InputManagerService.WindowManagerCallbacks { // Skip this window because it cannot possibly receive input. continue; } - + final int flags = child.mAttrs.flags; final int type = child.mAttrs.type; - + final boolean hasFocus = (child == mInputFocus); final boolean isVisible = child.isVisibleLw(); final boolean hasWallpaper = (child == mService.mWallpaperTarget) diff --git a/services/java/com/android/server/wm/StackBox.java b/services/java/com/android/server/wm/StackBox.java index bcc5137..b195f0b 100644 --- a/services/java/com/android/server/wm/StackBox.java +++ b/services/java/com/android/server/wm/StackBox.java @@ -42,7 +42,7 @@ public class StackBox { /** Non-null indicates this is mFirst or mSecond of a parent StackBox. Null indicates this * is this entire size of mDisplayContent. */ - final StackBox mParent; + StackBox mParent; /** First child, this is null exactly when mStack is non-null. */ StackBox mFirst; @@ -105,13 +105,14 @@ public class StackBox { return mFirst.contains(stackId) || mSecond.contains(stackId); } - /** Determine if the specified stack is the first child or second child. Presumes that this - * is called on mParent of the specified stack. - * @param stack the stack to determine. - * @return true if stack is the first child. + /** Determine if this StackBox is the first child or second child. + * @return true if this is the first child. */ - boolean isFirstChild(TaskStack stack) { - return mFirst.mStack == stack; + boolean isFirstChild() { + if (mParent == null) { + return false; + } + return mParent.mFirst == this; } /** Returns the bounds of the specified TaskStack if it is contained in this StackBox. @@ -217,15 +218,6 @@ public class StackBox { return mTmpTasks; } - /** Combine a child StackBox into its parent. - * @param child The surviving child to be merge up into this StackBox. */ - void absorb(StackBox child) { - mFirst = child.mFirst; - mSecond = child.mSecond; - mStack = child.mStack; - layoutNeeded = true; - } - /** Return the stackId of the first mFirst StackBox with a non-null mStack */ int getStackId() { if (mStack != null) { @@ -236,18 +228,33 @@ public class StackBox { /** Remove this box and propagate its sibling's content up to their parent. * @return The first stackId of the resulting StackBox. */ - int removeStack() { + int remove() { + if (mStack != null) { + mDisplayContent.mStackHistory.remove(mStack); + } + mDisplayContent.layoutNeeded = true; + if (mParent == null) { + // This is the top-plane stack. mDisplayContent.removeStackBox(this); return HOME_STACK_ID; } - if (mParent.mFirst == this) { - mParent.absorb(mParent.mSecond); + + StackBox sibling = isFirstChild() ? mParent.mSecond : mParent.mFirst; + StackBox grandparent = mParent.mParent; + if (grandparent == null) { + // mParent is a top-plane stack. Now sibling will be. + mDisplayContent.removeStackBox(mParent); + mDisplayContent.addStackBox(sibling, true); } else { - mParent.absorb(mParent.mFirst); + sibling.mParent = grandparent; + if (mParent.isFirstChild()) { + grandparent.mFirst = sibling; + } else { + grandparent.mSecond = sibling; + } } - mParent.makeDirty(); - return mParent.getStackId(); + return sibling.getStackId(); } boolean resize(int stackId, float weight) { @@ -255,7 +262,7 @@ public class StackBox { return mFirst.resize(stackId, weight) || mSecond.resize(stackId, weight); } if (mStack.mStackId == stackId) { - mParent.mWeight = mParent.isFirstChild(mStack) ? weight : 1.0f - weight; + mParent.mWeight = isFirstChild() ? weight : 1.0f - weight; return true; } return false; diff --git a/services/java/com/android/server/wm/Task.java b/services/java/com/android/server/wm/Task.java index 2520f31..88eb96e 100644 --- a/services/java/com/android/server/wm/Task.java +++ b/services/java/com/android/server/wm/Task.java @@ -47,6 +47,6 @@ class Task { @Override public String toString() { - return "taskId=" + taskId + " appTokens=" + mAppTokens; + return "{taskId=" + taskId + " appTokens=" + mAppTokens + "}"; } } diff --git a/services/java/com/android/server/wm/TaskStack.java b/services/java/com/android/server/wm/TaskStack.java index 1c49e7d..590849f 100644 --- a/services/java/com/android/server/wm/TaskStack.java +++ b/services/java/com/android/server/wm/TaskStack.java @@ -92,7 +92,7 @@ public class TaskStack { } int remove() { - return mStackBox.removeStack(); + return mStackBox.remove(); } int numTokens() { @@ -109,4 +109,9 @@ public class TaskStack { pw.print(prefix); pw.println(mTasks.get(taskNdx)); } } + + @Override + public String toString() { + return "{stackId=" + mStackId + " tasks=" + mTasks + "}"; + } } diff --git a/services/java/com/android/server/wm/WindowManagerService.java b/services/java/com/android/server/wm/WindowManagerService.java index a00fb7b..da28cd8 100644 --- a/services/java/com/android/server/wm/WindowManagerService.java +++ b/services/java/com/android/server/wm/WindowManagerService.java @@ -3383,6 +3383,7 @@ public class WindowManagerService extends IWindowManager.Stub } task = new Task(atoken, stack); stack.addTask(task, true); + stack.getDisplayContent().moveStack(stack, true); mTaskIdToTask.put(taskId, task); } else { task.addAppToken(addPos, atoken); @@ -3703,6 +3704,8 @@ public class WindowManagerService extends IWindowManager.Stub Slog.w(TAG, "Attempted to set focus to non-existing app token: " + token); return; } + Task task = mTaskIdToTask.get(newFocus.groupId); + task.getDisplayContent().moveStack(task.mStack, true); changed = mFocusedApp != newFocus; mFocusedApp = newFocus; if (DEBUG_FOCUS) Slog.v(TAG, "Set focused app to: " + mFocusedApp @@ -4675,6 +4678,7 @@ public class WindowManagerService extends IWindowManager.Stub displayContent.moveHomeStackBox(true); } stack.moveTaskToTop(task); + displayContent.moveStack(stack, true); moveTaskWindowsLocked(task); } } finally { @@ -4694,6 +4698,7 @@ public class WindowManagerService extends IWindowManager.Stub } task.mStack.moveTaskToBottom(task); moveTaskWindowsLocked(task); + task.getDisplayContent().moveStack(task.mStack, false); } } finally { Binder.restoreCallingIdentity(origId); @@ -4721,15 +4726,22 @@ public class WindowManagerService extends IWindowManager.Stub "createStack: weight must be between " + STACK_WEIGHT_MIN + " and " + STACK_WEIGHT_MAX + ", weight=" + weight); } - final TaskStack relativeStack = mStackIdToStack.get(relativeStackId); - DisplayContent displayContent = relativeStack != null ? - relativeStack.getDisplayContent() : getDefaultDisplayContentLocked(); - TaskStack stack = displayContent.createStack(stackId, relativeStackId, position, - weight); - if (stack != null) { - mStackIdToStack.put(stackId, stack); - performLayoutAndPlaceSurfacesLocked(); + final DisplayContent displayContent; + if (stackId != HOME_STACK_ID) { + // TODO: What to do for the first stack on a non-default display? + final TaskStack relativeStack = mStackIdToStack.get(relativeStackId); + if (relativeStack == null) { + throw new IllegalArgumentException("createStack: Invalid relativeStackId=" + + relativeStackId); + } + displayContent = relativeStack.getDisplayContent(); + } else { + displayContent = getDefaultDisplayContentLocked(); } + TaskStack stack = + displayContent.createStack(stackId, relativeStackId, position, weight); + mStackIdToStack.put(stackId, stack); + displayContent.moveStack(stack, true); } } @@ -4748,10 +4760,15 @@ public class WindowManagerService extends IWindowManager.Stub public void moveTaskToStack(int taskId, int stackId, boolean toTop) { synchronized (mWindowMap) { Task task = mTaskIdToTask.get(taskId); + if (task == null) { + return; + } task.mStack.removeTask(task); - TaskStack newStack = mStackIdToStack.get(stackId); - newStack.addTask(task, toTop); - newStack.getDisplayContent().layoutNeeded = true; + + TaskStack stack = mStackIdToStack.get(stackId); + stack.addTask(task, toTop); + stack.getDisplayContent().layoutNeeded = true; + performLayoutAndPlaceSurfacesLocked(); } } diff --git a/services/java/com/android/server/wm/WindowState.java b/services/java/com/android/server/wm/WindowState.java index 8be424b..905f55d 100644 --- a/services/java/com/android/server/wm/WindowState.java +++ b/services/java/com/android/server/wm/WindowState.java @@ -442,8 +442,7 @@ final class WindowState implements WindowManagerPolicy.WindowState { final int type = mAttrs.type; if (mAppToken != null) { - StackBox stack = mService.mTaskIdToTask.get(mAppToken.groupId).mStack.mStackBox; - mContainingFrame.set(stack.mBounds); + mContainingFrame.set(getStackBounds()); } else { mContainingFrame.set(pf); } @@ -704,6 +703,14 @@ final class WindowState implements WindowManagerPolicy.WindowState { return null; } + Rect getStackBounds() { + TaskStack stack = getStack(); + if (stack != null) { + return stack.mStackBox.mBounds; + } + return mFrame; + } + public long getInputDispatchingTimeoutNanos() { return mAppToken != null ? mAppToken.inputDispatchingTimeoutNanos |