Android Soft Keyboard schließen / ausblenden

Ich habe ein EditTextund ein Buttonin meinem Layout.

Nachdem Buttonich in das Bearbeitungsfeld geschrieben und auf das geklickt habe , möchte ich die virtuelle Tastatur ausblenden. Ich gehe davon aus, dass dies ein einfacher Code ist, aber wo finde ich ein Beispiel dafür?

Beim Berühren außerhalb der Tastatur.

Um diesen Wahnsinn zu klären, möchte ich mich zunächst im Namen aller Android-Nutzer für Googles geradezu lächerliche Behandlung der Softtastatur entschuldigen. Der Grund, warum es so viele unterschiedliche Antworten für dieselbe einfache Frage gibt, ist, dass diese API, wie viele andere in Android, schrecklich gestaltet ist. Ich kann mir keinen höflichen Weg vorstellen, es auszudrücken.

Ich möchte die Tastatur verstecken. Ich erwarte, Android mit der folgenden Aussage zu versorgen : Keyboard.hide(). Das Ende. Vielen Dank. Aber Android hat ein Problem. Sie müssen die verwenden InputMethodManager, um die Tastatur auszublenden. OK, gut, dies ist die Android-API für die Tastatur. ABER! Sie benötigen eine Context, um Zugriff auf das IMM zu erhalten. Jetzt haben wir ein Problem. Möglicherweise möchte ich die Tastatur vor einer statischen oder Utility-Klasse ausblenden, die keine Verwendung hat oder benötigt Context. oder Und noch viel schlimmer, das IMM erfordert, dass Sie angeben, vor was View(oder noch schlimmer, was Window) Sie die Tastatur verstecken möchten.

Dies macht das Verstecken der Tastatur so schwierig. Lieber Google: Wenn ich das Rezept für einen Kuchen nachschlage, gibt es keinen RecipeProviderauf der Erde, der sich weigert, mir das Rezept zu geben, es sei denn, ich antworte zuerst, von wem der Kuchen gegessen wird UND wo er gegessen wird !!

Diese traurige Geschichte endet mit der hässlichen Wahrheit: Um die Android-Tastatur zu verbergen, müssen Sie zwei Arten der Identifizierung angeben: a Contextund entweder a Viewoder a Window.

Ich habe eine statische Dienstprogrammmethode erstellt, die die Aufgabe SEHR solide erledigen kann, vorausgesetzt, Sie rufen sie von einem auf 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);
}

Beachten Sie, dass diese Dienstprogrammmethode NUR funktioniert, wenn sie von einem Activity! Die obige Methode ruft getCurrentFocusdas Ziel Activityauf, um das richtige Fenstertoken abzurufen.

Angenommen, Sie möchten die Tastatur vor einem EditTextgehosteten in einem verstecken DialogFragment? Sie können die obige Methode dafür nicht verwenden:

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

Dies funktioniert nicht, da Sie einen Verweis auf den FragmentHost des Hosts übergeben Activity, der keine fokussierte Kontrolle hat, solange der Fragmentangezeigt wird! Beeindruckend! Um die Tastatur vor Fragmenten zu verbergen, greife ich auf die niedrigere, häufigere und hässlichere Ebene zurück:

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

Im Folgenden finden Sie einige zusätzliche Informationen, die aus mehr Zeitverschwendung bei der Suche nach dieser Lösung gewonnen wurden:

Informationen zu windowSoftInputMode

Es gibt noch einen weiteren Streitpunkt, den Sie beachten sollten. Standardmäßig weist Android dem ersten EditTextoder fokussierbaren Steuerelement in Ihrem automatisch den anfänglichen Fokus zu Activity. Daraus folgt natürlich, dass die InputMethod (normalerweise die Softtastatur) auf das Fokusereignis reagiert, indem sie sich selbst zeigt. Wenn das windowSoftInputModeAttribut in auf AndroidManifest.xmlgesetzt ist, stateAlwaysHiddenwird die Tastatur angewiesen, diesen automatisch zugewiesenen Anfangsfokus zu ignorieren.

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

Es ist fast unglaublich, dass es nichts zu tun scheint, um zu verhindern, dass sich die Tastatur öffnet, wenn Sie das Steuerelement berühren (es sei denn focusable="false"und / oder focusableInTouchMode="false"dem Steuerelement zugewiesen sind). Anscheinend gilt die Einstellung windowSoftInputMode nur für automatische Fokusereignisse, nicht für Fokusereignisse, die durch Berührungsereignisse ausgelöst werden.

Daher stateAlwaysHiddenist in der Tat sehr schlecht benannt. Es sollte vielleicht stattdessen aufgerufen ignoreInitialFocuswerden.

Hoffe das hilft.

UPDATE: Weitere Möglichkeiten, um ein Fenstertoken zu erhalten

Wenn keine fokussierte Ansicht vorhanden ist (z. B. wenn Sie nur Fragmente geändert haben), gibt es andere Ansichten, die ein nützliches Fenstertoken bereitstellen.

Dies sind Alternativen für den obigen Code. if (view == null) view = new View(activity); Diese beziehen sich nicht explizit auf Ihre Aktivität.

Innerhalb einer Fragmentklasse:

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

Gegeben ein Fragment fragmentals Parameter:

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

Ausgehend von Ihrem Inhaltskörper:

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

UPDATE 2: Deaktivieren Sie den Fokus, um zu vermeiden, dass die Tastatur erneut angezeigt wird, wenn Sie die App über den Hintergrund öffnen

Fügen Sie diese Zeile am Ende der Methode hinzu:

view.clearFocus();

Sie können Android zwingen, die virtuelle Tastatur mit der zu verbergen InputMethodManager auszublenden , indem Sie hideSoftInputFromWindowdas Token des Fensters mit Ihrer fokussierten Ansicht aufrufen und übergeben.

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

Dadurch wird die Tastatur in allen Situationen ausgeblendet. In einigen Fällen möchten Sie InputMethodManager.HIDE_IMPLICIT_ONLYals zweiten Parameter übergeben, um sicherzustellen, dass Sie die Tastatur nur dann ausblenden, wenn der Benutzer sie nicht explizit zum Anzeigen gezwungen hat (indem Sie das Menü gedrückt halten).

Hinweis: Wenn Sie dies in Kotlin tun möchten, verwenden Sie: context?.getSystemService(Context.INPUT_METHOD_SERVICE) as InputMethodManager

Kotlin-Syntax

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

Ebenfalls nützlich zum Ausblenden der Softtastatur ist:

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

Dies kann verwendet werden, um die Softtastatur zu unterdrücken, bis der Benutzer die editText-Ansicht tatsächlich berührt.

Ich habe noch eine Lösung, um die Tastatur auszublenden:

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

Hier HIDE_IMPLICIT_ONLYan der Position von showFlagund 0an der Position von passieren hiddenFlag. Die weiche Tastatur wird gewaltsam geschlossen.

Meiers Lösung funktioniert auch bei mir. In meinem Fall ist die oberste Ebene meiner App ein tabHost und ich möchte das Schlüsselwort beim Wechseln der Tabs ausblenden. Ich erhalte das Fenstertoken aus der tabHost-Ansicht.

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

Bitte versuchen Sie diesen Code unten in onCreate()

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

Update: Ich weiß nicht, warum diese Lösung nicht mehr funktioniert (ich habe sie gerade auf Android 23 getestet). Bitte verwenden Sie stattdessen die Lösung von Saurabh Pareek . Hier ist es:

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

Alte Antwort:

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

Wenn alle anderen Antworten hier nicht so funktionieren, wie Sie es möchten, gibt es eine andere Möglichkeit, die Tastatur manuell zu steuern.

Erstellen Sie eine Funktion, mit der einige der EditTextEigenschaften verwaltet werden:

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

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

Stellen EditTextSie dann sicher, dass onFocus von Ihnen die Tastatur öffnet / schließt:

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

Wenn Sie jetzt die Tastatur manuell öffnen möchten, rufen Sie Folgendes auf:

setEditTextFocus(true);

Und zum Abschluss des Anrufs:

setEditTextFocus(false);

Saurabh Pareek hat bisher die beste Antwort.

Könnte aber auch die richtigen Flags verwenden.

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

Beispiel für eine echte Verwendung

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

Durch diese Suche habe ich hier eine Antwort gefunden, die für mich funktioniert

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

Die kurze Antwort

OnClickRufen Sie in Ihrem Hörer onEditorActiondas EditTextmit anIME_ACTION_DONE

button.setOnClickListener(new OnClickListener() {

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

Der Drilldown

Ich bin der Meinung, dass diese Methode besser, einfacher und besser auf das Designmuster von Android abgestimmt ist. In dem einfachen Beispiel oben (und normalerweise in den meisten Fällen) haben Sie einen EditText, der Fokus hatte / hatte, und es war auch normalerweise derjenige, der die Tastatur zuerst aufrief (es ist definitiv in der Lage, sie in vielen aufzurufen häufige Szenarien). In derselben Art und Weise, es sollte derjenige sein , um die Tastatur freizugeben, in der Regel , dass durch eine durchgeführt werden ImeAction. Sehen Sie nur, wie sich ein EditTextwith android:imeOptions="actionDone"verhält. Sie möchten dasselbe Verhalten mit denselben Mitteln erreichen.

Überprüfen Sie diese Antwort

Das sollte funktionieren:

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

Ich verwende eine benutzerdefinierte Tastatur, um eine Hex-Nummer einzugeben, damit die IMM-Tastatur nicht angezeigt wird ...

In v3.2.4_r1 setSoftInputShownOnFocus(boolean show) wurde hinzugefügt, um das Wetter zu steuern oder die Tastatur nicht anzuzeigen, wenn eine Textansicht den Fokus erhält, aber sie ist immer noch verborgen, sodass die Reflexion verwendet werden muss:

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

Bei älteren Versionen habe ich mit a sehr gute Ergebnisse erzielt (aber alles andere als perfekt) OnGlobalLayoutListener, die mit Hilfe von a hinzugefügt wurdenViewTreeObserver aus meiner Stammansicht und dann überprüft, ob die Tastatur wie folgt angezeigt wird:

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

Diese letzte Lösung zeigt möglicherweise die Tastatur für den Bruchteil einer Sekunde an und führt zu Problemen mit den Auswahlgriffen.

Wenn die Tastatur im Vollbildmodus angezeigt wird, wird onGlobalLayout nicht aufgerufen. Um dies zu vermeiden, verwenden Sie TextView # setImeOptions (int) oder in der TextView-XML-Deklaration:

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

Update: Ich habe gerade herausgefunden, welche Dialoge verwendet werden, um die Tastatur niemals anzuzeigen, und funktioniert in allen Versionen:

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

Ich habe mehr als zwei Tage damit verbracht, alle im Thread veröffentlichten Lösungen durchzuarbeiten, und festgestellt, dass sie auf die eine oder andere Weise fehlen. Meine genaue Anforderung ist eine Schaltfläche, mit der die Bildschirmtastatur mit 100% iger Zuverlässigkeit ein- oder ausgeblendet wird. Wenn sich die Tastatur in ihrem verborgenen Zustand befindet, sollte sie nicht erneut angezeigt werden, unabhängig davon, auf welche Eingabefelder der Benutzer klickt. Im sichtbaren Zustand sollte die Tastatur nicht verschwinden, egal auf welche Schaltflächen der Benutzer klickt. Dies muss unter Android 2.2+ bis hin zu den neuesten Geräten funktionieren.

Sie können eine funktionierende Implementierung davon in meiner App Clean RPN sehen .

Nach dem Testen vieler der vorgeschlagenen Antworten auf verschiedenen Handys (einschließlich Froyo- und Lebkuchengeräten) stellte sich heraus, dass Android-Apps zuverlässig:

1. Verstecken Sie die Tastatur vorübergehend. Es wird wieder angezeigt, wenn ein Benutzer ein neues Textfeld fokussiert.
2. Zeigen Sie die Tastatur an, wenn eine Aktivität gestartet wird, und setzen Sie ein Flag für die Aktivität, das angibt, dass die Tastatur immer sichtbar sein soll. Dieses Flag kann nur gesetzt werden, wenn eine Aktivität initialisiert wird.
3. Markieren Sie eine Aktivität, um die Verwendung der Tastatur niemals anzuzeigen oder zuzulassen. Dieses Flag kann nur gesetzt werden, wenn eine Aktivität initialisiert wird.

Für mich reicht es nicht aus, die Tastatur vorübergehend zu verstecken. Auf einigen Geräten wird es wieder angezeigt, sobald ein neues Textfeld fokussiert wird. Da meine App mehrere Textfelder auf einer Seite verwendet, wird beim Fokussieren eines neuen Textfelds die ausgeblendete Tastatur wieder angezeigt.

Leider funktionieren die Punkte 2 und 3 in der Liste nur dann zuverlässig, wenn eine Aktivität gestartet wird. Sobald die Aktivität sichtbar geworden ist, können Sie die Tastatur nicht mehr dauerhaft ein- oder ausblenden. Der Trick besteht darin, Ihre Aktivität tatsächlich neu zu starten, wenn der Benutzer die Umschalttaste der Tastatur drückt. Wenn der Benutzer in meiner App auf die Umschalttaste drückt, wird der folgende Code ausgeführt:

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

Dadurch wird der Status der aktuellen Aktivität in einem Bundle gespeichert. Anschließend wird die Aktivität gestartet und durchläuft einen Booleschen Wert, der angibt, ob die Tastatur angezeigt oder ausgeblendet werden soll.

Innerhalb der onCreate-Methode wird der folgende Code ausgeführt:

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

Wenn die Soft-Tastatur angezeigt werden soll, wird der InputMethodManager angewiesen, die Tastatur anzuzeigen, und das Fenster wird angewiesen, die Soft-Eingabe immer sichtbar zu machen. Wenn die Softtastatur ausgeblendet werden soll, wird WindowManager.LayoutParams.FLAG_ALT_FOCUSABLE_IM festgelegt.

Dieser Ansatz funktioniert zuverlässig auf allen Geräten, auf denen ich getestet habe - von einem 4 Jahre alten HTC-Telefon mit Android 2.2 bis zu einem Nexus 7 mit 4.2.2. Der einzige Nachteil bei diesem Ansatz ist, dass Sie vorsichtig mit der Zurück-Taste umgehen müssen. Da meine App im Wesentlichen nur einen Bildschirm hat (es ist ein Taschenrechner), kann ich onBackPressed () überschreiben und zum Startbildschirm des Geräts zurückkehren.

Alternativ zu dieser Allround-Lösung können Sie die Softtastatur verwenden , wenn Sie sie von einem beliebigen Ort aus schließen möchten, ohne auf das Feld (EditText) zu verweisen, das zum Öffnen der Tastatur verwendet wurde, dies aber dennoch tun möchten, wenn das Feld fokussiert ist dies (aus einer Aktivität):

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

Dank dieser SO-Antwort habe ich Folgendes abgeleitet, was in meinem Fall beim Scrollen durch die Fragmente eines ViewPagers gut funktioniert ...

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

Die obigen Antworten funktionieren für verschiedene Szenarien. Wenn Sie jedoch die Tastatur in einer Ansicht ausblenden möchten und Schwierigkeiten haben, den richtigen Kontext zu finden, versuchen Sie Folgendes:

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

und um den Kontext zu bekommen, holen Sie ihn vom Konstruktor :)

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

Wenn Sie die Softtastatur während eines Geräte- oder Funktionstests schließen möchten, können Sie dies tun, indem Sie in Ihrem Test auf die Schaltfläche "Zurück" klicken:

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

Ich habe "Zurück" in Anführungszeichen gesetzt, da das oben Gesagte nicht onBackPressed()für die betreffende Aktivität ausgelöst wird . Es schließt nur die Tastatur.

Stellen Sie sicher, dass Sie eine kurze Pause einlegen, bevor Sie fortfahren, da das Schließen der Zurück-Taste eine Weile dauert, sodass nachfolgende Klicks auf Ansichten usw. erst nach einer kurzen Pause registriert werden (1 Sekunde ist lang genug ime) ).

So geht's in Mono für Android (AKA MonoDroid)

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

Dies funktionierte für mich bei all dem bizarren Tastaturverhalten

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

Fügen Sie Ihrer Aktivität android:windowSoftInputMode="stateHidden"in der Manifest-Datei hinzu. Beispiel:

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

Einfache und benutzerfreundliche Methode, rufen Sie einfach hideKeyboardFrom (YourActivity.this) auf. Tastatur ausblenden

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

Verwenden Sie einfach diesen optimierten Code in Ihrer Aktivität:

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

nach diesem Aufruf von onTouchListener:

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

benutze das

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

Für meinen Fall habe ich eine Suchansicht in der Aktionsleiste verwendet. Nachdem ein Benutzer eine Suche durchgeführt hat, wird die Tastatur wieder geöffnet.

Bei Verwendung des InputMethodManager wurde die Tastatur nicht geschlossen. Ich musste ClearFocus löschen und die Fokussierbarkeit der Suchansicht auf false setzen:

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

Ich habe den Fall, in dem sich mein EditTextauch in einem befinden kann AlertDialog, daher sollte die Tastatur beim Entlassen geschlossen werden. Der folgende Code scheint überall zu funktionieren:

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

Ich habe fast alle diese Antworten ausprobiert, ich hatte einige zufällige Probleme, insbesondere mit der Samsung Galaxy S5.

Am Ende zwinge ich die Show und verstecke mich, und es funktioniert perfekt:

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