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

Commit 9e1fb436 authored by petsjonkin's avatar petsjonkin Committed by Oleg Petšjonkin
Browse files

Extract RefreshRateData from DisplayDeviceConfig 

Crete sparate structure for RefreshRateData to simplify adding Low Power / Low Brightness  refreshRates configuration.
Moved defaultRR to new structure

Bug: b/335458967
Test: atest DisplayModeDirectorTest, atest DisplayDeviceConfigTest
Change-Id: I28115f1e68cb9590eb5e0a3bfb1cda357f51c15a
parent 8522f9b4

services/core/java/com/android/server/display/DisplayDeviceConfig.java

+12 −101
Original line number Diff line number Diff line
@@ -70,6 +70,7 @@ import com.android.server.display.config.PowerThrottlingMap; 
import com.android.server.display.config.PowerThrottlingPoint;

import com.android.server.display.config.PredefinedBrightnessLimitNames;

import com.android.server.display.config.RefreshRateConfigs;

import com.android.server.display.config.RefreshRateData;

import com.android.server.display.config.RefreshRateRange;

import com.android.server.display.config.RefreshRateThrottlingMap;

import com.android.server.display.config.RefreshRateThrottlingPoint;
@@ -617,9 +618,7 @@ public class DisplayDeviceConfig { 
    private static final String STABLE_ID_SUFFIX_FORMAT = "id_%d";

    private static final String NO_SUFFIX_FORMAT = "%d";

    private static final long STABLE_FLAG = 1L << 62;

    private static final int DEFAULT_PEAK_REFRESH_RATE = 0;

    private static final int DEFAULT_REFRESH_RATE = 60;

    private static final int DEFAULT_REFRESH_RATE_IN_HBM = 0;



    private static final int DEFAULT_HIGH_REFRESH_RATE = 0;

    private static final float[] DEFAULT_BRIGHTNESS_THRESHOLDS = new float[]{};
@@ -753,32 +752,6 @@ public class DisplayDeviceConfig { 
    // This stores the raw value loaded from the config file - true if not written.

    private boolean mDdcAutoBrightnessAvailable = true;



    /**

     * The default peak refresh rate for a given device. This value prevents the framework from

     * using higher refresh rates, even if display modes with higher refresh rates are available

     * from hardware composer. Only has an effect if the value is non-zero.

     */

    private int mDefaultPeakRefreshRate = DEFAULT_PEAK_REFRESH_RATE;



    /**

     * The default refresh rate for a given device. This value sets the higher default

     * refresh rate. If the hardware composer on the device supports display modes with

     * a higher refresh rate than the default value specified here, the framework may use those

     * higher refresh rate modes if an app chooses one by setting preferredDisplayModeId or calling

     * setFrameRate(). We have historically allowed fallback to mDefaultPeakRefreshRate if

     * mDefaultRefreshRate is set to 0, but this is not supported anymore.

     */

    private int mDefaultRefreshRate = DEFAULT_REFRESH_RATE;



    /**

     * Default refresh rate while the device has high brightness mode enabled for HDR.

     */

    private int mDefaultRefreshRateInHbmHdr = DEFAULT_REFRESH_RATE_IN_HBM;



    /**

     * Default refresh rate while the device has high brightness mode enabled for Sunlight.

     */

    private int mDefaultRefreshRateInHbmSunlight = DEFAULT_REFRESH_RATE_IN_HBM;

    /**

     * Default refresh rate in the high zone defined by brightness and ambient thresholds.

     * If non-positive, then the refresh rate is unchanged even if thresholds are configured.
@@ -867,6 +840,8 @@ public class DisplayDeviceConfig { 
    @Nullable

    public EvenDimmerBrightnessData mEvenDimmerBrightnessData;



    private RefreshRateData mRefreshRateData = RefreshRateData.DEFAULT_REFRESH_RATE_DATA;



    /**

     * Maximum screen brightness setting when screen brightness capped in Wear Bedtime mode.

     */
@@ -1450,33 +1425,8 @@ public class DisplayDeviceConfig { 
        return mDisplayBrightnessMapping.getBrightnessArray(mode, preset);

    }



    /**

     * @return Default peak refresh rate of the associated display

     */

    public int getDefaultPeakRefreshRate() {

        return mDefaultPeakRefreshRate;

    }



    /**

     * @return Default refresh rate of the associated display

     */

    public int getDefaultRefreshRate() {

        return mDefaultRefreshRate;

    }



    /**

     * @return Default refresh rate while the device has high brightness mode enabled for HDR.

     */

    public int getDefaultRefreshRateInHbmHdr() {

        return mDefaultRefreshRateInHbmHdr;

    }



    /**

     * @return Default refresh rate while the device has high brightness mode enabled because of

     * high lux.

     */

    public int getDefaultRefreshRateInHbmSunlight() {

        return mDefaultRefreshRateInHbmSunlight;

    public RefreshRateData getRefreshRateData() {

        return mRefreshRateData;

    }



    /**
@@ -1687,11 +1637,8 @@ public class DisplayDeviceConfig { 
                + "\n"

                + "mDefaultLowBlockingZoneRefreshRate= " + mDefaultLowBlockingZoneRefreshRate

                + ", mDefaultHighBlockingZoneRefreshRate= " + mDefaultHighBlockingZoneRefreshRate

                + ", mDefaultPeakRefreshRate= " + mDefaultPeakRefreshRate

                + ", mDefaultRefreshRate= " + mDefaultRefreshRate

                + ", mRefreshRateData= " + mRefreshRateData

                + ", mRefreshRateZoneProfiles= " + mRefreshRateZoneProfiles

                + ", mDefaultRefreshRateInHbmHdr= " + mDefaultRefreshRateInHbmHdr

                + ", mDefaultRefreshRateInHbmSunlight= " + mDefaultRefreshRateInHbmSunlight

                + ", mRefreshRateThrottlingMap= " + mRefreshRateThrottlingMap

                + ", mLowBlockingZoneThermalMapId= " + mLowBlockingZoneThermalMapId

                + ", mHighBlockingZoneThermalMapId= " + mHighBlockingZoneThermalMapId
@@ -1782,6 +1729,8 @@ public class DisplayDeviceConfig { 
                mScreenOffBrightnessSensor = SensorData.loadScreenOffBrightnessSensorConfig(config);

                mProximitySensor = SensorData.loadProxSensorConfig(mFlags, config);

                mTempSensor = SensorData.loadTempSensorConfig(mFlags, config);

                mRefreshRateData = RefreshRateData

                        .loadRefreshRateData(config, mContext.getResources());

                loadAmbientHorizonFromDdc(config);

                loadBrightnessChangeThresholds(config);

                loadAutoBrightnessConfigValues(config);
@@ -1812,6 +1761,8 @@ public class DisplayDeviceConfig { 
        mAmbientLightSensor = SensorData.loadAmbientLightSensorConfig(mContext.getResources());

        mProximitySensor = SensorData.loadSensorUnspecifiedConfig();

        mTempSensor = SensorData.loadTempSensorUnspecifiedConfig();

        mRefreshRateData = RefreshRateData

                .loadRefreshRateData(null, mContext.getResources());

        loadBrightnessChangeThresholdsFromXml();

        loadAutoBrightnessConfigsFromConfigXml();

        loadAutoBrightnessAvailableFromConfigXml();
@@ -2162,33 +2113,13 @@ public class DisplayDeviceConfig { 
        BlockingZoneConfig higherBlockingZoneConfig =

                (refreshRateConfigs == null) ? null

                        : refreshRateConfigs.getHigherBlockingZoneConfigs();

        loadPeakDefaultRefreshRate(refreshRateConfigs);

        loadDefaultRefreshRate(refreshRateConfigs);

        loadDefaultRefreshRateInHbm(refreshRateConfigs);

        loadLowerRefreshRateBlockingZones(lowerBlockingZoneConfig);

        loadHigherRefreshRateBlockingZones(higherBlockingZoneConfig);

        loadRefreshRateZoneProfiles(refreshRateConfigs);

    }



    private void loadPeakDefaultRefreshRate(RefreshRateConfigs refreshRateConfigs) {

        if (refreshRateConfigs == null || refreshRateConfigs.getDefaultPeakRefreshRate() == null) {

            mDefaultPeakRefreshRate = mContext.getResources().getInteger(

                R.integer.config_defaultPeakRefreshRate);

        } else {

            mDefaultPeakRefreshRate =

                refreshRateConfigs.getDefaultPeakRefreshRate().intValue();

        }

    }



    private void loadDefaultRefreshRate(RefreshRateConfigs refreshRateConfigs) {

        if (refreshRateConfigs == null || refreshRateConfigs.getDefaultRefreshRate() == null) {

            mDefaultRefreshRate = mContext.getResources().getInteger(

                R.integer.config_defaultRefreshRate);

        } else {

            mDefaultRefreshRate =

                refreshRateConfigs.getDefaultRefreshRate().intValue();

        }

    }





    /** Loads the refresh rate profiles. */

    private void loadRefreshRateZoneProfiles(RefreshRateConfigs refreshRateConfigs) {
@@ -2205,26 +2136,6 @@ public class DisplayDeviceConfig { 
        }

    }



    private void loadDefaultRefreshRateInHbm(RefreshRateConfigs refreshRateConfigs) {

        if (refreshRateConfigs != null

                && refreshRateConfigs.getDefaultRefreshRateInHbmHdr() != null) {

            mDefaultRefreshRateInHbmHdr = refreshRateConfigs.getDefaultRefreshRateInHbmHdr()

                    .intValue();

        } else {

            mDefaultRefreshRateInHbmHdr = mContext.getResources().getInteger(

                    R.integer.config_defaultRefreshRateInHbmHdr);

        }



        if (refreshRateConfigs != null

                && refreshRateConfigs.getDefaultRefreshRateInHbmSunlight() != null) {

            mDefaultRefreshRateInHbmSunlight =

                    refreshRateConfigs.getDefaultRefreshRateInHbmSunlight().intValue();

        } else {

            mDefaultRefreshRateInHbmSunlight = mContext.getResources().getInteger(

                R.integer.config_defaultRefreshRateInHbmSunlight);

        }

    }



    /**

     * Loads the refresh rate configurations pertaining to the lower blocking zones.

     */

services/core/java/com/android/server/display/config/RefreshRateData.java

0 → 100644
+138 −0
Original line number Diff line number Diff line 
/*

 * Copyright (C) 2024 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 com.android.server.display.config;



import android.annotation.Nullable;

import android.content.res.Resources;



import com.android.internal.R;



/**

 * RefreshRates config for display

 */

public class RefreshRateData {

    public static RefreshRateData DEFAULT_REFRESH_RATE_DATA = loadRefreshRateData(null, null);



    private static final int DEFAULT_REFRESH_RATE = 60;

    private static final int DEFAULT_PEAK_REFRESH_RATE = 0;

    private static final int DEFAULT_REFRESH_RATE_IN_HBM = 0;



    /**

     * The default refresh rate for a given device. This value sets the higher default

     * refresh rate. If the hardware composer on the device supports display modes with

     * a higher refresh rate than the default value specified here, the framework may use those

     * higher refresh rate modes if an app chooses one by setting preferredDisplayModeId or calling

     * setFrameRate(). We have historically allowed fallback to mDefaultPeakRefreshRate if

     * defaultRefreshRate is set to 0, but this is not supported anymore.

     */

    public final int defaultRefreshRate;



    /**

     * The default peak refresh rate for a given device. This value prevents the framework from

     * using higher refresh rates, even if display modes with higher refresh rates are available

     * from hardware composer. Only has an effect if the value is non-zero.

     */

    public final int defaultPeakRefreshRate;



    /**

     * Default refresh rate while the device has high brightness mode enabled for HDR.

     */

    public final int defaultRefreshRateInHbmHdr;



    /**

     * Default refresh rate while the device has high brightness mode enabled for Sunlight.

     */

    public final int defaultRefreshRateInHbmSunlight;



    public RefreshRateData(int defaultRefreshRate, int defaultPeakRefreshRate,

            int defaultRefreshRateInHbmHdr, int defaultRefreshRateInHbmSunlight) {

        this.defaultRefreshRate = defaultRefreshRate;

        this.defaultPeakRefreshRate = defaultPeakRefreshRate;

        this.defaultRefreshRateInHbmHdr = defaultRefreshRateInHbmHdr;

        this.defaultRefreshRateInHbmSunlight = defaultRefreshRateInHbmSunlight;

    }





    @Override

    public String toString() {

        return "RefreshRateData {"

                + "defaultRefreshRate: " + defaultRefreshRate

                + "defaultPeakRefreshRate: " + defaultPeakRefreshRate

                + "defaultRefreshRateInHbmHdr: " + defaultRefreshRateInHbmHdr

                + "defaultRefreshRateInHbmSunlight: " + defaultRefreshRateInHbmSunlight

                + "} ";

    }



    /**

     * Loads RefreshRateData from DisplayConfiguration and Resources

     */

    public static RefreshRateData loadRefreshRateData(

            @Nullable DisplayConfiguration config, @Nullable Resources resources) {

        RefreshRateConfigs refreshRateConfigs = config == null ? null : config.getRefreshRate();



        int defaultRefreshRate = loadDefaultRefreshRate(refreshRateConfigs, resources);

        int defaultPeakRefreshRate = loadDefaultPeakRefreshRate(refreshRateConfigs, resources);

        int defaultRefreshRateInHbmHdr = loadDefaultRefreshRateInHbm(refreshRateConfigs, resources);

        int defaultRefreshRateInHbmSunlight = loadDefaultRefreshRateInHbmSunlight(

                refreshRateConfigs, resources);



        return new RefreshRateData(defaultRefreshRate, defaultPeakRefreshRate,

                defaultRefreshRateInHbmHdr, defaultRefreshRateInHbmSunlight);

    }



    private static int loadDefaultRefreshRate(

            @Nullable RefreshRateConfigs refreshRateConfigs, @Nullable Resources resources) {

        if (refreshRateConfigs != null && refreshRateConfigs.getDefaultRefreshRate() != null) {

            return refreshRateConfigs.getDefaultRefreshRate().intValue();

        } else if (resources != null) {

            return resources.getInteger(R.integer.config_defaultRefreshRate);

        }

        return DEFAULT_REFRESH_RATE;

    }



    private static int loadDefaultPeakRefreshRate(

            @Nullable RefreshRateConfigs refreshRateConfigs, @Nullable Resources resources) {

        if (refreshRateConfigs != null && refreshRateConfigs.getDefaultPeakRefreshRate() != null) {

            return refreshRateConfigs.getDefaultPeakRefreshRate().intValue();

        } else if (resources != null) {

            return resources.getInteger(R.integer.config_defaultPeakRefreshRate);

        }

        return DEFAULT_PEAK_REFRESH_RATE;

    }



    private static int loadDefaultRefreshRateInHbm(

            @Nullable RefreshRateConfigs refreshRateConfigs, @Nullable Resources resources) {

        if (refreshRateConfigs != null

                && refreshRateConfigs.getDefaultRefreshRateInHbmHdr() != null) {

            return refreshRateConfigs.getDefaultRefreshRateInHbmHdr().intValue();

        } else if (resources != null) {

            return resources.getInteger(R.integer.config_defaultRefreshRateInHbmHdr);

        }

        return DEFAULT_REFRESH_RATE_IN_HBM;

    }



    private static int loadDefaultRefreshRateInHbmSunlight(

            @Nullable RefreshRateConfigs refreshRateConfigs, @Nullable Resources resources) {

        if (refreshRateConfigs != null

                && refreshRateConfigs.getDefaultRefreshRateInHbmSunlight() != null) {

            return refreshRateConfigs.getDefaultRefreshRateInHbmSunlight().intValue();

        } else if (resources != null) {

            return resources.getInteger(R.integer.config_defaultRefreshRateInHbmSunlight);

        }

        return DEFAULT_REFRESH_RATE_IN_HBM;

    }

}

services/core/java/com/android/server/display/mode/DisplayModeDirector.java

+11 −7
Original line number Diff line number Diff line
@@ -77,6 +77,7 @@ import com.android.internal.os.BackgroundThread; 
import com.android.server.LocalServices;

import com.android.server.display.DisplayDeviceConfig;

import com.android.server.display.config.IdleScreenRefreshRateTimeoutLuxThresholdPoint;

import com.android.server.display.config.RefreshRateData;

import com.android.server.display.feature.DeviceConfigParameterProvider;

import com.android.server.display.feature.DisplayManagerFlags;

import com.android.server.display.utils.AmbientFilter;
@@ -961,13 +962,15 @@ public class DisplayModeDirector { 
         * This is used to update the refresh rate configs from the DeviceConfig, which

         * if missing from DisplayDeviceConfig, and finally fallback to config.xml.

         */

        public void setRefreshRates(DisplayDeviceConfig displayDeviceConfig,

        void setRefreshRates(DisplayDeviceConfig displayDeviceConfig,

                boolean attemptReadFromFeatureParams) {

            RefreshRateData refreshRateData = displayDeviceConfig == null ? null

                    : displayDeviceConfig.getRefreshRateData();

            setDefaultPeakRefreshRate(displayDeviceConfig, attemptReadFromFeatureParams);

            mDefaultRefreshRate =

                    (displayDeviceConfig == null) ? (float) mContext.getResources().getInteger(

                    (refreshRateData == null) ? (float) mContext.getResources().getInteger(

                            R.integer.config_defaultRefreshRate)

                        : (float) displayDeviceConfig.getDefaultRefreshRate();

                            : (float) refreshRateData.defaultRefreshRate;

        }



        public void observe() {
@@ -1049,7 +1052,8 @@ public class DisplayModeDirector { 
                defaultPeakRefreshRate =

                        (displayDeviceConfig == null) ? (float) mContext.getResources().getInteger(

                                R.integer.config_defaultPeakRefreshRate)

                                : (float) displayDeviceConfig.getDefaultPeakRefreshRate();

                                : (float) displayDeviceConfig.getRefreshRateData()

                                        .defaultPeakRefreshRate;

            }

            mDefaultPeakRefreshRate = defaultPeakRefreshRate;

        }
@@ -2809,7 +2813,7 @@ public class DisplayModeDirector { 
        private int getRefreshRateInHbmHdr(DisplayDeviceConfig displayDeviceConfig) {

            return getRefreshRate(

                    () -> mConfigParameterProvider.getRefreshRateInHbmHdr(),

                    () -> displayDeviceConfig.getDefaultRefreshRateInHbmHdr(),

                    () -> displayDeviceConfig.getRefreshRateData().defaultRefreshRateInHbmHdr,

                    R.integer.config_defaultRefreshRateInHbmHdr,

                    displayDeviceConfig

            );
@@ -2818,7 +2822,7 @@ public class DisplayModeDirector { 
        private int getRefreshRateInHbmSunlight(DisplayDeviceConfig displayDeviceConfig) {

            return getRefreshRate(

                    () -> mConfigParameterProvider.getRefreshRateInHbmSunlight(),

                    () -> displayDeviceConfig.getDefaultRefreshRateInHbmSunlight(),

                    () -> displayDeviceConfig.getRefreshRateData().defaultRefreshRateInHbmSunlight,

                    R.integer.config_defaultRefreshRateInHbmSunlight,

                    displayDeviceConfig

            );

services/tests/displayservicetests/src/com/android/server/display/DisplayDeviceConfigTest.java

+13 −9
Original line number Diff line number Diff line
@@ -57,6 +57,7 @@ import com.android.internal.R; 
import com.android.server.display.config.HdrBrightnessData;

import com.android.server.display.config.HysteresisLevels;

import com.android.server.display.config.IdleScreenRefreshRateTimeoutLuxThresholdPoint;

import com.android.server.display.config.RefreshRateData;

import com.android.server.display.config.ThermalStatus;

import com.android.server.display.feature.DisplayManagerFlags;

import com.android.server.display.feature.flags.Flags;
@@ -222,17 +223,18 @@ public final class DisplayDeviceConfigTest { 
        assertArrayEquals(new float[]{0.23f, 0.24f, 0.25f},

                ambientIdleHysteresis.getDarkeningThresholdsPercentages(), ZERO_DELTA);



        RefreshRateData refreshRateData = mDisplayDeviceConfig.getRefreshRateData();

        assertEquals(75, mDisplayDeviceConfig.getDefaultLowBlockingZoneRefreshRate());

        assertEquals(90, mDisplayDeviceConfig.getDefaultHighBlockingZoneRefreshRate());

        assertEquals(85, mDisplayDeviceConfig.getDefaultPeakRefreshRate());

        assertEquals(45, mDisplayDeviceConfig.getDefaultRefreshRate());

        assertEquals(85, refreshRateData.defaultPeakRefreshRate);

        assertEquals(45, refreshRateData.defaultRefreshRate);

        assertEquals(2, mDisplayDeviceConfig.getRefreshRangeProfiles().size());

        assertEquals(60, mDisplayDeviceConfig.getRefreshRange("test1").min, SMALL_DELTA);

        assertEquals(60, mDisplayDeviceConfig.getRefreshRange("test1").max, SMALL_DELTA);

        assertEquals(80, mDisplayDeviceConfig.getRefreshRange("test2").min, SMALL_DELTA);

        assertEquals(90, mDisplayDeviceConfig.getRefreshRange("test2").max, SMALL_DELTA);

        assertEquals(82, mDisplayDeviceConfig.getDefaultRefreshRateInHbmHdr());

        assertEquals(83, mDisplayDeviceConfig.getDefaultRefreshRateInHbmSunlight());

        assertEquals(82, refreshRateData.defaultRefreshRateInHbmHdr);

        assertEquals(83, refreshRateData.defaultRefreshRateInHbmSunlight);



        assertNotNull(mDisplayDeviceConfig.getHostUsiVersion());

        assertEquals(mDisplayDeviceConfig.getHostUsiVersion().getMajorVersion(), 2);
@@ -697,6 +699,7 @@ public final class DisplayDeviceConfigTest { 
        HysteresisLevels screenHysteresis = mDisplayDeviceConfig.getScreenBrightnessHysteresis();

        HysteresisLevels screenIdleHysteresis =

                mDisplayDeviceConfig.getScreenBrightnessIdleHysteresis();



        // Test thresholds

        assertEquals(0, ambientHysteresis.getMinBrightening(), ZERO_DELTA);

        assertEquals(0, ambientIdleHysteresis.getMinBrightening(), ZERO_DELTA);
@@ -737,6 +740,8 @@ public final class DisplayDeviceConfigTest { 
        assertArrayEquals(new float[]{0.37f, 0.38f, 0.39f},

                screenIdleHysteresis.getDarkeningThresholdsPercentages(), ZERO_DELTA);



        RefreshRateData refreshRateData = mDisplayDeviceConfig.getRefreshRateData();



        assertArrayEquals(new float[]{0, 30, 31},

                ambientIdleHysteresis.getBrighteningThresholdLevels(), ZERO_DELTA);

        assertArrayEquals(new float[]{0.27f, 0.28f, 0.29f},
@@ -749,13 +754,12 @@ public final class DisplayDeviceConfigTest { 
                DEFAULT_LOW_BLOCKING_ZONE_REFRESH_RATE);

        assertEquals(mDisplayDeviceConfig.getDefaultHighBlockingZoneRefreshRate(),

                DEFAULT_HIGH_BLOCKING_ZONE_REFRESH_RATE);

        assertEquals(mDisplayDeviceConfig.getDefaultPeakRefreshRate(), DEFAULT_PEAK_REFRESH_RATE);

        assertEquals(mDisplayDeviceConfig.getDefaultRefreshRate(), DEFAULT_REFRESH_RATE);

        assertEquals(refreshRateData.defaultPeakRefreshRate, DEFAULT_PEAK_REFRESH_RATE);

        assertEquals(refreshRateData.defaultRefreshRate, DEFAULT_REFRESH_RATE);

        assertEquals(0, mDisplayDeviceConfig.getRefreshRangeProfiles().size());

        assertEquals(mDisplayDeviceConfig.getDefaultRefreshRateInHbmSunlight(),

        assertEquals(refreshRateData.defaultRefreshRateInHbmSunlight,

                DEFAULT_REFRESH_RATE_IN_HBM_SUNLIGHT);

        assertEquals(mDisplayDeviceConfig.getDefaultRefreshRateInHbmHdr(),

                DEFAULT_REFRESH_RATE_IN_HBM_HDR);

        assertEquals(refreshRateData.defaultRefreshRateInHbmHdr, DEFAULT_REFRESH_RATE_IN_HBM_HDR);



        assertEquals("test_light_sensor", mDisplayDeviceConfig.getAmbientLightSensor().type);

        assertEquals("", mDisplayDeviceConfig.getAmbientLightSensor().name);

services/tests/displayservicetests/src/com/android/server/display/mode/DisplayModeDirectorTest.java

+17 −4

File changed.

Preview size limit exceeded, changes collapsed.