Android: Comment puis-je valider EditText d'entrée?

TextWatcher est un peu verbeux à mon goût, alors j'ai fait quelque chose d'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 */ }
}

Simplement l'utiliser comme ceci:

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

Afin de réduire le niveau de détail de la logique de validation, j'ai écrit un bibliothèque pour Android. Il prend soin de la plupart de la journée à jour des validations à l'aide d'Annotations et de règles prédéfinies. Il y a des contraintes telles que @TextRule, @NumberRule, @Required, @Regex, @Email, @IpAddress, @Password, etc.,

Vous pouvez ajouter des annotations à votre INTERFACE utilisateur widget de références et d'effectuer des validations. Il vous permet également d'effectuer des validations de manière asynchrone, ce qui est idéal pour les situations telles que la vérification de nom d'utilisateur unique à partir d'un serveur distant.

Il y a un exemple sur le page d'accueil du projet sur la façon d'utiliser les annotations. Vous pouvez également lire les associé post de blog 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 illustre l'utilisation 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 évolutif, vous pouvez écrire vos propres règles par l'extension de la Rule classe.

Approche mise à jour - TextInputLayout:

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

Comment l'utiliser?

Étape 1: Enveloppez vos EditText 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>

Etape 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 Github, la caisse de l'exemple, si vous le désirez!

J'ai écrit une classe qui étend la classe EditText qui prend en charge nativement certaines méthodes de validation et est très flexible.

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

1. alpha
2. alpha numérique
3. numérique
4. générique regexp
5. chaîne vide

Vous pouvez le vérifier ici

Espère qu'il vous plaira 🙂

Cela a l'air vraiment prometteur et juste ce que le doc a ordonné 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.
    }
}

les validateurs personnalisés et de ces construit en:

• regexp: pour les regexp
• numérique: pour un seul champ numérique
• alpha: pour une alpha seul champ
• alphanumérique: devinez quoi?
• personName: vérifie si le texte entré est une personne, le prénom ou le nom.
• personFullName: vérifie si la valeur saisie est un nom complet.
• e-mail: vérifie que le champ est une adresse email valide
• carte de crédit: vérifie que le champ contient une carte de crédit valide à l'aide de L'Algorithme De Luhn
• téléphone: vérifie que le champ contient un numéro de téléphone valide
• domainName: vérifie que le champ contient un nom de domaine valide ( toujours passe le test de l'API de Niveau < 8 )
• ipAddress: vérifie que le champ contient une adresse ip valide
• webUrl: vérifie que le champ contient une url valide ( toujours passe le test de l'API de Niveau < 8 )
• date: vérifie que le champ est une date valide/format datetime ( si customFormat est définie, vérifie avec customFormat )
• nocheck: Il ne vérifie rien, sauf le vide du champ.

Vous pouvez obtenir le comportement désiré par l'écoute lorsque l'utilisateur appuyez sur "Terminé" bouton sur le clavier, aussi regarder d'autres conseils sur le travail avec les EditText dans mon post "Android formulaire de validation de la bonne façon"

Exemple de code:

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;
    }});  

J'ai créé cette bibliothèque pour android où vous pouvez valider une conception de matériel EditText l'intérieur et à l'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.*" />

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

    ageSmartEditText.check()

Pour plus d'exemples et de personnalisation de vérifier le référentiel
https://github.com/TeleClinic/SmartEditText