Merge "Doze brightness float" into main
diff --git a/core/java/android/os/PowerManagerInternal.java b/core/java/android/os/PowerManagerInternal.java
index ce3156e..1fb7937 100644
--- a/core/java/android/os/PowerManagerInternal.java
+++ b/core/java/android/os/PowerManagerInternal.java
@@ -139,11 +139,16 @@
* @param screenState The overridden screen state, or {@link Display#STATE_UNKNOWN}
* to disable the override.
* @param reason The reason for overriding the screen state.
- * @param screenBrightness The overridden screen brightness, or
- * {@link PowerManager#BRIGHTNESS_DEFAULT} to disable the override.
+ * @param screenBrightnessFloat The overridden screen brightness between
+ * {@link PowerManager#BRIGHTNESS_MIN} and {@link PowerManager#BRIGHTNESS_MAX}, or
+ * {@link PowerManager#BRIGHTNESS_INVALID_FLOAT} if screenBrightnessInt should be used instead.
+ * @param screenBrightnessInt The overridden screen brightness between 1 and 255, or
+ * {@link PowerManager#BRIGHTNESS_DEFAULT} to disable the override. Not used if
+ * screenBrightnessFloat is provided (is not NaN).
*/
public abstract void setDozeOverrideFromDreamManager(
- int screenState, @Display.StateReason int reason, int screenBrightness);
+ int screenState, @Display.StateReason int reason, float screenBrightnessFloat,
+ int screenBrightnessInt);
/**
* Used by sidekick manager to tell the power manager if it shouldn't change the display state
diff --git a/core/java/android/provider/Settings.java b/core/java/android/provider/Settings.java
index c186538..0ee6f43 100644
--- a/core/java/android/provider/Settings.java
+++ b/core/java/android/provider/Settings.java
@@ -15820,7 +15820,7 @@
* The following keys are supported:
*
* <pre>
- * screen_brightness_array (int[])
+ * screen_brightness_array (int[], values in range [1, 255])
* dimming_scrim_array (int[])
* prox_screen_off_delay (long)
* prox_cooldown_trigger (long)
diff --git a/core/java/android/service/dreams/DreamService.java b/core/java/android/service/dreams/DreamService.java
index 74545a8..06e53ac 100644
--- a/core/java/android/service/dreams/DreamService.java
+++ b/core/java/android/service/dreams/DreamService.java
@@ -74,6 +74,7 @@
import com.android.internal.R;
import com.android.internal.annotations.VisibleForTesting;
+import com.android.internal.display.BrightnessSynchronizer;
import com.android.internal.util.DumpUtils;
import java.io.FileDescriptor;
@@ -269,6 +270,7 @@
private volatile int mDozeScreenState = Display.STATE_UNKNOWN;
private volatile @Display.StateReason int mDozeScreenStateReason = Display.STATE_REASON_UNKNOWN;
private volatile int mDozeScreenBrightness = PowerManager.BRIGHTNESS_DEFAULT;
+ private volatile float mDozeScreenBrightnessFloat = PowerManager.BRIGHTNESS_INVALID_FLOAT;
private boolean mDebug = false;
@@ -927,12 +929,12 @@
try {
if (startAndStopDozingInBackground()) {
mDreamManager.startDozingOneway(
- mDreamToken, mDozeScreenState, mDozeScreenStateReason,
- mDozeScreenBrightness);
+ mDreamToken, mDozeScreenState, mDozeScreenStateReason,
+ mDozeScreenBrightnessFloat, mDozeScreenBrightness);
} else {
mDreamManager.startDozing(
mDreamToken, mDozeScreenState, mDozeScreenStateReason,
- mDozeScreenBrightness);
+ mDozeScreenBrightnessFloat, mDozeScreenBrightness);
}
} catch (RemoteException ex) {
@@ -1057,7 +1059,7 @@
* Gets the screen brightness to use while dozing.
*
* @return The screen brightness while dozing as a value between
- * {@link PowerManager#BRIGHTNESS_OFF} (0) and {@link PowerManager#BRIGHTNESS_ON} (255),
+ * {@link PowerManager#BRIGHTNESS_OFF + 1} (1) and {@link PowerManager#BRIGHTNESS_ON} (255),
* or {@link PowerManager#BRIGHTNESS_DEFAULT} (-1) to ask the system to apply
* its default policy based on the screen state.
*
@@ -1078,11 +1080,11 @@
* The dream may set a different brightness before starting to doze and may adjust
* the brightness while dozing to conserve power and achieve various effects.
* </p><p>
- * Note that dream may specify any brightness in the full 0-255 range, including
+ * Note that dream may specify any brightness in the full 1-255 range, including
* values that are less than the minimum value for manual screen brightness
- * adjustments by the user. In particular, the value may be set to 0 which may
- * turn off the backlight entirely while still leaving the screen on although
- * this behavior is device dependent and not guaranteed.
+ * adjustments by the user. In particular, the value may be set to
+ * {@link PowerManager.BRIGHTNESS_OFF} which may turn off the backlight entirely while still
+ * leaving the screen on although this behavior is device dependent and not guaranteed.
* </p><p>
* The available range of display brightness values and their behavior while dozing is
* hardware dependent and may vary across devices. The dream may therefore
@@ -1090,7 +1092,7 @@
* </p>
*
* @param brightness The screen brightness while dozing as a value between
- * {@link PowerManager#BRIGHTNESS_OFF} (0) and {@link PowerManager#BRIGHTNESS_ON} (255),
+ * {@link PowerManager#BRIGHTNESS_OFF + 1} (1) and {@link PowerManager#BRIGHTNESS_ON} (255),
* or {@link PowerManager#BRIGHTNESS_DEFAULT} (-1) to ask the system to apply
* its default policy based on the screen state.
*
@@ -1108,6 +1110,44 @@
}
/**
+ * Sets the screen brightness to use while dozing.
+ * <p>
+ * The value of this property determines the power state of the primary display
+ * once {@link #startDozing} has been called. The default value is
+ * {@link PowerManager#BRIGHTNESS_INVALID_FLOAT} which lets the system decide.
+ * The dream may set a different brightness before starting to doze and may adjust
+ * the brightness while dozing to conserve power and achieve various effects.
+ * </p><p>
+ * Note that dream may specify any brightness in the full 0-1 range, including
+ * values that are less than the minimum value for manual screen brightness
+ * adjustments by the user. In particular, the value may be set to
+ * {@link PowerManager#BRIGHTNESS_OFF_FLOAT} which may turn off the backlight entirely while
+ * still leaving the screen on although this behavior is device dependent and not guaranteed.
+ * </p><p>
+ * The available range of display brightness values and their behavior while dozing is
+ * hardware dependent and may vary across devices. The dream may therefore
+ * need to be modified or configured to correctly support the hardware.
+ * </p>
+ *
+ * @param brightness The screen brightness while dozing as a value between
+ * {@link PowerManager#BRIGHTNESS_MIN} (0) and {@link PowerManager#BRIGHTNESS_MAX} (1),
+ * or {@link PowerManager#BRIGHTNESS_INVALID_FLOAT} (Float.NaN) to ask the system to apply
+ * its default policy based on the screen state.
+ *
+ * @hide For use by system UI components only.
+ */
+ @UnsupportedAppUsage
+ public void setDozeScreenBrightnessFloat(float brightness) {
+ if (!Float.isNaN(brightness)) {
+ brightness = clampAbsoluteBrightnessFloat(brightness);
+ }
+ if (!BrightnessSynchronizer.floatEquals(mDozeScreenBrightnessFloat, brightness)) {
+ mDozeScreenBrightnessFloat = brightness;
+ updateDoze();
+ }
+ }
+
+ /**
* Called when this Dream is constructed.
*/
@Override
@@ -1751,6 +1791,13 @@
return MathUtils.constrain(value, PowerManager.BRIGHTNESS_OFF, PowerManager.BRIGHTNESS_ON);
}
+ private static float clampAbsoluteBrightnessFloat(float value) {
+ if (value == PowerManager.BRIGHTNESS_OFF_FLOAT) {
+ return value;
+ }
+ return MathUtils.constrain(value, PowerManager.BRIGHTNESS_MIN, PowerManager.BRIGHTNESS_MAX);
+ }
+
/**
* The DreamServiceWrapper is used as a gateway to the system_server, where DreamController
* uses it to control the DreamService. It is also used to receive callbacks from the
diff --git a/core/java/android/service/dreams/IDreamManager.aidl b/core/java/android/service/dreams/IDreamManager.aidl
index 76f6363..611e791 100644
--- a/core/java/android/service/dreams/IDreamManager.aidl
+++ b/core/java/android/service/dreams/IDreamManager.aidl
@@ -42,7 +42,8 @@
/** @deprecated Please use finishSelfOneway instead. */
void finishSelf(in IBinder token, boolean immediate);
/** @deprecated Please use startDozingOneway instead. */
- void startDozing(in IBinder token, int screenState, int reason, int screenBrightness);
+ void startDozing(in IBinder token, int screenState, int reason, float screenBrightnessFloat,
+ int screenBrightnessInt);
void stopDozing(in IBinder token);
void forceAmbientDisplayEnabled(boolean enabled);
ComponentName[] getDreamComponentsForUser(int userId);
@@ -52,6 +53,7 @@
void startDreamActivity(in Intent intent);
@JavaPassthrough(annotation="@android.annotation.RequiresPermission(android.Manifest.permission.WRITE_DREAM_STATE)")
oneway void setDreamIsObscured(in boolean isObscured);
- oneway void startDozingOneway(in IBinder token, int screenState, int reason, int screenBrightness);
+ oneway void startDozingOneway(in IBinder token, int screenState, int reason,
+ float screenBrightnessFloat, int screenBrightnessInt);
oneway void finishSelfOneway(in IBinder token, boolean immediate);
}
diff --git a/packages/SystemUI/src/com/android/systemui/doze/AlwaysOnDisplayPolicy.java b/packages/SystemUI/src/com/android/systemui/doze/AlwaysOnDisplayPolicy.java
index e182d0b..f80e0be 100644
--- a/packages/SystemUI/src/com/android/systemui/doze/AlwaysOnDisplayPolicy.java
+++ b/packages/SystemUI/src/com/android/systemui/doze/AlwaysOnDisplayPolicy.java
@@ -57,21 +57,29 @@
/**
- * Integer used to dim the screen while dozing.
+ * Integer in the scale [1, 255] used to dim the screen while dozing.
*
* @see R.integer.config_screenBrightnessDoze
*/
public int defaultDozeBrightness;
/**
- * Integer used to dim the screen just before the screen turns off.
+ * Integer in the scale [1, 255] used to dim the screen just before the screen turns off.
*
* @see R.integer.config_screenBrightnessDim
*/
public int dimBrightness;
/**
- * Integer array to map ambient brightness type to real screen brightness.
+ * Float in the scale [0, 1] used to dim the screen just before the screen turns off.
+ *
+ * @see R.integer.config_screenBrightnessDimFloat
+ */
+ public float dimBrightnessFloat;
+
+ /**
+ * Integer array to map ambient brightness type to real screen brightness in the integer scale
+ * [1, 255].
*
* @see Settings.Global#ALWAYS_ON_DISPLAY_CONSTANTS
* @see #KEY_SCREEN_BRIGHTNESS_ARRAY
@@ -189,6 +197,8 @@
com.android.internal.R.integer.config_screenBrightnessDoze);
dimBrightness = resources.getInteger(
com.android.internal.R.integer.config_screenBrightnessDim);
+ dimBrightnessFloat = resources.getFloat(
+ com.android.internal.R.dimen.config_screenBrightnessDimFloat);
screenBrightnessArray = mParser.getIntArray(KEY_SCREEN_BRIGHTNESS_ARRAY,
resources.getIntArray(
R.array.config_doze_brightness_sensor_to_brightness));
diff --git a/packages/SystemUI/src/com/android/systemui/doze/DozeBrightnessHostForwarder.java b/packages/SystemUI/src/com/android/systemui/doze/DozeBrightnessHostForwarder.java
index cf0dcad..0b33614 100644
--- a/packages/SystemUI/src/com/android/systemui/doze/DozeBrightnessHostForwarder.java
+++ b/packages/SystemUI/src/com/android/systemui/doze/DozeBrightnessHostForwarder.java
@@ -36,4 +36,10 @@
super.setDozeScreenBrightness(brightness);
mHost.setDozeScreenBrightness(brightness);
}
+
+ @Override
+ public void setDozeScreenBrightnessFloat(float brightness) {
+ super.setDozeScreenBrightnessFloat(brightness);
+ mHost.setDozeScreenBrightnessFloat(brightness);
+ }
}
diff --git a/packages/SystemUI/src/com/android/systemui/doze/DozeHost.java b/packages/SystemUI/src/com/android/systemui/doze/DozeHost.java
index 17b455d..2e7a459 100644
--- a/packages/SystemUI/src/com/android/systemui/doze/DozeHost.java
+++ b/packages/SystemUI/src/com/android/systemui/doze/DozeHost.java
@@ -71,11 +71,17 @@
/**
* Sets the actual display brightness.
- * @param value from 0 to 255.
+ * @param value from 1 to 255.
*/
void setDozeScreenBrightness(int value);
/**
+ * Sets the actual display brightness.
+ * @param value from {@link PowerManager#BRIGHTNESS_MIN} to {@link PowerManager#BRIGHTNESS_MAX}.
+ */
+ void setDozeScreenBrightnessFloat(float value);
+
+ /**
* Fade out screen before switching off the display power mode.
* @param onDisplayOffCallback Executed when the display is black.
*/
diff --git a/packages/SystemUI/src/com/android/systemui/doze/DozeLog.java b/packages/SystemUI/src/com/android/systemui/doze/DozeLog.java
index 9a9e698..5bfcc97 100644
--- a/packages/SystemUI/src/com/android/systemui/doze/DozeLog.java
+++ b/packages/SystemUI/src/com/android/systemui/doze/DozeLog.java
@@ -401,13 +401,22 @@
/**
* Appends new AOD screen brightness to logs
- * @param brightness display brightness setting
+ * @param brightness display brightness setting between 1 and 255
*/
public void traceDozeScreenBrightness(int brightness) {
mLogger.logDozeScreenBrightness(brightness);
}
/**
+ * Appends new AOD screen brightness to logs
+ * @param brightness display brightness setting between {@link PowerManager#BRIGHTNESS_MIN} and
+ * {@link PowerManager#BRIGHTNESS_MAX}
+ */
+ public void traceDozeScreenBrightnessFloat(float brightness) {
+ mLogger.logDozeScreenBrightnessFloat(brightness);
+ }
+
+ /**
* Appends new AOD dimming scrim opacity to logs
* @param scrimOpacity
*/
diff --git a/packages/SystemUI/src/com/android/systemui/doze/DozeLogger.kt b/packages/SystemUI/src/com/android/systemui/doze/DozeLogger.kt
index 9d6693e..a31dbec 100644
--- a/packages/SystemUI/src/com/android/systemui/doze/DozeLogger.kt
+++ b/packages/SystemUI/src/com/android/systemui/doze/DozeLogger.kt
@@ -309,7 +309,15 @@
buffer.log(TAG, INFO, {
int1 = brightness
}, {
- "Doze screen brightness set, brightness=$int1"
+ "Doze screen brightness set (int), brightness=$int1"
+ })
+ }
+
+ fun logDozeScreenBrightnessFloat(brightness: Float) {
+ buffer.log(TAG, INFO, {
+ double1 = brightness.toDouble()
+ }, {
+ "Doze screen brightness set (float), brightness=$double1"
})
}
diff --git a/packages/SystemUI/src/com/android/systemui/doze/DozeMachine.java b/packages/SystemUI/src/com/android/systemui/doze/DozeMachine.java
index 7f0b16b..8198ef4 100644
--- a/packages/SystemUI/src/com/android/systemui/doze/DozeMachine.java
+++ b/packages/SystemUI/src/com/android/systemui/doze/DozeMachine.java
@@ -507,9 +507,13 @@
/** Request waking up. */
void requestWakeUp(@DozeLog.Reason int reason);
- /** Set screen brightness */
+ /** Set screen brightness between 1 and 255 */
void setDozeScreenBrightness(int brightness);
+ /** Set screen brightness between {@link PowerManager#BRIGHTNESS_MIN} and
+ * {@link PowerManager#BRIGHTNESS_MAX} */
+ void setDozeScreenBrightnessFloat(float brightness);
+
class Delegate implements Service {
private final Service mDelegate;
private final Executor mBgExecutor;
@@ -540,6 +544,13 @@
mDelegate.setDozeScreenBrightness(brightness);
});
}
+
+ @Override
+ public void setDozeScreenBrightnessFloat(float brightness) {
+ mBgExecutor.execute(() -> {
+ mDelegate.setDozeScreenBrightnessFloat(brightness);
+ });
+ }
}
}
}
diff --git a/packages/SystemUI/src/com/android/systemui/doze/DozeScreenBrightness.java b/packages/SystemUI/src/com/android/systemui/doze/DozeScreenBrightness.java
index 323ed98..6ed84e5 100644
--- a/packages/SystemUI/src/com/android/systemui/doze/DozeScreenBrightness.java
+++ b/packages/SystemUI/src/com/android/systemui/doze/DozeScreenBrightness.java
@@ -20,6 +20,8 @@
import static com.android.systemui.keyguard.WakefulnessLifecycle.WAKEFULNESS_GOING_TO_SLEEP;
+import android.annotation.Nullable;
+import android.annotation.SuppressLint;
import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
@@ -27,6 +29,7 @@
import android.hardware.SensorEvent;
import android.hardware.SensorEventListener;
import android.hardware.SensorManager;
+import android.hardware.display.DisplayManager;
import android.os.Handler;
import android.os.PowerManager;
import android.os.SystemProperties;
@@ -34,6 +37,7 @@
import android.os.UserHandle;
import android.provider.Settings;
import android.util.IndentingPrintWriter;
+import android.view.Display;
import com.android.internal.R;
import com.android.systemui.doze.dagger.BrightnessSensor;
@@ -46,6 +50,7 @@
import com.android.systemui.util.settings.SystemSettings;
import java.io.PrintWriter;
+import java.util.Arrays;
import java.util.Objects;
import java.util.Optional;
@@ -74,6 +79,7 @@
private final DozeHost mDozeHost;
private final Handler mHandler;
private final SensorManager mSensorManager;
+ private final DisplayManager mDisplayManager;
private final Optional<Sensor>[] mLightSensorOptional; // light sensors to use per posture
private final WakefulnessLifecycle mWakefulnessLifecycle;
private final DozeParameters mDozeParameters;
@@ -81,13 +87,17 @@
private final DozeLog mDozeLog;
private final SystemSettings mSystemSettings;
private final int[] mSensorToBrightness;
+ @Nullable
+ private final float[] mSensorToBrightnessFloat;
private final int[] mSensorToScrimOpacity;
private final int mScreenBrightnessDim;
+ private final float mScreenBrightnessDimFloat;
@DevicePostureController.DevicePostureInt
private int mDevicePosture;
private boolean mRegistered;
private int mDefaultDozeBrightness;
+ private float mDefaultDozeBrightnessFloat;
private boolean mPaused = false;
private boolean mScreenOff = false;
private int mLastSensorValue = -1;
@@ -102,6 +112,7 @@
private int mDebugBrightnessBucket = -1;
@Inject
+ @SuppressLint("AndroidFrameworkRequiresPermission")
public DozeScreenBrightness(
Context context,
@WrappedService DozeMachine.Service service,
@@ -113,10 +124,12 @@
DozeParameters dozeParameters,
DevicePostureController devicePostureController,
DozeLog dozeLog,
- SystemSettings systemSettings) {
+ SystemSettings systemSettings,
+ DisplayManager displayManager) {
mContext = context;
mDozeService = service;
mSensorManager = sensorManager;
+ mDisplayManager = displayManager;
mLightSensorOptional = lightSensorOptional;
mDevicePostureController = devicePostureController;
mDevicePosture = mDevicePostureController.getDevicePosture();
@@ -131,8 +144,13 @@
R.dimen.config_screenBrightnessMinimumDimAmountFloat);
mDefaultDozeBrightness = alwaysOnDisplayPolicy.defaultDozeBrightness;
+ mDefaultDozeBrightnessFloat =
+ mDisplayManager.getDefaultDozeBrightness(mContext.getDisplayId());
mScreenBrightnessDim = alwaysOnDisplayPolicy.dimBrightness;
+ mScreenBrightnessDimFloat = alwaysOnDisplayPolicy.dimBrightnessFloat;
mSensorToBrightness = alwaysOnDisplayPolicy.screenBrightnessArray;
+ mSensorToBrightnessFloat =
+ mDisplayManager.getDozeBrightnessSensorValueToBrightness(mContext.getDisplayId());
mSensorToScrimOpacity = alwaysOnDisplayPolicy.dimmingScrimArray;
mDevicePostureController.addCallback(mDevicePostureCallback);
@@ -193,11 +211,22 @@
if (force || mRegistered || mDebugBrightnessBucket != -1) {
int sensorValue = mDebugBrightnessBucket == -1
? mLastSensorValue : mDebugBrightnessBucket;
- int brightness = computeBrightness(sensorValue);
- boolean brightnessReady = brightness > 0;
- if (brightnessReady) {
- mDozeService.setDozeScreenBrightness(
- clampToDimBrightnessForScreenOff(clampToUserSetting(brightness)));
+ boolean brightnessReady;
+ if (shouldUseFloatBrightness()) {
+ float brightness = computeBrightnessFloat(sensorValue);
+ brightnessReady = brightness >= 0;
+ if (brightnessReady) {
+ mDozeService.setDozeScreenBrightnessFloat(
+ clampToDimBrightnessForScreenOffFloat(
+ clampToUserSettingFloat(brightness)));
+ }
+ } else {
+ int brightness = computeBrightness(sensorValue);
+ brightnessReady = brightness > 0;
+ if (brightnessReady) {
+ mDozeService.setDozeScreenBrightness(
+ clampToDimBrightnessForScreenOff(clampToUserSetting(brightness)));
+ }
}
int scrimOpacity = -1;
@@ -249,17 +278,30 @@
return mSensorToBrightness[sensorValue];
}
+ private float computeBrightnessFloat(int sensorValue) {
+ if (sensorValue < 0 || sensorValue >= mSensorToBrightnessFloat.length) {
+ return -1;
+ }
+ return mSensorToBrightnessFloat[sensorValue];
+ }
+
@Override
public void onAccuracyChanged(Sensor sensor, int accuracy) {
}
private void resetBrightnessToDefault() {
- mDozeService.setDozeScreenBrightness(
- clampToDimBrightnessForScreenOff(
- clampToUserSetting(mDefaultDozeBrightness)));
+ if (shouldUseFloatBrightness()) {
+ mDozeService.setDozeScreenBrightnessFloat(
+ clampToDimBrightnessForScreenOffFloat(
+ clampToUserSettingFloat(mDefaultDozeBrightnessFloat)));
+ } else {
+ mDozeService.setDozeScreenBrightness(
+ clampToDimBrightnessForScreenOff(
+ clampToUserSetting(mDefaultDozeBrightness)));
+ }
mDozeHost.setAodDimmingScrim(0f);
}
- //TODO: brightnessfloat change usages to float.
+
private int clampToUserSetting(int brightness) {
int screenBrightnessModeSetting = mSystemSettings.getIntForUser(
Settings.System.SCREEN_BRIGHTNESS_MODE,
@@ -274,6 +316,19 @@
return Math.min(brightness, userSetting);
}
+ @SuppressLint("AndroidFrameworkRequiresPermission")
+ private float clampToUserSettingFloat(float brightness) {
+ int screenBrightnessModeSetting = mSystemSettings.getIntForUser(
+ Settings.System.SCREEN_BRIGHTNESS_MODE,
+ Settings.System.SCREEN_BRIGHTNESS_MODE_MANUAL, UserHandle.USER_CURRENT);
+ if (screenBrightnessModeSetting == Settings.System.SCREEN_BRIGHTNESS_MODE_AUTOMATIC) {
+ return brightness;
+ }
+
+ float userSetting = mDisplayManager.getBrightness(Display.DEFAULT_DISPLAY);
+ return Math.min(brightness, userSetting);
+ }
+
/**
* Clamp the brightness to the dim brightness value used by PowerManagerService just before the
* device times out and goes to sleep, if we are sleeping from a timeout. This ensures that we
@@ -301,6 +356,31 @@
}
}
+ /**
+ * Clamp the brightness to the dim brightness value used by PowerManagerService just before the
+ * device times out and goes to sleep, if we are sleeping from a timeout. This ensures that we
+ * don't raise the brightness back to the user setting before or during the screen off
+ * animation.
+ */
+ private float clampToDimBrightnessForScreenOffFloat(float brightness) {
+ final boolean screenTurningOff =
+ (mDozeParameters.shouldClampToDimBrightness()
+ || mWakefulnessLifecycle.getWakefulness() == WAKEFULNESS_GOING_TO_SLEEP)
+ && mState == DozeMachine.State.INITIALIZED;
+ if (screenTurningOff
+ && mWakefulnessLifecycle.getLastSleepReason() == GO_TO_SLEEP_REASON_TIMEOUT) {
+ return Math.max(
+ PowerManager.BRIGHTNESS_MIN,
+ // Use the lower of either the dim brightness, or the current brightness reduced
+ // by the minimum dim amount. This is the same logic used in
+ // DisplayPowerController#updatePowerState to apply a minimum dim amount.
+ Math.min(brightness - mScreenBrightnessMinimumDimAmountFloat,
+ mScreenBrightnessDimFloat));
+ } else {
+ return brightness;
+ }
+ }
+
private void setLightSensorEnabled(boolean enabled) {
if (enabled && !mRegistered && isLightSensorPresent()) {
// Wait until we get an event from the sensor until indicating ready.
@@ -342,6 +422,20 @@
idpw.increaseIndent();
idpw.println("registered=" + mRegistered);
idpw.println("posture=" + DevicePostureController.devicePostureToString(mDevicePosture));
+ idpw.println("sensorToBrightness=" + Arrays.toString(mSensorToBrightness));
+ idpw.println("sensorToBrightnessFloat=" + Arrays.toString(mSensorToBrightnessFloat));
+ idpw.println("sensorToScrimOpacity=" + Arrays.toString(mSensorToScrimOpacity));
+ idpw.println("screenBrightnessDim=" + mScreenBrightnessDim);
+ idpw.println("screenBrightnessDimFloat=" + mScreenBrightnessDimFloat);
+ idpw.println("mDefaultDozeBrightness=" + mDefaultDozeBrightness);
+ idpw.println("mDefaultDozeBrightnessFloat=" + mDefaultDozeBrightnessFloat);
+ idpw.println("mLastSensorValue=" + mLastSensorValue);
+ idpw.println("shouldUseFloatBrightness()=" + shouldUseFloatBrightness());
+ }
+
+ private boolean shouldUseFloatBrightness() {
+ return com.android.server.display.feature.flags.Flags.dozeBrightnessFloat()
+ && mSensorToBrightnessFloat != null;
}
private final DevicePostureController.Callback mDevicePostureCallback =
diff --git a/packages/SystemUI/src/com/android/systemui/shade/NotificationShadeWindowControllerImpl.java b/packages/SystemUI/src/com/android/systemui/shade/NotificationShadeWindowControllerImpl.java
index b60c193..7db521e 100644
--- a/packages/SystemUI/src/com/android/systemui/shade/NotificationShadeWindowControllerImpl.java
+++ b/packages/SystemUI/src/com/android/systemui/shade/NotificationShadeWindowControllerImpl.java
@@ -341,6 +341,11 @@
mScreenBrightnessDoze = value / 255f;
}
+ @Override
+ public void setDozeScreenBrightnessFloat(float value) {
+ mScreenBrightnessDoze = value;
+ }
+
private void setKeyguardDark(boolean dark) {
int vis = mWindowRootView.getSystemUiVisibility();
if (dark) {
diff --git a/packages/SystemUI/src/com/android/systemui/statusbar/NotificationShadeWindowController.java b/packages/SystemUI/src/com/android/systemui/statusbar/NotificationShadeWindowController.java
index 707d59aa..85fad42 100644
--- a/packages/SystemUI/src/com/android/systemui/statusbar/NotificationShadeWindowController.java
+++ b/packages/SystemUI/src/com/android/systemui/statusbar/NotificationShadeWindowController.java
@@ -131,10 +131,20 @@
/** Sets the state of whether the remote input is active or not. */
default void onRemoteInputActive(boolean remoteInputActive) {}
- /** Sets the screen brightness level for when the device is dozing. */
+ /**
+ * Sets the screen brightness level for when the device is dozing.
+ * @param value The brightness value between 1 and 255
+ */
default void setDozeScreenBrightness(int value) {}
/**
+ * Sets the screen brightness level for when the device is dozing.
+ * @param value The brightness value between {@link PowerManager#BRIGHTNESS_MIN} and
+ * {@link PowerManager#BRIGHTNESS_MAX}
+ */
+ default void setDozeScreenBrightnessFloat(float value) {}
+
+ /**
* Sets whether the screen brightness is forced to the value we use for doze mode by the status
* bar window. No-op if the device does not support dozing.
*/
diff --git a/packages/SystemUI/src/com/android/systemui/statusbar/phone/DozeServiceHost.java b/packages/SystemUI/src/com/android/systemui/statusbar/phone/DozeServiceHost.java
index a32d5fe..ca1fb78b 100644
--- a/packages/SystemUI/src/com/android/systemui/statusbar/phone/DozeServiceHost.java
+++ b/packages/SystemUI/src/com/android/systemui/statusbar/phone/DozeServiceHost.java
@@ -437,6 +437,13 @@
mNotificationShadeWindowController.setDozeScreenBrightness(brightness);
}
+
+ @Override
+ public void setDozeScreenBrightnessFloat(float brightness) {
+ mDozeLog.traceDozeScreenBrightnessFloat(brightness);
+ mNotificationShadeWindowController.setDozeScreenBrightnessFloat(brightness);
+ }
+
@Override
public void setAodDimmingScrim(float scrimOpacity) {
mDozeLog.traceSetAodDimmingScrim(scrimOpacity);
diff --git a/packages/SystemUI/tests/src/com/android/systemui/doze/DozeScreenBrightnessTest.java b/packages/SystemUI/tests/src/com/android/systemui/doze/DozeScreenBrightnessTest.java
index aa5edae..4818119 100644
--- a/packages/SystemUI/tests/src/com/android/systemui/doze/DozeScreenBrightnessTest.java
+++ b/packages/SystemUI/tests/src/com/android/systemui/doze/DozeScreenBrightnessTest.java
@@ -42,13 +42,21 @@
import static org.mockito.Mockito.when;
import android.content.Intent;
+import android.hardware.display.DisplayManager;
import android.os.PowerManager;
import android.os.UserHandle;
+import android.platform.test.annotations.RequiresFlagsDisabled;
+import android.platform.test.annotations.RequiresFlagsEnabled;
+import android.platform.test.flag.junit.CheckFlagsRule;
+import android.platform.test.flag.junit.DeviceFlagsValueProvider;
import android.provider.Settings;
+import android.view.Display;
import androidx.test.ext.junit.runners.AndroidJUnit4;
import androidx.test.filters.SmallTest;
+import com.android.internal.display.BrightnessSynchronizer;
+import com.android.server.display.feature.flags.Flags;
import com.android.systemui.SysuiTestCase;
import com.android.systemui.dock.DockManager;
import com.android.systemui.keyguard.WakefulnessLifecycle;
@@ -62,6 +70,7 @@
import com.android.systemui.util.time.FakeSystemClock;
import org.junit.Before;
+import org.junit.Rule;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.ArgumentCaptor;
@@ -74,10 +83,15 @@
@RunWith(AndroidJUnit4.class)
public class DozeScreenBrightnessTest extends SysuiTestCase {
- private static final int DEFAULT_BRIGHTNESS = 10;
- private static final int DIM_BRIGHTNESS = 1;
- private static final int[] SENSOR_TO_BRIGHTNESS = new int[]{-1, 1, 2, 3, 4};
+ private static final int DEFAULT_BRIGHTNESS_INT = 10;
+ private static final float DEFAULT_BRIGHTNESS_FLOAT = 0.1f;
+ private static final int DIM_BRIGHTNESS_INT = 1;
+ private static final float DIM_BRIGHTNESS_FLOAT = 0.05f;
+ private static final int[] SENSOR_TO_BRIGHTNESS_INT = new int[]{-1, 1, 2, 3, 4};
+ private static final float[] SENSOR_TO_BRIGHTNESS_FLOAT =
+ new float[]{-1, 0.01f, 0.05f, 0.7f, 0.1f};
private static final int[] SENSOR_TO_OPACITY = new int[]{-1, 10, 0, 0, 0};
+ private static final float DELTA = BrightnessSynchronizer.EPSILON;
private DozeServiceFake mServiceFake;
private FakeSensorManager.FakeGenericSensor mSensor;
@@ -98,16 +112,23 @@
DozeLog mDozeLog;
@Mock
SystemSettings mSystemSettings;
+ @Mock
+ DisplayManager mDisplayManager;
private FakeExecutor mFakeExecutor = new FakeExecutor(new FakeSystemClock());
private FakeThreadFactory mFakeThreadFactory = new FakeThreadFactory(mFakeExecutor);
private DozeScreenBrightness mScreen;
+ @Rule
+ public final CheckFlagsRule mCheckFlagsRule = DeviceFlagsValueProvider.createCheckFlagsRule();
+
@Before
public void setUp() throws Exception {
MockitoAnnotations.initMocks(this);
when(mSystemSettings.getIntForUser(eq(Settings.System.SCREEN_BRIGHTNESS), anyInt(),
- eq(UserHandle.USER_CURRENT))).thenReturn(DEFAULT_BRIGHTNESS);
+ eq(UserHandle.USER_CURRENT))).thenReturn(PowerManager.BRIGHTNESS_ON);
+ when(mDisplayManager.getBrightness(Display.DEFAULT_DISPLAY))
+ .thenReturn(PowerManager.BRIGHTNESS_MAX);
doAnswer(invocation -> {
((Runnable) invocation.getArgument(0)).run();
return null;
@@ -117,9 +138,14 @@
mSensorManager = new AsyncSensorManager(fakeSensorManager, mFakeThreadFactory, null);
mAlwaysOnDisplayPolicy = new AlwaysOnDisplayPolicy(mContext);
- mAlwaysOnDisplayPolicy.defaultDozeBrightness = DEFAULT_BRIGHTNESS;
- mAlwaysOnDisplayPolicy.screenBrightnessArray = SENSOR_TO_BRIGHTNESS;
- mAlwaysOnDisplayPolicy.dimBrightness = DIM_BRIGHTNESS;
+ mAlwaysOnDisplayPolicy.defaultDozeBrightness = DEFAULT_BRIGHTNESS_INT;
+ when(mDisplayManager.getDefaultDozeBrightness(Display.DEFAULT_DISPLAY))
+ .thenReturn(DEFAULT_BRIGHTNESS_FLOAT);
+ mAlwaysOnDisplayPolicy.screenBrightnessArray = SENSOR_TO_BRIGHTNESS_INT;
+ when(mDisplayManager.getDozeBrightnessSensorValueToBrightness(Display.DEFAULT_DISPLAY))
+ .thenReturn(SENSOR_TO_BRIGHTNESS_FLOAT);
+ mAlwaysOnDisplayPolicy.dimBrightness = DIM_BRIGHTNESS_INT;
+ mAlwaysOnDisplayPolicy.dimBrightnessFloat = DIM_BRIGHTNESS_FLOAT;
mAlwaysOnDisplayPolicy.dimmingScrimArray = SENSOR_TO_OPACITY;
mSensor = fakeSensorManager.getFakeLightSensor();
mSensorInner = fakeSensorManager.getFakeLightSensor2();
@@ -135,19 +161,35 @@
mDozeParameters,
mDevicePostureController,
mDozeLog,
- mSystemSettings);
+ mSystemSettings,
+ mDisplayManager);
}
@Test
- public void testInitialize_setsScreenBrightnessToValidValue() throws Exception {
+ @RequiresFlagsDisabled(Flags.FLAG_DOZE_BRIGHTNESS_FLOAT)
+ public void testInitialize_setsScreenBrightnessToValidValue_Int() {
mScreen.transitionTo(UNINITIALIZED, INITIALIZED);
- assertEquals(DEFAULT_BRIGHTNESS, mServiceFake.screenBrightness);
- assertTrue(mServiceFake.screenBrightness <= PowerManager.BRIGHTNESS_ON);
+ assertEquals(DEFAULT_BRIGHTNESS_INT, mServiceFake.screenBrightnessInt);
+ assertTrue(mServiceFake.screenBrightnessInt >= PowerManager.BRIGHTNESS_OFF + 1);
+ assertTrue(mServiceFake.screenBrightnessInt <= PowerManager.BRIGHTNESS_ON);
+ assertTrue(Float.isNaN(mServiceFake.screenBrightnessFloat));
}
@Test
- public void testAod_usesDebugValue() throws Exception {
+ @RequiresFlagsEnabled(Flags.FLAG_DOZE_BRIGHTNESS_FLOAT)
+ public void testInitialize_setsScreenBrightnessToValidValue_Float() {
+ mScreen.transitionTo(UNINITIALIZED, INITIALIZED);
+
+ assertEquals(DEFAULT_BRIGHTNESS_FLOAT, mServiceFake.screenBrightnessFloat, DELTA);
+ assertTrue(mServiceFake.screenBrightnessFloat >= PowerManager.BRIGHTNESS_MIN);
+ assertTrue(mServiceFake.screenBrightnessFloat <= PowerManager.BRIGHTNESS_MAX);
+ assertEquals(PowerManager.BRIGHTNESS_DEFAULT, mServiceFake.screenBrightnessInt);
+ }
+
+ @Test
+ @RequiresFlagsDisabled(Flags.FLAG_DOZE_BRIGHTNESS_FLOAT)
+ public void testAod_usesDebugValue_Int() {
mScreen.transitionTo(UNINITIALIZED, INITIALIZED);
mScreen.transitionTo(INITIALIZED, DOZE_AOD);
waitForSensorManager();
@@ -157,11 +199,29 @@
mScreen.onReceive(mContext, intent);
mSensor.sendSensorEvent(3);
- assertEquals(1, mServiceFake.screenBrightness);
+ assertEquals(SENSOR_TO_BRIGHTNESS_INT[1], mServiceFake.screenBrightnessInt);
+ assertTrue(Float.isNaN(mServiceFake.screenBrightnessFloat));
}
@Test
- public void testAod_usesLightSensorRespectingUserSetting() {
+ @RequiresFlagsEnabled(Flags.FLAG_DOZE_BRIGHTNESS_FLOAT)
+ public void testAod_usesDebugValue_Float() {
+ mScreen.transitionTo(UNINITIALIZED, INITIALIZED);
+ mScreen.transitionTo(INITIALIZED, DOZE_AOD);
+ waitForSensorManager();
+
+ Intent intent = new Intent(DozeScreenBrightness.ACTION_AOD_BRIGHTNESS);
+ intent.putExtra(DozeScreenBrightness.BRIGHTNESS_BUCKET, 1);
+ mScreen.onReceive(mContext, intent);
+ mSensor.sendSensorEvent(3);
+
+ assertEquals(SENSOR_TO_BRIGHTNESS_FLOAT[1], mServiceFake.screenBrightnessFloat, DELTA);
+ assertEquals(PowerManager.BRIGHTNESS_DEFAULT, mServiceFake.screenBrightnessInt);
+ }
+
+ @Test
+ @RequiresFlagsDisabled(Flags.FLAG_DOZE_BRIGHTNESS_FLOAT)
+ public void testAod_usesLightSensorRespectingUserSetting_Int() {
int maxBrightness = 3;
when(mSystemSettings.getIntForUser(eq(Settings.System.SCREEN_BRIGHTNESS), anyInt(),
eq(UserHandle.USER_CURRENT))).thenReturn(maxBrightness);
@@ -170,11 +230,27 @@
.thenReturn(Settings.System.SCREEN_BRIGHTNESS_MODE_MANUAL);
mScreen.transitionTo(UNINITIALIZED, INITIALIZED);
- assertEquals(maxBrightness, mServiceFake.screenBrightness);
+ assertEquals(maxBrightness, mServiceFake.screenBrightnessInt);
+ assertTrue(Float.isNaN(mServiceFake.screenBrightnessFloat));
}
@Test
- public void testAod_usesLightSensorNotClampingToAutoBrightnessValue() {
+ @RequiresFlagsEnabled(Flags.FLAG_DOZE_BRIGHTNESS_FLOAT)
+ public void testAod_usesLightSensorRespectingUserSetting_Float() {
+ float maxBrightness = DEFAULT_BRIGHTNESS_FLOAT / 2;
+ when(mDisplayManager.getBrightness(Display.DEFAULT_DISPLAY)).thenReturn(maxBrightness);
+ when(mSystemSettings.getIntForUser(eq(Settings.System.SCREEN_BRIGHTNESS_MODE), anyInt(),
+ eq(UserHandle.USER_CURRENT)))
+ .thenReturn(Settings.System.SCREEN_BRIGHTNESS_MODE_MANUAL);
+
+ mScreen.transitionTo(UNINITIALIZED, INITIALIZED);
+ assertEquals(maxBrightness, mServiceFake.screenBrightnessFloat, DELTA);
+ assertEquals(PowerManager.BRIGHTNESS_DEFAULT, mServiceFake.screenBrightnessInt);
+ }
+
+ @Test
+ @RequiresFlagsDisabled(Flags.FLAG_DOZE_BRIGHTNESS_FLOAT)
+ public void testAod_usesLightSensorNotClampingToAutoBrightnessValue_Int() {
int maxBrightness = 3;
when(mSystemSettings.getIntForUser(eq(Settings.System.SCREEN_BRIGHTNESS), anyInt(),
eq(UserHandle.USER_CURRENT))).thenReturn(maxBrightness);
@@ -183,11 +259,27 @@
.thenReturn(Settings.System.SCREEN_BRIGHTNESS_MODE_AUTOMATIC);
mScreen.transitionTo(UNINITIALIZED, INITIALIZED);
- assertEquals(DEFAULT_BRIGHTNESS, mServiceFake.screenBrightness);
+ assertEquals(DEFAULT_BRIGHTNESS_INT, mServiceFake.screenBrightnessInt);
+ assertTrue(Float.isNaN(mServiceFake.screenBrightnessFloat));
}
@Test
- public void doze_doesNotUseLightSensor() {
+ @RequiresFlagsEnabled(Flags.FLAG_DOZE_BRIGHTNESS_FLOAT)
+ public void testAod_usesLightSensorNotClampingToAutoBrightnessValue_Float() {
+ float maxBrightness = DEFAULT_BRIGHTNESS_FLOAT / 2;
+ when(mDisplayManager.getBrightness(Display.DEFAULT_DISPLAY)).thenReturn(maxBrightness);
+ when(mSystemSettings.getIntForUser(eq(Settings.System.SCREEN_BRIGHTNESS_MODE), anyInt(),
+ eq(UserHandle.USER_CURRENT)))
+ .thenReturn(Settings.System.SCREEN_BRIGHTNESS_MODE_AUTOMATIC);
+
+ mScreen.transitionTo(UNINITIALIZED, INITIALIZED);
+ assertEquals(DEFAULT_BRIGHTNESS_FLOAT, mServiceFake.screenBrightnessFloat, DELTA);
+ assertEquals(PowerManager.BRIGHTNESS_DEFAULT, mServiceFake.screenBrightnessInt);
+ }
+
+ @Test
+ @RequiresFlagsDisabled(Flags.FLAG_DOZE_BRIGHTNESS_FLOAT)
+ public void doze_doesNotUseLightSensor_Int() {
// GIVEN the device is DOZE and the display state changes to ON
mScreen.transitionTo(UNINITIALIZED, INITIALIZED);
mScreen.transitionTo(INITIALIZED, DOZE);
@@ -197,12 +289,31 @@
mSensor.sendSensorEvent(3);
// THEN brightness is NOT changed, it's set to the default brightness
- assertNotSame(3, mServiceFake.screenBrightness);
- assertEquals(DEFAULT_BRIGHTNESS, mServiceFake.screenBrightness);
+ assertNotSame(SENSOR_TO_BRIGHTNESS_INT[3], mServiceFake.screenBrightnessInt);
+ assertEquals(DEFAULT_BRIGHTNESS_INT, mServiceFake.screenBrightnessInt);
+ assertTrue(Float.isNaN(mServiceFake.screenBrightnessFloat));
}
@Test
- public void dozeSuspendTriggers_doesNotUseLightSensor() {
+ @RequiresFlagsEnabled(Flags.FLAG_DOZE_BRIGHTNESS_FLOAT)
+ public void doze_doesNotUseLightSensor_Float() {
+ // GIVEN the device is DOZE and the display state changes to ON
+ mScreen.transitionTo(UNINITIALIZED, INITIALIZED);
+ mScreen.transitionTo(INITIALIZED, DOZE);
+ waitForSensorManager();
+
+ // WHEN new sensor event sent
+ mSensor.sendSensorEvent(3);
+
+ // THEN brightness is NOT changed, it's set to the default brightness
+ assertNotSame(SENSOR_TO_BRIGHTNESS_FLOAT[3], mServiceFake.screenBrightnessInt);
+ assertEquals(DEFAULT_BRIGHTNESS_FLOAT, mServiceFake.screenBrightnessFloat, DELTA);
+ assertEquals(PowerManager.BRIGHTNESS_DEFAULT, mServiceFake.screenBrightnessInt);
+ }
+
+ @Test
+ @RequiresFlagsDisabled(Flags.FLAG_DOZE_BRIGHTNESS_FLOAT)
+ public void dozeSuspendTriggers_doesNotUseLightSensor_Int() {
// GIVEN the device is DOZE and the display state changes to ON
mScreen.transitionTo(UNINITIALIZED, INITIALIZED);
mScreen.transitionTo(INITIALIZED, DOZE_SUSPEND_TRIGGERS);
@@ -212,12 +323,31 @@
mSensor.sendSensorEvent(3);
// THEN brightness is NOT changed, it's set to the default brightness
- assertNotSame(3, mServiceFake.screenBrightness);
- assertEquals(DEFAULT_BRIGHTNESS, mServiceFake.screenBrightness);
+ assertNotSame(SENSOR_TO_BRIGHTNESS_INT[3], mServiceFake.screenBrightnessInt);
+ assertEquals(DEFAULT_BRIGHTNESS_INT, mServiceFake.screenBrightnessInt);
+ assertTrue(Float.isNaN(mServiceFake.screenBrightnessFloat));
}
@Test
- public void aod_usesLightSensor() {
+ @RequiresFlagsEnabled(Flags.FLAG_DOZE_BRIGHTNESS_FLOAT)
+ public void dozeSuspendTriggers_doesNotUseLightSensor_Float() {
+ // GIVEN the device is DOZE and the display state changes to ON
+ mScreen.transitionTo(UNINITIALIZED, INITIALIZED);
+ mScreen.transitionTo(INITIALIZED, DOZE_SUSPEND_TRIGGERS);
+ waitForSensorManager();
+
+ // WHEN new sensor event sent
+ mSensor.sendSensorEvent(3);
+
+ // THEN brightness is NOT changed, it's set to the default brightness
+ assertNotSame(SENSOR_TO_BRIGHTNESS_FLOAT[3], mServiceFake.screenBrightnessFloat);
+ assertEquals(DEFAULT_BRIGHTNESS_FLOAT, mServiceFake.screenBrightnessFloat, DELTA);
+ assertEquals(PowerManager.BRIGHTNESS_DEFAULT, mServiceFake.screenBrightnessInt);
+ }
+
+ @Test
+ @RequiresFlagsDisabled(Flags.FLAG_DOZE_BRIGHTNESS_FLOAT)
+ public void aod_usesLightSensor_Int() {
// GIVEN the device is DOZE_AOD and the display state changes to ON
mScreen.transitionTo(UNINITIALIZED, INITIALIZED);
mScreen.transitionTo(INITIALIZED, DOZE_AOD);
@@ -227,11 +357,29 @@
mSensor.sendSensorEvent(3);
// THEN brightness is updated
- assertEquals(3, mServiceFake.screenBrightness);
+ assertEquals(SENSOR_TO_BRIGHTNESS_INT[3], mServiceFake.screenBrightnessInt);
+ assertTrue(Float.isNaN(mServiceFake.screenBrightnessFloat));
}
@Test
- public void docked_usesLightSensor() {
+ @RequiresFlagsEnabled(Flags.FLAG_DOZE_BRIGHTNESS_FLOAT)
+ public void aod_usesLightSensor_Float() {
+ // GIVEN the device is DOZE_AOD and the display state changes to ON
+ mScreen.transitionTo(UNINITIALIZED, INITIALIZED);
+ mScreen.transitionTo(INITIALIZED, DOZE_AOD);
+ waitForSensorManager();
+
+ // WHEN new sensor event sent
+ mSensor.sendSensorEvent(3);
+
+ // THEN brightness is updated
+ assertEquals(SENSOR_TO_BRIGHTNESS_FLOAT[3], mServiceFake.screenBrightnessFloat, DELTA);
+ assertEquals(PowerManager.BRIGHTNESS_DEFAULT, mServiceFake.screenBrightnessInt);
+ }
+
+ @Test
+ @RequiresFlagsDisabled(Flags.FLAG_DOZE_BRIGHTNESS_FLOAT)
+ public void docked_usesLightSensor_Int() {
// GIVEN the device is docked and the display state changes to ON
mScreen.transitionTo(UNINITIALIZED, INITIALIZED);
mScreen.transitionTo(INITIALIZED, DOZE_AOD);
@@ -242,11 +390,29 @@
mSensor.sendSensorEvent(3);
// THEN brightness is updated
- assertEquals(3, mServiceFake.screenBrightness);
+ assertEquals(SENSOR_TO_BRIGHTNESS_INT[3], mServiceFake.screenBrightnessInt);
+ assertTrue(Float.isNaN(mServiceFake.screenBrightnessFloat));
}
@Test
- public void testPulsing_withoutLightSensor_setsAoDDimmingScrimTransparent() throws Exception {
+ @RequiresFlagsEnabled(Flags.FLAG_DOZE_BRIGHTNESS_FLOAT)
+ public void docked_usesLightSensor_Float() {
+ // GIVEN the device is docked and the display state changes to ON
+ mScreen.transitionTo(UNINITIALIZED, INITIALIZED);
+ mScreen.transitionTo(INITIALIZED, DOZE_AOD);
+ mScreen.transitionTo(DOZE_AOD, DOZE_AOD_DOCKED);
+ waitForSensorManager();
+
+ // WHEN new sensor event sent
+ mSensor.sendSensorEvent(3);
+
+ // THEN brightness is updated
+ assertEquals(SENSOR_TO_BRIGHTNESS_FLOAT[3], mServiceFake.screenBrightnessFloat, DELTA);
+ assertEquals(PowerManager.BRIGHTNESS_DEFAULT, mServiceFake.screenBrightnessInt);
+ }
+
+ @Test
+ public void testPulsing_withoutLightSensor_setsAoDDimmingScrimTransparent() {
mScreen = new DozeScreenBrightness(
mContext,
mServiceFake,
@@ -258,7 +424,8 @@
mDozeParameters,
mDevicePostureController,
mDozeLog,
- mSystemSettings);
+ mSystemSettings,
+ mDisplayManager);
mScreen.transitionTo(UNINITIALIZED, INITIALIZED);
mScreen.transitionTo(INITIALIZED, DOZE);
reset(mDozeHost);
@@ -269,7 +436,8 @@
}
@Test
- public void testScreenOffAfterPulsing_pausesLightSensor() throws Exception {
+ @RequiresFlagsDisabled(Flags.FLAG_DOZE_BRIGHTNESS_FLOAT)
+ public void testScreenOffAfterPulsing_pausesLightSensor_Int() {
mScreen.transitionTo(UNINITIALIZED, INITIALIZED);
mScreen.transitionTo(INITIALIZED, DOZE);
mScreen.transitionTo(DOZE, DOZE_REQUEST_PULSE);
@@ -280,11 +448,29 @@
mSensor.sendSensorEvent(1);
- assertEquals(DEFAULT_BRIGHTNESS, mServiceFake.screenBrightness);
+ assertEquals(DEFAULT_BRIGHTNESS_INT, mServiceFake.screenBrightnessInt);
+ assertTrue(Float.isNaN(mServiceFake.screenBrightnessFloat));
}
@Test
- public void testNullSensor() throws Exception {
+ @RequiresFlagsEnabled(Flags.FLAG_DOZE_BRIGHTNESS_FLOAT)
+ public void testScreenOffAfterPulsing_pausesLightSensor_Float() {
+ mScreen.transitionTo(UNINITIALIZED, INITIALIZED);
+ mScreen.transitionTo(INITIALIZED, DOZE);
+ mScreen.transitionTo(DOZE, DOZE_REQUEST_PULSE);
+ mScreen.transitionTo(DOZE_REQUEST_PULSE, DOZE_PULSING);
+ mScreen.transitionTo(DOZE_PULSING, DOZE_PULSE_DONE);
+ mScreen.transitionTo(DOZE_PULSE_DONE, DOZE);
+ waitForSensorManager();
+
+ mSensor.sendSensorEvent(1);
+
+ assertEquals(DEFAULT_BRIGHTNESS_FLOAT, mServiceFake.screenBrightnessFloat, DELTA);
+ assertEquals(PowerManager.BRIGHTNESS_DEFAULT, mServiceFake.screenBrightnessInt);
+ }
+
+ @Test
+ public void testNullSensor() {
mScreen = new DozeScreenBrightness(
mContext,
mServiceFake,
@@ -296,7 +482,8 @@
mDozeParameters,
mDevicePostureController,
mDozeLog,
- mSystemSettings);
+ mSystemSettings,
+ mDisplayManager);
mScreen.transitionTo(UNINITIALIZED, INITIALIZED);
mScreen.transitionTo(INITIALIZED, DOZE_AOD);
@@ -305,7 +492,8 @@
}
@Test
- public void testSensorsSupportPostures_closed() throws Exception {
+ @RequiresFlagsDisabled(Flags.FLAG_DOZE_BRIGHTNESS_FLOAT)
+ public void testSensorsSupportPostures_closed_Int() {
// GIVEN the device is CLOSED
when(mDevicePostureController.getDevicePosture()).thenReturn(
DevicePostureController.DEVICE_POSTURE_CLOSED);
@@ -328,7 +516,8 @@
mDozeParameters,
mDevicePostureController,
mDozeLog,
- mSystemSettings);
+ mSystemSettings,
+ mDisplayManager);
// GIVEN the device is in AOD
mScreen.transitionTo(UNINITIALIZED, INITIALIZED);
@@ -340,11 +529,56 @@
mSensorInner.sendSensorEvent(4); // OPENED sensor
// THEN brightness is updated according to the sensor for CLOSED
- assertEquals(3, mServiceFake.screenBrightness);
+ assertEquals(SENSOR_TO_BRIGHTNESS_INT[3], mServiceFake.screenBrightnessInt);
+ assertTrue(Float.isNaN(mServiceFake.screenBrightnessFloat));
}
@Test
- public void testSensorsSupportPostures_open() throws Exception {
+ @RequiresFlagsEnabled(Flags.FLAG_DOZE_BRIGHTNESS_FLOAT)
+ public void testSensorsSupportPostures_closed_Float() {
+ // GIVEN the device is CLOSED
+ when(mDevicePostureController.getDevicePosture()).thenReturn(
+ DevicePostureController.DEVICE_POSTURE_CLOSED);
+
+ // GIVEN closed and opened postures use different light sensors
+ mScreen = new DozeScreenBrightness(
+ mContext,
+ mServiceFake,
+ mSensorManager,
+ new Optional[]{
+ Optional.empty() /* unknown */,
+ Optional.of(mSensor.getSensor()) /* closed */,
+ Optional.of(mSensorInner.getSensor()) /* half-opened */,
+ Optional.of(mSensorInner.getSensor()) /* opened */,
+ Optional.empty() /* flipped */
+ },
+ mDozeHost, null /* handler */,
+ mAlwaysOnDisplayPolicy,
+ mWakefulnessLifecycle,
+ mDozeParameters,
+ mDevicePostureController,
+ mDozeLog,
+ mSystemSettings,
+ mDisplayManager);
+
+ // GIVEN the device is in AOD
+ mScreen.transitionTo(UNINITIALIZED, INITIALIZED);
+ mScreen.transitionTo(INITIALIZED, DOZE_AOD);
+ waitForSensorManager();
+
+ // WHEN new different events are sent from the inner and outer sensors
+ mSensor.sendSensorEvent(3); // CLOSED sensor
+ mSensorInner.sendSensorEvent(4); // OPENED sensor
+
+ // THEN brightness is updated according to the sensor for CLOSED
+ assertEquals(SENSOR_TO_BRIGHTNESS_FLOAT[3], mServiceFake.screenBrightnessFloat,
+ DELTA);
+ assertEquals(PowerManager.BRIGHTNESS_DEFAULT, mServiceFake.screenBrightnessInt);
+ }
+
+ @Test
+ @RequiresFlagsDisabled(Flags.FLAG_DOZE_BRIGHTNESS_FLOAT)
+ public void testSensorsSupportPostures_open_Int() {
// GIVEN the device is OPENED
when(mDevicePostureController.getDevicePosture()).thenReturn(
DevicePostureController.DEVICE_POSTURE_OPENED);
@@ -367,7 +601,8 @@
mDozeParameters,
mDevicePostureController,
mDozeLog,
- mSystemSettings);
+ mSystemSettings,
+ mDisplayManager);
// GIVEN device is in AOD
mScreen.transitionTo(UNINITIALIZED, INITIALIZED);
@@ -379,11 +614,55 @@
mSensor.sendSensorEvent(3); // CLOSED sensor
// THEN brightness is updated according to the sensor for OPENED
- assertEquals(4, mServiceFake.screenBrightness);
+ assertEquals(SENSOR_TO_BRIGHTNESS_INT[4], mServiceFake.screenBrightnessInt);
+ assertTrue(Float.isNaN(mServiceFake.screenBrightnessFloat));
}
@Test
- public void testSensorsSupportPostures_swapPostures() throws Exception {
+ @RequiresFlagsEnabled(Flags.FLAG_DOZE_BRIGHTNESS_FLOAT)
+ public void testSensorsSupportPostures_open_Float() {
+ // GIVEN the device is OPENED
+ when(mDevicePostureController.getDevicePosture()).thenReturn(
+ DevicePostureController.DEVICE_POSTURE_OPENED);
+
+ // GIVEN closed and opened postures use different light sensors
+ mScreen = new DozeScreenBrightness(
+ mContext,
+ mServiceFake,
+ mSensorManager,
+ new Optional[]{
+ Optional.empty() /* unknown */,
+ Optional.of(mSensor.getSensor()) /* closed */,
+ Optional.of(mSensorInner.getSensor()) /* half-opened */,
+ Optional.of(mSensorInner.getSensor()) /* opened */,
+ Optional.empty() /* flipped */
+ },
+ mDozeHost, null /* handler */,
+ mAlwaysOnDisplayPolicy,
+ mWakefulnessLifecycle,
+ mDozeParameters,
+ mDevicePostureController,
+ mDozeLog,
+ mSystemSettings,
+ mDisplayManager);
+
+ // GIVEN device is in AOD
+ mScreen.transitionTo(UNINITIALIZED, INITIALIZED);
+ mScreen.transitionTo(INITIALIZED, DOZE_AOD);
+ waitForSensorManager();
+
+ // WHEN new different events are sent from the inner and outer sensors
+ mSensorInner.sendSensorEvent(4); // OPENED sensor
+ mSensor.sendSensorEvent(3); // CLOSED sensor
+
+ // THEN brightness is updated according to the sensor for OPENED
+ assertEquals(SENSOR_TO_BRIGHTNESS_FLOAT[4], mServiceFake.screenBrightnessFloat, DELTA);
+ assertEquals(PowerManager.BRIGHTNESS_DEFAULT, mServiceFake.screenBrightnessInt);
+ }
+
+ @Test
+ @RequiresFlagsDisabled(Flags.FLAG_DOZE_BRIGHTNESS_FLOAT)
+ public void testSensorsSupportPostures_swapPostures_Int() {
ArgumentCaptor<DevicePostureController.Callback> postureCallbackCaptor =
ArgumentCaptor.forClass(DevicePostureController.Callback.class);
reset(mDevicePostureController);
@@ -410,7 +689,8 @@
mDozeParameters,
mDevicePostureController,
mDozeLog,
- mSystemSettings);
+ mSystemSettings,
+ mDisplayManager);
verify(mDevicePostureController).addCallback(postureCallbackCaptor.capture());
// GIVEN device is in AOD
@@ -428,11 +708,65 @@
mSensorInner.sendSensorEvent(4); // OPENED sensor
// THEN brightness is updated according to the sensor for CLOSED
- assertEquals(3, mServiceFake.screenBrightness);
+ assertEquals(SENSOR_TO_BRIGHTNESS_INT[3], mServiceFake.screenBrightnessInt);
+ assertTrue(Float.isNaN(mServiceFake.screenBrightnessFloat));
}
@Test
- public void testNoBrightnessDeliveredAfterFinish() throws Exception {
+ @RequiresFlagsEnabled(Flags.FLAG_DOZE_BRIGHTNESS_FLOAT)
+ public void testSensorsSupportPostures_swapPostures_Float() {
+ ArgumentCaptor<DevicePostureController.Callback> postureCallbackCaptor =
+ ArgumentCaptor.forClass(DevicePostureController.Callback.class);
+ reset(mDevicePostureController);
+
+ // GIVEN the device starts up AOD OPENED
+ when(mDevicePostureController.getDevicePosture()).thenReturn(
+ DevicePostureController.DEVICE_POSTURE_OPENED);
+
+ // GIVEN closed and opened postures use different light sensors
+ mScreen = new DozeScreenBrightness(
+ mContext,
+ mServiceFake,
+ mSensorManager,
+ new Optional[]{
+ Optional.empty() /* unknown */,
+ Optional.of(mSensor.getSensor()) /* closed */,
+ Optional.of(mSensorInner.getSensor()) /* half-opened */,
+ Optional.of(mSensorInner.getSensor()) /* opened */,
+ Optional.empty() /* flipped */
+ },
+ mDozeHost, null /* handler */,
+ mAlwaysOnDisplayPolicy,
+ mWakefulnessLifecycle,
+ mDozeParameters,
+ mDevicePostureController,
+ mDozeLog,
+ mSystemSettings,
+ mDisplayManager);
+ verify(mDevicePostureController).addCallback(postureCallbackCaptor.capture());
+
+ // GIVEN device is in AOD
+ mScreen.transitionTo(UNINITIALIZED, INITIALIZED);
+ mScreen.transitionTo(INITIALIZED, DOZE_AOD);
+ waitForSensorManager();
+
+ // WHEN the posture changes to CLOSED
+ postureCallbackCaptor.getValue().onPostureChanged(
+ DevicePostureController.DEVICE_POSTURE_CLOSED);
+ waitForSensorManager();
+
+ // WHEN new different events are sent from the inner and outer sensors
+ mSensor.sendSensorEvent(3); // CLOSED sensor
+ mSensorInner.sendSensorEvent(4); // OPENED sensor
+
+ // THEN brightness is updated according to the sensor for CLOSED
+ assertEquals(SENSOR_TO_BRIGHTNESS_FLOAT[3], mServiceFake.screenBrightnessFloat, DELTA);
+ assertEquals(PowerManager.BRIGHTNESS_DEFAULT, mServiceFake.screenBrightnessInt);
+ }
+
+ @Test
+ @RequiresFlagsDisabled(Flags.FLAG_DOZE_BRIGHTNESS_FLOAT)
+ public void testNoBrightnessDeliveredAfterFinish_Int() {
mScreen.transitionTo(UNINITIALIZED, INITIALIZED);
mScreen.transitionTo(INITIALIZED, DOZE_AOD);
mScreen.transitionTo(DOZE_AOD, FINISH);
@@ -440,11 +774,27 @@
mSensor.sendSensorEvent(1);
- assertNotEquals(1, mServiceFake.screenBrightness);
+ assertNotEquals(SENSOR_TO_BRIGHTNESS_INT[1], mServiceFake.screenBrightnessInt);
+ assertTrue(Float.isNaN(mServiceFake.screenBrightnessFloat));
}
@Test
- public void testNonPositiveBrightness_keepsPreviousBrightnessAndScrim() {
+ @RequiresFlagsEnabled(Flags.FLAG_DOZE_BRIGHTNESS_FLOAT)
+ public void testNoBrightnessDeliveredAfterFinish_Float() {
+ mScreen.transitionTo(UNINITIALIZED, INITIALIZED);
+ mScreen.transitionTo(INITIALIZED, DOZE_AOD);
+ mScreen.transitionTo(DOZE_AOD, FINISH);
+ waitForSensorManager();
+
+ mSensor.sendSensorEvent(1);
+
+ assertNotEquals(SENSOR_TO_BRIGHTNESS_FLOAT[1], mServiceFake.screenBrightnessFloat);
+ assertEquals(PowerManager.BRIGHTNESS_DEFAULT, mServiceFake.screenBrightnessInt);
+ }
+
+ @Test
+ @RequiresFlagsDisabled(Flags.FLAG_DOZE_BRIGHTNESS_FLOAT)
+ public void testNonPositiveBrightness_keepsPreviousBrightnessAndScrim_Int() {
mScreen.transitionTo(UNINITIALIZED, INITIALIZED);
mScreen.transitionTo(INITIALIZED, DOZE_AOD);
waitForSensorManager();
@@ -452,7 +802,23 @@
mSensor.sendSensorEvent(1);
mSensor.sendSensorEvent(0);
- assertEquals(1, mServiceFake.screenBrightness);
+ assertEquals(SENSOR_TO_BRIGHTNESS_INT[1], mServiceFake.screenBrightnessInt);
+ assertTrue(Float.isNaN(mServiceFake.screenBrightnessFloat));
+ verify(mDozeHost).setAodDimmingScrim(eq(10f / 255f));
+ }
+
+ @Test
+ @RequiresFlagsEnabled(Flags.FLAG_DOZE_BRIGHTNESS_FLOAT)
+ public void testNonPositiveBrightness_keepsPreviousBrightnessAndScrim_Float() {
+ mScreen.transitionTo(UNINITIALIZED, INITIALIZED);
+ mScreen.transitionTo(INITIALIZED, DOZE_AOD);
+ waitForSensorManager();
+
+ mSensor.sendSensorEvent(1);
+ mSensor.sendSensorEvent(0);
+
+ assertEquals(SENSOR_TO_BRIGHTNESS_FLOAT[1], mServiceFake.screenBrightnessFloat, DELTA);
+ assertEquals(PowerManager.BRIGHTNESS_DEFAULT, mServiceFake.screenBrightnessInt);
verify(mDozeHost).setAodDimmingScrim(eq(10f / 255f));
}
@@ -473,7 +839,8 @@
}
@Test
- public void transitionToDoze_shouldClampBrightness_afterTimeout_clampsToDim() {
+ @RequiresFlagsDisabled(Flags.FLAG_DOZE_BRIGHTNESS_FLOAT)
+ public void transitionToDoze_shouldClampBrightness_afterTimeout_clampsToDim_Int() {
when(mWakefulnessLifecycle.getLastSleepReason()).thenReturn(
PowerManager.GO_TO_SLEEP_REASON_TIMEOUT);
when(mDozeParameters.shouldClampToDimBrightness()).thenReturn(true);
@@ -482,15 +849,38 @@
// If we're dozing after a timeout, and playing the unlocked screen animation, we should
// stay at or below dim brightness, because the screen dims just before timeout.
- assertTrue(mServiceFake.screenBrightness <= DIM_BRIGHTNESS);
+ assertTrue(mServiceFake.screenBrightnessInt <= DIM_BRIGHTNESS_INT);
+ assertTrue(Float.isNaN(mServiceFake.screenBrightnessFloat));
// Once we transition to Doze, use the doze brightness
mScreen.transitionTo(INITIALIZED, DOZE);
- assertEquals(mServiceFake.screenBrightness, DEFAULT_BRIGHTNESS);
+ assertEquals(mServiceFake.screenBrightnessInt, DEFAULT_BRIGHTNESS_INT);
+ assertTrue(Float.isNaN(mServiceFake.screenBrightnessFloat));
}
@Test
- public void transitionToDoze_shouldClampBrightness_notAfterTimeout_doesNotClampToDim() {
+ @RequiresFlagsEnabled(Flags.FLAG_DOZE_BRIGHTNESS_FLOAT)
+ public void transitionToDoze_shouldClampBrightness_afterTimeout_clampsToDim_Float() {
+ when(mWakefulnessLifecycle.getLastSleepReason()).thenReturn(
+ PowerManager.GO_TO_SLEEP_REASON_TIMEOUT);
+ when(mDozeParameters.shouldClampToDimBrightness()).thenReturn(true);
+
+ mScreen.transitionTo(UNINITIALIZED, INITIALIZED);
+
+ // If we're dozing after a timeout, and playing the unlocked screen animation, we should
+ // stay at or below dim brightness, because the screen dims just before timeout.
+ assertTrue(mServiceFake.screenBrightnessFloat <= DIM_BRIGHTNESS_FLOAT);
+ assertEquals(PowerManager.BRIGHTNESS_DEFAULT, mServiceFake.screenBrightnessInt);
+
+ // Once we transition to Doze, use the doze brightness
+ mScreen.transitionTo(INITIALIZED, DOZE);
+ assertEquals(mServiceFake.screenBrightnessFloat, DEFAULT_BRIGHTNESS_FLOAT, DELTA);
+ assertEquals(PowerManager.BRIGHTNESS_DEFAULT, mServiceFake.screenBrightnessInt);
+ }
+
+ @Test
+ @RequiresFlagsDisabled(Flags.FLAG_DOZE_BRIGHTNESS_FLOAT)
+ public void transitionToDoze_shouldClampBrightness_notAfterTimeout_doesNotClampToDim_Int() {
when(mWakefulnessLifecycle.getLastSleepReason()).thenReturn(
PowerManager.GO_TO_SLEEP_REASON_POWER_BUTTON);
when(mDozeParameters.shouldClampToDimBrightness()).thenReturn(true);
@@ -499,14 +889,36 @@
// If we're playing the unlocked screen off animation after a power button press, we should
// leave the brightness alone.
- assertEquals(mServiceFake.screenBrightness, DEFAULT_BRIGHTNESS);
+ assertEquals(mServiceFake.screenBrightnessInt, DEFAULT_BRIGHTNESS_INT);
+ assertTrue(Float.isNaN(mServiceFake.screenBrightnessFloat));
mScreen.transitionTo(INITIALIZED, DOZE);
- assertEquals(mServiceFake.screenBrightness, DEFAULT_BRIGHTNESS);
+ assertEquals(mServiceFake.screenBrightnessInt, DEFAULT_BRIGHTNESS_INT);
+ assertTrue(Float.isNaN(mServiceFake.screenBrightnessFloat));
}
@Test
- public void transitionToDoze_noClampBrightness_afterTimeout_noScreenOff_doesNotClampToDim() {
+ @RequiresFlagsEnabled(Flags.FLAG_DOZE_BRIGHTNESS_FLOAT)
+ public void transitionToDoze_shouldClampBrightness_notAfterTimeout_doesNotClampToDim_Float() {
+ when(mWakefulnessLifecycle.getLastSleepReason()).thenReturn(
+ PowerManager.GO_TO_SLEEP_REASON_POWER_BUTTON);
+ when(mDozeParameters.shouldClampToDimBrightness()).thenReturn(true);
+
+ mScreen.transitionTo(UNINITIALIZED, INITIALIZED);
+
+ // If we're playing the unlocked screen off animation after a power button press, we should
+ // leave the brightness alone.
+ assertEquals(mServiceFake.screenBrightnessFloat, DEFAULT_BRIGHTNESS_FLOAT, DELTA);
+ assertEquals(PowerManager.BRIGHTNESS_DEFAULT, mServiceFake.screenBrightnessInt);
+
+ mScreen.transitionTo(INITIALIZED, DOZE);
+ assertEquals(mServiceFake.screenBrightnessFloat, DEFAULT_BRIGHTNESS_FLOAT, DELTA);
+ assertEquals(PowerManager.BRIGHTNESS_DEFAULT, mServiceFake.screenBrightnessInt);
+ }
+
+ @Test
+ @RequiresFlagsDisabled(Flags.FLAG_DOZE_BRIGHTNESS_FLOAT)
+ public void transitionToDoze_noClamp_afterTimeout_noScreenOff_doesNotClampToDim_Int() {
when(mWakefulnessLifecycle.getLastSleepReason()).thenReturn(
PowerManager.GO_TO_SLEEP_REASON_TIMEOUT);
when(mDozeParameters.shouldClampToDimBrightness()).thenReturn(false);
@@ -515,11 +927,28 @@
mScreen.transitionTo(INITIALIZED, DOZE);
// If we aren't controlling the screen off animation, we should leave the brightness alone.
- assertEquals(mServiceFake.screenBrightness, DEFAULT_BRIGHTNESS);
+ assertEquals(mServiceFake.screenBrightnessInt, DEFAULT_BRIGHTNESS_INT);
+ assertTrue(Float.isNaN(mServiceFake.screenBrightnessFloat));
}
@Test
- public void transitionToDoze_noClampBrightness_afterTimeout_clampsToDim() {
+ @RequiresFlagsEnabled(Flags.FLAG_DOZE_BRIGHTNESS_FLOAT)
+ public void transitionToDoze_noClamp_afterTimeout_noScreenOff_doesNotClampToDim_Float() {
+ when(mWakefulnessLifecycle.getLastSleepReason()).thenReturn(
+ PowerManager.GO_TO_SLEEP_REASON_TIMEOUT);
+ when(mDozeParameters.shouldClampToDimBrightness()).thenReturn(false);
+
+ mScreen.transitionTo(UNINITIALIZED, INITIALIZED);
+ mScreen.transitionTo(INITIALIZED, DOZE);
+
+ // If we aren't controlling the screen off animation, we should leave the brightness alone.
+ assertEquals(mServiceFake.screenBrightnessFloat, DEFAULT_BRIGHTNESS_FLOAT, DELTA);
+ assertEquals(PowerManager.BRIGHTNESS_DEFAULT, mServiceFake.screenBrightnessInt);
+ }
+
+ @Test
+ @RequiresFlagsDisabled(Flags.FLAG_DOZE_BRIGHTNESS_FLOAT)
+ public void transitionToDoze_noClampBrightness_afterTimeout_clampsToDim_Int() {
when(mWakefulnessLifecycle.getLastSleepReason()).thenReturn(
PowerManager.GO_TO_SLEEP_REASON_TIMEOUT);
when(mWakefulnessLifecycle.getWakefulness()).thenReturn(
@@ -528,11 +957,28 @@
mScreen.transitionTo(UNINITIALIZED, INITIALIZED);
- assertTrue(mServiceFake.screenBrightness <= DIM_BRIGHTNESS);
+ assertTrue(mServiceFake.screenBrightnessInt <= DIM_BRIGHTNESS_INT);
+ assertTrue(Float.isNaN(mServiceFake.screenBrightnessFloat));
}
@Test
- public void transitionToDoze_noClampBrigthness_notAfterTimeout_doesNotClampToDim() {
+ @RequiresFlagsEnabled(Flags.FLAG_DOZE_BRIGHTNESS_FLOAT)
+ public void transitionToDoze_noClampBrightness_afterTimeout_clampsToDim_Float() {
+ when(mWakefulnessLifecycle.getLastSleepReason()).thenReturn(
+ PowerManager.GO_TO_SLEEP_REASON_TIMEOUT);
+ when(mWakefulnessLifecycle.getWakefulness()).thenReturn(
+ WakefulnessLifecycle.WAKEFULNESS_GOING_TO_SLEEP);
+ when(mDozeParameters.shouldClampToDimBrightness()).thenReturn(false);
+
+ mScreen.transitionTo(UNINITIALIZED, INITIALIZED);
+
+ assertTrue(mServiceFake.screenBrightnessFloat <= DIM_BRIGHTNESS_FLOAT);
+ assertEquals(PowerManager.BRIGHTNESS_DEFAULT, mServiceFake.screenBrightnessInt);
+ }
+
+ @Test
+ @RequiresFlagsDisabled(Flags.FLAG_DOZE_BRIGHTNESS_FLOAT)
+ public void transitionToDoze_noClampBrigthness_notAfterTimeout_doesNotClampToDim_Int() {
when(mWakefulnessLifecycle.getLastSleepReason()).thenReturn(
PowerManager.GO_TO_SLEEP_REASON_POWER_BUTTON);
when(mWakefulnessLifecycle.getWakefulness()).thenReturn(
@@ -542,11 +988,29 @@
mScreen.transitionTo(UNINITIALIZED, INITIALIZED);
mScreen.transitionTo(INITIALIZED, DOZE);
- assertEquals(mServiceFake.screenBrightness, DEFAULT_BRIGHTNESS);
+ assertEquals(mServiceFake.screenBrightnessInt, DEFAULT_BRIGHTNESS_INT);
+ assertTrue(Float.isNaN(mServiceFake.screenBrightnessFloat));
}
@Test
- public void transitionToAodPaused_lightSensorDisabled() {
+ @RequiresFlagsEnabled(Flags.FLAG_DOZE_BRIGHTNESS_FLOAT)
+ public void transitionToDoze_noClampBrigthness_notAfterTimeout_doesNotClampToDim_Float() {
+ when(mWakefulnessLifecycle.getLastSleepReason()).thenReturn(
+ PowerManager.GO_TO_SLEEP_REASON_POWER_BUTTON);
+ when(mWakefulnessLifecycle.getWakefulness()).thenReturn(
+ WakefulnessLifecycle.WAKEFULNESS_GOING_TO_SLEEP);
+ when(mDozeParameters.shouldClampToDimBrightness()).thenReturn(false);
+
+ mScreen.transitionTo(UNINITIALIZED, INITIALIZED);
+ mScreen.transitionTo(INITIALIZED, DOZE);
+
+ assertEquals(mServiceFake.screenBrightnessFloat, DEFAULT_BRIGHTNESS_FLOAT, DELTA);
+ assertEquals(PowerManager.BRIGHTNESS_DEFAULT, mServiceFake.screenBrightnessInt);
+ }
+
+ @Test
+ @RequiresFlagsDisabled(Flags.FLAG_DOZE_BRIGHTNESS_FLOAT)
+ public void transitionToAodPaused_lightSensorDisabled_Int() {
// GIVEN AOD
mScreen.transitionTo(UNINITIALIZED, INITIALIZED);
mScreen.transitionTo(INITIALIZED, DOZE_AOD);
@@ -558,11 +1022,31 @@
// THEN new light events don't update brightness since the light sensor was unregistered
mSensor.sendSensorEvent(1);
- assertEquals(mServiceFake.screenBrightness, DEFAULT_BRIGHTNESS);
+ assertEquals(mServiceFake.screenBrightnessInt, DEFAULT_BRIGHTNESS_INT);
+ assertTrue(Float.isNaN(mServiceFake.screenBrightnessFloat));
}
@Test
- public void transitionFromAodPausedToAod_lightSensorEnabled() {
+ @RequiresFlagsEnabled(Flags.FLAG_DOZE_BRIGHTNESS_FLOAT)
+ public void transitionToAodPaused_lightSensorDisabled_Float() {
+ // GIVEN AOD
+ mScreen.transitionTo(UNINITIALIZED, INITIALIZED);
+ mScreen.transitionTo(INITIALIZED, DOZE_AOD);
+
+ // WHEN AOD is paused
+ mScreen.transitionTo(DOZE_AOD, DOZE_AOD_PAUSING);
+ mScreen.transitionTo(DOZE_AOD, DOZE_AOD_PAUSED);
+ waitForSensorManager();
+
+ // THEN new light events don't update brightness since the light sensor was unregistered
+ mSensor.sendSensorEvent(1);
+ assertEquals(mServiceFake.screenBrightnessFloat, DEFAULT_BRIGHTNESS_FLOAT, DELTA);
+ assertEquals(PowerManager.BRIGHTNESS_DEFAULT, mServiceFake.screenBrightnessInt);
+ }
+
+ @Test
+ @RequiresFlagsDisabled(Flags.FLAG_DOZE_BRIGHTNESS_FLOAT)
+ public void transitionFromAodPausedToAod_lightSensorEnabled_Int() {
// GIVEN AOD paused
mScreen.transitionTo(UNINITIALIZED, INITIALIZED);
mScreen.transitionTo(INITIALIZED, DOZE_AOD);
@@ -577,7 +1061,54 @@
mSensor.sendSensorEvent(1);
// THEN aod brightness is updated
- assertEquals(mServiceFake.screenBrightness, 1);
+ assertEquals(SENSOR_TO_BRIGHTNESS_INT[1], mServiceFake.screenBrightnessInt);
+ assertTrue(Float.isNaN(mServiceFake.screenBrightnessFloat));
+ }
+
+ @Test
+ @RequiresFlagsEnabled(Flags.FLAG_DOZE_BRIGHTNESS_FLOAT)
+ public void transitionFromAodPausedToAod_lightSensorEnabled_Float() {
+ // GIVEN AOD paused
+ mScreen.transitionTo(UNINITIALIZED, INITIALIZED);
+ mScreen.transitionTo(INITIALIZED, DOZE_AOD);
+ mScreen.transitionTo(DOZE_AOD, DOZE_AOD_PAUSING);
+ mScreen.transitionTo(DOZE_AOD, DOZE_AOD_PAUSED);
+
+ // WHEN device transitions back to AOD
+ mScreen.transitionTo(DOZE_AOD_PAUSED, DOZE_AOD);
+ waitForSensorManager();
+
+ // WHEN there are brightness changes
+ mSensor.sendSensorEvent(1);
+
+ // THEN aod brightness is updated
+ assertEquals(SENSOR_TO_BRIGHTNESS_FLOAT[1], mServiceFake.screenBrightnessFloat, DELTA);
+ assertEquals(PowerManager.BRIGHTNESS_DEFAULT, mServiceFake.screenBrightnessInt);
+ }
+
+ @Test
+ @RequiresFlagsEnabled(Flags.FLAG_DOZE_BRIGHTNESS_FLOAT)
+ public void fallBackToIntIfFloatBrightnessUndefined() {
+ when(mDisplayManager.getDozeBrightnessSensorValueToBrightness(Display.DEFAULT_DISPLAY))
+ .thenReturn(null);
+ mScreen = new DozeScreenBrightness(
+ mContext,
+ mServiceFake,
+ mSensorManager,
+ new Optional[]{Optional.of(mSensor.getSensor())},
+ mDozeHost,
+ null /* handler */,
+ mAlwaysOnDisplayPolicy,
+ mWakefulnessLifecycle,
+ mDozeParameters,
+ mDevicePostureController,
+ mDozeLog,
+ mSystemSettings,
+ mDisplayManager);
+ mScreen.transitionTo(UNINITIALIZED, INITIALIZED);
+
+ assertEquals(DEFAULT_BRIGHTNESS_INT, mServiceFake.screenBrightnessInt);
+ assertTrue(Float.isNaN(mServiceFake.screenBrightnessFloat));
}
private void waitForSensorManager() {
diff --git a/packages/SystemUI/tests/src/com/android/systemui/doze/DozeServiceFake.java b/packages/SystemUI/tests/src/com/android/systemui/doze/DozeServiceFake.java
index 928b314..f55c2b7 100644
--- a/packages/SystemUI/tests/src/com/android/systemui/doze/DozeServiceFake.java
+++ b/packages/SystemUI/tests/src/com/android/systemui/doze/DozeServiceFake.java
@@ -30,7 +30,8 @@
public int screenState;
public boolean screenStateSet;
public boolean requestedWakeup;
- public int screenBrightness;
+ public int screenBrightnessInt;
+ public float screenBrightnessFloat;
public DozeServiceFake() {
reset();
@@ -54,7 +55,12 @@
@Override
public void setDozeScreenBrightness(int brightness) {
- screenBrightness = brightness;
+ screenBrightnessInt = brightness;
+ }
+
+ @Override
+ public void setDozeScreenBrightnessFloat(float brightness) {
+ screenBrightnessFloat = brightness;
}
public void reset() {
@@ -62,6 +68,7 @@
screenState = Display.STATE_UNKNOWN;
screenStateSet = false;
requestedWakeup = false;
- screenBrightness = PowerManager.BRIGHTNESS_DEFAULT;
+ screenBrightnessInt = PowerManager.BRIGHTNESS_DEFAULT;
+ screenBrightnessFloat = PowerManager.BRIGHTNESS_INVALID_FLOAT;
}
}
diff --git a/services/core/java/com/android/server/dreams/DreamManagerService.java b/services/core/java/com/android/server/dreams/DreamManagerService.java
index d43e783..a3b77e8 100644
--- a/services/core/java/com/android/server/dreams/DreamManagerService.java
+++ b/services/core/java/com/android/server/dreams/DreamManagerService.java
@@ -543,18 +543,20 @@
}
private void startDozingInternal(IBinder token, int screenState,
- @Display.StateReason int reason, int screenBrightness) {
+ @Display.StateReason int reason, float screenBrightnessFloat, int screenBrightnessInt) {
Slog.d(TAG, "Dream requested to start dozing: " + token
+ ", screenState=" + Display.stateToString(screenState)
+ ", reason=" + Display.stateReasonToString(reason)
- + ", screenBrightness=" + screenBrightness);
+ + ", screenBrightnessFloat=" + screenBrightnessFloat
+ + ", screenBrightnessInt=" + screenBrightnessInt);
synchronized (mLock) {
if (mCurrentDream != null && mCurrentDream.token == token && mCurrentDream.canDoze) {
mCurrentDream.dozeScreenState = screenState;
- mCurrentDream.dozeScreenBrightness = screenBrightness;
+ mCurrentDream.dozeScreenBrightness = screenBrightnessInt;
+ mCurrentDream.dozeScreenBrightnessFloat = screenBrightnessFloat;
mPowerManagerInternal.setDozeOverrideFromDreamManager(
- screenState, reason, screenBrightness);
+ screenState, reason, screenBrightnessFloat, screenBrightnessInt);
if (!mCurrentDream.isDozing) {
mCurrentDream.isDozing = true;
mDozeWakeLock.acquire();
@@ -575,6 +577,7 @@
mPowerManagerInternal.setDozeOverrideFromDreamManager(
Display.STATE_UNKNOWN,
Display.STATE_REASON_DREAM_MANAGER,
+ PowerManager.BRIGHTNESS_INVALID_FLOAT,
PowerManager.BRIGHTNESS_DEFAULT);
}
}
@@ -1095,7 +1098,7 @@
@Override // Binder call
public void startDozing(
IBinder token, int screenState, @Display.StateReason int reason,
- int screenBrightness) {
+ float screenBrightnessFloat, int screeBrightnessInt) {
// Requires no permission, called by Dream from an arbitrary process.
if (token == null) {
throw new IllegalArgumentException("token must not be null");
@@ -1103,7 +1106,8 @@
final long ident = Binder.clearCallingIdentity();
try {
- startDozingInternal(token, screenState, reason, screenBrightness);
+ startDozingInternal(token, screenState, reason, screenBrightnessFloat,
+ screeBrightnessInt);
} finally {
Binder.restoreCallingIdentity(ident);
}
@@ -1112,7 +1116,7 @@
@Override // Binder call
public void startDozingOneway(
IBinder token, int screenState, @Display.StateReason int reason,
- int screenBrightness) {
+ float screenBrightnessFloat, int screeBrightnessInt) {
// Requires no permission, called by Dream from an arbitrary process.
if (token == null) {
throw new IllegalArgumentException("token must not be null");
@@ -1120,7 +1124,8 @@
final long ident = Binder.clearCallingIdentity();
try {
- startDozingInternal(token, screenState, reason, screenBrightness);
+ startDozingInternal(token, screenState, reason, screenBrightnessFloat,
+ screeBrightnessInt);
} finally {
Binder.restoreCallingIdentity(ident);
}
@@ -1277,6 +1282,7 @@
public boolean isWaking = false;
public int dozeScreenState = Display.STATE_UNKNOWN;
public int dozeScreenBrightness = PowerManager.BRIGHTNESS_DEFAULT;
+ public float dozeScreenBrightnessFloat = PowerManager.BRIGHTNESS_INVALID_FLOAT;
DreamRecord(ComponentName name, int userId, boolean isPreview, boolean canDoze) {
this.name = name;
@@ -1297,6 +1303,7 @@
+ ", isWaking=" + isWaking
+ ", dozeScreenState=" + dozeScreenState
+ ", dozeScreenBrightness=" + dozeScreenBrightness
+ + ", dozeScreenBrightnessFloat=" + dozeScreenBrightnessFloat
+ '}';
}
}
diff --git a/services/core/java/com/android/server/power/PowerManagerService.java b/services/core/java/com/android/server/power/PowerManagerService.java
index 10faf14..ecb0c30b 100644
--- a/services/core/java/com/android/server/power/PowerManagerService.java
+++ b/services/core/java/com/android/server/power/PowerManagerService.java
@@ -34,6 +34,7 @@
import static com.android.internal.util.LatencyTracker.ACTION_TURN_ON_SCREEN;
import static com.android.server.deviceidle.Flags.disableWakelocksInLightIdle;
import static com.android.server.display.DisplayDeviceConfig.INVALID_BRIGHTNESS_IN_CONFIG;
+import static com.android.server.display.brightness.BrightnessUtils.isValidBrightnessValue;
import android.annotation.IntDef;
import android.annotation.NonNull;
@@ -650,11 +651,16 @@
private int mDozeScreenStateOverrideReasonFromDreamManager = Display.STATE_REASON_UNKNOWN;
- // The screen brightness to use while dozing.
+ // The screen brightness between 1 and 255 to use while dozing.
private int mDozeScreenBrightnessOverrideFromDreamManager = PowerManager.BRIGHTNESS_DEFAULT;
+ /**
+ * The screen brightness between {@link PowerManager#BRIGHTNESS_MIN} and
+ * {@link PowerManager.BRIGHTNESS_MAX} to use while dozing.
+ */
private float mDozeScreenBrightnessOverrideFromDreamManagerFloat =
PowerManager.BRIGHTNESS_INVALID_FLOAT;
+
// Keep display state when dozing.
private boolean mDrawWakeLockOverrideFromSidekick;
@@ -4455,15 +4461,21 @@
}
private void setDozeOverrideFromDreamManagerInternal(
- int screenState, @Display.StateReason int reason, int screenBrightness) {
+ int screenState, @Display.StateReason int reason, float screenBrightnessFloat,
+ int screenBrightnessInt) {
synchronized (mLock) {
if (mDozeScreenStateOverrideFromDreamManager != screenState
- || mDozeScreenBrightnessOverrideFromDreamManager != screenBrightness) {
+ || mDozeScreenBrightnessOverrideFromDreamManager != screenBrightnessInt
+ || !BrightnessSynchronizer.floatEquals(
+ mDozeScreenBrightnessOverrideFromDreamManagerFloat,
+ screenBrightnessFloat)) {
mDozeScreenStateOverrideFromDreamManager = screenState;
mDozeScreenStateOverrideReasonFromDreamManager = reason;
- mDozeScreenBrightnessOverrideFromDreamManager = screenBrightness;
+ mDozeScreenBrightnessOverrideFromDreamManager = screenBrightnessInt;
mDozeScreenBrightnessOverrideFromDreamManagerFloat =
- BrightnessSynchronizer.brightnessIntToFloat(mDozeScreenBrightnessOverrideFromDreamManager);
+ isValidBrightnessValue(screenBrightnessFloat)
+ ? screenBrightnessFloat
+ : BrightnessSynchronizer.brightnessIntToFloat(screenBrightnessInt);
mDirty |= DIRTY_SETTINGS;
updatePowerStateLocked();
}
@@ -7095,7 +7107,7 @@
@Override
public void setDozeOverrideFromDreamManager(
- int screenState, int reason, int screenBrightness) {
+ int screenState, int reason, float screenBrightnessFloat, int screenBrightnessInt) {
switch (screenState) {
case Display.STATE_UNKNOWN:
case Display.STATE_OFF:
@@ -7108,11 +7120,17 @@
screenState = Display.STATE_UNKNOWN;
break;
}
- if (screenBrightness < PowerManager.BRIGHTNESS_DEFAULT
- || screenBrightness > PowerManager.BRIGHTNESS_ON) {
- screenBrightness = PowerManager.BRIGHTNESS_DEFAULT;
+ if (screenBrightnessInt < PowerManager.BRIGHTNESS_DEFAULT
+ || screenBrightnessInt > PowerManager.BRIGHTNESS_ON) {
+ screenBrightnessInt = PowerManager.BRIGHTNESS_DEFAULT;
}
- setDozeOverrideFromDreamManagerInternal(screenState, reason, screenBrightness);
+ if (screenBrightnessFloat != PowerManager.BRIGHTNESS_OFF_FLOAT
+ && (screenBrightnessFloat < PowerManager.BRIGHTNESS_MIN
+ || screenBrightnessFloat > PowerManager.BRIGHTNESS_MAX)) {
+ screenBrightnessFloat = PowerManager.BRIGHTNESS_INVALID_FLOAT;
+ }
+ setDozeOverrideFromDreamManagerInternal(screenState, reason, screenBrightnessFloat,
+ screenBrightnessInt);
}
@Override
diff --git a/services/tests/powerservicetests/src/com/android/server/power/PowerManagerServiceTest.java b/services/tests/powerservicetests/src/com/android/server/power/PowerManagerServiceTest.java
index b737e0f..40c521a 100644
--- a/services/tests/powerservicetests/src/com/android/server/power/PowerManagerServiceTest.java
+++ b/services/tests/powerservicetests/src/com/android/server/power/PowerManagerServiceTest.java
@@ -1304,6 +1304,7 @@
.setDozeOverrideFromDreamManager(
Display.STATE_ON,
Display.STATE_REASON_DEFAULT_POLICY,
+ PowerManager.BRIGHTNESS_INVALID_FLOAT,
PowerManager.BRIGHTNESS_DEFAULT);
assertTrue(isAcquired[0]);
}