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>
.
![entrada de telefone](https://developer.android.com/static/images/ui/edittext-phone.png?authuser=9&hl=pt)
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" />
![Tipo de entrada textPassword](https://developer.android.com/static/images/training/input/ime_password.png?authuser=9&hl=pt)
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
![correção automática](https://developer.android.com/static/images/training/input/ime_autocorrect.png?authuser=9&hl=pt)
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:
![botão "Enviar"](https://developer.android.com/static/images/ui/edittext-actionsend.png?authuser=9&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 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.
![sugestões de texto](https://developer.android.com/static/images/ui/edittext-autocomplete.png?authuser=9&hl=pt)
AutoCompleteTextView
com texto
sugestões.O procedimento a seguir descreve como configurar um AutoCompleteTextView
que
fornece sugestões de uma matriz usando
ArrayAdapter
:
- 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" />
- 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>
- Na sua
Activity
ouFragment
, 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 stringscountries_array
para umaTextView
que existe nasimple_list_item_1
. Esse é um layout fornecido pelo Android que oferece uma aparência padrão do texto em uma lista. -
Atribua o adaptador ao
AutoCompleteTextView
chamandosetAdapter()
.