[DO NOT MERGE]Support rounded corner for multi-display devices am: 6603444a76 (bae802cf) · Commits · e / os / android_frameworks_base

core/java/android/util/DisplayUtils.java

0 → 100644

+54 −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.util;

		import android.content.res.Resources;

		import com.android.internal.R;

		/**
		* Utils for loading resources for multi-display.
		*
		* @hide
		*/
		public class DisplayUtils {

		/**
		* Gets the index of the given display unique id in {@link R.array#config_displayUniqueIdArray}
		* which is used to get the related cutout configs for that display.
		*
		* For multi-display device, {@link R.array#config_displayUniqueIdArray} should be set for each
		* display if there are different type of cutouts on each display.
		* For single display device, {@link R.array#config_displayUniqueIdArray} should not to be set
		* and the system will load the default configs for main built-in display.
		*/
		public static int getDisplayUniqueIdConfigIndex(Resources res, String displayUniqueId) {
		int index = -1;
		if (displayUniqueId == null \|\| displayUniqueId.isEmpty()) {
		return index;
		}
		final String[] ids = res.getStringArray(R.array.config_displayUniqueIdArray);
		final int size = ids.length;
		for (int i = 0; i < size; i++) {
		if (displayUniqueId.equals(ids[i])) {
		index = i;
		break;
		}
		}
		return index;
		}
		}

core/java/android/view/DisplayCutout.java

+6 −30

Original line number	Diff line number	Diff line
		@@ -39,6 +39,7 @@ import android.graphics.Rect;
		import android.os.Parcel;
		import android.os.Parcelable;
		import android.text.TextUtils;
		import android.util.DisplayUtils;
		import android.util.Pair;
		import android.util.RotationUtils;
		import android.util.proto.ProtoOutputStream;
		@@ -873,31 +874,6 @@ public final class DisplayCutout {
		false /* copyArguments */);
		}

		/**
		* Gets the index of the given display unique id in {@link R.array#config_displayUniqueIdArray}
		* which is used to get the related cutout configs for that display.
		*
		* For multi-display device, {@link R.array#config_displayUniqueIdArray} should be set for each
		* display if there are different type of cutouts on each display.
		* For single display device, {@link R.array#config_displayUniqueIdArray} should not to be set
		* and the system will load the default configs for main built-in display.
		*/
		private static int getDisplayCutoutConfigIndex(Resources res, String displayUniqueId) {
		int index = -1;
		if (displayUniqueId == null \|\| displayUniqueId.isEmpty()) {
		return index;
		}
		final String[] ids = res.getStringArray(R.array.config_displayUniqueIdArray);
		final int size = ids.length;
		for (int i = 0; i < size; i++) {
		if (displayUniqueId.equals(ids[i])) {
		index = i;
		break;
		}
		}
		return index;
		}

		/**
		* Gets the display cutout by the given display unique id.
		*
		@@ -905,7 +881,7 @@ public final class DisplayCutout {
		* {@link R.array#config_displayUniqueIdArray} is not set.
		*/
		private static String getDisplayCutoutPath(Resources res, String displayUniqueId) {
		final int index = getDisplayCutoutConfigIndex(res, displayUniqueId);
		final int index = DisplayUtils.getDisplayUniqueIdConfigIndex(res, displayUniqueId);
		final String[] array = res.getStringArray(R.array.config_displayCutoutPathArray);
		if (index >= 0 && index < array.length) {
		return array[index];
		@@ -920,7 +896,7 @@ public final class DisplayCutout {
		* {@link R.array#config_displayUniqueIdArray} is not set.
		*/
		private static String getDisplayCutoutApproximationRect(Resources res, String displayUniqueId) {
		final int index = getDisplayCutoutConfigIndex(res, displayUniqueId);
		final int index = DisplayUtils.getDisplayUniqueIdConfigIndex(res, displayUniqueId);
		final String[] array = res.getStringArray(
		R.array.config_displayCutoutApproximationRectArray);
		if (index >= 0 && index < array.length) {
		@@ -939,7 +915,7 @@ public final class DisplayCutout {
		* @hide
		*/
		public static boolean getMaskBuiltInDisplayCutout(Resources res, String displayUniqueId) {
		final int index = getDisplayCutoutConfigIndex(res, displayUniqueId);
		final int index = DisplayUtils.getDisplayUniqueIdConfigIndex(res, displayUniqueId);
		final TypedArray array = res.obtainTypedArray(R.array.config_maskBuiltInDisplayCutoutArray);
		boolean maskCutout;
		if (index >= 0 && index < array.length()) {
		@@ -961,7 +937,7 @@ public final class DisplayCutout {
		* @hide
		*/
		public static boolean getFillBuiltInDisplayCutout(Resources res, String displayUniqueId) {
		final int index = getDisplayCutoutConfigIndex(res, displayUniqueId);
		final int index = DisplayUtils.getDisplayUniqueIdConfigIndex(res, displayUniqueId);
		final TypedArray array = res.obtainTypedArray(R.array.config_fillBuiltInDisplayCutoutArray);
		boolean fillCutout;
		if (index >= 0 && index < array.length()) {
		@@ -984,7 +960,7 @@ public final class DisplayCutout {
		*/
		private static Insets getWaterfallInsets(Resources res, String displayUniqueId) {
		Insets insets;
		final int index = getDisplayCutoutConfigIndex(res, displayUniqueId);
		final int index = DisplayUtils.getDisplayUniqueIdConfigIndex(res, displayUniqueId);
		final TypedArray array = res.obtainTypedArray(R.array.config_waterfallCutoutArray);
		if (index >= 0 && index < array.length() && array.getResourceId(index, 0) > 0) {
		final int resourceId = array.getResourceId(index, 0);

core/java/android/view/RoundedCorners.java

+168 −6

Original line number	Diff line number	Diff line
		@@ -27,9 +27,11 @@ import static android.view.Surface.ROTATION_90;
		import android.annotation.NonNull;
		import android.annotation.Nullable;
		import android.content.res.Resources;
		import android.content.res.TypedArray;
		import android.graphics.Point;
		import android.os.Parcel;
		import android.os.Parcelable;
		import android.util.DisplayUtils;
		import android.util.Pair;
		import android.view.RoundedCorner.Position;

		@@ -94,8 +96,8 @@ public class RoundedCorners implements Parcelable {
		* @android:dimen/rounded_corner_radius_top and @android:dimen/rounded_corner_radius_bottom
		*/
		public static RoundedCorners fromResources(
		Resources res, int displayWidth, int displayHeight) {
		return fromRadii(loadRoundedCornerRadii(res), displayWidth, displayHeight);
		Resources res, String displayUniqueId, int displayWidth, int displayHeight) {
		return fromRadii(loadRoundedCornerRadii(res, displayUniqueId), displayWidth, displayHeight);
		}

		/**
		@@ -140,14 +142,16 @@ public class RoundedCorners implements Parcelable {
		* Loads the rounded corner radii from resources.
		*
		* @param res
		* @param displayUniqueId the display unique id.
		* @return a Pair of radius. The first is the top rounded corner radius and second is the
		* bottom corner radius.
		*/
		@Nullable
		private static Pair<Integer, Integer> loadRoundedCornerRadii(Resources res) {
		final int radiusDefault = res.getDimensionPixelSize(R.dimen.rounded_corner_radius);
		final int radiusTop = res.getDimensionPixelSize(R.dimen.rounded_corner_radius_top);
		final int radiusBottom = res.getDimensionPixelSize(R.dimen.rounded_corner_radius_bottom);
		private static Pair<Integer, Integer> loadRoundedCornerRadii(
		Resources res, String displayUniqueId) {
		final int radiusDefault = getRoundedCornerRadius(res, displayUniqueId);
		final int radiusTop = getRoundedCornerTopRadius(res, displayUniqueId);
		final int radiusBottom = getRoundedCornerBottomRadius(res, displayUniqueId);
		if (radiusDefault == 0 && radiusTop == 0 && radiusBottom == 0) {
		return null;
		}
		@@ -157,6 +161,164 @@ public class RoundedCorners implements Parcelable {
		return radii;
		}

		/**
		* Gets the default rounded corner radius of a display which is determined by the
		* given display unique id.
		*
		* Loads the default dimen{@link R.dimen#rounded_corner_radius} if
		* {@link R.array#config_displayUniqueIdArray} is not set.
		*
		* @hide
		*/
		public static int getRoundedCornerRadius(Resources res, String displayUniqueId) {
		final int index = DisplayUtils.getDisplayUniqueIdConfigIndex(res, displayUniqueId);
		final TypedArray array = res.obtainTypedArray(R.array.config_roundedCornerRadiusArray);
		int radius;
		if (index >= 0 && index < array.length()) {
		radius = array.getDimensionPixelSize(index, 0);
		} else {
		radius = res.getDimensionPixelSize(R.dimen.rounded_corner_radius);
		}
		array.recycle();
		return radius;
		}

		/**
		* Gets the top rounded corner radius of a display which is determined by the
		* given display unique id.
		*
		* Loads the default dimen{@link R.dimen#rounded_corner_radius_top} if
		* {@link R.array#config_displayUniqueIdArray} is not set.
		*
		* @hide
		*/
		public static int getRoundedCornerTopRadius(Resources res, String displayUniqueId) {
		final int index = DisplayUtils.getDisplayUniqueIdConfigIndex(res, displayUniqueId);
		final TypedArray array = res.obtainTypedArray(R.array.config_roundedCornerTopRadiusArray);
		int radius;
		if (index >= 0 && index < array.length()) {
		radius = array.getDimensionPixelSize(index, 0);
		} else {
		radius = res.getDimensionPixelSize(R.dimen.rounded_corner_radius_top);
		}
		array.recycle();
		return radius;
		}

		/**
		* Gets the bottom rounded corner radius of a display which is determined by the
		* given display unique id.
		*
		* Loads the default dimen{@link R.dimen#rounded_corner_radius_bottom} if
		* {@link R.array#config_displayUniqueIdArray} is not set.
		*
		* @hide
		*/
		public static int getRoundedCornerBottomRadius(Resources res, String displayUniqueId) {
		final int index = DisplayUtils.getDisplayUniqueIdConfigIndex(res, displayUniqueId);
		final TypedArray array = res.obtainTypedArray(
		R.array.config_roundedCornerBottomRadiusArray);
		int radius;
		if (index >= 0 && index < array.length()) {
		radius = array.getDimensionPixelSize(index, 0);
		} else {
		radius = res.getDimensionPixelSize(R.dimen.rounded_corner_radius_bottom);
		}
		array.recycle();
		return radius;
		}

		/**
		* Gets the rounded corner radius adjustment of a display which is determined by the
		* given display unique id.
		*
		* Loads the default dimen{@link R.dimen#rounded_corner_radius_adjustment} if
		* {@link R.array#config_displayUniqueIdArray} is not set.
		*
		* @hide
		*/
		public static int getRoundedCornerRadiusAdjustment(Resources res, String displayUniqueId) {
		final int index = DisplayUtils.getDisplayUniqueIdConfigIndex(res, displayUniqueId);
		final TypedArray array = res.obtainTypedArray(
		R.array.config_roundedCornerRadiusAdjustmentArray);
		int radius;
		if (index >= 0 && index < array.length()) {
		radius = array.getDimensionPixelSize(index, 0);
		} else {
		radius = res.getDimensionPixelSize(R.dimen.rounded_corner_radius_adjustment);
		}
		array.recycle();
		return radius;
		}

		/**
		* Gets the rounded corner top radius adjustment of a display which is determined by the
		* given display unique id.
		*
		* Loads the default dimen{@link R.dimen#rounded_corner_radius_top_adjustment} if
		* {@link R.array#config_displayUniqueIdArray} is not set.
		*
		* @hide
		*/
		public static int getRoundedCornerRadiusTopAdjustment(Resources res, String displayUniqueId) {
		final int index = DisplayUtils.getDisplayUniqueIdConfigIndex(res, displayUniqueId);
		final TypedArray array = res.obtainTypedArray(
		R.array.config_roundedCornerTopRadiusAdjustmentArray);
		int radius;
		if (index >= 0 && index < array.length()) {
		radius = array.getDimensionPixelSize(index, 0);
		} else {
		radius = res.getDimensionPixelSize(R.dimen.rounded_corner_radius_top_adjustment);
		}
		array.recycle();
		return radius;
		}

		/**
		* Gets the rounded corner bottom radius adjustment of a display which is determined by the
		* given display unique id.
		*
		* Loads the default dimen{@link R.dimen#rounded_corner_radius_bottom_adjustment} if
		* {@link R.array#config_displayUniqueIdArray} is not set.
		*
		* @hide
		*/
		public static int getRoundedCornerRadiusBottomAdjustment(
		Resources res, String displayUniqueId) {
		final int index = DisplayUtils.getDisplayUniqueIdConfigIndex(res, displayUniqueId);
		final TypedArray array = res.obtainTypedArray(
		R.array.config_roundedCornerBottomRadiusAdjustmentArray);
		int radius;
		if (index >= 0 && index < array.length()) {
		radius = array.getDimensionPixelSize(index, 0);
		} else {
		radius = res.getDimensionPixelSize(R.dimen.rounded_corner_radius_bottom_adjustment);
		}
		array.recycle();
		return radius;
		}

		/**
		* Gets whether a built-in display is round.
		*
		* Loads the default config{@link R.bool#config_mainBuiltInDisplayIsRound} if
		* {@link R.array#config_displayUniqueIdArray} is not set.
		*
		* @hide
		*/
		public static boolean getBuiltInDisplayIsRound(Resources res, String displayUniqueId) {
		final int index = DisplayUtils.getDisplayUniqueIdConfigIndex(res, displayUniqueId);
		final TypedArray array = res.obtainTypedArray(R.array.config_builtInDisplayIsRoundArray);
		boolean isRound;
		if (index >= 0 && index < array.length()) {
		isRound = array.getBoolean(index, false);
		} else {
		isRound = res.getBoolean(R.bool.config_mainBuiltInDisplayIsRound);
		}
		array.recycle();
		return isRound;
		}

		/**
		* Insets the reference frame of the rounded corners.
		*

core/java/com/android/internal/policy/ScreenDecorationsUtils.java

+15 −8

Original line number	Diff line number	Diff line
		@@ -16,7 +16,9 @@

		package com.android.internal.policy;

		import android.content.Context;
		import android.content.res.Resources;
		import android.view.RoundedCorners;

		import com.android.internal.R;

		@@ -29,23 +31,28 @@ public class ScreenDecorationsUtils {
		* Corner radius that should be used on windows in order to cover the display.
		* These values are expressed in pixels because they should not respect display or font
		* scaling, this means that we don't have to reload them on config changes.
		*
		* Note that if the context is not an UI context(not associated with Display), it will use
		* default display.
		*/
		public static float getWindowCornerRadius(Resources resources) {
		public static float getWindowCornerRadius(Context context) {
		final Resources resources = context.getResources();
		if (!supportsRoundedCornersOnWindows(resources)) {
		return 0f;
		}

		// Use Context#getDisplayNoVerify() in case the context is not an UI context.
		final String displayUniqueId = context.getDisplayNoVerify().getUniqueId();
		// Radius that should be used in case top or bottom aren't defined.
		float defaultRadius = resources.getDimension(R.dimen.rounded_corner_radius)
		- resources.getDimension(R.dimen.rounded_corner_radius_adjustment);
		float defaultRadius = RoundedCorners.getRoundedCornerRadius(resources, displayUniqueId)
		- RoundedCorners.getRoundedCornerRadiusAdjustment(resources, displayUniqueId);

		float topRadius = resources.getDimension(R.dimen.rounded_corner_radius_top)
		- resources.getDimension(R.dimen.rounded_corner_radius_top_adjustment);
		float topRadius = RoundedCorners.getRoundedCornerTopRadius(resources, displayUniqueId)
		- RoundedCorners.getRoundedCornerRadiusTopAdjustment(resources, displayUniqueId);
		if (topRadius == 0f) {
		topRadius = defaultRadius;
		}
		float bottomRadius = resources.getDimension(R.dimen.rounded_corner_radius_bottom)
		- resources.getDimension(R.dimen.rounded_corner_radius_bottom_adjustment);
		float bottomRadius = RoundedCorners.getRoundedCornerBottomRadius(resources, displayUniqueId)
		- RoundedCorners.getRoundedCornerRadiusBottomAdjustment(resources, displayUniqueId);
		if (bottomRadius == 0f) {
		bottomRadius = defaultRadius;
		}

core/res/res/values/config.xml

+52 −0

Original line number	Diff line number	Diff line
		@@ -5095,6 +5095,14 @@
		- config_fillBuiltInDisplayCutoutArray
		- config_maskBuiltInDisplayCutoutArray
		- config_waterfallCutoutArray
		- config_roundedCornerRadiusArray
		- config_roundedCornerTopRadiusArray
		- config_roundedCornerBottomRadiusArray
		- config_builtInDisplayIsRoundArray (config in SystemUI resource)
		- config_roundedCornerMultipleRadiusArray (config in SystemUI resource)
		- config_roundedCornerDrawableArray (config in SystemUI resource)
		- config_roundedCornerTopDrawableArray (config in SystemUI resource)
		- config_roundedCornerBottomDrawableArray (config in SystemUI resource)

		Leave this array empty for single display device and the system will load the default main
		built-in related configs.
		@@ -5156,4 +5164,48 @@
		This flag should be enabled only when the product does not have any UI to toggle airplane
		mode like automotive devices.-->
		<bool name="config_autoResetAirplaneMode">false</bool>

		<bool name="config_secondaryBuiltInDisplayIsRound">@bool/config_windowIsRound</bool>

		<!-- The display round config for each display in a multi-display device. -->
		<array name="config_builtInDisplayIsRoundArray" translatable="false">
		<item>@bool/config_mainBuiltInDisplayIsRound</item>
		<item>@bool/config_secondaryBuiltInDisplayIsRound</item>
		</array>

		<!-- The rounded corner radius for each display in a multi-display device. -->
		<array name="config_roundedCornerRadiusArray" translatable="false">
		<item>@dimen/rounded_corner_radius</item>
		<item>@dimen/secondary_rounded_corner_radius</item>
		</array>

		<!-- The top rounded corner radius for each display in a multi-display device. -->
		<array name="config_roundedCornerTopRadiusArray" translatable="false">
		<item>@dimen/rounded_corner_radius_top</item>
		<item>@dimen/secondary_rounded_corner_radius_top</item>
		</array>

		<!-- The bottom rounded corner radius for each display in a multi-display device. -->
		<array name="config_roundedCornerBottomRadiusArray" translatable="false">
		<item>@dimen/rounded_corner_radius_bottom</item>
		<item>@dimen/secondary_rounded_corner_radius_bottom</item>
		</array>

		<!-- The rounded corner radius adjustment for each display in a multi-display device. -->
		<array name="config_roundedCornerRadiusAdjustmentArray" translatable="false">
		<item>@dimen/rounded_corner_radius_adjustment</item>
		<item>@dimen/secondary_rounded_corner_radius_adjustment</item>
		</array>

		<!-- The rounded corner radius top adjustment for each display in a multi-display device. -->
		<array name="config_roundedCornerTopRadiusAdjustmentArray" translatable="false">
		<item>@dimen/rounded_corner_radius_top_adjustment</item>
		<item>@dimen/secondary_rounded_corner_radius_top_adjustment</item>
		</array>

		<!-- The rounded corner radius bottom adjustment for each display in a multi-display device. -->
		<array name="config_roundedCornerBottomRadiusAdjustmentArray" translatable="false">
		<item>@dimen/rounded_corner_radius_bottom_adjustment</item>
		<item>@dimen/secondary_rounded_corner_radius_bottom_adjustment</item>
		</array>
		</resources>