जवाबों:
मुझे यह दूसरे मंच पर मिला। चंवर की तरह काम करता है।
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++) {
if (!Character.isLetterOrDigit(source.charAt(i))) {
return "";
}
}
return null;
}
};
edit.setFilters(new InputFilter[] { filter });InputFilterएंड्रॉइड संस्करणों में थोड़े जटिल होते हैं जो शब्दकोश के सुझाव प्रदर्शित करते हैं। आपको कभी- SpannableStringBuilderकभी पैरामीटर Stringमें एक , कभी-कभी एक सादा मिलता है source।
निम्नलिखित InputFilterकाम करना चाहिए। इस कोड को बेहतर बनाने के लिए स्वतंत्र महसूस करें!
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();
}
}
}String replacement = source.subSequence(start, end).toString(); return replacement.replaceAll("[^A-Za-z0-9_\\-@]", "");
source instanceof SpannableStringBuilder प्रवेश करता है तो मुझे पिछले उत्तर की कोशिश करते समय एएबी देता है । सौभाग्य से मैं नीचे दिए गए @florian समाधान का उपयोग करके इसके चारों ओर काम करने में सक्षम था।
बहुत आसान:
<EditText
android:inputType="text"
android:digits="0,1,2,3,4,5,6,7,8,9,*,qwertzuiopasdfghjklyxcvbnm" />","बीच में देने की जरूरत नहीं है । आप कुछ इस तरह का उपयोग कर सकते हैं"0123456789qwertzuiopasdfghjklyxcvbnmQWERTZUIOPASDFGHJKLYXCVBNM"
imeOptions="actionNext", आदि
पोस्ट किए गए किसी भी उत्तर ने मेरे लिए काम नहीं किया। मैं अपने समाधान के साथ आया:
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 });EditTextपहले से ही अपने फ़िल्टर हो सकते हैं, जैसे लंबाई फ़िल्टर। इसलिए केवल फ़िल्टर को ओवरराइड करने के बजाय, आप अपने फ़िल्टर को पहले से मौजूद लोगों से जोड़ना चाहते हैं।
इस काम को 100% अपनी जरूरत और बहुत सरल प्रयोग करें।
<EditText
android:inputType="textFilter"
android:digits="@string/myAlphaNumeric" />तार में। xml
<string name="myAlphaNumeric">abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789</string>इनपुट प्रकार में विशेष वर्ण से बचने के लिए
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;
}
};आप नीचे की तरह अपने संपादित पाठ में फ़िल्टर सेट कर सकते हैं
edtText.setFilters(new InputFilter[] { filter });स्वीकृत उत्तर के अलावा, इसका उपयोग करना भी संभव है जैसे: केवल ऊपरी मामले के पात्रों (और संख्याओं) को स्वीकार करने के लिए android:inputType="textCapCharacters"एक विशेषता के रूप <EditText>में।
किसी कारण से android.text.LoginFilter क्लास का कंस्ट्रक्टर पैकेज-स्कॉप्ड है, इसलिए आप सीधे इसे विस्तारित नहीं कर सकते हैं (भले ही यह इस कोड के समान होगा)। लेकिन आप LoginFilter.UsernameFilterGeneric को बढ़ा सकते हैं! तब आपके पास बस यह है:
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;
}
}यह वास्तव में प्रलेखित नहीं है, लेकिन यह मूल काम का हिस्सा है, और स्रोत सीधा है । मैं इसे थोड़ी देर के लिए उपयोग कर रहा हूं, अब तक कोई समस्या नहीं है, हालांकि मैं मानता हूं कि मैंने कुछ जटिल स्पैनबल्स को शामिल करने की कोशिश नहीं की है।
यह सही है, एक्सएम लेआउट में इसे ठीक करने के लिए इसके बारे में जाने का सबसे अच्छा तरीका है:
<EditText
android:inputType="text"
android:digits="0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ" />जैसा कि फ्लोरियन फ्रॉलीच ने ठीक कहा है, यह पाठ विचारों के लिए भी अच्छा काम करता है।
<TextView
android:inputType="text"
android:digits="0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ" />सावधानी का एक शब्द है, android:digitsकेवल वर्णित पात्रों को प्रदर्शित किया जाएगा, इसलिए केवल पात्रों के किसी भी सेट को याद न करने के लिए सावधान रहें :)
inputTypeफ़िल्टरिंग को प्रभावित नहीं करता है।
इस सरल समाधान ने मेरे लिए तब काम किया जब मुझे उपयोगकर्ता को एक EditText में खाली तारों को दर्ज करने से रोकने की आवश्यकता थी। आप निश्चित रूप से अधिक वर्ण जोड़ सकते हैं:
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});
}यदि आप InputFilter को उप-वर्ग करते हैं तो आप अपना खुद का InputFilter बना सकते हैं जो किसी भी गैर-अल्फा-न्यूमेरिक वर्ण को फ़िल्टर करेगा।
InputFilter इंटरफ़ेस में एक विधि है, filter(CharSequence source, int start, int end, Spanned dest, int dstart, int dend) और यह आपको उन सभी जानकारी प्रदान करता है, जिनके बारे में आपको यह जानना होगा कि कौन से अक्षर EditText में दर्ज किए गए थे।
एक बार जब आप अपना खुद का InputFilter बना लेते हैं, तो आप इसे SetFilters (...) कहकर EditText को असाइन कर सकते हैं।
http://developer.android.com/reference/android/text/InputFilter.html#filter(java.lang.CharSequence , int, int, android.text.Spanned, int, int)
स्पैन के सामान को अनदेखा करना, जो अन्य लोगों के साथ निपटा है, शब्दकोश सुझावों को ठीक से संभालने के लिए मुझे निम्नलिखित कोड काम मिला।
सुझाव बढ़ने के साथ स्रोत बढ़ता है, इसलिए हमें यह देखना होगा कि कुछ भी वापस लौटने से पहले हमें कितने पात्रों की जगह लेनी होगी।
यदि हमारे पास कोई अमान्य वर्ण नहीं है, तो अशक्त लौटें ताकि डिफ़ॉल्ट प्रतिस्थापन हो।
अन्यथा हमें उस वैध अक्षर से बाहर निकालने की जरूरत है जो कि ACTUALLY को 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;
}
}; संपादन में शब्दों को रोकने के लिए। एक वर्ग बनाएँ जो यू कभी भी उपयोग कर सके।
public class Wordfilter implements InputFilter
{
@Override
public CharSequence filter(CharSequence source, int start, int end,Spanned dest, int dstart, int dend) {
// TODO Auto-generated method stub
boolean append = false;
String text = source.toString().substring(start, end);
StringBuilder str = new StringBuilder(dest.toString());
if(dstart == str.length())
{
append = true;
str.append(text);
}
else
str.replace(dstart, dend, text);
if(str.toString().contains("aaaaaaaaaaaa/*the word here*/aaaaaaaa"))
{
if(append==true)
return "";
else
return dest.subSequence(dstart, dend);
}
return null;
}
}पहले इसमें जोड़ें strings.xml:
<string name="vin_code_mask">0123456789abcdefghjklmnprstuvwxyz</string>XML :
android:digits="@string/vin_code_mask"कोटलिन में कोड :
edit_text.filters += InputFilter { source, start, end, _, _, _ ->
val mask = getString(R.string.vin_code_mask)
for (i in start until end) {
if (!mask.contains(source[i])) {
return@InputFilter ""
}
}
null
}अजीब है, लेकिन यह एमुलेटर के सॉफ्ट कीबोर्ड पर अजीब तरह से काम करता है।
चेतावनी! निम्न कोड सॉफ्टवेयर कीबोर्ड के लिए अंकों को छोड़कर सभी पत्रों और अन्य प्रतीकों को फ़िल्टर करेगा। स्मार्टफ़ोन पर केवल डिजिटल कीबोर्ड दिखाई देगा।
edit_text.keyListener = DigitsKeyListener.getInstance(context.getString(R.string.vin_code_mask))मैं भी आम तौर पर सेट maxLength, filters, inputType।
यह एक पुराना धागा है, लेकिन सभी समाधानों में समस्याएँ हैं (डिवाइस / एंड्रॉइड वर्जन / कीबोर्ड के आधार पर)।
अलग दृष्टिकोण
तो अंत में मैं बजाय का उपयोग करने का एक अलग दृष्टिकोण के साथ चला गया, InputFilterसमस्याग्रस्त कार्यान्वयन, मैं उपयोग कर रहा हूँ TextWatcherऔर TextChangedListenerके EditText।
पूर्ण कोड (उदाहरण)
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
public void onTextChanged(CharSequence s, int start, int before, int count) {
// Do Nothing
}
});कारण InputFilterएंड्रॉयड में एक अच्छा समाधान है, क्योंकि यह कुंजीपटल कार्यान्वयन पर निर्भर करता नहीं है। इनपुट पास होने से पहले कीबोर्ड इनपुट को फ़िल्टर किया जा रहा है EditText। लेकिन, क्योंकि कुछ कीबोर्ड में अलग-अलग कार्यान्वयन हैंInputFilter.filter() मंगलाचरण के , यह समस्याग्रस्त है।
दूसरी ओर TextWatcherकीबोर्ड कार्यान्वयन के बारे में परवाह नहीं है, यह हमें एक सरल समाधान बनाने की अनुमति देता है और सुनिश्चित करें कि यह सभी उपकरणों पर काम करेगा।
onTextChangedबस एक की जरूरत है public voidइसके बारे में में सामने।
मैंने इसे सरल बनाए रखने के लिए कुछ ऐसा किया है:
edit_text.filters = arrayOf(object : InputFilter {
override fun filter(
source: CharSequence?,
start: Int,
end: Int,
dest: Spanned?,
dstart: Int,
dend: Int
): CharSequence? {
return source?.subSequence(start, end)
?.replace(Regex("[^A-Za-z0-9 ]"), "")
}
})इस तरह हम स्रोत स्ट्रिंग के नए हिस्से में सभी अवांछित वर्णों को एक रिक्त स्ट्रिंग के साथ बदल रहे हैं।
edit_textचर रहा हैEditText वस्तु हम बात कर रहे हैं।
में कोड लिखा है kotlin।
इसका उपयोग संभव है setOnKeyListener। इस पद्धति में, हम इनपुट को अनुकूलित कर सकते हैं edittext!
इस तरह मैंने संपादित पाठ में नाम फ़ील्ड के लिए फ़िल्टर बनाया है। (पहला अक्षर CAPS है, और हर शब्द के बाद केवल एक ही स्थान की अनुमति दें।
public void setNameFilter() {
InputFilter filter = new InputFilter() {
@RequiresApi(api = Build.VERSION_CODES.KITKAT)
public CharSequence filter(CharSequence source, int start, int end,
Spanned dest, int dstart, int dend) {
for (int i = start; i < end; i++) {
if (dend == 0) {
if (Character.isSpaceChar(source.charAt(i)) ||
!Character.isAlphabetic(source.charAt(i))) {
return Constants.Delimiter.BLANK;
} else {
return String.valueOf(source.charAt(i)).toUpperCase();
}
} else if (Character.isSpaceChar(source.charAt(i)) &&
String.valueOf(dest).endsWith(Constants.Delimiter.ONE_SPACE)) {
return Constants.Delimiter.BLANK;
} else if ((!Character.isSpaceChar(source.charAt(i)) &&
!Character.isAlphabetic(source.charAt(i)))) {
return Constants.Delimiter.BLANK;
}
}
return null;
}
};
editText.setFilters(new InputFilter[]{filter, new InputFilter.LengthFilter(Constants.Length.NAME_LENGTH)});
}कोटलिन में मेरा एक ही जवाब है:
/**
* Returns the filter of the editText'es CharSequence value when [filterType] is:
* 1 -> letters; 2 -> letters and digits; 3 -> digits;
* 4 -> digits and dots
*/
class InputFilterAlphanumeric(private val filterType: Int): InputFilter {
override fun filter(source: CharSequence?, start: Int, end: Int, dest: Spanned?, dstart: Int, dend: Int): CharSequence {
(source as? SpannableStringBuilder)?.let {sourceAsSpannableBuilder ->
for (i in (end - 1) downTo start) {
val currentChar = source[i]
when(filterType) {
1 -> {
if (!currentChar.isLetter() && !currentChar.isWhitespace()) {
sourceAsSpannableBuilder.delete(i, i + 1)
}
}
2 -> {
if (!currentChar.isLetterOrDigit() && !currentChar.isWhitespace()) {
sourceAsSpannableBuilder.delete(i, i + 1)
}
}
3 -> {
if (!currentChar.isDigit()) {
sourceAsSpannableBuilder.delete(i, i + 1)
}
}
4 -> {
if (!currentChar.isDigit() || !currentChar.toString().contains(".")) {
sourceAsSpannableBuilder.delete(i, i + 1)
}
}
}
}
return source
} ?: run {
val filteredStringBuilder = StringBuilder()
for (i in start until end) {
val currentChar = source?.get(i)
when(filterType) {
1 -> {
if (currentChar?.isLetter()!! || currentChar.isWhitespace()) {
filteredStringBuilder.append(currentChar)
}
}
2 -> {
if (currentChar?.isLetterOrDigit()!! || currentChar.isWhitespace()) {
filteredStringBuilder.append(currentChar)
}
}
3 -> {
if (currentChar?.isDigit()!!) {
filteredStringBuilder.append(currentChar)
}
}
4 -> {
if (currentChar?.isDigit()!! || currentChar.toString().contains(".")) {
filteredStringBuilder.append(currentChar)
}
}
}
}
return filteredStringBuilder
}
}
}और एक्सटेंशन फ़ंक्शन के साथ कक्षा प्राप्त करें:
fun EditText.filterByDataType(filterType: Int) {
this.filters = arrayOf<InputFilter>(InputFilterAlphanumeric(filterType))
}