TextWatcher est un peu verbeux à mon goût, donc j'ai fait quelque chose un peu plus facile à avaler:

public abstract class TextValidator implements TextWatcher {
    private final TextView textView;

    public TextValidator(TextView textView) {
        this.textView = textView;
    }

    public abstract void validate(TextView textView, String text);

    @Override
    final public void afterTextChanged(Editable s) {
        String text = textView.getText().toString();
        validate(textView, text);
    }

    @Override
    final public void beforeTextChanged(CharSequence s, int start, int count, int after) { /* Don't care */ }

    @Override
    final public void onTextChanged(CharSequence s, int start, int before, int count) { /* Don't care */ }
}

il suffit de l'utiliser comme ceci:

editText.addTextChangedListener(new TextValidator(editText) {
    @Override public void validate(TextView textView, String text) {
       /* Validation code here */
    }
});

si vous voulez des popups et des images de validation de nice quand une erreur se produit, vous pouvez utiliser la setError méthode de la classe EditText comme je le décris ici

afin de réduire la verbosité de la logique de validation, j'ai écrit une" bibliothèque 1519100920 "pour Android . Il s'occupe de la plupart des validations quotidiennes à l'aide d'Annotations et de règles intégrées. Il y a des contraintes telles que: @TextRule , @NumberRule , @Required , @Regex , @Email , @IpAddress , @Password , etc.,

vous pouvez ajouter ces annotations à vos références de widget UI et effectuer des validations. Il permet également vous devez effectuer des validations asynchrones ce qui est idéal pour des situations telles que la vérification du nom d'utilisateur unique à partir d'un serveur distant.

il y a un exemple sur la page d'accueil du projet sur la façon d'utiliser les annotations. Vous pouvez également lire le post blog associé où j'ai écrit des exemples de codes sur la façon d'écrire des règles personnalisées pour les validations.

voici un exemple simple qui décrit l'usage de la bibliothèque.

@Required(order = 1)
@Email(order = 2)
private EditText emailEditText;

@Password(order = 3)
@TextRule(order = 4, minLength = 6, message = "Enter at least 6 characters.")
private EditText passwordEditText;

@ConfirmPassword(order = 5)
private EditText confirmPasswordEditText;

@Checked(order = 6, message = "You must agree to the terms.")
private CheckBox iAgreeCheckBox;

la Bibliothèque est extensible, vous pouvez écrire vos propres règles en étendant la classe Rule .

C'était une bonne solution de ici

InputFilter filter= new InputFilter() { 
    public CharSequence filter(CharSequence source, int start, int end, Spanned dest, int dstart, int dend) { 
        for (int i = start; i < end; i++) { 
            String checkMe = String.valueOf(source.charAt(i));

            Pattern pattern = Pattern.compile("[ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz123456789_]*");
            Matcher matcher = pattern.matcher(checkMe);
            boolean valid = matcher.matches();
            if(!valid){
                Log.d("", "invalid");
                return "";
            }
        } 
        return null; 
    } 
};

edit.setFilters(new InputFilter[]{filter}); 

mise à Jour de l'approche - TextInputLayout:

Google a récemment lancé la bibliothèque de soutien de conception et il ya un composant appelé TextInputLayout et il prend en charge l'affichage d'une erreur via setErrorEnabled(boolean) et setError(CharSequence) .

Comment l'utiliser?

Étape 1: enveloppez votre texte électronique avec TextInputLayout:

  <android.support.design.widget.TextInputLayout
    android:layout_width="match_parent"
    android:layout_height="wrap_content"
    android:id="@+id/layoutUserName">

    <EditText
      android:layout_width="match_parent"
      android:layout_height="wrap_content"
      android:hint="hint"
      android:id="@+id/editText1" />

  </android.support.design.widget.TextInputLayout>

Étape 2: Valider la saisie

// validating input on a button click
public void btnValidateInputClick(View view) {

    final TextInputLayout layoutUserName = (TextInputLayout) findViewById(R.id.layoutUserName);
    String strUsername = layoutLastName.getEditText().getText().toString();

    if(!TextUtils.isEmpty(strLastName)) {
        Snackbar.make(view, strUsername, Snackbar.LENGTH_SHORT).show();
        layoutUserName.setErrorEnabled(false);
    } else {
        layoutUserName.setError("Input required");
        layoutUserName.setErrorEnabled(true);
    }
}

j'ai créé un exemple sur mon dépôt Github , consultez l'exemple si vous le souhaitez!

je trouve InputFilter être plus approprié pour valider les saisies de texte sur android.

voici un exemple simple: comment utiliser InputFilter pour limiter les caractères dans un texte édité sur Android?

vous pouvez ajouter un Toast à la rétroaction de l'utilisateur sur vos restrictions. Vérifiez également la balise android:inputType.

j'ai écrit une classe qui étend EditText qui supporte nativement certaines méthodes de validation et est en fait très flexible.

en cours, comme je l'ai écrit, nativement pris en charge par attributs xml méthodes de validation sont:

1. alpha
2. alphanumérique
3. numérique
"151990920 génériques" regexp
4. chaîne emptyness

vous pouvez le vérifier ici

Espère qu'il vous plaira :)

j'avais besoin de faire une validation intra-champ et non pas une validation inter-champ pour tester que mes valeurs étaient des valeurs de virgule flottante non signées dans un cas et des valeurs de virgule flottante signées dans un autre. Voici ce qui semble fonctionner pour moi:

    <EditText
        android:id="@+id/x" 
        android:background="@android:drawable/editbox_background" 
        android:gravity="right" 
        android:inputType="numberSigned|numberDecimal" 
    />

Note, vous ne devez pas avoir d'espaces à l'intérieur de "numberSigned|numberDecimal". Par exemple:" numberSigned | numberDecimal " ne fonctionnera pas. Je ne sais pas pourquoi.

cela semble vraiment prometteur et juste ce que le doc a commandé pour moi:

EditText Validateur

    public void onClickNext(View v) {
    FormEditText[] allFields    = { etFirstname, etLastname, etAddress, etZipcode, etCity };


    boolean allValid = true;
    for (FormEditText field: allFields) {
        allValid = field.testValidity() && allValid;
    }

    if (allValid) {
        // YAY
    } else {
        // EditText are going to appear with an exclamation mark and an explicative message.
    }
}

validateurs sur mesure plus ceux construits dans:

• regexp : pour les regexp
• numérique : pour un seul champ numérique
• alpha : pour un alpha uniquement le champ
• alphanumérique : devinez quoi?
• nom : vérifie si le texte entré est un prénom ou un nom de famille.
• personFullName : vérifie si la valeur saisie est un nom complet.
• email : vérifie que le champ est un email valide
• carte de crédit : vérifie que le champ contient une carte de crédit valide en utilisant algorithme de Luhn
• téléphone : vérifie que le champ contient un numéro de téléphone valide
• nom de domaine : vérifie que le champ contient un nom de domaine valide (passe toujours le test au niveau API < 8 )
• ipAddress : vérifie que le champ contient adresse ip valide
• webUrl : vérifie que le champ contient une url valide (passe toujours le test au niveau API < 8 )
• date : vérifie que le champ est un format date/datetime valide (si customFormat est défini, vérifie avec customFormat )
• nocheck : Il ne vérifie rien, sauf le vide du champ.

.fichier xml

vous pouvez mettre l'attrubute suivant pour valider seulement le caractère alphabétique peut accepter dans edittext.

Faites ceci :

  android:entries="abcdefghijklmnopqrstuvwxyz"

vous pouvez obtenir le comportement désiré en écoutant lorsque l'utilisateur appuie sur" Fait "bouton sur le clavier, aussi vérifier d'autres conseils sur le travail avec EditText dans mon post "validation du formulaire Android-la bonne façon"

code échantillon:

mTextView.setOnEditorActionListener(new TextView.OnEditorActionListener() {
    @Override
    public boolean onEditorAction(TextView view, int actionId, KeyEvent event) {
        if (actionId == EditorInfo.IME_ACTION_DONE) {                    
            validateAndSubmit();
            return true;
        }
        return false;
    }});  

pour l'email et le mot de passe de validation essayer

  if (isValidEmail(et_regemail.getText().toString())&&etpass1.getText().toString().length()>7){
      if (validatePassword(etpass1.getText().toString())) {
      Toast.makeText(getApplicationContext(),"Go Ahead".....
      }
      else{

       Toast.makeText(getApplicationContext(),"InvalidPassword".....
       }

}else{

 Toast.makeText(getApplicationContext(),"Invalid Email".....
}


public boolean validatePassword(final String password){
    Pattern pattern;
    Matcher matcher;
    final String PASSWORD_PATTERN = "^(?=.*[0-9])(?=.*[A-Z])(?=.* 
    [@#$%^&+=!])(?=\S+$).{4,}$";
    pattern = Pattern.compile(PASSWORD_PATTERN);
    matcher = pattern.matcher(password);

    return matcher.matches();
}

public final static boolean isValidEmail(CharSequence target) {
    if (target == null)
        return false;

    return android.util.Patterns.EMAIL_ADDRESS.matcher(target).matches();
}

j'ai créé cette bibliothèque pour android où vous pouvez valider un design matériel EditText intérieur et EditTextLayout facilement comme ceci:

    compile 'com.github.TeleClinic:SmartEditText:0.1.0'

, alors vous pouvez l'utiliser comme ceci:

<com.teleclinic.kabdo.smartmaterialedittext.CustomViews.SmartEditText
    android:id="@+id/passwordSmartEditText"
    android:layout_width="match_parent"
    android:layout_height="wrap_content"
    app:setLabel="Password"
    app:setMandatoryErrorMsg="Mandatory field"
    app:setPasswordField="true"
    app:setRegexErrorMsg="Weak password"
    app:setRegexType="MEDIUM_PASSWORD_VALIDATION" />

<com.teleclinic.kabdo.smartmaterialedittext.CustomViews.SmartEditText
    android:id="@+id/ageSmartEditText"
    android:layout_width="match_parent"
    android:layout_height="wrap_content"
    app:setLabel="Age"
    app:setMandatoryErrorMsg="Mandatory field"
    app:setRegexErrorMsg="Is that really your age :D?"
    app:setRegexString=".*\d.*" />

alors vous pouvez vérifier si elle est valide comme ceci:

    ageSmartEditText.check()

pour plus d'exemples et de personnalisation, consultez le dépôt https://github.com/TeleClinic/SmartEditText