| /* |
| * 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.app.WindowConfiguration.ACTIVITY_TYPE_STANDARD; |
| import static android.view.InsetsSource.FLAG_FORCE_CONSUMING; |
| import static android.view.InsetsSource.FLAG_INSETS_ROUNDED_CORNER; |
| import static android.view.InsetsStateProto.DISPLAY_CUTOUT; |
| import static android.view.InsetsStateProto.DISPLAY_FRAME; |
| import static android.view.InsetsStateProto.SOURCES; |
| import static android.view.View.SYSTEM_UI_FLAG_LAYOUT_STABLE; |
| import static android.view.WindowInsets.Type.captionBar; |
| import static android.view.WindowInsets.Type.displayCutout; |
| import static android.view.WindowInsets.Type.ime; |
| import static android.view.WindowInsets.Type.indexOf; |
| import static android.view.WindowInsets.Type.statusBars; |
| import static android.view.WindowInsets.Type.systemBars; |
| import static android.view.WindowManager.LayoutParams.FLAG_FULLSCREEN; |
| import static android.view.WindowManager.LayoutParams.FLAG_LAYOUT_NO_LIMITS; |
| import static android.view.WindowManager.LayoutParams.SOFT_INPUT_ADJUST_NOTHING; |
| import static android.view.WindowManager.LayoutParams.SOFT_INPUT_ADJUST_RESIZE; |
| import static android.view.WindowManager.LayoutParams.SOFT_INPUT_MASK_ADJUST; |
| import static android.view.WindowManager.LayoutParams.TYPE_SYSTEM_ERROR; |
| import static android.view.WindowManager.LayoutParams.TYPE_WALLPAPER; |
| |
| import android.annotation.NonNull; |
| import android.annotation.Nullable; |
| import android.app.WindowConfiguration.ActivityType; |
| import android.graphics.Insets; |
| import android.graphics.Rect; |
| import android.os.Parcel; |
| import android.os.Parcelable; |
| import android.util.SparseArray; |
| import android.util.SparseIntArray; |
| import android.util.proto.ProtoOutputStream; |
| import android.view.InsetsSource.InternalInsetsSide; |
| import android.view.WindowInsets.Type; |
| import android.view.WindowInsets.Type.InsetsType; |
| import android.view.WindowManager.LayoutParams.SoftInputModeFlags; |
| |
| import com.android.internal.annotations.VisibleForTesting; |
| |
| import java.io.PrintWriter; |
| import java.util.Objects; |
| import java.util.StringJoiner; |
| |
| /** |
| * Holder for state of system windows that cause window insets for all other windows in the system. |
| * @hide |
| */ |
| public class InsetsState implements Parcelable { |
| |
| private final SparseArray<InsetsSource> mSources; |
| |
| /** |
| * The frame of the display these sources are relative to. |
| */ |
| private final Rect mDisplayFrame = new Rect(); |
| |
| /** The area cut from the display. */ |
| private final DisplayCutout.ParcelableWrapper mDisplayCutout = |
| new DisplayCutout.ParcelableWrapper(); |
| |
| /** |
| * The frame that rounded corners are relative to. |
| * |
| * There are 2 cases that will draw fake rounded corners: |
| * 1. In split-screen mode |
| * 2. Devices with a task bar |
| * We need to report these fake rounded corners to apps by re-calculating based on this frame. |
| */ |
| private final Rect mRoundedCornerFrame = new Rect(); |
| |
| /** The rounded corners on the display */ |
| private RoundedCorners mRoundedCorners = RoundedCorners.NO_ROUNDED_CORNERS; |
| |
| /** The bounds of the Privacy Indicator */ |
| private PrivacyIndicatorBounds mPrivacyIndicatorBounds = |
| new PrivacyIndicatorBounds(); |
| |
| /** The display shape */ |
| private DisplayShape mDisplayShape = DisplayShape.NONE; |
| |
| public InsetsState() { |
| mSources = new SparseArray<>(); |
| } |
| |
| public InsetsState(InsetsState copy) { |
| this(copy, false /* copySources */); |
| } |
| |
| public InsetsState(InsetsState copy, boolean copySources) { |
| mSources = new SparseArray<>(copy.mSources.size()); |
| set(copy, copySources); |
| } |
| |
| /** |
| * Calculates {@link WindowInsets} based on the current source configuration. |
| * |
| * @param frame The frame to calculate the insets relative to. |
| * @param ignoringVisibilityState {@link InsetsState} used to calculate |
| * {@link WindowInsets#getInsetsIgnoringVisibility(int)} information, or pass |
| * {@code null} to use this state to calculate that information. |
| * @return The calculated insets. |
| */ |
| public WindowInsets calculateInsets(Rect frame, @Nullable InsetsState ignoringVisibilityState, |
| boolean isScreenRound, int legacySoftInputMode, int legacyWindowFlags, |
| int legacySystemUiFlags, int windowType, @ActivityType int activityType, |
| @Nullable @InternalInsetsSide SparseIntArray idSideMap) { |
| Insets[] typeInsetsMap = new Insets[Type.SIZE]; |
| Insets[] typeMaxInsetsMap = new Insets[Type.SIZE]; |
| boolean[] typeVisibilityMap = new boolean[Type.SIZE]; |
| final Rect relativeFrame = new Rect(frame); |
| final Rect relativeFrameMax = new Rect(frame); |
| @InsetsType int forceConsumingTypes = 0; |
| @InsetsType int suppressScrimTypes = 0; |
| final Rect[][] typeBoundingRectsMap = new Rect[Type.SIZE][]; |
| final Rect[][] typeMaxBoundingRectsMap = new Rect[Type.SIZE][]; |
| for (int i = mSources.size() - 1; i >= 0; i--) { |
| final InsetsSource source = mSources.valueAt(i); |
| final @InsetsType int type = source.getType(); |
| |
| if ((source.getFlags() & InsetsSource.FLAG_FORCE_CONSUMING) != 0) { |
| forceConsumingTypes |= type; |
| } |
| |
| if ((source.getFlags() & InsetsSource.FLAG_SUPPRESS_SCRIM) != 0) { |
| suppressScrimTypes |= type; |
| } |
| |
| processSource(source, relativeFrame, false /* ignoreVisibility */, typeInsetsMap, |
| idSideMap, typeVisibilityMap, typeBoundingRectsMap); |
| |
| // IME won't be reported in max insets as the size depends on the EditorInfo of the IME |
| // target. |
| if (type != WindowInsets.Type.ime()) { |
| InsetsSource ignoringVisibilitySource = ignoringVisibilityState != null |
| ? ignoringVisibilityState.peekSource(source.getId()) |
| : source; |
| if (ignoringVisibilitySource == null) { |
| continue; |
| } |
| processSource(ignoringVisibilitySource, relativeFrameMax, |
| true /* ignoreVisibility */, typeMaxInsetsMap, null /* idSideMap */, |
| null /* typeVisibilityMap */, typeMaxBoundingRectsMap); |
| } |
| } |
| final int softInputAdjustMode = legacySoftInputMode & SOFT_INPUT_MASK_ADJUST; |
| |
| @InsetsType int compatInsetsTypes = systemBars() | displayCutout(); |
| if (softInputAdjustMode == SOFT_INPUT_ADJUST_RESIZE) { |
| compatInsetsTypes |= ime(); |
| } |
| if ((legacyWindowFlags & FLAG_FULLSCREEN) != 0) { |
| compatInsetsTypes &= ~statusBars(); |
| } |
| if (clearsCompatInsets(windowType, legacyWindowFlags, activityType, forceConsumingTypes)) { |
| compatInsetsTypes = 0; |
| } |
| |
| return new WindowInsets(typeInsetsMap, typeMaxInsetsMap, typeVisibilityMap, isScreenRound, |
| forceConsumingTypes, suppressScrimTypes, calculateRelativeCutout(frame), |
| calculateRelativeRoundedCorners(frame), |
| calculateRelativePrivacyIndicatorBounds(frame), |
| calculateRelativeDisplayShape(frame), |
| compatInsetsTypes, (legacySystemUiFlags & SYSTEM_UI_FLAG_LAYOUT_STABLE) != 0, |
| typeBoundingRectsMap, typeMaxBoundingRectsMap, frame.width(), frame.height()); |
| } |
| |
| private DisplayCutout calculateRelativeCutout(Rect frame) { |
| final DisplayCutout raw = mDisplayCutout.get(); |
| if (mDisplayFrame.equals(frame)) { |
| return raw; |
| } |
| if (frame == null) { |
| return DisplayCutout.NO_CUTOUT; |
| } |
| final int insetLeft = frame.left - mDisplayFrame.left; |
| final int insetTop = frame.top - mDisplayFrame.top; |
| final int insetRight = mDisplayFrame.right - frame.right; |
| final int insetBottom = mDisplayFrame.bottom - frame.bottom; |
| if (insetLeft >= raw.getSafeInsetLeft() |
| && insetTop >= raw.getSafeInsetTop() |
| && insetRight >= raw.getSafeInsetRight() |
| && insetBottom >= raw.getSafeInsetBottom()) { |
| return DisplayCutout.NO_CUTOUT; |
| } |
| return raw.inset(insetLeft, insetTop, insetRight, insetBottom); |
| } |
| |
| private RoundedCorners calculateRelativeRoundedCorners(Rect frame) { |
| if (frame == null) { |
| return RoundedCorners.NO_ROUNDED_CORNERS; |
| } |
| // If mRoundedCornerFrame is set, we should calculate the new RoundedCorners based on this |
| // frame. |
| final Rect roundedCornerFrame = new Rect(mRoundedCornerFrame); |
| for (int i = mSources.size() - 1; i >= 0; i--) { |
| final InsetsSource source = mSources.valueAt(i); |
| if (source.hasFlags(FLAG_INSETS_ROUNDED_CORNER)) { |
| final Insets insets = source.calculateInsets(roundedCornerFrame, false); |
| roundedCornerFrame.inset(insets); |
| } |
| } |
| if (!roundedCornerFrame.isEmpty() && !roundedCornerFrame.equals(mDisplayFrame)) { |
| return mRoundedCorners.insetWithFrame(frame, roundedCornerFrame); |
| } |
| if (mDisplayFrame.equals(frame)) { |
| return mRoundedCorners; |
| } |
| final int insetLeft = frame.left - mDisplayFrame.left; |
| final int insetTop = frame.top - mDisplayFrame.top; |
| final int insetRight = mDisplayFrame.right - frame.right; |
| final int insetBottom = mDisplayFrame.bottom - frame.bottom; |
| return mRoundedCorners.inset(insetLeft, insetTop, insetRight, insetBottom); |
| } |
| |
| private PrivacyIndicatorBounds calculateRelativePrivacyIndicatorBounds(Rect frame) { |
| if (mDisplayFrame.equals(frame)) { |
| return mPrivacyIndicatorBounds; |
| } |
| if (frame == null) { |
| return null; |
| } |
| final int insetLeft = frame.left - mDisplayFrame.left; |
| final int insetTop = frame.top - mDisplayFrame.top; |
| final int insetRight = mDisplayFrame.right - frame.right; |
| final int insetBottom = mDisplayFrame.bottom - frame.bottom; |
| return mPrivacyIndicatorBounds.inset(insetLeft, insetTop, insetRight, insetBottom); |
| } |
| |
| private DisplayShape calculateRelativeDisplayShape(Rect frame) { |
| if (mDisplayFrame.equals(frame)) { |
| return mDisplayShape; |
| } |
| if (frame == null) { |
| return DisplayShape.NONE; |
| } |
| return mDisplayShape.setOffset(-frame.left, -frame.top); |
| } |
| |
| public Insets calculateInsets(Rect frame, @InsetsType int types, boolean ignoreVisibility) { |
| Insets insets = Insets.NONE; |
| for (int i = mSources.size() - 1; i >= 0; i--) { |
| final InsetsSource source = mSources.valueAt(i); |
| if ((source.getType() & types) == 0) { |
| continue; |
| } |
| insets = Insets.max(source.calculateInsets(frame, ignoreVisibility), insets); |
| } |
| return insets; |
| } |
| |
| public Insets calculateInsets(Rect frame, @InsetsType int types, |
| @InsetsType int requestedVisibleTypes) { |
| Insets insets = Insets.NONE; |
| for (int i = mSources.size() - 1; i >= 0; i--) { |
| final InsetsSource source = mSources.valueAt(i); |
| if ((source.getType() & types & requestedVisibleTypes) == 0) { |
| continue; |
| } |
| insets = Insets.max(source.calculateInsets(frame, true), insets); |
| } |
| return insets; |
| } |
| |
| public Insets calculateVisibleInsets(Rect frame, int windowType, @ActivityType int activityType, |
| @SoftInputModeFlags int softInputMode, int windowFlags) { |
| final int softInputAdjustMode = softInputMode & SOFT_INPUT_MASK_ADJUST; |
| final int visibleInsetsTypes = softInputAdjustMode != SOFT_INPUT_ADJUST_NOTHING |
| ? systemBars() | ime() |
| : systemBars(); |
| @InsetsType int forceConsumingTypes = 0; |
| Insets insets = Insets.NONE; |
| for (int i = mSources.size() - 1; i >= 0; i--) { |
| final InsetsSource source = mSources.valueAt(i); |
| if ((source.getType() & visibleInsetsTypes) == 0) { |
| continue; |
| } |
| if (source.hasFlags(FLAG_FORCE_CONSUMING)) { |
| forceConsumingTypes |= source.getType(); |
| } |
| insets = Insets.max(source.calculateVisibleInsets(frame), insets); |
| } |
| return clearsCompatInsets(windowType, windowFlags, activityType, forceConsumingTypes) |
| ? Insets.NONE |
| : insets; |
| } |
| |
| /** |
| * Calculate which insets *cannot* be controlled, because the frame does not cover the |
| * respective side of the inset. |
| * |
| * If the frame of our window doesn't cover the entire inset, the control API makes very |
| * little sense, as we don't deal with negative insets. |
| */ |
| @InsetsType |
| public int calculateUncontrollableInsetsFromFrame(Rect frame) { |
| int blocked = 0; |
| for (int i = mSources.size() - 1; i >= 0; i--) { |
| final InsetsSource source = mSources.valueAt(i); |
| if (!canControlSource(frame, source)) { |
| blocked |= source.getType(); |
| } |
| } |
| return blocked; |
| } |
| |
| private static boolean canControlSource(Rect frame, InsetsSource source) { |
| final Insets insets = source.calculateInsets(frame, true /* ignoreVisibility */); |
| final Rect sourceFrame = source.getFrame(); |
| final int sourceWidth = sourceFrame.width(); |
| final int sourceHeight = sourceFrame.height(); |
| return insets.left == sourceWidth || insets.right == sourceWidth |
| || insets.top == sourceHeight || insets.bottom == sourceHeight; |
| } |
| |
| private void processSource(InsetsSource source, Rect relativeFrame, boolean ignoreVisibility, |
| Insets[] typeInsetsMap, @Nullable @InternalInsetsSide SparseIntArray idSideMap, |
| @Nullable boolean[] typeVisibilityMap, Rect[][] typeBoundingRectsMap) { |
| Insets insets = source.calculateInsets(relativeFrame, ignoreVisibility); |
| final Rect[] boundingRects = source.calculateBoundingRects(relativeFrame, ignoreVisibility); |
| |
| final int type = source.getType(); |
| processSourceAsPublicType(source, typeInsetsMap, idSideMap, typeVisibilityMap, |
| typeBoundingRectsMap, insets, boundingRects, type); |
| |
| if (type == Type.MANDATORY_SYSTEM_GESTURES) { |
| // Mandatory system gestures are also system gestures. |
| // TODO: find a way to express this more generally. One option would be to define |
| // Type.systemGestureInsets() as NORMAL | MANDATORY, but then we lose the |
| // ability to set systemGestureInsets() independently from |
| // mandatorySystemGestureInsets() in the Builder. |
| processSourceAsPublicType(source, typeInsetsMap, idSideMap, typeVisibilityMap, |
| typeBoundingRectsMap, insets, boundingRects, Type.SYSTEM_GESTURES); |
| } |
| if (type == Type.CAPTION_BAR) { |
| // Caption should also be gesture and tappable elements. This should not be needed when |
| // the caption is added from the shell, as the shell can add other types at the same |
| // time. |
| processSourceAsPublicType(source, typeInsetsMap, idSideMap, typeVisibilityMap, |
| typeBoundingRectsMap, insets, boundingRects, Type.SYSTEM_GESTURES); |
| processSourceAsPublicType(source, typeInsetsMap, idSideMap, typeVisibilityMap, |
| typeBoundingRectsMap, insets, boundingRects, Type.MANDATORY_SYSTEM_GESTURES); |
| processSourceAsPublicType(source, typeInsetsMap, idSideMap, typeVisibilityMap, |
| typeBoundingRectsMap, insets, boundingRects, Type.TAPPABLE_ELEMENT); |
| } |
| } |
| |
| private void processSourceAsPublicType(InsetsSource source, Insets[] typeInsetsMap, |
| @InternalInsetsSide @Nullable SparseIntArray idSideMap, |
| @Nullable boolean[] typeVisibilityMap, Rect[][] typeBoundingRectsMap, |
| Insets insets, Rect[] boundingRects, int type) { |
| int index = indexOf(type); |
| |
| // Don't put Insets.NONE into typeInsetsMap. Otherwise, two WindowInsets can be considered |
| // as non-equal while they provide the same insets of each type from WindowInsets#getInsets |
| // if one WindowInsets has Insets.NONE for a type and the other has null for the same type. |
| if (!Insets.NONE.equals(insets)) { |
| Insets existing = typeInsetsMap[index]; |
| if (existing == null) { |
| typeInsetsMap[index] = insets; |
| } else { |
| typeInsetsMap[index] = Insets.max(existing, insets); |
| } |
| } |
| |
| if (typeVisibilityMap != null) { |
| typeVisibilityMap[index] = source.isVisible(); |
| } |
| |
| if (idSideMap != null) { |
| @InternalInsetsSide int insetSide = InsetsSource.getInsetSide(insets); |
| if (insetSide != InsetsSource.SIDE_UNKNOWN) { |
| idSideMap.put(source.getId(), insetSide); |
| } |
| } |
| |
| if (typeBoundingRectsMap != null && boundingRects.length > 0) { |
| final Rect[] existing = typeBoundingRectsMap[index]; |
| if (existing == null) { |
| typeBoundingRectsMap[index] = boundingRects; |
| } else { |
| typeBoundingRectsMap[index] = concatenate(existing, boundingRects); |
| } |
| } |
| } |
| |
| private static Rect[] concatenate(Rect[] a, Rect[] b) { |
| final Rect[] c = new Rect[a.length + b.length]; |
| System.arraycopy(a, 0, c, 0, a.length); |
| System.arraycopy(b, 0, c, a.length, b.length); |
| return c; |
| } |
| |
| /** |
| * Gets the source mapped from the ID, or creates one if no such mapping has been made. |
| */ |
| public InsetsSource getOrCreateSource(int id, int type) { |
| InsetsSource source = mSources.get(id); |
| if (source != null) { |
| return source; |
| } |
| source = new InsetsSource(id, type); |
| mSources.put(id, source); |
| return source; |
| } |
| |
| /** |
| * Gets the source mapped from the ID, or <code>null</code> if no such mapping has been made. |
| */ |
| public @Nullable InsetsSource peekSource(int id) { |
| return mSources.get(id); |
| } |
| |
| /** |
| * Given an index in the range <code>0...sourceSize()-1</code>, returns the source ID from the |
| * <code>index</code>th ID-source mapping that this state stores. |
| */ |
| public int sourceIdAt(int index) { |
| return mSources.keyAt(index); |
| } |
| |
| /** |
| * Given an index in the range <code>0...sourceSize()-1</code>, returns the source from the |
| * <code>index</code>th ID-source mapping that this state stores. |
| */ |
| public InsetsSource sourceAt(int index) { |
| return mSources.valueAt(index); |
| } |
| |
| /** |
| * Returns the amount of the sources. |
| */ |
| public int sourceSize() { |
| return mSources.size(); |
| } |
| |
| /** |
| * Returns if the source is visible or the type is default visible and the source doesn't exist. |
| * |
| * @param id The ID of the source. |
| * @param type The {@link InsetsType} to see if it is default visible. |
| * @return {@code true} if the source is visible or the type is default visible and the source |
| * doesn't exist. |
| */ |
| public boolean isSourceOrDefaultVisible(int id, @InsetsType int type) { |
| final InsetsSource source = mSources.get(id); |
| return source != null ? source.isVisible() : (type & Type.defaultVisible()) != 0; |
| } |
| |
| public void setDisplayFrame(Rect frame) { |
| mDisplayFrame.set(frame); |
| } |
| |
| public Rect getDisplayFrame() { |
| return mDisplayFrame; |
| } |
| |
| public void setDisplayCutout(DisplayCutout cutout) { |
| mDisplayCutout.set(cutout); |
| } |
| |
| public DisplayCutout getDisplayCutout() { |
| return mDisplayCutout.get(); |
| } |
| |
| public void getDisplayCutoutSafe(Rect outBounds) { |
| outBounds.set( |
| WindowLayout.MIN_X, WindowLayout.MIN_Y, WindowLayout.MAX_X, WindowLayout.MAX_Y); |
| final DisplayCutout cutout = mDisplayCutout.get(); |
| final Rect displayFrame = mDisplayFrame; |
| if (!cutout.isEmpty()) { |
| if (cutout.getSafeInsetLeft() > 0) { |
| outBounds.left = displayFrame.left + cutout.getSafeInsetLeft(); |
| } |
| if (cutout.getSafeInsetTop() > 0) { |
| outBounds.top = displayFrame.top + cutout.getSafeInsetTop(); |
| } |
| if (cutout.getSafeInsetRight() > 0) { |
| outBounds.right = displayFrame.right - cutout.getSafeInsetRight(); |
| } |
| if (cutout.getSafeInsetBottom() > 0) { |
| outBounds.bottom = displayFrame.bottom - cutout.getSafeInsetBottom(); |
| } |
| } |
| } |
| |
| public void setRoundedCorners(RoundedCorners roundedCorners) { |
| mRoundedCorners = roundedCorners; |
| } |
| |
| public RoundedCorners getRoundedCorners() { |
| return mRoundedCorners; |
| } |
| |
| /** |
| * Set the frame that will be used to calculate the rounded corners. |
| * |
| * @see #mRoundedCornerFrame |
| */ |
| public void setRoundedCornerFrame(Rect frame) { |
| mRoundedCornerFrame.set(frame); |
| } |
| |
| public void setPrivacyIndicatorBounds(PrivacyIndicatorBounds bounds) { |
| mPrivacyIndicatorBounds = bounds; |
| } |
| |
| public PrivacyIndicatorBounds getPrivacyIndicatorBounds() { |
| return mPrivacyIndicatorBounds; |
| } |
| |
| public void setDisplayShape(DisplayShape displayShape) { |
| mDisplayShape = displayShape; |
| } |
| |
| public DisplayShape getDisplayShape() { |
| return mDisplayShape; |
| } |
| |
| /** |
| * Removes the source which has the ID from this state, if there was any. |
| * |
| * @param id The ID of the source to remove. |
| */ |
| public void removeSource(int id) { |
| mSources.delete(id); |
| } |
| |
| /** |
| * Removes the source at the specified index. |
| * |
| * @param index The index of the source to remove. |
| */ |
| public void removeSourceAt(int index) { |
| mSources.removeAt(index); |
| } |
| |
| /** |
| * A shortcut for setting the visibility of the source. |
| * |
| * @param id The ID of the source to set the visibility |
| * @param visible {@code true} for visible |
| */ |
| public void setSourceVisible(int id, boolean visible) { |
| final InsetsSource source = mSources.get(id); |
| if (source != null) { |
| source.setVisible(visible); |
| } |
| } |
| |
| /** |
| * Scales the frame and the visible frame (if there is one) of each source. |
| * |
| * @param scale the scale to be applied |
| */ |
| public void scale(float scale) { |
| mDisplayFrame.scale(scale); |
| mDisplayCutout.scale(scale); |
| mRoundedCorners = mRoundedCorners.scale(scale); |
| mRoundedCornerFrame.scale(scale); |
| mPrivacyIndicatorBounds = mPrivacyIndicatorBounds.scale(scale); |
| mDisplayShape = mDisplayShape.setScale(scale); |
| for (int i = mSources.size() - 1; i >= 0; i--) { |
| final InsetsSource source = mSources.valueAt(i); |
| source.getFrame().scale(scale); |
| final Rect visibleFrame = source.getVisibleFrame(); |
| if (visibleFrame != null) { |
| visibleFrame.scale(scale); |
| } |
| } |
| } |
| |
| public void set(InsetsState other) { |
| set(other, false /* copySources */); |
| } |
| |
| public void set(InsetsState other, boolean copySources) { |
| mDisplayFrame.set(other.mDisplayFrame); |
| mDisplayCutout.set(other.mDisplayCutout); |
| mRoundedCorners = other.getRoundedCorners(); |
| mRoundedCornerFrame.set(other.mRoundedCornerFrame); |
| mPrivacyIndicatorBounds = other.getPrivacyIndicatorBounds(); |
| mDisplayShape = other.getDisplayShape(); |
| mSources.clear(); |
| for (int i = 0, size = other.mSources.size(); i < size; i++) { |
| final InsetsSource otherSource = other.mSources.valueAt(i); |
| mSources.append(otherSource.getId(), copySources |
| ? new InsetsSource(otherSource) |
| : otherSource); |
| } |
| } |
| |
| /** |
| * Sets the values from the other InsetsState. But for sources, only specific types of source |
| * would be set. |
| * |
| * @param other the other InsetsState. |
| * @param types the only types of sources would be set. |
| */ |
| public void set(InsetsState other, @InsetsType int types) { |
| mDisplayFrame.set(other.mDisplayFrame); |
| mDisplayCutout.set(other.mDisplayCutout); |
| mRoundedCorners = other.getRoundedCorners(); |
| mRoundedCornerFrame.set(other.mRoundedCornerFrame); |
| mPrivacyIndicatorBounds = other.getPrivacyIndicatorBounds(); |
| mDisplayShape = other.getDisplayShape(); |
| if (types == 0) { |
| return; |
| } |
| for (int i = mSources.size() - 1; i >= 0; i--) { |
| final InsetsSource source = mSources.valueAt(i); |
| if ((source.getType() & types) != 0) { |
| mSources.removeAt(i); |
| } |
| } |
| for (int i = other.mSources.size() - 1; i >= 0; i--) { |
| final InsetsSource otherSource = other.mSources.valueAt(i); |
| if ((otherSource.getType() & types) != 0) { |
| mSources.put(otherSource.getId(), otherSource); |
| } |
| } |
| } |
| |
| public void addSource(InsetsSource source) { |
| mSources.put(source.getId(), source); |
| } |
| |
| public static boolean clearsCompatInsets(int windowType, int windowFlags, |
| @ActivityType int activityType, @InsetsType int forceConsumingTypes) { |
| return (windowFlags & FLAG_LAYOUT_NO_LIMITS) != 0 |
| // For compatibility reasons, this excludes the wallpaper, the system error windows, |
| // and the app windows while any system bar is forcibly consumed. |
| && windowType != TYPE_WALLPAPER && windowType != TYPE_SYSTEM_ERROR |
| // This ensures the app content won't be obscured by compat insets even if the app |
| // has FLAG_LAYOUT_NO_LIMITS. |
| && (forceConsumingTypes == 0 || activityType != ACTIVITY_TYPE_STANDARD); |
| } |
| |
| public void dump(String prefix, PrintWriter pw) { |
| final String newPrefix = prefix + " "; |
| pw.println(prefix + "InsetsState"); |
| pw.println(newPrefix + "mDisplayFrame=" + mDisplayFrame); |
| pw.println(newPrefix + "mDisplayCutout=" + mDisplayCutout.get()); |
| pw.println(newPrefix + "mRoundedCorners=" + mRoundedCorners); |
| pw.println(newPrefix + "mRoundedCornerFrame=" + mRoundedCornerFrame); |
| pw.println(newPrefix + "mPrivacyIndicatorBounds=" + mPrivacyIndicatorBounds); |
| pw.println(newPrefix + "mDisplayShape=" + mDisplayShape); |
| for (int i = 0, size = mSources.size(); i < size; i++) { |
| mSources.valueAt(i).dump(newPrefix + " ", pw); |
| } |
| } |
| |
| void dumpDebug(ProtoOutputStream proto, long fieldId) { |
| final long token = proto.start(fieldId); |
| final InsetsSource source = mSources.get(InsetsSource.ID_IME); |
| if (source != null) { |
| source.dumpDebug(proto, SOURCES); |
| } |
| mDisplayFrame.dumpDebug(proto, DISPLAY_FRAME); |
| mDisplayCutout.get().dumpDebug(proto, DISPLAY_CUTOUT); |
| proto.end(token); |
| } |
| |
| @Override |
| public boolean equals(@Nullable Object o) { |
| return equals(o, false, false); |
| } |
| |
| /** |
| * An equals method can exclude the caption insets. This is useful because we assemble the |
| * caption insets information on the client side, and when we communicate with server, it's |
| * excluded. |
| * @param excludesCaptionBar If {@link Type#captionBar()}} should be ignored. |
| * @param excludesInvisibleIme If {@link WindowInsets.Type#ime()} should be ignored when IME is |
| * not visible. |
| * @return {@code true} if the two InsetsState objects are equal, {@code false} otherwise. |
| */ |
| @VisibleForTesting |
| public boolean equals(@Nullable Object o, boolean excludesCaptionBar, |
| boolean excludesInvisibleIme) { |
| if (this == o) { return true; } |
| if (o == null || getClass() != o.getClass()) { return false; } |
| |
| InsetsState state = (InsetsState) o; |
| |
| if (!mDisplayFrame.equals(state.mDisplayFrame) |
| || !mDisplayCutout.equals(state.mDisplayCutout) |
| || !mRoundedCorners.equals(state.mRoundedCorners) |
| || !mRoundedCornerFrame.equals(state.mRoundedCornerFrame) |
| || !mPrivacyIndicatorBounds.equals(state.mPrivacyIndicatorBounds) |
| || !mDisplayShape.equals(state.mDisplayShape)) { |
| return false; |
| } |
| |
| final SparseArray<InsetsSource> thisSources = mSources; |
| final SparseArray<InsetsSource> thatSources = state.mSources; |
| if (!excludesCaptionBar && !excludesInvisibleIme) { |
| return thisSources.contentEquals(thatSources); |
| } else { |
| final int thisSize = thisSources.size(); |
| final int thatSize = thatSources.size(); |
| int thisIndex = 0; |
| int thatIndex = 0; |
| while (thisIndex < thisSize || thatIndex < thatSize) { |
| InsetsSource thisSource = thisIndex < thisSize |
| ? thisSources.valueAt(thisIndex) |
| : null; |
| |
| // Seek to the next non-excluding source of ours. |
| while (thisSource != null |
| && (excludesCaptionBar && thisSource.getType() == captionBar() |
| || excludesInvisibleIme && thisSource.getType() == ime() |
| && !thisSource.isVisible())) { |
| thisIndex++; |
| thisSource = thisIndex < thisSize ? thisSources.valueAt(thisIndex) : null; |
| } |
| |
| InsetsSource thatSource = thatIndex < thatSize |
| ? thatSources.valueAt(thatIndex) |
| : null; |
| |
| // Seek to the next non-excluding source of theirs. |
| while (thatSource != null |
| && (excludesCaptionBar && thatSource.getType() == captionBar() |
| || excludesInvisibleIme && thatSource.getType() == ime() |
| && !thatSource.isVisible())) { |
| thatIndex++; |
| thatSource = thatIndex < thatSize ? thatSources.valueAt(thatIndex) : null; |
| } |
| |
| if (!Objects.equals(thisSource, thatSource)) { |
| return false; |
| } |
| |
| thisIndex++; |
| thatIndex++; |
| } |
| return true; |
| } |
| } |
| |
| @Override |
| public int hashCode() { |
| return Objects.hash(mDisplayFrame, mDisplayCutout, mSources.contentHashCode(), |
| mRoundedCorners, mPrivacyIndicatorBounds, mRoundedCornerFrame, mDisplayShape); |
| } |
| |
| public InsetsState(Parcel in) { |
| mSources = readFromParcel(in); |
| } |
| |
| @Override |
| public int describeContents() { |
| return 0; |
| } |
| |
| @Override |
| public void writeToParcel(Parcel dest, int flags) { |
| mDisplayFrame.writeToParcel(dest, flags); |
| mDisplayCutout.writeToParcel(dest, flags); |
| dest.writeTypedObject(mRoundedCorners, flags); |
| mRoundedCornerFrame.writeToParcel(dest, flags); |
| dest.writeTypedObject(mPrivacyIndicatorBounds, flags); |
| dest.writeTypedObject(mDisplayShape, flags); |
| final int size = mSources.size(); |
| dest.writeInt(size); |
| for (int i = 0; i < size; i++) { |
| dest.writeTypedObject(mSources.valueAt(i), flags); |
| } |
| } |
| |
| public static final @NonNull Creator<InsetsState> CREATOR = new Creator<>() { |
| |
| public InsetsState createFromParcel(Parcel in) { |
| return new InsetsState(in); |
| } |
| |
| public InsetsState[] newArray(int size) { |
| return new InsetsState[size]; |
| } |
| }; |
| |
| public SparseArray<InsetsSource> readFromParcel(Parcel in) { |
| mDisplayFrame.readFromParcel(in); |
| mDisplayCutout.readFromParcel(in); |
| mRoundedCorners = in.readTypedObject(RoundedCorners.CREATOR); |
| mRoundedCornerFrame.readFromParcel(in); |
| mPrivacyIndicatorBounds = in.readTypedObject(PrivacyIndicatorBounds.CREATOR); |
| mDisplayShape = in.readTypedObject(DisplayShape.CREATOR); |
| final int size = in.readInt(); |
| final SparseArray<InsetsSource> sources; |
| if (mSources == null) { |
| // We are constructing this InsetsState. |
| sources = new SparseArray<>(size); |
| } else { |
| sources = mSources; |
| sources.clear(); |
| } |
| for (int i = 0; i < size; i++) { |
| final InsetsSource source = in.readTypedObject(InsetsSource.CREATOR); |
| sources.append(source.getId(), source); |
| } |
| return sources; |
| } |
| |
| @Override |
| public String toString() { |
| final StringJoiner joiner = new StringJoiner(", "); |
| for (int i = 0, size = mSources.size(); i < size; i++) { |
| joiner.add(mSources.valueAt(i).toString()); |
| } |
| return "InsetsState: {" |
| + "mDisplayFrame=" + mDisplayFrame |
| + ", mDisplayCutout=" + mDisplayCutout |
| + ", mRoundedCorners=" + mRoundedCorners |
| + " mRoundedCornerFrame=" + mRoundedCornerFrame |
| + ", mPrivacyIndicatorBounds=" + mPrivacyIndicatorBounds |
| + ", mDisplayShape=" + mDisplayShape |
| + ", mSources= { " + joiner |
| + " }"; |
| } |
| |
| /** |
| * Traverses sources in two {@link InsetsState}s and calls back when events defined in |
| * {@link OnTraverseCallbacks} happen. This is optimized for {@link SparseArray} that we avoid |
| * triggering the binary search while getting the key or the value. |
| * |
| * This can be used to copy attributes of sources from one InsetsState to the other one, or to |
| * remove sources existing in one InsetsState but not in the other one. |
| * |
| * @param state1 The first {@link InsetsState} to be traversed. |
| * @param state2 The second {@link InsetsState} to be traversed. |
| * @param cb The {@link OnTraverseCallbacks} to call back to the caller. |
| */ |
| public static void traverse(InsetsState state1, InsetsState state2, OnTraverseCallbacks cb) { |
| cb.onStart(state1, state2); |
| final int size1 = state1.sourceSize(); |
| final int size2 = state2.sourceSize(); |
| int index1 = 0; |
| int index2 = 0; |
| while (index1 < size1 && index2 < size2) { |
| int id1 = state1.sourceIdAt(index1); |
| int id2 = state2.sourceIdAt(index2); |
| while (id1 != id2) { |
| if (id1 < id2) { |
| cb.onIdNotFoundInState2(index1, state1.sourceAt(index1)); |
| index1++; |
| if (index1 < size1) { |
| id1 = state1.sourceIdAt(index1); |
| } else { |
| break; |
| } |
| } else { |
| cb.onIdNotFoundInState1(index2, state2.sourceAt(index2)); |
| index2++; |
| if (index2 < size2) { |
| id2 = state2.sourceIdAt(index2); |
| } else { |
| break; |
| } |
| } |
| } |
| if (index1 >= size1 || index2 >= size2) { |
| break; |
| } |
| final InsetsSource source1 = state1.sourceAt(index1); |
| final InsetsSource source2 = state2.sourceAt(index2); |
| cb.onIdMatch(source1, source2); |
| index1++; |
| index2++; |
| } |
| while (index2 < size2) { |
| cb.onIdNotFoundInState1(index2, state2.sourceAt(index2)); |
| index2++; |
| } |
| while (index1 < size1) { |
| cb.onIdNotFoundInState2(index1, state1.sourceAt(index1)); |
| index1++; |
| } |
| cb.onFinish(state1, state2); |
| } |
| |
| /** |
| * Used with {@link #traverse(InsetsState, InsetsState, OnTraverseCallbacks)} to call back when |
| * certain events happen. |
| */ |
| public interface OnTraverseCallbacks { |
| |
| /** |
| * Called at the beginning of the traverse. |
| * |
| * @param state1 same as the state1 supplied to {@link #traverse} |
| * @param state2 same as the state2 supplied to {@link #traverse} |
| */ |
| default void onStart(InsetsState state1, InsetsState state2) { } |
| |
| /** |
| * Called when finding two IDs from two InsetsStates are the same. |
| * |
| * @param source1 the source in state1. |
| * @param source2 the source in state2. |
| */ |
| default void onIdMatch(InsetsSource source1, InsetsSource source2) { } |
| |
| /** |
| * Called when finding an ID in state2 but not in state1. |
| * |
| * @param index2 the index of the ID in state2. |
| * @param source2 the source which has the ID in state2. |
| */ |
| default void onIdNotFoundInState1(int index2, InsetsSource source2) { } |
| |
| /** |
| * Called when finding an ID in state1 but not in state2. |
| * |
| * @param index1 the index of the ID in state1. |
| * @param source1 the source which has the ID in state1. |
| */ |
| default void onIdNotFoundInState2(int index1, InsetsSource source1) { } |
| |
| /** |
| * Called at the end of the traverse. |
| * |
| * @param state1 same as the state1 supplied to {@link #traverse} |
| * @param state2 same as the state2 supplied to {@link #traverse} |
| */ |
| default void onFinish(InsetsState state1, InsetsState state2) { } |
| } |
| } |
| |
