How to Implement TextWatcher in Android?

The implementation of TextWatcher in Android enables developers to actively monitor and respond to real-time changes made to an EditText widget. The TextWatcher interface presents three essential methods: beforeTextChanged(), onTextChanged(), and afterTextChanged(). These methods are called at different stages during the text editing process, providing valuable opportunities for observation, intervention, and subsequent actions.

To implement TextWatcher, there are three approaches available: utilizing an anonymous inner class, applying inline implementation, or implementing the TextWatcher interface within your activity or fragment.

In each method, one needs to override the necessary TextWatcher methods. After that, the TextWatcher should be attached to the EditText widget by utilizing the addTextChangedListener() method. This approach allows for various actions to be pe-rformed, such as validation, filtering, or updating UI elements based on the user's input of text.

TextWatcher

Android provides the TextWatcher interface in the android.text package. This interface allows users to actively observe and respond to modifications made to an editable text component, such as an EditText widget, in real-time. The TextWatcher interface offers three callback methods for efficient monitoring of text changes:

• onTextChanged(): Called when the text is being changed. It provides information about the changing text, such as the updated text content, the starting and ending indices of the changed portion, and the number of characters inserted or deleted.

• afterTextChanged(): Called after the text has been changed. It provides an Editable object representing the updated text content.

By implementing the TextWatcher interface and overriding its methods, various actions can be performed based on the user's text input. These actions include validation, filtering, or dynamically updating UI elements.

Approaches

To implement the TextWatcher interface in Android, there are a few different ways you can approach it. Here are three common methods:

• Using Anonymous Inner Class

• Using Inline Implementation

• Using Implement TextWatcher in Activity/Fragment

Using Anonymous Inner Class

This method involves the creation of an anonymous inner class that directly implements the TextWatcher interface and overrides its methods. This approach allows for inline definition of the implementation without requiring a separate class.

Algorithm

• Create an anonymous inner class that implements the TextWatcher interface.

• Override the necessary methods (beforeTextChanged, onTextChanged, afterTextChanged) within the anonymous inner class.

• Attach the anonymous inner class instance to the EditText widget using the addTextChangedListener method.

• Inside the overridden methods, implement the desired logic to handle text changes.

Example

import android.text.Editable;
import android.text.TextWatcher;
import android.widget.EditText;
import androidx.appcompat.app.AppCompatActivity;
import android.os.Bundle;

public class MainActivity extends AppCompatActivity {
   @Override
   protected void onCreate(Bundle savedInstanceState) {
      super.onCreate(savedInstanceState);
      setContentView(R.layout.activity_main);

      EditText editText = findViewById(R.id.editText);
      editText.addTextChangedListener(new TextWatcher() {
         @Override
         public void beforeTextChanged(CharSequence s, int start, int count, int after) {
            // This method is called before the text is changed.
            System.out.println("Before Text Changed: " + s);
         }

         @Override
         public void onTextChanged(CharSequence s, int start, int before, int count) {
            // This method is called when the text is being changed.
            System.out.println("On Text Changed: " + s);
         }

         @Override
         public void afterTextChanged(Editable s) {
            // This method is called after the text has been changed.
            System.out.println("After Text Changed: " + s.toString());
         }
      });
   }
}

Output

Using Inline Implementation

Similar to the first method, this approach creates a separate TextWatcher object but still allows you to define the implementation inline. It provides more flexibility as you can reuse or reference the TextWatcher object elsewhere if needed.

Algorithm

• Create a TextWatcher object that implements the TextWatcher interface.

• Override the necessary methods (beforeTextChanged, onTextChanged, afterTextChanged) within the TextWatcher object.

• Attach the TextWatcher object to the EditText widget using the addTextChangedListener method.

• Inside the overridden methods, implement the desired logic to handle text changes.

Example

import android.text.Editable;
import android.text.TextWatcher;
import android.widget.EditText;
import androidx.appcompat.app.AppCompatActivity;
import android.os.Bundle;

public class MainActivity extends AppCompatActivity {
   @Override
   protected void onCreate(Bundle savedInstanceState) {
      super.onCreate(savedInstanceState);
      setContentView(R.layout.activity_main);

      EditText editText = findViewById(R.id.editText);
      TextWatcher textWatcher = new TextWatcher() {
         @Override
         public void beforeTextChanged(CharSequence s, int start, int count, int after) {
            // This method is called before the text is changed.
            System.out.println("Before Text Changed: " + s);
         }

         @Override
         public void onTextChanged(CharSequence s, int start, int before, int count) {
            // This method is called when the text is being changed.
            System.out.println("On Text Changed: " + s);
         }

         @Override
         public void afterTextChanged(Editable s) {
            // This method is called after the text has been changed.
            System.out.println("After Text Changed: " + s.toString());
         }
      };
      editText.addTextChangedListener(textWatcher);
   }
}

Output

Using Implement TextWatcher in Activity/Fragment

In this method, you implement the TextWatcher interface directly in your activity or fragment. By doing so, the activity or fragment itself handles the text changes, eliminating the need for separate objects. This approach is useful when you want to keep the text change logic within the same class.

Algorithm

• Implement the TextWatcher interface directly in your activity or fragment.

• Override the necessary methods (beforeTextChanged, onTextChanged, afterTextChanged) within the activity or fragment.

• In the appropriate lifecycle method (e.g., onCreate), find the EditText widget and attach the activity or fragment instance as the TextWatcher using the addTextChangedListener method.

• Inside the overridden methods, implement the desired logic to handle text changes.

Example

import android.text.Editable;
import android.text.TextWatcher;
import android.widget.EditText;
import androidx.appcompat.app.AppCompatActivity;
import android.os.Bundle;

public class MainActivity extends AppCompatActivity implements 
TextWatcher {
   @Override
   protected void onCreate(Bundle savedInstanceState) {
      super.onCreate(savedInstanceState);
      setContentView(R.layout.activity_main);

      EditText editText = findViewById(R.id.editText);
      editText.addTextChangedListener(this);
   }

   @Override
   public void beforeTextChanged(CharSequence s, int start, int count, int after) {
      // This method is called before the text is changed.
      System.out.println("Before Text Changed: " + s);
   }

   @Override
   public void onTextChanged(CharSequence s, int start, int before, int count) {
      // This method is called when the text is being changed.
      System.out.println("On Text Changed: " + s);
   }

   @Override
   public void afterTextChanged(Editable s) {
      // This method is called after the text has been changed.
      System.out.println("After Text Changed: " + s.toString());
   }
}

Output

Conclusion

In this tutorial, developers can efficiently monitor and respond to real-time changes in editable text components on Android by implementing the TextWatcher interface. By utilizing the be-foreTextChanged(), onTextChanged(), and afterTextChanged() methods, developers gain the ability to perform various actions such as input validation, dynamic UI updates, and data filtering.

Whether it involves handling user input in forms, implementing search functionality, or providing real-time feedback, TextWatcher empowers Android developers to create interactive and responsive user experiences with flexibility.