Chiudi / nascondi la tastiera virtuale Android
Ho un EditText e un Button nel mio layout.
Dopo aver scritto nel campo modifica e cliccando sul Button, voglio nascondere la tastiera virtuale. Presumo che questo sia un semplice pezzo di codice, ma dove posso trovare un esempio di esso?
30 answers
Per contribuire a chiarire questa follia, vorrei iniziare scusandomi a nome di tutti gli utenti Android per il trattamento decisamente ridicolo di Google della tastiera virtuale. Il motivo per cui ci sono così tante risposte, ognuna diversa, per la stessa semplice domanda è perché questa API, come molte altre in Android, è orribilmente progettata. Non riesco a pensare a un modo educato per dichiararlo.
Voglio nascondere la tastiera. Mi aspetto di fornire ad Android la seguente istruzione: Keyboard.hide(). Fine. Grazie mille molto. Ma Android ha un problema. È necessario utilizzare InputMethodManager per nascondere la tastiera. OK, bene, questa è l'API di Android per la tastiera. MA! Si sono tenuti ad avere un Context al fine di ottenere l'accesso al IMM. Ora abbiamo un problema. Potrei voler nascondere la tastiera da una classe statica o di utilità che non ha alcun uso o necessità di Context. o E MOLTO peggio, l'IMM richiede di specificare cosa View (o peggio ancora, cosa Window) si desidera nascondere la tastiera DA.
Questo è ciò che rende nascondere la tastiera così impegnativo. Caro Google: Quando sto cercando la ricetta per una torta, non c'è RecipeProvider sulla Terra che si rifiuterebbe di fornirmi la ricetta a meno che non risponda prima a CHI sarà mangiata la torta E dove sarà mangiata!!
Questa triste storia termina con la brutta verità: per nascondere la tastiera Android, ti verrà richiesto di fornire 2 forme di identificazione: a Context e a View o a Window.
Ho creato un metodo di utilità statico che può fare il lavoro MOLTO solidamente, a condizione che si chiama da un 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);
}
Tieni presente che questo metodo di utilità funziona SOLO quando viene chiamato da un Activity! Il metodo precedente chiama getCurrentFocus della destinazione Activity per recuperare il token finestra corretto.
Ma supponiamo di voler nascondere la tastiera da un EditText ospitato in un DialogFragment? Non è possibile utilizzare il metodo sopra per questo:
hideKeyboard(getActivity()); //won't work
Questo non funzionerà perché passerai un riferimento all'host Fragment Activity, che non avrà alcun focus controllo mentre viene visualizzato Fragment! Wow! Quindi, per nascondere la tastiera dai frammenti, ricorro al livello inferiore, 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 riportate alcune informazioni aggiuntive raccolte da più tempo sprecato a inseguire questa soluzione:
Informazioni su windowSoftInputMode
C'è ancora un altro punto di contesa di cui essere consapevoli. Per impostazione predefinita, Android assegnerà automaticamente lo stato attivo iniziale al primo EditText o controllo attivabile nel Activity. Naturalmente segue che InputMethod (in genere la tastiera virtuale) risponderà all'evento di messa a fuoco mostrandosi. L'attributo windowSoftInputMode in AndroidManifest.xml, se impostato su stateAlwaysHidden, indica alla tastiera di ignorare questa messa a fuoco iniziale assegnata automaticamente.
<activity
android:name=".MyActivity"
android:windowSoftInputMode="stateAlwaysHidden"/>
Quasi incredibilmente, sembra non fare nulla per impedire l'apertura della tastiera quando si tocca il controllo (a meno che focusable="false" e/o focusableInTouchMode="false" non siano assegnati al controllo). Apparentemente, l'impostazione windowSoftInputMode si applica solo a automatic focus eventi, non per mettere a fuoco gli eventi attivati da eventi touch.
Pertanto, stateAlwaysHidden è molto mal chiamato davvero. Forse dovrebbe essere chiamato ignoreInitialFocus invece.
Spero che questo aiuti.
AGGIORNAMENTO: altri modi per ottenere un token window
Se non esiste una vista focalizzata (ad esempio può accadere se hai appena modificato i frammenti), ci sono altre viste che forniranno un utile token finestra.
Queste sono alternative per il codice precedente if (view == null) view = new View(activity); Non lo fanno fai riferimento esplicitamente alla tua attività.
All'interno di una classe di frammenti:
view = getView().getRootView().getWindowToken();
Dato un frammento fragment come parametro:
view = fragment.getView().getRootView().getWindowToken();
A partire dal corpo del contenuto:
view = findViewById(android.R.id.content).getRootView().getWindowToken();
AGGIORNAMENTO 2: Cancella il focus per evitare di mostrare nuovamente la tastiera se apri l'app dallo sfondo
Aggiungi questa riga alla fine del metodo:
view.clearFocus();
È possibile forzare Android a nascondere la tastiera virtuale utilizzando InputMethodManager, chiamando hideSoftInputFromWindow, passando il token della finestra contenente la tua vista focalizzata.
// 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ò costringerà la tastiera a essere nascosta in tutte le situazioni. In alcuni casi si desidera passare InputMethodManager.HIDE_IMPLICIT_ONLY come secondo parametro per assicurarsi di nascondere la tastiera solo quando l'utente non l'ha forzata esplicitamente a comparire (tenendo premuto menu).
Nota: Se si vuole fare questo in Kotlin, usa:
context?.getSystemService(Context.INPUT_METHOD_SERVICE) as InputMethodManager
Utile anche per nascondere la tastiera virtuale è:
getWindow().setSoftInputMode(
WindowManager.LayoutParams.SOFT_INPUT_STATE_ALWAYS_HIDDEN
);
Questo può essere usato per sopprimere la tastiera virtuale finché l'utente non tocca effettivamente la vista editText.
Ho un'altra soluzione per nascondere 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 virtuale.
La soluzione di Meier funziona anche per me. Nel mio caso il livello superiore della mia app è un tabHost e voglio nascondere la parola chiave quando si cambiano le schede: ottengo il token della finestra dalla vista tabHost.
tabHost.setOnTabChangedListener(new OnTabChangeListener() {
public void onTabChanged(String tabId) {
InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
imm.hideSoftInputFromWindow(tabHost.getApplicationWindowToken(), 0);
}
}
Prova questo codice qui sotto in onCreate()
EditText edtView=(EditText)findViewById(R.id.editTextConvertValue);
edtView.setInputType(0);
Aggiornamento: Non capisco perché questa soluzione non funzioni più ( ho appena provato su Android 23). Si prega di utilizzare la soluzione di Saurabh Pareek invece. Eccolo 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 vorresti, c'è un altro modo per controllare manualmente la tastiera.
Crea una funzione che gestirà alcune delle proprietà di EditText:
public void setEditTextFocus(boolean isFocused) {
searchEditText.setCursorVisible(isFocused);
searchEditText.setFocusable(isFocused);
searchEditText.setFocusableInTouchMode(isFocused);
if (isFocused) {
searchEditText.requestFocus();
}
}
Quindi, assicurarsi che onFocus del {[4] } si apre / chiude 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, ogni volta che si desidera aprire la tastiera manualmente chiamare:
setEditTextFocus(true);
E per la chiusura della chiamata:
setEditTextFocus(false);
Saurabh Pareek ha la migliore risposta finora.
Potrebbe anche usare i flag corretti, 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 così cercando, 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 risposta breve
Nel tuo OnClick listener chiama il onEditorAction del 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 modello di progettazione di Android.
Nel semplice esempio sopra (e di solito nella maggior parte dei casi comuni) avrai un EditText che ha/ha avuto il focus e di solito è stato anche 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 fatto da un ImeAction. Basta vedere come si comporta un EditText con android:imeOptions="actionDone", si desidera ottenere lo stesso comportamento 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 inserire un numero esadecimale, quindi non posso far apparire la tastiera IMM...
In v3.2.4_r1 setSoftInputShownOnFocus(boolean show) è stato aggiunto per controllare il tempo o meno per visualizzare la tastiera quando un TextView viene messo a fuoco, ma è ancora nascosto quindi la 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 tutt'altro che perfetti) con un OnGlobalLayoutListener, aggiunto con l'aiuto di un ViewTreeObserver dalla mia vista root e quindi controllando se la tastiera è mostrata come questo:
@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 potrebbe mostrare la tastiera per una frazione di secondo e rovinare le maniglie di selezione.
Quando nella tastiera entra a schermo intero, onGlobalLayout non viene chiamato. Per evitare ciò, utilizzare TextView # setImeOptions (int) o nella dichiarazione XML TextView:
android:imeOptions="actionNone|actionUnspecified|flagNoFullscreen|flagNoExtractUi"
Aggiornamento: Ho appena trovato quali finestre di dialogo usano per non mostrare 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);
}
}
Ho passato più di due giorni a lavorare su tutte le soluzioni pubblicate nel thread e le ho trovate carenti in un modo o nell'altro. Il mio requisito esatto è quello di avere un pulsante che con affidabilità al 100% mostri o nasconda la tastiera su schermo. Quando la tastiera è nel suo stato nascosto non dovrebbe riapparire, indipendentemente dai campi di input su cui l'utente fa clic. Quando è nel suo stato visibile la tastiera non dovrebbe scomparire indipendentemente dai pulsanti che l'utente fa clic. Questo deve lavorare su Android 2.2 + tutta la strada fino ai dispositivi più recenti.
Puoi vedere un'implementazione funzionante di questo nella mia app clean RPN.
Dopo aver testato molte delle risposte suggerite su un certo numero di telefoni diversi (tra cui dispositivi froyo e gingerbread) è diventato evidente che le app Android possono in modo affidabile:
- Nascondere temporaneamente la tastiera. Riapparirà di nuovo quando un utente mette a fuoco un nuovo campo di testo.
- Mostra la tastiera all'avvio di un'attività e impostare un flag sull'attività che indica che la tastiera dovrebbe sii sempre visibile. Questo flag può essere impostato solo quando un'attività inizializzazione.
- Contrassegna un'attività per non mostrare o consentire l'uso di tastiera. Questo flag può essere impostato solo quando un'attività inizializzazione.
Per me, nascondere temporaneamente la tastiera non è abbastanza. Su alcuni dispositivi riappare non appena viene focalizzato un nuovo campo di testo. Poiché la mia app utilizza più campi di testo su una pagina, concentrando una nuova campo di testo farà sì che la tastiera nascosta per pop back up di nuovo.
Sfortunatamente gli elementi 2 e 3 dell'elenco funzionano solo quando viene avviata un'attività. Una volta che l'attività è diventata visibile, non è possibile nascondere o mostrare la tastiera in modo permanente. Il trucco è quello di riavviare effettivamente l'attività quando l'utente preme il pulsante di commutazione della tastiera. Nella mia app quando l'utente preme il pulsante della tastiera, viene eseguito il seguente codice:
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);
}
}
Ciò causa l'attività corrente per avere il suo stato salvato in un Bundle, e quindi l'attività viene avviata, passando attraverso un booleano che indica se la tastiera deve 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);
}
Se viene visualizzata la tastiera virtuale, viene detto a InputMethodManager di mostrare la tastiera e alla finestra viene richiesto di rendere sempre visibile l'input virtuale. Se la tastiera virtuale deve essere nascosta allora il WindowManager.Parametri di layout.FLAG_ALT_FOCUSABLE_IM è impostato.
Questo approccio funziona in modo affidabile su tutti i dispositivi su cui ho testato - da un telefono HTC di 4 anni con Android 2.2 fino a un nexus 7 con 4.2.2. L'unico svantaggio con questo approccio è che devi stare attento con la gestione del pulsante indietro. Poiché la mia app ha essenzialmente una sola schermata (è una calcolatrice), posso sovrascrivere onBackPressed () e tornare alla schermata iniziale dei dispositivi.
In alternativa a questa soluzione all around, se si desidera chiudere la tastiera virtuale da qualsiasi punto senza avere un riferimento al campo (EditText) che è stato utilizzato per aprire la tastiera, ma si desidera comunque farlo se il campo è stato focalizzato, è possibile utilizzare questo (da un'attività):
if (getCurrentFocus() != null) {
InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
imm.hideSoftInputFromWindow(getCurrentFocus().getWindowToken(), 0);
}
Grazie a questa risposta SO, ho derivato quanto segue che, nel mio caso, funziona bene quando si scorrono i frammenti di un 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);
}
}
Le risposte precedenti funzionano per scenari diversi ma Se vuoi nascondere la tastiera all'interno di una vista e lottare per ottenere il contesto giusto prova questo:
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);
}
}
E per ottenere il contesto recuperarlo dal costruttore:)
public View/RelativeLayout/so and so (Context context, AttributeSet attrs, int defStyle) {
super(context, attrs, defStyle);
this.context = context;
init();
}
Se si desidera chiudere la tastiera virtuale durante un'unità o un test funzionale, è possibile farlo facendo clic sul pulsante "Indietro" dal test:
// Close the soft keyboard from a Test
getInstrumentation().sendKeyDownUpSync(KeyEvent.KEYCODE_BACK);
Metto "back button" tra virgolette, poiché quanto sopra non attiva onBackPressed() per l'attività in questione. Si chiude solo la tastiera.
Assicurati di mettere in pausa un po 'prima di passare, poiché ci vuole un po' di tempo per chiudere il pulsante Indietro, quindi i clic successivi alle Viste, ecc., non sarà registrato fino a dopo una breve pausa (1 il secondo è abbastanza lungo ime).
Ecco come si fa in Mono per Android (AKA MonoDroid)
InputMethodManager imm = GetSystemService (Context.InputMethodService) as InputMethodManager;
if (imm != null)
imm.HideSoftInputFromWindow (searchbox.WindowToken , 0);
Questo ha funzionato per me per tutto il bizzarro comportamento della tastiera
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);
}
}
Aggiungi alla tua attività android:windowSoftInputMode="stateHidden" nel file Manifest. Esempio:
<activity
android:name=".ui.activity.MainActivity"
android:label="@string/mainactivity"
android:windowSoftInputMode="stateHidden"/>
Usa questo
this.getWindow().setSoftInputMode(
WindowManager.LayoutParams.SOFT_INPUT_STATE_ALWAYS_HIDDEN);
Per il mio caso, stavo usando a SearchView nella actionbar. Dopo che un utente esegue una ricerca, la tastiera si aprirà di nuovo.
L'utilizzo di InputMethodManager non ha chiuso la tastiera. Ho dovuto clearFocus e impostare il focusable della vista di ricerca su false:
mSearchView.clearFocus();
mSearchView.setFocusable(false);
Ho quasi provato tutte queste risposte, ho avuto alcuni problemi casuali soprattutto con il Samsung galaxy s5.
Quello che finisco è forzare lo spettacolo e nascondere, e funziona perfettamente:
/**
* 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);
}
In alcuni casi questo metodo può funzionare ad eccezione di tutti gli altri. Questo salva la mia giornata:)
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);
}
}
}
Metodo semplice e facile da usare, basta chiamare hideKeyboardFrom(YourActivity.questo); per nascondere la tastiera
/**
* 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);
}
Basta usare questo codice ottimizzato nella tua attività:
if (this.getCurrentFocus() != null) {
InputMethodManager inputManager = (InputMethodManager) this.getSystemService(Context.INPUT_METHOD_SERVICE);
inputManager.hideSoftInputFromWindow(this.getCurrentFocus().getWindowToken(), InputMethodManager.HIDE_NOT_ALWAYS);
}
Ho il caso, dove il mio EditText può essere posizionato anche in un AlertDialog, quindi la tastiera dovrebbe essere chiusa al licenziamento. Il seguente codice sembra funzionare ovunque:
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 );
}