EditText के लिए लाइव वर्ण गणना

Question

मैं सोच रहा था कि एंड्रॉइड में एक एडिट-टेक्स्ट बॉक्स का लाइव कैरेक्टर काउंट करने का सबसे अच्छा तरीका क्या है। मैं देख रहा था इस लेकिन मैं इसके बारे में कोई मतलब ही नहीं सकता था।

समस्या का वर्णन करने के लिए, मेरे पास एक EditText है और मैं वर्णों को 150 तक सीमित करने का प्रयास कर रहा हूं। मैं यह एक इनपुट फ़िल्टर के साथ कर सकता हूं, हालांकि मैं पाठ बॉक्स के ठीक नीचे दिखाना चाहता हूं कि उपयोगकर्ता द्वारा दर्ज किए गए वर्णों की संख्या (लगभग) जैसे स्टैक ओवरफ्लो अभी कर रहा है)।

अगर कोई उदाहरण कोड का एक छोटा सा टुकड़ा लिख ​​सकता है या मुझे सही दिशा में इंगित कर सकता है तो मैं इसकी बहुत सराहना करूंगा।

Answer 1

जब पाठ बदल गया है, तो आप एक TextWatcher का उपयोग कर सकते हैं

private TextView mTextView;
private EditText mEditText;
private final TextWatcher mTextEditorWatcher = new TextWatcher() {
        public void beforeTextChanged(CharSequence s, int start, int count, int after) {
        }

        public void onTextChanged(CharSequence s, int start, int before, int count) {
           //This sets a textview to the current length
           mTextView.setText(String.valueOf(s.length()));
        }

        public void afterTextChanged(Editable s) {
        }
};

आप के साथ Edittext के लिए TextWatcher सेट करें

mEditText.addTextChangedListener(mTextEditorWatcher);

Comments

यह कोशिश की, महान काम करता है! सही उत्तर के रूप में चुना जाना चाहिए!

— पैट्रिक बूस

टेक्स्ट बॉक्स के निचले दाईं ओर गिनती को जोड़ने का सबसे अच्छा तरीका क्या होगा। संपादित पाठ बढ़ाएँ और स्ट्रिंग को मैन्युअल रूप से ड्रा करें?

— भालू

धन्यवाद मुझे भी मिल गया है, लेकिन पाठ में प्रवेश करते समय 150,149,148,147 .... जैसे उल्टे क्रम में कैसे गिना जाए।

— विनय मानेटी

इसे इस लाइन mTextView.setText (String.valueOf (150-s.length ()) के साथ बदलकर हल किया गया; के स्थान पर mTextView.setText (String.valueOf (s.length ()));

— विनाय मनेति

मेरी समस्या @Bear है के समान है। मुझे इस गिनती पाठ को संपादित पाठ के ठीक नीचे दिखाने की आवश्यकता है। किसी को भी इस संदर्भ में साझा करने के लिए कुछ भी है। धन्यवाद।

— सुरेश शर्मा

Answer 2

आप कर सकते हैं चरित्र की गणना xml से ही TextInputLayout आवरण का उपयोग करके EditText के लिए SupportLibrary v23.1 में शुरू की गई

बस अपने EditText को TextInputLayout के साथ लपेटें और CounterEnabled को सही पर सेट करें और एक काउंटरमैक्लोमीटर सेट करें।

<android.support.design.widget.TextInputLayout
    android:id="@+id/textContainer"
    android:layout_width="match_parent"
    android:layout_height="wrap_content"
    app:counterEnabled="true"
    app:counterMaxLength="20"
    >
    <EditText
        android:id="@+id/text"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:hint="Text Hint"
        />
</android.support.design.widget.TextInputLayout>

आपको इस तरह एक सामग्री प्रभाव मिलेगा

आप काउंटर शैली का उपयोग कर सकते हैं TextAppearance , काउंटर शैली के लिए counterTextAppearance का उपयोग कर सकते हैं ।

संपादित करें

Android प्रलेखन से।

TextInputEditText वर्ग इस लेआउट के एक बच्चे के रूप में प्रयोग की जाने वाली प्रदान की जाती है। TextInputEditText का उपयोग करके किसी भी पाठ इनपुट के दृश्य पहलुओं पर TextInputLayout को अधिक नियंत्रण की अनुमति देता है। एक उदाहरण का उपयोग इस प्रकार है:

     <android.support.design.widget.TextInputLayout
         android:layout_width="match_parent"
         android:layout_height="wrap_content">

     <android.support.design.widget.TextInputEditText
             android:layout_width="match_parent"
             android:layout_height="wrap_content"
             android:hint="@string/form_username"/>

 </android.support.design.widget.TextInputLayout>

TextInputLayout TextInputEditText

Comments

यह वही था जो मैं देख रहा था :) एक साफ, समर्थन-पुस्तकालय निहित है। धन्यवाद

— VPZ

स्वीकृत उत्तर होना चाहिए! मैं पूरी तरह से उन विशेषताओं को याद किया!

— सूद ०7

Answer 3

आप इसे TextInputLayoutऔर हमवतन पुस्तकालयों के साथ कर सकते हैं :

app:counterEnabled="true"
app:counterMaxLength="420"

और पूर्ण:

<android.support.design.widget.TextInputLayout
    android:layout_width="match_parent"
    android:layout_height="wrap_content"
    app:counterEnabled="true"
    app:counterMaxLength="420">

    <EditText
      android:layout_width="match_parent"
      android:layout_height="wrap_content"
      android:maxLength="420" />

</android.support.design.widget.TextInputLayout>

Comments

महान यह मेरे लिए काम किया, लेकिन मैं काउंटर का रंग कैसे बदलूं?

— एरिच गार्सिया

Answer 4

xml में यह विशेषता editText के लिए जोड़ें

    android:maxLength="80"

जावा में इस श्रोता जोड़ें

  ed_caption.addTextChangedListener(new TextWatcher() {
        @Override
        public void beforeTextChanged(CharSequence s, int start, int count, int after) {

        }

        @Override
        public void onTextChanged(CharSequence s, int start, int before, int count) {

        }

        @Override
        public void afterTextChanged(Editable s) {
            tv_counter.setText(80 - s.toString().length() + "/80");

        }
    });

Answer 5

इसके बहुत ही सरल नीचे दिए गए निर्देशों का पालन करें:

==== उन्हें अपने आयात में जोड़ें ===

import android.text.Editable;
import android.text.TextWatcher;

===== इसे परिभाषित करें =====

private TextView sms_count;

========== अंदर बनाएं ===== पर

sms_count = (TextView) findViewById(R.id.textView2);


final TextWatcher txwatcher = new TextWatcher() {
   public void beforeTextChanged(CharSequence s, int start, int count, int after) {
   }

   public void onTextChanged(CharSequence s, int start, int before, int count) {

      sms_count.setText(String.valueOf(s.length()));
   }

   public void afterTextChanged(Editable s) {
   }
};

sms_message.addTextChangedListener(txwatcher);

Answer 6

    You can use TextWatcher class to see text has changed and how much number of character remains.Here i have set counter of 140 characters.

    EditText typeMessageToPost;
    TextView number_of_character;
public void onCreate(Bundle savedBundleInstance) {
        super.onCreate(savedBundleInstance);
setContentView(R.layout.post_activity);
typeMessageToPost.addTextChangedListener(mTextEditorWatcher);
}
private final TextWatcher mTextEditorWatcher=new TextWatcher() {

        @Override
        public void onTextChanged(CharSequence s, int start, int before, int count) {
            // TODO Auto-generated method stub

        }

        @Override
        public void beforeTextChanged(CharSequence s, int start, int count,
                int after) {
            // TODO Auto-generated method stub

        }

        @Override
        public void afterTextChanged(Editable s) {
            // TODO Auto-generated method stub
            number_of_character.setText(String.valueOf(140-s.length()));
        }
    };

Comments

धन्यवाद @RavishSharma :) मैं आपकी टिप्पणी की सराहना करता हूं।

— राणा प्रताप सिंह

Answer 7

बस इन 2 लाइनों TextInputLayoutको अपनी XML फ़ाइल में सेट करें:

app:counterEnabled="true"
app:counterMaxLength="200"

Comments

महान उस के बारे में नहीं जानता था। यह हमेशा एक TextInputLayout में एक Edittext लपेटने के लिए बेहतर समाधान हो रहा है।

— स्टीफन स्प्रेंजर

Answer 8

यह समाधान Kotlinबचे हुए वर्णों की संख्या का उपयोग करता है और दिखाता है। इसके अलावा, यदि वर्णों की वर्तमान संख्या 50 की सीमा से अधिक है, तो पाठ का रंग लाल हो जाएगा।

Kotlin

private val mTitleTextWatcher = object : TextWatcher {
    override fun beforeTextChanged(s: CharSequence, start: Int, count: Int, after: Int) {}

    override fun onTextChanged(s: CharSequence, start: Int, before: Int, count: Int) {
        if(YOUR_EDIT_TEXT_ID.text.toString().trim().length < 51){
            YOUR_CHAR_LEFT_TEXTVIEW_ID.text = (50 - YOUR_EDIT_TEXT_ID.text.toString().trim().length).toString()
            YOUR_CHAR_LEFT_TEXTVIEW_ID.setTextColor(Color.BLACK)
        }
        else{
            YOUR_CHAR_LEFT_TEXTVIEW_ID.text = "0"
            YOUR_CHAR_LEFT_TEXTVIEW_ID.setTextColor(Color.RED)
        }
    }

    override fun afterTextChanged(s: Editable) {}
}

इसके अलावा, TextWatcherअपने को जोड़ने के लिए मत भूलनाEditText

YOUR_EDIT_TEXT_ID.addTextChangedListener(mTitleTextWatcher)

Answer 9

आप TextInputLayout में लपेटे जा रहे अपने TextInputEditText में एक काउंटर जोड़ सकते हैं। जैसा कि आप उदाहरण में देख सकते हैं, counterEnabledइस सुविधा को सक्षम counterMaxLenghकरता है और इसके लिए वर्णों की संख्या को परिभाषित करता है।

<com.google.android.material.textfield.TextInputLayout
        android:id="@+id/til_title"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        app:counterEnabled="true"
        app:counterMaxLength="50">
    <com.google.android.material.textfield.TextInputEditText
            android:id="@+id/et_title"
            android:layout_width="match_parent"
            android:layout_height="match_parent"/>
</com.google.android.material.textfield.TextInputLayout>

Answer 10

मैं उसी समस्या से मिला और मैंने कैमरन की विधि की कोशिश की। यह काम करता है लेकिन एक मामूली बग है: यदि उपयोगकर्ता कॉपी और पेस्ट का उपयोग करता है तो यह चार्ट को गिनने में विफल रहता है। इसलिए मैं पाठ बदलने के बाद करने का सुझाव देता हूं, जैसे नीचे:

    private final TextWatcher mTextEditorWatcher = new TextWatcher() {
         public void beforeTextChanged(CharSequence s, int start, int count, int after) {

         }

         public void onTextChanged(CharSequence s, int start, int before, int count) {

         }

          public void afterTextChanged(Editable s) {
             //This sets a textview to the current length
             mTextView.setText(String.valueOf(s.length()));
         }
    };

Answer 11

Android का उपयोग करें: अधिकतम गति = "140"

वह काम करना चाहिए। :)

उम्मीद है की वो मदद करदे

Answer 12

कुछ ऐसा करने का प्रयास करें।

यह समाधान CharSequence.length प्राप्त करने के विपरीत अधिक प्रदर्शनकारी हो सकता है। हर बार जब आप सॉफ्ट कीबोर्ड पर टैप करते हैं तो ईवेंट फायर हो जाता है; इसलिए, यदि आप एक लंबाई करते हैं, तो यह हर बार चार्जलेसनेस की गणना करेगा, जो कि यदि आप बड़े चारसेक्शन्स में मिलना शुरू करते हैं तो धीमा हो सकता है। पाठ बदलने पर ईवेंट श्रोता गिनती से पहले और बाद में बदल जाता है। यह वेतन वृद्धि और वेतन वृद्धि मूल्यों के लिए अच्छी तरह से काम करता है

@Override
        public void beforeTextChanged(CharSequence charSequence, int start, int count, int after) {
            int tick = start + after;
            if(tick < mMessageMax) {
                int remaining = mMessageMax - tick;
                ((TextView)findViewById(R.id.contact_us_chars)).setText(String.valueOf(remaining));
            }
        }

Comments

यह प्रभाव क्रमोन्नति है, इसके लिए TextWatcher सर्वश्रेष्ठ दृष्टिकोण है

— नवेद अहमद

Answer 13

इसे इस्तेमाल करे

private TextWatcher textWatcher = new TextWatcher() {
    @Override
    public void beforeTextChanged(final CharSequence s, final int start, final int count, final int after) {
        editText.post(new Runnable() {
            @Override
            public void run() {
                if (length < 100) {
                    if (count > 0 && after <= 0)/*remove emoij*/ {
                        length--;
                    } else if (count > after)/*remove text*/ {
                        length--;
                    } else if (count == 0 && after > 1)/*emoij*/ {
                        ++length;
                    } else if (count == 0 && after == 1)/*Text*/ {
                        ++length;
                    } else if (count > 0 && after > 1) {
                        ++length;
                    }
                    if (s.length() <= 0)
                        length = 0;
                    Log.w("MainActivity", " Length: " + length);
                } else {
                    if (count > 0 && after <= 0)/*remove emoij*/ {
                        length--;
                    } else if (count > after)/*remove text*/ {
                        length--;
                    }
                    Log.w("MainActivity", " Length: " + length);
                }

                if (length == 100) {
                    editText.setFilters(new InputFilter[]{new InputFilter.LengthFilter(s.length())});
                } else {
                    editText.setFilters(new InputFilter[]{});
                }
            }
        });
    }

    @Override
    public void onTextChanged(CharSequence s, int start, int before, int count) {

    }

    @Override
    public void afterTextChanged(Editable s) {

    }
};

`

Answer 14

साफ रास्ता;

abstract class CharacterWatcher : TextWatcher {
    override fun afterTextChanged(text: Editable?) {
        afterCharacterChanged(text?.lastOrNull(), text?.length)
    }

    override fun beforeTextChanged(text: CharSequence?, start: Int, count: Int, before: Int) {}

    override fun onTextChanged(text: CharSequence?, start: Int, before: Int, count: Int) {}

    abstract fun afterCharacterChanged(char: Char?, count: Int?)
}



 editText.addTextChangedListener(new CharacterWatcher() {
            @Override
            public void afterCharacterChanged(@Nullable Character character, @Nullable Integer count) {
                action()
            }
        });