it-swarm.com.ru

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

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

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

3341
Vidar Vestnes

Чтобы прояснить это безумие, я хотел бы начать с извинения от имени всех пользователей 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

Это не сработает, потому что вы передадите ссылку на хост FragmentActivity, который не будет иметь сфокусированного контроля, пока отображается 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();

1420
rmirabelle

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

Также полезно скрыть софт-клавиатуру:

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

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

764
Garnet Ulrich

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

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

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

317
Saurabh Pareek

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

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

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

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

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);
118
Nguyen Minh Binh
protected void hideSoftKeyboard(EditText input) {
    InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
    imm.hideSoftInputFromWindow(input.getWindowToken(), 0);    
}
74
Sreedev R

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

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

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

    if (isFocused) {
        searchEditText.requestFocus();
    }
}

Затем убедитесь, что на Focus 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);
63
Rotemmiz

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

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

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

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

В вашем слушателе OnClick вызовите onEditorActionEditText с IME_ACTION_DONE

button.setOnClickListener(new OnClickListener() {

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

Развертка

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


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

46
Alex.F

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

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

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

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

getWindow().setFlags(WindowManager.LayoutParams.FLAG_ALT_FOCUSABLE_IM,
        WindowManager.LayoutParams.FLAG_ALT_FOCUSABLE_IM);
39
sergio91pt
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);
    }
}
29
shobhan

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

Вы можете увидеть работающую реализацию этого в моем приложении clean 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 должен показать клавиатуру, а в окне указывается, чтобы программный ввод был всегда видимым. Если программная клавиатура должна быть скрыта, то устанавливается WindowManager.LayoutParams.FLAG_ALT_FOCUSABLE_IM.

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

25
Luke Sleeman

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

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

Благодаря этому 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);
    }
}
21
ban-geoengineering

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

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();
}
18
Ash

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

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

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

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

17
Peter Ajtai

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

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

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

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

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

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);
    }
}
13
Asaf Pinhassi

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

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

mSearchView.clearFocus();
mSearchView.setFocusable(false);
11
tommy chheng

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

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

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

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

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

this.getWindow().setSoftInputMode(
            WindowManager.LayoutParams.SOFT_INPUT_STATE_ALWAYS_HIDDEN);
11
Atish Agrawal

У меня есть случай, когда моя 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 );
}
10
injecteer
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;
    }
});
10
Riser

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

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

Работает как волшебное прикосновение каждый раз

private void closeKeyboard() {
    InputMethodManager inputManager = (InputMethodManager)getActivity().getSystemService(Context.INPUT_METHOD_SERVICE);
    inputManager.hideSoftInputFromWindow(getActivity().getCurrentFocus().getWindowToken(), InputMethodManager.HIDE_NOT_ALWAYS);

}

private void openKeyboard() {
    InputMethodManager imm = (InputMethodManager) getActivity().getSystemService(Context.INPUT_METHOD_SERVICE);
    if(imm != null){
        imm.toggleSoftInput(InputMethodManager.SHOW_IMPLICIT, 0);
    }
}
8
Giedrius Šlikas

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

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);
8
Girish Patel

Вы также можете изучить использование setImeOption в EditText.

У меня просто была очень симулированная ситуация, когда мой макет содержал EditText и кнопку поиска. Когда я обнаружил, что могу просто установить опцию ime на «actionSearch» в своем editText, я понял, что мне больше не нужна кнопка поиска. Программная клавиатура (в этом режиме) имеет значок поиска, с помощью которого можно начать поиск (и клавиатура закрывается, как и следовало ожидать). 

8
jasonhudgins

иногда все, что вам нужно, это кнопка ввода, чтобы сложить keyboard дать поле EditText, у которого есть атрибут 

 Android:imeOptions="actionDone" 

это изменит кнопку Enter на кнопку Done, которая закроет клавиатуру.

7
user1765048

Меня устраивает..

EditText editText=(EditText)findViewById(R.id.edittext1);

поместите ниже строки кода в onClick ()

editText.setFocusable(false);
editText.setFocusableInTouchMode(true);

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

(ИЛИ ЖЕ)

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

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

Следующий обходной путь работает, если вы поместите его в конец onCreate

getWindow().setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_STATE_ALWAYS_HIDDEN);
new Handler().postDelayed(new Runnable() {
            @Override
            public void run() {
                getWindow().setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_ADJUST_PAN);
            }
        },100);
6
Ricardo

Попробуй это

  • Просто вы можете позвонить в свой Activity 

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

  • В вашем MainActivitiy позвоните 

 hideKeyboardwithoutPopulate(MainActivity.this);

6
Vishal Yadav

В AndroidManifest.xml под <activity..> установите Android:windowSoftInputMode="stateAlwaysHidden"

5
milad.moafi

Если вы хотите скрыть клавиатуру, используя код Java, используйте это:

  InputMethodManager imm = (InputMethodManager)this.getSystemService(Context.INPUT_METHOD_SERVICE);
  imm.hideSoftInputFromWindow(fEmail.getWindowToken(), 0);

Или, если вы хотите всегда скрывать клавиатуру, используйте это в AndroidManifest:

 <activity
 Android:name=".activities.MyActivity"
 Android:configChanges="keyboardHidden"  />
5
pavel

Я написал небольшое расширение для Kotlin, если кто-то заинтересовался, не очень проверял это:

fun Fragment.hideKeyboard(context: Context = App.instance) {
    val windowToken = view?.rootView?.windowToken
    windowToken?.let {
        val imm = context.getSystemService(Activity.INPUT_METHOD_SERVICE) as InputMethodManager
        imm.hideSoftInputFromWindow(windowToken, 0)
    }
}

App.instance является статическим объектом «this», хранящимся в приложении

Обновление: в некоторых случаях windowToken имеет значение null. Я добавил дополнительный способ закрытия клавиатуры с помощью отражения, чтобы определить, закрыта ли клавиатура

/**
 * If no window token is found, keyboard is checked using reflection to know if keyboard visibility toggle is needed
 *
 * @param useReflection - whether to use reflection in case of no window token or not
 */
fun Fragment.hideKeyboard(context: Context = MainApp.instance, useReflection: Boolean = true) {
    val windowToken = view?.rootView?.windowToken
    val imm = context.getSystemService(Context.INPUT_METHOD_SERVICE) as InputMethodManager
    windowToken?.let {
        imm.hideSoftInputFromWindow(windowToken, 0)
    } ?: run {
        if (useReflection) {
            try {
                if (getKeyboardHeight(imm) > 0) {
                    imm.toggleSoftInput(0, InputMethodManager.HIDE_NOT_ALWAYS)
                }
            } catch (exception: Exception) {
                Timber.e(exception)
            }
        }
    }
}

fun getKeyboardHeight(imm: InputMethodManager): Int = InputMethodManager::class.Java.getMethod("getInputMethodWindowVisibleHeight").invoke(imm) as Int
5
Janusz Hain
public static void hideSoftKeyboard(Activity activity) {
    InputMethodManager inputMethodManager = (InputMethodManager)activity.getSystemService(Activity.INPUT_METHOD_SERVICE);
    inputMethodManager.hideSoftInputFromWindow(activity.getCurrentFocus().getWindowToken(), 0);
}
5
Muhammad Aamir Ali

это работает ..

Просто передайте текущий экземпляр активности в функцию 

 public void isKeyBoardShow(Activity activity) {
    InputMethodManager imm = (InputMethodManager) activity.getSystemService(Activity.INPUT_METHOD_SERVICE);
    if (imm.isActive()) {
        imm.toggleSoftInput(InputMethodManager.HIDE_IMPLICIT_ONLY, 0); // hide
    } else {
        imm.toggleSoftInput(0, InputMethodManager.HIDE_IMPLICIT_ONLY); // show
    }
}
5
dev_mg99

На самом деле, авторитет Android всегда дает новые обновления, но они не устраняют свои старые недостатки, с которыми сталкиваются все разработчики Android в своей разработке. Это должно быть обработано авторитетом Android по умолчанию, при изменении фокуса с EditText следует скрыть/показать параметр клавиатуры мягкого ввода. Но извините, они не справляются. Хорошо Оставь это.

Ниже приведены решения для отображения/скрытия/переключения параметра клавиатуры в разделе «Деятельность» или «Фрагмент».

Показать клавиатуру для просмотра:

/**
 * open soft keyboard.
 *
 * @param context
 * @param view
 */
public static void showKeyBoard(Context context, View view) {
    try {
        InputMethodManager keyboard = (InputMethodManager) context.getSystemService(Context.INPUT_METHOD_SERVICE);
        keyboard.showSoftInput(view, 0);
    } catch (Exception e) {
        e.printStackTrace();
    }
}

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

/**
 * open soft keyboard.
 *
 * @param mActivity context
 */
public static void showKeyBoard(Activity mActivity) {
    try {
        View view = mActivity.getCurrentFocus();
        if (view != null) {
            InputMethodManager keyboard = (InputMethodManager) mActivity.getSystemService(Context.INPUT_METHOD_SERVICE);
            keyboard.showSoftInputFromInputMethod(view.getWindowToken(), InputMethodManager.SHOW_FORCED);
        }
    } catch (Exception e) {
        e.printStackTrace();
    }
}

Показать клавиатуру с контекстом фрагмента:

/**
 * open soft keyboard.
 *
 * @param mFragment context
 */
public static void showKeyBoard(Fragment mFragment) {
    try {
        if (mFragment == null || mFragment.getActivity() == null) {
            return;
        }
        View view = mFragment.getActivity().getCurrentFocus();
        if (view != null) {
            InputMethodManager keyboard = (InputMethodManager) mFragment.getActivity().getSystemService(Context.INPUT_METHOD_SERVICE);
            keyboard.showSoftInputFromInputMethod(view.getWindowToken(), InputMethodManager.SHOW_FORCED);
        }
    } catch (Exception e) {
        e.printStackTrace();
    }
}

Скрыть клавиатуру для просмотра:

/**
 * close soft keyboard.
 *
 * @param context
 * @param view
 */
public static void hideKeyBoard(Context context, View view) {
    try {
        InputMethodManager keyboard = (InputMethodManager) context.getSystemService(Context.INPUT_METHOD_SERVICE);
        keyboard.hideSoftInputFromWindow(view.getWindowToken(), 0);
    } catch (Exception e) {
        e.printStackTrace();
    }
}

Скрыть клавиатуру в контексте действия:

/**
 * close opened soft keyboard.
 *
 * @param mActivity context
 */
public static void hideSoftKeyboard(Activity mActivity) {
    try {
        View view = mActivity.getCurrentFocus();
        if (view != null) {
            InputMethodManager inputManager = (InputMethodManager) mActivity.getSystemService(Context.INPUT_METHOD_SERVICE);
            inputManager.hideSoftInputFromWindow(view.getWindowToken(), 0);
        }
    } catch (Exception e) {
        e.printStackTrace();
    }
}

Скрыть клавиатуру с контекстом фрагмента:

/**
 * close opened soft keyboard.
 *
 * @param mFragment context
 */
public static void hideSoftKeyboard(Fragment mFragment) {
    try {
        if (mFragment == null || mFragment.getActivity() == null) {
            return;
        }
        View view = mFragment.getActivity().getCurrentFocus();
        if (view != null) {
            InputMethodManager inputManager = (InputMethodManager) mFragment.getActivity().getSystemService(Context.INPUT_METHOD_SERVICE);
            inputManager.hideSoftInputFromWindow(view.getWindowToken(), 0);
        }
    } catch (Exception e) {
        e.printStackTrace();
    }
}

Переключить клавиатуру:

/**
 * toggle soft keyboard.
 *
 * @param context
 */
public static void toggleSoftKeyboard(Context context) {
    try {
        InputMethodManager imm = (InputMethodManager) context.getSystemService(Activity.INPUT_METHOD_SERVICE);
        imm.toggleSoftInput(InputMethodManager.HIDE_IMPLICIT_ONLY, 0);
    } catch (Exception e) {
        e.printStackTrace();
    }
}
4
Ready Android

просто код: используйте этот код в onCreate ()

getWindow().setSoftInputMode(
    WindowManager.LayoutParams.SOFT_INPUT_STATE_ALWAYS_HIDDEN
);
4
Adnan Abdollah Zaki

Здесь есть оба метода скрытия и показа.

Котлин

fun hideKeyboard(activity: Activity) {
    val v = activity.currentFocus
    val imm = activity.getSystemService(Context.INPUT_METHOD_SERVICE) as InputMethodManager
    assert(v != null)
    imm.hideSoftInputFromWindow(v!!.windowToken, InputMethodManager.HIDE_NOT_ALWAYS)
}

private fun showKeyboard(activity: Activity) {
    val v = activity.currentFocus
    val imm = activity.getSystemService(Context.INPUT_METHOD_SERVICE) as InputMethodManager
    assert(v != null)
    imm.showSoftInput(v, InputMethodManager.SHOW_IMPLICIT)
}

Джава

public static void hideKeyboard(Activity activity) {
    View v = activity.getCurrentFocus();
    InputMethodManager imm = (InputMethodManager) activity.getSystemService(Context.INPUT_METHOD_SERVICE);
    assert imm != null && v != null;
    imm.hideSoftInputFromWindow(v.getWindowToken(), InputMethodManager.HIDE_NOT_ALWAYS);
}

private static void showKeyboard(Activity activity) {
    View v = activity.getCurrentFocus();
    InputMethodManager imm = (InputMethodManager) activity.getSystemService(Context.INPUT_METHOD_SERVICE);
    assert imm != null && v != null;
    imm.showSoftInput(v, InputMethodManager.SHOW_IMPLICIT);
}
3
Khemraj

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

Добавьте это расширение функций:

Для деятельности:

fun Activity.hideKeyboard() {
    val inputManager = getSystemService(Context.INPUT_METHOD_SERVICE) as InputMethodManager
    val view = currentFocus
    if (view != null) {
        inputManager.hideSoftInputFromWindow(view.windowToken, InputMethodManager.HIDE_NOT_ALWAYS)
    }
}

Для фрагмента:

fun Fragment.hideKeyboard() {
    activity?.let {
        val inputManager = it.getSystemService(Context.INPUT_METHOD_SERVICE) as InputMethodManager
        val view = it.currentFocus
        if (view != null) {
            inputManager.hideSoftInputFromWindow(view.windowToken, InputMethodManager.HIDE_NOT_ALWAYS)
        }
    }
}

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

 hideKeyboard()
3
Krasavello13
final RelativeLayout llLogin = (RelativeLayout) findViewById(R.id.rl_main);
        llLogin.setOnTouchListener(
                new View.OnTouchListener() {
                    @Override
                    public boolean onTouch(View view, MotionEvent ev) {
                        InputMethodManager imm = (InputMethodManager) this.getSystemService(
                                Context.INPUT_METHOD_SERVICE);
                        imm.hideSoftInputFromWindow(this.getCurrentFocus().getWindowToken(), 0);
                        return false;
                    }
                });
3
Mr.vicky

Попробуй это

public void disableSoftKeyboard(final EditText v) {
    if (Build.VERSION.SDK_INT >= 11) {
        v.setRawInputType(InputType.TYPE_CLASS_TEXT);
        v.setTextIsSelectable(true);
    } else {
        v.setRawInputType(InputType.TYPE_NULL);
        v.setFocusable(true);
    }
}
3
Sagar Badave

Очень простой способ

Я делаю это во всех своих проектах и ​​работаю как во сне. В ваших объявлениях layout.xml просто добавьте одну строку:

Android:focusableInTouchMode="true"

Пример полного кода:

<?xml version="1.0" encoding="utf-8"?>
<Android.support.constraint.ConstraintLayout
    xmlns:app="http://schemas.Android.com/apk/res-auto"
    Android:layout_width="match_parent"
    Android:layout_height="match_parent"
    Android:focusableInTouchMode="true">

    <EditText
        Android:layout_width="match_parent"
        Android:layout_height="wrap_content" />

    <ListView
        Android:layout_width="match_parent"
        Android:layout_height="wrap_content">

    </ListView>

</Android.support.constraint.ConstraintLayout>
3
Daniel Beltrami

Вот лучшие решения

Решение 1) Установите для inputType значение «text»

<EditText
Android:id="@+id/my_edit_text"
Android:layout_width="fill_parent"
Android:layout_height="wrap_content"
Android:hint="Tap here to type"
Android:inputType="text" />

Это также может быть сделано программно через. метод setInputType () (унаследованный от TextView). 

EditText editText = (EditText) findViewById(R.id.my_edit_text);
editText.setRawInputType(InputType.TYPE_CLASS_TEXT | 
InputType.TYPE_TEXT_VARIATION_NORMAL);

Решение 2) Используйте InputMethodManager.hideSoftInputFromWindow ()

InputMethodManager imm = 
(InputMethodManager)getSystemService(Context.INPUT_METHOD_SERVICE);
imm.hideSoftInputFromWindow(myEditText.getWindowToken(), 0);

или же

InputMethodManager imm = (InputMethodManager) 
getSystemService(Context.INPUT_METHOD_SERVICE);
imm.hideSoftInputFromWindow(myEditText.getWindowToken(), 
InputMethodManager.HIDE_NOT_ALWAYS);
3
Faxriddin Abdullayev

простой метод, ребята: попробуйте это ...

private void closeKeyboard(boolean b) {

        View view = this.getCurrentFocus();

        if(b) {
            if (view != null) {
                InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
                imm.hideSoftInputFromWindow(view.getWindowToken(), 0);
            }
        }
        else {
            InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
            imm.showSoftInput(view, 0);
        }
    }
3
Joolah
public static void hideSoftKeyboard(Activity activity) {
    InputMethodManager inputMethodManager = (InputMethodManager) activity
            .getSystemService(Activity.INPUT_METHOD_SERVICE);
    inputMethodManager.hideSoftInputFromWindow(activity.getCurrentFocus()
            .getWindowToken(), 0);
}
3
Vaishali Sutariya

Когда вы хотите скрыть клавиатуру вручную по нажатию кнопки:

/**
 * Hides the already popped up keyboard from the screen.
 *
 */
public void hideKeyboard() {
    try {
        // use application level context to avoid unnecessary leaks.
        InputMethodManager inputManager = (InputMethodManager) getApplicationContext().getSystemService(Context.INPUT_METHOD_SERVICE);
        assert inputManager != null;
        inputManager.hideSoftInputFromWindow(getCurrentFocus().getWindowToken(), InputMethodManager.HIDE_NOT_ALWAYS);
    } catch (Exception e) {
        e.printStackTrace();
    }
}

Если вы хотите скрыть клавиатуру, где бы вы ни щелкали на экране, кроме текста редактирования Переопределите этот метод в своей деятельности:

@Override
public boolean dispatchTouchEvent(MotionEvent ev) {
    View view = getCurrentFocus();
    if (view != null && (ev.getAction() == MotionEvent.ACTION_UP || ev.getAction() == MotionEvent.ACTION_MOVE) && view instanceof EditText && !view.getClass().getName().startsWith("Android.webkit.")) {
        int scrcoords[] = new int[2];
        view.getLocationOnScreen(scrcoords);
        float x = ev.getRawX() + view.getLeft() - scrcoords[0];
        float y = ev.getRawY() + view.getTop() - scrcoords[1];
        if (x < view.getLeft() || x > view.getRight() || y < view.getTop() || y > view.getBottom())
            ((InputMethodManager)this.getSystemService(Context.INPUT_METHOD_SERVICE)).hideSoftInputFromWindow((this.getWindow().getDecorView().getApplicationWindowToken()), 0);
    }
    return super.dispatchTouchEvent(ev);
}
2
Rishabh Saxena

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

View view = this.getCurrentFocus();
if (view != null) {  
InputMethodManager im = 
(InputMethodManager)getSystemService(Context.INPUT_METHOD_SERVICE);
im.hideSoftInputFromWindow(view.getWindowToken(), 0);
}

Вызов editText.clearFocus () и затем InputMethodManager.HIDE_IMPLICIT_ONLY даже работает 

2
Nadeem Bhat

вы можете просто добавить этот код, где вы хотите, чтобы скрыть программную клавиатуру "

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

В котлине

fun hideKeyboard(activity: BaseActivity) {
        val view = activity.currentFocus?: View(activity)
        val imm = activity.getSystemService(Activity.INPUT_METHOD_SERVICE) as InputMethodManager
        imm.hideSoftInputFromWindow(view.windowToken, 0)
    }
2
Qamar

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

public class MyActivity extends Activity
{
    /** This maintains true if the keyboard is open. Otherwise, it is false. */
    private boolean isKeyboardOpen = false;

    @Override
    public void onCreate(Bundle savedInstanceState)
    {
        super.onCreate(savedInstanceState);
        LayoutInflater inflater;
        inflater = (LayoutInflater) getSystemService(Context.LAYOUT_INFLATER_SERVICE);
        View contentView = inflater.inflate(context.getResources().getIdentifier("main", "layout", getPackageName()), null);

        setContentView(contentView);
        contentView.getViewTreeObserver().addOnGlobalLayoutListener(new OnGlobalLayoutListener() 
        {
            public void onGlobalLayout() 
            {
                Rect r = new Rect();
                contentView.getWindowVisibleDisplayFrame(r);
                int heightDiff = contentView.getRootView().getHeight() - (r.bottom - r.top);
                if (heightDiff > 100) 
                    isKeyboardVisible = true;
                else
                    isKeyboardVisible = false;
             });
         }
    }

    public void closeKeyboardIfOpen()
    {
        InputMethodManager imm;
        imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
        if (isKeyboardVisible)
            imm.toggleSoftInput(InputMethodManager.HIDE_IMPLICIT_ONLY, 0);
    }   
}
2
Phil

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

public static void hideSoftKeyboard(Context mContext,EditText username){
        if(((Activity) mContext).getCurrentFocus()!=null && ((Activity) mContext).getCurrentFocus() instanceof EditText){
            InputMethodManager imm = (InputMethodManager)mContext.getSystemService(Context.INPUT_METHOD_SERVICE);
            imm.hideSoftInputFromWindow(username.getWindowToken(), 0);
        }
    }

Используйте это так:

Какой бы ни была версия Android. Этот метод обязательно сработает

2
Gaurav Arora

Это сработало для меня.

public static void hideKeyboard(Activity act, EditText et){
    Context c = act.getBaseContext();
    View v = et.findFocus();
    if(v == null)
        return;
    InputMethodManager inputManager = (InputMethodManager) c.getSystemService(Context.INPUT_METHOD_SERVICE);
    inputManager.hideSoftInputFromWindow(v.getWindowToken(), InputMethodManager.HIDE_NOT_ALWAYS);
}
2
moberme

Все отчаянно опробовал все здесь, комбинируя все методы, и, конечно, клавиатура не закрывается в Android 4.0.3 (она работала в Honeicomb AFAIR).

Затем я неожиданно обнаружил выигрышную комбинацию:

textField.setRawInputType(InputType.TYPE_CLASS_TEXT |InputType.TYPE_TEXT_VARIATION_NORMAL);

в сочетании с вашими обычными рецептами

blahblaj.hideSoftInputFromWindow ...

надеюсь, что это останавливает кого-то от самоубийства .. Я был близок к этому. Конечно, я понятия не имею, почему это работает.

1
rupps

Альтернативой использования SearchView будет использование этого кода:

searchView = (SearchView) searchItem.getActionView();    
searchView.setOnQueryTextListener(new OnQueryTextListener() {
    @Override
    public boolean onQueryTextSubmit(String query) {
        InputMethodManager imm = (InputMethodManager)
        getSystemService(getApplicationContext().INPUT_METHOD_SERVICE);
        imm.hideSoftInputFromWindow(searchView.getApplicationWindowToken(), 0);
    }
}

Это окно поиска SearchView в панели действий, которое при отправке текста из запроса (пользователь нажимает клавишу Enter или кнопку/значок поиска), затем активируется код InputMethodManager и приводит к падению вашей программной клавиатуры. Этот код был помещен в мою onCreateOptionsMenu(). searchItem из MenuItem, который является частью кода по умолчанию для onCreateOptionsmenu(). Спасибо @mckoss за хороший кусок этого кода!

1
Azurespot

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

fun View.hideKeyboard() = this.let {
    val imm = context.getSystemService(Context.INPUT_METHOD_SERVICE) as InputMethodManager
    imm.hideSoftInputFromWindow(windowToken, 0)
}

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

window.decorView.hideKeyboard();

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

etUsername.hideKeyboard();

Удачного кодирования ...

1
Jedsada Tiwongvorakul

Вызовите этот метод, чтобы скрыть программную клавиатуру

public void hideKeyBoard() {
    View view1 = this.getCurrentFocus();
    if(view!= null){
        InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
        imm.hideSoftInputFromWindow(view1.getWindowToken(), 0);
    }
}
1
Rajneesh Shukla
public static void closeInput(final View caller) {  
    caller.postDelayed(new Runnable() {
        @Override
        public void run() {
            InputMethodManager imm = (InputMethodManager) caller.getContext().getSystemService(Context.INPUT_METHOD_SERVICE);
            imm.hideSoftInputFromWindow(caller.getWindowToken(), InputMethodManager.HIDE_NOT_ALWAYS);
        }
    }, 100);
}

Этот метод обычно работает, но есть одно условие: вы не можете установить Android:windowSoftInputMode="any_of_these"

1
Jacek Kwiecień

Несмотря на все эти ответы, просто чтобы быть достаточно простым, я написал общий метод для этого:

/**
 * hide soft keyboard in a activity
 * @param activity
 */
public static void hideKeyboard (Activity activity){
    activity.getWindow().setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_STATE_HIDDEN);
    if (activity.getCurrentFocus() != null) {
        InputMethodManager inputMethodManager = (InputMethodManager) activity.getSystemService(activity.INPUT_METHOD_SERVICE);
        inputMethodManager.hideSoftInputFromWindow(activity.getCurrentFocus().getWindowToken(), 0);
    }
}
1
Geng Jiawen

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

import Android.app.Activity
import Android.content.Context
import Android.support.design.widget.Snackbar
import Android.view.View
import Android.view.inputmethod.InputMethodManager

public class KeyboardHider {
    companion object {

        fun hideKeyboard(view: View, context: Context) {
            val inputMethodManager = context.getSystemService(Activity.INPUT_METHOD_SERVICE) as InputMethodManager
            inputMethodManager.hideSoftInputFromWindow(view.windowToken, 0)
        }

    }

}

Вызовите метод Above из любого места, используя одну строку кода.

CustomSnackbar.hideKeyboard(view, [email protected])

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

1
Arihant Jain

Привет Это просто, если вы работаете с Kotlin, я верю, что вы можете легко преобразовать код в Java тоже сначала в своей деятельности, используйте эту функцию, когда ваша деятельность загружается, например, в вызове onCreate ().

fun hideKeybord (){
val inputManager = getSystemService(Context.INPUT_METHOD_SERVICE) as InputMethodManager
if (inputManager.isAcceptingText){
    inputManager.hideSoftInputFromWindow(currentFocus.windowToken, 0)
}

}

как я уже упоминал, вызовите эту функцию в методе onCreate (), а затем добавьте эту строку Android:windowSoftInputMode="stateAlwaysHidden" к своей активности в файле manafest.xml. Вот так ... 

<activity
    Android:name=".Activity.MainActivity"
    Android:label="@string/app_name"
    Android:theme="@style/AppTheme.NoActionBar"
    Android:windowSoftInputMode="stateAlwaysHidden">
0
hardiBSalih

Для пользователей kotlin здесь есть метод расширения kotlin, который работал для моих случаев использования:

fun View.hideKeyboard() {
    val imm = this.context.getSystemService(Activity.INPUT_METHOD_SERVICE) as InputMethodManager
    imm.hideSoftInputFromWindow(windowToken, 0)
}

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

0
shrewdu

Если ваше приложение нацелено на API Level 21 или более , то есть метод по умолчанию:

editTextObj.setShowSoftInputOnFocus(false);

Убедитесь, что вы установили код ниже в XML-теге EditText.

<EditText  
    ....
    Android:enabled="true"
    Android:focusable="true" />
0
Harpreet

Этот фрагмент кода может помочь:

    final InputMethodManager inputMethodManager = (InputMethodManager) getSystemService(Activity.INPUT_METHOD_SERVICE);
    if (inputMethodManager != null && inputMethodManager.isActive()) {
        if (getCurrentFocus() != null) {
            inputMethodManager.hideSoftInputFromWindow(getCurrentFocus().getWindowToken(), 0);
        }
    }

Его можно вызывать в различных методах в зависимости от необходимости (например, onPause, onResume, onRestart ...)

0
Selman Tosun

Я использую следующие расширения активности Kotlin:

/**
 * Hides soft keyboard if is open.
 */
fun Activity.hideKeyboard() {
    currentFocus?.windowToken?.let {
        (getSystemService(Context.INPUT_METHOD_SERVICE) as? InputMethodManager?)
                ?.hideSoftInputFromWindow(it, InputMethodManager.HIDE_NOT_ALWAYS)
    }
}

/**
 * Shows soft keyboard and request focus to given view.
 */
fun Activity.showKeyboard(view: View) {
    view.requestFocus()
    currentFocus?.windowToken?.let {
        (getSystemService(Context.INPUT_METHOD_SERVICE) as? InputMethodManager?)
                ?.showSoftInput(view, InputMethodManager.SHOW_IMPLICIT)
    }
}
0
jBegera

Чтобы показать клавиатуру при запуске приложения:

        getWindow().setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_ADJUST_PAN | WindowManager.LayoutParams.SOFT_INPUT_STATE_VISIBLE);
        view.requestFocus();
        new Handler().postDelayed(new Runnable() {
            public void run() {
                getWindow().setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_ADJUST_PAN);
            }
        }, 1000);
0
Dmitry

Котлин версия 

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

окружите его попыткой catch, чтобы клавиатура уже была закрыта, приложение не зависало: 

try{

View view = this.getCurrentFocus();
if (view != null) {  
    InputMethodManager imm = (InputMethodManager)getSystemService(Context.INPUT_METHOD_SERVICE);
    imm.hideSoftInputFromWindow(view.getWindowToken(), 0);
}
}catch (Exception e)
{
  e.printStackTrace();
}
0
Heena Arora

Я очень много перепробовал все решения, но у меня не получилось, поэтому я нашел свое решение: У вас должны быть логические переменные, такие как:

public static isKeyboardShowing = false;
InputMethodManager inputMethodManager = (InputMethodManager) getActivity()
            .getSystemService(Context.INPUT_METHOD_SERVICE);

И в случае сенсорного экрана вы звоните:

@Override
public boolean onTouchEvent(MotionEvent event) {
    if(keyboardShowing==true){
        inputMethodManager.toggleSoftInput(InputMethodManager.RESULT_UNCHANGED_HIDDEN, 0);
        keyboardShowing = false;
    }
    return super.onTouchEvent(event);
}

И в EditText есть в любом месте:

yourEditText.setOnClickListener(new OnClickListener() {

        @Override
        public void onClick(View v) {
            yourClass.keyboardShowing = true;

        }
    });
0
nobjta_9x_tq

Для Xamarin. Android:

public void HideKeyboard()
{
    var imm = activity.GetSystemService(Context.InputMethodService).JavaCast<InputMethodManager>();
    var view = activity.CurrentFocus ?? new View(activity);
    imm.HideSoftInputFromWindow(view.WindowToken, HideSoftInputFlags.None);
}
0
mr5

Вам нужно всего лишь написать одну строку внутри вашего тега активности манифеста

 Android:windowSoftInputMode="stateAlwaysHidden|adjustPan"

и это будет работать.

0
Mansuu....
 fun hideKeyboard(appCompatActivity: AppCompatActivity) {
        val view = appCompatActivity.currentFocus
        val imm = appCompatActivity.getSystemService(Context.INPUT_METHOD_SERVICE) as InputMethodManager
        imm.hideSoftInputFromWindow(view.windowToken, 0)
    }
0
Umesh Maharjan

просто сделать общий метод для всего приложения в BaseActivity и BaseFragment

в onCreate() инициализировать inputMethodManager

inputMethodManager = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);

сделать эти методы, чтобы скрыть и показать клавиатуру

public void hideKeyBoard(View view) {
     if (view != null) {
         inputMethodManager.hideSoftInputFromWindow(view.getWindowToken(), 0);
      }
 }

public void showKeyboard(View view, boolean isForceToShow) {
      if (isForceToShow)
         inputMethodManager.toggleSoftInput(InputMethodManager.SHOW_FORCED, 0);
      else if (view != null)
           inputMethodManager.showSoftInput(view, 0);
}
0
Priyankagb
use Text watcher instead of EditText.and after you finished entering the input 

ты можешь использовать 

InputMethodManager imm = (InputMethodManager)getSystemService(Context.INPUT_METHOD_SERVICE);
    imm.hideSoftInputFromWindow(view.getWindowToken(), 0);
0
koteswara D K
there are two ways to do so...

method 1:in manifest file

define the line **Android:windowSoftInputMode="adjustPan|stateAlwaysHidden"** of code in your manifest.xml file as below...

<activity
            Android:name="packagename.youactivityname"
            Android:screenOrientation="portrait"
            Android:windowSoftInputMode="adjustPan|stateAlwaysHidden" />

Method 2 : in Activity or Java class

 if(getCurrentFocus()!=null) {
            InputMethodManager inputMethodManager = (InputMethodManager) getSystemService(INPUT_METHOD_SERVICE)`enter code here`;
            inputMethodManager.hideSoftInputFromWindow(getCurrentFocus().getWindowToken(), 0);
        }

это будет работать .... @ ASK

0
Ambilpura Sunil Kumar
/** 
 *
 *   Hide I Said!!!
 *
 */
public static boolean hideSoftKeyboard(@NonNull Activity activity) {
    View currentFocus = activity.getCurrentFocus();
    if (currentFocus == null) {
        currentFocus = activity.getWindow().getDecorView();
        if (currentFocus != null) {
            return getSoftInput(activity).hideSoftInputFromWindow(currentFocus.getWindowToken(), 0, null);
        }
    }
    return false;
}

public static boolean hideSoftKeyboard(@NonNull Context context) {
   if(Activity.class.isAssignableFrom(context.getClass())){
       return hideSoftKeyboard((Activity)context);
   }
   return false;
}

public static InputMethodManager getSoftInput(@NonNull Context context) {
    return (InputMethodManager) context.getSystemService(Activity.INPUT_METHOD_SERVICE);
}
0
ceph3us

Некоторый код котлина: 

Скрыть клавиатуру из Активности:

(currentFocus ?: View(this))
            .apply { (getSystemService(Activity.INPUT_METHOD_SERVICE) as InputMethodManager)
                        .hideSoftInputFromWindow(windowToken, 0) }
0
Rafols

Вики ответ на Kotlin:

1 - Создайте функцию верхнего уровня внутри файла (например, файла, который содержит все ваши функции верхнего уровня):

fun Activity.hideKeyboard(){
    val imm = this.getSystemService(Activity.INPUT_METHOD_SERVICE) as InputMethodManager
    var view = currentFocus
    if (view == null) { view = View(this) }
    imm.hideSoftInputFromWindow(view.windowToken, 0)
}

2 - Затем назовите это в любой деятельности, в которой это было необходимо:

this.hideKeyboard()
0
Phil
public void hideKeyboard() 
{
    if(getCurrentFocus()!=null) 
    {
        InputMethodManager inputMethodManager = (InputMethodManager) getSystemService(INPUT_METHOD_SERVICE);
        inputMethodManager.hideSoftInputFromWindow(getCurrentFocus().getWindowToken(), 0);
    }
}


public void showKeyboard(View mView) {
    InputMethodManager inputMethodManager = (InputMethodManager) getSystemService(INPUT_METHOD_SERVICE);
    mView.requestFocus();
    inputMethodManager.showSoftInput(mView, 0);
}
0
Coldfin Lab
private void hideSoftKeyboard() {
    View view = getView();
    if (view != null) {
        InputMethodManager inputMethodManager = (InputMethodManager) getActivity()
                .getSystemService(Activity.INPUT_METHOD_SERVICE);
        inputMethodManager.hideSoftInputFromWindow(view.getWindowToken(), 0);
    }
}
0
Duna

Прочитав все ответы выше и в другом посте, мне все равно не удалось автоматически открыть клавиатуру.

В моем проекте я создал диалог (AlertDialog) динамически (программируя его без или с минимумом необходимого XML).

Итак, я делал что-то вроде:

    dialogBuilder = new AlertDialog.Builder(activity);

    if(dialogBuilder==null)
        return false; //error

    inflater      = activity.getLayoutInflater();
    dialogView    = inflater.inflate(layout, null);
    ...

И после завершения настройки всех представлений (TextView, ImageView, EditText и т.д.) Я сделал:

        alertDialog = dialogBuilder.create();

        alertDialog.show();

Поэкспериментировав со всеми ответами, я обнаружил, что большинство из них работают IF вы знаете ГДЕ, чтобы поставить запрос ... И это был ключ ко всем.

Итак, хитрость заключается в том, чтобы поставить BEFORE при создании диалога: alertDialog.show() в моем случае это сработало как charm:

        alertDialog = dialogBuilder.create();           
        alertDialog.getWindow().setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_STATE_ALWAYS_VISIBLE);

        //And only when everything is finished - let's bring up the window - 
        alertDialog.show();

        //Viola... keyboard is waiting for you open and ready...
        //Just don't forget to request focus for the needed view (i.e. EditText..)

Я совершенно уверен, что этот принцип одинаков для всех окон, поэтому обратите внимание на расположение вашего кода "showKeyboard" - это должно быть до запуска окна.

Небольшой запрос от команды разработчиков Android SDK:

Я думаю, что все это не нужно, поскольку тысячи программистов со всего мира имеют дело с этой нелепой и тривиальной проблемой, а ее решение должно быть простым и понятным: ИМХО, если я получу requestFocus() для ориентированной на ввод view (например, EditText), клавиатура должна открываться автоматически, если пользователь не запрашивает not-to, поэтому я думаю, что здесь используется метод requestFocus (), и он должен принимать логическое значение showSoftKeyboard со значением по умолчанию true: View.requestFocus(boolean showSoftKeyboard);

Надеюсь, что это поможет другим, как я.

0
JamesC

Попробуйте это в Котлине

 private fun hideKeyboard(){
    val imm = activity!!.getSystemService(INPUT_METHOD_SERVICE) as InputMethodManager
    imm.hideSoftInputFromWindow(activity!!.currentFocus!!.windowToken, 0)
}

Попробуйте это на Java

 private void hideKeyboard(){
  InputMethodManager imm =(InputMethodManager)getSystemService(INPUT_METHOD_SERVICE);
  imm.hideSoftInputFromWindow(getCurrentFocus().getWindowToken(), 0);
}
0
bala