1 /*
2  * Copyright (C) 2020 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.globalactions;
18 
19 import static android.content.pm.UserInfo.FLAG_ADMIN;
20 
21 import static com.google.common.truth.Truth.assertThat;
22 
23 import static org.mockito.ArgumentMatchers.any;
24 import static org.mockito.ArgumentMatchers.anyInt;
25 import static org.mockito.ArgumentMatchers.eq;
26 import static org.mockito.Mockito.doReturn;
27 import static org.mockito.Mockito.spy;
28 import static org.mockito.Mockito.times;
29 import static org.mockito.Mockito.verify;
30 import static org.mockito.Mockito.when;
31 
32 import android.app.IActivityManager;
33 import android.app.admin.DevicePolicyManager;
34 import android.app.trust.TrustManager;
35 import android.content.pm.PackageManager;
36 import android.content.pm.UserInfo;
37 import android.content.res.Resources;
38 import android.graphics.Color;
39 import android.media.AudioManager;
40 import android.os.Handler;
41 import android.os.UserManager;
42 import android.provider.Settings;
43 import android.service.dreams.IDreamManager;
44 import android.testing.AndroidTestingRunner;
45 import android.testing.TestableLooper;
46 import android.view.GestureDetector;
47 import android.view.IWindowManager;
48 import android.view.KeyEvent;
49 import android.view.MotionEvent;
50 import android.view.WindowManagerPolicyConstants;
51 import android.window.OnBackInvokedCallback;
52 import android.window.OnBackInvokedDispatcher;
53 
54 import androidx.test.filters.FlakyTest;
55 import androidx.test.filters.SmallTest;
56 
57 import com.android.internal.colorextraction.ColorExtractor;
58 import com.android.internal.logging.MetricsLogger;
59 import com.android.internal.logging.UiEventLogger;
60 import com.android.internal.statusbar.IStatusBarService;
61 import com.android.internal.widget.LockPatternUtils;
62 import com.android.keyguard.KeyguardUpdateMonitor;
63 import com.android.systemui.SysuiTestCase;
64 import com.android.systemui.animation.DialogLaunchAnimator;
65 import com.android.systemui.broadcast.BroadcastDispatcher;
66 import com.android.systemui.colorextraction.SysuiColorExtractor;
67 import com.android.systemui.plugins.GlobalActions;
68 import com.android.systemui.settings.UserContextProvider;
69 import com.android.systemui.settings.UserTracker;
70 import com.android.systemui.shade.ShadeController;
71 import com.android.systemui.statusbar.NotificationShadeWindowController;
72 import com.android.systemui.statusbar.VibratorHelper;
73 import com.android.systemui.statusbar.phone.CentralSurfaces;
74 import com.android.systemui.statusbar.phone.LightBarController;
75 import com.android.systemui.statusbar.policy.ConfigurationController;
76 import com.android.systemui.statusbar.policy.KeyguardStateController;
77 import com.android.systemui.telephony.TelephonyListenerManager;
78 import com.android.systemui.util.RingerModeLiveData;
79 import com.android.systemui.util.RingerModeTracker;
80 import com.android.systemui.util.settings.GlobalSettings;
81 import com.android.systemui.util.settings.SecureSettings;
82 
83 import org.junit.Before;
84 import org.junit.Test;
85 import org.junit.runner.RunWith;
86 import org.mockito.ArgumentCaptor;
87 import org.mockito.Captor;
88 import org.mockito.Mock;
89 import org.mockito.MockitoAnnotations;
90 
91 import java.util.List;
92 import java.util.Optional;
93 import java.util.concurrent.Executor;
94 
95 @SmallTest
96 @RunWith(AndroidTestingRunner.class)
97 @TestableLooper.RunWithLooper(setAsMainLooper = true)
98 public class GlobalActionsDialogLiteTest extends SysuiTestCase {
99     private GlobalActionsDialogLite mGlobalActionsDialogLite;
100 
101     @Mock private GlobalActions.GlobalActionsManager mWindowManagerFuncs;
102     @Mock private AudioManager mAudioManager;
103     @Mock private IDreamManager mDreamManager;
104     @Mock private DevicePolicyManager mDevicePolicyManager;
105     @Mock private LockPatternUtils mLockPatternUtils;
106     @Mock private BroadcastDispatcher mBroadcastDispatcher;
107     @Mock private TelephonyListenerManager mTelephonyListenerManager;
108     @Mock private GlobalSettings mGlobalSettings;
109     @Mock private SecureSettings mSecureSettings;
110     @Mock private Resources mResources;
111     @Mock private ConfigurationController mConfigurationController;
112     @Mock private UserTracker mUserTracker;
113     @Mock private KeyguardStateController mKeyguardStateController;
114     @Mock private UserManager mUserManager;
115     @Mock private TrustManager mTrustManager;
116     @Mock private IActivityManager mActivityManager;
117     @Mock private MetricsLogger mMetricsLogger;
118     @Mock private SysuiColorExtractor mColorExtractor;
119     @Mock private IStatusBarService mStatusBarService;
120     @Mock private LightBarController mLightBarController;
121     @Mock private NotificationShadeWindowController mNotificationShadeWindowController;
122     @Mock private IWindowManager mWindowManager;
123     @Mock private Executor mBackgroundExecutor;
124     @Mock private UiEventLogger mUiEventLogger;
125     @Mock private RingerModeTracker mRingerModeTracker;
126     @Mock private RingerModeLiveData mRingerModeLiveData;
127     @Mock private PackageManager mPackageManager;
128     @Mock private Handler mHandler;
129     @Mock private UserContextProvider mUserContextProvider;
130     @Mock private VibratorHelper mVibratorHelper;
131     @Mock private CentralSurfaces mCentralSurfaces;
132     @Mock private ShadeController mShadeController;
133     @Mock private KeyguardUpdateMonitor mKeyguardUpdateMonitor;
134     @Mock private DialogLaunchAnimator mDialogLaunchAnimator;
135     @Mock private OnBackInvokedDispatcher mOnBackInvokedDispatcher;
136     @Captor private ArgumentCaptor<OnBackInvokedCallback> mOnBackInvokedCallback;
137 
138     private TestableLooper mTestableLooper;
139 
140     @Before
setUp()141     public void setUp() throws Exception {
142         MockitoAnnotations.initMocks(this);
143         mTestableLooper = TestableLooper.get(this);
144         allowTestableLooperAsMainThread();
145 
146         when(mRingerModeTracker.getRingerMode()).thenReturn(mRingerModeLiveData);
147         when(mUserContextProvider.getUserContext()).thenReturn(mContext);
148         when(mResources.getConfiguration()).thenReturn(
149                 getContext().getResources().getConfiguration());
150 
151         mGlobalActionsDialogLite = new GlobalActionsDialogLite(mContext,
152                 mWindowManagerFuncs,
153                 mAudioManager,
154                 mDreamManager,
155                 mDevicePolicyManager,
156                 mLockPatternUtils,
157                 mBroadcastDispatcher,
158                 mTelephonyListenerManager,
159                 mGlobalSettings,
160                 mSecureSettings,
161                 mVibratorHelper,
162                 mResources,
163                 mConfigurationController,
164                 mUserTracker,
165                 mKeyguardStateController,
166                 mUserManager,
167                 mTrustManager,
168                 mActivityManager,
169                 null,
170                 mMetricsLogger,
171                 mColorExtractor,
172                 mStatusBarService,
173                 mLightBarController,
174                 mNotificationShadeWindowController,
175                 mWindowManager,
176                 mBackgroundExecutor,
177                 mUiEventLogger,
178                 mRingerModeTracker,
179                 mHandler,
180                 mPackageManager,
181                 Optional.of(mCentralSurfaces),
182                 mShadeController,
183                 mKeyguardUpdateMonitor,
184                 mDialogLaunchAnimator);
185         mGlobalActionsDialogLite.setZeroDialogPressDelayForTesting();
186 
187         ColorExtractor.GradientColors backdropColors = new ColorExtractor.GradientColors();
188         backdropColors.setMainColor(Color.BLACK);
189         when(mColorExtractor.getNeutralColors()).thenReturn(backdropColors);
190     }
191 
192     @Test
testShouldLogShow()193     public void testShouldLogShow() {
194         mGlobalActionsDialogLite.onShow(null);
195         mTestableLooper.processAllMessages();
196         verifyLogPosted(GlobalActionsDialogLite.GlobalActionsEvent.GA_POWER_MENU_OPEN);
197     }
198 
199     @Test
testShouldLogDismiss()200     public void testShouldLogDismiss() {
201         mGlobalActionsDialogLite.onDismiss(mGlobalActionsDialogLite.mDialog);
202         mTestableLooper.processAllMessages();
203         verifyLogPosted(GlobalActionsDialogLite.GlobalActionsEvent.GA_POWER_MENU_CLOSE);
204     }
205 
206     @Test
testShouldLogClose_backButton()207     public void testShouldLogClose_backButton() {
208         mGlobalActionsDialogLite = spy(mGlobalActionsDialogLite);
209         doReturn(4).when(mGlobalActionsDialogLite).getMaxShownPowerItems();
210         doReturn(true).when(mGlobalActionsDialogLite).shouldDisplayLockdown(any());
211         doReturn(true).when(mGlobalActionsDialogLite).shouldShowAction(any());
212         String[] actions = {
213                 GlobalActionsDialogLite.GLOBAL_ACTION_KEY_EMERGENCY,
214                 GlobalActionsDialogLite.GLOBAL_ACTION_KEY_LOCKDOWN,
215                 GlobalActionsDialogLite.GLOBAL_ACTION_KEY_POWER,
216                 GlobalActionsDialogLite.GLOBAL_ACTION_KEY_RESTART,
217         };
218         doReturn(actions).when(mGlobalActionsDialogLite).getDefaultActions();
219         GlobalActionsDialogLite.ActionsDialogLite dialog = mGlobalActionsDialogLite.createDialog();
220         dialog.onBackPressed();
221         mTestableLooper.processAllMessages();
222         verifyLogPosted(GlobalActionsDialogLite.GlobalActionsEvent.GA_CLOSE_BACK);
223     }
224 
225     @Test
testPredictiveBackCallbackRegisteredAndUnregistered()226     public void testPredictiveBackCallbackRegisteredAndUnregistered() {
227         mGlobalActionsDialogLite = spy(mGlobalActionsDialogLite);
228         doReturn(4).when(mGlobalActionsDialogLite).getMaxShownPowerItems();
229         doReturn(true).when(mGlobalActionsDialogLite).shouldDisplayLockdown(any());
230         doReturn(true).when(mGlobalActionsDialogLite).shouldShowAction(any());
231         String[] actions = {
232                 GlobalActionsDialogLite.GLOBAL_ACTION_KEY_EMERGENCY,
233                 GlobalActionsDialogLite.GLOBAL_ACTION_KEY_LOCKDOWN,
234                 GlobalActionsDialogLite.GLOBAL_ACTION_KEY_POWER,
235                 GlobalActionsDialogLite.GLOBAL_ACTION_KEY_RESTART,
236         };
237         doReturn(actions).when(mGlobalActionsDialogLite).getDefaultActions();
238 
239         GlobalActionsDialogLite.ActionsDialogLite dialog = mGlobalActionsDialogLite.createDialog();
240         dialog.setBackDispatcherOverride(mOnBackInvokedDispatcher);
241         dialog.create();
242         mTestableLooper.processAllMessages();
243         verify(mOnBackInvokedDispatcher).registerOnBackInvokedCallback(
244                 eq(OnBackInvokedDispatcher.PRIORITY_DEFAULT), any());
245         dialog.onDetachedFromWindow();
246         mTestableLooper.processAllMessages();
247         verify(mOnBackInvokedDispatcher).unregisterOnBackInvokedCallback(any());
248     }
249 
250     /**
251      * This specific test case appears to be flaky.
252      * b/249136797 tracks the task of root-causing and fixing it.
253      */
254     @FlakyTest
255     @Test
testPredictiveBackInvocationDismissesDialog()256     public void testPredictiveBackInvocationDismissesDialog() {
257         mGlobalActionsDialogLite = spy(mGlobalActionsDialogLite);
258         doReturn(4).when(mGlobalActionsDialogLite).getMaxShownPowerItems();
259         doReturn(true).when(mGlobalActionsDialogLite).shouldDisplayLockdown(any());
260         doReturn(true).when(mGlobalActionsDialogLite).shouldShowAction(any());
261         String[] actions = {
262                 GlobalActionsDialogLite.GLOBAL_ACTION_KEY_EMERGENCY,
263                 GlobalActionsDialogLite.GLOBAL_ACTION_KEY_LOCKDOWN,
264                 GlobalActionsDialogLite.GLOBAL_ACTION_KEY_POWER,
265                 GlobalActionsDialogLite.GLOBAL_ACTION_KEY_RESTART,
266         };
267         doReturn(actions).when(mGlobalActionsDialogLite).getDefaultActions();
268 
269         GlobalActionsDialogLite.ActionsDialogLite dialog = mGlobalActionsDialogLite.createDialog();
270         dialog.create();
271         dialog.show();
272         mTestableLooper.processAllMessages();
273         dialog.getWindow().injectInputEvent(
274                 new KeyEvent(KeyEvent.ACTION_DOWN, KeyEvent.KEYCODE_BACK));
275         dialog.getWindow().injectInputEvent(
276                 new KeyEvent(KeyEvent.ACTION_UP, KeyEvent.KEYCODE_BACK));
277         mTestableLooper.processAllMessages();
278         verifyLogPosted(GlobalActionsDialogLite.GlobalActionsEvent.GA_CLOSE_BACK);
279         assertThat(dialog.isShowing()).isFalse();
280     }
281 
282     @Test
testSingleTap_logAndDismiss()283     public void testSingleTap_logAndDismiss() {
284         mGlobalActionsDialogLite = spy(mGlobalActionsDialogLite);
285         doReturn(4).when(mGlobalActionsDialogLite).getMaxShownPowerItems();
286         doReturn(true).when(mGlobalActionsDialogLite).shouldDisplayLockdown(any());
287         doReturn(true).when(mGlobalActionsDialogLite).shouldShowAction(any());
288         String[] actions = {
289                 GlobalActionsDialogLite.GLOBAL_ACTION_KEY_EMERGENCY,
290                 GlobalActionsDialogLite.GLOBAL_ACTION_KEY_LOCKDOWN,
291                 GlobalActionsDialogLite.GLOBAL_ACTION_KEY_POWER,
292                 GlobalActionsDialogLite.GLOBAL_ACTION_KEY_RESTART,
293         };
294         doReturn(actions).when(mGlobalActionsDialogLite).getDefaultActions();
295         GlobalActionsDialogLite.ActionsDialogLite dialog = mGlobalActionsDialogLite.createDialog();
296 
297         GestureDetector.SimpleOnGestureListener gestureListener = spy(dialog.mGestureListener);
298         gestureListener.onSingleTapUp(null);
299         verifyLogPosted(GlobalActionsDialogLite.GlobalActionsEvent.GA_CLOSE_TAP_OUTSIDE);
300     }
301 
302     @Test
testSwipeDownLockscreen_logAndOpenQS()303     public void testSwipeDownLockscreen_logAndOpenQS() {
304         mGlobalActionsDialogLite = spy(mGlobalActionsDialogLite);
305         doReturn(4).when(mGlobalActionsDialogLite).getMaxShownPowerItems();
306         doReturn(true).when(mGlobalActionsDialogLite).shouldDisplayLockdown(any());
307         doReturn(true).when(mGlobalActionsDialogLite).shouldShowAction(any());
308         doReturn(true).when(mCentralSurfaces).isKeyguardShowing();
309         String[] actions = {
310                 GlobalActionsDialogLite.GLOBAL_ACTION_KEY_EMERGENCY,
311                 GlobalActionsDialogLite.GLOBAL_ACTION_KEY_LOCKDOWN,
312                 GlobalActionsDialogLite.GLOBAL_ACTION_KEY_POWER,
313                 GlobalActionsDialogLite.GLOBAL_ACTION_KEY_RESTART,
314         };
315         doReturn(actions).when(mGlobalActionsDialogLite).getDefaultActions();
316         GlobalActionsDialogLite.ActionsDialogLite dialog = mGlobalActionsDialogLite.createDialog();
317 
318         GestureDetector.SimpleOnGestureListener gestureListener = spy(dialog.mGestureListener);
319         MotionEvent start = MotionEvent.obtain(0, 0, MotionEvent.ACTION_DOWN, 0, 0, 0);
320         MotionEvent end = MotionEvent.obtain(0, 0, MotionEvent.ACTION_DOWN, 0, 500, 0);
321         gestureListener.onFling(start, end, 0, 1000);
322         verifyLogPosted(GlobalActionsDialogLite.GlobalActionsEvent.GA_CLOSE_TAP_OUTSIDE);
323         verify(mShadeController).animateExpandQs();
324     }
325 
326     @Test
testSwipeDown_logAndOpenNotificationShade()327     public void testSwipeDown_logAndOpenNotificationShade() {
328         mGlobalActionsDialogLite = spy(mGlobalActionsDialogLite);
329         doReturn(4).when(mGlobalActionsDialogLite).getMaxShownPowerItems();
330         doReturn(true).when(mGlobalActionsDialogLite).shouldDisplayLockdown(any());
331         doReturn(true).when(mGlobalActionsDialogLite).shouldShowAction(any());
332         doReturn(false).when(mCentralSurfaces).isKeyguardShowing();
333         String[] actions = {
334                 GlobalActionsDialogLite.GLOBAL_ACTION_KEY_EMERGENCY,
335                 GlobalActionsDialogLite.GLOBAL_ACTION_KEY_LOCKDOWN,
336                 GlobalActionsDialogLite.GLOBAL_ACTION_KEY_POWER,
337                 GlobalActionsDialogLite.GLOBAL_ACTION_KEY_RESTART,
338         };
339         doReturn(actions).when(mGlobalActionsDialogLite).getDefaultActions();
340         GlobalActionsDialogLite.ActionsDialogLite dialog = mGlobalActionsDialogLite.createDialog();
341 
342         GestureDetector.SimpleOnGestureListener gestureListener = spy(dialog.mGestureListener);
343         MotionEvent start = MotionEvent.obtain(0, 0, MotionEvent.ACTION_DOWN, 0, 0, 0);
344         MotionEvent end = MotionEvent.obtain(0, 0, MotionEvent.ACTION_DOWN, 0, 500, 0);
345         gestureListener.onFling(start, end, 0, 1000);
346         verifyLogPosted(GlobalActionsDialogLite.GlobalActionsEvent.GA_CLOSE_TAP_OUTSIDE);
347         verify(mShadeController).animateExpandShade();
348     }
349 
350     @Test
testShouldLogBugreportPress()351     public void testShouldLogBugreportPress() throws InterruptedException {
352         GlobalActionsDialogLite.BugReportAction bugReportAction =
353                 mGlobalActionsDialogLite.makeBugReportActionForTesting();
354         bugReportAction.onPress();
355         verifyLogPosted(GlobalActionsDialogLite.GlobalActionsEvent.GA_BUGREPORT_PRESS);
356     }
357 
358     @Test
testShouldLogBugreportLongPress()359     public void testShouldLogBugreportLongPress() {
360         GlobalActionsDialogLite.BugReportAction bugReportAction =
361                 mGlobalActionsDialogLite.makeBugReportActionForTesting();
362         bugReportAction.onLongPress();
363         verifyLogPosted(GlobalActionsDialogLite.GlobalActionsEvent.GA_BUGREPORT_LONG_PRESS);
364     }
365 
366     @Test
testShouldLogEmergencyDialerPress()367     public void testShouldLogEmergencyDialerPress() {
368         GlobalActionsDialogLite.EmergencyDialerAction emergencyDialerAction =
369                 mGlobalActionsDialogLite.makeEmergencyDialerActionForTesting();
370         emergencyDialerAction.onPress();
371         verifyLogPosted(GlobalActionsDialogLite.GlobalActionsEvent.GA_EMERGENCY_DIALER_PRESS);
372     }
373 
374     @Test
testShouldLogScreenshotPress()375     public void testShouldLogScreenshotPress() {
376         GlobalActionsDialogLite.ScreenshotAction screenshotAction =
377                 mGlobalActionsDialogLite.makeScreenshotActionForTesting();
378         screenshotAction.onPress();
379         verifyLogPosted(GlobalActionsDialogLite.GlobalActionsEvent.GA_SCREENSHOT_PRESS);
380     }
381 
382     @Test
testShouldShowScreenshot()383     public void testShouldShowScreenshot() {
384         mContext.getOrCreateTestableResources().addOverride(
385                 com.android.internal.R.integer.config_navBarInteractionMode,
386                 WindowManagerPolicyConstants.NAV_BAR_MODE_2BUTTON);
387 
388         GlobalActionsDialogLite.ScreenshotAction screenshotAction =
389                 mGlobalActionsDialogLite.makeScreenshotActionForTesting();
390         assertThat(screenshotAction.shouldShow()).isTrue();
391     }
392 
393     @Test
testShouldNotShowScreenshot()394     public void testShouldNotShowScreenshot() {
395         mContext.getOrCreateTestableResources().addOverride(
396                 com.android.internal.R.integer.config_navBarInteractionMode,
397                 WindowManagerPolicyConstants.NAV_BAR_MODE_3BUTTON);
398 
399         GlobalActionsDialogLite.ScreenshotAction screenshotAction =
400                 mGlobalActionsDialogLite.makeScreenshotActionForTesting();
401         assertThat(screenshotAction.shouldShow()).isFalse();
402     }
403 
verifyLogPosted(GlobalActionsDialogLite.GlobalActionsEvent event)404     private void verifyLogPosted(GlobalActionsDialogLite.GlobalActionsEvent event) {
405         mTestableLooper.processAllMessages();
406         verify(mUiEventLogger, times(1))
407                 .log(event);
408     }
409 
410     @SafeVarargs
assertItemsOfType(List<T> stuff, Class<? extends T>... classes)411     private static <T> void assertItemsOfType(List<T> stuff, Class<? extends T>... classes) {
412         assertThat(stuff).hasSize(classes.length);
413         for (int i = 0; i < stuff.size(); i++) {
414             assertThat(stuff.get(i)).isInstanceOf(classes[i]);
415         }
416     }
417 
418     @Test
testCreateActionItems_lockdownEnabled_doesShowLockdown()419     public void testCreateActionItems_lockdownEnabled_doesShowLockdown() {
420         mGlobalActionsDialogLite = spy(mGlobalActionsDialogLite);
421         doReturn(4).when(mGlobalActionsDialogLite).getMaxShownPowerItems();
422         doReturn(true).when(mGlobalActionsDialogLite).shouldDisplayEmergency();
423         doReturn(true).when(mGlobalActionsDialogLite).shouldDisplayLockdown(any());
424         doReturn(true).when(mGlobalActionsDialogLite).shouldShowAction(any());
425         String[] actions = {
426                 GlobalActionsDialogLite.GLOBAL_ACTION_KEY_EMERGENCY,
427                 GlobalActionsDialogLite.GLOBAL_ACTION_KEY_LOCKDOWN,
428                 GlobalActionsDialogLite.GLOBAL_ACTION_KEY_POWER,
429                 GlobalActionsDialogLite.GLOBAL_ACTION_KEY_RESTART,
430         };
431         doReturn(actions).when(mGlobalActionsDialogLite).getDefaultActions();
432         mGlobalActionsDialogLite.createActionItems();
433 
434         assertItemsOfType(mGlobalActionsDialogLite.mItems,
435                 GlobalActionsDialogLite.EmergencyAction.class,
436                 GlobalActionsDialogLite.LockDownAction.class,
437                 GlobalActionsDialogLite.ShutDownAction.class,
438                 GlobalActionsDialogLite.RestartAction.class);
439         assertThat(mGlobalActionsDialogLite.mOverflowItems).isEmpty();
440         assertThat(mGlobalActionsDialogLite.mPowerItems).isEmpty();
441     }
442 
443     @Test
testCreateActionItems_lockdownDisabled_doesNotShowLockdown()444     public void testCreateActionItems_lockdownDisabled_doesNotShowLockdown() {
445         mGlobalActionsDialogLite = spy(mGlobalActionsDialogLite);
446         doReturn(4).when(mGlobalActionsDialogLite).getMaxShownPowerItems();
447         doReturn(true).when(mGlobalActionsDialogLite).shouldDisplayEmergency();
448         // make sure lockdown action will NOT be shown
449         doReturn(false).when(mGlobalActionsDialogLite).shouldDisplayLockdown(any());
450         doReturn(true).when(mGlobalActionsDialogLite).shouldShowAction(any());
451         String[] actions = {
452                 GlobalActionsDialogLite.GLOBAL_ACTION_KEY_EMERGENCY,
453                 // lockdown action not allowed
454                 GlobalActionsDialogLite.GLOBAL_ACTION_KEY_LOCKDOWN,
455                 GlobalActionsDialogLite.GLOBAL_ACTION_KEY_POWER,
456                 GlobalActionsDialogLite.GLOBAL_ACTION_KEY_RESTART,
457         };
458         doReturn(actions).when(mGlobalActionsDialogLite).getDefaultActions();
459         mGlobalActionsDialogLite.createActionItems();
460 
461         assertItemsOfType(mGlobalActionsDialogLite.mItems,
462                 GlobalActionsDialogLite.EmergencyAction.class,
463                 GlobalActionsDialogLite.ShutDownAction.class,
464                 GlobalActionsDialogLite.RestartAction.class);
465         assertThat(mGlobalActionsDialogLite.mOverflowItems).isEmpty();
466         assertThat(mGlobalActionsDialogLite.mPowerItems).isEmpty();
467     }
468 
469     @Test
testCreateActionItems_emergencyDisabled_doesNotShowEmergency()470     public void testCreateActionItems_emergencyDisabled_doesNotShowEmergency() {
471         mGlobalActionsDialogLite = spy(mGlobalActionsDialogLite);
472         doReturn(4).when(mGlobalActionsDialogLite).getMaxShownPowerItems();
473         // make sure emergency action will NOT be shown
474         doReturn(false).when(mGlobalActionsDialogLite).shouldDisplayEmergency();
475         doReturn(true).when(mGlobalActionsDialogLite).shouldDisplayLockdown(any());
476         doReturn(true).when(mGlobalActionsDialogLite).shouldShowAction(any());
477         String[] actions = {
478                 // emergency action not allowed
479                 GlobalActionsDialogLite.GLOBAL_ACTION_KEY_EMERGENCY,
480                 GlobalActionsDialogLite.GLOBAL_ACTION_KEY_LOCKDOWN,
481                 GlobalActionsDialogLite.GLOBAL_ACTION_KEY_POWER,
482                 GlobalActionsDialogLite.GLOBAL_ACTION_KEY_RESTART,
483         };
484         doReturn(actions).when(mGlobalActionsDialogLite).getDefaultActions();
485         mGlobalActionsDialogLite.createActionItems();
486 
487         assertItemsOfType(mGlobalActionsDialogLite.mItems,
488                 GlobalActionsDialogLite.LockDownAction.class,
489                 GlobalActionsDialogLite.ShutDownAction.class,
490                 GlobalActionsDialogLite.RestartAction.class);
491         assertThat(mGlobalActionsDialogLite.mOverflowItems).isEmpty();
492         assertThat(mGlobalActionsDialogLite.mPowerItems).isEmpty();
493     }
494 
495     @Test
testShouldLogLockdownPress()496     public void testShouldLogLockdownPress() {
497         GlobalActionsDialogLite.LockDownAction lockDownAction =
498                 mGlobalActionsDialogLite.new LockDownAction();
499         lockDownAction.onPress();
500         verifyLogPosted(GlobalActionsDialogLite.GlobalActionsEvent.GA_LOCKDOWN_PRESS);
501     }
502 
503     @Test
testShouldLogShutdownPress()504     public void testShouldLogShutdownPress() {
505         GlobalActionsDialogLite.ShutDownAction shutDownAction =
506                 mGlobalActionsDialogLite.new ShutDownAction();
507         shutDownAction.onPress();
508         verifyLogPosted(GlobalActionsDialogLite.GlobalActionsEvent.GA_SHUTDOWN_PRESS);
509     }
510 
511     @Test
testShouldLogShutdownLongPress()512     public void testShouldLogShutdownLongPress() {
513         GlobalActionsDialogLite.ShutDownAction shutDownAction =
514                 mGlobalActionsDialogLite.new ShutDownAction();
515         shutDownAction.onLongPress();
516         verifyLogPosted(GlobalActionsDialogLite.GlobalActionsEvent.GA_SHUTDOWN_LONG_PRESS);
517     }
518 
519     @Test
testShouldLogRebootPress()520     public void testShouldLogRebootPress() {
521         GlobalActionsDialogLite.RestartAction restartAction =
522                 mGlobalActionsDialogLite.new RestartAction();
523         restartAction.onPress();
524         verifyLogPosted(GlobalActionsDialogLite.GlobalActionsEvent.GA_REBOOT_PRESS);
525     }
526 
527     @Test
testShouldLogRebootLongPress()528     public void testShouldLogRebootLongPress() {
529         GlobalActionsDialogLite.RestartAction restartAction =
530                 mGlobalActionsDialogLite.new RestartAction();
531         restartAction.onLongPress();
532         verifyLogPosted(GlobalActionsDialogLite.GlobalActionsEvent.GA_REBOOT_LONG_PRESS);
533     }
534 
535     @Test
testOnLockScreen_disableSmartLock()536     public void testOnLockScreen_disableSmartLock() {
537         mGlobalActionsDialogLite = spy(mGlobalActionsDialogLite);
538         int user = KeyguardUpdateMonitor.getCurrentUser();
539         doReturn(4).when(mGlobalActionsDialogLite).getMaxShownPowerItems();
540         doReturn(true).when(mGlobalActionsDialogLite).shouldDisplayLockdown(any());
541         doReturn(true).when(mGlobalActionsDialogLite).shouldShowAction(any());
542         doReturn(false).when(mCentralSurfaces).isKeyguardShowing();
543         String[] actions = {
544                 GlobalActionsDialogLite.GLOBAL_ACTION_KEY_EMERGENCY,
545                 GlobalActionsDialogLite.GLOBAL_ACTION_KEY_LOCKDOWN,
546                 GlobalActionsDialogLite.GLOBAL_ACTION_KEY_POWER,
547                 GlobalActionsDialogLite.GLOBAL_ACTION_KEY_RESTART,
548         };
549         doReturn(actions).when(mGlobalActionsDialogLite).getDefaultActions();
550 
551         // When entering power menu from lockscreen, with smart lock enabled
552         when(mKeyguardUpdateMonitor.getUserHasTrust(anyInt())).thenReturn(true);
553         mGlobalActionsDialogLite.showOrHideDialog(true, true, null /* view */);
554 
555         // Then smart lock will be disabled
556         verify(mLockPatternUtils).requireCredentialEntry(eq(user));
557 
558         // hide dialog again
559         mGlobalActionsDialogLite.showOrHideDialog(true, true, null /* view */);
560     }
561 
562     @Test
testBugreportAction_whenDebugMode_shouldOfferBugreportButtonBeforeProvisioning()563     public void testBugreportAction_whenDebugMode_shouldOfferBugreportButtonBeforeProvisioning() {
564         UserInfo currentUser = mockCurrentUser(FLAG_ADMIN);
565 
566         when(mGlobalActionsDialogLite.getCurrentUser()).thenReturn(currentUser);
567         when(mGlobalSettings.getIntForUser(Settings.Secure.BUGREPORT_IN_POWER_MENU,
568                 0, currentUser.id)).thenReturn(1);
569 
570         GlobalActionsDialogLite.BugReportAction bugReportAction =
571                 mGlobalActionsDialogLite.makeBugReportActionForTesting();
572         assertThat(bugReportAction.showBeforeProvisioning()).isTrue();
573     }
574 
575     @Test
testBugreportAction_whenUserIsNotAdmin_noBugReportActionBeforeProvisioning()576     public void testBugreportAction_whenUserIsNotAdmin_noBugReportActionBeforeProvisioning() {
577         UserInfo currentUser = mockCurrentUser(0);
578 
579         when(mGlobalActionsDialogLite.getCurrentUser()).thenReturn(currentUser);
580         doReturn(1).when(mGlobalSettings)
581                 .getIntForUser(Settings.Secure.BUGREPORT_IN_POWER_MENU, 0, currentUser.id);
582 
583         GlobalActionsDialogLite.BugReportAction bugReportAction =
584                 mGlobalActionsDialogLite.makeBugReportActionForTesting();
585         assertThat(bugReportAction.showBeforeProvisioning()).isFalse();
586     }
587 
mockCurrentUser(int flags)588     private UserInfo mockCurrentUser(int flags) {
589         return new UserInfo(10, "A User", flags);
590 
591     }
592 }
593