Add PrivacyIndicator APIs to WindowInsets (8e762afc) · Commits · e / os / android_frameworks_base

core/api/current.txt

+2 −0

Original line number	Diff line number	Diff line
		@@ -50260,6 +50260,7 @@ package android.view {
		method @NonNull public android.graphics.Insets getInsets(int);
		method @NonNull public android.graphics.Insets getInsetsIgnoringVisibility(int);
		method @Deprecated @NonNull public android.graphics.Insets getMandatorySystemGestureInsets();
		method @Nullable public android.graphics.Rect getPrivacyIndicatorBounds();
		method @Nullable public android.view.RoundedCorner getRoundedCorner(int);
		method @Deprecated public int getStableInsetBottom();
		method @Deprecated public int getStableInsetLeft();
		@@ -50294,6 +50295,7 @@ package android.view {
		method @NonNull public android.view.WindowInsets.Builder setInsets(int, @NonNull android.graphics.Insets);
		method @NonNull public android.view.WindowInsets.Builder setInsetsIgnoringVisibility(int, @NonNull android.graphics.Insets) throws java.lang.IllegalArgumentException;
		method @Deprecated @NonNull public android.view.WindowInsets.Builder setMandatorySystemGestureInsets(@NonNull android.graphics.Insets);
		method @NonNull public android.view.WindowInsets.Builder setPrivacyIndicatorBounds(@Nullable android.graphics.Rect);
		method @NonNull public android.view.WindowInsets.Builder setRoundedCorner(int, @Nullable android.view.RoundedCorner);
		method @Deprecated @NonNull public android.view.WindowInsets.Builder setStableInsets(@NonNull android.graphics.Insets);
		method @Deprecated @NonNull public android.view.WindowInsets.Builder setSystemGestureInsets(@NonNull android.graphics.Insets);

core/java/android/view/IWindowManager.aidl

+7 −0

Original line number	Diff line number	Diff line
		@@ -384,6 +384,13 @@ interface IWindowManager
		*/
		oneway void setRecentsVisibility(boolean visible);

		/**
		* Called by System UI to indicate the maximum bounds of the system Privacy Indicator, for the
		* current orientation, whether the indicator is showing or not. Should be an array of length
		* 4, with the bounds for ROTATION_0, 90, 180, and 270, in that order.
		*/
		oneway void updateStaticPrivacyIndicatorBounds(int displayId, in Rect[] staticBounds);

		/**
		* Called by System UI to enable or disable haptic feedback on the navigation bar buttons.
		*/

core/java/android/view/InsetsController.java

+1 −0

Original line number	Diff line number	Diff line
		@@ -690,6 +690,7 @@ public class InsetsController implements WindowInsetsController, InsetsAnimation
		mState.setDisplayFrame(newState.getDisplayFrame());
		mState.setDisplayCutout(newState.getDisplayCutout());
		mState.setRoundedCorners(newState.getRoundedCorners());
		mState.setPrivacyIndicatorBounds(newState.getPrivacyIndicatorBounds());
		@InsetsType int disabledUserAnimationTypes = 0;
		@InsetsType int[] cancelledUserAnimationTypes = {0};
		for (@InternalInsetsType int type = 0; type < InsetsState.SIZE; type++) {

core/java/android/view/InsetsState.java

+39 −4

Original line number	Diff line number	Diff line
		@@ -171,6 +171,10 @@ public class InsetsState implements Parcelable {
		/** The rounded corners on the display */
		private RoundedCorners mRoundedCorners = RoundedCorners.NO_ROUNDED_CORNERS;

		/** The bounds of the Privacy Indicator */
		private PrivacyIndicatorBounds mPrivacyIndicatorBounds =
		new PrivacyIndicatorBounds();

		public InsetsState() {
		}

		@@ -243,8 +247,9 @@ public class InsetsState implements Parcelable {

		return new WindowInsets(typeInsetsMap, typeMaxInsetsMap, typeVisibilityMap, isScreenRound,
		alwaysConsumeSystemBars, calculateRelativeCutout(frame),
		calculateRelativeRoundedCorners(frame), compatInsetsTypes,
		(legacySystemUiFlags & SYSTEM_UI_FLAG_LAYOUT_STABLE) != 0);
		calculateRelativeRoundedCorners(frame),
		calculateRelativePrivacyIndicatorBounds(frame),
		compatInsetsTypes, (legacySystemUiFlags & SYSTEM_UI_FLAG_LAYOUT_STABLE) != 0);
		}

		private DisplayCutout calculateRelativeCutout(Rect frame) {
		@@ -282,6 +287,20 @@ public class InsetsState implements Parcelable {
		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);
		}

		public Rect calculateInsets(Rect frame, @InsetsType int types, boolean ignoreVisibility) {
		Insets insets = Insets.NONE;
		for (int type = FIRST_TYPE; type <= LAST_TYPE; type++) {
		@@ -471,6 +490,14 @@ public class InsetsState implements Parcelable {
		return mRoundedCorners;
		}

		public void setPrivacyIndicatorBounds(PrivacyIndicatorBounds bounds) {
		mPrivacyIndicatorBounds = bounds;
		}

		public PrivacyIndicatorBounds getPrivacyIndicatorBounds() {
		return mPrivacyIndicatorBounds;
		}

		/**
		* Modifies the state of this class to exclude a certain type to make it ready for dispatching
		* to the client.
		@@ -508,6 +535,7 @@ public class InsetsState implements Parcelable {
		mDisplayFrame.scale(scale);
		mDisplayCutout.scale(scale);
		mRoundedCorners = mRoundedCorners.scale(scale);
		mPrivacyIndicatorBounds = mPrivacyIndicatorBounds.scale(scale);
		for (int i = 0; i < SIZE; i++) {
		final InsetsSource source = mSources[i];
		if (source != null) {
		@@ -528,6 +556,7 @@ public class InsetsState implements Parcelable {
		mDisplayFrame.set(other.mDisplayFrame);
		mDisplayCutout.set(other.mDisplayCutout);
		mRoundedCorners = other.getRoundedCorners();
		mPrivacyIndicatorBounds = other.getPrivacyIndicatorBounds();
		if (copySources) {
		for (int i = 0; i < SIZE; i++) {
		InsetsSource source = other.mSources[i];
		@@ -551,6 +580,7 @@ public class InsetsState implements Parcelable {
		mDisplayFrame.set(other.mDisplayFrame);
		mDisplayCutout.set(other.mDisplayCutout);
		mRoundedCorners = other.getRoundedCorners();
		mPrivacyIndicatorBounds = other.getPrivacyIndicatorBounds();
		final ArraySet<Integer> t = toInternalType(types);
		for (int i = t.size() - 1; i >= 0; i--) {
		final int type = t.valueAt(i);
		@@ -670,6 +700,7 @@ public class InsetsState implements Parcelable {
		pw.println(newPrefix + "mDisplayFrame=" + mDisplayFrame);
		pw.println(newPrefix + "mDisplayCutout=" + mDisplayCutout.get());
		pw.println(newPrefix + "mRoundedCorners=" + mRoundedCorners);
		pw.println(newPrefix + "mPrivacyIndicatorBounds=" + mPrivacyIndicatorBounds);
		for (int i = 0; i < SIZE; i++) {
		InsetsSource source = mSources[i];
		if (source == null) continue;
		@@ -764,7 +795,8 @@ public class InsetsState implements Parcelable {

		if (!mDisplayFrame.equals(state.mDisplayFrame)
		\|\| !mDisplayCutout.equals(state.mDisplayCutout)
		\|\| !mRoundedCorners.equals(state.mRoundedCorners)) {
		\|\| !mRoundedCorners.equals(state.mRoundedCorners)
		\|\| !mPrivacyIndicatorBounds.equals(state.mPrivacyIndicatorBounds)) {
		return false;
		}
		for (int i = 0; i < SIZE; i++) {
		@@ -789,7 +821,7 @@ public class InsetsState implements Parcelable {
		@Override
		public int hashCode() {
		return Objects.hash(mDisplayFrame, mDisplayCutout, Arrays.hashCode(mSources),
		mRoundedCorners);
		mRoundedCorners, mPrivacyIndicatorBounds);
		}

		public InsetsState(Parcel in) {
		@@ -807,6 +839,7 @@ public class InsetsState implements Parcelable {
		mDisplayCutout.writeToParcel(dest, flags);
		dest.writeTypedArray(mSources, 0 /* parcelableFlags */);
		dest.writeTypedObject(mRoundedCorners, flags);
		dest.writeTypedObject(mPrivacyIndicatorBounds, flags);
		}

		public static final @NonNull Creator<InsetsState> CREATOR = new Creator<InsetsState>() {
		@@ -825,6 +858,7 @@ public class InsetsState implements Parcelable {
		mDisplayCutout.readFromParcel(in);
		in.readTypedArray(mSources, InsetsSource.CREATOR);
		mRoundedCorners = in.readTypedObject(RoundedCorners.CREATOR);
		mPrivacyIndicatorBounds = in.readTypedObject(PrivacyIndicatorBounds.CREATOR);
		}

		@Override
		@@ -840,6 +874,7 @@ public class InsetsState implements Parcelable {
		+ "mDisplayFrame=" + mDisplayFrame
		+ ", mDisplayCutout=" + mDisplayCutout
		+ ", mRoundedCorners=" + mRoundedCorners
		+ ", mPrivacyIndicatorBounds=" + mPrivacyIndicatorBounds
		+ ", mSources= { " + joiner
		+ " }";
		}

core/java/android/view/PrivacyIndicatorBounds.java

0 → 100644

+251 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2021 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.Surface.ROTATION_0;

		import android.annotation.NonNull;
		import android.annotation.Nullable;
		import android.graphics.Rect;
		import android.os.Parcelable;

		import com.android.internal.util.ArrayUtils;
		import com.android.internal.util.DataClass;

		/**
		* A class which manages the bounds of the privacy indicator
		*
		* @hide
		*/
		@DataClass(
		genEqualsHashCode = true,
		genConstructor = false,
		genAidl = false,
		genGetters = false
		)
		public class PrivacyIndicatorBounds implements Parcelable {

		private final @NonNull Rect[] mStaticBounds;
		private final int mRotation;

		public PrivacyIndicatorBounds() {
		mStaticBounds = new Rect[4];
		mRotation = ROTATION_0;
		}

		public PrivacyIndicatorBounds(@NonNull Rect[] staticBounds, @Surface.Rotation int rotation) {
		mStaticBounds = staticBounds;
		mRotation = rotation;
		}

		/**
		* Return a PrivacyIndicatorBounds with updated static bounds
		*/
		public PrivacyIndicatorBounds updateStaticBounds(@NonNull Rect[] staticPositions) {
		return new PrivacyIndicatorBounds(staticPositions, mRotation);
		}

		/**
		* Update the bounds of the indicator for a specific rotation, or ROTATION_0, if the provided
		* rotation integer isn't found
		*/
		public PrivacyIndicatorBounds updateBoundsForRotation(@Nullable Rect bounds,
		@Surface.Rotation int rotation) {
		if (rotation >= mStaticBounds.length \|\| rotation < 0) {
		return this;
		}
		Rect[] newBounds = ArrayUtils.cloneOrNull(mStaticBounds);
		newBounds[rotation] = bounds;
		return updateStaticBounds(newBounds);
		}

		/**
		* Return an inset PrivacyIndicatorBounds
		*/
		public PrivacyIndicatorBounds inset(int insetLeft, int insetTop, int insetRight,
		int insetBottom) {
		if (insetLeft == 0 && insetTop == 0 && insetRight == 0 && insetBottom == 0) {
		return this;
		}
		Rect[] insetStaticBounds = new Rect[mStaticBounds.length];
		for (int i = 0; i < mStaticBounds.length; i++) {
		insetStaticBounds[i] =
		insetRect(mStaticBounds[i], insetLeft, insetTop, insetRight, insetBottom);
		}
		return updateStaticBounds(insetStaticBounds);
		}

		private static Rect insetRect(Rect orig, int insetLeft, int insetTop, int insetRight,
		int insetBottom) {
		if (orig == null) {
		return null;
		}
		int left = Math.max(0, orig.left - insetLeft);
		int top = Math.max(0, orig.top - insetTop);
		int right = Math.max(left, orig.right - insetRight);
		int bottom = Math.max(top, orig.bottom - insetBottom);
		return new Rect(left, top, right, bottom);
		}

		/**
		* Return a PrivacyIndicatorBounds with the static position rotated.
		*/
		public PrivacyIndicatorBounds rotate(@Surface.Rotation int rotation) {
		if (rotation == ROTATION_0) {
		return this;
		}
		return new PrivacyIndicatorBounds(mStaticBounds, rotation);
		}

		/**
		* Returns a scaled PrivacyIndicatorBounds
		*/
		public PrivacyIndicatorBounds scale(float scale) {
		if (scale == 1f) {
		return this;
		}

		Rect[] scaledStaticPos = new Rect[mStaticBounds.length];
		for (int i = 0; i < mStaticBounds.length; i++) {
		scaledStaticPos[i] = scaleRect(mStaticBounds[i], scale);
		}
		return new PrivacyIndicatorBounds(scaledStaticPos, mRotation);
		}

		private static Rect scaleRect(Rect orig, float scale) {
		if (orig == null) {
		return null;
		}

		Rect newRect = new Rect(orig);
		newRect.scale(scale);
		return newRect;
		}

		public Rect getStaticPrivacyIndicatorBounds() {
		return mStaticBounds[mRotation];
		}

		@Override
		public String toString() {
		return "PrivacyIndicatorBounds {static bounds=" + getStaticPrivacyIndicatorBounds()
		+ " rotation=" + mRotation + "}";
		}



		// Code below generated by codegen v1.0.23.
		//
		// DO NOT MODIFY!
		// CHECKSTYLE:OFF Generated code
		//
		// To regenerate run:
		// $ codegen $ANDROID_BUILD_TOP/frameworks/base/core/java/android/view/PrivacyIndicatorBounds.java
		//
		// To exclude the generated code from IntelliJ auto-formatting enable (one-time):
		// Settings > Editor > Code Style > Formatter Control
		//@formatter:off


		@Override
		@DataClass.Generated.Member
		public boolean equals(@Nullable Object o) {
		// You can override field equality logic by defining either of the methods like:
		// boolean fieldNameEquals(PrivacyIndicatorBounds other) { ... }
		// boolean fieldNameEquals(FieldType otherValue) { ... }

		if (this == o) return true;
		if (o == null \|\| getClass() != o.getClass()) return false;
		@SuppressWarnings("unchecked")
		PrivacyIndicatorBounds that = (PrivacyIndicatorBounds) o;
		//noinspection PointlessBooleanExpression
		return true
		&& java.util.Arrays.equals(mStaticBounds, that.mStaticBounds)
		&& mRotation == that.mRotation;
		}

		@Override
		@DataClass.Generated.Member
		public int hashCode() {
		// You can override field hashCode logic by defining methods like:
		// int fieldNameHashCode() { ... }

		int _hash = 1;
		_hash = 31 * _hash + java.util.Arrays.hashCode(mStaticBounds);
		_hash = 31 * _hash + mRotation;
		return _hash;
		}

		@Override
		@DataClass.Generated.Member
		public void writeToParcel(@NonNull android.os.Parcel dest, int flags) {
		// You can override field parcelling by defining methods like:
		// void parcelFieldName(Parcel dest, int flags) { ... }

		dest.writeTypedArray(mStaticBounds, flags);
		dest.writeInt(mRotation);
		}

		@Override
		@DataClass.Generated.Member
		public int describeContents() { return 0; }

		/** @hide */
		@SuppressWarnings({"unchecked", "RedundantCast"})
		@DataClass.Generated.Member
		protected PrivacyIndicatorBounds(@NonNull android.os.Parcel in) {
		// You can override field unparcelling by defining methods like:
		// static FieldType unparcelFieldName(Parcel in) { ... }

		Rect[] staticBounds = (Rect[]) in.createTypedArray(Rect.CREATOR);
		int rotation = in.readInt();

		this.mStaticBounds = staticBounds;
		com.android.internal.util.AnnotationValidations.validate(
		NonNull.class, null, mStaticBounds);
		this.mRotation = rotation;

		// onConstructed(); // You can define this method to get a callback
		}

		@DataClass.Generated.Member
		public static final @NonNull Parcelable.Creator<PrivacyIndicatorBounds> CREATOR
		= new Parcelable.Creator<PrivacyIndicatorBounds>() {
		@Override
		public PrivacyIndicatorBounds[] newArray(int size) {
		return new PrivacyIndicatorBounds[size];
		}

		@Override
		public PrivacyIndicatorBounds createFromParcel(@NonNull android.os.Parcel in) {
		return new PrivacyIndicatorBounds(in);
		}
		};

		@DataClass.Generated(
		time = 1621526273838L,
		codegenVersion = "1.0.23",
		sourceFile = "frameworks/base/core/java/android/view/PrivacyIndicatorBounds.java",
		inputSignatures = "private final @android.annotation.NonNull android.graphics.Rect[] mStaticBounds\nprivate final int mRotation\npublic android.view.PrivacyIndicatorBounds updateStaticBounds(android.graphics.Rect[])\npublic android.view.PrivacyIndicatorBounds updateBoundsForRotation(android.graphics.Rect,int)\npublic android.view.PrivacyIndicatorBounds inset(int,int,int,int)\nprivate static android.graphics.Rect insetRect(android.graphics.Rect,int,int,int,int)\npublic android.view.PrivacyIndicatorBounds rotate(int)\npublic android.view.PrivacyIndicatorBounds scale(float)\nprivate static android.graphics.Rect scaleRect(android.graphics.Rect,float)\npublic android.graphics.Rect getStaticPrivacyIndicatorBounds()\npublic @java.lang.Override java.lang.String toString()\nclass PrivacyIndicatorBounds extends java.lang.Object implements [android.os.Parcelable]\n@com.android.internal.util.DataClass(genEqualsHashCode=true, genConstructor=false, genAidl=false, genGetters=false)")
		@Deprecated
		private void __metadata() {}


		//@formatter:on
		// End of generated code

		}