1 /*
2  * Copyright (C) 2022 The Android Open Source Project
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  *      http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16 
17 package com.android.server.power;
18 
19 
20 import static android.hardware.display.DisplayManagerInternal.DisplayPowerRequest.POLICY_BRIGHT;
21 import static android.hardware.display.DisplayManagerInternal.DisplayPowerRequest.POLICY_DIM;
22 import static android.hardware.display.DisplayManagerInternal.DisplayPowerRequest.POLICY_DOZE;
23 import static android.hardware.display.DisplayManagerInternal.DisplayPowerRequest.POLICY_OFF;
24 import static android.os.PowerManager.GO_TO_SLEEP_REASON_APPLICATION;
25 import static android.os.PowerManager.GO_TO_SLEEP_REASON_DEVICE_ADMIN;
26 import static android.os.PowerManager.GO_TO_SLEEP_REASON_DEVICE_FOLD;
27 import static android.os.PowerManager.GO_TO_SLEEP_REASON_TIMEOUT;
28 import static android.os.PowerManager.WAKE_REASON_GESTURE;
29 import static android.os.PowerManager.WAKE_REASON_PLUGGED_IN;
30 import static android.os.PowerManagerInternal.WAKEFULNESS_ASLEEP;
31 import static android.os.PowerManagerInternal.WAKEFULNESS_AWAKE;
32 import static android.os.PowerManagerInternal.WAKEFULNESS_DOZING;
33 import static android.os.PowerManagerInternal.WAKEFULNESS_DREAMING;
34 
35 import static com.android.server.power.PowerManagerService.USER_ACTIVITY_SCREEN_BRIGHT;
36 import static com.android.server.power.PowerManagerService.WAKE_LOCK_DOZE;
37 import static com.android.server.power.PowerManagerService.WAKE_LOCK_SCREEN_BRIGHT;
38 
39 import static com.google.common.truth.Truth.assertThat;
40 
41 import static org.mockito.ArgumentMatchers.any;
42 import static org.mockito.ArgumentMatchers.anyInt;
43 import static org.mockito.ArgumentMatchers.eq;
44 import static org.mockito.ArgumentMatchers.isNull;
45 import static org.mockito.Mockito.never;
46 import static org.mockito.Mockito.verify;
47 
48 import android.hardware.display.DisplayManagerInternal;
49 import android.os.PowerManager;
50 import android.os.PowerSaveState;
51 import android.view.Display;
52 
53 import androidx.test.platform.app.InstrumentationRegistry;
54 
55 import com.android.internal.util.LatencyTracker;
56 
57 import org.junit.Before;
58 import org.junit.Test;
59 import org.mockito.Mock;
60 import org.mockito.MockitoAnnotations;
61 
62 /**
63  * Tests for {@link com.android.server.power.PowerGroup}.
64  *
65  * Build/Install/Run:
66  *  atest FrameworksServicesTests:PowerManagerServiceTest
67  */
68 public class PowerGroupTest {
69 
70     private static final int GROUP_ID = 0;
71     private static final int UID = 11;
72     private static final long TIMESTAMP_CREATE = 1;
73     private static final long TIMESTAMP1 = 999;
74     private static final long TIMESTAMP2 = TIMESTAMP1 + 10;
75     private static final long TIMESTAMP3 = TIMESTAMP2 + 10;
76 
77     private static final float PRECISION = 0.001f;
78 
79     private static final float BRIGHTNESS = 0.99f;
80     private static final float BRIGHTNESS_DOZE = 0.5f;
81 
82 
83 
84     private PowerGroup mPowerGroup;
85     @Mock private PowerGroup.PowerGroupListener mWakefulnessCallbackMock;
86     @Mock private Notifier mNotifier;
87     @Mock private DisplayManagerInternal mDisplayManagerInternal;
88 
89 
90     @Before
setUp()91     public void setUp() {
92         MockitoAnnotations.initMocks(this);
93         mPowerGroup = new PowerGroup(GROUP_ID, mWakefulnessCallbackMock, mNotifier,
94                 mDisplayManagerInternal, WAKEFULNESS_AWAKE, /* ready= */ true,
95                 /* supportsSandman= */ true, TIMESTAMP_CREATE);
96     }
97 
98     @Test
testWakePowerGroup()99     public void testWakePowerGroup() {
100         mPowerGroup.sleepLocked(TIMESTAMP1, UID, GO_TO_SLEEP_REASON_APPLICATION);
101         verify(mWakefulnessCallbackMock).onWakefulnessChangedLocked(eq(GROUP_ID),
102                 eq(WAKEFULNESS_ASLEEP), eq(TIMESTAMP1), eq(GO_TO_SLEEP_REASON_APPLICATION),
103                 eq(UID), /* opUid= */anyInt(), /* opPackageName= */ isNull(), /* details= */
104                 isNull());
105         String details = "wake PowerGroup1";
106         LatencyTracker latencyTracker = LatencyTracker.getInstance(
107                 InstrumentationRegistry.getInstrumentation().getContext());
108         mPowerGroup.wakeUpLocked(TIMESTAMP2, WAKE_REASON_PLUGGED_IN, details, UID,
109                 /* opPackageName= */ null, /* opUid= */ 0, latencyTracker);
110         verify(mWakefulnessCallbackMock).onWakefulnessChangedLocked(eq(GROUP_ID),
111                 eq(WAKEFULNESS_AWAKE), eq(TIMESTAMP2), eq(WAKE_REASON_PLUGGED_IN), eq(UID),
112                 /* opUid= */ anyInt(), /* opPackageName= */ isNull(), eq(details));
113     }
114 
115     @Test
testDreamPowerGroup()116     public void testDreamPowerGroup() {
117         assertThat(mPowerGroup.getWakefulnessLocked()).isEqualTo(WAKEFULNESS_AWAKE);
118         mPowerGroup.dreamLocked(TIMESTAMP1, UID, /* allowWake= */ false);
119         assertThat(mPowerGroup.getWakefulnessLocked()).isEqualTo(WAKEFULNESS_DREAMING);
120         assertThat(mPowerGroup.isSandmanSummonedLocked()).isTrue();
121         verify(mWakefulnessCallbackMock).onWakefulnessChangedLocked(eq(GROUP_ID),
122                 eq(WAKEFULNESS_DREAMING), eq(TIMESTAMP1), eq(GO_TO_SLEEP_REASON_APPLICATION),
123                 eq(UID), /* opUid= */anyInt(), /* opPackageName= */ isNull(), /* details= */
124                 isNull());
125     }
126 
127     @Test
testDozePowerGroup()128     public void testDozePowerGroup() {
129         assertThat(mPowerGroup.getWakefulnessLocked()).isEqualTo(WAKEFULNESS_AWAKE);
130         mPowerGroup.dozeLocked(TIMESTAMP1, UID, GO_TO_SLEEP_REASON_TIMEOUT);
131         assertThat(mPowerGroup.getWakefulnessLocked()).isEqualTo(WAKEFULNESS_DOZING);
132         assertThat(mPowerGroup.isSandmanSummonedLocked()).isTrue();
133         verify(mWakefulnessCallbackMock).onWakefulnessChangedLocked(eq(GROUP_ID),
134                 eq(WAKEFULNESS_DOZING), eq(TIMESTAMP1), eq(GO_TO_SLEEP_REASON_TIMEOUT),
135                 eq(UID), /* opUid= */ anyInt(), /* opPackageName= */ isNull(),
136                 /* details= */ isNull());
137     }
138 
139     @Test
testDozePowerGroupWhenNonInteractiveHasNoEffect()140     public void testDozePowerGroupWhenNonInteractiveHasNoEffect() {
141         mPowerGroup.sleepLocked(TIMESTAMP1, UID, GO_TO_SLEEP_REASON_TIMEOUT);
142         verify(mWakefulnessCallbackMock).onWakefulnessChangedLocked(eq(GROUP_ID),
143                 eq(WAKEFULNESS_ASLEEP), eq(TIMESTAMP1), eq(GO_TO_SLEEP_REASON_TIMEOUT),
144                 eq(UID), /* opUid= */ anyInt(), /* opPackageName= */ isNull(),
145                 /* details= */ isNull());
146         assertThat(mPowerGroup.getWakefulnessLocked()).isEqualTo(WAKEFULNESS_ASLEEP);
147         assertThat(mPowerGroup.dozeLocked(TIMESTAMP2, UID, GO_TO_SLEEP_REASON_TIMEOUT)).isFalse();
148         assertThat(mPowerGroup.getWakefulnessLocked()).isEqualTo(WAKEFULNESS_ASLEEP);
149         verify(mWakefulnessCallbackMock, never()).onWakefulnessChangedLocked(
150                 eq(GROUP_ID), eq(WAKEFULNESS_DOZING), eq(TIMESTAMP2), /* reason= */ anyInt(),
151                 eq(UID), /* opUid= */ anyInt(), /* opPackageName= */ any(), /* details= */ any());
152     }
153 
154     @Test
testSleepPowerGroup()155     public void testSleepPowerGroup() {
156         assertThat(mPowerGroup.getWakefulnessLocked()).isEqualTo(WAKEFULNESS_AWAKE);
157         mPowerGroup.sleepLocked(TIMESTAMP1, UID, GO_TO_SLEEP_REASON_DEVICE_FOLD);
158         assertThat(mPowerGroup.isSandmanSummonedLocked()).isTrue();
159         assertThat(mPowerGroup.getWakefulnessLocked()).isEqualTo(WAKEFULNESS_ASLEEP);
160         verify(mWakefulnessCallbackMock).onWakefulnessChangedLocked(eq(GROUP_ID),
161                 eq(WAKEFULNESS_ASLEEP), eq(TIMESTAMP1), eq(GO_TO_SLEEP_REASON_DEVICE_FOLD),
162                 eq(UID), /* opUid= */ anyInt(), /* opPackageName= */ isNull(),
163                 /* details= */ isNull());
164     }
165 
166     @Test
testDreamPowerGroupWhenNotAwakeHasNoEffect()167     public void testDreamPowerGroupWhenNotAwakeHasNoEffect() {
168         mPowerGroup.dozeLocked(TIMESTAMP1, UID, GO_TO_SLEEP_REASON_TIMEOUT);
169         verify(mWakefulnessCallbackMock).onWakefulnessChangedLocked(eq(GROUP_ID),
170                 eq(WAKEFULNESS_DOZING), eq(TIMESTAMP1), eq(GO_TO_SLEEP_REASON_TIMEOUT),
171                 eq(UID), /* opUid= */ anyInt(), /* opPackageName= */ isNull(),
172                 /* details= */ isNull());
173         assertThat(mPowerGroup.getWakefulnessLocked()).isEqualTo(WAKEFULNESS_DOZING);
174         assertThat(mPowerGroup.dreamLocked(TIMESTAMP2, UID, /* allowWake= */ false)).isFalse();
175         assertThat(mPowerGroup.getWakefulnessLocked()).isEqualTo(WAKEFULNESS_DOZING);
176         verify(mWakefulnessCallbackMock, never()).onWakefulnessChangedLocked(
177                 eq(GROUP_ID), /* wakefulness= */ eq(WAKEFULNESS_DREAMING), eq(TIMESTAMP2),
178                 /* reason= */ anyInt(), eq(UID), /* opUid= */ anyInt(), /* opPackageName= */ any(),
179                 /* details= */ any());
180     }
181 
182     @Test
testDreamPowerGroupWhenNotAwakeShouldWake()183     public void testDreamPowerGroupWhenNotAwakeShouldWake() {
184         mPowerGroup.dozeLocked(TIMESTAMP1, UID, GO_TO_SLEEP_REASON_TIMEOUT);
185         verify(mWakefulnessCallbackMock).onWakefulnessChangedLocked(eq(GROUP_ID),
186                 eq(WAKEFULNESS_DOZING), eq(TIMESTAMP1), eq(GO_TO_SLEEP_REASON_TIMEOUT),
187                 eq(UID), /* opUid= */ anyInt(), /* opPackageName= */ isNull(),
188                 /* details= */ isNull());
189         assertThat(mPowerGroup.getWakefulnessLocked()).isEqualTo(WAKEFULNESS_DOZING);
190         assertThat(mPowerGroup.dreamLocked(TIMESTAMP2, UID, /* allowWake= */ true)).isTrue();
191         assertThat(mPowerGroup.getWakefulnessLocked()).isEqualTo(WAKEFULNESS_DREAMING);
192         verify(mWakefulnessCallbackMock).onWakefulnessChangedLocked(
193                 eq(GROUP_ID), /* wakefulness= */ eq(WAKEFULNESS_DREAMING), eq(TIMESTAMP2),
194                 /* reason= */ anyInt(), eq(UID), /* opUid= */ anyInt(), /* opPackageName= */ any(),
195                 /* details= */ any());
196     }
197 
198     @Test
testLastWakeAndSleepTimeIsUpdated()199     public void testLastWakeAndSleepTimeIsUpdated() {
200         assertThat(mPowerGroup.getLastWakeTimeLocked()).isEqualTo(TIMESTAMP_CREATE);
201         assertThat(mPowerGroup.getLastSleepTimeLocked()).isEqualTo(TIMESTAMP_CREATE);
202 
203         // Verify that the transition to WAKEFULNESS_DOZING updates the last sleep time
204         String details = "PowerGroup1 Timeout";
205         mPowerGroup.setWakefulnessLocked(WAKEFULNESS_DOZING, TIMESTAMP1, UID,
206                 GO_TO_SLEEP_REASON_TIMEOUT, /* opUid= */ 0, /* opPackageName= */ null, details);
207         assertThat(mPowerGroup.getLastSleepTimeLocked()).isEqualTo(TIMESTAMP1);
208         assertThat(mPowerGroup.getLastWakeTimeLocked()).isEqualTo(TIMESTAMP_CREATE);
209         assertThat(mPowerGroup.getWakefulnessLocked()).isEqualTo(WAKEFULNESS_DOZING);
210         verify(mWakefulnessCallbackMock).onWakefulnessChangedLocked(eq(GROUP_ID),
211                 eq(WAKEFULNESS_DOZING), eq(TIMESTAMP1), eq(GO_TO_SLEEP_REASON_TIMEOUT),
212                 eq(UID), /* opUid= */anyInt(), /* opPackageName= */ isNull(), eq(details));
213 
214         // Verify that the transition to WAKEFULNESS_ASLEEP after dozing does not update the last
215         // wake or sleep time
216         mPowerGroup.setWakefulnessLocked(WAKEFULNESS_ASLEEP, TIMESTAMP2, UID,
217                 GO_TO_SLEEP_REASON_DEVICE_ADMIN, /* opUid= */ 0, /* opPackageName= */ null,
218                 details);
219         assertThat(mPowerGroup.getLastSleepTimeLocked()).isEqualTo(TIMESTAMP1);
220         assertThat(mPowerGroup.getLastWakeTimeLocked()).isEqualTo(TIMESTAMP_CREATE);
221         assertThat(mPowerGroup.getWakefulnessLocked()).isEqualTo(WAKEFULNESS_ASLEEP);
222         verify(mWakefulnessCallbackMock).onWakefulnessChangedLocked(eq(GROUP_ID),
223                 eq(WAKEFULNESS_ASLEEP), eq(TIMESTAMP2), eq(GO_TO_SLEEP_REASON_DEVICE_ADMIN),
224                 eq(UID), /* opUid= */anyInt(), /* opPackageName= */ isNull(), eq(details));
225 
226         // Verify that waking up the power group only updates the last wake time
227         details = "PowerGroup1 Gesture";
228         mPowerGroup.setWakefulnessLocked(WAKEFULNESS_AWAKE, TIMESTAMP2, UID,
229                 WAKE_REASON_GESTURE, /* opUid= */ 0, /* opPackageName= */ null, details);
230         assertThat(mPowerGroup.getLastWakeTimeLocked()).isEqualTo(TIMESTAMP2);
231         assertThat(mPowerGroup.getLastSleepTimeLocked()).isEqualTo(TIMESTAMP1);
232         assertThat(mPowerGroup.getWakefulnessLocked()).isEqualTo(WAKEFULNESS_AWAKE);
233         verify(mWakefulnessCallbackMock).onWakefulnessChangedLocked(eq(GROUP_ID),
234                 eq(WAKEFULNESS_AWAKE), eq(TIMESTAMP2), eq(WAKE_REASON_GESTURE),
235                 eq(UID), /* opUid= */ anyInt(), /* opPackageName= */ isNull(), eq(details));
236 
237         // Verify that a transition to WAKEFULNESS_ASLEEP from an interactive state updates the last
238         // sleep time
239         mPowerGroup.setWakefulnessLocked(WAKEFULNESS_ASLEEP, TIMESTAMP3, UID,
240                 GO_TO_SLEEP_REASON_DEVICE_ADMIN, /* opUid= */ 0, /* opPackageName= */ null,
241                 details);
242         assertThat(mPowerGroup.getLastSleepTimeLocked()).isEqualTo(TIMESTAMP3);
243         assertThat(mPowerGroup.getLastWakeTimeLocked()).isEqualTo(TIMESTAMP2);
244         assertThat(mPowerGroup.getWakefulnessLocked()).isEqualTo(WAKEFULNESS_ASLEEP);
245         verify(mWakefulnessCallbackMock).onWakefulnessChangedLocked(eq(GROUP_ID),
246                 eq(WAKEFULNESS_ASLEEP), eq(TIMESTAMP3), eq(GO_TO_SLEEP_REASON_DEVICE_ADMIN),
247                 eq(UID), /* opUid= */anyInt(), /* opPackageName= */ isNull(), eq(details));
248     }
249 
250     @Test
testUpdateWhileAwake_UpdatesDisplayPowerRequest()251     public void testUpdateWhileAwake_UpdatesDisplayPowerRequest() {
252         final boolean batterySaverEnabled = true;
253         float brightnessFactor = 0.7f;
254         PowerSaveState powerSaveState = new PowerSaveState.Builder()
255                 .setBatterySaverEnabled(batterySaverEnabled)
256                 .setBrightnessFactor(brightnessFactor)
257                 .build();
258 
259         mPowerGroup.updateLocked(/* screenBrightnessOverride= */ BRIGHTNESS,
260                 /* useProximitySensor= */ false,
261                 /* boostScreenBrightness= */ false,
262                 /* dozeScreenStateOverride= */ Display.STATE_ON,
263                 /* dozeScreenBrightness= */ BRIGHTNESS_DOZE,
264                 /* overrideDrawWakeLock= */ false,
265                 powerSaveState,
266                 /* quiescent= */ false,
267                 /* dozeAfterScreenOff= */ false,
268                 /* bootCompleted= */ true,
269                 /* screenBrightnessBoostInProgress= */ false,
270                 /* waitForNegativeProximity= */ false);
271         DisplayManagerInternal.DisplayPowerRequest displayPowerRequest =
272                 mPowerGroup.mDisplayPowerRequest;
273         assertThat(displayPowerRequest.policy).isEqualTo(POLICY_DIM);
274         assertThat(displayPowerRequest.screenBrightnessOverride).isWithin(PRECISION).of(BRIGHTNESS);
275         assertThat(displayPowerRequest.useProximitySensor).isEqualTo(false);
276         assertThat(displayPowerRequest.boostScreenBrightness).isEqualTo(false);
277         assertThat(displayPowerRequest.dozeScreenState).isEqualTo(Display.STATE_UNKNOWN);
278         assertThat(displayPowerRequest.dozeScreenBrightness).isEqualTo(
279                 PowerManager.BRIGHTNESS_INVALID_FLOAT);
280         assertThat(displayPowerRequest.lowPowerMode).isEqualTo(batterySaverEnabled);
281         assertThat(displayPowerRequest.screenLowPowerBrightnessFactor).isWithin(PRECISION).of(
282                 brightnessFactor);
283     }
284 
285     @Test
testUpdateWhileDozing_UpdatesDisplayPowerRequest()286     public void testUpdateWhileDozing_UpdatesDisplayPowerRequest() {
287         final boolean batterySaverEnabled = false;
288         float brightnessFactor = 0.3f;
289         PowerSaveState powerSaveState = new PowerSaveState.Builder()
290                 .setBatterySaverEnabled(batterySaverEnabled)
291                 .setBrightnessFactor(brightnessFactor)
292                 .build();
293         mPowerGroup.dozeLocked(TIMESTAMP1, UID, GO_TO_SLEEP_REASON_APPLICATION);
294         assertThat(mPowerGroup.getWakefulnessLocked()).isEqualTo(WAKEFULNESS_DOZING);
295         mPowerGroup.setWakeLockSummaryLocked(WAKE_LOCK_DOZE);
296 
297         mPowerGroup.updateLocked(/* screenBrightnessOverride= */ BRIGHTNESS,
298                 /* useProximitySensor= */ true,
299                 /* boostScreenBrightness= */ true,
300                 /* dozeScreenStateOverride= */ Display.STATE_ON,
301                 /* dozeScreenBrightness= */ BRIGHTNESS_DOZE,
302                 /* overrideDrawWakeLock= */ false,
303                 powerSaveState,
304                 /* quiescent= */ false,
305                 /* dozeAfterScreenOff= */ false,
306                 /* bootCompleted= */ true,
307                 /* screenBrightnessBoostInProgress= */ false,
308                 /* waitForNegativeProximity= */ false);
309         DisplayManagerInternal.DisplayPowerRequest displayPowerRequest =
310                 mPowerGroup.mDisplayPowerRequest;
311         assertThat(displayPowerRequest.policy).isEqualTo(POLICY_DOZE);
312         assertThat(displayPowerRequest.screenBrightnessOverride).isWithin(PRECISION).of(BRIGHTNESS);
313         assertThat(displayPowerRequest.useProximitySensor).isEqualTo(true);
314         assertThat(displayPowerRequest.boostScreenBrightness).isEqualTo(true);
315         assertThat(displayPowerRequest.dozeScreenState).isEqualTo(Display.STATE_ON);
316         assertThat(displayPowerRequest.dozeScreenBrightness).isWithin(PRECISION).of(
317                 BRIGHTNESS_DOZE);
318         assertThat(displayPowerRequest.lowPowerMode).isEqualTo(batterySaverEnabled);
319         assertThat(displayPowerRequest.screenLowPowerBrightnessFactor).isWithin(PRECISION).of(
320                 brightnessFactor);
321     }
322 
323     @Test
testUpdateWhileDozing_DozeAfterScreenOff()324     public void testUpdateWhileDozing_DozeAfterScreenOff() {
325         final boolean batterySaverEnabled = false;
326         float brightnessFactor = 0.3f;
327         PowerSaveState powerSaveState = new PowerSaveState.Builder()
328                 .setBatterySaverEnabled(batterySaverEnabled)
329                 .setBrightnessFactor(brightnessFactor)
330                 .build();
331         mPowerGroup.dozeLocked(TIMESTAMP1, UID, GO_TO_SLEEP_REASON_APPLICATION);
332         assertThat(mPowerGroup.getWakefulnessLocked()).isEqualTo(WAKEFULNESS_DOZING);
333 
334         mPowerGroup.updateLocked(/* screenBrightnessOverride= */ BRIGHTNESS,
335                 /* useProximitySensor= */ true,
336                 /* boostScreenBrightness= */ true,
337                 /* dozeScreenStateOverride= */ Display.STATE_ON,
338                 /* dozeScreenBrightness= */ BRIGHTNESS_DOZE,
339                 /* overrideDrawWakeLock= */ false,
340                 powerSaveState,
341                 /* quiescent= */ false,
342                 /* dozeAfterScreenOff= */ true,
343                 /* bootCompleted= */ true,
344                 /* screenBrightnessBoostInProgress= */ false,
345                 /* waitForNegativeProximity= */ false);
346         DisplayManagerInternal.DisplayPowerRequest displayPowerRequest =
347                 mPowerGroup.mDisplayPowerRequest;
348         assertThat(displayPowerRequest.policy).isEqualTo(POLICY_OFF);
349         assertThat(displayPowerRequest.screenBrightnessOverride).isWithin(PRECISION).of(BRIGHTNESS);
350         assertThat(displayPowerRequest.useProximitySensor).isEqualTo(true);
351         assertThat(displayPowerRequest.boostScreenBrightness).isEqualTo(true);
352         assertThat(displayPowerRequest.dozeScreenState).isEqualTo(Display.STATE_UNKNOWN);
353         assertThat(displayPowerRequest.dozeScreenBrightness).isEqualTo(
354                 PowerManager.BRIGHTNESS_INVALID_FLOAT);
355         assertThat(displayPowerRequest.lowPowerMode).isEqualTo(batterySaverEnabled);
356         assertThat(displayPowerRequest.screenLowPowerBrightnessFactor).isWithin(PRECISION).of(
357                 brightnessFactor);
358     }
359 
360     @Test
testUpdateQuiescent()361     public void testUpdateQuiescent() {
362         final boolean batterySaverEnabled = false;
363         float brightnessFactor = 0.3f;
364         PowerSaveState powerSaveState = new PowerSaveState.Builder()
365                 .setBatterySaverEnabled(batterySaverEnabled)
366                 .setBrightnessFactor(brightnessFactor)
367                 .build();
368         assertThat(mPowerGroup.getWakefulnessLocked()).isEqualTo(WAKEFULNESS_AWAKE);
369 
370         mPowerGroup.updateLocked(/* screenBrightnessOverride= */ BRIGHTNESS,
371                 /* useProximitySensor= */ true,
372                 /* boostScreenBrightness= */ true,
373                 /* dozeScreenStateOverride= */ Display.STATE_ON,
374                 /* dozeScreenBrightness= */ BRIGHTNESS_DOZE,
375                 /* overrideDrawWakeLock= */ false,
376                 powerSaveState,
377                 /* quiescent= */ true,
378                 /* dozeAfterScreenOff= */ true,
379                 /* bootCompleted= */ true,
380                 /* screenBrightnessBoostInProgress= */ false,
381                 /* waitForNegativeProximity= */ false);
382         DisplayManagerInternal.DisplayPowerRequest displayPowerRequest =
383                 mPowerGroup.mDisplayPowerRequest;
384         assertThat(displayPowerRequest.policy).isEqualTo(POLICY_OFF);
385         assertThat(displayPowerRequest.screenBrightnessOverride).isWithin(PRECISION).of(BRIGHTNESS);
386         assertThat(displayPowerRequest.useProximitySensor).isEqualTo(true);
387         assertThat(displayPowerRequest.boostScreenBrightness).isEqualTo(true);
388         assertThat(displayPowerRequest.dozeScreenState).isEqualTo(Display.STATE_UNKNOWN);
389         assertThat(displayPowerRequest.dozeScreenBrightness).isEqualTo(
390                 PowerManager.BRIGHTNESS_INVALID_FLOAT);
391         assertThat(displayPowerRequest.lowPowerMode).isEqualTo(batterySaverEnabled);
392         assertThat(displayPowerRequest.screenLowPowerBrightnessFactor).isWithin(PRECISION).of(
393                 brightnessFactor);
394     }
395 
396     @Test
testUpdateWhileAsleep_UpdatesDisplayPowerRequest()397     public void testUpdateWhileAsleep_UpdatesDisplayPowerRequest() {
398         final boolean batterySaverEnabled = false;
399         float brightnessFactor = 0.3f;
400         PowerSaveState powerSaveState = new PowerSaveState.Builder()
401                 .setBatterySaverEnabled(batterySaverEnabled)
402                 .setBrightnessFactor(brightnessFactor)
403                 .build();
404         mPowerGroup.sleepLocked(TIMESTAMP1, UID, GO_TO_SLEEP_REASON_TIMEOUT);
405         assertThat(mPowerGroup.getWakefulnessLocked()).isEqualTo(WAKEFULNESS_ASLEEP);
406         mPowerGroup.updateLocked(/* screenBrightnessOverride= */ BRIGHTNESS,
407                 /* useProximitySensor= */ true,
408                 /* boostScreenBrightness= */ true,
409                 /* dozeScreenStateOverride= */ Display.STATE_ON,
410                 /* dozeScreenBrightness= */ BRIGHTNESS_DOZE,
411                 /* overrideDrawWakeLock= */ false,
412                 powerSaveState,
413                 /* quiescent= */ false,
414                 /* dozeAfterScreenOff= */ false,
415                 /* bootCompleted= */ true,
416                 /* screenBrightnessBoostInProgress= */ false,
417                 /* waitForNegativeProximity= */ false);
418         DisplayManagerInternal.DisplayPowerRequest displayPowerRequest =
419                 mPowerGroup.mDisplayPowerRequest;
420         assertThat(displayPowerRequest.policy).isEqualTo(POLICY_OFF);
421         assertThat(displayPowerRequest.screenBrightnessOverride).isWithin(PRECISION).of(BRIGHTNESS);
422         assertThat(displayPowerRequest.useProximitySensor).isEqualTo(true);
423         assertThat(displayPowerRequest.boostScreenBrightness).isEqualTo(true);
424         assertThat(displayPowerRequest.dozeScreenState).isEqualTo(Display.STATE_UNKNOWN);
425         assertThat(displayPowerRequest.dozeScreenBrightness).isEqualTo(
426                 PowerManager.BRIGHTNESS_INVALID_FLOAT);
427         assertThat(displayPowerRequest.lowPowerMode).isEqualTo(batterySaverEnabled);
428         assertThat(displayPowerRequest.screenLowPowerBrightnessFactor).isWithin(PRECISION).of(
429                 brightnessFactor);
430     }
431 
432     @Test
testUpdateWhileDreamingWithScreenBrightWakelock_UpdatesDisplayPowerRequest()433     public void testUpdateWhileDreamingWithScreenBrightWakelock_UpdatesDisplayPowerRequest() {
434         final boolean batterySaverEnabled = false;
435         float brightnessFactor = 0.3f;
436         PowerSaveState powerSaveState = new PowerSaveState.Builder()
437                 .setBatterySaverEnabled(batterySaverEnabled)
438                 .setBrightnessFactor(brightnessFactor)
439                 .build();
440         mPowerGroup.dreamLocked(TIMESTAMP1, UID, /* allowWake= */ false);
441         assertThat(mPowerGroup.getWakefulnessLocked()).isEqualTo(WAKEFULNESS_DREAMING);
442         mPowerGroup.setWakeLockSummaryLocked(WAKE_LOCK_SCREEN_BRIGHT);
443         mPowerGroup.updateLocked(/* screenBrightnessOverride= */ BRIGHTNESS,
444                 /* useProximitySensor= */ true,
445                 /* boostScreenBrightness= */ true,
446                 /* dozeScreenStateOverride= */ Display.STATE_ON,
447                 /* dozeScreenBrightness= */ BRIGHTNESS_DOZE,
448                 /* overrideDrawWakeLock= */ false,
449                 powerSaveState,
450                 /* quiescent= */ false,
451                 /* dozeAfterScreenOff= */ false,
452                 /* bootCompleted= */ true,
453                 /* screenBrightnessBoostInProgress= */ false,
454                 /* waitForNegativeProximity= */ false);
455         DisplayManagerInternal.DisplayPowerRequest displayPowerRequest =
456                 mPowerGroup.mDisplayPowerRequest;
457         assertThat(displayPowerRequest.policy).isEqualTo(POLICY_BRIGHT);
458         assertThat(displayPowerRequest.screenBrightnessOverride).isWithin(PRECISION).of(BRIGHTNESS);
459         assertThat(displayPowerRequest.useProximitySensor).isEqualTo(true);
460         assertThat(displayPowerRequest.boostScreenBrightness).isEqualTo(true);
461         assertThat(displayPowerRequest.dozeScreenState).isEqualTo(Display.STATE_UNKNOWN);
462         assertThat(displayPowerRequest.dozeScreenBrightness).isEqualTo(
463                 PowerManager.BRIGHTNESS_INVALID_FLOAT);
464         assertThat(displayPowerRequest.lowPowerMode).isEqualTo(batterySaverEnabled);
465         assertThat(displayPowerRequest.screenLowPowerBrightnessFactor).isWithin(PRECISION).of(
466                 brightnessFactor);
467     }
468 
469     @Test
testUpdateWhileAwakeBootNotComplete_UpdatesDisplayPowerRequest()470     public void testUpdateWhileAwakeBootNotComplete_UpdatesDisplayPowerRequest() {
471         final boolean batterySaverEnabled = false;
472         float brightnessFactor = 0.3f;
473         PowerSaveState powerSaveState = new PowerSaveState.Builder()
474                 .setBatterySaverEnabled(batterySaverEnabled)
475                 .setBrightnessFactor(brightnessFactor)
476                 .build();
477         assertThat(mPowerGroup.getWakefulnessLocked()).isEqualTo(WAKEFULNESS_AWAKE);
478         mPowerGroup.updateLocked(/* screenBrightnessOverride= */ BRIGHTNESS,
479                 /* useProximitySensor= */ true,
480                 /* boostScreenBrightness= */ true,
481                 /* dozeScreenStateOverride= */ Display.STATE_ON,
482                 /* dozeScreenBrightness= */ BRIGHTNESS_DOZE,
483                 /* overrideDrawWakeLock= */ false,
484                 powerSaveState,
485                 /* quiescent= */ false,
486                 /* dozeAfterScreenOff= */ false,
487                 /* bootCompleted= */ false,
488                 /* screenBrightnessBoostInProgress= */ false,
489                 /* waitForNegativeProximity= */ false);
490         DisplayManagerInternal.DisplayPowerRequest displayPowerRequest =
491                 mPowerGroup.mDisplayPowerRequest;
492         assertThat(displayPowerRequest.policy).isEqualTo(POLICY_BRIGHT);
493         assertThat(displayPowerRequest.screenBrightnessOverride).isWithin(PRECISION).of(BRIGHTNESS);
494         assertThat(displayPowerRequest.useProximitySensor).isEqualTo(true);
495         assertThat(displayPowerRequest.boostScreenBrightness).isEqualTo(true);
496         assertThat(displayPowerRequest.dozeScreenState).isEqualTo(Display.STATE_UNKNOWN);
497         assertThat(displayPowerRequest.dozeScreenBrightness).isEqualTo(
498                 PowerManager.BRIGHTNESS_INVALID_FLOAT);
499         assertThat(displayPowerRequest.lowPowerMode).isEqualTo(batterySaverEnabled);
500         assertThat(displayPowerRequest.screenLowPowerBrightnessFactor).isWithin(PRECISION).of(
501                 brightnessFactor);
502     }
503 
504     @Test
testUpdateWhileAwakeUserActivityScreenBright_UpdatesDisplayPowerRequest()505     public void testUpdateWhileAwakeUserActivityScreenBright_UpdatesDisplayPowerRequest() {
506         final boolean batterySaverEnabled = false;
507         float brightnessFactor = 0.3f;
508         PowerSaveState powerSaveState = new PowerSaveState.Builder()
509                 .setBatterySaverEnabled(batterySaverEnabled)
510                 .setBrightnessFactor(brightnessFactor)
511                 .build();
512         assertThat(mPowerGroup.getWakefulnessLocked()).isEqualTo(WAKEFULNESS_AWAKE);
513         mPowerGroup.setUserActivitySummaryLocked(USER_ACTIVITY_SCREEN_BRIGHT);
514         mPowerGroup.updateLocked(/* screenBrightnessOverride= */ BRIGHTNESS,
515                 /* useProximitySensor= */ true,
516                 /* boostScreenBrightness= */ true,
517                 /* dozeScreenStateOverride= */ Display.STATE_ON,
518                 /* dozeScreenBrightness= */ BRIGHTNESS_DOZE,
519                 /* overrideDrawWakeLock= */ false,
520                 powerSaveState,
521                 /* quiescent= */ false,
522                 /* dozeAfterScreenOff= */ false,
523                 /* bootCompleted= */ true,
524                 /* screenBrightnessBoostInProgress= */ false,
525                 /* waitForNegativeProximity= */ false);
526         DisplayManagerInternal.DisplayPowerRequest displayPowerRequest =
527                 mPowerGroup.mDisplayPowerRequest;
528         assertThat(displayPowerRequest.policy).isEqualTo(POLICY_BRIGHT);
529         assertThat(displayPowerRequest.screenBrightnessOverride).isWithin(PRECISION).of(BRIGHTNESS);
530         assertThat(displayPowerRequest.useProximitySensor).isEqualTo(true);
531         assertThat(displayPowerRequest.boostScreenBrightness).isEqualTo(true);
532         assertThat(displayPowerRequest.dozeScreenState).isEqualTo(Display.STATE_UNKNOWN);
533         assertThat(displayPowerRequest.dozeScreenBrightness).isEqualTo(
534                 PowerManager.BRIGHTNESS_INVALID_FLOAT);
535         assertThat(displayPowerRequest.lowPowerMode).isEqualTo(batterySaverEnabled);
536         assertThat(displayPowerRequest.screenLowPowerBrightnessFactor).isWithin(PRECISION).of(
537                 brightnessFactor);
538     }
539 
540     @Test
testUpdateWhileAwakeScreenBrightnessBoostInProgress_UpdatesDisplayPowerRequest()541     public void testUpdateWhileAwakeScreenBrightnessBoostInProgress_UpdatesDisplayPowerRequest() {
542         final boolean batterySaverEnabled = false;
543         float brightnessFactor = 0.3f;
544         PowerSaveState powerSaveState = new PowerSaveState.Builder()
545                 .setBatterySaverEnabled(batterySaverEnabled)
546                 .setBrightnessFactor(brightnessFactor)
547                 .build();
548         assertThat(mPowerGroup.getWakefulnessLocked()).isEqualTo(WAKEFULNESS_AWAKE);
549         mPowerGroup.updateLocked(/* screenBrightnessOverride= */ BRIGHTNESS,
550                 /* useProximitySensor= */ true,
551                 /* boostScreenBrightness= */ true,
552                 /* dozeScreenStateOverride= */ Display.STATE_ON,
553                 /* dozeScreenBrightness= */ BRIGHTNESS_DOZE,
554                 /* overrideDrawWakeLock= */ false,
555                 powerSaveState,
556                 /* quiescent= */ false,
557                 /* dozeAfterScreenOff= */ false,
558                 /* bootCompleted= */ true,
559                 /* screenBrightnessBoostInProgress= */ true,
560                 /* waitForNegativeProximity= */ false);
561         DisplayManagerInternal.DisplayPowerRequest displayPowerRequest =
562                 mPowerGroup.mDisplayPowerRequest;
563         assertThat(displayPowerRequest.policy).isEqualTo(POLICY_BRIGHT);
564         assertThat(displayPowerRequest.screenBrightnessOverride).isWithin(PRECISION).of(BRIGHTNESS);
565         assertThat(displayPowerRequest.useProximitySensor).isEqualTo(true);
566         assertThat(displayPowerRequest.boostScreenBrightness).isEqualTo(true);
567         assertThat(displayPowerRequest.dozeScreenState).isEqualTo(Display.STATE_UNKNOWN);
568         assertThat(displayPowerRequest.dozeScreenBrightness).isEqualTo(
569                 PowerManager.BRIGHTNESS_INVALID_FLOAT);
570         assertThat(displayPowerRequest.lowPowerMode).isEqualTo(batterySaverEnabled);
571         assertThat(displayPowerRequest.screenLowPowerBrightnessFactor).isWithin(PRECISION).of(
572                 brightnessFactor);
573     }
574 }
575