écouteur onchange android edittext

Je connais un peu TextWatchermais cela se déclenche sur chaque personnage que vous entrez. Je veux un auditeur qui se déclenche chaque fois que l'utilisateur termine l'édition. C'est possible? J'obtiens également TextWatcherune instance de Editablemais j'ai besoin d'une instance de EditText. Comment puis-je l'obtenir?

EDIT : la deuxième question est plus importante. Veuillez y répondre.

Tout d'abord, vous pouvez voir si l'utilisateur a terminé de modifier le texte s'il EditTextperd le focus ou si l'utilisateur appuie sur le bouton Terminé (cela dépend de votre implémentation et de ce qui vous convient le mieux). Deuxièmement, vous ne pouvez pas obtenir une EditTextinstance dans le TextWatcheruniquement si vous avez déclaré le EditTextcomme objet d'instance. Même si vous ne devriez pas modifier le EditTextdans le TextWatchercar il n'est pas sûr.

ÉDITER:

Pour pouvoir intégrer l' EditTextinstance dans votre TextWatcherimplémentation, vous devez essayer quelque chose comme ceci:

public class YourClass extends Activity {

    private EditText yourEditText;

    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);

        setContentView(R.layout.main);
        yourEditText = (EditText) findViewById(R.id.yourEditTextId);

        yourEditText.addTextChangedListener(new TextWatcher() {

            public void afterTextChanged(Editable s) {

                // you can call or do what you want with your EditText here

                // yourEditText... 
            }

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

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

Notez que l'exemple ci-dessus peut contenir des erreurs, mais je voulais juste vous montrer un exemple.

Cela me dérangeait que l'implémentation d'un écouteur pour tous mes champs EditText m'obligeait à avoir un code laid et détaillé, alors j'ai écrit la classe ci-dessous. Peut être utile à quiconque tombe dessus.

public abstract class TextChangedListener<T> implements TextWatcher {
    private T target;

    public TextChangedListener(T target) {
        this.target = target;
    }

    @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) {
        this.onTextChanged(target, s);
    }

    public abstract void onTextChanged(T target, Editable s);
}

Maintenant, implémenter un auditeur est un peu plus propre.

editText.addTextChangedListener(new TextChangedListener<EditText>(editText) {
            @Override
            public void onTextChanged(EditText target, Editable s) {
                //Do stuff
            }
        });

Quant à la fréquence à laquelle il se déclenche, on pourrait peut-être implémenter une vérification pour exécuter le code souhaité //Do stuffaprès un

Quiconque utilise ButterKnife . Vous pouvez utiliser comme:

@OnTextChanged(R.id.zip_code)
void onZipCodeTextChanged(CharSequence zipCode, int start, int count, int after) {

}

Je l'ai fait en utilisant AutotextView:

AutotextView textView = (AutotextView) findViewById(R.id.autotextview);
textView.addTextChangedListener(new TextWatcher() {

    @Override
    public void onTextChanged(CharSequence cs, int arg1, int arg2, int arg3) {
        seq = cs;
    }

    @Override
    public void beforeTextChanged(CharSequence s, int arg1, int arg2, int arg3) {

    }

    @Override
    public void afterTextChanged(Editable arg0) {
        new SearchTask().execute(seq.toString().trim());
    }

});

 myTextBox.addTextChangedListener(new TextWatcher() {  

    public void afterTextChanged(Editable s) {}  

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

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

    TextView myOutputBox = (TextView) findViewById(R.id.myOutputBox);  
    myOutputBox.setText(s);  

    }  
});  

TextWatchern'a pas fonctionné pour moi car il a continué à tirer pour tous EditTextet à bousiller les valeurs de chacun.

Voici ma solution:

public class ConsultantTSView extends Activity {
    .....

    //Submit is called when I push submit button.
    //I wanted to retrieve all EditText(tsHours) values in my HoursList

    public void submit(View view){

        ListView TSDateListView = (ListView) findViewById(R.id.hoursList);
        String value = ((EditText) TSDateListView.getChildAt(0).findViewById(R.id.tsHours)).getText().toString();
    }
}

Par conséquent, en utilisant la getChildAt(xx)méthode, vous pouvez récupérer n'importe quel élément dans ListViewet obtenir l'élément individuel à l'aide de findViewById. Et il donnera alors la valeur la plus récente.

Autant que je puisse y penser, il n'y a que deux façons de le faire. Comment savoir que l'utilisateur a fini d'écrire un mot? Soit sur le focus perdu, soit en cliquant sur un bouton "ok". Il n'y a aucun moyen dans mon esprit que vous puissiez savoir que l'utilisateur a appuyé sur le dernier caractère ...

Alors appelez onFocusChange(View v, boolean hasFocus)ou ajoutez un bouton et un écouteur de clic.

La méthode Watcher se déclenche à chaque entrée de caractère. Donc, j'ai construit ce code basé sur la méthode onFocusChange:

public static boolean comS(String s1,String s2){
    if (s1.length()==s2.length()){
        int l=s1.length();
        for (int i=0;i<l;i++){
            if (s1.charAt(i)!=s2.charAt(i))return false;
        }
        return true;
    }
    return false;
}

public void onChange(final EditText EdTe, final Runnable FRun){
    class finalS{String s="";}
    final finalS dat=new finalS();  
    EdTe.setOnFocusChangeListener(new OnFocusChangeListener() {          
        @Override
        public void onFocusChange(View v, boolean hasFocus) {
            if (hasFocus) {dat.s=""+EdTe.getText();}
            else if (!comS(dat.s,""+EdTe.getText())){(new Handler()).post(FRun);}       
        }
    });
}

Pour l'utiliser, appelez simplement comme ceci:

onChange(YourEditText, new Runnable(){public void run(){
    // V  V    YOUR WORK HERE

    }}
);

Vous pouvez ignorer la fonction comS en remplaçant! ComS (dat.s, "" + EdTe.getText ()) par la fonction! Equal. Cependant, la fonction d'égalité elle-même ne fonctionne pas correctement pendant l'exécution.

L'écouteur onChange se souviendra des anciennes données d'EditText lors de la saisie du focus utilisateur, puis comparera les nouvelles données lorsque l'utilisateur perd le focus ou passe à une autre entrée. Si la comparaison de l'ancienne chaîne n'est pas la même nouvelle chaîne, cela déclenche le travail.

Si vous n'avez qu'un seul EditText, vous devrez alors créer une fonction ClearFocus en créant un Ultimate Secret Transparent Micro EditText 😸 en dehors des fenêtres 😽 et demander le focus, puis masquer le clavier via Import Method Manager.