Cada campo de texto espera um determinado tipo de entrada, 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 mostre o método de entrada simples adequado, como um teclado na tela.
Além dos tipos de botões disponíveis em um método de entrada, é possível especificar comportamentos, por exemplo, se o método de entrada oferece sugestões de ortografia, colocar novas frases com letra maiúscula e substituir o botão de retorno de carro por um de ação, como Concluído ou Próximo. Nesta página, mostramos como especificar essas características.
Especificar o tipo de teclado
Sempre declare o método de entrada para seus campos de texto adicionando o atributo
android:inputType
ao
elemento <EditText>
.
![entrada de telefone](https://developer.android.google.cn/static/images/ui/edittext-phone.png?authuser=7&hl=pt)
phone
.Por exemplo, se você quiser um método de entrada para inserir um número de telefone, use o
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" />
![Tipo de entrada textPassword](https://developer.android.google.cn/static/images/training/input/ime_password.png?authuser=7&hl=pt)
textPassword
.Se o campo de texto for uma senha, use o valor "textPassword"
para que
o campo oculte 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 é possível combinar alguns deles para especificar a aparência do método de entrada e outros
comportamentos.
Ativar sugestões de ortografia e outros comportamentos
![correção automática](https://developer.android.google.cn/static/images/training/input/ime_autocorrect.png?authuser=7&hl=pt)
textAutoCorrect
possibilita a correção automática de
erros de ortografia.O atributo android:inputType
permite especificar vários comportamentos para o método de
entrada. Se o campo for destinado a entradas de texto básicas, por exemplo, para uma
mensagem de texto, ative a correção automática de ortografia com o valor
"textAutoCorrect"
.
É possível combinar diferentes comportamentos e estilos de método de entrada com o
atributo 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 erros de ortografia:
<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 fornece um botão de ação do usuário no canto inferior adequado para
o campo de texto atual. Por padrão, o sistema usa esse botão para uma ação Next ou
Done, a menos que seu campo seja compatível com texto com várias linhas, como em
android:inputType="textMultiLine"
. Nesse caso, o botão de ação é um retorno
de carro. No entanto, é possível especificar outras ações que podem ser mais apropriadas para o campo de texto, como Enviar ou Ir.
Para especificar o botão de ação do teclado, use o atributo
android:imeOptions
com um valor de ação como "actionSend"
ou "actionSearch"
. Por
exemplo:
![botão "Enviar"](https://developer.android.google.cn/static/images/ui/edittext-actionsend.png?authuser=7&hl=pt)
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 detectar pressionamentos no botão de ação definindo um
TextView.OnEditorActionListener
para o elemento EditText
. No
listener, responda ao ID de ação do IME apropriado definido na
classe EditorInfo
,
como
IME_ACTION_SEND
,
conforme mostrado no exemplo abaixo:
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
Para oferecer sugestões aos usuários enquanto eles digitam, use uma subclasse de
EditText
chamada
AutoCompleteTextView
.
Para implementar o preenchimento automático, especifique um
Adapter
que forneça as sugestões
de texto. Há vários adaptadores disponíveis, dependendo da origem dos dados, como
um banco de dados ou uma matriz.
![sugestões de texto](https://developer.android.google.cn/static/images/ui/edittext-autocomplete.png?authuser=7&hl=pt)
AutoCompleteTextView
com sugestões de texto.O procedimento a seguir descreve como configurar um AutoCompleteTextView
que
forneça sugestões de uma matriz usando
ArrayAdapter
:
- Adicione o
AutoCompleteTextView
ao layout. Confira um layout com apenas o campo de texto:<?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" />
- Defina a matriz que contém todas as sugestões de texto. Por exemplo, esta é 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>
- Na
Activity
ouFragment
, use o código abaixo para especificar 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 na matriz de stringscountries_array
a umTextView
que existe no layoutsimple_list_item_1
. Esse é um layout fornecido pelo Android que fornece uma aparência padrão para o texto em uma lista. -
Atribua o adaptador ao
AutoCompleteTextView
chamandosetAdapter()
.