Закройте/спрячьте мягкую клавиатуру Android - программирование
Подтвердить что ты не робот

Закройте/спрячьте мягкую клавиатуру Android

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

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

4b9b3361

ОТВЕТЫ

Ответ 1

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

Я хочу спрятать клавиатуру. Я ожидаю предоставить Android следующее утверждение: Keyboard.hide(). Конец. Большое спасибо. Но у Android есть проблема. Вы должны использовать InputMethodManager чтобы скрыть клавиатуру. Хорошо, хорошо, это Android API для клавиатуры. НО! Вы должны иметь 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

Это не сработает, потому что вы передадите ссылку на 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, stateAlwaysHidden клавиатуру игнорировать этот автоматически назначенный начальный фокус.

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

Почти невероятно, кажется, что он ничего не делает для предотвращения открытия клавиатуры при прикосновении к focusable="false" управления (если только 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();

Ответ 2

Вы можете заставить 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

Синтаксис Котлина

// Check if no view has focus:
 val view = this.currentFocus
 view?.let { v ->
  val imm = getSystemService(Context.INPUT_METHOD_SERVICE) as? InputMethodManager 
  imm?.hideSoftInputFromWindow(v.windowToken, 0)
 }

Ответ 3

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

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

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

Ответ 4

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

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

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

Ответ 5

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

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

Ответ 6

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

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

Ответ 7

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

Ответ 8

protected void hideSoftKeyboard(EditText input) {
    InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
    imm.hideSoftInputFromWindow(input.getWindowToken(), 0);    
}

Ответ 9

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

Создайте функцию с этим, чтобы управлять некоторыми свойствами 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);

Ответ 10

Saurabh Pareek имеет лучший ответ.

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

/* 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 ... */
}

Ответ 11

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

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

Ответ 12

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

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

Отметьте этот связанный ответ

Ответ 13

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

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

Ответ 14

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

Ответ 15

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

Ответ 16

Я потратил более двух дней, работая над всеми решениями, опубликованными в ветке, и обнаружил, что их так или иначе не хватает. Мое точное требование - иметь кнопку, которая со 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() и вернуться на домашний экран устройства.

Ответ 17

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

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

Ответ 18

Благодаря this SO answer, я получил следующее, которое в моем случае прекрасно работает при прокрутке фрагментов 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);
    }
}

Ответ 19

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

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

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

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

Я помещаю "кавычки" в кавычки, так как приведенное выше не вызывает onBackPressed() для рассматриваемой Деятельности. Он просто закрывает клавиатуру.

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

Ответ 21

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

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

Ответ 22

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

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

Ответ 23

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

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

Ответ 24

Простой и простой в использовании метод, просто вызовите 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);
}

Ответ 25

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

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

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

Ответ 26

public static void hideSoftKeyboard(Activity activity) {
    InputMethodManager inputMethodManager = (InputMethodManager)  activity.getSystemService(Activity.INPUT_METHOD_SERVICE);
    inputMethodManager.hideSoftInputFromWindow(activity.getCurrentFocus().getWindowToken(), 0);
}

после этого вызова onTouchListener:

findViewById(android.R.id.content).setOnTouchListener(new OnTouchListener() {
    @Override
    public boolean onTouch(View v, MotionEvent event) {
        Utils.hideSoftKeyboard(activity);
        return false;
    }
});

Ответ 27

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

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

Ответ 28

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

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

Ответ 29

У меня есть случай, где my EditText может быть также расположен в AlertDialog, поэтому клавиатура должна быть закрыта при увольнении. Следующий код, кажется, работает где угодно:

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

Ответ 30

Я почти попробовал все эти ответы, у меня были некоторые случайные проблемы, особенно с галактикой Samsung 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);
}