Zamknij / Ukryj miękką klawiaturę Androida

Możesz wymusić na Androidzie ukrycie wirtualnej klawiatury za pomocą InputMethodManager , wywołując hideSoftInputFromWindow, przechodzenie w token okna zawierającego fokusowany widok.

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

Wymusi to ukrycie klawiatury we wszystkich sytuacjach. W niektórych przypadkach będziesz chciał podać InputMethodManager.HIDE_IMPLICIT_ONLY jako drugi parametr, aby upewnić się, że ukrywasz klawiaturę tylko wtedy, gdy użytkownik nie wymusił jej wyświetlenia(przytrzymując menu).

Uwaga: Jeśli chcesz to w Kotlinie, użyj: context?.getSystemService(Context.INPUT_METHOD_SERVICE) as InputMethodManager

Przydatne również do ukrywania soft-keyboardu jest:

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

To może być używane do wyłączania miękkiej klawiatury, dopóki użytkownik nie dotknie widoku editText.

Mam jeszcze jedno rozwiązanie do ukrycia klawiatury:

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

Tutaj mijamy HIDE_IMPLICIT_ONLY na pozycji showFlag i 0 na pozycji hiddenFlag. Będzie mocno zamknąć miękką klawiaturę.

Rozwiązanie Meiera też działa. W moim przypadku najwyższym poziomem mojej aplikacji jest tabHost i chcę ukryć słowo kluczowe podczas przełączania kart-dostaję token okna z widoku tabHost.

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

Proszę wypróbować poniższy kod w onCreate()

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

Update: Nie wiem dlaczego to rozwiązanie już nie działa ( właśnie testowałem na Androidzie 23). Zamiast tego należy użyć roztworu Saurabh Pareek. Tutaj jest:

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

Stara ODPOWIEDŹ:

//Show soft-keyboard:
getWindow().setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_STATE_ALWAYS_VISIBLE);
//hide keyboard :
 getWindow().setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_STATE_ALWAYS_HIDDEN);

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

Jeśli wszystkie inne odpowiedzi nie działają dla ciebie tak, jak byś chciał, istnieje inny sposób ręcznego sterowania klawiaturą.

Utwórz funkcję, która będzie zarządzać niektórymi właściwościami EditText:

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

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

Następnie upewnij się, że onFocus z EditText otwierasz/zamykasz klawiaturę:

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

Teraz, gdy chcesz ręcznie otworzyć klawiaturę, zadzwoń:

setEditTextFocus(true);

I na zakończenie rozmowy:

setEditTextFocus(false);

Saurabh Pareek ma najlepszą jak dotąd odpowiedź.

Równie dobrze można użyć poprawnych FLAG.

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

Przykład rzeczywistego użycia

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

Z tak poszukiwanych, tutaj znalazłem odpowiedź, która działa dla mnie

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

Krótka odpowiedź

In your OnClick listener call the onEditorAction of the EditText with IME_ACTION_DONE

button.setOnClickListener(new OnClickListener() {

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

The drill-down

Uważam, że ta metoda jest lepsza, prostsza i bardziej dostosowana do wzorca projektowego Androida. W prostym przykładzie powyżej (i zazwyczaj w większości typowych przypadków) będziesz miał EditText, który miał/miał fokus i to również zwykle był ten, który wywołał klawiaturę w pierwszej kolejności (na pewno jest w stanie wywołać ją w wielu typowych scenariuszach). W ten sam sposób, to powinien być ten, który zwolni klawiaturę, zwykle można to zrobić za pomocą ImeAction. Po prostu zobacz, jak zachowuje się EditText z android:imeOptions="actionDone", chcesz osiągnąć to samo zachowanie za pomocą tych samych środków.

Sprawdź to odpowiedź pokrewna

To powinno zadziałać:

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

Używam niestandardowej klawiatury, aby wprowadzić numer szesnastkowy, więc nie mogę mieć klawiatury IMM...

W v3.2.4_r1setSoftInputShownOnFocus(boolean show) został dodany do sterowania pogodą lub nie, aby wyświetlać klawiaturę, gdy TextView zostanie ustawiony ostrość, ale nadal jest ukryty, więc należy użyć odbicia:

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

Dla starszych wersji uzyskałem bardzo dobre wyniki (ale dalekie od ideału) z OnGlobalLayoutListener, dodanym przy pomocy ViewTreeObserver z widoku głównego, a następnie sprawdzając, czy klawiatura jest pokazana jak to:

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

To ostatnie rozwiązanie może wyświetlać klawiaturę przez ułamek sekundy i mieszać z uchwytami wyboru.

Gdy na klawiaturze wchodzi Pełny ekran, onGlobalLayout nie jest wywoływany. Aby tego uniknąć, użyj TextView#setImeOptions (int) lub w deklaracji XML TextView:

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

Update: właśnie znalazłem, czego okna dialogowe używają, aby nigdy nie pokazywać klawiatury i działa we wszystkich wersjach:

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

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

Spędziłem ponad dwa dni pracując nad wszystkimi rozwiązaniami zamieszczonymi w wątku i znalazłem ich brak w taki czy inny sposób. Moim dokładnym wymogiem jest posiadanie przycisku, który ze 100% niezawodnością pokaże lub ukryje klawiaturę ekranową. Gdy klawiatura jest w stanie ukrytym nie powinna pojawić się ponownie, Bez względu na to, jakie pola wejściowe kliknie użytkownik. Gdy jest w widocznym stanie, klawiatura nie powinna znikać bez względu na to, jakie przyciski kliknie użytkownik. To musi pracuj na Androidzie 2.2+ aż do najnowszych urządzeń.

Możesz zobaczyć działającą implementację tego w mojej aplikacji clean RPN .

Po przetestowaniu wielu sugerowanych odpowiedzi na wielu różnych telefonach (w tym na urządzeniach froyo i Gingerbread) okazało się, że aplikacje na Androida mogą niezawodnie:

1. tymczasowo ukryj klawiaturę. Pojawi się ponownie, gdy użytkownik skupia nowe pole tekstowe.
2. Pokaż klawiaturę, gdy zaczyna się czynność oraz Ustaw flagę na aktywności wskazującą, że powinny zawsze bądź widoczny. Flaga ta może być ustawiona tylko wtedy, gdy aktywność jest inicjuję.
3. zaznacz działanie, aby nigdy nie pokazywać ani nie zezwalać na korzystanie z klawiatura. Flaga ta może być ustawiona tylko wtedy, gdy aktywność jest inicjuję.

Dla mnie chwilowe ukrycie klawiatury to za mało. Na niektórych urządzeniach pojawi się ponownie, gdy tylko nowe pole tekstowe zostanie skupione. Ponieważ moja aplikacja używa wielu pól tekstowych na jednej stronie, skupiając nowy pole tekstowe spowoduje ponowne pojawienie się ukrytej klawiatury.

Niestety pozycja 2 i 3 na liście działa tylko wtedy, gdy aktywność jest uruchamiana. Gdy aktywność stanie się widoczna, nie można trwale ukryć ani pokazać klawiatury. Sztuczka polega na ponownym uruchomieniu aktywności, gdy użytkownik naciśnie przycisk przełączania klawiatury. W mojej aplikacji, gdy użytkownik naciśnie przycisk przełączania klawiatury, uruchamia się następujący kod:

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

Powoduje to bieżącą aktywność aby jego stan został zapisany w pakiecie, a następnie aktywność jest uruchamiana, przechodząc przez logikę, która wskazuje, czy klawiatura powinna być pokazana lub ukryta.

Wewnątrz metody onCreate uruchamiany jest następujący kod:

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

Jeśli miękka klawiatura ma być pokazana, wtedy Menedżer InputMethodManager ma pokazywać klawiaturę, a okno jest poinstruowane, aby miękkie wejście było zawsze widoczne. Jeśli miękka klawiatura powinna być ukryta, to WindowManager.LayoutParams.Ustawiono FLAG_ALT_FOCUSABLE_IM.

To podejście działa niezawodnie na wszystkich urządzeniach, na których testowałem - od 4-letniego telefonu HTC z Androidem 2.2 do Nexusa 7 z systemem 4.2.2. Jedyną wadą tego podejścia jest to, że trzeba być ostrożnym z obsługą przycisku Wstecz. Ponieważ moja aplikacja zasadniczo ma tylko jeden ekran (jego Kalkulator) mogę zastąpić onbackpressed() i wrócić do ekranu głównego urządzenia.

Alternatywnie do To rozwiązanie , Jeśli chcesz zamknąć miękką klawiaturę z dowolnego miejsca bez odniesienia do pola (EditText), które zostało użyte do otwarcia klawiatury, ale nadal chcesz to zrobić, jeśli pole jest skupione, możesz użyć tego (z aktywności):

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

Dzięki this SO answer , uzyskałem następujące, które w moim przypadku działają ładnie podczas przewijania fragmentów Viewpagera...

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

Powyższe odpowiedzi działają dla różnych scenariuszy, ale Jeśli chcesz ukryć klawiaturę wewnątrz widoku i walczyć o odpowiedni kontekst, spróbuj tego:

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

I aby uzyskać kontekst pobierz go z konstruktora:)

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

Jeśli chcesz zamknąć miękką klawiaturę podczas testu urządzenia lub funkcji, możesz to zrobić, klikając przycisk "Wstecz" z testu:

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

Umieszczam "przycisk Wstecz" w cudzysłowach, ponieważ powyższe nie uruchamia onBackPressed() dla danej aktywności. Po prostu zamyka klawiaturę.

Upewnij się, że zatrzymasz się na chwilę przed przejściem, ponieważ zamknięcie przycisku back zajmuje trochę czasu, więc kolejne kliknięcia do widoków itp., zostanie zarejestrowany dopiero po krótkiej przerwie (1 drugi jest wystarczająco długi ime).

W tym celu należy wykonać następujące czynności:]}

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

To działało dla mnie na wszystkie dziwne zachowanie klawiatury

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

Dodaj do swojej aktywności android:windowSoftInputMode="stateHidden" w pliku Manifest. Przykład:

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

Użyj tego

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

W moim przypadku używałem widoku wyszukiwania w pasku działań. Po wykonaniu przez użytkownika wyszukiwania, klawiatura otworzy się ponownie.

Użycie Menedżera InputMethodManager nie zamykało klawiatury. Musiałem clearFocus i ustawić focusable w widoku wyszukiwania na false:

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

Prawie próbowałem wszystkich tych odpowiedzi, miałem kilka przypadkowych problemów, zwłaszcza z Samsungiem galaxy S5.

To co kończę to wymuszanie pokazu i ukrycia, i to działa idealnie:

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

W niektórych przypadkach ta metoda może działać z wyjątkiem wszystkich innych. To ratuje mój dzień:)

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

Prosta i łatwa w użyciu metoda, wystarczy wywołać hideKeyboardFrom(your activity.to); aby ukryć klawiaturę

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

Po prostu użyj tego zoptymalizowanego kodu w swojej aktywności:

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

Mam przypadek, w którym moje EditText może znajdować się również w AlertDialog, więc klawiatura powinna być zamknięta po zwolnieniu. Poniższy kod wydaje się działać wszędzie:

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