Google is committed to advancing racial equity for Black communities. See how.
Added in API level 3

InputMethodManager

class InputMethodManager
kotlin.Any
   ↳ android.view.inputmethod.InputMethodManager

Central system API to the overall input method framework (IMF) architecture, which arbitrates interaction between applications and the current input method.

Topics covered here:

  1. Architecture Overview
  2. Applications
  3. Input Methods
  4. Security

Architecture Overview

There are three primary parties involved in the input method framework (IMF) architecture:

  • The input method manager as expressed by this class is the central point of the system that manages interaction between all other parts. It is expressed as the client-side API here which exists in each application context and communicates with a global system service that manages the interaction across all processes.
  • An input method (IME) implements a particular interaction model allowing the user to generate text. The system binds to the current input method that is in use, causing it to be created and run, and tells it when to hide and show its UI. Only one IME is running at a time.
  • Multiple client applications arbitrate with the input method manager for input focus and control over the state of the IME. Only one such client is ever active (working with the IME) at a time.

Applications

In most cases, applications that are using the standard android.widget.TextView or its subclasses will have little they need to do to work well with soft input methods. The main things you need to be aware of are:

  • Properly set the android.R.attr#inputType in your editable text views, so that the input method will have enough context to help the user in entering text into them.
  • Deal well with losing screen space when the input method is displayed. Ideally an application should handle its window being resized smaller, but it can rely on the system performing panning of the window if needed. You should set the android.R.attr#windowSoftInputMode attribute on your activity or the corresponding values on windows you create to help the system determine whether to pan or resize (it will try to determine this automatically but may get it wrong).
  • You can also control the preferred soft input state (open, closed, etc) for your window using the same android.R.attr#windowSoftInputMode attribute.

More finer-grained control is available through the APIs here to directly interact with the IMF and its IME -- either showing or hiding the input area, letting the user pick an input method, etc.

For the rare people amongst us writing their own text editors, you will need to implement android.view.View#onCreateInputConnection to return a new instance of your own InputConnection interface allowing the IME to interact with your editor.

Input Methods

An input method (IME) is implemented as a android.app.Service, typically deriving from android.inputmethodservice.InputMethodService. It must provide the core InputMethod interface, though this is normally handled by android.inputmethodservice.InputMethodService and implementors will only need to deal with the higher-level API there.

See the android.inputmethodservice.InputMethodService class for more information on implementing IMEs.

Security

There are a lot of security issues associated with input methods, since they essentially have freedom to completely drive the UI and monitor everything the user enters. The Android input method framework also allows arbitrary third party IMEs, so care must be taken to restrict their selection and interactions.

Here are some key points about the security architecture behind the IMF:

  • Only the system is allowed to directly access an IME's InputMethod interface, via the android.Manifest.permission#BIND_INPUT_METHOD permission. This is enforced in the system by not binding to an input method service that does not require this permission, so the system can guarantee no other untrusted clients are accessing the current input method outside of its control.

  • There may be many client processes of the IMF, but only one may be active at a time. The inactive clients can not interact with key parts of the IMF through the mechanisms described below.

  • Clients of an input method are only given access to its InputMethodSession interface. One instance of this interface is created for each client, and only calls from the session associated with the active client will be processed by the current IME. This is enforced by android.inputmethodservice.AbstractInputMethodService for normal IMEs, but must be explicitly handled by an IME that is customizing the raw InputMethodSession implementation.

  • Only the active client's InputConnection will accept operations. The IMF tells each client process whether it is active, and the framework enforces that in inactive processes calls on to the current InputConnection will be ignored. This ensures that the current IME can only deliver events and text edits to the UI that the user sees as being in focus.

  • An IME can never interact with an InputConnection while the screen is off. This is enforced by making all clients inactive while the screen is off, and prevents bad IMEs from driving the UI when the user can not be aware of its behavior.

  • A client application can ask that the system let the user pick a new IME, but can not programmatically switch to one itself. This avoids malicious applications from switching the user to their own IME, which remains running when the user navigates away to another application. An IME, on the other hand, is allowed to programmatically switch the system to another IME, since it already has full control of user input.

  • The user must explicitly enable a new IME in settings before they can switch to it, to confirm with the system that they know about it and want to make it available for use.


Requires the PackageManager#FEATURE_INPUT_METHODS feature which can be detected using PackageManager.hasSystemFeature(String).

Summary

Constants
static Int

Flag for hideSoftInputFromWindow and InputMethodService#requestHideSelf(int) to indicate that the soft input window should only be hidden if it was not explicitly shown by the user.
static Int

Flag for hideSoftInputFromWindow and InputMethodService#requestShowSelf(int) to indicate that the soft input window should normally be hidden, unless it was originally shown with SHOW_FORCED.
static Int

Flag for the ResultReceiver result code from showSoftInput(android.view.View,int,android.os.ResultReceiver) and hideSoftInputFromWindow(android.os.IBinder,int,android.os.ResultReceiver): the state of the soft input window changed from shown to hidden.
static Int

Flag for the ResultReceiver result code from showSoftInput(android.view.View,int,android.os.ResultReceiver) and hideSoftInputFromWindow(android.os.IBinder,int,android.os.ResultReceiver): the state of the soft input window changed from hidden to shown.
static Int

Flag for the ResultReceiver result code from showSoftInput(android.view.View,int,android.os.ResultReceiver) and hideSoftInputFromWindow(android.os.IBinder,int,android.os.ResultReceiver): the state of the soft input window was unchanged and remains hidden.
static Int

Flag for the ResultReceiver result code from showSoftInput(android.view.View,int,android.os.ResultReceiver) and hideSoftInputFromWindow(android.os.IBinder,int,android.os.ResultReceiver): the state of the soft input window was unchanged and remains shown.
static Int

Flag for showSoftInput to indicate that the user has forced the input method open (such as by long-pressing menu) so it should not be closed until they explicitly do so.
static Int

Flag for showSoftInput to indicate that this is an implicit request to show the input window, not as the result of a direct request by the user.

Public methods
Unit

Provides the default implementation of InputConnection#sendKeyEvent(KeyEvent), which is expected to dispatch an keyboard event sent from the IME to an appropriate event target depending on the given View and the current focus state.
Unit
displayCompletions(view: View!, completions: Array<CompletionInfo!>!)
InputMethodSubtype!

Returns the current input method subtype.
MutableList<InputMethodInfo!>!

Returns the list of enabled input methods.
MutableList<InputMethodSubtype!>!
getEnabledInputMethodSubtypeList(imi: InputMethodInfo!, allowsImplicitlySelectedSubtypes: Boolean)

Returns a list of enabled input method subtypes for the specified input method info.
MutableList<InputMethodInfo!>!

Returns the list of installed input methods.
InputMethodSubtype!

MutableMap<InputMethodInfo!, MutableList<InputMethodSubtype!>!>!

Returns a map of all shortcut input method info and their subtypes.
Unit

Close/hide the input method's soft input area, so the user no longer sees it or can interact with it.
Boolean
hideSoftInputFromWindow(windowToken: IBinder!, flags: Int)

Synonym for hideSoftInputFromWindow(android.os.IBinder,int,android.os.ResultReceiver) without a result: request to hide the soft input window from the context of the window that is currently accepting input.
Boolean
hideSoftInputFromWindow(windowToken: IBinder!, flags: Int, resultReceiver: ResultReceiver!)

Request to hide the soft input window from the context of the window that is currently accepting input.
Unit
hideStatusIcon(imeToken: IBinder!)
Boolean

Return true if the currently served view is accepting full text edits.
Boolean
isActive(view: View!)

Return true if the given view is the currently active view for the input method.
Boolean

Return true if any view is currently active in the input method.
Boolean

Allows you to discover whether the attached input method is running in fullscreen mode.
Boolean

Return true if the current input method wants to watch the location of the input editor's cursor in its window.
Unit

If the input method is currently connected to the given view, restart it with its new contents.
Unit
sendAppPrivateCommand(view: View!, action: String!, data: Bundle!)

Call InputMethodSession#appPrivateCommand(String, Bundle) on the current Input Method.
Unit

Set additional input method subtypes.
Boolean

Switch to a new input method subtype of the current input method.
Unit
setInputMethod(token: IBinder!, id: String!)

Force switch to a new input method component.
Unit

Force switch to a new input method and subtype.
Boolean

Returns true if the current IME needs to offer the users ways to switch to a next input method (e.g. a globe key.).
Unit

Show the settings for enabling subtypes of the specified input method.
Unit

Show IME picker popup window.
Boolean
showSoftInput(view: View!, flags: Int)

Synonym for showSoftInput(android.view.View,int,android.os.ResultReceiver) without a result receiver: explicitly request that the current input method's soft input area be shown to the user, if needed.
Boolean
showSoftInput(view: View!, flags: Int, resultReceiver: ResultReceiver!)

Explicitly request that the current input method's soft input area be shown to the user, if needed.
Unit

Show the input method's soft input area, so the user sees the input method window and can interact with it.
Unit
showStatusIcon(imeToken: IBinder!, packageName: String!, iconId: Int)
Boolean

Force switch to the last used input method and subtype.
Boolean
switchToNextInputMethod(imeToken: IBinder!, onlyCurrentIme: Boolean)

Force switch to the next input method and subtype.
Unit
toggleSoftInput(showFlags: Int, hideFlags: Int)

This method toggles the input method window display.
Unit
toggleSoftInputFromWindow(windowToken: IBinder!, showFlags: Int, hideFlags: Int)

This method toggles the input method window display.
Unit
updateCursor(view: View!, left: Int, top: Int, right: Int, bottom: Int)

Report the current cursor location in its window.
Unit
updateCursorAnchorInfo(view: View!, cursorAnchorInfo: CursorAnchorInfo!)

Report positional change of the text insertion point and/or characters in the composition string.
Unit
updateExtractedText(view: View!, token: Int, text: ExtractedText!)
Unit
updateSelection(view: View!, selStart: Int, selEnd: Int, candidatesStart: Int, candidatesEnd: Int)

Report the current selection range.
Unit
viewClicked(view: View!)

Notify the event when the user tapped or clicked the text view.

Constants

HIDE_IMPLICIT_ONLY

Added in API level 3
static val HIDE_IMPLICIT_ONLY: Int

Flag for hideSoftInputFromWindow and InputMethodService#requestHideSelf(int) to indicate that the soft input window should only be hidden if it was not explicitly shown by the user.

Value: 1

HIDE_NOT_ALWAYS

Added in API level 3
static val HIDE_NOT_ALWAYS: Int

Flag for hideSoftInputFromWindow and InputMethodService#requestShowSelf(int) to indicate that the soft input window should normally be hidden, unless it was originally shown with SHOW_FORCED.

Value: 2

RESULT_HIDDEN

Added in API level 3
static val RESULT_HIDDEN: Int

Flag for the ResultReceiver result code from showSoftInput(android.view.View,int,android.os.ResultReceiver) and hideSoftInputFromWindow(android.os.IBinder,int,android.os.ResultReceiver): the state of the soft input window changed from shown to hidden.

Value: 3

RESULT_SHOWN

Added in API level 3
static val RESULT_SHOWN: Int

Flag for the ResultReceiver result code from showSoftInput(android.view.View,int,android.os.ResultReceiver) and hideSoftInputFromWindow(android.os.IBinder,int,android.os.ResultReceiver): the state of the soft input window changed from hidden to shown.

Value: 2

RESULT_UNCHANGED_HIDDEN

Added in API level 3
static val RESULT_UNCHANGED_HIDDEN: Int

Flag for the ResultReceiver result code from showSoftInput(android.view.View,int,android.os.ResultReceiver) and hideSoftInputFromWindow(android.os.IBinder,int,android.os.ResultReceiver): the state of the soft input window was unchanged and remains hidden.

Value: 1

RESULT_UNCHANGED_SHOWN

Added in API level 3
static val RESULT_UNCHANGED_SHOWN: Int

Flag for the ResultReceiver result code from showSoftInput(android.view.View,int,android.os.ResultReceiver) and hideSoftInputFromWindow(android.os.IBinder,int,android.os.ResultReceiver): the state of the soft input window was unchanged and remains shown.

Value: 0

SHOW_FORCED

Added in API level 3
static val SHOW_FORCED: Int

Flag for showSoftInput to indicate that the user has forced the input method open (such as by long-pressing menu) so it should not be closed until they explicitly do so.

Value: 2

SHOW_IMPLICIT

Added in API level 3
static val SHOW_IMPLICIT: Int

Flag for showSoftInput to indicate that this is an implicit request to show the input window, not as the result of a direct request by the user. The window may not be shown in this case.

Value: 1

Public methods

dispatchKeyEventFromInputMethod

Added in API level 24
fun dispatchKeyEventFromInputMethod(
    targetView: View?, 
    event: KeyEvent
): Unit

Provides the default implementation of InputConnection#sendKeyEvent(KeyEvent), which is expected to dispatch an keyboard event sent from the IME to an appropriate event target depending on the given View and the current focus state.

CAUTION: This method is provided only for the situation where InputConnection#sendKeyEvent(KeyEvent) needs to be implemented without relying on BaseInputConnection. Do not use this API for anything else.

Parameters
targetView View?: the default target view. If null is specified, then this method tries to find a good event target based on the current focus state. This value may be null.
event KeyEvent: the key event to be dispatched. This value cannot be null.

displayCompletions

Added in API level 3
fun displayCompletions(
    view: View!, 
    completions: Array<CompletionInfo!>!
): Unit

getCurrentInputMethodSubtype

Added in API level 11
fun getCurrentInputMethodSubtype(): InputMethodSubtype!

Returns the current input method subtype. This subtype is one of the subtypes in the current input method. This method returns null when the current input method doesn't have any input method subtype.

getEnabledInputMethodList

Added in API level 3
fun getEnabledInputMethodList(): MutableList<InputMethodInfo!>!

Returns the list of enabled input methods.

On multi user environment, this API returns a result for the calling process user.

Return
MutableList<InputMethodInfo!>! List of InputMethodInfo.

getEnabledInputMethodSubtypeList

Added in API level 11
fun getEnabledInputMethodSubtypeList(
    imi: InputMethodInfo!, 
    allowsImplicitlySelectedSubtypes: Boolean
): MutableList<InputMethodSubtype!>!

Returns a list of enabled input method subtypes for the specified input method info.

On multi user environment, this API returns a result for the calling process user.

Parameters
imi InputMethodInfo!: An input method info whose subtypes list will be returned.
allowsImplicitlySelectedSubtypes Boolean: A boolean flag to allow to return the implicitly selected subtypes. If an input method info doesn't have enabled subtypes, the framework will implicitly enable subtypes according to the current system language.

getInputMethodList

Added in API level 3
fun getInputMethodList(): MutableList<InputMethodInfo!>!

Returns the list of installed input methods.

On multi user environment, this API returns a result for the calling process user.

Return
MutableList<InputMethodInfo!>! List of InputMethodInfo.

getLastInputMethodSubtype

Added in API level 14
fun getLastInputMethodSubtype(): InputMethodSubtype!

getShortcutInputMethodsAndSubtypes

Added in API level 11
fun getShortcutInputMethodsAndSubtypes(): MutableMap<InputMethodInfo!, MutableList<InputMethodSubtype!>!>!

Returns a map of all shortcut input method info and their subtypes.

hideSoftInputFromInputMethod

Added in API level 3
Deprecated in API level 28
fun hideSoftInputFromInputMethod(
    token: IBinder!, 
    flags: Int
): Unit

Deprecated: Use InputMethodService#requestHideSelf(int) instead. This method was intended for IME developers who should be accessing APIs through the service. APIs in this class are intended for app developers interacting with the IME.

Close/hide the input method's soft input area, so the user no longer sees it or can interact with it. This can only be called from the currently active input method, as validated by the given token.

Parameters
token IBinder!: Supplies the identifying token given to an input method when it was started, which allows it to perform this operation on itself.
flags Int: Provides additional operating flags. Currently may be 0 or have the HIDE_IMPLICIT_ONLY, HIDE_NOT_ALWAYS bit set.

hideSoftInputFromWindow

Added in API level 3
fun hideSoftInputFromWindow(
    windowToken: IBinder!, 
    flags: Int
): Boolean

Synonym for hideSoftInputFromWindow(android.os.IBinder,int,android.os.ResultReceiver) without a result: request to hide the soft input window from the context of the window that is currently accepting input.

Parameters
windowToken IBinder!: The token of the window that is making the request, as returned by View#getWindowToken().
flags Int: Provides additional operating flags. Currently may be 0 or have the HIDE_IMPLICIT_ONLY bit set.

hideSoftInputFromWindow

Added in API level 3
fun hideSoftInputFromWindow(
    windowToken: IBinder!, 
    flags: Int, 
    resultReceiver: ResultReceiver!
): Boolean

Request to hide the soft input window from the context of the window that is currently accepting input. This should be called as a result of the user doing some actually than fairly explicitly requests to have the input window hidden.

Caveat: ResultReceiver instance passed to this method can be a long-lived object, because it may not be garbage-collected until all the corresponding ResultReceiver objects transferred to different processes get garbage-collected. Follow the general patterns to avoid memory leaks in Android. Consider to use java.lang.ref.WeakReference so that application logic objects such as android.app.Activity and Context can be garbage collected regardless of the lifetime of ResultReceiver.

Parameters
windowToken IBinder!: The token of the window that is making the request, as returned by View#getWindowToken().
flags Int: Provides additional operating flags. Currently may be 0 or have the HIDE_IMPLICIT_ONLY bit set.
resultReceiver ResultReceiver!: If non-null, this will be called by the IME when it has processed your request to tell you what it has done. The result code you receive may be either RESULT_UNCHANGED_SHOWN, RESULT_UNCHANGED_HIDDEN, RESULT_SHOWN, or RESULT_HIDDEN.

hideStatusIcon

Added in API level 3
Deprecated in API level 28
fun hideStatusIcon(imeToken: IBinder!): Unit

Deprecated: Use InputMethodService#hideStatusIcon() instead. This method was intended for IME developers who should be accessing APIs through the service. APIs in this class are intended for app developers interacting with the IME.

isAcceptingText

Added in API level 3
fun isAcceptingText(): Boolean

Return true if the currently served view is accepting full text edits. If false, it has no input connection, so can only handle raw key events.

isActive

Added in API level 3
fun isActive(view: View!): Boolean

Return true if the given view is the currently active view for the input method.

isActive

Added in API level 3
fun isActive(): Boolean

Return true if any view is currently active in the input method.

isFullscreenMode

Added in API level 3
fun isFullscreenMode(): Boolean

Allows you to discover whether the attached input method is running in fullscreen mode. Return true if it is fullscreen, entirely covering your UI, else returns false.

isWatchingCursor

Added in API level 3
Deprecated in API level 21
fun isWatchingCursor(view: View!): Boolean

Deprecated: Use InputConnection#requestCursorUpdates(int) instead.

Return true if the current input method wants to watch the location of the input editor's cursor in its window.

restartInput

Added in API level 3
fun restartInput(view: View!): Unit

If the input method is currently connected to the given view, restart it with its new contents. You should call this when the text within your view changes outside of the normal input method or key input flow, such as when an application calls TextView.setText().

Parameters
view View!: The view whose text has changed.

sendAppPrivateCommand

Added in API level 3
fun sendAppPrivateCommand(
    view: View!, 
    action: String!, 
    data: Bundle!
): Unit

Call InputMethodSession#appPrivateCommand(String, Bundle) on the current Input Method.

Parameters
view View!: Optional View that is sending the command, or null if you want to send the command regardless of the view that is attached to the input method.
action String!: Name of the command to be performed. This must be a scoped name, i.e. prefixed with a package name you own, so that different developers will not create conflicting commands.
data Bundle!: Any data to include with the command.

setAdditionalInputMethodSubtypes

Added in API level 14
Deprecated in API level 29
fun setAdditionalInputMethodSubtypes(
    imiId: String!, 
    subtypes: Array<InputMethodSubtype!>!
): Unit

Deprecated: For IMEs that have already implemented features like customizable/downloadable keyboard layouts/languages, please start migration to other approaches. One idea would be exposing only one unified InputMethodSubtype then implement IME's own language switching mechanism within that unified subtype. The support of "Additional Subtype" may be completely dropped in a future version of Android.

Set additional input method subtypes. Only a process which shares the same uid with the IME can add additional input method subtypes to the IME. Please note that a subtype's status is stored in the system. For example, enabled subtypes are remembered by the framework even after they are removed by using this method. If you re-add the same subtypes again, they will just get enabled. If you want to avoid such conflicts, for instance, you may want to create a "different" new subtype even with the same locale and mode, by changing its extra value. The different subtype won't get affected by the stored past status. (You may want to take a look at InputMethodSubtype#hashCode() to refer to the current implementation.)

NOTE: If the same subtype exists in both the manifest XML file and additional subtypes specified by subtypes, those multiple instances are automatically merged into one instance.

CAVEAT: In API Level 23 and prior, the system may do nothing if an empty InputMethodSubtype is specified in subtypes, which prevents you from removing the last one entry of additional subtypes. If your IME statically defines one or more subtypes in the manifest XML file, you may be able to work around this limitation by specifying one of those statically defined subtypes in subtypes.

Parameters
imiId String!: Id of InputMethodInfo which additional input method subtypes will be added to.
subtypes Array<InputMethodSubtype!>!: subtypes will be added as additional subtypes of the current input method.

setCurrentInputMethodSubtype

Added in API level 11
Deprecated in API level 29
fun setCurrentInputMethodSubtype(subtype: InputMethodSubtype!): Boolean

Deprecated: If the calling process is an IME, use InputMethodService#switchInputMethod(String, InputMethodSubtype), which does not require any permission as long as the caller is the current IME. If the calling process is some privileged app that already has android.Manifest.permission#WRITE_SECURE_SETTINGS permission, just directly update Settings.Secure#SELECTED_INPUT_METHOD_SUBTYPE.

Switch to a new input method subtype of the current input method.
Requires android.Manifest.permission#WRITE_SECURE_SETTINGS

Parameters
subtype InputMethodSubtype!: A new input method subtype to switch.
Return
Boolean true if the current subtype was successfully switched. When the specified subtype is null, this method returns false.

setInputMethod

Added in API level 3
Deprecated in API level 28
fun setInputMethod(
    token: IBinder!, 
    id: String!
): Unit

Deprecated: Use InputMethodService#switchInputMethod(String) instead. This method was intended for IME developers who should be accessing APIs through the service. APIs in this class are intended for app developers interacting with the IME.

Force switch to a new input method component. This can only be called from an application or a service which has a token of the currently active input method.

On Android Build.VERSION_CODES#Q and later devices, the undocumented behavior that token can be null when the caller has android.Manifest.permission#WRITE_SECURE_SETTINGS is deprecated. Instead, update android.provider.Settings.Secure#DEFAULT_INPUT_METHOD and android.provider.Settings.Secure#SELECTED_INPUT_METHOD_SUBTYPE directly.

Parameters
token IBinder!: Supplies the identifying token given to an input method when it was started, which allows it to perform this operation on itself.
id String!: The unique identifier for the new input method to be switched to.

setInputMethodAndSubtype

Added in API level 11
Deprecated in API level 28
fun setInputMethodAndSubtype(
    token: IBinder, 
    id: String!, 
    subtype: InputMethodSubtype!
): Unit

Deprecated: Use InputMethodService#switchInputMethod(String, InputMethodSubtype) instead. This method was intended for IME developers who should be accessing APIs through the service. APIs in this class are intended for app developers interacting with the IME.

Force switch to a new input method and subtype. This can only be called from an application or a service which has a token of the currently active input method.

On Android Build.VERSION_CODES#Q and later devices, token cannot be null even with android.Manifest.permission#WRITE_SECURE_SETTINGS. Instead, update android.provider.Settings.Secure#DEFAULT_INPUT_METHOD and android.provider.Settings.Secure#SELECTED_INPUT_METHOD_SUBTYPE directly.

Parameters
token IBinder: Supplies the identifying token given to an input method when it was started, which allows it to perform this operation on itself. This value cannot be null.
id String!: The unique identifier for the new input method to be switched to.
subtype InputMethodSubtype!: The new subtype of the new input method to be switched to.

shouldOfferSwitchingToNextInputMethod

Added in API level 19
Deprecated in API level 28
fun shouldOfferSwitchingToNextInputMethod(imeToken: IBinder!): Boolean

Deprecated: Use InputMethodService#shouldOfferSwitchingToNextInputMethod() instead. This method was intended for IME developers who should be accessing APIs through the service. APIs in this class are intended for app developers interacting with the IME.

Returns true if the current IME needs to offer the users ways to switch to a next input method (e.g. a globe key.). When an IME sets supportsSwitchingToNextInputMethod and this method returns true, the IME has to offer ways to to invoke switchToNextInputMethod accordingly.

Note that the system determines the most appropriate next input method and subtype in order to provide the consistent user experience in switching between IMEs and subtypes.

Parameters
imeToken IBinder!: Supplies the identifying token given to an input method when it was started, which allows it to perform this operation on itself.

showInputMethodAndSubtypeEnabler

Added in API level 11
fun showInputMethodAndSubtypeEnabler(imiId: String!): Unit

Show the settings for enabling subtypes of the specified input method.

Parameters
imiId String!: An input method, whose subtypes settings will be shown. If imiId is null, subtypes of all input methods will be shown.

showInputMethodPicker

Added in API level 3
fun showInputMethodPicker(): Unit

Show IME picker popup window.

Requires the PackageManager#FEATURE_INPUT_METHODS feature which can be detected using PackageManager#hasSystemFeature(String).

showSoftInput

Added in API level 3
fun showSoftInput(
    view: View!, 
    flags: Int
): Boolean

Synonym for showSoftInput(android.view.View,int,android.os.ResultReceiver) without a result receiver: explicitly request that the current input method's soft input area be shown to the user, if needed.

Parameters
view View!: The currently focused view, which would like to receive soft keyboard input.
flags Int: Provides additional operating flags. Currently may be 0 or have the SHOW_IMPLICIT bit set.

showSoftInput

Added in API level 3
fun showSoftInput(
    view: View!, 
    flags: Int, 
    resultReceiver: ResultReceiver!
): Boolean

Explicitly request that the current input method's soft input area be shown to the user, if needed. Call this if the user interacts with your view in such a way that they have expressed they would like to start performing input into it.

Caveat: ResultReceiver instance passed to this method can be a long-lived object, because it may not be garbage-collected until all the corresponding ResultReceiver objects transferred to different processes get garbage-collected. Follow the general patterns to avoid memory leaks in Android. Consider to use java.lang.ref.WeakReference so that application logic objects such as android.app.Activity and Context can be garbage collected regardless of the lifetime of ResultReceiver.

Parameters
view View!: The currently focused view, which would like to receive soft keyboard input.
flags Int: Provides additional operating flags. Currently may be 0 or have the SHOW_IMPLICIT bit set.
resultReceiver ResultReceiver!: If non-null, this will be called by the IME when it has processed your request to tell you what it has done. The result code you receive may be either RESULT_UNCHANGED_SHOWN, RESULT_UNCHANGED_HIDDEN, RESULT_SHOWN, or RESULT_HIDDEN.

showSoftInputFromInputMethod

Added in API level 3
Deprecated in API level 28
fun showSoftInputFromInputMethod(
    token: IBinder!, 
    flags: Int
): Unit

Deprecated: Use InputMethodService#requestShowSelf(int) instead. This method was intended for IME developers who should be accessing APIs through the service. APIs in this class are intended for app developers interacting with the IME.

Show the input method's soft input area, so the user sees the input method window and can interact with it. This can only be called from the currently active input method, as validated by the given token.

Parameters
token IBinder!: Supplies the identifying token given to an input method when it was started, which allows it to perform this operation on itself.
flags Int: Provides additional operating flags. Currently may be 0 or have the SHOW_IMPLICIT or SHOW_FORCED bit set.

showStatusIcon

Added in API level 3
Deprecated in API level 28
fun showStatusIcon(
    imeToken: IBinder!, 
    packageName: String!, 
    iconId: Int
): Unit

Deprecated: Use InputMethodService#showStatusIcon(int) instead. This method was intended for IME developers who should be accessing APIs through the service. APIs in this class are intended for app developers interacting with the IME.

switchToLastInputMethod

Added in API level 11
Deprecated in API level 28
fun switchToLastInputMethod(imeToken: IBinder!): Boolean

Deprecated: Use InputMethodService#switchToPreviousInputMethod() instead. This method was intended for IME developers who should be accessing APIs through the service. APIs in this class are intended for app developers interacting with the IME.

Force switch to the last used input method and subtype. If the last input method didn't have any subtypes, the framework will simply switch to the last input method with no subtype specified.

Parameters
imeToken IBinder!: Supplies the identifying token given to an input method when it was started, which allows it to perform this operation on itself.
Return
Boolean true if the current input method and subtype was successfully switched to the last used input method and subtype.

switchToNextInputMethod

Added in API level 16
Deprecated in API level 28
fun switchToNextInputMethod(
    imeToken: IBinder!, 
    onlyCurrentIme: Boolean
): Boolean

Deprecated: Use InputMethodService#switchToNextInputMethod(boolean) instead. This method was intended for IME developers who should be accessing APIs through the service. APIs in this class are intended for app developers interacting with the IME.

Force switch to the next input method and subtype. If there is no IME enabled except current IME and subtype, do nothing.

Parameters
imeToken IBinder!: Supplies the identifying token given to an input method when it was started, which allows it to perform this operation on itself.
onlyCurrentIme Boolean: if true, the framework will find the next subtype which belongs to the current IME
Return
Boolean true if the current input method and subtype was successfully switched to the next input method and subtype.

toggleSoftInput

Added in API level 3
fun toggleSoftInput(
    showFlags: Int, 
    hideFlags: Int
): Unit

This method toggles the input method window display. If the input window is already displayed, it gets hidden. If not the input window will be displayed.

Parameters
showFlags Int: Provides additional operating flags. May be 0 or have the SHOW_IMPLICIT, SHOW_FORCED bit set.
hideFlags Int: Provides additional operating flags. May be 0 or have the HIDE_IMPLICIT_ONLY, HIDE_NOT_ALWAYS bit set.

toggleSoftInputFromWindow

Added in API level 3
fun toggleSoftInputFromWindow(
    windowToken: IBinder!, 
    showFlags: Int, 
    hideFlags: Int
): Unit

This method toggles the input method window display. If the input window is already displayed, it gets hidden. If not the input window will be displayed.

Parameters
windowToken IBinder!: The token of the window that is making the request, as returned by View#getWindowToken().
showFlags Int: Provides additional operating flags. May be 0 or have the SHOW_IMPLICIT, SHOW_FORCED bit set.
hideFlags Int: Provides additional operating flags. May be 0 or have the HIDE_IMPLICIT_ONLY, HIDE_NOT_ALWAYS bit set.

updateCursor

Added in API level 3
Deprecated in API level 21
fun updateCursor(
    view: View!, 
    left: Int, 
    top: Int, 
    right: Int, 
    bottom: Int
): Unit

Deprecated: Use updateCursorAnchorInfo(android.view.View,android.view.inputmethod.CursorAnchorInfo) instead.

Report the current cursor location in its window.

updateCursorAnchorInfo

Added in API level 21
fun updateCursorAnchorInfo(
    view: View!, 
    cursorAnchorInfo: CursorAnchorInfo!
): Unit

Report positional change of the text insertion point and/or characters in the composition string.

updateExtractedText

Added in API level 3
fun updateExtractedText(
    view: View!, 
    token: Int, 
    text: ExtractedText!
): Unit

updateSelection

Added in API level 3
fun updateSelection(
    view: View!, 
    selStart: Int, 
    selEnd: Int, 
    candidatesStart: Int, 
    candidatesEnd: Int
): Unit

Report the current selection range.

Editor authors, you need to call this method whenever the cursor moves in your editor. Remember that in addition to doing this, your editor needs to always supply current cursor values in EditorInfo#initialSelStart and EditorInfo#initialSelEnd every time android.view.View#onCreateInputConnection(EditorInfo) is called, which happens whenever the keyboard shows up or the focus changes to a text field, among other cases.

viewClicked

Added in API level 14
Deprecated in API level 29
fun viewClicked(view: View!): Unit

Deprecated: The semantics of this method can never be defined well for composite View that works as a giant "Canvas", which can host its own UI hierarchy and sub focus state. android.webkit.WebView is a good example. Application / IME developers should not rely on this method.

Notify the event when the user tapped or clicked the text view.

Parameters
view View!: View which is being clicked.