FileDocCategorySizeDatePackage
KeyEvent.javaAPI DocAndroid 5.1 API119106Thu Mar 12 22:22:10 GMT 2015android.view

KeyEvent

public class KeyEvent extends InputEvent implements android.os.Parcelable
Object used to report key and button events.

Each key press is described by a sequence of key events. A key press starts with a key event with {@link #ACTION_DOWN}. If the key is held sufficiently long that it repeats, then the initial down is followed additional key events with {@link #ACTION_DOWN} and a non-zero value for {@link #getRepeatCount()}. The last key event is a {@link #ACTION_UP} for the key up. If the key press is canceled, the key up event will have the {@link #FLAG_CANCELED} flag set.

Key events are generally accompanied by a key code ({@link #getKeyCode()}), scan code ({@link #getScanCode()}) and meta state ({@link #getMetaState()}). Key code constants are defined in this class. Scan code constants are raw device-specific codes obtained from the OS and so are not generally meaningful to applications unless interpreted using the {@link KeyCharacterMap}. Meta states describe the pressed state of key modifiers such as {@link #META_SHIFT_ON} or {@link #META_ALT_ON}.

Key codes typically correspond one-to-one with individual keys on an input device. Many keys and key combinations serve quite different functions on different input devices so care must be taken when interpreting them. Always use the {@link KeyCharacterMap} associated with the input device when mapping keys to characters. Be aware that there may be multiple key input devices active at the same time and each will have its own key character map.

As soft input methods can use multiple and inventive ways of inputting text, there is no guarantee that any key press on a soft keyboard will generate a key event: this is left to the IME's discretion, and in fact sending such events is discouraged. You should never rely on receiving KeyEvents for any key on a soft input method. In particular, the default software keyboard will never send any key event to any application targetting Jelly Bean or later, and will only send events for some presses of the delete and return keys to applications targetting Ice Cream Sandwich or earlier. Be aware that other software input methods may never send key events regardless of the version. Consider using editor actions like {@link android.view.inputmethod.EditorInfo#IME_ACTION_DONE} if you need specific interaction with the software keyboard, as it gives more visibility to the user as to how your application will react to key presses.

When interacting with an IME, the framework may deliver key events with the special action {@link #ACTION_MULTIPLE} that either specifies that single repeated key code or a sequence of characters to insert.

In general, the framework cannot guarantee that the key events it delivers to a view always constitute complete key sequences since some events may be dropped or modified by containing views before they are delivered. The view implementation should be prepared to handle {@link #FLAG_CANCELED} and should tolerate anomalous situations such as receiving a new {@link #ACTION_DOWN} without first having received an {@link #ACTION_UP} for the prior key press.

Refer to {@link InputDevice} for more information about how different kinds of input devices and sources represent keys and buttons.

Fields Summary
public static final int
KEYCODE_UNKNOWN
Key code constant: Unknown key code.
public static final int
KEYCODE_SOFT_LEFT
Key code constant: Soft Left key. Usually situated below the display on phones and used as a multi-function feature key for selecting a software defined function shown on the bottom left of the display.
public static final int
KEYCODE_SOFT_RIGHT
Key code constant: Soft Right key. Usually situated below the display on phones and used as a multi-function feature key for selecting a software defined function shown on the bottom right of the display.
public static final int
KEYCODE_HOME
Key code constant: Home key. This key is handled by the framework and is never delivered to applications.
public static final int
KEYCODE_BACK
Key code constant: Back key.
public static final int
KEYCODE_CALL
Key code constant: Call key.
public static final int
KEYCODE_ENDCALL
Key code constant: End Call key.
public static final int
KEYCODE_0
Key code constant: '0' key.
public static final int
KEYCODE_1
Key code constant: '1' key.
public static final int
KEYCODE_2
Key code constant: '2' key.
public static final int
KEYCODE_3
Key code constant: '3' key.
public static final int
KEYCODE_4
Key code constant: '4' key.
public static final int
KEYCODE_5
Key code constant: '5' key.
public static final int
KEYCODE_6
Key code constant: '6' key.
public static final int
KEYCODE_7
Key code constant: '7' key.
public static final int
KEYCODE_8
Key code constant: '8' key.
public static final int
KEYCODE_9
Key code constant: '9' key.
public static final int
KEYCODE_STAR
Key code constant: '*' key.
public static final int
KEYCODE_POUND
Key code constant: '#' key.
public static final int
KEYCODE_DPAD_UP
Key code constant: Directional Pad Up key. May also be synthesized from trackball motions.
public static final int
KEYCODE_DPAD_DOWN
Key code constant: Directional Pad Down key. May also be synthesized from trackball motions.
public static final int
KEYCODE_DPAD_LEFT
Key code constant: Directional Pad Left key. May also be synthesized from trackball motions.
public static final int
KEYCODE_DPAD_RIGHT
Key code constant: Directional Pad Right key. May also be synthesized from trackball motions.
public static final int
KEYCODE_DPAD_CENTER
Key code constant: Directional Pad Center key. May also be synthesized from trackball motions.
public static final int
KEYCODE_VOLUME_UP
Key code constant: Volume Up key. Adjusts the speaker volume up.
public static final int
KEYCODE_VOLUME_DOWN
Key code constant: Volume Down key. Adjusts the speaker volume down.
public static final int
KEYCODE_POWER
Key code constant: Power key.
public static final int
KEYCODE_CAMERA
Key code constant: Camera key. Used to launch a camera application or take pictures.
public static final int
KEYCODE_CLEAR
Key code constant: Clear key.
public static final int
KEYCODE_A
Key code constant: 'A' key.
public static final int
KEYCODE_B
Key code constant: 'B' key.
public static final int
KEYCODE_C
Key code constant: 'C' key.
public static final int
KEYCODE_D
Key code constant: 'D' key.
public static final int
KEYCODE_E
Key code constant: 'E' key.
public static final int
KEYCODE_F
Key code constant: 'F' key.
public static final int
KEYCODE_G
Key code constant: 'G' key.
public static final int
KEYCODE_H
Key code constant: 'H' key.
public static final int
KEYCODE_I
Key code constant: 'I' key.
public static final int
KEYCODE_J
Key code constant: 'J' key.
public static final int
KEYCODE_K
Key code constant: 'K' key.
public static final int
KEYCODE_L
Key code constant: 'L' key.
public static final int
KEYCODE_M
Key code constant: 'M' key.
public static final int
KEYCODE_N
Key code constant: 'N' key.
public static final int
KEYCODE_O
Key code constant: 'O' key.
public static final int
KEYCODE_P
Key code constant: 'P' key.
public static final int
KEYCODE_Q
Key code constant: 'Q' key.
public static final int
KEYCODE_R
Key code constant: 'R' key.
public static final int
KEYCODE_S
Key code constant: 'S' key.
public static final int
KEYCODE_T
Key code constant: 'T' key.
public static final int
KEYCODE_U
Key code constant: 'U' key.
public static final int
KEYCODE_V
Key code constant: 'V' key.
public static final int
KEYCODE_W
Key code constant: 'W' key.
public static final int
KEYCODE_X
Key code constant: 'X' key.
public static final int
KEYCODE_Y
Key code constant: 'Y' key.
public static final int
KEYCODE_Z
Key code constant: 'Z' key.
public static final int
KEYCODE_COMMA
Key code constant: ',' key.
public static final int
KEYCODE_PERIOD
Key code constant: '.' key.
public static final int
KEYCODE_ALT_LEFT
Key code constant: Left Alt modifier key.
public static final int
KEYCODE_ALT_RIGHT
Key code constant: Right Alt modifier key.
public static final int
KEYCODE_SHIFT_LEFT
Key code constant: Left Shift modifier key.
public static final int
KEYCODE_SHIFT_RIGHT
Key code constant: Right Shift modifier key.
public static final int
KEYCODE_TAB
Key code constant: Tab key.
public static final int
KEYCODE_SPACE
Key code constant: Space key.
public static final int
KEYCODE_SYM
Key code constant: Symbol modifier key. Used to enter alternate symbols.
public static final int
KEYCODE_EXPLORER
Key code constant: Explorer special function key. Used to launch a browser application.
public static final int
KEYCODE_ENVELOPE
Key code constant: Envelope special function key. Used to launch a mail application.
public static final int
KEYCODE_ENTER
Key code constant: Enter key.
public static final int
KEYCODE_DEL
Key code constant: Backspace key. Deletes characters before the insertion point, unlike {@link #KEYCODE_FORWARD_DEL}.
public static final int
KEYCODE_GRAVE
Key code constant: '`' (backtick) key.
public static final int
KEYCODE_MINUS
Key code constant: '-'.
public static final int
KEYCODE_EQUALS
Key code constant: '=' key.
public static final int
KEYCODE_LEFT_BRACKET
Key code constant: '[' key.
public static final int
KEYCODE_RIGHT_BRACKET
Key code constant: ']' key.
public static final int
KEYCODE_BACKSLASH
Key code constant: '\' key.
public static final int
KEYCODE_SEMICOLON
Key code constant: ';' key.
public static final int
KEYCODE_APOSTROPHE
Key code constant: ''' (apostrophe) key.
public static final int
KEYCODE_SLASH
Key code constant: '/' key.
public static final int
KEYCODE_AT
Key code constant: '@' key.
public static final int
KEYCODE_NUM
Key code constant: Number modifier key. Used to enter numeric symbols. This key is not Num Lock; it is more like {@link #KEYCODE_ALT_LEFT} and is interpreted as an ALT key by {@link android.text.method.MetaKeyKeyListener}.
public static final int
KEYCODE_HEADSETHOOK
Key code constant: Headset Hook key. Used to hang up calls and stop media.
public static final int
KEYCODE_FOCUS
Key code constant: Camera Focus key. Used to focus the camera.
public static final int
KEYCODE_PLUS
Key code constant: '+' key.
public static final int
KEYCODE_MENU
Key code constant: Menu key.
public static final int
KEYCODE_NOTIFICATION
Key code constant: Notification key.
public static final int
KEYCODE_SEARCH
Key code constant: Search key.
public static final int
KEYCODE_MEDIA_PLAY_PAUSE
Key code constant: Play/Pause media key.
public static final int
KEYCODE_MEDIA_STOP
Key code constant: Stop media key.
public static final int
KEYCODE_MEDIA_NEXT
Key code constant: Play Next media key.
public static final int
KEYCODE_MEDIA_PREVIOUS
Key code constant: Play Previous media key.
public static final int
KEYCODE_MEDIA_REWIND
Key code constant: Rewind media key.
public static final int
KEYCODE_MEDIA_FAST_FORWARD
Key code constant: Fast Forward media key.
public static final int
KEYCODE_MUTE
Key code constant: Mute key. Mutes the microphone, unlike {@link #KEYCODE_VOLUME_MUTE}.
public static final int
KEYCODE_PAGE_UP
Key code constant: Page Up key.
public static final int
KEYCODE_PAGE_DOWN
Key code constant: Page Down key.
public static final int
KEYCODE_PICTSYMBOLS
Key code constant: Picture Symbols modifier key. Used to switch symbol sets (Emoji, Kao-moji).
public static final int
KEYCODE_SWITCH_CHARSET
Key code constant: Switch Charset modifier key. Used to switch character sets (Kanji, Katakana).
public static final int
KEYCODE_BUTTON_A
Key code constant: A Button key. On a game controller, the A button should be either the button labeled A or the first button on the bottom row of controller buttons.
public static final int
KEYCODE_BUTTON_B
Key code constant: B Button key. On a game controller, the B button should be either the button labeled B or the second button on the bottom row of controller buttons.
public static final int
KEYCODE_BUTTON_C
Key code constant: C Button key. On a game controller, the C button should be either the button labeled C or the third button on the bottom row of controller buttons.
public static final int
KEYCODE_BUTTON_X
Key code constant: X Button key. On a game controller, the X button should be either the button labeled X or the first button on the upper row of controller buttons.
public static final int
KEYCODE_BUTTON_Y
Key code constant: Y Button key. On a game controller, the Y button should be either the button labeled Y or the second button on the upper row of controller buttons.
public static final int
KEYCODE_BUTTON_Z
Key code constant: Z Button key. On a game controller, the Z button should be either the button labeled Z or the third button on the upper row of controller buttons.
public static final int
KEYCODE_BUTTON_L1
Key code constant: L1 Button key. On a game controller, the L1 button should be either the button labeled L1 (or L) or the top left trigger button.
public static final int
KEYCODE_BUTTON_R1
Key code constant: R1 Button key. On a game controller, the R1 button should be either the button labeled R1 (or R) or the top right trigger button.
public static final int
KEYCODE_BUTTON_L2
Key code constant: L2 Button key. On a game controller, the L2 button should be either the button labeled L2 or the bottom left trigger button.
public static final int
KEYCODE_BUTTON_R2
Key code constant: R2 Button key. On a game controller, the R2 button should be either the button labeled R2 or the bottom right trigger button.
public static final int
KEYCODE_BUTTON_THUMBL
Key code constant: Left Thumb Button key. On a game controller, the left thumb button indicates that the left (or only) joystick is pressed.
public static final int
KEYCODE_BUTTON_THUMBR
Key code constant: Right Thumb Button key. On a game controller, the right thumb button indicates that the right joystick is pressed.
public static final int
KEYCODE_BUTTON_START
Key code constant: Start Button key. On a game controller, the button labeled Start.
public static final int
KEYCODE_BUTTON_SELECT
Key code constant: Select Button key. On a game controller, the button labeled Select.
public static final int
KEYCODE_BUTTON_MODE
Key code constant: Mode Button key. On a game controller, the button labeled Mode.
public static final int
KEYCODE_ESCAPE
Key code constant: Escape key.
public static final int
KEYCODE_FORWARD_DEL
Key code constant: Forward Delete key. Deletes characters ahead of the insertion point, unlike {@link #KEYCODE_DEL}.
public static final int
KEYCODE_CTRL_LEFT
Key code constant: Left Control modifier key.
public static final int
KEYCODE_CTRL_RIGHT
Key code constant: Right Control modifier key.
public static final int
KEYCODE_CAPS_LOCK
Key code constant: Caps Lock key.
public static final int
KEYCODE_SCROLL_LOCK
Key code constant: Scroll Lock key.
public static final int
KEYCODE_META_LEFT
Key code constant: Left Meta modifier key.
public static final int
KEYCODE_META_RIGHT
Key code constant: Right Meta modifier key.
public static final int
KEYCODE_FUNCTION
Key code constant: Function modifier key.
public static final int
KEYCODE_SYSRQ
Key code constant: System Request / Print Screen key.
public static final int
KEYCODE_BREAK
Key code constant: Break / Pause key.
public static final int
KEYCODE_MOVE_HOME
Key code constant: Home Movement key. Used for scrolling or moving the cursor around to the start of a line or to the top of a list.
public static final int
KEYCODE_MOVE_END
Key code constant: End Movement key. Used for scrolling or moving the cursor around to the end of a line or to the bottom of a list.
public static final int
KEYCODE_INSERT
Key code constant: Insert key. Toggles insert / overwrite edit mode.
public static final int
KEYCODE_FORWARD
Key code constant: Forward key. Navigates forward in the history stack. Complement of {@link #KEYCODE_BACK}.
public static final int
KEYCODE_MEDIA_PLAY
Key code constant: Play media key.
public static final int
KEYCODE_MEDIA_PAUSE
Key code constant: Pause media key.
public static final int
KEYCODE_MEDIA_CLOSE
Key code constant: Close media key. May be used to close a CD tray, for example.
public static final int
KEYCODE_MEDIA_EJECT
Key code constant: Eject media key. May be used to eject a CD tray, for example.
public static final int
KEYCODE_MEDIA_RECORD
Key code constant: Record media key.
public static final int
KEYCODE_F1
Key code constant: F1 key.
public static final int
KEYCODE_F2
Key code constant: F2 key.
public static final int
KEYCODE_F3
Key code constant: F3 key.
public static final int
KEYCODE_F4
Key code constant: F4 key.
public static final int
KEYCODE_F5
Key code constant: F5 key.
public static final int
KEYCODE_F6
Key code constant: F6 key.
public static final int
KEYCODE_F7
Key code constant: F7 key.
public static final int
KEYCODE_F8
Key code constant: F8 key.
public static final int
KEYCODE_F9
Key code constant: F9 key.
public static final int
KEYCODE_F10
Key code constant: F10 key.
public static final int
KEYCODE_F11
Key code constant: F11 key.
public static final int
KEYCODE_F12
Key code constant: F12 key.
public static final int
KEYCODE_NUM_LOCK
Key code constant: Num Lock key. This is the Num Lock key; it is different from {@link #KEYCODE_NUM}. This key alters the behavior of other keys on the numeric keypad.
public static final int
KEYCODE_NUMPAD_0
Key code constant: Numeric keypad '0' key.
public static final int
KEYCODE_NUMPAD_1
Key code constant: Numeric keypad '1' key.
public static final int
KEYCODE_NUMPAD_2
Key code constant: Numeric keypad '2' key.
public static final int
KEYCODE_NUMPAD_3
Key code constant: Numeric keypad '3' key.
public static final int
KEYCODE_NUMPAD_4
Key code constant: Numeric keypad '4' key.
public static final int
KEYCODE_NUMPAD_5
Key code constant: Numeric keypad '5' key.
public static final int
KEYCODE_NUMPAD_6
Key code constant: Numeric keypad '6' key.
public static final int
KEYCODE_NUMPAD_7
Key code constant: Numeric keypad '7' key.
public static final int
KEYCODE_NUMPAD_8
Key code constant: Numeric keypad '8' key.
public static final int
KEYCODE_NUMPAD_9
Key code constant: Numeric keypad '9' key.
public static final int
KEYCODE_NUMPAD_DIVIDE
Key code constant: Numeric keypad '/' key (for division).
public static final int
KEYCODE_NUMPAD_MULTIPLY
Key code constant: Numeric keypad '*' key (for multiplication).
public static final int
KEYCODE_NUMPAD_SUBTRACT
Key code constant: Numeric keypad '-' key (for subtraction).
public static final int
KEYCODE_NUMPAD_ADD
Key code constant: Numeric keypad '+' key (for addition).
public static final int
KEYCODE_NUMPAD_DOT
Key code constant: Numeric keypad '.' key (for decimals or digit grouping).
public static final int
KEYCODE_NUMPAD_COMMA
Key code constant: Numeric keypad ',' key (for decimals or digit grouping).
public static final int
KEYCODE_NUMPAD_ENTER
Key code constant: Numeric keypad Enter key.
public static final int
KEYCODE_NUMPAD_EQUALS
Key code constant: Numeric keypad '=' key.
public static final int
KEYCODE_NUMPAD_LEFT_PAREN
Key code constant: Numeric keypad '(' key.
public static final int
KEYCODE_NUMPAD_RIGHT_PAREN
Key code constant: Numeric keypad ')' key.
public static final int
KEYCODE_VOLUME_MUTE
Key code constant: Volume Mute key. Mutes the speaker, unlike {@link #KEYCODE_MUTE}. This key should normally be implemented as a toggle such that the first press mutes the speaker and the second press restores the original volume.
public static final int
KEYCODE_INFO
Key code constant: Info key. Common on TV remotes to show additional information related to what is currently being viewed.
public static final int
KEYCODE_CHANNEL_UP
Key code constant: Channel up key. On TV remotes, increments the television channel.
public static final int
KEYCODE_CHANNEL_DOWN
Key code constant: Channel down key. On TV remotes, decrements the television channel.
public static final int
KEYCODE_ZOOM_IN
Key code constant: Zoom in key.
public static final int
KEYCODE_ZOOM_OUT
Key code constant: Zoom out key.
public static final int
KEYCODE_TV
Key code constant: TV key. On TV remotes, switches to viewing live TV.
public static final int
KEYCODE_WINDOW
Key code constant: Window key. On TV remotes, toggles picture-in-picture mode or other windowing functions.
public static final int
KEYCODE_GUIDE
Key code constant: Guide key. On TV remotes, shows a programming guide.
public static final int
KEYCODE_DVR
Key code constant: DVR key. On some TV remotes, switches to a DVR mode for recorded shows.
public static final int
KEYCODE_BOOKMARK
Key code constant: Bookmark key. On some TV remotes, bookmarks content or web pages.
public static final int
KEYCODE_CAPTIONS
Key code constant: Toggle captions key. Switches the mode for closed-captioning text, for example during television shows.
public static final int
KEYCODE_SETTINGS
Key code constant: Settings key. Starts the system settings activity.
public static final int
KEYCODE_TV_POWER
Key code constant: TV power key. On TV remotes, toggles the power on a television screen.
public static final int
KEYCODE_TV_INPUT
Key code constant: TV input key. On TV remotes, switches the input on a television screen.
public static final int
KEYCODE_STB_POWER
Key code constant: Set-top-box power key. On TV remotes, toggles the power on an external Set-top-box.
public static final int
KEYCODE_STB_INPUT
Key code constant: Set-top-box input key. On TV remotes, switches the input mode on an external Set-top-box.
public static final int
KEYCODE_AVR_POWER
Key code constant: A/V Receiver power key. On TV remotes, toggles the power on an external A/V Receiver.
public static final int
KEYCODE_AVR_INPUT
Key code constant: A/V Receiver input key. On TV remotes, switches the input mode on an external A/V Receiver.
public static final int
KEYCODE_PROG_RED
Key code constant: Red "programmable" key. On TV remotes, acts as a contextual/programmable key.
public static final int
KEYCODE_PROG_GREEN
Key code constant: Green "programmable" key. On TV remotes, actsas a contextual/programmable key.
public static final int
KEYCODE_PROG_YELLOW
Key code constant: Yellow "programmable" key. On TV remotes, acts as a contextual/programmable key.
public static final int
KEYCODE_PROG_BLUE
Key code constant: Blue "programmable" key. On TV remotes, acts as a contextual/programmable key.
public static final int
KEYCODE_APP_SWITCH
Key code constant: App switch key. Should bring up the application switcher dialog.
public static final int
KEYCODE_BUTTON_1
Key code constant: Generic Game Pad Button #1.
public static final int
KEYCODE_BUTTON_2
Key code constant: Generic Game Pad Button #2.
public static final int
KEYCODE_BUTTON_3
Key code constant: Generic Game Pad Button #3.
public static final int
KEYCODE_BUTTON_4
Key code constant: Generic Game Pad Button #4.
public static final int
KEYCODE_BUTTON_5
Key code constant: Generic Game Pad Button #5.
public static final int
KEYCODE_BUTTON_6
Key code constant: Generic Game Pad Button #6.
public static final int
KEYCODE_BUTTON_7
Key code constant: Generic Game Pad Button #7.
public static final int
KEYCODE_BUTTON_8
Key code constant: Generic Game Pad Button #8.
public static final int
KEYCODE_BUTTON_9
Key code constant: Generic Game Pad Button #9.
public static final int
KEYCODE_BUTTON_10
Key code constant: Generic Game Pad Button #10.
public static final int
KEYCODE_BUTTON_11
Key code constant: Generic Game Pad Button #11.
public static final int
KEYCODE_BUTTON_12
Key code constant: Generic Game Pad Button #12.
public static final int
KEYCODE_BUTTON_13
Key code constant: Generic Game Pad Button #13.
public static final int
KEYCODE_BUTTON_14
Key code constant: Generic Game Pad Button #14.
public static final int
KEYCODE_BUTTON_15
Key code constant: Generic Game Pad Button #15.
public static final int
KEYCODE_BUTTON_16
Key code constant: Generic Game Pad Button #16.
public static final int
KEYCODE_LANGUAGE_SWITCH
Key code constant: Language Switch key. Toggles the current input language such as switching between English and Japanese on a QWERTY keyboard. On some devices, the same function may be performed by pressing Shift+Spacebar.
public static final int
KEYCODE_MANNER_MODE
Key code constant: Manner Mode key. Toggles silent or vibrate mode on and off to make the device behave more politely in certain settings such as on a crowded train. On some devices, the key may only operate when long-pressed.
public static final int
KEYCODE_3D_MODE
Key code constant: 3D Mode key. Toggles the display between 2D and 3D mode.
public static final int
KEYCODE_CONTACTS
Key code constant: Contacts special function key. Used to launch an address book application.
public static final int
KEYCODE_CALENDAR
Key code constant: Calendar special function key. Used to launch a calendar application.
public static final int
KEYCODE_MUSIC
Key code constant: Music special function key. Used to launch a music player application.
public static final int
KEYCODE_CALCULATOR
Key code constant: Calculator special function key. Used to launch a calculator application.
public static final int
KEYCODE_ZENKAKU_HANKAKU
Key code constant: Japanese full-width / half-width key.
public static final int
KEYCODE_EISU
Key code constant: Japanese alphanumeric key.
public static final int
KEYCODE_MUHENKAN
Key code constant: Japanese non-conversion key.
public static final int
KEYCODE_HENKAN
Key code constant: Japanese conversion key.
public static final int
KEYCODE_KATAKANA_HIRAGANA
Key code constant: Japanese katakana / hiragana key.
public static final int
KEYCODE_YEN
Key code constant: Japanese Yen key.
public static final int
KEYCODE_RO
Key code constant: Japanese Ro key.
public static final int
KEYCODE_KANA
Key code constant: Japanese kana key.
public static final int
KEYCODE_ASSIST
Key code constant: Assist key. Launches the global assist activity. Not delivered to applications.
public static final int
KEYCODE_BRIGHTNESS_DOWN
Key code constant: Brightness Down key. Adjusts the screen brightness down.
public static final int
KEYCODE_BRIGHTNESS_UP
Key code constant: Brightness Up key. Adjusts the screen brightness up.
public static final int
KEYCODE_MEDIA_AUDIO_TRACK
Key code constant: Audio Track key. Switches the audio tracks.
public static final int
KEYCODE_SLEEP
Key code constant: Sleep key. Puts the device to sleep. Behaves somewhat like {@link #KEYCODE_POWER} but it has no effect if the device is already asleep.
public static final int
KEYCODE_WAKEUP
Key code constant: Wakeup key. Wakes up the device. Behaves somewhat like {@link #KEYCODE_POWER} but it has no effect if the device is already awake.
public static final int
KEYCODE_PAIRING
Key code constant: Pairing key. Initiates peripheral pairing mode. Useful for pairing remote control devices or game controllers, especially if no other input mode is available.
public static final int
KEYCODE_MEDIA_TOP_MENU
Key code constant: Media Top Menu key. Goes to the top of media menu.
public static final int
KEYCODE_11
Key code constant: '11' key.
public static final int
KEYCODE_12
Key code constant: '12' key.
public static final int
KEYCODE_LAST_CHANNEL
Key code constant: Last Channel key. Goes to the last viewed channel.
public static final int
KEYCODE_TV_DATA_SERVICE
Key code constant: TV data service key. Displays data services like weather, sports.
public static final int
KEYCODE_VOICE_ASSIST
Key code constant: Voice Assist key. Launches the global voice assist activity. Not delivered to applications.
public static final int
KEYCODE_TV_RADIO_SERVICE
Key code constant: Radio key. Toggles TV service / Radio service.
public static final int
KEYCODE_TV_TELETEXT
Key code constant: Teletext key. Displays Teletext service.
public static final int
KEYCODE_TV_NUMBER_ENTRY
Key code constant: Number entry key. Initiates to enter multi-digit channel nubmber when each digit key is assigned for selecting separate channel. Corresponds to Number Entry Mode (0x1D) of CEC User Control Code.
public static final int
KEYCODE_TV_TERRESTRIAL_ANALOG
Key code constant: Analog Terrestrial key. Switches to analog terrestrial broadcast service.
public static final int
KEYCODE_TV_TERRESTRIAL_DIGITAL
Key code constant: Digital Terrestrial key. Switches to digital terrestrial broadcast service.
public static final int
KEYCODE_TV_SATELLITE
Key code constant: Satellite key. Switches to digital satellite broadcast service.
public static final int
KEYCODE_TV_SATELLITE_BS
Key code constant: BS key. Switches to BS digital satellite broadcasting service available in Japan.
public static final int
KEYCODE_TV_SATELLITE_CS
Key code constant: CS key. Switches to CS digital satellite broadcasting service available in Japan.
public static final int
KEYCODE_TV_SATELLITE_SERVICE
Key code constant: BS/CS key. Toggles between BS and CS digital satellite services.
public static final int
KEYCODE_TV_NETWORK
Key code constant: Toggle Network key. Toggles selecting broacast services.
public static final int
KEYCODE_TV_ANTENNA_CABLE
Key code constant: Antenna/Cable key. Toggles broadcast input source between antenna and cable.
public static final int
KEYCODE_TV_INPUT_HDMI_1
Key code constant: HDMI #1 key. Switches to HDMI input #1.
public static final int
KEYCODE_TV_INPUT_HDMI_2
Key code constant: HDMI #2 key. Switches to HDMI input #2.
public static final int
KEYCODE_TV_INPUT_HDMI_3
Key code constant: HDMI #3 key. Switches to HDMI input #3.
public static final int
KEYCODE_TV_INPUT_HDMI_4
Key code constant: HDMI #4 key. Switches to HDMI input #4.
public static final int
KEYCODE_TV_INPUT_COMPOSITE_1
Key code constant: Composite #1 key. Switches to composite video input #1.
public static final int
KEYCODE_TV_INPUT_COMPOSITE_2
Key code constant: Composite #2 key. Switches to composite video input #2.
public static final int
KEYCODE_TV_INPUT_COMPONENT_1
Key code constant: Component #1 key. Switches to component video input #1.
public static final int
KEYCODE_TV_INPUT_COMPONENT_2
Key code constant: Component #2 key. Switches to component video input #2.
public static final int
KEYCODE_TV_INPUT_VGA_1
Key code constant: VGA #1 key. Switches to VGA (analog RGB) input #1.
public static final int
KEYCODE_TV_AUDIO_DESCRIPTION
Key code constant: Audio description key. Toggles audio description off / on.
public static final int
KEYCODE_TV_AUDIO_DESCRIPTION_MIX_UP
Key code constant: Audio description mixing volume up key. Louden audio description volume as compared with normal audio volume.
public static final int
KEYCODE_TV_AUDIO_DESCRIPTION_MIX_DOWN
Key code constant: Audio description mixing volume down key. Lessen audio description volume as compared with normal audio volume.
public static final int
KEYCODE_TV_ZOOM_MODE
Key code constant: Zoom mode key. Changes Zoom mode (Normal, Full, Zoom, Wide-zoom, etc.)
public static final int
KEYCODE_TV_CONTENTS_MENU
Key code constant: Contents menu key. Goes to the title list. Corresponds to Contents Menu (0x0B) of CEC User Control Code
public static final int
KEYCODE_TV_MEDIA_CONTEXT_MENU
Key code constant: Media context menu key. Goes to the context menu of media contents. Corresponds to Media Context-sensitive Menu (0x11) of CEC User Control Code.
public static final int
KEYCODE_TV_TIMER_PROGRAMMING
Key code constant: Timer programming key. Goes to the timer recording menu. Corresponds to Timer Programming (0x54) of CEC User Control Code.
public static final int
KEYCODE_HELP
Key code constant: Help key.
private static final int
LAST_KEYCODE
private static final String[]
META_SYMBOLIC_NAMES
private static final String
LABEL_PREFIX
public static final int
MAX_KEYCODE
public static final int
ACTION_DOWN
{@link #getAction} value: the key has been pressed down.
public static final int
ACTION_UP
{@link #getAction} value: the key has been released.
public static final int
ACTION_MULTIPLE
{@link #getAction} value: multiple duplicate key events have occurred in a row, or a complex string is being delivered. If the key code is not {#link {@link #KEYCODE_UNKNOWN} then the {#link {@link #getRepeatCount()} method returns the number of times the given key code should be executed. Otherwise, if the key code is {@link #KEYCODE_UNKNOWN}, then this is a sequence of characters as returned by {@link #getCharacters}.
public static final int
META_CAP_LOCKED
SHIFT key locked in CAPS mode. Reserved for use by {@link MetaKeyKeyListener} for a published constant in its API.
public static final int
META_ALT_LOCKED
ALT key locked. Reserved for use by {@link MetaKeyKeyListener} for a published constant in its API.
public static final int
META_SYM_LOCKED
SYM key locked. Reserved for use by {@link MetaKeyKeyListener} for a published constant in its API.
public static final int
META_SELECTING
Text is in selection mode. Reserved for use by {@link MetaKeyKeyListener} for a private unpublished constant in its API that is currently being retained for legacy reasons.
public static final int
META_ALT_ON

This mask is used to check whether one of the ALT meta keys is pressed.

public static final int
META_ALT_LEFT_ON

This mask is used to check whether the left ALT meta key is pressed.

public static final int
META_ALT_RIGHT_ON

This mask is used to check whether the right the ALT meta key is pressed.

public static final int
META_SHIFT_ON

This mask is used to check whether one of the SHIFT meta keys is pressed.

public static final int
META_SHIFT_LEFT_ON

This mask is used to check whether the left SHIFT meta key is pressed.

public static final int
META_SHIFT_RIGHT_ON

This mask is used to check whether the right SHIFT meta key is pressed.

public static final int
META_SYM_ON

This mask is used to check whether the SYM meta key is pressed.

public static final int
META_FUNCTION_ON

This mask is used to check whether the FUNCTION meta key is pressed.

public static final int
META_CTRL_ON

This mask is used to check whether one of the CTRL meta keys is pressed.

public static final int
META_CTRL_LEFT_ON

This mask is used to check whether the left CTRL meta key is pressed.

public static final int
META_CTRL_RIGHT_ON

This mask is used to check whether the right CTRL meta key is pressed.

public static final int
META_META_ON

This mask is used to check whether one of the META meta keys is pressed.

public static final int
META_META_LEFT_ON

This mask is used to check whether the left META meta key is pressed.

public static final int
META_META_RIGHT_ON

This mask is used to check whether the right META meta key is pressed.

public static final int
META_CAPS_LOCK_ON

This mask is used to check whether the CAPS LOCK meta key is on.

public static final int
META_NUM_LOCK_ON

This mask is used to check whether the NUM LOCK meta key is on.

public static final int
META_SCROLL_LOCK_ON

This mask is used to check whether the SCROLL LOCK meta key is on.

public static final int
META_SHIFT_MASK
This mask is a combination of {@link #META_SHIFT_ON}, {@link #META_SHIFT_LEFT_ON} and {@link #META_SHIFT_RIGHT_ON}.
public static final int
META_ALT_MASK
This mask is a combination of {@link #META_ALT_ON}, {@link #META_ALT_LEFT_ON} and {@link #META_ALT_RIGHT_ON}.
public static final int
META_CTRL_MASK
This mask is a combination of {@link #META_CTRL_ON}, {@link #META_CTRL_LEFT_ON} and {@link #META_CTRL_RIGHT_ON}.
public static final int
META_META_MASK
This mask is a combination of {@link #META_META_ON}, {@link #META_META_LEFT_ON} and {@link #META_META_RIGHT_ON}.
public static final int
FLAG_WOKE_HERE
This mask is set if the device woke because of this key event.
public static final int
FLAG_SOFT_KEYBOARD
This mask is set if the key event was generated by a software keyboard.
public static final int
FLAG_KEEP_TOUCH_MODE
This mask is set if we don't want the key event to cause us to leave touch mode.
public static final int
FLAG_FROM_SYSTEM
This mask is set if an event was known to come from a trusted part of the system. That is, the event is known to come from the user, and could not have been spoofed by a third party component.
public static final int
FLAG_EDITOR_ACTION
This mask is used for compatibility, to identify enter keys that are coming from an IME whose enter key has been auto-labelled "next" or "done". This allows TextView to dispatch these as normal enter keys for old applications, but still do the appropriate action when receiving them.
public static final int
FLAG_CANCELED
When associated with up key events, this indicates that the key press has been canceled. Typically this is used with virtual touch screen keys, where the user can slide from the virtual key area on to the display: in that case, the application will receive a canceled up event and should not perform the action normally associated with the key. Note that for this to work, the application can not perform an action for a key until it receives an up or the long press timeout has expired.
public static final int
FLAG_VIRTUAL_HARD_KEY
This key event was generated by a virtual (on-screen) hard key area. Typically this is an area of the touchscreen, outside of the regular display, dedicated to "hardware" buttons.
public static final int
FLAG_LONG_PRESS
This flag is set for the first key repeat that occurs after the long press timeout.
public static final int
FLAG_CANCELED_LONG_PRESS
Set when a key event has {@link #FLAG_CANCELED} set because a long press action was executed while it was down.
public static final int
FLAG_TRACKING
Set for {@link #ACTION_UP} when this event's key code is still being tracked from its initial down. That is, somebody requested that tracking started on the key down and a long press has not caused the tracking to be canceled.
public static final int
FLAG_FALLBACK
Set when a key event has been synthesized to implement default behavior for an event that the application did not handle. Fallback key events are generated by unhandled trackball motions (to emulate a directional keypad) and by certain unhandled key presses that are declared in the key map (such as special function numeric keypad keys when numlock is off).
public static final int
FLAG_PREDISPATCH
Signifies that the key is being predispatched.
public static final int
FLAG_START_TRACKING
Private control to determine when an app is tracking a key sequence.
public static final int
FLAG_TAINTED
Private flag that indicates when the system has detected that this key event may be inconsistent with respect to the sequence of previously delivered key events, such as when a key up event is sent but the key was not down.
static final boolean
DEBUG
static final String
TAG
private static final int
MAX_RECYCLED
private static final Object
gRecyclerLock
private static int
gRecyclerUsed
private static KeyEvent
gRecyclerTop
private KeyEvent
mNext
private int
mDeviceId
private int
mSource
private int
mMetaState
private int
mAction
private int
mKeyCode
private int
mScanCode
private int
mRepeatCount
private int
mFlags
private long
mDownTime
private long
mEventTime
private String
mCharacters
private static final int
META_MODIFIER_MASK
private static final int
META_LOCK_MASK
private static final int
META_ALL_MASK
private static final int
META_SYNTHETIC_MASK
private static final int
META_INVALID_MODIFIER_MASK
public static final Parcelable.Creator
CREATOR
Constructors Summary
public KeyEvent(long downTime, long eventTime, int action, int code, int repeat, int metaState, int deviceId, int scancode, int flags)
Create a new key event.

param
downTime The time (in {@link android.os.SystemClock#uptimeMillis}) at which this key code originally went down.
param
eventTime The time (in {@link android.os.SystemClock#uptimeMillis}) at which this event happened.
param
action Action code: either {@link #ACTION_DOWN}, {@link #ACTION_UP}, or {@link #ACTION_MULTIPLE}.
param
code The key code.
param
repeat A repeat count for down events (> 0 if this is after the initial down) or event count for multiple events.
param
metaState Flags indicating which meta keys are currently pressed.
param
deviceId The device ID that generated the key event.
param
scancode Raw device scan code of the event.
param
flags The flags for this key event

        mDownTime = downTime;
        mEventTime = eventTime;
        mAction = action;
        mKeyCode = code;
        mRepeatCount = repeat;
        mMetaState = metaState;
        mDeviceId = deviceId;
        mScanCode = scancode;
        mFlags = flags;
public KeyEvent(long downTime, long eventTime, int action, int code, int repeat, int metaState, int deviceId, int scancode, int flags, int source)
Create a new key event.

param
downTime The time (in {@link android.os.SystemClock#uptimeMillis}) at which this key code originally went down.
param
eventTime The time (in {@link android.os.SystemClock#uptimeMillis}) at which this event happened.
param
action Action code: either {@link #ACTION_DOWN}, {@link #ACTION_UP}, or {@link #ACTION_MULTIPLE}.
param
code The key code.
param
repeat A repeat count for down events (> 0 if this is after the initial down) or event count for multiple events.
param
metaState Flags indicating which meta keys are currently pressed.
param
deviceId The device ID that generated the key event.
param
scancode Raw device scan code of the event.
param
flags The flags for this key event
param
source The input source such as {@link InputDevice#SOURCE_KEYBOARD}.

        mDownTime = downTime;
        mEventTime = eventTime;
        mAction = action;
        mKeyCode = code;
        mRepeatCount = repeat;
        mMetaState = metaState;
        mDeviceId = deviceId;
        mScanCode = scancode;
        mFlags = flags;
        mSource = source;
public KeyEvent(long time, String characters, int deviceId, int flags)
Create a new key event for a string of characters. The key code, action, repeat count and source will automatically be set to {@link #KEYCODE_UNKNOWN}, {@link #ACTION_MULTIPLE}, 0, and {@link InputDevice#SOURCE_KEYBOARD} for you.

param
time The time (in {@link android.os.SystemClock#uptimeMillis}) at which this event occured.
param
characters The string of characters.
param
deviceId The device ID that generated the key event.
param
flags The flags for this key event

        mDownTime = time;
        mEventTime = time;
        mCharacters = characters;
        mAction = ACTION_MULTIPLE;
        mKeyCode = KEYCODE_UNKNOWN;
        mRepeatCount = 0;
        mDeviceId = deviceId;
        mFlags = flags;
        mSource = InputDevice.SOURCE_KEYBOARD;
public KeyEvent(KeyEvent origEvent)
Make an exact copy of an existing key event.

        mDownTime = origEvent.mDownTime;
        mEventTime = origEvent.mEventTime;
        mAction = origEvent.mAction;
        mKeyCode = origEvent.mKeyCode;
        mRepeatCount = origEvent.mRepeatCount;
        mMetaState = origEvent.mMetaState;
        mDeviceId = origEvent.mDeviceId;
        mSource = origEvent.mSource;
        mScanCode = origEvent.mScanCode;
        mFlags = origEvent.mFlags;
        mCharacters = origEvent.mCharacters;
public KeyEvent(KeyEvent origEvent, long eventTime, int newRepeat)
Copy an existing key event, modifying its time and repeat count.

deprecated
Use {@link #changeTimeRepeat(KeyEvent, long, int)} instead.
param
origEvent The existing event to be copied.
param
eventTime The new event time (in {@link android.os.SystemClock#uptimeMillis}) of the event.
param
newRepeat The new repeat count of the event.

        mDownTime = origEvent.mDownTime;
        mEventTime = eventTime;
        mAction = origEvent.mAction;
        mKeyCode = origEvent.mKeyCode;
        mRepeatCount = newRepeat;
        mMetaState = origEvent.mMetaState;
        mDeviceId = origEvent.mDeviceId;
        mSource = origEvent.mSource;
        mScanCode = origEvent.mScanCode;
        mFlags = origEvent.mFlags;
        mCharacters = origEvent.mCharacters;
private KeyEvent(KeyEvent origEvent, int action)
Copy an existing key event, modifying its action.

param
origEvent The existing event to be copied.
param
action The new action code of the event.

        mDownTime = origEvent.mDownTime;
        mEventTime = origEvent.mEventTime;
        mAction = action;
        mKeyCode = origEvent.mKeyCode;
        mRepeatCount = origEvent.mRepeatCount;
        mMetaState = origEvent.mMetaState;
        mDeviceId = origEvent.mDeviceId;
        mSource = origEvent.mSource;
        mScanCode = origEvent.mScanCode;
        mFlags = origEvent.mFlags;
        // Don't copy mCharacters, since one way or the other we'll lose it
        // when changing the action.
private KeyEvent()
public KeyEvent(int action, int code)
Create a new key event.

param
action Action code: either {@link #ACTION_DOWN}, {@link #ACTION_UP}, or {@link #ACTION_MULTIPLE}.
param
code The key code.

        mAction = action;
        mKeyCode = code;
        mRepeatCount = 0;
        mDeviceId = KeyCharacterMap.VIRTUAL_KEYBOARD;
public KeyEvent(long downTime, long eventTime, int action, int code, int repeat)
Create a new key event.

param
downTime The time (in {@link android.os.SystemClock#uptimeMillis}) at which this key code originally went down.
param
eventTime The time (in {@link android.os.SystemClock#uptimeMillis}) at which this event happened.
param
action Action code: either {@link #ACTION_DOWN}, {@link #ACTION_UP}, or {@link #ACTION_MULTIPLE}.
param
code The key code.
param
repeat A repeat count for down events (> 0 if this is after the initial down) or event count for multiple events.

        mDownTime = downTime;
        mEventTime = eventTime;
        mAction = action;
        mKeyCode = code;
        mRepeatCount = repeat;
        mDeviceId = KeyCharacterMap.VIRTUAL_KEYBOARD;
public KeyEvent(long downTime, long eventTime, int action, int code, int repeat, int metaState)
Create a new key event.

param
downTime The time (in {@link android.os.SystemClock#uptimeMillis}) at which this key code originally went down.
param
eventTime The time (in {@link android.os.SystemClock#uptimeMillis}) at which this event happened.
param
action Action code: either {@link #ACTION_DOWN}, {@link #ACTION_UP}, or {@link #ACTION_MULTIPLE}.
param
code The key code.
param
repeat A repeat count for down events (> 0 if this is after the initial down) or event count for multiple events.
param
metaState Flags indicating which meta keys are currently pressed.

        mDownTime = downTime;
        mEventTime = eventTime;
        mAction = action;
        mKeyCode = code;
        mRepeatCount = repeat;
        mMetaState = metaState;
        mDeviceId = KeyCharacterMap.VIRTUAL_KEYBOARD;
public KeyEvent(long downTime, long eventTime, int action, int code, int repeat, int metaState, int deviceId, int scancode)
Create a new key event.

param
downTime The time (in {@link android.os.SystemClock#uptimeMillis}) at which this key code originally went down.
param
eventTime The time (in {@link android.os.SystemClock#uptimeMillis}) at which this event happened.
param
action Action code: either {@link #ACTION_DOWN}, {@link #ACTION_UP}, or {@link #ACTION_MULTIPLE}.
param
code The key code.
param
repeat A repeat count for down events (> 0 if this is after the initial down) or event count for multiple events.
param
metaState Flags indicating which meta keys are currently pressed.
param
deviceId The device ID that generated the key event.
param
scancode Raw device scan code of the event.

        mDownTime = downTime;
        mEventTime = eventTime;
        mAction = action;
        mKeyCode = code;
        mRepeatCount = repeat;
        mMetaState = metaState;
        mDeviceId = deviceId;
        mScanCode = scancode;
private KeyEvent(android.os.Parcel in)

        mDeviceId = in.readInt();
        mSource = in.readInt();
        mAction = in.readInt();
        mKeyCode = in.readInt();
        mRepeatCount = in.readInt();
        mMetaState = in.readInt();
        mScanCode = in.readInt();
        mFlags = in.readInt();
        mDownTime = in.readLong();
        mEventTime = in.readLong();
Methods Summary
public static java.lang.StringactionToString(int action)
Returns a string that represents the symbolic name of the specified action such as "ACTION_DOWN", or an equivalent numeric constant such as "35" if unknown.

param
action The action.
return
The symbolic name of the specified action.
hide

        switch (action) {
            case ACTION_DOWN:
                return "ACTION_DOWN";
            case ACTION_UP:
                return "ACTION_UP";
            case ACTION_MULTIPLE:
                return "ACTION_MULTIPLE";
            default:
                return Integer.toString(action);
        }
public final voidcancel()
Set {@link #FLAG_CANCELED} flag for the key event.

hide

        mFlags |= FLAG_CANCELED;
public static android.view.KeyEventchangeAction(android.view.KeyEvent event, int action)
Create a new key event that is the same as the given one, but whose action is replaced with the given value.

param
event The existing event to be copied. This is not modified.
param
action The new action code of the event.

        return new KeyEvent(event, action);
public static android.view.KeyEventchangeFlags(android.view.KeyEvent event, int flags)
Create a new key event that is the same as the given one, but whose flags are replaced with the given value.

param
event The existing event to be copied. This is not modified.
param
flags The new flags constant.

        event = new KeyEvent(event);
        event.mFlags = flags;
        return event;
public static android.view.KeyEventchangeTimeRepeat(android.view.KeyEvent event, long eventTime, int newRepeat)
Create a new key event that is the same as the given one, but whose event time and repeat count are replaced with the given value.

param
event The existing event to be copied. This is not modified.
param
eventTime The new event time (in {@link android.os.SystemClock#uptimeMillis}) of the event.
param
newRepeat The new repeat count of the event.

        return new KeyEvent(event, eventTime, newRepeat);
public static android.view.KeyEventchangeTimeRepeat(android.view.KeyEvent event, long eventTime, int newRepeat, int newFlags)
Create a new key event that is the same as the given one, but whose event time and repeat count are replaced with the given value.

param
event The existing event to be copied. This is not modified.
param
eventTime The new event time (in {@link android.os.SystemClock#uptimeMillis}) of the event.
param
newRepeat The new repeat count of the event.
param
newFlags New flags for the event, replacing the entire value in the original event.

        KeyEvent ret = new KeyEvent(event);
        ret.mEventTime = eventTime;
        ret.mRepeatCount = newRepeat;
        ret.mFlags = newFlags;
        return ret;
public android.view.KeyEventcopy()

hide

        return obtain(this);
public static android.view.KeyEventcreateFromParcelBody(android.os.Parcel in)

hide


      
         
        return new KeyEvent(in);
public final booleandispatch(android.view.KeyEvent$Callback receiver)

deprecated
Use {@link #dispatch(Callback, DispatcherState, Object)} instead.

        return dispatch(receiver, null, null);
public final booleandispatch(android.view.KeyEvent$Callback receiver, android.view.KeyEvent$DispatcherState state, java.lang.Object target)
Deliver this key event to a {@link Callback} interface. If this is an ACTION_MULTIPLE event and it is not handled, then an attempt will be made to deliver a single normal event.

param
receiver The Callback that will be given the event.
param
state State information retained across events.
param
target The target of the dispatch, for use in tracking.
return
The return value from the Callback method that was called.

        switch (mAction) {
            case ACTION_DOWN: {
                mFlags &= ~FLAG_START_TRACKING;
                if (DEBUG) Log.v(TAG, "Key down to " + target + " in " + state
                        + ": " + this);
                boolean res = receiver.onKeyDown(mKeyCode, this);
                if (state != null) {
                    if (res && mRepeatCount == 0 && (mFlags&FLAG_START_TRACKING) != 0) {
                        if (DEBUG) Log.v(TAG, "  Start tracking!");
                        state.startTracking(this, target);
                    } else if (isLongPress() && state.isTracking(this)) {
                        try {
                            if (receiver.onKeyLongPress(mKeyCode, this)) {
                                if (DEBUG) Log.v(TAG, "  Clear from long press!");
                                state.performedLongPress(this);
                                res = true;
                            }
                        } catch (AbstractMethodError e) {
                        }
                    }
                }
                return res;
            }
            case ACTION_UP:
                if (DEBUG) Log.v(TAG, "Key up to " + target + " in " + state
                        + ": " + this);
                if (state != null) {
                    state.handleUpEvent(this);
                }
                return receiver.onKeyUp(mKeyCode, this);
            case ACTION_MULTIPLE:
                final int count = mRepeatCount;
                final int code = mKeyCode;
                if (receiver.onKeyMultiple(code, count, this)) {
                    return true;
                }
                if (code != KeyEvent.KEYCODE_UNKNOWN) {
                    mAction = ACTION_DOWN;
                    mRepeatCount = 0;
                    boolean handled = receiver.onKeyDown(code, this);
                    if (handled) {
                        mAction = ACTION_UP;
                        receiver.onKeyUp(code, this);
                    }
                    mAction = ACTION_MULTIPLE;
                    mRepeatCount = count;
                    return handled;
                }
                return false;
        }
        return false;
public final intgetAction()
Retrieve the action of this key event. May be either {@link #ACTION_DOWN}, {@link #ACTION_UP}, or {@link #ACTION_MULTIPLE}.

return
The event action: ACTION_DOWN, ACTION_UP, or ACTION_MULTIPLE.

        return mAction;
public final java.lang.StringgetCharacters()
For the special case of a {@link #ACTION_MULTIPLE} event with key code of {@link #KEYCODE_UNKNOWN}, this is a raw string of characters associated with the event. In all other cases it is null.

return
Returns a String of 1 or more characters associated with the event.

        return mCharacters;
public static intgetDeadChar(int accent, int c)
Get the character that is produced by putting accent on the character c. For example, getDeadChar('`', 'e') returns è.

        return KeyCharacterMap.getDeadChar(accent, c);
public final intgetDeviceId()
{@inheritDoc}

        return mDeviceId;
public chargetDisplayLabel()
Gets the primary character for this key. In other words, the label that is physically printed on it.

return
The display label character, or 0 if none (eg. for non-printing keys).

        return getKeyCharacterMap().getDisplayLabel(mKeyCode);
public final longgetDownTime()
Retrieve the time of the most recent key down event, in the {@link android.os.SystemClock#uptimeMillis} time base. If this is a down event, this will be the same as {@link #getEventTime()}. Note that when chording keys, this value is the down time of the most recently pressed key, which may not be the same physical key of this event.

return
Returns the most recent key down time, in the {@link android.os.SystemClock#uptimeMillis} time base

        return mDownTime;
public final longgetEventTime()
Retrieve the time this event occurred, in the {@link android.os.SystemClock#uptimeMillis} time base.

return
Returns the time this event occurred, in the {@link android.os.SystemClock#uptimeMillis} time base.

        return mEventTime;
public final longgetEventTimeNano()
Retrieve the time this event occurred, in the {@link android.os.SystemClock#uptimeMillis} time base but with nanosecond (instead of millisecond) precision.

The value is in nanosecond precision but it may not have nanosecond accuracy.

return
Returns the time this event occurred, in the {@link android.os.SystemClock#uptimeMillis} time base but with nanosecond (instead of millisecond) precision.
hide

        return mEventTime * 1000000L;
public final intgetFlags()
Returns the flags for this key event.

see
#FLAG_WOKE_HERE

        return mFlags;
public final android.view.KeyCharacterMapgetKeyCharacterMap()
Gets the {@link KeyCharacterMap} associated with the keyboard device.

return
The associated key character map.
throws
{@link KeyCharacterMap.UnavailableException} if the key character map could not be loaded because it was malformed or the default key character map is missing from the system.
see
KeyCharacterMap#load

        return KeyCharacterMap.load(mDeviceId);
public final intgetKeyCode()
Retrieve the key code of the key event. This is the physical key that was pressed, not the Unicode character.

return
The key code of the event.

        return mKeyCode;
public booleangetKeyData(android.view.KeyCharacterMap.KeyData results)
Get the character conversion data for a given key code.

param
results A {@link KeyCharacterMap.KeyData} instance that will be filled with the results.
return
True if the key was mapped. If the key was not mapped, results is not modified.
deprecated
instead use {@link #getDisplayLabel()}, {@link #getNumber()} or {@link #getUnicodeChar(int)}.

        return getKeyCharacterMap().getKeyData(mKeyCode, results);
public final intgetKeyboardDevice()
Renamed to {@link #getDeviceId}.

hide
deprecated
use {@link #getDeviceId()} instead.

        return mDeviceId;
public chargetMatch(char[] chars)
Gets the first character in the character array that can be generated by the specified key code.

This is a convenience function that returns the same value as {@link #getMatch(char[],int) getMatch(chars, 0)}.

param
chars The array of matching characters to consider.
return
The matching associated character, or 0 if none.

        return getMatch(chars, 0);
public chargetMatch(char[] chars, int metaState)
Gets the first character in the character array that can be generated by the specified key code. If there are multiple choices, prefers the one that would be generated with the specified meta key modifier state.

param
chars The array of matching characters to consider.
param
metaState The preferred meta key modifier state.
return
The matching associated character, or 0 if none.

        return getKeyCharacterMap().getMatch(mKeyCode, chars, metaState);
public static intgetMaxKeyCode()
Returns the maximum keycode.


             
        
        return LAST_KEYCODE;
public final intgetMetaState()

Returns the state of the meta keys.

return
an integer in which each bit set to 1 represents a pressed meta key
see
#isAltPressed()
see
#isShiftPressed()
see
#isSymPressed()
see
#isCtrlPressed()
see
#isMetaPressed()
see
#isFunctionPressed()
see
#isCapsLockOn()
see
#isNumLockOn()
see
#isScrollLockOn()
see
#META_ALT_ON
see
#META_ALT_LEFT_ON
see
#META_ALT_RIGHT_ON
see
#META_SHIFT_ON
see
#META_SHIFT_LEFT_ON
see
#META_SHIFT_RIGHT_ON
see
#META_SYM_ON
see
#META_FUNCTION_ON
see
#META_CTRL_ON
see
#META_CTRL_LEFT_ON
see
#META_CTRL_RIGHT_ON
see
#META_META_ON
see
#META_META_LEFT_ON
see
#META_META_RIGHT_ON
see
#META_CAPS_LOCK_ON
see
#META_NUM_LOCK_ON
see
#META_SCROLL_LOCK_ON
see
#getModifiers

        return mMetaState;
public static intgetModifierMetaStateMask()
Gets a mask that includes all valid modifier key meta state bits.

For the purposes of this function, {@link #KEYCODE_CAPS_LOCK}, {@link #KEYCODE_SCROLL_LOCK}, and {@link #KEYCODE_NUM_LOCK} are not considered modifier keys. Consequently, the mask specifically excludes {@link #META_CAPS_LOCK_ON}, {@link #META_SCROLL_LOCK_ON} and {@link #META_NUM_LOCK_ON}.

return
The modifier meta state mask which is a combination of {@link #META_SHIFT_ON}, {@link #META_SHIFT_LEFT_ON}, {@link #META_SHIFT_RIGHT_ON}, {@link #META_ALT_ON}, {@link #META_ALT_LEFT_ON}, {@link #META_ALT_RIGHT_ON}, {@link #META_CTRL_ON}, {@link #META_CTRL_LEFT_ON}, {@link #META_CTRL_RIGHT_ON}, {@link #META_META_ON}, {@link #META_META_LEFT_ON}, {@link #META_META_RIGHT_ON}, {@link #META_SYM_ON}, {@link #META_FUNCTION_ON}.


                                                                                             
        
        return META_MODIFIER_MASK;
public final intgetModifiers()
Returns the state of the modifier keys.

For the purposes of this function, {@link #KEYCODE_CAPS_LOCK}, {@link #KEYCODE_SCROLL_LOCK}, and {@link #KEYCODE_NUM_LOCK} are not considered modifier keys. Consequently, this function specifically masks out {@link #META_CAPS_LOCK_ON}, {@link #META_SCROLL_LOCK_ON} and {@link #META_NUM_LOCK_ON}.

The value returned consists of the meta state (from {@link #getMetaState}) normalized using {@link #normalizeMetaState(int)} and then masked with {@link #getModifierMetaStateMask} so that only valid modifier bits are retained.

return
An integer in which each bit set to 1 represents a pressed modifier key.
see
#getMetaState

        return normalizeMetaState(mMetaState) & META_MODIFIER_MASK;
public chargetNumber()
Gets the number or symbol associated with the key.

The character value is returned, not the numeric value. If the key is not a number, but is a symbol, the symbol is retuned.

This method is intended to to support dial pads and other numeric or symbolic entry on keyboards where certain keys serve dual function as alphabetic and symbolic keys. This method returns the number or symbol associated with the key independent of whether the user has pressed the required modifier.

For example, on one particular keyboard the keys on the top QWERTY row generate numbers when ALT is pressed such that ALT-Q maps to '1'. So for that keyboard when {@link #getNumber} is called with {@link KeyEvent#KEYCODE_Q} it returns '1' so that the user can type numbers without pressing ALT when it makes sense.

return
The associated numeric or symbolic character, or 0 if none.

        return getKeyCharacterMap().getNumber(mKeyCode);
public final intgetRepeatCount()
Retrieve the repeat count of the event. For both key up and key down events, this is the number of times the key has repeated with the first down starting at 0 and counting up from there. For multiple key events, this is the number of down/up pairs that have occurred.

return
The number of times the key has repeated.

        return mRepeatCount;
public final intgetScanCode()
Retrieve the hardware key id of this key event. These values are not reliable and vary from device to device. {@more} Mostly this is here for debugging purposes.

        return mScanCode;
public final intgetSource()
{@inheritDoc}

        return mSource;
public intgetUnicodeChar()
Gets the Unicode character generated by the specified key and meta key state combination.

Returns the Unicode character that the specified key would produce when the specified meta bits (see {@link MetaKeyKeyListener}) were active.

Returns 0 if the key is not one that is used to type Unicode characters.

If the return value has bit {@link KeyCharacterMap#COMBINING_ACCENT} set, the key is a "dead key" that should be combined with another to actually produce a character -- see {@link KeyCharacterMap#getDeadChar} -- after masking with {@link KeyCharacterMap#COMBINING_ACCENT_MASK}.

return
The associated character or combining accent, or 0 if none.

        return getUnicodeChar(mMetaState);
public intgetUnicodeChar(int metaState)
Gets the Unicode character generated by the specified key and meta key state combination.

Returns the Unicode character that the specified key would produce when the specified meta bits (see {@link MetaKeyKeyListener}) were active.

Returns 0 if the key is not one that is used to type Unicode characters.

If the return value has bit {@link KeyCharacterMap#COMBINING_ACCENT} set, the key is a "dead key" that should be combined with another to actually produce a character -- see {@link KeyCharacterMap#getDeadChar} -- after masking with {@link KeyCharacterMap#COMBINING_ACCENT_MASK}.

param
metaState The meta key modifier state.
return
The associated character or combining accent, or 0 if none.

        return getKeyCharacterMap().get(mKeyCode, metaState);
public final booleanhasModifiers(int modifiers)
Returns true if only the specified modifiers keys are pressed. Returns false if a different combination of modifier keys are pressed.

For the purposes of this function, {@link #KEYCODE_CAPS_LOCK}, {@link #KEYCODE_SCROLL_LOCK}, and {@link #KEYCODE_NUM_LOCK} are not considered modifier keys. Consequently, this function ignores {@link #META_CAPS_LOCK_ON}, {@link #META_SCROLL_LOCK_ON} and {@link #META_NUM_LOCK_ON}.

If the specified modifier mask includes directional modifiers, such as {@link #META_SHIFT_LEFT_ON}, then this method ensures that the modifier is pressed on that side. If the specified modifier mask includes non-directional modifiers, such as {@link #META_SHIFT_ON}, then this method ensures that the modifier is pressed on either side. If the specified modifier mask includes both directional and non-directional modifiers for the same type of key, such as {@link #META_SHIFT_ON} and {@link #META_SHIFT_LEFT_ON}, then this method throws an illegal argument exception.

param
modifiers The meta state of the modifier keys to check. May be a combination of modifier meta states as defined by {@link #getModifierMetaStateMask()}. May be 0 to ensure that no modifier keys are pressed.
return
True if only the specified modifier keys are pressed.
throws
IllegalArgumentException if the modifiers parameter contains invalid modifiers
see
#metaStateHasModifiers

        return metaStateHasModifiers(mMetaState, modifiers);
public final booleanhasNoModifiers()
Returns true if no modifier keys are pressed.

For the purposes of this function, {@link #KEYCODE_CAPS_LOCK}, {@link #KEYCODE_SCROLL_LOCK}, and {@link #KEYCODE_NUM_LOCK} are not considered modifier keys. Consequently, this function ignores {@link #META_CAPS_LOCK_ON}, {@link #META_SCROLL_LOCK_ON} and {@link #META_NUM_LOCK_ON}.

The meta state is normalized prior to comparison using {@link #normalizeMetaState(int)}.

return
True if no modifier keys are pressed.
see
#metaStateHasNoModifiers

        return metaStateHasNoModifiers(mMetaState);
public final booleanisAltPressed()

Returns the pressed state of the ALT meta key.

return
true if the ALT key is pressed, false otherwise
see
#KEYCODE_ALT_LEFT
see
#KEYCODE_ALT_RIGHT
see
#META_ALT_ON

        return (mMetaState & META_ALT_ON) != 0;
public final booleanisCanceled()
For {@link #ACTION_UP} events, indicates that the event has been canceled as per {@link #FLAG_CANCELED}.

        return (mFlags&FLAG_CANCELED) != 0;
public final booleanisCapsLockOn()

Returns the locked state of the CAPS LOCK meta key.

return
true if the CAPS LOCK key is on, false otherwise
see
#KEYCODE_CAPS_LOCK
see
#META_CAPS_LOCK_ON

        return (mMetaState & META_CAPS_LOCK_ON) != 0;
public static final booleanisConfirmKey(int keyCode)
Whether key will, by default, trigger a click on the focused view.

hide

        switch (keyCode) {
            case KeyEvent.KEYCODE_DPAD_CENTER:
            case KeyEvent.KEYCODE_ENTER:
                return true;
            default:
                return false;
        }
public final booleanisCtrlPressed()

Returns the pressed state of the CTRL meta key.

return
true if the CTRL key is pressed, false otherwise
see
#KEYCODE_CTRL_LEFT
see
#KEYCODE_CTRL_RIGHT
see
#META_CTRL_ON

        return (mMetaState & META_CTRL_ON) != 0;
public final booleanisDown()
Don't use in new code, instead explicitly check {@link #getAction()}.

return
If the action is ACTION_DOWN, returns true; else false.
deprecated
hide

        return mAction == ACTION_DOWN;
public final booleanisFunctionPressed()

Returns the pressed state of the FUNCTION meta key.

return
true if the FUNCTION key is pressed, false otherwise
see
#KEYCODE_FUNCTION
see
#META_FUNCTION_ON

        return (mMetaState & META_FUNCTION_ON) != 0;
public static final booleanisGamepadButton(int keyCode)
Returns true if the specified keycode is a gamepad button.

return
True if the keycode is a gamepad button, such as {@link #KEYCODE_BUTTON_A}.

        switch (keyCode) {
            case KeyEvent.KEYCODE_BUTTON_A:
            case KeyEvent.KEYCODE_BUTTON_B:
            case KeyEvent.KEYCODE_BUTTON_C:
            case KeyEvent.KEYCODE_BUTTON_X:
            case KeyEvent.KEYCODE_BUTTON_Y:
            case KeyEvent.KEYCODE_BUTTON_Z:
            case KeyEvent.KEYCODE_BUTTON_L1:
            case KeyEvent.KEYCODE_BUTTON_R1:
            case KeyEvent.KEYCODE_BUTTON_L2:
            case KeyEvent.KEYCODE_BUTTON_R2:
            case KeyEvent.KEYCODE_BUTTON_THUMBL:
            case KeyEvent.KEYCODE_BUTTON_THUMBR:
            case KeyEvent.KEYCODE_BUTTON_START:
            case KeyEvent.KEYCODE_BUTTON_SELECT:
            case KeyEvent.KEYCODE_BUTTON_MODE:
            case KeyEvent.KEYCODE_BUTTON_1:
            case KeyEvent.KEYCODE_BUTTON_2:
            case KeyEvent.KEYCODE_BUTTON_3:
            case KeyEvent.KEYCODE_BUTTON_4:
            case KeyEvent.KEYCODE_BUTTON_5:
            case KeyEvent.KEYCODE_BUTTON_6:
            case KeyEvent.KEYCODE_BUTTON_7:
            case KeyEvent.KEYCODE_BUTTON_8:
            case KeyEvent.KEYCODE_BUTTON_9:
            case KeyEvent.KEYCODE_BUTTON_10:
            case KeyEvent.KEYCODE_BUTTON_11:
            case KeyEvent.KEYCODE_BUTTON_12:
            case KeyEvent.KEYCODE_BUTTON_13:
            case KeyEvent.KEYCODE_BUTTON_14:
            case KeyEvent.KEYCODE_BUTTON_15:
            case KeyEvent.KEYCODE_BUTTON_16:
                return true;
            default:
                return false;
        }
public final booleanisLongPress()
For {@link #ACTION_DOWN} events, indicates that the event has been canceled as per {@link #FLAG_LONG_PRESS}.

        return (mFlags&FLAG_LONG_PRESS) != 0;
public static final booleanisMediaKey(int keyCode)
Whether this key is a media key, which can be send to apps that are interested in media key events.

hide

        switch (keyCode) {
            case KeyEvent.KEYCODE_MEDIA_PLAY:
            case KeyEvent.KEYCODE_MEDIA_PAUSE:
            case KeyEvent.KEYCODE_MEDIA_PLAY_PAUSE:
            case KeyEvent.KEYCODE_MUTE:
            case KeyEvent.KEYCODE_HEADSETHOOK:
            case KeyEvent.KEYCODE_MEDIA_STOP:
            case KeyEvent.KEYCODE_MEDIA_NEXT:
            case KeyEvent.KEYCODE_MEDIA_PREVIOUS:
            case KeyEvent.KEYCODE_MEDIA_REWIND:
            case KeyEvent.KEYCODE_MEDIA_RECORD:
            case KeyEvent.KEYCODE_MEDIA_FAST_FORWARD:
                return true;
        }
        return false;
public static final booleanisMetaKey(int keyCode)

hide

        return keyCode == KeyEvent.KEYCODE_META_LEFT || keyCode == KeyEvent.KEYCODE_META_RIGHT;
public final booleanisMetaPressed()

Returns the pressed state of the META meta key.

return
true if the META key is pressed, false otherwise
see
#KEYCODE_META_LEFT
see
#KEYCODE_META_RIGHT
see
#META_META_ON

        return (mMetaState & META_META_ON) != 0;
public static booleanisModifierKey(int keyCode)
Returns true if this key code is a modifier key.

For the purposes of this function, {@link #KEYCODE_CAPS_LOCK}, {@link #KEYCODE_SCROLL_LOCK}, and {@link #KEYCODE_NUM_LOCK} are not considered modifier keys. Consequently, this function return false for those keys.

return
True if the key code is one of {@link #KEYCODE_SHIFT_LEFT} {@link #KEYCODE_SHIFT_RIGHT}, {@link #KEYCODE_ALT_LEFT}, {@link #KEYCODE_ALT_RIGHT}, {@link #KEYCODE_CTRL_LEFT}, {@link #KEYCODE_CTRL_RIGHT}, {@link #KEYCODE_META_LEFT}, or {@link #KEYCODE_META_RIGHT}, {@link #KEYCODE_SYM}, {@link #KEYCODE_NUM}, {@link #KEYCODE_FUNCTION}.

        switch (keyCode) {
            case KEYCODE_SHIFT_LEFT:
            case KEYCODE_SHIFT_RIGHT:
            case KEYCODE_ALT_LEFT:
            case KEYCODE_ALT_RIGHT:
            case KEYCODE_CTRL_LEFT:
            case KEYCODE_CTRL_RIGHT:
            case KEYCODE_META_LEFT:
            case KEYCODE_META_RIGHT:
            case KEYCODE_SYM:
            case KEYCODE_NUM:
            case KEYCODE_FUNCTION:
                return true;
            default:
                return false;
        }
public final booleanisNumLockOn()

Returns the locked state of the NUM LOCK meta key.

return
true if the NUM LOCK key is on, false otherwise
see
#KEYCODE_NUM_LOCK
see
#META_NUM_LOCK_ON

        return (mMetaState & META_NUM_LOCK_ON) != 0;
public booleanisPrintingKey()
Returns true if this key produces a glyph.

return
True if the key is a printing key.

        return getKeyCharacterMap().isPrintingKey(mKeyCode);
public final booleanisScrollLockOn()

Returns the locked state of the SCROLL LOCK meta key.

return
true if the SCROLL LOCK key is on, false otherwise
see
#KEYCODE_SCROLL_LOCK
see
#META_SCROLL_LOCK_ON

        return (mMetaState & META_SCROLL_LOCK_ON) != 0;
public final booleanisShiftPressed()

Returns the pressed state of the SHIFT meta key.

return
true if the SHIFT key is pressed, false otherwise
see
#KEYCODE_SHIFT_LEFT
see
#KEYCODE_SHIFT_RIGHT
see
#META_SHIFT_ON

        return (mMetaState & META_SHIFT_ON) != 0;
public final booleanisSymPressed()

Returns the pressed state of the SYM meta key.

return
true if the SYM key is pressed, false otherwise
see
#KEYCODE_SYM
see
#META_SYM_ON

        return (mMetaState & META_SYM_ON) != 0;
public final booleanisSystem()
Is this a system key? System keys can not be used for menu shortcuts.

        return isSystemKey(mKeyCode);
public static final booleanisSystemKey(int keyCode)
Is this a system key? System keys can not be used for menu shortcuts.

hide

        switch (keyCode) {
            case KeyEvent.KEYCODE_MENU:
            case KeyEvent.KEYCODE_SOFT_RIGHT:
            case KeyEvent.KEYCODE_HOME:
            case KeyEvent.KEYCODE_BACK:
            case KeyEvent.KEYCODE_CALL:
            case KeyEvent.KEYCODE_ENDCALL:
            case KeyEvent.KEYCODE_VOLUME_UP:
            case KeyEvent.KEYCODE_VOLUME_DOWN:
            case KeyEvent.KEYCODE_VOLUME_MUTE:
            case KeyEvent.KEYCODE_MUTE:
            case KeyEvent.KEYCODE_POWER:
            case KeyEvent.KEYCODE_HEADSETHOOK:
            case KeyEvent.KEYCODE_MEDIA_PLAY:
            case KeyEvent.KEYCODE_MEDIA_PAUSE:
            case KeyEvent.KEYCODE_MEDIA_PLAY_PAUSE:
            case KeyEvent.KEYCODE_MEDIA_STOP:
            case KeyEvent.KEYCODE_MEDIA_NEXT:
            case KeyEvent.KEYCODE_MEDIA_PREVIOUS:
            case KeyEvent.KEYCODE_MEDIA_REWIND:
            case KeyEvent.KEYCODE_MEDIA_RECORD:
            case KeyEvent.KEYCODE_MEDIA_FAST_FORWARD:
            case KeyEvent.KEYCODE_CAMERA:
            case KeyEvent.KEYCODE_FOCUS:
            case KeyEvent.KEYCODE_SEARCH:
            case KeyEvent.KEYCODE_BRIGHTNESS_DOWN:
            case KeyEvent.KEYCODE_BRIGHTNESS_UP:
            case KeyEvent.KEYCODE_MEDIA_AUDIO_TRACK:
                return true;
        }

        return false;
public final booleanisTainted()

hide

        return (mFlags & FLAG_TAINTED) != 0;
public final booleanisTracking()
For {@link #ACTION_UP} events, indicates that the event is still being tracked from its initial down event as per {@link #FLAG_TRACKING}.

        return (mFlags&FLAG_TRACKING) != 0;
public final booleanisWakeKey()

hide

        return isWakeKey(mKeyCode);
public static final booleanisWakeKey(int keyCode)

hide

        switch (keyCode) {
            case KeyEvent.KEYCODE_BACK:
            case KeyEvent.KEYCODE_POWER:
            case KeyEvent.KEYCODE_MENU:
            case KeyEvent.KEYCODE_SLEEP:
            case KeyEvent.KEYCODE_WAKEUP:
            case KeyEvent.KEYCODE_PAIRING:
                return true;
        }
        return false;
public static intkeyCodeFromString(java.lang.String symbolicName)
Gets a keycode by its symbolic name such as "KEYCODE_A" or an equivalent numeric constant such as "1001".

param
symbolicName The symbolic name of the keycode.
return
The keycode or {@link #KEYCODE_UNKNOWN} if not found.
see
#keycodeToString(int)

        if (symbolicName.startsWith(LABEL_PREFIX)) {
            symbolicName = symbolicName.substring(LABEL_PREFIX.length());
            int keyCode = nativeKeyCodeFromString(symbolicName);
            if (keyCode > 0) {
                return keyCode;
            }
        }
        try {
            return Integer.parseInt(symbolicName, 10);
        } catch (NumberFormatException ex) {
            return KEYCODE_UNKNOWN;
        }
public static java.lang.StringkeyCodeToString(int keyCode)
Returns a string that represents the symbolic name of the specified keycode such as "KEYCODE_A", "KEYCODE_DPAD_UP", or an equivalent numeric constant such as "1001" if unknown.

param
keyCode The key code.
return
The symbolic name of the specified keycode.
see
KeyCharacterMap#getDisplayLabel

        String symbolicName = nativeKeyCodeToString(keyCode);
        return symbolicName != null ? LABEL_PREFIX + symbolicName : Integer.toString(keyCode);
private static intmetaStateFilterDirectionalModifiers(int metaState, int modifiers, int basic, int left, int right)

        final boolean wantBasic = (modifiers & basic) != 0;
        final int directional = left | right;
        final boolean wantLeftOrRight = (modifiers & directional) != 0;

        if (wantBasic) {
            if (wantLeftOrRight) {
                throw new IllegalArgumentException("modifiers must not contain "
                        + metaStateToString(basic) + " combined with "
                        + metaStateToString(left) + " or " + metaStateToString(right));
            }
            return metaState & ~directional;
        } else if (wantLeftOrRight) {
            return metaState & ~basic;
        } else {
            return metaState;
        }
public static booleanmetaStateHasModifiers(int metaState, int modifiers)
Returns true if only the specified modifier keys are pressed according to the specified meta state. Returns false if a different combination of modifier keys are pressed.

For the purposes of this function, {@link #KEYCODE_CAPS_LOCK}, {@link #KEYCODE_SCROLL_LOCK}, and {@link #KEYCODE_NUM_LOCK} are not considered modifier keys. Consequently, this function ignores {@link #META_CAPS_LOCK_ON}, {@link #META_SCROLL_LOCK_ON} and {@link #META_NUM_LOCK_ON}.

If the specified modifier mask includes directional modifiers, such as {@link #META_SHIFT_LEFT_ON}, then this method ensures that the modifier is pressed on that side. If the specified modifier mask includes non-directional modifiers, such as {@link #META_SHIFT_ON}, then this method ensures that the modifier is pressed on either side. If the specified modifier mask includes both directional and non-directional modifiers for the same type of key, such as {@link #META_SHIFT_ON} and {@link #META_SHIFT_LEFT_ON}, then this method throws an illegal argument exception.

param
metaState The meta state to consider.
param
modifiers The meta state of the modifier keys to check. May be a combination of modifier meta states as defined by {@link #getModifierMetaStateMask()}. May be 0 to ensure that no modifier keys are pressed.
return
True if only the specified modifier keys are pressed.
throws
IllegalArgumentException if the modifiers parameter contains invalid modifiers
see
#hasModifiers

        // Note: For forward compatibility, we allow the parameter to contain meta states
        //       that we do not recognize but we explicitly disallow meta states that
        //       are not valid modifiers.
        if ((modifiers & META_INVALID_MODIFIER_MASK) != 0) {
            throw new IllegalArgumentException("modifiers must not contain "
                    + "META_CAPS_LOCK_ON, META_NUM_LOCK_ON, META_SCROLL_LOCK_ON, "
                    + "META_CAP_LOCKED, META_ALT_LOCKED, META_SYM_LOCKED, "
                    + "or META_SELECTING");
        }

        metaState = normalizeMetaState(metaState) & META_MODIFIER_MASK;
        metaState = metaStateFilterDirectionalModifiers(metaState, modifiers,
                META_SHIFT_ON, META_SHIFT_LEFT_ON, META_SHIFT_RIGHT_ON);
        metaState = metaStateFilterDirectionalModifiers(metaState, modifiers,
                META_ALT_ON, META_ALT_LEFT_ON, META_ALT_RIGHT_ON);
        metaState = metaStateFilterDirectionalModifiers(metaState, modifiers,
                META_CTRL_ON, META_CTRL_LEFT_ON, META_CTRL_RIGHT_ON);
        metaState = metaStateFilterDirectionalModifiers(metaState, modifiers,
                META_META_ON, META_META_LEFT_ON, META_META_RIGHT_ON);
        return metaState == modifiers;
public static booleanmetaStateHasNoModifiers(int metaState)
Returns true if no modifiers keys are pressed according to the specified meta state.

For the purposes of this function, {@link #KEYCODE_CAPS_LOCK}, {@link #KEYCODE_SCROLL_LOCK}, and {@link #KEYCODE_NUM_LOCK} are not considered modifier keys. Consequently, this function ignores {@link #META_CAPS_LOCK_ON}, {@link #META_SCROLL_LOCK_ON} and {@link #META_NUM_LOCK_ON}.

The meta state is normalized prior to comparison using {@link #normalizeMetaState(int)}.

param
metaState The meta state to consider.
return
True if no modifier keys are pressed.
see
#hasNoModifiers()

        return (normalizeMetaState(metaState) & META_MODIFIER_MASK) == 0;
public static java.lang.StringmetaStateToString(int metaState)
Returns a string that represents the symbolic name of the specified combined meta key modifier state flags such as "0", "META_SHIFT_ON", "META_ALT_ON|META_SHIFT_ON" or an equivalent numeric constant such as "0x10000000" if unknown.

param
metaState The meta state.
return
The symbolic name of the specified combined meta state flags.
hide

        if (metaState == 0) {
            return "0";
        }
        StringBuilder result = null;
        int i = 0;
        while (metaState != 0) {
            final boolean isSet = (metaState & 1) != 0;
            metaState >>>= 1; // unsigned shift!
            if (isSet) {
                final String name = META_SYMBOLIC_NAMES[i];
                if (result == null) {
                    if (metaState == 0) {
                        return name;
                    }
                    result = new StringBuilder(name);
                } else {
                    result.append('|");
                    result.append(name);
                }
            }
            i += 1;
        }
        return result.toString();
private static native intnativeKeyCodeFromString(java.lang.String keyCode)

private static native java.lang.StringnativeKeyCodeToString(int keyCode)
public static intnormalizeMetaState(int metaState)
Normalizes the specified meta state.


The meta state is normalized such that if either the left or right modifier meta state
bits are set then the result will also include the universal bit for that modifier.


If the specified meta state contains {@link #META_ALT_LEFT_ON} then
the result will also contain {@link #META_ALT_ON} in addition to {@link #META_ALT_LEFT_ON}
and the other bits that were specified in the input. The same is process is
performed for shift, control and meta.


If the specified meta state contains synthetic meta states defined by
{@link MetaKeyKeyListener}, then those states are translated here and the original
synthetic meta states are removed from the result.
{@link MetaKeyKeyListener#META_CAP_LOCKED} is translated to {@link #META_CAPS_LOCK_ON}.
{@link MetaKeyKeyListener#META_ALT_LOCKED} is translated to {@link #META_ALT_ON}.
{@link MetaKeyKeyListener#META_SYM_LOCKED} is translated to {@link #META_SYM_ON}.


Undefined meta state bits are removed.

param
metaState The meta state.
return
The normalized meta state.
        if ((metaState & (META_SHIFT_LEFT_ON | META_SHIFT_RIGHT_ON)) != 0) {
            metaState |= META_SHIFT_ON;
        }
        if ((metaState & (META_ALT_LEFT_ON | META_ALT_RIGHT_ON)) != 0) {
            metaState |= META_ALT_ON;
        }
        if ((metaState & (META_CTRL_LEFT_ON | META_CTRL_RIGHT_ON)) != 0) {
            metaState |= META_CTRL_ON;
        }
        if ((metaState & (META_META_LEFT_ON | META_META_RIGHT_ON)) != 0) {
            metaState |= META_META_ON;
        }
        if ((metaState & MetaKeyKeyListener.META_CAP_LOCKED) != 0) {
            metaState |= META_CAPS_LOCK_ON;
        }
        if ((metaState & MetaKeyKeyListener.META_ALT_LOCKED) != 0) {
            metaState |= META_ALT_ON;
        }
        if ((metaState & MetaKeyKeyListener.META_SYM_LOCKED) != 0) {
            metaState |= META_SYM_ON;
        }
        return metaState & META_ALL_MASK;
    
private static android.view.KeyEventobtain()
        final KeyEvent ev;
        synchronized (gRecyclerLock) {
            ev = gRecyclerTop;
            if (ev == null) {
                return new KeyEvent();
            }
            gRecyclerTop = ev.mNext;
            gRecyclerUsed -= 1;
        }
        ev.mNext = null;
        ev.prepareForReuse();
        return ev;
    
public static android.view.KeyEventobtain(long downTime, long eventTime, int action, int code, int repeat, int metaState, int deviceId, int scancode, int flags, int source, java.lang.String characters)
Obtains a (potentially recycled) key event.
hide
        KeyEvent ev = obtain();
        ev.mDownTime = downTime;
        ev.mEventTime = eventTime;
        ev.mAction = action;
        ev.mKeyCode = code;
        ev.mRepeatCount = repeat;
        ev.mMetaState = metaState;
        ev.mDeviceId = deviceId;
        ev.mScanCode = scancode;
        ev.mFlags = flags;
        ev.mSource = source;
        ev.mCharacters = characters;
        return ev;
    
public static android.view.KeyEventobtain(android.view.KeyEvent other)
Obtains a (potentially recycled) copy of another key event.
hide
        KeyEvent ev = obtain();
        ev.mDownTime = other.mDownTime;
        ev.mEventTime = other.mEventTime;
        ev.mAction = other.mAction;
        ev.mKeyCode = other.mKeyCode;
        ev.mRepeatCount = other.mRepeatCount;
        ev.mMetaState = other.mMetaState;
        ev.mDeviceId = other.mDeviceId;
        ev.mScanCode = other.mScanCode;
        ev.mFlags = other.mFlags;
        ev.mSource = other.mSource;
        ev.mCharacters = other.mCharacters;
        return ev;
    
public final voidrecycle()
Recycles a key event.
Key events should only be recycled if they are owned by the system since user
code expects them to be essentially immutable, "tracking" notwithstanding.
hide
        super.recycle();
        mCharacters = null;

        synchronized (gRecyclerLock) {
            if (gRecyclerUsed < MAX_RECYCLED) {
                gRecyclerUsed++;
                mNext = gRecyclerTop;
                gRecyclerTop = this;
            }
        }
    
public final voidrecycleIfNeededAfterDispatch()
hide
        // Do nothing.
    
public final voidsetSource(int source)
{@inheritDoc}
        mSource = source;
    
public final voidsetTainted(boolean tainted)
hide
        mFlags = tainted ? mFlags | FLAG_TAINTED : mFlags & ~FLAG_TAINTED;
    
public final voidstartTracking()
Call this during {@link Callback#onKeyDown} to have the system track
the key through its final up (possibly including a long press). Note
that only one key can be tracked at a time -- if another key down
event is received while a previous one is being tracked, tracking is
stopped on the previous event.
        mFlags |= FLAG_START_TRACKING;
    
public java.lang.StringtoString()
        StringBuilder msg = new StringBuilder();
        msg.append("KeyEvent { action=").append(actionToString(mAction));
        msg.append(", keyCode=").append(keyCodeToString(mKeyCode));
        msg.append(", scanCode=").append(mScanCode);
        if (mCharacters != null) {
            msg.append(", characters=\"").append(mCharacters).append("\"");
        }
        msg.append(", metaState=").append(metaStateToString(mMetaState));
        msg.append(", flags=0x").append(Integer.toHexString(mFlags));
        msg.append(", repeatCount=").append(mRepeatCount);
        msg.append(", eventTime=").append(mEventTime);
        msg.append(", downTime=").append(mDownTime);
        msg.append(", deviceId=").append(mDeviceId);
        msg.append(", source=0x").append(Integer.toHexString(mSource));
        msg.append(" }");
        return msg.toString();
    
public voidwriteToParcel(android.os.Parcel out, int flags)
        out.writeInt(PARCEL_TOKEN_KEY_EVENT);

        out.writeInt(mDeviceId);
        out.writeInt(mSource);
        out.writeInt(mAction);
        out.writeInt(mKeyCode);
        out.writeInt(mRepeatCount);
        out.writeInt(mMetaState);
        out.writeInt(mScanCode);
        out.writeInt(mFlags);
        out.writeLong(mDownTime);
        out.writeLong(mEventTime);