Merge "Clean up unnecessary interfaces of WindowManagerPolicy" (4c2e2872) · Commits · e / os / android_frameworks_base

services/core/java/com/android/server/policy/PhoneWindowManager.java

+0 −14

Original line number	Diff line number	Diff line
		@@ -2218,11 +2218,6 @@ public class PhoneWindowManager implements WindowManagerPolicy {
		}
		}

		@Override
		public int getMaxWallpaperLayer() {
		return getWindowLayerFromTypeLw(TYPE_NOTIFICATION_SHADE);
		}

		@Override
		public boolean isKeyguardHostWindow(WindowManager.LayoutParams attrs) {
		return attrs.type == TYPE_NOTIFICATION_SHADE;
		@@ -5323,15 +5318,6 @@ public class PhoneWindowManager implements WindowManagerPolicy {
		mKeyguardDelegate.setSwitchingUser(switching);
		}

		@Override
		public boolean isTopLevelWindow(int windowType) {
		if (windowType >= WindowManager.LayoutParams.FIRST_SUB_WINDOW
		&& windowType <= WindowManager.LayoutParams.LAST_SUB_WINDOW) {
		return (windowType == WindowManager.LayoutParams.TYPE_APPLICATION_ATTACHED_DIALOG);
		}
		return true;
		}

		@Override
		public void dumpDebug(ProtoOutputStream proto, long fieldId) {
		final long token = proto.start(fieldId);

services/core/java/com/android/server/policy/WindowManagerPolicy.java

+0 −246

Original line number	Diff line number	Diff line
		@@ -67,7 +67,6 @@ import static java.lang.annotation.RetentionPolicy.SOURCE;
		import android.annotation.IntDef;
		import android.annotation.NonNull;
		import android.annotation.Nullable;
		import android.app.WindowConfiguration;
		import android.content.Context;
		import android.content.res.CompatibilityInfo;
		import android.content.res.Configuration;
		@@ -90,7 +89,6 @@ import android.view.animation.Animation;
		import com.android.internal.policy.IKeyguardDismissCallback;
		import com.android.internal.policy.IShortcutService;
		import com.android.server.wm.DisplayRotation;
		import com.android.server.wm.WindowFrames;

		import java.io.PrintWriter;
		import java.lang.annotation.Retention;
		@@ -180,92 +178,11 @@ public interface WindowManagerPolicy extends WindowManagerPolicyConstants {
		* to prepareAddWindow() until removeWindow().
		*/
		public interface WindowState {
		/**
		* Return the uid of the app that owns this window.
		*/
		int getOwningUid();

		/**
		* Return the package name of the app that owns this window.
		*/
		String getOwningPackage();

		/**
		* Perform standard frame computation. The result can be obtained with
		* getFrame() if so desired. Must be called with the window manager
		* lock held.
		*
		*/
		public void computeFrameLw();

		/**
		* Retrieve the current frame of the window that has been assigned by
		* the window manager. Must be called with the window manager lock held.
		*
		* @return Rect The rectangle holding the window frame.
		*/
		public Rect getFrameLw();

		/**
		* Retrieve the frame of the display that this window was last
		* laid out in. Must be called with the
		* window manager lock held.
		*
		* @return Rect The rectangle holding the display frame.
		*/
		public Rect getDisplayFrameLw();

		/**
		* Retrieve the frame of the content area that this window was last
		* laid out in. This is the area in which the content of the window
		* should be placed. It will be smaller than the display frame to
		* account for screen decorations such as a status bar or soft
		* keyboard. Must be called with the
		* window manager lock held.
		*
		* @return Rect The rectangle holding the content frame.
		*/
		public Rect getContentFrameLw();

		/**
		* Retrieve the frame of the visible area that this window was last
		* laid out in. This is the area of the screen in which the window
		* will actually be fully visible. It will be smaller than the
		* content frame to account for transient UI elements blocking it
		* such as an input method's candidates UI. Must be called with the
		* window manager lock held.
		*
		* @return Rect The rectangle holding the visible frame.
		*/
		public Rect getVisibleFrameLw();

		/**
		* Returns true if this window is waiting to receive its given
		* internal insets from the client app, and so should not impact the
		* layout of other windows.
		*/
		public boolean getGivenInsetsPendingLw();

		/**
		* Retrieve the insets given by this window's client for the content
		* area of windows behind it. Must be called with the
		* window manager lock held.
		*
		* @return Rect The left, top, right, and bottom insets, relative
		* to the window's frame, of the actual contents.
		*/
		public Rect getGivenContentInsetsLw();

		/**
		* Retrieve the insets given by this window's client for the visible
		* area of windows behind it. Must be called with the
		* window manager lock held.
		*
		* @return Rect The left, top, right, and bottom insets, relative
		* to the window's frame, of the actual visible area.
		*/
		public Rect getGivenVisibleInsetsLw();

		/**
		* Retrieve the current LayoutParams of the window.
		*
		@@ -274,17 +191,6 @@ public interface WindowManagerPolicy extends WindowManagerPolicyConstants {
		*/
		public WindowManager.LayoutParams getAttrs();

		/**
		* Retrieve the current system UI visibility flags associated with
		* this window.
		*/
		public int getSystemUiVisibility();

		/**
		* Get the layer at which this window's surface will be Z-ordered.
		*/
		public int getSurfaceLayer();

		/**
		* Retrieve the type of the top-level window.
		*
		@@ -300,22 +206,6 @@ public interface WindowManagerPolicy extends WindowManagerPolicyConstants {
		*/
		public IApplicationToken getAppToken();

		/**
		* Return true if this window is participating in voice interaction.
		*/
		public boolean isVoiceInteraction();

		/**
		* Return true if, at any point, the application token associated with
		* this window has actually displayed any windows. This is most useful
		* with the "starting up" window to determine if any windows were
		* displayed when it is closed.
		*
		* @return Returns true if one or more windows have been displayed,
		* else false.
		*/
		public boolean hasAppShownWindows();

		/**
		* Is this window visible? It is not visible if there is no
		* surface, or we are in the process of running an exit animation
		@@ -323,42 +213,12 @@ public interface WindowManagerPolicy extends WindowManagerPolicyConstants {
		*/
		boolean isVisibleLw();

		/**
		* Is this window currently visible to the user on-screen? It is
		* displayed either if it is visible or it is currently running an
		* animation before no longer being visible. Must be called with the
		* window manager lock held.
		*/
		boolean isDisplayedLw();

		/**
		* Return true if this window (or a window it is attached to, but not
		* considering its app token) is currently animating.
		*/
		boolean isAnimatingLw();

		/**
		* Is this window considered to be gone for purposes of layout?
		*/
		boolean isGoneForLayoutLw();

		/**
		* Returns true if the window has a surface that it has drawn a
		* complete UI in to. Note that this is different from {@link #hasDrawnLw()}
		* in that it also returns true if the window is READY_TO_SHOW, but was not yet
		* promoted to HAS_DRAWN.
		*/
		boolean isDrawnLw();

		/**
		* Returns true if this window has been shown on screen at some time in
		* the past. Must be called with the window manager lock held.
		*
		* @deprecated Use {@link #isDrawnLw} or any of the other drawn/visibility methods.
		*/
		@Deprecated
		public boolean hasDrawnLw();

		/**
		* Can be called by the policy to force a window to be hidden,
		* regardless of whether the client or window manager would like
		@@ -376,52 +236,13 @@ public interface WindowManagerPolicy extends WindowManagerPolicyConstants {
		*/
		public boolean showLw(boolean doAnimation);

		/**
		* Check whether the process hosting this window is currently alive.
		*/
		public boolean isAlive();

		/**
		* Check if window is on {@link Display#DEFAULT_DISPLAY}.
		* @return true if window is on default display.
		*/
		public boolean isDefaultDisplay();

		/**
		* Check whether the window is currently dimming.
		*/
		public boolean isDimming();

		/**
		* Returns true if the window is letterboxed for the display cutout.
		*/
		default boolean isLetterboxedForDisplayCutoutLw() {
		return false;
		}

		/** @return the current windowing mode of this window. */
		int getWindowingMode();

		/**
		* Returns the {@link WindowConfiguration.ActivityType} associated with the configuration
		* of this window.
		*/
		default int getActivityType() {
		return WindowConfiguration.WINDOWING_MODE_UNDEFINED;
		}

		/**
		* Returns true if the window is current in multi-windowing mode. i.e. it shares the
		* screen with other application windows.
		*/
		boolean inMultiWindowMode();

		public int getRotationAnimationHint();

		public boolean isInputMethodWindow();

		public boolean isInputMethodTarget();

		public int getDisplayId();

		/**
		@@ -432,42 +253,8 @@ public interface WindowManagerPolicy extends WindowManagerPolicyConstants {
		return false;
		}

		/**
		* Returns true if the window owner has the permission to acquire a sleep token when it's
		* visible. That is, they have the permission {@link Manifest.permission#DEVICE_POWER}.
		*/
		boolean canAcquireSleepToken();

		/** @return true if this window desires key events. */
		boolean canReceiveKeys();

		/** @return true if the window can show over keyguard. */
		boolean canShowWhenLocked();

		/**
		* Writes {@link com.android.server.wm.IdentifierProto} to stream.
		*/
		void writeIdentifierToProto(ProtoOutputStream proto, long fieldId);

		/**
		* @return The {@link WindowFrames} associated with this {@link WindowState}
		*/
		WindowFrames getWindowFrames();
		}

		/**
		* Representation of a input consumer that the policy has added to the
		* window manager to consume input events going to windows below it.
		*/
		public interface InputConsumer {
		/**
		* Remove the input consumer from the window manager.
		*/
		void dismiss();
		/**
		* Dispose the input consumer and input receiver from UI thread.
		*/
		void dispose();
		}

		/**
		@@ -537,11 +324,6 @@ public interface WindowManagerPolicy extends WindowManagerPolicyConstants {
		/** Unregister a system listener for touch events */
		void unregisterPointerEventListener(PointerEventListener listener, int displayId);

		/**
		* @return The currently active input method window.
		*/
		WindowState getInputMethodWindowLw();

		/**
		* Notifies window manager that {@link #isKeyguardTrustedLw} has changed.
		*/
		@@ -614,17 +396,6 @@ public interface WindowManagerPolicy extends WindowManagerPolicyConstants {
		void moveDisplayToTop(int displayId);
		}

		/**
		* Provides the rotation of a device.
		*
		* @see com.android.server.policy.WindowOrientationListener
		*/
		public interface RotationSource {
		int getProposedRotation();

		void setCurrentRotation(int rotation);
		}

		/**
		* Interface to get public information of a display content.
		*/
		@@ -888,12 +659,6 @@ public interface WindowManagerPolicy extends WindowManagerPolicyConstants {
		return 0;
		}

		/**
		* Get the highest layer (actually one more than) that the wallpaper is
		* allowed to be in.
		*/
		public int getMaxWallpaperLayer();

		/**
		* Return whether the given window can become the Keyguard window. Typically returns true for
		* the StatusBar.
		@@ -1383,17 +1148,6 @@ public interface WindowManagerPolicy extends WindowManagerPolicyConstants {
		*/
		void dumpDebug(ProtoOutputStream proto, long fieldId);

		/**
		* Returns whether a given window type is considered a top level one.
		* A top level window does not have a container, i.e. attached window,
		* or if it has a container it is laid out as a top-level window, not
		* as a child of its container.
		*
		* @param windowType The window type.
		* @return True if the window is a top level one.
		*/
		public boolean isTopLevelWindow(int windowType);

		/**
		* Notifies the keyguard to start fading out.
		*

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

+6 −6

Original line number	Diff line number	Diff line
		@@ -700,8 +700,8 @@ final class AccessibilityController {
		touchableRegion.getBounds(touchableFrame);
		RectF windowFrame = mTempRectF;
		windowFrame.set(touchableFrame);
		windowFrame.offset(-windowState.getFrameLw().left,
		-windowState.getFrameLw().top);
		windowFrame.offset(-windowState.getFrame().left,
		-windowState.getFrame().top);
		matrix.mapRect(windowFrame);
		Region windowBounds = mTempRegion2;
		windowBounds.set((int) windowFrame.left, (int) windowFrame.top,
		@@ -730,7 +730,7 @@ final class AccessibilityController {
		}

		// Count letterbox into nonMagnifiedBounds
		if (windowState.isLetterboxedForDisplayCutoutLw()) {
		if (windowState.isLetterboxedForDisplayCutout()) {
		Region letterboxBounds = getLetterboxBounds(windowState);
		nonMagnifiedBounds.op(letterboxBounds, Region.Op.UNION);
		availableBounds.op(letterboxBounds, Region.Op.DIFFERENCE);
		@@ -1429,11 +1429,11 @@ final class AccessibilityController {
		// Account for all space in the task, whether the windows in it are
		// touchable or not. The modal window blocks all touches from the task's
		// area.
		unaccountedSpace.op(windowState.getDisplayFrameLw(), unaccountedSpace,
		unaccountedSpace.op(windowState.getDisplayFrame(), unaccountedSpace,
		Region.Op.REVERSE_DIFFERENCE);
		} else {
		// If a window has tap exclude region, we need to account it.
		final Region displayRegion = new Region(windowState.getDisplayFrameLw());
		final Region displayRegion = new Region(windowState.getDisplayFrame());
		final Region tapExcludeRegion = new Region();
		windowState.getTapExcludeRegion(tapExcludeRegion);
		displayRegion.op(tapExcludeRegion, displayRegion,
		@@ -1470,7 +1470,7 @@ final class AccessibilityController {
		// Move to origin as all transforms are captured by the matrix.
		RectF windowFrame = mTempRectF;
		windowFrame.set(rect);
		windowFrame.offset(-windowState.getFrameLw().left, -windowState.getFrameLw().top);
		windowFrame.offset(-windowState.getFrame().left, -windowState.getFrame().top);

		matrix.mapRect(windowFrame);

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

+9 −9

Original line number	Diff line number	Diff line
		@@ -1334,7 +1334,7 @@ final class ActivityRecord extends WindowToken implements WindowManagerService.A
		if (w == null \|\| winHint != null && w != winHint) {
		return;
		}
		final boolean surfaceReady = w.isDrawnLw() // Regular case
		final boolean surfaceReady = w.isDrawn() // Regular case
		\|\| w.mWinAnimator.mSurfaceDestroyDeferred // The preserved surface is still ready.
		\|\| w.isDragResizeChanged(); // Waiting for relayoutWindow to call preserveSurface.
		final boolean needsLetterbox = surfaceReady && w.isLetterboxedAppWindow() && fillsParent();
		@@ -1355,7 +1355,7 @@ final class ActivityRecord extends WindowToken implements WindowManagerService.A
		: inMultiWindowMode()
		? task.getBounds()
		: getRootTask().getParent().getBounds();
		mLetterbox.layout(spaceToFill, w.getFrameLw(), mTmpPoint);
		mLetterbox.layout(spaceToFill, w.getFrame(), mTmpPoint);
		} else if (mLetterbox != null) {
		mLetterbox.hide();
		}
		@@ -4296,7 +4296,7 @@ final class ActivityRecord extends WindowToken implements WindowManagerService.A
		} else {
		// If we are being set visible, and the starting window is not yet displayed,
		// then make sure it doesn't get displayed.
		if (startingWindow != null && !startingWindow.isDrawnLw()) {
		if (startingWindow != null && !startingWindow.isDrawn()) {
		startingWindow.clearPolicyVisibilityFlag(LEGACY_POLICY_VISIBILITY);
		startingWindow.mLegacyPolicyVisibilityAfterAnim = false;
		}
		@@ -5596,9 +5596,9 @@ final class ActivityRecord extends WindowToken implements WindowManagerService.A
		if (DEBUG_VISIBILITY \|\| WM_DEBUG_ORIENTATION.isLogToLogcat()) {
		final boolean isAnimationSet = isAnimating(TRANSITION \| PARENTS,
		ANIMATION_TYPE_APP_TRANSITION);
		Slog.v(TAG, "Eval win " + w + ": isDrawn=" + w.isDrawnLw()
		Slog.v(TAG, "Eval win " + w + ": isDrawn=" + w.isDrawn()
		+ ", isAnimationSet=" + isAnimationSet);
		if (!w.isDrawnLw()) {
		if (!w.isDrawn()) {
		Slog.v(TAG, "Not displayed: s=" + winAnimator.mSurfaceController
		+ " pv=" + w.isVisibleByPolicy()
		+ " mDrawState=" + winAnimator.drawStateToString()
		@@ -5613,7 +5613,7 @@ final class ActivityRecord extends WindowToken implements WindowManagerService.A
		if (findMainWindow(false /* includeStartingApp */) != w) {
		mNumInterestingWindows++;
		}
		if (w.isDrawnLw()) {
		if (w.isDrawn()) {
		mNumDrawnWindows++;

		if (DEBUG_VISIBILITY \|\| WM_DEBUG_ORIENTATION.isLogToLogcat()) {
		@@ -5626,7 +5626,7 @@ final class ActivityRecord extends WindowToken implements WindowManagerService.A
		isInterestingAndDrawn = true;
		}
		}
		} else if (w.isDrawnLw()) {
		} else if (w.isDrawn()) {
		// The starting window for this container is drawn.
		mStackSupervisor.getActivityMetricsLogger().notifyStartingWindowDrawn(this);
		startingDisplayed = true;
		@@ -6155,7 +6155,7 @@ final class ActivityRecord extends WindowToken implements WindowManagerService.A
		if (win == null) {
		return;
		}
		final Rect frame = win.getRelativeFrameLw();
		final Rect frame = win.getRelativeFrame();
		final int thumbnailDrawableRes = task.mUserId == mWmService.mCurrentUserId
		? R.drawable.ic_account_circle
		: R.drawable.ic_corp_badge;
		@@ -6181,7 +6181,7 @@ final class ActivityRecord extends WindowToken implements WindowManagerService.A
		// destination of the thumbnail header animation. If this is a full screen
		// window scenario, we use the whole display as the target.
		WindowState win = findMainWindow();
		Rect appRect = win != null ? win.getContentFrameLw() :
		final Rect appRect = win != null ? win.getContentFrame() :
		new Rect(0, 0, displayInfo.appWidth, displayInfo.appHeight);
		final Rect insets = win != null ? win.getContentInsets() : null;
		final Configuration displayConfig = mDisplayContent.getConfiguration();

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

+4 −4

Original line number	Diff line number	Diff line
		@@ -222,12 +222,12 @@ public class BarController {
		}

		protected boolean skipAnimation() {
		return !mWin.isDrawnLw();
		return !mWin.isDrawn();
		}

		private @StatusBarManager.WindowVisibleState int computeStateLw(
		boolean wasVis, boolean wasAnim, WindowState win, boolean change) {
		if (win.isDrawnLw()) {
		if (win.isDrawn()) {
		final boolean vis = win.isVisibleLw();
		final boolean anim = win.isAnimatingLw();
		if (mState == StatusBarManager.WINDOW_STATE_HIDING && !change && !vis) {
		@@ -264,7 +264,7 @@ public class BarController {
		}

		boolean checkHiddenLw() {
		if (mWin != null && mWin.isDrawnLw()) {
		if (mWin != null && mWin.isDrawn()) {
		if (!mWin.isVisibleLw() && !mWin.isAnimatingLw()) {
		updateStateLw(StatusBarManager.WINDOW_STATE_HIDDEN);
		}
		@@ -291,7 +291,7 @@ public class BarController {
		} else if (mWin == null) {
		if (DEBUG) Slog.d(mTag, "Not showing transient bar, bar doesn't exist");
		return false;
		} else if (mWin.isDisplayedLw()) {
		} else if (mWin.isDisplayed()) {
		if (DEBUG) Slog.d(mTag, "Not showing transient bar, bar already visible");
		return false;
		} else {