Come rilevare se gli utenti smettono di digitare in EditText android

Question

Ho un campo EditText nel mio layout. Voglio eseguire un'azione quando l'utente smette di digitare in quell'editoriale. Ho implementato TextWatcher ed usando le sue funzioni

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


@Override 
public void onTextChanged(CharSequence text, int start, int lengthBefore, int lengthAfter) { } 

@Override 
    public void afterTextChanged(Editable editable) { 

    } 

funzione OnTextChanged e afterTextChanged vieni chiamato solo dopo aver digitato un carattere, ma voglio eseguire l'azione dopo che l'utente si fermò a digitare in quel campo EditText, proprio come facebook non sul suo " Check-in ".

Come posso implementare questo, per favore dimmi se qualcuno ha qualche idea qui.

Grazie mille in anticipo.

Answer 1

Questo è come ho fatto e lavora per me!

long delay = 1000; // 1 seconds after user stops typing 
long last_text_edit = 0; 
Handler handler = new Handler(); 

private Runnable input_finish_checker = new Runnable() { 
    public void run() { 
     if (System.currentTimeMillis() > (last_text_edit + delay - 500)) { 
      // TODO: do what you need here 
      // ............ 
      // ............ 
      DoStaff(); 
     } 
    } 
}; 

EditText editText = (EditText) findViewById(R.id.editTextStopId); 
editText.addTextChangedListener(new TextWatcher() { 
    @Override 
    public void beforeTextChanged (CharSequence s,int start, int count, 
    int after){ 
    } 
    @Override 
    public void onTextChanged (final CharSequence s, int start, int before, 
    int count){ 
     //You need to remove this to run only once 
     handler.removeCallbacks(input_finish_checker); 

    } 
    @Override 
    public void afterTextChanged (final Editable s){ 
     //avoid triggering event when text is empty 
     if (s.length() > 0) { 
      last_text_edit = System.currentTimeMillis(); 
      handler.postDelayed(input_finish_checker, delay); 
     } else { 

     } 
    } 
} 

); 

Answer 2

È un approccio leggermente diverso. Ma puoi fare qualcosa del genere

Suppongo che dopo che un utente abbia iniziato a digitare in edittext, e non abbia digitato per un particolare periodo di tempo, si può ritenere che abbia smesso di digitare.

editText.addTextChangedListener(new TextWatcher() { 

     boolean isTyping = false; 

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

     private Timer timer = new Timer(); 
     private final long DELAY = 5000; // milliseconds 

     @Override 
     public void afterTextChanged(final Editable s) { 
      Log.d("", ""); 
      if(!isTyping) { 
       Log.d(TAG, "started typing"); 
       // Send notification for start typing event 
       isTyping = true; 
      } 
      timer.cancel(); 
      timer = new Timer(); 
      timer.schedule(
        new TimerTask() { 
         @Override 
         public void run() { 
          isTyping = false; 
          Log.d(TAG, "stopped typing"); 
          //send notification for stopped typing event 
         } 
        }, 
        DELAY 
      ); 
     } 
    }); 

Fondamentalmente quello che state facendo qui è che ogni volta che un utente inizia a digitare, se v'è un intervallo di tempo di 5000 millisecondi nel cambiare il testo all'interno della EditText, si considera come l'utente ha smesso di scrivere. Ovviamente è possibile modificare l'ora in qualsiasi momento.

Answer 3

È possibile utilizzare un listener di modifica della messa a fuoco. Se l'EditText ha concentrerà quindi assumere utente ancora modificando altrimenti hanno smesso ed è possibile eseguire l'azione:

EditText et = new EditText(mContext); 
    et.setOnFocusChangeListener(new View.OnFocusChangeListener() { 
     @Override 
     public void onFocusChange(View view, boolean hasFocus) { 
      if (hasFocus) { 
       //user has focused 
      } else { 
       //focus has stopped perform your desired action 
      } 
     } 
    }); 

Answer 4

può urlare codice di aiuto che

yourEdiTtext.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) { 
       //Write your code for on change in edittext 

      } 

      @Override 
      public void afterTextChanged(Editable s) { 

      } 
     }); 

Answer 5

ho usato un CountDownTimer per scoprire se l'utente smesso di digitare dopo un po '. Spero di aiutare.

yourEditText.addTextChangedListener(new TextWatcher() { 

     CountDownTimer timer = null; 

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

     } 

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

      if (timer != null) { 
       timer.cancel(); 
      } 

      timer = new CountDownTimer(1500, 1000) { 

       public void onTick(long millisUntilFinished) { 
       } 

       public void onFinish() { 

        //do what you wish 

       } 

      }.start(); 

     } 

     @Override 
     public void afterTextChanged(Editable s) { 

     } 
    }); 

Answer 6

C'è un modo molto semplice e facile di fare questo usando RxBindings per Android,

Prendi la libreria se non l'hai già fatto,

compile 'com.jakewharton.rxbinding:rxbinding:0.4.0' 

Aggiungere e modificare questo snippet le vostre esigenze,

RxTextView.textChanges(mEditText) 
      .debounce(3, TimeUnit.SECONDS) 
      .subscribe(textChanged -> { 
       Log.d("TAG", "Stopped typing!"); 
      }); 

Che cos'è l'operatore di rimbalzo? - Learn more about it here

Nel nostro contesto, antirimbalzo solo vi notifica del cambiamento testo all'interno della EditText dopo un certo tempo è passato dall'ultima sostituzione di testo che si è verificato all'interno del EditText.

Qui sto aspettando il 3 secondi fino a quando l'ultima modifica di testo è avvenuta per concludere che l'utente ha smesso di digitare. Puoi modificarlo in base alle tue esigenze.