1 /* 2 * Copyright 2023 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.view.Display.DEFAULT_DISPLAY; 20 21 import static com.android.server.policy.PhoneWindowManager.DOUBLE_TAP_HOME_RECENT_SYSTEM_UI; 22 import static com.android.server.policy.PhoneWindowManager.LONG_PRESS_HOME_ALL_APPS; 23 import static com.android.server.policy.PhoneWindowManager.LONG_PRESS_HOME_ASSIST; 24 import static com.android.server.policy.PhoneWindowManager.LONG_PRESS_HOME_NOTIFICATION_PANEL; 25 import static com.android.server.policy.PhoneWindowManager.POWER_VOLUME_UP_BEHAVIOR_GLOBAL_ACTIONS; 26 import static com.android.server.policy.PhoneWindowManager.POWER_VOLUME_UP_BEHAVIOR_MUTE; 27 import static com.android.server.policy.PhoneWindowManager.SETTINGS_KEY_BEHAVIOR_NOTIFICATION_PANEL; 28 29 import android.hardware.input.KeyGestureEvent; 30 import android.os.RemoteException; 31 import android.platform.test.annotations.DisableFlags; 32 import android.platform.test.annotations.EnableFlags; 33 import android.platform.test.annotations.Presubmit; 34 import android.provider.Settings; 35 import android.view.KeyEvent; 36 37 import androidx.test.filters.MediumTest; 38 39 import com.android.hardware.input.Flags; 40 import com.android.internal.annotations.Keep; 41 42 import junitparams.JUnitParamsRunner; 43 import junitparams.Parameters; 44 45 import org.junit.Before; 46 import org.junit.Test; 47 import org.junit.runner.RunWith; 48 49 @Presubmit 50 @MediumTest 51 @RunWith(JUnitParamsRunner.class) 52 public class KeyGestureEventTests extends ShortcutKeyTestBase { 53 54 private static final int META_KEY = KeyEvent.KEYCODE_META_LEFT; 55 private static final int META_ON = MODIFIER.get(KeyEvent.KEYCODE_META_LEFT); 56 private static final int ALT_KEY = KeyEvent.KEYCODE_ALT_LEFT; 57 private static final int ALT_ON = MODIFIER.get(KeyEvent.KEYCODE_ALT_LEFT); 58 private static final int CTRL_KEY = KeyEvent.KEYCODE_CTRL_LEFT; 59 private static final int CTRL_ON = MODIFIER.get(KeyEvent.KEYCODE_CTRL_LEFT); 60 61 @Keep shortcutTestArgumentsNotMigratedToKeyGestureController()62 private static Object[][] shortcutTestArgumentsNotMigratedToKeyGestureController() { 63 // testName, testKeys, expectedKeyGestureType, expectedKey, expectedModifierState 64 return new Object[][]{ 65 {"HOME key -> Open Home", new int[]{KeyEvent.KEYCODE_HOME}, 66 KeyGestureEvent.KEY_GESTURE_TYPE_HOME, 67 KeyEvent.KEYCODE_HOME, 0}, 68 {"BACK key -> Go back", new int[]{KeyEvent.KEYCODE_BACK}, 69 KeyGestureEvent.KEY_GESTURE_TYPE_BACK, 70 KeyEvent.KEYCODE_BACK, 0}, 71 {"VOLUME_UP key -> Increase Volume", new int[]{KeyEvent.KEYCODE_VOLUME_UP}, 72 KeyGestureEvent.KEY_GESTURE_TYPE_VOLUME_UP, 73 KeyEvent.KEYCODE_VOLUME_UP, 0}, 74 {"VOLUME_DOWN key -> Decrease Volume", new int[]{KeyEvent.KEYCODE_VOLUME_DOWN}, 75 KeyGestureEvent.KEY_GESTURE_TYPE_VOLUME_DOWN, 76 KeyEvent.KEYCODE_VOLUME_DOWN, 0}, 77 {"VOLUME_MUTE key -> Mute Volume", new int[]{KeyEvent.KEYCODE_VOLUME_MUTE}, 78 KeyGestureEvent.KEY_GESTURE_TYPE_VOLUME_MUTE, 79 KeyEvent.KEYCODE_VOLUME_MUTE, 0}, 80 {"MUTE key -> Mute System Microphone", new int[]{KeyEvent.KEYCODE_MUTE}, 81 KeyGestureEvent.KEY_GESTURE_TYPE_SYSTEM_MUTE, KeyEvent.KEYCODE_MUTE, 82 0}, 83 {"POWER key -> Toggle Power", new int[]{KeyEvent.KEYCODE_POWER}, 84 KeyGestureEvent.KEY_GESTURE_TYPE_TOGGLE_POWER, KeyEvent.KEYCODE_POWER, 85 0}, 86 {"TV_POWER key -> Toggle Power", new int[]{KeyEvent.KEYCODE_TV_POWER}, 87 KeyGestureEvent.KEY_GESTURE_TYPE_TOGGLE_POWER, 88 KeyEvent.KEYCODE_TV_POWER, 0}, 89 {"SYSTEM_NAVIGATION_DOWN key -> System Navigation", 90 new int[]{KeyEvent.KEYCODE_SYSTEM_NAVIGATION_DOWN}, 91 KeyGestureEvent.KEY_GESTURE_TYPE_SYSTEM_NAVIGATION, 92 KeyEvent.KEYCODE_SYSTEM_NAVIGATION_DOWN, 93 0}, 94 {"SYSTEM_NAVIGATION_UP key -> System Navigation", 95 new int[]{KeyEvent.KEYCODE_SYSTEM_NAVIGATION_UP}, 96 KeyGestureEvent.KEY_GESTURE_TYPE_SYSTEM_NAVIGATION, 97 KeyEvent.KEYCODE_SYSTEM_NAVIGATION_UP, 98 0}, 99 {"SYSTEM_NAVIGATION_LEFT key -> System Navigation", 100 new int[]{KeyEvent.KEYCODE_SYSTEM_NAVIGATION_LEFT}, 101 KeyGestureEvent.KEY_GESTURE_TYPE_SYSTEM_NAVIGATION, 102 KeyEvent.KEYCODE_SYSTEM_NAVIGATION_LEFT, 103 0}, 104 {"SYSTEM_NAVIGATION_RIGHT key -> System Navigation", 105 new int[]{KeyEvent.KEYCODE_SYSTEM_NAVIGATION_RIGHT}, 106 KeyGestureEvent.KEY_GESTURE_TYPE_SYSTEM_NAVIGATION, 107 KeyEvent.KEYCODE_SYSTEM_NAVIGATION_RIGHT, 0}, 108 {"SLEEP key -> System Sleep", new int[]{KeyEvent.KEYCODE_SLEEP}, 109 KeyGestureEvent.KEY_GESTURE_TYPE_SLEEP, KeyEvent.KEYCODE_SLEEP, 0}, 110 {"SOFT_SLEEP key -> System Sleep", new int[]{KeyEvent.KEYCODE_SOFT_SLEEP}, 111 KeyGestureEvent.KEY_GESTURE_TYPE_SLEEP, KeyEvent.KEYCODE_SOFT_SLEEP, 112 0}, 113 {"WAKEUP key -> System Wakeup", new int[]{KeyEvent.KEYCODE_WAKEUP}, 114 KeyGestureEvent.KEY_GESTURE_TYPE_WAKEUP, KeyEvent.KEYCODE_WAKEUP, 0}, 115 {"MEDIA_PLAY key -> Media Control", new int[]{KeyEvent.KEYCODE_MEDIA_PLAY}, 116 KeyGestureEvent.KEY_GESTURE_TYPE_MEDIA_KEY, 117 KeyEvent.KEYCODE_MEDIA_PLAY, 0}, 118 {"MEDIA_PAUSE key -> Media Control", new int[]{KeyEvent.KEYCODE_MEDIA_PAUSE}, 119 KeyGestureEvent.KEY_GESTURE_TYPE_MEDIA_KEY, 120 KeyEvent.KEYCODE_MEDIA_PAUSE, 0}, 121 {"MEDIA_PLAY_PAUSE key -> Media Control", 122 new int[]{KeyEvent.KEYCODE_MEDIA_PLAY_PAUSE}, 123 KeyGestureEvent.KEY_GESTURE_TYPE_MEDIA_KEY, 124 KeyEvent.KEYCODE_MEDIA_PLAY_PAUSE, 0}}; 125 } 126 127 @Keep shortcutTestArgumentsMigratedToKeyGestureController()128 private static Object[][] shortcutTestArgumentsMigratedToKeyGestureController() { 129 // testName, testKeys, expectedKeyGestureType, expectedKey, expectedModifierState 130 return new Object[][]{ 131 {"Meta + H -> Open Home", new int[]{META_KEY, KeyEvent.KEYCODE_H}, 132 KeyGestureEvent.KEY_GESTURE_TYPE_HOME, KeyEvent.KEYCODE_H, META_ON}, 133 {"Meta + Enter -> Open Home", new int[]{META_KEY, KeyEvent.KEYCODE_ENTER}, 134 KeyGestureEvent.KEY_GESTURE_TYPE_HOME, KeyEvent.KEYCODE_ENTER, 135 META_ON}, 136 {"RECENT_APPS key -> Open Overview", new int[]{KeyEvent.KEYCODE_RECENT_APPS}, 137 KeyGestureEvent.KEY_GESTURE_TYPE_RECENT_APPS, 138 KeyEvent.KEYCODE_RECENT_APPS, 0}, 139 {"Meta + Tab -> Open Overview", new int[]{META_KEY, KeyEvent.KEYCODE_TAB}, 140 KeyGestureEvent.KEY_GESTURE_TYPE_RECENT_APPS, KeyEvent.KEYCODE_TAB, 141 META_ON}, 142 {"Alt + Tab -> Open Overview", new int[]{ALT_KEY, KeyEvent.KEYCODE_TAB}, 143 KeyGestureEvent.KEY_GESTURE_TYPE_RECENT_APPS, KeyEvent.KEYCODE_TAB, 144 ALT_ON}, 145 {"Meta + Escape -> Go back", new int[]{META_KEY, KeyEvent.KEYCODE_ESCAPE}, 146 KeyGestureEvent.KEY_GESTURE_TYPE_BACK, KeyEvent.KEYCODE_ESCAPE, 147 META_ON}, 148 {"Meta + Left arrow -> Go back", new int[]{META_KEY, KeyEvent.KEYCODE_DPAD_LEFT}, 149 KeyGestureEvent.KEY_GESTURE_TYPE_BACK, KeyEvent.KEYCODE_DPAD_LEFT, 150 META_ON}, 151 {"APP_SWITCH key -> Open App switcher", new int[]{KeyEvent.KEYCODE_APP_SWITCH}, 152 KeyGestureEvent.KEY_GESTURE_TYPE_APP_SWITCH, 153 KeyEvent.KEYCODE_APP_SWITCH, 0}, 154 {"ASSIST key -> Launch assistant", new int[]{KeyEvent.KEYCODE_ASSIST}, 155 KeyGestureEvent.KEY_GESTURE_TYPE_LAUNCH_ASSISTANT, 156 KeyEvent.KEYCODE_ASSIST, 0}, 157 {"Meta + A -> Launch assistant", new int[]{META_KEY, KeyEvent.KEYCODE_A}, 158 KeyGestureEvent.KEY_GESTURE_TYPE_LAUNCH_ASSISTANT, KeyEvent.KEYCODE_A, 159 META_ON}, 160 {"VOICE_ASSIST key -> Launch Voice Assistant", 161 new int[]{KeyEvent.KEYCODE_VOICE_ASSIST}, 162 KeyGestureEvent.KEY_GESTURE_TYPE_LAUNCH_VOICE_ASSISTANT, 163 KeyEvent.KEYCODE_VOICE_ASSIST, 0}, 164 {"Meta + I -> Launch System Settings", new int[]{META_KEY, KeyEvent.KEYCODE_I}, 165 KeyGestureEvent.KEY_GESTURE_TYPE_LAUNCH_SYSTEM_SETTINGS, 166 KeyEvent.KEYCODE_I, META_ON}, 167 {"Meta + N -> Toggle Notification panel", new int[]{META_KEY, KeyEvent.KEYCODE_N}, 168 KeyGestureEvent.KEY_GESTURE_TYPE_TOGGLE_NOTIFICATION_PANEL, 169 KeyEvent.KEYCODE_N, META_ON}, 170 {"NOTIFICATION key -> Toggle Notification Panel", 171 new int[]{KeyEvent.KEYCODE_NOTIFICATION}, 172 KeyGestureEvent.KEY_GESTURE_TYPE_TOGGLE_NOTIFICATION_PANEL, 173 KeyEvent.KEYCODE_NOTIFICATION, 174 0}, 175 {"Meta + S -> Take Screenshot", 176 new int[]{META_KEY, KeyEvent.KEYCODE_S}, 177 KeyGestureEvent.KEY_GESTURE_TYPE_TAKE_SCREENSHOT, KeyEvent.KEYCODE_S, 178 META_ON}, 179 {"Meta + / -> Open Shortcut Helper", new int[]{META_KEY, KeyEvent.KEYCODE_SLASH}, 180 KeyGestureEvent.KEY_GESTURE_TYPE_OPEN_SHORTCUT_HELPER, 181 KeyEvent.KEYCODE_SLASH, META_ON}, 182 {"BRIGHTNESS_UP key -> Increase Brightness", 183 new int[]{KeyEvent.KEYCODE_BRIGHTNESS_UP}, 184 KeyGestureEvent.KEY_GESTURE_TYPE_BRIGHTNESS_UP, 185 KeyEvent.KEYCODE_BRIGHTNESS_UP, 0}, 186 {"BRIGHTNESS_DOWN key -> Decrease Brightness", 187 new int[]{KeyEvent.KEYCODE_BRIGHTNESS_DOWN}, 188 KeyGestureEvent.KEY_GESTURE_TYPE_BRIGHTNESS_DOWN, 189 KeyEvent.KEYCODE_BRIGHTNESS_DOWN, 0}, 190 {"KEYBOARD_BACKLIGHT_UP key -> Increase Keyboard Backlight", 191 new int[]{KeyEvent.KEYCODE_KEYBOARD_BACKLIGHT_UP}, 192 KeyGestureEvent.KEY_GESTURE_TYPE_KEYBOARD_BACKLIGHT_UP, 193 KeyEvent.KEYCODE_KEYBOARD_BACKLIGHT_UP, 0}, 194 {"KEYBOARD_BACKLIGHT_DOWN key -> Decrease Keyboard Backlight", 195 new int[]{KeyEvent.KEYCODE_KEYBOARD_BACKLIGHT_DOWN}, 196 KeyGestureEvent.KEY_GESTURE_TYPE_KEYBOARD_BACKLIGHT_DOWN, 197 KeyEvent.KEYCODE_KEYBOARD_BACKLIGHT_DOWN, 0}, 198 {"KEYBOARD_BACKLIGHT_TOGGLE key -> Toggle Keyboard Backlight", 199 new int[]{KeyEvent.KEYCODE_KEYBOARD_BACKLIGHT_TOGGLE}, 200 KeyGestureEvent.KEY_GESTURE_TYPE_KEYBOARD_BACKLIGHT_TOGGLE, 201 KeyEvent.KEYCODE_KEYBOARD_BACKLIGHT_TOGGLE, 0}, 202 {"ALL_APPS key -> Open App Drawer", 203 new int[]{KeyEvent.KEYCODE_ALL_APPS}, 204 KeyGestureEvent.KEY_GESTURE_TYPE_ALL_APPS, 205 KeyEvent.KEYCODE_ALL_APPS, 0}, 206 {"SEARCH key -> Launch Search Activity", new int[]{KeyEvent.KEYCODE_SEARCH}, 207 KeyGestureEvent.KEY_GESTURE_TYPE_LAUNCH_SEARCH, 208 KeyEvent.KEYCODE_SEARCH, 0}, 209 {"LANGUAGE_SWITCH key -> Switch Keyboard Language", 210 new int[]{KeyEvent.KEYCODE_LANGUAGE_SWITCH}, 211 KeyGestureEvent.KEY_GESTURE_TYPE_LANGUAGE_SWITCH, 212 KeyEvent.KEYCODE_LANGUAGE_SWITCH, 0}, 213 {"META key -> Open App Drawer", new int[]{META_KEY}, 214 KeyGestureEvent.KEY_GESTURE_TYPE_ALL_APPS, META_KEY, 215 META_ON}, 216 {"Meta + Alt -> Toggle CapsLock", new int[]{META_KEY, ALT_KEY}, 217 KeyGestureEvent.KEY_GESTURE_TYPE_TOGGLE_CAPS_LOCK, ALT_KEY, 218 META_ON | ALT_ON}, 219 {"Alt + Meta -> Toggle CapsLock", new int[]{ALT_KEY, META_KEY}, 220 KeyGestureEvent.KEY_GESTURE_TYPE_TOGGLE_CAPS_LOCK, META_KEY, 221 META_ON | ALT_ON}, 222 {"CAPS_LOCK key -> Toggle CapsLock", new int[]{KeyEvent.KEYCODE_CAPS_LOCK}, 223 KeyGestureEvent.KEY_GESTURE_TYPE_TOGGLE_CAPS_LOCK, 224 KeyEvent.KEYCODE_CAPS_LOCK, 0}, 225 {"Meta + Ctrl + DPAD_UP -> Split screen navigation", 226 new int[]{META_KEY, CTRL_KEY, KeyEvent.KEYCODE_DPAD_UP}, 227 KeyGestureEvent.KEY_GESTURE_TYPE_MULTI_WINDOW_NAVIGATION, 228 KeyEvent.KEYCODE_DPAD_UP, 229 META_ON | CTRL_ON}, 230 {"Meta + Ctrl + DPAD_LEFT -> Split screen navigation", 231 new int[]{META_KEY, CTRL_KEY, KeyEvent.KEYCODE_DPAD_LEFT}, 232 KeyGestureEvent.KEY_GESTURE_TYPE_SPLIT_SCREEN_NAVIGATION_LEFT, 233 KeyEvent.KEYCODE_DPAD_LEFT, 234 META_ON | CTRL_ON}, 235 {"Meta + Ctrl + DPAD_RIGHT -> Split screen navigation", 236 new int[]{META_KEY, CTRL_KEY, KeyEvent.KEYCODE_DPAD_RIGHT}, 237 KeyGestureEvent.KEY_GESTURE_TYPE_SPLIT_SCREEN_NAVIGATION_RIGHT, 238 KeyEvent.KEYCODE_DPAD_RIGHT, 239 META_ON | CTRL_ON}, 240 {"Meta + L -> Lock Homescreen", new int[]{META_KEY, KeyEvent.KEYCODE_L}, 241 KeyGestureEvent.KEY_GESTURE_TYPE_LOCK_SCREEN, KeyEvent.KEYCODE_L, 242 META_ON}, 243 {"Meta + Ctrl + DPAD_DOWN -> Enter desktop mode", 244 new int[]{META_KEY, CTRL_KEY, KeyEvent.KEYCODE_DPAD_DOWN}, 245 KeyGestureEvent.KEY_GESTURE_TYPE_DESKTOP_MODE, 246 KeyEvent.KEYCODE_DPAD_DOWN, 247 META_ON | CTRL_ON}, 248 {"Meta + B -> Launch Default Browser", new int[]{META_KEY, KeyEvent.KEYCODE_B}, 249 KeyGestureEvent.KEY_GESTURE_TYPE_LAUNCH_DEFAULT_BROWSER, 250 KeyEvent.KEYCODE_B, META_ON}, 251 {"EXPLORER key -> Launch Default Browser", new int[]{KeyEvent.KEYCODE_EXPLORER}, 252 KeyGestureEvent.KEY_GESTURE_TYPE_LAUNCH_DEFAULT_BROWSER, 253 KeyEvent.KEYCODE_EXPLORER, 0}, 254 {"Meta + P -> Launch Default Contacts", new int[]{META_KEY, KeyEvent.KEYCODE_P}, 255 KeyGestureEvent.KEY_GESTURE_TYPE_LAUNCH_DEFAULT_CONTACTS, 256 KeyEvent.KEYCODE_P, META_ON}, 257 {"CONTACTS key -> Launch Default Contacts", new int[]{KeyEvent.KEYCODE_CONTACTS}, 258 KeyGestureEvent.KEY_GESTURE_TYPE_LAUNCH_DEFAULT_CONTACTS, 259 KeyEvent.KEYCODE_CONTACTS, 0}, 260 {"Meta + E -> Launch Default Email", new int[]{META_KEY, KeyEvent.KEYCODE_E}, 261 KeyGestureEvent.KEY_GESTURE_TYPE_LAUNCH_DEFAULT_EMAIL, 262 KeyEvent.KEYCODE_E, META_ON}, 263 {"ENVELOPE key -> Launch Default Email", new int[]{KeyEvent.KEYCODE_ENVELOPE}, 264 KeyGestureEvent.KEY_GESTURE_TYPE_LAUNCH_DEFAULT_EMAIL, 265 KeyEvent.KEYCODE_ENVELOPE, 0}, 266 {"Meta + C -> Launch Default Calendar", new int[]{META_KEY, KeyEvent.KEYCODE_C}, 267 KeyGestureEvent.KEY_GESTURE_TYPE_LAUNCH_DEFAULT_CALENDAR, 268 KeyEvent.KEYCODE_C, META_ON}, 269 {"CALENDAR key -> Launch Default Calendar", new int[]{KeyEvent.KEYCODE_CALENDAR}, 270 KeyGestureEvent.KEY_GESTURE_TYPE_LAUNCH_DEFAULT_CALENDAR, 271 KeyEvent.KEYCODE_CALENDAR, 0}, 272 {"MUSIC key -> Launch Default Music", new int[]{KeyEvent.KEYCODE_MUSIC}, 273 KeyGestureEvent.KEY_GESTURE_TYPE_LAUNCH_DEFAULT_MUSIC, 274 KeyEvent.KEYCODE_MUSIC, 0}, 275 {"Meta + U -> Launch Default Calculator", new int[]{META_KEY, KeyEvent.KEYCODE_U}, 276 KeyGestureEvent.KEY_GESTURE_TYPE_LAUNCH_DEFAULT_CALCULATOR, 277 KeyEvent.KEYCODE_U, META_ON}, 278 {"CALCULATOR key -> Launch Default Calculator", 279 new int[]{KeyEvent.KEYCODE_CALCULATOR}, 280 KeyGestureEvent.KEY_GESTURE_TYPE_LAUNCH_DEFAULT_CALCULATOR, 281 KeyEvent.KEYCODE_CALCULATOR, 0}, 282 {"Meta + M -> Launch Default Maps", new int[]{META_KEY, KeyEvent.KEYCODE_M}, 283 KeyGestureEvent.KEY_GESTURE_TYPE_LAUNCH_DEFAULT_MAPS, 284 KeyEvent.KEYCODE_M, META_ON}}; 285 } 286 287 @Keep longPressOnHomeTestArguments()288 private static Object[][] longPressOnHomeTestArguments() { 289 // testName, testKeys, longPressOnHomeBehavior, expectedKeyGestureType, expectedKey, 290 // expectedModifierState 291 return new Object[][]{ 292 {"Long press HOME key -> Toggle Notification panel", 293 new int[]{KeyEvent.KEYCODE_HOME}, LONG_PRESS_HOME_NOTIFICATION_PANEL, 294 KeyGestureEvent.KEY_GESTURE_TYPE_TOGGLE_NOTIFICATION_PANEL, 295 KeyEvent.KEYCODE_HOME, 0}, 296 {"Long press HOME key -> Launch assistant", 297 new int[]{KeyEvent.KEYCODE_HOME}, LONG_PRESS_HOME_ASSIST, 298 KeyGestureEvent.KEY_GESTURE_TYPE_LAUNCH_ASSISTANT, 299 KeyEvent.KEYCODE_HOME, 0}, 300 {"Long press HOME key -> Open App Drawer", 301 new int[]{KeyEvent.KEYCODE_HOME}, LONG_PRESS_HOME_ALL_APPS, 302 KeyGestureEvent.KEY_GESTURE_TYPE_ALL_APPS, 303 KeyEvent.KEYCODE_HOME, 0}}; 304 } 305 306 @Before setUp()307 public void setUp() { 308 setUpPhoneWindowManager(/*supportSettingsUpdate*/ true); 309 mPhoneWindowManager.overrideLaunchHome(); 310 mPhoneWindowManager.overrideSearchKeyBehavior( 311 PhoneWindowManager.SEARCH_KEY_BEHAVIOR_TARGET_ACTIVITY); 312 mPhoneWindowManager.overrideEnableBugReportTrigger(true); 313 mPhoneWindowManager.overrideStatusBarManagerInternal(); 314 mPhoneWindowManager.overrideStartActivity(); 315 mPhoneWindowManager.overrideSendBroadcast(); 316 mPhoneWindowManager.overrideUserSetupComplete(); 317 mPhoneWindowManager.setupAssistForLaunch(); 318 mPhoneWindowManager.overrideTogglePanel(); 319 mPhoneWindowManager.overrideInjectKeyEvent(); 320 mPhoneWindowManager.overrideRoleManager(); 321 } 322 323 @Test 324 @Parameters(method = "shortcutTestArgumentsNotMigratedToKeyGestureController") testShortcuts_notMigratedToKeyGestureController(String testName, int[] testKeys, @KeyGestureEvent.KeyGestureType int expectedKeyGestureType, int expectedKey, int expectedModifierState)325 public void testShortcuts_notMigratedToKeyGestureController(String testName, 326 int[] testKeys, @KeyGestureEvent.KeyGestureType int expectedKeyGestureType, 327 int expectedKey, int expectedModifierState) { 328 testShortcutInternal(testName, testKeys, expectedKeyGestureType, expectedKey, 329 expectedModifierState); 330 } 331 332 @Test 333 @Parameters(method = "shortcutTestArgumentsMigratedToKeyGestureController") 334 @DisableFlags(com.android.hardware.input.Flags.FLAG_USE_KEY_GESTURE_EVENT_HANDLER) testShortcuts_migratedToKeyGestureController(String testName, int[] testKeys, @KeyGestureEvent.KeyGestureType int expectedKeyGestureType, int expectedKey, int expectedModifierState)335 public void testShortcuts_migratedToKeyGestureController(String testName, int[] testKeys, 336 @KeyGestureEvent.KeyGestureType int expectedKeyGestureType, int expectedKey, 337 int expectedModifierState) { 338 testShortcutInternal(testName, testKeys, expectedKeyGestureType, expectedKey, 339 expectedModifierState); 340 } 341 342 @Test 343 @Parameters(method = "longPressOnHomeTestArguments") testLongPressOnHome(String testName, int[] testKeys, int longPressOnHomeBehavior, @KeyGestureEvent.KeyGestureType int expectedKeyGestureType, int expectedKey, int expectedModifierState)344 public void testLongPressOnHome(String testName, int[] testKeys, int longPressOnHomeBehavior, 345 @KeyGestureEvent.KeyGestureType int expectedKeyGestureType, int expectedKey, 346 int expectedModifierState) { 347 mPhoneWindowManager.overrideLongPressOnHomeBehavior(longPressOnHomeBehavior); 348 sendLongPressKeyCombination(testKeys); 349 mPhoneWindowManager.assertKeyGestureCompleted( 350 new int[]{expectedKey}, expectedModifierState, expectedKeyGestureType, 351 "Failed while executing " + testName); 352 } 353 354 @Test testDoubleTapOnHomeBehavior_AppSwitchBehavior()355 public void testDoubleTapOnHomeBehavior_AppSwitchBehavior() { 356 mPhoneWindowManager.overriderDoubleTapOnHomeBehavior(DOUBLE_TAP_HOME_RECENT_SYSTEM_UI); 357 sendKeyCombination(new int[]{KeyEvent.KEYCODE_HOME}, 0 /* duration */); 358 sendKeyCombination(new int[]{KeyEvent.KEYCODE_HOME}, 0 /* duration */); 359 mPhoneWindowManager.assertKeyGestureCompleted( 360 new int[]{KeyEvent.KEYCODE_HOME}, /* modifierState = */0, 361 KeyGestureEvent.KEY_GESTURE_TYPE_APP_SWITCH, 362 "Failed while executing Double tap HOME -> Open App switcher"); 363 } 364 365 @Test 366 @DisableFlags(com.android.hardware.input.Flags.FLAG_USE_KEY_GESTURE_EVENT_HANDLER) testSettingsKey_ToggleNotificationBehavior()367 public void testSettingsKey_ToggleNotificationBehavior() { 368 mPhoneWindowManager.overrideSettingsKeyBehavior(SETTINGS_KEY_BEHAVIOR_NOTIFICATION_PANEL); 369 testShortcutInternal("SETTINGS key -> Toggle Notification panel", 370 new int[]{KeyEvent.KEYCODE_SETTINGS}, 371 KeyGestureEvent.KEY_GESTURE_TYPE_TOGGLE_NOTIFICATION_PANEL, 372 KeyEvent.KEYCODE_SETTINGS, 0); 373 } 374 375 @Test 376 @EnableFlags(com.android.server.flags.Flags.FLAG_NEW_BUGREPORT_KEYBOARD_SHORTCUT) 377 @DisableFlags(com.android.hardware.input.Flags.FLAG_USE_KEY_GESTURE_EVENT_HANDLER) testBugreportShortcutPress()378 public void testBugreportShortcutPress() { 379 testShortcutInternal("Meta + Ctrl + Del -> Trigger bug report", 380 new int[]{META_KEY, CTRL_KEY, KeyEvent.KEYCODE_DEL}, 381 KeyGestureEvent.KEY_GESTURE_TYPE_TRIGGER_BUG_REPORT, KeyEvent.KEYCODE_DEL, 382 META_ON | CTRL_ON); 383 } 384 385 @Test 386 @EnableFlags(Flags.FLAG_ENABLE_TALKBACK_AND_MAGNIFIER_KEY_GESTURES) 387 @DisableFlags(com.android.hardware.input.Flags.FLAG_USE_KEY_GESTURE_EVENT_HANDLER) testToggleTalkbackPress()388 public void testToggleTalkbackPress() { 389 testShortcutInternal("Meta + Alt + T -> Toggle talkback", 390 new int[]{META_KEY, ALT_KEY, KeyEvent.KEYCODE_T}, 391 KeyGestureEvent.KEY_GESTURE_TYPE_TOGGLE_TALKBACK, 392 KeyEvent.KEYCODE_T, 393 META_ON | ALT_ON); 394 } 395 396 @Test 397 @EnableFlags({com.android.hardware.input.Flags.FLAG_KEYBOARD_A11Y_SHORTCUT_CONTROL, 398 com.android.hardware.input.Flags.FLAG_KEYBOARD_A11Y_MOUSE_KEYS}) 399 @DisableFlags(com.android.hardware.input.Flags.FLAG_USE_KEY_GESTURE_EVENT_HANDLER) testKeyboardAccessibilityToggleShortcutPress()400 public void testKeyboardAccessibilityToggleShortcutPress() { 401 testShortcutInternal("Meta + Alt + 3 -> Toggle Bounce Keys", 402 new int[]{META_KEY, ALT_KEY, KeyEvent.KEYCODE_3}, 403 KeyGestureEvent.KEY_GESTURE_TYPE_TOGGLE_BOUNCE_KEYS, 404 KeyEvent.KEYCODE_3, 405 META_ON | ALT_ON); 406 testShortcutInternal("Meta + Alt + 4 -> Toggle Mouse Keys", 407 new int[]{META_KEY, ALT_KEY, KeyEvent.KEYCODE_4}, 408 KeyGestureEvent.KEY_GESTURE_TYPE_TOGGLE_MOUSE_KEYS, 409 KeyEvent.KEYCODE_4, 410 META_ON | ALT_ON); 411 testShortcutInternal("Meta + Alt + 5 -> Toggle Sticky Keys", 412 new int[]{META_KEY, ALT_KEY, KeyEvent.KEYCODE_5}, 413 KeyGestureEvent.KEY_GESTURE_TYPE_TOGGLE_STICKY_KEYS, 414 KeyEvent.KEYCODE_5, 415 META_ON | ALT_ON); 416 testShortcutInternal("Meta + Alt + 6 -> Toggle Slow Keys", 417 new int[]{META_KEY, ALT_KEY, KeyEvent.KEYCODE_6}, 418 KeyGestureEvent.KEY_GESTURE_TYPE_TOGGLE_SLOW_KEYS, 419 KeyEvent.KEYCODE_6, 420 META_ON | ALT_ON); 421 } 422 testShortcutInternal(String testName, int[] testKeys, @KeyGestureEvent.KeyGestureType int expectedKeyGestureType, int expectedKey, int expectedModifierState)423 private void testShortcutInternal(String testName, int[] testKeys, 424 @KeyGestureEvent.KeyGestureType int expectedKeyGestureType, int expectedKey, 425 int expectedModifierState) { 426 sendKeyCombination(testKeys, 0 /* duration */); 427 mPhoneWindowManager.assertKeyGestureCompleted( 428 new int[]{expectedKey}, expectedModifierState, expectedKeyGestureType, 429 "Failed while executing " + testName); 430 } 431 432 @Test testKeyGestureRecentApps()433 public void testKeyGestureRecentApps() { 434 sendKeyGestureEventComplete(KeyGestureEvent.KEY_GESTURE_TYPE_RECENT_APPS); 435 mPhoneWindowManager.assertShowRecentApps(); 436 } 437 438 @Test testKeyGestureAppSwitch()439 public void testKeyGestureAppSwitch() { 440 sendKeyGestureEventComplete(KeyGestureEvent.KEY_GESTURE_TYPE_APP_SWITCH); 441 mPhoneWindowManager.assertToggleRecentApps(); 442 } 443 444 @Test testKeyGestureLaunchAssistant()445 public void testKeyGestureLaunchAssistant() { 446 sendKeyGestureEventComplete(KeyGestureEvent.KEY_GESTURE_TYPE_LAUNCH_ASSISTANT); 447 mPhoneWindowManager.assertSearchManagerLaunchAssist(); 448 } 449 450 @Test testKeyGestureLaunchVoiceAssistant()451 public void testKeyGestureLaunchVoiceAssistant() { 452 sendKeyGestureEventComplete(KeyGestureEvent.KEY_GESTURE_TYPE_LAUNCH_VOICE_ASSISTANT); 453 mPhoneWindowManager.assertSearchManagerLaunchAssist(); 454 } 455 456 @Test testKeyGestureGoHome()457 public void testKeyGestureGoHome() { 458 sendKeyGestureEventComplete(KeyGestureEvent.KEY_GESTURE_TYPE_HOME); 459 mPhoneWindowManager.assertGoToHomescreen(); 460 } 461 462 @Test testKeyGestureLaunchSystemSettings()463 public void testKeyGestureLaunchSystemSettings() { 464 sendKeyGestureEventComplete(KeyGestureEvent.KEY_GESTURE_TYPE_LAUNCH_SYSTEM_SETTINGS); 465 mPhoneWindowManager.assertLaunchSystemSettings(); 466 } 467 468 @Test testKeyGestureLock()469 public void testKeyGestureLock() { 470 sendKeyGestureEventComplete(KeyGestureEvent.KEY_GESTURE_TYPE_LOCK_SCREEN); 471 mPhoneWindowManager.assertLockedAfterAppTransitionFinished(); 472 } 473 474 @Test testKeyGestureToggleNotificationPanel()475 public void testKeyGestureToggleNotificationPanel() throws RemoteException { 476 sendKeyGestureEventComplete(KeyGestureEvent.KEY_GESTURE_TYPE_TOGGLE_NOTIFICATION_PANEL); 477 mPhoneWindowManager.assertTogglePanel(); 478 } 479 480 @Test testKeyGestureScreenshot()481 public void testKeyGestureScreenshot() { 482 sendKeyGestureEventComplete(KeyGestureEvent.KEY_GESTURE_TYPE_TAKE_SCREENSHOT); 483 mPhoneWindowManager.assertTakeScreenshotCalled(); 484 } 485 486 @Test testKeyGestureTriggerBugReport()487 public void testKeyGestureTriggerBugReport() throws RemoteException { 488 sendKeyGestureEventComplete(KeyGestureEvent.KEY_GESTURE_TYPE_TRIGGER_BUG_REPORT); 489 mPhoneWindowManager.assertTakeBugreport(true); 490 } 491 492 @Test testKeyGestureBack()493 public void testKeyGestureBack() { 494 mPhoneWindowManager.overrideDelegateBackGestureRemote(true); 495 sendKeyGestureEventComplete(KeyGestureEvent.KEY_GESTURE_TYPE_BACK); 496 mPhoneWindowManager.assertBackEventInjected(); 497 498 mPhoneWindowManager.overrideDelegateBackGestureRemote(false); 499 sendKeyGestureEventComplete(KeyGestureEvent.KEY_GESTURE_TYPE_BACK); 500 mPhoneWindowManager.assertBackEventInjected(); 501 } 502 503 @Test testKeyGestureMultiWindowNavigation()504 public void testKeyGestureMultiWindowNavigation() { 505 sendKeyGestureEventComplete(KeyGestureEvent.KEY_GESTURE_TYPE_MULTI_WINDOW_NAVIGATION); 506 mPhoneWindowManager.assertMoveFocusedTaskToFullscreen(); 507 } 508 509 @Test testKeyGestureDesktopMode()510 public void testKeyGestureDesktopMode() { 511 sendKeyGestureEventComplete(KeyGestureEvent.KEY_GESTURE_TYPE_DESKTOP_MODE); 512 mPhoneWindowManager.assertMoveFocusedTaskToDesktop(); 513 } 514 515 @Test testKeyGestureSplitscreenNavigation()516 public void testKeyGestureSplitscreenNavigation() { 517 sendKeyGestureEventComplete(KeyGestureEvent.KEY_GESTURE_TYPE_SPLIT_SCREEN_NAVIGATION_LEFT); 518 mPhoneWindowManager.assertMoveFocusedTaskToStageSplit(true); 519 520 sendKeyGestureEventComplete(KeyGestureEvent.KEY_GESTURE_TYPE_SPLIT_SCREEN_NAVIGATION_RIGHT); 521 mPhoneWindowManager.assertMoveFocusedTaskToStageSplit(false); 522 } 523 524 @Test testKeyGestureShortcutHelper()525 public void testKeyGestureShortcutHelper() { 526 sendKeyGestureEventComplete(KeyGestureEvent.KEY_GESTURE_TYPE_OPEN_SHORTCUT_HELPER); 527 mPhoneWindowManager.assertToggleShortcutsMenu(); 528 } 529 530 @Test testKeyGestureBrightnessChange()531 public void testKeyGestureBrightnessChange() { 532 float[] currentBrightness = new float[]{0.1f, 0.05f, 0.0f}; 533 float[] newBrightness = new float[]{0.065738f, 0.0275134f, 0.0f}; 534 535 for (int i = 0; i < currentBrightness.length; i++) { 536 mPhoneWindowManager.prepareBrightnessDecrease(currentBrightness[i]); 537 sendKeyGestureEventComplete(KeyGestureEvent.KEY_GESTURE_TYPE_BRIGHTNESS_DOWN); 538 mPhoneWindowManager.verifyNewBrightness(newBrightness[i]); 539 } 540 } 541 542 @Test testKeyGestureRecentAppSwitcher()543 public void testKeyGestureRecentAppSwitcher() { 544 sendKeyGestureEventStart(KeyGestureEvent.KEY_GESTURE_TYPE_RECENT_APPS_SWITCHER); 545 mPhoneWindowManager.assertShowRecentApps(); 546 sendKeyGestureEventComplete(KeyGestureEvent.KEY_GESTURE_TYPE_RECENT_APPS_SWITCHER); 547 mPhoneWindowManager.assertHideRecentApps(); 548 } 549 550 @Test testKeyGestureLanguageSwitch()551 public void testKeyGestureLanguageSwitch() { 552 sendKeyGestureEventComplete(KeyGestureEvent.KEY_GESTURE_TYPE_LANGUAGE_SWITCH); 553 mPhoneWindowManager.assertSwitchKeyboardLayout(1, DEFAULT_DISPLAY); 554 555 sendKeyGestureEventComplete(KeyGestureEvent.KEY_GESTURE_TYPE_LANGUAGE_SWITCH, 556 KeyEvent.META_SHIFT_ON); 557 mPhoneWindowManager.assertSwitchKeyboardLayout(-1, DEFAULT_DISPLAY); 558 } 559 560 @Test testKeyGestureLaunchSearch()561 public void testKeyGestureLaunchSearch() { 562 sendKeyGestureEventComplete(KeyGestureEvent.KEY_GESTURE_TYPE_LAUNCH_SEARCH); 563 mPhoneWindowManager.assertLaunchSearch(); 564 } 565 566 @Test testKeyGestureScreenshotChord()567 public void testKeyGestureScreenshotChord() { 568 sendKeyGestureEventStart(KeyGestureEvent.KEY_GESTURE_TYPE_SCREENSHOT_CHORD); 569 mPhoneWindowManager.moveTimeForward(500); 570 sendKeyGestureEventCancel(KeyGestureEvent.KEY_GESTURE_TYPE_SCREENSHOT_CHORD); 571 mPhoneWindowManager.assertTakeScreenshotCalled(); 572 } 573 574 @Test testKeyGestureScreenshotChordCancelled()575 public void testKeyGestureScreenshotChordCancelled() { 576 sendKeyGestureEventStart(KeyGestureEvent.KEY_GESTURE_TYPE_SCREENSHOT_CHORD); 577 sendKeyGestureEventCancel(KeyGestureEvent.KEY_GESTURE_TYPE_SCREENSHOT_CHORD); 578 mPhoneWindowManager.assertTakeScreenshotNotCalled(); 579 } 580 581 @Test testKeyGestureRingerToggleChord()582 public void testKeyGestureRingerToggleChord() { 583 mPhoneWindowManager.overridePowerVolumeUp(POWER_VOLUME_UP_BEHAVIOR_MUTE); 584 sendKeyGestureEventStart(KeyGestureEvent.KEY_GESTURE_TYPE_RINGER_TOGGLE_CHORD); 585 mPhoneWindowManager.moveTimeForward(500); 586 sendKeyGestureEventCancel(KeyGestureEvent.KEY_GESTURE_TYPE_RINGER_TOGGLE_CHORD); 587 mPhoneWindowManager.assertVolumeMute(); 588 } 589 590 @Test testKeyGestureRingerToggleChordCancelled()591 public void testKeyGestureRingerToggleChordCancelled() { 592 mPhoneWindowManager.overridePowerVolumeUp(POWER_VOLUME_UP_BEHAVIOR_MUTE); 593 sendKeyGestureEventStart(KeyGestureEvent.KEY_GESTURE_TYPE_RINGER_TOGGLE_CHORD); 594 sendKeyGestureEventCancel(KeyGestureEvent.KEY_GESTURE_TYPE_RINGER_TOGGLE_CHORD); 595 mPhoneWindowManager.assertVolumeNotMuted(); 596 } 597 598 @Test testKeyGestureGlobalAction()599 public void testKeyGestureGlobalAction() { 600 mPhoneWindowManager.overridePowerVolumeUp(POWER_VOLUME_UP_BEHAVIOR_GLOBAL_ACTIONS); 601 sendKeyGestureEventStart(KeyGestureEvent.KEY_GESTURE_TYPE_GLOBAL_ACTIONS); 602 mPhoneWindowManager.moveTimeForward(500); 603 sendKeyGestureEventCancel(KeyGestureEvent.KEY_GESTURE_TYPE_GLOBAL_ACTIONS); 604 mPhoneWindowManager.assertShowGlobalActionsCalled(); 605 } 606 607 @Test testKeyGestureGlobalActionCancelled()608 public void testKeyGestureGlobalActionCancelled() { 609 mPhoneWindowManager.overridePowerVolumeUp(POWER_VOLUME_UP_BEHAVIOR_GLOBAL_ACTIONS); 610 sendKeyGestureEventStart(KeyGestureEvent.KEY_GESTURE_TYPE_GLOBAL_ACTIONS); 611 sendKeyGestureEventCancel(KeyGestureEvent.KEY_GESTURE_TYPE_GLOBAL_ACTIONS); 612 mPhoneWindowManager.assertShowGlobalActionsNotCalled(); 613 } 614 615 @Test testKeyGestureTvTriggerBugReport()616 public void testKeyGestureTvTriggerBugReport() { 617 sendKeyGestureEventStart(KeyGestureEvent.KEY_GESTURE_TYPE_TV_TRIGGER_BUG_REPORT); 618 mPhoneWindowManager.moveTimeForward(1000); 619 sendKeyGestureEventCancel(KeyGestureEvent.KEY_GESTURE_TYPE_TV_TRIGGER_BUG_REPORT); 620 mPhoneWindowManager.assertBugReportTakenForTv(); 621 } 622 623 @Test testKeyGestureTvTriggerBugReportCancelled()624 public void testKeyGestureTvTriggerBugReportCancelled() { 625 sendKeyGestureEventStart(KeyGestureEvent.KEY_GESTURE_TYPE_TV_TRIGGER_BUG_REPORT); 626 sendKeyGestureEventCancel(KeyGestureEvent.KEY_GESTURE_TYPE_TV_TRIGGER_BUG_REPORT); 627 mPhoneWindowManager.assertBugReportNotTakenForTv(); 628 } 629 630 @Test testKeyGestureAccessibilityShortcut()631 public void testKeyGestureAccessibilityShortcut() { 632 sendKeyGestureEventComplete(KeyGestureEvent.KEY_GESTURE_TYPE_ACCESSIBILITY_SHORTCUT); 633 mPhoneWindowManager.assertAccessibilityKeychordCalled(); 634 } 635 636 @Test testKeyGestureCloseAllDialogs()637 public void testKeyGestureCloseAllDialogs() { 638 sendKeyGestureEventComplete(KeyGestureEvent.KEY_GESTURE_TYPE_CLOSE_ALL_DIALOGS); 639 mPhoneWindowManager.assertCloseAllDialogs(); 640 } 641 642 @Test 643 @EnableFlags(com.android.hardware.input.Flags.FLAG_ENABLE_TALKBACK_AND_MAGNIFIER_KEY_GESTURES) testKeyGestureToggleTalkback()644 public void testKeyGestureToggleTalkback() { 645 sendKeyGestureEventComplete(KeyGestureEvent.KEY_GESTURE_TYPE_TOGGLE_TALKBACK); 646 mPhoneWindowManager.assertTalkBack(true); 647 648 sendKeyGestureEventComplete(KeyGestureEvent.KEY_GESTURE_TYPE_TOGGLE_TALKBACK); 649 mPhoneWindowManager.assertTalkBack(false); 650 } 651 652 @Test 653 @EnableFlags(com.android.hardware.input.Flags.FLAG_ENABLE_VOICE_ACCESS_KEY_GESTURES) testKeyGestureToggleVoiceAccess()654 public void testKeyGestureToggleVoiceAccess() { 655 sendKeyGestureEventComplete(KeyGestureEvent.KEY_GESTURE_TYPE_TOGGLE_VOICE_ACCESS); 656 mPhoneWindowManager.assertVoiceAccess(true); 657 658 sendKeyGestureEventComplete(KeyGestureEvent.KEY_GESTURE_TYPE_TOGGLE_VOICE_ACCESS); 659 mPhoneWindowManager.assertVoiceAccess(false); 660 } 661 662 @Test testKeyGestureToggleDoNotDisturb()663 public void testKeyGestureToggleDoNotDisturb() { 664 mPhoneWindowManager.overrideZenMode(Settings.Global.ZEN_MODE_OFF); 665 sendKeyGestureEventComplete(KeyGestureEvent.KEY_GESTURE_TYPE_TOGGLE_DO_NOT_DISTURB); 666 mPhoneWindowManager.assertZenMode(Settings.Global.ZEN_MODE_IMPORTANT_INTERRUPTIONS); 667 668 mPhoneWindowManager.overrideZenMode(Settings.Global.ZEN_MODE_IMPORTANT_INTERRUPTIONS); 669 sendKeyGestureEventComplete(KeyGestureEvent.KEY_GESTURE_TYPE_TOGGLE_DO_NOT_DISTURB); 670 mPhoneWindowManager.assertZenMode(Settings.Global.ZEN_MODE_OFF); 671 } 672 673 @Test testLaunchSettingsAndSearchDoesntOpenAnything_withKeyguardOn()674 public void testLaunchSettingsAndSearchDoesntOpenAnything_withKeyguardOn() { 675 mPhoneWindowManager.overrideKeyguardOn(true); 676 677 sendKeyGestureEventComplete(KeyGestureEvent.KEY_GESTURE_TYPE_LAUNCH_SYSTEM_SETTINGS); 678 sendKeyGestureEventComplete(KeyGestureEvent.KEY_GESTURE_TYPE_LAUNCH_SEARCH); 679 680 mPhoneWindowManager.assertNoActivityLaunched(); 681 } 682 683 @Test testLaunchSettingsAndSearchDoesntOpenAnything_withUserSetupIncomplete()684 public void testLaunchSettingsAndSearchDoesntOpenAnything_withUserSetupIncomplete() { 685 mPhoneWindowManager.overrideIsUserSetupComplete(false); 686 687 sendKeyGestureEventComplete(KeyGestureEvent.KEY_GESTURE_TYPE_LAUNCH_SYSTEM_SETTINGS); 688 sendKeyGestureEventComplete(KeyGestureEvent.KEY_GESTURE_TYPE_LAUNCH_SEARCH); 689 690 mPhoneWindowManager.assertNoActivityLaunched(); 691 } 692 693 @Test testLaunchAssistantDoesntWork_withKeyguardOn()694 public void testLaunchAssistantDoesntWork_withKeyguardOn() { 695 mPhoneWindowManager.overrideKeyguardOn(true); 696 697 sendKeyGestureEventComplete(KeyGestureEvent.KEY_GESTURE_TYPE_LAUNCH_ASSISTANT); 698 sendKeyGestureEventComplete(KeyGestureEvent.KEY_GESTURE_TYPE_LAUNCH_VOICE_ASSISTANT); 699 700 mPhoneWindowManager.assertSearchManagerDoesntLaunchAssist(); 701 } 702 703 @Test testLaunchAssistantDoesntWork_withUserSetupIncomplete()704 public void testLaunchAssistantDoesntWork_withUserSetupIncomplete() { 705 mPhoneWindowManager.overrideIsUserSetupComplete(false); 706 707 sendKeyGestureEventComplete(KeyGestureEvent.KEY_GESTURE_TYPE_LAUNCH_ASSISTANT); 708 sendKeyGestureEventComplete(KeyGestureEvent.KEY_GESTURE_TYPE_LAUNCH_VOICE_ASSISTANT); 709 710 mPhoneWindowManager.assertSearchManagerDoesntLaunchAssist(); 711 } 712 } 713