92 Вопрос: Закрыть / скрыть программную клавиатуру Android

вопрос создан в Thu, Dec 21, 2017 12:00 AM

У меня есть макет EditText и Button.

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

    
3497
  1. Что если у вас есть только один EditText и несколько кнопок, таких как флажки и радио? Единственное место, где вам нужна клавиатура, находится в одном EditText. Как зарегистрироваться, чтобы узнать, что что-то еще было выбрано /нажато, чтобы скрыть клавиатуру?
    2011-06-01 15: 48: 11Z
  2. Я чувствую себя глупо. Я не могу спрятать клавиатуру на ICS. Перепробовал здесь все методы и их комбинации. Ни за что. Способ показать это работает, но я не могу скрыть это независимо от того, какой токен ветра, скрыть флаги, настройки манифеста или свечи для любых святых. На показе клавиатуры я всегда вижу это: I /LatinIME (396): указан InputType.TYPE_NULL W /LatinIME (396): неожиданный класс ввода: inputType = 0x00000000 imeOptions = 0x00000000
    2013-05-15 13: 28: 22Z
  3. /** * Этот метод используется для скрытия программной клавиатуры. * @param Activity * /public void hideSoftKeyboard (Activity Activity) {InputMethodManager inputMethodManager = (InputMethodManager) activity.getSystemService (Activity.INPUT_METHOD_SERVICE); inputMethodManager.hideSoftInputFromWindow (activity.getCurrentFocus (). getWindowToken (), 0); }
    2014-01-13 13: 30: 35Z
  4. это сработало для меня
    2014-06-20 12: 45: 04Z
  5. Подобные API-интерфейсы - вот почему миру нужно больше инженеров-программистов, а не компьютерных специалистов.
    2017-11-30 21: 38: 52Z
30 ответов                              30                         

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

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

Вот что делает скрытие клавиатуры таким сложным. Уважаемый Google! Когда я просматриваю рецепт торта, на Земле нет RecipeProvider, который бы отказался предоставить мне этот рецепт, если я не отвечу сначала, КТО будет съеден торт И где он будет съеден !!

Эта печальная история заканчивается ужасной правдой: чтобы скрыть клавиатуру Android, вам потребуется предоставить 2 формы идентификации: 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

Это не сработает, потому что вы передадите ссылку на хост Fragment Activity, который не будет иметь сфокусированного элемента управления, пока отображается 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" и /или focusableInTouchMode="false"). По-видимому, параметр windowSoftInputMode применяется только к событиям автоматической фокусировки, а не к событиям фокусировки, вызванным событиями касания.

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

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

ОБНОВЛЕНИЕ: больше способов получить маркер окна

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

Это альтернативы приведенному выше коду 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(); р>     

1599
2018-11-27 08: 34: 00Z
  1. Я не думаю, что вы должны модифицировать softInputMode. Это переопределит настройки AndroidManifest.
    2014-01-09 07: 26: 21Z
  2. @ AlexanderFarber да, обычно это EditText, но я считаю, что любой видимый View будет работать (например, TextView), так как окно View используется только для получения скрыть клавиатуру от). Кроме того, я считаю, что View должен исходить от хоста Activity, а не от Fragment
    2015-04-20 18: 30: 54Z
  3. @ rmirabelle В Fragment кажется, что вы можете использовать getActivity().getWindow().getDecorView()
    2015-06-11 16: 09: 10Z
  4. Google должен просто предоставить эту утилиту Keyboard.hide();
    2016-10-18 09: 47: 38Z
  5. thx !! мне помогли, и это не первое, что я нашел таким изогнутым в Android, так много ошибок, и вещи, которые работают для одного и не работают для других ... каждый элемент управления с его различным поведением, вещи не являются общими, это усложняет работу и развитие ...
    2017-09-05 12: 02: 26Z

Вы можете заставить 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 в качестве второго параметра, чтобы гарантировать, что вы скрываете клавиатуру только тогда, когда пользователь явно не заставлял ее появляться (удерживая меню).

Примечание. Если вы хотите сделать это в Kotlin, используйте: context?.getSystemService(Context.INPUT_METHOD_SERVICE) as InputMethodManager р>

Синтаксис Kotlin

// Check if no view has focus:
 val view = this.currentFocus
 view?.let { v ->
  val imm = getSystemService(Context.INPUT_METHOD_SERVICE) as? InputMethodManager 
  imm?.let { it.hideSoftInputFromWindow(v.windowToken, 0) }
 }
    
4318
2019-02-28 07: 59: 57Z
  1. Спасибо, что это прекрасно работает, если использовать 0 в качестве второго параметра. Но если я использую InputMethodManager.HIDE_IMPLICIT_ONLY, клавиатура никогда не будет скрыта (хотя я не удерживаю меню). Есть намеки?
    2010-06-23 22: 50: 24Z
  2. Круто. Просто чтобы уточнить, это только отклоняет его, если оно присутствует, но не предотвращает его появление, верно?
    2011-02-16 19: 48: 24Z
  3. Может быть полезно вызвать editText.clearFocus (), прежде чем скрывать softInput
    2013-10-01 19: 51: 31Z
  4. Вызов editText.clearFocus(), а затем InputMethodManager.HIDE_IMPLICIT_ONLY даже работает на 4.1
    2013-11-30 12: 57: 56Z
  5. То, что у меня работало на 4.4 /htc, выполняло View focused = getCurrentFocus(), чтобы получить то, что определенно является в данный момент сфокусированным представлением, вызывая focused.clearFocus(), а затем inputMethodManager.hideSoftInputFromWindow(focused.getWindowToken(), 0) ( с четкими флагами).
    2015-08-13 00: 12: 17Z

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

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

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

    
775
2014-11-24 16: 07: 40Z
  1. Вы также можете добиться того же эффекта, добавив android: windowSoftInputMode = "stateHidden" к своей активности в манифесте.
    2012-08-10 16: 09: 11Z
  2. Попробовал это во фрагменте (ссылаясь на собственное действие) на уровне API 9, и, к сожалению, это не сработало. Пробовал вызывать его в onResume и onActivityCreated - безрезультатно.
    2013-03-10 16: 07: 44Z
  3. Я работаю в диалоговом окне, и это сработало. Я использую Android 3.2. Я поместил его в метод onCreateDialog (Bundle). Это не сработало в методе onCreate. Диалог диалога = super.onCreateDialog (saveInstanceState); dialog.getWindow (). setSoftInputMode (WindowManager.LayoutParams. SOFT_INPUT_STATE_ALWAYS_HIDDEN); В результате мое представление с EditTexts в нем отображается без клавиатуры. Когда пользователь касается редактируемого текста, появляется клавиатура.
    2013-07-03 05: 12: 55Z
  4. Это не работает, когда фокус все еще находится в EditText (например, после нажатия кнопки). Используйте для этого решение Рето.
    2013-07-09 06: 48: 43Z
  5. Почему переопределение настроек манифеста - плохая идея? Я звоню из фрагмента. Там нет настройки манифестаэто относится к фрагменту ...
    2014-04-24 00: 48: 59Z

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

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

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

    
326
2016-06-27 15: 26: 34Z
  1. Вы используете флаг скрытия в параметре showflags. Это работает только потому, что константы используют одни и те же целые числа. Пример использования правильных флагов
    2013-03-23 ​​14: 35: 12Z
  2. протестировано на Android 4.0, мне нравится это решение, потому что у меня есть несколько текстов для редактирования, кнопки для этого действия, которые могут иметь фокус
    2013-05-16 15: 04: 21Z
  3. Почему отображается клавиатура, если она была скрыта? :)
    2013-06-08 19: 33: 31Z
  4. @ Mark: поскольку метод называется «toggleSoftInput», а не «hideSoftInput»:)
    2013-08-30 02: 08: 40Z
  5. Это решение показывает клавиатуру, если она скрыта. Это не правильно
    2016-05-14 20: 14: 25Z

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

tabHost.setOnTabChangedListener(new OnTabChangeListener() {
    public void onTabChanged(String tabId) {
        InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
        imm.hideSoftInputFromWindow(tabHost.getApplicationWindowToken(), 0);
    }
}
    
142
2014-11-24 15: 54: 56Z
  1. Я получил это для работы с SearchView тоже. Смотрите мой ответ ниже. Спасибо, МакКосс!
    2014-07-06 23: 43: 58Z

Пожалуйста, попробуйте следующий код в onCreate()

EditText edtView=(EditText)findViewById(R.id.editTextConvertValue);
edtView.setInputType(0);
    
130
2018-05-24 18: 15: 06Z
  1. Этот метод позволяет обойти ошибку «не удается скрыть программную клавиатуру» в 2.0 и 2.1, как описано в code.google.com/p/android/issues/detail?id=7115 ... перечисленный выше метод hideSoftInputFromWindow не работал, когда я его пробовал, но не работал editView.setInputType (0).
    2010-04-17 05: 50: 54Z
  2. Это допустимо для каждого Javadoc (не для взлома), хотя я бы переписал метод как editView.setInputType(InputType.TYPE_NULL);
    2010-10-11 20: 49: 27Z
  3. это работает, однако скрывает андроид: подсказка. я использую Android 1.5
    2012-01-11 10: 32: 12Z
  4. @ Bostone Это не работает для SearchView
    2014-06-20 09: 11: 03Z
  5. это отлично подходит для случаев, когда вам нужно закрыть кеyboard из диалога, не нужно получать экземпляр или что-либо еще и может назначить это для всех редактируемых текстов, когда пользователь нажимает кнопку, закрывающую диалог
    2014-12-26 21: 38: 05Z

Update: Я не знаю, почему это решение больше не работает (я только что протестировал на 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);
    
122
2017-05-23 12: 10: 54Z
  1. Где мне разместить этот код? Я пытался вставить getWindow (). SetSoftInputMode (WindowManager.LayoutParams.SOFT_INPUT_STATE_ALWAYS_HIDDEN); в onCreate (), но клавиатура никогда не скрывается
    2013-07-15 18: 20: 10Z
  2. не работает, протестировано в radioGroup.setOnCheckedChangeListener, API 23
    2015-08-06 16: 50: 14Z
  3. Если вы посмотрите ближе, InputMethodManager.HIDE_IMPLICIT_ONLY и InputMethodManager.SHOW_IMPLICIT имеют одинаковое значение, равное «1», поэтому между этими вызовами нет никакой разницы. = &GT; не работает
    2016-08-18 10: 43: 08Z
  4. при вызове imm.toggleSoftInput (InputMethodManager.HIDE_IMPLICIT_ONLY, 0); тогда клавиатура отобразится на экране :). Лучшая реализация: github.com/ravindu1024/android-keyboardlistener Позор для Android SDK
    2016-11-29 10: 15: 53Z
  5. I don't know why this solution is not work any more - поскольку это Android , все сможет измениться, возможно, отчасти из-за плохого дизайна ... Мы пишем небрежно, затем вычеркиваем все и переписываем все.
    2016-12-16 04: 22: 07Z
protected void hideSoftKeyboard(EditText input) {
    InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
    imm.hideSoftInputFromWindow(input.getWindowToken(), 0);    
}
    
79
2018-11-28 10: 55: 30Z
  1. Это сработало для меня! Но почему вы положили input.setInputType (0) ? Я не мог взаимодействовать с EditTextView , когда у меня была эта строка кода (она работала, когда я ее удалял).
    2014-04-10 13: 52: 53Z
  2. Возможно, input.getContext().getSystemService(Context.INPUT_METHOD_SERVICE).
    2018-09-19 14: 28: 11Z
  3. Я удалил input.setInputType(0); из этого кода. Он изменил поведение клавиатуры и inputType для EditText.
    2018-11-28 10: 56: 21Z

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

Создайте функцию, которая будет управлять некоторыми свойствами 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);
    
66
2014-11-24 15: 55: 42Z
  1. + 1 - Если вы хотите начать действие с закрытой клавиатурой, используйте это решение и добавьте onclicklistener, который устанавливает setEditTextFocus (true). Работает как шарм!
    2012-06-06 14: 36: 15Z
  2. Я получил сообщение «Невозможно разрешить контекст символа» в 7-й и 10-й строке второго блока кода.
    2017-02-28 17: 02: 15Z
  3. Вместо этого используйте getContext ()
    2017-02-28 17: 04: 15Z

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

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

/* 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 ... */
}
    
57
2017-05-23 11: 55: 19Z
  1. В 2.1 клавиатура в любом случае всплывает, а затем скрывается. Не хорошо.
    2013-03-26 17: 27: 54Z
  2. Это наиболее эффективный вариант для последней версии. Всегда нужно настроить его для более старых версий. Особенно до v3.
    2013-04-25 14: 34: 11Z
  3. Не удается разрешить метод getSystemService () с фрагментами!
    2013-07-17 06: 21: 51Z
  4. @ Mazen: используйте fragment.getActivity().getSystemService();
    2013-07-29 10: 56: 31Z
  5. Нет. На моем Samsung Tab, Android 5.0, так называемый код «скрыть клавиатуру», приведенный выше, переключит программную клавиатуру - если она уже скрыта, она покажет ее. Есть причина, по которой эта функция имеет имя TOGGLE.
    2015-11-13 03: 22: 20Z

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

// 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);
    
52
2015-04-24 21: 09: 51Z

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

В вашем слушателе 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", вы хотите добиться того же поведения тем же означает. р>

Проверьте этот связанный ответ

    
49
2017-05-23 12: 10: 54Z
  1. Это ответ. Единственный метод, который работает кросс-версия. Я вернулся к этому вопросу, чтобы опубликовать этот ответ, потому что я не думал, что кто-то еще знал
    2015-02-05 07: 23: 10Z
  2. Это должен быть правильный ответ. Вместо того, чтобы обманывать Android, чтобы скрыть клавиатуру, когда она действительно должна быть там, мы говорим ему, что пользователь завершил, что, в свою очередь, запускает ту же ImeAction [глупое имя, я признаю], как если бы пользователь нажал «DONE» на клавиатуре , Таким образом, не имеет значения, если пользователь подтверждает ввод с клавиатуры или нажимает кнопку пользовательского интерфейса.
    2015-05-08 16: 03: 12Z

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

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);
    
44
2016-07-15 14: 51: 17Z
  1. Сработало частично, даже если клавиатура была скрыта "isActive ()" возвращает false!
    2013-10-04 18: 27: 03Z
  2. Конечно, это нужно. Или, может быть, я вас не понимаю. В любом случае, вы можете дополнить класс методами hide() и show(), чтобы иметь больше контроля над тем, когда он должен отображаться, а когда нет. У меня работает, я тоже так сделал :) Буду редактировать пример
    2013-10-05 07: 55: 39Z
  3. @ YoushaAleayoub да, будет. KeyBoard.toggle(fragment.getActivity())
    2016-07-15 14: 46: 54Z
  4. @ slinden77, лол, я говорю о вашем ответе ... не тот, который вы прокомментировали. Так что ответ все еще не будет работать.
    2016-07-16 16: 55: 06Z
  5. @ YoushaAleayoub хм да, будет. Оригинальный вопрос не упоминает фрагменты, вы тот, кто упоминал фрагменты. Так что мой ответ совершенно верный. Чтобы использовать его с фрагментами, вызовите метод не так, как в Fragment, как в комментариях. Узнайте, как использовать методы, пожалуйста, а затем вернуться. Вы путаете людей со своими глупыми ответами
    2016-07-17 16: 48: 09Z

Я использую пользовательскую клавиатуру для ввода шестнадцатеричного числа, поэтому я не могу отобразить клавиатуру 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) или в объявлении TextView XML:

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

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

getWindow().setFlags(WindowManager.LayoutParams.FLAG_ALT_FOCUSABLE_IM,
        WindowManager.LayoutParams.FLAG_ALT_FOCUSABLE_IM);
    
40
2012-05-28 20: 48: 33Z
  1. Спасибо. Два флага FLAG_ALT_FOCUSABLE_IM и FLAG_ALT_FOCUSABLE_IM - фактически единственное, что помогло в моем случае. Я не хотел, чтобы в моей деятельности отображалась клавиатура - даже когда пользователь нажимал текст редактирования. (Я сделал свою собственную "клавиатуру").
    2012-08-13 19: 33: 04Z
  2. флаги FLAG_ALT_FOCUSABLE_IM решили мою проблему
    2013-01-25 16: 01: 49Z
  3. Отличное решение, однако, если ваша передняя активность не полноэкранная, за ней видна клавиатура. Также вспомогательное средство перемещения курсора клавиатуры также все еще видимо. И это не скины.
    2013-03-26 17: 42: 09Z
  4. Я второй это. Из всех возможных способов работает только метод getWindow (). SetFlags (), по крайней мере, на стоковой Android 5.1. Обратите внимание, что setSoftInputShownOnFocus () теперь является setShowSoftInputOnFocus () и больше не скрыт, но не работает, по крайней мере, когда пользователь касается поля.
    2015-12-20 19: 04: 34Z
  5. Ваше "обновление" было единственным рабочим решением для меня. Я ищу решение по крайней мере два часа:)
    2016-08-08 19: 05: 38Z
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);
    }
}
    
31
2015-06-01 13: 36: 12Z

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

Работающую реализацию этого вы можете увидеть в моем приложении чистый RPN .

После тестирования многих из предложенных ответов на нескольких разных телефонах (включая устройства froyo и пряники) стало очевидно, что приложения для 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 должен показать клавиатуру, а в окне указывается, чтобы программный ввод был всегда видимым. Если программная клавиатура должна быть скрыта, то устанавливается WindowManager.LayoutParams.FLAG_ALT_FOCUSABLE_IM.

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

    
28
2018-03-06 07: 10: 29Z
  1. elaborя ел обходной путь, но я думаю, что это слишком много, чтобы воссоздать тысячи объектов, просто чтобы скрыть клавиатуру. Я не знаю, кто разработал IMM для Android, но он пахнет как Windows APi. На мой взгляд, хороший IME должен иметь два метода: скрыть и показать: -)
    2013-05-15 13: 43: 12Z
  2. Все это верно, но мой обходной путь имеет одно преимущество - он всегда работает! Я не нашел другого решения, которое бы всегда переключало клавиатуру, независимо от того, какие поля в пользовательском интерфейсе имеют фокус, что пользователь сделал для переключения и клавиатуры и какую версию андроида они запускают: - \
    2013-05-20 11: 35: 55Z
  3. Чувак, я отчаянно пытаюсь спрятать клавиатуру. Перепробовал тысячи вещей и оооочень работает. Но ваш обходной путь для меня слишком большой, мне нужно воссоздать, как 10 фрагментов, инициализировать сервисы, удалить множество WeakReferences .... вы знаете? GC просто выбросил бы как 25mb: S ... Все еще ищу надежный способ сделать это: (
    2013-05-20 14: 57: 45Z
  4. @ Дмитрий, ну, это не привет, это сложное приложение для планшетов. Я отказываюсь полностью выгружать его из памяти, просто чтобы спрятать глупую клавиатуру ... В любом случае я нашел что-то, что работает, объединяя тысячу предложенных здесь решений:)
    2013-10-08 16: 21: 53Z

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

if (getCurrentFocus() != null) {
    InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
    imm.hideSoftInputFromWindow(getCurrentFocus().getWindowToken(), 0);
}
    
25
2017-05-23 12: 10: 54Z

Благодаря этому SO-ответу я получил следующее, которое в моем случае хорошо работает при прокрутке фрагменты 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);
    }
}
    
23
2017-05-23 12: 34: 58Z

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

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);
    }
}

и получить контекст, извлеките его из конструктора :)

public View/RelativeLayout/so and so (Context context, AttributeSet attrs, int defStyle) {
    super(context, attrs, defStyle);
    this.context = context;
    init();
}
    
20
2015-04-24 21: 10: 37Z

Если вы хотите закрыть экранную клавиатуру во время модульного или функционального теста, вы можете сделать это, нажав «кнопку назад» в вашем тесте:

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

Я поставил «кнопку назад» в кавычки, так как приведенное выше не вызывает onBackPressed() для рассматриваемой операции. Он просто закрывает клавиатуру.

Обязательно сделайте небольшую паузу, прежде чем двигаться дальше, поскольку для закрытия кнопки «назад» требуется некоторое время, поэтому последующие нажатия на «Виды» и т. д. не будут регистрироваться до тех пор, пока не произойдет короткая пауза (1 секунда достаточно долго).

    
18
2011-12-13 21: 55: 41Z

Вот как это делается в Mono для Android (AKA MonoDroid)

InputMethodManager imm = GetSystemService (Context.InputMethodService) as InputMethodManager;
if (imm != null)
    imm.HideSoftInputFromWindow (searchbox.WindowToken , 0);
    
15
2012-05-15 01: 36: 10Z
  1. Что такое searchbox во фрагменте?
    2012-11-26 19: 14: 36Z
  2. @ PCoder Я думаю, что его edittext
    2016-10-24 13: 16: 51Z

Это сработало для меня при любом странном поведении клавиатуры

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);
    }
}
    
15
2015-04-24 21: 11: 16Z
  1. Думаю, я пробовал 10 ответов до этого. Оставил надежду. Спасибо мужчина.
    2016-01-20 20: 33: 14Z
  2. Что такое mRootView?
    2018-11-28 19: 49: 54Z

Добавьте к своей деятельности android:windowSoftInputMode="stateHidden" в файле манифеста. Пример: р>

<activity
            android:name=".ui.activity.MainActivity"
            android:label="@string/mainactivity"
            android:windowSoftInputMode="stateHidden"/>
    
14
2016-02-04 12: 21: 40Z

используйте это

this.getWindow().setSoftInputMode(
            WindowManager.LayoutParams.SOFT_INPUT_STATE_ALWAYS_HIDDEN);
    
12
2013-08-09 13: 42: 00Z

В моем случае я использовал SearchView на панели действий. После того, как пользователь выполнит поиск, клавиатура снова откроется.

Использование InputMethodManager не закрывало клавиатуру. Мне пришлось очистить Focus и установить фокусировку в окне поиска на false:

mSearchView.clearFocus();
mSearchView.setFocusable(false);
    
12
2015-04-24 21: 10: 48Z
  1. Очень умный. Если пользователь хочет другой поиск, просто нажмите кнопку поиска еще раз.
    2013-03-23 ​​14: 48: 56Z
  2. SearchView не имеет clearFocus() на страницах API Android, поэтому у меня это не сработало, но сработало другое решение (см. мой ответ ниже).
    2014-07-06 23: 46: 34Z
  3. 2016-04-18 21: 50: 37Z

Просто используйте этот оптимизированный код в своей деятельности:

if (this.getCurrentFocus() != null) {
    InputMethodManager inputManager = (InputMethodManager) this.getSystemService(Context.INPUT_METHOD_SERVICE);
    inputManager.hideSoftInputFromWindow(this.getCurrentFocus().getWindowToken(), InputMethodManager.HIDE_NOT_ALWAYS);
}
    
12
2015-04-24 21: 11: 54Z

Я почти попробовал все эти ответы, у меня были некоторые случайные проблемы, особенно с Samsung Galaxy S5.

В итоге я заставляю показывать и прятаться, и это прекрасно работает:

/**
 * 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);
}
    
12
2015-05-15 12: 40: 06Z

В некоторых случаях этот метод может работать, кроме всех остальных. Это спасает мой день:)

public static void hideSoftKeyboard(Activity activity) {
    if (activity != null) {
        InputMethodManager inputManager = (InputMethodManager) activity.getSystemService(Context.INPUT_METHOD_SERVICE);
        if (activity.getCurrentFocus() != null && inputManager != null) {
            inputManager.hideSoftInputFromWindow(activity.getCurrentFocus().getWindowToken(), 0);
            inputManager.hideSoftInputFromInputMethod(activity.getCurrentFocus().getWindowToken(), 0);
        }
    }
}

public static void hideSoftKeyboard(View view) {
    if (view != null) {
        InputMethodManager inputManager = (InputMethodManager) view.getContext().getSystemService(Context.INPUT_METHOD_SERVICE);
        if (inputManager != null) {
            inputManager.hideSoftInputFromWindow(view.getWindowToken(), 0);
        }
    }
}
    
12
2016-02-04 11: 46: 12Z

Простой и легкий в использовании метод, просто вызовите hideKeyboardFrom (YourActivity.this); , чтобы скрыть клавиатуру

/**
 * 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);
}
    
12
2017-02-21 06: 52: 20Z

Для открытой клавиатуры:

InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
imm.showSoftInput(edtView, InputMethodManager.SHOW_IMPLICIT);

Для закрытия /скрытия клавиатуры:

 InputMethodManager imm = (InputMethodManager)getSystemService(Context.INPUT_METHOD_SERVICE);
 imm.hideSoftInputFromWindow(edtView.getWindowToken(), 0);
    
11
2015-02-05 12: 39: 18Z
  1. спасибо, это работает для меня
    2017-07-14 13: 46: 00Z
источник размещен Вот