Necesito hacer una validación de entrada de formulario en una serie de EditTexts. Estoy usando OnFocusChangeListeners para activar la validación después de que el usuario escriba en cada uno, pero esto no se comporta como se desea para el último EditText.

Si hago clic en el botón "Listo" mientras escribo en el EditText final, entonces InputMethod se desconecta, pero técnicamente nunca se pierde el foco en EditText (y, por lo tanto, la validación nunca ocurre).

¿Cuál es la mejor solución?

¿Debería estar monitoreando cuando InputMethod se desvincula de cada EditText en lugar de cuando cambia el foco? ¿Si es así, cómo?

¿Por qué no lo usas TextWatcher?

Dado que tiene una serie de EditTextcuadros para validar, creo que lo siguiente le conviene:

1. Su actividad implementa la android.text.TextWatcherinterfaz
2. Agregue oyentes TextChanged a sus cuadros EditText

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

3. De los métodos anulados, puede usar el afterTextChanged(Editable s)método de la siguiente manera

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

La Editable srealidad no ayuda para encontrar lo que se está cambiando el texto del cuadro de EditarTexto. Pero puede verificar directamente el contenido de los cuadros EditText como

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

En el mismo método. Espero estar claro y si lo estoy, ¡ayuda! :)

EDITAR: Para un enfoque más limpio, consulte la respuesta de Christopher Perry a continuación.

TextWatcher es un poco detallado para mi gusto, así que hice algo un poco más fácil de tragar:

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

Solo úsalo así:

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

Si desea ventanas emergentes e imágenes de validación agradables cuando ocurre un error, puede usar el setErrormétodo de la EditTextclase como describo aquí

Para reducir la verbosidad de la lógica de validación, he creado una biblioteca para Android . Se encarga de la mayoría de las validaciones diarias mediante anotaciones y reglas integradas. Hay limitaciones tales como @TextRule, @NumberRule, @Required, @Regex, @Email, @IpAddress, @Password, etc,

Puede agregar estas anotaciones a sus referencias de widget de IU y realizar validaciones. También le permite realizar validaciones de forma asíncrona, lo que es ideal para situaciones como la verificación de un nombre de usuario único desde un servidor remoto.

Hay un ejemplo en la página de inicio del proyecto sobre cómo usar las anotaciones. También puede leer la publicación de blog asociada donde he escrito códigos de muestra sobre cómo escribir reglas personalizadas para validaciones.

Aquí hay un ejemplo simple que muestra el uso de la biblioteca.

@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 biblioteca es extensible, puede escribir sus propias reglas extendiendo la Ruleclase.

Esta fue una buena solución desde aquí

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

Enfoque actualizado - TextInputLayout:

Google ha lanzado recientemente la biblioteca de soporte de diseño y hay un componente llamado TextInputLayout y admite mostrar un error a través de setErrorEnabled(boolean)y setError(CharSequence).

¿Cómo usarlo?

Paso 1: Envuelva su 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>

Paso 2: validar la entrada

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

He creado un ejemplo sobre mi repositorio de Github , ¡mira el ejemplo si lo deseas!

Escribí una clase que extiende EditText que admite de forma nativa algunos métodos de validación y que en realidad es muy flexible.

Actualmente, mientras escribo, los métodos de validación de atributos xml son nativamente compatibles :

1. alfa
2. alfanumérico
3. numérico
4. expresión genérica
5. vacío de la cuerda

Puedes verlo aquí

Espero que lo disfrutes :)

Creo que InputFilter es más apropiado para validar entradas de texto en Android.

Aquí hay un ejemplo simple: ¿Cómo uso InputFilter para limitar los caracteres en un EditText en Android?

Puede agregar un Brindis para informar al usuario sobre sus restricciones. También verifique la etiqueta android: inputType.

Necesitaba hacer validación intracampo y no validación intercampo para probar que mis valores eran valores de coma flotante sin signo en un caso y valores de punto flotante con signo en otro. Esto es lo que parece funcionar para mí:

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

Tenga en cuenta que no debe tener espacios dentro de "numberSigned | numberDecimal". Por ejemplo: "numberSigned | numberDecimal" no funcionará. No estoy seguro de por qué.

Esto parece muy prometedor y justo lo que el doctor me ordenó:

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

validadores personalizados más estos integrados en:

• regexp : para expresiones regulares personalizadas
• numérico : para un solo campo numérico
• alfa : para un campo solo alfa
• alphaNumeric : ¿adivina qué?
• personName : verifica si el texto ingresado es una persona nombre o apellido.
• personFullName : verifica si el valor ingresado es un nombre completo completo.
• correo electrónico : comprueba que el campo es un correo electrónico válido
• creditCard : verifica que el campo contenga una tarjeta de crédito válida usando el algoritmo de Luhn
• teléfono : comprueba que el campo contiene un número de teléfono válido
• domainName : comprueba que el campo contiene un nombre de dominio válido (siempre pasa la prueba en el nivel de API <8)
• ipAddress : verifica que el campo contenga una dirección IP válida
• webUrl : comprueba que el campo contiene una URL válida (siempre pasa la prueba en el nivel de API <8)
• fecha : verifica que el campo tenga un formato válido de fecha / fecha y hora (si se configura customFormat, verifica con customFormat)
• nocheck : No verifica nada excepto el vacío del campo.

En el archivo main.xml

Puede poner el siguiente atributo para validar que solo los caracteres alfabéticos pueden aceptar en edittext.

Hacer esto :

  android:entries="abcdefghijklmnopqrstuvwxyz"

Puede obtener el comportamiento deseado escuchando cuando el usuario presiona el botón "Listo" en el teclado, también consulte otros consejos sobre cómo trabajar con EditText en mi publicación "Validación de formulario de Android: la forma correcta"

Código de muestra:

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

para la validación de correo electrónico y contraseña intente

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

He creado esta biblioteca para Android donde puede validar un diseño de material EditText dentro y EditTextLayout fácilmente de esta manera:

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

entonces puedes usarlo así:

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

Luego puede verificar si es válido así:

    ageSmartEditText.check()

Para obtener más ejemplos y personalización, consulte el repositorio https://github.com/TeleClinic/SmartEditText