Refactor and improve window layering. (92e432c3) · Commits · e / os / android_frameworks_base

core/java/android/app/ActivityManager.java

+0 −8

Original line number	Diff line number	Diff line
		@@ -556,14 +556,6 @@ public class ActivityManager {
		public static boolean isAlwaysOnTop(int stackId) {
		return stackId == PINNED_STACK_ID;
		}

		/**
		* Returns true if the application windows in this stack should be displayed above all
		* other application windows, including during the animation.
		*/
		public static boolean shouldIncreaseApplicationWindowLayer(int stackId) {
		return stackId == PINNED_STACK_ID \|\| stackId == DOCKED_STACK_ID;
		}
		}

		/**

services/core/java/com/android/server/wm/AppWindowAnimator.java

+1 −1

Original line number	Diff line number	Diff line
		@@ -223,7 +223,7 @@ public class AppWindowAnimator {
		}
		if (DEBUG_LAYERS) Slog.v(TAG, "Updating layer " + w + ": " + winAnimator.mAnimLayer);
		if (w == mService.mInputMethodTarget && !mService.mInputMethodTargetWaitingAnim) {
		mService.setInputMethodAnimLayerAdjustment(adj);
		mService.mLayersController.setInputMethodAnimLayerAdjustment(adj);
		}
		wallpaperController.setAnimLayerAdjustment(w, adj);
		}

services/core/java/com/android/server/wm/WindowLayersController.java

0 → 100644

+202 −0

Original line number	Diff line number	Diff line
		package com.android.server.wm;

		import static android.view.WindowManager.LayoutParams.TYPE_DOCK_DIVIDER;
		import static com.android.server.wm.WindowManagerDebugConfig.DEBUG_LAYERS;
		import static com.android.server.wm.WindowManagerDebugConfig.TAG_WM;
		import static com.android.server.wm.WindowManagerService.WINDOW_LAYER_MULTIPLIER;

		import android.app.ActivityManager.StackId;
		import android.util.Slog;
		import android.view.Display;

		import java.io.PrintWriter;

		/**
		* Controller for assigning layers to windows on the display.
		*
		* This class encapsulates general algorithm for assigning layers and special rules that we need to
		* apply on top. The general algorithm goes through windows from bottom to the top and the higher
		* the window is, the higher layer is assigned. The final layer is equal to base layer +
		* adjustment from the order. This means that the window list is assumed to be ordered roughly by
		* the base layer (there are exceptions, e.g. due to keyguard and wallpaper and they need to be
		* handled with care, because they break the algorithm).
		*
		* On top of the general algorithm we add special rules, that govern such amazing things as:
		* <li>IME (which has higher base layer, but will be positioned above application windows)</li>
		* <li>docked/pinned windows (that need to be lifted above other application windows, including
		* animations)
		* <li>dock divider (which needs to live above applications, but below IME)</li>
		* <li>replaced windows, which need to live above their normal level, because they anticipate
		* an animation</li>.
		*/
		public class WindowLayersController {
		private final WindowManagerService mService;

		private int mInputMethodAnimLayerAdjustment;

		public WindowLayersController(WindowManagerService service) {
		mService = service;
		}

		private int mHighestApplicationLayer = 0;
		private WindowState mPinnedWindow = null;
		private WindowState mDockedWindow = null;
		private WindowState mDockDivider = null;
		private WindowState mImeWindow = null;
		private WindowState mReplacingWindow = null;

		final void assignLayersLocked(WindowList windows) {
		if (DEBUG_LAYERS) Slog.v(TAG_WM, "Assigning layers based on windows=" + windows,
		new RuntimeException("here").fillInStackTrace());

		clear();
		int curBaseLayer = 0;
		int curLayer = 0;
		boolean anyLayerChanged = false;
		for (int i = 0, windowCount = windows.size(); i < windowCount; i++) {
		final WindowState w = windows.get(i);
		boolean layerChanged = false;

		int oldLayer = w.mLayer;
		if (w.mBaseLayer == curBaseLayer \|\| w.mIsImWindow \|\| (i > 0 && w.mIsWallpaper)) {
		curLayer += WINDOW_LAYER_MULTIPLIER;
		w.mLayer = curLayer;
		} else {
		curBaseLayer = curLayer = w.mBaseLayer;
		w.mLayer = curLayer;
		}
		if (w.mLayer != oldLayer) {
		layerChanged = true;
		anyLayerChanged = true;
		}

		final WindowStateAnimator winAnimator = w.mWinAnimator;
		oldLayer = winAnimator.mAnimLayer;
		winAnimator.mAnimLayer = w.mLayer + w.getAnimLayerAdjustment() +
		getSpecialWindowAnimLayerAdjustment(w);
		if (winAnimator.mAnimLayer != oldLayer) {
		layerChanged = true;
		anyLayerChanged = true;
		}

		if (w.mAppToken != null) {
		mHighestApplicationLayer = Math.max(mHighestApplicationLayer,
		winAnimator.mAnimLayer);
		}
		collectSpecialWindows(w);

		if (layerChanged) {
		w.scheduleAnimationIfDimming();
		}
		}

		adjustSpecialWindows();

		//TODO (multidisplay): Magnification is supported only for the default display.
		if (mService.mAccessibilityController != null && anyLayerChanged
		&& windows.get(windows.size() - 1).getDisplayId() == Display.DEFAULT_DISPLAY) {
		mService.mAccessibilityController.onWindowLayersChangedLocked();
		}

		if (DEBUG_LAYERS) logDebugLayers(windows);
		}

		void setInputMethodAnimLayerAdjustment(int adj) {
		if (DEBUG_LAYERS) Slog.v(TAG_WM, "Setting im layer adj to " + adj);
		mInputMethodAnimLayerAdjustment = adj;
		final WindowState imw = mService.mInputMethodWindow;
		if (imw != null) {
		imw.mWinAnimator.mAnimLayer = imw.mLayer + adj;
		if (DEBUG_LAYERS) Slog.v(TAG_WM, "IM win " + imw
		+ " anim layer: " + imw.mWinAnimator.mAnimLayer);
		for (int i = imw.mChildWindows.size() - 1; i >= 0; i--) {
		final WindowState childWindow = imw.mChildWindows.get(i);
		childWindow.mWinAnimator.mAnimLayer = childWindow.mLayer + adj;
		if (DEBUG_LAYERS) Slog.v(TAG_WM, "IM win " + childWindow
		+ " anim layer: " + childWindow.mWinAnimator.mAnimLayer);
		}
		}
		for (int i = mService.mInputMethodDialogs.size(); i >= 0; i--) {
		final WindowState dialog = mService.mInputMethodDialogs.get(i);
		dialog.mWinAnimator.mAnimLayer = dialog.mLayer + adj;
		if (DEBUG_LAYERS) Slog.v(TAG_WM, "IM win " + imw
		+ " anim layer: " + dialog.mWinAnimator.mAnimLayer);
		}
		}

		int getSpecialWindowAnimLayerAdjustment(WindowState win) {
		if (win.mIsImWindow) {
		return mInputMethodAnimLayerAdjustment;
		} else if (win.mIsWallpaper) {
		return mService.mWallpaperControllerLocked.getAnimLayerAdjustment();
		}
		return 0;
		}

		private void logDebugLayers(WindowList windows) {
		for (int i = 0, n = windows.size(); i < n; i++) {
		final WindowState w = windows.get(i);
		final WindowStateAnimator winAnimator = w.mWinAnimator;
		Slog.v(TAG_WM, "Assign layer " + w + ": " + "mBase=" + w.mBaseLayer
		+ " mLayer=" + w.mLayer + (w.mAppToken == null
		? "" : " mAppLayer=" + w.mAppToken.mAppAnimator.animLayerAdjustment)
		+ " =mAnimLayer=" + winAnimator.mAnimLayer);
		}
		}

		private void clear() {
		mHighestApplicationLayer = 0;
		mImeWindow = null;
		mPinnedWindow = null;
		mDockedWindow = null;
		mDockDivider = null;
		}

		private void collectSpecialWindows(WindowState w) {
		if (w.mIsImWindow) {
		mImeWindow = w;
		} else if (w.mAttrs.type == TYPE_DOCK_DIVIDER) {
		mDockDivider = w;
		} else {
		final TaskStack stack = w.getStack();
		if (stack.mStackId == StackId.PINNED_STACK_ID) {
		mPinnedWindow = w;
		} else if (stack.mStackId == StackId.DOCKED_STACK_ID) {
		mDockedWindow = w;
		}
		}
		}

		private void adjustSpecialWindows() {
		int layer = mHighestApplicationLayer + 1;
		// For pinned and docked stack window, we want to make them above other windows
		// also when these windows are animating.
		layer = assignAndIncreaseLayerIfNeeded(mDockedWindow, layer);
		layer = assignAndIncreaseLayerIfNeeded(mDockDivider, layer);
		// We know that we will be animating a relaunching window in the near future,
		// which will receive a z-order increase. We want the replaced window to
		// immediately receive the same treatment, e.g. to be above the dock divider.
		layer = assignAndIncreaseLayerIfNeeded(mReplacingWindow, layer);
		layer = assignAndIncreaseLayerIfNeeded(mPinnedWindow, layer);
		layer = assignAndIncreaseLayerIfNeeded(mImeWindow, layer);
		}

		private int assignAndIncreaseLayerIfNeeded(WindowState win, int layer) {
		if (win != null) {
		win.mLayer = layer;
		win.mWinAnimator.mAnimLayer = layer;
		layer++;
		}
		return layer;
		}

		void dump(PrintWriter pw, String s) {
		if (mInputMethodAnimLayerAdjustment != 0 \|\|
		mService.mWallpaperControllerLocked.getAnimLayerAdjustment() != 0) {
		pw.print(" mInputMethodAnimLayerAdjustment=");
		pw.print(mInputMethodAnimLayerAdjustment);
		pw.print(" mWallpaperAnimLayerAdjustment=");
		pw.println(mService.mWallpaperControllerLocked.getAnimLayerAdjustment());
		}
		}
		}

services/core/java/com/android/server/wm/WindowManagerService.java

+14 −142

Original line number	Diff line number	Diff line
		@@ -66,7 +66,6 @@ import static com.android.server.wm.WindowManagerDebugConfig.DEBUG_FOCUS;
		import static com.android.server.wm.WindowManagerDebugConfig.DEBUG_FOCUS_LIGHT;
		import static com.android.server.wm.WindowManagerDebugConfig.DEBUG_INPUT_METHOD;
		import static com.android.server.wm.WindowManagerDebugConfig.DEBUG_KEYGUARD;
		import static com.android.server.wm.WindowManagerDebugConfig.DEBUG_LAYERS;
		import static com.android.server.wm.WindowManagerDebugConfig.DEBUG_LAYOUT;
		import static com.android.server.wm.WindowManagerDebugConfig.DEBUG_ORIENTATION;
		import static com.android.server.wm.WindowManagerDebugConfig.DEBUG_RESIZE;
		@@ -92,7 +91,6 @@ import android.Manifest;
		import android.animation.ValueAnimator;
		import android.annotation.NonNull;
		import android.annotation.Nullable;
		import android.app.ActivityManager.StackId;
		import android.app.ActivityManagerNative;
		import android.app.AppOpsManager;
		import android.app.IActivityManager;
		@@ -566,7 +564,6 @@ public class WindowManagerService extends IWindowManager.Stub

		/** If true hold off on modifying the animation layer of mInputMethodTarget */
		boolean mInputMethodTargetWaitingAnim;
		int mInputMethodAnimLayerAdjustment;

		WindowState mInputMethodWindow = null;
		final ArrayList<WindowState> mInputMethodDialogs = new ArrayList<>();
		@@ -608,6 +605,8 @@ public class WindowManagerService extends IWindowManager.Stub

		WallpaperController mWallpaperControllerLocked;

		final WindowLayersController mLayersController;

		boolean mAnimateWallpaperWithTarget;

		AppWindowToken mFocusedApp = null;
		@@ -880,6 +879,7 @@ public class WindowManagerService extends IWindowManager.Stub

		mWallpaperControllerLocked = new WallpaperController(this);
		mWindowPlacerLocked = new WindowSurfacePlacer(this);
		mLayersController = new WindowLayersController(this);

		LocalServices.addService(WindowManagerPolicy.class, mPolicy);

		@@ -1509,9 +1509,10 @@ public class WindowManagerService extends IWindowManager.Stub
		mInputMethodTarget = w;
		mInputMethodTargetWaitingAnim = false;
		if (w.mAppToken != null) {
		setInputMethodAnimLayerAdjustment(w.mAppToken.mAppAnimator.animLayerAdjustment);
		mLayersController.setInputMethodAnimLayerAdjustment(
		w.mAppToken.mAppAnimator.animLayerAdjustment);
		} else {
		setInputMethodAnimLayerAdjustment(0);
		mLayersController.setInputMethodAnimLayerAdjustment(0);
		}
		}
		return i+1;
		@@ -1520,7 +1521,7 @@ public class WindowManagerService extends IWindowManager.Stub
		if (DEBUG_INPUT_METHOD) Slog.w(TAG_WM, "Moving IM target from " + curTarget + " to null."
		+ (HIDE_STACK_CRAWLS ? "" : " Callers=" + Debug.getCallers(4)));
		mInputMethodTarget = null;
		setInputMethodAnimLayerAdjustment(0);
		mLayersController.setInputMethodAnimLayerAdjustment(0);
		}
		return -1;
		}
		@@ -1542,33 +1543,6 @@ public class WindowManagerService extends IWindowManager.Stub
		moveInputMethodDialogsLocked(pos);
		}

		void setInputMethodAnimLayerAdjustment(int adj) {
		if (DEBUG_LAYERS) Slog.v(TAG_WM, "Setting im layer adj to " + adj);
		mInputMethodAnimLayerAdjustment = adj;
		WindowState imw = mInputMethodWindow;
		if (imw != null) {
		imw.mWinAnimator.mAnimLayer = imw.mLayer + adj;
		if (DEBUG_LAYERS) Slog.v(TAG_WM, "IM win " + imw
		+ " anim layer: " + imw.mWinAnimator.mAnimLayer);
		int wi = imw.mChildWindows.size();
		while (wi > 0) {
		wi--;
		WindowState cw = imw.mChildWindows.get(wi);
		cw.mWinAnimator.mAnimLayer = cw.mLayer + adj;
		if (DEBUG_LAYERS) Slog.v(TAG_WM, "IM win " + cw
		+ " anim layer: " + cw.mWinAnimator.mAnimLayer);
		}
		}
		int di = mInputMethodDialogs.size();
		while (di > 0) {
		di --;
		imw = mInputMethodDialogs.get(di);
		imw.mWinAnimator.mAnimLayer = imw.mLayer + adj;
		if (DEBUG_LAYERS) Slog.v(TAG_WM, "IM win " + imw
		+ " anim layer: " + imw.mWinAnimator.mAnimLayer);
		}
		}

		private int tmpRemoveWindowLocked(int interestingPos, WindowState win) {
		WindowList windows = win.getWindowList();
		int wpos = windows.indexOf(win);
		@@ -1767,7 +1741,7 @@ public class WindowManagerService extends IWindowManager.Stub
		}

		if (needAssignLayers) {
		assignLayersLocked(windows);
		mLayersController.assignLayersLocked(windows);
		}

		return true;
		@@ -2059,7 +2033,7 @@ public class WindowManagerService extends IWindowManager.Stub
		moveInputMethodWindowsIfNeededLocked(false);
		}

		assignLayersLocked(displayContent.getWindowList());
		mLayersController.assignLayersLocked(displayContent.getWindowList());
		// Don't do layout here, the window must call
		// relayout to be displayed, so we'll do it there.

		@@ -2386,7 +2360,7 @@ public class WindowManagerService extends IWindowManager.Stub
		if (windows != null) {
		windows.remove(win);
		if (!mWindowPlacerLocked.isInLayout()) {
		assignLayersLocked(windows);
		mLayersController.assignLayersLocked(windows);
		win.setDisplayLayoutNeeded();
		mWindowPlacerLocked.performSurfacePlacement();
		if (win.mAppToken != null) {
		@@ -2741,7 +2715,7 @@ public class WindowManagerService extends IWindowManager.Stub
		// its layer recomputed. However, if the IME was hidden
		// and isn't actually moved in the list, its layer may be
		// out of data so we make sure to recompute it.
		assignLayersLocked(win.getWindowList());
		mLayersController.assignLayersLocked(win.getWindowList());
		}

		if (wallpaperMayMove) {
		@@ -4584,7 +4558,7 @@ public class WindowManagerService extends IWindowManager.Stub

		if (!updateFocusedWindowLocked(UPDATE_FOCUS_WILL_PLACE_SURFACES,
		false /updateInputWindows/)) {
		assignLayersLocked(displayContent.getWindowList());
		mLayersController.assignLayersLocked(displayContent.getWindowList());
		}

		mInputMonitor.setUpdateInputWindowsNeededLw();
		@@ -8660,102 +8634,6 @@ public class WindowManagerService extends IWindowManager.Stub
		Arrays.fill(mRebuildTmp, null);
		}

		final void assignLayersLocked(WindowList windows) {
		int N = windows.size();
		int curBaseLayer = 0;
		int curLayer = 0;
		int i;

		if (DEBUG_LAYERS) Slog.v(TAG_WM, "Assigning layers based on windows=" + windows,
		new RuntimeException("here").fillInStackTrace());

		boolean anyLayerChanged = false;

		for (i=0; i<N; i++) {
		final WindowState w = windows.get(i);
		final WindowStateAnimator winAnimator = w.mWinAnimator;
		boolean layerChanged = false;
		int oldLayer = w.mLayer;
		if (w.mBaseLayer == curBaseLayer \|\| w.mIsImWindow \|\| (i > 0 && w.mIsWallpaper)) {
		curLayer += WINDOW_LAYER_MULTIPLIER;
		w.mLayer = curLayer;
		} else {
		curBaseLayer = curLayer = w.mBaseLayer;
		w.mLayer = curLayer;
		}
		if (w.mLayer != oldLayer) {
		layerChanged = true;
		anyLayerChanged = true;
		}
		final AppWindowToken wtoken = w.mAppToken;
		oldLayer = winAnimator.mAnimLayer;
		if (w.mTargetAppToken != null) {
		winAnimator.mAnimLayer =
		w.mLayer + w.mTargetAppToken.mAppAnimator.animLayerAdjustment;
		} else if (wtoken != null) {
		winAnimator.mAnimLayer =
		w.mLayer + wtoken.mAppAnimator.animLayerAdjustment;
		forceHigherLayerIfNeeded(w, winAnimator, wtoken);
		} else {
		winAnimator.mAnimLayer = w.mLayer;
		}
		if (w.mIsImWindow) {
		winAnimator.mAnimLayer += mInputMethodAnimLayerAdjustment;
		} else if (w.mIsWallpaper) {
		winAnimator.mAnimLayer += mWallpaperControllerLocked.getAnimLayerAdjustment();
		}
		if (winAnimator.mAnimLayer != oldLayer) {
		layerChanged = true;
		anyLayerChanged = true;
		}
		final DimLayer.DimLayerUser dimLayerUser = w.getDimLayerUser();
		final DisplayContent displayContent = w.getDisplayContent();
		if (layerChanged && dimLayerUser != null && displayContent != null &&
		displayContent.mDimLayerController.isDimming(dimLayerUser, winAnimator)) {
		// Force an animation pass just to update the mDimLayer layer.
		scheduleAnimationLocked();
		}
		if (DEBUG_LAYERS) Slog.v(TAG_WM, "Assign layer " + w + ": "
		+ "mBase=" + w.mBaseLayer
		+ " mLayer=" + w.mLayer
		+ (wtoken == null ?
		"" : " mAppLayer=" + wtoken.mAppAnimator.animLayerAdjustment)
		+ " =mAnimLayer=" + winAnimator.mAnimLayer);
		//System.out.println(
		// "Assigned layer " + curLayer + " to " + w.mClient.asBinder());
		}

		//TODO (multidisplay): Magnification is supported only for the default display.
		if (mAccessibilityController != null && anyLayerChanged
		&& windows.get(windows.size() - 1).getDisplayId() == Display.DEFAULT_DISPLAY) {
		mAccessibilityController.onWindowLayersChangedLocked();
		}
		}

		private void forceHigherLayerIfNeeded(WindowState w, WindowStateAnimator winAnimator,
		AppWindowToken wtoken) {
		boolean force = false;

		if (w.mWillReplaceWindow) {
		// We know that we will be animating a relaunching window in the near future,
		// which will receive a z-order increase. We want the replaced window to
		// immediately receive the same treatment, e.g. to be above the dock divider.
		force = true;
		}
		if (!force) {
		final TaskStack stack = w.getStack();
		if (stack != null && (StackId.shouldIncreaseApplicationWindowLayer(stack.mStackId))) {
		// For pinned and docked stack window, we want to make them above other windows
		// also when these windows are animating.
		force = true;
		}
		}
		if (force) {
		w.mLayer += TYPE_LAYER_OFFSET;
		winAnimator.mAnimLayer += TYPE_LAYER_OFFSET;
		}
		}

		void makeWindowFreezingScreenIfNeededLocked(WindowState w) {
		// If the screen is currently frozen or off, then keep
		// it frozen/off until this window draws at its new
		@@ -9126,7 +9004,7 @@ public class WindowManagerService extends IWindowManager.Stub
		} else if (mode == UPDATE_FOCUS_WILL_PLACE_SURFACES) {
		// Client will do the layout, but we need to assign layers
		// for handleNewWindowLocked() below.
		assignLayersLocked(displayContent.getWindowList());
		mLayersController.assignLayersLocked(displayContent.getWindowList());
		}
		}

		@@ -9814,13 +9692,7 @@ public class WindowManagerService extends IWindowManager.Stub
		}
		mWindowPlacerLocked.dump(pw, " ");
		mWallpaperControllerLocked.dump(pw, " ");
		if (mInputMethodAnimLayerAdjustment != 0 \|\|
		mWallpaperControllerLocked.getAnimLayerAdjustment() != 0) {
		pw.print(" mInputMethodAnimLayerAdjustment=");
		pw.print(mInputMethodAnimLayerAdjustment);
		pw.print(" mWallpaperAnimLayerAdjustment=");
		pw.println(mWallpaperControllerLocked.getAnimLayerAdjustment());
		}
		mLayersController.dump(pw, " ");
		pw.print(" mSystemBooted="); pw.print(mSystemBooted);
		pw.print(" mDisplayEnabled="); pw.println(mDisplayEnabled);
		if (needsLayout()) {

services/core/java/com/android/server/wm/WindowState.java

+23 −0

Original line number	Diff line number	Diff line
		@@ -1273,6 +1273,29 @@ final class WindowState implements WindowManagerPolicy.WindowState {
		mHasSurface = hasSurface;
		}

		int getAnimLayerAdjustment() {
		if (mTargetAppToken != null) {
		return mTargetAppToken.mAppAnimator.animLayerAdjustment;
		} else if (mAppToken != null) {
		return mAppToken.mAppAnimator.animLayerAdjustment;
		} else {
		// Nothing is animating, so there is no animation adjustment.
		return 0;
		}
		}

		void scheduleAnimationIfDimming() {
		if (mDisplayContent == null) {
		return;
		}
		final DimLayer.DimLayerUser dimLayerUser = getDimLayerUser();
		if (dimLayerUser != null && mDisplayContent.mDimLayerController.isDimming(
		dimLayerUser, mWinAnimator)) {
		// Force an animation pass just to update the mDimLayer layer.
		mService.scheduleAnimationLocked();
		}
		}

		private final class DeadWindowEventReceiver extends InputEventReceiver {
		DeadWindowEventReceiver(InputChannel inputChannel) {
		super(inputChannel, mService.mH.getLooper());