android EditText - terminé la saisie de l'événement

Lorsque l'utilisateur a terminé l'édition, il sera presse de la Done ou Enter

((EditText)findViewById(R.id.youredittext)).setOnEditorActionListener(
    new EditText.OnEditorActionListener() {
        @Override
        public boolean onEditorAction(TextView v, int actionId, KeyEvent event) {
            if (actionId == EditorInfo.IME_ACTION_SEARCH ||
                    actionId == EditorInfo.IME_ACTION_DONE ||
                    event != null &&
                    event.getAction() == KeyEvent.ACTION_DOWN &&
                    event.getKeyCode() == KeyEvent.KEYCODE_ENTER) {
                if (event == null || !event.isShiftPressed()) {
                   //the user is done typing. 

                   return true; //consume.
                }                
            }
            return false; //pass on to other listeners. 
        }
    }
);

Personnellement, je préfère automatique soumettre après la fin de la saisie. Voici comment vous pouvez détecter cet événement.

Déclarations et d'initialisation:

private Timer timer = new Timer();
private final long DELAY = 1000; //in ms

Auditeur, par exemple onCreate()

EditText editTextStop = (EditText) findViewById(R.id.editTextStopId);
    editTextStop.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) {
            if(timer != null)
                timer.cancel();
        }
        @Override
        public void afterTextChanged(final Editable s) {
            //avoid triggering event when text is too short
            if (s.length() >= 3) {              

                timer = new Timer();
                timer.schedule(new TimerTask() {
                    @Override
                    public void run() {
                        //TODO: do what you need here (refresh list)
                        //you will probably need to use
                        //runOnUiThread(Runnable action) for some specific
                        //actions
                        serviceConnector.getStopPoints(s.toString());
                    }

                }, DELAY);
            }
        }
    });

Ainsi, lorsque le texte est modifié, le minuteur commence à attendre pour les prochaines modifications à se produire. Quand ils se déroulent de la minuterie est annulée et puis a commencé une fois de plus.

Bien que de nombreuses réponses ne sont point dans la bonne direction, je pense qu'aucun d'entre eux répond à ce que l'auteur de la question a été de réfléchir. Ou, au moins, j'ai compris la question différemment, parce que je cherchais la réponse à un problème similaire.
Le problème est "Comment savoir lorsque l'utilisateur arrête de taper sans lui en appuyant sur un bouton", et déclencher une action (par exemple l'auto-complétion). Si vous souhaitez faire démarrer la Minuterie dans onTextChanged avec un retard que l'on peut considérer comme utilisateur arrêté de frappe (par exemple 500-700ms), pour chaque nouvelle lettre lorsque vous démarrez le chronomètre annuler la précédente (ou au moins utiliser une sorte de drapeau que quand ils tique qu'ils ne font rien). Voici un code similaire à ce que j'ai utilisé:

new Timer().schedule(new TimerTask() {
  @Override
  public void run() {
     if (!running) {                            
        new DoPost().execute(s.toString());
  });
 }
}, 700);

Noter que j'ai modifier exécution de drapeau booléen à l'intérieur de mon async task (Tâche devient le json à partir du serveur pour l'auto-complétion).

Également garder à l'esprit que cela crée beaucoup de minuterie de tâches (je pense qu'ils sont programmés sur le même Thread tu mais faudrait vérifier cela), alors il y a probablement beaucoup d'endroits pour s'améliorer, mais cette approche fonctionne aussi et la ligne de fond est que vous devez utiliser une Minuterie puisqu'il n'est pas "Utilisateur arrêté de taper événement"

Une approche différente ... voici un exemple:
Si l'utilisateur dispose d'un délai de 600-1000ms lors de la saisie, vous pouvez envisager de il est arrêté.

JS:

 myEditText.addTextChangedListener(new TextWatcher() {
             
            private String s;
            private long after;
			private Thread t;
            private Runnable runnable_EditTextWatcher = new Runnable() {
                @Override
                public void run() {
                    while (true) {
                        if ((System.currentTimeMillis() - after) > 600)
                        {
                            Log.d("Debug_EditTEXT_watcher", "(System.currentTimeMillis()-after)>600 ->  " + (System.currentTimeMillis() - after) + " > " + s);
                            //Do your stuff
                            t = null;
                            break;
                        }
                    }
                }
            };
            
            @Override
            public void onTextChanged(CharSequence ss, int start, int before, int count) {
                s = ss.toString();
            }
            
            @Override
            public void beforeTextChanged(CharSequence s, int start, int count, int after) {
            }
            
            @Override
            public void afterTextChanged(Editable ss) {
                after = System.currentTimeMillis();
                if (t == null)
                {
                    t = new Thread(runnable_EditTextWatcher);
                      t.start();
                }
            }
        });

J'ai eu le même problème et qui n'ont pas besoin de s'appuyer sur l'utilisateur en appuyant sur Fait ou Enter.

Ma première tentative a été d'utiliser le onFocusChange l'auditeur, mais il est apparu que mon EditText obtenu le focus par défaut. Lorsque l'utilisateur a appuyé sur quelque autre point de vue, la onFocusChange a été déclenchée sans que l'utilisateur n'avoir jamais attribué le focus.

Solution suivante il l'a fait pour moi, d'où le onFocusChange si l'utilisateur a touché le EditText:

final myEditText = new EditText(myContext); //make final to refer in onTouch
myEditText.setOnTouchListener(new OnTouchListener() {

        @Override
        public boolean onTouch(View v, MotionEvent event) {
            myEditText.setOnFocusChangeListener(new OnFocusChangeListener() {

                @Override
                public void onFocusChange(View v, boolean hasFocus) {
                    if(!hasFocus){
                        //user is done editing
                    }
                }
            }
        }
}

Dans mon cas, lorsque l'utilisateur a terminé le montage de l'écran a été réaffichées, en renouvelant la myEditText objet. Si le même objet est conservé, vous devriez probablement supprimer la onFocusChange auditeur dans onFocusChange pour empêcher la onFocusChange problème décrit au début de ce post.

J'ai fini le même problème et je ne pouvais pas utiliser la solution avec onEditorAction ou onFocusChange et je ne voulais pas essayer de la minuterie. Une minuterie est trop dangereux pour le mois de mai goût, parce que de toutes les discussions et trop imprévisibles, que vous ne savez pas quand vous code est exécuté.

La onEditorAction ne pas attraper lorsque l'utilisateur de quitter sans l'aide d'un bouton et si vous l'utilisez, s'il vous plaît notez que KeyEvent peut être null. L'accent n'est pas fiable à ses deux extrémités, l'utilisateur peut obtenir concentrer et de laisser sans entrer n'importe quel texte ou en sélectionnant le champ et l'utilisateur n'a pas besoin de quitter la dernière EditText champ.

Ma solution utiliser onFocusChange et d'un indicateur défini lorsque l'utilisateur démarre l'édition d'un texte et d'une fonction permettant d'obtenir le texte de la dernière vue, ce que j'appelle quand le besoin.

Je viens d'effacer l'accent sur tous mes champs de texte à tricker le congé de texte afficher le code, Le clearFocus code est exécuté seulement si le champ a le focus. J'ai appeler la fonction dans onSaveInstanceState donc je n'ai pas pour sauver le drapeau (mEditing) comme un état de l'EditText vue lors de boutons importants est cliqué et lorsque l'activité est fermé.

Être prudent avec TexWatcher comme il est appel souvent j'utilise la condition au point de ne pas réagir lorsque l'onRestoreInstanceState code de la saisie de texte.
Je

final EditText mEditTextView = (EditText) getView();
mEditTextView.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) {
if (!mEditing && mEditTextView.hasFocus()) {
mEditing = true;
}
}
});
mEditTextView.setOnFocusChangeListener(new View.OnFocusChangeListener() {
@Override
public void onFocusChange(View v, boolean hasFocus) {
if (!hasFocus && mEditing) {
mEditing = false;
///Do the thing
}
}
});
protected void saveLastOpenField(){
for (EditText view:getFields()){
view.clearFocus();
}
}