Android: मैं EditText इनपुट को कैसे मान्य कर सकता हूं?

Question

मुझे EditTexts की एक श्रृंखला पर इनपुट इनपुट सत्यापन करने की आवश्यकता है। मैं प्रत्येक प्रकार में उपयोगकर्ता प्रकारों के बाद सत्यापन को चालू करने के लिए OnFocusChangeListeners का उपयोग कर रहा हूं, लेकिन यह अंतिम EditText के लिए वांछित व्यवहार नहीं करता है।

अगर मैं अंतिम EditText में टाइप करते समय "Done" बटन पर क्लिक करता हूं तो InputMethod डिस्कनेक्ट हो जाता है, लेकिन EditText पर तकनीकी रूप से फ़ोकस कभी नहीं खोता है (और इसलिए सत्यापन कभी भी नहीं होता है)।

सबसे अच्छा उपाय क्या है?

क्या मुझे ध्यान देना चाहिए कि कब इनपुटमेथोड फोकस बदलने के बजाय प्रत्येक EditText से निकलता है? यदि हां, तो कैसे?

Comments

क्या वास्तव में उपयोगकर्ता टाइप कर रहा है उसी समय EditText इनपुट को मान्य करने की आवश्यकता है? उपयोगकर्ता द्वारा Done बटन पर क्लिक करने के बाद आप केवल EditText को मान्य क्यों नहीं करते?

— क्रिस्टियन

ठीक यही मैं चाहता हूं: पाठ को सत्यापित करने के लिए जब उपयोगकर्ता Done बटन पर क्लिक करता है (Done बटन से मेरा मतलब है QWERTY InputManager पर "Done" बटन ... फ़ॉर्म का सबमिट बटन नहीं)। सिवाय इसके कि जब मैंने डन बटन को हिट किया, तो फॉर्म में अंतिम तत्व पर ध्यान केंद्रित करता है, और मेरी सत्यापन विधि कभी ट्रिगर नहीं होती है। आशा है कि मेरा शब्द स्पष्ट है ...

— स्टीफन

@ क्रिस्चियन का समाधान वही है जो मैं देख रहा था और यहाँ पाया जाता है: stackoverflow.com/questions/43013812/…

— लैम्पपोस्ट

@ क्रिश्चियन थोड़ा देर से आ रहा है, लेकिन मैं एक ऐसे समाधान की तलाश कर रहा हूं, जहां व्यक्ति टाइप कर रहा हो, एडिट टेक्स्ट मान्य हो । मेरे पास एक लॉगिन / रजिस्टर फॉर्म है और मैं केवल "सबमिट" बटन दिखाना चाहता हूं जब फॉर्म डेटा मान्य है।

— Zonker.in.Geneva

Answer 1

आप उपयोग क्यों नहीं करते TextWatcher?

चूंकि आपके पास EditTextमान्य होने के लिए कई बॉक्स हैं, मुझे लगता है कि निम्नलिखित आपके लिए उपयुक्त होंगे:

1. आपकी गतिविधि android.text.TextWatcherइंटरफ़ेस को लागू करती है
2. आप EditText बॉक्स में TextChanged श्रोताओं को जोड़ते हैं

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

3. ओवरराइड विधियों में से, आप afterTextChanged(Editable s)निम्नानुसार विधि का उपयोग कर सकते हैं

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

Editable sवास्तव में जो EditText बॉक्स का पाठ बदला जा रहा है खोजने के लिए मदद नहीं करता है। लेकिन आप सीधे EditText बॉक्स की सामग्री की तरह देख सकते हैं

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

उसी विधि में। मुझे आशा है कि मैं स्पष्ट हूं और अगर मैं हूं, तो यह मदद करता है! :)

EDIT: एक क्लीनर दृष्टिकोण के लिए नीचे क्रिस्टोफर पेरी के जवाब को देखें।

Comments

यह वैसा ही दिखता है जैसा मुझे चाहिए। TextWatcher (SDK / API के लिए नया) के बारे में नहीं सुना था, लेकिन मैं इसका परीक्षण करूंगा और यह देखूंगा कि यह मेरे सोचने के तरीके का व्यवहार करता है या नहीं। जानकारी के लिए धन्यवाद!

— स्टीफन

आपका स्वागत है! :) अब जब आप इसे मान्य कर रहे हैं, तो क्या आप साझा कर सकते हैं कि आप सत्यापन विफलता के उपयोगकर्ता को कैसे सूचित करेंगे? मैं वर्तमान में उसी के लिए सर्वोत्तम तरीकों की तलाश कर रहा हूं।

— Niks

निखिल पाटिल, मैं सिर्फ टोस्ट का उपयोग करता हूं ताकि उपयोगकर्ता को पता चल सके कि उन्होंने कुछ गलत किया है। क्या कोई कारण है कि आपके मामले में प्रभावी नहीं होगा?

— येवगेनी सिम्किन

बेशक, टोस्ट Android पर एक प्राकृतिक तरीका है। लेकिन जब हमारे पास स्क्रीन पर काफी मात्रा में ऐसे तत्व होते हैं, जिन्हें सत्यापन की आवश्यकता होती है, तो टोस्ट सही विकल्प नहीं लगता है। (IMHO, यह उपयोगकर्ता को नाराज करेगा) मैं TextView.setError () ( developer.android.com

— निक्स

यद्यपि TextWatcher पर खराब समर्थन है, यह काम करता है ... थोड़े!

— टिवी

Answer 2

TextWatcher मेरे स्वाद के लिए एक बिट क्रिया है, इसलिए मैंने कुछ निगलने में आसान बना दिया है:

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

बस इसे इस तरह उपयोग करें:

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

Comments

@fremmedehenvendelser: हर EditTextIS-एकTextView

— Niks

अमूर्त वर्ग का जबरदस्त अमूर्तता और उपयोग

— साहेर अहवाल

@fullmeriffic शायद आपने अपने EditText को प्रारंभ नहीं किया था। सुनिश्चित करें कि आप addTextChangedListenerअपने एडिटटेक्स्ट को दृश्य से हल करने के बाद कॉल कर रहे हैं

— घोस्टली

@StephaneEybert यह एक अनाम वर्ग है

— क्रिस्टोफर पेरी

व्यवहार में इंटरफ़ेस अलगाव सिद्धांत

— Maciej Beimcik

Answer 3

यदि आप कोई त्रुटि होने पर अच्छा सत्यापन पॉपअप और चित्र चाहते हैं, तो आप कक्षा की setErrorविधि का उपयोग कर सकते हैं EditTextजैसा कि मैं यहां बताता हूं

Comments

दो EditTexts तक पहुंचने के लिए आपको टेक्स्टवॉचर कैसे मिलेगा ? मैंने सफलतापूर्वक अपने लिए एक TextWatcher जोड़ा है passwordConfirmTextField, लेकिन मुझे दूसरे को संदर्भित करने की आवश्यकता है passwordTextField, इसलिए मैं उनकी तुलना कर सकता हूं। कोई सुझाव?

— Zonker.in.Geneva

Answer 4

सत्यापन तर्क की सत्यता को कम करने के लिए मैंने एंड्रॉइड के लिए एक पुस्तकालय को अधिकृत किया है । यह एनोटेशन और बिल्ट-इन नियमों का उपयोग करते हुए दिन के अधिकांश मान्यताओं का ध्यान रखता है। इस तरह की अड़चनें हैं @TextRule,@NumberRule , @Required, @Regex, @Email, @IpAddress, @Password, आदि,

आप इन एनोटेशन को अपने UI विजेट संदर्भों में जोड़ सकते हैं और सत्यापन कर सकते हैं। यह आपको अतुल्यकालिक रूप से मान्यताओं को निष्पादित करने की अनुमति देता है जो एक दूरस्थ सर्वर से अद्वितीय उपयोगकर्ता नाम के लिए जाँच करने जैसी स्थितियों के लिए आदर्श है।

इस पर एक उदाहरण है एनोटेशन का उपयोग कैसे करें पर प्रोजेक्ट होम पेज पर । आप इससे सम्बंधित ब्लॉग पोस्ट भी पढ़ सकते हैं जहाँ मैंने सत्यापन के लिए कस्टम नियम लिखने के लिए नमूना कोड लिखे हैं।

यहां एक सरल उदाहरण है जो पुस्तकालय के उपयोग को दर्शाता है।

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

पुस्तकालय विस्तार योग्य है, आप Ruleकक्षा का विस्तार करके अपने नियम लिख सकते हैं ।

Comments

यह पुस्तकालय एक आकर्षण की तरह काम करता है। लेकिन संस्करण 2.0.3 से @TextRule एनोटेशन हटा दिया गया था?

— लट्रोया

इसे @Lengthएनोटेशन के साथ बदल दिया गया है ।

— रघुनाथ जवाहर

@RagunathJawahar मैंने नोट किया है कि सत्यापन काम नहीं करता है यदि आप आने वाले डेटा, Ie संपर्क को मान्य करते हैं, तो मैं उस ईमेल को मान्य करने का प्रयास कर रहा हूं जो आशय से आया है -> संपर्क, लेकिन एक बार जब मैं EditText पर ध्यान केंद्रित करता हूं और किसी पाठ को जोड़ता हूं तो सत्यापन सत्यापन के रूप में काम भी TextChange पर बुलाया जा रहा है और मान्य () भी कहा जाता है जब हम संपर्क से डेटा प्राप्त करते हैं।

— रौनक मेहता

Answer 5

यह यहाँ से अच्छा समाधान था

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

Comments

मैं इसे अंतरिक्ष के साथ कैसे उपयोग करूं और एक दूसरे के बगल में कोई दो स्थान सीमित न करूं?

— चिरू

Answer 6

अद्यतित दृष्टिकोण - TextInputLayout:

गूगल ने हाल ही डिजाइन समर्थन पुस्तकालय की शुरूआत की है और वहाँ एक घटक कहा जाता है TextInputLayout और यह के माध्यम से एक त्रुटि दिखा समर्थन करता है setErrorEnabled(boolean)और setError(CharSequence)।

इसे कैसे उपयोग करे?

चरण 1: TextInputLayout के साथ अपना EditText लपेटें:

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

चरण 2: इनपुट को मान्य करें

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

मैंने अपने गितुब भंडार पर एक उदाहरण बनाया है , यदि आप चाहें तो उदाहरण देखें!

Comments

सर्वश्रेष्ठ उत्तर, लेकिन मुझे उपयोग करना था com.google.android.material.textfield.TextInputLayout( सामग्री परिवर्तन पर ध्यान दें )। इसे इस उत्तर से प्राप्त करें: stackoverflow.com/a/56753953/900394

— Alaa M.

Answer 7

मैंने एक वर्ग लिखा जो EditText का विस्तार करता है जो मूल रूप से कुछ सत्यापन विधियों का समर्थन करता है और वास्तव में बहुत लचीला है।

वर्तमान में, जैसा कि मैं लिखता हूं, मूल रूप से xml विशेषताओं के माध्यम से समर्थित सत्यापन विधि हैं:

1. अल्फा
2. अल्फा न्यूमेरिक
3. संख्यात्मक
4. जेनेरिक regexp
5. स्ट्रिंग रिक्ति

आप इसे यहां देख सकते हैं

आशा हैं आप इसका आनंद ले :)

Answer 8

मुझे लगता है कि Android पर पाठ इनपुट को मान्य करने के लिए InputFilter अधिक उपयुक्त है।

यहाँ एक सरल उदाहरण दिया गया है: मैं Android में एक EditText में वर्णों को सीमित करने के लिए InputFilter का उपयोग कैसे करूं?

आप अपने प्रतिबंधों के बारे में उपयोगकर्ता की प्रतिक्रिया के लिए एक टोस्ट जोड़ सकते हैं। इसके अलावा एंड्रॉइड की जांच करें: inputType टैग।

Comments

यह उन चीज़ों के लिए एक अच्छा समाधान है, जिन्हें आप टाइप (अल्फा न्यूमेरिक इनपुट) के रूप में मान्य कर सकते हैं, लेकिन यह उन चीज़ों के लिए काम नहीं करेगा, जिन्हें उपयोगकर्ता द्वारा इनपुट (ईमेल पता) दर्ज करने के बाद ही मान्य किया जाना चाहिए।

— पीटर अज़ताई

आप उस टोस्ट को कैसे ट्रिगर करेंगे? फ़िल्टर किसी भी टेक्स्टवॉचर्स को प्रतिक्रिया करने से रोकता है ... शायद onKeyListener के साथ?

— अवधि

मैंने उस टोस्ट को फ़िल्टर () इनपुट विधि (इनपुटफिल्टर क्लास) पद्धति से एक IF स्थिति के साथ चालू किया।

— मोइसिस

Answer 9

मुझे यह परखने के लिए इंट्रा-फील्ड सत्यापन करने की आवश्यकता है और अंतर-क्षेत्र सत्यापन की आवश्यकता नहीं है कि मेरे मान एक मामले में फ्लोटिंग पॉइंट मान थे और दूसरे में फ्लोटिंग पॉइंट वैल्यू पर हस्ताक्षर किए थे। यहाँ मेरे लिए काम करने लगता है:

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

ध्यान दें, आपके पास "numberSigned | numberDecimal" के अंदर कोई स्थान नहीं होना चाहिए। उदाहरण के लिए: "numberSigned | numberDecimal" काम नहीं करेगा। मुझे यकीन नहीं है कि क्यों।

Answer 10

यह वास्तव में आशाजनक लग रहा है और सिर्फ डॉक्टर ने मेरे लिए क्या आदेश दिया है:

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

कस्टम सत्यापनकर्ता प्लस इन में निर्मित:

• regexp : कस्टम regexp के लिए
• संख्यात्मक : केवल एक संख्यात्मक क्षेत्र के लिए
• अल्फा : एक अल्फा केवल फ़ील्ड के लिए
• AlphaNumeric : लगता है क्या?
• PERSONNAME : यह जांचता है कि दर्ज किया गया पाठ पहले या अंतिम नाम वाला व्यक्ति है या नहीं।
• personFullName : यह जांचता है कि क्या दर्ज किया गया मान पूर्ण नाम है।
• ईमेल : जाँचता है कि क्षेत्र एक वैध ईमेल है
• creditCard : जाँचता है कि इस क्षेत्र में Luhn एल्गोरिथम का उपयोग करके एक वैध क्रेडिट कार्ड है
• फ़ोन : जाँचता है कि फ़ील्ड में एक मान्य फ़ोन नंबर है
• डोमेन नाम : जाँचता है कि फ़ील्ड में एक मान्य डोमेन नाम है (हमेशा एपीआई स्तर <8 में परीक्षण पास करता है)
• आईपी ​​पता : जाँचता है कि फ़ील्ड में एक मान्य IP पता है
• webUrl : जाँचता है कि फ़ील्ड में एक मान्य url है (हमेशा एपीआई स्तर <8 में परीक्षण पास करता है)
• दिनांक : जाँच करता है कि फ़ील्ड एक मान्य दिनांक / डेटाटाइम प्रारूप है (यदि customFormat सेट है, customFormat के साथ जाँच करता है)
• nocheck : यह क्षेत्र की रिक्तता को छोड़कर कुछ भी जाँच नहीं करता है।

Answer 11

Main.xml फ़ाइल में

आप एडिटब्यूट को केवल वर्णमाला में स्वीकार करने वाले वर्णमाला को मान्य करने के लिए निम्नलिखित नोट कर सकते हैं।

यह करो :

  android:entries="abcdefghijklmnopqrstuvwxyz"

Answer 12

जब आप कीबोर्ड पर "डन" बटन दबाते हैं, तो यह सुनकर आप वांछित व्यवहार प्राप्त कर सकते हैं, साथ ही मेरी पोस्ट "एंड्रॉइड फॉर्म वैधीकरण - सही तरीका" में EditText के साथ काम करने के बारे में अन्य युक्तियों की जांच करें

नमूना कोड:

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

Answer 13

ईमेल और पासवर्ड सत्यापन के लिए प्रयास करें

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

Answer 14

मैंने इस लाइब्रेरी को एंड्रॉइड के लिए बनाया है, जहां आप एक सामग्री डिज़ाइन को संपादित कर सकते हैं EditText अंदर और EditTextLayout आसानी से इस तरह:

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

तो आप इसे इस तरह से उपयोग कर सकते हैं:

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

तब आप जाँच कर सकते हैं कि क्या यह इस प्रकार वैध है:

    ageSmartEditText.check()

अधिक उदाहरणों और अनुकूलन के लिए रिपॉजिटरी https://github.com/TeleClinic/SmartEditText की जाँच करें