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

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

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

3140
задан Vidar Vestnes 10 июля '09 в 14:27
источник поделиться
75 ответов
  • 1
  • 2
  • 3

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

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

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

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

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

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

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

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

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

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

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

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

О windowSoftInputMode

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

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

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

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

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


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

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

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

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

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

С учетом фрагмента Fragment в качестве параметра:

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

Начиная с вашего содержимого:

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

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

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

view.clearFocus();

1086
ответ дан rmirabelle 22 июля '13 в 16:44
источник поделиться

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

4191
ответ дан Reto Meier 10 июля '09 в 14:52
источник поделиться

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

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

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

746
ответ дан Garnet Ulrich 13 янв. '10 в 22:01
источник поделиться

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

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

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

298
ответ дан Saurabh Pareek 29 февр. '12 в 8:31
источник поделиться

Решение 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);
    }
}
129
ответ дан mckoss 12 февр. '10 в 0:07
источник поделиться

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

EditText edtView=(EditText)findViewById(R.id.editTextConvertValue);
edtView.setInputType(0);
117
ответ дан Jeyavel 04 дек. '09 в 13:01
источник поделиться

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);
110
ответ дан Nguyen Minh Binh 17 авг. '11 в 17:06
источник поделиться
protected void hideSoftKeyboard(EditText input) {
    input.setInputType(0);
    InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
    imm.hideSoftInputFromWindow(input.getWindowToken(), 0);    
}
65
ответ дан Sreedev R 04 мая '12 в 7:02
источник поделиться

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

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

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 ... */
}
51
ответ дан Alex 23 марта '13 в 17:33
источник поделиться

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

// 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);
45
ответ дан shontauro 22 февр. '12 в 21:54
источник поделиться

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

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


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

42
ответ дан Alex.F 04 авг. '14 в 16:09
источник поделиться

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

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);
40
ответ дан slinden77 07 сент. '13 в 11:45
источник поделиться

Я использую пользовательскую клавиатуру для ввода номера шестнадцатеричного кода, поэтому я не могу отображать клавиатуру 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);
36
ответ дан sergio91pt 04 мая '12 в 0:28
источник поделиться
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 01 июня '15 в 16:36
источник поделиться

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

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

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

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

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

К сожалению, пункты 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 до версии 7. 4.2.2. Единственным недостатком такого подхода является то, что вам нужно быть осторожным при обращении с кнопкой "Назад". Поскольку у моего приложения есть только один экран (его калькулятор), я могу переопределить onBackPressed() и вернуться на главный экран устройства.

25
ответ дан Luke Sleeman 06 апр. '13 в 16:20
источник поделиться

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

if (getCurrentFocus() != null) {
    InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
    imm.hideSoftInputFromWindow(getCurrentFocus().getWindowToken(), 0);
}
24
ответ дан Saran 05 сент. '13 в 1:38
источник поделиться

Благодаря 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);
    }
}
21
ответ дан ban-geoengineering 23 июля '15 в 11:43
источник поделиться

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

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 14 сент. '12 в 21:51
источник поделиться

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

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

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

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

15
ответ дан Peter Ajtai 13 дек. '11 в 21:52
источник поделиться

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

InputMethodManager imm = GetSystemService (Context.InputMethodService) as InputMethodManager;
if (imm != null)
    imm.HideSoftInputFromWindow (searchbox.WindowToken , 0);
14
ответ дан BahaiResearch.com 15 мая '12 в 4:36
источник поделиться

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

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 03 дек. '13 в 9:24
источник поделиться

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

<activity
            android:name=".ui.activity.MainActivity"
            android:label="@string/mainactivity"
            android:windowSoftInputMode="stateHidden"/>
12
ответ дан NickUnuchek 04 февр. '16 в 15:21
источник поделиться

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

this.getWindow().setSoftInputMode(
            WindowManager.LayoutParams.SOFT_INPUT_STATE_ALWAYS_HIDDEN);
11
ответ дан Atish Agrawal 09 авг. '13 в 16:42
источник поделиться

Простой и простой в использовании метод, просто вызовите 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 21 февр. '17 в 9:52
источник поделиться

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

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

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

mSearchView.clearFocus();
mSearchView.setFocusable(false);
11
ответ дан tommy chheng 14 марта '13 в 0:31
источник поделиться

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

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 04 февр. '16 в 14:46
источник поделиться

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

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 25 мая '14 в 15:38
источник поделиться

У меня есть случай, где 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 );
}
10
ответ дан injecteer 03 дек. '14 в 18:30
источник поделиться
  • 1
  • 2
  • 3

Другие вопросы по меткам