NightDisplayServiceTest.java revision e5bb03e2ea8cf0d7ab98fb6e6f8db1007d8d48d2 
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
17package com.android.server;
18
19import android.app.ActivityManager;
20import android.app.AlarmManager;
21import android.content.Context;
22import android.content.ContextWrapper;
23import android.os.UserHandle;
24import android.provider.Settings;
25import android.provider.Settings.Secure;
26import android.support.test.InstrumentationRegistry;
27import android.support.test.runner.AndroidJUnit4;
28import android.test.mock.MockContentResolver;
29
30import com.android.internal.app.NightDisplayController;
31import com.android.internal.app.NightDisplayController.LocalTime;
32import com.android.internal.util.test.FakeSettingsProvider;
33import com.android.server.display.DisplayTransformManager;
34import com.android.server.display.NightDisplayService;
35import com.android.server.twilight.TwilightManager;
36import com.android.server.twilight.TwilightState;
37import org.junit.After;
38import org.junit.Before;
39import org.junit.Test;
40import org.junit.runner.RunWith;
41import org.mockito.Mockito;
42
43import java.util.Calendar;
44
45import static com.google.common.truth.Truth.assertWithMessage;
46import static org.mockito.Mockito.doReturn;
47
48@RunWith(AndroidJUnit4.class)
49public class NightDisplayServiceTest {
50
51    private Context mContext;
52    private int mUserId;
53
54    private TwilightManager mTwilightManager;
55
56    private NightDisplayController mNightDisplayController;
57    private NightDisplayService mNightDisplayService;
58
59    @Before
60    public void setUp() {
61        mContext = Mockito.spy(new ContextWrapper(InstrumentationRegistry.getTargetContext()));
62        mUserId = ActivityManager.getCurrentUser();
63
64        doReturn(mContext).when(mContext).getApplicationContext();
65
66        final MockContentResolver cr = new MockContentResolver(mContext);
67        cr.addProvider(Settings.AUTHORITY, new FakeSettingsProvider());
68        doReturn(cr).when(mContext).getContentResolver();
69
70        final AlarmManager am = Mockito.mock(AlarmManager.class);
71        doReturn(am).when(mContext).getSystemService(Context.ALARM_SERVICE);
72
73        final DisplayTransformManager dtm = Mockito.mock(DisplayTransformManager.class);
74        LocalServices.addService(DisplayTransformManager.class, dtm);
75
76        mTwilightManager = Mockito.mock(TwilightManager.class);
77        LocalServices.addService(TwilightManager.class, mTwilightManager);
78
79        mNightDisplayController = new NightDisplayController(mContext, mUserId);
80        mNightDisplayService = new NightDisplayService(mContext);
81    }
82
83    @After
84    public void tearDown() {
85        LocalServices.removeServiceForTest(DisplayTransformManager.class);
86        LocalServices.removeServiceForTest(TwilightManager.class);
87
88        mNightDisplayService = null;
89        mNightDisplayController = null;
90
91        mTwilightManager = null;
92
93        mUserId = UserHandle.USER_NULL;
94        mContext = null;
95    }
96
97    @Test
98    public void customSchedule_whenStartedAfterNight_ifOffAfterNight_turnsOff() {
99        setAutoModeCustom(-120 /* startTimeOffset */, -60 /* endTimeOffset */);
100        setActivated(false /* activated */, -30 /* lastActivatedTimeOffset */);
101
102        startService();
103        assertActivated(false /* activated */);
104    }
105
106    @Test
107    public void customSchedule_whenStartedAfterNight_ifOffBeforeNight_turnsOff() {
108        setAutoModeCustom(-120 /* startTimeOffset */, -60 /* endTimeOffset */);
109        setActivated(false /* activated */, -180 /* lastActivatedTimeOffset */);
110
111        startService();
112        assertActivated(false /* activated */);
113    }
114
115    @Test
116    public void customSchedule_whenStartedAfterNight_ifOffDuringNight_turnsOff() {
117        setAutoModeCustom(-120 /* startTimeOffset */, -60 /* endTimeOffset */);
118        setActivated(false /* activated */, -90 /* lastActivatedTimeOffset */);
119
120        startService();
121        assertActivated(false /* activated */);
122    }
123
124    @Test
125    public void customSchedule_whenStartedAfterNight_ifOffInFuture_turnsOff() {
126        setAutoModeCustom(-120 /* startTimeOffset */, -60 /* endTimeOffset */);
127        setActivated(false /* activated */, 30 /* lastActivatedTimeOffset */);
128
129        startService();
130        assertActivated(false /* activated */);
131    }
132
133    @Test
134    public void customSchedule_whenStartedAfterNight_ifOnAfterNight_turnsOn() {
135        setAutoModeCustom(-120 /* startTimeOffset */, -60 /* endTimeOffset */);
136        setActivated(true /* activated */, -30 /* lastActivatedTimeOffset */);
137
138        startService();
139        assertActivated(true /* activated */);
140    }
141
142    @Test
143    public void customSchedule_whenStartedAfterNight_ifOnBeforeNight_turnsOff() {
144        setAutoModeCustom(-120 /* startTimeOffset */, -60 /* endTimeOffset */);
145        setActivated(true /* activated */, -180 /* lastActivatedTimeOffset */);
146
147        startService();
148        assertActivated(false /* activated */);
149    }
150
151    @Test
152    public void customSchedule_whenStartedAfterNight_ifOnDuringNight_turnsOff() {
153        setAutoModeCustom(-120 /* startTimeOffset */, -60 /* endTimeOffset */);
154        setActivated(true /* activated */, -90 /* lastActivatedTimeOffset */);
155
156        startService();
157        assertActivated(false /* activated */);
158    }
159
160    @Test
161    public void customSchedule_whenStartedAfterNight_ifOnInFuture_turnsOff() {
162        setAutoModeCustom(-120 /* startTimeOffset */, -60 /* endTimeOffset */);
163        setActivated(true /* activated */, 30 /* lastActivatedTimeOffset */);
164
165        startService();
166        assertActivated(false /* activated */);
167    }
168
169    @Test
170    public void customSchedule_whenStartedBeforeNight_ifOffAfterNight_turnsOff() {
171        setAutoModeCustom(60 /* startTimeOffset */, 120 /* endTimeOffset */);
172        setActivated(false /* activated */, 180 /* lastActivatedTimeOffset */);
173
174        startService();
175        assertActivated(false /* activated */);
176    }
177
178    @Test
179    public void customSchedule_whenStartedBeforeNight_ifOffBeforeNight_turnsOff() {
180        setAutoModeCustom(60 /* startTimeOffset */, 120 /* endTimeOffset */);
181        setActivated(false /* activated */, 30 /* lastActivatedTimeOffset */);
182
183        startService();
184        assertActivated(false /* activated */);
185    }
186
187    @Test
188    public void customSchedule_whenStartedBeforeNight_ifOffDuringNight_turnsOff() {
189        setAutoModeCustom(60 /* startTimeOffset */, 120 /* endTimeOffset */);
190        setActivated(false /* activated */, 90 /* lastActivatedTimeOffset */);
191
192        startService();
193        assertActivated(false /* activated */);
194    }
195
196    @Test
197    public void customSchedule_whenStartedBeforeNight_ifOffInPast_turnsOff() {
198        setAutoModeCustom(60 /* startTimeOffset */, 120 /* endTimeOffset */);
199        setActivated(false /* activated */, -30 /* lastActivatedTimeOffset */);
200
201        startService();
202        assertActivated(false /* activated */);
203    }
204
205    @Test
206    public void customSchedule_whenStartedBeforeNight_ifOnAfterNight_turnsOff() {
207        setAutoModeCustom(60 /* startTimeOffset */, 120 /* endTimeOffset */);
208        setActivated(true /* activated */, 180 /* lastActivatedTimeOffset */);
209
210        startService();
211        assertActivated(false /* activated */);
212    }
213
214    @Test
215    public void customSchedule_whenStartedBeforeNight_ifOnBeforeNight_turnsOff() {
216        setAutoModeCustom(60 /* startTimeOffset */, 120 /* endTimeOffset */);
217        setActivated(true /* activated */, 30 /* lastActivatedTimeOffset */);
218
219        startService();
220        assertActivated(false /* activated */);
221    }
222
223    @Test
224    public void customSchedule_whenStartedBeforeNight_ifOnDuringNight_turnsOff() {
225        setAutoModeCustom(60 /* startTimeOffset */, 120 /* endTimeOffset */);
226        setActivated(true /* activated */, 90 /* lastActivatedTimeOffset */);
227
228        startService();
229        assertActivated(false /* activated */);
230    }
231
232    @Test
233    public void customSchedule_whenStartedBeforeNight_ifOnInPast_turnsOn() {
234        setAutoModeCustom(60 /* startTimeOffset */, 120 /* endTimeOffset */);
235        setActivated(true /* activated */, -30 /* lastActivatedTimeOffset */);
236
237        startService();
238        assertActivated(true /* activated */);
239    }
240
241    @Test
242    public void customSchedule_whenStartedDuringNight_ifOffAfterNight_turnsOn() {
243        setAutoModeCustom(-60 /* startTimeOffset */, 60 /* endTimeOffset */);
244        setActivated(false /* activated */, 90 /* lastActivatedTimeOffset */);
245
246        startService();
247        assertActivated(true /* activated */);
248    }
249
250    @Test
251    public void customSchedule_whenStartedDuringNight_ifOffBeforeNight_turnsOn() {
252        setAutoModeCustom(-60 /* startTimeOffset */, 60 /* endTimeOffset */);
253        setActivated(false /* activated */, -90 /* lastActivatedTimeOffset */);
254
255        startService();
256        assertActivated(true /* activated */);
257    }
258
259    @Test
260    public void customSchedule_whenStartedDuringNight_ifOffDuringNightInFuture_turnsOn() {
261        setAutoModeCustom(-60 /* startTimeOffset */, 60 /* endTimeOffset */);
262        setActivated(false /* activated */, 30 /* lastActivatedTimeOffset */);
263
264        startService();
265        assertActivated(true /* activated */);
266    }
267
268    @Test
269    public void customSchedule_whenStartedDuringNight_ifOffDuringNightInPast_turnsOff() {
270        setAutoModeCustom(-60 /* startTimeOffset */, 60 /* endTimeOffset */);
271        setActivated(false /* activated */, -30 /* lastActivatedTimeOffset */);
272
273        startService();
274        assertActivated(false /* activated */);
275    }
276
277    @Test
278    public void customSchedule_whenStartedDuringNight_ifOnAfterNight_turnsOn() {
279        setAutoModeCustom(-60 /* startTimeOffset */, 60 /* endTimeOffset */);
280        setActivated(true /* activated */, 90 /* lastActivatedTimeOffset */);
281
282        startService();
283        assertActivated(true /* activated */);
284    }
285
286    @Test
287    public void customSchedule_whenStartedDuringNight_ifOnBeforeNight_turnsOn() {
288        setAutoModeCustom(-60 /* startTimeOffset */, 60 /* endTimeOffset */);
289        setActivated(true /* activated */, -90 /* lastActivatedTimeOffset */);
290
291        startService();
292        assertActivated(true /* activated */);
293    }
294
295    @Test
296    public void customSchedule_whenStartedDuringNight_ifOnDuringNightInFuture_turnsOn() {
297        setAutoModeCustom(-60 /* startTimeOffset */, 60 /* endTimeOffset */);
298        setActivated(true /* activated */, 30 /* lastActivatedTimeOffset */);
299
300        startService();
301        assertActivated(true /* activated */);
302    }
303
304    @Test
305    public void customSchedule_whenStartedDuringNight_ifOnDuringNightInPast_turnsOn() {
306        setAutoModeCustom(-60 /* startTimeOffset */, 60 /* endTimeOffset */);
307        setActivated(true /* activated */, -30 /* lastActivatedTimeOffset */);
308
309        startService();
310        assertActivated(true /* activated */);
311    }
312
313    @Test
314    public void twilightSchedule_whenStartedAfterNight_ifOffAfterNight_turnsOff() {
315        setAutoModeTwilight(-120 /* sunsetOffset */, -60 /* sunriseOffset */);
316        setActivated(false /* activated */, -30 /* lastActivatedTimeOffset */);
317
318        startService();
319        assertActivated(false /* activated */);
320    }
321
322    @Test
323    public void twilightSchedule_whenStartedAfterNight_ifOffBeforeNight_turnsOff() {
324        setAutoModeTwilight(-120 /* sunsetOffset */, -60 /* sunriseOffset */);
325        setActivated(false /* activated */, -180 /* lastActivatedTimeOffset */);
326
327        startService();
328        assertActivated(false /* activated */);
329    }
330
331    @Test
332    public void twilightSchedule_whenStartedAfterNight_ifOffDuringNight_turnsOff() {
333        setAutoModeTwilight(-120 /* sunsetOffset */, -60 /* sunriseOffset */);
334        setActivated(false /* activated */, -90 /* lastActivatedTimeOffset */);
335
336        startService();
337        assertActivated(false /* activated */);
338    }
339
340    @Test
341    public void twilightSchedule_whenStartedAfterNight_ifOffInFuture_turnsOff() {
342        setAutoModeTwilight(-120 /* sunsetOffset */, -60 /* sunriseOffset */);
343        setActivated(false /* activated */, 30 /* lastActivatedTimeOffset */);
344
345        startService();
346        assertActivated(false /* activated */);
347    }
348
349    @Test
350    public void twilightSchedule_whenStartedAfterNight_ifOnAfterNight_turnsOn() {
351        setAutoModeTwilight(-120 /* sunsetOffset */, -60 /* sunriseOffset */);
352        setActivated(true /* activated */, -30 /* lastActivatedTimeOffset */);
353
354        startService();
355        assertActivated(true /* activated */);
356    }
357
358    @Test
359    public void twilightSchedule_whenStartedAfterNight_ifOnBeforeNight_turnsOff() {
360        setAutoModeTwilight(-120 /* sunsetOffset */, -60 /* sunriseOffset */);
361        setActivated(true /* activated */, -180 /* lastActivatedTimeOffset */);
362
363        startService();
364        assertActivated(false /* activated */);
365    }
366
367    @Test
368    public void twilightSchedule_whenStartedAfterNight_ifOnDuringNight_turnsOff() {
369        setAutoModeTwilight(-120 /* sunsetOffset */, -60 /* sunriseOffset */);
370        setActivated(true /* activated */, -90 /* lastActivatedTimeOffset */);
371
372        startService();
373        assertActivated(false /* activated */);
374    }
375
376    @Test
377    public void twilightSchedule_whenStartedAfterNight_ifOnInFuture_turnsOff() {
378        setAutoModeTwilight(-120 /* sunsetOffset */, -60 /* sunriseOffset */);
379        setActivated(true /* activated */, 30 /* lastActivatedTimeOffset */);
380
381        startService();
382        assertActivated(false /* activated */);
383    }
384
385    @Test
386    public void twilightSchedule_whenStartedBeforeNight_ifOffAfterNight_turnsOff() {
387        setAutoModeTwilight(60 /* sunsetOffset */, 120 /* sunriseOffset */);
388        setActivated(false /* activated */, 180 /* lastActivatedTimeOffset */);
389
390        startService();
391        assertActivated(false /* activated */);
392    }
393
394    @Test
395    public void twilightSchedule_whenStartedBeforeNight_ifOffBeforeNight_turnsOff() {
396        setAutoModeTwilight(60 /* sunsetOffset */, 120 /* sunriseOffset */);
397        setActivated(false /* activated */, 30 /* lastActivatedTimeOffset */);
398
399        startService();
400        assertActivated(false /* activated */);
401    }
402
403    @Test
404    public void twilightSchedule_whenStartedBeforeNight_ifOffDuringNight_turnsOff() {
405        setAutoModeTwilight(60 /* sunsetOffset */, 120 /* sunriseOffset */);
406        setActivated(false /* activated */, 90 /* lastActivatedTimeOffset */);
407
408        startService();
409        assertActivated(false /* activated */);
410    }
411
412    @Test
413    public void twilightSchedule_whenStartedBeforeNight_ifOffInPast_turnsOff() {
414        setAutoModeTwilight(60 /* sunsetOffset */, 120 /* sunriseOffset */);
415        setActivated(false /* activated */, -30 /* lastActivatedTimeOffset */);
416
417        startService();
418        assertActivated(false /* activated */);
419    }
420
421    @Test
422    public void twilightSchedule_whenStartedBeforeNight_ifOnAfterNight_turnsOff() {
423        setAutoModeTwilight(60 /* sunsetOffset */, 120 /* sunriseOffset */);
424        setActivated(true /* activated */, 180 /* lastActivatedTimeOffset */);
425
426        startService();
427        assertActivated(false /* activated */);
428    }
429
430    @Test
431    public void twilightSchedule_whenStartedBeforeNight_ifOnBeforeNight_turnsOff() {
432        setAutoModeTwilight(60 /* sunsetOffset */, 120 /* sunriseOffset */);
433        setActivated(true /* activated */, 30 /* lastActivatedTimeOffset */);
434
435        startService();
436        assertActivated(false /* activated */);
437    }
438
439    @Test
440    public void twilightSchedule_whenStartedBeforeNight_ifOnDuringNight_turnsOff() {
441        setAutoModeTwilight(60 /* sunsetOffset */, 120 /* sunriseOffset */);
442        setActivated(true /* activated */, 90 /* lastActivatedTimeOffset */);
443
444        startService();
445        assertActivated(false /* activated */);
446    }
447
448    @Test
449    public void twilightSchedule_whenStartedBeforeNight_ifOnInPast_turnsOn() {
450        setAutoModeTwilight(60 /* sunsetOffset */, 120 /* sunriseOffset */);
451        setActivated(true /* activated */, -30 /* lastActivatedTimeOffset */);
452
453        startService();
454        assertActivated(true /* activated */);
455    }
456
457    @Test
458    public void twilightSchedule_whenStartedDuringNight_ifOffAfterNight_turnsOn() {
459        setAutoModeTwilight(-60 /* sunsetOffset */, 60 /* sunriseOffset */);
460        setActivated(false /* activated */, 90 /* lastActivatedTimeOffset */);
461
462        startService();
463        assertActivated(true /* activated */);
464    }
465
466    @Test
467    public void twilightSchedule_whenStartedDuringNight_ifOffBeforeNight_turnsOn() {
468        setAutoModeTwilight(-60 /* sunsetOffset */, 60 /* sunriseOffset */);
469        setActivated(false /* activated */, -90 /* lastActivatedTimeOffset */);
470
471        startService();
472        assertActivated(true /* activated */);
473    }
474
475    @Test
476    public void twilightSchedule_whenStartedDuringNight_ifOffDuringNightInFuture_turnsOn() {
477        setAutoModeTwilight(-60 /* sunsetOffset */, 60 /* sunriseOffset */);
478        setActivated(false /* activated */, 30 /* lastActivatedTimeOffset */);
479
480        startService();
481        assertActivated(true /* activated */);
482    }
483
484    @Test
485    public void twilightSchedule_whenStartedDuringNight_ifOffDuringNightInPast_turnsOff() {
486        setAutoModeTwilight(-60 /* sunsetOffset */, 60 /* sunriseOffset */);
487        setActivated(false /* activated */, -30 /* lastActivatedTimeOffset */);
488
489        startService();
490        assertActivated(false /* activated */);
491    }
492
493    @Test
494    public void twilightSchedule_whenStartedDuringNight_ifOnAfterNight_turnsOn() {
495        setAutoModeTwilight(-60 /* sunsetOffset */, 60 /* sunriseOffset */);
496        setActivated(true /* activated */, 90 /* lastActivatedTimeOffset */);
497
498        startService();
499        assertActivated(true /* activated */);
500    }
501
502    @Test
503    public void twilightSchedule_whenStartedDuringNight_ifOnBeforeNight_turnsOn() {
504        setAutoModeTwilight(-60 /* sunsetOffset */, 60 /* sunriseOffset */);
505        setActivated(true /* activated */, -90 /* lastActivatedTimeOffset */);
506
507        startService();
508        assertActivated(true /* activated */);
509    }
510
511    @Test
512    public void twilightSchedule_whenStartedDuringNight_ifOnDuringNightInFuture_turnsOn() {
513        setAutoModeTwilight(-60 /* sunsetOffset */, 60 /* sunriseOffset */);
514        setActivated(true /* activated */, 30 /* lastActivatedTimeOffset */);
515
516        startService();
517        assertActivated(true /* activated */);
518    }
519
520    @Test
521    public void twilightSchedule_whenStartedDuringNight_ifOnDuringNightInPast_turnsOn() {
522        setAutoModeTwilight(-60 /* sunsetOffset */, 60 /* sunriseOffset */);
523        setActivated(true /* activated */, -30 /* lastActivatedTimeOffset */);
524
525        startService();
526        assertActivated(true /* activated */);
527    }
528
529    /**
530     * Convenience for making a {@link LocalTime} instance with an offset relative to now.
531     *
532     * @param offsetMinutes the offset relative to now (in minutes)
533     * @return the LocalTime instance
534     */
535    private LocalTime getLocalTimeRelativeToNow(int offsetMinutes) {
536        final Calendar c = Calendar.getInstance();
537        c.add(Calendar.MINUTE, offsetMinutes);
538        return new LocalTime(c.get(Calendar.HOUR_OF_DAY), c.get(Calendar.MINUTE));
539    }
540
541    /**
542     * Configures Night display to use a custom schedule.
543     *
544     * @param startTimeOffset the offset relative to now to activate Night display (in minutes)
545     * @param endTimeOffset   the offset relative to now to deactivate Night display (in minutes)
546     */
547    private void setAutoModeCustom(int startTimeOffset, int endTimeOffset) {
548        mNightDisplayController.setAutoMode(NightDisplayController.AUTO_MODE_CUSTOM);
549        mNightDisplayController.setCustomStartTime(getLocalTimeRelativeToNow(startTimeOffset));
550        mNightDisplayController.setCustomEndTime(getLocalTimeRelativeToNow(endTimeOffset));
551    }
552
553    /**
554     * Configures Night display to use the twilight schedule.
555     *
556     * @param sunsetOffset  the offset relative to now for sunset (in minutes)
557     * @param sunriseOffset the offset relative to now for sunrise (in minutes)
558     */
559    private void setAutoModeTwilight(int sunsetOffset, int sunriseOffset) {
560        mNightDisplayController.setAutoMode(NightDisplayController.AUTO_MODE_TWILIGHT);
561
562        final LocalTime sunset = getLocalTimeRelativeToNow(sunsetOffset);
563        final LocalTime sunrise = getLocalTimeRelativeToNow(sunriseOffset);
564
565        final Calendar now = Calendar.getInstance();
566        long sunsetMillis = sunset.getDateTimeBefore(now).getTimeInMillis();
567        long sunriseMillis = sunrise.getDateTimeBefore(now).getTimeInMillis();
568        if (sunsetMillis < sunriseMillis) {
569            sunsetMillis = sunset.getDateTimeAfter(now).getTimeInMillis();
570        } else {
571            sunriseMillis = sunrise.getDateTimeAfter(now).getTimeInMillis();
572        }
573
574        final TwilightState state = new TwilightState(sunriseMillis, sunsetMillis);
575        doReturn(state).when(mTwilightManager).getLastTwilightState();
576    }
577
578    /**
579     * Configures the Night display activated state.
580     *
581     * @param activated               {@code true} if Night display should be activated
582     * @param lastActivatedTimeOffset the offset relative to now to record that Night display was
583                                      activated (in minutes)
584     */
585    private void setActivated(boolean activated, int lastActivatedTimeOffset) {
586        mNightDisplayController.setActivated(activated);
587
588        final Calendar c = Calendar.getInstance();
589        c.add(Calendar.MINUTE, lastActivatedTimeOffset);
590        Secure.putLongForUser(mContext.getContentResolver(),
591                Secure.NIGHT_DISPLAY_LAST_ACTIVATED_TIME, c.getTimeInMillis(), mUserId);
592    }
593
594    /**
595     * Convenience method to start {@link #mNightDisplayService}.
596     */
597    private void startService() {
598        Secure.putIntForUser(mContext.getContentResolver(), Secure.USER_SETUP_COMPLETE, 1, mUserId);
599
600        InstrumentationRegistry.getInstrumentation().runOnMainSync(new Runnable() {
601            @Override
602            public void run() {
603                mNightDisplayService.onStart();
604                mNightDisplayService.onBootPhase(SystemService.PHASE_BOOT_COMPLETED);
605                mNightDisplayService.onStartUser(mUserId);
606            }
607        });
608    }
609
610    /**
611     * Convenience method for asserting whether Night display should be activated.
612     *
613     * @param activated the expected activated state of Night display
614     */
615    private void assertActivated(boolean activated) {
616        assertWithMessage("Invalid Night display activated state")
617                .that(mNightDisplayController.isActivated())
618                .isEqualTo(activated);
619    }
620}
621