1 /* 2 * Copyright (C) 2022 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17 package com.android.server.policy; 18 19 import static android.os.Build.HW_TIMEOUT_MULTIPLIER; 20 import static android.provider.Settings.Secure.VOLUME_HUSH_MUTE; 21 import static android.view.Display.DEFAULT_DISPLAY; 22 import static android.view.Display.STATE_ON; 23 import static android.view.WindowManagerPolicyConstants.FLAG_INTERACTIVE; 24 25 import static com.android.dx.mockito.inline.extended.ExtendedMockito.any; 26 import static com.android.dx.mockito.inline.extended.ExtendedMockito.anyInt; 27 import static com.android.dx.mockito.inline.extended.ExtendedMockito.anyLong; 28 import static com.android.dx.mockito.inline.extended.ExtendedMockito.anyString; 29 import static com.android.dx.mockito.inline.extended.ExtendedMockito.doAnswer; 30 import static com.android.dx.mockito.inline.extended.ExtendedMockito.doNothing; 31 import static com.android.dx.mockito.inline.extended.ExtendedMockito.doReturn; 32 import static com.android.dx.mockito.inline.extended.ExtendedMockito.eq; 33 import static com.android.dx.mockito.inline.extended.ExtendedMockito.mock; 34 import static com.android.dx.mockito.inline.extended.ExtendedMockito.mockitoSession; 35 import static com.android.dx.mockito.inline.extended.ExtendedMockito.never; 36 import static com.android.dx.mockito.inline.extended.ExtendedMockito.spy; 37 import static com.android.dx.mockito.inline.extended.ExtendedMockito.spyOn; 38 import static com.android.dx.mockito.inline.extended.ExtendedMockito.times; 39 import static com.android.dx.mockito.inline.extended.ExtendedMockito.verify; 40 import static com.android.server.policy.PhoneWindowManager.LONG_PRESS_POWER_ASSISTANT; 41 import static com.android.server.policy.PhoneWindowManager.LONG_PRESS_POWER_GLOBAL_ACTIONS; 42 import static com.android.server.policy.PhoneWindowManager.LONG_PRESS_POWER_GO_TO_VOICE_ASSIST; 43 import static com.android.server.policy.PhoneWindowManager.LONG_PRESS_POWER_NOTHING; 44 import static com.android.server.policy.PhoneWindowManager.LONG_PRESS_POWER_SHUT_OFF; 45 import static com.android.server.policy.PhoneWindowManager.LONG_PRESS_POWER_SHUT_OFF_NO_CONFIRM; 46 import static com.android.server.policy.PhoneWindowManager.POWER_VOLUME_UP_BEHAVIOR_MUTE; 47 48 import static org.junit.Assert.assertTrue; 49 import static org.mockito.ArgumentMatchers.anyBoolean; 50 import static org.mockito.ArgumentMatchers.anyList; 51 import static org.mockito.ArgumentMatchers.isNull; 52 import static org.mockito.Mockito.CALLS_REAL_METHODS; 53 import static org.mockito.Mockito.after; 54 import static org.mockito.Mockito.atLeast; 55 import static org.mockito.Mockito.atMost; 56 import static org.mockito.Mockito.description; 57 import static org.mockito.Mockito.mockingDetails; 58 import static org.mockito.Mockito.timeout; 59 import static org.mockito.Mockito.withSettings; 60 61 import android.app.ActivityManagerInternal; 62 import android.app.AppOpsManager; 63 import android.app.IActivityManager; 64 import android.app.NotificationManager; 65 import android.app.SearchManager; 66 import android.app.role.RoleManager; 67 import android.content.ComponentName; 68 import android.content.Context; 69 import android.content.Intent; 70 import android.content.pm.PackageManager; 71 import android.content.pm.ResolveInfo; 72 import android.database.ContentObserver; 73 import android.hardware.SensorPrivacyManager; 74 import android.hardware.display.DisplayManager; 75 import android.hardware.display.DisplayManagerInternal; 76 import android.hardware.input.InputManager; 77 import android.hardware.input.KeyGestureEvent; 78 import android.media.AudioManagerInternal; 79 import android.os.Handler; 80 import android.os.HandlerThread; 81 import android.os.IBinder; 82 import android.os.Looper; 83 import android.os.PowerManager; 84 import android.os.PowerManagerInternal; 85 import android.os.RemoteException; 86 import android.os.UserHandle; 87 import android.os.Vibrator; 88 import android.os.VibratorInfo; 89 import android.os.test.TestLooper; 90 import android.provider.Settings; 91 import android.service.dreams.DreamManagerInternal; 92 import android.service.quickaccesswallet.QuickAccessWalletClient; 93 import android.telecom.TelecomManager; 94 import android.util.MutableBoolean; 95 import android.view.Display; 96 import android.view.InputEvent; 97 import android.view.KeyCharacterMap; 98 import android.view.KeyEvent; 99 import android.view.accessibility.AccessibilityManager; 100 import android.view.autofill.AutofillManagerInternal; 101 102 import com.android.dx.mockito.inline.extended.StaticMockitoSession; 103 import com.android.internal.accessibility.AccessibilityShortcutController; 104 import com.android.internal.logging.MetricsLogger; 105 import com.android.internal.logging.UiEventLogger; 106 import com.android.internal.policy.KeyInterceptionInfo; 107 import com.android.server.GestureLauncherService; 108 import com.android.server.LocalServices; 109 import com.android.server.SystemService; 110 import com.android.server.input.InputManagerInternal; 111 import com.android.server.inputmethod.InputMethodManagerInternal; 112 import com.android.server.pm.UserManagerInternal; 113 import com.android.server.policy.keyguard.KeyguardServiceDelegate; 114 import com.android.server.statusbar.StatusBarManagerInternal; 115 import com.android.server.testutils.OffsettableClock; 116 import com.android.server.vr.VrManagerInternal; 117 import com.android.server.wm.ActivityTaskManagerInternal; 118 import com.android.server.wm.DisplayPolicy; 119 import com.android.server.wm.DisplayRotation; 120 import com.android.server.wm.WindowManagerInternal; 121 import com.android.server.wm.WindowManagerInternal.AppTransitionListener; 122 123 import junit.framework.Assert; 124 125 import org.mockito.AdditionalMatchers; 126 import org.mockito.ArgumentCaptor; 127 import org.mockito.Mock; 128 import org.mockito.MockSettings; 129 import org.mockito.Mockito; 130 import org.mockito.MockitoAnnotations; 131 import org.mockito.quality.Strictness; 132 133 import java.util.List; 134 import java.util.concurrent.BlockingQueue; 135 import java.util.function.Supplier; 136 137 class TestPhoneWindowManager { 138 private static final long TEST_SINGLE_KEY_DELAY_MILLIS 139 = SingleKeyGestureDetector.MULTI_PRESS_TIMEOUT + 1000L * HW_TIMEOUT_MULTIPLIER; 140 private static final String TEST_BROWSER_ROLE_PACKAGE_NAME = "com.browser"; 141 private static final String TEST_SMS_ROLE_PACKAGE_NAME = "com.sms"; 142 143 private PhoneWindowManager mPhoneWindowManager; 144 private Context mContext; 145 private GestureLauncherService mGestureLauncherService; 146 147 @Mock private WindowManagerInternal mWindowManagerInternal; 148 @Mock private ActivityManagerInternal mActivityManagerInternal; 149 @Mock ActivityTaskManagerInternal mActivityTaskManagerInternal; 150 @Mock IActivityManager mActivityManagerService; 151 @Mock private InputManagerInternal mInputManagerInternal; 152 @Mock private InputManager mInputManager; 153 @Mock private SensorPrivacyManager mSensorPrivacyManager; 154 @Mock private DreamManagerInternal mDreamManagerInternal; 155 @Mock private PowerManagerInternal mPowerManagerInternal; 156 @Mock private DisplayManagerInternal mDisplayManagerInternal; 157 @Mock private AppOpsManager mAppOpsManager; 158 @Mock private DisplayManager mDisplayManager; 159 @Mock private PackageManager mPackageManager; 160 @Mock private TelecomManager mTelecomManager; 161 @Mock private NotificationManager mNotificationManager; 162 @Mock private Vibrator mVibrator; 163 @Mock private VibratorInfo mVibratorInfo; 164 @Mock private PowerManager mPowerManager; 165 @Mock private WindowManagerPolicy.WindowManagerFuncs mWindowManagerFuncsImpl; 166 @Mock private InputMethodManagerInternal mInputMethodManagerInternal; 167 @Mock private UserManagerInternal mUserManagerInternal; 168 @Mock private AudioManagerInternal mAudioManagerInternal; 169 @Mock private SearchManager mSearchManager; 170 @Mock private RoleManager mRoleManager; 171 @Mock private AccessibilityManager mAccessibilityManager; 172 173 @Mock private Display mDisplay; 174 @Mock private DisplayRotation mDisplayRotation; 175 @Mock private DisplayPolicy mDisplayPolicy; 176 @Mock private WindowManagerPolicy.ScreenOnListener mScreenOnListener; 177 @Mock private QuickAccessWalletClient mQuickAccessWalletClient; 178 @Mock private MetricsLogger mMetricsLogger; 179 @Mock private UiEventLogger mUiEventLogger; 180 @Mock private GlobalActions mGlobalActions; 181 @Mock private AccessibilityShortcutController mAccessibilityShortcutController; 182 183 @Mock private StatusBarManagerInternal mStatusBarManagerInternal; 184 185 @Mock private KeyguardServiceDelegate mKeyguardServiceDelegate; 186 187 @Mock 188 private PhoneWindowManager.ButtonOverridePermissionChecker mButtonOverridePermissionChecker; 189 @Mock private WindowWakeUpPolicy mWindowWakeUpPolicy; 190 191 @Mock private IBinder mInputToken; 192 @Mock private IBinder mImeTargetWindowToken; 193 194 private StaticMockitoSession mMockitoSession; 195 private OffsettableClock mClock = new OffsettableClock(); 196 private TestLooper mTestLooper = new TestLooper(() -> mClock.now()); 197 private HandlerThread mHandlerThread; 198 private Handler mHandler; 199 200 private boolean mIsTalkBackEnabled; 201 private boolean mIsTalkBackShortcutGestureEnabled; 202 203 private boolean mDelegateBackGestureRemote; 204 private boolean mIsVoiceAccessEnabled; 205 206 private Intent mBrowserIntent; 207 private Intent mSmsIntent; 208 209 private int mKeyEventPolicyFlags = FLAG_INTERACTIVE; 210 211 private class TestTalkbackShortcutController extends TalkbackShortcutController { TestTalkbackShortcutController(Context context)212 TestTalkbackShortcutController(Context context) { 213 super(context); 214 } 215 216 @Override toggleTalkback(int currentUserId, ShortcutSource source)217 boolean toggleTalkback(int currentUserId, ShortcutSource source) { 218 mIsTalkBackEnabled = !mIsTalkBackEnabled; 219 return mIsTalkBackEnabled; 220 } 221 222 @Override isTalkBackShortcutGestureEnabled()223 boolean isTalkBackShortcutGestureEnabled() { 224 return mIsTalkBackShortcutGestureEnabled; 225 } 226 } 227 228 private class TestVoiceAccessShortcutController extends VoiceAccessShortcutController { TestVoiceAccessShortcutController(Context context)229 TestVoiceAccessShortcutController(Context context) { 230 super(context); 231 } 232 233 @Override toggleVoiceAccess(int currentUserId)234 boolean toggleVoiceAccess(int currentUserId) { 235 mIsVoiceAccessEnabled = !mIsVoiceAccessEnabled; 236 return mIsVoiceAccessEnabled; 237 } 238 } 239 240 private class TestInjector extends PhoneWindowManager.Injector { TestInjector(Context context, WindowManagerPolicy.WindowManagerFuncs funcs)241 TestInjector(Context context, WindowManagerPolicy.WindowManagerFuncs funcs) { 242 super(context, funcs); 243 } 244 245 @Override getLooper()246 Looper getLooper() { 247 return mTestLooper.getLooper(); 248 } 249 getAccessibilityShortcutController( Context context, Handler handler, int initialUserId)250 AccessibilityShortcutController getAccessibilityShortcutController( 251 Context context, Handler handler, int initialUserId) { 252 return mAccessibilityShortcutController; 253 } 254 getGlobalActionsFactory()255 Supplier<GlobalActions> getGlobalActionsFactory() { 256 return () -> mGlobalActions; 257 } 258 getKeyguardServiceDelegate()259 KeyguardServiceDelegate getKeyguardServiceDelegate() { 260 return mKeyguardServiceDelegate; 261 } 262 getActivityManagerService()263 IActivityManager getActivityManagerService() { 264 return mActivityManagerService; 265 } 266 getButtonOverridePermissionChecker()267 PhoneWindowManager.ButtonOverridePermissionChecker getButtonOverridePermissionChecker() { 268 return mButtonOverridePermissionChecker; 269 } 270 getTalkbackShortcutController()271 TalkbackShortcutController getTalkbackShortcutController() { 272 return new TestTalkbackShortcutController(mContext); 273 } 274 getVoiceAccessShortcutController()275 VoiceAccessShortcutController getVoiceAccessShortcutController() { 276 return new TestVoiceAccessShortcutController(mContext); 277 } 278 getWindowWakeUpPolicy()279 WindowWakeUpPolicy getWindowWakeUpPolicy() { 280 return mWindowWakeUpPolicy; 281 } 282 } 283 284 /** 285 * {@link TestPhoneWindowManager}'s constructor. 286 * 287 * @param context The {@Context} to be used in any Context-related actions. 288 * @param supportSettingsUpdate {@code true} if this object should read and listen to provider 289 * settings values. 290 */ TestPhoneWindowManager(Context context, boolean supportSettingsUpdate)291 TestPhoneWindowManager(Context context, boolean supportSettingsUpdate) { 292 MockitoAnnotations.initMocks(this); 293 mHandler = new Handler(mTestLooper.getLooper()); 294 mContext = mockingDetails(context).isSpy() ? context : spy(context); 295 mGestureLauncherService = spy(new GestureLauncherService(mContext, mMetricsLogger, 296 mQuickAccessWalletClient, mUiEventLogger)); 297 setUp(supportSettingsUpdate); 298 mTestLooper.dispatchAll(); 299 } 300 setUp(boolean supportSettingsUpdate)301 private void setUp(boolean supportSettingsUpdate) { 302 // Use stubOnly() to reduce memory usage if it doesn't need verification. 303 final MockSettings spyStubOnly = withSettings().stubOnly() 304 .defaultAnswer(CALLS_REAL_METHODS); 305 // Return mocked services: LocalServices.getService 306 mMockitoSession = mockitoSession() 307 .mockStatic(LocalServices.class, spyStubOnly) 308 .mockStatic(KeyCharacterMap.class) 309 .mockStatic(GestureLauncherService.class) 310 .strictness(Strictness.LENIENT) 311 .startMocking(); 312 313 mPhoneWindowManager = spy(new PhoneWindowManager()); 314 315 KeyCharacterMap virtualKcm = mContext.getSystemService(InputManager.class) 316 .getInputDevice(KeyCharacterMap.VIRTUAL_KEYBOARD).getKeyCharacterMap(); 317 doReturn(virtualKcm).when(() -> KeyCharacterMap.load(anyInt())); 318 doReturn(mWindowManagerInternal).when( 319 () -> LocalServices.getService(eq(WindowManagerInternal.class))); 320 doReturn(mActivityManagerInternal).when( 321 () -> LocalServices.getService(eq(ActivityManagerInternal.class))); 322 doReturn(mActivityTaskManagerInternal).when( 323 () -> LocalServices.getService(eq(ActivityTaskManagerInternal.class))); 324 doReturn(mInputManagerInternal).when( 325 () -> LocalServices.getService(eq(InputManagerInternal.class))); 326 doReturn(mDreamManagerInternal).when( 327 () -> LocalServices.getService(eq(DreamManagerInternal.class))); 328 doReturn(mPowerManagerInternal).when( 329 () -> LocalServices.getService(eq(PowerManagerInternal.class))); 330 doReturn(mDisplayManagerInternal).when( 331 () -> LocalServices.getService(eq(DisplayManagerInternal.class))); 332 doReturn(mGestureLauncherService).when( 333 () -> LocalServices.getService(eq(GestureLauncherService.class))); 334 doReturn(true).when( 335 () -> GestureLauncherService.isCameraDoubleTapPowerSettingEnabled(any(), anyInt()) 336 ); 337 doReturn(true).when( 338 () -> GestureLauncherService.isEmergencyGestureSettingEnabled(any(), anyInt()) 339 ); 340 doReturn(true).when( 341 () -> GestureLauncherService.isGestureLauncherEnabled(any()) 342 ); 343 mGestureLauncherService.onBootPhase(SystemService.PHASE_THIRD_PARTY_APPS_CAN_START); 344 doReturn(mUserManagerInternal).when( 345 () -> LocalServices.getService(eq(UserManagerInternal.class))); 346 doReturn(null).when(() -> LocalServices.getService(eq(VrManagerInternal.class))); 347 doReturn(null).when(() -> LocalServices.getService(eq(AutofillManagerInternal.class))); 348 LocalServices.removeServiceForTest(InputMethodManagerInternal.class); 349 LocalServices.addService(InputMethodManagerInternal.class, mInputMethodManagerInternal); 350 351 doReturn(mAppOpsManager).when(mContext).getSystemService(eq(AppOpsManager.class)); 352 doReturn(mDisplayManager).when(mContext).getSystemService(eq(DisplayManager.class)); 353 doReturn(mInputManager).when(mContext).getSystemService(eq(InputManager.class)); 354 doNothing().when(mInputManager).registerKeyGestureEventHandler(anyList(), any()); 355 doNothing().when(mInputManager).unregisterKeyGestureEventHandler(any()); 356 doReturn(mPackageManager).when(mContext).getPackageManager(); 357 doReturn(mSensorPrivacyManager).when(mContext).getSystemService( 358 eq(SensorPrivacyManager.class)); 359 doReturn(mSearchManager).when(mContext).getSystemService(eq(SearchManager.class)); 360 doReturn(mRoleManager).when(mContext).getSystemService(eq(RoleManager.class)); 361 doReturn(mAccessibilityManager).when(mContext).getSystemService( 362 eq(AccessibilityManager.class)); 363 doReturn(false).when(mAccessibilityManager).isEnabled(); 364 doReturn(false).when(mPackageManager).hasSystemFeature(any()); 365 doReturn(false).when(mTelecomManager).isInCall(); 366 doReturn(false).when(mTelecomManager).isRinging(); 367 doReturn(mTelecomManager).when(mPhoneWindowManager).getTelecommService(); 368 doNothing().when(mNotificationManager).silenceNotificationSound(); 369 doReturn(mNotificationManager).when(mPhoneWindowManager).getNotificationService(); 370 doReturn(mVibratorInfo).when(mVibrator).getInfo(); 371 doReturn(mVibrator).when(mContext).getSystemService(eq(Context.VIBRATOR_SERVICE)); 372 373 final PowerManager.WakeLock wakeLock = mock(PowerManager.WakeLock.class); 374 doReturn(wakeLock).when(mPowerManager).newWakeLock(anyInt(), anyString()); 375 doReturn(mPowerManager).when(mContext).getSystemService(eq(Context.POWER_SERVICE)); 376 doReturn(true).when(mPowerManager).isInteractive(); 377 378 doReturn(mDisplay).when(mDisplayManager).getDisplay(eq(DEFAULT_DISPLAY)); 379 doReturn(STATE_ON).when(mDisplay).getState(); 380 doReturn(true).when(mDisplayPolicy).isAwake(); 381 doNothing().when(mDisplayPolicy).takeScreenshot(anyInt(), anyInt()); 382 doReturn(mDisplayPolicy).when(mDisplayRotation).getDisplayPolicy(); 383 doReturn(mScreenOnListener).when(mDisplayPolicy).getScreenOnListener(); 384 mPhoneWindowManager.setDefaultDisplay(new WindowManagerPolicy.DisplayContentInfo() { 385 @Override 386 public DisplayRotation getDisplayRotation() { 387 return mDisplayRotation; 388 } 389 @Override 390 public Display getDisplay() { 391 return mDisplay; 392 } 393 }); 394 395 doNothing().when(mPhoneWindowManager).initializeHdmiState(); 396 if (supportSettingsUpdate) { 397 doAnswer(inv -> { 398 // Make any call to updateSettings run synchronously for tests. 399 mPhoneWindowManager.updateSettings(null); 400 return null; 401 }).when(mPhoneWindowManager).updateSettings(any(Handler.class)); 402 } else { 403 doNothing().when(mPhoneWindowManager).updateSettings(any()); 404 } 405 doNothing().when(mPhoneWindowManager).screenTurningOn(anyInt(), any()); 406 doNothing().when(mPhoneWindowManager).screenTurnedOn(anyInt()); 407 doNothing().when(mPhoneWindowManager).startedWakingUp(anyInt(), anyInt()); 408 doNothing().when(mPhoneWindowManager).finishedWakingUp(anyInt(), anyInt()); 409 doNothing().when(mPhoneWindowManager).lockNow(any()); 410 411 doReturn(mImeTargetWindowToken) 412 .when(mWindowManagerInternal).getTargetWindowTokenFromInputToken(mInputToken); 413 414 mPhoneWindowManager.init(new TestInjector(mContext, mWindowManagerFuncsImpl)); 415 mPhoneWindowManager.systemReady(); 416 mPhoneWindowManager.systemBooted(); 417 418 overrideLaunchAccessibility(); 419 doReturn(false).when(mPhoneWindowManager).keyguardOn(); 420 doNothing().when(mContext).startActivityAsUser(any(), any()); 421 doNothing().when(mContext).startActivityAsUser(any(), any(), any()); 422 423 KeyInterceptionInfo interceptionInfo = new KeyInterceptionInfo(0, 0, null, 0); 424 doReturn(interceptionInfo) 425 .when(mWindowManagerInternal).getKeyInterceptionInfoFromToken(any()); 426 427 doReturn(true).when(mRoleManager).isRoleAvailable(eq(RoleManager.ROLE_BROWSER)); 428 doReturn(true).when(mRoleManager).isRoleAvailable(eq(RoleManager.ROLE_SMS)); 429 doReturn(TEST_BROWSER_ROLE_PACKAGE_NAME).when(mRoleManager).getDefaultApplication( 430 eq(RoleManager.ROLE_BROWSER)); 431 doReturn(TEST_SMS_ROLE_PACKAGE_NAME).when(mRoleManager).getDefaultApplication( 432 eq(RoleManager.ROLE_SMS)); 433 mBrowserIntent = new Intent(Intent.ACTION_MAIN); 434 mBrowserIntent.setPackage(TEST_BROWSER_ROLE_PACKAGE_NAME); 435 mSmsIntent = new Intent(Intent.ACTION_MAIN); 436 mSmsIntent.setPackage(TEST_SMS_ROLE_PACKAGE_NAME); 437 doReturn(mBrowserIntent).when(mPackageManager).getLaunchIntentForPackage( 438 eq(TEST_BROWSER_ROLE_PACKAGE_NAME)); 439 doReturn(mSmsIntent).when(mPackageManager).getLaunchIntentForPackage( 440 eq(TEST_SMS_ROLE_PACKAGE_NAME)); 441 Mockito.reset(mContext); 442 } 443 tearDown()444 void tearDown() { 445 LocalServices.removeServiceForTest(InputMethodManagerInternal.class); 446 Mockito.reset(mPhoneWindowManager); 447 mMockitoSession.finishMocking(); 448 } 449 dispatchAllPendingEvents()450 void dispatchAllPendingEvents() { 451 mTestLooper.dispatchAll(); 452 } 453 454 // Override accessibility setting and perform function. overrideLaunchAccessibility()455 private void overrideLaunchAccessibility() { 456 doReturn(true).when(mAccessibilityShortcutController) 457 .isAccessibilityShortcutAvailable(anyBoolean()); 458 doNothing().when(mAccessibilityShortcutController).performAccessibilityShortcut(); 459 } 460 interceptKeyBeforeQueueing(KeyEvent event)461 int interceptKeyBeforeQueueing(KeyEvent event) { 462 return mPhoneWindowManager.interceptKeyBeforeQueueing(event, mKeyEventPolicyFlags); 463 } 464 interceptKeyBeforeDispatching(KeyEvent event)465 long interceptKeyBeforeDispatching(KeyEvent event) { 466 return mPhoneWindowManager.interceptKeyBeforeDispatching(mInputToken, event, 467 mKeyEventPolicyFlags); 468 } 469 interceptUnhandledKey(KeyEvent event)470 void interceptUnhandledKey(KeyEvent event) { 471 mPhoneWindowManager.interceptUnhandledKey(event, mInputToken); 472 } 473 sendKeyGestureEvent(KeyGestureEvent event)474 void sendKeyGestureEvent(KeyGestureEvent event) { 475 mPhoneWindowManager.handleKeyGestureEvent(event, mInputToken); 476 } 477 478 /** 479 * Provide access to the SettingsObserver so that tests can manually trigger Settings changes. 480 */ getSettingsObserver()481 ContentObserver getSettingsObserver() { 482 return mPhoneWindowManager.mSettingsObserver; 483 } 484 getCurrentTime()485 long getCurrentTime() { 486 return mClock.now(); 487 } 488 moveTimeForward(long timeMs)489 void moveTimeForward(long timeMs) { 490 mClock.fastForward(timeMs); 491 mTestLooper.dispatchAll(); 492 } 493 overrideZenMode(int mode)494 void overrideZenMode(int mode) { 495 doReturn(mode).when(mNotificationManager).getZenMode(); 496 } 497 assertZenMode(int mode)498 void assertZenMode(int mode) { 499 verify(mNotificationManager).setZenMode(eq(mode), any(), anyString(), eq(true)); 500 } 501 502 /** 503 * Below functions will override the setting or the policy behavior. 504 */ overridePowerVolumeUp(int behavior)505 void overridePowerVolumeUp(int behavior) { 506 mPhoneWindowManager.mPowerVolUpBehavior = behavior; 507 508 // override mRingerToggleChord as mute so we could trigger the behavior. 509 if (behavior == POWER_VOLUME_UP_BEHAVIOR_MUTE) { 510 mPhoneWindowManager.mRingerToggleChord = VOLUME_HUSH_MUTE; 511 doReturn(mAudioManagerInternal).when( 512 () -> LocalServices.getService(eq(AudioManagerInternal.class))); 513 } 514 } 515 overrideShortPressOnPower(int behavior)516 void overrideShortPressOnPower(int behavior) { 517 mPhoneWindowManager.mShortPressOnPowerBehavior = behavior; 518 } 519 overrideShouldEarlyShortPressOnStemPrimary(boolean shouldEarlyShortPress)520 void overrideShouldEarlyShortPressOnStemPrimary(boolean shouldEarlyShortPress) { 521 mPhoneWindowManager.mShouldEarlyShortPressOnStemPrimary = shouldEarlyShortPress; 522 } 523 overrideTalkbackShortcutGestureEnabled(boolean enabled)524 void overrideTalkbackShortcutGestureEnabled(boolean enabled) { 525 mIsTalkBackShortcutGestureEnabled = enabled; 526 } 527 528 // Override assist perform function. overrideLongPressOnPower(int behavior)529 void overrideLongPressOnPower(int behavior) { 530 mPhoneWindowManager.mLongPressOnPowerBehavior = behavior; 531 532 switch (behavior) { 533 case LONG_PRESS_POWER_NOTHING: 534 case LONG_PRESS_POWER_GLOBAL_ACTIONS: 535 case LONG_PRESS_POWER_SHUT_OFF: 536 case LONG_PRESS_POWER_SHUT_OFF_NO_CONFIRM: 537 case LONG_PRESS_POWER_GO_TO_VOICE_ASSIST: 538 break; 539 case LONG_PRESS_POWER_ASSISTANT: 540 setupAssistForLaunch(); 541 mPhoneWindowManager.mLongPressOnPowerAssistantTimeoutMs = 500; 542 break; 543 } 544 } 545 overrideLongPressPowerForSyntheticEvent(final int behavior, final BlockingQueue<InputEvent> eventQueue)546 void overrideLongPressPowerForSyntheticEvent(final int behavior, 547 final BlockingQueue<InputEvent> eventQueue) throws RemoteException { 548 mPhoneWindowManager.getStatusBarService(); 549 spyOn(mPhoneWindowManager.mStatusBarService); 550 Mockito.doAnswer(invocation -> { 551 eventQueue.add(new KeyEvent(invocation.getArgument(0))); 552 return null; 553 }).when(mPhoneWindowManager.mStatusBarService).handleSystemKey(any()); 554 overrideLongPressOnPower(behavior); 555 } 556 overrideLongPressOnHomeBehavior(int behavior)557 void overrideLongPressOnHomeBehavior(int behavior) { 558 mPhoneWindowManager.mLongPressOnHomeBehavior = behavior; 559 } 560 overriderDoubleTapOnHomeBehavior(int behavior)561 void overriderDoubleTapOnHomeBehavior(int behavior) { 562 mPhoneWindowManager.mDoubleTapOnHomeBehavior = behavior; 563 } 564 overrideSettingsKeyBehavior(int behavior)565 void overrideSettingsKeyBehavior(int behavior) { 566 mPhoneWindowManager.mSettingsKeyBehavior = behavior; 567 } 568 overrideCanStartDreaming(boolean canDream)569 void overrideCanStartDreaming(boolean canDream) { 570 doReturn(canDream).when(mDreamManagerInternal).canStartDreaming(anyBoolean()); 571 } 572 overrideIsDreaming(boolean isDreaming)573 void overrideIsDreaming(boolean isDreaming) { 574 doReturn(isDreaming).when(mDreamManagerInternal).isDreaming(); 575 } 576 overrideDisplayState(int state)577 void overrideDisplayState(int state) { 578 doReturn(state).when(mDisplay).getState(); 579 doReturn(state == STATE_ON).when(mDisplayPolicy).isAwake(); 580 Mockito.reset(mPowerManager); 581 } 582 overrideIncallPowerBehavior(int behavior)583 void overrideIncallPowerBehavior(int behavior) { 584 mPhoneWindowManager.mIncallPowerBehavior = behavior; 585 setPhoneCallIsInProgress(); 586 } 587 overrideDelegateBackGestureRemote(boolean isDelegating)588 void overrideDelegateBackGestureRemote(boolean isDelegating) { 589 mDelegateBackGestureRemote = isDelegating; 590 doReturn(mDelegateBackGestureRemote).when(mActivityTaskManagerInternal) 591 .requestBackGesture(); 592 } 593 prepareBrightnessDecrease(float currentBrightness)594 void prepareBrightnessDecrease(float currentBrightness) { 595 doReturn(0.0f).when(mPowerManager).getBrightnessConstraint( 596 DEFAULT_DISPLAY, PowerManager.BRIGHTNESS_CONSTRAINT_TYPE_MINIMUM); 597 doReturn(1.0f).when(mPowerManager).getBrightnessConstraint( 598 DEFAULT_DISPLAY, PowerManager.BRIGHTNESS_CONSTRAINT_TYPE_MAXIMUM); 599 doReturn(currentBrightness).when(mDisplayManager) 600 .getBrightness(DEFAULT_DISPLAY); 601 } 602 verifyNewBrightness(float newBrightness)603 void verifyNewBrightness(float newBrightness) { 604 verify(mDisplayManager).setBrightness(Mockito.eq(0), 605 AdditionalMatchers.eq(newBrightness, 0.001f)); 606 } 607 setPhoneCallIsInProgress()608 void setPhoneCallIsInProgress() { 609 // Let device has an ongoing phone call. 610 doReturn(false).when(mTelecomManager).isRinging(); 611 doReturn(true).when(mTelecomManager).isInCall(); 612 doReturn(true).when(mTelecomManager).endCall(); 613 } 614 overrideTogglePanel()615 void overrideTogglePanel() { 616 // Can't directly mock on IStatusbarService, use spyOn and override the specific api. 617 mPhoneWindowManager.getStatusBarService(); 618 spyOn(mPhoneWindowManager.mStatusBarService); 619 try { 620 doNothing().when(mPhoneWindowManager.mStatusBarService).togglePanel(); 621 } catch (RemoteException e) { 622 e.printStackTrace(); 623 } 624 } 625 overrideStatusBarManagerInternal()626 void overrideStatusBarManagerInternal() { 627 doReturn(mStatusBarManagerInternal).when( 628 () -> LocalServices.getService(eq(StatusBarManagerInternal.class))); 629 } 630 overrideLaunchHome()631 void overrideLaunchHome() { 632 doNothing().when(mPhoneWindowManager).launchHomeFromHotKey(anyInt()); 633 } 634 overrideKeyguardOn(boolean isKeyguardOn)635 void overrideKeyguardOn(boolean isKeyguardOn) { 636 doReturn(isKeyguardOn).when(mPhoneWindowManager).keyguardOn(); 637 } 638 overrideIsUserSetupComplete(boolean isCompleted)639 void overrideIsUserSetupComplete(boolean isCompleted) { 640 doReturn(isCompleted).when(mPhoneWindowManager).isUserSetupComplete(); 641 } 642 setKeyguardServiceDelegateIsShowing(boolean isShowing)643 void setKeyguardServiceDelegateIsShowing(boolean isShowing) { 644 doReturn(isShowing).when(mKeyguardServiceDelegate).isShowing(); 645 } 646 overrideRoleManager()647 void overrideRoleManager() { 648 doReturn(mContext).when(mContext).createContextAsUser(any(), anyInt()); 649 doReturn(mRoleManager).when(mContext).getSystemService(eq(RoleManager.class)); 650 doReturn(mPackageManager).when(mContext).getPackageManager(); 651 } 652 setupAssistForLaunch()653 void setupAssistForLaunch() { 654 doNothing().when(mPhoneWindowManager).sendCloseSystemWindows(); 655 doReturn(true).when(mPhoneWindowManager).isUserSetupComplete(); 656 doReturn(mContext).when(mContext).createContextAsUser(any(), anyInt()); 657 doReturn(mSearchManager).when(mContext).getSystemService(eq(SearchManager.class)); 658 } 659 overrideSearchManager(SearchManager searchManager)660 void overrideSearchManager(SearchManager searchManager) { 661 doReturn(searchManager).when(mContext).getSystemService(eq(SearchManager.class)); 662 } 663 assumeResolveActivityNotNull()664 void assumeResolveActivityNotNull() { 665 ResolveInfo resolveInfo = new ResolveInfo(); 666 doReturn(resolveInfo).when(mPackageManager).resolveActivity(any(), anyInt()); 667 doReturn(mPackageManager).when(mContext).getPackageManager(); 668 } 669 overrideInjectKeyEvent()670 void overrideInjectKeyEvent() { 671 doReturn(true).when(mInputManager).injectInputEvent(any(KeyEvent.class), anyInt()); 672 } 673 assertBackEventInjected()674 void assertBackEventInjected() { 675 if (mDelegateBackGestureRemote) { 676 Mockito.verify(mActivityTaskManagerInternal).requestBackGesture(); 677 ArgumentCaptor<InputEvent> intentCaptor = ArgumentCaptor.forClass(InputEvent.class); 678 verify(mInputManager, never()).injectInputEvent(intentCaptor.capture(), anyInt()); 679 } else { 680 ArgumentCaptor<InputEvent> intentCaptor = ArgumentCaptor.forClass(InputEvent.class); 681 verify(mInputManager, times(2)).injectInputEvent(intentCaptor.capture(), anyInt()); 682 List<InputEvent> inputEvents = intentCaptor.getAllValues(); 683 Assert.assertEquals(KeyEvent.KEYCODE_BACK, 684 ((KeyEvent) inputEvents.get(0)).getKeyCode()); 685 Assert.assertEquals(KeyEvent.KEYCODE_BACK, 686 ((KeyEvent) inputEvents.get(1)).getKeyCode()); 687 // Reset verifier for next call. 688 Mockito.clearInvocations(mContext); 689 } 690 } 691 overrideSearchKeyBehavior(int behavior)692 void overrideSearchKeyBehavior(int behavior) { 693 mPhoneWindowManager.mSearchKeyBehavior = behavior; 694 } 695 overrideEnableBugReportTrigger(boolean enable)696 void overrideEnableBugReportTrigger(boolean enable) { 697 mPhoneWindowManager.mEnableBugReportKeyboardShortcut = enable; 698 } 699 overrideStartActivity()700 void overrideStartActivity() { 701 doNothing().when(mContext).startActivityAsUser(any(), any()); 702 doNothing().when(mContext).startActivityAsUser(any(), any(), any()); 703 } 704 overrideSendBroadcast()705 void overrideSendBroadcast() { 706 doNothing().when(mContext).sendBroadcastAsUser(any(), any(), any()); 707 } 708 overrideUserSetupComplete()709 void overrideUserSetupComplete() { 710 doReturn(true).when(mPhoneWindowManager).isUserSetupComplete(); 711 } 712 overrideStemPressTargetActivity(ComponentName component)713 void overrideStemPressTargetActivity(ComponentName component) { 714 mPhoneWindowManager.mPrimaryShortPressTargetActivity = component; 715 } 716 overrideFocusedWindowButtonOverridePermission(boolean granted)717 void overrideFocusedWindowButtonOverridePermission(boolean granted) { 718 doReturn(granted) 719 .when(mButtonOverridePermissionChecker).canAppOverrideSystemKey(any(), anyInt()); 720 } 721 overrideKeyEventPolicyFlags(int flags)722 void overrideKeyEventPolicyFlags(int flags) { 723 mKeyEventPolicyFlags = flags; 724 } 725 726 /** 727 * Below functions will check the policy behavior could be invoked. 728 */ assertTakeScreenshotCalled()729 void assertTakeScreenshotCalled() { 730 mTestLooper.dispatchAll(); 731 verify(mDisplayPolicy).takeScreenshot(anyInt(), anyInt()); 732 } 733 assertTakeScreenshotNotCalled()734 void assertTakeScreenshotNotCalled() { 735 mTestLooper.dispatchAll(); 736 verify(mDisplayPolicy, never()).takeScreenshot(anyInt(), anyInt()); 737 } 738 assertShowGlobalActionsCalled()739 void assertShowGlobalActionsCalled() { 740 mTestLooper.dispatchAll(); 741 verify(mPhoneWindowManager).showGlobalActions(); 742 verify(mGlobalActions).showDialog(anyBoolean(), anyBoolean()); 743 verify(mPowerManager).userActivity(anyLong(), anyBoolean()); 744 } 745 assertShowGlobalActionsNotCalled()746 void assertShowGlobalActionsNotCalled() { 747 mTestLooper.dispatchAll(); 748 verify(mGlobalActions, never()).showDialog(anyBoolean(), anyBoolean()); 749 verify(mPowerManager, never()).userActivity(anyLong(), anyBoolean()); 750 } 751 assertVolumeMute()752 void assertVolumeMute() { 753 mTestLooper.dispatchAll(); 754 verify(mAudioManagerInternal).silenceRingerModeInternal(eq("volume_hush")); 755 } 756 assertVolumeNotMuted()757 void assertVolumeNotMuted() { 758 mTestLooper.dispatchAll(); 759 verify(mAudioManagerInternal, never()).silenceRingerModeInternal(any()); 760 } 761 assertAccessibilityKeychordCalled()762 void assertAccessibilityKeychordCalled() { 763 mTestLooper.dispatchAll(); 764 verify(mAccessibilityShortcutController).performAccessibilityShortcut(); 765 } 766 assertCloseAllDialogs()767 void assertCloseAllDialogs() { 768 verify(mContext).closeSystemDialogs(); 769 } 770 assertDreamRequest()771 void assertDreamRequest() { 772 mTestLooper.dispatchAll(); 773 verify(mDreamManagerInternal).requestDream(); 774 } 775 assertPowerSleep()776 void assertPowerSleep() { 777 mTestLooper.dispatchAll(); 778 verify(mPowerManager).goToSleep(anyLong(), anyInt(), anyInt()); 779 } 780 assertPowerWakeUp()781 void assertPowerWakeUp() { 782 mTestLooper.dispatchAll(); 783 verify(mWindowWakeUpPolicy).wakeUpFromKey( 784 eq(DEFAULT_DISPLAY), anyLong(), eq(KeyEvent.KEYCODE_POWER), anyBoolean()); 785 } 786 assertNoPowerSleep()787 void assertNoPowerSleep() { 788 mTestLooper.dispatchAll(); 789 verify(mPowerManager, never()).goToSleep(anyLong(), anyInt(), anyInt()); 790 } 791 assertDoublePowerLaunch()792 void assertDoublePowerLaunch() { 793 ArgumentCaptor<MutableBoolean> valueCaptor = ArgumentCaptor.forClass(MutableBoolean.class); 794 795 mTestLooper.dispatchAll(); 796 verify(mGestureLauncherService, atLeast(2)) 797 .interceptPowerKeyDown(any(), anyBoolean(), valueCaptor.capture()); 798 verify(mGestureLauncherService, atMost(4)) 799 .interceptPowerKeyDown(any(), anyBoolean(), valueCaptor.capture()); 800 801 List<Boolean> capturedValues = valueCaptor.getAllValues().stream() 802 .map(mutableBoolean -> mutableBoolean.value) 803 .toList(); 804 805 assertTrue(capturedValues.contains(true)); 806 } 807 assertNoDoublePowerLaunch()808 void assertNoDoublePowerLaunch() { 809 ArgumentCaptor<MutableBoolean> valueCaptor = ArgumentCaptor.forClass(MutableBoolean.class); 810 811 mTestLooper.dispatchAll(); 812 verify(mGestureLauncherService, atLeast(0)) 813 .interceptPowerKeyDown(any(), anyBoolean(), valueCaptor.capture()); 814 815 List<Boolean> capturedValues = valueCaptor.getAllValues().stream() 816 .map(mutableBoolean -> mutableBoolean.value) 817 .toList(); 818 819 assertTrue(capturedValues.stream().noneMatch(value -> value)); 820 } 821 assertEmergencyLaunch()822 void assertEmergencyLaunch() { 823 ArgumentCaptor<MutableBoolean> valueCaptor = ArgumentCaptor.forClass(MutableBoolean.class); 824 825 mTestLooper.dispatchAll(); 826 verify(mGestureLauncherService, atLeast(1)) 827 .interceptPowerKeyDown(any(), anyBoolean(), valueCaptor.capture()); 828 829 List<Boolean> capturedValues = valueCaptor.getAllValues().stream() 830 .map(mutableBoolean -> mutableBoolean.value) 831 .toList(); 832 833 assertTrue(capturedValues.getLast()); 834 } 835 assertSearchManagerLaunchAssist()836 void assertSearchManagerLaunchAssist() { 837 mTestLooper.dispatchAll(); 838 verify(mSearchManager).launchAssist(any()); 839 } 840 assertSearchManagerDoesntLaunchAssist()841 void assertSearchManagerDoesntLaunchAssist() { 842 mTestLooper.dispatchAll(); 843 verify(mSearchManager, never()).launchAssist(any()); 844 } 845 assertLaunchSystemSettings()846 void assertLaunchSystemSettings() { 847 mTestLooper.dispatchAll(); 848 ArgumentCaptor<Intent> intentCaptor = ArgumentCaptor.forClass(Intent.class); 849 verify(mContext).startActivityAsUser(intentCaptor.capture(), any(), any()); 850 Assert.assertEquals(Settings.ACTION_SETTINGS, intentCaptor.getValue().getAction()); 851 // Reset verifier for next call. 852 Mockito.clearInvocations(mContext); 853 } 854 assertLaunchSearch()855 void assertLaunchSearch() { 856 mTestLooper.dispatchAll(); 857 ArgumentCaptor<Intent> intentCaptor = ArgumentCaptor.forClass(Intent.class); 858 verify(mContext).startActivityAsUser(intentCaptor.capture(), any(), any()); 859 Assert.assertEquals(Intent.ACTION_WEB_SEARCH, intentCaptor.getValue().getAction()); 860 // Reset verifier for next call. 861 Mockito.clearInvocations(mContext); 862 } 863 assertLaunchCategory(String category)864 void assertLaunchCategory(String category) { 865 mTestLooper.dispatchAll(); 866 ArgumentCaptor<Intent> intentCaptor = ArgumentCaptor.forClass(Intent.class); 867 try { 868 verify(mContext).startActivityAsUser(intentCaptor.capture(), any()); 869 Assert.assertTrue(intentCaptor.getValue().getSelector().hasCategory(category)); 870 } catch (Throwable t) { 871 throw new AssertionError("failed to assert " + category, t); 872 } 873 // Reset verifier for next call. 874 Mockito.clearInvocations(mContext); 875 } 876 assertLaunchRole(String role)877 void assertLaunchRole(String role) { 878 mTestLooper.dispatchAll(); 879 ArgumentCaptor<Intent> intentCaptor = ArgumentCaptor.forClass(Intent.class); 880 try { 881 verify(mContext).startActivityAsUser(intentCaptor.capture(), any()); 882 switch (role) { 883 case RoleManager.ROLE_BROWSER: 884 Assert.assertEquals(mBrowserIntent, intentCaptor.getValue()); 885 break; 886 case RoleManager.ROLE_SMS: 887 Assert.assertEquals(mSmsIntent, intentCaptor.getValue()); 888 break; 889 default: 890 throw new AssertionError("Role " + role + " not supported in tests."); 891 } 892 } catch (Throwable t) { 893 throw new AssertionError("failed to assert " + role, t); 894 } 895 // Reset verifier for next call. 896 Mockito.clearInvocations(mContext); 897 } 898 assertShowRecentApps()899 void assertShowRecentApps() { 900 mTestLooper.dispatchAll(); 901 verify(mStatusBarManagerInternal).showRecentApps(anyBoolean()); 902 } 903 assertHideRecentApps()904 void assertHideRecentApps() { 905 mTestLooper.dispatchAll(); 906 verify(mStatusBarManagerInternal).hideRecentApps(anyBoolean(), anyBoolean()); 907 } 908 assertToggleRecentApps()909 void assertToggleRecentApps() { 910 mTestLooper.dispatchAll(); 911 verify(mStatusBarManagerInternal).toggleRecentApps(); 912 } 913 assertMoveFocusedTaskToDesktop()914 void assertMoveFocusedTaskToDesktop() { 915 mTestLooper.dispatchAll(); 916 verify(mStatusBarManagerInternal).moveFocusedTaskToDesktop(anyInt()); 917 } 918 assertMoveFocusedTaskToFullscreen()919 void assertMoveFocusedTaskToFullscreen() { 920 mTestLooper.dispatchAll(); 921 verify(mStatusBarManagerInternal).moveFocusedTaskToFullscreen(anyInt()); 922 } 923 assertMoveFocusedTaskToStageSplit(boolean leftOrTop)924 void assertMoveFocusedTaskToStageSplit(boolean leftOrTop) { 925 mTestLooper.dispatchAll(); 926 verify(mStatusBarManagerInternal).moveFocusedTaskToStageSplit(anyInt(), eq(leftOrTop)); 927 } 928 assertStatusBarStartAssist()929 void assertStatusBarStartAssist() { 930 mTestLooper.dispatchAll(); 931 verify(mStatusBarManagerInternal).startAssist(any()); 932 } 933 assertSwitchKeyboardLayout(int direction, int displayId)934 void assertSwitchKeyboardLayout(int direction, int displayId) { 935 mTestLooper.dispatchAll(); 936 verify(mInputMethodManagerInternal).onSwitchKeyboardLayoutShortcut(eq(direction), 937 eq(displayId), eq(mImeTargetWindowToken)); 938 } 939 assertTakeBugreport(boolean wasCalled)940 void assertTakeBugreport(boolean wasCalled) throws RemoteException { 941 mTestLooper.dispatchAll(); 942 if (wasCalled) { 943 verify(mActivityManagerService).launchBugReportHandlerApp(); 944 } else { 945 verify(mActivityManagerService, never()).launchBugReportHandlerApp(); 946 } 947 948 } 949 assertBugReportTakenForTv()950 void assertBugReportTakenForTv() { 951 mTestLooper.dispatchAll(); 952 verify(mPhoneWindowManager).requestBugreportForTv(); 953 } 954 assertBugReportNotTakenForTv()955 void assertBugReportNotTakenForTv() { 956 mTestLooper.dispatchAll(); 957 verify(mPhoneWindowManager, never()).requestBugreportForTv(); 958 } 959 assertTogglePanel()960 void assertTogglePanel() throws RemoteException { 961 mTestLooper.dispatchAll(); 962 verify(mPhoneWindowManager.mStatusBarService).togglePanel(); 963 } 964 assertToggleShortcutsMenu()965 void assertToggleShortcutsMenu() { 966 mTestLooper.dispatchAll(); 967 verify(mStatusBarManagerInternal).toggleKeyboardShortcutsMenu(anyInt()); 968 } 969 assertToggleCapsLock()970 void assertToggleCapsLock() { 971 mTestLooper.dispatchAll(); 972 verify(mInputManagerInternal).toggleCapsLock(anyInt()); 973 } 974 assertLockedAfterAppTransitionFinished()975 void assertLockedAfterAppTransitionFinished() { 976 ArgumentCaptor<AppTransitionListener> transitionCaptor = 977 ArgumentCaptor.forClass(AppTransitionListener.class); 978 verify(mWindowManagerInternal).registerAppTransitionListener( 979 transitionCaptor.capture()); 980 final IBinder token = mock(IBinder.class); 981 transitionCaptor.getValue().onAppTransitionFinishedLocked(token); 982 verify(mPhoneWindowManager).lockNow(null); 983 } 984 assertDidNotLockAfterAppTransitionFinished()985 void assertDidNotLockAfterAppTransitionFinished() { 986 ArgumentCaptor<AppTransitionListener> transitionCaptor = 987 ArgumentCaptor.forClass(AppTransitionListener.class); 988 verify(mWindowManagerInternal).registerAppTransitionListener( 989 transitionCaptor.capture()); 990 final IBinder token = mock(IBinder.class); 991 transitionCaptor.getValue().onAppTransitionFinishedLocked(token); 992 verify(mPhoneWindowManager, never()).lockNow(null); 993 } 994 assertGoToHomescreen()995 void assertGoToHomescreen() { 996 mTestLooper.dispatchAll(); 997 verify(mPhoneWindowManager).launchHomeFromHotKey(anyInt()); 998 } 999 assertOpenAllAppView()1000 void assertOpenAllAppView() { 1001 moveTimeForward(TEST_SINGLE_KEY_DELAY_MILLIS); 1002 ArgumentCaptor<Intent> intentCaptor = ArgumentCaptor.forClass(Intent.class); 1003 verify(mContext, timeout(TEST_SINGLE_KEY_DELAY_MILLIS)) 1004 .startActivityAsUser(intentCaptor.capture(), isNull(), any(UserHandle.class)); 1005 Assert.assertEquals(Intent.ACTION_ALL_APPS, intentCaptor.getValue().getAction()); 1006 } 1007 assertNotOpenAllAppView()1008 void assertNotOpenAllAppView() { 1009 mTestLooper.dispatchAll(); 1010 verify(mContext, after(TEST_SINGLE_KEY_DELAY_MILLIS).never()) 1011 .startActivityAsUser(any(Intent.class), any(), any(UserHandle.class)); 1012 } 1013 assertActivityTargetLaunched(ComponentName targetActivity)1014 void assertActivityTargetLaunched(ComponentName targetActivity) { 1015 moveTimeForward(TEST_SINGLE_KEY_DELAY_MILLIS); 1016 ArgumentCaptor<Intent> intentCaptor = ArgumentCaptor.forClass(Intent.class); 1017 verify(mContext, timeout(TEST_SINGLE_KEY_DELAY_MILLIS)) 1018 .startActivityAsUser(intentCaptor.capture(), isNull(), any(UserHandle.class)); 1019 Assert.assertEquals(targetActivity, intentCaptor.getValue().getComponent()); 1020 } 1021 assertKeyGestureCompleted(int[] keycodes, int modifierState, int gestureType, String errorMsg)1022 void assertKeyGestureCompleted(int[] keycodes, int modifierState, int gestureType, 1023 String errorMsg) { 1024 mTestLooper.dispatchAll(); 1025 verify(mInputManagerInternal, description(errorMsg)).notifyKeyGestureCompleted( 1026 anyInt(), eq(keycodes), eq(modifierState), eq(gestureType)); 1027 } 1028 assertSwitchToTask(int persistentId)1029 void assertSwitchToTask(int persistentId) throws RemoteException { 1030 mTestLooper.dispatchAll(); 1031 verify(mActivityManagerService, 1032 timeout(TEST_SINGLE_KEY_DELAY_MILLIS)).startActivityFromRecents(eq(persistentId), 1033 isNull()); 1034 } 1035 assertTalkBack(boolean expectEnabled)1036 void assertTalkBack(boolean expectEnabled) { 1037 mTestLooper.dispatchAll(); 1038 Assert.assertEquals(expectEnabled, mIsTalkBackEnabled); 1039 } 1040 assertVoiceAccess(boolean expectEnabled)1041 void assertVoiceAccess(boolean expectEnabled) { 1042 mTestLooper.dispatchAll(); 1043 Assert.assertEquals(expectEnabled, mIsVoiceAccessEnabled); 1044 } 1045 assertKeyGestureEventSentToKeyGestureController(int gestureType)1046 void assertKeyGestureEventSentToKeyGestureController(int gestureType) { 1047 verify(mInputManagerInternal) 1048 .handleKeyGestureInKeyGestureController(anyInt(), any(), anyInt(), eq(gestureType)); 1049 } 1050 assertNoActivityLaunched()1051 void assertNoActivityLaunched() { 1052 mTestLooper.dispatchAll(); 1053 verify(mContext, never()).startActivityAsUser(any(), any(), any()); 1054 verify(mContext, never()).startActivityAsUser(any(), any()); 1055 } 1056 } 1057