¿Cómo usar la clase TextWatcher en Android?

¿Alguien puede decirme cómo enmascarar la subcadena en EditText o cómo cambiar la entrada de subcadena EditText al tipo de contraseña o reemplazar por otro carácter como este 123xxxxxxxxx3455

String contents = et1.getText().toString(); et1.setText(contents.replace.substring(0, contents.length()-2),"*"); 

Por favor, dígame cómo puedo usar el método TextWatcher en Android.

Para el uso del TextWatcher

 et1.addTextChangedListener(new TextWatcher() { @Override public void onTextChanged(CharSequence s, int start, int before, int count) { // TODO Auto-generated method stub } @Override public void beforeTextChanged(CharSequence s, int start, int count, int after) { // TODO Auto-generated method stub } @Override public void afterTextChanged(Editable s) { // TODO Auto-generated method stub } }); 

La interfaz TextWatcher tiene 3 métodos de callback que se TextWatcher en el siguiente orden cuando se produce un cambio en el texto:

1 beforeTextChanged(CharSequence s, int start, int count, int after)

: Se llama antes de que los cambios se hayan aplicado al texto.
El parámetro s es el texto antes de aplicar cualquier cambio.
El parámetro de start es la posición del comienzo de la parte modificada en el texto.
El parámetro de count es la longitud de la parte modificada en la secuencia s desde la posición start .
Y el parámetro after es la longitud de la nueva secuencia que reemplazará la parte de la secuencia s de start a start+count .
No debe cambiar el texto en TextView desde este método (usando myTextView.setText(String newText) ).

2 onTextChanged(CharSequence s, int start, int before, int count)

Similar al método beforeTextChanged pero llamado después de que el texto cambie.
El parámetro s es el texto después de aplicar los cambios.
El parámetro de start es el mismo que en el método beforeTextChanged .
El parámetro count es el parámetro after en el método beforeTextChanged.
Y el parámetro before es el parámetro de count en el método beforeTextChanged.
No debe cambiar el texto en TextView desde este método (usando myTextView.setText(String newText) ).

3 afterTextChanged(Editable s)

Puede cambiar el texto en TextView desde este método.
/! \ Advertencia: cuando cambie el texto en el TextView , el TextWatcher se activará nuevamente, comenzando un ciclo infinito. A continuación, debe agregar como una propiedad boolean _ignore que previene el bucle infinito.
Ejemplo:

 new TextWatcher() { boolean _ignore = false; // indicates if the change was made by the TextWatcher itself. @Override public void afterTextChanged(Editable s) { if (_ignore) return; _ignore = true; // prevent infinite loop // Change your text here. // myTextView.setText(myNewText); _ignore = false; // release, so the TextWatcher start to listen again. } // Other methods... } 

Resumen:

enter image description here

Mi oyente personalizado:

Personalmente, hice mi oyente de texto personalizado, que me da las 4 partes en cadenas separadas, que para mi es mucho más intuitivo de usar.

  /** * Text view listener which splits the update text event in four parts: * 
    *
  • The text placed before the updated part.
  • *
  • The old text in the updated part.
  • *
  • The new text in the updated part.
  • *
  • The text placed after the updated part.
  • *
* Created by Jeremy B. */ public abstract class TextViewListener implements TextWatcher { /** * Unchanged sequence which is placed before the updated sequence. */ private String _before; /** * Updated sequence before the update. */ private String _old; /** * Updated sequence after the update. */ private String _new; /** * Unchanged sequence which is placed after the updated sequence. */ private String _after; /** * Indicates when changes are made from within the listener, should be omitted. */ private boolean _ignore = false; @Override public void beforeTextChanged(CharSequence sequence, int start, int count, int after) { _before = sequence.subSequence(0,start).toString(); _old = sequence.subSequence(start, start+count).toString(); _after = sequence.subSequence(start+count, sequence.length()).toString(); } @Override public void onTextChanged(CharSequence sequence, int start, int before, int count) { _new = sequence.subSequence(start, start+count).toString(); } @Override public void afterTextChanged(Editable sequence) { if (_ignore) return; onTextChanged(_before, _old, _new, _after); } /** * Triggered method when the text in the text view has changed. *
* You can apply changes to the text view from this method * with the condition to call {@link #startUpdates()} before any update, * and to call {@link #endUpdates()} after them. * * @param before Unchanged part of the text placed before the updated part. * @param old Old updated part of the text. * @param aNew New updated part of the text? * @param after Unchanged part of the text placed after the updated part. */ protected abstract void onTextChanged(String before, String old, String aNew, String after); /** * Call this method when you start to update the text view, so it stops listening to it and then prevent an infinite loop. * @see #endUpdates() */ protected void startUpdates(){ _ignore = true; } /** * Call this method when you finished to update the text view in order to restart to listen to it. * @see #startUpdates() */ protected void endUpdates(){ _ignore = false; } }

Ejemplo:

 myEditText.addTextChangedListener(new TextViewListener() { @Override protected void onTextChanged(String before, String old, String aNew, String after) { // intuitive usation of parametters String completeOldText = before + old + after; String completeNewText = before + aNew + after; // update TextView startUpdates(); // to prevent infinite loop. myEditText.setText(myNewText); endUpdates(); } 

Respuesta suplementaria

Aquí hay un suplemento visual para las otras respuestas. Mi respuesta más completa con el código y las explicaciones está aquí .

  • Rojo: texto a punto de ser eliminado (reemplazado)
  • Verde: texto que acaba de agregarse (reemplaza el antiguo texto rojo)

enter image description here

Usando TextWatcher en Android

Aquí hay un código de muestra. Intenta usar el método addTextChangedListener de TextView

 addTextChangedListener(new TextWatcher() { BigDecimal previousValue; BigDecimal currentValue; @Override public void onTextChanged(CharSequence s, int start, int before, int count) { if (isFirstTimeChange) { return; } if (s.toString().length() > 0) { try { currentValue = new BigDecimal(s.toString().replace(".", "").replace(',', '.')); } catch (Exception e) { currentValue = new BigDecimal(0); } } } @Override public void beforeTextChanged(CharSequence s, int start, int count, int after) { if (isFirstTimeChange) { return; } if (s.toString().length() > 0) { try { previousValue = new BigDecimal(s.toString().replace(".", "").replace(',', '.')); } catch (Exception e) { previousValue = new BigDecimal(0); } } } @Override public void afterTextChanged(Editable editable) { if (isFirstTimeChange) { isFirstTimeChange = false; return; } if (currentValue != null && previousValue != null) { if ((currentValue.compareTo(previousValue) > 0)) { //setBackgroundResource(R.color.devises_overview_color_green); setBackgroundColor(flashOnColor); } else if ((currentValue.compareTo(previousValue) < 0)) { //setBackgroundResource(R.color.devises_overview_color_red); setBackgroundColor(flashOffColor); } else { //setBackgroundColor(textColor); } handler.removeCallbacks(runnable); handler.postDelayed(runnable, 1000); } } }); 

Crear una subclase personalizada de TextWatcher:

 public class CustomWatcher implements TextWatcher { private boolean mWasEdited = 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) { } @Override public void afterTextChanged(Editable s) { if (mWasEdited){ mWasEdited = false; return; } // get entered value (if required) String enteredValue = s.toString(); String newValue = "new value"; // don't get trap into infinite loop mWasEdited = true; // just replace entered value with whatever you want s.replace(0, s.length(), newValue); } } 

Establecer oyente para su EditText:

 mTargetEditText.addTextChangedListener(new CustomWatcher()); 

Una perspectiva un poco más grande de la solución:

 @Override public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) { View v = inflater.inflate(R.layout.yourlayout, container, false); View tv = v.findViewById(R.id.et1); ((TextView) tv).addTextChangedListener(new TextWatcher() { @Override public void onTextChanged(CharSequence s, int start, int before, int count) { SpannableString contentText = new SpannableString(((TextView) tv).getText()); String contents = Html.toHtml(contentText).toString(); } @Override public void beforeTextChanged(CharSequence s, int start, int count, int after) { // TODO Auto-generated method stub } @Override public void afterTextChanged(Editable s) { // TODO Auto-generated method stub } }); return v; } 

Esto funciona para mí, haciéndolo la primera vez.

  public class Test extends AppCompatActivity { EditText firstEditText; EditText secondEditText; @Override protected void onCreate(@Nullable Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.test); firstEditText = (EditText)findViewById(R.id.firstEditText); secondEditText = (EditText)findViewById(R.id.secondEditText); firstEditText.addTextChangedListener(new EditTextListener()); } private class EditTextListener implements 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) { secondEditText.setText(firstEditText.getText()); } @Override public void afterTextChanged(Editable s) { } } } 
 editext1.addTextChangedListener(new TextWatcher() { @Override public void onTextChanged(CharSequence s, int start, int before, int count) { editext2.setText(new String(s.toString())); } @Override public void beforeTextChanged(CharSequence s, int start, int count, int after) { editext2.setText(new String(s.toString())); } @Override public void afterTextChanged(Editable s) { editext2.setText(new String(s.toString())); } }); 

Para obtener más información, haga clic aquí http://androiddhina.blogspot.in/2015/05/android-textwatcher.html