Comment puis-je utiliser InputFilter à la limite de caractères dans un EditText dans Android?

InputFilters sont un peu compliqué dans les versions d'Android qui affichent dictionnaire des suggestions. Vous obtenez parfois une SpannableStringBuilder, parfois une simple Chaîne de caractères dans la source paramètre.

Suivantes InputFilter devrait fonctionner. N'hésitez pas à améliorer ce code!

new InputFilter() {
    @Override
    public CharSequence filter(CharSequence source, int start, int end,
            Spanned dest, int dstart, int dend) {

        if (source instanceof SpannableStringBuilder) {
            SpannableStringBuilder sourceAsSpannableBuilder = (SpannableStringBuilder)source;
            for (int i = end - 1; i >= start; i--) { 
                char currentChar = source.charAt(i);
                 if (!Character.isLetterOrDigit(currentChar) && !Character.isSpaceChar(currentChar)) {    
                     sourceAsSpannableBuilder.delete(i, i+1);
                 }     
            }
            return source;
        } else {
            StringBuilder filteredStringBuilder = new StringBuilder();
            for (int i = start; i < end; i++) { 
                char currentChar = source.charAt(i);
                if (Character.isLetterOrDigit(currentChar) || Character.isSpaceChar(currentChar)) {    
                    filteredStringBuilder.append(currentChar);
                }     
            }
            return filteredStringBuilder.toString();
        }
    }
}

Aucune des réponses n'a fonctionné pour moi. Je suis venu avec mon propre solution:

InputFilter filter = new InputFilter() {
    @Override
    public CharSequence filter(CharSequence source, int start, int end, Spanned dest, int dstart, int dend) {
        boolean keepOriginal = true;
        StringBuilder sb = new StringBuilder(end - start);
        for (int i = start; i < end; i++) {
            char c = source.charAt(i);
            if (isCharAllowed(c)) //put your condition here
                sb.append(c);
            else
                keepOriginal = false;
        }
        if (keepOriginal)
            return null;
        else {
            if (source instanceof Spanned) {
                SpannableString sp = new SpannableString(sb);
                TextUtils.copySpansFrom((Spanned) source, start, sb.length(), null, sp, 0);
                return sp;
            } else {
                return sb;
            }           
        }
    }

    private boolean isCharAllowed(char c) {
        return Character.isLetterOrDigit(c) || Character.isSpaceChar(c);
    }
}
editText.setFilters(new InputFilter[] { filter });

Pour éviter les Caractères Spéciaux type d'entrée

public static InputFilter filter = new InputFilter() {
    @Override
    public CharSequence filter(CharSequence source, int start, int end, Spanned dest, int dstart, int dend) {
        String blockCharacterSet = "~#^|$%*!@/()-'\":;,?{}=!$^';,?×÷<>{}€£¥₩%~`¤♡♥_|《》¡¿°•○●
◇◆♧♣▲▼▶◀↑↓←→☆★
:-);-):-D:-(:'(:O 1234567890";
        if (source != null && blockCharacterSet.contains(("" + source))) {
            return "";
        }
        return null;
    }
};

Vous pouvez définir un filtre pour votre modifier le texte comme ci-dessous

edtText.setFilters(new InputFilter[] { filter });

Pour une raison quelconque, le android.texte.LoginFilter constructeur de la classe est paquet d'étendue, de sorte que vous ne pouvez pas directement l'étendre (même si elle serait identique à ce code). Mais vous pouvez l'étendre LoginFilter.UsernameFilterGeneric! Ensuite vous avez juste ceci:

class ABCFilter extends LoginFilter.UsernameFilterGeneric {
    public UsernameFilter() {
        super(false); //false prevents not-allowed characters from being appended
    }

    @Override
    public boolean isAllowed(char c) {
        if ('A' <= c && c <= 'C')
            return true;
        if ('a' <= c && c <= 'c')
            return true;

        return false;
    }
}

Ce n'est pas vraiment documenté, mais ça fait partie du noyau de la lib, et la la source est simple. Je l'ai utilisé pendant un certain temps maintenant, jusqu'ici pas de problèmes, mais je dois admettre que je n'ai pas essayé de faire quelque chose de complexe impliquant spannables.

Cette solution simple a fonctionné pour moi quand j'en avais besoin pour empêcher l'utilisateur d'entrer des chaînes vides dans un EditText. Vous pouvez bien sûr ajouter d'autres caractères:

InputFilter textFilter = new InputFilter() {

@Override

public CharSequence filter(CharSequence c, int arg1, int arg2,

    Spanned arg3, int arg4, int arg5) {

    StringBuilder sbText = new StringBuilder(c);

    String text = sbText.toString();

    if (text.contains(" ")) {    
        return "";   
    }    
    return c;   
    }   
};

private void setTextFilter(EditText editText) {

    editText.setFilters(new InputFilter[]{textFilter});

}

Ignorant la durée de choses que d'autres gens ont de traiter, de gérer correctement dictionnaire des suggestions, j'ai trouvé le code suivant fonctionne.

La source grandit à mesure que la suggestion grandit donc, nous avons à regarder combien de caractères il est en fait ce qui nous attend pour remplacer avant de retourner quoi que ce soit.

Si nous n'avons pas de caractères non valides, de retourner la valeur null de sorte que le défaut de remplacement se produit.

Sinon, nous avons besoin d'extraire les caractères valides à partir de la sous-chaîne qui va vraiment être placé dans l'EditText.

InputFilter filter = new InputFilter() { 
    public CharSequence filter(CharSequence source, int start, int end, 
    Spanned dest, int dstart, int dend) { 

        boolean includesInvalidCharacter = false;
        StringBuilder stringBuilder = new StringBuilder();

        int destLength = dend - dstart + 1;
        int adjustStart = source.length() - destLength;
        for(int i=start ; i<end ; i++) {
            char sourceChar = source.charAt(i);
            if(Character.isLetterOrDigit(sourceChar)) {
                if(i >= adjustStart)
                     stringBuilder.append(sourceChar);
            } else
                includesInvalidCharacter = true;
        }
        return includesInvalidCharacter ? stringBuilder : null;
    } 
}; 

C'est un vieux thread, mais le dessein de solutions ont toutes les questions (selon l'appareil /la version d'Android /Clavier).

APPROCHE DIFFÉRENTE

Donc finalement, je suis allé avec une approche différente, au lieu d'utiliser le InputFilter problématique de la mise en œuvre, je suis en utilisant TextWatcher et la TextChangedListener de la EditText.

CODE COMPLET (EXEMPLE)

editText.addTextChangedListener(new TextWatcher() {
@Override
public void afterTextChanged(Editable editable) {
super.afterTextChanged(editable);
String originalText = editable.toString();
int originalTextLength = originalText.length();
int currentSelection = editText.getSelectionStart();
//Create the filtered text
StringBuilder sb = new StringBuilder();
boolean hasChanged = false;
for (int i = 0; i < originalTextLength; i++) {
char currentChar = originalText.charAt(i);
if (isAllowed(currentChar)) {
sb.append(currentChar);
} else {
hasChanged = true;
if (currentSelection >= i) {
currentSelection--;
}
}
}
//If we filtered something, update the text and the cursor location
if (hasChanged) {
String newText = sb.toString();
editText.setText(newText);
editText.setSelection(currentSelection);
}
}
private boolean isAllowed(char c) {
//TODO: Add the filter logic here
return Character.isLetter(c) || Character.isSpaceChar(c);
}
@Override
public void beforeTextChanged(CharSequence s, int start, int count, int after) {
//Do Nothing
}
@Override
onTextChanged(CharSequence s, int start, int before, int count) {
//Do Nothing
}
});

La raison InputFilter n'est pas une bonne solution dans Android est car il dépend du clavier de mise en œuvre. La saisie au Clavier est filtré avant l'entrée est passée à la EditText. Mais, parce que certains claviers ont différentes implémentations pour la InputFilter.filter() invocation, c'est problématique.

D'autre part TextWatcher ne charge pas sur le clavier de mise en œuvre, il nous permet de créer une solution simple et être sûr que cela fonctionne sur tous les appareils.

si vous souhaitez inclure l'espace blanc dans votre entrée, puis ajouter de l'espace dans android:code à quatre chiffres, comme indiqué ci-dessus.

Il fonctionne très bien pour moi, même dans la version 4.0 d'android.

profiter 🙂