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

Commit 2e52f542 authored by Enxun Wei's avatar Enxun Wei
Browse files

Revert "Add support to make the refresh rate used when the device has HDR... 

Revert "Add support to make the refresh rate used when the device has HDR enabled configurable for each display."

This reverts commit 35b8ec4a.

Reason for revert: Caused test failures b/268455056

Change-Id: I3c0845dea87eda88bfa83ee8ed67b6f52dc05f4e
parent 35b8ec4a

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

+0 −17
Original line number Diff line number Diff line
@@ -1344,23 +1344,6 @@ public class DisplayDeviceConfig { 
        return mDefaultRefreshRate;

    }



    /**

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

     */

    public int getDefaultRefreshRateInHbmHdr() {

        return mContext.getResources().getInteger(

            R.integer.config_defaultRefreshRateInHbmHdr);

    }



    /**

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

     * high lux.

     */

    public int getDefaultRefreshRateInHbmSunlight() {

        return mContext.getResources().getInteger(

            R.integer.config_defaultRefreshRateInHbmSunlight);

    }



    /**

     * @return Default refresh rate in the higher blocking zone of the associated display

     */

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

+31 −65
Original line number Diff line number Diff line
@@ -123,10 +123,6 @@ public class DisplayModeDirector { 
    private final DeviceConfigInterface mDeviceConfig;

    private final DeviceConfigDisplaySettings mDeviceConfigDisplaySettings;



    @GuardedBy("mLock")

    @Nullable

    private DisplayDeviceConfig mDefaultDisplayDeviceConfig;



    // A map from the display ID to the collection of votes and their priority. The latter takes

    // the form of another map from the priority to the vote itself so that each priority is

    // guaranteed to have exactly one vote, which is also easily and efficiently replaceable.
@@ -167,7 +163,6 @@ public class DisplayModeDirector { 
        mDeviceConfigDisplaySettings = new DeviceConfigDisplaySettings();

        mSettingsObserver = new SettingsObserver(context, handler);

        mBrightnessObserver = new BrightnessObserver(context, handler, injector);

        mDefaultDisplayDeviceConfig = null;

        mUdfpsObserver = new UdfpsObserver();

        final BallotBox ballotBox = (displayId, priority, vote) -> {

            synchronized (mLock) {
@@ -706,15 +701,11 @@ public class DisplayModeDirector { 
     * @param displayDeviceConfig configurations relating to the underlying display device.

     */

    public void defaultDisplayDeviceUpdated(DisplayDeviceConfig displayDeviceConfig) {

        synchronized (mLock) {

            mDefaultDisplayDeviceConfig = displayDeviceConfig;

        mSettingsObserver.setRefreshRates(displayDeviceConfig,

            /* attemptLoadingFromDeviceConfig= */ true);

        mBrightnessObserver.updateBlockingZoneThresholds(displayDeviceConfig,

            /* attemptLoadingFromDeviceConfig= */ true);

        mBrightnessObserver.reloadLightSensor(displayDeviceConfig);

            mHbmObserver.setupHdrRefreshRates(displayDeviceConfig);

        }

    }



    /**
@@ -2775,7 +2766,7 @@ public class DisplayModeDirector { 
     * HBM that are associated with that display. Restrictions are retrieved from

     * DisplayManagerInternal but originate in the display-device-config file.

     */

    public class HbmObserver implements DisplayManager.DisplayListener {

    public static class HbmObserver implements DisplayManager.DisplayListener {

        private final BallotBox mBallotBox;

        private final Handler mHandler;

        private final SparseIntArray mHbmMode = new SparseIntArray();
@@ -2795,24 +2786,10 @@ public class DisplayModeDirector { 
            mDeviceConfigDisplaySettings = displaySettings;

        }



        /**

         * Sets up the refresh rate to be used when HDR is enabled

         */

        public void setupHdrRefreshRates(DisplayDeviceConfig displayDeviceConfig) {

            mRefreshRateInHbmHdr = mDeviceConfigDisplaySettings

                .getRefreshRateInHbmHdr(displayDeviceConfig);

            mRefreshRateInHbmSunlight = mDeviceConfigDisplaySettings

                .getRefreshRateInHbmSunlight(displayDeviceConfig);

        }



        /**

         * Sets up the HDR refresh rates, and starts observing for the changes in the display that

         * might impact it

         */

        public void observe() {

            synchronized (mLock) {

                setupHdrRefreshRates(mDefaultDisplayDeviceConfig);

            }

            mRefreshRateInHbmSunlight = mDeviceConfigDisplaySettings.getRefreshRateInHbmSunlight();

            mRefreshRateInHbmHdr = mDeviceConfigDisplaySettings.getRefreshRateInHbmHdr();



            mDisplayManagerInternal = LocalServices.getService(DisplayManagerInternal.class);

            mInjector.registerDisplayListener(this, mHandler,

                    DisplayManager.EVENT_FLAG_DISPLAY_BRIGHTNESS
@@ -3044,33 +3021,26 @@ public class DisplayModeDirector { 
                    -1);

        }



        public int getRefreshRateInHbmHdr(DisplayDeviceConfig displayDeviceConfig) {

            int refreshRate =

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

                            R.integer.config_defaultRefreshRateInHbmHdr)

                            : displayDeviceConfig.getDefaultRefreshRateInHbmHdr();

            try {

                refreshRate = mDeviceConfig.getInt(DeviceConfig.NAMESPACE_DISPLAY_MANAGER,

                    DisplayManager.DeviceConfig.KEY_REFRESH_RATE_IN_HBM_HDR,

                    refreshRate);

            } catch (NullPointerException e) {

                // Do Nothing

            }

            return refreshRate;

        }

        public int getRefreshRateInHbmSunlight() {

            final int defaultRefreshRateInHbmSunlight =

                    mContext.getResources().getInteger(

                            R.integer.config_defaultRefreshRateInHbmSunlight);



        public int getRefreshRateInHbmSunlight(DisplayDeviceConfig displayDeviceConfig) {

            int refreshRate =

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

                        .getInteger(R.integer.config_defaultRefreshRateInHbmSunlight)

                        : displayDeviceConfig.getDefaultRefreshRateInHbmSunlight();

            try {

                refreshRate = mDeviceConfig.getInt(DeviceConfig.NAMESPACE_DISPLAY_MANAGER,

            final int refreshRate = mDeviceConfig.getInt(DeviceConfig.NAMESPACE_DISPLAY_MANAGER,

                    DisplayManager.DeviceConfig.KEY_REFRESH_RATE_IN_HBM_SUNLIGHT,

                    refreshRate);

            } catch (NullPointerException e) {

                // Do Nothing

                    defaultRefreshRateInHbmSunlight);



            return refreshRate;

        }



        public int getRefreshRateInHbmHdr() {

            final int defaultRefreshRateInHbmHdr =

                    mContext.getResources().getInteger(R.integer.config_defaultRefreshRateInHbmHdr);



            final int refreshRate = mDeviceConfig.getInt(DeviceConfig.NAMESPACE_DISPLAY_MANAGER,

                    DisplayManager.DeviceConfig.KEY_REFRESH_RATE_IN_HBM_HDR,

                    defaultRefreshRateInHbmHdr);



            return refreshRate;

        }
@@ -3120,19 +3090,15 @@ public class DisplayModeDirector { 
                        0).sendToTarget();

            }



            synchronized (mLock) {

                final int refreshRateInHbmSunlight =

                        getRefreshRateInHbmSunlight(mDefaultDisplayDeviceConfig);

            final int refreshRateInHbmSunlight = getRefreshRateInHbmSunlight();

            mHandler.obtainMessage(MSG_REFRESH_RATE_IN_HBM_SUNLIGHT_CHANGED,

                    refreshRateInHbmSunlight, 0)

                    .sendToTarget();



                final int refreshRateInHbmHdr =

                        getRefreshRateInHbmHdr(mDefaultDisplayDeviceConfig);

            final int refreshRateInHbmHdr = getRefreshRateInHbmHdr();

            mHandler.obtainMessage(MSG_REFRESH_RATE_IN_HBM_HDR_CHANGED, refreshRateInHbmHdr, 0)

                    .sendToTarget();

        }

        }



        private int[] getIntArrayProperty(String prop) {

            String strArray = mDeviceConfig.getString(DeviceConfig.NAMESPACE_DISPLAY_MANAGER, prop,

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

+2 −12
Original line number Diff line number Diff line
@@ -55,8 +55,6 @@ public final class DisplayDeviceConfigTest { 
    private static final int DEFAULT_REFRESH_RATE = 120;

    private static final int DEFAULT_HIGH_BLOCKING_ZONE_REFRESH_RATE = 55;

    private static final int DEFAULT_LOW_BLOCKING_ZONE_REFRESH_RATE = 95;

    private static final int DEFAULT_REFRESH_RATE_IN_HBM_HDR = 90;

    private static final int DEFAULT_REFRESH_RATE_IN_HBM_SUNLIGHT = 100;

    private static final int[] LOW_BRIGHTNESS_THRESHOLD_OF_PEAK_REFRESH_RATE = new int[]{10, 30};

    private static final int[] LOW_AMBIENT_THRESHOLD_OF_PEAK_REFRESH_RATE = new int[]{1, 21};

    private static final int[] HIGH_BRIGHTNESS_THRESHOLD_OF_PEAK_REFRESH_RATE = new int[]{160};
@@ -297,11 +295,9 @@ public final class DisplayDeviceConfigTest { 
                DEFAULT_HIGH_BLOCKING_ZONE_REFRESH_RATE);

        assertEquals(mDisplayDeviceConfig.getDefaultPeakRefreshRate(), DEFAULT_PEAK_REFRESH_RATE);

        assertEquals(mDisplayDeviceConfig.getDefaultRefreshRate(), DEFAULT_REFRESH_RATE);



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

        assertEquals(mDisplayDeviceConfig.getDefaultRefreshRateInHbmSunlight(),

                DEFAULT_REFRESH_RATE_IN_HBM_SUNLIGHT);

        assertEquals(mDisplayDeviceConfig.getDefaultRefreshRateInHbmHdr(),

                DEFAULT_REFRESH_RATE_IN_HBM_HDR);



        assertArrayEquals(mDisplayDeviceConfig.getLowDisplayBrightnessThresholds(),

                LOW_BRIGHTNESS_THRESHOLD_OF_PEAK_REFRESH_RATE);

        assertArrayEquals(mDisplayDeviceConfig.getLowAmbientBrightnessThresholds(),
@@ -698,12 +694,6 @@ public final class DisplayDeviceConfigTest { 
        when(mResources.getIntArray(

                R.array.config_highAmbientBrightnessThresholdsOfFixedRefreshRate))

                .thenReturn(HIGH_AMBIENT_THRESHOLD_OF_PEAK_REFRESH_RATE);

        when(mResources.getInteger(

            R.integer.config_defaultRefreshRateInHbmHdr))

            .thenReturn(DEFAULT_REFRESH_RATE_IN_HBM_HDR);

        when(mResources.getInteger(

            R.integer.config_defaultRefreshRateInHbmSunlight))

            .thenReturn(DEFAULT_REFRESH_RATE_IN_HBM_SUNLIGHT);



        mDisplayDeviceConfig = DisplayDeviceConfig.create(mContext, true);

    }

services/tests/servicestests/src/com/android/server/display/DisplayModeDirectorTest.java

+1 −28
Original line number Diff line number Diff line
@@ -2264,10 +2264,6 @@ public class DisplayModeDirectorTest { 
            .thenReturn(65);

        when(resources.getInteger(R.integer.config_defaultRefreshRateInZone))

            .thenReturn(85);

        when(resources.getInteger(R.integer.config_defaultRefreshRateInHbmHdr))

            .thenReturn(95);

        when(resources.getInteger(R.integer.config_defaultRefreshRateInHbmSunlight))

            .thenReturn(100);

        when(resources.getIntArray(R.array.config_brightnessThresholdsOfPeakRefreshRate))

            .thenReturn(new int[]{5});

        when(resources.getIntArray(R.array.config_ambientThresholdsOfPeakRefreshRate))
@@ -2278,21 +2274,8 @@ public class DisplayModeDirectorTest { 
        when(

            resources.getIntArray(R.array.config_highAmbientBrightnessThresholdsOfFixedRefreshRate))

            .thenReturn(new int[]{7000});

        when(resources.getInteger(

            com.android.internal.R.integer.config_displayWhiteBalanceBrightnessFilterHorizon))

            .thenReturn(3);

        ArgumentCaptor<TypedValue> valueArgumentCaptor = ArgumentCaptor.forClass(TypedValue.class);

        doAnswer((Answer<Void>) invocation -> {

            valueArgumentCaptor.getValue().type = 4;

            valueArgumentCaptor.getValue().data = 13;

            return null;

        }).when(resources).getValue(eq(com.android.internal.R.dimen

                .config_displayWhiteBalanceBrightnessFilterIntercept),

                valueArgumentCaptor.capture(), eq(true));

        DisplayModeDirector director =

                createDirectorFromRefreshRateArray(new float[]{60.0f, 90.0f}, 0);

        SensorManager sensorManager = createMockSensorManager(createLightSensor());

        director.start(sensorManager);

        // We don't expect any interaction with DeviceConfig when the director is initialized

        // because we explicitly avoid doing this as this can lead to a latency spike in the

        // startup of DisplayManagerService
@@ -2302,8 +2285,6 @@ public class DisplayModeDirectorTest { 
                0.0);

        assertEquals(director.getBrightnessObserver().getRefreshRateInHighZone(), 65);

        assertEquals(director.getBrightnessObserver().getRefreshRateInLowZone(), 85);

        assertEquals(director.getHbmObserver().getRefreshRateInHbmHdr(), 95);

        assertEquals(director.getHbmObserver().getRefreshRateInHbmSunlight(), 100);

        assertArrayEquals(director.getBrightnessObserver().getHighDisplayBrightnessThreshold(),

                new int[]{250});

        assertArrayEquals(director.getBrightnessObserver().getHighAmbientBrightnessThreshold(),
@@ -2313,7 +2294,6 @@ public class DisplayModeDirectorTest { 
        assertArrayEquals(director.getBrightnessObserver().getLowAmbientBrightnessThreshold(),

                new int[]{10});





        // Notify that the default display is updated, such that DisplayDeviceConfig has new values

        DisplayDeviceConfig displayDeviceConfig = mock(DisplayDeviceConfig.class);

        when(displayDeviceConfig.getDefaultLowBlockingZoneRefreshRate()).thenReturn(50);
@@ -2324,8 +2304,6 @@ public class DisplayModeDirectorTest { 
        when(displayDeviceConfig.getLowAmbientBrightnessThresholds()).thenReturn(new int[]{30});

        when(displayDeviceConfig.getHighDisplayBrightnessThresholds()).thenReturn(new int[]{210});

        when(displayDeviceConfig.getHighAmbientBrightnessThresholds()).thenReturn(new int[]{2100});

        when(displayDeviceConfig.getDefaultRefreshRateInHbmHdr()).thenReturn(65);

        when(displayDeviceConfig.getDefaultRefreshRateInHbmSunlight()).thenReturn(75);

        director.defaultDisplayDeviceUpdated(displayDeviceConfig);



        assertEquals(director.getSettingsObserver().getDefaultRefreshRate(), 60, 0.0);
@@ -2341,8 +2319,6 @@ public class DisplayModeDirectorTest { 
                new int[]{25});

        assertArrayEquals(director.getBrightnessObserver().getLowAmbientBrightnessThreshold(),

                new int[]{30});

        assertEquals(director.getHbmObserver().getRefreshRateInHbmHdr(), 65);

        assertEquals(director.getHbmObserver().getRefreshRateInHbmSunlight(), 75);



        // Notify that the default display is updated, such that DeviceConfig has new values

        FakeDeviceConfig config = mInjector.getDeviceConfig();
@@ -2353,8 +2329,7 @@ public class DisplayModeDirectorTest { 
        config.setLowDisplayBrightnessThresholds(new int[]{10});

        config.setHighDisplayBrightnessThresholds(new int[]{255});

        config.setHighAmbientBrightnessThresholds(new int[]{8000});

        config.setRefreshRateInHbmHdr(70);

        config.setRefreshRateInHbmSunlight(80);



        director.defaultDisplayDeviceUpdated(displayDeviceConfig);



        assertEquals(director.getSettingsObserver().getDefaultRefreshRate(), 60, 0.0);
@@ -2370,8 +2345,6 @@ public class DisplayModeDirectorTest { 
                new int[]{10});

        assertArrayEquals(director.getBrightnessObserver().getLowAmbientBrightnessThreshold(),

                new int[]{20});

        assertEquals(director.getHbmObserver().getRefreshRateInHbmHdr(), 70);

        assertEquals(director.getHbmObserver().getRefreshRateInHbmSunlight(), 80);

    }



    @Test