Texttwatcher jest trochę gadatliwy jak na mój gust, więc zrobiłem coś łatwiejszego do przełknięcia:

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

Po prostu użyj go tak:

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

Jeśli chcesz ładne popupy walidacji i obrazy, gdy wystąpi błąd, możesz użyć setError metoda klasy EditText jak opisuję TUTAJ

W celu zmniejszenia szczegółowości logiki walidacji napisałem bibliotekę dla Androida . Obsługuje większość codziennych walidacji za pomocą adnotacji i wbudowanych reguł. Istnieją ograniczenia, takie jak @TextRule, @NumberRule, @Required, @Regex, @Email, @IpAddress, @Password, itd.,

Możesz dodać te adnotacje do odniesień do widgetów UI i przeprowadzić walidacje. Umożliwia również asynchronicznie Przeprowadzanie walidacji, co jest idealne w sytuacjach, takich jak sprawdzanie unikalna nazwa użytkownika z serwera zdalnego.

Na stronie głównej projektu znajduje się przykład użycia adnotacji. Możesz również przeczytać powiązany post na blogu , w którym napisałem przykładowe kody, jak pisać niestandardowe zasady walidacji.

Oto prosty przykład przedstawiający sposób korzystania z biblioteki.

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

Biblioteka jest rozszerzalna, możesz napisać własne reguły rozszerzając klasę Rule.

To było ładne rozwiązanie z Tutaj

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

Zaktualizowane podejście-TextInputLayout:

Google niedawno uruchomiło bibliotekę design support library i istnieje jeden komponent o nazwie TextInputLayout i obsługuje wyświetlanie błędu przez setErrorEnabled(boolean) i setError(CharSequence).

Jak go używać?

Krok 1: owiń swój EditText za pomocą 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>

Krok 2: zweryfikuj dane wejściowe

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

Stworzyłem przykład w moim repozytorium Github, sprawdź przykład, jeśli chcesz!

Uważam, że InputFilter jest bardziej odpowiedni do walidacji wejść tekstowych na Androida.

Oto prosty przykład: Jak używać InputFilter do ograniczania znaków w edytowanym tekście w Androidzie?

Możesz dodać Toast za opinię użytkownika o swoich ograniczeniach. Sprawdź również tag android: inputType.

Napisałem klasę, która rozszerza EditText, która natywnie obsługuje niektóre metody walidacji i jest bardzo elastyczna.

Aktualne, jak piszę, natywnie obsługiwane przez atrybuty xml metody walidacji to:

1. Alfa
2. alpha numeric
3. numeryczne
4. generic regexp
5. pustość strun

Możesz to sprawdzić tutaj

Mam nadzieję, że ci się spodoba:)

Musiałem przeprowadzić walidację wewnątrz pola, a nie między polami, aby sprawdzić, czy moje wartości były niepodpisanymi wartościami zmiennoprzecinkowymi w jednym przypadku, a podpisanymi wartościami zmiennoprzecinkowymi w innym. Oto, co wydaje mi się działać:

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

Uwaga, nie możesz mieć spacji w "numberSigned|numberDecimal". Na przykład: "numberSigned | numberDecimal" nie będzie działać. Nie wiem dlaczego.

To wygląda naprawdę obiecująco i dokładnie to, co lekarz zamówił dla mnie:

Walidator EditText

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

Walidatory niestandardowe plus te wbudowane:

• regexp : dla niestandardowych regexp
• numeric : tylko dla pola numerycznego
• alpha : dla pola tylko Alfa
• / Align = "left" /
• personName : sprawdza, czy wprowadzony tekst jest osobą pierwszą lub ostatnią nazwisko.
• personFullName : sprawdza, czy wprowadzona wartość jest pełną pełną nazwą.
• email : sprawdza, czy pole jest prawidłowym adresem e-mail
• creditCard : sprawdza, czy pole zawiera ważną kartę kredytową za pomocą algorytmu Luhna
• phone : sprawdza, czy pole zawiera prawidłowy numer telefonu
• domainName : sprawdza, czy pole zawiera poprawną nazwę domeny (zawsze przechodzi test na poziomie API
• ipAddress: sprawdza, czy pole zawiera poprawny adres ip
• webUrl : sprawdza, czy pole zawiera poprawny adres url (zawsze przechodzi test na poziomie API
• date : sprawdza, czy pole jest poprawnym formatem daty / datetime (jeśli ustawiony jest customFormat, sprawdza za pomocą customFormat)
• nocheck : nie sprawdza niczego poza pustością pola.

In main.plik xml

Możesz umieścić następujący attrubute, aby potwierdzić, że tylko znak alfabetyczny może być zaakceptowany w edittext.

Zrób to:

  android:entries="abcdefghijklmnopqrstuvwxyz"

Możesz uzyskać pożądane zachowanie, słuchając, gdy użytkownik naciśnie przycisk "Gotowe" na klawiaturze, a także sprawdź inne wskazówki dotyczące pracy z EditText w moim poście "Walidacja formularza Android-właściwy sposób"

Przykładowy kod:

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

Do weryfikacji adresu e-mail i hasła spróbuj

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

Stworzyłem tę bibliotekę dla Androida, w której możesz łatwo zweryfikować projekt materiału EditText inside I EditTextLayout w następujący sposób:

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

Wtedy możesz użyć go tak:

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

Następnie możesz sprawdzić, czy jest to ważne w następujący sposób:

    ageSmartEditText.check()

Aby uzyskać więcej przykładów i dostosować sprawdź repozytorium https://github.com/TeleClinic/SmartEditText