1 /*
2  * Copyright (C) 2017 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.systemui.doze;
18 
19 import static com.android.systemui.doze.DozeMachine.State.DOZE;
20 import static com.android.systemui.doze.DozeMachine.State.DOZE_AOD;
21 import static com.android.systemui.doze.DozeMachine.State.DOZE_AOD_DOCKED;
22 import static com.android.systemui.doze.DozeMachine.State.DOZE_AOD_PAUSED;
23 import static com.android.systemui.doze.DozeMachine.State.DOZE_AOD_PAUSING;
24 import static com.android.systemui.doze.DozeMachine.State.DOZE_PULSE_DONE;
25 import static com.android.systemui.doze.DozeMachine.State.DOZE_PULSING;
26 import static com.android.systemui.doze.DozeMachine.State.DOZE_REQUEST_PULSE;
27 import static com.android.systemui.doze.DozeMachine.State.DOZE_SUSPEND_TRIGGERS;
28 import static com.android.systemui.doze.DozeMachine.State.FINISH;
29 import static com.android.systemui.doze.DozeMachine.State.INITIALIZED;
30 import static com.android.systemui.doze.DozeMachine.State.UNINITIALIZED;
31 
32 import static org.junit.Assert.assertEquals;
33 import static org.junit.Assert.assertNotEquals;
34 import static org.junit.Assert.assertNotSame;
35 import static org.junit.Assert.assertTrue;
36 import static org.mockito.ArgumentMatchers.any;
37 import static org.mockito.ArgumentMatchers.anyInt;
38 import static org.mockito.ArgumentMatchers.eq;
39 import static org.mockito.Mockito.doAnswer;
40 import static org.mockito.Mockito.reset;
41 import static org.mockito.Mockito.verify;
42 import static org.mockito.Mockito.when;
43 
44 import android.content.Intent;
45 import android.os.PowerManager;
46 import android.os.UserHandle;
47 import android.provider.Settings;
48 import android.testing.AndroidTestingRunner;
49 
50 import androidx.test.filters.SmallTest;
51 
52 import com.android.systemui.SysuiTestCase;
53 import com.android.systemui.dock.DockManager;
54 import com.android.systemui.keyguard.WakefulnessLifecycle;
55 import com.android.systemui.statusbar.phone.DozeParameters;
56 import com.android.systemui.statusbar.policy.DevicePostureController;
57 import com.android.systemui.util.concurrency.FakeExecutor;
58 import com.android.systemui.util.concurrency.FakeThreadFactory;
59 import com.android.systemui.util.sensors.AsyncSensorManager;
60 import com.android.systemui.util.sensors.FakeSensorManager;
61 import com.android.systemui.util.settings.SystemSettings;
62 import com.android.systemui.util.time.FakeSystemClock;
63 
64 import org.junit.Before;
65 import org.junit.Test;
66 import org.junit.runner.RunWith;
67 import org.mockito.ArgumentCaptor;
68 import org.mockito.Mock;
69 import org.mockito.MockitoAnnotations;
70 
71 import java.util.Optional;
72 
73 @SmallTest
74 @RunWith(AndroidTestingRunner.class)
75 public class DozeScreenBrightnessTest extends SysuiTestCase {
76 
77     private static final int DEFAULT_BRIGHTNESS = 10;
78     private static final int DIM_BRIGHTNESS = 1;
79     private static final int[] SENSOR_TO_BRIGHTNESS = new int[]{-1, 1, 2, 3, 4};
80     private static final int[] SENSOR_TO_OPACITY = new int[]{-1, 10, 0, 0, 0};
81 
82     private DozeServiceFake mServiceFake;
83     private FakeSensorManager.FakeGenericSensor mSensor;
84     private FakeSensorManager.FakeGenericSensor mSensorInner;
85     private AsyncSensorManager mSensorManager;
86     private AlwaysOnDisplayPolicy mAlwaysOnDisplayPolicy;
87     @Mock
88     DozeHost mDozeHost;
89     @Mock
90     WakefulnessLifecycle mWakefulnessLifecycle;
91     @Mock
92     DozeParameters mDozeParameters;
93     @Mock
94     DockManager mDockManager;
95     @Mock
96     DevicePostureController mDevicePostureController;
97     @Mock
98     DozeLog mDozeLog;
99     @Mock
100     SystemSettings mSystemSettings;
101     private FakeExecutor mFakeExecutor = new FakeExecutor(new FakeSystemClock());
102     private FakeThreadFactory mFakeThreadFactory = new FakeThreadFactory(mFakeExecutor);
103 
104     private DozeScreenBrightness mScreen;
105 
106     @Before
setUp()107     public void setUp() throws Exception {
108         MockitoAnnotations.initMocks(this);
109         when(mSystemSettings.getIntForUser(eq(Settings.System.SCREEN_BRIGHTNESS), anyInt(),
110                 eq(UserHandle.USER_CURRENT))).thenReturn(DEFAULT_BRIGHTNESS);
111         doAnswer(invocation -> {
112             ((Runnable) invocation.getArgument(0)).run();
113             return null;
114         }).when(mDozeHost).prepareForGentleSleep(any());
115         mServiceFake = new DozeServiceFake();
116         FakeSensorManager fakeSensorManager = new FakeSensorManager(mContext);
117         mSensorManager = new AsyncSensorManager(fakeSensorManager, mFakeThreadFactory, null);
118 
119         mAlwaysOnDisplayPolicy = new AlwaysOnDisplayPolicy(mContext);
120         mAlwaysOnDisplayPolicy.defaultDozeBrightness = DEFAULT_BRIGHTNESS;
121         mAlwaysOnDisplayPolicy.screenBrightnessArray = SENSOR_TO_BRIGHTNESS;
122         mAlwaysOnDisplayPolicy.dimBrightness = DIM_BRIGHTNESS;
123         mAlwaysOnDisplayPolicy.dimmingScrimArray = SENSOR_TO_OPACITY;
124         mSensor = fakeSensorManager.getFakeLightSensor();
125         mSensorInner = fakeSensorManager.getFakeLightSensor2();
126         mScreen = new DozeScreenBrightness(
127                 mContext,
128                 mServiceFake,
129                 mSensorManager,
130                 new Optional[]{Optional.of(mSensor.getSensor())},
131                 mDozeHost,
132                 null /* handler */,
133                 mAlwaysOnDisplayPolicy,
134                 mWakefulnessLifecycle,
135                 mDozeParameters,
136                 mDevicePostureController,
137                 mDozeLog,
138                 mSystemSettings);
139     }
140 
141     @Test
testInitialize_setsScreenBrightnessToValidValue()142     public void testInitialize_setsScreenBrightnessToValidValue() throws Exception {
143         mScreen.transitionTo(UNINITIALIZED, INITIALIZED);
144 
145         assertEquals(DEFAULT_BRIGHTNESS, mServiceFake.screenBrightness);
146         assertTrue(mServiceFake.screenBrightness <= PowerManager.BRIGHTNESS_ON);
147     }
148 
149     @Test
testAod_usesDebugValue()150     public void testAod_usesDebugValue() throws Exception {
151         mScreen.transitionTo(UNINITIALIZED, INITIALIZED);
152         mScreen.transitionTo(INITIALIZED, DOZE_AOD);
153         waitForSensorManager();
154 
155         Intent intent = new Intent(DozeScreenBrightness.ACTION_AOD_BRIGHTNESS);
156         intent.putExtra(DozeScreenBrightness.BRIGHTNESS_BUCKET, 1);
157         mScreen.onReceive(mContext, intent);
158         mSensor.sendSensorEvent(3);
159 
160         assertEquals(1, mServiceFake.screenBrightness);
161     }
162 
163     @Test
testAod_usesLightSensorRespectingUserSetting()164     public void testAod_usesLightSensorRespectingUserSetting() {
165         int maxBrightness = 3;
166         when(mSystemSettings.getIntForUser(eq(Settings.System.SCREEN_BRIGHTNESS), anyInt(),
167                 eq(UserHandle.USER_CURRENT))).thenReturn(maxBrightness);
168         when(mSystemSettings.getIntForUser(eq(Settings.System.SCREEN_BRIGHTNESS_MODE), anyInt(),
169                 eq(UserHandle.USER_CURRENT)))
170                 .thenReturn(Settings.System.SCREEN_BRIGHTNESS_MODE_MANUAL);
171 
172         mScreen.transitionTo(UNINITIALIZED, INITIALIZED);
173         assertEquals(maxBrightness, mServiceFake.screenBrightness);
174     }
175 
176     @Test
testAod_usesLightSensorNotClampingToAutoBrightnessValue()177     public void testAod_usesLightSensorNotClampingToAutoBrightnessValue() {
178         int maxBrightness = 3;
179         when(mSystemSettings.getIntForUser(eq(Settings.System.SCREEN_BRIGHTNESS), anyInt(),
180                 eq(UserHandle.USER_CURRENT))).thenReturn(maxBrightness);
181         when(mSystemSettings.getIntForUser(eq(Settings.System.SCREEN_BRIGHTNESS_MODE), anyInt(),
182                 eq(UserHandle.USER_CURRENT)))
183                 .thenReturn(Settings.System.SCREEN_BRIGHTNESS_MODE_AUTOMATIC);
184 
185         mScreen.transitionTo(UNINITIALIZED, INITIALIZED);
186         assertEquals(DEFAULT_BRIGHTNESS, mServiceFake.screenBrightness);
187     }
188 
189     @Test
doze_doesNotUseLightSensor()190     public void doze_doesNotUseLightSensor() {
191         // GIVEN the device is DOZE and the display state changes to ON
192         mScreen.transitionTo(UNINITIALIZED, INITIALIZED);
193         mScreen.transitionTo(INITIALIZED, DOZE);
194         waitForSensorManager();
195 
196         // WHEN new sensor event sent
197         mSensor.sendSensorEvent(3);
198 
199         // THEN brightness is NOT changed, it's set to the default brightness
200         assertNotSame(3, mServiceFake.screenBrightness);
201         assertEquals(DEFAULT_BRIGHTNESS, mServiceFake.screenBrightness);
202     }
203 
204     @Test
dozeSuspendTriggers_doesNotUseLightSensor()205     public void dozeSuspendTriggers_doesNotUseLightSensor() {
206         // GIVEN the device is DOZE and the display state changes to ON
207         mScreen.transitionTo(UNINITIALIZED, INITIALIZED);
208         mScreen.transitionTo(INITIALIZED, DOZE_SUSPEND_TRIGGERS);
209         waitForSensorManager();
210 
211         // WHEN new sensor event sent
212         mSensor.sendSensorEvent(3);
213 
214         // THEN brightness is NOT changed, it's set to the default brightness
215         assertNotSame(3, mServiceFake.screenBrightness);
216         assertEquals(DEFAULT_BRIGHTNESS, mServiceFake.screenBrightness);
217     }
218 
219     @Test
aod_usesLightSensor()220     public void aod_usesLightSensor() {
221         // GIVEN the device is DOZE_AOD and the display state changes to ON
222         mScreen.transitionTo(UNINITIALIZED, INITIALIZED);
223         mScreen.transitionTo(INITIALIZED, DOZE_AOD);
224         waitForSensorManager();
225 
226         // WHEN new sensor event sent
227         mSensor.sendSensorEvent(3);
228 
229         // THEN brightness is updated
230         assertEquals(3, mServiceFake.screenBrightness);
231     }
232 
233     @Test
docked_usesLightSensor()234     public void docked_usesLightSensor() {
235         // GIVEN the device is docked and the display state changes to ON
236         mScreen.transitionTo(UNINITIALIZED, INITIALIZED);
237         mScreen.transitionTo(INITIALIZED, DOZE_AOD);
238         mScreen.transitionTo(DOZE_AOD, DOZE_AOD_DOCKED);
239         waitForSensorManager();
240 
241         // WHEN new sensor event sent
242         mSensor.sendSensorEvent(3);
243 
244         // THEN brightness is updated
245         assertEquals(3, mServiceFake.screenBrightness);
246     }
247 
248     @Test
testPulsing_withoutLightSensor_setsAoDDimmingScrimTransparent()249     public void testPulsing_withoutLightSensor_setsAoDDimmingScrimTransparent() throws Exception {
250         mScreen = new DozeScreenBrightness(
251                 mContext,
252                 mServiceFake,
253                 mSensorManager,
254                 new Optional[] {Optional.empty()} /* sensor */,
255                 mDozeHost, null /* handler */,
256                 mAlwaysOnDisplayPolicy,
257                 mWakefulnessLifecycle,
258                 mDozeParameters,
259                 mDevicePostureController,
260                 mDozeLog,
261                 mSystemSettings);
262         mScreen.transitionTo(UNINITIALIZED, INITIALIZED);
263         mScreen.transitionTo(INITIALIZED, DOZE);
264         reset(mDozeHost);
265 
266         mScreen.transitionTo(DOZE, DOZE_REQUEST_PULSE);
267 
268         verify(mDozeHost).setAodDimmingScrim(eq(0f));
269     }
270 
271     @Test
testScreenOffAfterPulsing_pausesLightSensor()272     public void testScreenOffAfterPulsing_pausesLightSensor() throws Exception {
273         mScreen.transitionTo(UNINITIALIZED, INITIALIZED);
274         mScreen.transitionTo(INITIALIZED, DOZE);
275         mScreen.transitionTo(DOZE, DOZE_REQUEST_PULSE);
276         mScreen.transitionTo(DOZE_REQUEST_PULSE, DOZE_PULSING);
277         mScreen.transitionTo(DOZE_PULSING, DOZE_PULSE_DONE);
278         mScreen.transitionTo(DOZE_PULSE_DONE, DOZE);
279         waitForSensorManager();
280 
281         mSensor.sendSensorEvent(1);
282 
283         assertEquals(DEFAULT_BRIGHTNESS, mServiceFake.screenBrightness);
284     }
285 
286     @Test
testNullSensor()287     public void testNullSensor() throws Exception {
288         mScreen = new DozeScreenBrightness(
289                 mContext,
290                 mServiceFake,
291                 mSensorManager,
292                 new Optional[]{Optional.empty()} /* sensor */,
293                 mDozeHost, null /* handler */,
294                 mAlwaysOnDisplayPolicy,
295                 mWakefulnessLifecycle,
296                 mDozeParameters,
297                 mDevicePostureController,
298                 mDozeLog,
299                 mSystemSettings);
300 
301         mScreen.transitionTo(UNINITIALIZED, INITIALIZED);
302         mScreen.transitionTo(INITIALIZED, DOZE_AOD);
303         mScreen.transitionTo(DOZE_AOD, DOZE_AOD_PAUSING);
304         mScreen.transitionTo(DOZE_AOD_PAUSING, DOZE_AOD_PAUSED);
305     }
306 
307     @Test
testSensorsSupportPostures_closed()308     public void testSensorsSupportPostures_closed() throws Exception {
309         // GIVEN the device is CLOSED
310         when(mDevicePostureController.getDevicePosture()).thenReturn(
311                 DevicePostureController.DEVICE_POSTURE_CLOSED);
312 
313         // GIVEN closed and opened postures use different light sensors
314         mScreen = new DozeScreenBrightness(
315                 mContext,
316                 mServiceFake,
317                 mSensorManager,
318                 new Optional[]{
319                         Optional.empty() /* unknown */,
320                         Optional.of(mSensor.getSensor()) /* closed */,
321                         Optional.of(mSensorInner.getSensor()) /* half-opened */,
322                         Optional.of(mSensorInner.getSensor()) /* opened */,
323                         Optional.empty() /* flipped */
324                 },
325                 mDozeHost, null /* handler */,
326                 mAlwaysOnDisplayPolicy,
327                 mWakefulnessLifecycle,
328                 mDozeParameters,
329                 mDevicePostureController,
330                 mDozeLog,
331                 mSystemSettings);
332 
333         // GIVEN the device is in AOD
334         mScreen.transitionTo(UNINITIALIZED, INITIALIZED);
335         mScreen.transitionTo(INITIALIZED, DOZE_AOD);
336         waitForSensorManager();
337 
338         // WHEN new different events are sent from the inner and outer sensors
339         mSensor.sendSensorEvent(3); // CLOSED sensor
340         mSensorInner.sendSensorEvent(4); // OPENED sensor
341 
342         // THEN brightness is updated according to the sensor for CLOSED
343         assertEquals(3, mServiceFake.screenBrightness);
344     }
345 
346     @Test
testSensorsSupportPostures_open()347     public void testSensorsSupportPostures_open() throws Exception {
348         // GIVEN the device is OPENED
349         when(mDevicePostureController.getDevicePosture()).thenReturn(
350                 DevicePostureController.DEVICE_POSTURE_OPENED);
351 
352         // GIVEN closed and opened postures use different light sensors
353         mScreen = new DozeScreenBrightness(
354                 mContext,
355                 mServiceFake,
356                 mSensorManager,
357                 new Optional[]{
358                         Optional.empty() /* unknown */,
359                         Optional.of(mSensor.getSensor()) /* closed */,
360                         Optional.of(mSensorInner.getSensor()) /* half-opened */,
361                         Optional.of(mSensorInner.getSensor()) /* opened */,
362                         Optional.empty() /* flipped */
363                 },
364                 mDozeHost, null /* handler */,
365                 mAlwaysOnDisplayPolicy,
366                 mWakefulnessLifecycle,
367                 mDozeParameters,
368                 mDevicePostureController,
369                 mDozeLog,
370                 mSystemSettings);
371 
372         // GIVEN device is in AOD
373         mScreen.transitionTo(UNINITIALIZED, INITIALIZED);
374         mScreen.transitionTo(INITIALIZED, DOZE_AOD);
375         waitForSensorManager();
376 
377         // WHEN new different events are sent from the inner and outer sensors
378         mSensorInner.sendSensorEvent(4); // OPENED sensor
379         mSensor.sendSensorEvent(3); // CLOSED sensor
380 
381         // THEN brightness is updated according to the sensor for OPENED
382         assertEquals(4, mServiceFake.screenBrightness);
383     }
384 
385     @Test
testSensorsSupportPostures_swapPostures()386     public void testSensorsSupportPostures_swapPostures() throws Exception {
387         ArgumentCaptor<DevicePostureController.Callback> postureCallbackCaptor =
388                 ArgumentCaptor.forClass(DevicePostureController.Callback.class);
389         reset(mDevicePostureController);
390 
391         // GIVEN the device starts up AOD OPENED
392         when(mDevicePostureController.getDevicePosture()).thenReturn(
393                 DevicePostureController.DEVICE_POSTURE_OPENED);
394 
395         // GIVEN closed and opened postures use different light sensors
396         mScreen = new DozeScreenBrightness(
397                 mContext,
398                 mServiceFake,
399                 mSensorManager,
400                 new Optional[]{
401                         Optional.empty() /* unknown */,
402                         Optional.of(mSensor.getSensor()) /* closed */,
403                         Optional.of(mSensorInner.getSensor()) /* half-opened */,
404                         Optional.of(mSensorInner.getSensor()) /* opened */,
405                         Optional.empty() /* flipped */
406                 },
407                 mDozeHost, null /* handler */,
408                 mAlwaysOnDisplayPolicy,
409                 mWakefulnessLifecycle,
410                 mDozeParameters,
411                 mDevicePostureController,
412                 mDozeLog,
413                 mSystemSettings);
414         verify(mDevicePostureController).addCallback(postureCallbackCaptor.capture());
415 
416         // GIVEN device is in AOD
417         mScreen.transitionTo(UNINITIALIZED, INITIALIZED);
418         mScreen.transitionTo(INITIALIZED, DOZE_AOD);
419         waitForSensorManager();
420 
421         // WHEN the posture changes to CLOSED
422         postureCallbackCaptor.getValue().onPostureChanged(
423                 DevicePostureController.DEVICE_POSTURE_CLOSED);
424         waitForSensorManager();
425 
426         // WHEN new different events are sent from the inner and outer sensors
427         mSensor.sendSensorEvent(3); // CLOSED sensor
428         mSensorInner.sendSensorEvent(4); // OPENED sensor
429 
430         // THEN brightness is updated according to the sensor for CLOSED
431         assertEquals(3, mServiceFake.screenBrightness);
432     }
433 
434     @Test
testNoBrightnessDeliveredAfterFinish()435     public void testNoBrightnessDeliveredAfterFinish() throws Exception {
436         mScreen.transitionTo(UNINITIALIZED, INITIALIZED);
437         mScreen.transitionTo(INITIALIZED, DOZE_AOD);
438         mScreen.transitionTo(DOZE_AOD, FINISH);
439         waitForSensorManager();
440 
441         mSensor.sendSensorEvent(1);
442 
443         assertNotEquals(1, mServiceFake.screenBrightness);
444     }
445 
446     @Test
testNonPositiveBrightness_keepsPreviousBrightnessAndScrim()447     public void testNonPositiveBrightness_keepsPreviousBrightnessAndScrim() {
448         mScreen.transitionTo(UNINITIALIZED, INITIALIZED);
449         mScreen.transitionTo(INITIALIZED, DOZE_AOD);
450         waitForSensorManager();
451 
452         mSensor.sendSensorEvent(1);
453         mSensor.sendSensorEvent(0);
454 
455         assertEquals(1, mServiceFake.screenBrightness);
456         verify(mDozeHost).setAodDimmingScrim(eq(10f / 255f));
457     }
458 
459     @Test
pausingAod_unblanksAfterSensorEvent()460     public void pausingAod_unblanksAfterSensorEvent() {
461         mScreen.transitionTo(UNINITIALIZED, INITIALIZED);
462         mScreen.transitionTo(INITIALIZED, DOZE_AOD);
463         waitForSensorManager();
464 
465         mScreen.transitionTo(DOZE_AOD, DOZE_AOD_PAUSING);
466         mScreen.transitionTo(DOZE_AOD_PAUSING, DOZE_AOD_PAUSED);
467 
468         reset(mDozeHost);
469         mScreen.transitionTo(DOZE_AOD_PAUSED, DOZE_AOD);
470         waitForSensorManager();
471         mSensor.sendSensorEvent(2);
472         verify(mDozeHost).setAodDimmingScrim(eq(0f));
473     }
474 
475     @Test
transitionToDoze_shouldClampBrightness_afterTimeout_clampsToDim()476     public void transitionToDoze_shouldClampBrightness_afterTimeout_clampsToDim() {
477         when(mWakefulnessLifecycle.getLastSleepReason()).thenReturn(
478                 PowerManager.GO_TO_SLEEP_REASON_TIMEOUT);
479         when(mDozeParameters.shouldClampToDimBrightness()).thenReturn(true);
480 
481         mScreen.transitionTo(UNINITIALIZED, INITIALIZED);
482 
483         // If we're dozing after a timeout, and playing the unlocked screen animation, we should
484         // stay at or below dim brightness, because the screen dims just before timeout.
485         assertTrue(mServiceFake.screenBrightness <= DIM_BRIGHTNESS);
486 
487         // Once we transition to Doze, use the doze brightness
488         mScreen.transitionTo(INITIALIZED, DOZE);
489         assertEquals(mServiceFake.screenBrightness, DEFAULT_BRIGHTNESS);
490     }
491 
492     @Test
transitionToDoze_shouldClampBrightness_notAfterTimeout_doesNotClampToDim()493     public void transitionToDoze_shouldClampBrightness_notAfterTimeout_doesNotClampToDim() {
494         when(mWakefulnessLifecycle.getLastSleepReason()).thenReturn(
495                 PowerManager.GO_TO_SLEEP_REASON_POWER_BUTTON);
496         when(mDozeParameters.shouldClampToDimBrightness()).thenReturn(true);
497 
498         mScreen.transitionTo(UNINITIALIZED, INITIALIZED);
499 
500         // If we're playing the unlocked screen off animation after a power button press, we should
501         // leave the brightness alone.
502         assertEquals(mServiceFake.screenBrightness, DEFAULT_BRIGHTNESS);
503 
504         mScreen.transitionTo(INITIALIZED, DOZE);
505         assertEquals(mServiceFake.screenBrightness, DEFAULT_BRIGHTNESS);
506     }
507 
508     @Test
transitionToDoze_noClampBrightness_afterTimeout_noScreenOff_doesNotClampToDim()509     public void transitionToDoze_noClampBrightness_afterTimeout_noScreenOff_doesNotClampToDim() {
510         when(mWakefulnessLifecycle.getLastSleepReason()).thenReturn(
511                 PowerManager.GO_TO_SLEEP_REASON_TIMEOUT);
512         when(mDozeParameters.shouldClampToDimBrightness()).thenReturn(false);
513 
514         mScreen.transitionTo(UNINITIALIZED, INITIALIZED);
515         mScreen.transitionTo(INITIALIZED, DOZE);
516 
517         // If we aren't controlling the screen off animation, we should leave the brightness alone.
518         assertEquals(mServiceFake.screenBrightness, DEFAULT_BRIGHTNESS);
519     }
520 
521     @Test
transitionToDoze_noClampBrightness_afterTimeout_clampsToDim()522     public void transitionToDoze_noClampBrightness_afterTimeout_clampsToDim() {
523         when(mWakefulnessLifecycle.getLastSleepReason()).thenReturn(
524                 PowerManager.GO_TO_SLEEP_REASON_TIMEOUT);
525         when(mWakefulnessLifecycle.getWakefulness()).thenReturn(
526                 WakefulnessLifecycle.WAKEFULNESS_GOING_TO_SLEEP);
527         when(mDozeParameters.shouldClampToDimBrightness()).thenReturn(false);
528 
529         mScreen.transitionTo(UNINITIALIZED, INITIALIZED);
530 
531         assertTrue(mServiceFake.screenBrightness <= DIM_BRIGHTNESS);
532     }
533 
534     @Test
transitionToDoze_noClampBrigthness_notAfterTimeout_doesNotClampToDim()535     public void transitionToDoze_noClampBrigthness_notAfterTimeout_doesNotClampToDim() {
536         when(mWakefulnessLifecycle.getLastSleepReason()).thenReturn(
537                 PowerManager.GO_TO_SLEEP_REASON_POWER_BUTTON);
538         when(mWakefulnessLifecycle.getWakefulness()).thenReturn(
539                 WakefulnessLifecycle.WAKEFULNESS_GOING_TO_SLEEP);
540         when(mDozeParameters.shouldClampToDimBrightness()).thenReturn(false);
541 
542         mScreen.transitionTo(UNINITIALIZED, INITIALIZED);
543         mScreen.transitionTo(INITIALIZED, DOZE);
544 
545         assertEquals(mServiceFake.screenBrightness, DEFAULT_BRIGHTNESS);
546     }
547 
548     @Test
transitionToAodPaused_lightSensorDisabled()549     public void transitionToAodPaused_lightSensorDisabled() {
550         // GIVEN AOD
551         mScreen.transitionTo(UNINITIALIZED, INITIALIZED);
552         mScreen.transitionTo(INITIALIZED, DOZE_AOD);
553 
554         // WHEN AOD is paused
555         mScreen.transitionTo(DOZE_AOD, DOZE_AOD_PAUSING);
556         mScreen.transitionTo(DOZE_AOD, DOZE_AOD_PAUSED);
557         waitForSensorManager();
558 
559         // THEN new light events don't update brightness since the light sensor was unregistered
560         mSensor.sendSensorEvent(1);
561         assertEquals(mServiceFake.screenBrightness, DEFAULT_BRIGHTNESS);
562     }
563 
564     @Test
transitionFromAodPausedToAod_lightSensorEnabled()565     public void transitionFromAodPausedToAod_lightSensorEnabled() {
566         // GIVEN AOD paused
567         mScreen.transitionTo(UNINITIALIZED, INITIALIZED);
568         mScreen.transitionTo(INITIALIZED, DOZE_AOD);
569         mScreen.transitionTo(DOZE_AOD, DOZE_AOD_PAUSING);
570         mScreen.transitionTo(DOZE_AOD, DOZE_AOD_PAUSED);
571 
572         // WHEN device transitions back to AOD
573         mScreen.transitionTo(DOZE_AOD_PAUSED, DOZE_AOD);
574         waitForSensorManager();
575 
576         // WHEN there are brightness changes
577         mSensor.sendSensorEvent(1);
578 
579         // THEN aod brightness is updated
580         assertEquals(mServiceFake.screenBrightness, 1);
581     }
582 
waitForSensorManager()583     private void waitForSensorManager() {
584         mFakeExecutor.runAllReady();
585     }
586 }