diff options
7 files changed, 203 insertions, 25 deletions
diff --git a/services/core/java/com/android/server/display/DisplayPowerController2.java b/services/core/java/com/android/server/display/DisplayPowerController2.java index 9ded42aa6539..1f58a1c40fd8 100644 --- a/services/core/java/com/android/server/display/DisplayPowerController2.java +++ b/services/core/java/com/android/server/display/DisplayPowerController2.java @@ -299,7 +299,6 @@ final class DisplayPowerController2 implements AutomaticBrightnessController.Cal private boolean mAppliedAutoBrightness; private boolean mAppliedDimming; private boolean mAppliedLowPower; - private boolean mAppliedTemporaryBrightness; private boolean mAppliedTemporaryAutoBrightnessAdjustment; private boolean mAppliedBrightnessBoost; private boolean mAppliedThrottling; @@ -395,11 +394,6 @@ final class DisplayPowerController2 implements AutomaticBrightnessController.Cal // behalf of the user. private float mCurrentScreenBrightnessSetting; - // The temporary screen brightness. Typically set when a user is interacting with the - // brightness slider but hasn't settled on a choice yet. Set to - // PowerManager.BRIGHTNESS_INVALID_FLOAT when there's no temporary brightness set. - private float mTemporaryScreenBrightness; - // The current screen brightness while in VR mode. private float mScreenBrightnessForVr; @@ -566,7 +560,6 @@ final class DisplayPowerController2 implements AutomaticBrightnessController.Cal mCurrentScreenBrightnessSetting = getScreenBrightnessSetting(); mScreenBrightnessForVr = getScreenBrightnessForVrSetting(); mAutoBrightnessAdjustment = getAutoBrightnessAdjustmentSetting(); - mTemporaryScreenBrightness = PowerManager.BRIGHTNESS_INVALID_FLOAT; mPendingScreenBrightnessSetting = PowerManager.BRIGHTNESS_INVALID_FLOAT; mTemporaryAutoBrightnessAdjustment = PowerManager.BRIGHTNESS_INVALID_FLOAT; mPendingAutoBrightnessAdjustment = PowerManager.BRIGHTNESS_INVALID_FLOAT; @@ -1218,16 +1211,6 @@ final class DisplayPowerController2 implements AutomaticBrightnessController.Cal final boolean userSetBrightnessChanged = updateUserSetScreenBrightness(); - // Use the temporary screen brightness if there isn't an override, either from - // WindowManager or based on the display state. - if (isValidBrightnessValue(mTemporaryScreenBrightness)) { - brightnessState = mTemporaryScreenBrightness; - mAppliedTemporaryBrightness = true; - mBrightnessReasonTemp.setReason(BrightnessReason.REASON_TEMPORARY); - } else { - mAppliedTemporaryBrightness = false; - } - final boolean autoBrightnessAdjustmentChanged = updateAutoBrightnessAdjustment(); // Use the autobrightness adjustment override if set. @@ -1414,7 +1397,8 @@ final class DisplayPowerController2 implements AutomaticBrightnessController.Cal // Skip the animation when the screen is off or suspended or transition to/from VR. boolean brightnessAdjusted = false; final boolean brightnessIsTemporary = - mAppliedTemporaryBrightness || mAppliedTemporaryAutoBrightnessAdjustment; + (mBrightnessReason.getReason() == BrightnessReason.REASON_TEMPORARY) + || mAppliedTemporaryAutoBrightnessAdjustment; if (!mPendingScreenOff) { if (mSkipScreenOnBrightnessRamp) { if (state == Display.STATE_ON) { @@ -2202,13 +2186,15 @@ final class DisplayPowerController2 implements AutomaticBrightnessController.Cal } if (mCurrentScreenBrightnessSetting == mPendingScreenBrightnessSetting) { mPendingScreenBrightnessSetting = PowerManager.BRIGHTNESS_INVALID_FLOAT; - mTemporaryScreenBrightness = PowerManager.BRIGHTNESS_INVALID_FLOAT; + mDisplayBrightnessController + .setTemporaryBrightness(PowerManager.BRIGHTNESS_INVALID_FLOAT); return false; } setCurrentScreenBrightness(mPendingScreenBrightnessSetting); mLastUserSetScreenBrightness = mPendingScreenBrightnessSetting; mPendingScreenBrightnessSetting = PowerManager.BRIGHTNESS_INVALID_FLOAT; - mTemporaryScreenBrightness = PowerManager.BRIGHTNESS_INVALID_FLOAT; + mDisplayBrightnessController + .setTemporaryBrightness(PowerManager.BRIGHTNESS_INVALID_FLOAT); return true; } @@ -2291,7 +2277,6 @@ final class DisplayPowerController2 implements AutomaticBrightnessController.Cal pw.println(" mLastUserSetScreenBrightness=" + mLastUserSetScreenBrightness); pw.println(" mPendingScreenBrightnessSetting=" + mPendingScreenBrightnessSetting); - pw.println(" mTemporaryScreenBrightness=" + mTemporaryScreenBrightness); pw.println(" mAutoBrightnessAdjustment=" + mAutoBrightnessAdjustment); pw.println(" mBrightnessReason=" + mBrightnessReason); pw.println(" mTemporaryAutoBrightnessAdjustment=" + mTemporaryAutoBrightnessAdjustment); @@ -2301,7 +2286,6 @@ final class DisplayPowerController2 implements AutomaticBrightnessController.Cal pw.println(" mAppliedDimming=" + mAppliedDimming); pw.println(" mAppliedLowPower=" + mAppliedLowPower); pw.println(" mAppliedThrottling=" + mAppliedThrottling); - pw.println(" mAppliedTemporaryBrightness=" + mAppliedTemporaryBrightness); pw.println(" mAppliedTemporaryAutoBrightnessAdjustment=" + mAppliedTemporaryAutoBrightnessAdjustment); pw.println(" mAppliedBrightnessBoost=" + mAppliedBrightnessBoost); @@ -2541,7 +2525,8 @@ final class DisplayPowerController2 implements AutomaticBrightnessController.Cal case MSG_SET_TEMPORARY_BRIGHTNESS: // TODO: Should we have a a timeout for the temporary brightness? - mTemporaryScreenBrightness = Float.intBitsToFloat(msg.arg1); + mDisplayBrightnessController + .setTemporaryBrightness(Float.intBitsToFloat(msg.arg1)); updatePowerState(); break; diff --git a/services/core/java/com/android/server/display/brightness/BrightnessUtils.java b/services/core/java/com/android/server/display/brightness/BrightnessUtils.java index d62b1ee96798..fd4e296ae002 100644 --- a/services/core/java/com/android/server/display/brightness/BrightnessUtils.java +++ b/services/core/java/com/android/server/display/brightness/BrightnessUtils.java @@ -28,7 +28,7 @@ public final class BrightnessUtils { * Checks whether the brightness is within the valid brightness range, not including off. */ public static boolean isValidBrightnessValue(float brightness) { - return brightness >= PowerManager.BRIGHTNESS_MIN + return !Float.isNaN(brightness) && brightness >= PowerManager.BRIGHTNESS_MIN && brightness <= PowerManager.BRIGHTNESS_MAX; } diff --git a/services/core/java/com/android/server/display/brightness/DisplayBrightnessController.java b/services/core/java/com/android/server/display/brightness/DisplayBrightnessController.java index 80b5e65909c8..bdc8d9dbb043 100644 --- a/services/core/java/com/android/server/display/brightness/DisplayBrightnessController.java +++ b/services/core/java/com/android/server/display/brightness/DisplayBrightnessController.java @@ -68,6 +68,21 @@ public final class DisplayBrightnessController { } /** + * Sets the temporary brightness + */ + public void setTemporaryBrightness(Float temporaryBrightness) { + mDisplayBrightnessStrategySelector.getTemporaryDisplayBrightnessStrategy() + .setTemporaryScreenBrightness(temporaryBrightness); + } + + /** + * Returns the current selected DisplayBrightnessStrategy + */ + public DisplayBrightnessStrategy getCurrentDisplayBrightnessStrategy() { + return mDisplayBrightnessStrategy; + } + + /** * Returns a boolean flag indicating if the light sensor is to be used to decide the screen * brightness when dozing */ diff --git a/services/core/java/com/android/server/display/brightness/DisplayBrightnessStrategySelector.java b/services/core/java/com/android/server/display/brightness/DisplayBrightnessStrategySelector.java index b83b13b7da4c..4759b7df69ab 100644 --- a/services/core/java/com/android/server/display/brightness/DisplayBrightnessStrategySelector.java +++ b/services/core/java/com/android/server/display/brightness/DisplayBrightnessStrategySelector.java @@ -19,6 +19,7 @@ package com.android.server.display.brightness; import android.annotation.NonNull; import android.content.Context; import android.hardware.display.DisplayManagerInternal; +import android.util.IndentingPrintWriter; import android.util.Slog; import android.view.Display; @@ -29,6 +30,7 @@ import com.android.server.display.brightness.strategy.DozeBrightnessStrategy; import com.android.server.display.brightness.strategy.InvalidBrightnessStrategy; import com.android.server.display.brightness.strategy.OverrideBrightnessStrategy; import com.android.server.display.brightness.strategy.ScreenOffBrightnessStrategy; +import com.android.server.display.brightness.strategy.TemporaryBrightnessStrategy; import java.io.PrintWriter; @@ -48,7 +50,9 @@ public class DisplayBrightnessStrategySelector { // The brightness strategy used to manage the brightness state when the request state is // invalid. private final OverrideBrightnessStrategy mOverrideBrightnessStrategy; - // The brightness strategy used to manage the brightness state request is invalid. + // The brightness strategy used to manage the brightness state in temporary state + private final TemporaryBrightnessStrategy mTemporaryBrightnessStrategy; + // The brightness strategy used to manage the brightness state when the request is invalid. private final InvalidBrightnessStrategy mInvalidBrightnessStrategy; // We take note of the old brightness strategy so that we can know when the strategy changes. @@ -67,6 +71,7 @@ public class DisplayBrightnessStrategySelector { mDozeBrightnessStrategy = injector.getDozeBrightnessStrategy(); mScreenOffBrightnessStrategy = injector.getScreenOffBrightnessStrategy(); mOverrideBrightnessStrategy = injector.getOverrideBrightnessStrategy(); + mTemporaryBrightnessStrategy = injector.getTemporaryBrightnessStrategy(); mInvalidBrightnessStrategy = injector.getInvalidBrightnessStrategy(); mAllowAutoBrightnessWhileDozingConfig = context.getResources().getBoolean( R.bool.config_allowAutoBrightnessWhileDozing); @@ -89,6 +94,9 @@ public class DisplayBrightnessStrategySelector { } else if (BrightnessUtils .isValidBrightnessValue(displayPowerRequest.screenBrightnessOverride)) { displayBrightnessStrategy = mOverrideBrightnessStrategy; + } else if (BrightnessUtils.isValidBrightnessValue( + mTemporaryBrightnessStrategy.getTemporaryScreenBrightness())) { + displayBrightnessStrategy = mTemporaryBrightnessStrategy; } if (!mOldBrightnessStrategyName.equals(displayBrightnessStrategy.getName())) { @@ -101,6 +109,10 @@ public class DisplayBrightnessStrategySelector { return displayBrightnessStrategy; } + public TemporaryBrightnessStrategy getTemporaryDisplayBrightnessStrategy() { + return mTemporaryBrightnessStrategy; + } + /** * Returns a boolean flag indicating if the light sensor is to be used to decide the screen * brightness when dozing @@ -120,6 +132,8 @@ public class DisplayBrightnessStrategySelector { writer.println( " mAllowAutoBrightnessWhileDozingConfig= " + mAllowAutoBrightnessWhileDozingConfig); + IndentingPrintWriter ipw = new IndentingPrintWriter(writer, " "); + mTemporaryBrightnessStrategy.dump(ipw); } /** @@ -152,6 +166,10 @@ public class DisplayBrightnessStrategySelector { return new OverrideBrightnessStrategy(); } + TemporaryBrightnessStrategy getTemporaryBrightnessStrategy() { + return new TemporaryBrightnessStrategy(); + } + InvalidBrightnessStrategy getInvalidBrightnessStrategy() { return new InvalidBrightnessStrategy(); } diff --git a/services/core/java/com/android/server/display/brightness/strategy/TemporaryBrightnessStrategy.java b/services/core/java/com/android/server/display/brightness/strategy/TemporaryBrightnessStrategy.java new file mode 100644 index 000000000000..f8063f3f3c30 --- /dev/null +++ b/services/core/java/com/android/server/display/brightness/strategy/TemporaryBrightnessStrategy.java @@ -0,0 +1,75 @@ +/* + * Copyright (C) 2022 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.brightness.strategy; + +import android.hardware.display.DisplayManagerInternal; +import android.os.PowerManager; + +import com.android.server.display.DisplayBrightnessState; +import com.android.server.display.brightness.BrightnessReason; +import com.android.server.display.brightness.BrightnessUtils; + +import java.io.PrintWriter; + +/** + * Manages the brightness of the display when the system brightness is temporary + */ +public class TemporaryBrightnessStrategy implements DisplayBrightnessStrategy { + // The temporary screen brightness. Typically set when a user is interacting with the + // brightness slider but hasn't settled on a choice yet. Set to + // PowerManager.BRIGHTNESS_INVALID_FLOAT when there's no temporary brightness set. + private float mTemporaryScreenBrightness; + + public TemporaryBrightnessStrategy() { + mTemporaryScreenBrightness = PowerManager.BRIGHTNESS_INVALID_FLOAT; + } + + // Use the temporary screen brightness if there isn't an override, either from + // WindowManager or based on the display state. + @Override + public DisplayBrightnessState updateBrightness( + DisplayManagerInternal.DisplayPowerRequest displayPowerRequest) { + // Todo(brup): Introduce a validator class and add validations before setting the brightness + DisplayBrightnessState displayBrightnessState = + BrightnessUtils.constructDisplayBrightnessState(BrightnessReason.REASON_TEMPORARY, + mTemporaryScreenBrightness, + mTemporaryScreenBrightness); + mTemporaryScreenBrightness = Float.NaN; + return displayBrightnessState; + } + + @Override + public String getName() { + return "TemporaryBrightnessStrategy"; + } + + public float getTemporaryScreenBrightness() { + return mTemporaryScreenBrightness; + } + + public void setTemporaryScreenBrightness(float temporaryScreenBrightness) { + mTemporaryScreenBrightness = temporaryScreenBrightness; + } + + /** + * Dumps the state of this class. + */ + public void dump(PrintWriter writer) { + writer.println("TemporaryBrightnessStrategy:"); + writer.println(" mTemporaryScreenBrightness:" + mTemporaryScreenBrightness); + } +} diff --git a/services/tests/servicestests/src/com/android/server/display/brightness/DisplayBrightnessStrategySelectorTest.java b/services/tests/servicestests/src/com/android/server/display/brightness/DisplayBrightnessStrategySelectorTest.java index 59c69d114884..ccc43f29b2d1 100644 --- a/services/tests/servicestests/src/com/android/server/display/brightness/DisplayBrightnessStrategySelectorTest.java +++ b/services/tests/servicestests/src/com/android/server/display/brightness/DisplayBrightnessStrategySelectorTest.java @@ -33,6 +33,7 @@ import com.android.server.display.brightness.strategy.DozeBrightnessStrategy; import com.android.server.display.brightness.strategy.InvalidBrightnessStrategy; import com.android.server.display.brightness.strategy.OverrideBrightnessStrategy; import com.android.server.display.brightness.strategy.ScreenOffBrightnessStrategy; +import com.android.server.display.brightness.strategy.TemporaryBrightnessStrategy; import org.junit.Before; import org.junit.Test; @@ -53,6 +54,8 @@ public final class DisplayBrightnessStrategySelectorTest { @Mock private OverrideBrightnessStrategy mOverrideBrightnessStrategy; @Mock + private TemporaryBrightnessStrategy mTemporaryBrightnessStrategy; + @Mock private InvalidBrightnessStrategy mInvalidBrightnessStrategy; @Mock private Context mContext; @@ -65,6 +68,7 @@ public final class DisplayBrightnessStrategySelectorTest { public void before() { MockitoAnnotations.initMocks(this); when(mContext.getResources()).thenReturn(mResources); + when(mInvalidBrightnessStrategy.getName()).thenReturn("InvalidBrightnessStrategy"); DisplayBrightnessStrategySelector.Injector injector = new DisplayBrightnessStrategySelector.Injector() { @Override @@ -83,6 +87,11 @@ public final class DisplayBrightnessStrategySelectorTest { } @Override + TemporaryBrightnessStrategy getTemporaryBrightnessStrategy() { + return mTemporaryBrightnessStrategy; + } + + @Override InvalidBrightnessStrategy getInvalidBrightnessStrategy() { return mInvalidBrightnessStrategy; } @@ -121,6 +130,16 @@ public final class DisplayBrightnessStrategySelectorTest { } @Test + public void selectStrategySelectsTemporaryStrategyWhenValid() { + DisplayManagerInternal.DisplayPowerRequest displayPowerRequest = mock( + DisplayManagerInternal.DisplayPowerRequest.class); + displayPowerRequest.screenBrightnessOverride = Float.NaN; + when(mTemporaryBrightnessStrategy.getTemporaryScreenBrightness()).thenReturn(0.3f); + assertEquals(mDisplayBrightnessStrategySelector.selectStrategy(displayPowerRequest, + Display.STATE_ON), mTemporaryBrightnessStrategy); + } + + @Test public void selectStrategySelectsInvalidStrategyWhenNoStrategyIsValid() { DisplayManagerInternal.DisplayPowerRequest displayPowerRequest = mock( DisplayManagerInternal.DisplayPowerRequest.class); diff --git a/services/tests/servicestests/src/com/android/server/display/brightness/strategy/TemporaryBrightnessStrategyTest.java b/services/tests/servicestests/src/com/android/server/display/brightness/strategy/TemporaryBrightnessStrategyTest.java new file mode 100644 index 000000000000..4a32796470c7 --- /dev/null +++ b/services/tests/servicestests/src/com/android/server/display/brightness/strategy/TemporaryBrightnessStrategyTest.java @@ -0,0 +1,66 @@ +/* + * Copyright (C) 2022 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.brightness.strategy; + + +import static org.junit.Assert.assertEquals; + +import android.hardware.display.DisplayManagerInternal; + +import androidx.test.filters.SmallTest; +import androidx.test.runner.AndroidJUnit4; + +import com.android.server.display.DisplayBrightnessState; +import com.android.server.display.brightness.BrightnessReason; + +import org.junit.Before; +import org.junit.Test; +import org.junit.runner.RunWith; + +@SmallTest +@RunWith(AndroidJUnit4.class) + +public class TemporaryBrightnessStrategyTest { + private TemporaryBrightnessStrategy mTemporaryBrightnessStrategy; + + @Before + public void before() { + mTemporaryBrightnessStrategy = new TemporaryBrightnessStrategy(); + } + + @Test + public void updateBrightnessWorksAsExpectedWhenTemporaryBrightnessIsSet() { + DisplayManagerInternal.DisplayPowerRequest + displayPowerRequest = new DisplayManagerInternal.DisplayPowerRequest(); + float temporaryBrightness = 0.2f; + mTemporaryBrightnessStrategy.setTemporaryScreenBrightness(temporaryBrightness); + BrightnessReason brightnessReason = new BrightnessReason(); + brightnessReason.setReason(BrightnessReason.REASON_TEMPORARY); + DisplayBrightnessState expectedDisplayBrightnessState = + new DisplayBrightnessState.Builder() + .setBrightness(temporaryBrightness) + .setBrightnessReason(brightnessReason) + .setSdrBrightness(temporaryBrightness) + .build(); + DisplayBrightnessState updatedDisplayBrightnessState = + mTemporaryBrightnessStrategy.updateBrightness(displayPowerRequest); + assertEquals(updatedDisplayBrightnessState, expectedDisplayBrightnessState); + assertEquals(mTemporaryBrightnessStrategy.getTemporaryScreenBrightness(), + Float.NaN, 0.0f); + } + +} |