Chiudere / hide la tastiera Android Soft

Ho un EditText e un Button nel mio layout.

Dopo aver scritto nel field di modifica e facendo clic sul Button , voglio hide la tastiera virtuale. Suppongo che esista un codice semplice, uno o due, per farlo accadere.

  • Errore: Imansible risolvere il target 'android-2'
  • Android Test Module (Gradle Plugin 1.3) non funziona: "classi di debug non trovate"
  • Flusso di lavoro MDM in Android
  • Vista della Galleria Android
  • Android ffmpeg: crea video da sequnce di immagini usando jni
  • Android Studio - IBus prima di 1.5.11 può causare problemi di input. Vedi IDEA-78860 per dettagli
  • Dove posso trovare un esempio?

  • come implementare un listener a lungo click in una list
  • New Intent () inizia nuova istanza con Android: launchMode = "singleTop"
  • Come compilare APK dalla row di command?
  • come impostare marginBottom in listview di android o linearlayout in modo dinamico?
  • Android HTML.fromHTML () con le immagini?
  • Come utilizzare lo scanner di impronte digitali per autenticare gli utenti
  • 30 Solutions collect form web for “Chiudere / hide la tastiera Android Soft”

    È ansible forzare Android per hide la tastiera virtuale utilizzando InputMethodManager , chiamando hideSoftInputFromWindow , passando nel token della window che contiene la visualizzazione mirata.

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

    Ciò obbligherà la tastiera a essere nascosta in tutte le situazioni. In alcuni casi si desidera passare in InputMethodManager.HIDE_IMPLICIT_ONLY come il secondo parametro per assicurarsi di hide la tastiera solo quando l'utente non lo ha esplicitamente InputMethodManager.HIDE_IMPLICIT_ONLY a far apparire (tenendo premuto il menu).

    Per contribuire a chiarire questa follia, vorrei iniziare a chiedere scusa a nome di tutti gli utenti di Android per il trattamento ridicole di Google della tastiera soft. Il motivo per cui ci sono tante risposte, ognuna diversa, per la stessa semplice domanda è perché questa API, come molti altri in Android, è orribilmente progettata. Non posso pensare a nessun modo educato di affermarlo.

    Voglio hide la tastiera. Mi aspetto di fornire Android con la seguente dichiarazione: Keyboard.hide() . Fine. Grazie mille. Ma Android ha un problema. È necessario utilizzare InputMethodManager per hide la tastiera. OK, va bene, questa è l'API di Android alla tastiera. MA! È necessario disporre di un Context per get l'accesso all'IMM. Ora abbiamo un problema. Vorrei hide la tastiera da una class statica o di utilità che non utilizza né necessita di alcun Context . o ESSO Peggio ancora, l'IMM richiede che specificate quale View (o peggio ancora, quale Window ) desideri hide la tastiera FROM.

    Questo è ciò che rende nascosto la tastiera così impegnativa. Caro Google: quando sto cercando la ricetta per una torta, non c'è RecipeProvider in Terra che rifiuterebbe di fornirmi la ricetta a less che non mi rispondii prima CHE la torta verrà mangiata da AND where sarà mangiata !!

    Questa triste storia finisce con la brutta verità: per hide la tastiera Android, sarà necessario fornire due forms di identificazione: un Context e una View o una Window .

    Ho creato un metodo di utilità statica che può rendere il lavoro MOLTO solidamente, a patto che lo chiami da un'attività.

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

    Tieni presente che questo metodo di utilità funziona SOLO quando viene richiamato da un'attività! Il metodo sopra richiamato invita getCurrentFocus dell'attività target per recuperare il proprio token di window.

    Ma supponi che vuoi hide la tastiera da un EditText ospitato in un DialogFragment ? Non è ansible utilizzare il metodo sopra per quello:

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

    Questo non funziona perché passerai un riferimento all'attività host del Fragment , che non avrà alcun controllo mirato mentre viene visualizzato il Fragment ! Wow! Quindi, per hide la tastiera da frammenti, ricorso al livello più basso, più comune e più brutto:

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

    Di seguito sono riportte alcune informazioni aggiuntive raccolte da più tempo sprecati che inseguono questa soluzione:

    Informazioni su windowSoftInputMode

    C'è ancora un altro punto di contesa per essere consapevoli. Per impostazione predefinita, Android assegnerà automaticamente la messa a fuoco iniziale al primo controllo EditText o focusable nell'attività. Naturalmente segue che l'InputMethod (tipicamente la tastiera soft) risponderà all'evento di messa a fuoco mostrando se stesso. L'attributo windowSoftInputMode in AndroidManifest.xml , quando impostato su stateAlwaysHidden , indica alla tastiera di ignorare questo focus iniziale assegnato automaticamente.

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

    Quasi incredibilmente, sembra non fare nulla per impedire che la tastiera si apra quando si tocca il controllo (a less che non si attribuisca focusable="false" e / o focusableInTouchMode="false" al controllo). A quanto pare, l'impostazione windowSoftInputMode si applica solo agli events di messa a fuoco automatica, per non concentrare gli events provocati da events di contatto.

    Pertanto, stateAlwaysHidden è MOLTO male in realtà denominato. Dovrebbe essere chiamato invece ignoreInitialFocus .

    Spero che questo ti aiuti.


    UPDATE: Altri modi per get un token di window

    Se non esiste una vista mirata (ad esempio può verificarsi se hai appena modificato i frammenti), ci sono altre viste che forniranno un token di window utile.

    Queste sono alternative al codice precedente if (view == null) view = new View(activity); Questi non si riferiscono esplicitamente alla tua attività.

    All'interno di una class di frammentazione:

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

    Dato un frammento di fragment come parametro:

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

    Partendo dal tuo corpo del contenuto:

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

    UPDATE 2: Clear focus per non visualizzare nuovamente la tastiera se apri l'applicazione dal fondo

    Aggiungere questa row alla fine del metodo:

    view.clearFocus();

    Utile per hide la tastiera morbida è:

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

    Questo può essere utilizzato per sopprimere la tastiera soft fino a quando l'utente effettivamente tocca la visualizzazione editText.

    Ho una sola soluzione per hide la tastiera:

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

    Qui passare HIDE_IMPLICIT_ONLY alla posizione di showFlag e 0 alla posizione di hiddenFlag . Chiuderà con forza la tastiera soft.

    La soluzione di Meier funziona anche per me. Nel mio caso il livello superiore della mia applicazione è un tabHost e voglio hide la parola chiave quando commuta le tabs – ottengo il token della window dalla tabHost View.

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

    Provi questo codice sotto in oncreate ()

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

    Aggiornamento: Non so perché questa soluzione non funziona più (ho appena testato su Android 23). Utilizza invece la soluzione di Saurabh Pareek . Ecco qui:

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

    Vecchia risposta:

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

    Se tutte le altre risposte qui non funzionano per te come volete, c'è un altro modo per controllare manualmente la tastiera.

    Crea una function con quella che gestirà alcune delle properties; di EditText :

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

    Quindi, assicurati che onFocus del EditText apri / chiudi la tastiera:

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

    Ora, each volta che si desidera aprire la tastiera manualmente call:

     setEditTextFocus(true); 

    E per chiudere la chiamata:

     setEditTextFocus(false); 

    Saurabh Pareek ha finora la risposta migliore.

    Può anche utilizzare le bandiere corrette, però.

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

    Esempio di utilizzo reale

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

    da quella ricerca, qui ho trovato una risposta che funziona per me

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

    La breve risposta

    Nella tua chiamata di OnClick chiama l' onEditorAction del text EditText con IME_ACTION_DONE

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

    Il drill-down

    Ritengo che questo metodo sia migliore, più semplice e più allineato con il model di progettazione di Android. Nel semplice esempio sopra (e di solito nella maggior parte dei casi comuni) avrai un EditText che ha / ha avuto fuoco e anche di solito è stato quello di invocare la tastiera in primo luogo (è sicuramente in grado di invocarlo in molti scenari comuni). Allo stesso modo, dovrebbe essere quello di rilasciare la tastiera, di solito che può essere fatta da ImeAction . Basta vedere come un EditText con android:imeOptions="actionDone" si comport, si vuole get lo stesso comportmento con gli stessi mezzi.


    Controlla questa risposta correlata

    Questo dovrebbe funzionare:

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

    Sto usando una tastiera personalizzata per immettere un numero Hex in modo che non posso visualizzare la tastiera IMM …

    In v3.2.4_r1 setSoftInputShownOnFocus(boolean show) stato aggiunto per controllare il tempo o non visualizzare la tastiera quando un TextView ottiene la messa a fuoco, ma la sua ancora nascosta in modo da riflessione deve essere utilizzata:

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

    Per le versioni precedenti, ho ottenuto ottimi risultati (ma non sono perfetti) con un OnGlobalLayoutListener , aggiunto con l'aiuto di un ViewTreeObserver dalla mia vista principale e poi controllando se la tastiera è mostrata come questa:

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

    Quest'ultima soluzione può mostrare la tastiera per un secondo e secondi con le maniglie di selezione.

    Quando la tastiera entra a schermo integer, non viene chiamato GloballyLayout. Per evitare questo, utilizzare TextView # setImeOptions (int) o nella dichiarazione XML di TextView:

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

    Aggiornamento: solo che le windows di dialogo utilizzano per non visualizzare mai la tastiera e funziona in tutte le versioni:

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

    In alternativa a questa soluzione , se voleste chiudere la tastiera soft da qualsiasi punto senza avere un riferimento al field (EditText) utilizzato per aprire la tastiera, ma voleva ancora farlo se il field è stato focalizzato, è ansible utilizzare questo (da un'attività):

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

    Ho passato più di due giorni a lavorare in tutte le soluzioni pubblicate nel thread e le ho trovate mancanti in un modo o nell'altro. Il mio esatto requisito è quello di avere un button che con 100% affidabilità mostrare o hide la tastiera sullo schermo. Quando la tastiera è nel suo stato nascosto, non dovrebbe apparire nuovamente, a prescindere dai campi di input che l'utente fa clic. Quando è nel suo stato visibile, la tastiera non deve sparire, a prescindere dai pulsanti che l'utente fa clic. Questo deve funzionare su Android 2.2+ fino all'ultimo dispositivo.

    Puoi vedere un'implementazione funzionante di questo nel mio RPN pulito app.

    Dopo aver testato molte delle risposte suggerite su un numero di telefoni diversi (inclusi i dispositivi froyo e panpepato ), è emerso che le applicazioni Android possono affidarsi in modo affidabile:

    1. Nascondere temporaneamente la tastiera. Riapparirà nuovamente quando un utente mette a fuoco un nuovo field di text.
    2. Mostra la tastiera quando inizia un'attività e imposta un flag sull'attività che indica che la tastiera deve sempre essere visibile. Questa bandiera può essere impostata solo quando un'attività viene inizializzata.
    3. Segna un'attività per non mostrare mai né consentire l'utilizzo della tastiera. Questa bandiera può essere impostata solo quando un'attività viene inizializzata.

    Per me, hide temporaneamente la tastiera non basta. Su alcuni dispositivi, verrà visualizzato nuovamente non appena viene messo a fuoco un nuovo field di text. Poiché la mia applicazione utilizza più campi di text in una pagina, mettere a fuoco un nuovo field di text provoca la ripetizione della tastiera nascosta.

    Purtroppo l'elemento 2 e 3 nell'elenco funziona solo affidabilità quando viene avviata un'attività. Una volta che l'attività è diventata visibile, non è ansible hide o mostrare la tastiera in modo permanente. Il trucco è quello di riavviare la tua attività quando l'utente preme il button di triggerszione della tastiera. Nella mia applicazione quando l'utente preme sul button della tastiera, il codice seguente viene eseguito:

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

    In questo modo l'attività corrente ha il suo stato salvato in un Bundle e l'attività viene avviata, passando attraverso un boolean che indica se la tastiera dovrebbe essere mostrata o nascosta.

    All'interno del metodo onCreate viene eseguito il seguente codice:

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

    If the soft keyboard should be shown, then the InputMethodManager is told to show the keyboard and the window is instructed to make the soft input always visible. If the soft keyboard should be hidden then the WindowManager.LayoutParams.FLAG_ALT_FOCUSABLE_IM is set.

    This approach works reliably on all devices I have tested on – from a 4 year old HTC phone running android 2.2 up to a nexus 7 running 4.2.2. The only disadvantage with this approach is you need to be careful with handling the back button. As my app essentially only has one screen (its a calculator) I can override onBackPressed() and return to the devices home screen.

    Above answers work for different scenario's but If you want to hide the keyboard inside a view and struggling to get the right context try this:

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

    and to get the context fetch it from constructor:)

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

    Thanks to this SO answer , I derived the following which, in my case, works nicely when scrolling through the the fragments of a 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); } } 

    If you want to close the soft keyboard during a unit or functional test, you can do so by clicking the "back button" from your test:

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

    I put "back button" in quotes, since the above doesn't trigger the onBackPressed() for the Activity in question. It just closes the keyboard.

    Make sure to pause for a little while before moving on, since it takes a little while to close the back button, so subsequent clicks to Views, etc., won't be registered until after a short pause (1 second is long enough ime).

    Here's how you do it in Mono for Android (AKA MonoDroid)

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

    This worked for me for all the bizarre keyboard behavior

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

    Add to your activity android:windowSoftInputMode="stateHidden" in Manifest file. Esempio:

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

    For my case, I was using the a SearchView in the actionbar. After a user performs a search, the keyboard would pop open again.

    Using the InputMethodManager did not close the keyboard. I had to clearFocus and set the focusable of the search view to false:

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

    use this

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

    I have almost tried all of these answers, I had some random issues especially with the samsung galaxy s5.

    What I end up with is forcing the show and hide, and it works perfectly:

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

    Just use this optimized code in your activity:

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

    I have the case, where my EditText can be located also in an AlertDialog , so the keyboard should be closed on dismiss. The following code seems to be working anywhere:

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

    Simple and Easy to use method, just call hideKeyboardFrom(YourActivity.this); to hide keyboard

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

    You could also look into using setImeOption on the EditText.

    I just had a very simular situation where my layout contained an EditText and a search button. When I discovered I could just set the ime option to "actionSearch" on my editText, I realized I didn't even need a search button anymore. The soft keyboard (in this mode) has a search icon, which can be used to kick off the search (and the keyboard closes itself as you would expect).

    L'Android è un fan Android di Google, tutto su telefoni Android, Android Wear, Android Dev e applicazioni Android Games e così via.