web-dev-qa-db-fra.com

Différences entre onTextChanged de TextWatcher, beforeTextChanged et afterTextChanged

Dans mon Android, j'ai dû ajouter un TextChangedListener (TextWatcher) à une vue d'édition de texte. Et il y a trois parties:

  • onTextChanged()
  • beforeTextChanged()
  • afterTextChanged()

Quelles sont les différences de ces trois? J'ai dû mettre en œuvre une recherche d'une table sur l'auditeur clé et pour mon cas, tous les trois se ressemblaient. Ils fonctionnaient également de la même manière. Lorsque j'entre une partie du nom d'un produit, le tableau se redessine avec uniquement les produits qui contiennent du texte saisi. Mais j'ai utilisé la partie afterTextChanged(). Mon code est:

EditProduct.addTextChangedListener(new TextWatcher() {

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

            // System.out.println("onTextChanged"+s);
        }

        @Override
        public void beforeTextChanged(CharSequence s, int start, int count,
                int after) {
            // TODO Auto-generated method stub
            // System.out.println("beforeTextChanged"+s);
        }

        @Override
        public void afterTextChanged(Editable s) {
            // TODO Auto-generated method stub
            // System.out.println("afterTextChanged"+s);

            String new_prx = s.toString();

            System.out.println(s);
            mini_productList = new ArrayList<Product>();

            // mini_productList
            int count = 0;
            if (new_prx.equals("")) {

                loadtableProducts(productList);

            } else {

                for (int i = 0; i < productList.size(); i++) {

                    if (productList.get(i).getDescription().toString()
                            .substring(0, (new_prx.length()))
                            .equalsIgnoreCase(new_prx)) {
                        mini_productList.add(productList.get(i));
                        count++;

                    }
                }

                loadtableProducts(mini_productList);
            }
        }
    });

Alors, quelqu'un peut-il me donner une explication sur ces trois?

androidtextwatcherandroid-textwatcher
34
Samantha Withanage

onTextChanged s'exécute pendant la modification du texte.

afterTextChanged s'exécute immédiatement après la modification du texte.

beforeTextChanged s'exécute l'instant précédant la modification du texte.

Selon le moment où vous souhaitez affecter des variables ou faire des choses, vous souhaiterez peut-être exécuter le code à l'instant précédant la modification ou à l'instant suivant.

En voici un exemple:

String afterTextChanged = "";
String beforeTextChanged = "";
String onTextChanged = "";

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);

    et = (EditText)findViewById(R.id.editText);

    et.addTextChangedListener(new TextWatcher() {

        @Override
        public void onTextChanged(CharSequence s, int st, int b, int c) 
        {
            onTextChanged = et.getText().toString();
        }

        @Override
        public void beforeTextChanged(CharSequence s, int st, int c, int a) 
        {
            beforeTextChanged = et.getText().toString();
        }

        @Override
        public void afterTextChanged(Editable s) 
        {
            afterTextChanged = et.getText().toString();
            Toast.makeText(Activity.this, "before: " + beforeTextChanged
                                           + '\n' + "on: " + onTextChanged 
                                           + '\n' + "after: " + afterTextChanged
                           ,Toast.LENGTH_SHORT).show();
        }
    });
}

Dans ce cas, disons que vous avez changé le texte de "h" en "hi", la sortie serait:

avant: "h"
sur: "salut"
après: "salut"

23
Michael Yaworski

Les paramètres de beforeTextChanged et onTextChanged sont un peu difficiles à comprendre au début. Il peut être utile de les voir utilisés dans un exemple. Regardez la démonstration suivante plusieurs fois. Faites attention aux comptes.

  • Le surlignage rouge est l'ancien texte qui est sur le point d'être remplacé par le texte vert.
  • Le surlignage vert est le nouveau texte qui vient de remplacer le texte rouge.

enter image description here

beforeTextChanged

  • start est l'index de début du texte surligné en rouge (qui est sur le point d'être supprimé)
  • count est la longueur du texte en surbrillance rouge (qui est sur le point d'être supprimé)
  • after est la longueur du texte en surbrillance vert (qui est sur le point d'être ajouté)

onTextChanged

  • start est l'index de début du texte surligné en vert (qui vient d'être ajouté).
    C'est le même que le start de beforeTextChanged.
  • before est la longueur du texte en surbrillance rouge (qui vient d'être supprimé).
    C'est le même que le count de beforeTextChanged.
  • count est la longueur du texte en surbrillance vert (qui vient d'être ajouté).
    C'est le même que le after de beforeTextChanged.

afterTextChanged

  • editable est le texte modifiable de EditText. Vous pouvez le modifier ici. Cela déclenchera à nouveau tous les événements TextWatcher.
  • On ne vous donne aucune information sur ce qui a été changé. Si vous voulez le savoir, vous pouvez définir une étendue dans onTextChanged, puis rechercher l'étendue ici.

Quand utiliser quoi?

Si vous souhaitez observer les modifications apportées, utilisez beforeTextChanged() ou onTextChanged(). Vous n'êtes cependant pas autorisé à modifier le texte CharSequence dans l'une de ces méthodes.

Si vous souhaitez modifier davantage le texte après sa modification, faites-le dans afterTextChanged().

Code

Voici le code si vous voulez jouer avec lui-même.

MainActivity.Java

public class MainActivity extends AppCompatActivity {

    final static int RED_COLOR = Color.parseColor("#fb7373");
    final static int GREEN_COLOR = Color.parseColor("#40de83");

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        EditText editText = findViewById(R.id.editText);
        final TextView tvBeforeText = findViewById(R.id.tvBeforeText);
        final TextView tvBeforeNumbers = findViewById(R.id.tvBeforeNumbers);
        final TextView tvAfterText = findViewById(R.id.tvAfterText);
        final TextView tvAfterNumbers = findViewById(R.id.tvAfterNumbers);

        editText.addTextChangedListener(new TextWatcher() {
            @Override
            public void beforeTextChanged(CharSequence s, int start, int count, int after) {
                SpannableString spannableString = new SpannableString(s);
                BackgroundColorSpan backgroundSpan = new BackgroundColorSpan(RED_COLOR);
                spannableString.setSpan(backgroundSpan, start, start + count, Spannable.SPAN_EXCLUSIVE_EXCLUSIVE);
                tvBeforeText.setText(spannableString);
                tvBeforeNumbers.setText("start=" + start + "  count=" + count + " after=" + after);
            }

            @Override
            public void onTextChanged(CharSequence s, int start, int before, int count) {
                SpannableString spannableString = new SpannableString(s);
                BackgroundColorSpan backgroundSpan = new BackgroundColorSpan(GREEN_COLOR);
                spannableString.setSpan(backgroundSpan, start, start + count, Spannable.SPAN_EXCLUSIVE_EXCLUSIVE);
                tvAfterText.setText(spannableString);
                tvAfterNumbers.setText("start=" + start + " before=" + before + " count=" + count);
            }

            @Override
            public void afterTextChanged(Editable s) {
                Log.i("TAG", "afterTextChanged: " + s);
            }
        });
    }
}

activity_main.xml

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout
    xmlns:Android="http://schemas.Android.com/apk/res/Android"
    Android:orientation="vertical"
    Android:layout_width="match_parent"
    Android:layout_height="match_parent"
    Android:padding="5dp">

    <EditText
        Android:id="@+id/editText"
        Android:layout_width="match_parent"
        Android:layout_height="wrap_content" />

    <TextView
        Android:layout_width="wrap_content"
        Android:layout_height="wrap_content"
        Android:textSize="20sp"
        Android:text="beforeTextChanged" />

    <TextView
        Android:id="@+id/tvBeforeText"
        Android:textSize="17sp"
        Android:layout_width="wrap_content"
        Android:layout_height="wrap_content" />

    <TextView
        Android:id="@+id/tvBeforeNumbers"
        Android:textSize="17sp"
        Android:text="start=0 count=0 after=0"
        Android:layout_width="wrap_content"
        Android:layout_height="wrap_content" />

    <TextView
        Android:layout_width="wrap_content"
        Android:layout_height="wrap_content"
        Android:textSize="20sp"
        Android:layout_marginTop="20dp"
        Android:text="onTextChanged" />

    <TextView
        Android:id="@+id/tvAfterText"
        Android:textSize="17sp"
        Android:layout_width="wrap_content"
        Android:layout_height="wrap_content" />

    <TextView
        Android:id="@+id/tvAfterNumbers"
        Android:textSize="17sp"
        Android:text="start=0 count=0 after=0"
        Android:layout_width="wrap_content"
        Android:layout_height="wrap_content" />
</LinearLayout>
37
Suragch

Android TextChangedListener est un type de déclencheur qui est appelé lors du changement de texte d'un champ de saisie.

TextChangedListener a trois événements.

1.beforeTextChanged: Cela signifie que les caractères sont sur le point d'être remplacés par du nouveau texte. Le texte n'est pas modifiable. Cet événement est utilisé lorsque vous devez jeter un œil à l'ancien texte qui est sur le point de changer.

2.onTextChanged: Des modifications ont été apportées, certains caractères viennent d'être remplacés. Le texte n'est pas modifiable. Cet événement est utilisé lorsque vous devez voir quels caractères du texte sont nouveaux.

.afterTextChanged: La même chose que ci-dessus, sauf que maintenant le texte est modifiable. Cet événement est utilisé lorsque vous devez voir et éventuellement modifier un nouveau texte.

20
Jigar Pandya
  • abstract void afterTextChanged(Editable s)

Cette méthode est appelée pour vous informer que, quelque part dans s, le texte a été modifié.

  • abstract void beforeTextChanged(CharSequence s, int start, int count, int after)

Cette méthode est appelée pour vous informer que, dans s, les caractères de comptage commençant au début sont sur le point d'être remplacés par un nouveau texte avec une longueur après.

  • abstract void onTextChanged(CharSequence s, int start, int before, int count)

Cette méthode est appelée pour vous informer que, dans s, les caractères de comptage commençant au début viennent de remplacer l'ancien texte qui avait une longueur auparavant.

Vous pouvez en savoir plus ici .

2
Kailash Dabhi

  1. afterTextChanged (Editable s) - Cette méthode est appelée lorsque le texte a été modifié. Étant donné que toutes les modifications que vous apporterez entraîneront le rappel de cette méthode de manière récursive, vous devez faire attention à l'exécution des opérations ici, sinon cela pourrait conduire à une boucle infinie.

  2. beforeTextChanged (CharSequence s, int start, int count, int after) - Cette méthode est appelée pour vous informer que, dans s, les caractères de comptage commençant au début sont sur le point d'être remplacés par un nouveau texte de longueur après. C'est une erreur d'essayer d'apporter des modifications à s à partir de ce rappel.

  3. onTextChanged (CharSequence s, int start, int before, int count) - Cette méthode est appelée pour vous informer que, dans s, les caractères de comptage commençant au début viennent de remplacer l'ancien texte qui avait une longueur auparavant. C'est une erreur d'essayer d'apporter des modifications à s à partir de ce rappel.

0
user2666607