Anzahl der Live-Charaktere für EditText

Ich habe mich gefragt, wie man eine Live-Zeichenzählung eines Textfelds am besten in Android durchführen kann. Ich war auf der Suche dieses aber ich konnte keinen Sinn daraus zu machen scheinen.

Um das Problem zu beschreiben, habe ich einen EditText und versuche, die Zeichen auf 150 zu beschränken. Ich kann dies mit einem Eingabefilter tun, möchte jedoch direkt unter dem Textfeld die Anzahl der von einem Benutzer eingegebenen Zeichen anzeigen (Fast) wie es der Stapelüberlauf gerade tut).

Wenn jemand einen kleinen Ausschnitt aus Beispielcode schreiben oder mich in die richtige Richtung weisen könnte, würde ich das sehr schätzen.

Mit einem TextWatcher können Sie sehen, wann sich der Text geändert hat

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

Sie setzen den TextWatcher für den Edittext mit

mEditText.addTextChangedListener(mTextEditorWatcher);

Sie können die Zeichenzählung aus XML selbst mit dem in SupportLibrary v23.1 eingeführten TextInputLayout- Wrapper für EditText durchführen

Wickeln Sie einfach Ihren EditText mit einem TextInputLayout ein und setzen Sie CounterEnabled auf true und setzen Sie eine 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>

Sie werden einen wesentlichen Einfluss wie erhalten diese

Sie können counterOverflowTextAppearance , counterTextAppearance verwenden , um den Zähler zu formatieren .

BEARBEITEN

Aus der Android-Dokumentation.

Die TextInputEditText- Klasse wird als untergeordnetes Element dieses Layouts bereitgestellt. Die Verwendung von TextInputEditText ermöglicht TextInputLayout eine bessere Kontrolle über die visuellen Aspekte jeder Texteingabe. Ein Beispiel für eine Verwendung ist wie folgt:

     <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

Sie können dies tun mit TextInputLayoutund kompatiblen Bibliotheken mit:

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

und komplett:

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

Fügen Sie in XML dieses Attribut für editText hinzu

    android:maxLength="80"

Fügen Sie in Java diesen Listener hinzu

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

        }
    });

Es ist sehr einfach Befolgen Sie die folgenden Anweisungen:

==== Fügen Sie sie Ihren Importen hinzu ===

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

===== Definiere dies =====

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

Setzen Sie einfach diese 2 Zeilen TextInputLayoutin Ihre XML-Datei ein:

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

Diese Lösung verwendet Kotlinund zeigt die Anzahl der verbleibenden Zeichen an. Wenn die aktuelle Anzahl von Zeichen die Grenze von 50 überschreitet, ändert sich die Textfarbe in Rot.

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

Vergessen Sie auch nicht, das TextWatcherzu Ihrem hinzuzufügenEditText

YOUR_EDIT_TEXT_ID.addTextChangedListener(mTitleTextWatcher)

Sie können Ihrem TextInputEditText, der in ein TextInputLayout eingeschlossen wird, einen Zähler hinzufügen. Wie Sie im Beispiel sehen können, counterEnabledwird diese Funktion counterMaxLenghaktiviert und die Anzahl der Zeichen dafür definiert.

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

Ich bin auf das gleiche Problem gestoßen und habe Camerons Methode ausprobiert. Es funktioniert, aber es gibt einen kleinen Fehler: Wenn der Benutzer Kopieren und Einfügen verwendet, werden die Zeichen nicht gezählt. Daher schlage ich vor, dies zu tun, nachdem sich der Text geändert hat, wie unten:

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

Verwenden Sie Android: maxLength = "140"

Das sollte funktionieren. :) :)

hoffentlich hilft das

Versuchen Sie so etwas zu tun.

Diese Lösung ist möglicherweise leistungsfähiger als das Abrufen von CharSequence.length. Jedes Mal, wenn Sie auf die Softtastatur tippen, wird das Ereignis ausgelöst. Wenn Sie also eine Länge ausführen, wird jedes Mal die CharSequence gezählt. Dies kann sich verlangsamen, wenn Sie anfangen, in große CharSequnces zu geraten. Der Ereignis-Listener bei Textänderungen greift die Vorher- und Nachher-Zählung an. Dies funktioniert gut für Inkrementierungs- und Dekrementierungswerte

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

Versuche dies

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

    }
};

`

Freier Weg;

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