android - seleccionar - guia de configuración de accesibilidad motorola

Detectar botón de borrado en teclado suave

Question

Tengo dos EditText (cada uno solo acepta un carácter) y quiero manejar ambos campos como si solo tuviera uno.

Estoy usando un TextWatcher para establecer el enfoque en el segundo cuando el usuario escribe un carácter en el primero, pero no sé cómo hacer lo contrario.

Si el usuario presiona el botón de eliminar en el segundo EditText (quedando este EditText vacío) quiero mover el foco al primer EditText y eliminar el carácter allí.

El problema es que TextWatcher no funciona cuando el usuario intenta eliminar un campo vacío (porque en realidad nada está cambiando). Y el evento onKeyDown solo funciona con teclados duros, así que no tengo idea de cómo tratar este problema ...

¡Gracias!

Answer 1

Lo EditText anulando EditText para obtener acceso al objeto InputConnection que contiene el método deleteSurroundingText . Ayuda a detectar el evento de eliminación (retroceso). Por favor, eche un vistazo a una solución que proporcioné allí: Android: no puede capturar retroceso / borrado, presione suavemente. teclado

Esta solución funciona correctamente para hardKeyboard y softKeyboard.

Answer 2

Posible duplicado del evento clave Android EditText delete (retroceso)

simplemente revisé el código de esa pregunta (que en realidad proviene de la pregunta provista y respondida por Labeeb P) con el proyecto de prueba con solo dos ediciones en el diseño y parece funcionar bien. Puedo recibir la eliminación incluso si la edición es vacío.

    final EditText edit1 = (EditText) findViewById(R.id.editText1);

    edit1.setOnKeyListener(new View.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
                Log.e("IME_TEST", "DEL KEY");
            }
            return false;
        }
    });

Parece que la documentación de Android de EditText debería ser más clara o al menos cualquier guía para la interacción de EditText - Soft Keyboard que se proporciona, porque hay muchas otras típicas que deberían ser desarrolladas por casi todos los desarrolladores.

ACTUALIZACIÓN: Parece que esto no funciona en las últimas versiones de Android (al menos después de 4.1). Esta respuesta parece funcionar en las versiones posteriores a 4.1.

Answer 3

Una solución más simple para esto que encontré es usar un InputFilter . El método filter() InputFilter parece informar todos los eventos de teclado virtual, incluso aquellos en los que el valor de EditText no está cambiando.

Entonces, para abordar su situación específica, construya un filtro de entrada y establezca en consecuencia:

private InputFilter filter = (charSequence, start, end, dest, dStart, dEnd) -> {

    if (end == 0 || dStart < dEnd) {
        // backspace was pressed! handle accordingly
    }

    return charSequence;
};

...

myEditText.setFilters(new InputFilter[] { filter });

Los eventos de retroceso se pueden evaluar utilizando end , dStart y dEnd . dStart siempre será menor que dEnd si se eliminó un carácter. Si EditText está vacío, aún puede evaluar las pulsaciones de retroceso marcando si end == 0.

Tenga en cuenta que las eliminaciones masivas también se detectarán en esta declaración if , por lo que es posible que desee realizar algunas comprobaciones adicionales dentro del filter() . También tenga en cuenta que si está utilizando el teclado de su computadora para escribir en EditTexts en emuladores, puede obtener resultados inesperados. Mejor hacer clic en los botones de software para la prueba.

Answer 4

Use la Extensión que se proporciona en https://github.com/ciasaboark/Android-Shell/blob/master/src/com/example/com/programmingthetux/tutorial/ZanyEditText.java

import java.util.Random;

import android.content.Context;
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;
/**
 * Created by mkallingal on 4/25/2016.
 */
public class CustomEditText extends EditText {

    private Random r = new Random();

    public CustomEditText(Context context, AttributeSet attrs, int defStyle) {
        super(context, attrs, defStyle);
    }

    public CustomEditText(Context context, AttributeSet attrs) {
        super(context, attrs);
    }

    public CustomEditText(Context context) {
        super(context);
    }

    public void setRandomBackgroundColor() {

    }

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

    }
}

Ahora puedes usarlo en tu Actividad así:

final CustomEditText _EditText = new CustomEditText(_Context);

     _EditText.setOnKeyListener(new View.OnKeyListener() {
                    @Override
                    public boolean onKey(View v, int keyCode, KeyEvent event) {
                        if (keyCode == KeyEvent.KEYCODE_DEL) {
                            String _text=_EditText.getText().toString();
                            if(StringUtils.isBlank(_text))
                                 //EditText is now empty
                            }
                        }
                        return false;
                    }
                });