HANDWRITING_DELEGATE_FLAG_HOME_DELEGATOR_ALLOWED

static val HANDWRITING_DELEGATE_FLAG_HOME_DELEGATOR_ALLOWED: Int

Flag indicating that views from the default home screen (Intent.CATEGORY_HOME) may act as a handwriting delegator for the delegate editor view. If set, views from the home screen package will be trusted for handwriting delegation, in addition to views in the delegatorPackageName passed to acceptStylusHandwritingDelegation(View,String,int,Executor,Consumer) .

Value: 1

HIDE_IMPLICIT_ONLY

static val HIDE_IMPLICIT_ONLY: Int

Deprecated: Starting in Android B, this flag has no effect anymore.

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

static val HIDE_NOT_ALWAYS: Int

Deprecated: Starting in Android B, this flag has no effect anymore.

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

static val RESULT_HIDDEN: Int

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

Value: 3

RESULT_SHOWN

static val RESULT_SHOWN: Int

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

Value: 2

RESULT_UNCHANGED_HIDDEN

static val RESULT_UNCHANGED_HIDDEN: Int

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

Value: 1

RESULT_UNCHANGED_SHOWN

static val RESULT_UNCHANGED_SHOWN: Int

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

Value: 0

SHOW_FORCED

static val SHOW_FORCED: Int

Deprecated: Use #showSoftInput without this flag instead. Using this flag can lead to the soft input remaining visible even when the calling application is closed. The use of this flag can make the soft input remain visible globally. Starting in Android T, this flag only has an effect while the caller is currently focused. Starting in Android B, this flag has no effect anymore.

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

static val SHOW_IMPLICIT: Int

Deprecated: Use #showSoftInput without this flag instead. Starting in Android B, this flag has no effect anymore.

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

acceptStylusHandwritingDelegation

fun acceptStylusHandwritingDelegation(delegateView: View): Boolean

Accepts and starts a stylus handwriting session on the delegate view, if handwriting initiation delegation was previously requested using prepareStylusHandwritingDelegation(View) from the delegator.

Otherwise, if the delegator view previously started delegation using startConnectionlessStylusHandwritingForDelegation(View,CursorAnchorInfo,Executor,ConnectionlessHandwritingCallback), requests the IME to commit the recognised handwritten text from the connectionless session to the delegate view.

Note: If delegator and delegate are in different application packages, use acceptStylusHandwritingDelegation(View,String) instead.

acceptStylusHandwritingDelegation

fun acceptStylusHandwritingDelegation(
    delegateView: View, 
    delegatorPackageName: String
): Boolean

Accepts and starts a stylus handwriting session on the delegate view, if handwriting initiation delegation was previously requested using prepareStylusHandwritingDelegation(View,String) from the delegator and the view belongs to a specified delegate package.

Otherwise, if the delegator view previously started delegation using startConnectionlessStylusHandwritingForDelegation(View,CursorAnchorInfo,String,Executor,ConnectionlessHandwritingCallback), requests the IME to commit the recognised handwritten text from the connectionless session to the delegate view.

Note: If delegator and delegate are in the same application package, use acceptStylusHandwritingDelegation(View) instead.

acceptStylusHandwritingDelegation

fun acceptStylusHandwritingDelegation(
    delegateView: View, 
    delegatorPackageName: String, 
    flags: Int, 
    executor: Executor, 
    callback: Consumer<Boolean!>
): Unit

Accepts and starts a stylus handwriting session on the delegate view, if handwriting initiation delegation was previously requested using prepareStylusHandwritingDelegation(View,String) from the delegator and the view belongs to a specified delegate package.

Otherwise, if the delegator view previously started delegation using startConnectionlessStylusHandwritingForDelegation(View,CursorAnchorInfo,String,Executor,ConnectionlessHandwritingCallback), requests the IME to commit the recognised handwritten text from the connectionless session to the delegate view.

Note: If delegator and delegate are in the same application package, use acceptStylusHandwritingDelegation(View) instead.

acceptStylusHandwritingDelegation

fun acceptStylusHandwritingDelegation(
    delegateView: View, 
    delegatorPackageName: String, 
    executor: Executor, 
    callback: Consumer<Boolean!>
): Unit

Accepts and starts a stylus handwriting session on the delegate view, if handwriting initiation delegation was previously requested using prepareStylusHandwritingDelegation(View,String) from the delegator and the view belongs to a specified delegate package.

Otherwise, if the delegator view previously started delegation using startConnectionlessStylusHandwritingForDelegation(View,CursorAnchorInfo,String,Executor,ConnectionlessHandwritingCallback), requests the IME to commit the recognised handwritten text from the connectionless session to the delegate view.

dispatchKeyEventFromInputMethod

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.

getCurrentInputMethodInfo

fun getCurrentInputMethodInfo(): InputMethodInfo?

Returns the InputMethodInfo of the currently selected input method (for the process's user).

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

getCurrentInputMethodSubtype

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.

getEnabledInputMethodSubtypeList

fun getEnabledInputMethodSubtypeList(
    imi: InputMethodInfo?, 
    allowsImplicitlyEnabledSubtypes: 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.

hideSoftInputFromInputMethod

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.

hideSoftInputFromWindow

fun hideSoftInputFromWindow(
    windowToken: IBinder!, 
    flags: Int
): 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.

hideSoftInputFromWindow

fun hideSoftInputFromWindow(
    windowToken: IBinder!, 
    flags: Int, 
    resultReceiver: ResultReceiver!
): Boolean

Deprecated: The ResultReceiver is not a reliable way of determining whether the Input Method is actually shown or hidden. If result is needed, use android.view.WindowInsetsController#hide instead and set a View.OnApplyWindowInsetsListener and verify the provided WindowInsets for the visibility of IME. If result is not needed, use #hideSoftInputFromView(android.view.View,int) instead.

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.

hideStatusIcon

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

fun isAcceptingText(): Boolean

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

isActive

fun isActive(): Boolean

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

isActive

fun isActive(view: View!): Boolean

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

isConnectionlessStylusHandwritingAvailable

fun isConnectionlessStylusHandwritingAvailable(): Boolean

Returns true if the currently selected IME supports connectionless stylus handwriting sessions and is enabled.

isFullscreenMode

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.

isInputMethodSuppressingSpellChecker

fun isInputMethodSuppressingSpellChecker(): Boolean

Return true if the input method is suppressing system spell checker.

isStylusHandwritingAvailable

fun isStylusHandwritingAvailable(): Boolean

Returns true if currently selected IME supports Stylus handwriting & is enabled. If the method returns false, startStylusHandwriting(View) shouldn't be called and Stylus touch should continue as normal touch input.

prepareStylusHandwritingDelegation

fun prepareStylusHandwritingDelegation(delegatorView: View): Unit

Prepares delegation of starting stylus handwriting session to a different editor in same or different window than the view on which initial handwriting stroke was detected. Delegation can be used to start stylus handwriting session before the Editor view or its InputConnection is started. Calling this method starts buffering of stylus motion events until acceptStylusHandwritingDelegation(View) is called, at which point the handwriting session can be started and the buffered stylus motion events will be delivered to the IME. e.g. Delegation can be used when initial handwriting stroke is on a pseudo Editor like widget (with no InputConnection) but actual Editor is on a different window.

Note: If an actual Editor capable of InputConnection is being scribbled upon using stylus, use startStylusHandwriting(View) instead.

prepareStylusHandwritingDelegation

fun prepareStylusHandwritingDelegation(
    delegatorView: View, 
    delegatePackageName: String
): Unit

Prepares delegation of starting stylus handwriting session to a different editor in same or a different window in a different package than the view on which initial handwriting stroke was detected. Delegation can be used to start stylus handwriting session before the Editor view or its InputConnection is started. Calling this method starts buffering of stylus motion events until acceptStylusHandwritingDelegation(View,String) is called, at which point the handwriting session can be started and the buffered stylus motion events will be delivered to the IME. e.g. Delegation can be used when initial handwriting stroke is on a pseudo Editor like widget (with no InputConnection) but actual Editor is on a different window in the given package.

Note: If delegator and delegate are in same package use prepareStylusHandwritingDelegation(View) instead.

restartInput

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().

sendAppPrivateCommand

fun sendAppPrivateCommand(
    view: View!, 
    action: String!, 
    data: Bundle!
): Unit

Call InputMethodSession.appPrivateCommand() on the current Input Method.

setAdditionalInputMethodSubtypes

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.

shouldOfferSwitchingToNextInputMethod

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.

showInputMethodAndSubtypeEnabler

fun showInputMethodAndSubtypeEnabler(imiId: String?): Unit

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

showSoftInput

fun showSoftInput(
    view: View!, 
    flags: Int
): 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.

showSoftInput

fun showSoftInput(
    view: View!, 
    flags: Int, 
    resultReceiver: ResultReceiver!
): Boolean

Deprecated: The ResultReceiver is not a reliable way of determining whether the Input Method is actually shown or hidden. If result is needed, use android.view.WindowInsetsController#show instead and set a View.OnApplyWindowInsetsListener and verify the provided WindowInsets for the visibility of IME. If result is not needed, use showSoftInput(View,int) instead.

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.

showSoftInputFromInputMethod

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.

showStatusIcon

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.

startConnectionlessStylusHandwriting

fun startConnectionlessStylusHandwriting(
    view: View, 
    cursorAnchorInfo: CursorAnchorInfo?, 
    callbackExecutor: Executor, 
    callback: ConnectionlessHandwritingCallback
): Unit

Starts a connectionless stylus handwriting session. A connectionless session differs from a regular stylus handwriting session in that the IME does not use an input connection to communicate with a text editor. Instead, the IME directly returns recognised handwritten text via a callback.

The {code cursorAnchorInfo} may be used by the IME to improve the handwriting recognition accuracy and user experience of the handwriting session. Usually connectionless handwriting is used for a view which appears like a text editor but does not really support text editing. For best results, the {code cursorAnchorInfo} should be populated as it would be for a real text editor (for example, the insertion marker location can be set to where the user would expect it to be, even if there is no visible cursor).

startConnectionlessStylusHandwritingForDelegation

fun startConnectionlessStylusHandwritingForDelegation(
    delegatorView: View, 
    cursorAnchorInfo: CursorAnchorInfo?, 
    delegatePackageName: String, 
    callbackExecutor: Executor, 
    callback: ConnectionlessHandwritingCallback
): Unit

Starts a connectionless stylus handwriting session (see startConnectionlessStylusHandwriting) and additionally enables the recognised handwritten text to be later committed to a text editor using acceptStylusHandwritingDelegation(View,String).

After a connectionless session started using this method completes successfully, a text editor view, called the delegate view, may call acceptStylusHandwritingDelegation(View,String) which will request the IME to commit the recognised handwritten text from the connectionless session to the delegate view.

The delegate view must belong to delegatePackageName for the delegation to succeed.

startConnectionlessStylusHandwritingForDelegation

fun startConnectionlessStylusHandwritingForDelegation(
    delegatorView: View, 
    cursorAnchorInfo: CursorAnchorInfo?, 
    callbackExecutor: Executor, 
    callback: ConnectionlessHandwritingCallback
): Unit

Starts a connectionless stylus handwriting session (see startConnectionlessStylusHandwriting) and additionally enables the recognised handwritten text to be later committed to a text editor using acceptStylusHandwritingDelegation(View).

After a connectionless session started using this method completes successfully, a text editor view, called the delegate view, may call acceptStylusHandwritingDelegation(View) which will request the IME to commit the recognised handwritten text from the connectionless session to the delegate view.

The delegate view must belong to the same package as the delegator view for the delegation to succeed. If the delegate view belongs to a different package, use startConnectionlessStylusHandwritingForDelegation(View,CursorAnchorInfo,String,Executor,ConnectionlessHandwritingCallback) instead.

startStylusHandwriting

fun startStylusHandwriting(view: View): Unit

Start stylus handwriting session. If supported by the current input method, a stylus handwriting session is started on the given View, capturing all stylus input and converting it to InputConnection commands. If handwriting mode is started successfully by the IME, any currently dispatched stylus pointers will be android.view.MotionEvent#FLAG_CANCELED cancelled. If Stylus handwriting mode is not supported or cannot be fulfilled for any reason by IME, request will be ignored and Stylus touch will continue as normal touch input. Ideally, isStylusHandwritingAvailable() should be called first to determine if stylus handwriting is supported by IME.

switchToLastInputMethod

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.

switchToNextInputMethod

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.

toggleSoftInput

fun toggleSoftInput(
    showFlags: Int, 
    hideFlags: Int
): Unit

Deprecated: Use showSoftInput(View,int) or hideSoftInputFromWindow(IBinder,int) explicitly instead. In particular during focus changes, the current visibility of the IME is not well defined. Starting in Android S, this only has an effect if the calling app is the current IME focus.

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.

toggleSoftInputFromWindow

fun toggleSoftInputFromWindow(
    windowToken: IBinder!, 
    showFlags: Int, 
    hideFlags: Int
): Unit

Deprecated: Use showSoftInput(View,int) or hideSoftInputFromWindow(IBinder,int) explicitly instead. In particular during focus changes, the current visibility of the IME is not well defined. Starting in Android S, this only has an effect if the calling app is the current IME focus.

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.

updateCursor

fun updateCursor(
    view: View!, 
    left: Int, 
    top: Int, 
    right: Int, 
    bottom: Int
): Unit

Deprecated: Use updateCursorAnchorInfo(View,CursorAnchorInfo) instead.

Report the current cursor location in its window.

updateCursorAnchorInfo

fun updateCursorAnchorInfo(
    view: View!, 
    cursorAnchorInfo: CursorAnchorInfo!
): Unit

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

viewClicked

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.