Android Inputmethod Latin

Android Inputmethod Latin

Platform

Android Studio

Google Play

Jetpack

Kotlin

Docs

Games

Overview

Guides

UI Guide

Reference

Samples

Design & Quality

Platform

Android Studio

Google Play

Jetpack

Kotlin

Docs

Overview

Guides

UI Guide

Reference

Samples

Design & Quality

Games

Work with window insets and cutouts

Work with advanced images and graphics

Learn how to use Open GL ES with graphics

Work with animations and transitions

Work with input method editors (IMEs)

Integrate Android search features into your app

Integrate content with home channels

Kotlin
override fun onCreateInputView(): View {
return layoutInflater.inflate(R.layout.input, null).apply {
if (this is MyKeyboardView) {
setOnKeyboardActionListener(this@MyInputMethod)
keyboard = latinKeyboard
}
}
}

Java
@Override
public View onCreateInputView() {
MyKeyboardView inputView =
(MyKeyboardView) getLayoutInflater().inflate(R.layout.input, null);

inputView.setOnKeyboardActionListener(this);
inputView.setKeyboard(latinKeyboard);

return inputView;
}

Kotlin
inputType and InputType.TYPE_MASK_CLASS

Java
inputType & InputType.TYPE_MASK_CLASS

Kotlin
currentInputConnection.also { ic: InputConnection ->
ic.deleteSurroundingText(4, 0)
ic.commitText("Hello", 1)
ic.commitText("!", 1)
}

Java
InputConnection ic = getCurrentInputConnection();
ic.deleteSurroundingText(4, 0);
ic.commitText("Hello", 1);
ic.commitText("!", 1);

Kotlin
currentInputConnection.also { ic: InputConnection ->
ic.setComposingText("Composi", 1)
ic.setComposingText("Composin", 1)
ic.commitText("Composing ", 1)
}

Java
InputConnection ic = getCurrentInputConnection();
ic.setComposingText("Composi", 1);
ic.setComposingText("Composin", 1);
ic.commitText("Composing ", 1);

Check out Android Developers on YouTube
Connect with the Android Developers community on LinkedIn

Android

Chrome

Firebase

Google Cloud Platform

All products

Privacy

License

Brand guidelines

Get news and tips by email

Subscribe

English

Bahasa Indonesia

Español – América Latina

Português – Brasil

中文 – 简体

日本語

한국어

An input method editor (IME) is a user control that enables users to enter text. Android
provides an extensible input-method framework that allows applications to provide users
alternative input methods, such as on-screen keyboards or even speech input. After installing
the desired IMEs, a user can select which one to use from the system settings, and use it
across the entire system; only one IME may be enabled at a time.

To add an IME to the Android system, you create an Android application
containing a class that extends InputMethodService . In
addition, you usually create a "settings" activity that passes options to the IME service. You
can also define a settings UI that's displayed as part of the system settings.

If you haven't worked with IMEs before, you should read the introductory article

Onscreen Input Methods first.

The following diagram describes the life cycle of an IME:

Figure 1. The life cycle of an IME.

The following sections describe how to implement the UI and code associated with an IME that
follows this lifecycle.

In the Android system, an IME is an Android application that contains a special IME service.
The application's manifest file must declare the service, request the necessary permissions,
provide an intent filter that matches the action action.view.InputMethod , and
provide metadata that defines characteristics of the IME. In addition, to provide a settings
interface that allows the user to modify the behavior of the IME, you can define a "settings"
activity that can be launched from System Settings.

The following snippet declares an IME service. It requests the permission
BIND_INPUT_METHOD to allow the service to connect the IME
to the system, sets up an intent filter that matches the action
android.view.InputMethod , and defines metadata for the IME:

This next snippet declares the settings activity for the IME. It has an intent filter for
ACTION_MAIN that indicates this activity is the main entry point
for the IME application:

You can also provide access to the IME's settings directly from its UI.

Classes specific to IMEs are found in the android.inputmethodservice and
android.view.inputmethod packages. The KeyEvent class is
important for handling keyboard characters.

The central part of an IME is a service component, a class that extends
InputMethodService . In addition to implementing the
normal service lifecycle, this class has callbacks for providing your IME's UI, handling user
input, and delivering text to the field that currently has focus. By default, the
InputMethodService class provides most of the implementation
for managing the state and visibility of the IME and communicating with the current input
field.

The following classes are also important:

There are two main visual elements for an IME: the input view and the
candidates view. You only have to implement the elements that are relevant to
the input method you're designing.

The input view is the UI where the user inputs text in the form of keyclicks, handwriting or
gestures. When the IME is displayed for the first time, the system calls the
onCreateInputView() callback. In your
implementation of this method, you create the layout you want to display in the IME
window and return the layout to the system. This snippet is an example of implementing the
onCreateInputView() method:

In this example, MyKeyboardView is an instance of a custom
implementation of
KeyboardView that renders a
Keyboard .

The candidates view is the UI where the IME displays potential word corrections or
suggestions for the user to select. In the IME lifecycle, the system calls
onCreateCandidatesView() when it's ready
to display the candidates view. In your implementation of this method, return a layout that
shows word suggestions, or return null if you don’t want to show anything. A null response is
the default behavior, so you don’t have to implement this if you don’t provide suggestions.

This section describes some specific UI design considerations for IMEs.

The UI for your IME must be able to scale for different screen sizes, and it also
must handle both landscape and portrait orientations. In non-fullscreen IME mode, leave
sufficient space for the application to show the text field and any associated context, so that
no more than half the screen is occupied by the IME. In fullscreen IME mode this is not an
issue.

Android text fields allow you to set a specific input type, such as free-form text, numbers,
URLs, email addresses, and search strings. When you implement a new IME, you need to detect
the input type of each field and provide the appropriate interface for it. However, you
don't have to set up your IME to check that the user entered valid text for the input type;
that's the responsibility of the application that owns the text field.

For example, here are screenshots of the interfaces that the Latin IME provided with the
Android platform provides for text and phone number inputs:

When an input field receives focus and your IME starts, the system calls
onStartInputView() ,
passing in an EditorInfo object that contains details about
the input type and other attributes of the text field. In this object, the
inputType field contains the text field's input
type.

The inputType field is an int
that contains bit patterns for various input type settings. To test it for the text field's
input type, mask it with the constant TYPE_MASK_CLASS , like
this:

The input type bit pattern can have one of several values, including:

These constants are described in more detail in the reference documentation for
InputType .

The inputType field can contain other bits that
indicate a variant of the text field type, such as:

Remember to mask inputType with the appropriate
constant when you test for these variants. The available mask constants are listed in the
reference documentation for InputType .

Caution: In your own IME, make sure you handle text correctly when you send it
to a password field. Hide the password in your UI both in the input view and in the candidates
view. Also remember that you shouldn't store passwords on a device. To learn more, see the
Designing for Security guide.

As the user inputs text with your IME, you can send text to the application by sending
individual key events or by editing the text around the cursor in the application's text
field. In either case, you use an instance of InputConnection
to deliver the text. To get this instance, call
InputMethodService.getCurrentInputConnection() .

When you're handling the editing of existing text in a text field, some of the more useful
methods in BaseInputConnection are:

For example, the following snippet shows how to replace the four characters to the left of the
cursor with the text "Hello!":

If your IME does text prediction or requires multiple steps to compose a glyph or
word, you can show the progress in the text field until the user commits the word, and then you
can replace the partial composition with the completed text. You may give special treatment to
the text by adding a "span" to it when you pass it to
setComposingText() .

The following snippet shows how to show progress in a text field:

The following screenshots show how this appears to the user:

Figure 3. Composing text before committing.

Even though the input method window doesn't have explicit focus, it receives hardware key
events first and can choose to consume them or forward them along to the application. For
example, you may want to consume the directional keys to navigate within your UI for candidate
selection during composition. You may also want to trap the back key to dismiss any popups
originating from the input method window.

To intercept hardware keys, override
onKeyDown()
and onKeyUp() .

Remember to call the super() method for keys you don't want to handle yourself.

Subtypes allow the IME to expose multiple input modes and languages supported by an IME. A
subtype can represent:

Basically, the mode can be any text such as "keyboard", "voice", and so forth. A subtype can
also expose a combination of these.

Subtype information is used for an IME switcher dialog that's available from the notification
bar and also for IME settings. The information also allows the framework to bring up a
specific subtype of an IME directly. When you build an IME, use the subtype facility, because
it helps the user identify and switch between different IME languages and modes.

You define subtypes in one of the input method's XML resource files, using the
element. The following snippet defines an IME with two
subtypes: a keyboard subtype for the US English locale, and another keyboard subtype for the
French language locale for France:

To ensure that your subtypes are labeled correctly in the UI, use %s to get a subtype label
that is the same as the subtype’s locale label. This is demonstrated in the next two snippets.
The first snippet shows part of the input method's XML file:

The next snippet is part of the IME's strings.xml file. The string
resource label_subtype_generic , which is used by the input method UI definition to
set the subtype's label, is defined as:

This setting causes the subtype’s display name to match the locale setting.
For example, in any English locale, the display name is “English (United States)”.

The Android system manages all subtypes exposed by all IMEs. IME subtypes are
treated as modes of the IME they belong to. In the notification bar, a user can select an
available subtype for the currently-set IME, as shown in the following screenshot:

Figure 4. Choosing an IME subtype from the notification
bar.

Figure 5. Setting subtype preferences in System Settings.

A user can control how subtypes are used in the “Language & input” settings panel in the
System Settings area.

Figure 6. Choosing a language for the IME.

You can allow users to switch easily among multiple IME subtypes by providing a switching key,
such as the globe-shaped language icon, as part of the keyboard. Doing so greatly improves the
keyboard's usability, and can help avoid user frustration.
To enable such switching, perform the following steps:

Caution: Prior to Android 5.0 (API level 21),
switchToNextInputMethod()
is not aware of the supportsSwitchingToNextInputMethod attribute. If the user switches
into an IME without a switching key, they may get stuck in that IME, unable to switch out of it easily.

Here are some other things to consider as you're implementing your IME:

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.

Sign up or log in to customize your list.

more stack exchange communities

company blog

Stack Overflow for Teams
– Start collaborating and sharing organizational knowledge.

Create a free Team
Why Teams?

Asked
11 years, 5 months ago

Modified
10 years, 4 months ago

747 1 1 gold badge 7 7 silver badges 18 18 bronze badges

Sorted by:

Reset to default

Highest score (default)

Trending (recent votes count more)

Date modified (newest first)

Date created (oldest first)

860 3 3 gold badges 13 13 silver bad
Free Porn Fisting Anal
High Heels Sounding
Hard Zoo Porn

Android Inputmethod Latin

Report Page