InputType — ce que c'est, attributs de saisie et leur configuration dans Android

Qu'est-ce qu'InputType dans Android

InputType est une constante entière (Int) qui code le mode de saisie pour un champ de texte. Dans Android, elle est définie dans la classe android.text.InputType. La valeur InputType se compose de deux parties : la classe de saisie (bits 0–4) et les modificateurs (bits 5–31). La classe de saisie définit le type de données de base — texte, nombre, téléphone, date. Les modificateurs précisent le comportement au sein de la classe sélectionnée — par exemple, pour la classe texte, vous pouvez activer la correction automatique, les majuscules ou la saisie multiligne.

Le mécanisme InputType fonctionne à trois niveaux : au niveau du framework Android, il détermine quel InputConnection sera créé (la connexion entre EditText et IME) ; au niveau de l'IME (clavier), il spécifie quels caractères afficher et comment gérer la saisie ; au niveau de l'application, il filtre les caractères via l'InputFilter intégré dans EditText. Selon Android Source Code (AOSP, 2026), le masque de bits est traité dans la méthode TextView.getInputType(), qui retourne la valeur actuelle, et setInputType(), qui reconfigure les filtres internes et la connexion IME.

Une caractéristique importante d'InputType est qu'il ne peut pas être lu depuis un autre processus pour des raisons de sécurité. Cela empêche le vol de données via l'accès au type de saisie (par exemple, déterminer si un champ est un mot de passe). Lorsqu'on tente de lire InputType depuis une autre application, TYPE_CLASS_TEXT est retourné par défaut.

// Constantes InputType de base
InputType.TYPE_CLASS_TEXT       // 0x0001 = 1
InputType.TYPE_CLASS_NUMBER     // 0x0002 = 2
InputType.TYPE_CLASS_PHONE      // 0x0003 = 3
InputType.TYPE_CLASS_DATETIME   // 0x0004 = 4

// Masque pour extraire la classe
InputType.TYPE_MASK_CLASS       // 0x0000000F

Classes InputType : TEXT, NUMBER, PHONE, DATETIME

Android définit quatre classes de base InputType. Chaque classe correspond à une catégorie de données spécifique et active le type de clavier correspondant. La classe est spécifiée dans les bits 0–4 du masque de bits et peut être extraite via le masque TYPE_MASK_CLASS (0x0F).

TYPE_CLASS_DATETIME est rarement utilisé directement — pour la saisie de dates, on utilise généralement DatePicker ou DatePickerDialog plutôt qu'un champ de texte. Cependant, dans certains scénarios (saisie manuelle rapide de date), cette classe peut être utile. Elle n'a pas de clavier spécialisé et affiche généralement un clavier numérique.

Chaque classe de saisie peut être combinée avec des variations — des sous-types spécifiés dans les bits 5–7. Par exemple, TYPE_TEXT_VARIATION_PASSWORD (bit 5) ajoute une saisie masquée à la classe TEXT. Bits de variation : 0x000000E0 (masque TYPE_MASK_VARIATION).

Indicateurs modificateurs d'InputType

Les indicateurs modificateurs d'InputType (bits 8–31) ajoutent des capacités supplémentaires à la classe de base. Ils ne changent pas le type de clavier mais modifient le comportement de saisie. Les indicateurs sont spécifiques à chaque classe — les indicateurs TEXT ne fonctionnent pas avec NUMBER, et vice versa. Voici les principaux modificateurs pour chaque classe.

Indicateurs pour TEXT

• TYPE_TEXT_FLAG_CAP_CHARACTERS — toutes les lettres en majuscules.
• TYPE_TEXT_FLAG_CAP_WORDS — chaque mot commence par une majuscule.
• TYPE_TEXT_FLAG_CAP_SENTENCES — majuscule en début de phrase (par défaut).
• TYPE_TEXT_FLAG_AUTO_CORRECT — correction automatique des fautes de frappe.
• TYPE_TEXT_FLAG_AUTO_COMPLETE — saisie semi-automatique (pour AutoCompleteTextView).
• TYPE_TEXT_FLAG_MULTI_LINE — saisie multiligne.
• TYPE_TEXT_FLAG_NO_SUGGESTIONS — désactiver les suggestions.

Indicateurs pour NUMBER

• TYPE_NUMBER_FLAG_SIGNED — autorise les nombres négatifs (signe moins).
• TYPE_NUMBER_FLAG_DECIMAL — autorise le point décimal.

Selon Android Developers Documentation (2026), les indicateurs de différentes classes ne se chevauchent pas — essayer d'utiliser un indicateur TEXT avec NUMBER sera ignoré. Pour vérifier un indicateur défini, utilisez le ET binaire : (inputType and FLAG) != 0.

Combinaisons InputType : exemples pour différents scénarios

La bonne combinaison de classes et d'indicateurs InputType est la clé pour créer des formulaires conviviaux. Examinons des scénarios typiques et leurs configurations InputType correspondantes. Chaque scénario optimise la saisie pour un type de données spécifique, rendant le formulaire intuitif et accélérant son remplissage.

// Combinaison pour champ de prix
editText.inputType = InputType.TYPE_CLASS_NUMBER or
    InputType.TYPE_NUMBER_FLAG_DECIMAL

// Combinaison pour champ de commentaire
editText.inputType = InputType.TYPE_CLASS_TEXT or
    InputType.TYPE_TEXT_FLAG_CAP_SENTENCES or
    InputType.TYPE_TEXT_FLAG_MULTI_LINE

Travail programmatique avec InputType

Définir InputType programmatiquement via setInputType() écrase la valeur précédente. Si vous devez modifier seulement une partie du masque (par exemple, ajouter un indicateur), vous devez enregistrer la valeur actuelle, la modifier et la réappliquer. Chaque appel à setInputType() reconfigure les filtres internes d'EditText.

La méthode setRawInputType() diffère de setInputType en ce qu'elle ne déclenche pas la reconfiguration des filtres et des suggestions. Elle est utilisée pour modifier temporairement InputType sans recharger complètement l'état d'EditText. Après avoir appelé setInputType(), il est recommandé de redémarrer l'IME pour mettre à jour le clavier.

Changement de modes

// Basculer entre mot de passe et texte visible
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
    }

    // Conserver la position du curseur
    val cursorPos = editText.selectionStart
    editText.setSelection(cursorPos)
}

Extraction de classe et variation

// Obtenir la classe de saisie
fun getInputClass(inputType: Int): Int {
    return inputType and InputType.TYPE_MASK_CLASS
}

// Obtenir la variation de saisie
fun getInputVariation(inputType: Int): Int {
    return inputType and InputType.TYPE_MASK_VARIATION
}

// Vérifier si le champ est un mot de passe
fun isPasswordField(editText: EditText): Boolean {
    return (editText.inputType and
        InputType.TYPE_TEXT_VARIATION_PASSWORD) != 0
}

Bonnes pratiques pour choisir InputType

Choisir le bon InputType n'est pas seulement une question d'UX, mais aussi de sécurité et d'exactitude des données. Les principales recommandations incluent : toujours spécifier un InputType explicite pour chaque EditText ; utiliser la classe de saisie la plus spécifique possible ; ne pas combiner des indicateurs de différentes classes ; utiliser des variations PASSWORD pour les champs de données sensibles ; utiliser imeOptions="actionSearch" pour les champs de recherche.

InputType affecte également le fonctionnement des services d'accessibilité (Accessibility). Les champs de type textPassword bénéficient d'une protection supplémentaire des lecteurs d'écran — ils ne lisent pas les caractères saisis à voix haute. Pour les champs textEmailAddress, le lecteur d'écran informe l'utilisateur que le champ est destiné à l'email et fournit des suggestions appropriées.

• Explicite — définissez toujours InputType explicitement, ne vous fiez pas à la valeur par défaut (textMultiLine).
• Spécificité — utilisez le type le plus spécifique : textEmailAddress, pas text, pour l'email.
• Sécurité — pour les mots de passe, PIN et données de carte, utilisez les variations PASSWORD.
• Saisie automatique — combinez InputType avec autofillHints pour prendre en charge les gestionnaires de mots de passe.
• Tests — testez le comportement sur différents claviers (Gboard, SwiftKey, Samsung Keyboard).

Selon Material Design Guidelines (2025), InputType doit correspondre au type de données que l'utilisateur saisit. Un InputType incorrect non seulement ralentit la saisie, mais peut aussi entraîner des erreurs : par exemple, si vous laissez textMultiLine pour un champ de numéro de téléphone, le clavier n'affichera pas le pavé numérique et l'utilisateur devra changer manuellement de disposition à chaque fois.