Ich muss eine Formulareingabevalidierung für eine Reihe von EditTexts durchführen. Ich verwende OnFocusChangeListeners, um die Validierung auszulösen, nachdem der Benutzer sie eingegeben hat, aber dies verhält sich für den letzten EditText nicht wie gewünscht.

Wenn ich während der Eingabe in den endgültigen EditText auf die Schaltfläche "Fertig" klicke, wird die Eingabemethode getrennt, aber der technische Fokus geht nie auf den EditText verloren (und daher erfolgt keine Validierung).

Was ist die beste Lösung?

Sollte ich überwachen, wann die InputMethod von jedem EditText getrennt wird, anstatt wenn sich der Fokus ändert? Wenn das so ist, wie?

Warum benutzt du nicht TextWatcher?

Da Sie eine Reihe von EditTextzu validierenden Feldern haben, denke ich, dass Folgendes zu Ihnen passen wird:

1. Ihre Aktivität implementiert die android.text.TextWatcherSchnittstelle
2. Sie fügen Ihren EditText-Feldern TextChanged-Listener hinzu

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

3. Von den überschriebenen Methoden können Sie die afterTextChanged(Editable s)Methode wie folgt verwenden

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

Das Editable shilft nicht wirklich herauszufinden, welcher Text des EditText-Felds geändert wird. Sie können aber direkt den Inhalt der EditText-Felder wie überprüfen

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

in der gleichen Methode. Ich hoffe ich bin klar und wenn ich es bin, hilft es! :) :)

EDIT: Für einen saubereren Ansatz beziehen Sie sich auf die Antwort von Christopher Perry unten.

TextWatcher ist für meinen Geschmack etwas ausführlich, daher habe ich etwas leichter zu schlucken gemacht:

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

Verwenden Sie es einfach so:

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

Wenn Sie bei einem Fehler nette Überprüfungs-Popups und Bilder wünschen, können Sie die hier beschriebene setErrorMethode der EditTextKlasse verwenden

Um die Ausführlichkeit der Validierungslogik zu verringern, habe ich eine Bibliothek für Android erstellt . Es kümmert sich um die meisten täglichen Validierungen mithilfe von Anmerkungen und integrierten Regeln. Es gibt Einschränkungen wie @TextRule, @NumberRule, @Required, @Regex, @Email, @IpAddress, @Password, usw.,

Sie können diese Anmerkungen zu Ihren UI-Widget-Referenzen hinzufügen und Überprüfungen durchführen. Außerdem können Sie Validierungen asynchron durchführen. Dies ist ideal für Situationen, in denen beispielsweise von einem Remoteserver nach einem eindeutigen Benutzernamen gesucht wird.

Auf der Projekthomepage finden Sie ein Beispiel für die Verwendung von Anmerkungen. Sie können auch den zugehörigen Blog-Beitrag lesen, in dem ich Beispielcodes zum Schreiben benutzerdefinierter Regeln für Validierungen geschrieben habe.

Hier ist ein einfaches Beispiel, das die Verwendung der Bibliothek zeigt.

@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;

Die Bibliothek ist erweiterbar. Sie können Ihre eigenen Regeln schreiben, indem Sie die RuleKlasse erweitern.

Dies war eine schöne Lösung von hier

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

Aktualisierter Ansatz - TextInputLayout:

Google hat kürzlich eine Design-Support-Bibliothek gestartet. Es gibt eine Komponente namens TextInputLayout , die das Anzeigen eines Fehlers über setErrorEnabled(boolean)und unterstützt setError(CharSequence).

Wie benutzt man es?

Schritt 1: Wickeln Sie Ihren EditText mit TextInputLayout ein:

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

Schritt 2: Überprüfen Sie die Eingabe

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

Ich habe ein Beispiel über mein Github-Repository erstellt . Schauen Sie sich das Beispiel an, wenn Sie möchten!

Ich habe eine Klasse geschrieben, die EditText erweitert, die nativ einige Validierungsmethoden unterstützt und tatsächlich sehr flexibel ist.

Während ich schreibe, werden aktuelle Methoden zur Validierung von XML-Attributen nativ unterstützt :

1. Alpha
2. alphanumerisch
3. numerisch
4. generischer regulärer Ausdruck
5. String Leere

Sie können es hier überprüfen

Hoffe es gefällt euch :)

Ich finde InputFilter besser geeignet, um Texteingaben auf Android zu validieren.

Hier ein einfaches Beispiel: Wie verwende ich InputFilter, um Zeichen in einem EditText in Android einzuschränken?

Sie können einen Toast hinzufügen, um den Benutzer über Ihre Einschränkungen zu informieren. Überprüfen Sie auch das android: inputType-Tag aus.

Ich musste eine Validierung innerhalb des Feldes und keine Validierung zwischen den Feldern durchführen, um zu testen, ob meine Werte in einem Fall vorzeichenlose Gleitkommawerte und in einem anderen Fall vorzeichenbehaftete Gleitkommawerte waren. Folgendes scheint für mich zu funktionieren:

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

Beachten Sie, dass in "numberSigned | numberDecimal" keine Leerzeichen stehen dürfen. Zum Beispiel: "numberSigned | numberDecimal" funktioniert nicht. Ich bin mir nicht sicher warum.

Das sieht sehr vielversprechend aus und genau das, was der Arzt für mich bestellt hat:

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

Benutzerdefinierte Validatoren sowie diese integrierten:

• regulärer Ausdruck : für benutzerdefinierten regulären Ausdruck
• numerisch : für ein nur numerisches Feld
• Alpha : Für ein Nur-Alpha-Feld
• alphaNumeric : weißt du was?
• personName : Überprüft, ob der eingegebene Text ein Vor- oder Nachname einer Person ist.
• personFullName : Überprüft, ob der eingegebene Wert ein vollständiger vollständiger Name ist.
• E-Mail : Überprüft, ob das Feld eine gültige E-Mail ist
• creditCard : Überprüft mithilfe des Luhn-Algorithmus , ob das Feld eine gültige Kreditkarte enthält
• Telefon : Überprüft, ob das Feld eine gültige Telefonnummer enthält
• Domänenname : Überprüft, ob das Feld einen gültigen Domänennamen enthält (besteht den Test immer in API-Stufe <8).
• ipAddress : Überprüft, ob das Feld eine gültige IP-Adresse enthält
• webUrl : Überprüft, ob das Feld eine gültige URL enthält (besteht den Test immer in API Level <8).
• Datum : Überprüft, ob das Feld ein gültiges Datums- / Datums- / Uhrzeitformat hat (wenn customFormat festgelegt ist, wird dies mit customFormat überprüft.)
• nocheck : Es prüft nichts außer der Leere des Feldes.

In der Datei main.xml

Sie können den folgenden Attribut setzen, um zu überprüfen, ob nur alphabetische Zeichen in edittext akzeptiert werden können.

Mach das :

  android:entries="abcdefghijklmnopqrstuvwxyz"

Sie können das gewünschte Verhalten erzielen, indem Sie zuhören, wenn der Benutzer auf der Tastatur auf die Schaltfläche "Fertig" klickt. Weitere Tipps zur Arbeit mit EditText finden Sie in meinem Beitrag "Android-Formularüberprüfung - der richtige Weg".

Beispielcode:

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

Versuchen Sie es mit einer E-Mail- und Passwortüberprüfung

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

Ich habe diese Bibliothek für Android erstellt, in der Sie ein Materialdesign EditText im Inneren und EditTextLayout einfach so überprüfen können:

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

dann können Sie es so verwenden:

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

Dann können Sie überprüfen, ob es so gültig ist:

    ageSmartEditText.check()

Weitere Beispiele und Anpassungen finden Sie im Repository unter https://github.com/TeleClinic/SmartEditText