Make ScreenUndimDetector only trigger on default display group

When only a non-default display group should be awake, the
ScreenUndimDetector was keeping the default display awake because it
wasn't looking at the display group id for the dim->bright transitions
that it watches.

Bug: 195266040
Test: atest ScreenUndimDetectorTest
Change-Id: I0900b3754913d859694e64ebec89529eeebf7ecd

4 files changed, 109 insertions, 52 deletions

diff --git a/services/core/java/com/android/server/power/Notifier.java b/services/core/java/com/android/server/power/Notifier.java
index 70a804b8135b..73ec2cd66ac1 100644
--- a/services/core/java/com/android/server/power/Notifier.java
+++ b/services/core/java/com/android/server/power/Notifier.java
@@ -545,7 +545,7 @@ public class Notifier {
     /**
      * Called when there has been user activity.
      */
-    public void onUserActivity(int event, int uid) {
+    public void onUserActivity(int displayGroupId, int event, int uid) {
         if (DEBUG) {
             Slog.d(TAG, "onUserActivity: event=" + event + ", uid=" + uid);
         }
@@ -560,7 +560,8 @@ public class Notifier {
             if (!mUserActivityPending) {
                 mUserActivityPending = true;
                 Message msg = mHandler.obtainMessage(MSG_USER_ACTIVITY);
-                msg.arg1 = event;
+                msg.arg1 = displayGroupId;
+                msg.arg2 = event;
                 msg.setAsynchronous(true);
                 mHandler.sendMessage(msg);
             }
@@ -633,14 +634,15 @@ public class Notifier {
     /**
      * Called when the screen policy changes.
      */
-    public void onScreenPolicyUpdate(int newPolicy) {
+    public void onScreenPolicyUpdate(int displayGroupId, int newPolicy) {
         if (DEBUG) {
             Slog.d(TAG, "onScreenPolicyUpdate: newPolicy=" + newPolicy);
         }
 
         synchronized (mLock) {
             Message msg = mHandler.obtainMessage(MSG_SCREEN_POLICY);
-            msg.arg1 = newPolicy;
+            msg.arg1 = displayGroupId;
+            msg.arg2 = newPolicy;
             msg.setAsynchronous(true);
             mHandler.sendMessage(msg);
         }
@@ -675,7 +677,7 @@ public class Notifier {
         mSuspendBlocker.release();
     }
 
-    private void sendUserActivity(int event) {
+    private void sendUserActivity(int displayGroupId, int event) {
         synchronized (mLock) {
             if (!mUserActivityPending) {
                 return;
@@ -686,7 +688,7 @@ public class Notifier {
         tm.notifyUserActivity();
         mPolicy.userActivity();
         mFaceDownDetector.userActivity(event);
-        mScreenUndimDetector.userActivity();
+        mScreenUndimDetector.userActivity(displayGroupId);
     }
 
     void postEnhancedDischargePredictionBroadcast(long delayMs) {
@@ -840,8 +842,8 @@ public class Notifier {
         mSuspendBlocker.release();
     }
 
-    private void screenPolicyChanging(int screenPolicy) {
-        mScreenUndimDetector.recordScreenPolicy(screenPolicy);
+    private void screenPolicyChanging(int displayGroupId, int screenPolicy) {
+        mScreenUndimDetector.recordScreenPolicy(displayGroupId, screenPolicy);
     }
 
     private void lockProfile(@UserIdInt int userId) {
@@ -866,7 +868,7 @@ public class Notifier {
         public void handleMessage(Message msg) {
             switch (msg.what) {
                 case MSG_USER_ACTIVITY:
-                    sendUserActivity(msg.arg1);
+                    sendUserActivity(msg.arg1, msg.arg2);
                     break;
                 case MSG_BROADCAST:
                     sendNextBroadcast();
@@ -885,7 +887,7 @@ public class Notifier {
                     showWiredChargingStarted(msg.arg1);
                     break;
                 case MSG_SCREEN_POLICY:
-                    screenPolicyChanging(msg.arg1);
+                    screenPolicyChanging(msg.arg1, msg.arg2);
                     break;
             }
         }
diff --git a/services/core/java/com/android/server/power/PowerManagerService.java b/services/core/java/com/android/server/power/PowerManagerService.java
index 1455326b12f8..1e7410451021 100644
--- a/services/core/java/com/android/server/power/PowerManagerService.java
+++ b/services/core/java/com/android/server/power/PowerManagerService.java
@@ -1792,7 +1792,7 @@ public final class PowerManagerService extends SystemService
                 mLastInteractivePowerHintTime = eventTime;
             }
 
-            mNotifier.onUserActivity(event, uid);
+            mNotifier.onUserActivity(powerGroup.getGroupId(), event, uid);
             mAttentionDetector.onUserActivity(eventTime, event);
 
             if (mUserInactiveOverrideFromWindowManager) {
@@ -3372,7 +3372,7 @@ public final class PowerManagerService extends SystemService
 
                 final boolean ready = mDisplayManagerInternal.requestPowerState(groupId,
                         displayPowerRequest, mRequestWaitForNegativeProximity);
-                mNotifier.onScreenPolicyUpdate(displayPowerRequest.policy);
+                mNotifier.onScreenPolicyUpdate(groupId, displayPowerRequest.policy);
 
                 if (DEBUG_SPEW) {
                     Slog.d(TAG, "updateDisplayPowerStateLocked: displayReady=" + ready
diff --git a/services/core/java/com/android/server/power/ScreenUndimDetector.java b/services/core/java/com/android/server/power/ScreenUndimDetector.java
index 951bc1f76e6d..c4929c210e2c 100644
--- a/services/core/java/com/android/server/power/ScreenUndimDetector.java
+++ b/services/core/java/com/android/server/power/ScreenUndimDetector.java
@@ -28,6 +28,7 @@ import android.os.PowerManager;
 import android.os.SystemClock;
 import android.provider.DeviceConfig;
 import android.util.Slog;
+import android.view.Display;
 
 import com.android.internal.annotations.VisibleForTesting;
 import com.android.internal.util.FrameworkStatsLog;
@@ -123,8 +124,8 @@ public class ScreenUndimDetector {
      * Launches a message that figures out the screen transitions and detects user undims. Must be
      * called by the parent that is trying to update the screen policy.
      */
-    public void recordScreenPolicy(int newPolicy) {
-        if (newPolicy == mCurrentScreenPolicy) {
+    public void recordScreenPolicy(int displayGroupId, int newPolicy) {
+        if (displayGroupId != Display.DEFAULT_DISPLAY_GROUP || newPolicy == mCurrentScreenPolicy) {
             return;
         }
 
@@ -268,7 +269,10 @@ public class ScreenUndimDetector {
      * The user interacted with the screen after an undim, indicating the phone is in use.
      * We use this event for logging.
      */
-    public void userActivity() {
+    public void userActivity(int displayGroupId) {
+        if (displayGroupId != Display.DEFAULT_DISPLAY) {
+            return;
+        }
         if (mUndimOccurredTime != 1 && mInteractionAfterUndimTime == -1) {
             mInteractionAfterUndimTime = mClock.getCurrentTime();
         }
diff --git a/services/tests/mockingservicestests/src/com/android/server/power/ScreenUndimDetectorTest.java b/services/tests/mockingservicestests/src/com/android/server/power/ScreenUndimDetectorTest.java
index 6a3548178cba..234d70b98580 100644
--- a/services/tests/mockingservicestests/src/com/android/server/power/ScreenUndimDetectorTest.java
+++ b/services/tests/mockingservicestests/src/com/android/server/power/ScreenUndimDetectorTest.java
@@ -22,6 +22,7 @@ import static android.hardware.display.DisplayManagerInternal.DisplayPowerReques
 import static android.hardware.display.DisplayManagerInternal.DisplayPowerRequest.POLICY_OFF;
 import static android.hardware.display.DisplayManagerInternal.DisplayPowerRequest.POLICY_VR;
 import static android.provider.DeviceConfig.NAMESPACE_ATTENTION_MANAGER_SERVICE;
+import static android.view.Display.DEFAULT_DISPLAY_GROUP;
 
 import static com.android.server.power.ScreenUndimDetector.DEFAULT_MAX_DURATION_BETWEEN_UNDIMS_MILLIS;
 import static com.android.server.power.ScreenUndimDetector.KEY_KEEP_SCREEN_ON_ENABLED;
@@ -60,6 +61,7 @@ public class ScreenUndimDetectorTest {
                     POLICY_DIM,
                     POLICY_BRIGHT,
                     POLICY_VR);
+    private static final int OTHER_DISPLAY_GROUP = DEFAULT_DISPLAY_GROUP + 1;
 
     @ClassRule
     public static final TestableContext sContext = new TestableContext(
@@ -106,8 +108,8 @@ public class ScreenUndimDetectorTest {
                 KEY_KEEP_SCREEN_ON_ENABLED, Boolean.FALSE.toString(), false /*makeDefault*/);
 
         setup();
-        mScreenUndimDetector.recordScreenPolicy(POLICY_DIM);
-        mScreenUndimDetector.recordScreenPolicy(POLICY_BRIGHT);
+        mScreenUndimDetector.recordScreenPolicy(DEFAULT_DISPLAY_GROUP, POLICY_DIM);
+        mScreenUndimDetector.recordScreenPolicy(DEFAULT_DISPLAY_GROUP, POLICY_BRIGHT);
 
         assertThat(mScreenUndimDetector.mWakeLock.isHeld()).isFalse();
     }
@@ -116,8 +118,8 @@ public class ScreenUndimDetectorTest {
     public void recordScreenPolicy_samePolicy_noop() {
         for (int policy : ALL_POLICIES) {
             setup();
-            mScreenUndimDetector.recordScreenPolicy(policy);
-            mScreenUndimDetector.recordScreenPolicy(policy);
+            mScreenUndimDetector.recordScreenPolicy(DEFAULT_DISPLAY_GROUP, policy);
+            mScreenUndimDetector.recordScreenPolicy(DEFAULT_DISPLAY_GROUP, policy);
 
             assertThat(mScreenUndimDetector.mWakeLock.isHeld()).isFalse();
         }
@@ -125,13 +127,24 @@ public class ScreenUndimDetectorTest {
 
     @Test
     public void recordScreenPolicy_dimToBright_extends() {
-        mScreenUndimDetector.recordScreenPolicy(POLICY_DIM);
-        mScreenUndimDetector.recordScreenPolicy(POLICY_BRIGHT);
+        mScreenUndimDetector.recordScreenPolicy(DEFAULT_DISPLAY_GROUP, POLICY_DIM);
+        mScreenUndimDetector.recordScreenPolicy(DEFAULT_DISPLAY_GROUP, POLICY_BRIGHT);
 
         assertThat(mScreenUndimDetector.mWakeLock.isHeld()).isTrue();
     }
 
     @Test
+    public void recordScreenPolicy_dimToBright_ignoresOtherDisplayGroup() {
+        mScreenUndimDetector.recordScreenPolicy(DEFAULT_DISPLAY_GROUP, POLICY_DIM);
+
+        mScreenUndimDetector.recordScreenPolicy(OTHER_DISPLAY_GROUP, POLICY_BRIGHT);
+        assertThat(mScreenUndimDetector.mWakeLock.isHeld()).isFalse();
+
+        mScreenUndimDetector.recordScreenPolicy(DEFAULT_DISPLAY_GROUP, POLICY_BRIGHT);
+        assertThat(mScreenUndimDetector.mWakeLock.isHeld()).isTrue();
+    }
+
+    @Test
     public void recordScreenPolicy_otherTransitions_doesNotExtend() {
         for (int from : ALL_POLICIES) {
             for (int to : ALL_POLICIES) {
@@ -139,8 +152,8 @@ public class ScreenUndimDetectorTest {
                     continue;
                 }
                 setup();
-                mScreenUndimDetector.recordScreenPolicy(from);
-                mScreenUndimDetector.recordScreenPolicy(to);
+                mScreenUndimDetector.recordScreenPolicy(DEFAULT_DISPLAY_GROUP, from);
+                mScreenUndimDetector.recordScreenPolicy(DEFAULT_DISPLAY_GROUP, to);
 
                 assertThat(mScreenUndimDetector.mWakeLock.isHeld()).isFalse();
                 assertThat(mScreenUndimDetector.mUndimCounter).isEqualTo(0);
@@ -155,14 +168,35 @@ public class ScreenUndimDetectorTest {
                 Integer.toString(2), false /*makeDefault*/);
         mScreenUndimDetector.readValuesFromDeviceConfig();
 
-        mScreenUndimDetector.recordScreenPolicy(POLICY_DIM);
-        mScreenUndimDetector.recordScreenPolicy(POLICY_BRIGHT);
+        mScreenUndimDetector.recordScreenPolicy(DEFAULT_DISPLAY_GROUP, POLICY_DIM);
+        mScreenUndimDetector.recordScreenPolicy(DEFAULT_DISPLAY_GROUP, POLICY_BRIGHT);
+
+        assertThat(mScreenUndimDetector.mWakeLock.isHeld()).isFalse();
+
+        mScreenUndimDetector.recordScreenPolicy(DEFAULT_DISPLAY_GROUP, POLICY_DIM);
+        mScreenUndimDetector.recordScreenPolicy(DEFAULT_DISPLAY_GROUP, POLICY_BRIGHT);
+
+        assertThat(mScreenUndimDetector.mWakeLock.isHeld()).isTrue();
+    }
+
+    @Test
+    public void recordScreenPolicy_dimToBright_twoUndimsNeeded_otherDisplayDoesNotExtend() {
+        DeviceConfig.setProperty(NAMESPACE_ATTENTION_MANAGER_SERVICE,
+                KEY_UNDIMS_REQUIRED,
+                Integer.toString(2), false /*makeDefault*/);
+        mScreenUndimDetector.readValuesFromDeviceConfig();
+
+        mScreenUndimDetector.recordScreenPolicy(DEFAULT_DISPLAY_GROUP, POLICY_DIM);
+        mScreenUndimDetector.recordScreenPolicy(DEFAULT_DISPLAY_GROUP, POLICY_BRIGHT);
 
         assertThat(mScreenUndimDetector.mWakeLock.isHeld()).isFalse();
 
-        mScreenUndimDetector.recordScreenPolicy(POLICY_DIM);
-        mScreenUndimDetector.recordScreenPolicy(POLICY_BRIGHT);
+        mScreenUndimDetector.recordScreenPolicy(DEFAULT_DISPLAY_GROUP, POLICY_DIM);
+        mScreenUndimDetector.recordScreenPolicy(OTHER_DISPLAY_GROUP, POLICY_BRIGHT);
+
+        assertThat(mScreenUndimDetector.mWakeLock.isHeld()).isFalse();
 
+        mScreenUndimDetector.recordScreenPolicy(DEFAULT_DISPLAY_GROUP, POLICY_BRIGHT);
         assertThat(mScreenUndimDetector.mWakeLock.isHeld()).isTrue();
     }
 
@@ -173,10 +207,10 @@ public class ScreenUndimDetectorTest {
                 Integer.toString(2), false /*makeDefault*/);
         mScreenUndimDetector.readValuesFromDeviceConfig();
 
-        mScreenUndimDetector.recordScreenPolicy(POLICY_DIM);
-        mScreenUndimDetector.recordScreenPolicy(POLICY_BRIGHT);
-        mScreenUndimDetector.recordScreenPolicy(POLICY_DIM);
-        mScreenUndimDetector.recordScreenPolicy(POLICY_OFF);
+        mScreenUndimDetector.recordScreenPolicy(DEFAULT_DISPLAY_GROUP, POLICY_DIM);
+        mScreenUndimDetector.recordScreenPolicy(DEFAULT_DISPLAY_GROUP, POLICY_BRIGHT);
+        mScreenUndimDetector.recordScreenPolicy(DEFAULT_DISPLAY_GROUP, POLICY_DIM);
+        mScreenUndimDetector.recordScreenPolicy(DEFAULT_DISPLAY_GROUP, POLICY_OFF);
 
         assertThat(mScreenUndimDetector.mWakeLock.isHeld()).isFalse();
         assertThat(mScreenUndimDetector.mUndimCounter).isEqualTo(0);
@@ -189,10 +223,27 @@ public class ScreenUndimDetectorTest {
                 Integer.toString(2), false /*makeDefault*/);
         mScreenUndimDetector.readValuesFromDeviceConfig();
 
-        mScreenUndimDetector.recordScreenPolicy(POLICY_BRIGHT);
-        mScreenUndimDetector.recordScreenPolicy(POLICY_DIM);
-        mScreenUndimDetector.recordScreenPolicy(POLICY_BRIGHT);
-        mScreenUndimDetector.recordScreenPolicy(POLICY_OFF);
+        mScreenUndimDetector.recordScreenPolicy(DEFAULT_DISPLAY_GROUP, POLICY_BRIGHT);
+        mScreenUndimDetector.recordScreenPolicy(DEFAULT_DISPLAY_GROUP, POLICY_DIM);
+        mScreenUndimDetector.recordScreenPolicy(DEFAULT_DISPLAY_GROUP, POLICY_BRIGHT);
+        mScreenUndimDetector.recordScreenPolicy(DEFAULT_DISPLAY_GROUP, POLICY_OFF);
+
+        assertThat(mScreenUndimDetector.mWakeLock.isHeld()).isFalse();
+        assertThat(mScreenUndimDetector.mUndimCounter).isEqualTo(0);
+    }
+
+    @Test
+    public void recordScreenPolicy_undimToOff_otherDisplayDoesNotResetCounter() {
+        DeviceConfig.setProperty(NAMESPACE_ATTENTION_MANAGER_SERVICE,
+                KEY_UNDIMS_REQUIRED,
+                Integer.toString(2), false /*makeDefault*/);
+        mScreenUndimDetector.readValuesFromDeviceConfig();
+
+        mScreenUndimDetector.recordScreenPolicy(DEFAULT_DISPLAY_GROUP, POLICY_BRIGHT);
+        mScreenUndimDetector.recordScreenPolicy(DEFAULT_DISPLAY_GROUP, POLICY_DIM);
+
+        mScreenUndimDetector.recordScreenPolicy(DEFAULT_DISPLAY_GROUP, POLICY_BRIGHT);
+        mScreenUndimDetector.recordScreenPolicy(DEFAULT_DISPLAY_GROUP, POLICY_OFF);
 
         assertThat(mScreenUndimDetector.mWakeLock.isHeld()).isFalse();
         assertThat(mScreenUndimDetector.mUndimCounter).isEqualTo(0);
@@ -206,15 +257,15 @@ public class ScreenUndimDetectorTest {
         mScreenUndimDetector.readValuesFromDeviceConfig();
 
         // undim
-        mScreenUndimDetector.recordScreenPolicy(POLICY_BRIGHT);
-        mScreenUndimDetector.recordScreenPolicy(POLICY_DIM);
-        mScreenUndimDetector.recordScreenPolicy(POLICY_BRIGHT);
+        mScreenUndimDetector.recordScreenPolicy(DEFAULT_DISPLAY_GROUP, POLICY_BRIGHT);
+        mScreenUndimDetector.recordScreenPolicy(DEFAULT_DISPLAY_GROUP, POLICY_DIM);
+        mScreenUndimDetector.recordScreenPolicy(DEFAULT_DISPLAY_GROUP, POLICY_BRIGHT);
         // off
-        mScreenUndimDetector.recordScreenPolicy(POLICY_OFF);
+        mScreenUndimDetector.recordScreenPolicy(DEFAULT_DISPLAY_GROUP, POLICY_OFF);
         // second undim
-        mScreenUndimDetector.recordScreenPolicy(POLICY_BRIGHT);
-        mScreenUndimDetector.recordScreenPolicy(POLICY_DIM);
-        mScreenUndimDetector.recordScreenPolicy(POLICY_BRIGHT);
+        mScreenUndimDetector.recordScreenPolicy(DEFAULT_DISPLAY_GROUP, POLICY_BRIGHT);
+        mScreenUndimDetector.recordScreenPolicy(DEFAULT_DISPLAY_GROUP, POLICY_DIM);
+        mScreenUndimDetector.recordScreenPolicy(DEFAULT_DISPLAY_GROUP, POLICY_BRIGHT);
 
         assertThat(mScreenUndimDetector.mWakeLock.isHeld()).isFalse();
         assertThat(mScreenUndimDetector.mUndimCounter).isEqualTo(1);
@@ -227,12 +278,12 @@ public class ScreenUndimDetectorTest {
                 Integer.toString(2), false /*makeDefault*/);
         mScreenUndimDetector.readValuesFromDeviceConfig();
 
-        mScreenUndimDetector.recordScreenPolicy(POLICY_DIM);
-        mScreenUndimDetector.recordScreenPolicy(POLICY_BRIGHT);
+        mScreenUndimDetector.recordScreenPolicy(DEFAULT_DISPLAY_GROUP, POLICY_DIM);
+        mScreenUndimDetector.recordScreenPolicy(DEFAULT_DISPLAY_GROUP, POLICY_BRIGHT);
 
         mClock.advanceTime(DEFAULT_MAX_DURATION_BETWEEN_UNDIMS_MILLIS + 5);
-        mScreenUndimDetector.recordScreenPolicy(POLICY_DIM);
-        mScreenUndimDetector.recordScreenPolicy(POLICY_BRIGHT);
+        mScreenUndimDetector.recordScreenPolicy(DEFAULT_DISPLAY_GROUP, POLICY_DIM);
+        mScreenUndimDetector.recordScreenPolicy(DEFAULT_DISPLAY_GROUP, POLICY_BRIGHT);
 
         assertThat(mScreenUndimDetector.mWakeLock.isHeld()).isFalse();
         assertThat(mScreenUndimDetector.mUndimCounter).isEqualTo(1);
@@ -246,8 +297,8 @@ public class ScreenUndimDetectorTest {
             mScreenUndimDetector.mUndimCounterStartedMillis = 123;
             mScreenUndimDetector.mWakeLock.acquire();
 
-            mScreenUndimDetector.recordScreenPolicy(POLICY_DIM);
-            mScreenUndimDetector.recordScreenPolicy(to);
+            mScreenUndimDetector.recordScreenPolicy(DEFAULT_DISPLAY_GROUP, POLICY_DIM);
+            mScreenUndimDetector.recordScreenPolicy(DEFAULT_DISPLAY_GROUP, to);
 
             assertThat(mScreenUndimDetector.mUndimCounter).isEqualTo(0);
             assertThat(mScreenUndimDetector.mUndimCounterStartedMillis).isEqualTo(0);
@@ -264,8 +315,8 @@ public class ScreenUndimDetectorTest {
             mScreenUndimDetector.mUndimCounterStartedMillis = 123;
             mScreenUndimDetector.mWakeLock.acquire();
 
-            mScreenUndimDetector.recordScreenPolicy(POLICY_BRIGHT);
-            mScreenUndimDetector.recordScreenPolicy(to);
+            mScreenUndimDetector.recordScreenPolicy(DEFAULT_DISPLAY_GROUP, POLICY_BRIGHT);
+            mScreenUndimDetector.recordScreenPolicy(DEFAULT_DISPLAY_GROUP, to);
 
             assertThat(mScreenUndimDetector.mUndimCounter).isEqualTo(0);
             assertThat(mScreenUndimDetector.mUndimCounterStartedMillis).isEqualTo(0);
@@ -294,8 +345,8 @@ public class ScreenUndimDetectorTest {
                 mScreenUndimDetector.mUndimCounterStartedMillis =
                         SystemClock.currentThreadTimeMillis();
 
-                mScreenUndimDetector.recordScreenPolicy(from);
-                mScreenUndimDetector.recordScreenPolicy(to);
+                mScreenUndimDetector.recordScreenPolicy(DEFAULT_DISPLAY_GROUP, from);
+                mScreenUndimDetector.recordScreenPolicy(DEFAULT_DISPLAY_GROUP, to);
 
                 assertThat(mScreenUndimDetector.mUndimCounter).isNotEqualTo(0);
                 assertThat(mScreenUndimDetector.mUndimCounterStartedMillis).isNotEqualTo(0);