Android: Wie kann ich die EditText-Eingabe validieren?

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

Wenn ich auf die Schaltfläche “Fertig” klicke, während ich in den endgültigen EditText tippe, wird die InputMethod getrennt, aber technisch gesehen geht der Fokus nie auf den EditText verloren (und daher findet keine Validierung statt).

Was ist die beste Lösung?

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

Warum benutzt du nicht TextWatcher ?

Da hast du etliche EditText Boxen zu validieren, ich denke, das Folgende wird Ihnen passen:

1. Ihre Tätigkeit setzt um android.text.TextWatcher Schnittstelle
2. Sie fügen TextChanged-Listener zu Ihren EditText-Boxen hinzu

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

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

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

Die Editable s hilft nicht wirklich herauszufinden, in welchem ​​EditText-Feld der Text geändert wird. Aber Sie könnten den Inhalt der EditText-Boxen wie direkt überprüfen

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

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

BEARBEITEN: Für einen saubereren Ansatz lesen Sie 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 schöne Validierungs-Popups und Bilder wünschen, wenn ein Fehler auftritt, können Sie die verwenden setError Methode der EditText Klasse, wie ich es beschreibe Hier

Um die Ausführlichkeit der Validierungslogik zu reduzieren, habe ich a verfasst Bibliothek für Android. Es erledigt die meisten täglichen Validierungen mithilfe von Anmerkungen und integrierten Regeln. Es gibt Einschränkungen wie z @TextRule, @NumberRule, @Required, @Regex, @Email, @IpAddress, @Passwordetc.,

Sie können diese Anmerkungen zu Ihren UI-Widget-Referenzen hinzufügen und Validierungen durchführen. Es ermöglicht Ihnen auch, Validierungen asynchron durchzuführen, was ideal für Situationen ist, wie z. B. die Überprüfung auf eindeutige Benutzernamen von einem Remote-Server.

Es gibt ein Beispiel auf der Projekthomepage zur Verwendung von Anmerkungen. Sie können auch die lesen zugehörigen Blogbeitrag wo ich Beispielcodes zum Schreiben benutzerdefinierter Regeln für Validierungen geschrieben habe.

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

@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 erweitern Rule Klasse.

Aktualisierter Ansatz – TextInputLayout:

Google hat kürzlich eine Bibliothek zur Designunterstützung gestartet, und es gibt eine Komponente namens TextInputLayout und es unterstützt das Anzeigen eines Fehlers über setErrorEnabled(boolean) und setError(CharSequence).

Wie benutzt man es?

Schritt 1: Umschließen Sie Ihren EditText mit 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>

Schritt 2: Eingabe validieren

// 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 meine erstellt Github-Repositorysehen Sie sich das Beispiel an, wenn Sie möchten!

Das war eine nette 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}); 

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

Aktuell, während ich schreibe, nativ durch unterstützt xml-Attribute Validierungsmethoden sind:

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

Sie können es überprüfen Hier

Hoffe es gefällt euch 🙂