1 /*
2  * Copyright (C) 2021 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.car.systeminterface;
18 
19 import static android.car.feature.Flags.FLAG_MULTI_DISPLAY_BRIGHTNESS_CONTROL;
20 import static android.car.user.CarUserManager.USER_LIFECYCLE_EVENT_TYPE_SWITCHING;
21 import static android.car.user.CarUserManager.USER_LIFECYCLE_EVENT_TYPE_UNLOCKED;
22 
23 import static com.google.common.truth.Truth.assertThat;
24 
25 import static org.mockito.AdditionalMatchers.or;
26 import static org.mockito.ArgumentMatchers.any;
27 import static org.mockito.ArgumentMatchers.anyFloat;
28 import static org.mockito.ArgumentMatchers.anyInt;
29 import static org.mockito.ArgumentMatchers.anyLong;
30 import static org.mockito.ArgumentMatchers.anyString;
31 import static org.mockito.ArgumentMatchers.eq;
32 import static org.mockito.ArgumentMatchers.isNull;
33 import static org.mockito.Mockito.clearInvocations;
34 import static org.mockito.Mockito.doAnswer;
35 import static org.mockito.Mockito.never;
36 import static org.mockito.Mockito.times;
37 import static org.mockito.Mockito.verify;
38 import static org.mockito.Mockito.when;
39 
40 import android.car.builtin.view.DisplayHelper;
41 import android.car.user.CarUserManager.UserLifecycleEvent;
42 import android.car.user.CarUserManager.UserLifecycleListener;
43 import android.content.ContentResolver;
44 import android.content.Context;
45 import android.database.ContentObserver;
46 import android.hardware.display.DisplayManager;
47 import android.hardware.display.DisplayManager.DisplayListener;
48 import android.net.Uri;
49 import android.os.PowerManager;
50 import android.os.UserManager;
51 import android.platform.test.annotations.DisableFlags;
52 import android.platform.test.annotations.EnableFlags;
53 import android.platform.test.flag.junit.SetFlagsRule;
54 import android.platform.test.ravenwood.RavenwoodRule;
55 import android.view.Display;
56 
57 import com.android.car.power.CarPowerManagementService;
58 import com.android.car.provider.Settings;
59 import com.android.car.user.CarUserService;
60 import com.android.car.user.CurrentUserFetcher;
61 
62 import org.junit.Before;
63 import org.junit.Rule;
64 import org.junit.Test;
65 import org.junit.runner.RunWith;
66 import org.mockito.ArgumentCaptor;
67 import org.mockito.Mock;
68 import org.mockito.junit.MockitoJUnitRunner;
69 
70 import java.util.ArrayList;
71 
72 @RunWith(MockitoJUnitRunner.Silent.class)
73 public final class DisplayInterfaceTest {
74 
75     private static final int MAIN_DISPLAY_ID = Display.DEFAULT_DISPLAY;
76     private static final int DISTANT_DISPLAY_ID = 2;
77     private static final int VIRTUAL_DISPLAY_ID = 3;
78     private static final int OVERLAY_DISPLAY_ID = 4;
79 
80     private static final int GLOBAL_BRIGHTNESS = 125;
81     private static final int GLOBAL_BRIGHTNESS_2 = 130;
82     private static final float DISPLAY_MANAGER_BRIGHTNESS_1 = 0.5f;
83     private static final float DISPLAY_MANAGER_BRIGHTNESS_2 = 0.6f;
84 
85     private static final int MIN_SCREEN_BRIGHTNESS_SETTING = 1;
86     private static final int MAX_SCREEN_BRIGHTNESS_SETTING = 255;
87 
88     @Rule
89     public final RavenwoodRule mRavenwood = new RavenwoodRule.Builder()
90             .setProvideMainThread(true)
91             .setSystemPropertyImmutable("android.car.user_hal_timeout", 0).build();
92     @Rule
93     public final SetFlagsRule mSetFlagsRule = new SetFlagsRule();
94 
95     @Mock
96     private Context mContext;
97 
98     @Mock
99     private WakeLockInterface mWakeLockInterface;
100 
101     @Mock
102     private CarPowerManagementService mCarPowerManagementService;
103 
104     @Mock
105     private DisplayManager mDisplayManager;
106 
107     @Mock
108     private ContentResolver mContentResolver;
109 
110     @Mock
111     private CarUserService mCarUserService;
112 
113     @Mock
114     private PowerManager mPowerManager;
115 
116     @Mock
117     private UserManager mUserManager;
118 
119     @Mock
120     private DisplayHelperInterface mDisplayHelper;
121 
122     @Mock
123     private Settings mSettings;
124 
125     @Mock
126     private Display mDisplay;
127 
128     @Mock
129     private CurrentUserFetcher mCurrentUserFetcher;
130 
131     @Mock
132     private Display mDistantDisplay;
133     @Mock
134     private Display mVirtualDisplay;
135     @Mock
136     private Display mOverlayDisplay;
137 
138     private DisplayInterface.DefaultImpl mDisplayInterface;
139 
addDisplay(Display display, int displayId, int displayType)140     private void addDisplay(Display display, int displayId, int displayType) {
141         when(display.getDisplayId()).thenReturn(displayId);
142         when(mDisplayManager.getDisplay(displayId)).thenReturn(display);
143         when(mDisplayHelper.getType(display)).thenReturn(displayType);
144         when(mCurrentUserFetcher.getCurrentUser()).thenReturn(0);
145     }
146 
147     @Before
setUp()148     public void setUp() throws Exception {
149         when(mSettings.getIntSystem(eq(mContentResolver), anyString())).thenReturn(
150                 GLOBAL_BRIGHTNESS);
151         when(mSettings.getUriForSystem(anyString())).thenReturn(Uri.parse(""));
152         when(mContext.createContextAsUser(any(), anyInt())).thenReturn(mContext);
153         when(mContext.getContentResolver()).thenReturn(mContentResolver);
154         when(mContext.getSystemService(DisplayManager.class)).thenReturn(mDisplayManager);
155         when(mContext.getSystemService(PowerManager.class)).thenReturn(mPowerManager);
156         when(mContext.getSystemService(UserManager.class)).thenReturn(mUserManager);
157         when(mPowerManager.getMinimumScreenBrightnessSetting()).thenReturn(
158                 MIN_SCREEN_BRIGHTNESS_SETTING);
159         when(mPowerManager.getMaximumScreenBrightnessSetting()).thenReturn(
160                 MAX_SCREEN_BRIGHTNESS_SETTING);
161 
162         addDisplay(mDisplay, MAIN_DISPLAY_ID, DisplayHelper.TYPE_INTERNAL);
163         addDisplay(mDistantDisplay, DISTANT_DISPLAY_ID, DisplayHelper.TYPE_INTERNAL);
164         addDisplay(mVirtualDisplay, VIRTUAL_DISPLAY_ID, DisplayHelper.TYPE_VIRTUAL);
165         addDisplay(mOverlayDisplay, OVERLAY_DISPLAY_ID, DisplayHelper.TYPE_OVERLAY);
166     }
167 
168     @Test
169     @DisableFlags(FLAG_MULTI_DISPLAY_BRIGHTNESS_CONTROL)
testStartDisplayStateMonitoring_visibleBgUsersSupported()170     public void testStartDisplayStateMonitoring_visibleBgUsersSupported() {
171         when(mDisplayManager.getDisplays()).thenReturn(new Display[]{
172                 mDisplay, mDistantDisplay, mVirtualDisplay, mOverlayDisplay});
173         when(mDisplay.getState()).thenReturn(Display.STATE_ON);
174         when(mDistantDisplay.getState()).thenReturn(Display.STATE_ON);
175         when(mDisplayManager.getBrightness(MAIN_DISPLAY_ID)).thenReturn(
176                 DISPLAY_MANAGER_BRIGHTNESS_1);
177         when(mDisplayManager.getBrightness(DISTANT_DISPLAY_ID)).thenReturn(
178                 DISPLAY_MANAGER_BRIGHTNESS_2);
179 
180         createDisplayInterface(/* visibleBgUsersSupported= */ true);
181 
182         mDisplayInterface.startDisplayStateMonitoring();
183 
184         verify(mDisplayManager).registerDisplayListener(any(), isNull(), anyLong(), anyLong());
185         verify(mCarUserService).addUserLifecycleListener(any(), any());
186         var intCaptor = ArgumentCaptor.forClass(Integer.class);
187         verify(mCarPowerManagementService, times(2)).sendDisplayBrightness(
188                 or(eq(MAIN_DISPLAY_ID), eq(DISTANT_DISPLAY_ID)), intCaptor.capture());
189         int brightness1 = intCaptor.getAllValues().get(0);
190         int brightness2 = intCaptor.getAllValues().get(1);
191         assertThat(brightness1).isNotEqualTo(0);
192         assertThat(brightness2).isNotEqualTo(0);
193         assertThat(brightness1).isNotEqualTo(brightness2);
194     }
195 
196     @Test
197     @DisableFlags(FLAG_MULTI_DISPLAY_BRIGHTNESS_CONTROL)
testStartDisplayStateMonitoring_visibleBgUsersNotSupported()198     public void testStartDisplayStateMonitoring_visibleBgUsersNotSupported() {
199         when(mDisplayManager.getDisplays()).thenReturn(new Display[]{mDisplay, mDistantDisplay});
200         when(mDisplay.getState()).thenReturn(Display.STATE_ON);
201         when(mDistantDisplay.getState()).thenReturn(Display.STATE_ON);
202 
203         createDisplayInterface(/* visibleBgUsersSupported= */ false);
204 
205         mDisplayInterface.startDisplayStateMonitoring();
206 
207         verify(mContentResolver).registerContentObserver(any(), eq(false), any());
208         verify(mCarUserService).addUserLifecycleListener(any(), any());
209         verify(mCarPowerManagementService, times(2)).sendDisplayBrightnessLegacy(anyInt());
210     }
211 
212     @Test
213     @EnableFlags(FLAG_MULTI_DISPLAY_BRIGHTNESS_CONTROL)
testStartDisplayStateMonitoring_multiDisplayControlSupported()214     public void testStartDisplayStateMonitoring_multiDisplayControlSupported() {
215         when(mDisplayManager.getDisplays()).thenReturn(new Display[]{mDisplay, mDistantDisplay});
216         when(mDisplay.getState()).thenReturn(Display.STATE_ON);
217         when(mDistantDisplay.getState()).thenReturn(Display.STATE_ON);
218 
219         createDisplayInterface(/* visibleBgUsersSupported= */ false);
220 
221         mDisplayInterface.startDisplayStateMonitoring();
222 
223         verify(mDisplayManager).registerDisplayListener(any(), isNull(), anyLong(), anyLong());
224         verify(mCarUserService).addUserLifecycleListener(any(), any());
225         // If multi display brightness is supported, even if MUMD is not enabled, we must refresh
226         // all display's brightness.
227         verify(mCarPowerManagementService, times(2)).sendDisplayBrightness(
228                 or(eq(MAIN_DISPLAY_ID), eq(DISTANT_DISPLAY_ID)), anyInt());
229     }
230 
231     @Test
232     @DisableFlags(FLAG_MULTI_DISPLAY_BRIGHTNESS_CONTROL)
testStopDisplayStateMonitoring_visibleBgUsersSupported()233     public void testStopDisplayStateMonitoring_visibleBgUsersSupported() {
234         when(mDisplayManager.getDisplays()).thenReturn(new Display[]{mDisplay});
235         when(mDisplayManager.getBrightness(anyInt())).thenReturn(DISPLAY_MANAGER_BRIGHTNESS_1);
236 
237         createDisplayInterface(/* visibleBgUsersSupported= */ true);
238         mDisplayInterface.startDisplayStateMonitoring();
239         mDisplayInterface.stopDisplayStateMonitoring();
240 
241         verify(mDisplayManager).unregisterDisplayListener(any());
242         verify(mCarUserService).removeUserLifecycleListener(any());
243     }
244 
245     @Test
246     @DisableFlags(FLAG_MULTI_DISPLAY_BRIGHTNESS_CONTROL)
testStopDisplayStateMonitoring_visibleBgUsersNoSupported()247     public void testStopDisplayStateMonitoring_visibleBgUsersNoSupported() {
248         when(mDisplayManager.getDisplays()).thenReturn(new Display[]{mDisplay});
249 
250         createDisplayInterface(/* visibleBgUsersSupported= */ false);
251         mDisplayInterface.startDisplayStateMonitoring();
252         mDisplayInterface.stopDisplayStateMonitoring();
253 
254         verify(mContentResolver).unregisterContentObserver(any());
255         verify(mCarUserService).removeUserLifecycleListener(any());
256     }
257 
258     @Test
259     @EnableFlags(FLAG_MULTI_DISPLAY_BRIGHTNESS_CONTROL)
testOnUserSwitchEvent_notUserSwitchingEvent()260     public void testOnUserSwitchEvent_notUserSwitchingEvent() {
261         when(mDisplayManager.getDisplays()).thenReturn(new Display[]{mDisplay});
262 
263         createDisplayInterface(/* visibleBgUsersSupported= */ false);
264         mDisplayInterface.startDisplayStateMonitoring();
265         var userLifecycleListenerCaptor = ArgumentCaptor.forClass(UserLifecycleListener.class);
266 
267         verify(mCarUserService).addUserLifecycleListener(any(),
268                 userLifecycleListenerCaptor.capture());
269         clearInvocations(mCarPowerManagementService);
270 
271         userLifecycleListenerCaptor.getValue().onEvent(
272                 new UserLifecycleEvent(USER_LIFECYCLE_EVENT_TYPE_UNLOCKED, /* to= */ 0));
273 
274         verify(mCarPowerManagementService, never()).sendDisplayBrightness(anyInt(), anyInt());
275     }
276 
277     @Test
278     @EnableFlags(FLAG_MULTI_DISPLAY_BRIGHTNESS_CONTROL)
testOnUserSwitchEvent_newUserNotDriver()279     public void testOnUserSwitchEvent_newUserNotDriver() {
280         when(mDisplayManager.getDisplays()).thenReturn(new Display[]{mDisplay});
281 
282         createDisplayInterface(/* visibleBgUsersSupported= */ false);
283         mDisplayInterface.startDisplayStateMonitoring();
284         var userLifecycleListenerCaptor = ArgumentCaptor.forClass(UserLifecycleListener.class);
285 
286         verify(mCarUserService).addUserLifecycleListener(any(),
287                 userLifecycleListenerCaptor.capture());
288         clearInvocations(mCarPowerManagementService);
289 
290         userLifecycleListenerCaptor.getValue().onEvent(
291                 new UserLifecycleEvent(USER_LIFECYCLE_EVENT_TYPE_SWITCHING, /* to= */ 1));
292 
293         verify(mCarPowerManagementService, never()).sendDisplayBrightness(anyInt(), anyInt());
294     }
295 
296     @Test
297     @EnableFlags(FLAG_MULTI_DISPLAY_BRIGHTNESS_CONTROL)
testOnUserSwitchEvent()298     public void testOnUserSwitchEvent() {
299         when(mDisplayManager.getDisplays()).thenReturn(new Display[]{mDisplay, mDistantDisplay});
300 
301         createDisplayInterface(/* visibleBgUsersSupported= */ false);
302         mDisplayInterface.startDisplayStateMonitoring();
303 
304         var userLifecycleListenerCaptor = ArgumentCaptor.forClass(UserLifecycleListener.class);
305         verify(mCarUserService).addUserLifecycleListener(any(),
306                 userLifecycleListenerCaptor.capture());
307         clearInvocations(mCarPowerManagementService);
308 
309         userLifecycleListenerCaptor.getValue().onEvent(
310                 new UserLifecycleEvent(USER_LIFECYCLE_EVENT_TYPE_SWITCHING, /* to= */ 0));
311 
312         verify(mCarPowerManagementService, times(2)).sendDisplayBrightness(
313                 or(eq(MAIN_DISPLAY_ID), eq(DISTANT_DISPLAY_ID)), anyInt());
314     }
315 
316     @Test
317     @EnableFlags(FLAG_MULTI_DISPLAY_BRIGHTNESS_CONTROL)
testOnDisplayBrightnessChangeFromVhal_ForMainDisplay()318     public void testOnDisplayBrightnessChangeFromVhal_ForMainDisplay() {
319         when(mDisplayManager.getDisplays()).thenReturn(new Display[]{mDisplay, mDistantDisplay});
320 
321         createDisplayInterface(/* visibleBgUsersSupported= */ false);
322         mDisplayInterface.onDisplayBrightnessChangeFromVhal(MAIN_DISPLAY_ID,
323                 /* percentBright= */ 50);
324 
325         verify(mDisplayManager).setBrightness(eq(MAIN_DISPLAY_ID), anyFloat());
326     }
327 
328     @Test
329     @EnableFlags(FLAG_MULTI_DISPLAY_BRIGHTNESS_CONTROL)
testOnDisplayBrightnessChangeFromVhal_ForDistantDisplay()330     public void testOnDisplayBrightnessChangeFromVhal_ForDistantDisplay() {
331         when(mDisplayManager.getDisplays()).thenReturn(new Display[]{mDisplay, mDistantDisplay});
332 
333         createDisplayInterface(/* visibleBgUsersSupported= */ false);
334         mDisplayInterface.onDisplayBrightnessChangeFromVhal(DISTANT_DISPLAY_ID,
335                 /* percentBright= */ 50);
336 
337         verify(mDisplayManager).setBrightness(eq(DISTANT_DISPLAY_ID), anyFloat());
338     }
339 
340     @Test
341     @DisableFlags(FLAG_MULTI_DISPLAY_BRIGHTNESS_CONTROL)
testDisplayBrightnessChangeFromSettings()342     public void testDisplayBrightnessChangeFromSettings() throws Exception {
343         when(mDisplayManager.getDisplays()).thenReturn(new Display[]{mDisplay, mDistantDisplay});
344         when(mDisplay.getState()).thenReturn(Display.STATE_ON);
345         when(mDistantDisplay.getState()).thenReturn(Display.STATE_ON);
346 
347         createDisplayInterface(/* visibleBgUsersSupported= */ false);
348 
349         mDisplayInterface.startDisplayStateMonitoring();
350 
351         var observerCaptor = ArgumentCaptor.forClass(ContentObserver.class);
352         verify(mContentResolver).registerContentObserver(any(), eq(false),
353                 observerCaptor.capture());
354         clearInvocations(mCarPowerManagementService);
355 
356         // Simulate user changes the global brightness setting to GLOBAL_BRIGHTNESS_2.
357         when(mSettings.getIntSystem(eq(mContentResolver), anyString())).thenReturn(
358                 GLOBAL_BRIGHTNESS_2);
359 
360         observerCaptor.getValue().onChange(true);
361 
362         verify(mCarPowerManagementService).sendDisplayBrightnessLegacy(anyInt());
363     }
364 
365     @Test
366     @DisableFlags(FLAG_MULTI_DISPLAY_BRIGHTNESS_CONTROL)
testDisplayBrightnessChangeFromSettings_ignoreRecentChange()367     public void testDisplayBrightnessChangeFromSettings_ignoreRecentChange() throws Exception {
368         when(mDisplayManager.getDisplays()).thenReturn(new Display[]{mDisplay, mDistantDisplay});
369         when(mDisplay.getState()).thenReturn(Display.STATE_ON);
370         when(mDistantDisplay.getState()).thenReturn(Display.STATE_ON);
371 
372         createDisplayInterface(/* visibleBgUsersSupported= */ false);
373 
374         mDisplayInterface.startDisplayStateMonitoring();
375 
376         var observerCaptor = ArgumentCaptor.forClass(ContentObserver.class);
377         verify(mContentResolver).registerContentObserver(any(), eq(false),
378                 observerCaptor.capture());
379         clearInvocations(mCarPowerManagementService);
380 
381         // This variable stores the global brightness settings. Need to use a list to be
382         // effective final.
383         ArrayList<Integer> brightness = new ArrayList<>();
384 
385         doAnswer((inv) -> {
386             brightness.add(inv.getArgument(2));
387             return null;
388         }).when(mSettings).putIntSystem(eq(mContentResolver), anyString(), anyInt());
389         when(mSettings.getIntSystem(eq(mContentResolver), anyString())).thenAnswer((inv) -> {
390             return brightness.get(0);
391         });
392 
393         // Simulate a brightness change from VHAL.
394         mDisplayInterface.onDisplayBrightnessChangeFromVhal(MAIN_DISPLAY_ID,
395                 /* percentBright= */ 50);
396         // This should trigger an onChange event.
397         observerCaptor.getValue().onChange(true);
398 
399         // Because the brightness event is caused by VHAL, so we must ignore it
400         // and not report back to VHAL again.
401         verify(mCarPowerManagementService, never()).sendDisplayBrightnessLegacy(anyInt());
402     }
403 
404     @Test
405     @EnableFlags(FLAG_MULTI_DISPLAY_BRIGHTNESS_CONTROL)
testDisplayBrightnessChangeFromDisplayManager()406     public void testDisplayBrightnessChangeFromDisplayManager() throws Exception {
407         when(mDisplayManager.getDisplays()).thenReturn(new Display[]{mDisplay, mDistantDisplay});
408         when(mDisplay.getState()).thenReturn(Display.STATE_ON);
409         when(mDistantDisplay.getState()).thenReturn(Display.STATE_ON);
410 
411         createDisplayInterface(/* visibleBgUsersSupported= */ false);
412 
413         mDisplayInterface.startDisplayStateMonitoring();
414 
415         var displayListenerCaptor = ArgumentCaptor.forClass(DisplayListener.class);
416         verify(mDisplayManager).registerDisplayListener(displayListenerCaptor.capture(), isNull(),
417                 anyLong(), anyLong());
418         clearInvocations(mCarPowerManagementService);
419 
420         // Simulate user changes the global brightness setting to GLOBAL_BRIGHTNESS_2.
421         when(mDisplayManager.getBrightness(anyInt())).thenReturn(DISPLAY_MANAGER_BRIGHTNESS_2);
422         displayListenerCaptor.getValue().onDisplayChanged(MAIN_DISPLAY_ID);
423 
424         verify(mCarPowerManagementService).sendDisplayBrightness(eq(MAIN_DISPLAY_ID), anyInt());
425     }
426 
427     @Test
428     @EnableFlags(FLAG_MULTI_DISPLAY_BRIGHTNESS_CONTROL)
testDisplayBrightnessChangeFromDisplayManager_ignoreRecentChange()429     public void testDisplayBrightnessChangeFromDisplayManager_ignoreRecentChange()
430             throws Exception {
431         when(mDisplayManager.getDisplays()).thenReturn(new Display[]{mDisplay, mDistantDisplay});
432         when(mDisplay.getState()).thenReturn(Display.STATE_ON);
433         when(mDistantDisplay.getState()).thenReturn(Display.STATE_ON);
434 
435         createDisplayInterface(/* visibleBgUsersSupported= */ false);
436 
437         mDisplayInterface.startDisplayStateMonitoring();
438 
439         var displayListenerCaptor = ArgumentCaptor.forClass(DisplayListener.class);
440         verify(mDisplayManager).registerDisplayListener(displayListenerCaptor.capture(), isNull(),
441                 anyLong(), anyLong());
442         clearInvocations(mCarPowerManagementService);
443 
444         // This variable stores the brightness settings. Need to use a list to be
445         // effective final.
446         ArrayList<Float> brightness = new ArrayList<>();
447 
448         doAnswer((inv) -> {
449             brightness.add(inv.getArgument(1));
450             return null;
451         }).when(mDisplayManager).setBrightness(eq(MAIN_DISPLAY_ID), anyFloat());
452         when(mDisplayManager.getBrightness(eq(MAIN_DISPLAY_ID))).thenAnswer((inv) -> {
453             return brightness.get(0);
454         });
455 
456         // Simulate a brightness change from VHAL.
457         mDisplayInterface.onDisplayBrightnessChangeFromVhal(MAIN_DISPLAY_ID,
458                 /* percentBright= */ 50);
459         // This should trigger an onDisplayChanged event.
460         displayListenerCaptor.getValue().onDisplayChanged(MAIN_DISPLAY_ID);
461 
462         // Because the brightness event is caused by VHAL, so we must ignore it
463         // and not report back to VHAL again.
464         verify(mCarPowerManagementService, never()).sendDisplayBrightness(anyInt(), anyInt());
465     }
466 
467     @Test
468     @EnableFlags(FLAG_MULTI_DISPLAY_BRIGHTNESS_CONTROL)
testIsAnyDisplayEnabled_on_beforeStartMonitoring()469     public void testIsAnyDisplayEnabled_on_beforeStartMonitoring() {
470         when(mDisplayManager.getDisplays()).thenReturn(new Display[]{
471                 mDisplay, mDistantDisplay, mVirtualDisplay, mOverlayDisplay});
472         when(mDisplay.getState()).thenReturn(Display.STATE_ON);
473         when(mDistantDisplay.getState()).thenReturn(Display.STATE_OFF);
474         when(mDisplayManager.getBrightness(MAIN_DISPLAY_ID)).thenReturn(
475                 DISPLAY_MANAGER_BRIGHTNESS_1);
476         when(mDisplayManager.getBrightness(DISTANT_DISPLAY_ID)).thenReturn(
477                 DISPLAY_MANAGER_BRIGHTNESS_2);
478 
479         createDisplayInterface(/* visibleBgUsersSupported= */ true);
480 
481         assertThat(mDisplayInterface.isAnyDisplayEnabled()).isTrue();
482     }
483 
484     @Test
485     @EnableFlags(FLAG_MULTI_DISPLAY_BRIGHTNESS_CONTROL)
testIsAnyDisplayEnabled_off_beforeStartMonitoring()486     public void testIsAnyDisplayEnabled_off_beforeStartMonitoring() {
487         when(mDisplayManager.getDisplays()).thenReturn(new Display[]{
488                 mDisplay, mDistantDisplay, mVirtualDisplay, mOverlayDisplay});
489         when(mDisplay.getState()).thenReturn(Display.STATE_OFF);
490         when(mDistantDisplay.getState()).thenReturn(Display.STATE_OFF);
491         when(mDisplayManager.getBrightness(MAIN_DISPLAY_ID)).thenReturn(
492                 DISPLAY_MANAGER_BRIGHTNESS_1);
493         when(mDisplayManager.getBrightness(DISTANT_DISPLAY_ID)).thenReturn(
494                 DISPLAY_MANAGER_BRIGHTNESS_2);
495 
496         createDisplayInterface(/* visibleBgUsersSupported= */ true);
497 
498         assertThat(mDisplayInterface.isAnyDisplayEnabled()).isFalse();
499     }
500 
501     @Test
502     @EnableFlags(FLAG_MULTI_DISPLAY_BRIGHTNESS_CONTROL)
testSetAllDisplayState_beforeStartMonitoring()503     public void testSetAllDisplayState_beforeStartMonitoring() {
504         when(mDisplayManager.getDisplays()).thenReturn(new Display[]{
505                 mDisplay, mDistantDisplay, mVirtualDisplay, mOverlayDisplay});
506         when(mCarPowerManagementService.canTurnOnDisplay(anyInt())).thenReturn(true);
507 
508         createDisplayInterface(/* visibleBgUsersSupported= */ true);
509 
510         mDisplayInterface.setAllDisplayState(true);
511 
512         verify(mWakeLockInterface).switchToFullWakeLock(MAIN_DISPLAY_ID);
513         verify(mWakeLockInterface).switchToFullWakeLock(DISTANT_DISPLAY_ID);
514     }
515 
createDisplayInterface(boolean visibleBgUsersSupported)516     private void createDisplayInterface(boolean visibleBgUsersSupported) {
517         when(mUserManager.isVisibleBackgroundUsersSupported()).thenReturn(
518                 visibleBgUsersSupported);
519 
520         mDisplayInterface = new DisplayInterface.DefaultImpl(mContext, mWakeLockInterface,
521                 mSettings, mDisplayHelper, mCurrentUserFetcher);
522         mDisplayInterface.init(mCarPowerManagementService, mCarUserService);
523     }
524 }
525