Especificar o tipo de método de entrada

Testar o Compose

O Jetpack Compose é o kit de ferramentas de interface recomendado para Android. Aprenda a usar o toque e a entrada no Compose.

TecladoOptions de texto →

Todo campo de texto espera um certo tipo de entrada de texto, como endereço de e-mail, número de telefone ou texto simples. É necessário especificar o tipo de entrada para cada campo de texto no app para que o sistema exiba o método de entrada flexível apropriado, como um teclado na tela.

Além dos tipos de botões disponíveis com um método de entrada, é possível especificar comportamentos, como se o método de entrada fornece sugestões de ortografia, coloca novas frases em maiúscula e substitui as botão de retorno de carro com um botão de ação, como Concluído ou Próximo. Nesta página, mostramos como para especificar essas características.

Especificar o tipo de teclado

Sempre declare o método de entrada para seus campos de texto adicionando o android:inputType ao atributo <EditText>.

Figura 1. O tipo de entrada phone.

Por exemplo, se você quiser um método de entrada para inserir um número de telefone, use o método Valor "phone":

<EditText
    android:id="@+id/phone"
    android:layout_width="fill_parent"
    android:layout_height="wrap_content"
    android:hint="@string/phone_hint"
    android:inputType="phone" />

Figura 2. O tipo de entrada textPassword.

Se o campo de texto for uma senha, use o valor "textPassword" para que o campo de texto oculta a entrada do usuário:

<EditText
    android:id="@+id/password"
    android:hint="@string/password_hint"
    android:inputType="textPassword"
    ... />

Há vários valores possíveis documentados com o atributo android:inputType, e você pode combinar alguns dos valores para especificar a aparência do método de entrada e outros o comportamento dos modelos.

Ativar sugestões de ortografia e outros comportamentos

Figura 3. A adição de textAutoCorrect possibilita a correção automática de erros ortográficos.

O atributo android:inputType permite especificar vários comportamentos para a entrada . Mais importante ainda, se o campo de texto for destinado a entrada de texto básica, como para um mensagem de texto: ative a correção ortográfica automática com "textAutoCorrect" .

É possível combinar diferentes comportamentos e estilos de método de entrada com o android:inputType. Por exemplo, veja como criar um campo de texto que coloca em maiúscula a primeira palavra de uma frase e também corrige automaticamente os erros ortográficos:

<EditText
    android:id="@+id/message"
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    android:inputType=
        "textCapSentences|textAutoCorrect"
    ... />

Especificar a ação do método de entrada

A maioria dos métodos de entrada simples tem um botão de ação do usuário no canto inferior apropriado para o campo de texto atual. Por padrão, o sistema usa esse botão para Próxima ou Concluído, a menos que seu campo de texto seja compatível com texto de várias linhas, como em android:inputType="textMultiLine": nesse caso, o botão de ação é um carro. voltar. No entanto, você pode especificar outras ações que podem ser mais apropriadas para o seu campo de texto, como Enviar ou Ir.

Para especificar o botão de ação do teclado, use o android:imeOptions com um valor de ação como "actionSend" ou "actionSearch". Por exemplo:

Figura 4. O botão Enviar aparece quando você declara android:imeOptions="actionSend".

<EditText
    android:id="@+id/search"
    android:layout_width="fill_parent"
    android:layout_height="wrap_content"
    android:hint="@string/search_hint"
    android:inputType="text"
    android:imeOptions="actionSend" />

Você pode ouvir pressionamentos no botão de ação definindo um TextView.OnEditorActionListener para o elemento EditText. Em seu ouvinte, responda ao ID de ação do IME apropriado definido no Classe EditorInfo, como IME_ACTION_SEND, conforme mostrado neste exemplo:

Kotlin

findViewById<EditText>(R.id.search).setOnEditorActionListener { v, actionId, event ->
    return@setOnEditorActionListener when (actionId) {
        EditorInfo.IME_ACTION_SEND -> {
            sendMessage()
            true
        }
        else -> false
    }
}

Java

EditText editText = (EditText) findViewById(R.id.search);
editText.setOnEditorActionListener(new OnEditorActionListener() {
    @Override
    public boolean onEditorAction(TextView v, int actionId, KeyEvent event) {
        boolean handled = false;
        if (actionId == EditorInfo.IME_ACTION_SEND) {
            sendMessage();
            handled = true;
        }
        return handled;
    }
});

Oferecer sugestões de preenchimento automático

Se você deseja fornecer sugestões aos usuários enquanto eles digitam, você pode usar uma subclasse de EditText ligou AutoCompleteTextView. Para implementar o preenchimento automático, você deve especificar um Adapter que fornece o texto sugestões. Há diversos adaptadores disponíveis, dependendo da origem dos dados, como em um banco de dados ou em uma matriz.

Figura 5. Exemplo de AutoCompleteTextView com texto sugestões.

O procedimento a seguir descreve como configurar um AutoCompleteTextView que fornece sugestões de uma matriz usando ArrayAdapter:

1. Adicione o AutoCompleteTextView ao layout. Aqui está um layout com apenas o texto campo:

   <?xml version="1.0" encoding="utf-8"?>
   <AutoCompleteTextView xmlns:android="http://schemas.android.com/apk/res/android"
       android:id="@+id/autocomplete_country"
       android:layout_width="fill_parent"
       android:layout_height="wrap_content" />
   

2. Defina a matriz que contém todas as sugestões de texto. Por exemplo, aqui está uma matriz de nomes de países:

   <?xml version="1.0" encoding="utf-8"?>
   <resources>
       <string-array name="countries_array">
           <item>Afghanistan</item>
           <item>Albania</item>
           <item>Algeria</item>
           <item>American Samoa</item>
           <item>Andorra</item>
           <item>Angola</item>
           <item>Anguilla</item>
           <item>Antarctica</item>
           ...
       </string-array>
   </resources>
   

3. Na sua Activity ou Fragment, use o seguinte código para especifique o adaptador que fornece as sugestões:

   Kotlin

   // Get a reference to the AutoCompleteTextView in the layout.
   val textView = findViewById(R.id.autocomplete_country) as AutoCompleteTextView
   // Get the string array.
   val countries: Array<out String> = resources.getStringArray(R.array.countries_array)
   // Create the adapter and set it to the AutoCompleteTextView.
   ArrayAdapter<String>(this, android.R.layout.simple_list_item_1, countries).also { adapter ->
       textView.setAdapter(adapter)
   }
   

   Java

   // Get a reference to the AutoCompleteTextView in the layout.
   AutoCompleteTextView textView = (AutoCompleteTextView) findViewById(R.id.autocomplete_country);
   // Get the string array.
   String[] countries = getResources().getStringArray(R.array.countries_array);
   // Create the adapter and set it to the AutoCompleteTextView.
   ArrayAdapter<String> adapter =
           new ArrayAdapter<String>(this, android.R.layout.simple_list_item_1, countries);
   textView.setAdapter(adapter);
   

   No exemplo anterior, um novo ArrayAdapter é inicializado para vincular cada item da matriz de strings countries_array para uma TextView que existe na simple_list_item_1. Esse é um layout fornecido pelo Android que oferece uma aparência padrão do texto em uma lista.

4. Atribua o adaptador ao AutoCompleteTextView chamando setAdapter().