escucha de Cambios de Texto en Android

Sé que esto es viejo, pero alguien podría encontrarse con esto de nuevo algún día.

Tuve un problema similar en el que llamaría a setText en un EditText y onTextChanged sería llamado cuando no quería que lo hiciera. Mi primera solución fue escribir un poco de código después de llamar a setText() para deshacer el daño hecho por el oyente. Pero eso no fue muy elegante. Después de hacer algunas investigaciones y pruebas descubrí que usando getText ().clear() borra el texto de la misma manera que setText (""), pero ya que no está configurando el texto al oyente no se le llama, así que eso resolvió mi problema. Cambié todas mis llamadas setText ( "" ) a getText ().clear () y ya no necesitaba las vendas, así que tal vez eso también solucione tu problema.

Prueba esto:

Field1 = (EditText)findViewById(R.id.field1);
Field2 = (EditText)findViewById(R.id.field2);

Field1.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) {
      Field2.getText().clear();
   }
  });

Field2.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) {
     Field1.getText().clear();
   }
  });

Un poco tarde en una respuesta, pero aquí hay una solución reutilizable:

/**
 * An extension of TextWatcher which stops further callbacks being called as 
 * a result of a change happening within the callbacks themselves.
 */
public abstract class EditableTextWatcher implements TextWatcher {

    private boolean editing;

    @Override
    public final void beforeTextChanged(CharSequence s, int start, 
                                                    int count, int after) {
        if (editing)
            return;

        editing = true;
        try {
            beforeTextChange(s, start, count, after);
        } finally {
            editing = false;
        }
    }

    protected abstract void beforeTextChange(CharSequence s, int start, 
                                                     int count, int after);

    @Override
    public final void onTextChanged(CharSequence s, int start, 
                                                int before, int count) {
        if (editing)
            return;

        editing = true;
        try {
            onTextChange(s, start, before, count);
        } finally {
            editing = false;
        }
    }

    protected abstract void onTextChange(CharSequence s, int start, 
                                            int before, int count);

    @Override
    public final void afterTextChanged(Editable s) {
        if (editing)
            return;

        editing = true;
        try {
            afterTextChange(s);
        } finally {
            editing = false;
        }
    }

    public boolean isEditing() {
        return editing;
    }

    protected abstract void afterTextChange(Editable s);
}

Así que cuando se usa lo anterior, cualquier llamada setText() que ocurra dentro del TextWatcher no resultará en que el TextWatcher sea llamado de nuevo:

/**
 * A setText() call in any of the callbacks below will not result in TextWatcher being 
 * called again.
 */
public class MyTextWatcher extends EditableTextWatcher {

    @Override
    protected void beforeTextChange(CharSequence s, int start, int count, int after) {
    }

    @Override
    protected void onTextChange(CharSequence s, int start, int before, int count) {
    }

    @Override
    protected void afterTextChange(Editable s) {
    }
}

Compruebe la cadena antes de establecer otro EditText en vacío. si Field1 está vacío, ¿por qué necesita cambiar de nuevo a ("")? así que puedes comprobar el tamaño de Tu Cadena con s. lenght () o cualquier otra solución

Otra forma de comprobar la longitud de la cadena es:

String sUsername = Field1.getText().toString();
if (!sUsername.matches(""))
{
// do your job
}

También me he enfrentado al mismo problema y sigo obteniendo excepciones completas de pila, y vengo con la siguiente solución.

    edt_amnt_sent.addTextChangedListener(new TextWatcher() {    
        @Override
        public void afterTextChanged(Editable s) {

            if (skipOnChange)
                return;

            skipOnChange = true;
            try {
                //method
                }
            } catch (NumberFormatException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            } finally {
                skipOnChange = false;
            }
        }
    });

    edt_amnt_receive.addTextChangedListener(new TextWatcher() {


        @Override
        public void afterTextChanged(Editable s) {

            if (skipOnChange)
                return;

            skipOnChange = true;
            try 
            {
                //method
            } catch (NumberFormatException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            } finally {
                skipOnChange = false;
            }
        }
    });

Declarado inicialmente boolean skipOnChange = false;

Si estás usando Kotlin para el desarrollo de Android, puedes agregar el listener de cambios de texto usando este código:

myTextField.addTextChangedListener(object : TextWatcher{
        override fun afterTextChanged(s: Editable?) {}

        override fun beforeTextChanged(s: CharSequence?, start: Int, count: Int, after: Int) {}

        override fun onTextChanged(s: CharSequence?, start: Int, before: Int, count: Int) {}
    })

También puedes usar el método hasFocus ():

public void onTextChanged(CharSequence s, int start,
     int before, int count) {
     if (Field2.hasfocus()){
         Field1.setText("");
     }
   }

Probé esto para una tarea universitaria en la que estaba trabajando para convertir escalas de temperatura a medida que el usuario las escribía. Funcionó perfectamente, y es mucho más simple.