689 lines
25 KiB
Java
689 lines
25 KiB
Java
/*
|
|
* 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 android.view;
|
|
|
|
import static android.view.InsetsSourceProto.FRAME;
|
|
import static android.view.InsetsSourceProto.TYPE;
|
|
import static android.view.InsetsSourceProto.TYPE_NUMBER;
|
|
import static android.view.InsetsSourceProto.VISIBLE;
|
|
import static android.view.InsetsSourceProto.VISIBLE_FRAME;
|
|
import static android.view.WindowInsets.Type.captionBar;
|
|
import static android.view.WindowInsets.Type.ime;
|
|
|
|
import android.annotation.IntDef;
|
|
import android.annotation.IntRange;
|
|
import android.annotation.NonNull;
|
|
import android.annotation.Nullable;
|
|
import android.graphics.Insets;
|
|
import android.graphics.Rect;
|
|
import android.os.Parcel;
|
|
import android.os.Parcelable;
|
|
import android.util.proto.ProtoOutputStream;
|
|
import android.view.WindowInsets.Type.InsetsType;
|
|
|
|
import java.io.PrintWriter;
|
|
import java.lang.annotation.Retention;
|
|
import java.lang.annotation.RetentionPolicy;
|
|
import java.util.ArrayList;
|
|
import java.util.Arrays;
|
|
import java.util.Objects;
|
|
import java.util.StringJoiner;
|
|
|
|
/**
|
|
* Represents the state of a single entity generating insets for clients.
|
|
* @hide
|
|
*/
|
|
public class InsetsSource implements Parcelable {
|
|
|
|
@Retention(RetentionPolicy.SOURCE)
|
|
@IntDef(prefix = "SIDE_", value = {
|
|
SIDE_NONE,
|
|
SIDE_LEFT,
|
|
SIDE_TOP,
|
|
SIDE_RIGHT,
|
|
SIDE_BOTTOM,
|
|
SIDE_UNKNOWN
|
|
})
|
|
public @interface InternalInsetsSide {}
|
|
|
|
static final int SIDE_NONE = 0;
|
|
static final int SIDE_LEFT = 1;
|
|
static final int SIDE_TOP = 2;
|
|
static final int SIDE_RIGHT = 3;
|
|
static final int SIDE_BOTTOM = 4;
|
|
static final int SIDE_UNKNOWN = 5;
|
|
|
|
/** The insets source ID of IME */
|
|
public static final int ID_IME = createId(null, 0, ime());
|
|
|
|
/** The insets source ID of the IME caption bar ("fake" IME navigation bar). */
|
|
public static final int ID_IME_CAPTION_BAR =
|
|
InsetsSource.createId(null /* owner */, 1 /* index */, captionBar());
|
|
|
|
/**
|
|
* Controls whether this source suppresses the scrim. If the scrim is ignored, the system won't
|
|
* draw a semi-transparent scrim behind the system bar area even when the bar contrast is
|
|
* enforced.
|
|
*
|
|
* @see android.R.styleable#Window_enforceStatusBarContrast
|
|
* @see android.R.styleable#Window_enforceNavigationBarContrast
|
|
*/
|
|
public static final int FLAG_SUPPRESS_SCRIM = 1;
|
|
|
|
/**
|
|
* Controls whether the insets frame will be used to move {@link RoundedCorner} inward with the
|
|
* insets frame size when calculating the rounded corner insets to other windows.
|
|
*
|
|
* For example, task bar will draw fake rounded corners above itself, so we need to move the
|
|
* rounded corner up by the task bar insets size to make other windows see a rounded corner
|
|
* above the task bar.
|
|
*/
|
|
public static final int FLAG_INSETS_ROUNDED_CORNER = 1 << 1;
|
|
|
|
/**
|
|
* Controls whether the insets provided by this source should be forcibly consumed.
|
|
*/
|
|
public static final int FLAG_FORCE_CONSUMING = 1 << 2;
|
|
|
|
/**
|
|
* Controls whether the insets source will play an animation when resizing.
|
|
*/
|
|
public static final int FLAG_ANIMATE_RESIZING = 1 << 3;
|
|
|
|
@Retention(RetentionPolicy.SOURCE)
|
|
@IntDef(flag = true, prefix = "FLAG_", value = {
|
|
FLAG_SUPPRESS_SCRIM,
|
|
FLAG_INSETS_ROUNDED_CORNER,
|
|
FLAG_FORCE_CONSUMING,
|
|
FLAG_ANIMATE_RESIZING,
|
|
})
|
|
public @interface Flags {}
|
|
|
|
/**
|
|
* Used when there are no bounding rects to describe an inset, which is only possible when the
|
|
* insets itself is {@link Insets#NONE}.
|
|
*/
|
|
private static final Rect[] NO_BOUNDING_RECTS = new Rect[0];
|
|
|
|
private @Flags int mFlags;
|
|
|
|
/**
|
|
* An unique integer to identify this source across processes.
|
|
*/
|
|
private final int mId;
|
|
|
|
private final @InsetsType int mType;
|
|
|
|
/** Frame of the source in screen coordinate space */
|
|
private final Rect mFrame;
|
|
private @Nullable Rect mVisibleFrame;
|
|
private @Nullable Rect[] mBoundingRects;
|
|
|
|
private boolean mVisible;
|
|
|
|
/**
|
|
* Used to decide which side of the relative frame should receive insets when the frame fully
|
|
* covers the relative frame.
|
|
*/
|
|
private @InternalInsetsSide int mSideHint = SIDE_NONE;
|
|
|
|
private final Rect mTmpFrame = new Rect();
|
|
private final Rect mTmpBoundingRect = new Rect();
|
|
|
|
public InsetsSource(int id, @InsetsType int type) {
|
|
mId = id;
|
|
mType = type;
|
|
mFrame = new Rect();
|
|
mVisible = (WindowInsets.Type.defaultVisible() & type) != 0;
|
|
}
|
|
|
|
public InsetsSource(InsetsSource other) {
|
|
mId = other.mId;
|
|
mType = other.mType;
|
|
mFrame = new Rect(other.mFrame);
|
|
mVisible = other.mVisible;
|
|
mVisibleFrame = other.mVisibleFrame != null
|
|
? new Rect(other.mVisibleFrame)
|
|
: null;
|
|
mFlags = other.mFlags;
|
|
mSideHint = other.mSideHint;
|
|
mBoundingRects = other.mBoundingRects != null
|
|
? other.mBoundingRects.clone()
|
|
: null;
|
|
}
|
|
|
|
public void set(InsetsSource other) {
|
|
mFrame.set(other.mFrame);
|
|
mVisible = other.mVisible;
|
|
mVisibleFrame = other.mVisibleFrame != null
|
|
? new Rect(other.mVisibleFrame)
|
|
: null;
|
|
mFlags = other.mFlags;
|
|
mSideHint = other.mSideHint;
|
|
mBoundingRects = other.mBoundingRects != null
|
|
? other.mBoundingRects.clone()
|
|
: null;
|
|
}
|
|
|
|
public InsetsSource setFrame(int left, int top, int right, int bottom) {
|
|
mFrame.set(left, top, right, bottom);
|
|
return this;
|
|
}
|
|
|
|
public InsetsSource setFrame(Rect frame) {
|
|
mFrame.set(frame);
|
|
return this;
|
|
}
|
|
|
|
public InsetsSource setVisibleFrame(@Nullable Rect visibleFrame) {
|
|
mVisibleFrame = visibleFrame != null ? new Rect(visibleFrame) : null;
|
|
return this;
|
|
}
|
|
|
|
public InsetsSource setVisible(boolean visible) {
|
|
mVisible = visible;
|
|
return this;
|
|
}
|
|
|
|
public InsetsSource setFlags(@Flags int flags) {
|
|
mFlags = flags;
|
|
return this;
|
|
}
|
|
|
|
public InsetsSource setFlags(@Flags int flags, @Flags int mask) {
|
|
mFlags = (mFlags & ~mask) | (flags & mask);
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* Updates the side hint which is used to decide which side of the relative frame should receive
|
|
* insets when the frame fully covers the relative frame.
|
|
*
|
|
* @param bounds A rectangle which contains the frame. It will be used to calculate the hint.
|
|
*/
|
|
public InsetsSource updateSideHint(Rect bounds) {
|
|
mSideHint = getInsetSide(
|
|
calculateInsets(bounds, mFrame, true /* ignoreVisibility */));
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* Set the bounding rectangles of this source. They are expected to be relative to the source
|
|
* frame.
|
|
*/
|
|
public InsetsSource setBoundingRects(@Nullable Rect[] rects) {
|
|
mBoundingRects = rects != null ? rects.clone() : null;
|
|
return this;
|
|
}
|
|
|
|
public int getId() {
|
|
return mId;
|
|
}
|
|
|
|
public @InsetsType int getType() {
|
|
return mType;
|
|
}
|
|
|
|
public Rect getFrame() {
|
|
return mFrame;
|
|
}
|
|
|
|
public @Nullable Rect getVisibleFrame() {
|
|
return mVisibleFrame;
|
|
}
|
|
|
|
public boolean isVisible() {
|
|
return mVisible;
|
|
}
|
|
|
|
public @Flags int getFlags() {
|
|
return mFlags;
|
|
}
|
|
|
|
public boolean hasFlags(int flags) {
|
|
return (mFlags & flags) == flags;
|
|
}
|
|
|
|
/**
|
|
* Returns the bounding rectangles of this source.
|
|
*/
|
|
public @Nullable Rect[] getBoundingRects() {
|
|
return mBoundingRects;
|
|
}
|
|
|
|
/**
|
|
* Calculates the insets this source will cause to a client window.
|
|
*
|
|
* @param relativeFrame The frame to calculate the insets relative to.
|
|
* @param ignoreVisibility If true, always reports back insets even if source isn't visible.
|
|
* @return The resulting insets. The contract is that only one side will be occupied by a
|
|
* source.
|
|
*/
|
|
public Insets calculateInsets(Rect relativeFrame, boolean ignoreVisibility) {
|
|
return calculateInsets(relativeFrame, mFrame, ignoreVisibility);
|
|
}
|
|
|
|
/**
|
|
* Like {@link #calculateInsets(Rect, boolean)}, but will return visible insets.
|
|
*/
|
|
public Insets calculateVisibleInsets(Rect relativeFrame) {
|
|
return calculateInsets(relativeFrame, mVisibleFrame != null ? mVisibleFrame : mFrame,
|
|
false /* ignoreVisibility */);
|
|
}
|
|
|
|
private Insets calculateInsets(Rect relativeFrame, Rect frame, boolean ignoreVisibility) {
|
|
if (!ignoreVisibility && !mVisible) {
|
|
return Insets.NONE;
|
|
}
|
|
// During drag-move and drag-resizing, the caption insets position may not get updated
|
|
// before the app frame get updated. To layout the app content correctly during drag events,
|
|
// we always return the insets with the corresponding height covering the top.
|
|
// However, with the "fake" IME navigation bar treated as a caption bar, we return the
|
|
// insets with the corresponding height the bottom.
|
|
if (getType() == WindowInsets.Type.captionBar()) {
|
|
return getId() == ID_IME_CAPTION_BAR
|
|
? Insets.of(0, 0, 0, frame.height())
|
|
: Insets.of(0, frame.height(), 0, 0);
|
|
}
|
|
// Checks for whether there is shared edge with insets for 0-width/height window.
|
|
final boolean hasIntersection = relativeFrame.isEmpty()
|
|
? getIntersection(frame, relativeFrame, mTmpFrame)
|
|
: mTmpFrame.setIntersect(frame, relativeFrame);
|
|
if (!hasIntersection) {
|
|
return Insets.NONE;
|
|
}
|
|
|
|
// TODO: Currently, non-floating IME always intersects at bottom due to issues with cutout.
|
|
// However, we should let the policy decide from the server.
|
|
if (getType() == WindowInsets.Type.ime()) {
|
|
return Insets.of(0, 0, 0, mTmpFrame.height());
|
|
}
|
|
|
|
if (mTmpFrame.equals(relativeFrame)) {
|
|
// Covering all sides
|
|
switch (mSideHint) {
|
|
default:
|
|
case SIDE_LEFT:
|
|
return Insets.of(mTmpFrame.width(), 0, 0, 0);
|
|
case SIDE_TOP:
|
|
return Insets.of(0, mTmpFrame.height(), 0, 0);
|
|
case SIDE_RIGHT:
|
|
return Insets.of(0, 0, mTmpFrame.width(), 0);
|
|
case SIDE_BOTTOM:
|
|
return Insets.of(0, 0, 0, mTmpFrame.height());
|
|
}
|
|
} else if (mTmpFrame.width() == relativeFrame.width()) {
|
|
// Intersecting at top/bottom
|
|
if (mTmpFrame.top == relativeFrame.top) {
|
|
return Insets.of(0, mTmpFrame.height(), 0, 0);
|
|
} else if (mTmpFrame.bottom == relativeFrame.bottom) {
|
|
return Insets.of(0, 0, 0, mTmpFrame.height());
|
|
}
|
|
// TODO: remove when insets are shell-customizable.
|
|
// This is a hack that says "if this is a top-inset (eg statusbar), always apply it
|
|
// to the top". It is used when adjusting primary split for IME.
|
|
if (mTmpFrame.top == 0) {
|
|
return Insets.of(0, mTmpFrame.height(), 0, 0);
|
|
}
|
|
} else if (mTmpFrame.height() == relativeFrame.height()) {
|
|
// Intersecting at left/right
|
|
if (mTmpFrame.left == relativeFrame.left) {
|
|
return Insets.of(mTmpFrame.width(), 0, 0, 0);
|
|
} else if (mTmpFrame.right == relativeFrame.right) {
|
|
return Insets.of(0, 0, mTmpFrame.width(), 0);
|
|
}
|
|
}
|
|
return Insets.NONE;
|
|
}
|
|
|
|
/**
|
|
* Calculates the bounding rects the source will cause to a client window.
|
|
*/
|
|
public @NonNull Rect[] calculateBoundingRects(Rect relativeFrame, boolean ignoreVisibility) {
|
|
if (!ignoreVisibility && !mVisible) {
|
|
return NO_BOUNDING_RECTS;
|
|
}
|
|
|
|
final Rect frame = getFrame();
|
|
if (mBoundingRects == null) {
|
|
// No bounding rects set, make a single bounding rect that covers the intersection of
|
|
// the |frame| and the |relativeFrame|. Also make it relative to the window origin.
|
|
return mTmpBoundingRect.setIntersect(frame, relativeFrame)
|
|
? new Rect[]{
|
|
new Rect(
|
|
mTmpBoundingRect.left - relativeFrame.left,
|
|
mTmpBoundingRect.top - relativeFrame.top,
|
|
mTmpBoundingRect.right - relativeFrame.left,
|
|
mTmpBoundingRect.bottom - relativeFrame.top
|
|
)
|
|
}
|
|
: NO_BOUNDING_RECTS;
|
|
}
|
|
|
|
// Special treatment for captionBar inset type. During drag-resizing, the |frame| and
|
|
// |boundingRects| may not get updated as quickly as |relativeFrame|, so just assume the
|
|
// |frame| will always be either at the top or bottom of |relativeFrame|. This means some
|
|
// calculations to make |boundingRects| relative to |relativeFrame| can be skipped or
|
|
// simplified.
|
|
// TODO(b/254128050): remove special treatment.
|
|
if (getType() == WindowInsets.Type.captionBar()) {
|
|
final ArrayList<Rect> validBoundingRects = new ArrayList<>();
|
|
for (final Rect boundingRect : mBoundingRects) {
|
|
// Assume that the caption |frame| and |relativeFrame| perfectly align at the top
|
|
// or bottom, meaning that the provided |boundingRect|, which is relative to the
|
|
// |frame| either is already relative to |relativeFrame| (for top captionBar()), or
|
|
// just needs to be made relative to |relativeFrame| for bottom bars.
|
|
final int frameHeight = frame.height();
|
|
mTmpBoundingRect.set(boundingRect);
|
|
if (getId() == ID_IME_CAPTION_BAR) {
|
|
mTmpBoundingRect.offset(0, relativeFrame.height() - frameHeight);
|
|
}
|
|
validBoundingRects.add(new Rect(mTmpBoundingRect));
|
|
}
|
|
return validBoundingRects.toArray(new Rect[validBoundingRects.size()]);
|
|
}
|
|
|
|
// Regular treatment for non-captionBar inset types.
|
|
final ArrayList<Rect> validBoundingRects = new ArrayList<>();
|
|
for (final Rect boundingRect : mBoundingRects) {
|
|
// |boundingRect| was provided relative to |frame|. Make it absolute to be in the same
|
|
// coordinate system as |frame|.
|
|
final Rect absBoundingRect = new Rect(
|
|
boundingRect.left + frame.left,
|
|
boundingRect.top + frame.top,
|
|
boundingRect.right + frame.left,
|
|
boundingRect.bottom + frame.top
|
|
);
|
|
// Now find the intersection of that |absBoundingRect| with |relativeFrame|. In other
|
|
// words, whichever part of the bounding rect is inside the window frame.
|
|
if (!mTmpBoundingRect.setIntersect(absBoundingRect, relativeFrame)) {
|
|
// It's possible for this to be empty if the frame and bounding rects were larger
|
|
// than the |relativeFrame|, such as when a system window is wider than the app
|
|
// window width. Just ignore that rect since it will have no effect on the
|
|
// window insets.
|
|
continue;
|
|
}
|
|
// At this point, |mTmpBoundingRect| is a valid bounding rect located fully inside the
|
|
// window, convert it to be relative to the window so that apps don't need to know the
|
|
// location of the window to understand bounding rects.
|
|
validBoundingRects.add(new Rect(
|
|
mTmpBoundingRect.left - relativeFrame.left,
|
|
mTmpBoundingRect.top - relativeFrame.top,
|
|
mTmpBoundingRect.right - relativeFrame.left,
|
|
mTmpBoundingRect.bottom - relativeFrame.top));
|
|
}
|
|
if (validBoundingRects.isEmpty()) {
|
|
return NO_BOUNDING_RECTS;
|
|
}
|
|
return validBoundingRects.toArray(new Rect[validBoundingRects.size()]);
|
|
}
|
|
|
|
/**
|
|
* Outputs the intersection of two rectangles. The shared edges will also be counted in the
|
|
* intersection.
|
|
*
|
|
* @param a The first rectangle being intersected with.
|
|
* @param b The second rectangle being intersected with.
|
|
* @param out The rectangle which represents the intersection.
|
|
* @return {@code true} if there is any intersection.
|
|
*/
|
|
private static boolean getIntersection(@NonNull Rect a, @NonNull Rect b, @NonNull Rect out) {
|
|
if (a.left <= b.right && b.left <= a.right && a.top <= b.bottom && b.top <= a.bottom) {
|
|
out.left = Math.max(a.left, b.left);
|
|
out.top = Math.max(a.top, b.top);
|
|
out.right = Math.min(a.right, b.right);
|
|
out.bottom = Math.min(a.bottom, b.bottom);
|
|
return true;
|
|
}
|
|
out.setEmpty();
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Retrieves the side for a certain {@code insets}. It is required that only one field l/t/r/b
|
|
* is set in order that this method returns a meaningful result.
|
|
*/
|
|
static @InternalInsetsSide int getInsetSide(Insets insets) {
|
|
if (Insets.NONE.equals(insets)) {
|
|
return SIDE_NONE;
|
|
}
|
|
if (insets.left != 0) {
|
|
return SIDE_LEFT;
|
|
}
|
|
if (insets.top != 0) {
|
|
return SIDE_TOP;
|
|
}
|
|
if (insets.right != 0) {
|
|
return SIDE_RIGHT;
|
|
}
|
|
if (insets.bottom != 0) {
|
|
return SIDE_BOTTOM;
|
|
}
|
|
return SIDE_UNKNOWN;
|
|
}
|
|
|
|
static String sideToString(@InternalInsetsSide int side) {
|
|
switch (side) {
|
|
case SIDE_NONE:
|
|
return "NONE";
|
|
case SIDE_LEFT:
|
|
return "LEFT";
|
|
case SIDE_TOP:
|
|
return "TOP";
|
|
case SIDE_RIGHT:
|
|
return "RIGHT";
|
|
case SIDE_BOTTOM:
|
|
return "BOTTOM";
|
|
default:
|
|
return "UNKNOWN:" + side;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Creates an identifier of an {@link InsetsSource}.
|
|
*
|
|
* @param owner An object owned by the owner. Only the owner can modify its own sources.
|
|
* @param index An owner may have multiple sources with the same type. For example, the system
|
|
* server might have multiple display cutout sources. This is used to identify
|
|
* which one is which. The value must be in a range of [0, 2047].
|
|
* @param type The {@link InsetsType type} of the source.
|
|
* @return a unique integer as the identifier.
|
|
*/
|
|
public static int createId(Object owner, @IntRange(from = 0, to = 2047) int index,
|
|
@InsetsType int type) {
|
|
if (index < 0 || index >= 2048) {
|
|
throw new IllegalArgumentException();
|
|
}
|
|
// owner takes top 16 bits;
|
|
// index takes 11 bits since the 6th bit;
|
|
// type takes bottom 5 bits.
|
|
return ((System.identityHashCode(owner) % (1 << 16)) << 16)
|
|
+ (index << 5)
|
|
+ WindowInsets.Type.indexOf(type);
|
|
}
|
|
|
|
/**
|
|
* Gets the index from the ID.
|
|
*
|
|
* @see #createId(Object, int, int)
|
|
*/
|
|
public static int getIndex(int id) {
|
|
// start: ????????????????***********?????
|
|
// & 65535: 0000000000000000***********?????
|
|
// >> 5: 000000000000000000000***********
|
|
return (id & 65535) >> 5;
|
|
}
|
|
|
|
/**
|
|
* Gets the {@link InsetsType} from the ID.
|
|
*
|
|
* @see #createId(Object, int, int)
|
|
* @see WindowInsets.Type#indexOf(int)
|
|
*/
|
|
public static int getType(int id) {
|
|
// start: ???????????????????????????*****
|
|
// & 31: 000000000000000000000000000*****
|
|
// 1 <<: See WindowInsets.Type#indexOf
|
|
return 1 << (id & 31);
|
|
}
|
|
|
|
public static String flagsToString(@Flags int flags) {
|
|
final StringJoiner joiner = new StringJoiner("|");
|
|
if ((flags & FLAG_SUPPRESS_SCRIM) != 0) {
|
|
joiner.add("SUPPRESS_SCRIM");
|
|
}
|
|
if ((flags & FLAG_INSETS_ROUNDED_CORNER) != 0) {
|
|
joiner.add("INSETS_ROUNDED_CORNER");
|
|
}
|
|
if ((flags & FLAG_FORCE_CONSUMING) != 0) {
|
|
joiner.add("FORCE_CONSUMING");
|
|
}
|
|
if ((flags & FLAG_ANIMATE_RESIZING) != 0) {
|
|
joiner.add("ANIMATE_RESIZING");
|
|
}
|
|
return joiner.toString();
|
|
}
|
|
|
|
/**
|
|
* Export the state of {@link InsetsSource} into a protocol buffer output stream.
|
|
*
|
|
* @param proto Stream to write the state to
|
|
* @param fieldId FieldId of InsetsSource as defined in the parent message
|
|
*/
|
|
public void dumpDebug(ProtoOutputStream proto, long fieldId) {
|
|
final long token = proto.start(fieldId);
|
|
if (!android.os.Flags.androidOsBuildVanillaIceCream()) {
|
|
// Deprecated since V.
|
|
proto.write(TYPE, WindowInsets.Type.toString(mType));
|
|
}
|
|
mFrame.dumpDebug(proto, FRAME);
|
|
if (mVisibleFrame != null) {
|
|
mVisibleFrame.dumpDebug(proto, VISIBLE_FRAME);
|
|
}
|
|
proto.write(VISIBLE, mVisible);
|
|
proto.write(TYPE_NUMBER, mType);
|
|
proto.end(token);
|
|
}
|
|
|
|
public void dump(String prefix, PrintWriter pw) {
|
|
pw.print(prefix);
|
|
pw.print("InsetsSource id="); pw.print(Integer.toHexString(mId));
|
|
pw.print(" type="); pw.print(WindowInsets.Type.toString(mType));
|
|
pw.print(" frame="); pw.print(mFrame.toShortString());
|
|
if (mVisibleFrame != null) {
|
|
pw.print(" visibleFrame="); pw.print(mVisibleFrame.toShortString());
|
|
}
|
|
pw.print(" visible="); pw.print(mVisible);
|
|
pw.print(" flags="); pw.print(flagsToString(mFlags));
|
|
pw.print(" sideHint="); pw.print(sideToString(mSideHint));
|
|
pw.print(" boundingRects="); pw.print(Arrays.toString(mBoundingRects));
|
|
pw.println();
|
|
}
|
|
|
|
@Override
|
|
public boolean equals(@Nullable Object o) {
|
|
return equals(o, false);
|
|
}
|
|
|
|
/**
|
|
* @param excludeInvisibleImeFrames If {@link WindowInsets.Type#ime()} frames should be ignored
|
|
* when IME is not visible.
|
|
*/
|
|
public boolean equals(@Nullable Object o, boolean excludeInvisibleImeFrames) {
|
|
if (this == o) return true;
|
|
if (o == null || getClass() != o.getClass()) return false;
|
|
|
|
InsetsSource that = (InsetsSource) o;
|
|
|
|
if (mId != that.mId) return false;
|
|
if (mType != that.mType) return false;
|
|
if (mVisible != that.mVisible) return false;
|
|
if (mFlags != that.mFlags) return false;
|
|
if (mSideHint != that.mSideHint) return false;
|
|
if (excludeInvisibleImeFrames && !mVisible && mType == WindowInsets.Type.ime()) return true;
|
|
if (!Objects.equals(mVisibleFrame, that.mVisibleFrame)) return false;
|
|
if (!mFrame.equals(that.mFrame)) return false;
|
|
return Arrays.equals(mBoundingRects, that.mBoundingRects);
|
|
}
|
|
|
|
@Override
|
|
public int hashCode() {
|
|
return Objects.hash(mId, mType, mFrame, mVisibleFrame, mVisible, mFlags, mSideHint,
|
|
Arrays.hashCode(mBoundingRects));
|
|
}
|
|
|
|
public InsetsSource(Parcel in) {
|
|
mId = in.readInt();
|
|
mType = in.readInt();
|
|
mFrame = Rect.CREATOR.createFromParcel(in);
|
|
if (in.readInt() != 0) {
|
|
mVisibleFrame = Rect.CREATOR.createFromParcel(in);
|
|
} else {
|
|
mVisibleFrame = null;
|
|
}
|
|
mVisible = in.readBoolean();
|
|
mFlags = in.readInt();
|
|
mSideHint = in.readInt();
|
|
mBoundingRects = in.createTypedArray(Rect.CREATOR);
|
|
}
|
|
|
|
@Override
|
|
public int describeContents() {
|
|
return 0;
|
|
}
|
|
|
|
@Override
|
|
public void writeToParcel(Parcel dest, int flags) {
|
|
dest.writeInt(mId);
|
|
dest.writeInt(mType);
|
|
mFrame.writeToParcel(dest, 0);
|
|
if (mVisibleFrame != null) {
|
|
dest.writeInt(1);
|
|
mVisibleFrame.writeToParcel(dest, 0);
|
|
} else {
|
|
dest.writeInt(0);
|
|
}
|
|
dest.writeBoolean(mVisible);
|
|
dest.writeInt(mFlags);
|
|
dest.writeInt(mSideHint);
|
|
dest.writeTypedArray(mBoundingRects, flags);
|
|
}
|
|
|
|
@Override
|
|
public String toString() {
|
|
return "InsetsSource: {" + Integer.toHexString(mId)
|
|
+ " mType=" + WindowInsets.Type.toString(mType)
|
|
+ " mFrame=" + mFrame.toShortString()
|
|
+ " mVisible=" + mVisible
|
|
+ " mFlags=" + flagsToString(mFlags)
|
|
+ " mSideHint=" + sideToString(mSideHint)
|
|
+ " mBoundingRects=" + Arrays.toString(mBoundingRects)
|
|
+ "}";
|
|
}
|
|
|
|
public static final @NonNull Creator<InsetsSource> CREATOR = new Creator<>() {
|
|
|
|
public InsetsSource createFromParcel(Parcel in) {
|
|
return new InsetsSource(in);
|
|
}
|
|
|
|
public InsetsSource[] newArray(int size) {
|
|
return new InsetsSource[size];
|
|
}
|
|
};
|
|
}
|