Android/frameworks_base
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

[DO NOT MERGE]Support rounded corner for multi-display devices

Browse Source 
- Add new array configs for every rounded corner configs.
- Update rounded corner drawable when a display changes in
  ScreenDecorations.

Bug: 131221697
Test: atest DisplayCutoutTest RoundedCornersTest LocalDisplayAdapterTest
      ScreenDecorationsTest
Change-Id: I1f32ff680609267010b05a39a5b8e84511bf1243
This commit is contained in:
shawnlin
2021-08-16 16:39:27 +08:00
parent b4e5f03c20
commit 6603444a76
21 changed files with 687 additions and 253 deletions
Download Patch File Download Diff File Expand all files Collapse all files

54
core/java/android/util/DisplayUtils.java Normal file
View File

@@ -0,0 +1,54 @@
/*
* 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;
}
}

36
core/java/android/view/DisplayCutout.java
View File

@@ -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);

174
core/java/android/view/RoundedCorners.java
View File

@@ -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.
*

23
core/java/com/android/internal/policy/ScreenDecorationsUtils.java
View File

@@ -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;
}

52
core/res/res/values/config.xml
View File

@@ -5093,6 +5093,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.
@@ -5154,4 +5162,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>

8
core/res/res/values/dimens.xml
View File

@@ -952,4 +952,12 @@
<dimen name="secondary_waterfall_display_top_edge_size">0px</dimen>
<dimen name="secondary_waterfall_display_right_edge_size">0px</dimen>
<dimen name="secondary_waterfall_display_bottom_edge_size">0px</dimen>
<!-- Rounded corner settings for secondary built-in display -->
<dimen name="secondary_rounded_corner_radius">0px</dimen>
<dimen name="secondary_rounded_corner_radius_top">0px</dimen>
<dimen name="secondary_rounded_corner_radius_bottom">0px</dimen>
<dimen name="secondary_rounded_corner_radius_adjustment">0px</dimen>
<dimen name="secondary_rounded_corner_radius_top_adjustment">0px</dimen>
<dimen name="secondary_rounded_corner_radius_bottom_adjustment">0px</dimen>
</resources>

15
core/res/res/values/symbols.xml
View File

@@ -4449,4 +4449,19 @@
<java-symbol type="array" name="config_mainBuiltInDisplayWaterfallCutout" />
<java-symbol type="array" name="config_secondaryBuiltInDisplayWaterfallCutout" />
<java-symbol type="array" name="config_waterfallCutoutArray" />
<java-symbol type="dimen" name="secondary_rounded_corner_radius" />
<java-symbol type="dimen" name="secondary_rounded_corner_radius_top" />
<java-symbol type="dimen" name="secondary_rounded_corner_radius_bottom" />
<java-symbol type="dimen" name="secondary_rounded_corner_radius_adjustment" />
<java-symbol type="dimen" name="secondary_rounded_corner_radius_top_adjustment" />
<java-symbol type="dimen" name="secondary_rounded_corner_radius_bottom_adjustment" />
<java-symbol type="array" name="config_roundedCornerRadiusArray" />
<java-symbol type="array" name="config_roundedCornerTopRadiusArray" />
<java-symbol type="array" name="config_roundedCornerBottomRadiusArray" />
<java-symbol type="array" name="config_roundedCornerRadiusAdjustmentArray" />
<java-symbol type="array" name="config_roundedCornerTopRadiusAdjustmentArray" />
<java-symbol type="array" name="config_roundedCornerBottomRadiusAdjustmentArray" />
<java-symbol type="bool" name="config_secondaryBuiltInDisplayIsRound" />
<java-symbol type="array" name="config_builtInDisplayIsRoundArray" />
</resources>

2
libs/WindowManager/Shell/src/com/android/wm/shell/draganddrop/DropOutlineDrawable.java
View File

@@ -86,7 +86,7 @@ public class DropOutlineDrawable extends Drawable {
public DropOutlineDrawable(Context context) {
super();
// TODO(b/169894807): Use corner specific radii and maybe lower radius for non-edge corners
mCornerRadius = ScreenDecorationsUtils.getWindowCornerRadius(context.getResources());
mCornerRadius = ScreenDecorationsUtils.getWindowCornerRadius(context);
mColor = context.getColor(R.color.drop_outline_background);
mMaxAlpha = Color.alpha(mColor);
// Initialize as hidden

2
packages/SystemUI/animation/src/com/android/systemui/animation/ActivityLaunchAnimator.kt
View File

@@ -482,7 +482,7 @@ class ActivityLaunchAnimator(
val endRadius = if (isExpandingFullyAbove) {
// Most of the time, expanding fully above the root view means expanding in full
// screen.
ScreenDecorationsUtils.getWindowCornerRadius(context.resources)
ScreenDecorationsUtils.getWindowCornerRadius(context)
} else {
// This usually means we are in split screen mode, so 2 out of 4 corners will have
// a radius of 0.

16
packages/SystemUI/res/drawable/rounded_corner_bottom_secondary.xml Normal file
View File

@@ -0,0 +1,16 @@
<!--
Copyright (C) 2021 The Android Open Source Project
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.
-->
<!-- Overlay this resource to change rounded_corners_bottom -->
<inset xmlns:android="http://schemas.android.com/apk/res/android"
android:drawable="@drawable/rounded_secondary"/>

16
packages/SystemUI/res/drawable/rounded_corner_top_secondary.xml Normal file
View File

@@ -0,0 +1,16 @@
<!--
Copyright (C) 2021 The Android Open Source Project
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.
-->
<!-- Overlay this resource to change rounded_corners_top -->
<inset xmlns:android="http://schemas.android.com/apk/res/android"
android:drawable="@drawable/rounded_secondary"/>

24
packages/SystemUI/res/drawable/rounded_secondary.xml Normal file
View File

@@ -0,0 +1,24 @@
<!--
Copyright (C) 2021 The Android Open Source Project
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.
-->
<vector xmlns:android="http://schemas.android.com/apk/res/android"
android:width="8dp"
android:height="8dp"
android:viewportWidth="8"
android:viewportHeight="8">
<path
android:fillColor="#000000"
android:pathData="M8,0H0v8C0,3.6,3.6,0,8,0z" />
</vector>

32
packages/SystemUI/res/values/config.xml
View File

@@ -679,4 +679,36 @@
<!-- Flag to activate notification to contents feature -->
<bool name="config_notificationToContents">false</bool>
<!-- Respect drawable/rounded_secondary.xml intrinsic size for multiple radius corner path
customization for secondary display-->
<bool name="config_roundedCornerMultipleRadiusSecondary">false</bool>
<!-- Whether the rounded corners are multiple radius for each display in a multi-display device.
{@see com.android.internal.R.array#config_displayUniqueIdArray} -->
<array name="config_roundedCornerMultipleRadiusArray">
<item>@bool/config_roundedCornerMultipleRadius</item>
<item>@bool/config_roundedCornerMultipleRadiusSecondary</item>
</array>
<!-- The rounded corner drawable for each display in a multi-display device.
{@see com.android.internal.R.array#config_displayUniqueIdArray} -->
<array name="config_roundedCornerDrawableArray">
<item>@drawable/rounded</item>
<item>@drawable/rounded_secondary</item>
</array>
<!-- The top rounded corner drawable for each display in a multi-display device.
{@see com.android.internal.R.array#config_displayUniqueIdArray} -->
<array name="config_roundedCornerTopDrawableArray">
<item>@drawable/rounded_corner_top</item>
<item>@drawable/rounded_corner_top_secondary</item>
</array>
<!-- The bottom rounded corner drawable for each display in a multi-display device.
{@see com.android.internal.R.array#config_displayUniqueIdArray} -->
<array name="config_roundedCornerBottomDrawableArray">
<item>@drawable/rounded_corner_bottom</item>
<item>@drawable/rounded_corner_bottom_secondary</item>
</array>
</resources>

4
packages/SystemUI/shared/src/com/android/systemui/shared/system/QuickStepContract.java
View File

@@ -285,8 +285,8 @@ public class QuickStepContract {
* 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.
*/
public static float getWindowCornerRadius(Resources resources) {
return ScreenDecorationsUtils.getWindowCornerRadius(resources);
public static float getWindowCornerRadius(Context context) {
return ScreenDecorationsUtils.getWindowCornerRadius(context);
}
/**

193
packages/SystemUI/src/com/android/systemui/ScreenDecorations.java
View File

@@ -42,6 +42,7 @@ import android.content.IntentFilter;
import android.content.res.ColorStateList;
import android.content.res.Configuration;
import android.content.res.Resources;
import android.content.res.TypedArray;
import android.graphics.Canvas;
import android.graphics.Color;
import android.graphics.Matrix;
@@ -59,6 +60,7 @@ import android.os.SystemProperties;
import android.os.UserHandle;
import android.provider.Settings.Secure;
import android.util.DisplayMetrics;
import android.util.DisplayUtils;
import android.util.Log;
import android.view.Display;
import android.view.DisplayCutout;
@@ -66,6 +68,7 @@ import android.view.DisplayCutout.BoundsPosition;
import android.view.DisplayInfo;
import android.view.Gravity;
import android.view.LayoutInflater;
import android.view.RoundedCorners;
import android.view.Surface;
import android.view.View;
import android.view.View.OnLayoutChangeListener;
@@ -159,6 +162,10 @@ public class ScreenDecorations extends SystemUI implements Tunable {
private boolean mIsRoundedCornerMultipleRadius;
private int mStatusBarHeightPortrait;
private int mStatusBarHeightLandscape;
private Drawable mRoundedCornerDrawable;
private Drawable mRoundedCornerDrawableTop;
private Drawable mRoundedCornerDrawableBottom;
private String mDisplayUniqueId;
private CameraAvailabilityListener.CameraTransitionCallback mCameraTransitionCallback =
new CameraAvailabilityListener.CameraTransitionCallback() {
@@ -244,10 +251,11 @@ public class ScreenDecorations extends SystemUI implements Tunable {
private void startOnScreenDecorationsThread() {
mRotation = mContext.getDisplay().getRotation();
mDisplayUniqueId = mContext.getDisplay().getUniqueId();
mIsRoundedCornerMultipleRadius = isRoundedCornerMultipleRadius(mContext, mDisplayUniqueId);
mWindowManager = mContext.getSystemService(WindowManager.class);
mDisplayManager = mContext.getSystemService(DisplayManager.class);
mIsRoundedCornerMultipleRadius = mContext.getResources().getBoolean(
R.bool.config_roundedCornerMultipleRadius);
updateRoundedCornerDrawable();
updateRoundedCornerRadii();
setupDecorations();
setupCameraListener();
@@ -287,6 +295,14 @@ public class ScreenDecorations extends SystemUI implements Tunable {
}
}
}
final String newUniqueId = mContext.getDisplay().getUniqueId();
if ((newUniqueId != null && !newUniqueId.equals(mDisplayUniqueId))
|| (mDisplayUniqueId != null && !mDisplayUniqueId.equals(newUniqueId))) {
mDisplayUniqueId = newUniqueId;
mIsRoundedCornerMultipleRadius =
isRoundedCornerMultipleRadius(mContext, mDisplayUniqueId);
updateRoundedCornerDrawable();
}
updateOrientation();
}
};
@@ -474,6 +490,7 @@ public class ScreenDecorations extends SystemUI implements Tunable {
updateRoundedCornerView(pos, R.id.left);
updateRoundedCornerView(pos, R.id.right);
updateRoundedCornerSize(mRoundedDefault, mRoundedDefaultTop, mRoundedDefaultBottom);
updateRoundedCornerImageView();
// update cutout view rotation
if (mCutoutViews != null && mCutoutViews[pos] != null) {
@@ -677,27 +694,26 @@ public class ScreenDecorations extends SystemUI implements Tunable {
// upgrading all of the configs to contain (width, height) pairs. Instead assume that a
// device configured using the single integer config value is okay with drawing the corners
// as a square
final int newRoundedDefault = mContext.getResources().getDimensionPixelSize(
com.android.internal.R.dimen.rounded_corner_radius);
final int newRoundedDefaultTop = mContext.getResources().getDimensionPixelSize(
com.android.internal.R.dimen.rounded_corner_radius_top);
final int newRoundedDefaultBottom = mContext.getResources().getDimensionPixelSize(
com.android.internal.R.dimen.rounded_corner_radius_bottom);
final int newRoundedDefault = RoundedCorners.getRoundedCornerRadius(
mContext.getResources(), mDisplayUniqueId);
final int newRoundedDefaultTop = RoundedCorners.getRoundedCornerTopRadius(
mContext.getResources(), mDisplayUniqueId);
final int newRoundedDefaultBottom = RoundedCorners.getRoundedCornerBottomRadius(
mContext.getResources(), mDisplayUniqueId);
final boolean changed = mRoundedDefault.x != newRoundedDefault
|| mRoundedDefaultTop.x != newRoundedDefaultTop
|| mRoundedDefaultBottom.x != newRoundedDefaultBottom;
if (changed) {
// If config_roundedCornerMultipleRadius set as true, ScreenDecorations respect the
// (width, height) size of drawable/rounded.xml instead of rounded_corner_radius
if (mIsRoundedCornerMultipleRadius) {
Drawable d = mContext.getDrawable(R.drawable.rounded);
mRoundedDefault.set(d.getIntrinsicWidth(), d.getIntrinsicHeight());
d = mContext.getDrawable(R.drawable.rounded_corner_top);
mRoundedDefaultTop.set(d.getIntrinsicWidth(), d.getIntrinsicHeight());
d = mContext.getDrawable(R.drawable.rounded_corner_bottom);
mRoundedDefaultBottom.set(d.getIntrinsicWidth(), d.getIntrinsicHeight());
mRoundedDefault.set(mRoundedCornerDrawable.getIntrinsicWidth(),
mRoundedCornerDrawable.getIntrinsicHeight());
mRoundedDefaultTop.set(mRoundedCornerDrawableTop.getIntrinsicWidth(),
mRoundedCornerDrawableTop.getIntrinsicHeight());
mRoundedDefaultBottom.set(mRoundedCornerDrawableBottom.getIntrinsicWidth(),
mRoundedCornerDrawableBottom.getIntrinsicHeight());
} else {
mRoundedDefault.set(newRoundedDefault, newRoundedDefault);
mRoundedDefaultTop.set(newRoundedDefaultTop, newRoundedDefaultTop);
@@ -707,6 +723,89 @@ public class ScreenDecorations extends SystemUI implements Tunable {
}
}
/**
* Gets whether the rounded corners are multiple radii for current display.
*
* Loads the default config {@link R.bool#config_roundedCornerMultipleRadius} if
* {@link com.android.internal.R.array#config_displayUniqueIdArray} is not set.
*/
private static boolean isRoundedCornerMultipleRadius(Context context, String displayUniqueId) {
final Resources res = context.getResources();
final int index = DisplayUtils.getDisplayUniqueIdConfigIndex(res, displayUniqueId);
final TypedArray array = res.obtainTypedArray(
R.array.config_roundedCornerMultipleRadiusArray);
boolean isMultipleRadius;
if (index >= 0 && index < array.length()) {
isMultipleRadius = array.getBoolean(index, false);
} else {
isMultipleRadius = res.getBoolean(R.bool.config_roundedCornerMultipleRadius);
}
array.recycle();
return isMultipleRadius;
}
/**
* Gets the rounded corner drawable for current display.
*
* Loads the default config {@link R.drawable#rounded} if
* {@link com.android.internal.R.array#config_displayUniqueIdArray} is not set.
*/
private static Drawable getRoundedCornerDrawable(Context context, String displayUniqueId) {
final Resources res = context.getResources();
final int index = DisplayUtils.getDisplayUniqueIdConfigIndex(res, displayUniqueId);
final TypedArray array = res.obtainTypedArray(R.array.config_roundedCornerDrawableArray);
Drawable drawable;
if (index >= 0 && index < array.length()) {
drawable = array.getDrawable(index);
} else {
drawable = context.getDrawable(R.drawable.rounded);
}
array.recycle();
return drawable;
}
/**
* Gets the rounded corner top drawable for current display.
*
* Loads the default config {@link R.drawable#rounded_corner_top} if
* {@link com.android.internal.R.array#config_displayUniqueIdArray} is not set.
*/
private static Drawable getRoundedCornerTopDrawable(Context context, String displayUniqueId) {
final Resources res = context.getResources();
final int index = DisplayUtils.getDisplayUniqueIdConfigIndex(res, displayUniqueId);
final TypedArray array = res.obtainTypedArray(R.array.config_roundedCornerTopDrawableArray);
Drawable drawable;
if (index >= 0 && index < array.length()) {
drawable = array.getDrawable(index);
} else {
drawable = context.getDrawable(R.drawable.rounded_corner_top);
}
array.recycle();
return drawable;
}
/**
* Gets the rounded corner bottom drawable for current display.
*
* Loads the default config {@link R.drawable#rounded_corner_bottom} if
* {@link com.android.internal.R.array#config_displayUniqueIdArray} is not set.
*/
private static Drawable getRoundedCornerBottomDrawable(
Context context, String displayUniqueId) {
final Resources res = context.getResources();
final int index = DisplayUtils.getDisplayUniqueIdConfigIndex(res, displayUniqueId);
final TypedArray array = res.obtainTypedArray(
R.array.config_roundedCornerBottomDrawableArray);
Drawable drawable;
if (index >= 0 && index < array.length()) {
drawable = array.getDrawable(index);
} else {
drawable = context.getDrawable(R.drawable.rounded_corner_bottom);
}
array.recycle();
return drawable;
}
private void updateRoundedCornerView(@BoundsPosition int pos, int id) {
final View rounded = mOverlays[pos].findViewById(id);
if (rounded == null) {
@@ -837,6 +936,51 @@ public class ScreenDecorations extends SystemUI implements Tunable {
});
}
private void updateRoundedCornerDrawable() {
mRoundedCornerDrawable = getRoundedCornerDrawable(mContext, mDisplayUniqueId);
mRoundedCornerDrawableTop = getRoundedCornerTopDrawable(mContext, mDisplayUniqueId);
mRoundedCornerDrawableBottom = getRoundedCornerBottomDrawable(mContext, mDisplayUniqueId);
updateRoundedCornerImageView();
}
private void updateRoundedCornerImageView() {
final Drawable top = mRoundedCornerDrawableTop != null
? mRoundedCornerDrawableTop : mRoundedCornerDrawable;
final Drawable bottom = mRoundedCornerDrawableBottom != null
? mRoundedCornerDrawableBottom : mRoundedCornerDrawable;
if (mOverlays == null) {
return;
}
for (int i = 0; i < BOUNDS_POSITION_LENGTH; i++) {
if (mOverlays[i] == null) {
continue;
}
((ImageView) mOverlays[i].findViewById(R.id.left)).setImageDrawable(
isTopRoundedCorner(i, R.id.left) ? top : bottom);
((ImageView) mOverlays[i].findViewById(R.id.right)).setImageDrawable(
isTopRoundedCorner(i, R.id.right) ? top : bottom);
}
}
private boolean isTopRoundedCorner(@BoundsPosition int pos, int id) {
switch (pos) {
case BOUNDS_POSITION_LEFT:
case BOUNDS_POSITION_RIGHT:
if (mRotation == ROTATION_270) {
return id == R.id.left ? false : true;
} else {
return id == R.id.left ? true : false;
}
case BOUNDS_POSITION_TOP:
return true;
case BOUNDS_POSITION_BOTTOM:
return false;
default:
throw new IllegalArgumentException("Unknown bounds position");
}
}
private void updateRoundedCornerSize(
Point sizeDefault,
Point sizeTop,
@@ -855,21 +999,10 @@ public class ScreenDecorations extends SystemUI implements Tunable {
if (mOverlays[i] == null) {
continue;
}
if (i == BOUNDS_POSITION_LEFT || i == BOUNDS_POSITION_RIGHT) {
if (mRotation == ROTATION_270) {
setSize(mOverlays[i].findViewById(R.id.left), sizeBottom);
setSize(mOverlays[i].findViewById(R.id.right), sizeTop);
} else {
setSize(mOverlays[i].findViewById(R.id.left), sizeTop);
setSize(mOverlays[i].findViewById(R.id.right), sizeBottom);
}
} else if (i == BOUNDS_POSITION_TOP) {
setSize(mOverlays[i].findViewById(R.id.left), sizeTop);
setSize(mOverlays[i].findViewById(R.id.right), sizeTop);
} else if (i == BOUNDS_POSITION_BOTTOM) {
setSize(mOverlays[i].findViewById(R.id.left), sizeBottom);
setSize(mOverlays[i].findViewById(R.id.right), sizeBottom);
}
setSize(mOverlays[i].findViewById(R.id.left),
isTopRoundedCorner(i, R.id.left) ? sizeTop : sizeBottom);
setSize(mOverlays[i].findViewById(R.id.right),
isTopRoundedCorner(i, R.id.right) ? sizeTop : sizeBottom);
}
}

2
packages/SystemUI/src/com/android/systemui/recents/OverviewProxyService.java
View File

@@ -559,7 +559,7 @@ public class OverviewProxyService extends CurrentUserTracker implements
com.android.internal.R.string.config_recentsComponentName));
mQuickStepIntent = new Intent(ACTION_QUICKSTEP)
.setPackage(mRecentsComponentName.getPackageName());
mWindowCornerRadius = ScreenDecorationsUtils.getWindowCornerRadius(mContext.getResources());
mWindowCornerRadius = ScreenDecorationsUtils.getWindowCornerRadius(mContext);
mSupportsRoundedCornersOnWindows = ScreenDecorationsUtils
.supportsRoundedCornersOnWindows(mContext.getResources());
mSysUiState = sysUiState;

3
packages/SystemUI/src/com/android/systemui/statusbar/phone/NotificationPanelViewController.java
View File

@@ -984,7 +984,8 @@ public class NotificationPanelViewController extends PanelViewController {
R.dimen.pulse_expansion_max_top_overshoot);
mScrimCornerRadius = mResources.getDimensionPixelSize(
R.dimen.notification_scrim_corner_radius);
mScreenCornerRadius = (int) ScreenDecorationsUtils.getWindowCornerRadius(mResources);
mScreenCornerRadius = (int) ScreenDecorationsUtils.getWindowCornerRadius(
mView.getContext());
mLockscreenNotificationQSPadding = mResources.getDimensionPixelSize(
R.dimen.notification_side_paddings);
}

271
packages/SystemUI/tests/src/com/android/systemui/ScreenDecorationsTest.java
View File

@@ -43,6 +43,7 @@ import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
import android.content.res.Configuration;
import android.content.res.TypedArray;
import android.graphics.Insets;
import android.graphics.Point;
import android.graphics.Rect;
@@ -60,7 +61,6 @@ import android.view.WindowMetrics;
import androidx.test.filters.SmallTest;
import com.android.systemui.R.dimen;
import com.android.systemui.broadcast.BroadcastDispatcher;
import com.android.systemui.settings.UserTracker;
import com.android.systemui.statusbar.events.PrivacyDotViewController;
@@ -100,6 +100,8 @@ public class ScreenDecorationsTest extends SysuiTestCase {
private UserTracker mUserTracker;
@Mock
private PrivacyDotViewController mDotViewController;
@Mock
private TypedArray mMockTypedArray;
@Before
public void setup() {
@@ -121,6 +123,7 @@ public class ScreenDecorationsTest extends SysuiTestCase {
.getDisplay(DEFAULT_DISPLAY);
when(mDisplayManager.getDisplay(anyInt())).thenReturn(display);
mContext.addMockSystemService(DisplayManager.class, mDisplayManager);
when(mMockTypedArray.length()).thenReturn(0);
mScreenDecorations = spy(new ScreenDecorations(mContext, mExecutor, mSecureSettings,
mBroadcastDispatcher, mTunerService, mUserTracker, mDotViewController,
@@ -148,18 +151,9 @@ public class ScreenDecorationsTest extends SysuiTestCase {
@Test
public void testNoRounding_NoCutout() {
mContext.getOrCreateTestableResources().addOverride(
com.android.internal.R.bool.config_fillMainBuiltInDisplayCutout, false);
mContext.getOrCreateTestableResources().addOverride(
com.android.internal.R.dimen.rounded_corner_radius, 0);
mContext.getOrCreateTestableResources().addOverride(
com.android.internal.R.dimen.rounded_corner_radius_top, 0);
mContext.getOrCreateTestableResources().addOverride(
com.android.internal.R.dimen.rounded_corner_radius_bottom, 0);
mContext.getOrCreateTestableResources()
.addOverride(dimen.rounded_corner_content_padding, 0);
mContext.getOrCreateTestableResources()
.addOverride(R.bool.config_roundedCornerMultipleRadius, false);
setupResources(0 /* radius */, 0 /* radiusTop */, 0 /* radiusBottom */,
0 /* roundedPadding */, false /* multipleRadius */,
false /* fillCutout */);
// no cutout
doReturn(null).when(mScreenDecorations).getCutout();
@@ -173,14 +167,9 @@ public class ScreenDecorationsTest extends SysuiTestCase {
@Test
public void testRounding_NoCutout() {
mContext.getOrCreateTestableResources().addOverride(
com.android.internal.R.bool.config_fillMainBuiltInDisplayCutout, false);
mContext.getOrCreateTestableResources().addOverride(
com.android.internal.R.dimen.rounded_corner_radius, 20);
mContext.getOrCreateTestableResources()
.addOverride(dimen.rounded_corner_content_padding, 20);
mContext.getOrCreateTestableResources()
.addOverride(R.bool.config_roundedCornerMultipleRadius, false);
setupResources(20 /* radius */, 0 /* radiusTop */, 0 /* radiusBottom */,
20 /* roundedPadding */, false /* multipleRadius */,
false /* fillCutout */);
// no cutout
doReturn(null).when(mScreenDecorations).getCutout();
@@ -203,19 +192,10 @@ public class ScreenDecorationsTest extends SysuiTestCase {
@Test
public void testRoundingRadius_NoCutout() {
final int testRadius = 1;
final Point testRadiusPoint = new Point(1, 1);
mContext.getOrCreateTestableResources().addOverride(
com.android.internal.R.bool.config_fillMainBuiltInDisplayCutout, false);
mContext.getOrCreateTestableResources().addOverride(
com.android.internal.R.dimen.rounded_corner_radius, testRadius);
mContext.getOrCreateTestableResources().addOverride(
com.android.internal.R.dimen.rounded_corner_radius_top, testRadius);
mContext.getOrCreateTestableResources().addOverride(
com.android.internal.R.dimen.rounded_corner_radius_bottom, testRadius);
mContext.getOrCreateTestableResources()
.addOverride(R.bool.config_roundedCornerMultipleRadius, false);
setupResources(1 /* radius */, 1 /* radiusTop */, 1 /* radiusBottom */,
0 /* roundedPadding */, false /* multipleRadius */,
false /* fillCutout */);
// no cutout
doReturn(null).when(mScreenDecorations).getCutout();
@@ -230,16 +210,8 @@ public class ScreenDecorationsTest extends SysuiTestCase {
public void testRoundingTopBottomRadius_OnTopBottomOverlay() {
final int testTopRadius = 1;
final int testBottomRadius = 5;
mContext.getOrCreateTestableResources().addOverride(
com.android.internal.R.bool.config_fillMainBuiltInDisplayCutout, false);
mContext.getOrCreateTestableResources().addOverride(
com.android.internal.R.dimen.rounded_corner_radius, testTopRadius);
mContext.getOrCreateTestableResources().addOverride(
com.android.internal.R.dimen.rounded_corner_radius_top, testTopRadius);
mContext.getOrCreateTestableResources().addOverride(
com.android.internal.R.dimen.rounded_corner_radius_bottom, testBottomRadius);
mContext.getOrCreateTestableResources()
.addOverride(R.bool.config_roundedCornerMultipleRadius, false);
setupResources(testTopRadius, testTopRadius, testBottomRadius, 0 /* roundedPadding */,
false /* multipleRadius */, false /* fillCutout */);
// no cutout
doReturn(null).when(mScreenDecorations).getCutout();
@@ -267,16 +239,8 @@ public class ScreenDecorationsTest extends SysuiTestCase {
public void testRoundingTopBottomRadius_OnLeftRightOverlay() {
final int testTopRadius = 1;
final int testBottomRadius = 5;
mContext.getOrCreateTestableResources().addOverride(
com.android.internal.R.bool.config_fillMainBuiltInDisplayCutout, false);
mContext.getOrCreateTestableResources().addOverride(
com.android.internal.R.dimen.rounded_corner_radius, testTopRadius);
mContext.getOrCreateTestableResources().addOverride(
com.android.internal.R.dimen.rounded_corner_radius_top, testTopRadius);
mContext.getOrCreateTestableResources().addOverride(
com.android.internal.R.dimen.rounded_corner_radius_bottom, testBottomRadius);
mContext.getOrCreateTestableResources()
.addOverride(R.bool.config_roundedCornerMultipleRadius, false);
setupResources(testTopRadius, testTopRadius, testBottomRadius, 0 /* roundedPadding */,
false /* multipleRadius */, false /* fillCutout */);
// left cutout
doReturn(new DisplayCutout(
@@ -310,15 +274,9 @@ public class ScreenDecorationsTest extends SysuiTestCase {
public void testRoundingMultipleRadius_NoCutout() {
final VectorDrawable d = (VectorDrawable) mContext.getDrawable(R.drawable.rounded);
final Point multipleRadiusSize = new Point(d.getIntrinsicWidth(), d.getIntrinsicHeight());
mContext.getOrCreateTestableResources().addOverride(
com.android.internal.R.bool.config_fillMainBuiltInDisplayCutout, false);
mContext.getOrCreateTestableResources().addOverride(
com.android.internal.R.dimen.rounded_corner_radius, 9999);
mContext.getOrCreateTestableResources()
.addOverride(dimen.rounded_corner_content_padding, 9999);
mContext.getOrCreateTestableResources()
.addOverride(R.bool.config_roundedCornerMultipleRadius, true);
setupResources(9999 /* radius */, 0 /* radiusTop */, 0 /* radiusBottom */,
9999 /* roundedPadding */, true /* multipleRadius */,
false /* fillCutout */);
// no cutout
doReturn(null).when(mScreenDecorations).getCutout();
@@ -345,27 +303,18 @@ public class ScreenDecorationsTest extends SysuiTestCase {
@Test
public void testNoRounding_CutoutShortEdge() {
mContext.getOrCreateTestableResources().addOverride(
com.android.internal.R.bool.config_fillMainBuiltInDisplayCutout, true);
mContext.getOrCreateTestableResources().addOverride(
com.android.internal.R.dimen.rounded_corner_radius, 0);
mContext.getOrCreateTestableResources().addOverride(
com.android.internal.R.dimen.rounded_corner_radius_top, 0);
mContext.getOrCreateTestableResources().addOverride(
com.android.internal.R.dimen.rounded_corner_radius_bottom, 0);
mContext.getOrCreateTestableResources()
.addOverride(dimen.rounded_corner_content_padding, 0);
mContext.getOrCreateTestableResources()
.addOverride(R.bool.config_roundedCornerMultipleRadius, false);
setupResources(0 /* radius */, 0 /* radiusTop */, 0 /* radiusBottom */,
0 /* roundedPadding */, false /* multipleRadius */,
true /* fillCutout */);
// top cutout
doReturn(new DisplayCutout(
Insets.of(0, 10, 0, 0),
ZERO_RECT,
new Rect(9, 0, 10, 1),
ZERO_RECT,
ZERO_RECT,
Insets.NONE)).when(mScreenDecorations).getCutout();
Insets.of(0, 10, 0, 0),
ZERO_RECT,
new Rect(9, 0, 10, 1),
ZERO_RECT,
ZERO_RECT,
Insets.NONE)).when(mScreenDecorations).getCutout();
mScreenDecorations.start();
// Top window is created for top cutout.
@@ -381,18 +330,9 @@ public class ScreenDecorationsTest extends SysuiTestCase {
@Test
public void testNoRounding_CutoutLongEdge() {
mContext.getOrCreateTestableResources().addOverride(
com.android.internal.R.bool.config_fillMainBuiltInDisplayCutout, true);
mContext.getOrCreateTestableResources().addOverride(
com.android.internal.R.dimen.rounded_corner_radius, 0);
mContext.getOrCreateTestableResources().addOverride(
com.android.internal.R.dimen.rounded_corner_radius_top, 0);
mContext.getOrCreateTestableResources().addOverride(
com.android.internal.R.dimen.rounded_corner_radius_bottom, 0);
mContext.getOrCreateTestableResources()
.addOverride(dimen.rounded_corner_content_padding, 0);
mContext.getOrCreateTestableResources()
.addOverride(R.bool.config_roundedCornerMultipleRadius, false);
setupResources(0 /* radius */, 0 /* radiusTop */, 0 /* radiusBottom */,
0 /* roundedPadding */, false /* multipleRadius */,
true /* fillCutout */);
// left cutout
doReturn(new DisplayCutout(
@@ -417,14 +357,9 @@ public class ScreenDecorationsTest extends SysuiTestCase {
@Test
public void testRounding_CutoutShortEdge() {
mContext.getOrCreateTestableResources().addOverride(
com.android.internal.R.bool.config_fillMainBuiltInDisplayCutout, true);
mContext.getOrCreateTestableResources().addOverride(
com.android.internal.R.dimen.rounded_corner_radius, 20);
mContext.getOrCreateTestableResources()
.addOverride(dimen.rounded_corner_content_padding, 20);
mContext.getOrCreateTestableResources()
.addOverride(R.bool.config_roundedCornerMultipleRadius, false);
setupResources(20 /* radius */, 0 /* radiusTop */, 0 /* radiusBottom */,
20 /* roundedPadding */, false /* multipleRadius */,
true /* fillCutout */);
// top cutout
doReturn(new DisplayCutout(
@@ -450,14 +385,9 @@ public class ScreenDecorationsTest extends SysuiTestCase {
@Test
public void testRounding_CutoutLongEdge() {
mContext.getOrCreateTestableResources().addOverride(
com.android.internal.R.bool.config_fillMainBuiltInDisplayCutout, true);
mContext.getOrCreateTestableResources().addOverride(
com.android.internal.R.dimen.rounded_corner_radius, 20);
mContext.getOrCreateTestableResources()
.addOverride(dimen.rounded_corner_content_padding, 20);
mContext.getOrCreateTestableResources()
.addOverride(R.bool.config_roundedCornerMultipleRadius, false);
setupResources(20 /* radius */, 0 /* radiusTop */, 0 /* radiusBottom */,
20 /* roundedPadding */, false /* multipleRadius */,
true /* fillCutout */);
// left cutout
doReturn(new DisplayCutout(
@@ -483,14 +413,9 @@ public class ScreenDecorationsTest extends SysuiTestCase {
@Test
public void testRounding_CutoutShortAndLongEdge() {
mContext.getOrCreateTestableResources().addOverride(
com.android.internal.R.bool.config_fillMainBuiltInDisplayCutout, true);
mContext.getOrCreateTestableResources().addOverride(
com.android.internal.R.dimen.rounded_corner_radius, 20);
mContext.getOrCreateTestableResources()
.addOverride(dimen.rounded_corner_content_padding, 20);
mContext.getOrCreateTestableResources()
.addOverride(R.bool.config_roundedCornerMultipleRadius, false);
setupResources(20 /* radius */, 0 /* radiusTop */, 0 /* radiusBottom */,
20 /* roundedPadding */, false /* multipleRadius */,
true /* fillCutout */);
// top and left cutout
doReturn(new DisplayCutout(
@@ -517,18 +442,9 @@ public class ScreenDecorationsTest extends SysuiTestCase {
@Test
public void testNoRounding_SwitchFrom_ShortEdgeCutout_To_LongCutout() {
mContext.getOrCreateTestableResources().addOverride(
com.android.internal.R.bool.config_fillMainBuiltInDisplayCutout, true);
mContext.getOrCreateTestableResources().addOverride(
com.android.internal.R.dimen.rounded_corner_radius, 0);
mContext.getOrCreateTestableResources().addOverride(
com.android.internal.R.dimen.rounded_corner_radius_top, 0);
mContext.getOrCreateTestableResources().addOverride(
com.android.internal.R.dimen.rounded_corner_radius_bottom, 0);
mContext.getOrCreateTestableResources()
.addOverride(dimen.rounded_corner_content_padding, 0);
mContext.getOrCreateTestableResources()
.addOverride(R.bool.config_roundedCornerMultipleRadius, false);
setupResources(0 /* radius */, 0 /* radiusTop */, 0 /* radiusBottom */,
0 /* roundedPadding */, false /* multipleRadius */,
true /* fillCutout */);
// Set to short edge cutout(top).
doReturn(new DisplayCutout(
@@ -566,18 +482,9 @@ public class ScreenDecorationsTest extends SysuiTestCase {
@Test
public void testDelayedCutout() {
mContext.getOrCreateTestableResources().addOverride(
com.android.internal.R.bool.config_fillMainBuiltInDisplayCutout, false);
mContext.getOrCreateTestableResources().addOverride(
com.android.internal.R.dimen.rounded_corner_radius, 0);
mContext.getOrCreateTestableResources().addOverride(
com.android.internal.R.dimen.rounded_corner_radius_top, 0);
mContext.getOrCreateTestableResources().addOverride(
com.android.internal.R.dimen.rounded_corner_radius_bottom, 0);
mContext.getOrCreateTestableResources()
.addOverride(dimen.rounded_corner_content_padding, 0);
mContext.getOrCreateTestableResources()
.addOverride(R.bool.config_roundedCornerMultipleRadius, false);
setupResources(0 /* radius */, 0 /* radiusTop */, 0 /* radiusBottom */,
0 /* roundedPadding */, false /* multipleRadius */,
false /* fillCutout */);
// top cutout
doReturn(new DisplayCutout(
@@ -591,8 +498,9 @@ public class ScreenDecorationsTest extends SysuiTestCase {
mScreenDecorations.start();
assertNull(mScreenDecorations.mOverlays);
mContext.getOrCreateTestableResources().addOverride(
com.android.internal.R.bool.config_fillMainBuiltInDisplayCutout, true);
when(mContext.getResources().getBoolean(
com.android.internal.R.bool.config_fillMainBuiltInDisplayCutout))
.thenReturn(true);
mScreenDecorations.onConfigurationChanged(new Configuration());
// Only top windows should be added.
@@ -612,34 +520,24 @@ public class ScreenDecorationsTest extends SysuiTestCase {
@Test
public void testUpdateRoundedCorners() {
mContext.getOrCreateTestableResources().addOverride(
com.android.internal.R.bool.config_fillMainBuiltInDisplayCutout, false);
mContext.getOrCreateTestableResources().addOverride(
com.android.internal.R.dimen.rounded_corner_radius, 20);
mContext.getOrCreateTestableResources()
.addOverride(R.bool.config_roundedCornerMultipleRadius, false);
setupResources(20 /* radius */, 0 /* radiusTop */, 0 /* radiusBottom */,
0 /* roundedPadding */, false /* multipleRadius */,
false /* fillCutout */);
mScreenDecorations.start();
assertEquals(mScreenDecorations.mRoundedDefault, new Point(20, 20));
mContext.getOrCreateTestableResources().addOverride(
com.android.internal.R.dimen.rounded_corner_radius, 5);
when(mContext.getResources().getDimensionPixelSize(
com.android.internal.R.dimen.rounded_corner_radius)).thenReturn(5);
mScreenDecorations.onConfigurationChanged(null);
assertEquals(mScreenDecorations.mRoundedDefault, new Point(5, 5));
}
@Test
public void testOnlyRoundedCornerRadiusTop() {
mContext.getOrCreateTestableResources().addOverride(
com.android.internal.R.bool.config_fillMainBuiltInDisplayCutout, false);
mContext.getOrCreateTestableResources().addOverride(
com.android.internal.R.dimen.rounded_corner_radius, 0);
mContext.getOrCreateTestableResources().addOverride(
com.android.internal.R.dimen.rounded_corner_radius_top, 10);
mContext.getOrCreateTestableResources().addOverride(
com.android.internal.R.dimen.rounded_corner_radius_bottom, 0);
mContext.getOrCreateTestableResources()
.addOverride(R.bool.config_roundedCornerMultipleRadius, false);
setupResources(0 /* radius */, 10 /* radiusTop */, 0 /* radiusBottom */,
0 /* roundedPadding */, false /* multipleRadius */,
false /* fillCutout */);
mScreenDecorations.start();
assertEquals(new Point(0, 0), mScreenDecorations.mRoundedDefault);
@@ -649,16 +547,9 @@ public class ScreenDecorationsTest extends SysuiTestCase {
@Test
public void testOnlyRoundedCornerRadiusBottom() {
mContext.getOrCreateTestableResources().addOverride(
com.android.internal.R.bool.config_fillMainBuiltInDisplayCutout, false);
mContext.getOrCreateTestableResources().addOverride(
com.android.internal.R.dimen.rounded_corner_radius, 0);
mContext.getOrCreateTestableResources().addOverride(
com.android.internal.R.dimen.rounded_corner_radius_top, 0);
mContext.getOrCreateTestableResources().addOverride(
com.android.internal.R.dimen.rounded_corner_radius_bottom, 20);
mContext.getOrCreateTestableResources()
.addOverride(R.bool.config_roundedCornerMultipleRadius, false);
setupResources(0 /* radius */, 0 /* radiusTop */, 20 /* radiusBottom */,
0 /* roundedPadding */, false /* multipleRadius */,
false /* fillCutout */);
mScreenDecorations.start();
assertEquals(new Point(0, 0), mScreenDecorations.mRoundedDefault);
@@ -721,4 +612,44 @@ public class ScreenDecorationsTest extends SysuiTestCase {
verify(mTunerService, times(1)).removeTunable(any());
assertThat(mScreenDecorations.mIsRegistered, is(false));
}
private void setupResources(int radius, int radiusTop, int radiusBottom, int roundedPadding,
boolean multipleRadius, boolean fillCutout) {
mContext.getOrCreateTestableResources().addOverride(
com.android.internal.R.array.config_displayUniqueIdArray,
new String[]{});
mContext.getOrCreateTestableResources().addOverride(
com.android.internal.R.array.config_roundedCornerRadiusArray,
mMockTypedArray);
mContext.getOrCreateTestableResources().addOverride(
com.android.internal.R.array.config_roundedCornerTopRadiusArray,
mMockTypedArray);
mContext.getOrCreateTestableResources().addOverride(
com.android.internal.R.array.config_roundedCornerBottomRadiusArray,
mMockTypedArray);
mContext.getOrCreateTestableResources().addOverride(
R.array.config_roundedCornerDrawableArray,
mMockTypedArray);
mContext.getOrCreateTestableResources().addOverride(
R.array.config_roundedCornerTopDrawableArray,
mMockTypedArray);
mContext.getOrCreateTestableResources().addOverride(
R.array.config_roundedCornerBottomDrawableArray,
mMockTypedArray);
mContext.getOrCreateTestableResources().addOverride(
R.array.config_roundedCornerMultipleRadiusArray,
mMockTypedArray);
mContext.getOrCreateTestableResources().addOverride(
com.android.internal.R.dimen.rounded_corner_radius, radius);
mContext.getOrCreateTestableResources().addOverride(
com.android.internal.R.dimen.rounded_corner_radius_top, radiusTop);
mContext.getOrCreateTestableResources().addOverride(
com.android.internal.R.dimen.rounded_corner_radius_bottom, radiusBottom);
mContext.getOrCreateTestableResources().addOverride(
R.dimen.rounded_corner_content_padding, roundedPadding);
mContext.getOrCreateTestableResources().addOverride(
R.bool.config_roundedCornerMultipleRadius, multipleRadius);
mContext.getOrCreateTestableResources().addOverride(
com.android.internal.R.bool.config_fillMainBuiltInDisplayCutout, fillCutout);
}
}

5
services/core/java/com/android/server/display/LocalDisplayAdapter.java
View File

@@ -601,8 +601,6 @@ final class LocalDisplayAdapter extends DisplayAdapter {
&& SystemProperties.getBoolean(PROPERTY_EMULATOR_CIRCULAR, false))) {
mInfo.flags |= DisplayDeviceInfo.FLAG_ROUND;
}
mInfo.roundedCorners = RoundedCorners.fromResources(
res, mInfo.width, mInfo.height);
} else {
if (!res.getBoolean(
com.android.internal.R.bool.config_localDisplaysMirrorContent)) {
@@ -620,6 +618,9 @@ final class LocalDisplayAdapter extends DisplayAdapter {
mInfo.displayCutout = DisplayCutout.fromResourcesRectApproximation(res,
mInfo.uniqueId, mInfo.width, mInfo.height);
mInfo.roundedCorners = RoundedCorners.fromResources(
res, mInfo.uniqueId, mInfo.width, mInfo.height);
if (mStaticDisplayInfo.isInternal) {
mInfo.type = Display.TYPE_INTERNAL;
mInfo.touch = DisplayDeviceInfo.TOUCH_INTERNAL;

2
services/core/java/com/android/server/wm/DisplayPolicy.java
View File

@@ -2391,7 +2391,7 @@ public class DisplayPolicy {
*/
float getWindowCornerRadius() {
return mDisplayContent.getDisplay().getType() == TYPE_INTERNAL
? ScreenDecorationsUtils.getWindowCornerRadius(mContext.getResources()) : 0f;
? ScreenDecorationsUtils.getWindowCornerRadius(mContext) : 0f;
}
boolean isShowingDreamLw() {

6
services/tests/mockingservicestests/src/com/android/server/display/LocalDisplayAdapterTest.java
View File

@@ -142,6 +142,12 @@ public class LocalDisplayAdapterTest {
.thenReturn(mockArray);
when(mMockedResources.obtainTypedArray(R.array.config_waterfallCutoutArray))
.thenReturn(mockArray);
when(mMockedResources.obtainTypedArray(R.array.config_roundedCornerRadiusArray))
.thenReturn(mockArray);
when(mMockedResources.obtainTypedArray(R.array.config_roundedCornerTopRadiusArray))
.thenReturn(mockArray);
when(mMockedResources.obtainTypedArray(R.array.config_roundedCornerBottomRadiusArray))
.thenReturn(mockArray);
}
@After