TextKeyListener

open class TextKeyListener : BaseKeyListener, SpanWatcher

kotlin.Any
↳	android.text.method.MetaKeyKeyListener
	↳	android.text.method.BaseKeyListener
		↳	android.text.method.TextKeyListener

This is the key listener for typing normal text. It delegates to other key listeners appropriate to the current keyboard and language.

As for all implementations of KeyListener, this class is only concerned with hardware keyboards. Software input methods have no obligation to trigger the methods in this class.

Summary

Nested classes
	`Capitalize`

Inherited constants

From class MetaKeyKeyListener

`Int`	`META_ALT_LOCKED` Flag that indicates that the ALT key is locked.
`Int`	`META_ALT_ON` Flag that indicates that the ALT key is on. Value equals `KeyEvent.META_ALT_ON`.
`Int`	`META_CAP_LOCKED` Flag that indicates that the SHIFT key is locked in CAPS mode.
`Int`	`META_SHIFT_ON` Flag that indicates that the SHIFT key is on. Value equals `KeyEvent.META_SHIFT_ON`.
`Int`	`META_SYM_LOCKED` Flag that indicates that the SYM key is locked.
`Int`	`META_SYM_ON` Flag that indicates that the SYM key is on. Value equals `KeyEvent.META_SYM_ON`.

Public constructors
`TextKeyListener(cap: TextKeyListener.Capitalize!, autotext: Boolean)` Creates a new TextKeyListener with the specified capitalization and correction properties.

Public methods
open static Unit	`clear(e: Editable!)` Clear all the input state (autotext, autocap, multitap, undo) from the specified Editable, going beyond Editable.
open Int	`getInputType()` Return the type of text that this key listener is manipulating, as per `android.text.InputType`.
open static TextKeyListener!	`getInstance()` Returns a new or existing instance with no automatic capitalization or correction.
open static TextKeyListener!	`getInstance(autotext: Boolean, cap: TextKeyListener.Capitalize!)` Returns a new or existing instance with the specified capitalization and correction properties.
open Boolean	`onKeyDown(view: View!, content: Editable!, keyCode: Int, event: KeyEvent!)` Handles presses of the meta keys.
open Boolean	`onKeyOther(view: View!, content: Editable!, event: KeyEvent!)` Base implementation handles ACTION_MULTIPLE KEYCODE_UNKNOWN by inserting the event's text into the content.
open Boolean	`onKeyUp(view: View!, content: Editable!, keyCode: Int, event: KeyEvent!)` Handles release of the meta keys.
open Unit	`onSpanAdded(s: Spannable!, what: Any!, start: Int, end: Int)` This method is called to notify you that the specified object has been attached to the specified range of the text.
open Unit	`onSpanChanged(s: Spannable!, what: Any!, start: Int, end: Int, st: Int, en: Int)` This method is called to notify you that the specified object has been relocated from the range `ostart…oend` to the new range `nstart…nend` of the text.
open Unit	`onSpanRemoved(s: Spannable!, what: Any!, start: Int, end: Int)` This method is called to notify you that the specified object has been detached from the specified range of the text.
open Unit	`release()`
open static Boolean	`shouldCap(cap: TextKeyListener.Capitalize!, cs: CharSequence!, off: Int)` Returns whether it makes sense to automatically capitalize at the specified position in the specified text, with the specified rules.

Inherited functions

From class MetaKeyKeyListener

`Unit`	`adjustMetaAfterKeypress(content: Spannable!)` Call this method after you handle a keypress so that the meta state will be reset to unshifted (if it is not still down) or primed to be reset to unshifted (once it is released).
`Long`	`adjustMetaAfterKeypress(state: Long)` Call this method after you handle a keypress so that the meta state will be reset to unshifted (if it is not still down) or primed to be reset to unshifted (once it is released). Takes the current state, returns the new state.
`Unit`	`clearMetaKeyState(view: View!, content: Editable!, states: Int)`
`Long`	`clearMetaKeyState(state: Long, which: Int)` Clears the state of the specified meta key if it is locked.
`Unit`	`clearMetaKeyState(content: Editable!, states: Int)`
`Int`	`getMetaState(text: CharSequence!)` Gets the state of the meta keys.
`Int`	`getMetaState(text: CharSequence!, event: KeyEvent!)` Gets the state of the meta keys for a specific key event. For input devices that use toggled key modifiers, the `toggled' state is stored into the text buffer. This method retrieves the meta state for this event, accounting for the stored state. If the event has been created by a device that does not support toggled key modifiers, like a virtual device for example, the stored state is ignored.
`Int`	`getMetaState(text: CharSequence!, meta: Int)` Gets the state of a particular meta key.
`Int`	`getMetaState(text: CharSequence!, meta: Int, event: KeyEvent!)` Gets the state of a particular meta key to use with a particular key event. If the key event has been created by a device that does not support toggled key modifiers, like a virtual keyboard for example, only the meta state in the key event is considered.
`Int`	`getMetaState(state: Long)` Gets the state of the meta keys.
`Int`	`getMetaState(state: Long, meta: Int)` Gets the state of a particular meta key.
`Long`	`handleKeyDown(state: Long, keyCode: Int, event: KeyEvent!)` Handles presses of the meta keys.
`Long`	`handleKeyUp(state: Long, keyCode: Int, event: KeyEvent!)` Handles release of the meta keys.
`Boolean`	`isMetaTracker(text: CharSequence!, what: Any!)` Returns true if this object is one that this class would use to keep track of any meta state in the specified text.
`Boolean`	`isSelectingMetaTracker(text: CharSequence!, what: Any!)` Returns true if this object is one that this class would use to keep track of the selecting meta state in the specified text.
`Boolean`	`onKeyUp(view: View!, content: Editable!, keyCode: Int, event: KeyEvent!)` Handles release of the meta keys.
`Unit`	`resetLockedMeta(content: Spannable!)` Call this if you are a method that ignores the locked meta state (arrow keys, for example) and you handle a key.
`Long`	`resetLockedMeta(state: Long)` Call this if you are a method that ignores the locked meta state (arrow keys, for example) and you handle a key.
`Unit`	`resetMetaState(text: Spannable!)` Resets all meta state to inactive.

From class BaseKeyListener

`Boolean`	`backspace(view: View!, content: Editable!, keyCode: Int, event: KeyEvent!)` Performs the action that happens when you press the `KeyEvent.KEYCODE_DEL` key in a `TextView`. If there is a selection, deletes the selection; otherwise, deletes the character before the cursor, if any; ALT+DEL deletes everything on the line the cursor is on.
`Boolean`	`forwardDelete(view: View!, content: Editable!, keyCode: Int, event: KeyEvent!)` Performs the action that happens when you press the `KeyEvent.KEYCODE_FORWARD_DEL` key in a `TextView`. If there is a selection, deletes the selection; otherwise, deletes the character before the cursor, if any; ALT+FORWARD_DEL deletes everything on the line the cursor is on.

From class KeyListener

Int

getInputType()

Return the type of text that this key listener is manipulating, as per android.text.InputType. This is used to determine the mode of the soft keyboard that is shown for the editor.

If you return android.text.InputType#TYPE_NULL then no soft keyboard will provided. In other words, you must be providing your own key pad for on-screen input and the key listener will be used to handle input from a hard keyboard.

If you return any other value, a soft input method will be created when the user puts focus in the editor, which will provide a keypad and also consume hard key events. This means that the key listener will generally not be used, instead the soft input method will take care of managing key input as per the content type returned here.

Public constructors

TextKeyListener(
    cap: TextKeyListener.Capitalize!, 
    autotext: Boolean)

Creates a new TextKeyListener with the specified capitalization and correction properties.

Parameters
`cap`	TextKeyListener.Capitalize!: when, if ever, to automatically capitalize.
`autotext`	Boolean: whether to automatically do spelling corrections.

Public methods

clear

open static fun clear(e: Editable!): Unit

Clear all the input state (autotext, autocap, multitap, undo) from the specified Editable, going beyond Editable.clear(), which just clears the text but not the input state.

Parameters
`e`	Editable!: the buffer whose text and state are to be cleared.

getInputType

open fun getInputType(): Int

Return the type of text that this key listener is manipulating, as per android.text.InputType. This is used to determine the mode of the soft keyboard that is shown for the editor.

getInstance

open static fun getInstance(): TextKeyListener!

Returns a new or existing instance with no automatic capitalization or correction.

onKeyOther

open fun onKeyOther(
    view: View!, 
    content: Editable!, 
    event: KeyEvent!
): Boolean

Base implementation handles ACTION_MULTIPLE KEYCODE_UNKNOWN by inserting the event's text into the content.

onSpanAdded

open fun onSpanAdded(
    s: Spannable!, 
    what: Any!, 
    start: Int, 
    end: Int
): Unit

This method is called to notify you that the specified object has been attached to the specified range of the text.

onSpanChanged

open fun onSpanChanged(
    s: Spannable!, 
    what: Any!, 
    start: Int, 
    end: Int, 
    st: Int, 
    en: Int
): Unit

This method is called to notify you that the specified object has been relocated from the range ostart…oend to the new range nstart…nend of the text.

onSpanRemoved

open fun onSpanRemoved(
    s: Spannable!, 
    what: Any!, 
    start: Int, 
    end: Int
): Unit

This method is called to notify you that the specified object has been detached from the specified range of the text.

release

open fun release(): Unit

shouldCap

open static fun shouldCap(
    cap: TextKeyListener.Capitalize!, 
    cs: CharSequence!, 
    off: Int
): Boolean

Returns whether it makes sense to automatically capitalize at the specified position in the specified text, with the specified rules.

Parameters
`cap`	TextKeyListener.Capitalize!: the capitalization rules to consider.
`cs`	CharSequence!: the text in which an insertion is being made.
`off`	Int: the offset into that text where the insertion is being made.

Return
`Boolean`	whether the character being inserted should be capitalized.

Content and code samples on this page are subject to the licenses described in the Content License. Java and OpenJDK are trademarks or registered trademarks of Oracle and/or its affiliates.