Chiudere / nascondere la tastiera virtuale Android

StackOverflow https://stackoverflow.com/questions/1109022

Domanda

Ho un EditText e un Button nel mio layout.

Dopo aver scritto nel campo di modifica e facendo clic sul Button, voglio nascondere la tastiera virtuale. Presumo che questo è un semplice pezzo di codice, ma dove posso trovare un esempio di esso?

È stato utile?

Soluzione

Per aiutare a chiarire questa follia, vorrei innanzi tutto scusarmi a nome di tutti gli utenti Android per il trattamento addirittura ridicolo di Google della tastiera morbida. La ragione per cui ci sono così tante risposte, ognuna diversa, per la stessa semplice domanda perché questa API, come molti altri in Android, è stato progettato orribilmente. Posso pensare a un modo educato per affermarlo.

voglio nascondere la tastiera. Mi aspetto di fornire Android con la seguente dichiarazione: Keyboard.hide(). La fine. Grazie mille. Ma Android ha un problema. È necessario utilizzare il InputMethodManager per nascondere la tastiera. OK, bene, questa è l'API di Android alla tastiera. MA! Si sono tenuti ad avere un Context al fine di ottenere l'accesso al IMM. Ora abbiamo un problema. Mi può essere utile per nascondere la tastiera da una classe statica o di utilità che non ha alcun uso o bisogno di alcun Context. o E gran lunga peggiore, l'IMM richiede di specificare che cosa View (o, peggio ancora, che cosa Window) che si desidera nascondere la tastiera FROM.

Questo è ciò che rende nascondere la tastiera così impegnativo. Caro Google: Quando sto guardando la ricetta per una torta, non v'è alcuna RecipeProvider sulla Terra che potrebbe rifiutarsi di fornire me con la ricetta a meno che prima rispondere a chi la torta sarà mangiato da e dove sarà mangiato !!

Questa triste storia si conclude con la brutta verità: per nascondere la tastiera Android, vi verrà richiesto di fornire 2 forme di identificazione:. Un Context e di un View o un Window

Ho creato un metodo di utilità statica che può fare il lavoro molto solidamente, a condizione che si chiami 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);
}

Si noti che questo metodo di utilità funziona solo quando viene chiamato da un Activity! Il metodo di cui sopra chiama getCurrentFocus del Activity bersaglio per andare a prendere la giusta finestra di token.

Ma si supponga di voler nascondere la tastiera da un EditText ospitato in un DialogFragment? Non è possibile utilizzare il metodo di cui sopra per questo: 

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

Questo non funziona perché sarete passando un riferimento alla Fragment host del Activity, che non avrà il controllo mirato, mentre viene mostrato il Fragment! Wow! Così, per nascondere la tastiera da frammenti, ricorro al livello inferiore, più comune, e più brutta: 

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

Di seguito è riportato alcune informazioni aggiuntive raccolte da più tempo sprecato a caccia di questa soluzione:

Chi windowSoftInputMode

Non c'è ancora un altro punto di contesa di essere a conoscenza. Per impostazione predefinita, Android assegnerà automaticamente focus iniziale alla prima EditText o il controllo attivabile nel vostro Activity. Ne consegue naturalmente che l'InputMethod (in genere la tastiera virtuale) risponderà all'evento attenzione, mostrando sé. L'attributo windowSoftInputMode in AndroidManifest.xml, se impostato stateAlwaysHidden, istruisce la tastiera per ignorare questa concentrazione iniziale automaticamente assegnato. 

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

Quasi incredibilmente, sembra fare nulla per evitare che la tastiera apertura quando si tocca il controllo (a meno che focusable="false" e / o focusableInTouchMode="false" vengono assegnati al controllo). A quanto pare, l'impostazione windowSoftInputMode si applica solo agli eventi messa a fuoco automatica, senza mettere a fuoco gli eventi innescati da eventi touch.

Pertanto, stateAlwaysHidden è molto mal chiamato davvero. Si dovrebbe forse essere chiamato ignoreInitialFocus invece.

Spero che questo aiuti.

UPDATE: Altri modi per ottenere un gettone finestra

Se non c'è la vista concentrata (per esempio può accadere se appena modificato frammenti), ci sono altri punti di vista che forniranno una finestra utile token.

Queste sono alternative per il codice di cui sopra if (view == null) view = new View(activity); Questi non fanno esplicito riferimento alla vostra attività.

all'interno di una classe frammento:

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

Dato un frammento fragment come parametro: 

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

A partire dal corpo di contenuti: 

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

UPDATE 2: Cancella attenzione per evitare che mostra la tastiera di nuovo se si apre l'applicazione dallo sfondo

Aggiungi questa riga alla fine del metodo:

view.clearFocus();

Altri suggerimenti

È possibile forzare Android per nascondere la tastiera virtuale utilizzando il InputMethodManager , chiamando hideSoftInputFromWindow , passando nel token della finestra che contiene la visualizzazione 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);
}

Questo costringerà la tastiera per essere nascosto in tutte le situazioni. In alcuni casi si vuole passare InputMethodManager.HIDE_IMPLICIT_ONLY come secondo parametro per essere sicuri di nascondere solo la tastiera quando l'utente non ha esplicitamente costringerlo a comparire (tenendo premuto menu).

Nota: Se si vuole fare questo in Kotlin, uso: context?.getSystemService(Context.INPUT_METHOD_SERVICE) as InputMethodManager

Kotlin Sintassi 

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

Anche utile per nascondere il soft-tastiera è: 

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

Questa può essere utilizzata per sopprimere il soft-tastiera fino a quando l'utente tocca in realtà l'EditText View.

Ho avuto un altro 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 nella posizione di showFlag e 0 nella posizione di hiddenFlag. Sarà con forza chiudere 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 passa le schede -. Ottengo il token finestra dalla tabHost Visualizza 

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

Si prega di provare questo sottostante Codice in onCreate() 

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

Aggiornamento: Non so il motivo per cui questa soluzione non è funziona più (ho appena testato su Android 23). Si prega di utilizzare la soluzione di Saurabh Pareek . Eccolo: 

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

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

Se tutte le altre risposte qui non funzionano per voi come li vorrebbe, c'è un altro modo di controllare manualmente la tastiera.

Crea una funzione con che gestirà alcune delle proprietà del EditText: 

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

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

Quindi, assicurarsi che onFocus del EditText 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 di chiamata manualmente: 

setEditTextFocus(true);

E per la chiamata di chiusura: 

setEditTextFocus(false);

Saurabh Pareek ha la risposta migliore finora.

Potrebbe anche utilizzare le bandiere giuste, 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ì la 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 risposta breve

Nel vostro ascoltatore OnClick chiamare 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

Sento che questo metodo è migliore, più semplice e più in linea con il modello di progettazione di Android. Nel semplice esempio di cui sopra (e di solito nella maggior parte dei casi comuni) avrete un EditText che ha / aveva messa a fuoco ed è anche di solito era quello di richiamare la tastiera, in primo luogo (è sicuramente in grado di richiamare in molti scenari comuni). Nello stesso modo, è dovrebbe essere quello di liberare la tastiera, che di solito può essere fatto da un ImeAction. Basta vedere come un EditText con android:imeOptions="actionDone" si comporta, si vuole raggiungere lo stesso comportamento con gli stessi mezzi.

Controlla questo legati risposta

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 avere la tastiera IMM presentarsi ...

In v3.2.4_r1 setSoftInputShownOnFocus(boolean show) è stato aggiunto al controllo del tempo o meno per visualizzare la tastiera quando un TextView ottiene messa a fuoco, ma la sua ancora nascosto in modo riflesso deve essere utilizzato: 

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 risultati molto buoni (ma ben lungi dall'essere perfetto) con un OnGlobalLayoutListener, ha aggiunto con l'aiuto di un ViewTreeObserver dal mio punto di vista delle radici e quindi verificare se la tastiera è mostrato in questo modo: 

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

Questa ultima soluzione può mostrare la tastiera per una frazione di secondo e pasticci con le maniglie di selezione.

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

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

Aggiornamento: Appena trovato quello che le finestre di dialogo per usare mai mostrare 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 trascorso più di due giorni di lavoro attraverso tutte le soluzioni postato nel thread e li ho trovati privi di un modo o nell'altro. La mia esigenza esatta è di avere un pulsante che con il 100% di affidabilità mostrare o nascondere la tastiera su schermo. Quando la tastiera è nel suo stato nascosto è non dovrebbe ri-apparire, non importa quale ingresso campi l'utente fa clic su. Quando è nel suo stato visibile la tastiera non deve sparire, non importa quali pulsanti l'utente fa clic. Questo ha bisogno di lavorare su Android 2.2+ tutta la strada fino alle più recenti dispositivi.

Si può vedere un'implementazione di lavoro di questo nella mia app pulita RPN .

Dopo aver testato molte delle risposte suggerite su una serie di diversi telefoni (inclusi i dispositivi Froyo e Gingerbread) è emerso che le applicazioni Android possono affidabile:

  1. temporaneamente nascondere la tastiera. Si riapparirà di nuovo quando un utente concentra un nuovo campo di testo.
  2. Mostra la tastiera quando un'attività inizia e impostare un flag sull'attività indica che essi dovrebbero tastiera essere sempre visibile. Questo flag può essere impostato solo quando un'attività è inizializzazione.
  3. Mark un'attività di non mostrare o permettere l'uso del tastiera. Questo flag può essere impostato solo quando un'attività è inizializzazione.

Per quanto mi riguarda, si nasconde temporaneamente la tastiera non è sufficiente. Su alcuni dispositivi che si ri-apparirà non appena un nuovo campo di testo è a fuoco. Come la mia applicazione utilizza più campi di testo su una pagina, puntando un nuovo campo di testo farà sì che la tastiera nascosta per far apparire il backup di nuovo.

Purtroppo punto 2 e 3 della lista funzionano solo l'affidabilità quando viene avviato un'attività. Una volta che l'attività è diventata visibile non si può nascondere in modo permanente o visualizzare la tastiera. Il trucco è quello di riavviare in realtà la vostra attività quando l'utente preme il tasto della tastiera a ginocchiera. Nella mia app quando l'utente preme sul tasto della tastiera a ginocchiera, il seguente codice 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);
    }
}

Ciò causa l'attività corrente di avere stato salvato in un pacchetto, e quindi viene avviata l'attività, passando attraverso un booleano che indica se la tastiera deve essere mostrata o nascosta.

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

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 la tastiera virtuale dovrebbe essere mostrato, allora l'InputMethodManager viene detto per mostrare la tastiera e la finestra è incaricato di fare l'ingresso morbido sempre visibile. Se la tastiera virtuale deve essere nascosto allora la WindowManager.LayoutParams.FLAG_ALT_FOCUSABLE_IM è impostato.

Questo approccio funziona in modo affidabile su tutti i dispositivi che ho testato su - da una di 4 anni del telefono HTC in esecuzione Android 2.2 fino ad un Nexus 7 in esecuzione 4.2.2. L'unico svantaggio di questo approccio è che dovete stare attenti con la manipolazione il pulsante indietro. Come la mia app in sostanza ha un solo schermo (è una calcolatrice) posso ignorare onBackPressed () e tornare alla schermata dei dispositivi di casa.

In alternativa a questo tutto intorno soluzione , se si voleva chiudere la tastiera virtuale da qualsiasi luogo senza avere un riferimento al campo (EditText) che è stato utilizzato per aprire la tastiera, ma ha voluto farlo se il campo si è concentrata, si potrebbe utilizzare questo (da un Attività): 

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

Grazie a questo SO rispondere , ho derivato il seguito della quale, nel mio caso, funziona bene quando si scorre l'il frammenti di una 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);
    }
}

Sopra risposte lavorano per diversi scenari di ma Se si desidera nascondere la tastiera all'interno di una visione e che lottano per ottenere il giusto contesto provare 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 recuperare 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 nel corso di un'unità o test funzionale, è possibile farlo cliccando sul pulsante "indietro" dal test: 

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

ho messo "pulsante indietro" tra virgolette, dal momento che quanto sopra non innescare la onBackPressed() per l'attività in questione. E 'appena si chiude la tastiera.

Assicurati di mettere in pausa per un po 'prima di passare, dal momento che ci vuole un po' di tempo per chiudere il pulsante indietro, in modo da scatti successivi a Visualizzazioni, ecc, non verranno registrati fino a quando, dopo una breve pausa (1 secondo è abbastanza a 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 per me ha funzionato per tutto il comportamento della tastiera bizzarro 

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 android:windowSoftInputMode="stateHidden" attività nel file manifesto. Esempio: 

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

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

dopo quella chiamata sul onTouchListener: 

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

utilizzare questo 

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

Per il mio caso, stavo usando il un SearchView nel ActionBar. Dopo che un utente esegue una ricerca, la tastiera sarebbe pop di nuovo aperto.

Uso della InputMethodManager non chiudere la tastiera. Ho dovuto clearFocus e impostare l'attivabile della vista di ricerca su false: 

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

Basta usare il codice ottimizzato nella vostra 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, in cui la mia EditText può essere collocato anche in un AlertDialog, quindi la tastiera dovrebbe essere chiuso il 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 );
}

ho quasi provato tutte queste risposte, ho avuto alcuni problemi casuali in particolare con la galassia Samsung s5.

Quello che io alla fine con sta costringendo il mostrare 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 può metodi lavori, ad eccezione di tutti gli altri. Ciò consente di risparmiare il mio giorno:) 

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);
        }
    }
}
Autorizzato sotto: CC-BY-SA insieme a attribuzione
Non affiliato a StackOverflow
scroll top