listener di android edittext onchange

Ne so un po ', TextWatcherma questo colpisce ogni personaggio in cui inserisci. Voglio un ascoltatore che si attiva ogni volta che l'utente termina la modifica. È possibile? Anche in TextWatcherottengo un'istanza di Editablema ho bisogno di un'istanza di EditText. Come lo ottengo?

EDIT : la seconda domanda è più importante. Per favore, rispondi.

Innanzitutto, puoi vedere se l'utente ha finito di modificare il testo se EditTextperde il focus o se l'utente preme il pulsante Fine (questo dipende dalla tua implementazione e da cosa si adatta meglio a te). Secondo, non puoi ottenere EditTextun'istanza all'interno di TextWatchersolo se hai dichiarato EditTextcome oggetto istanza. Anche se non dovresti modificare il file EditTextall'interno di TextWatcherperché non è sicuro.

MODIFICARE:

Per poter inserire l' EditTextistanza nella tua TextWatcherimplementazione, dovresti provare qualcosa di simile:

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

Nota che l'esempio sopra potrebbe contenere alcuni errori, ma volevo solo mostrarti un esempio.

Mi dava fastidio che l'implementazione di un listener per tutti i miei campi EditText mi richiedesse di avere un codice brutto e dettagliato, quindi ho scritto la classe seguente. Può essere utile a chiunque si imbatta in questo.

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

Ora l'implementazione di un ascoltatore è un po 'più pulita.

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

Per quanto riguarda la frequenza con cui si attiva, si potrebbe forse implementare un controllo per eseguire il codice desiderato //Do stuffdopo un dato a

Chiunque utilizzi ButterKnife . Puoi usare come:

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

}

L'ho fatto usando 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);  

    }  
});  

TextWatchernon ha funzionato per me perché continuava a sparare per tutti EditTexte a rovinare i valori degli altri.

Ecco la mia soluzione:

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

Quindi utilizzando il getChildAt(xx)metodo è possibile recuperare qualsiasi elemento in ListViewe ottenere il singolo elemento utilizzando findViewById. E darà quindi il valore più recente.

Per quanto posso pensare, ci sono solo due modi per farlo. Come puoi sapere che l'utente ha finito di scrivere una parola? O quando la messa a fuoco è persa o facendo clic su un pulsante "ok". Non c'è modo che tu possa sapere che l'utente ha premuto l'ultimo carattere ...

Quindi chiama onFocusChange(View v, boolean hasFocus)o aggiungi un pulsante e un ascoltatore di clic.

Il metodo Watcher si attiva a ogni input di carattere. Quindi, ho creato questo codice basato sul metodo 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);}       
        }
    });
}

Per usarlo, chiama in questo modo:

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

    }}
);

È possibile ignorare la funzione comS sostituendo! ComS (dat.s, "" + EdTe.getText ()) con la funzione! Equal. Tuttavia, la stessa funzione di uguale qualche volta non funziona correttamente in fase di esecuzione.

Il listener onChange ricorderà i vecchi dati di EditText durante la digitazione del focus dell'utente, quindi confronterà i nuovi dati quando l'utente perde il focus o passa a un altro input. Se si confronta la vecchia stringa non la stessa nuova stringa, viene attivato il lavoro.

Se hai solo 1 EditText, allora dovrai creare una funzione ClearFocus creando un Micro EditText trasparente Ultimate Secret 😸 fuori dalle finestre 😽 e richiedendo lo stato attivo, quindi nascondi la tastiera tramite Import Method Manager.