Android EditText borrar (retroceso) evento clave

NOTA: onKeyListener no funciona para teclados blandos.

Puede configurar OnKeyListener para editText para que pueda detectar cualquier tecla presionada
EDIT: Un error común que estamos comprobando KeyEvent.KEYCODE_BACK para backspace , pero realmente es KeyEvent.KEYCODE_DEL (Realmente ese nombre es confuso!)

 editText.setOnKeyListener(new OnKeyListener() { @Override public boolean onKey(View v, int keyCode, KeyEvent event) { //You can identify which key pressed buy checking keyCode value with KeyEvent.KEYCODE_ if(keyCode == KeyEvent.KEYCODE_DEL) { //this is for backspace } return false; } }); 

Ha pasado un tiempo desde que me preguntaste, pero tuve el mismo problema. Como ya se mencionó por Estel el problema con los oyentes clave es que sólo funcionan con teclados de hardware. Para hacer esto con un IME (teclado suave) , la solución es un poco más elaborada.

El único método que realmente queremos anular es sendKeyEvent en la clase InputConnection del InputConnection . Este método se llama cuando se producen eventos clave en un IME. Pero para superar esto, necesitamos implementar un EditText personalizado que reemplaza al método onCreateInputConnection , envolviendo el objeto InputConnection defecto en una clase proxy. : |

Suena complicado, pero aquí está el ejemplo más simple que podría inventar:

 public class ZanyEditText extends EditText { private Random r = new Random(); public ZanyEditText(Context context, AttributeSet attrs, int defStyle) { super(context, attrs, defStyle); } public ZanyEditText(Context context, AttributeSet attrs) { super(context, attrs); } public ZanyEditText(Context context) { super(context); } public void setRandomBackgroundColor() { setBackgroundColor(Color.rgb(r.nextInt(256), r.nextInt(256), r .nextInt(256))); } @Override public InputConnection onCreateInputConnection(EditorInfo outAttrs) { return new ZanyInputConnection(super.onCreateInputConnection(outAttrs), true); } private class ZanyInputConnection extends InputConnectionWrapper { public ZanyInputConnection(InputConnection target, boolean mutable) { super(target, mutable); } @Override public boolean sendKeyEvent(KeyEvent event) { if (event.getAction() == KeyEvent.ACTION_DOWN && event.getKeyCode() == KeyEvent.KEYCODE_DEL) { ZanyEditText.this.setRandomBackgroundColor(); // Un-comment if you wish to cancel the backspace: // return false; } return super.sendKeyEvent(event); } } } 

La línea con la llamada a setRandomBackgroundColor es donde ocurre mi acción especial de retroceso. En este caso, cambiar el color de fondo del EditText .

Si está inflando esto desde XML, recuerde usar el nombre completo del paquete como la etiqueta:

 <cc.buttfu.test.ZanyEditText android:layout_width="fill_parent" android:layout_height="wrap_content" android:id="@+id/somefield" ></cc.buttfu.test.ZanyEditText> 

Esto es sólo una adición a la respuesta de Idris, añadiendo en la anulación a deleteSurroundingText también. He encontrado más información sobre eso aquí: Android: Backspace en WebView / BaseInputConnection

 package com.elavon.virtualmerchantmobile.utils; import java.util.Random; import android.content.Context; import android.graphics.Color; import android.util.AttributeSet; import android.view.KeyEvent; import android.view.inputmethod.EditorInfo; import android.view.inputmethod.InputConnection; import android.view.inputmethod.InputConnectionWrapper; import android.widget.EditText; public class ZanyEditText extends EditText { private Random r = new Random(); public ZanyEditText(Context context, AttributeSet attrs, int defStyle) { super(context, attrs, defStyle); } public ZanyEditText(Context context, AttributeSet attrs) { super(context, attrs); } public ZanyEditText(Context context) { super(context); } public void setRandomBackgroundColor() { setBackgroundColor(Color.rgb(r.nextInt(256), r.nextInt(256), r .nextInt(256))); } @Override public InputConnection onCreateInputConnection(EditorInfo outAttrs) { return new ZanyInputConnection(super.onCreateInputConnection(outAttrs), true); } private class ZanyInputConnection extends InputConnectionWrapper { public ZanyInputConnection(InputConnection target, boolean mutable) { super(target, mutable); } @Override public boolean sendKeyEvent(KeyEvent event) { if (event.getAction() == KeyEvent.ACTION_DOWN && event.getKeyCode() == KeyEvent.KEYCODE_DEL) { ZanyEditText.this.setRandomBackgroundColor(); // Un-comment if you wish to cancel the backspace: // return false; } return super.sendKeyEvent(event); } @Override public boolean deleteSurroundingText(int beforeLength, int afterLength) { // magic: in latest Android, deleteSurroundingText(1, 0) will be called for backspace if (beforeLength == 1 && afterLength == 0) { // backspace return sendKeyEvent(new KeyEvent(KeyEvent.ACTION_DOWN, KeyEvent.KEYCODE_DEL)) && sendKeyEvent(new KeyEvent(KeyEvent.ACTION_UP, KeyEvent.KEYCODE_DEL)); } return super.deleteSurroundingText(beforeLength, afterLength); } } } 

Me envió 2 días para encontrar una solución y me di cuenta de un trabajo 🙂 (en las teclas programables)

 public TextWatcher textWatcher = 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) { if (count == 0) { //Put your code here. //Runs when delete/backspace pressed on soft key (tested on htc m8) //You can use EditText.getText().length() to make if statements here } } @Override public void afterTextChanged(Editable s) { } } 

Después de agregar el textwatcher a su EditText:

 yourEditText.addTextChangedListener(textWatcher); 

Espero que funcione en otros dispositivos androides también (samsung, LG, etc).

Aquí está mi solución fácil, que funciona para todos los API:

 private int mPreviousLength; private boolean mBackSpace; // ... @Override public void beforeTextChanged(CharSequence s, int start, int count, int after) { mPreviousLength = s.length(); } @Override public void onTextChanged(CharSequence s, int start, int before, int count) { } @Override public void afterTextChanged(Editable s) { mBackSpace = mPreviousLength > s.length(); if (mBackSpace) { // do your stuff ... } } 

Ejemplo de creación de EditText con TextWatcher

 EditText someEdit=new EditText(this); //create TextWatcher for our EditText TextWatcher1 TW1 = new TextWatcher1(someEdit); //apply our TextWatcher to EditText someEdit.addTextChangedListener(TW1); 

TextWatcher personalizado

 public class TextWatcher1 implements TextWatcher { public EditText editText; //constructor public TextWatcher1(EditText et){ super(); editText = et; //Code for monitoring keystrokes editText.setOnKeyListener(new View.OnKeyListener() { @Override public boolean onKey(View v, int keyCode, KeyEvent event) { if(keyCode == KeyEvent.KEYCODE_DEL){ editText.setText(""); } return false; } }); } //Some manipulation with text public void afterTextChanged(Editable s) { if(editText.getText().length() == 12){ editText.setText(editText.getText().delete(editText.getText().length() - 1, editText.getText().length())); editText.setSelection(editText.getText().toString().length()); } if (editText.getText().length()==2||editText.getText().length()==5||editText.getText().length()==8){ editText.setText(editText.getText()+"/"); editText.setSelection(editText.getText().toString().length()); } } public void beforeTextChanged(CharSequence s, int start, int count, int after){ } public void onTextChanged(CharSequence s, int start, int before, int count) { } } 

Hay una pregunta similar en el Stackoverflow. Necesita reemplazar EditText para obtener acceso al objeto InputConnection que contiene el método deleteSurroundingText . Le ayudará a detectar el evento de eliminación (retroceso). Por favor, eche un vistazo a una solución que proporcioné allí Android – no puede capturar backspace / borrar la prensa en suave. teclado

Esto parece estar funcionando para mí:

 public void onTextChanged(CharSequence s, int start, int before, int count) { if (before - count == 1) { onBackSpace(); } else if (s.subSequence(start, start + count).toString().equals("\n")) { onNewLine(); } } 

También me he enfrentado el mismo problema en Dialog .. porque estoy usando setOnKeyListener .. Pero establezco true return true. Después del cambio, como debajo del código que funciona bien para mí ..

  mDialog.setOnKeyListener(new Dialog.OnKeyListener() { @Override public boolean onKey(DialogInterface arg0, int keyCode, KeyEvent event) { if (keyCode == KeyEvent.KEYCODE_BACK) { mDialog.dismiss(); return true; } return false;//this line is important } }); 

Basado en @Jiff ZanyEditText aquí es WiseEditText con setSoftKeyListener(OnKeyListener)

 package com.locopixel.seagame.ui.custom; import java.util.Random; import android.content.Context; import android.graphics.Color; import android.support.v7.widget.AppCompatEditText; import android.util.AttributeSet; import android.view.KeyEvent; import android.view.inputmethod.EditorInfo; import android.view.inputmethod.InputConnection; import android.view.inputmethod.InputConnectionWrapper; public class WiseEditText extends AppCompatEditText { private Random r = new Random(); private OnKeyListener keyListener; public WiseEditText(Context context, AttributeSet attrs, int defStyle) { super(context, attrs, defStyle); } public WiseEditText(Context context, AttributeSet attrs) { super(context, attrs); } public WiseEditText(Context context) { super(context); } @Override public InputConnection onCreateInputConnection(EditorInfo outAttrs) { return new MyInputConnection(super.onCreateInputConnection(outAttrs), true); } private class MyInputConnection extends InputConnectionWrapper { public MyInputConnection(InputConnection target, boolean mutable) { super(target, mutable); } @Override public boolean sendKeyEvent(KeyEvent event) { if (keyListener != null) { keyListener.onKey(WiseEditText.this,event.getKeyCode(),event); } return super.sendKeyEvent(event); } @Override public boolean deleteSurroundingText(int beforeLength, int afterLength) { // magic: in latest Android, deleteSurroundingText(1, 0) will be called for backspace if (beforeLength == 1 && afterLength == 0) { // backspace return sendKeyEvent(new KeyEvent(KeyEvent.ACTION_DOWN, KeyEvent.KEYCODE_DEL)) && sendKeyEvent(new KeyEvent(KeyEvent.ACTION_UP, KeyEvent.KEYCODE_DEL)); } return super.deleteSurroundingText(beforeLength, afterLength); } } public void setSoftKeyListener(OnKeyListener listener){ keyListener = listener; } } 

Puede establecer un oyente clave en la actividad y, en el método de devolución de llamada, puede detectar qué clave ha alcanzado el usuario. El código a continuación es para su referencia. Espero eso ayude.

 //after user hits keys, this method would be called. public boolean onKeyUp(int keyCode, KeyEvent event) { if (editText.isFocused()) { switch (keyCode) { case KeyEvent.KEYCODE_DEL: //delete key Log.i("INFO", "delete key hit"); //you should see this log in ddms after you hit delete key break; } } return super.onKeyUp(keyCode, event); }