android.view.KeyEvent

Here are the examples of the java api class android.view.KeyEvent taken from open source projects.

1. KeyComboPreferenceTest#testDpadKeys_shouldBeIgnored()

Project: talkback
File: KeyComboPreferenceTest.java
@Test
public void testDpadKeys_shouldBeIgnored() {
    TestableKeyComboPreference keyComboPreference = buildPreference(R.string.pref_key_mapped_to_click_key, R.string.action_name_click);
    KeyEvent dpadCenterEvent = new KeyEvent(KeyEvent.ACTION_DOWN, KeyEvent.KEYCODE_DPAD_CENTER);
    KeyEvent dpadDownEvent = new KeyEvent(KeyEvent.ACTION_DOWN, KeyEvent.KEYCODE_DPAD_DOWN);
    KeyEvent dpadUpEvent = new KeyEvent(KeyEvent.ACTION_DOWN, KeyEvent.KEYCODE_DPAD_UP);
    KeyEvent dpadRightEvent = new KeyEvent(KeyEvent.ACTION_DOWN, KeyEvent.KEYCODE_DPAD_RIGHT);
    KeyEvent dpadLeftEvent = new KeyEvent(KeyEvent.ACTION_DOWN, KeyEvent.KEYCODE_DPAD_LEFT);
    KeyEvent backEvent = new KeyEvent(KeyEvent.ACTION_DOWN, KeyEvent.KEYCODE_BACK);
    assertFalse(keyComboPreference.onKey((DialogInterface) null, dpadCenterEvent.getKeyCode(), dpadCenterEvent));
    assertFalse(keyComboPreference.onKey((DialogInterface) null, dpadDownEvent.getKeyCode(), dpadDownEvent));
    assertFalse(keyComboPreference.onKey((DialogInterface) null, dpadUpEvent.getKeyCode(), dpadUpEvent));
    assertFalse(keyComboPreference.onKey((DialogInterface) null, dpadRightEvent.getKeyCode(), dpadRightEvent));
    assertFalse(keyComboPreference.onKey((DialogInterface) null, dpadLeftEvent.getKeyCode(), dpadLeftEvent));
    assertFalse(keyComboPreference.onKey((DialogInterface) null, backEvent.getKeyCode(), backEvent));
}

2. KeyComboPreferenceTest#testListView_addsNewKeysWhenPressed()

Project: talkback
File: KeyComboPreferenceTest.java
@Test
public void testListView_addsNewKeysWhenPressed() {
    KeyEvent keyEventA = new KeyEvent(KeyEvent.ACTION_DOWN, KeyEvent.KEYCODE_A);
    KeyEvent keyEventB = new KeyEvent(KeyEvent.ACTION_DOWN, KeyEvent.KEYCODE_B);
    TestableKeyComboPreference keyComboPreference = buildPreference(R.string.pref_key_mapped_to_click_key, R.string.action_name_click, keyEventA, keyEventB);
    KeyEvent keyEventC = new KeyEvent(KeyEvent.ACTION_DOWN, KeyEvent.KEYCODE_C);
    keyComboPreference.onKey((DialogInterface) null, keyEventC.getKeyCode(), keyEventC);
    assertEquals(3, mKeysListView.getAdapter().getCount());
}

3. KeyComboPreferenceTest#testGetExtendedKeyCode_withMetaKeys()

Project: talkback
File: KeyComboPreferenceTest.java
@Test
public void testGetExtendedKeyCode_withMetaKeys() {
    /* Confirm that extra bits are set when meta keys are pressed */
    final int baseKeyCode = KeyEvent.KEYCODE_A;
    KeyEvent eventWithAlt = new KeyEvent(0, 0, KeyEvent.ACTION_DOWN, baseKeyCode, 0, KeyEvent.META_ALT_ON);
    KeyEvent eventWithSftAlt = new KeyEvent(0, 0, KeyEvent.ACTION_DOWN, baseKeyCode, 0, KeyEvent.META_ALT_ON | KeyEvent.META_SHIFT_ON);
    KeyEvent eventWithCtrlSftAlt = new KeyEvent(0, 0, KeyEvent.ACTION_DOWN, baseKeyCode, 0, KeyEvent.META_ALT_ON | KeyEvent.META_SHIFT_ON | KeyEvent.META_CTRL_ON);
    long keyCodeWithAlt = KeyComboPreference.keyEventToExtendedKeyCode(eventWithAlt);
    long keyCodeWithSftAlt = KeyComboPreference.keyEventToExtendedKeyCode(eventWithSftAlt);
    long keyCodeWithCtrlSftAlt = KeyComboPreference.keyEventToExtendedKeyCode(eventWithCtrlSftAlt);
    assertTrue(keyCodeWithAlt > baseKeyCode);
    assertTrue(keyCodeWithSftAlt > keyCodeWithAlt);
    assertTrue(keyCodeWithCtrlSftAlt > keyCodeWithSftAlt);
}

4. KeyComboPreferenceTest#testListView_removesExistingKeysWhenPressed()

Project: talkback
File: KeyComboPreferenceTest.java
@Test
public void testListView_removesExistingKeysWhenPressed() {
    KeyEvent keyEventA = new KeyEvent(KeyEvent.ACTION_DOWN, KeyEvent.KEYCODE_A);
    KeyEvent keyEventB = new KeyEvent(KeyEvent.ACTION_DOWN, KeyEvent.KEYCODE_B);
    TestableKeyComboPreference keyComboPreference = buildPreference(R.string.pref_key_mapped_to_click_key, R.string.action_name_click, keyEventA, keyEventB);
    keyComboPreference.onKey((DialogInterface) null, keyEventB.getKeyCode(), keyEventB);
    assertEquals(1, mKeysListView.getAdapter().getCount());
}

5. KeyComboPreferenceTest#testKeysConfiguredInDialog_savedInPreference()

Project: talkback
File: KeyComboPreferenceTest.java
@Test
public void testKeysConfiguredInDialog_savedInPreference() {
    TestableKeyComboPreference keyComboPreference = buildPreference(R.string.pref_key_mapped_to_click_key, R.string.action_name_click);
    KeyEvent keyEventA = new KeyEvent(KeyEvent.ACTION_DOWN, KeyEvent.KEYCODE_A);
    KeyEvent keyEventB = new KeyEvent(KeyEvent.ACTION_DOWN, KeyEvent.KEYCODE_B);
    Long keyCodeA = KeyComboPreference.keyEventToExtendedKeyCode(keyEventA);
    Long keyCodeB = KeyComboPreference.keyEventToExtendedKeyCode(keyEventB);
    keyComboPreference.onKey((DialogInterface) null, keyCodeA.intValue(), keyEventA);
    keyComboPreference.onKey((DialogInterface) null, keyCodeB.intValue(), keyEventB);
    keyComboPreference.callOnDialogClosed(true);
    Set<Long> keyCodesForPreference = KeyComboPreference.getKeyCodesForPreference(mContext, R.string.pref_key_mapped_to_click_key);
    assertEquals(2, keyCodesForPreference.size());
    assertTrue(keyCodesForPreference.contains(keyCodeA));
    assertTrue(keyCodesForPreference.contains(keyCodeB));
}

6. KeyComboPreferenceTest#testPreferenceReset_clearsPreferences()

Project: talkback
File: KeyComboPreferenceTest.java
@Test
public void testPreferenceReset_clearsPreferences() {
    KeyEvent keyEventA = new KeyEvent(KeyEvent.ACTION_DOWN, KeyEvent.KEYCODE_A);
    KeyEvent keyEventB = new KeyEvent(KeyEvent.ACTION_DOWN, KeyEvent.KEYCODE_B);
    TestableKeyComboPreference keyComboPreference = buildPreference(R.string.pref_key_mapped_to_click_key, R.string.action_name_click, keyEventA, keyEventB);
    mResetButton.performClick();
    keyComboPreference.callOnDialogClosed(true);
    Set<Long> keyCodesForPreference = KeyComboPreference.getKeyCodesForPreference(mContext, R.string.pref_key_mapped_to_click_key);
    assertEquals(0, keyCodesForPreference.size());
}

7. KeyComboPreferenceTest#testMultipleKeysConfigured_showsNumberOfKeysInSummary()

Project: talkback
File: KeyComboPreferenceTest.java
@Test
public void testMultipleKeysConfigured_showsNumberOfKeysInSummary() {
    KeyEvent keyEventZ = new KeyEvent(KeyEvent.ACTION_DOWN, KeyEvent.KEYCODE_Z);
    KeyEvent keyEventY = new KeyEvent(KeyEvent.ACTION_DOWN, KeyEvent.KEYCODE_Y);
    TestableKeyComboPreference keyComboPreference = buildPreference(R.string.pref_key_mapped_to_click_key, R.string.action_name_click, keyEventZ, keyEventY);
    String summary = (String) keyComboPreference.getSummary();
    assertFalse(summary.contains("Z"));
    assertFalse(summary.contains("Y"));
    assertTrue(summary.contains("2"));
}

8. TextFormattersTest#sendVolumeKey()

Project: talkback
File: TextFormattersTest.java
/**
     * Volume button simulation needs to be handled separately from key event simulation because the
     * normal Android system instrumentation will just change the system volume instead of
     * delivering the volume key events to TalkBack.
     */
private void sendVolumeKey(int keyCode) {
    assertTrue(keyCode == KeyEvent.KEYCODE_VOLUME_UP || keyCode == KeyEvent.KEYCODE_VOLUME_DOWN);
    long down = SystemClock.uptimeMillis();
    KeyEvent keyDown = new KeyEvent(down, down, KeyEvent.ACTION_DOWN, keyCode, 0, 0);
    mTalkBack.onKeyEventShared(keyDown);
    long up = SystemClock.uptimeMillis();
    KeyEvent keyUp = new KeyEvent(down, up, KeyEvent.ACTION_UP, keyCode, 0, 0);
    mTalkBack.onKeyEventShared(keyUp);
}

9. BackButtonMultiPageTest#testViaBackButtonOnLayout()

Project: cordova-android-chromeview
File: BackButtonMultiPageTest.java
public void testViaBackButtonOnLayout() {
    testView.loadUrl("file:///android_asset/www/backbuttonmultipage/sample2.html");
    sleep();
    String url = testView.getUrl();
    assertTrue(url.endsWith("sample2.html"));
    testView.loadUrl("file:///android_asset/www/backbuttonmultipage/sample3.html");
    sleep();
    url = testView.getUrl();
    assertTrue(url.endsWith("sample3.html"));
    BaseInputConnection viewConnection = new BaseInputConnection(containerView, true);
    KeyEvent backDown = new KeyEvent(KeyEvent.ACTION_DOWN, KeyEvent.KEYCODE_BACK);
    KeyEvent backUp = new KeyEvent(KeyEvent.ACTION_UP, KeyEvent.KEYCODE_BACK);
    viewConnection.sendKeyEvent(backDown);
    viewConnection.sendKeyEvent(backUp);
    sleep();
    url = testView.getUrl();
    assertTrue(url.endsWith("sample2.html"));
    viewConnection.sendKeyEvent(backDown);
    viewConnection.sendKeyEvent(backUp);
    sleep();
    url = testView.getUrl();
    assertTrue(url.endsWith("index.html"));
}

10. BackButtonMultiPageTest#testViaBackButtonOnView()

Project: cordova-android-chromeview
File: BackButtonMultiPageTest.java
public void testViaBackButtonOnView() {
    testView.loadUrl("file:///android_asset/www/backbuttonmultipage/sample2.html");
    sleep();
    String url = testView.getUrl();
    assertTrue(url.endsWith("sample2.html"));
    testView.loadUrl("file:///android_asset/www/backbuttonmultipage/sample3.html");
    sleep();
    url = testView.getUrl();
    assertTrue(url.endsWith("sample3.html"));
    BaseInputConnection viewConnection = new BaseInputConnection(testView, true);
    KeyEvent backDown = new KeyEvent(KeyEvent.ACTION_DOWN, KeyEvent.KEYCODE_BACK);
    KeyEvent backUp = new KeyEvent(KeyEvent.ACTION_UP, KeyEvent.KEYCODE_BACK);
    viewConnection.sendKeyEvent(backDown);
    viewConnection.sendKeyEvent(backUp);
    sleep();
    url = testView.getUrl();
    assertTrue(url.endsWith("sample2.html"));
    viewConnection.sendKeyEvent(backDown);
    viewConnection.sendKeyEvent(backUp);
    sleep();
    url = testView.getUrl();
    assertTrue(url.endsWith("index.html"));
}

11. PreferenceActivityTest#whenAutoScanDisabledButKeyMapped_keyPrefShown()

Project: talkback
File: PreferenceActivityTest.java
@Test
public void whenAutoScanDisabledButKeyMapped_keyPrefShown() {
    setAutoScanEnabled(false);
    KeyEvent keyEvent = new KeyEvent(KeyEvent.ACTION_DOWN, KeyEvent.KEYCODE_A);
    long keyCode = KeyComboPreference.keyEventToExtendedKeyCode(keyEvent);
    Set<String> stringSet = new HashSet<>(Arrays.asList((new Long(keyCode)).toString()));
    mSharedPreferences.edit().putStringSet(mContext.getString(R.string.pref_key_mapped_to_auto_scan_key), stringSet).apply();
    mSharedPreferences.edit().putStringSet(mContext.getString(R.string.pref_key_mapped_to_reverse_auto_scan_key), stringSet).apply();
    SwitchAccessPreferenceActivity activity = getPrefActivity();
    assertTrue(preferencePresent(activity, R.string.pref_key_mapped_to_auto_scan_key));
    assertTrue(preferencePresent(activity, R.string.pref_key_mapped_to_reverse_auto_scan_key));
}

12. PreferenceActivityTest#optionScanningDisabledButKeysMappedToOption3_showPreference()

Project: talkback
File: PreferenceActivityTest.java
@Test
public void optionScanningDisabledButKeysMappedToOption3_showPreference() {
    setStringPreference(R.string.pref_scanning_methods_key, mContext.getString(R.string.views_linear_ime_row_col_key));
    KeyEvent keyEvent = new KeyEvent(KeyEvent.ACTION_DOWN, KeyEvent.KEYCODE_A);
    long keyCode = KeyComboPreference.keyEventToExtendedKeyCode(keyEvent);
    Set<String> stringSet = new HashSet<>(Arrays.asList((new Long(keyCode)).toString()));
    mSharedPreferences.edit().putStringSet(mContext.getString(R.string.pref_key_mapped_to_switch_3_key), stringSet).apply();
    SwitchAccessPreferenceActivity activity = getPrefActivity();
    assertTrue(preferencePresent(activity, R.string.pref_key_mapped_to_switch_3_key));
}

13. PreferenceActivityTest#whenOptionScanningEnabledAndTwoKeysConfigured_showThreeOptionScanKeyPrefs()

Project: talkback
File: PreferenceActivityTest.java
@Test
public void whenOptionScanningEnabledAndTwoKeysConfigured_showThreeOptionScanKeyPrefs() {
    setStringPreference(R.string.pref_scanning_methods_key, mContext.getString(R.string.option_scanning_key));
    SwitchAccessPreferenceActivity activity = getPrefActivity();
    KeyEvent keyEvent = new KeyEvent(KeyEvent.ACTION_DOWN, KeyEvent.KEYCODE_A);
    long keyCode = KeyComboPreference.keyEventToExtendedKeyCode(keyEvent);
    Set<String> stringSet = new HashSet<>(Arrays.asList((new Long(keyCode)).toString()));
    mSharedPreferences.edit().putStringSet(mContext.getString(R.string.pref_key_mapped_to_click_key), stringSet).putStringSet(mContext.getString(R.string.pref_key_mapped_to_next_key), stringSet).apply();
    notifyPreferenceChanged(activity, R.string.pref_key_mapped_to_next_key);
    assertTrue(preferencePresent(activity, R.string.pref_key_mapped_to_click_key));
    assertTrue(preferencePresent(activity, R.string.pref_key_mapped_to_next_key));
    assertTrue(preferencePresent(activity, R.string.pref_key_mapped_to_switch_3_key));
    assertFalse(preferencePresent(activity, R.string.pref_key_mapped_to_switch_4_key));
    assertFalse(preferencePresent(activity, R.string.pref_key_mapped_to_switch_5_key));
}

14. KeyComboPreferenceTest#buildPreference()

Project: talkback
File: KeyComboPreferenceTest.java
private TestableKeyComboPreference buildPreference(int prefKeyId, int prefTitleId, KeyEvent... keyEvents) {
    String prefKey = mContext.getString(prefKeyId);
    Set<String> stringSet = new HashSet<>();
    for (KeyEvent keyEvent : keyEvents) {
        long keyCode = KeyComboPreference.keyEventToExtendedKeyCode(keyEvent);
        stringSet.add((new Long(keyCode)).toString());
    }
    mSharedPrefs.edit().putStringSet(prefKey, stringSet).apply();
    // Sanity check
    Set<Long> keyCodesForPreference = KeyComboPreference.getKeyCodesForPreference(mContext, prefKeyId);
    assertEquals(keyEvents.length, keyCodesForPreference.size());
    TestableKeyComboPreference keyComboPreference = new TestableKeyComboPreference(mContext, null);
    keyComboPreference.setKey(prefKey);
    keyComboPreference.attachToHierarchy();
    keyComboPreference.onBindDialogViewPublic(mMockView);
    keyComboPreference.setTitle(mContext.getString(prefTitleId));
    return keyComboPreference;
}

15. KeyComboPreferenceTest#testKeysAssignedToOtherActions_shouldShowToast()

Project: talkback
File: KeyComboPreferenceTest.java
@Test
public void testKeysAssignedToOtherActions_shouldShowToast() {
    TestableKeyComboPreference keyComboPreference = buildPreference(R.string.pref_key_mapped_to_next_key, R.string.action_name_next);
    KeyEvent keyEventA = new KeyEvent(KeyEvent.ACTION_DOWN, KeyEvent.KEYCODE_A);
    TestableKeyComboPreference otherKeyComboPreference = buildPreference(R.string.pref_key_mapped_to_click_key, R.string.action_name_click, keyEventA);
    ShadowToast.reset();
    keyComboPreference.onKey((DialogInterface) null, keyEventA.getKeyCode(), keyEventA);
    assertEquals(1, ShadowToast.shownToastCount());
}

16. KeyComboPreferenceTest#testKeysAssignedToOtherActions_shouldNotBeAddedToPreference()

Project: talkback
File: KeyComboPreferenceTest.java
@Test
public void testKeysAssignedToOtherActions_shouldNotBeAddedToPreference() {
    TestableKeyComboPreference keyComboPreference = buildPreference(R.string.pref_key_mapped_to_next_key, R.string.action_name_next);
    KeyEvent keyEventA = new KeyEvent(KeyEvent.ACTION_DOWN, KeyEvent.KEYCODE_A);
    TestableKeyComboPreference otherKeyComboPreference = buildPreference(R.string.pref_key_mapped_to_click_key, R.string.action_name_click, keyEventA);
    keyComboPreference.onKey((DialogInterface) null, keyEventA.getKeyCode(), keyEventA);
    keyComboPreference.callOnDialogClosed(true);
    Set<Long> keyCodesForPreference = KeyComboPreference.getKeyCodesForPreference(mContext, R.string.pref_key_mapped_to_next_key);
    assertEquals(0, keyCodesForPreference.size());
}

17. KeyComboPreferenceTest#testKeysInPreference_canBeReAdded()

Project: talkback
File: KeyComboPreferenceTest.java
@Test
public void testKeysInPreference_canBeReAdded() {
    KeyEvent keyEventA = new KeyEvent(KeyEvent.ACTION_DOWN, KeyEvent.KEYCODE_A);
    TestableKeyComboPreference keyComboPreference = buildPreference(R.string.pref_key_mapped_to_click_key, R.string.action_name_click, keyEventA);
    keyComboPreference.onKey((DialogInterface) null, keyEventA.getKeyCode(), keyEventA);
    keyComboPreference.onKey((DialogInterface) null, keyEventA.getKeyCode(), keyEventA);
    keyComboPreference.callOnDialogClosed(true);
    Set<Long> keyCodesForPreference = KeyComboPreference.getKeyCodesForPreference(mContext, R.string.pref_key_mapped_to_click_key);
    assertEquals(1, keyCodesForPreference.size());
    assertTrue(keyCodesForPreference.contains(KeyComboPreference.keyEventToExtendedKeyCode(keyEventA)));
}

18. KeyComboPreferenceTest#testKeysInPreference_areRemoved()

Project: talkback
File: KeyComboPreferenceTest.java
@Test
public void testKeysInPreference_areRemoved() {
    KeyEvent keyEventA = new KeyEvent(KeyEvent.ACTION_DOWN, KeyEvent.KEYCODE_A);
    TestableKeyComboPreference keyComboPreference = buildPreference(R.string.pref_key_mapped_to_click_key, R.string.action_name_click, keyEventA);
    keyComboPreference.onKey((DialogInterface) null, keyEventA.getKeyCode(), keyEventA);
    keyComboPreference.callOnDialogClosed(true);
    Set<Long> keyCodesForPreference = KeyComboPreference.getKeyCodesForPreference(mContext, R.string.pref_key_mapped_to_click_key);
    assertEquals(0, keyCodesForPreference.size());
}

19. KeyComboPreferenceTest#testGetKeyCodesForPreference_withStringSetPreference()

Project: talkback
File: KeyComboPreferenceTest.java
@Test
public void testGetKeyCodesForPreference_withStringSetPreference() {
    KeyEvent keyEvent = new KeyEvent(KeyEvent.ACTION_DOWN, KeyEvent.KEYCODE_A);
    long keyCode = KeyComboPreference.keyEventToExtendedKeyCode(keyEvent);
    Set<String> stringSet = new HashSet<>(Arrays.asList((new Long(keyCode)).toString()));
    mSharedPrefs.edit().putStringSet(mContext.getString(R.string.pref_key_mapped_to_click_key), stringSet).apply();
    Set<Long> keyCodesForPreference = KeyComboPreference.getKeyCodesForPreference(mContext, R.string.pref_key_mapped_to_click_key);
    assertEquals(1, keyCodesForPreference.size());
    assertEquals(keyCode, (long) keyCodesForPreference.iterator().next());
}

20. RxSearchEditTextTest#keyboardDismisses()

Project: RxBinding
File: RxSearchEditTextTest.java
@Test
@UiThreadTest
public void keyboardDismisses() {
    RecordingObserver<Void> o = new RecordingObserver<>();
    Subscription subscription = RxSearchEditText.keyboardDismisses(view).subscribe(o);
    o.assertNoMoreEvents();
    KeyEvent event = new KeyEvent(KeyEvent.ACTION_DOWN, KeyEvent.KEYCODE_BACK);
    view.onKeyPreIme(KeyEvent.KEYCODE_BACK, event);
    assertThat(o.takeNext()).isNull();
    subscription.unsubscribe();
    view.onKeyPreIme(KeyEvent.KEYCODE_BACK, event);
    o.assertNoMoreEvents();
}

21. RxSearchBarTest#searchQueryChangeEventsKeyboardDismissed()

Project: RxBinding
File: RxSearchBarTest.java
@Test
@UiThreadTest
public void searchQueryChangeEventsKeyboardDismissed() {
    RecordingObserver<SearchBarSearchQueryEvent> o = new RecordingObserver<>();
    Subscription subscription = RxSearchBar.searchQueryChangeEvents(searchBar).subscribe(o);
    o.assertNoMoreEvents();
    KeyEvent keyEvent = new KeyEvent(KeyEvent.ACTION_DOWN, KeyEvent.KEYCODE_BACK);
    searchBar.setSearchQuery("q");
    searchEditText.onKeyPreIme(KeyEvent.KEYCODE_BACK, keyEvent);
    // Text change event:
    SearchBarSearchQueryEvent event = o.takeNext();
    assertThat(event.searchQuery()).isEqualTo("q");
    assertThat(event.kind()).isEqualTo(CHANGED);
    // Keyboard dismiss event:
    SearchBarSearchQueryEvent event1 = o.takeNext();
    assertThat(event1.searchQuery()).isEqualTo("q");
    assertThat(event1.kind()).isEqualTo(KEYBOARD_DISMISSED);
    subscription.unsubscribe();
    searchEditText.onKeyPreIme(KeyEvent.KEYCODE_BACK, keyEvent);
    o.assertNoMoreEvents();
}

22. TemplateDevice#dispatchKeyEvent()

Project: GearVRf
File: TemplateDevice.java
/**
     * Synthesize and forward a KeyEvent to the library.
     *
     * This call is made from the native layer.
     *
     * @param code   id of the button
     * @param action integer representing the action taken on the button
     */
public void dispatchKeyEvent(int code, int action) {
    int keyCode = 0;
    int keyAction = 0;
    if (code == BUTTON_1) {
        keyCode = KeyEvent.KEYCODE_BUTTON_1;
    } else if (code == BUTTON_2) {
        keyCode = KeyEvent.KEYCODE_BUTTON_2;
    }
    if (action == ACTION_DOWN) {
        keyAction = KeyEvent.ACTION_DOWN;
    } else if (action == ACTION_UP) {
        keyAction = KeyEvent.ACTION_UP;
    }
    KeyEvent keyEvent = new KeyEvent(keyAction, keyCode);
    setKeyEvent(keyEvent);
}

23. EventInjectorTest#testInjectKeyEventUpWithNoDown()

Project: double-espresso
File: EventInjectorTest.java
@LargeTest
public void testInjectKeyEventUpWithNoDown() throws Exception {
    sendActivity = getActivity();
    getInstrumentation().runOnMainSync(new Runnable() {

        @Override
        public void run() {
            View view = sendActivity.findViewById(R.id.send_data_edit_text);
            assertTrue(view.requestFocus());
            latch.countDown();
        }
    });
    assertTrue("Timed out!", latch.await(10, TimeUnit.SECONDS));
    KeyCharacterMap keyCharacterMap = UiControllerImpl.getKeyCharacterMap();
    KeyEvent[] events = keyCharacterMap.getEvents("a".toCharArray());
    assertTrue(injector.injectKeyEvent(events[1]));
}

24. ActivityDelegateTest#testSingleEvent()

Project: CompositeAndroid
File: ActivityDelegateTest.java
@Test
public void testSingleEvent() throws Exception {
    final ActivityPlugin a = spy(new ActivityPlugin());
    final CompositeActivity activity = mock(CompositeActivity.class);
    final ActivityDelegate delegate = new ActivityDelegate(activity);
    delegate.addPlugin(a);
    final KeyEvent event = new KeyEvent(KeyEvent.ACTION_DOWN, 1);
    delegate.onKeyDown(1, event);
    verify(a).onKeyDown(1, event);
    verify(activity).onKeyDown__super(1, event);
}

25. ActivityDelegateTest#testCallHook()

Project: CompositeAndroid
File: ActivityDelegateTest.java
@Test
public void testCallHook() throws Exception {
    final ActivityPlugin a = spy(new ActivityPlugin());
    final ActivityPlugin b = spy(new ActivityPlugin());
    final ActivityPlugin c = spy(new ActivityPlugin());
    final CompositeActivity activity = mock(CompositeActivity.class);
    final ActivityDelegate delegate = new ActivityDelegate(activity);
    delegate.addPlugin(a);
    delegate.addPlugin(b);
    delegate.addPlugin(c);
    final KeyEvent event = new KeyEvent(KeyEvent.ACTION_DOWN, 1);
    delegate.onKeyDown(1, event);
    verify(a).onKeyDown(1, event);
    verify(b).onKeyDown(1, event);
    verify(c).onKeyDown(1, event);
    verify(activity).onKeyDown__super(1, event);
}

26. CCKeyDispatcher#update()

Project: cocos2d
File: CCKeyDispatcher.java
public void update() {
    KeyEvent event;
    while ((event = eventQueue.poll()) != null) {
        switch(event.getAction()) {
            case KeyEvent.ACTION_DOWN:
                onKeyDown(event);
                break;
            case KeyEvent.ACTION_UP:
                onKeyUp(event);
                break;
        }
    }
}

27. ViewRecorderSDK#initKeyTable()

Project: Cafe
File: ViewRecorderSDK.java
private void initKeyTable() {
    KeyEvent keyEvent = new KeyEvent(0, 0);
    ArrayList<String> names = ReflectHelper.getFieldNameByType(keyEvent, null, int.class);
    try {
        for (String name : names) {
            if (name.startsWith("KEYCODE_")) {
                Integer keyCode = (Integer) ReflectHelper.getField(keyEvent, null, name);
                mKeyCodeMap.put(keyCode, name);
            }
        }
    } catch (SecurityException e) {
        e.printStackTrace();
    } catch (IllegalArgumentException e) {
        e.printStackTrace();
    } catch (NoSuchFieldException e) {
        e.printStackTrace();
    } catch (IllegalAccessException e) {
        e.printStackTrace();
    }
}

28. ViewRecorder#initKeyTable()

Project: Cafe
File: ViewRecorder.java
private void initKeyTable() {
    KeyEvent keyEvent = new KeyEvent(0, 0);
    ArrayList<String> names = local.getFieldNameByType(keyEvent, null, int.class);
    try {
        for (String name : names) {
            if (name.startsWith("KEYCODE_")) {
                Integer keyCode = (Integer) local.getField(keyEvent, null, name);
                mKeyCodeMap.put(keyCode, name);
            }
        }
    } catch (SecurityException e) {
        e.printStackTrace();
    } catch (IllegalArgumentException e) {
        e.printStackTrace();
    } catch (NoSuchFieldException e) {
        e.printStackTrace();
    } catch (IllegalAccessException e) {
        e.printStackTrace();
    }
}

29. MediaButtonReceiver#onReceive()

Project: AntennaPod
File: MediaButtonReceiver.java
@Override
public void onReceive(Context context, Intent intent) {
    Log.d(TAG, "Received intent");
    KeyEvent event = (KeyEvent) intent.getExtras().get(Intent.EXTRA_KEY_EVENT);
    if (event != null && event.getAction() == KeyEvent.ACTION_DOWN && event.getRepeatCount() == 0) {
        ClientConfig.initialize(context);
        Intent serviceIntent = new Intent(context, PlaybackService.class);
        serviceIntent.putExtra(EXTRA_KEYCODE, event.getKeyCode());
        serviceIntent.putExtra(EXTRA_SOURCE, event.getSource());
        context.startService(serviceIntent);
    }
}

30. RemoteControllerService#sendKeyEvent()

Project: tomahawk-android
File: RemoteControllerService.java
/**
     * Send a keyEvent with the given keyCode to the RemoteController
     *
     * @param keyCode the keyCode that should be send to the RemoteController
     * @return return true if both clicks (up and down) were delivered successfully
     */
private boolean sendKeyEvent(int keyCode) {
    //send "down" and "up" keyevents.
    KeyEvent keyEvent = new KeyEvent(KeyEvent.ACTION_DOWN, keyCode);
    boolean first = mRemoteController.sendMediaKeyEvent(keyEvent);
    keyEvent = new KeyEvent(KeyEvent.ACTION_UP, keyCode);
    boolean second = mRemoteController.sendMediaKeyEvent(keyEvent);
    return first && second;
}

31. KeyComboPreferenceTest#testListView_containsPreConfiguredKeys()

Project: talkback
File: KeyComboPreferenceTest.java
@Test
public void testListView_containsPreConfiguredKeys() {
    KeyEvent keyEventA = new KeyEvent(KeyEvent.ACTION_DOWN, KeyEvent.KEYCODE_A);
    KeyEvent keyEventB = new KeyEvent(KeyEvent.ACTION_DOWN, KeyEvent.KEYCODE_B);
    buildPreference(R.string.pref_key_mapped_to_click_key, R.string.action_name_click, keyEventA, keyEventB);
    assertEquals(2, mKeysListView.getAdapter().getCount());
}

32. KeyComboPreferenceTest#testKeysConfiguredInDialog_withLegacyConfigured_savedInPreference()

Project: talkback
File: KeyComboPreferenceTest.java
@Test
public void testKeysConfiguredInDialog_withLegacyConfigured_savedInPreference() {
    /* Configured legacy sharedpreference for 'A' */
    KeyEvent keyEventA = new KeyEvent(KeyEvent.ACTION_DOWN, KeyEvent.KEYCODE_A);
    Long keyCodeA = KeyComboPreference.keyEventToExtendedKeyCode(keyEventA);
    String prefKey = mContext.getString(R.string.pref_key_mapped_to_click_key);
    mSharedPrefs.edit().putLong(prefKey, keyCodeA).apply();
    /* Build the preference */
    TestableKeyComboPreference keyComboPreference = new TestableKeyComboPreference(mContext, null);
    keyComboPreference.setKey(prefKey);
    keyComboPreference.attachToHierarchy();
    keyComboPreference.onBindDialogViewPublic(mMockView);
    keyComboPreference.setTitle(R.string.action_name_click);
    /* Send a 'B' key to the preference to add to the legacy A */
    KeyEvent keyEventB = new KeyEvent(KeyEvent.ACTION_DOWN, KeyEvent.KEYCODE_B);
    Long keyCodeB = KeyComboPreference.keyEventToExtendedKeyCode(keyEventB);
    keyComboPreference.onKey((DialogInterface) null, keyCodeB.intValue(), keyEventB);
    keyComboPreference.callOnDialogClosed(true);
    /* Both A and B should be configured */
    Set<Long> keyCodesForPreference = KeyComboPreference.getKeyCodesForPreference(mContext, R.string.pref_key_mapped_to_click_key);
    assertEquals(2, keyCodesForPreference.size());
    assertTrue(keyCodesForPreference.contains(keyCodeA));
    assertTrue(keyCodesForPreference.contains(keyCodeB));
}

33. VolumeNavigationDelegateTest#testOnKeyUp()

Project: materialistic
File: VolumeNavigationDelegateTest.java
@Test
public void testOnKeyUp() {
    KeyEvent keyEvent = mock(KeyEvent.class);
    when(keyEvent.getFlags()).thenReturn(KeyEvent.FLAG_CANCELED_LONG_PRESS);
    assertFalse(delegate.onKeyUp(KeyEvent.KEYCODE_BACK, keyEvent));
    assertFalse(delegate.onKeyUp(KeyEvent.KEYCODE_VOLUME_UP, keyEvent));
    assertFalse(delegate.onKeyUp(KeyEvent.KEYCODE_VOLUME_DOWN, keyEvent));
    KeyEvent keyEventVolUp = new KeyEvent(KeyEvent.ACTION_UP, KeyEvent.KEYCODE_VOLUME_UP), keyEventVolDown = new KeyEvent(KeyEvent.ACTION_UP, KeyEvent.KEYCODE_VOLUME_DOWN);
    assertTrue(delegate.onKeyUp(KeyEvent.KEYCODE_VOLUME_UP, keyEventVolUp));
    verify(scrollable).scrollToPrevious();
    verify(appBar).setExpanded(eq(true), anyBoolean());
    reset(scrollable, appBar);
    when(scrollable.scrollToPrevious()).thenReturn(true);
    assertTrue(delegate.onKeyUp(KeyEvent.KEYCODE_VOLUME_UP, keyEventVolUp));
    verify(scrollable).scrollToPrevious();
    verify(appBar, never()).setExpanded(eq(true), anyBoolean());
    reset(scrollable, appBar);
    when(appBar.getHeight()).thenReturn(10);
    when(appBar.getBottom()).thenReturn(10);
    assertTrue(delegate.onKeyUp(KeyEvent.KEYCODE_VOLUME_DOWN, keyEventVolDown));
    verify(scrollable, never()).scrollToNext();
    verify(appBar).setExpanded(eq(false), anyBoolean());
    reset(scrollable, appBar);
    when(appBar.getHeight()).thenReturn(10);
    when(appBar.getBottom()).thenReturn(0);
    assertTrue(delegate.onKeyUp(KeyEvent.KEYCODE_VOLUME_DOWN, keyEventVolDown));
    verify(scrollable).scrollToNext();
    verify(appBar, never()).setExpanded(eq(false), anyBoolean());
}

34. EventInjectorTest#testInjectStaleKeyEvent()

Project: double-espresso
File: EventInjectorTest.java
@LargeTest
public void testInjectStaleKeyEvent() throws Exception {
    sendActivity = getActivity();
    getInstrumentation().runOnMainSync(new Runnable() {

        @Override
        public void run() {
            View view = sendActivity.findViewById(R.id.send_data_edit_text);
            assertTrue(view.requestFocus());
            latch.countDown();
        }
    });
    assertTrue("Timed out!", latch.await(10, TimeUnit.SECONDS));
    assertFalse("SecurityException exception was thrown.", injectEventThrewSecurityException.get());
    KeyCharacterMap keyCharacterMap = UiControllerImpl.getKeyCharacterMap();
    KeyEvent[] events = keyCharacterMap.getEvents("a".toCharArray());
    KeyEvent event = KeyEvent.changeTimeRepeat(events[0], 1, 0);
    // Stale event does not fail for API < 13.
    if (Build.VERSION.SDK_INT < 13) {
        assertTrue(injector.injectKeyEvent(event));
    } else {
        assertFalse(injector.injectKeyEvent(event));
    }
}

35. UiControllerImpl#injectString()

Project: double-espresso
File: UiControllerImpl.java
@Override
public boolean injectString(String str) throws InjectEventSecurityException {
    checkNotNull(str);
    checkState(Looper.myLooper() == mainLooper, "Expecting to be on main thread!");
    initialize();
    // No-op if string is empty.
    if (str.length() == 0) {
        Log.w(TAG, "Supplied string is empty resulting in no-op (nothing is typed).");
        return true;
    }
    boolean eventInjected = false;
    KeyCharacterMap keyCharacterMap = getKeyCharacterMap();
    // TODO(user): Investigate why not use (as suggested in javadoc of keyCharacterMap.getEvents):
    // http://developer.android.com/reference/android/view/KeyEvent.html#KeyEvent(long,
    // java.lang.String, int, int)
    KeyEvent[] events = keyCharacterMap.getEvents(str.toCharArray());
    checkNotNull(events, "Failed to get events for string " + str);
    Log.d(TAG, String.format("Injecting string: \"%s\"", str));
    for (KeyEvent event : events) {
        checkNotNull(event, String.format("Failed to get event for character (%c) with key code (%s)", event.getKeyCode(), event.getUnicodeChar()));
        eventInjected = false;
        for (int attempts = 0; !eventInjected && attempts < 4; attempts++) {
            attempts++;
            // We have to change the time of an event before injecting it because
            // all KeyEvents returned by KeyCharacterMap.getEvents() have the same
            // time stamp and the system rejects too old events. Hence, it is
            // possible for an event to become stale before it is injected if it
            // takes too long to inject the preceding ones.
            event = KeyEvent.changeTimeRepeat(event, SystemClock.uptimeMillis(), 0);
            eventInjected = injectKeyEvent(event);
        }
        if (!eventInjected) {
            Log.e(TAG, String.format("Failed to inject event for character (%c) with key code (%s)", event.getUnicodeChar(), event.getKeyCode()));
            break;
        }
    }
    return eventInjected;
}

36. MediaController2#broadcastMediaAction()

Project: AcDisplay
File: MediaController2.java
/**
     * Emulates hardware buttons' click via broadcast system.
     *
     * @see android.view.KeyEvent
     */
public static void broadcastMediaAction(@NonNull Context context, int action) {
    int keyCode;
    switch(action) {
        case ACTION_PLAY_PAUSE:
            keyCode = KeyEvent.KEYCODE_MEDIA_PLAY_PAUSE;
            break;
        case ACTION_STOP:
            keyCode = KeyEvent.KEYCODE_MEDIA_STOP;
            break;
        case ACTION_SKIP_TO_NEXT:
            keyCode = KeyEvent.KEYCODE_MEDIA_NEXT;
            break;
        case ACTION_SKIP_TO_PREVIOUS:
            keyCode = KeyEvent.KEYCODE_MEDIA_PREVIOUS;
            break;
        default:
            throw new IllegalArgumentException();
    }
    Intent intent = new Intent(Intent.ACTION_MEDIA_BUTTON);
    KeyEvent keyDown = new KeyEvent(KeyEvent.ACTION_DOWN, keyCode);
    KeyEvent keyUp = new KeyEvent(KeyEvent.ACTION_UP, keyCode);
    context.sendOrderedBroadcast(intent.putExtra(Intent.EXTRA_KEY_EVENT, keyDown), null);
    context.sendOrderedBroadcast(intent.putExtra(Intent.EXTRA_KEY_EVENT, keyUp), null);
}

37. EnterLayout#deleteOneChar()

Project: YouJoin-Android
File: EnterLayout.java
public void deleteOneChar() {
    KeyEvent event = new KeyEvent(0, 0, 0, KeyEvent.KEYCODE_DEL, 0, 0, 0, 0, KeyEvent.KEYCODE_ENDCALL);
    content.dispatchKeyEvent(event);
}

38. KeyComboPreferenceTest#testOneKeyConfigured_showsKeyInSummary()

Project: talkback
File: KeyComboPreferenceTest.java
@Test
public void testOneKeyConfigured_showsKeyInSummary() {
    KeyEvent keyEventZ = new KeyEvent(KeyEvent.ACTION_DOWN, KeyEvent.KEYCODE_Z);
    TestableKeyComboPreference keyComboPreference = buildPreference(R.string.pref_key_mapped_to_click_key, R.string.action_name_click, keyEventZ);
    String summary = (String) keyComboPreference.getSummary();
    assertTrue(summary.contains("Z"));
}

39. KeyComboPreferenceTest#testGetKeyCodesForPreference_withLegacyLongPreference()

Project: talkback
File: KeyComboPreferenceTest.java
@Test
public void testGetKeyCodesForPreference_withLegacyLongPreference() {
    KeyEvent keyEvent = new KeyEvent(KeyEvent.ACTION_DOWN, KeyEvent.KEYCODE_A);
    long keyCode = KeyComboPreference.keyEventToExtendedKeyCode(keyEvent);
    mSharedPrefs.edit().putLong(mContext.getString(R.string.pref_key_mapped_to_click_key), keyCode).apply();
    Set<Long> keyCodesForPreference = KeyComboPreference.getKeyCodesForPreference(mContext, R.string.pref_key_mapped_to_click_key);
    long firstKeycode = keyCodesForPreference.iterator().next();
    assertEquals(keyCode, firstKeycode);
}

40. KeyComboPreferenceTest#testGetExtendedKeyCode_basic()

Project: talkback
File: KeyComboPreferenceTest.java
@Test
public void testGetExtendedKeyCode_basic() {
    KeyEvent event = new KeyEvent(0, 0, KeyEvent.ACTION_DOWN, KeyEvent.KEYCODE_A, 0, 0);
    long keyCode = KeyComboPreference.keyEventToExtendedKeyCode(event);
    assertEquals(event.getKeyCode(), (int) keyCode);
}

41. KeyboardEventManagerTest#testAutoScanKeyUp_returnsTrueWithoutDoingAnything()

Project: talkback
File: KeyboardEventManagerTest.java
@Test
public void testAutoScanKeyUp_returnsTrueWithoutDoingAnything() {
    KeyEvent autoScanKeyEvent = new KeyEvent(KeyEvent.ACTION_UP, KeyEvent.KEYCODE_C);
    setupPreferenceForAction(autoScanKeyEvent, R.string.pref_key_mapped_to_auto_scan_key);
    setupBooleanPreference(true, R.string.pref_key_auto_scan_enabled);
    assertTrue(mKeyboardEventManager.onKeyEvent(autoScanKeyEvent, mRunAction, null));
    verifyZeroInteractions(mMockOptionManger, mMockAutoScanController);
}

42. KeyboardEventManagerTest#testAutoScanKeyEnable_activatesAutoScan()

Project: talkback
File: KeyboardEventManagerTest.java
@Test
public void testAutoScanKeyEnable_activatesAutoScan() {
    KeyEvent autoScanKeyEvent = new KeyEvent(KeyEvent.ACTION_DOWN, KeyEvent.KEYCODE_C);
    setupPreferenceForAction(autoScanKeyEvent, R.string.pref_key_mapped_to_auto_scan_key);
    setupBooleanPreference(true, R.string.pref_key_auto_scan_enabled);
    assertTrue(mKeyboardEventManager.onKeyEvent(autoScanKeyEvent, mRunAction, null));
    verify(mMockAutoScanController, times(1)).autoScanActivated(false);
    verifyNoMoreInteractions(mMockOptionManger, mMockAutoScanController);
}

43. KeyboardEventManagerTest#testAutoScanKeyNoEnable_doesNotActivateAutoScan()

Project: talkback
File: KeyboardEventManagerTest.java
@Test
public void testAutoScanKeyNoEnable_doesNotActivateAutoScan() {
    KeyEvent autoScanKeyEvent = new KeyEvent(KeyEvent.ACTION_DOWN, KeyEvent.KEYCODE_C);
    setupPreferenceForAction(autoScanKeyEvent, R.string.pref_key_mapped_to_auto_scan_key);
    setupBooleanPreference(false, R.string.pref_key_auto_scan_enabled);
    assertFalse(mKeyboardEventManager.onKeyEvent(autoScanKeyEvent, mRunAction, null));
    verify(mMockAutoScanController, times(0)).autoScanActivated(false);
    verifyNoMoreInteractions(mMockOptionManger, mMockAutoScanController);
}

44. KeyboardEventManagerTest#testPreviousKey_selectsParent()

Project: talkback
File: KeyboardEventManagerTest.java
@Test
public void testPreviousKey_selectsParent() {
    KeyEvent previousKeyEvent = new KeyEvent(KeyEvent.ACTION_DOWN, KeyEvent.KEYCODE_D);
    setupPreferenceForAction(previousKeyEvent, R.string.pref_key_mapped_to_previous_key);
    assertTrue(mKeyboardEventManager.onKeyEvent(previousKeyEvent, mRunAction, null));
    verify(mMockOptionManger, times(1)).moveToParent(true);
    verifyNoMoreInteractions(mMockOptionManger, mMockAutoScanController);
}

45. KeyboardEventManagerTest#testClickKey_shouldNotifyListener()

Project: talkback
File: KeyboardEventManagerTest.java
@Test
public void testClickKey_shouldNotifyListener() {
    KeyboardAction.KeyboardActionListener mockListener = mock(KeyboardAction.KeyboardActionListener.class);
    KeyEvent clickKeyEvent = new KeyEvent(KeyEvent.ACTION_DOWN, KeyEvent.KEYCODE_B);
    setupPreferenceForAction(clickKeyEvent, R.string.pref_key_mapped_to_click_key);
    assertTrue(mKeyboardEventManager.onKeyEvent(clickKeyEvent, mRunAction, mockListener));
    verify(mockListener, times(1)).onKeyboardAction(R.string.pref_key_mapped_to_click_key);
}

46. KeyboardEventManagerTest#testOptionScanKey5_selectsOption4()

Project: talkback
File: KeyboardEventManagerTest.java
@Test
public void testOptionScanKey5_selectsOption4() {
    KeyEvent clickKeyEvent = new KeyEvent(KeyEvent.ACTION_DOWN, KeyEvent.KEYCODE_B);
    setupPreferenceForAction(clickKeyEvent, R.string.pref_key_mapped_to_switch_5_key);
    assertTrue(mKeyboardEventManager.onKeyEvent(clickKeyEvent, mRunAction, null));
    verify(mMockOptionManger, times(1)).selectOption(4);
    verifyNoMoreInteractions(mMockOptionManger, mMockAutoScanController);
}

47. KeyboardEventManagerTest#testOptionScanKey4_selectsOption3()

Project: talkback
File: KeyboardEventManagerTest.java
@Test
public void testOptionScanKey4_selectsOption3() {
    KeyEvent clickKeyEvent = new KeyEvent(KeyEvent.ACTION_DOWN, KeyEvent.KEYCODE_B);
    setupPreferenceForAction(clickKeyEvent, R.string.pref_key_mapped_to_switch_4_key);
    assertTrue(mKeyboardEventManager.onKeyEvent(clickKeyEvent, mRunAction, null));
    verify(mMockOptionManger, times(1)).selectOption(3);
    verifyNoMoreInteractions(mMockOptionManger, mMockAutoScanController);
}

48. KeyboardEventManagerTest#testOptionScanKey3_selectsOption2()

Project: talkback
File: KeyboardEventManagerTest.java
@Test
public void testOptionScanKey3_selectsOption2() {
    KeyEvent clickKeyEvent = new KeyEvent(KeyEvent.ACTION_DOWN, KeyEvent.KEYCODE_B);
    setupPreferenceForAction(clickKeyEvent, R.string.pref_key_mapped_to_switch_3_key);
    assertTrue(mKeyboardEventManager.onKeyEvent(clickKeyEvent, mRunAction, null));
    verify(mMockOptionManger, times(1)).selectOption(2);
    verifyNoMoreInteractions(mMockOptionManger, mMockAutoScanController);
}

49. KeyboardEventManagerTest#testClickKey_selectsOption0()

Project: talkback
File: KeyboardEventManagerTest.java
@Test
public void testClickKey_selectsOption0() {
    KeyEvent clickKeyEvent = new KeyEvent(KeyEvent.ACTION_DOWN, KeyEvent.KEYCODE_B);
    setupPreferenceForAction(clickKeyEvent, R.string.pref_key_mapped_to_click_key);
    assertTrue(mKeyboardEventManager.onKeyEvent(clickKeyEvent, mRunAction, null));
    verify(mMockOptionManger, times(1)).selectOption(0);
    verifyNoMoreInteractions(mMockOptionManger, mMockAutoScanController);
}

50. KeyboardEventManagerTest#testNextKey_selectsOption1()

Project: talkback
File: KeyboardEventManagerTest.java
@Test
public void testNextKey_selectsOption1() {
    KeyEvent nextKeyEvent = new KeyEvent(KeyEvent.ACTION_DOWN, KeyEvent.KEYCODE_A);
    setupPreferenceForAction(nextKeyEvent, R.string.pref_key_mapped_to_next_key);
    assertTrue(mKeyboardEventManager.onKeyEvent(nextKeyEvent, mRunAction, null));
    verify(mMockOptionManger, times(1)).selectOption(1);
    verifyNoMoreInteractions(mMockOptionManger, mMockAutoScanController);
}

51. KeyboardEventManagerTest#testBackKey_performGlobalActionCalledOnService()

Project: talkback
File: KeyboardEventManagerTest.java
@Test
public void testBackKey_performGlobalActionCalledOnService() {
    KeyEvent backKeyEvent = new KeyEvent(KeyEvent.ACTION_DOWN, KeyEvent.KEYCODE_0);
    setupPreferenceForAction(backKeyEvent, R.string.pref_key_mapped_to_back_key);
    assertTrue(mKeyboardEventManager.onKeyEvent(backKeyEvent, mRunAction, null));
    List<Integer> globalActionList = mShadowService.getGlobalActionsPerformed();
    assertEquals(1, globalActionList.size());
    assertEquals((long) AccessibilityService.GLOBAL_ACTION_BACK, (long) globalActionList.get(0));
}

52. KeyboardEventManagerTest#testUnassignedKey_notHandled()

Project: talkback
File: KeyboardEventManagerTest.java
@Test
public void testUnassignedKey_notHandled() {
    KeyEvent unassignedKeyEvent = new KeyEvent(KeyEvent.ACTION_DOWN, KeyEvent.KEYCODE_ENTER);
    mSharedPreferences.edit().clear().commit();
    assertFalse(mKeyboardEventManager.onKeyEvent(unassignedKeyEvent, mRunAction, null));
    List<Integer> globalActionList = mShadowService.getGlobalActionsPerformed();
    assertEquals(0, globalActionList.size());
}

53. KeyComboPreference#describeExtendedKeyCode()

Project: talkback
File: KeyComboPreference.java
/**
     * Create a string that describes the extended key code. This string can be
     * shown to the user to indicate the current choice of key.
     *
     * @param extendedKeyCode The key code to describe
     * @return A description of the key code
     */
private String describeExtendedKeyCode(long extendedKeyCode) {
    if (extendedKeyCode == INVALID_EXTENDED_KEY_CODE) {
        return getContext().getString(R.string.no_key_assigned);
    }
    /* If meta keys are pressed, build a string to represent this combination of keys */
    StringBuilder keystrokeDescriptionBuilder = new StringBuilder();
    if ((extendedKeyCode & (((long) KeyEvent.META_CTRL_ON) << 32)) != 0) {
        keystrokeDescriptionBuilder.append(getContext().getString(R.string.key_combo_preference_control_plus));
    }
    if ((extendedKeyCode & (((long) KeyEvent.META_ALT_ON) << 32)) != 0) {
        keystrokeDescriptionBuilder.append(getContext().getString(R.string.key_combo_preference_alt_plus));
    }
    if ((extendedKeyCode & (((long) KeyEvent.META_SHIFT_ON) << 32)) != 0) {
        keystrokeDescriptionBuilder.append(getContext().getString(R.string.key_combo_preference_shift_plus));
    }
    /* Try to obtain a localized representation of the key */
    KeyEvent keyEvent = new KeyEvent(KeyEvent.ACTION_DOWN, (int) extendedKeyCode);
    char displayLabel = keyEvent.getDisplayLabel();
    if (displayLabel != 0 && !Character.isWhitespace(displayLabel)) {
        keystrokeDescriptionBuilder.append(displayLabel);
    } else if (keyEvent.getKeyCode() == KeyEvent.KEYCODE_SPACE) {
        keystrokeDescriptionBuilder.append(getContext().getString(R.string.name_of_space_bar));
    } else if (keyEvent.getKeyCode() == KeyEvent.KEYCODE_ENTER) {
        keystrokeDescriptionBuilder.append(getContext().getString(R.string.name_of_enter_key));
    } else if (keyEvent.getKeyCode() == KeyEvent.KEYCODE_TAB) {
        keystrokeDescriptionBuilder.append(getContext().getString(R.string.name_of_tab_key));
    } else {
        /* Fall back on non-localized descriptions */
        keystrokeDescriptionBuilder.append(KeyEvent.keyCodeToString((int) extendedKeyCode));
    }
    return keystrokeDescriptionBuilder.toString();
}

54. InputHelper#backspace()

Project: KJFrameForAndroid
File: InputHelper.java
public static void backspace(EditText editText) {
    if (editText == null) {
        return;
    }
    KeyEvent event = new KeyEvent(0, 0, 0, KeyEvent.KEYCODE_DEL, 0, 0, 0, 0, KeyEvent.KEYCODE_ENDCALL);
    editText.dispatchKeyEvent(event);
}

55. EmojiconsFragment#backspace()

Project: KitKatEmoji
File: EmojiconsFragment.java
public static void backspace(EditText editText) {
    KeyEvent event = new KeyEvent(0, 0, 0, KeyEvent.KEYCODE_DEL, 0, 0, 0, 0, KeyEvent.KEYCODE_ENDCALL);
    editText.dispatchKeyEvent(event);
}

56. EmojiEditText#backspace()

Project: Emoji
File: EmojiEditText.java
public void backspace() {
    final KeyEvent event = new KeyEvent(0, 0, 0, KeyEvent.KEYCODE_DEL, 0, 0, 0, 0, KeyEvent.KEYCODE_ENDCALL);
    dispatchKeyEvent(event);
}

57. EventInjectorTest#testInjectKeyEvent_securityException()

Project: double-espresso
File: EventInjectorTest.java
@LargeTest
public void testInjectKeyEvent_securityException() {
    KeyCharacterMap keyCharacterMap = UiControllerImpl.getKeyCharacterMap();
    KeyEvent[] events = keyCharacterMap.getEvents("a".toCharArray());
    try {
        injector.injectKeyEvent(events[0]);
        fail("Should have thrown a security exception!");
    } catch (InjectEventSecurityException expected) {
    }
}

58. EventInjector#injectKeyEvent()

Project: double-espresso
File: EventInjector.java
boolean injectKeyEvent(KeyEvent event) throws InjectEventSecurityException {
    long downTime = event.getDownTime();
    long eventTime = event.getEventTime();
    int action = event.getAction();
    int code = event.getKeyCode();
    int repeatCount = event.getRepeatCount();
    int metaState = event.getMetaState();
    int deviceId = event.getDeviceId();
    int scancode = event.getScanCode();
    int flags = event.getFlags();
    if (eventTime == 0) {
        eventTime = SystemClock.uptimeMillis();
    }
    if (downTime == 0) {
        downTime = eventTime;
    }
    // API < 9 does not have constructor with source (nor has source field).
    KeyEvent newEvent;
    if (Build.VERSION.SDK_INT < 9) {
        newEvent = new KeyEvent(downTime, eventTime, action, code, repeatCount, metaState, deviceId, scancode, flags | KeyEvent.FLAG_FROM_SYSTEM);
    } else {
        int source = event.getSource();
        newEvent = new KeyEvent(downTime, eventTime, action, code, repeatCount, metaState, deviceId, scancode, flags | KeyEvent.FLAG_FROM_SYSTEM, source);
    }
    Log.v("ESP_TRACE", String.format("%s:Injecting event for character (%c) with key code (%s) downtime: (%s)", TAG, newEvent.getUnicodeChar(), newEvent.getKeyCode(), newEvent.getDownTime()));
    return injectionStrategy.injectKeyEvent(newEvent);
}

59. RemoteControlReceiver#onReceive()

Project: dmix
File: RemoteControlReceiver.java
@Override
public final void onReceive(final Context context, final Intent intent) {
    final String action = intent.getAction();
    final KeyEvent event = intent.getParcelableExtra(Intent.EXTRA_KEY_EVENT);
    Log.d(TAG, "Intent: " + intent + " received with context: " + context + " with action: " + action);
    if (event != null && event.getAction() == KeyEvent.ACTION_DOWN && Intent.ACTION_MEDIA_BUTTON.equals(action)) {
        final int eventKeyCode = event.getKeyCode();
        Log.d(TAG, "with keycode: " + eventKeyCode);
        switch(eventKeyCode) {
            case KeyEvent.KEYCODE_MEDIA_STOP:
                MPDControl.run(MPDControl.ACTION_STOP);
                break;
            case KeyEvent.KEYCODE_HEADSETHOOK:
            case KeyEvent.KEYCODE_MEDIA_PLAY_PAUSE:
                MPDControl.run(MPDControl.ACTION_TOGGLE_PLAYBACK);
                break;
            case KeyEvent.KEYCODE_MEDIA_NEXT:
                MPDControl.run(MPDControl.ACTION_NEXT);
                break;
            case KeyEvent.KEYCODE_MEDIA_PREVIOUS:
                MPDControl.run(MPDControl.ACTION_PREVIOUS);
                break;
            default:
                break;
        }
    } else {
        switch(action) {
            case AudioManager.ACTION_AUDIO_BECOMING_NOISY:
                if (Tools.isServerLocalhost()) {
                    MPDControl.run(MPDControl.ACTION_PAUSE);
                } else {
                    redirectIntentToService(false, intent);
                }
                break;
            case Intent.ACTION_BOOT_COMPLETED:
                if (sApp.isNotificationPersistent()) {
                    redirectIntentToService(true, intent);
                }
                break;
            case MPDroidService.ACTION_STOP:
                sApp.setPersistentOverride(true);
            /** Fall Through */
            case NotificationHandler.ACTION_START:
            case StreamHandler.ACTION_START:
                redirectIntentToService(true, intent);
                break;
            default:
                MPDControl.run(action);
                break;
        }
    }
}

60. DialerFragment#onKey()

Project: CSipSimple
File: DialerFragment.java
@Override
public boolean onKey(View arg0, int keyCode, KeyEvent arg2) {
    KeyEvent event = new KeyEvent(KeyEvent.ACTION_DOWN, keyCode);
    return digits.onKeyDown(keyCode, event);
}

61. DialerFragment#keyPressed()

Project: CSipSimple
File: DialerFragment.java
private void keyPressed(int keyCode) {
    KeyEvent event = new KeyEvent(KeyEvent.ACTION_DOWN, keyCode);
    digits.onKeyDown(keyCode, event);
}

62. ActivityDelegateTest#testStopPropagatingEvent()

Project: CompositeAndroid
File: ActivityDelegateTest.java
/*
    @Test
    public void testNonConfigurationInstance() throws Exception {

        final ActivityPlugin a = spy(new ActivityPlugin());
        final ActivityPlugin b = spy(new ActivityPlugin() {
            @Override
            public Object onRetainCustomNonConfigurationInstance() {
                final Object superNic = super.onRetainCustomNonConfigurationInstance();
                assertEquals("c", superNic.toString());
                return new NonConfigurationInstanceWrapper(superNic) {
                    @Override
                    public String toString() {
                        return "b";
                    }
                };
            }
        });
        final ActivityPlugin c = spy(new ActivityPlugin() {
            @Override
            public Object onRetainCustomNonConfigurationInstance() {
                return new NonConfigurationInstanceWrapper(
                        super.onRetainCustomNonConfigurationInstance()) {
                    @Override
                    public String toString() {
                        return "c";
                    }
                };
            }
        });

        final CompositeActivity activity = mock(CompositeActivity.class);
        doReturn("SuperObject").when(activity).onRetainCustomNonConfigurationInstance_super();
        final ActivityDelegate delegate = new ActivityDelegate(activity);

        delegate.addPlugin(a);
        delegate.addPlugin(b);
        delegate.addPlugin(c);

        Object o = delegate.onRetainCustomNonConfigurationInstance();
        assertEquals("b", o.toString());


        doReturn(o).when(activity).getLastCustomNonConfigurationInstance_super();

        assertEquals("SuperObject", a.getLastCustomNonConfigurationInstance().toString());
        assertEquals("b", b.getLastCustomNonConfigurationInstance().toString());
        assertEquals("c", c.getLastCustomNonConfigurationInstance().toString());
    }*/
@Test
public void testStopPropagatingEvent() throws Exception {
    final ActivityPlugin a = spy(new ActivityPlugin());
    final ActivityPlugin b = spy(new ActivityPlugin() {

        @Override
        public boolean onKeyDown(final int keyCode, final KeyEvent event) {
            if (keyCode == 25) {
                // stop propagating
                return true;
            }
            return super.onKeyDown(keyCode, event);
        }
    });
    final ActivityPlugin c = spy(new ActivityPlugin() {

        @Override
        public boolean onKeyDown(final int keyCode, final KeyEvent event) {
            return super.onKeyDown(25, event);
        }
    });
    final CompositeActivity activity = mock(CompositeActivity.class);
    final ActivityDelegate delegate = new ActivityDelegate(activity);
    delegate.addPlugin(a);
    delegate.addPlugin(b);
    delegate.addPlugin(c);
    final KeyEvent event = new KeyEvent(KeyEvent.ACTION_DOWN, 1);
    delegate.onKeyDown(1, event);
    verify(a, never()).onKeyDown(25, event);
    verify(b).onKeyDown(25, event);
    verify(c).onKeyDown(1, event);
    verify(activity, never()).onKeyDown__super(25, event);
}

63. ActivityDelegateTest#testNoPlugins()

Project: CompositeAndroid
File: ActivityDelegateTest.java
@Test
public void testNoPlugins() throws Exception {
    final CompositeActivity activity = mock(CompositeActivity.class);
    final ActivityDelegate delegate = new ActivityDelegate(activity);
    final KeyEvent event = new KeyEvent(KeyEvent.ACTION_DOWN, 1);
    delegate.onKeyDown(1, event);
    verify(activity).onKeyDown__super(1, event);
}

64. ActivityDelegateTest#testChangeParamsWithSuperCall()

Project: CompositeAndroid
File: ActivityDelegateTest.java
@Test
public void testChangeParamsWithSuperCall() throws Exception {
    final ActivityPlugin a = spy(new ActivityPlugin());
    final ActivityPlugin b = spy(new ActivityPlugin() {

        @Override
        public boolean onKeyDown(final int keyCode, final KeyEvent event) {
            return super.onKeyDown(25, event);
        }
    });
    final ActivityPlugin c = spy(new ActivityPlugin());
    final CompositeActivity activity = mock(CompositeActivity.class);
    final ActivityDelegate delegate = new ActivityDelegate(activity);
    delegate.addPlugin(a);
    delegate.addPlugin(b);
    delegate.addPlugin(c);
    final KeyEvent event = new KeyEvent(KeyEvent.ACTION_DOWN, 1);
    delegate.onKeyDown(1, event);
    verify(a).onKeyDown(25, event);
    verify(b).onKeyDown(1, event);
    verify(c).onKeyDown(1, event);
    verify(activity).onKeyDown__super(25, event);
}

65. ActivityDelegateTest#testCallEarlySuper()

Project: CompositeAndroid
File: ActivityDelegateTest.java
@Test
public void testCallEarlySuper() throws Exception {
    final ActivityPlugin a = spy(new ActivityPlugin());
    final ActivityPlugin b = spy(new ActivityPlugin() {

        @Override
        public boolean onKeyDown(final int keyCode, final KeyEvent event) {
            return true;
        }
    });
    final ActivityPlugin c = spy(new ActivityPlugin());
    final CompositeActivity activity = mock(CompositeActivity.class);
    final ActivityDelegate delegate = new ActivityDelegate(activity);
    delegate.addPlugin(a);
    delegate.addPlugin(b);
    delegate.addPlugin(c);
    final KeyEvent event = new KeyEvent(KeyEvent.ACTION_DOWN, 1);
    delegate.onKeyDown(1, event);
    verify(a, never()).onKeyDown(1, event);
    verify(b).onKeyDown(1, event);
    verify(c).onKeyDown(1, event);
    verify(activity, never()).onKeyDown__super(1, event);
}

66. CCKeyDispatcher#queueMotionEvent()

Project: cocos2d
File: CCKeyDispatcher.java
public void queueMotionEvent(KeyEvent event) {
    // copy event for queue
    KeyEvent eventForQueue = new KeyEvent(event);
    eventQueue.push(eventForQueue);
}

67. ChatKeyboardLayout#del()

Project: ChatKeyboard
File: ChatKeyboardLayout.java
public void del() {
    int action = KeyEvent.ACTION_DOWN;
    int code = KeyEvent.KEYCODE_DEL;
    KeyEvent event = new KeyEvent(action, code);
    etInputArea.onKeyDown(KeyEvent.KEYCODE_DEL, event);
}

68. EntryKeyboardView#sendKeyEventsToTarget()

Project: bither-android
File: EntryKeyboardView.java
private void sendKeyEventsToTarget(int character) {
    if (viewRootImpl == null && canGetViewRootImpl) {
        getViewRootImpl();
    }
    KeyEvent[] events = KeyCharacterMap.load(KeyCharacterMap.VIRTUAL_KEYBOARD).getEvents(new char[] { (char) character });
    try {
        Method method = viewRootImpl.getClass().getDeclaredMethod("dispatchKeyFromIme", KeyEvent.class);
        method.setAccessible(true);
        if (events != null) {
            final int N = events.length;
            for (int i = 0; i < N; i++) {
                KeyEvent event = events[i];
                event = KeyEvent.changeFlags(event, event.getFlags() | KeyEvent.FLAG_SOFT_KEYBOARD | KeyEvent.FLAG_KEEP_TOUCH_MODE);
                method.invoke(viewRootImpl, event);
            }
        }
    } catch (Exception e) {
        e.printStackTrace();
        LogUtil.e(TAG, "can not dispatch input event");
    }
}

69. PlayerWidgetService#createMediaButtonIntent()

Project: AntennaPod
File: PlayerWidgetService.java
/**
     * Creates an intent which fakes a mediabutton press
     */
private PendingIntent createMediaButtonIntent() {
    KeyEvent event = new KeyEvent(KeyEvent.ACTION_DOWN, KeyEvent.KEYCODE_MEDIA_PLAY_PAUSE);
    Intent startingIntent = new Intent(MediaButtonReceiver.NOTIFY_BUTTON_RECEIVER);
    startingIntent.putExtra(Intent.EXTRA_KEY_EVENT, event);
    return PendingIntent.getBroadcast(this, 0, startingIntent, 0);
}

70. MainActivity#pressKey()

Project: android-widget-keyboardless-edittext
File: MainActivity.java
private void pressKey(int keycode) {
    KeyEvent event = new KeyEvent(KeyEvent.ACTION_DOWN, keycode);
    mEditText.onKeyDown(keycode, event);
}

71. EmojiKeyboard#onBackspaceClick()

Project: actor-platform
File: EmojiKeyboard.java
@Override
public void onBackspaceClick(View v) {
    if (messageBody == null) {
        return;
    }
    KeyEvent event = new KeyEvent(0, 0, 0, KeyEvent.KEYCODE_DEL, 0, 0, 0, 0, KeyEvent.KEYCODE_ENDCALL);
    messageBody.dispatchKeyEvent(event);
}