Liczba aktywnych znaków w EditText

Zastanawiałem się, jaki najlepszy sposób na liczenie znaków w polu edycji na żywo jest w systemie Android. Patrzyłem na to, ale nie mogłem tego zrozumieć.

Aby opisać problem, mam EditText i próbuję ograniczyć liczbę znaków do 150. Mogę to zrobić za pomocą filtru wejściowego, jednak chcę pokazać tuż pod polem tekstowym liczbę znaków, które wprowadził użytkownik (Prawie tak jak przepełnienie stosu robi się teraz).

Gdyby ktoś mógł napisać mały fragment przykładowego kodu lub wskazać mi właściwy kierunek, byłbym bardzo wdzięczny.

możesz użyć TextWatchera, aby zobaczyć, kiedy tekst się zmienił

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

ustawiasz TextWatcher dla edittext za pomocą

mEditText.addTextChangedListener(mTextEditorWatcher);

Możesz zliczać znaki z samego xml za pomocą opakowania TextInputLayout dla EditText wprowadzonego w SupportLibrary v23.1

Po prostu zawiń EditText za pomocą TextInputLayout i ustaw CounterEnabled na true i ustaw counterMaxLength.

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

Dostaniesz istotny wpływ jak to

Możesz użyć counterOverflowTextAppearance , counterTextAppearance, aby nadać styl licznikowi.

EDYTOWAĆ

Z dokumentacji Androida.

TextInputEditText klasa jest do stosowania jako dziecko tego układu. Użycie TextInputEditText umożliwia TextInputLayout większą kontrolę nad wizualnymi aspektami dowolnego wprowadzania tekstu. Przykładowe użycie jest następujące:

     <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

Możesz to zrobić za pomocą TextInputLayoutbibliotek kompatybilnych z:

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

i uzupełnij:

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

w xml dodaj ten atrybut do editText

    android:maxLength="80"

w java dodaj ten odbiornik

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

        }
    });

To bardzo proste Postępuj zgodnie z poniższymi instrukcjami:

==== Dodaj je do swoich importów ===

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

===== Zdefiniuj to =====

private TextView sms_count;

========== Inside On Create =====

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

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

Po prostu ustaw te 2 linie TextInputLayoutw swoim pliku XML:

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

To rozwiązanie używa Kotlini pokazuje liczbę pozostałych znaków. Ponadto, jeśli aktualna liczba znaków przekroczy limit 50, kolor tekstu zmieni się na czerwony.

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

Nie zapomnij też dodać TextWatcherdo swojegoEditText

YOUR_EDIT_TEXT_ID.addTextChangedListener(mTitleTextWatcher)

Możesz dodać licznik do swojego TextInputEditText, który jest zawijany w TextInputLayout. Jak widać na przykładzie, counterEnabledwłącza tę funkcję i counterMaxLenghokreśla dla niej liczbę znaków.

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

Spotkałem ten sam problem i wypróbowałem metodę Camerona. Działa, ale jest drobny błąd: jeśli użytkownik użyje kopiuj i wklej, nie policzy znaków. Proponuję więc zrobić po zmianie tekstu, jak poniżej:

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

Użyj Androida: maxLength = "140"

To powinno działać. :)

Mam nadzieję, że to pomoże

Spróbuj zrobić coś takiego.

To rozwiązanie może być bardziej wydajne niż uzyskiwanie CharSequence.length. Za każdym dotknięciem miękkiej klawiatury zdarzenie jest uruchamiane; dlatego jeśli zrobisz długość, za każdym razem policzy CharSequence, co może spowolnić, jeśli zaczniesz wchodzić w duże CharSequnces. Odbiornik zdarzenia przy zmianie tekstu ustawia licznik przed i po. Działa to dobrze w przypadku wartości zwiększania i zmniejszania

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

Spróbuj tego

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

    }
};

`

Przejrzysta droga;

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