web-dev-qa-db-fra.com

Comment utiliser Single TextWatcher pour plusieurs EditTexts?

J'ai trois widgets EditText dans ma présentation. Existe-t-il un moyen d’utiliser une seule variable TextWatcher pour les trois EditTexts?

androidtextwatcher
108
bie

Je viens de rencontrer ce problème. Je l'ai résolu en créant une implémentation de classe interne de TextWatcher qui prend un View comme argument. Ensuite, dans l’implémentation de la méthode, il suffit d’allumer la vue pour voir laquelle est la variable Editable

Déclaration: 

private class GenericTextWatcher implements TextWatcher{

    private View view;
    private GenericTextWatcher(View view) {
        this.view = view;
    }

    public void beforeTextChanged(CharSequence charSequence, int i, int i1, int i2) {}
    public void onTextChanged(CharSequence charSequence, int i, int i1, int i2) {}

    public void afterTextChanged(Editable editable) {
        String text = editable.toString();
        switch(view.getId()){
            case R.id.name:
                model.setName(text);
                break;
            case R.id.email:
                model.setEmail(text);
                break;
            case R.id.phone:
                model.setPhone(text);
                break;
        }
    }
}

Utilisation: 

name = (EditText) findViewById(R.id.name);
name.setText(model.getName());
name.addTextChangedListener(new GenericTextWatcher(name));

email = (EditText) findViewById(R.id.email);
email.setText(model.getEmail());
email.addTextChangedListener(new GenericTextWatcher(email));

phone = (EditText) findViewById(R.id.phone);
phone.setText(model.getPhone());
phone.addTextChangedListener(new GenericTextWatcher(phone));
179
Sky Kelsey

Si vous voulez utiliser uniquement afterTextChanged, comparez les éditeurs:

@Override
public void afterTextChanged(Editable editable) {
    if (editable == mEditText1.getEditableText()) {
        // DO STH
    } else if (editable == mEditText2.getEditableText()) {
        // DO STH
    }
}
34
Tomasz

Cela fonctionnera avec ce code

TextWatcher watcher = new TextWatcher() {
  @Override
        public void onTextChanged(CharSequence s, int start, int before, int count) {
            //YOUR CODE
        }

        @Override
        public void beforeTextChanged(CharSequence s, int start, int count, int after) {
            //YOUR CODE
        }

        @Override
        public void afterTextChanged(Editable s) {
          String outputedText = s.toString();

  mOutputText.setText(outputedText);

        }
    };

Puis ajoutez ceci dans oncreate

  mInputText.addTextChangedListener(watcher);
        e2.addTextChangedListener(watcher);
        e3.addTextChangedListener(watcher);
        e4.addTextChangedListener(watcher);
9
Asha Babu

Implémentation MultiTextWatcher

public class MultiTextWatcher {

    private TextWatcherWithInstance callback;

    public MultiTextWatcher setCallback(TextWatcherWithInstance callback) {
        this.callback = callback;
        return this;
    }

    public MultiTextWatcher registerEditText(final EditText editText) {
        editText.addTextChangedListener(new TextWatcher() {
            @Override
            public void beforeTextChanged(CharSequence s, int start, int count, int after) {
                callback.beforeTextChanged(editText, s, start, count, after);
            }

            @Override
            public void onTextChanged(CharSequence s, int start, int before, int count) {
                callback.onTextChanged(editText, s, start, before, count);
            }

            @Override
            public void afterTextChanged(Editable editable) {
                callback.afterTextChanged(editText, editable);
            }
        });

        return this;
    }

    interface TextWatcherWithInstance {
        void beforeTextChanged(EditText editText, CharSequence s, int start, int count, int after);

        void onTextChanged(EditText editText, CharSequence s, int start, int before, int count);

        void afterTextChanged(EditText editText, Editable editable);
    }
}

Usage

    new MultiTextWatcher()
            .registerEditText(editText1)
            .registerEditText(editText2)
            .registerEditText(editText3)
            .setCallback(new TextWatcherWithInstance() {
                @Override
                public void beforeTextChanged(EditText editText, CharSequence s, int start, int count, int after) {
                    // TODO: Do some thing with editText
                }

                @Override
                public void onTextChanged(EditText editText, CharSequence s, int start, int before, int count) {
                    // TODO: Do some thing with editText
                }

                @Override
                public void afterTextChanged(EditText editText, Editable editable) {
                    // TODO: Do some thing with editText
                }
            });
9
Ilya Gazman

Si vous souhaitez utiliser onTextChanged compare hashCode() mentionné ci-dessous - 

@Override
public void onTextChanged(CharSequence charSequence, int i, int i1, int i2) {
    if(charSequence.hashCode() == first_edit_text.getText().hashCode()){
        // do other things 
    }

    if(charSequence.hashCode() == second_edit_text.getText().hashCode()){
       // do other things 
    }

}

Ou

Si vous voulez utiliser afterTextChanged compare Editable mentionné ci-dessous -

@Override
public void afterTextChanged(Editable editable) {
    if (editable == first_edit_text.getEditableText()) {
        // do other things 
    } else if (editable == second_edit_text.getEditableText()) {
       // do other things 
    }
}
5
Aman Jham

Faites en sorte que votre classe hérite de Activity et implémente TextWatcher.

Ensuite, à travers la magie du polymorphisme, il vous suffit de vous abonner aux événements.

Cela ne vous dira pas ce que TextEdit a changé, cependant, si vous combinez ceci et la réponse de Sky Kelsey , vous pourrez résoudre ce problème. 

    public YourActivity extends Activity implements TextWatcher {

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

            //Subscribe to the events
            EditText txt1 = (EditText) findViewById(R.id.txt1);
            txt1.addTextChangedListener(this);

            EditText txt2 = (EditText) findViewById(R.id.txt2);
            txt2.addTextChangedListener(this);
        }

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

                EditText txt1 = (EditText) findViewById(R.id.txt1);
                EditText txt2 = (EditText) findViewById(R.id.txt2);
                // You probably only want the text value from the EditText. But you get the idea. 
                    doStuff(txt1,txt2);
        }

        @Override
        public boolean onCreateOptionsMenu(Menu menu) {
            // Inflate the menu; this adds items to the action bar if it is present.
            getMenuInflater().inflate(R.menu.calc, menu);
            return true;
        }

        @Override
        public void afterTextChanged(Editable s) {
            // TODO Auto-generated method stub
        }

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

Je sais que c'est un vieux problème et que la décision est bonne. J'écrirai les leurs, cela aidera peut-être quelqu'un.

En émulant l'exemple classique où nous avons N EditText, et nous voulons montrer le bouton si tous les champs sont remplis. Cet exemple est logique, surtout si vous utilisez d'autres validateurs pour chacun d'eux.

J'ai fait un exemple en ce qui concerne la question, mais vous pouvez faire n'importe quel jeu

MultiEditText.class

public class MultiEditText extends AppCompatActivity{

EditText ed_1, ed_2, ed_3;
Button btn_ok;

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

    ed_1 = (EditText) findViewById(R.id.ed_1);
    ed_2 = (EditText) findViewById(R.id.ed_2);
    ed_3 = (EditText) findViewById(R.id.ed_3);
    btn_ok = (Button) findViewById(R.id.btn_ok);
    btn_ok.setEnabled(false);

    //if want more here can cycle interface List

    EditText[] edList = {ed_1, ed_2, ed_3};
    CustomTextWatcher textWatcher = new CustomTextWatcher(edList, btn_ok);
    for (EditText editText : edList) editText.addTextChangedListener(textWatcher);

    }
}

Cela a l'air très simple, maintenant 

CustomTextWatcher.class

public class CustomTextWatcher implements TextWatcher {

View v;
EditText[] edList;

public CustomTextWatcher(EditText[] edList, Button v) {
    this.v = v;
    this.edList = edList;
}

@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) {
    for (EditText editText : edList) {
        if (editText.getText().toString().trim().length() <= 0) {
            v.setEnabled(false);
            break;
        }
        else v.setEnabled(true);
    }
  }
}

Je vais ajouter une mise en page, de sorte que vous ne perdez pas de temps

multi_edit_text.xml

<RelativeLayout xmlns:Android="http://schemas.Android.com/apk/res/Android"
Android:layout_width="match_parent"
Android:layout_height="match_parent"
Android:padding="16dp">

<EditText
    Android:id="@+id/ed_1"
    Android:layout_width="match_parent"
    Android:layout_height="wrap_content"
    Android:layout_alignParentTop="true"
    Android:layout_centerHorizontal="true"
    Android:layout_marginTop="8dp" />

<EditText
    Android:id="@+id/ed_2"
    Android:layout_width="match_parent"
    Android:layout_height="wrap_content"
    Android:layout_below="@+id/ed_1"
    Android:layout_centerHorizontal="true"
    Android:layout_marginTop="8dp" />

<EditText
    Android:id="@+id/ed_3"
    Android:layout_width="match_parent"
    Android:layout_height="wrap_content"
    Android:layout_below="@+id/ed_2"
    Android:layout_centerHorizontal="true"
    Android:layout_marginTop="8dp" />

<Button
    Android:id="@+id/btn_ok"
    Android:layout_width="wrap_content"
    Android:layout_height="wrap_content"
    Android:layout_below="@+id/ed_3"
    Android:layout_centerHorizontal="true"
    Android:layout_marginTop="8dp"
    Android:text="OK" />
</RelativeLayout>
4
Shwarz Andrei
TextWatcher watcher = new TextWatcher(){

    @Override
    public void beforeTextChanged(CharSequence charSequence, int i, int i1, int i2) {
    }

    @Override
    public void onTextChanged(CharSequence charSequence, int i, int i1, int i2) {
    }

    @Override
    public void afterTextChanged(Editable editable) {
    }
};

Ensuite:

editText1.addTextChangedListener(watcher);
editText2.addTextChangedListener(watcher);
editText3.addTextChangedListener(watcher);
3
Cristian

Voici comment je l'ai fait: 

Créez une ArrayList of EditTexts, puis utilisez une boucle for pour appliquer TextWatcher à tous les EditTexts. Si vous avez un comportement pour tous les editTexts, appliquez-le simplement ici, si vous avez des comportements spécifiques pour certains editTexts, vous pouvez utiliser un if. instruction pour sélectionner et appliquer à editTexts individuels ... voici mon code: 

    ArrayList<EditText> editTexts = new ArrayList<>(); // Container list

    editText1 = (EditText) findViewById(R.id.editText1);
    editText2 = (EditText) findViewById(R.id.editText2);
    editText3 = (EditText) findViewById(R.id.editText3);

    editTexts.add(editText1); // editTexts[0]
    editTexts.add(editText2); // editTexts[1]
    editTexts.add(editText3); // editTexts[2]

    for (final EditText editText : editTexts) { //need to be final for custom behaviors 
        editText.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) {
                //Apply general behavior for all editTexts

                if (editText == editTexts.get(1)) {
                    //Apply custom behavior just for this editText                           
                }
            }
        });

    }

J'espère que cela t'aides

0
SamiHajjaj
public class MainActivity extends AppCompatActivity{
    EditText value1, value2;

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

        //instantiate EditText controls
        value1 = (EditText)findViewById(R.id.txtValue1);
        value2 = (EditText)findViewById(R.id.txtValue2);

        //set up text changed listener
        value1.addTextChangedListener(new TextChange(value1));               
        value2.addTextChangedListener(new TextChange(value2));                       

       //inner class
       private class TextChange implements TextWatcher {
        /**
         * This method is called to notify you that, within <code>s</code>,
         * the <code>count</code> characters beginning at <code>start</code>
         * are about to be replaced by new text with length <code>after</code>.
         * It is an error to attempt to make changes to <code>s</code> from
         * this callback.
         *
         * @param s
         * @param start
         * @param count
         * @param after
         */
            View view;
            private TextChange (View v) {
                view = v;
            }//end constructor

            @Override
            public void beforeTextChanged(CharSequence s, int start, int count, int after) {

            }

            /**
             * This method is called to notify you that, within <code>s</code>,
             * the <code>count</code> characters beginning at <code>start</code>
             * have just replaced old text that had length <code>before</code>.
             * It is an error to attempt to make changes to <code>s</code> from
             * this callback.
             *
             * @param s
             * @param start
             * @param before
             * @param count
             */
            @Override
            public void onTextChanged(CharSequence s, int start, int before, int count) {

                switch (view.getId()) {
                    case R.id.txtValue1:
                        //insert your TextChangedListener codes here
                        break;

                    case R.id.txtValue2:
                        //insert your TextChangedListener codes here
                        break;

                }//end switch

            }//end method onTextChanged
          }//end inner class TextChange
}//end classMainActivity
0
Ng Kian Keong

Je sais que cette question est ancienne, mais je voulais partager l'une de mes solutions (en Kotlin). Ma solution est une amélioration de la réponse de @Shwarz Andrei, ma raison était que si vous vouliez manipuler plus de choses/objets.

Au lieu de transmettre les paramètres list of EditTexts et a Button en tant que paramètres, vous ne transmettez que votre list of editText. Ensuite, dans votre classe personnalisée, vous implémenteriez un lambda tel que: 

var hasFilled:((Boolean)->Unit)? = null

Ensuite, vous définissez ou élevez-le dans la afterTextChanged

override fun afterTextChanged(p0: Editable?) {
       for (edit in _editTextList) {
           if (edit?.text.toString().trim().isEmpty()) {
                 hasFilled?.invoke(false) //<-- here 
               break
           } else {
               hasFilled?.invoke(true) //<--- here 
           }
       }
   }

Donc à chaque fois, il y a un changement dans un EditText, votre lambda est invoqué

        val editTexts = listOf(emailEditText,passwordEditText) // your list of editText
        val textWatcher = customTextWatcher(editTexts) // initialize your custom object 
        editTexts.forEach { it -> it?.addTextChangedListener(textWatcher) } // each editText would listen for changes 


        textWatcher.hasFilled = { value ->  // now you have access to your lambda 
            if (value != true)  {
               // change the state of the button to unable 
              // do other things 
            } else {
              // change the state of the button to enable 
              // do other things 
            }
        }
0
Lamar

Ceci est ma solution pour Kotlin. Vous pouvez simplement utiliser l’égalité référentielle (===) pour vérifier le même objet et cela fonctionne parfaitement.

val mTextWatcher = object : TextWatcher {
        override fun afterTextChanged(et: Editable?) {

            when {
                et === et1.editableText -> {
                    Toast.makeText(this@MainActivity, "EditText 1", Toast.LENGTH_LONG).show()
                }
                et === et2.editableText -> {
                    Toast.makeText(this@MainActivity, "EditText 2", Toast.LENGTH_LONG).show()
                }

            }
        }

        override fun beforeTextChanged(p0: CharSequence?, p1: Int, p2: Int, p3: Int) {
        }
        override fun onTextChanged(p0: CharSequence?, p1: Int, p2: Int, p3: Int) {
        }
    }
    et1.addTextChangedListener(mTextWatcher)
    et2.addTextChangedListener(mTextWatcher)
0
Shohan Ahmed Sijan