Закрыть / скрыть Soft Soft

В моем макете есть EditText и Button .

После записи в поле редактирования и нажатия на Button я хочу скрыть виртуальную клавиатуру. Я предполагаю, что есть простой, один или двухстрочный код, чтобы это произошло.

Где я могу найти пример?

Solutions Collecting From Web of "Закрыть / скрыть Soft Soft"

Вы можете заставить Android скрыть виртуальную клавиатуру с помощью InputMethodManager , вызвав hideSoftInputFromWindow , передав токен окна, содержащего ваше сфокусированное представление.

 // Check if no view has focus: View view = this.getCurrentFocus(); if (view != null) { InputMethodManager imm = (InputMethodManager)getSystemService(Context.INPUT_METHOD_SERVICE); imm.hideSoftInputFromWindow(view.getWindowToken(), 0); } 

Это заставит клавиатуру быть скрытой во всех ситуациях. В некоторых случаях вы захотите передать в InputMethodManager.HIDE_IMPLICIT_ONLY в качестве второго параметра, чтобы убедиться, что вы скрываете клавиатуру, когда пользователь явно не заставлял ее отображаться (удерживая нажатой клавишу меню).

Чтобы помочь прояснить это безумие, я хотел бы начать с извинения от имени всех пользователей Android за простое смешное обращение с Google к мягкой клавиатуре. Причина в том, что так много ответов, по-разному, по одному и тому же вопросу, потому что этот API, как и многие другие в Android, ужасно разработан. Я не могу думать о том, чтобы не сказать об этом.

Я хочу скрыть клавиатуру. Я ожидаю, что Android предоставит следующее заявление: Keyboard.hide() . Конец. Большое спасибо. Но у Android есть проблема. Вы должны использовать InputMethodManager чтобы скрыть клавиатуру. Хорошо, отлично, это API Android на клавиатуре. НО! Для доступа к IMM требуется Context . Теперь у нас есть проблема. Возможно, я хочу скрыть клавиатуру от статического или служебного класса, который не нужен или нужен для любого Context . Или И еще хуже, IMM требует, чтобы вы указали, какой View (или что еще хуже, какое Window ) вы хотите скрыть клавиатуру FROM.

Это то, что скрывает клавиатуру так сложно. Дорогой Google: Когда я ищу рецепт для пирога, на Земле нет RecipeProvider , который откажется предоставить мне рецепт, если я не отвечу сначала, что торт будет съеден И где он будет съеден !!

Эта печальная история заканчивается уродливой правдой: чтобы скрыть клавиатуру Android, вам потребуется предоставить две формы идентификации: Context и либо View либо Window .

Я создал статический метод утилиты, который может выполнять работу ОЧЕНЬ солидно, если вы вызываете его из Activity .

 public static void hideKeyboard(Activity activity) { InputMethodManager imm = (InputMethodManager) activity.getSystemService(Activity.INPUT_METHOD_SERVICE); //Find the currently focused view, so we can grab the correct window token from it. View view = activity.getCurrentFocus(); //If no view currently has focus, create a new one, just so we can grab a window token from it if (view == null) { view = new View(activity); } imm.hideSoftInputFromWindow(view.getWindowToken(), 0); } 

Имейте в виду, что этот метод утилиты ТОЛЬКО работает при вызове из Activity ! Вышеупомянутый метод вызывает getCurrentFocus целевого Activity для извлечения правильного токена окна.

Но предположим, что вы хотите скрыть клавиатуру из EditText размещенного в DialogFragment ? Вы не можете использовать вышеописанный метод:

 hideKeyboard(getActivity()); //won't work 

Это не сработает, потому что вы передадите ссылку на хост- Activity Fragment , в которой не будет сфокусированного управления, пока отображается Fragment ! Вау! Поэтому, скрывая клавиатуру от фрагментов, я прибегаю к более низкому уровню, более распространенному и уродливому:

 public static void hideKeyboardFrom(Context context, View view) { InputMethodManager imm = (InputMethodManager) context.getSystemService(Activity.INPUT_METHOD_SERVICE); imm.hideSoftInputFromWindow(view.getWindowToken(), 0); } 

Ниже приведена дополнительная информация, полученная из большего количества времени, потраченного впустую на это решение:

О окне WindowSoftInputMode

Есть еще один спорный момент, о котором нужно знать. По умолчанию Android автоматически назначит начальный фокус первому EditText или настраиваемому элементу управления в вашей Activity . Из этого следует, что InputMethod (обычно мягкая клавиатура) будет реагировать на событие фокусировки, показывая себя. windowSoftInputMode в AndroidManifest.xml , когда установлен в stateAlwaysHidden , указывает клавиатуре игнорировать этот автоматически назначенный начальный фокус.

 <activity android:name=".MyActivity" android:windowSoftInputMode="stateAlwaysHidden"/> 

Почти невероятно, кажется, ничего не делает для того, чтобы клавиатура не открывалась, когда вы касаетесь focusable="false" управления (если контрольный элемент не focusable="false" и / или focusableInTouchMode="false" ). По-видимому, параметр windowSoftInputMode применяется только к событиям автоматической фокусировки, а не к фокусу событий, вызванных событиями касания.

Поэтому stateAlwaysHidden ОЧЕНЬ плохо назван. Его следует, скорее всего, назвать ignoreInitialFocus .

Надеюсь это поможет.


UPDATE: больше способов получить токен окна

Если нет сфокусированного представления (например, может случиться, если вы только что изменили фрагменты), есть и другие представления, которые будут предоставлять полезный токен окна.

Это альтернативы для вышеуказанного кода, if (view == null) view = new View(activity); Они не относятся прямо к вашей деятельности.

Внутри класса фрагмента:

 view = getView().getRootView().getWindowToken(); 

Учитывая фрагмент fragment как параметр:

 view = fragment.getView().getRootView().getWindowToken(); 

Начиная с вашего контента:

 view = findViewById(android.R.id.content).getRootView().getWindowToken(); 

ОБНОВЛЕНИЕ 2: очистить фокус, чтобы снова не показывать клавиатуру, если вы открываете приложение из фона

Добавьте эту строку в конец метода:

view.clearFocus();

Также полезно скрывать мягкую клавиатуру:

 getWindow().setSoftInputMode( WindowManager.LayoutParams.SOFT_INPUT_STATE_ALWAYS_HIDDEN ); 

Это можно использовать для подавления мягкой клавиатуры до тех пор, пока пользователь не коснется экрана editText.

У меня есть еще одно решение скрыть клавиатуру:

 InputMethodManager imm = (InputMethodManager) getSystemService(Activity.INPUT_METHOD_SERVICE); imm.toggleSoftInput(InputMethodManager.HIDE_IMPLICIT_ONLY, 0); 

Здесь передайте HIDE_IMPLICIT_ONLY в позиции showFlag и 0 в позиции hiddenFlag . Он будет принудительно закрывать мягкую клавиатуру.

Решение Мейера работает и на меня. В моем случае верхний уровень моего приложения – tabHost, и я хочу скрыть ключевое слово при переключении вкладок – я получаю маркер окна из tabHost View.

 tabHost.setOnTabChangedListener(new OnTabChangeListener() { public void onTabChanged(String tabId) { InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE); imm.hideSoftInputFromWindow(tabHost.getApplicationWindowToken(), 0); } } 

Пожалуйста, попробуйте этот ниже код в oncreate ()

 EditText edtView=(EditText)findViewById(R.id.editTextConvertValue); edtView.setInputType(0); 

Обновление: я не знаю, почему это решение больше не работает (я только что тестировал на Android 23). Вместо этого используйте решение Saurabh Pareek . Вот:

 InputMethodManager imm = (InputMethodManager) getSystemService(Activity.INPUT_METHOD_SERVICE); //Hide: imm.toggleSoftInput(InputMethodManager.HIDE_IMPLICIT_ONLY, 0); //Show imm.toggleSoftInput(InputMethodManager.SHOW_IMPLICIT, 0); 

Старый ответ:

 //Show soft-keyboard: getWindow().setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_STATE_ALWAYS_VISIBLE); //hide keyboard : getWindow().setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_STATE_ALWAYS_HIDDEN); 
 protected void hideSoftKeyboard(EditText input) { input.setInputType(0); InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE); imm.hideSoftInputFromWindow(input.getWindowToken(), 0); } 

Если все остальные ответы здесь не работают для вас, как вы хотели бы, есть другой способ ручного управления клавиатурой.

Создание функции с помощью которой будет управлять некоторыми свойствами EditText :

 public void setEditTextFocus(boolean isFocused) { searchEditText.setCursorVisible(isFocused); searchEditText.setFocusable(isFocused); searchEditText.setFocusableInTouchMode(isFocused); if (isFocused) { searchEditText.requestFocus(); } } 

Затем убедитесь, что в фокусе EditText вы открываете / закрываете клавиатуру:

 searchEditText.setOnFocusChangeListener(new OnFocusChangeListener() { @Override public void onFocusChange(View v, boolean hasFocus) { if (v == searchEditText) { if (hasFocus) { // Open keyboard ((InputMethodManager) context.getSystemService(Context.INPUT_METHOD_SERVICE)).showSoftInput(searchEditText, InputMethodManager.SHOW_FORCED); } else { // Close keyboard ((InputMethodManager) context.getSystemService(Context.INPUT_METHOD_SERVICE)).hideSoftInputFromWindow(searchEditText.getWindowToken(), 0); } } } }); 

Теперь, когда вы хотите открыть клавиатуру вручную, вызовите:

 setEditTextFocus(true); 

И для закрытия вызова:

 setEditTextFocus(false); 

Саураб Парик имеет лучший ответ.

Тем не менее, можно использовать правильные флаги.

 /* hide keyboard */ ((InputMethodManager) getSystemService(Activity.INPUT_METHOD_SERVICE)) .toggleSoftInput(InputMethodManager.SHOW_IMPLICIT, 0); /* show keyboard */ ((InputMethodManager) getSystemService(Activity.INPUT_METHOD_SERVICE)) .toggleSoftInput(0, InputMethodManager.HIDE_IMPLICIT_ONLY); 

Пример реального использования

 /* click button */ public void onClick(View view) { /* hide keyboard */ ((InputMethodManager) getSystemService(Activity.INPUT_METHOD_SERVICE)) .toggleSoftInput(InputMethodManager.SHOW_IMPLICIT, 0); /* start loader to check parameters ... */ } /* loader finished */ public void onLoadFinished(Loader<Object> loader, Object data) { /* parameters not valid ... */ /* show keyboard */ ((InputMethodManager) getSystemService(Activity.INPUT_METHOD_SERVICE)) .toggleSoftInput(0, InputMethodManager.HIDE_IMPLICIT_ONLY); /* parameters valid ... */ } 

От такого поиска, здесь я нашел ответ, который работает для меня

 // Show soft-keyboard: InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE); imm.toggleSoftInput(InputMethodManager.SHOW_FORCED, 0); // Hide soft-keyboard: getWindow().setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_STATE_ALWAYS_HIDDEN); 

Короткий ответ

В вашем прослушивателе OnClick вызывается onEditorAction из EditText с IME_ACTION_DONE

 button.setOnClickListener(new OnClickListener() { @Override public void onClick(View v) { someEditText.onEditorAction(EditorInfo.IME_ACTION_DONE) } }); 

Развертывание

Я считаю, что этот метод лучше, проще и более согласован с шаблоном проектирования Android. В простом примере выше (и, как правило, в большинстве распространенных случаев) у вас есть EditText который имеет / имел фокус, и, как правило, он также вызывал клавиатуру в первую очередь (она, безусловно, может вызвать ее в Многие распространенные сценарии). Таким же образом, он должен освободить клавиатуру, обычно это может быть сделано с помощью ImeAction . Просто посмотрите, как ведет себя EditText с android:imeOptions="actionDone" , вы хотите добиться такого же поведения теми же средствами.


Проверьте этот ответ

Я использую пользовательскую клавиатуру для ввода номера Hex, поэтому у меня не может появиться клавиатура IMM …

В v3.2.4_r1 setSoftInputShownOnFocus(boolean show) был добавлен для управления погодой или нет, чтобы отображать клавиатуру, когда TextView получает фокус, но ее все еще скрыто, поэтому необходимо использовать отражение:

 if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.HONEYCOMB_MR2) { try { Method method = TextView.class.getMethod("setSoftInputShownOnFocus", boolean.class); method.invoke(mEditText, false); } catch (Exception e) { // Fallback to the second method } } 

Для более старых версий я получил очень хорошие результаты (но далеко не идеальный) с помощью OnGlobalLayoutListener , добавленный с помощью ViewTreeObserver из моего корневого представления, а затем проверяя, показана ли клавиатура следующим образом:

 @Override public void onGlobalLayout() { Configuration config = getResources().getConfiguration(); // Dont allow the default keyboard to show up if (config.keyboardHidden != Configuration.KEYBOARDHIDDEN_YES) { InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE); imm.hideSoftInputFromWindow(mRootView.getWindowToken(), 0); } } 

Это последнее решение может отображать клавиатуру в течение секунды и беспорядок с помощью дескрипторов выделения.

Когда клавиатура входит во весь экран, onGlobalLayout не вызывается. Чтобы этого избежать, используйте TextView # setImeOptions (int) или в XML-декларации TextView:

 android:imeOptions="actionNone|actionUnspecified|flagNoFullscreen|flagNoExtractUi" 

Обновление: просто нашел, какие диалоги используют, чтобы никогда не показывать клавиатуру и работать во всех версиях:

 getWindow().setFlags(WindowManager.LayoutParams.FLAG_ALT_FOCUSABLE_IM, WindowManager.LayoutParams.FLAG_ALT_FOCUSABLE_IM); 

Это должно работать:

 public class KeyBoard { public static void show(Activity activity){ InputMethodManager imm = (InputMethodManager) activity.getSystemService(Activity.INPUT_METHOD_SERVICE); imm.toggleSoftInput(0, InputMethodManager.HIDE_IMPLICIT_ONLY); // show } public static void hide(Activity activity){ InputMethodManager imm = (InputMethodManager) activity.getSystemService(Activity.INPUT_METHOD_SERVICE); imm.toggleSoftInput(InputMethodManager.HIDE_IMPLICIT_ONLY, 0); // hide } public static void toggle(Activity activity){ InputMethodManager imm = (InputMethodManager) activity.getSystemService(Activity.INPUT_METHOD_SERVICE); if (imm.isActive()){ hide(activity); } else { show(activity); } } } KeyBoard.toggle(activity); 
 public void setKeyboardVisibility(boolean show) { InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE); if(show){ imm.toggleSoftInput(InputMethodManager.SHOW_FORCED, 0); }else{ imm.hideSoftInputFromWindow(getCurrentFocus().getWindowToken(),0); } } 

В качестве альтернативы этому решению все вокруг , если вы хотите закрыть мягкую клавиатуру из любого места, не имея ссылки на поле (EditText), которое использовалось для открытия клавиатуры, но все же захотелось сделать это, если поле было сфокусировано, вы можете использовать Это (из Activity):

 if (getCurrentFocus() != null) { InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE); imm.hideSoftInputFromWindow(getCurrentFocus().getWindowToken(), 0); } 

Я провел более двух дней, работая над всеми решениями, размещенными в потоке, и обнаружил, что их так или иначе не хватает. Мое точное требование – иметь кнопку, которая будет со 100% -й проверкой надежности или скрывать экранную клавиатуру. Когда клавиатура находится в скрытом состоянии, она не должна появляться повторно, независимо от того, какие поля ввода пользователь нажимает. Когда он находится в своем видимом состоянии, клавиатура не должна исчезать независимо от того, какие кнопки пользователь нажимает. Это должно работать на Android 2.2+ вплоть до новейших устройств.

Вы можете увидеть, как это работает в моем чистом RPN приложении.

После тестирования многих предложенных ответов на ряде различных телефонов (в том числе устройств froyo и gingerbread ) стало очевидно, что приложения для Android могут быть надежно:

  1. Временно скройте клавиатуру. Он снова появится снова, когда пользователь сосредоточит новое текстовое поле.
  2. Покажите клавиатуру, когда начинается действие, и установите флажок в действии, указывающий, что клавиатура всегда должна быть видимой. Этот флаг может быть установлен только при инициализации активности.
  3. Отметьте действие, чтобы никогда не показывать или не разрешать использование клавиатуры. Этот флаг может быть установлен только при инициализации активности.

Для меня временно скрывать клавиатуру недостаточно. На некоторых устройствах он снова появится, как только будет сфокусировано новое текстовое поле. Поскольку мое приложение использует несколько текстовых полей на одной странице, фокусировка нового текстового поля приведет к тому, что скрытая клавиатура снова появится снова.

К сожалению, пункты 2 и 3 в списке работают только надёжно, когда начинается действие. Когда активность станет видимой, вы не сможете надолго скрыть или показать клавиатуру. Хитрость заключается в том, чтобы фактически перезапустить вашу деятельность, когда пользователь нажимает кнопку переключения клавиатуры. В моем приложении, когда пользователь нажимает кнопку переключения, запускается следующий код:

 private void toggleKeyboard(){ if(keypadPager.getVisibility() == View.VISIBLE){ Intent i = new Intent(this, MainActivity.class); i.addFlags(Intent.FLAG_ACTIVITY_NO_ANIMATION); Bundle state = new Bundle(); onSaveInstanceState(state); state.putBoolean(SHOW_KEYBOARD, true); i.putExtras(state); startActivity(i); } else{ Intent i = new Intent(this, MainActivity.class); i.addFlags(Intent.FLAG_ACTIVITY_NO_ANIMATION); Bundle state = new Bundle(); onSaveInstanceState(state); state.putBoolean(SHOW_KEYBOARD, false); i.putExtras(state); startActivity(i); } } 

Это заставляет текущую активность сохранять свое состояние в Bundle , а затем запускается активность, проходя через логическое значение, указывающее, следует ли показывать или скрывать клавиатуру.

Внутри метода onCreate выполняется следующий код:

 if(bundle.getBoolean(SHOW_KEYBOARD)){ ((InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE)).showSoftInput(newEquationText,0); getWindow().setSoftInputMode(LayoutParams.SOFT_INPUT_STATE_ALWAYS_VISIBLE); } else{ getWindow().setFlags(WindowManager.LayoutParams.FLAG_ALT_FOCUSABLE_IM, WindowManager.LayoutParams.FLAG_ALT_FOCUSABLE_IM); } 

Если нужно InputMethodManager мягкую клавиатуру, то InputMethodManager будет предложено отобразить клавиатуру, и окно будет проинструктировано, чтобы сделать мягкий вход всегда видимым. Если мягкая клавиатура должна быть скрыта, то устанавливается WindowManager.LayoutParams.FLAG_ALT_FOCUSABLE_IM .

Этот подход надежно работает на всех устройствах, на которых я тестировал: от 4-летнего телефона HTC, работающего под управлением Android 2.2 до версии 7, работающей под управлением 4.2.2. Единственным недостатком такого подхода является то, что вам нужно быть осторожным при обращении с кнопкой «Назад». Поскольку у моего приложения есть только один экран (его калькулятор), я могу переопределить onBackPressed() и вернуться к onBackPressed() экрану устройств.

Выше ответы работают для разных сценариев, но если вы хотите скрыть клавиатуру внутри представления и изо всех сил пытаться получить правильный контекст, попробуйте это:

 setOnClickListener(new OnClickListener() { @Override public void onClick(View v) { hideSoftKeyBoardOnTabClicked(v); } } private void hideSoftKeyBoardOnTabClicked(View v) { if (v != null && context != null) { InputMethodManager imm = (InputMethodManager) context.getSystemService(Context.INPUT_METHOD_SERVICE); imm.hideSoftInputFromWindow(v.getApplicationWindowToken(), InputMethodManager.HIDE_NOT_ALWAYS); } } 

and to get the context fetch it from constructor:)

 public View/RelativeLayout/so and so (Context context, AttributeSet attrs, int defStyle) { super(context, attrs, defStyle); this.context = context; init(); } 

Thanks to this SO answer , I derived the following which, in my case, works nicely when scrolling through the the fragments of a ViewPager…

 private void hideKeyboard() { // Check if no view has focus: View view = this.getCurrentFocus(); if (view != null) { InputMethodManager inputManager = (InputMethodManager) this.getSystemService(Context.INPUT_METHOD_SERVICE); inputManager.hideSoftInputFromWindow(view.getWindowToken(), InputMethodManager.HIDE_NOT_ALWAYS); } } private void showKeyboard() { // Check if no view has focus: View view = this.getCurrentFocus(); if (view != null) { InputMethodManager inputManager = (InputMethodManager) this.getSystemService(Context.INPUT_METHOD_SERVICE); inputManager.showSoftInput(view, InputMethodManager.SHOW_IMPLICIT); } } 

Here's how you do it in Mono for Android (AKA MonoDroid)

 InputMethodManager imm = GetSystemService (Context.InputMethodService) as InputMethodManager; if (imm != null) imm.HideSoftInputFromWindow (searchbox.WindowToken , 0); 

If you want to close the soft keyboard during a unit or functional test, you can do so by clicking the "back button" from your test:

 // Close the soft keyboard from a Test getInstrumentation().sendKeyDownUpSync(KeyEvent.KEYCODE_BACK); 

I put "back button" in quotes, since the above doesn't trigger the onBackPressed() for the Activity in question. It just closes the keyboard.

Make sure to pause for a little while before moving on, since it takes a little while to close the back button, so subsequent clicks to Views, etc., won't be registered until after a short pause (1 second is long enough ime).

This worked for me for all the bizarre keyboard behavior

 private boolean isKeyboardVisible() { Rect r = new Rect(); //r will be populated with the coordinates of your view that area still visible. mRootView.getWindowVisibleDisplayFrame(r); int heightDiff = mRootView.getRootView().getHeight() - (r.bottom - r.top); return heightDiff > 100; // if more than 100 pixels, its probably a keyboard... } protected void showKeyboard() { if (isKeyboardVisible()) return; InputMethodManager inputMethodManager = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE); if (getCurrentFocus() == null) { inputMethodManager.toggleSoftInput(InputMethodManager.SHOW_FORCED, 0); } else { View view = getCurrentFocus(); inputMethodManager.showSoftInput(view, InputMethodManager.SHOW_FORCED); } } protected void hideKeyboard() { if (!isKeyboardVisible()) return; InputMethodManager inputMethodManager = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE); View view = getCurrentFocus(); if (view == null) { if (inputMethodManager.isAcceptingText()) inputMethodManager.toggleSoftInput(InputMethodManager.HIDE_NOT_ALWAYS, 0); } else { if (view instanceof EditText) ((EditText) view).setText(((EditText) view).getText().toString()); // reset edit text bug on some keyboards bug inputMethodManager.hideSoftInputFromInputMethod(view.getWindowToken(), InputMethodManager.HIDE_NOT_ALWAYS); } } 

For my case, I was using the a SearchView in the actionbar. After a user performs a search, the keyboard would pop open again.

Using the InputMethodManager did not close the keyboard. I had to clearFocus and set the focusable of the search view to false:

 mSearchView.clearFocus(); mSearchView.setFocusable(false); 

Add to your activity android:windowSoftInputMode="stateHidden" in Manifest file. Пример:

 <activity android:name=".ui.activity.MainActivity" android:label="@string/mainactivity" android:windowSoftInputMode="stateHidden"/> 

использовать это

 this.getWindow().setSoftInputMode( WindowManager.LayoutParams.SOFT_INPUT_STATE_ALWAYS_HIDDEN); 

I have almost tried all of these answers, I had some random issues especially with the samsung galaxy s5.

What I end up with is forcing the show and hide, and it works perfectly:

 /** * Force show softKeyboard. */ public static void forceShow(@NonNull Context context) { InputMethodManager imm = (InputMethodManager) context.getSystemService(Context.INPUT_METHOD_SERVICE); imm.toggleSoftInput(InputMethodManager.SHOW_FORCED, 0); } /** * Force hide softKeyboard. */ public static void forceHide(@NonNull Activity activity, @NonNull EditText editText) { if (activity.getCurrentFocus() == null || !(activity.getCurrentFocus() instanceof EditText)) { editText.requestFocus(); } InputMethodManager imm = (InputMethodManager) activity.getSystemService(Context.INPUT_METHOD_SERVICE); imm.hideSoftInputFromWindow(editText.getWindowToken(), 0); activity.getWindow().setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_STATE_ALWAYS_HIDDEN); } 

Just use this optimized code in your activity:

 if (this.getCurrentFocus() != null) { InputMethodManager inputManager = (InputMethodManager) this.getSystemService(Context.INPUT_METHOD_SERVICE); inputManager.hideSoftInputFromWindow(this.getCurrentFocus().getWindowToken(), InputMethodManager.HIDE_NOT_ALWAYS); } 

I have the case, where my EditText can be located also in an AlertDialog , so the keyboard should be closed on dismiss. The following code seems to be working anywhere:

 public static void hideKeyboard( Activity activity ) { InputMethodManager imm = (InputMethodManager)activity.getSystemService( Context.INPUT_METHOD_SERVICE ); View f = activity.getCurrentFocus(); if( null != f && null != f.getWindowToken() && EditText.class.isAssignableFrom( f.getClass() ) ) imm.hideSoftInputFromWindow( f.getWindowToken(), 0 ); else activity.getWindow().setSoftInputMode( WindowManager.LayoutParams.SOFT_INPUT_STATE_ALWAYS_HIDDEN ); } 

Simple and Easy to use method, just call hideKeyboardFrom(YourActivity.this); to hide keyboard

 /** * This method is used to hide keyboard * @param activity */ public static void hideKeyboardFrom(Activity activity) { InputMethodManager imm = (InputMethodManager) activity.getSystemService(Activity.INPUT_METHOD_SERVICE); imm.hideSoftInputFromWindow(activity.getCurrentFocus().getWindowToken(), 0); } 

You could also look into using setImeOption on the EditText.

I just had a very simular situation where my layout contained an EditText and a search button. When I discovered I could just set the ime option to "actionSearch" on my editText, I realized I didn't even need a search button anymore. The soft keyboard (in this mode) has a search icon, which can be used to kick off the search (and the keyboard closes itself as you would expect).