From b7c40451f4e0660571f2b2cead76c49282b2194d Mon Sep 17 00:00:00 2001 From: Daniel Solomon Date: Fri, 3 Dec 2021 19:53:30 -0800 Subject: [PATCH] Notify display brightness changed due to brightness transforms Currently, DisplayPowerController generates display brightness change events following Manual and Adaptive Brightness changes, and ignores brightness transforms due to dimming (preceding display timeout) and low power mode. Depending on device configuration, this can prevent refresh rate policy in DisplayModeDirector from being applied correctly. This change causes a brightness change event to be triggered for those brightness transforms. Bug: 202873446 Test: Use `dumpsys display` to ensure refresh rate votes are cast correctly during display dimming prior to a timeout, and after that dimming period is interrupted by touching the display. Change-Id: Ic9442ff2fc64878b0ead074dbc9969184a183116 --- .../display/DisplayPowerController.java | 117 ++++++++++++------ 1 file changed, 82 insertions(+), 35 deletions(-) diff --git a/services/core/java/com/android/server/display/DisplayPowerController.java b/services/core/java/com/android/server/display/DisplayPowerController.java index 22dd2c05c1578..cbc2c0c6c8acc 100644 --- a/services/core/java/com/android/server/display/DisplayPowerController.java +++ b/services/core/java/com/android/server/display/DisplayPowerController.java @@ -50,6 +50,8 @@ import android.os.UserHandle; import android.provider.Settings; import android.util.Log; import android.util.MathUtils; +import android.util.MutableFloat; +import android.util.MutableInt; import android.util.Slog; import android.util.TimeUtils; import android.view.Display; @@ -1323,6 +1325,7 @@ final class DisplayPowerController implements AutomaticBrightnessController.Call // Animate the screen brightness when the screen is on or dozing. // Skip the animation when the screen is off or suspended or transition to/from VR. + boolean brightnessAdjusted = false; if (!mPendingScreenOff) { if (mSkipScreenOnBrightnessRamp) { if (state == Display.STATE_ON) { @@ -1410,15 +1413,19 @@ final class DisplayPowerController implements AutomaticBrightnessController.Call // slider event so notify as if the system changed the brightness. userInitiatedChange = false; } - notifyBrightnessChanged(brightnessState, userInitiatedChange, + notifyBrightnessTrackerChanged(brightnessState, userInitiatedChange, hadUserBrightnessPoint); } // We save the brightness info *after* the brightness setting has been changed and // adjustments made so that the brightness info reflects the latest value. - saveBrightnessInfo(getScreenBrightnessSetting(), animateValue); + brightnessAdjusted = saveBrightnessInfo(getScreenBrightnessSetting(), animateValue); } else { - saveBrightnessInfo(getScreenBrightnessSetting()); + brightnessAdjusted = saveBrightnessInfo(getScreenBrightnessSetting()); + } + + if (brightnessAdjusted) { + postBrightnessChangeRunnable(); } // Log any changes to what is currently driving the brightness setting. @@ -1534,31 +1541,50 @@ final class DisplayPowerController implements AutomaticBrightnessController.Call public BrightnessInfo getBrightnessInfo() { synchronized (mCachedBrightnessInfo) { return new BrightnessInfo( - mCachedBrightnessInfo.brightness, - mCachedBrightnessInfo.adjustedBrightness, - mCachedBrightnessInfo.brightnessMin, - mCachedBrightnessInfo.brightnessMax, - mCachedBrightnessInfo.hbmMode, - mCachedBrightnessInfo.highBrightnessTransitionPoint); + mCachedBrightnessInfo.brightness.value, + mCachedBrightnessInfo.adjustedBrightness.value, + mCachedBrightnessInfo.brightnessMin.value, + mCachedBrightnessInfo.brightnessMax.value, + mCachedBrightnessInfo.hbmMode.value, + mCachedBrightnessInfo.hbmTransitionPoint.value); } } - private void saveBrightnessInfo(float brightness) { - saveBrightnessInfo(brightness, brightness); + private boolean saveBrightnessInfo(float brightness) { + return saveBrightnessInfo(brightness, brightness); } - private void saveBrightnessInfo(float brightness, float adjustedBrightness) { + private boolean saveBrightnessInfo(float brightness, float adjustedBrightness) { synchronized (mCachedBrightnessInfo) { - mCachedBrightnessInfo.brightness = brightness; - mCachedBrightnessInfo.adjustedBrightness = adjustedBrightness; - mCachedBrightnessInfo.brightnessMin = mHbmController.getCurrentBrightnessMin(); - mCachedBrightnessInfo.brightnessMax = mHbmController.getCurrentBrightnessMax(); - mCachedBrightnessInfo.hbmMode = mHbmController.getHighBrightnessMode(); - mCachedBrightnessInfo.highBrightnessTransitionPoint = - mHbmController.getTransitionPoint(); + boolean changed = false; + + changed |= + mCachedBrightnessInfo.checkAndSetFloat(mCachedBrightnessInfo.brightness, + brightness); + changed |= + mCachedBrightnessInfo.checkAndSetFloat(mCachedBrightnessInfo.adjustedBrightness, + adjustedBrightness); + changed |= + mCachedBrightnessInfo.checkAndSetFloat(mCachedBrightnessInfo.brightnessMin, + mHbmController.getCurrentBrightnessMin()); + changed |= + mCachedBrightnessInfo.checkAndSetFloat(mCachedBrightnessInfo.brightnessMax, + mHbmController.getCurrentBrightnessMax()); + changed |= + mCachedBrightnessInfo.checkAndSetInt(mCachedBrightnessInfo.hbmMode, + mHbmController.getHighBrightnessMode()); + changed |= + mCachedBrightnessInfo.checkAndSetFloat(mCachedBrightnessInfo.hbmTransitionPoint, + mHbmController.getTransitionPoint()); + + return changed; } } + void postBrightnessChangeRunnable() { + mHandler.post(mOnBrightnessChangeRunnable); + } + private HighBrightnessModeController createHbmControllerLocked() { final DisplayDevice device = mLogicalDisplay.getPrimaryDisplayDeviceLocked(); final DisplayDeviceConfig ddConfig = device.getDisplayDeviceConfig(); @@ -1571,7 +1597,7 @@ final class DisplayPowerController implements AutomaticBrightnessController.Call PowerManager.BRIGHTNESS_MIN, PowerManager.BRIGHTNESS_MAX, hbmData, () -> { sendUpdatePowerStateLocked(); - mHandler.post(mOnBrightnessChangeRunnable); + postBrightnessChangeRunnable(); // TODO(b/192258832): Switch the HBMChangeCallback to a listener pattern. if (mAutomaticBrightnessController != null) { mAutomaticBrightnessController.update(); @@ -2073,7 +2099,7 @@ final class DisplayPowerController implements AutomaticBrightnessController.Call private void setCurrentScreenBrightness(float brightnessValue) { if (brightnessValue != mCurrentScreenBrightnessSetting) { mCurrentScreenBrightnessSetting = brightnessValue; - mHandler.post(mOnBrightnessChangeRunnable); + postBrightnessChangeRunnable(); } } @@ -2125,7 +2151,7 @@ final class DisplayPowerController implements AutomaticBrightnessController.Call return true; } - private void notifyBrightnessChanged(float brightness, boolean userInitiated, + private void notifyBrightnessTrackerChanged(float brightness, boolean userInitiated, boolean hadUserDataPoint) { final float brightnessInNits = convertToNits(brightness); if (mPowerRequest.useAutoBrightness && brightnessInNits >= 0.0f @@ -2236,16 +2262,17 @@ final class DisplayPowerController implements AutomaticBrightnessController.Call pw.println(" mColorFadeFadesConfig=" + mColorFadeFadesConfig); pw.println(" mColorFadeEnabled=" + mColorFadeEnabled); synchronized (mCachedBrightnessInfo) { - pw.println(" mCachedBrightnessInfo.brightness=" + mCachedBrightnessInfo.brightness); + pw.println(" mCachedBrightnessInfo.brightness=" + + mCachedBrightnessInfo.brightness.value); pw.println(" mCachedBrightnessInfo.adjustedBrightness=" + - mCachedBrightnessInfo.adjustedBrightness); + mCachedBrightnessInfo.adjustedBrightness.value); pw.println(" mCachedBrightnessInfo.brightnessMin=" + - mCachedBrightnessInfo.brightnessMin); + mCachedBrightnessInfo.brightnessMin.value); pw.println(" mCachedBrightnessInfo.brightnessMax=" + - mCachedBrightnessInfo.brightnessMax); - pw.println(" mCachedBrightnessInfo.hbmMode=" + mCachedBrightnessInfo.hbmMode); - pw.println(" mCachedBrightnessInfo.highBrightnessTransitionPoint=" + - mCachedBrightnessInfo.highBrightnessTransitionPoint); + mCachedBrightnessInfo.brightnessMax.value); + pw.println(" mCachedBrightnessInfo.hbmMode=" + mCachedBrightnessInfo.hbmMode.value); + pw.println(" mCachedBrightnessInfo.hbmTransitionPoint=" + + mCachedBrightnessInfo.hbmTransitionPoint.value); } pw.println(" mDisplayBlanksAfterDozeConfig=" + mDisplayBlanksAfterDozeConfig); pw.println(" mBrightnessBucketsInDozeConfig=" + mBrightnessBucketsInDozeConfig); @@ -2663,11 +2690,31 @@ final class DisplayPowerController implements AutomaticBrightnessController.Call } static class CachedBrightnessInfo { - public float brightness; - public float adjustedBrightness; - public float brightnessMin; - public float brightnessMax; - public int hbmMode; - public float highBrightnessTransitionPoint; + public MutableFloat brightness = new MutableFloat(PowerManager.BRIGHTNESS_INVALID_FLOAT); + public MutableFloat adjustedBrightness = + new MutableFloat(PowerManager.BRIGHTNESS_INVALID_FLOAT); + public MutableFloat brightnessMin = + new MutableFloat(PowerManager.BRIGHTNESS_INVALID_FLOAT); + public MutableFloat brightnessMax = + new MutableFloat(PowerManager.BRIGHTNESS_INVALID_FLOAT); + public MutableInt hbmMode = new MutableInt(BrightnessInfo.HIGH_BRIGHTNESS_MODE_OFF); + public MutableFloat hbmTransitionPoint = + new MutableFloat(HighBrightnessModeController.HBM_TRANSITION_POINT_INVALID); + + public boolean checkAndSetFloat(MutableFloat mf, float f) { + if (mf.value != f) { + mf.value = f; + return true; + } + return false; + } + + public boolean checkAndSetInt(MutableInt mi, int i) { + if (mi.value != i) { + mi.value = i; + return true; + } + return false; + } } }