Devo eseguire la convalida dell'input del modulo su una serie di EditTexts. Sto usando OnFocusChangeListeners per attivare la convalida dopo che l'utente ha digitato in ognuno, ma questo non si comporta come desiderato per l'ultimo EditText.

Se clicco sul pulsante "Fine" durante la digitazione nell'EditText finale, l'InputMethod viene disconnesso, ma tecnicamente il focus non viene mai perso sull'EditText (e quindi la validazione non si verifica mai).

Qual è la soluzione migliore?

Dovrei monitorare quando InputMethod si separa da ogni EditText piuttosto che quando lo stato attivo cambia? Se é cosi, come?

Perché non usi TextWatcher?

Dal momento che hai un numero di EditTextcaselle da convalidare, penso che ti soddisferanno:

1. La tua attività implementa l' android.text.TextWatcherinterfaccia
2. Aggiungi listener TextChanged alle caselle Modifica testo

txt1.addTextChangedListener(this);
txt2.addTextChangedListener(this);
txt3.addTextChangedListener(this);

3. Dei metodi sostituiti, è possibile utilizzare il afterTextChanged(Editable s)metodo come segue

@Override
public void afterTextChanged(Editable s) {
    // validation code goes here
}

La Editable srealtà non aiutano a trovare quale testo di dialogo EditText viene modificato. Ma puoi controllare direttamente il contenuto delle caselle EditText come

String txt1String = txt1.getText().toString();
// Validate txt1String

nello stesso metodo. Spero di essere chiaro e se lo sono, aiuta! :)

EDIT: per un approccio più pulito fare riferimento alla risposta di Christopher Perry di seguito.

TextWatcher è un po 'prolisso per i miei gusti, quindi ho reso qualcosa di più facile da ingoiare:

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 */ }
}

Usalo in questo modo:

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

Se desideri visualizzare popup e immagini di convalida quando si verifica un errore, puoi utilizzare il setErrormetodo della EditTextclasse come descritto qui

Al fine di ridurre la verbosità della logica di validazione, ho creato una libreria per Android . Si occupa della maggior parte delle convalide quotidiane utilizzando Annotazioni e regole integrate. Ci sono vincoli, come @TextRule, @NumberRule, @Required, @Regex, @Email, @IpAddress, @Password, ecc,

È possibile aggiungere queste annotazioni ai riferimenti del widget dell'interfaccia utente ed eseguire convalide. Inoltre, consente di eseguire convalide in modo asincrono, il che è l'ideale per situazioni come la ricerca di un nome utente univoco da un server remoto.

C'è un esempio nella home page del progetto su come usare le annotazioni. Puoi anche leggere il post sul blog associato in cui ho scritto dei codici di esempio su come scrivere regole personalizzate per le convalide.

Ecco un semplice esempio che descrive l'utilizzo della libreria.

@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 libreria è estensibile, puoi scrivere le tue regole estendendo la Ruleclasse.

Questa è stata una bella soluzione da qui

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

Approccio aggiornato - TextInputLayout:

Google ha recentemente lanciato la libreria di supporto alla progettazione e esiste un componente chiamato TextInputLayout e supporta la visualizzazione di un errore tramite setErrorEnabled(boolean)e setError(CharSequence).

Come usarlo?

Passaggio 1: avvolgi il tuo EditText con 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>

Passaggio 2: convalida dell'input

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

Ho creato un esempio sul mio repository Github , controlla l'esempio se lo desideri!

Ho scritto una classe che estende EditText che supporta nativamente alcuni metodi di validazione ed è in realtà molto flessibile.

Attualmente, mentre scrivo, supportati nativamente attraverso i metodi di convalida degli attributi xml sono:

1. alfa
2. alfanumerico
3. numerico
4. regexp generico
5. vuoto della stringa

Puoi dare un'occhiata qui

Spero ti sia piaciuto :)

Trovo InputFilter più appropriato per convalidare input di testo su Android.

Ecco un semplice esempio: come posso usare InputFilter per limitare i caratteri in un EditText in Android?

È possibile aggiungere un brindisi per dare un feedback all'utente sulle restrizioni. Controlla anche il tag android: inputType.

Avevo bisogno di fare la validazione tra campi e non quella tra campi per verificare che i miei valori fossero valori in virgola mobile senza segno in un caso e valori in virgola mobile con segno in un altro. Ecco cosa sembra funzionare per me:

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

Nota, non devi avere spazi all'interno di "numberSigned | numberDecimal". Ad esempio: "numberSigned | numberDecimal" non funzionerà. Non sono sicuro del perché.

Questo sembra davvero promettente e proprio quello che il documento ha ordinato per me:

EditText Validator

    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.
    }
}

validatori personalizzati più questi integrati:

• regexp : per regexp personalizzato
• numerico : per un solo campo numerico
• alfa : per un campo solo alfa
• alphaNumeric : indovina un po '?
• personName : controlla se il testo inserito è una persona nome o cognome.
• personFullName : controlla se il valore inserito è un nome completo completo.
• e-mail : verifica che il campo sia un'e-mail valida
• creditCard : verifica che il campo contenga una carta di credito valida utilizzando Luhn Algorithm
• telefono : verifica che il campo contenga un numero di telefono valido
• domainName : controlla che il campo contenga un nome di dominio valido (supera sempre il test in API Level <8)
• ipAddress : verifica che il campo contenga un indirizzo IP valido
• webUrl : verifica che il campo contenga un URL valido (supera sempre il test nel Livello API <8)
• data : controlla che il campo sia un formato data / data valido (se è impostato customFormat, controlla con customFormat)
• nocheck : non controlla nulla tranne lo spazio vuoto del campo.

Nel file main.xml

È possibile inserire il seguente attrubute per convalidare solo caratteri alfabetici che possono essere accettati in edittext.

Fai questo :

  android:entries="abcdefghijklmnopqrstuvwxyz"

Puoi ottenere il comportamento desiderato ascoltando quando l'utente preme il pulsante "Fine" sulla tastiera, controlla anche altri suggerimenti su come lavorare con EditText nel mio post "Convalida del modulo Android - la strada giusta"

Codice di esempio:

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

per la convalida di e-mail e password provare

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

Ho creato questa libreria per Android in cui è possibile convalidare un design del materiale EditText all'interno e EditTextLayout facilmente in questo modo:

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

allora puoi usarlo in questo modo:

<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.*" />

Quindi puoi verificare se è valido in questo modo:

    ageSmartEditText.check()

Per ulteriori esempi e personalizzazioni consultare il repository https://github.com/TeleClinic/SmartEditText