IT. Expert System.

Android Reference

InputMethodManager


android.view.inputmethod

Class InputMethodManager



  • public final class InputMethodManager
    extends Object
    Central system API to the overall input method framework (IMF) architecture, which arbitrates interaction between applications and the current input method. You can retrieve an instance of this interface with Context.getSystemService().

    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 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 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 View.onCreateInputConnection(android.view.inputmethod.EditorInfo) 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 Service, typically deriving from InputMethodService. It must provide the core InputMethod interface, though this is normally handled by InputMethodService and implementors will only need to deal with the higher-level API there.

    See the 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 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.

    • Method Detail

      • getInstance

        public static InputMethodManager getInstance(Context context)
        Retrieve the global InputMethodManager instance, creating it if it doesn't already exist.
      • getInstance

        public static InputMethodManager getInstance(Looper mainLooper)
        Internally, the input method manager can't be context-dependent, so we have this here for the places that need it.
      • peekInstance

        public static InputMethodManager peekInstance()
        Private optimization: retrieve the global InputMethodManager instance, if it exists.
      • getClient

        public IInputMethodClient getClient()
      • getInputContext

        public IInputContext getInputContext()
      • getEnabledInputMethodSubtypeList

        public List<InputMethodSubtype> getEnabledInputMethodSubtypeList(InputMethodInfo imi,
                                                                boolean allowsImplicitlySelectedSubtypes)
        Returns a list of enabled input method subtypes for the specified input method info.
        Parameters:
        imi - An input method info whose subtypes list will be returned.
        allowsImplicitlySelectedSubtypes - 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.
      • showStatusIcon

        public void showStatusIcon(IBinder imeToken,
                          String packageName,
                          int iconId)
      • hideStatusIcon

        public void hideStatusIcon(IBinder imeToken)
      • setImeWindowStatus

        public void setImeWindowStatus(IBinder imeToken,
                              int vis,
                              int backDisposition)
      • setFullscreenMode

        public void setFullscreenMode(boolean fullScreen)
      • registerSuggestionSpansForNotification

        public void registerSuggestionSpansForNotification(SuggestionSpan[] spans)
      • notifySuggestionPicked

        public void notifySuggestionPicked(SuggestionSpan span,
                                  String originalString,
                                  int index)
      • isFullscreenMode

        public boolean isFullscreenMode()
        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.
      • isActive

        public boolean isActive(View view)
        Return true if the given view is the currently active view for the input method.
      • isActive

        public boolean isActive()
        Return true if any view is currently active in the input method.
      • isAcceptingText

        public boolean isAcceptingText()
        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.
      • reportFinishInputConnection

        public void reportFinishInputConnection(InputConnection ic)
        Called from the FINISH_INPUT_CONNECTION message above.
      • displayCompletions

        public void displayCompletions(View view,
                              CompletionInfo[] completions)
      • updateExtractedText

        public void updateExtractedText(View view,
                               int token,
                               ExtractedText text)
      • showSoftInput

        public boolean showSoftInput(View view,
                            int flags)
        Synonym for showSoftInput(View, int, 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 - The currently focused view, which would like to receive soft keyboard input.
        flags - Provides additional operating flags. Currently may be 0 or have the SHOW_IMPLICIT bit set.
      • showSoftInput

        public boolean showSoftInput(View view,
                            int flags,
                            ResultReceiver resultReceiver)
        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.
        Parameters:
        view - The currently focused view, which would like to receive soft keyboard input.
        flags - Provides additional operating flags. Currently may be 0 or have the SHOW_IMPLICIT bit set.
        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.
      • showSoftInputUnchecked

        public void showSoftInputUnchecked(int flags,
                                  ResultReceiver resultReceiver)
      • hideSoftInputFromWindow

        public boolean hideSoftInputFromWindow(IBinder windowToken,
                                      int flags)
        Synonym for hideSoftInputFromWindow(IBinder, int, ResultReceiver) without a result: request to hide the soft input window from the context of the window that is currently accepting input.
        Parameters:
        windowToken - The token of the window that is making the request, as returned by View.getWindowToken().
        flags - Provides additional operating flags. Currently may be 0 or have the HIDE_IMPLICIT_ONLY bit set.
      • hideSoftInputFromWindow

        public boolean hideSoftInputFromWindow(IBinder windowToken,
                                      int flags,
                                      ResultReceiver resultReceiver)
        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.
        Parameters:
        windowToken - The token of the window that is making the request, as returned by View.getWindowToken().
        flags - Provides additional operating flags. Currently may be 0 or have the HIDE_IMPLICIT_ONLY bit set.
        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.
      • toggleSoftInputFromWindow

        public void toggleSoftInputFromWindow(IBinder windowToken,
                                     int showFlags,
                                     int hideFlags)
        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 - The token of the window that is making the request, as returned by View.getWindowToken().
        showFlags - Provides additional operating flags. May be 0 or have the SHOW_IMPLICIT, SHOW_FORCED bit set.
        hideFlags - Provides additional operating flags. May be 0 or have the HIDE_IMPLICIT_ONLY, HIDE_NOT_ALWAYS bit set.
      • toggleSoftInput

        public void toggleSoftInput(int showFlags,
                           int hideFlags)
      • restartInput

        public void restartInput(View view)
        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 - The view whose text has changed.
      • windowDismissed

        public void windowDismissed(IBinder appWindowToken)
        When the focused window is dismissed, this method is called to finish the input method started before.
      • focusIn

        public void focusIn(View view)
        Call this when a view receives focus.
      • focusOut

        public void focusOut(View view)
        Call this when a view loses focus.
      • checkFocus

        public void checkFocus()
      • onWindowFocus

        public void onWindowFocus(View rootView,
                         View focusedView,
                         int softInputMode,
                         boolean first,
                         int windowFlags)
        Called by ViewAncestor when its window gets input focus.
      • startGettingWindowFocus

        public void startGettingWindowFocus(View rootView)
      • updateSelection

        public void updateSelection(View view,
                           int selStart,
                           int selEnd,
                           int candidatesStart,
                           int candidatesEnd)
        Report the current selection range.
      • viewClicked

        public void viewClicked(View view)
        Notify the event when the user tapped or clicked the text view.
      • isWatchingCursor

        public boolean isWatchingCursor(View view)
        Returns true if the current input method wants to watch the location of the input editor's cursor in its window.
      • updateCursor

        public void updateCursor(View view,
                        int left,
                        int top,
                        int right,
                        int bottom)
        Report the current cursor location in its window.
      • sendAppPrivateCommand

        public void sendAppPrivateCommand(View view,
                                 String action,
                                 Bundle data)
        Call InputMethodSession.appPrivateCommand() on the current Input Method.
        Parameters:
        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 - 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 - Any data to include with the command.
      • setInputMethod

        public void setInputMethod(IBinder token,
                          String id)
        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.
        Parameters:
        token - Supplies the identifying token given to an input method when it was started, which allows it to perform this operation on itself.
        id - The unique identifier for the new input method to be switched to.
      • setInputMethodAndSubtype

        public void setInputMethodAndSubtype(IBinder token,
                                    String id,
                                    InputMethodSubtype subtype)
        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.
        Parameters:
        token - Supplies the identifying token given to an input method when it was started, which allows it to perform this operation on itself.
        id - The unique identifier for the new input method to be switched to.
        subtype - The new subtype of the new input method to be switched to.
      • hideSoftInputFromInputMethod

        public void hideSoftInputFromInputMethod(IBinder token,
                                        int flags)
        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 - Supplies the identifying token given to an input method when it was started, which allows it to perform this operation on itself.
        flags - Provides additional operating flags. Currently may be 0 or have the HIDE_IMPLICIT_ONLY, HIDE_NOT_ALWAYS bit set.
      • showSoftInputFromInputMethod

        public void showSoftInputFromInputMethod(IBinder token,
                                        int flags)
        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 - Supplies the identifying token given to an input method when it was started, which allows it to perform this operation on itself.
        flags - Provides additional operating flags. Currently may be 0 or have the SHOW_IMPLICIT or SHOW_FORCED bit set.
      • showInputMethodPicker

        public void showInputMethodPicker()
      • showInputMethodAndSubtypeEnabler

        public void showInputMethodAndSubtypeEnabler(String imiId)
        Show the settings for enabling subtypes of the specified input method.
        Parameters:
        imiId - An input method, whose subtypes settings will be shown. If imiId is null, subtypes of all input methods will be shown.
      • getCurrentInputMethodSubtype

        public InputMethodSubtype getCurrentInputMethodSubtype()
        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.
      • setCurrentInputMethodSubtype

        public boolean setCurrentInputMethodSubtype(InputMethodSubtype subtype)
        Switch to a new input method subtype of the current input method.
        Parameters:
        subtype - A new input method subtype to switch.
        Returns:
        true if the current subtype was successfully switched. When the specified subtype is null, this method returns false.
      • switchToLastInputMethod

        public boolean switchToLastInputMethod(IBinder imeToken)
        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 - Supplies the identifying token given to an input method when it was started, which allows it to perform this operation on itself.
        Returns:
        true if the current input method and subtype was successfully switched to the last used input method and subtype.
      • switchToNextInputMethod

        public boolean switchToNextInputMethod(IBinder imeToken,
                                      boolean onlyCurrentIme)
        Force switch to the next input method and subtype. If there is no IME enabled except current IME and subtype, do nothing.
        Parameters:
        imeToken - Supplies the identifying token given to an input method when it was started, which allows it to perform this operation on itself.
        onlyCurrentIme - if true, the framework will find the next subtype which belongs to the current IME
        Returns:
        true if the current input method and subtype was successfully switched to the next input method and subtype.
      • setAdditionalInputMethodSubtypes

        public void setAdditionalInputMethodSubtypes(String imiId,
                                            InputMethodSubtype[] subtypes)
        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.)
        Parameters:
        imiId - Id of InputMethodInfo which additional input method subtypes will be added to.
        subtypes - subtypes will be added as additional subtypes of the current input method.


Content

Android Reference

Java basics

Java Enterprise Edition (EE)

Java Standard Edition (SE)

SQL

HTML

PHP

CSS

Java Script

MYSQL

JQUERY

VBS

REGEX

C

C++

C#

Design patterns

RFC (standard status)

RFC (proposed standard status)

RFC (draft standard status)

RFC (informational status)

RFC (experimental status)

RFC (best current practice status)

RFC (historic status)

RFC (unknown status)

IT dictionary

License.
All information of this service is derived from the free sources and is provided solely in the form of quotations. This service provides information and interfaces solely for the familiarization (not ownership) and under the "as is" condition.
Copyright 2016 © ELTASK.COM. All rights reserved.
Site is optimized for mobile devices.
Downloads: 230 / 158726281. Delta: 0.05265 с