Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 6603444a authored by shawnlin's avatar shawnlin
Browse files

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

- 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
parent b4e5f03c

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