InputType — o que é, atributos de entrada e sua configuração no Android

O que é InputType no Android

InputType é uma constante inteira (Int) que codifica o modo de entrada para um campo de texto. No Android, é definida na classe android.text.InputType. O valor InputType consiste em duas partes: a classe de entrada (bits 0–4) e os modificadores (bits 5–31). A classe de entrada define o tipo de dados básico — texto, número, telefone, data. Os modificadores refinam o comportamento dentro da classe selecionada — por exemplo, para a classe de texto, você pode ativar a autocorreção, letras maiúsculas ou entrada multilinha.

O mecanismo InputType funciona em três níveis: no nível do framework Android, ele determina qual InputConnection será criado (a conexão entre EditText e IME); no nível do IME (teclado), ele especifica quais caracteres exibir e como lidar com a entrada; no nível do aplicativo, ele filtra os caracteres através do InputFilter integrado no EditText. De acordo com Android Source Code (AOSP, 2026), a máscara de bits é tratada no método TextView.getInputType(), que retorna o valor atual, e setInputType(), que reconfigura os filtros internos e a conexão com o IME.

Uma característica importante do InputType é que ele não pode ser lido de outro processo por razões de segurança. Isso evita o roubo de dados através do acesso ao tipo de entrada (por exemplo, determinar se um campo é uma senha). Ao tentar ler o InputType de outro aplicativo, TYPE_CLASS_TEXT é retornado por padrão.

// Constantes básicas do InputType
InputType.TYPE_CLASS_TEXT       // 0x0001 = 1
InputType.TYPE_CLASS_NUMBER     // 0x0002 = 2
InputType.TYPE_CLASS_PHONE      // 0x0003 = 3
InputType.TYPE_CLASS_DATETIME   // 0x0004 = 4

// Máscara para extrair a classe
InputType.TYPE_MASK_CLASS       // 0x0000000F

Classes de InputType: TEXT, NUMBER, PHONE, DATETIME

O Android define quatro classes básicas de InputType. Cada classe corresponde a uma categoria específica de dados e ativa o tipo de teclado correspondente. A classe é especificada nos bits 0–4 da máscara de bits e pode ser extraída através da máscara TYPE_MASK_CLASS (0x0F).

TYPE_CLASS_DATETIME raramente é usado diretamente — para entrada de data normalmente se usa DatePicker ou DatePickerDialog em vez de um campo de texto. No entanto, em alguns cenários (entrada manual rápida de data), esta classe pode ser útil. Ela não tem um teclado especializado e geralmente exibe um teclado numérico.

Cada classe de entrada pode ser combinada com variações — subtipos especificados nos bits 5–7. Por exemplo, TYPE_TEXT_VARIATION_PASSWORD (bit 5) adiciona entrada oculta à classe TEXT. Bits de variação: 0x000000E0 (máscara TYPE_MASK_VARIATION).

Flags modificadoras do InputType

As flags modificadoras do InputType (bits 8–31) adicionam capacidades adicionais à classe base. Elas não alteram o tipo de teclado, mas modificam o comportamento de entrada. As flags são específicas para cada classe — as flags de TEXT não funcionam com NUMBER, e vice-versa. Abaixo estão os principais modificadores para cada classe.

Flags para TEXT

• TYPE_TEXT_FLAG_CAP_CHARACTERS — todas as letras maiúsculas.
• TYPE_TEXT_FLAG_CAP_WORDS — cada palavra com inicial maiúscula.
• TYPE_TEXT_FLAG_CAP_SENTENCES — letra maiúscula no início de uma frase (padrão).
• TYPE_TEXT_FLAG_AUTO_CORRECT — correção automática de erros de digitação.
• TYPE_TEXT_FLAG_AUTO_COMPLETE — preenchimento automático (para AutoCompleteTextView).
• TYPE_TEXT_FLAG_MULTI_LINE — entrada multilinha.
• TYPE_TEXT_FLAG_NO_SUGGESTIONS — desativar sugestões.

Flags para NUMBER

• TYPE_NUMBER_FLAG_SIGNED — permite números negativos (sinal de menos).
• TYPE_NUMBER_FLAG_DECIMAL — permite ponto decimal.

De acordo com Android Developers Documentation (2026), as flags de diferentes classes não se sobrepõem — tentar usar uma flag de TEXT com NUMBER será ignorado. Para verificar uma flag definida, use AND bit a bit: (inputType and FLAG) != 0.

Combinações de InputType: exemplos para diferentes cenários

A combinação correta de classes e flags de InputType é a chave para criar formulários fáceis de usar. Vamos examinar cenários típicos e suas configurações de InputType correspondentes. Cada cenário otimiza a entrada para um tipo específico de dados, tornando o formulário intuitivo e acelerando o preenchimento.

// Combinação para campo de preço
editText.inputType = InputType.TYPE_CLASS_NUMBER or
    InputType.TYPE_NUMBER_FLAG_DECIMAL

// Combinação para campo de comentário
editText.inputType = InputType.TYPE_CLASS_TEXT or
    InputType.TYPE_TEXT_FLAG_CAP_SENTENCES or
    InputType.TYPE_TEXT_FLAG_MULTI_LINE

Trabalho programático com InputType

Definir InputType programaticamente via setInputType() sobrescreve o valor anterior. Se você precisar alterar apenas parte da máscara (por exemplo, adicionar uma flag), deve salvar o valor atual, modificá-lo e aplicá-lo novamente. Cada chamada a setInputType() reconfigura os filtros internos do EditText.

O método setRawInputType() difere do setInputType porque não aciona a reconfiguração de filtros e sugestões. É usado para alterar temporariamente o InputType sem recarregar completamente o estado do EditText. Após chamar setInputType(), é recomendado reiniciar o IME para atualizar o teclado.

Alternância de modos

// Alternar entre senha e texto visível
fun togglePasswordVisibility(editText: EditText) {
    val currentType = editText.inputType
    val isPassword = (currentType and
        InputType.TYPE_TEXT_VARIATION_PASSWORD) != 0

    editText.inputType = if (isPassword) {
        InputType.TYPE_CLASS_TEXT or
            InputType.TYPE_TEXT_VARIATION_VISIBLE_PASSWORD
    } else {
        InputType.TYPE_CLASS_TEXT or
            InputType.TYPE_TEXT_VARIATION_PASSWORD
    }

    // Manter posição do cursor
    val cursorPos = editText.selectionStart
    editText.setSelection(cursorPos)
}

Extração de classe e variação

// Obter classe de entrada
fun getInputClass(inputType: Int): Int {
    return inputType and InputType.TYPE_MASK_CLASS
}

// Obter variação de entrada
fun getInputVariation(inputType: Int): Int {
    return inputType and InputType.TYPE_MASK_VARIATION
}

// Verificar se é campo de senha
fun isPasswordField(editText: EditText): Boolean {
    return (editText.inputType and
        InputType.TYPE_TEXT_VARIATION_PASSWORD) != 0
}

Melhores práticas para escolher InputType

Escolher o InputType correto não é apenas uma questão de UX, mas também de segurança e correção dos dados. As principais recomendações incluem: especificar sempre um InputType explícito para cada EditText; usar a classe de entrada mais específica possível; não combinar flags de classes diferentes; usar variações PASSWORD para campos de dados sensíveis; usar imeOptions="actionSearch" para campos de pesquisa.

InputType também afeta a operação dos serviços de acessibilidade (Accessibility). Os campos com o tipo textPassword recebem proteção adicional dos leitores de tela — eles não leem os caracteres inseridos em voz alta. Para campos textEmailAddress, o leitor de tela informa ao usuário que o campo é destinado a email e fornece sugestões apropriadas.

• Explicitude — defina sempre o InputType explicitamente, não confie no valor padrão (textMultiLine).
• Especificidade — use o tipo mais específico: textEmailAddress, não text, para email.
• Segurança — para senhas, PIN e dados de cartão, use variações PASSWORD.
• Preenchimento automático — combine InputType com autofillHints para suportar gerenciadores de senhas.
• Testes — teste o comportamento em diferentes teclados (Gboard, SwiftKey, Samsung Keyboard).

De acordo com Material Design Guidelines (2025), o InputType deve corresponder ao tipo de dados que o usuário está inserindo. Um InputType incorreto não só retarda a entrada, mas também pode causar erros: por exemplo, se você deixar textMultiLine para um campo de número de telefone, o teclado não mostrará o teclado numérico e o usuário terá que alternar os layouts manualmente toda vez.