diff options
17 files changed, 297 insertions, 89 deletions
diff --git a/core/java/android/hardware/display/DisplayManagerInternal.java b/core/java/android/hardware/display/DisplayManagerInternal.java index 58aafbc648f7..ec67212b46b7 100644 --- a/core/java/android/hardware/display/DisplayManagerInternal.java +++ b/core/java/android/hardware/display/DisplayManagerInternal.java @@ -498,6 +498,7 @@ public abstract class DisplayManagerInternal { // Overrides the policy for adjusting screen brightness and state while dozing. public int dozeScreenState; public float dozeScreenBrightness; + public int dozeScreenStateReason; public DisplayPowerRequest() { policy = POLICY_BRIGHT; @@ -508,6 +509,7 @@ public abstract class DisplayManagerInternal { blockScreenOn = false; dozeScreenBrightness = PowerManager.BRIGHTNESS_INVALID_FLOAT; dozeScreenState = Display.STATE_UNKNOWN; + dozeScreenStateReason = Display.STATE_REASON_UNKNOWN; } public DisplayPowerRequest(DisplayPowerRequest other) { @@ -529,6 +531,7 @@ public abstract class DisplayManagerInternal { boostScreenBrightness = other.boostScreenBrightness; dozeScreenBrightness = other.dozeScreenBrightness; dozeScreenState = other.dozeScreenState; + dozeScreenStateReason = other.dozeScreenStateReason; } @Override @@ -551,7 +554,8 @@ public abstract class DisplayManagerInternal { && lowPowerMode == other.lowPowerMode && boostScreenBrightness == other.boostScreenBrightness && floatEquals(dozeScreenBrightness, other.dozeScreenBrightness) - && dozeScreenState == other.dozeScreenState; + && dozeScreenState == other.dozeScreenState + && dozeScreenStateReason == other.dozeScreenStateReason; } private boolean floatEquals(float f1, float f2) { @@ -575,7 +579,9 @@ public abstract class DisplayManagerInternal { + ", lowPowerMode=" + lowPowerMode + ", boostScreenBrightness=" + boostScreenBrightness + ", dozeScreenBrightness=" + dozeScreenBrightness - + ", dozeScreenState=" + Display.stateToString(dozeScreenState); + + ", dozeScreenState=" + Display.stateToString(dozeScreenState) + + ", dozeScreenStateReason=" + + Display.stateReasonToString(dozeScreenStateReason); } public static String policyToString(int policy) { diff --git a/core/java/android/os/PowerManagerInternal.java b/core/java/android/os/PowerManagerInternal.java index fec67b97030d..df353e56a540 100644 --- a/core/java/android/os/PowerManagerInternal.java +++ b/core/java/android/os/PowerManagerInternal.java @@ -136,11 +136,12 @@ public abstract class PowerManagerInternal { * * @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. */ public abstract void setDozeOverrideFromDreamManager( - int screenState, int screenBrightness); + int screenState, @Display.StateReason int reason, int screenBrightness); /** * Used by sidekick manager to tell the power manager if it shouldn't change the display state diff --git a/core/java/android/service/dreams/DreamService.java b/core/java/android/service/dreams/DreamService.java index 4060b242292a..3df70164c964 100644 --- a/core/java/android/service/dreams/DreamService.java +++ b/core/java/android/service/dreams/DreamService.java @@ -264,6 +264,7 @@ public class DreamService extends Service implements Window.Callback { private boolean mDozing; private boolean mWindowless; private int mDozeScreenState = Display.STATE_UNKNOWN; + private @Display.StateReason int mDozeScreenStateReason = Display.STATE_REASON_UNKNOWN; private int mDozeScreenBrightness = PowerManager.BRIGHTNESS_DEFAULT; private boolean mDebug = false; @@ -748,7 +749,9 @@ public class DreamService extends Service implements Window.Callback { if (mDozing) { try { - mDreamManager.startDozing(mDreamToken, mDozeScreenState, mDozeScreenBrightness); + mDreamManager.startDozing( + mDreamToken, mDozeScreenState, mDozeScreenStateReason, + mDozeScreenBrightness); } catch (RemoteException ex) { // system server died } @@ -808,6 +811,19 @@ public class DreamService extends Service implements Window.Callback { } /** + * Same as {@link #setDozeScreenState(int, int)}, but with no screen state reason specified. + * + * <p>Use {@link #setDozeScreenState(int, int)} whenever possible to allow properly accounting + * for the screen state reason. + * + * @hide + */ + @UnsupportedAppUsage + public void setDozeScreenState(int state) { + setDozeScreenState(state, Display.STATE_REASON_UNKNOWN); + } + + /** * Sets the screen state to use while dozing. * <p> * The value of this property determines the power state of the primary display @@ -841,13 +857,15 @@ public class DreamService extends Service implements Window.Callback { * {@link Display#STATE_DOZE}, {@link Display#STATE_DOZE_SUSPEND}, * {@link Display#STATE_ON_SUSPEND}, {@link Display#STATE_OFF}, or {@link Display#STATE_UNKNOWN} * for the default behavior. + * @param reason the reason for setting the specified screen state. * * @hide For use by system UI components only. */ @UnsupportedAppUsage - public void setDozeScreenState(int state) { + public void setDozeScreenState(int state, @Display.StateReason int reason) { if (mDozeScreenState != state) { mDozeScreenState = state; + mDozeScreenStateReason = reason; updateDoze(); } } diff --git a/core/java/android/service/dreams/IDreamManager.aidl b/core/java/android/service/dreams/IDreamManager.aidl index c489c5808728..e45384f5512a 100644 --- a/core/java/android/service/dreams/IDreamManager.aidl +++ b/core/java/android/service/dreams/IDreamManager.aidl @@ -40,7 +40,7 @@ interface IDreamManager { boolean isDreamingOrInPreview(); boolean canStartDreaming(boolean isScreenOn); void finishSelf(in IBinder token, boolean immediate); - void startDozing(in IBinder token, int screenState, int screenBrightness); + void startDozing(in IBinder token, int screenState, int reason, int screenBrightness); void stopDozing(in IBinder token); void forceAmbientDisplayEnabled(boolean enabled); ComponentName[] getDreamComponentsForUser(int userId); diff --git a/core/java/android/view/Display.java b/core/java/android/view/Display.java index 1f2b4faacc10..4475418e1e57 100644 --- a/core/java/android/view/Display.java +++ b/core/java/android/view/Display.java @@ -503,6 +503,79 @@ public final class Display { */ public static final int STATE_ON_SUSPEND = ViewProtoEnums.DISPLAY_STATE_ON_SUSPEND; // 6 + /** + * The cause of the display state change is unknown. + * + * @hide + */ + public static final int STATE_REASON_UNKNOWN = ViewProtoEnums.DISPLAY_STATE_REASON_UNKNOWN; + + /** + * The default power and display policy caused the display state. + * + * @hide + */ + public static final int STATE_REASON_DEFAULT_POLICY = + ViewProtoEnums.DISPLAY_STATE_REASON_DEFAULT_POLICY; + + /** + * The display state was changed due to acquiring a draw wake lock. + * + * @hide + */ + public static final int STATE_REASON_DRAW_WAKE_LOCK = + ViewProtoEnums.DISPLAY_STATE_REASON_DRAW_WAKE_LOCK; + + /** + * The display state was changed due to display offloading. + * + * @hide + */ + public static final int STATE_REASON_OFFLOAD = ViewProtoEnums.DISPLAY_STATE_REASON_OFFLOAD; + + /** + * The display state was changed due to a tilt event. + * + * @hide + */ + public static final int STATE_REASON_TILT = ViewProtoEnums.DISPLAY_STATE_REASON_TILT; + + /** + * The display state was changed due to the dream manager. + * + * @hide + */ + public static final int STATE_REASON_DREAM_MANAGER = + ViewProtoEnums.DISPLAY_STATE_REASON_DREAM_MANAGER; + + /** + * The display state was changed due to a {@link KeyEvent}. + * + * @hide + */ + public static final int STATE_REASON_KEY = ViewProtoEnums.DISPLAY_STATE_REASON_KEY; + + /** + * The display state was changed due to a {@link MotionEvent}. + * + * @hide + */ + public static final int STATE_REASON_MOTION = ViewProtoEnums.DISPLAY_STATE_REASON_MOTION; + + /** @hide */ + @IntDef(prefix = {"STATE_REASON_"}, value = { + STATE_REASON_UNKNOWN, + STATE_REASON_DEFAULT_POLICY, + STATE_REASON_DRAW_WAKE_LOCK, + STATE_REASON_OFFLOAD, + STATE_REASON_TILT, + STATE_REASON_DREAM_MANAGER, + STATE_REASON_KEY, + STATE_REASON_MOTION, + }) + @Retention(RetentionPolicy.SOURCE) + public @interface StateReason {} + /* The color mode constants defined below must be kept in sync with the ones in * system/core/include/system/graphics-base.h */ @@ -1996,6 +2069,30 @@ public final class Display { } } + /** @hide */ + public static String stateReasonToString(@StateReason int reason) { + switch (reason) { + case STATE_REASON_UNKNOWN: + return "UNKNOWN"; + case STATE_REASON_DEFAULT_POLICY: + return "DEFAULT_POLICY"; + case STATE_REASON_DRAW_WAKE_LOCK: + return "DRAW_WAKE_LOCK"; + case STATE_REASON_OFFLOAD: + return "OFFLOAD"; + case STATE_REASON_TILT: + return "TILT"; + case STATE_REASON_DREAM_MANAGER: + return "DREAM_MANAGER"; + case STATE_REASON_KEY: + return "KEY"; + case STATE_REASON_MOTION: + return "MOTION"; + default: + return Integer.toString(reason); + } + } + /** * Returns true if display updates may be suspended while in the specified * display power state. In SUSPEND states, updates are absolutely forbidden. diff --git a/services/core/java/com/android/server/display/DisplayOffloadSessionImpl.java b/services/core/java/com/android/server/display/DisplayOffloadSessionImpl.java index b1defe94436a..65c9f3556fad 100644 --- a/services/core/java/com/android/server/display/DisplayOffloadSessionImpl.java +++ b/services/core/java/com/android/server/display/DisplayOffloadSessionImpl.java @@ -21,6 +21,7 @@ import static com.android.server.display.AutomaticBrightnessController.AUTO_BRIG import android.annotation.Nullable; import android.hardware.display.DisplayManagerInternal; import android.os.Trace; +import android.view.Display; /** * An implementation of the offload session that keeps track of whether the session is active. @@ -42,7 +43,7 @@ public class DisplayOffloadSessionImpl implements DisplayManagerInternal.Display @Override public void setDozeStateOverride(int displayState) { - mDisplayPowerController.overrideDozeScreenState(displayState); + mDisplayPowerController.overrideDozeScreenState(displayState, Display.STATE_REASON_OFFLOAD); } @Override diff --git a/services/core/java/com/android/server/display/DisplayPowerController.java b/services/core/java/com/android/server/display/DisplayPowerController.java index d99f7121a14c..043ff0e9e394 100644 --- a/services/core/java/com/android/server/display/DisplayPowerController.java +++ b/services/core/java/com/android/server/display/DisplayPowerController.java @@ -61,6 +61,7 @@ import android.util.IndentingPrintWriter; import android.util.MathUtils; import android.util.MutableFloat; import android.util.MutableInt; +import android.util.Pair; import android.util.Slog; import android.util.SparseArray; import android.view.Display; @@ -788,14 +789,14 @@ final class DisplayPowerController implements AutomaticBrightnessController.Call } @Override - public void overrideDozeScreenState(int displayState) { + public void overrideDozeScreenState(int displayState, @Display.StateReason int reason) { mHandler.postAtTime(() -> { if (mDisplayOffloadSession == null || !(DisplayOffloadSession.isSupportedOffloadState(displayState) || displayState == Display.STATE_UNKNOWN)) { return; } - mDisplayStateController.overrideDozeScreenState(displayState); + mDisplayStateController.overrideDozeScreenState(displayState, reason); sendUpdatePowerState(); }, mClock.uptimeMillis()); } @@ -975,7 +976,7 @@ final class DisplayPowerController implements AutomaticBrightnessController.Call && mAutomaticBrightnessController.isInIdleMode()); mScreenBrightnessRampAnimator.setListener(mRampAnimatorListener); - noteScreenState(mPowerState.getScreenState()); + noteScreenState(mPowerState.getScreenState(), Display.STATE_REASON_DEFAULT_POLICY); noteScreenBrightness(mPowerState.getScreenBrightness()); // Initialize all of the brightness tracking state @@ -1276,8 +1277,10 @@ final class DisplayPowerController implements AutomaticBrightnessController.Call displayBrightnessFollowers = mDisplayBrightnessFollowers.clone(); } - int state = mDisplayStateController - .updateDisplayState(mPowerRequest, mIsEnabled, mIsInTransition); + final Pair<Integer, Integer> stateAndReason = + mDisplayStateController + .updateDisplayState(mPowerRequest, mIsEnabled, mIsInTransition); + int state = stateAndReason.first; // Initialize things the first time the power state is changed. if (mustInitialize) { @@ -1287,7 +1290,9 @@ final class DisplayPowerController implements AutomaticBrightnessController.Call // Animate the screen state change unless already animating. // The transition may be deferred, so after this point we will use the // actual state instead of the desired one. - animateScreenStateChange(state, mDisplayStateController.shouldPerformScreenOffTransition()); + animateScreenStateChange( + state, /* reason= */ stateAndReason.second, + mDisplayStateController.shouldPerformScreenOffTransition()); state = mPowerState.getScreenState(); // Switch to doze auto-brightness mode if needed @@ -2024,11 +2029,11 @@ final class DisplayPowerController implements AutomaticBrightnessController.Call Trace.TRACE_TAG_POWER, SCREEN_ON_BLOCKED_BY_DISPLAYOFFLOAD_TRACE_NAME, 0); } - private boolean setScreenState(int state) { - return setScreenState(state, false /*reportOnly*/); + private boolean setScreenState(int state, @Display.StateReason int reason) { + return setScreenState(state, reason, false /*reportOnly*/); } - private boolean setScreenState(int state, boolean reportOnly) { + private boolean setScreenState(int state, @Display.StateReason int reason, boolean reportOnly) { final boolean isOff = (state == Display.STATE_OFF); final boolean isOn = (state == Display.STATE_ON); final boolean changed = mPowerState.getScreenState() != state; @@ -2075,9 +2080,9 @@ final class DisplayPowerController implements AutomaticBrightnessController.Call + " value=" + propertyValue + " " + e.getMessage()); } - mPowerState.setScreenState(state); + mPowerState.setScreenState(state, reason); // Tell battery stats about the transition. - noteScreenState(state); + noteScreenState(state, reason); } } @@ -2174,7 +2179,8 @@ final class DisplayPowerController implements AutomaticBrightnessController.Call } } - private void animateScreenStateChange(int target, boolean performScreenOffTransition) { + private void animateScreenStateChange( + int target, @Display.StateReason int reason, boolean performScreenOffTransition) { // If there is already an animation in progress, don't interfere with it. if (mColorFadeEnabled && (mColorFadeOnAnimator.isStarted() || mColorFadeOffAnimator.isStarted())) { @@ -2200,14 +2206,14 @@ final class DisplayPowerController implements AutomaticBrightnessController.Call // display has turned off so it can prepare the appropriate power on animation, but we // don't want to actually transition to the fully off state since that takes // significantly longer to transition from. - setScreenState(Display.STATE_OFF, target != Display.STATE_OFF /*reportOnly*/); + setScreenState(Display.STATE_OFF, reason, target != Display.STATE_OFF /*reportOnly*/); } // If we were in the process of turning off the screen but didn't quite // finish. Then finish up now to prevent a jarring transition back // to screen on if we skipped blocking screen on as usual. if (mPendingScreenOff && target != Display.STATE_OFF) { - setScreenState(Display.STATE_OFF); + setScreenState(Display.STATE_OFF, reason); mPendingScreenOff = false; mPowerState.dismissColorFadeResources(); } @@ -2216,7 +2222,7 @@ final class DisplayPowerController implements AutomaticBrightnessController.Call // Want screen on. The contents of the screen may not yet // be visible if the color fade has not been dismissed because // its last frame of animation is solid black. - if (!setScreenState(Display.STATE_ON)) { + if (!setScreenState(Display.STATE_ON, reason)) { return; // screen on blocked } if (USE_COLOR_FADE_ON_ANIMATION && mColorFadeEnabled && mPowerRequest.isBrightOrDim()) { @@ -2246,7 +2252,7 @@ final class DisplayPowerController implements AutomaticBrightnessController.Call } // Set screen state. - if (!setScreenState(Display.STATE_DOZE)) { + if (!setScreenState(Display.STATE_DOZE, reason)) { return; // screen on blocked } @@ -2265,10 +2271,10 @@ final class DisplayPowerController implements AutomaticBrightnessController.Call // If not already suspending, temporarily set the state to doze until the // screen on is unblocked, then suspend. if (mPowerState.getScreenState() != Display.STATE_DOZE_SUSPEND) { - if (!setScreenState(Display.STATE_DOZE)) { + if (!setScreenState(Display.STATE_DOZE, reason)) { return; // screen on blocked } - setScreenState(Display.STATE_DOZE_SUSPEND); // already on so can't block + setScreenState(Display.STATE_DOZE_SUSPEND, reason); // already on so can't block } // Dismiss the black surface without fanfare. @@ -2286,10 +2292,10 @@ final class DisplayPowerController implements AutomaticBrightnessController.Call // If not already suspending, temporarily set the state to on until the // screen on is unblocked, then suspend. if (mPowerState.getScreenState() != Display.STATE_ON_SUSPEND) { - if (!setScreenState(Display.STATE_ON)) { + if (!setScreenState(Display.STATE_ON, reason)) { return; } - setScreenState(Display.STATE_ON_SUSPEND); + setScreenState(Display.STATE_ON_SUSPEND, reason); } // Dismiss the black surface without fanfare. @@ -2305,7 +2311,7 @@ final class DisplayPowerController implements AutomaticBrightnessController.Call if (mPowerState.getColorFadeLevel() == 0.0f) { // Turn the screen off. // A black surface is already hiding the contents of the screen. - setScreenState(Display.STATE_OFF); + setScreenState(Display.STATE_OFF, reason); mPendingScreenOff = false; mPowerState.dismissColorFadeResources(); } else if (performScreenOffTransition @@ -2667,10 +2673,10 @@ final class DisplayPowerController implements AutomaticBrightnessController.Call } - private void noteScreenState(int screenState) { + private void noteScreenState(int screenState, @Display.StateReason int reason) { // Log screen state change with display id FrameworkStatsLog.write(FrameworkStatsLog.SCREEN_STATE_CHANGED_V2, - screenState, mDisplayStatsId); + screenState, mDisplayStatsId, reason); if (mBatteryStats != null) { try { // TODO(multi-display): make this multi-display diff --git a/services/core/java/com/android/server/display/DisplayPowerControllerInterface.java b/services/core/java/com/android/server/display/DisplayPowerControllerInterface.java index 408d610dea91..d28578ad571f 100644 --- a/services/core/java/com/android/server/display/DisplayPowerControllerInterface.java +++ b/services/core/java/com/android/server/display/DisplayPowerControllerInterface.java @@ -23,6 +23,7 @@ import android.hardware.display.BrightnessConfiguration; import android.hardware.display.BrightnessInfo; import android.hardware.display.DisplayManagerInternal; import android.os.PowerManager; +import android.view.Display; import java.io.PrintWriter; @@ -137,7 +138,13 @@ public interface DisplayPowerControllerInterface { boolean requestPowerState(DisplayManagerInternal.DisplayPowerRequest request, boolean waitForNegativeProximity); - void overrideDozeScreenState(int displayState); + /** + * Overrides the current doze screen state. + * + * @param displayState the new doze display state. + * @param reason the reason behind the new doze display state. + */ + void overrideDozeScreenState(int displayState, @Display.StateReason int reason); void setDisplayOffloadSession(DisplayManagerInternal.DisplayOffloadSession session); diff --git a/services/core/java/com/android/server/display/DisplayPowerState.java b/services/core/java/com/android/server/display/DisplayPowerState.java index 90bad12869f4..e5efebcf1b41 100644 --- a/services/core/java/com/android/server/display/DisplayPowerState.java +++ b/services/core/java/com/android/server/display/DisplayPowerState.java @@ -159,12 +159,13 @@ final class DisplayPowerState { /** * Sets whether the screen is on, off, or dozing. */ - public void setScreenState(int state) { + public void setScreenState(int state, @Display.StateReason int reason) { if (mScreenState != state) { if (DEBUG) { - Slog.w(TAG, "setScreenState: state=" + Display.stateToString(state)); + Slog.w(TAG, + "setScreenState: state=" + Display.stateToString(state) + + "; reason=" + Display.stateReasonToString(reason)); } - mScreenState = state; mScreenReady = false; scheduleScreenUpdate(); diff --git a/services/core/java/com/android/server/display/state/DisplayStateController.java b/services/core/java/com/android/server/display/state/DisplayStateController.java index 5f289349751f..21bb208981c8 100644 --- a/services/core/java/com/android/server/display/state/DisplayStateController.java +++ b/services/core/java/com/android/server/display/state/DisplayStateController.java @@ -18,6 +18,7 @@ package com.android.server.display.state; import android.hardware.display.DisplayManagerInternal; import android.util.IndentingPrintWriter; +import android.util.Pair; import android.view.Display; import com.android.server.display.DisplayPowerProximityStateController; @@ -33,6 +34,7 @@ public class DisplayStateController { private DisplayPowerProximityStateController mDisplayPowerProximityStateController; private boolean mPerformScreenOffTransition = false; private int mDozeStateOverride = Display.STATE_UNKNOWN; + private int mDozeStateOverrideReason = Display.STATE_REASON_UNKNOWN; public DisplayStateController(DisplayPowerProximityStateController displayPowerProximityStateController) { @@ -47,14 +49,19 @@ public class DisplayStateController { * @param isDisplayEnabled A boolean flag representing if the display is enabled * @param isDisplayInTransition A boolean flag representing if the display is undergoing the * transition phase + * @return a {@link Pair} of integers, the first being the updated display state, and the second + * being the reason behind the new display state. */ - public int updateDisplayState(DisplayManagerInternal.DisplayPowerRequest displayPowerRequest, - boolean isDisplayEnabled, boolean isDisplayInTransition) { + public Pair<Integer, Integer> updateDisplayState( + DisplayManagerInternal.DisplayPowerRequest displayPowerRequest, + boolean isDisplayEnabled, + boolean isDisplayInTransition) { mPerformScreenOffTransition = false; // Compute the basic display state using the policy. // We might override this below based on other factors. // Initialise brightness as invalid. int state; + int reason = Display.STATE_REASON_DEFAULT_POLICY; switch (displayPowerRequest.policy) { case DisplayManagerInternal.DisplayPowerRequest.POLICY_OFF: state = Display.STATE_OFF; @@ -63,8 +70,10 @@ public class DisplayStateController { case DisplayManagerInternal.DisplayPowerRequest.POLICY_DOZE: if (mDozeStateOverride != Display.STATE_UNKNOWN) { state = mDozeStateOverride; + reason = mDozeStateOverrideReason; } else if (displayPowerRequest.dozeScreenState != Display.STATE_UNKNOWN) { state = displayPowerRequest.dozeScreenState; + reason = displayPowerRequest.dozeScreenStateReason; } else { state = Display.STATE_DOZE; } @@ -84,11 +93,13 @@ public class DisplayStateController { state = Display.STATE_OFF; } - return state; + return new Pair(state, reason); } - public void overrideDozeScreenState(int displayState) { + /** Overrides the doze screen state with a given reason. */ + public void overrideDozeScreenState(int displayState, @Display.StateReason int reason) { mDozeStateOverride = displayState; + mDozeStateOverrideReason = reason; } /** diff --git a/services/core/java/com/android/server/dreams/DreamManagerService.java b/services/core/java/com/android/server/dreams/DreamManagerService.java index d9970204cf66..42c9e082cf70 100644 --- a/services/core/java/com/android/server/dreams/DreamManagerService.java +++ b/services/core/java/com/android/server/dreams/DreamManagerService.java @@ -512,7 +512,7 @@ public final class DreamManagerService extends SystemService { } private void startDozingInternal(IBinder token, int screenState, - int screenBrightness) { + @Display.StateReason int reason, int screenBrightness) { if (DEBUG) { Slog.d(TAG, "Dream requested to start dozing: " + token + ", screenState=" + screenState @@ -524,7 +524,7 @@ public final class DreamManagerService extends SystemService { mCurrentDream.dozeScreenState = screenState; mCurrentDream.dozeScreenBrightness = screenBrightness; mPowerManagerInternal.setDozeOverrideFromDreamManager( - screenState, screenBrightness); + screenState, reason, screenBrightness); if (!mCurrentDream.isDozing) { mCurrentDream.isDozing = true; mDozeWakeLock.acquire(); @@ -543,7 +543,9 @@ public final class DreamManagerService extends SystemService { mCurrentDream.isDozing = false; mDozeWakeLock.release(); mPowerManagerInternal.setDozeOverrideFromDreamManager( - Display.STATE_UNKNOWN, PowerManager.BRIGHTNESS_DEFAULT); + Display.STATE_UNKNOWN, + Display.STATE_REASON_DREAM_MANAGER, + PowerManager.BRIGHTNESS_DEFAULT); } } } @@ -1046,7 +1048,9 @@ public final class DreamManagerService extends SystemService { } @Override // Binder call - public void startDozing(IBinder token, int screenState, int screenBrightness) { + public void startDozing( + IBinder token, int screenState, @Display.StateReason int reason, + int screenBrightness) { // Requires no permission, called by Dream from an arbitrary process. if (token == null) { throw new IllegalArgumentException("token must not be null"); @@ -1054,7 +1058,7 @@ public final class DreamManagerService extends SystemService { final long ident = Binder.clearCallingIdentity(); try { - startDozingInternal(token, screenState, screenBrightness); + startDozingInternal(token, screenState, reason, screenBrightness); } finally { Binder.restoreCallingIdentity(ident); } diff --git a/services/core/java/com/android/server/power/PowerGroup.java b/services/core/java/com/android/server/power/PowerGroup.java index 6a0fe90a1e65..9a9c4f273b82 100644 --- a/services/core/java/com/android/server/power/PowerGroup.java +++ b/services/core/java/com/android/server/power/PowerGroup.java @@ -431,8 +431,10 @@ public class PowerGroup { } boolean updateLocked(float screenBrightnessOverride, boolean useProximitySensor, - boolean boostScreenBrightness, int dozeScreenState, float dozeScreenBrightness, - boolean overrideDrawWakeLock, PowerSaveState powerSaverState, boolean quiescent, + boolean boostScreenBrightness, int dozeScreenState, + @Display.StateReason int dozeScreenStateReason, + float dozeScreenBrightness, boolean overrideDrawWakeLock, + PowerSaveState powerSaverState, boolean quiescent, boolean dozeAfterScreenOff, boolean bootCompleted, boolean screenBrightnessBoostInProgress, boolean waitForNegativeProximity, boolean brightWhenDozing) { @@ -444,18 +446,28 @@ public class PowerGroup { if (mDisplayPowerRequest.policy == DisplayPowerRequest.POLICY_DOZE) { mDisplayPowerRequest.dozeScreenState = dozeScreenState; + mDisplayPowerRequest.dozeScreenStateReason = dozeScreenStateReason; if ((getWakeLockSummaryLocked() & WAKE_LOCK_DRAW) != 0 && !overrideDrawWakeLock) { if (mDisplayPowerRequest.dozeScreenState == Display.STATE_DOZE_SUSPEND) { mDisplayPowerRequest.dozeScreenState = Display.STATE_DOZE; + mDisplayPowerRequest.dozeScreenStateReason = + Display.STATE_REASON_DRAW_WAKE_LOCK; } if (mDisplayPowerRequest.dozeScreenState == Display.STATE_ON_SUSPEND) { mDisplayPowerRequest.dozeScreenState = Display.STATE_ON; + mDisplayPowerRequest.dozeScreenStateReason = + Display.STATE_REASON_DRAW_WAKE_LOCK; } + } else { + mDisplayPowerRequest.dozeScreenStateReason = + Display.STATE_REASON_DEFAULT_POLICY; } mDisplayPowerRequest.dozeScreenBrightness = dozeScreenBrightness; } else { mDisplayPowerRequest.dozeScreenState = Display.STATE_UNKNOWN; mDisplayPowerRequest.dozeScreenBrightness = PowerManager.BRIGHTNESS_INVALID_FLOAT; + mDisplayPowerRequest.dozeScreenStateReason = + Display.STATE_REASON_DEFAULT_POLICY; } mDisplayPowerRequest.lowPowerMode = powerSaverState.batterySaverEnabled; mDisplayPowerRequest.screenLowPowerBrightnessFactor = powerSaverState.brightnessFactor; diff --git a/services/core/java/com/android/server/power/PowerManagerService.java b/services/core/java/com/android/server/power/PowerManagerService.java index ea9ab30e6293..3dec02ecc9a0 100644 --- a/services/core/java/com/android/server/power/PowerManagerService.java +++ b/services/core/java/com/android/server/power/PowerManagerService.java @@ -640,6 +640,8 @@ public final class PowerManagerService extends SystemService // The screen state to use while dozing. private int mDozeScreenStateOverrideFromDreamManager = Display.STATE_UNKNOWN; + private int mDozeScreenStateOverrideReasonFromDreamManager = Display.STATE_REASON_UNKNOWN; + // The screen brightness to use while dozing. private int mDozeScreenBrightnessOverrideFromDreamManager = PowerManager.BRIGHTNESS_DEFAULT; @@ -3574,6 +3576,7 @@ public final class PowerManagerService extends SystemService boolean ready = powerGroup.updateLocked(screenBrightnessOverride, shouldUseProximitySensorLocked(), shouldBoostScreenBrightness(), mDozeScreenStateOverrideFromDreamManager, + mDozeScreenStateOverrideReasonFromDreamManager, mDozeScreenBrightnessOverrideFromDreamManagerFloat, mDrawWakeLockOverrideFromSidekick, mBatterySaverSupported @@ -4383,11 +4386,12 @@ public final class PowerManagerService extends SystemService } private void setDozeOverrideFromDreamManagerInternal( - int screenState, int screenBrightness) { + int screenState, @Display.StateReason int reason, int screenBrightness) { synchronized (mLock) { if (mDozeScreenStateOverrideFromDreamManager != screenState || mDozeScreenBrightnessOverrideFromDreamManager != screenBrightness) { mDozeScreenStateOverrideFromDreamManager = screenState; + mDozeScreenStateOverrideReasonFromDreamManager = reason; mDozeScreenBrightnessOverrideFromDreamManager = screenBrightness; mDozeScreenBrightnessOverrideFromDreamManagerFloat = BrightnessSynchronizer.brightnessIntToFloat(mDozeScreenBrightnessOverrideFromDreamManager); @@ -6985,7 +6989,8 @@ public final class PowerManagerService extends SystemService } @Override - public void setDozeOverrideFromDreamManager(int screenState, int screenBrightness) { + public void setDozeOverrideFromDreamManager( + int screenState, int reason, int screenBrightness) { switch (screenState) { case Display.STATE_UNKNOWN: case Display.STATE_OFF: @@ -7002,7 +7007,7 @@ public final class PowerManagerService extends SystemService || screenBrightness > PowerManager.BRIGHTNESS_ON) { screenBrightness = PowerManager.BRIGHTNESS_DEFAULT; } - setDozeOverrideFromDreamManagerInternal(screenState, screenBrightness); + setDozeOverrideFromDreamManagerInternal(screenState, reason, screenBrightness); } @Override diff --git a/services/tests/displayservicetests/src/com/android/server/display/DisplayPowerControllerTest.java b/services/tests/displayservicetests/src/com/android/server/display/DisplayPowerControllerTest.java index a28259ded005..db2a1f46a891 100644 --- a/services/tests/displayservicetests/src/com/android/server/display/DisplayPowerControllerTest.java +++ b/services/tests/displayservicetests/src/com/android/server/display/DisplayPowerControllerTest.java @@ -265,7 +265,8 @@ public final class DisplayPowerControllerTest { advanceTime(1); // The display should have been turned off - verify(mHolder.displayPowerState).setScreenState(Display.STATE_OFF); + verify(mHolder.displayPowerState) + .setScreenState(Display.STATE_OFF, Display.STATE_REASON_DEFAULT_POLICY); clearInvocations(mHolder.displayPowerState); when(mHolder.displayPowerState.getScreenState()).thenReturn(Display.STATE_OFF); @@ -276,13 +277,15 @@ public final class DisplayPowerControllerTest { advanceTime(1); // The prox sensor is debounced so the display should not have been turned back on yet - verify(mHolder.displayPowerState, never()).setScreenState(Display.STATE_ON); + verify(mHolder.displayPowerState, never()) + .setScreenState(Display.STATE_ON, Display.STATE_REASON_DEFAULT_POLICY); // Advance time by more than PROXIMITY_SENSOR_NEGATIVE_DEBOUNCE_DELAY advanceTime(1000); // The display should have been turned back on - verify(mHolder.displayPowerState).setScreenState(Display.STATE_ON); + verify(mHolder.displayPowerState) + .setScreenState(Display.STATE_ON, Display.STATE_REASON_DEFAULT_POLICY); } @Test @@ -305,7 +308,8 @@ public final class DisplayPowerControllerTest { advanceTime(1); // The display should have been turned off - verify(mHolder.displayPowerState).setScreenState(Display.STATE_OFF); + verify(mHolder.displayPowerState) + .setScreenState(Display.STATE_OFF, Display.STATE_REASON_DEFAULT_POLICY); when(mHolder.displayPowerState.getScreenState()).thenReturn(Display.STATE_OFF); // The display device changes and we no longer have a prox sensor @@ -318,7 +322,8 @@ public final class DisplayPowerControllerTest { // The display should have been turned back on and the listener should have been // unregistered - verify(mHolder.displayPowerState).setScreenState(Display.STATE_ON); + verify(mHolder.displayPowerState) + .setScreenState(Display.STATE_ON, Display.STATE_REASON_DEFAULT_POLICY); verify(mSensorManagerMock).unregisterListener(listener); } @@ -814,17 +819,17 @@ public final class DisplayPowerControllerTest { DisplayPowerRequest dpr = new DisplayPowerRequest(); mHolder.dpc.requestPowerState(dpr, /* waitForNegativeProximity= */ false); advanceTime(1); // Run updatePowerState - verify(mHolder.displayPowerState).setScreenState(anyInt()); + verify(mHolder.displayPowerState).setScreenState(anyInt(), anyInt()); mHolder = createDisplayPowerController(42, UNIQUE_ID); mHolder.dpc.requestPowerState(dpr, /* waitForNegativeProximity= */ false); advanceTime(1); // Run updatePowerState - verify(mHolder.displayPowerState, never()).setScreenState(anyInt()); + verify(mHolder.displayPowerState, never()).setScreenState(anyInt(), anyInt()); mHolder.dpc.onBootCompleted(); advanceTime(1); // Run updatePowerState - verify(mHolder.displayPowerState).setScreenState(anyInt()); + verify(mHolder.displayPowerState).setScreenState(anyInt(), anyInt()); } @Test @@ -1469,7 +1474,7 @@ public final class DisplayPowerControllerTest { doAnswer(invocation -> { when(mHolder.displayPowerState.getScreenState()).thenReturn(invocation.getArgument(0)); return null; - }).when(mHolder.displayPowerState).setScreenState(anyInt()); + }).when(mHolder.displayPowerState).setScreenState(anyInt(), anyInt()); mHolder.dpc.setDisplayOffloadSession(mDisplayOffloadSession); // start with DOZE. @@ -1479,10 +1484,12 @@ public final class DisplayPowerControllerTest { mHolder.dpc.requestPowerState(dpr, /* waitForNegativeProximity= */ false); advanceTime(1); // Run updatePowerState - mHolder.dpc.overrideDozeScreenState(supportedTargetState); + mHolder.dpc.overrideDozeScreenState( + supportedTargetState, Display.STATE_REASON_DEFAULT_POLICY); advanceTime(1); // Run updatePowerState - verify(mHolder.displayPowerState).setScreenState(supportedTargetState); + verify(mHolder.displayPowerState) + .setScreenState(supportedTargetState, Display.STATE_REASON_DEFAULT_POLICY); } @Test @@ -1495,7 +1502,7 @@ public final class DisplayPowerControllerTest { doAnswer(invocation -> { when(mHolder.displayPowerState.getScreenState()).thenReturn(invocation.getArgument(0)); return null; - }).when(mHolder.displayPowerState).setScreenState(anyInt()); + }).when(mHolder.displayPowerState).setScreenState(anyInt(), anyInt()); mHolder.dpc.setDisplayOffloadSession(mDisplayOffloadSession); // start with DOZE. @@ -1505,10 +1512,12 @@ public final class DisplayPowerControllerTest { mHolder.dpc.requestPowerState(dpr, /* waitForNegativeProximity= */ false); advanceTime(1); // Run updatePowerState - mHolder.dpc.overrideDozeScreenState(unSupportedTargetState); + mHolder.dpc.overrideDozeScreenState( + unSupportedTargetState, Display.STATE_REASON_DEFAULT_POLICY); advanceTime(1); // Run updatePowerState - verify(mHolder.displayPowerState, never()).setScreenState(anyInt()); + verify(mHolder.displayPowerState, never()) + .setScreenState(anyInt(), eq(Display.STATE_REASON_DEFAULT_POLICY)); } @Test @@ -1520,7 +1529,7 @@ public final class DisplayPowerControllerTest { doAnswer(invocation -> { when(mHolder.displayPowerState.getScreenState()).thenReturn(invocation.getArgument(0)); return null; - }).when(mHolder.displayPowerState).setScreenState(anyInt()); + }).when(mHolder.displayPowerState).setScreenState(anyInt(), anyInt()); mHolder.dpc.setDisplayOffloadSession(mDisplayOffloadSession); // start with OFF. @@ -1530,10 +1539,11 @@ public final class DisplayPowerControllerTest { mHolder.dpc.requestPowerState(dpr, /* waitForNegativeProximity= */ false); advanceTime(1); // Run updatePowerState - mHolder.dpc.overrideDozeScreenState(supportedTargetState); + mHolder.dpc.overrideDozeScreenState( + supportedTargetState, Display.STATE_REASON_DEFAULT_POLICY); advanceTime(1); // Run updatePowerState - verify(mHolder.displayPowerState, never()).setScreenState(anyInt()); + verify(mHolder.displayPowerState, never()).setScreenState(anyInt(), anyInt()); } @Test diff --git a/services/tests/displayservicetests/src/com/android/server/display/state/DisplayStateControllerTest.java b/services/tests/displayservicetests/src/com/android/server/display/state/DisplayStateControllerTest.java index f5c6bb2e618b..de53266dc14e 100644 --- a/services/tests/displayservicetests/src/com/android/server/display/state/DisplayStateControllerTest.java +++ b/services/tests/displayservicetests/src/com/android/server/display/state/DisplayStateControllerTest.java @@ -18,11 +18,13 @@ package com.android.server.display.state; import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertTrue; import static org.mockito.Mockito.mock; import static org.mockito.Mockito.verify; import static org.mockito.Mockito.when; import android.hardware.display.DisplayManagerInternal; +import android.util.Pair; import android.view.Display; import androidx.test.filters.SmallTest; @@ -61,9 +63,11 @@ public final class DisplayStateControllerTest { DisplayManagerInternal.DisplayPowerRequest.class); displayPowerRequest.policy = DisplayManagerInternal.DisplayPowerRequest.POLICY_OFF; - int state = mDisplayStateController.updateDisplayState(displayPowerRequest, DISPLAY_ENABLED, - !DISPLAY_IN_TRANSITION); - assertEquals(Display.STATE_OFF, state); + Pair<Integer, Integer> stateAndReason = + mDisplayStateController.updateDisplayState( + displayPowerRequest, DISPLAY_ENABLED, !DISPLAY_IN_TRANSITION); + assertTrue(Display.STATE_OFF == stateAndReason.first); + assertTrue(Display.STATE_REASON_DEFAULT_POLICY == stateAndReason.second); verify(mDisplayPowerProximityStateController).updateProximityState(displayPowerRequest, Display.STATE_OFF); assertEquals(true, mDisplayStateController.shouldPerformScreenOffTransition()); @@ -101,9 +105,11 @@ public final class DisplayStateControllerTest { DisplayManagerInternal.DisplayPowerRequest.class); displayPowerRequest.policy = DisplayManagerInternal.DisplayPowerRequest.POLICY_BRIGHT; - int state = mDisplayStateController.updateDisplayState(displayPowerRequest, - !DISPLAY_ENABLED, !DISPLAY_IN_TRANSITION); - assertEquals(Display.STATE_OFF, state); + Pair<Integer, Integer> stateAndReason = + mDisplayStateController.updateDisplayState( + displayPowerRequest, !DISPLAY_ENABLED, !DISPLAY_IN_TRANSITION); + assertTrue(Display.STATE_OFF == stateAndReason.first); + assertTrue(Display.STATE_REASON_DEFAULT_POLICY == stateAndReason.second); verify(mDisplayPowerProximityStateController).updateProximityState(displayPowerRequest, Display.STATE_ON); assertEquals(false, mDisplayStateController.shouldPerformScreenOffTransition()); @@ -117,9 +123,11 @@ public final class DisplayStateControllerTest { DisplayManagerInternal.DisplayPowerRequest.class); displayPowerRequest.policy = DisplayManagerInternal.DisplayPowerRequest.POLICY_BRIGHT; - int state = mDisplayStateController.updateDisplayState(displayPowerRequest, DISPLAY_ENABLED, - DISPLAY_IN_TRANSITION); - assertEquals(Display.STATE_OFF, state); + Pair<Integer, Integer> stateAndReason = + mDisplayStateController.updateDisplayState( + displayPowerRequest, DISPLAY_ENABLED, DISPLAY_IN_TRANSITION); + assertTrue(Display.STATE_OFF == stateAndReason.first); + assertTrue(Display.STATE_REASON_DEFAULT_POLICY == stateAndReason.second); verify(mDisplayPowerProximityStateController).updateProximityState(displayPowerRequest, Display.STATE_ON); assertEquals(false, mDisplayStateController.shouldPerformScreenOffTransition()); @@ -133,9 +141,11 @@ public final class DisplayStateControllerTest { DisplayManagerInternal.DisplayPowerRequest.class); displayPowerRequest.policy = DisplayManagerInternal.DisplayPowerRequest.POLICY_BRIGHT; - int state = mDisplayStateController.updateDisplayState(displayPowerRequest, DISPLAY_ENABLED, - !DISPLAY_IN_TRANSITION); - assertEquals(Display.STATE_OFF, state); + Pair<Integer, Integer> stateAndReason = + mDisplayStateController.updateDisplayState( + displayPowerRequest, DISPLAY_ENABLED, !DISPLAY_IN_TRANSITION); + assertTrue(Display.STATE_OFF == stateAndReason.first); + assertTrue(Display.STATE_REASON_DEFAULT_POLICY == stateAndReason.second); verify(mDisplayPowerProximityStateController).updateProximityState(displayPowerRequest, Display.STATE_ON); assertEquals(false, mDisplayStateController.shouldPerformScreenOffTransition()); @@ -146,12 +156,15 @@ public final class DisplayStateControllerTest { DisplayManagerInternal.DisplayPowerRequest displayPowerRequest = new DisplayManagerInternal.DisplayPowerRequest(); displayPowerRequest.policy = DisplayManagerInternal.DisplayPowerRequest.POLICY_DOZE; - mDisplayStateController.overrideDozeScreenState(Display.STATE_DOZE_SUSPEND); + mDisplayStateController.overrideDozeScreenState( + Display.STATE_DOZE_SUSPEND, Display.STATE_REASON_OFFLOAD); - int state = mDisplayStateController.updateDisplayState(displayPowerRequest, DISPLAY_ENABLED, - !DISPLAY_IN_TRANSITION); + Pair<Integer, Integer> stateAndReason = + mDisplayStateController.updateDisplayState( + displayPowerRequest, DISPLAY_ENABLED, !DISPLAY_IN_TRANSITION); - assertEquals(state, Display.STATE_DOZE_SUSPEND); + assertTrue(Display.STATE_DOZE_SUSPEND == stateAndReason.first); + assertTrue(Display.STATE_REASON_OFFLOAD == stateAndReason.second); } @Test @@ -159,12 +172,15 @@ public final class DisplayStateControllerTest { DisplayManagerInternal.DisplayPowerRequest displayPowerRequest = new DisplayManagerInternal.DisplayPowerRequest(); displayPowerRequest.policy = DisplayManagerInternal.DisplayPowerRequest.POLICY_OFF; - mDisplayStateController.overrideDozeScreenState(Display.STATE_DOZE_SUSPEND); + mDisplayStateController.overrideDozeScreenState( + Display.STATE_DOZE_SUSPEND, Display.STATE_REASON_DEFAULT_POLICY); - int state = mDisplayStateController.updateDisplayState(displayPowerRequest, DISPLAY_ENABLED, - !DISPLAY_IN_TRANSITION); + Pair<Integer, Integer> stateAndReason = + mDisplayStateController.updateDisplayState( + displayPowerRequest, DISPLAY_ENABLED, !DISPLAY_IN_TRANSITION); - assertEquals(state, Display.STATE_OFF); + assertTrue(Display.STATE_OFF == stateAndReason.first); + assertTrue(Display.STATE_REASON_DEFAULT_POLICY == stateAndReason.second); } private void validDisplayState(int policy, int displayState, boolean isEnabled, @@ -172,9 +188,10 @@ public final class DisplayStateControllerTest { DisplayManagerInternal.DisplayPowerRequest displayPowerRequest = mock( DisplayManagerInternal.DisplayPowerRequest.class); displayPowerRequest.policy = policy; - int state = mDisplayStateController.updateDisplayState(displayPowerRequest, isEnabled, - isInTransition); - assertEquals(displayState, state); + Pair<Integer, Integer> stateAndReason = + mDisplayStateController.updateDisplayState( + displayPowerRequest, isEnabled, isInTransition); + assertTrue(displayState == stateAndReason.first); verify(mDisplayPowerProximityStateController).updateProximityState(displayPowerRequest, displayState); assertEquals(false, mDisplayStateController.shouldPerformScreenOffTransition()); diff --git a/services/tests/powerservicetests/src/com/android/server/power/PowerGroupTest.java b/services/tests/powerservicetests/src/com/android/server/power/PowerGroupTest.java index a776eec4546f..94b8d68395a5 100644 --- a/services/tests/powerservicetests/src/com/android/server/power/PowerGroupTest.java +++ b/services/tests/powerservicetests/src/com/android/server/power/PowerGroupTest.java @@ -260,6 +260,7 @@ public class PowerGroupTest { /* useProximitySensor= */ false, /* boostScreenBrightness= */ false, /* dozeScreenStateOverride= */ Display.STATE_ON, + /* dozeScreenStateReason= */ Display.STATE_REASON_DEFAULT_POLICY, /* dozeScreenBrightness= */ BRIGHTNESS_DOZE, /* overrideDrawWakeLock= */ false, powerSaveState, @@ -299,6 +300,7 @@ public class PowerGroupTest { /* useProximitySensor= */ true, /* boostScreenBrightness= */ true, /* dozeScreenStateOverride= */ Display.STATE_ON, + /* dozeScreenStateReason= */ Display.STATE_REASON_DEFAULT_POLICY, /* dozeScreenBrightness= */ BRIGHTNESS_DOZE, /* overrideDrawWakeLock= */ false, powerSaveState, @@ -337,6 +339,7 @@ public class PowerGroupTest { /* useProximitySensor= */ true, /* boostScreenBrightness= */ true, /* dozeScreenStateOverride= */ Display.STATE_ON, + /* dozeScreenStateReason= */ Display.STATE_REASON_DEFAULT_POLICY, /* dozeScreenBrightness= */ BRIGHTNESS_DOZE, /* overrideDrawWakeLock= */ false, powerSaveState, @@ -374,6 +377,7 @@ public class PowerGroupTest { /* useProximitySensor= */ true, /* boostScreenBrightness= */ true, /* dozeScreenStateOverride= */ Display.STATE_ON, + /* dozeScreenStateReason= */ Display.STATE_REASON_DEFAULT_POLICY, /* dozeScreenBrightness= */ BRIGHTNESS_DOZE, /* overrideDrawWakeLock= */ false, powerSaveState, @@ -411,6 +415,7 @@ public class PowerGroupTest { /* useProximitySensor= */ true, /* boostScreenBrightness= */ true, /* dozeScreenStateOverride= */ Display.STATE_ON, + /* dozeScreenStateReason= */ Display.STATE_REASON_DEFAULT_POLICY, /* dozeScreenBrightness= */ BRIGHTNESS_DOZE, /* overrideDrawWakeLock= */ false, powerSaveState, @@ -449,6 +454,7 @@ public class PowerGroupTest { /* useProximitySensor= */ true, /* boostScreenBrightness= */ true, /* dozeScreenStateOverride= */ Display.STATE_ON, + /* dozeScreenStateReason= */ Display.STATE_REASON_DEFAULT_POLICY, /* dozeScreenBrightness= */ BRIGHTNESS_DOZE, /* overrideDrawWakeLock= */ false, powerSaveState, @@ -485,6 +491,7 @@ public class PowerGroupTest { /* useProximitySensor= */ true, /* boostScreenBrightness= */ true, /* dozeScreenStateOverride= */ Display.STATE_ON, + /* dozeScreenStateReason= */ Display.STATE_REASON_DEFAULT_POLICY, /* dozeScreenBrightness= */ BRIGHTNESS_DOZE, /* overrideDrawWakeLock= */ false, powerSaveState, @@ -522,6 +529,7 @@ public class PowerGroupTest { /* useProximitySensor= */ true, /* boostScreenBrightness= */ true, /* dozeScreenStateOverride= */ Display.STATE_ON, + /* dozeScreenStateReason= */ Display.STATE_REASON_DEFAULT_POLICY, /* dozeScreenBrightness= */ BRIGHTNESS_DOZE, /* overrideDrawWakeLock= */ false, powerSaveState, @@ -558,6 +566,7 @@ public class PowerGroupTest { /* useProximitySensor= */ true, /* boostScreenBrightness= */ true, /* dozeScreenStateOverride= */ Display.STATE_ON, + /* dozeScreenStateReason= */ Display.STATE_REASON_DEFAULT_POLICY, /* dozeScreenBrightness= */ BRIGHTNESS_DOZE, /* overrideDrawWakeLock= */ false, powerSaveState, 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 f86ff14218ba..52f28e95e6b5 100644 --- a/services/tests/powerservicetests/src/com/android/server/power/PowerManagerServiceTest.java +++ b/services/tests/powerservicetests/src/com/android/server/power/PowerManagerServiceTest.java @@ -1293,7 +1293,10 @@ public class PowerManagerServiceTest { // Override the display state by DreamManager and verify is reacquires the blocker. mService.getLocalServiceInstance() - .setDozeOverrideFromDreamManager(Display.STATE_ON, PowerManager.BRIGHTNESS_DEFAULT); + .setDozeOverrideFromDreamManager( + Display.STATE_ON, + Display.STATE_REASON_DEFAULT_POLICY, + PowerManager.BRIGHTNESS_DEFAULT); assertTrue(isAcquired[0]); } |