/*
|
* Copyright (C) 2018 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 com.android.server.wm.WindowFramesProto.CONTAINING_FRAME;
|
import static com.android.server.wm.WindowFramesProto.CONTENT_FRAME;
|
import static com.android.server.wm.WindowFramesProto.CONTENT_INSETS;
|
import static com.android.server.wm.WindowFramesProto.CUTOUT;
|
import static com.android.server.wm.WindowFramesProto.DECOR_FRAME;
|
import static com.android.server.wm.WindowFramesProto.DISPLAY_FRAME;
|
import static com.android.server.wm.WindowFramesProto.FRAME;
|
import static com.android.server.wm.WindowFramesProto.OUTSETS;
|
import static com.android.server.wm.WindowFramesProto.OUTSET_FRAME;
|
import static com.android.server.wm.WindowFramesProto.OVERSCAN_FRAME;
|
import static com.android.server.wm.WindowFramesProto.OVERSCAN_INSETS;
|
import static com.android.server.wm.WindowFramesProto.PARENT_FRAME;
|
import static com.android.server.wm.WindowFramesProto.STABLE_INSETS;
|
import static com.android.server.wm.WindowFramesProto.VISIBLE_FRAME;
|
import static com.android.server.wm.WindowFramesProto.VISIBLE_INSETS;
|
|
import android.annotation.NonNull;
|
import android.graphics.Rect;
|
import android.util.proto.ProtoOutputStream;
|
import android.view.DisplayCutout;
|
|
import com.android.server.wm.utils.InsetUtils;
|
import com.android.server.wm.utils.WmDisplayCutout;
|
|
import java.io.PrintWriter;
|
|
/**
|
* Container class for all the window frames that affect how windows are laid out.
|
*
|
* TODO(b/111611553): Investigate which frames are still needed and which are duplicates
|
*/
|
public class WindowFrames {
|
private static final StringBuilder sTmpSB = new StringBuilder();
|
|
/**
|
* In most cases, this is the area of the entire screen.
|
*
|
* TODO(b/111611553): The name is unclear and most likely should be swapped with
|
* {@link #mDisplayFrame}
|
* TODO(b/111611553): In some cases, it also includes top insets, like for IME. Determine
|
* whether this is still necessary to do.
|
*/
|
public final Rect mParentFrame = new Rect();
|
|
/**
|
* The entire screen area of the {@link TaskStack} this window is in. Usually equal to the
|
* screen area of the device.
|
*
|
* TODO(b/111611553): The name is unclear and most likely should be swapped with
|
* {@link #mParentFrame}
|
*/
|
public final Rect mDisplayFrame = new Rect();
|
|
/**
|
* The region of the display frame that the display type supports displaying content on. This
|
* is mostly a special case for TV where some displays don’t have the entire display usable.
|
* {@link android.view.WindowManager.LayoutParams#FLAG_LAYOUT_IN_OVERSCAN} flag can be used to
|
* allow window display contents to extend into the overscan region.
|
*/
|
public final Rect mOverscanFrame = new Rect();
|
|
/**
|
* Legacy stuff. Generally equal to the content frame expect when the IME for older apps
|
* displays hint text.
|
*/
|
public final Rect mVisibleFrame = new Rect();
|
|
/**
|
* The area not occupied by the status and navigation bars. So, if both status and navigation
|
* bars are visible, the decor frame is equal to the stable frame.
|
*/
|
public final Rect mDecorFrame = new Rect();
|
|
/**
|
* Equal to the decor frame if the IME (e.g. keyboard) is not present. Equal to the decor frame
|
* minus the area occupied by the IME if the IME is present.
|
*/
|
public final Rect mContentFrame = new Rect();
|
|
/**
|
* The display frame minus the stable insets. This value is always constant regardless of if
|
* the status bar or navigation bar is visible.
|
*/
|
public final Rect mStableFrame = new Rect();
|
|
/**
|
* Frame that includes dead area outside of the surface but where we want to pretend that it's
|
* possible to draw.
|
*/
|
final public Rect mOutsetFrame = new Rect();
|
|
/**
|
* Similar to {@link #mDisplayFrame}
|
*
|
* TODO: Why is this different than mDisplayFrame
|
*/
|
final Rect mContainingFrame = new Rect();
|
|
/**
|
* "Real" frame that the application sees, in display coordinate space.
|
*/
|
final Rect mFrame = new Rect();
|
|
/**
|
* The last real frame that was reported to the client.
|
*/
|
final Rect mLastFrame = new Rect();
|
|
private boolean mFrameSizeChanged = false;
|
|
// Frame that is scaled to the application's coordinate space when in
|
// screen size compatibility mode.
|
final Rect mCompatFrame = new Rect();
|
|
/**
|
* Whether the parent frame would have been different if there was no display cutout.
|
*/
|
private boolean mParentFrameWasClippedByDisplayCutout;
|
|
/**
|
* Part of the display that has been cut away. See {@link DisplayCutout}.
|
*/
|
WmDisplayCutout mDisplayCutout = WmDisplayCutout.NO_CUTOUT;
|
|
/**
|
* The last cutout that has been reported to the client.
|
*/
|
private WmDisplayCutout mLastDisplayCutout = WmDisplayCutout.NO_CUTOUT;
|
|
private boolean mDisplayCutoutChanged;
|
|
/**
|
* Insets that determine the area covered by the display overscan region. These are in the
|
* application's coordinate space (without compatibility scale applied).
|
*/
|
final Rect mOverscanInsets = new Rect();
|
final Rect mLastOverscanInsets = new Rect();
|
private boolean mOverscanInsetsChanged;
|
|
/**
|
* Insets that determine the area covered by the stable system windows. These are in the
|
* application's coordinate space (without compatibility scale applied).
|
*/
|
final Rect mStableInsets = new Rect();
|
final Rect mLastStableInsets = new Rect();
|
private boolean mStableInsetsChanged;
|
|
/**
|
* Outsets determine the area outside of the surface where we want to pretend that it's possible
|
* to draw anyway.
|
*/
|
final Rect mOutsets = new Rect();
|
final Rect mLastOutsets = new Rect();
|
private boolean mOutsetsChanged = false;
|
|
/**
|
* Insets that determine the actually visible area. These are in the application's
|
* coordinate space (without compatibility scale applied).
|
*/
|
final Rect mVisibleInsets = new Rect();
|
final Rect mLastVisibleInsets = new Rect();
|
private boolean mVisibleInsetsChanged;
|
|
/**
|
* Insets that are covered by system windows (such as the status bar) and
|
* transient docking windows (such as the IME). These are in the application's
|
* coordinate space (without compatibility scale applied).
|
*/
|
final Rect mContentInsets = new Rect();
|
final Rect mLastContentInsets = new Rect();
|
private boolean mContentInsetsChanged;
|
|
private final Rect mTmpRect = new Rect();
|
|
private boolean mHasOutsets;
|
|
private boolean mContentChanged;
|
|
public WindowFrames() {
|
}
|
|
public WindowFrames(Rect parentFrame, Rect displayFrame, Rect overscanFrame, Rect contentFrame,
|
Rect visibleFrame, Rect decorFrame, Rect stableFrame, Rect outsetFrame) {
|
setFrames(parentFrame, displayFrame, overscanFrame, contentFrame, visibleFrame, decorFrame,
|
stableFrame, outsetFrame);
|
}
|
|
public void setFrames(Rect parentFrame, Rect displayFrame, Rect overscanFrame,
|
Rect contentFrame, Rect visibleFrame, Rect decorFrame, Rect stableFrame,
|
Rect outsetFrame) {
|
mParentFrame.set(parentFrame);
|
mDisplayFrame.set(displayFrame);
|
mOverscanFrame.set(overscanFrame);
|
mContentFrame.set(contentFrame);
|
mVisibleFrame.set(visibleFrame);
|
mDecorFrame.set(decorFrame);
|
mStableFrame.set(stableFrame);
|
mOutsetFrame.set(outsetFrame);
|
}
|
|
public void setParentFrameWasClippedByDisplayCutout(
|
boolean parentFrameWasClippedByDisplayCutout) {
|
mParentFrameWasClippedByDisplayCutout = parentFrameWasClippedByDisplayCutout;
|
}
|
|
boolean parentFrameWasClippedByDisplayCutout() {
|
return mParentFrameWasClippedByDisplayCutout;
|
}
|
|
public void setDisplayCutout(WmDisplayCutout displayCutout) {
|
mDisplayCutout = displayCutout;
|
}
|
|
/**
|
* @return true if the width or height has changed since last reported to the client.
|
*/
|
private boolean didFrameSizeChange() {
|
return (mLastFrame.width() != mFrame.width()) || (mLastFrame.height() != mFrame.height());
|
}
|
|
/**
|
* Calculates the outsets for this windowFrame. The outsets are calculated by the area between
|
* the {@link #mOutsetFrame} and the {@link #mContentFrame}. If there are no outsets, then
|
* {@link #mOutsets} is set to empty.
|
*/
|
void calculateOutsets() {
|
if (mHasOutsets) {
|
InsetUtils.insetsBetweenFrames(mOutsetFrame, mContentFrame, mOutsets);
|
}
|
}
|
|
/**
|
* Calculate the insets for the type
|
* {@link android.view.WindowManager.LayoutParams#TYPE_DOCK_DIVIDER}
|
*
|
* @param cutoutInsets The insets for the cutout.
|
*/
|
void calculateDockedDividerInsets(Rect cutoutInsets) {
|
// For the docked divider, we calculate the stable insets like a full-screen window
|
// so it can use it to calculate the snap positions.
|
mTmpRect.set(mDisplayFrame);
|
mTmpRect.inset(cutoutInsets);
|
mTmpRect.intersectUnchecked(mStableFrame);
|
InsetUtils.insetsBetweenFrames(mDisplayFrame, mTmpRect, mStableInsets);
|
|
// The divider doesn't care about insets in any case, so set it to empty so we don't
|
// trigger a relayout when moving it.
|
mContentInsets.setEmpty();
|
mVisibleInsets.setEmpty();
|
mDisplayCutout = WmDisplayCutout.NO_CUTOUT;
|
}
|
|
/**
|
* Calculate the insets for a window.
|
*
|
* @param windowsAreFloating Whether the window is in a floating task such as pinned or
|
* freeform
|
* @param inFullscreenContainer Whether the window is in a container that takes up the screen's
|
* entire space
|
* @param windowBounds The bounds for the window
|
*/
|
void calculateInsets(boolean windowsAreFloating, boolean inFullscreenContainer,
|
Rect windowBounds) {
|
// Override right and/or bottom insets in case if the frame doesn't fit the screen in
|
// non-fullscreen mode.
|
boolean overrideRightInset = !windowsAreFloating && !inFullscreenContainer
|
&& mFrame.right > windowBounds.right;
|
boolean overrideBottomInset = !windowsAreFloating && !inFullscreenContainer
|
&& mFrame.bottom > windowBounds.bottom;
|
|
mTmpRect.set(mFrame.left, mFrame.top,
|
overrideRightInset ? windowBounds.right : mFrame.right,
|
overrideBottomInset ? windowBounds.bottom : mFrame.bottom);
|
|
InsetUtils.insetsBetweenFrames(mTmpRect, mContentFrame, mContentInsets);
|
InsetUtils.insetsBetweenFrames(mTmpRect, mVisibleFrame, mVisibleInsets);
|
InsetUtils.insetsBetweenFrames(mTmpRect, mStableFrame, mStableInsets);
|
}
|
|
/**
|
* Scales all the insets by a specific amount.
|
*
|
* @param scale The amount to scale the insets by.
|
*/
|
void scaleInsets(float scale) {
|
mOverscanInsets.scale(scale);
|
mContentInsets.scale(scale);
|
mVisibleInsets.scale(scale);
|
mStableInsets.scale(scale);
|
mOutsets.scale(scale);
|
}
|
|
void offsetFrames(int layoutXDiff, int layoutYDiff) {
|
mFrame.offset(layoutXDiff, layoutYDiff);
|
mContentFrame.offset(layoutXDiff, layoutYDiff);
|
mVisibleFrame.offset(layoutXDiff, layoutYDiff);
|
mStableFrame.offset(layoutXDiff, layoutYDiff);
|
}
|
|
/**
|
* Updates info about whether the size of the window has changed since last reported.
|
*
|
* @return true if info about size has changed since last reported.
|
*/
|
boolean setReportResizeHints() {
|
mOverscanInsetsChanged |= !mLastOverscanInsets.equals(mOverscanInsets);
|
mContentInsetsChanged |= !mLastContentInsets.equals(mContentInsets);
|
mVisibleInsetsChanged |= !mLastVisibleInsets.equals(mVisibleInsets);
|
mStableInsetsChanged |= !mLastStableInsets.equals(mStableInsets);
|
mOutsetsChanged |= !mLastOutsets.equals(mOutsets);
|
mFrameSizeChanged |= didFrameSizeChange();
|
mDisplayCutoutChanged |= !mLastDisplayCutout.equals(mDisplayCutout);
|
return mOverscanInsetsChanged || mContentInsetsChanged || mVisibleInsetsChanged
|
|| mStableInsetsChanged || mOutsetsChanged || mFrameSizeChanged
|
|| mDisplayCutoutChanged;
|
}
|
|
/**
|
* Resets the insets changed flags so they're all set to false again. This should be called
|
* after the insets are reported to client.
|
*/
|
void resetInsetsChanged() {
|
mOverscanInsetsChanged = false;
|
mContentInsetsChanged = false;
|
mVisibleInsetsChanged = false;
|
mStableInsetsChanged = false;
|
mOutsetsChanged = false;
|
mFrameSizeChanged = false;
|
mDisplayCutoutChanged = false;
|
}
|
|
/**
|
* Copy over inset values as the last insets that were sent to the client.
|
*/
|
void updateLastInsetValues() {
|
mLastOverscanInsets.set(mOverscanInsets);
|
mLastContentInsets.set(mContentInsets);
|
mLastVisibleInsets.set(mVisibleInsets);
|
mLastStableInsets.set(mStableInsets);
|
mLastOutsets.set(mOutsets);
|
mLastDisplayCutout = mDisplayCutout;
|
}
|
|
/**
|
* Sets the last content insets as (-1, -1, -1, -1) to force the next layout pass to update
|
* the client.
|
*/
|
void resetLastContentInsets() {
|
mLastContentInsets.set(-1, -1, -1, -1);
|
}
|
|
/**
|
* Sets whether the frame has outsets.
|
*/
|
public void setHasOutsets(boolean hasOutsets) {
|
if (mHasOutsets == hasOutsets) {
|
return;
|
}
|
mHasOutsets = hasOutsets;
|
if (!hasOutsets) {
|
mOutsets.setEmpty();
|
}
|
}
|
|
/**
|
* Sets whether the content has changed. This means that either the size or parent frame has
|
* changed.
|
*/
|
public void setContentChanged(boolean contentChanged) {
|
mContentChanged = contentChanged;
|
}
|
|
/**
|
* @see #setContentChanged(boolean)
|
*/
|
boolean hasContentChanged() {
|
return mContentChanged;
|
}
|
|
public void writeToProto(@NonNull ProtoOutputStream proto, long fieldId) {
|
final long token = proto.start(fieldId);
|
mParentFrame.writeToProto(proto, PARENT_FRAME);
|
mContentFrame.writeToProto(proto, CONTENT_FRAME);
|
mDisplayFrame.writeToProto(proto, DISPLAY_FRAME);
|
mOverscanFrame.writeToProto(proto, OVERSCAN_FRAME);
|
mVisibleFrame.writeToProto(proto, VISIBLE_FRAME);
|
mDecorFrame.writeToProto(proto, DECOR_FRAME);
|
mOutsetFrame.writeToProto(proto, OUTSET_FRAME);
|
mContainingFrame.writeToProto(proto, CONTAINING_FRAME);
|
mFrame.writeToProto(proto, FRAME);
|
mDisplayCutout.getDisplayCutout().writeToProto(proto, CUTOUT);
|
mContentInsets.writeToProto(proto, CONTENT_INSETS);
|
mOverscanInsets.writeToProto(proto, OVERSCAN_INSETS);
|
mVisibleInsets.writeToProto(proto, VISIBLE_INSETS);
|
mStableInsets.writeToProto(proto, STABLE_INSETS);
|
mOutsets.writeToProto(proto, OUTSETS);
|
|
proto.end(token);
|
}
|
|
public void dump(PrintWriter pw, String prefix) {
|
pw.println(prefix + "Frames: containing="
|
+ mContainingFrame.toShortString(sTmpSB)
|
+ " parent=" + mParentFrame.toShortString(sTmpSB));
|
pw.println(prefix + " display=" + mDisplayFrame.toShortString(sTmpSB)
|
+ " overscan=" + mOverscanFrame.toShortString(sTmpSB));
|
pw.println(prefix + " content=" + mContentFrame.toShortString(sTmpSB)
|
+ " visible=" + mVisibleFrame.toShortString(sTmpSB));
|
pw.println(prefix + " decor=" + mDecorFrame.toShortString(sTmpSB));
|
pw.println(prefix + " outset=" + mOutsetFrame.toShortString(sTmpSB));
|
pw.println(prefix + "mFrame=" + mFrame.toShortString(sTmpSB)
|
+ " last=" + mLastFrame.toShortString(sTmpSB));
|
pw.println(prefix + " cutout=" + mDisplayCutout.getDisplayCutout()
|
+ " last=" + mLastDisplayCutout.getDisplayCutout());
|
pw.print(prefix + "Cur insets: overscan=" + mOverscanInsets.toShortString(sTmpSB)
|
+ " content=" + mContentInsets.toShortString(sTmpSB)
|
+ " visible=" + mVisibleInsets.toShortString(sTmpSB)
|
+ " stable=" + mStableInsets.toShortString(sTmpSB)
|
+ " outsets=" + mOutsets.toShortString(sTmpSB));
|
pw.println(prefix + "Lst insets: overscan=" + mLastOverscanInsets.toShortString(sTmpSB)
|
+ " content=" + mLastContentInsets.toShortString(sTmpSB)
|
+ " visible=" + mLastVisibleInsets.toShortString(sTmpSB)
|
+ " stable=" + mLastStableInsets.toShortString(sTmpSB)
|
+ " outset=" + mLastOutsets.toShortString(sTmpSB));
|
}
|
|
String getInsetsInfo() {
|
return "ci=" + mContentInsets.toShortString()
|
+ " vi=" + mVisibleInsets.toShortString()
|
+ " si=" + mStableInsets.toShortString()
|
+ " of=" + mOutsets.toShortString();
|
}
|
|
String getInsetsChangedInfo() {
|
return "contentInsetsChanged=" + mContentInsetsChanged
|
+ " " + mContentInsets.toShortString()
|
+ " visibleInsetsChanged=" + mVisibleInsetsChanged
|
+ " " + mVisibleInsets.toShortString()
|
+ " stableInsetsChanged=" + mStableInsetsChanged
|
+ " " + mStableInsets.toShortString()
|
+ " outsetsChanged=" + mOutsetsChanged
|
+ " " + mOutsets.toShortString()
|
+ " displayCutoutChanged=" + mDisplayCutoutChanged;
|
}
|
}
|
