Pipeline for display state reason logging

This change creates pipeline to support passing screen state reason to
entities that affect the display screen state. In a follow up change,
this reason will be logged in the backend at DisplayPowerController.

Bug: 283014701
Test: manual logs, unit tests
Change-Id: I1455790aa48687d238dc9153a6ea11e77f759821

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]);
     }