/*
|
* Copyright (C) 2017 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.view.Surface.ROTATION_180;
|
import static android.view.Surface.ROTATION_270;
|
import static android.view.Surface.ROTATION_90;
|
import static com.android.server.wm.DisplayFramesProto.STABLE_BOUNDS;
|
|
import android.annotation.NonNull;
|
import android.graphics.Rect;
|
import android.util.proto.ProtoOutputStream;
|
import android.view.DisplayCutout;
|
import android.view.DisplayInfo;
|
|
import com.android.server.wm.utils.WmDisplayCutout;
|
|
import java.io.PrintWriter;
|
|
/**
|
* Container class for all the display frames that affect how we do window layout on a display.
|
* @hide
|
*/
|
public class DisplayFrames {
|
public final int mDisplayId;
|
|
/**
|
* The current size of the screen; really; extends into the overscan area of the screen and
|
* doesn't account for any system elements like the status bar.
|
*/
|
public final Rect mOverscan = new Rect();
|
|
/**
|
* The current visible size of the screen; really; (ir)regardless of whether the status bar can
|
* be hidden but not extending into the overscan area.
|
*/
|
public final Rect mUnrestricted = new Rect();
|
|
/** Like mOverscan*, but allowed to move into the overscan region where appropriate. */
|
public final Rect mRestrictedOverscan = new Rect();
|
|
/**
|
* The current size of the screen; these may be different than (0,0)-(dw,dh) if the status bar
|
* can't be hidden; in that case it effectively carves out that area of the display from all
|
* other windows.
|
*/
|
public final Rect mRestricted = new Rect();
|
|
/**
|
* During layout, the current screen borders accounting for any currently visible system UI
|
* elements.
|
*/
|
public final Rect mSystem = new Rect();
|
|
/** For applications requesting stable content insets, these are them. */
|
public final Rect mStable = new Rect();
|
|
/**
|
* For applications requesting stable content insets but have also set the fullscreen window
|
* flag, these are the stable dimensions without the status bar.
|
*/
|
public final Rect mStableFullscreen = new Rect();
|
|
/**
|
* During layout, the current screen borders with all outer decoration (status bar, input method
|
* dock) accounted for.
|
*/
|
public final Rect mCurrent = new Rect();
|
|
/**
|
* During layout, the frame in which content should be displayed to the user, accounting for all
|
* screen decoration except for any space they deem as available for other content. This is
|
* usually the same as mCurrent*, but may be larger if the screen decor has supplied content
|
* insets.
|
*/
|
public final Rect mContent = new Rect();
|
|
/**
|
* During layout, the frame in which voice content should be displayed to the user, accounting
|
* for all screen decoration except for any space they deem as available for other content.
|
*/
|
public final Rect mVoiceContent = new Rect();
|
|
/** During layout, the current screen borders along which input method windows are placed. */
|
public final Rect mDock = new Rect();
|
|
/** The display cutout used for layout (after rotation) */
|
@NonNull public WmDisplayCutout mDisplayCutout = WmDisplayCutout.NO_CUTOUT;
|
|
/** The cutout as supplied by display info */
|
@NonNull public WmDisplayCutout mDisplayInfoCutout = WmDisplayCutout.NO_CUTOUT;
|
|
/**
|
* During layout, the frame that is display-cutout safe, i.e. that does not intersect with it.
|
*/
|
public final Rect mDisplayCutoutSafe = new Rect();
|
|
private final Rect mDisplayInfoOverscan = new Rect();
|
private final Rect mRotatedDisplayInfoOverscan = new Rect();
|
public int mDisplayWidth;
|
public int mDisplayHeight;
|
|
public int mRotation;
|
|
public DisplayFrames(int displayId, DisplayInfo info, WmDisplayCutout displayCutout) {
|
mDisplayId = displayId;
|
onDisplayInfoUpdated(info, displayCutout);
|
}
|
|
public void onDisplayInfoUpdated(DisplayInfo info, WmDisplayCutout displayCutout) {
|
mDisplayWidth = info.logicalWidth;
|
mDisplayHeight = info.logicalHeight;
|
mRotation = info.rotation;
|
mDisplayInfoOverscan.set(
|
info.overscanLeft, info.overscanTop, info.overscanRight, info.overscanBottom);
|
mDisplayInfoCutout = displayCutout != null ? displayCutout : WmDisplayCutout.NO_CUTOUT;
|
}
|
|
public void onBeginLayout() {
|
switch (mRotation) {
|
case ROTATION_90:
|
mRotatedDisplayInfoOverscan.left = mDisplayInfoOverscan.top;
|
mRotatedDisplayInfoOverscan.top = mDisplayInfoOverscan.right;
|
mRotatedDisplayInfoOverscan.right = mDisplayInfoOverscan.bottom;
|
mRotatedDisplayInfoOverscan.bottom = mDisplayInfoOverscan.left;
|
break;
|
case ROTATION_180:
|
mRotatedDisplayInfoOverscan.left = mDisplayInfoOverscan.right;
|
mRotatedDisplayInfoOverscan.top = mDisplayInfoOverscan.bottom;
|
mRotatedDisplayInfoOverscan.right = mDisplayInfoOverscan.left;
|
mRotatedDisplayInfoOverscan.bottom = mDisplayInfoOverscan.top;
|
break;
|
case ROTATION_270:
|
mRotatedDisplayInfoOverscan.left = mDisplayInfoOverscan.bottom;
|
mRotatedDisplayInfoOverscan.top = mDisplayInfoOverscan.left;
|
mRotatedDisplayInfoOverscan.right = mDisplayInfoOverscan.top;
|
mRotatedDisplayInfoOverscan.bottom = mDisplayInfoOverscan.right;
|
break;
|
default:
|
mRotatedDisplayInfoOverscan.set(mDisplayInfoOverscan);
|
break;
|
}
|
|
mRestrictedOverscan.set(0, 0, mDisplayWidth, mDisplayHeight);
|
mOverscan.set(mRestrictedOverscan);
|
mSystem.set(mRestrictedOverscan);
|
mUnrestricted.set(mRotatedDisplayInfoOverscan);
|
mUnrestricted.right = mDisplayWidth - mUnrestricted.right;
|
mUnrestricted.bottom = mDisplayHeight - mUnrestricted.bottom;
|
mRestricted.set(mUnrestricted);
|
mDock.set(mUnrestricted);
|
mContent.set(mUnrestricted);
|
mVoiceContent.set(mUnrestricted);
|
mStable.set(mUnrestricted);
|
mStableFullscreen.set(mUnrestricted);
|
mCurrent.set(mUnrestricted);
|
|
mDisplayCutout = mDisplayInfoCutout;
|
mDisplayCutoutSafe.set(Integer.MIN_VALUE, Integer.MIN_VALUE,
|
Integer.MAX_VALUE, Integer.MAX_VALUE);
|
if (!mDisplayCutout.getDisplayCutout().isEmpty()) {
|
final DisplayCutout c = mDisplayCutout.getDisplayCutout();
|
if (c.getSafeInsetLeft() > 0) {
|
mDisplayCutoutSafe.left = mRestrictedOverscan.left + c.getSafeInsetLeft();
|
}
|
if (c.getSafeInsetTop() > 0) {
|
mDisplayCutoutSafe.top = mRestrictedOverscan.top + c.getSafeInsetTop();
|
}
|
if (c.getSafeInsetRight() > 0) {
|
mDisplayCutoutSafe.right = mRestrictedOverscan.right - c.getSafeInsetRight();
|
}
|
if (c.getSafeInsetBottom() > 0) {
|
mDisplayCutoutSafe.bottom = mRestrictedOverscan.bottom - c.getSafeInsetBottom();
|
}
|
}
|
}
|
|
public int getInputMethodWindowVisibleHeight() {
|
return mDock.bottom - mCurrent.bottom;
|
}
|
|
public void writeToProto(ProtoOutputStream proto, long fieldId) {
|
final long token = proto.start(fieldId);
|
mStable.writeToProto(proto, STABLE_BOUNDS);
|
proto.end(token);
|
}
|
|
public void dump(String prefix, PrintWriter pw) {
|
pw.println(prefix + "DisplayFrames w=" + mDisplayWidth + " h=" + mDisplayHeight
|
+ " r=" + mRotation);
|
final String myPrefix = prefix + " ";
|
dumpFrame(mStable, "mStable", myPrefix, pw);
|
dumpFrame(mStableFullscreen, "mStableFullscreen", myPrefix, pw);
|
dumpFrame(mDock, "mDock", myPrefix, pw);
|
dumpFrame(mCurrent, "mCurrent", myPrefix, pw);
|
dumpFrame(mSystem, "mSystem", myPrefix, pw);
|
dumpFrame(mContent, "mContent", myPrefix, pw);
|
dumpFrame(mVoiceContent, "mVoiceContent", myPrefix, pw);
|
dumpFrame(mOverscan, "mOverscan", myPrefix, pw);
|
dumpFrame(mRestrictedOverscan, "mRestrictedOverscan", myPrefix, pw);
|
dumpFrame(mRestricted, "mRestricted", myPrefix, pw);
|
dumpFrame(mUnrestricted, "mUnrestricted", myPrefix, pw);
|
dumpFrame(mDisplayInfoOverscan, "mDisplayInfoOverscan", myPrefix, pw);
|
dumpFrame(mRotatedDisplayInfoOverscan, "mRotatedDisplayInfoOverscan", myPrefix, pw);
|
pw.println(myPrefix + "mDisplayCutout=" + mDisplayCutout);
|
}
|
|
private void dumpFrame(Rect frame, String name, String prefix, PrintWriter pw) {
|
pw.print(prefix + name + "="); frame.printShortString(pw); pw.println();
|
}
|
}
|
