EditText: What It Is, Attributes, and Working with Input Fields in Android

What is EditText in Android

EditText is a class from the android.widget package that implements an interactive text field for user data input. In the Android inheritance hierarchy, EditText extends TextView, so it inherits all properties of a text label, including font, color and alignment management. The main difference between EditText and TextView is the ability to edit content — users can enter, delete and modify text directly in the interface.

Each EditText is associated with an Editable instance that stores the entered text and supports insert, delete and replace operations. When typing, EditText automatically manages cursor position, text selection and an undo/redo change history. According to the Android Developers Guide (2026), EditText also supports autocomplete through the AutoCompleteTextView class, which inherits from EditText.

The EditText architecture is built on the separation of model (Editable), view (TextView) and controller (InputConnection). When gaining focus, EditText creates an InputConnection through which the input system passes characters, key presses and editing commands. This mechanism ensures compatibility with any input method — from virtual keyboards to physical Bluetooth keyboards and voice input.

val editText = EditText(context).apply {
    hint = "Enter text"
    inputType = InputType.TYPE_CLASS_TEXT
    maxLines = 1
    setTextColor(Color.parseColor("#000000"))
}

Key EditText Attributes

EditText provides dozens of attributes for fine-tuning behavior and appearance. They can be set both in XML layouts and programmatically via Kotlin or Java. Attributes fall into categories: text control, constraints, visual styling and keyboard interaction.

The android:hint attribute is one of the most important — it tells the user what data is expected in the field. When text is entered, the hint is automatically hidden. The hint does not participate in form submission and is not saved as a field value. Material Design recommends using TextInputLayout with a floating label instead of a plain hint for a more modern look.

• android:selectAllOnFocus — selects all text when the field gains focus (useful for search fields).
• android:maxLength — limits the number of input characters, truncating excess.
• android:lines — sets a fixed field height in lines (unlike minLines).
• android:gravity — text alignment within the field: left, center, top, etc.

                <!-- EditText in XML layout -->
@+id/etEmail
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:hint="Enter email"
android:inputType="textEmailAddress"
android:maxLines="1"
android:importantForAutofill="yes" />

Input Modes and inputType

The inputType attribute determines which keyboard type will be shown to the user and which characters are allowed for input. It is a bitmask where the input class (TYPE_CLASS_TEXT, TYPE_CLASS_NUMBER, TYPE_CLASS_PHONE) is combined with modifiers.

Each input mode not only changes the keyboard layout but also affects text processing: in numeric mode only digits and decimal separators are allowed, in email mode the @ symbol and domain extensions are available, and in phone mode digits and +, #, * symbols are displayed. Choosing the correct inputType critically affects user experience — an inappropriate keyboard forces users to switch modes, increasing form fill time by 30–50%.

According to the Material Design Guidelines (2025), it is recommended to use the most specific inputType for each field: textPassword for passwords, numberDecimal for prices, phone for phone numbers, textMultiLine for multi-line input. This speeds up form filling and reduces input errors.

// Programmatic inputType setup
editText.inputType = InputType.TYPE_CLASS_TEXT or
    InputType.TYPE_TEXT_FLAG_CAP_SENTENCES or
    InputType.TYPE_TEXT_FLAG_AUTO_CORRECT

EditText Listeners: TextWatcher and OnEditorActionListener

TextWatcher is an interface for tracking text changes in EditText in real time. It contains three methods: beforeTextChanged is called before a change, onTextChanged is called during the change, afterTextChanged is called after the text change completes. TextWatcher is used for input validation, character counting, search and autocomplete.

OnEditorActionListener handles user actions on the keyboard: pressing Done (IME_ACTION_DONE), Search (IME_ACTION_SEARCH), Send (IME_ACTION_SEND), Next field (IME_ACTION_NEXT) and others. This listener is especially useful for organizing form navigation — when pressing Next, focus automatically moves to the next field, and when pressing Done, the keyboard is hidden and submission is performed.

According to the Android Developers Blog (2025), proper use of OnEditorActionListener with the android:imeOptions attribute allows creating intuitive forms without additional submit buttons — the user fills in fields and presses Done on the keyboard, triggering save or search.

// TextWatcher for email validation
editText.addTextChangedListener(object : TextWatcher {
    override fun afterTextChanged(s: Editable?) {
        val isValid = Patterns.EMAIL_ADDRESS.matcher(s).matches()
        editText.error = if (isValid) null else "Invalid email format"
    }
})

// OnEditorActionListener for form submission
editText.setOnEditorActionListener { _, actionId, _ ->
    if (actionId == EditorInfo.IME_ACTION_DONE) {
        submitForm()
        true
    } else false
}

EditText Code Examples

Let us look at a complete example of creating a login screen using EditText for email and password input. This example demonstrates inputType configuration, validation via TextWatcher and handling of the login button press.

Login Screen XML Layout

@+id/etLoginEmail
android:layout_width="match_parent"
android:hint="Email"
android:inputType="textEmailAddress"
android:maxLines="1" />

@+id/etLoginPassword
android:layout_width="match_parent"
android:hint="Password"
android:inputType="textPassword"
android:maxLines="1" />

Programmatic EditText Setup

class LoginFragment : Fragment() {
    private lateinit var etEmail: EditText
    private lateinit var etPassword: EditText

    override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
        etEmail = view.findViewById(R.id.etLoginEmail)
        etPassword = view.findViewById(R.id.etLoginPassword)

        etEmail.addTextChangedListener(emailWatcher)
        etPassword.setOnEditorActionListener { _, actionId, _ ->
            if (actionId == EditorInfo.IME_ACTION_DONE) {
                performLogin()
                true
            } else false
        }
    }
}

Styling EditText

EditText supports customization through XML attributes, themes and styles. You can change text color, hint color, underline color (backgroundTint), font style, text size and much more. Material Components provides the MaterialComponents.EditText theme with custom attributes including boxStrokeColor, boxBackgroundColor and endIconMode.

To change the EditText underline color, use the android:backgroundTint attribute, which sets the color for default and focused states. In Material Design, the underline color is managed through the theme's colorPrimary. For full customization, you can create a custom drawable for the background in the res/drawable folder.

To create a consistent style for all EditText fields in your app, it is recommended to define a global style in the theme. Material Design offers the Widget.MaterialComponents.TextInputLayout.OutlinedBox style, which is automatically applied to all input fields using TextInputLayout. This ensures a consistent look without duplicating attributes in every layout.