texto - textview android studio español

Android: ¿Cómo puedo validar la entrada de EditText?

Question

Necesito hacer una validación de entrada en una serie de EditTexts. Estoy usando OnFocusChangeListeners para activar la validación después de que el usuario escribe 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 EditText final, entonces InputMethod se desconecta, pero técnicamente el enfoque nunca se pierde en EditText (y por eso la validación nunca ocurre).

¿Cuál es la mejor solución?

¿Debo monitorear cuando InputMethod se desvincula de cada EditText en lugar de cuando cambia el foco? ¿Si es así, cómo?

Answer 1

Esto parece realmente prometedor y justo lo que el doc ordenó para mí:

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:

• regexp : para expresiones regulares personalizadas
• numérico : para un único campo numérico
• alpha : para un campo solo alfa
• alphaNumeric : ¿adivina qué?
• personName : comprueba si el texto ingresado es el nombre o apellido de una persona.
• personFullName : verifica si el valor ingresado es un nombre completo completo.
• correo electrónico : comprueba que el campo sea un correo electrónico válido
• CreditCard : comprueba que el campo contiene una tarjeta de crédito válida utilizando el algoritmo Luhn
• teléfono : verifica que el campo contenga un número de teléfono válido
• domainName : comprueba que el campo contenga un nombre de dominio válido (siempre pasa la prueba en el nivel API <8)
• ipAddress : comprueba 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 : comprueba que el campo sea un formato válido de fecha / hora (si se establece el formato personalizado, se comprueba con el formato personalizado)
• nocheck : no comprueba nada excepto el vacío del campo.

Answer 2

Enfoque actualizado - TextInputLayout:

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

¿Cómo usarlo?

Paso 1: ajuste 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 , ¡revisa el ejemplo si lo deseas!

Answer 3

Con el fin de 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 usando Anotaciones y reglas incorporadas. Existen restricciones como @TextRule , @NumberRule , @Required , @Regex , @Email , @IpAddress , @Password , etc.,

Puede agregar estas anotaciones a las referencias de su widget de UI y realizar validaciones. También le permite realizar validaciones de forma asíncrona, lo que es ideal para situaciones como la búsqueda 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 representa 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 clase Rule .

Answer 4

En archivo main.xml

Puede poner el siguiente attrubute para validar solo las alphabatics que el personaje puede aceptar en edittext.

Hacer esto :

  android:entries="abcdefghijklmnopqrstuvwxyz"

Answer 5

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

Aquí hay un ejemplo simple: here

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

Answer 6

Escribí una clase que amplía EditText que admite nativamente algunos métodos de validación y que en realidad es muy flexible.

Actualmente, mientras escribo, los métodos de validación de los atributos xml soportados de forma nativa son:

1. alfa
2. alfanumérico
3. numérico
4. expresiones regulares genéricas
5. vacío de cadena

Puedes verlo here

Espero que lo disfrutes :)

Answer 7

Esta fue una buena solución de here

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

Answer 8

He creado esta biblioteca para Android, donde puedes validar un diseño de material EditText dentro y EditTextLayout fácilmente así:

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

Entonces puedes verificar si es válido así:

    ageSmartEditText.check()

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

Answer 9

Necesitaba hacer la validación dentro del campo y no la validación entre campos para probar que mis valores eran valores de punto flotante sin signo en un caso y valores de coma flotante firmados 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 haber espacios dentro de "numberSigned | numberDecimal". Por ejemplo: "numberSigned | numberDecimal" no funcionará. No estoy seguro por qué.

Answer 10

Puede obtener el comportamiento deseado al escuchar cuando el usuario presiona el botón "Listo" en el teclado, también puede consultar otros consejos sobre cómo trabajar con EditText en mi publicación "Validación de formulario de Android: el camino correcto"

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

Answer 11

Si quieres buenas ventanas emergentes e imágenes de validación cuando ocurre un error, puedes usar el método setError de la clase EditText como describo here

Answer 12

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

Answer 13

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

Answer 14

¿Por qué no usas TextWatcher ?

Dado que tiene una cantidad de cuadros EditText para validar, creo que lo siguiente le conviene:

1. Tu actividad implementa la interfaz android.text.TextWatcher
2. Se le agregan oyentes TextChanged EditText boxes

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

3. De los métodos reemplazados, puede usar el afterTextChanged(Editable s) siguiente manera

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

El Editable s realmente no ayuda a encontrar qué texto de la caja EditText se está cambiando. Pero puede verificar directamente el contenido de los cuadros EditText como

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

en el mismo método. Espero ser claro y si lo soy, ¡ayuda! :)

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