Introduction

To make an EditText lose focus in Android, calling clearFocus() is usually necessary but often not sufficient. Focus rarely disappears into nothing. It usually moves to another focusable view, and if you also want the keyboard to go away, you need to hide it separately. That is why the practical fix is usually: clear focus, move focus elsewhere, and dismiss the keyboard.

The Basic Approach

The simplest code looks like this:

val editText = findViewById<EditText>(R.id.searchInput)
editText.clearFocus()

This removes focus from the EditText itself, but in many layouts Android will immediately move focus back to it or to another view depending on the focus rules of the screen.

So in real apps you usually want a dedicated target for the new focus.

Move Focus to Another View

A common pattern is to make the root layout focusable and request focus on it:

1<LinearLayout
2    android:id="@+id/rootLayout"
3    android:layout_width="match_parent"
4    android:layout_height="match_parent"
5    android:focusable="true"
6    android:focusableInTouchMode="true"
7    android:orientation="vertical">
8
9    <EditText
10        android:id="@+id/searchInput"
11        android:layout_width="match_parent"
12        android:layout_height="wrap_content" />
13</LinearLayout>

Then in code:

1val root = findViewById<View>(R.id.rootLayout)
2val editText = findViewById<EditText>(R.id.searchInput)
3
4editText.clearFocus()
5root.requestFocus()

This gives Android somewhere valid to move focus, which makes the result more stable.

Hide the Keyboard Too

If your real goal is “stop editing and close the keyboard,” add input-method handling as well:

1val imm = getSystemService(Context.INPUT_METHOD_SERVICE) as InputMethodManager
2imm.hideSoftInputFromWindow(editText.windowToken, 0)
3editText.clearFocus()
4root.requestFocus()

Without the keyboard call, the EditText may lose focus while the soft keyboard still remains visible for a moment or until the next interaction.

A Complete Helper Function

A small helper keeps this behavior reusable:

1fun clearEditTextFocus(editText: EditText, fallbackView: View, context: Context) {
2    val imm = context.getSystemService(Context.INPUT_METHOD_SERVICE) as InputMethodManager
3    imm.hideSoftInputFromWindow(editText.windowToken, 0)
4    editText.clearFocus()
5    fallbackView.requestFocus()
6}

Usage:

clearEditTextFocus(searchInput, rootLayout, this)

This is the sort of helper that belongs in form-heavy activities or fragments.

When the EditText Regains Focus Immediately

If the field keeps taking focus back, there is usually another cause in the layout or lifecycle:

• the EditText is the only focusable view
• code later calls requestFocus() on it again
• the layout requests initial focus during screen startup
• a dialog or fragment transaction changes focus behavior

A temporary workaround some developers try is:

android:focusable="false"
android:focusableInTouchMode="false"

But that is only correct if the field really should stop being editable for a while. It is not a general-purpose focus-clearing solution.

A Common XML Trick for Initial Focus

If the problem is that the EditText grabs focus automatically when the screen opens, add a dummy or parent focus target before it:

1<LinearLayout
2    android:layout_width="match_parent"
3    android:layout_height="match_parent"
4    android:orientation="vertical"
5    android:focusable="true"
6    android:focusableInTouchMode="true">
7
8    <EditText
9        android:id="@+id/nameInput"
10        android:layout_width="match_parent"
11        android:layout_height="wrap_content" />
12</LinearLayout>

This often prevents automatic initial focus without disabling the EditText completely.

Java Version

The same idea in Java:

1View root = findViewById(R.id.rootLayout);
2EditText editText = findViewById(R.id.searchInput);
3InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
4
5imm.hideSoftInputFromWindow(editText.getWindowToken(), 0);
6editText.clearFocus();
7root.requestFocus();

The logic is unchanged: hide keyboard, clear focus, move focus elsewhere.

Common Pitfalls

The biggest pitfall is calling clearFocus() and expecting focus to vanish without another view taking it. Android focus usually transfers rather than disappearing.

Another common mistake is forgetting the keyboard. Removing focus and hiding the keyboard are related actions, but they are not the same thing.

People also often set focusable="false" on the EditText when they really only wanted to dismiss it temporarily. That can break later editing behavior.

Finally, if focus returns immediately, inspect the rest of the layout and lifecycle code. Something else is probably requesting focus again.

Summary

• 'editText.clearFocus() is the starting point, not always the full solution.'
• Move focus to another valid view, often the root layout.
• Hide the soft keyboard separately if that is part of the desired UX.
• Use XML root focus settings to prevent unwanted initial focus on screen load.
• If the field keeps regaining focus, look for another explicit or implicit focus request in your code or layout.