Zamknij / ukryj miękką klawiaturę Androida

Mam A EditTexti A Buttonw moim układzie.

Po wpisaniu w polu edycji i kliknięciu przycisku Buttonchcę ukryć wirtualną klawiaturę. Zakładam, że jest to prosty fragment kodu, ale gdzie mogę znaleźć przykład?

Podczas dotykania poza klawiaturą.

Aby pomóc wyjaśnić to szaleństwo, chciałbym zacząć od przeprosin w imieniu wszystkich użytkowników Androida za wręcz absurdalne traktowanie przez Google miękkiej klawiatury. Powodem jest tak wiele odpowiedzi, z których każda jest inna, na to samo proste pytanie, ponieważ ten interfejs API, podobnie jak wiele innych w Androidzie, jest strasznie zaprojektowany. Nie potrafię wymyślić żadnego grzecznego sposobu na wyrażenie tego.

Chcę ukryć klawiaturę. Spodziewam się, aby zapewnić Android z następującym stwierdzeniem: Keyboard.hide(). Koniec. Dziękuję Ci bardzo. Ale Android ma problem. Musisz użyć, InputMethodManageraby ukryć klawiaturę. OK, w porządku, to jest interfejs API Androida do klawiatury. ALE! Musisz mieć Context, aby uzyskać dostęp do IMM. Teraz mamy problem. Mogę chcieć ukryć klawiaturę przed klasą statyczną lub użytkową, która nie jest potrzebna ani potrzebna Context. lub I DALEKO gorzej, IMM wymaga określenia, coView (lub jeszcze gorzej, co Window) chcesz ukryć przed klawiaturą.

Właśnie dlatego ukrywanie klawiatury jest tak trudne. Drogi Google: Kiedy szukam przepisu na ciasto, nie maRecipeProvider na Ziemi która nie odmówiłaby podania mi przepisu, chyba że najpierw odpowiem KTO, przez co ciasto zostanie zjedzone ORAZ gdzie zostanie zjedzone !!

Ta smutna historia kończy się brzydką prawdą: aby ukryć klawiaturę Androida, musisz podać 2 formy identyfikacji: a Contexti a Viewlub aWindow .

Stworzyłem statyczną metodę narzędzia, która może wykonać zadanie BARDZO solidnie, pod warunkiem, że wywołasz go z 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);
}

Należy pamiętać, że ta metoda narzędzia działa TYLKO po wywołaniu z Activity! Powyższe wywołania metody getCurrentFocuscelu w Activitycelu pobrania odpowiedniego tokena okna.

Ale załóżmy, że chcesz ukryć klawiaturę przed EditTexthostowanym w DialogFragment? Nie możesz użyć powyższej metody do tego:

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

To nie zadziała, ponieważ przekażesz referencję do Fragmenthosta Activity, który nie będzie miał żadnej skoncentrowanej kontroli, gdy Fragmentzostanie wyświetlony! Łał! Aby ukryć klawiaturę przed fragmentami, uciekam się do niższego poziomu, bardziej powszechnego i brzydszego:

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

Poniżej znajduje się kilka dodatkowych informacji zebranych po dłuższym marnowaniu czasu na pogoń za tym rozwiązaniem:

Informacje o windowSoftInputMode

Jest jeszcze jeden punkt sporny, o którym należy pamiętać. Domyślnie Android automatycznie przypisze początkowy fokus do pierwszej EditTextlub sterowalnej fokusu w twoim Activity. Wynika z tego naturalnie, że InputMethod (zazwyczaj miękka klawiatura) zareaguje na zdarzenie skupienia, pokazując się. windowSoftInputModeAtrybut AndroidManifest.xml, gdy ustawiony stateAlwaysHidden, instruuje klawiaturę do ignorowania tego automatycznie przypisany początkowej ostrości.

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

Niemal niewiarygodne wydaje się, że nie robi nic, aby uniemożliwić otwarcie klawiatury po dotknięciu kontrolki (chyba że focusable="false"i / lub focusableInTouchMode="false"są przypisane do kontrolki). Najwyraźniej ustawienie windowSoftInputMode dotyczy tylko zdarzeń automatycznego fokusa, a nie zdarzeń fokusa wyzwalanych przez zdarzenia dotykowe.

Dlatego stateAlwaysHiddenjest BARDZO źle nazwany. Być może należy to nazwać ignoreInitialFocuszamiast tego.

Mam nadzieję że to pomoże.

AKTUALIZACJA: Więcej sposobów na uzyskanie tokena okna

Jeśli nie ma skupionego widoku (np. Może się zdarzyć, jeśli właśnie zmieniłeś fragmenty), istnieją inne widoki, które dostarczą przydatnego tokena okna.

Są to alternatywy dla powyższego kodu. if (view == null) view = new View(activity); Nie odnoszą się one wprost do Twojej aktywności.

Wewnątrz klasy fragmentu:

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

Biorąc pod uwagę fragment fragmentjako parametr:

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

Począwszy od treści treści:

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

AKTUALIZACJA 2: Wyczyść fokus, aby uniknąć ponownego wyświetlania klawiatury, jeśli otworzysz aplikację z tła

Dodaj ten wiersz na końcu metody:

view.clearFocus();

Możesz zmusić Androida do ukrycia wirtualnej klawiatury za pomocą InputMethodManager , wywołując hideSoftInputFromWindow, przekazując token okna zawierającego skupiony 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ł przekazać InputMethodManager.HIDE_IMPLICIT_ONLYjako drugi parametr, aby mieć pewność, że ukryjesz klawiaturę tylko wtedy, gdy użytkownik nie wymusił jej jawnego wyświetlenia (przytrzymując menu).

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

Składnia Kotlina

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

Przydatne również do ukrywania klawiatury programowej jest:

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

Można tego użyć, aby wyłączyć klawiaturę ekranową, dopóki użytkownik nie dotknie widoku edycji tekstu.

Mam jeszcze jedno rozwiązanie, aby ukryć klawiaturę:

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

Tutaj przechodzą HIDE_IMPLICIT_ONLYw pozycji showFlagi 0w pozycji hiddenFlag. Mocno zamknie miękką klawiaturę.

Rozwiązanie Meiera również działa dla mnie. W moim przypadku najwyższym poziomem mojej aplikacji jest tabHost i chcę ukryć słowo kluczowe podczas przełączania kart - otrzymuję 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);
    }
}

Spróbuj tego poniżej kodu w onCreate()

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

Aktualizacja: Nie wiem, dlaczego to rozwiązanie już nie działa (właśnie testowałem na Androidzie 23). Zamiast tego skorzystaj z rozwiązania Saurabh Pareek . Oto on:

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) {
    InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
    imm.hideSoftInputFromWindow(input.getWindowToken(), 0);    
}

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

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

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

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

Następnie upewnij się, że onFocus EditTextciebie otwiera / zamyka 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 do zakończenia połączenia:

setEditTextFocus(false);

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

Może jednak również 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 ... */
}

po tak poszukiwaniach 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ź

W swoim OnClicksłuchaczu zadzwoń onEditorActionza EditTextpomocąIME_ACTION_DONE

button.setOnClickListener(new OnClickListener() {

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

Drążenie w dół

Wydaje mi się, że ta metoda jest lepsza, prostsza i bardziej zgodna ze wzorcem projektowym Androida. W powyższym prostym przykładzie (i zwykle w większości typowych przypadków) będziesz mieć, EditTextktóry był / miał fokus, a także zwykle to on w pierwszej kolejności wywoływał klawiaturę (zdecydowanie jest w stanie wywołać ją w wielu przypadkach typowe scenariusze). W tej samej drodze, to powinno być jedno, aby zwolnić klawiaturę, zazwyczaj, które mogą być wykonywane przez ImeAction. Zobacz, jak to EditTextdziałaandroid:imeOptions="actionDone" zachowuje się „ , i chcesz osiągnąć to samo zachowanie w ten sam sposób.

Sprawdź tę powiązaną odpowiedź

To powinno dział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 do wprowadzenia numeru szesnastkowego, więc nie mogę wyświetlić klawiatury IMM ...

W wersji 3.2.4_r1 setSoftInputShownOnFocus(boolean show)dodano, aby kontrolować pogodę lub nie wyświetlać klawiatury, gdy obiekt TextView zostanie ustawiony, 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
    }
}

W przypadku starszych wersji uzyskałem bardzo dobre wyniki (ale dalekie od ideału) za pomocą a OnGlobalLayoutListener, dodanego za pomocą a ViewTreeObserverz mojego widoku głównego, a następnie sprawdzenia, czy klawiatura jest wyświetlana w następujący sposób:

@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 pokazywać klawiaturę na ułamek sekundy i zadziera z uchwytami wyboru.

Kiedy na klawiaturze pojawia się 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"

Aktualizacja: Właśnie znalazłem okna dialogowe, które nigdy nie pokazują klawiatury i działają 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 opublikowanymi w wątku i stwierdziłem, że brakuje im w ten czy inny sposób. Moim dokładnym wymaganiem jest mieć przycisk, który ze 100% niezawodnością pokaże lub ukryje klawiaturę ekranową. Gdy klawiatura jest w stanie ukrytym, nie powinna się ponownie pojawiać, bez względu na pola wejściowe, które kliknie użytkownik. Gdy jest w stanie widocznym, klawiatura nie powinna zniknąć bez względu na to, jakie przyciski użytkownik kliknie. To musi działać na Androidzie 2.2+ aż do najnowszych urządzeń.

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

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

1. Tymczasowo ukryj klawiaturę. Pojawi się ponownie, gdy użytkownik ustawi nowe pole tekstowe.
2. Pokaż klawiaturę po rozpoczęciu działania i ustaw flagę działania wskazującą, że klawiatura powinna być zawsze widoczna. Tę flagę można ustawić tylko podczas inicjowania działania.
3. Oznacz aktywność, aby nigdy nie pokazywać ani nie zezwalać na korzystanie z klawiatury. Tę flagę można ustawić tylko podczas inicjowania działania.

Dla mnie chwilowe ukrywanie klawiatury nie wystarczy. Na niektórych urządzeniach pojawi się ponownie, gdy tylko nowe pole tekstowe zostanie zogniskowane. Ponieważ moja aplikacja korzysta z wielu pól tekstowych na jednej stronie, skupienie nowego pola tekstowego spowoduje ponowne pojawienie się ukrytej klawiatury.

Niestety pozycje 2 i 3 na liście działają tylko wtedy, gdy działanie jest rozpoczęte. Gdy aktywność stanie się widoczna, nie można trwale ukryć ani pokazać klawiatury. Sztuką jest zrestartowanie 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, że bieżąca aktywność zostaje zapisana w pakiecie, a następnie aktywność jest uruchamiana, przechodząc przez wartość logiczną, która wskazuje, czy klawiatura powinna być pokazana, czy 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 powinna zostać wyświetlona klawiatura programowa, wówczas InputMethodManager ma wyświetlać klawiaturę, a okno jest instruowane, aby program był zawsze widoczny. Jeśli miękka klawiatura powinna być ukryta, wówczas ustawiany jest WindowManager.LayoutParams.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 4.2.2. Jedyną wadą tego podejścia jest ostrożność przy posługiwaniu się przyciskiem Wstecz. Ponieważ moja aplikacja zasadniczo ma tylko jeden ekran (jest to kalkulator), mogę zastąpić onBackPressed () i wrócić do ekranu głównego urządzeń.

Alternatywnie do tego wszechstronnego rozwiązania , jeśli chcesz zamknąć klawiaturę programową z dowolnego miejsca bez odniesienia do pola (EditText), które było użyte do otwarcia klawiatury, ale nadal chciałbyś to zrobić, jeśli pole było skupione, możesz użyć to (z działania):

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

Dzięki tej odpowiedzi SO wyprowadziłem następujące, które w moim przypadku działa ładnie podczas przewijania fragmentów 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);
    }
}

Powyższe odpowiedzi działają w różnych scenariuszach, ale jeśli chcesz ukryć klawiaturę w widoku i próbujesz uzyskać właściwy 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 pobierz 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ąć klawiaturę programową podczas testu jednostkowego lub funkcjonalnego, możesz to zrobić, klikając przycisk „Wstecz” w teście:

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

W cudzysłowie wstawiam „przycisk Wstecz”, ponieważ powyższe nie uruchamia onBackPressed() danego działania. Po prostu zamyka klawiaturę.

Pamiętaj, aby zatrzymać się na chwilę przed przejściem dalej, ponieważ zamknięcie przycisku wstecz zajmuje trochę czasu, więc kolejne kliknięcia w Widoki itp. Nie zostaną zarejestrowane, dopóki nie nastąpi krótka pauza (1 sekunda jest wystarczająco długa ).

Oto jak to robisz w Mono na Androida (AKA MonoDroid)

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

To zadziałało w przypadku wszystkich dziwnych zachowań 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 manifestu. Przykład:

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

Prosta i łatwa w użyciu metoda, wystarczy wywołać hideKeyboardFrom (YourActivity.this); 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 działalności:

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

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

po tym wywołaniu onTouchListener:

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

Użyj tego

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

W moim przypadku korzystałem z SearchView na pasku akcji. Po przeprowadzeniu wyszukiwania przez użytkownika klawiatura ponownie się otworzy.

Użycie InputMethodManager nie zamknęło klawiatury. Musiałem wyczyścić Focus i ustawić fokus widoku wyszukiwania na false:

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

Mam skrzynkę, w której mój EditTextmoże być umieszczony również w AlertDialog, więc klawiatura powinna być zamknięta po zwolnieniu. Następujący 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 );
}

Prawie wypróbowałem wszystkie te odpowiedzi, miałem kilka przypadkowych problemów, szczególnie z Samsung Galaxy S5.

Skończyło się na wymuszeniu pokazu i ukrycia, i 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);
}