Schließen/verbergen Sie die Android Soft-Tastatur

Sie können Android dazu zwingen, die virtuelle Tastatur mithilfe des Befehls InputMethodManager , Aufruf von hideSoftInputFromWindow auszublenden, indem Sie das Token des Fensters übergeben, das Ihre fokussierte Ansicht enthält.

// 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_ONLY als zweiten Parameter übergeben, um sicherzustellen, dass Sie die Tastatur nur ausblenden, wenn der Benutzer sie nicht explizit erzwungen hat (durch Halten des Menüs).

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?.let { it.hideSoftInputFromWindow(v.windowToken, 0) }
 }

Auch zum Ausblenden der Soft-Tastatur ist Folgendes hilfreich:

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

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

Ich habe eine weitere Lösung, um die Tastatur zu verbergen:

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

Hier übergeben Sie HIDE_IMPLICIT_ONLY an der Position von showFlag und 0 an der Position von hiddenFlag. Die Soft-Tastatur wird mit Gewalt geschlossen.

Meiers Lösung funktioniert auch für mich. In meinem Fall ist die oberste Ebene meiner App ein tabHost, und ich möchte das Schlüsselwort ausblenden, wenn Sie zwischen Registerkarten wechseln. 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 versuche diesen Code 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 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 für Sie funktionieren, können Sie die Tastatur manuell steuern.

Erstellen Sie eine Funktion, mit der einige der EditText-Eigenschaften verwaltet werden:

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

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

Stellen Sie dann sicher, dass Sie bei onFocus der EditText die Tastatur öffnen/schließen:

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 nun die Tastatur manuell öffnen möchten, rufen Sie Folgendes auf: 

setEditTextFocus(true);

Und zum Schlußruf:

setEditTextFocus(false);

Saurabh Pareek hat bisher die beste Antwort.

Könnte aber auch die korrekten Flaggen 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 den realen Gebrauch

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

von dieser 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

Rufen Sie in Ihrem OnClick-Listener das onEditorAction des EditText mit IME_ACTION_DONE auf

button.setOnClickListener(new OnClickListener() {

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

Der Drilldown

Ich denke, diese Methode ist besser, einfacher und besser auf das Designmuster von Android abgestimmt. In dem einfachen Beispiel oben (und normalerweise in den meisten häufigen Fällen) haben Sie eine EditText, die den Fokus hatte/hatte und dies normalerweise auch war Die Tastatur wird in erster Linie aufgerufen (sie kann sie definitiv in vielen gängigen Szenarien aufrufen). Auf dieselbe Art und Weise sollte it die Tastatur freigeben, die normalerweise von einer ImeAction ausgeführt werden kann. Sie müssen nur sehen, wie sich ein EditText mit Android:imeOptions="actionDone" verhält. Sie möchten dasselbe Verhalten mit den gleichen Mitteln erreichen.

Überprüfen Sie diese bezogene 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, sodass die IMM-Tastatur nicht angezeigt werden kann.

In v3.2.4_r1 wurde setSoftInputShownOnFocus(boolean show) hinzugefügt, um das Wetter zu steuern oder die Tastatur nicht anzuzeigen, wenn ein TextView den Fokus erhält, aber es ist immer noch ausgeblendet, sodass die Reflektion 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 erhielt ich sehr gute Ergebnisse (aber weit davon entfernt, perfekt zu sein), mit einer OnGlobalLayoutListener, die mithilfe einer ViewTreeObserver aus meiner Root-Ansicht hinzugefügt wurde. Anschließend wurde überprüft, ob die Tastatur folgendermaßen 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 kann die Tastatur für einen Sekundenbruchteil anzeigen und die Auswahlgriffe durcheinanderbringen.

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

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

Update: Ich habe gerade gefunden, was Dialoge verwenden, um die Tastatur nie 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 ich habe festgestellt, dass sie auf die eine oder andere Weise fehlen. Meine genaue Anforderung ist, eine Schaltfläche zu haben, die die Bildschirmtastatur mit 100% iger Zuverlässigkeit anzeigen oder ausblenden kann. Wenn sich die Tastatur in ausgeblendetem Zustand befindet, sollte sie nicht erneut angezeigt werden, unabhängig davon, welche Eingabefelder der Benutzer anklickt. Wenn es sichtbar ist, sollte die Tastatur nicht verschwinden, unabhängig davon, welche Schaltflächen der Benutzer anklickt. Dies muss auf Android 2.2 und den neuesten Geräten bis zu den neuesten Geräten funktionieren.

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

Nachdem viele der vorgeschlagenen Antworten auf verschiedenen Telefonen getestet wurden (einschließlich Froyo- und Gingerbread-Geräten), stellte sich heraus, dass Android-Apps zuverlässig funktionieren können:

1. Verstecken Sie die Tastatur vorübergehend. Es erscheint wieder, wenn ein Benutzer Ein neues Textfeld fokussiert.
2. Zeigen Sie die Tastatur an, wenn eine Aktivität beginnt Und setzen Sie ein Kennzeichen für die Aktivität, um anzugeben, 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 das temporäre Verstecken der Tastatur nicht aus. Bei einigen Geräten wird es erneut angezeigt, sobald ein neues Textfeld fokussiert ist. Da meine App mehrere Textfelder auf einer Seite verwendet, fokussiert ein neues Textfeld die verborgene Tastatur wieder.

Leider sind die Punkte 2 und 3 der Liste nur dann zuverlässig, wenn eine Aktivität gestartet wird. Sobald die Aktivität sichtbar ist, können Sie die Tastatur nicht dauerhaft ausblenden oder anzeigen. Der Trick besteht darin, Ihre Aktivität tatsächlich neu zu starten, wenn der Benutzer die Tastaturumschalttaste drückt. Wenn in meiner App der Benutzer auf die umschaltbare Tastaturtaste 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, wobei ein Boolean durchlaufen wird, der angibt, ob die Tastatur angezeigt oder verborgen werden soll.

In 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 aufgefordert, die Soft-Eingabe immer sichtbar zu machen. Wenn die Soft-Tastatur ausgeblendet werden soll, wird der WindowManager.LayoutParams.FLAG_ALT_FOCUSABLE_IM gesetzt.

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 besteht darin, dass Sie beim Umgang mit der Rücktaste vorsichtig sein müssen. Da meine App im Wesentlichen nur einen Bildschirm (einen Taschenrechner) hat, kann ich onBackPressed () überschreiben und zum Startbildschirm des Geräts zurückkehren.

Alternativ zu diese Rundum-Lösung , wenn Sie die Soft-Tastatur von einer beliebigen Stelle aus schließen möchten, ohne einen Verweis auf das Feld (EditText) zu haben, das zum Öffnen der Tastatur verwendet wurde, dies aber dennoch tun würde, wenn Das Feld war fokussiert, Sie können dies (aus einer Aktivität) verwenden:

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, aber Wenn Sie die Tastatur in einer Ansicht ausblenden möchten und versuchen, den richtigen Kontext zu erhalten, 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 vom Konstruktor abzurufen :) 

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, klicken Sie in Ihrem Test auf die Schaltfläche "Zurück".

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

Ich füge "Anführungszeichen" in Anführungszeichen ein, da das oben genannte die onBackPressed() für die betreffende Aktivität nicht auslöst. 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-Schaltfläche einige Zeit dauert. Nachfolgende Klicks auf Ansichten usw. werden erst nach einer kurzen Pause registriert (1 Sekunde ist lang genug ).

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

Fügen Sie Ihrer Aktivität Android:windowSoftInputMode="stateHidden" in der Manifestdatei hinzu. Beispiel:

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

Dies funktionierte für mich bei all dem bizarren Verhalten der Tastatur

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ür meinen Fall habe ich eine SearchView in der Aktionsleiste verwendet. Nachdem ein Benutzer eine Suche ausgeführt hat, öffnet sich die Tastatur erneut.

Mit dem InputMethodManager wurde die Tastatur nicht geschlossen. Ich musste clearFocus einstellen und den Fokus der Suchansicht auf false setzen:

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

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

Was ich am Ende erhalte, ist das Zeigen und Verbergen, 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);
}

In einigen Fällen können diese Methoden mit Ausnahme aller anderen funktionieren. Das spart meinen Tag :)

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

Einfache und benutzerfreundliche Methode, rufen Sie einfach hideKeyboardFrom (YourActivity.this) auf; um die Tastatur auszublenden

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

benutze das

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

Ich habe den Fall, dass sich meine EditText auch in einer AlertDialog befinden kann, also sollte die Tastatur beim Schließen 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 );
}

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

danach rufen Sie onTouchListener auf:

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

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

Funktioniert jedes Mal wie eine magische Berührung

private void closeKeyboard() {
    InputMethodManager inputManager = (InputMethodManager)getActivity().getSystemService(Context.INPUT_METHOD_SERVICE);
    inputManager.hideSoftInputFromWindow(getActivity().getCurrentFocus().getWindowToken(), InputMethodManager.HIDE_NOT_ALWAYS);

}

private void openKeyboard() {
    InputMethodManager imm = (InputMethodManager) getActivity().getSystemService(Context.INPUT_METHOD_SERVICE);
    if(imm != null){
        imm.toggleSoftInput(InputMethodManager.SHOW_IMPLICIT, 0);
    }
}

Für Open Keyboard:

InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
imm.showSoftInput(edtView, InputMethodManager.SHOW_IMPLICIT);

Zum Schließen/Verbergen der Tastatur:

 InputMethodManager imm = (InputMethodManager)getSystemService(Context.INPUT_METHOD_SERVICE);
 imm.hideSoftInputFromWindow(edtView.getWindowToken(), 0);

Sie können auch mit setImeOption im EditText nachschauen.

Ich hatte gerade eine sehr ähnliche Situation, in der mein Layout einen EditText und eine Suchschaltfläche enthielt. Als ich herausfand, dass ich die Option "ime" auf "editSearch" setzen konnte, wurde mir klar, dass ich nicht einmal einen Suchknopf mehr brauchte. Die Soft-Tastatur (in diesem Modus) verfügt über ein Suchsymbol, mit dem die Suche gestartet werden kann (und die Tastatur schließt sich wie erwartet). 

manchmal brauchen Sie nur die Eingabetaste, um die keyboard.__ zu falten. Geben Sie die EditText-Box ein, in der Sie das Attribut haben 

 Android:imeOptions="actionDone" 

dadurch wird die Eingabetaste in eine Fertig-Schaltfläche geändert, mit der die Tastatur geschlossen wird.

Für mich geht das..

EditText editText=(EditText)findViewById(R.id.edittext1);

in onClick () unter der Codezeile einfügen

editText.setFocusable(false);
editText.setFocusableInTouchMode(true);

verbergen Sie die Tastatur, wenn Sie auf die Schaltfläche klicken. Wenn Sie die Schaltfläche berühren, wird die EditText-Tastatur angezeigt.

(ODER)

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

Manchmal kann eine Aktivität vorhanden sein, die eine Listenansicht mit Zeilen enthält, die editText enthält. Sie müssen also das Manifest SOFT_INPUT_ADJUST_PAN einrichten. Dann wird die Tastatur angezeigt, was ärgerlich ist.

Der folgende Workarround funktioniert, wenn Sie ihn am Ende von onCreate platzieren.

getWindow().setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_STATE_ALWAYS_HIDDEN);
new Handler().postDelayed(new Runnable() {
            @Override
            public void run() {
                getWindow().setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_ADJUST_PAN);
            }
        },100);

Versuche dies

• Einfach können Sie Ihre Activity aufrufen 

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

• Rufen Sie dies in Ihrer MainActivitiy auf 

 hideKeyboardwithoutPopulate(MainActivity.this);

In AndroidManifest.xml unter <activity..> setzen Sie Android:windowSoftInputMode="stateAlwaysHidden"

Wenn Sie die Tastatur mit Java-Code ausblenden möchten, verwenden Sie Folgendes:

  InputMethodManager imm = (InputMethodManager)this.getSystemService(Context.INPUT_METHOD_SERVICE);
  imm.hideSoftInputFromWindow(fEmail.getWindowToken(), 0);

Oder wenn Sie die Tastatur immer ausblenden möchten, verwenden Sie dies in Ihrem AndroidManifest:

 <activity
 Android:name=".activities.MyActivity"
 Android:configChanges="keyboardHidden"  />

Ich habe eine kleine Erweiterung für Kotlin geschrieben, falls es jemanden interessiert, der nicht viel getestet hat:

fun Fragment.hideKeyboard(context: Context = App.instance) {
    val windowToken = view?.rootView?.windowToken
    windowToken?.let {
        val imm = context.getSystemService(Activity.INPUT_METHOD_SERVICE) as InputMethodManager
        imm.hideSoftInputFromWindow(windowToken, 0)
    }
}

App.instanz ist statisch "dieses" Anwendungsobjekt, das in der Anwendung gespeichert ist

Update: In einigen Fällen ist windowToken null. Ich habe eine zusätzliche Möglichkeit zum Schließen der Tastatur mit Reflektion hinzugefügt, um festzustellen, ob die Tastatur geschlossen ist

/**
 * If no window token is found, keyboard is checked using reflection to know if keyboard visibility toggle is needed
 *
 * @param useReflection - whether to use reflection in case of no window token or not
 */
fun Fragment.hideKeyboard(context: Context = MainApp.instance, useReflection: Boolean = true) {
    val windowToken = view?.rootView?.windowToken
    val imm = context.getSystemService(Context.INPUT_METHOD_SERVICE) as InputMethodManager
    windowToken?.let {
        imm.hideSoftInputFromWindow(windowToken, 0)
    } ?: run {
        if (useReflection) {
            try {
                if (getKeyboardHeight(imm) > 0) {
                    imm.toggleSoftInput(0, InputMethodManager.HIDE_NOT_ALWAYS)
                }
            } catch (exception: Exception) {
                Timber.e(exception)
            }
        }
    }
}

fun getKeyboardHeight(imm: InputMethodManager): Int = InputMethodManager::class.Java.getMethod("getInputMethodWindowVisibleHeight").invoke(imm) as Int

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

das funktioniert ..

Übergeben Sie einfach Ihre aktuelle Aktivitätsinstanz in der Funktion 

 public void isKeyBoardShow(Activity activity) {
    InputMethodManager imm = (InputMethodManager) activity.getSystemService(Activity.INPUT_METHOD_SERVICE);
    if (imm.isActive()) {
        imm.toggleSoftInput(InputMethodManager.HIDE_IMPLICIT_ONLY, 0); // hide
    } else {
        imm.toggleSoftInput(0, InputMethodManager.HIDE_IMPLICIT_ONLY); // show
    }
}

Eigentlich gibt Android-Autorität immer neue Updates, aber sie behandeln nicht ihre alten Nachteile, mit denen alle Android-Entwickler in ihrer Entwicklung konfrontiert sind. Diese sollte standardmäßig von Android-Autoritäten gehandhabt werden. Wenn Sie den Fokus von EditText ändern, sollten Sie die Soft-Input-Tastaturoption ein-/ausblenden. Tut mir leid, aber sie schaffen es nicht. OK lass es.

Nachfolgend finden Sie die Lösungen zum Anzeigen/Ausblenden/Umschalten einer Tastaturoption in Aktivität oder Fragment.

Tastatur für die Ansicht anzeigen:

/**
 * open soft keyboard.
 *
 * @param context
 * @param view
 */
public static void showKeyBoard(Context context, View view) {
    try {
        InputMethodManager keyboard = (InputMethodManager) context.getSystemService(Context.INPUT_METHOD_SERVICE);
        keyboard.showSoftInput(view, 0);
    } catch (Exception e) {
        e.printStackTrace();
    }
}

Tastatur mit Aktivitätskontext anzeigen:

/**
 * open soft keyboard.
 *
 * @param mActivity context
 */
public static void showKeyBoard(Activity mActivity) {
    try {
        View view = mActivity.getCurrentFocus();
        if (view != null) {
            InputMethodManager keyboard = (InputMethodManager) mActivity.getSystemService(Context.INPUT_METHOD_SERVICE);
            keyboard.showSoftInputFromInputMethod(view.getWindowToken(), InputMethodManager.SHOW_FORCED);
        }
    } catch (Exception e) {
        e.printStackTrace();
    }
}

Tastatur mit Fragmentkontext anzeigen:

/**
 * open soft keyboard.
 *
 * @param mFragment context
 */
public static void showKeyBoard(Fragment mFragment) {
    try {
        if (mFragment == null || mFragment.getActivity() == null) {
            return;
        }
        View view = mFragment.getActivity().getCurrentFocus();
        if (view != null) {
            InputMethodManager keyboard = (InputMethodManager) mFragment.getActivity().getSystemService(Context.INPUT_METHOD_SERVICE);
            keyboard.showSoftInputFromInputMethod(view.getWindowToken(), InputMethodManager.SHOW_FORCED);
        }
    } catch (Exception e) {
        e.printStackTrace();
    }
}

Tastatur für die Ansicht ausblenden:

/**
 * close soft keyboard.
 *
 * @param context
 * @param view
 */
public static void hideKeyBoard(Context context, View view) {
    try {
        InputMethodManager keyboard = (InputMethodManager) context.getSystemService(Context.INPUT_METHOD_SERVICE);
        keyboard.hideSoftInputFromWindow(view.getWindowToken(), 0);
    } catch (Exception e) {
        e.printStackTrace();
    }
}

Tastatur mit Aktivitätskontext ausblenden:

/**
 * close opened soft keyboard.
 *
 * @param mActivity context
 */
public static void hideSoftKeyboard(Activity mActivity) {
    try {
        View view = mActivity.getCurrentFocus();
        if (view != null) {
            InputMethodManager inputManager = (InputMethodManager) mActivity.getSystemService(Context.INPUT_METHOD_SERVICE);
            inputManager.hideSoftInputFromWindow(view.getWindowToken(), 0);
        }
    } catch (Exception e) {
        e.printStackTrace();
    }
}

Tastatur mit Fragmentkontext ausblenden:

/**
 * close opened soft keyboard.
 *
 * @param mFragment context
 */
public static void hideSoftKeyboard(Fragment mFragment) {
    try {
        if (mFragment == null || mFragment.getActivity() == null) {
            return;
        }
        View view = mFragment.getActivity().getCurrentFocus();
        if (view != null) {
            InputMethodManager inputManager = (InputMethodManager) mFragment.getActivity().getSystemService(Context.INPUT_METHOD_SERVICE);
            inputManager.hideSoftInputFromWindow(view.getWindowToken(), 0);
        }
    } catch (Exception e) {
        e.printStackTrace();
    }
}

Tastatur umschalten:

/**
 * toggle soft keyboard.
 *
 * @param context
 */
public static void toggleSoftKeyboard(Context context) {
    try {
        InputMethodManager imm = (InputMethodManager) context.getSystemService(Activity.INPUT_METHOD_SERVICE);
        imm.toggleSoftInput(InputMethodManager.HIDE_IMPLICIT_ONLY, 0);
    } catch (Exception e) {
        e.printStackTrace();
    }
}

einfach Code: Verwenden Sie diesen Code in onCreate ()

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

Hier sind beide Methoden zum Verbergen und Anzeigen.

Kotlin

fun hideKeyboard(activity: Activity) {
    val v = activity.currentFocus
    val imm = activity.getSystemService(Context.INPUT_METHOD_SERVICE) as InputMethodManager
    assert(v != null)
    imm.hideSoftInputFromWindow(v!!.windowToken, InputMethodManager.HIDE_NOT_ALWAYS)
}

private fun showKeyboard(activity: Activity) {
    val v = activity.currentFocus
    val imm = activity.getSystemService(Context.INPUT_METHOD_SERVICE) as InputMethodManager
    assert(v != null)
    imm.showSoftInput(v, InputMethodManager.SHOW_IMPLICIT)
}

Java

public static void hideKeyboard(Activity activity) {
    View v = activity.getCurrentFocus();
    InputMethodManager imm = (InputMethodManager) activity.getSystemService(Context.INPUT_METHOD_SERVICE);
    assert imm != null && v != null;
    imm.hideSoftInputFromWindow(v.getWindowToken(), InputMethodManager.HIDE_NOT_ALWAYS);
}

private static void showKeyboard(Activity activity) {
    View v = activity.getCurrentFocus();
    InputMethodManager imm = (InputMethodManager) activity.getSystemService(Context.INPUT_METHOD_SERVICE);
    assert imm != null && v != null;
    imm.showSoftInput(v, InputMethodManager.SHOW_IMPLICIT);
}

Wenn Sie Kotlin für die Entwicklung Ihrer Anwendung verwenden, ist dies sehr einfach.

Fügen Sie diese Erweiterungsfunktionen hinzu:

Für Aktivität:

fun Activity.hideKeyboard() {
    val inputManager = getSystemService(Context.INPUT_METHOD_SERVICE) as InputMethodManager
    val view = currentFocus
    if (view != null) {
        inputManager.hideSoftInputFromWindow(view.windowToken, InputMethodManager.HIDE_NOT_ALWAYS)
    }
}

Für Fragment:

fun Fragment.hideKeyboard() {
    activity?.let {
        val inputManager = it.getSystemService(Context.INPUT_METHOD_SERVICE) as InputMethodManager
        val view = it.currentFocus
        if (view != null) {
            inputManager.hideSoftInputFromWindow(view.windowToken, InputMethodManager.HIDE_NOT_ALWAYS)
        }
    }
}

Jetzt können Sie Ihr Fragment oder Ihre Aktivität einfach aufrufen:

 hideKeyboard()

final RelativeLayout llLogin = (RelativeLayout) findViewById(R.id.rl_main);
        llLogin.setOnTouchListener(
                new View.OnTouchListener() {
                    @Override
                    public boolean onTouch(View view, MotionEvent ev) {
                        InputMethodManager imm = (InputMethodManager) this.getSystemService(
                                Context.INPUT_METHOD_SERVICE);
                        imm.hideSoftInputFromWindow(this.getCurrentFocus().getWindowToken(), 0);
                        return false;
                    }
                });

Probier diese

public void disableSoftKeyboard(final EditText v) {
    if (Build.VERSION.SDK_INT >= 11) {
        v.setRawInputType(InputType.TYPE_CLASS_TEXT);
        v.setTextIsSelectable(true);
    } else {
        v.setRawInputType(InputType.TYPE_NULL);
        v.setFocusable(true);
    }
}

Sehr einfacher Weg

Ich mache das in all meinen Projekten und arbeite wie ein Traum. Fügen Sie in Ihren Deklarationen layout.xml einfach diese Zeile ein:

Android:focusableInTouchMode="true"

Vollständiger Codebeispiel:

<?xml version="1.0" encoding="utf-8"?>
<Android.support.constraint.ConstraintLayout
    xmlns:app="http://schemas.Android.com/apk/res-auto"
    Android:layout_width="match_parent"
    Android:layout_height="match_parent"
    Android:focusableInTouchMode="true">

    <EditText
        Android:layout_width="match_parent"
        Android:layout_height="wrap_content" />

    <ListView
        Android:layout_width="match_parent"
        Android:layout_height="wrap_content">

    </ListView>

</Android.support.constraint.ConstraintLayout>

Hier sind die besten Lösungen

Lösung 1) Stellen Sie den inputType auf "text"

<EditText
Android:id="@+id/my_edit_text"
Android:layout_width="fill_parent"
Android:layout_height="wrap_content"
Android:hint="Tap here to type"
Android:inputType="text" />

Dies kann auch programmgesteuert über erfolgen. die Methode setInputType () (von TextView geerbt). 

EditText editText = (EditText) findViewById(R.id.my_edit_text);
editText.setRawInputType(InputType.TYPE_CLASS_TEXT | 
InputType.TYPE_TEXT_VARIATION_NORMAL);

Lösung 2) Verwenden Sie InputMethodManager.hideSoftInputFromWindow ().

InputMethodManager imm = 
(InputMethodManager)getSystemService(Context.INPUT_METHOD_SERVICE);
imm.hideSoftInputFromWindow(myEditText.getWindowToken(), 0);

oder

InputMethodManager imm = (InputMethodManager) 
getSystemService(Context.INPUT_METHOD_SERVICE);
imm.hideSoftInputFromWindow(myEditText.getWindowToken(), 
InputMethodManager.HIDE_NOT_ALWAYS);

einfache Methode Jungs: versuchen Sie dies ...

private void closeKeyboard(boolean b) {

        View view = this.getCurrentFocus();

        if(b) {
            if (view != null) {
                InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
                imm.hideSoftInputFromWindow(view.getWindowToken(), 0);
            }
        }
        else {
            InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
            imm.showSoftInput(view, 0);
        }
    }

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

Eine einfache Problemumgehung besteht darin, nur editText.setEnabled(false);editText.setEnabled(true); in Ihrer Button onClick() -Methode anzugeben.

Wenn Sie die Tastatur bei Betätigung der Schaltfläche manuell ausblenden möchten, klicken Sie auf:

/**
 * Hides the already popped up keyboard from the screen.
 *
 */
public void hideKeyboard() {
    try {
        // use application level context to avoid unnecessary leaks.
        InputMethodManager inputManager = (InputMethodManager) getApplicationContext().getSystemService(Context.INPUT_METHOD_SERVICE);
        assert inputManager != null;
        inputManager.hideSoftInputFromWindow(getCurrentFocus().getWindowToken(), InputMethodManager.HIDE_NOT_ALWAYS);
    } catch (Exception e) {
        e.printStackTrace();
    }
}

Wenn Sie die Tastatur an einer beliebigen Stelle ausblenden möchten, auf die Sie klicken, außer edittext .

@Override
public boolean dispatchTouchEvent(MotionEvent ev) {
    View view = getCurrentFocus();
    if (view != null && (ev.getAction() == MotionEvent.ACTION_UP || ev.getAction() == MotionEvent.ACTION_MOVE) && view instanceof EditText && !view.getClass().getName().startsWith("Android.webkit.")) {
        int scrcoords[] = new int[2];
        view.getLocationOnScreen(scrcoords);
        float x = ev.getRawX() + view.getLeft() - scrcoords[0];
        float y = ev.getRawY() + view.getTop() - scrcoords[1];
        if (x < view.getLeft() || x > view.getRight() || y < view.getTop() || y > view.getBottom())
            ((InputMethodManager)this.getSystemService(Context.INPUT_METHOD_SERVICE)).hideSoftInputFromWindow((this.getWindow().getDecorView().getApplicationWindowToken()), 0);
    }
    return super.dispatchTouchEvent(ev);
}

In Android können Sie das Vkeyboard mithilfe von InputMethodManage ausblenden, indem Sie das Token des Fensters übergeben, das Ihre fokussierte Ansicht enthält.

View view = this.getCurrentFocus();
if (view != null) {  
InputMethodManager im = 
(InputMethodManager)getSystemService(Context.INPUT_METHOD_SERVICE);
im.hideSoftInputFromWindow(view.getWindowToken(), 0);
}

Durch den Aufruf von editText.clearFocus () und dann InputMethodManager.HIDE_IMPLICIT_ONLY funktioniert sogar 

sie können diesen Code einfach dort einfügen, wo Sie die Soft-Tastatur ausblenden möchten. "

                        // Check if no view has focus:
                            View view = getCurrentFocus();
                            if (view != null) {
                                InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
                                imm.hideSoftInputFromWindow(view.getWindowToken(), 0);
                            }

In Kotlin

fun hideKeyboard(activity: BaseActivity) {
        val view = activity.currentFocus?: View(activity)
        val imm = activity.getSystemService(Activity.INPUT_METHOD_SERVICE) as InputMethodManager
        imm.hideSoftInputFromWindow(view.windowToken, 0)
    }

Ich habe ein Layout teilweise aus XML und teilweise aus einer benutzerdefinierten Layout-Engine erstellt, die alle im Code verarbeitet wird. Das einzige, was für mich funktionierte, war zu verfolgen, ob die Tastatur geöffnet war oder nicht, und die Tastaturumschaltmethode wie folgt zu verwenden:

public class MyActivity extends Activity
{
    /** This maintains true if the keyboard is open. Otherwise, it is false. */
    private boolean isKeyboardOpen = false;

    @Override
    public void onCreate(Bundle savedInstanceState)
    {
        super.onCreate(savedInstanceState);
        LayoutInflater inflater;
        inflater = (LayoutInflater) getSystemService(Context.LAYOUT_INFLATER_SERVICE);
        View contentView = inflater.inflate(context.getResources().getIdentifier("main", "layout", getPackageName()), null);

        setContentView(contentView);
        contentView.getViewTreeObserver().addOnGlobalLayoutListener(new OnGlobalLayoutListener() 
        {
            public void onGlobalLayout() 
            {
                Rect r = new Rect();
                contentView.getWindowVisibleDisplayFrame(r);
                int heightDiff = contentView.getRootView().getHeight() - (r.bottom - r.top);
                if (heightDiff > 100) 
                    isKeyboardVisible = true;
                else
                    isKeyboardVisible = false;
             });
         }
    }

    public void closeKeyboardIfOpen()
    {
        InputMethodManager imm;
        imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
        if (isKeyboardVisible)
            imm.toggleSoftInput(InputMethodManager.HIDE_IMPLICIT_ONLY, 0);
    }   
}

Diese Methode funktioniert immer um jeden Preis. Verwenden Sie es einfach überall, wo Sie die Tastatur ausblenden möchten

public static void hideSoftKeyboard(Context mContext,EditText username){
        if(((Activity) mContext).getCurrentFocus()!=null && ((Activity) mContext).getCurrentFocus() instanceof EditText){
            InputMethodManager imm = (InputMethodManager)mContext.getSystemService(Context.INPUT_METHOD_SERVICE);
            imm.hideSoftInputFromWindow(username.getWindowToken(), 0);
        }
    }

Verwenden Sie es so:

Was ist die Android-Version? Diese Methode wird sicherlich funktionieren

Das hat bei mir funktioniert.

public static void hideKeyboard(Activity act, EditText et){
    Context c = act.getBaseContext();
    View v = et.findFocus();
    if(v == null)
        return;
    InputMethodManager inputManager = (InputMethodManager) c.getSystemService(Context.INPUT_METHOD_SERVICE);
    inputManager.hideSoftInputFromWindow(v.getWindowToken(), InputMethodManager.HIDE_NOT_ALWAYS);
}

Versucht alles hier in Verzweiflung, kombiniert alle Methoden und natürlich wird die Tastatur in Android 4.0.3 nicht geschlossen (es funktionierte in Honeicomb AFAIR).

Dann fand ich plötzlich eine scheinbar gewinnende Kombination:

textField.setRawInputType(InputType.TYPE_CLASS_TEXT |InputType.TYPE_TEXT_VARIATION_NORMAL);

kombiniert mit Ihren üblichen Rezepten

blahblaj.hideSoftInputFromWindow ...

ich hoffe, das hindert jemanden daran, Selbstmord zu begehen. Ich war nah dran. Ich habe natürlich keine Ahnung, warum es funktioniert.

Eine Alternative zur Verwendung von SearchView wäre die Verwendung dieses Codes:

searchView = (SearchView) searchItem.getActionView();    
searchView.setOnQueryTextListener(new OnQueryTextListener() {
    @Override
    public boolean onQueryTextSubmit(String query) {
        InputMethodManager imm = (InputMethodManager)
        getSystemService(getApplicationContext().INPUT_METHOD_SERVICE);
        imm.hideSoftInputFromWindow(searchView.getApplicationWindowToken(), 0);
    }
}

Dies ist ein SearchView-Suchfeld in der Aktionsleiste. Wenn der Text aus der Abfrage übermittelt wird (der Benutzer drückt entweder die Enter-Taste oder eine Suchschaltfläche/ein Symbol), wird der InputMethodManager-Code aktiviert und die Soft-Tastatur wird heruntergefahren. Dieser Code wurde in meine onCreateOptionsMenu() eingefügt. searchItem ist von MenuItem, was Teil des Standardcodes für die onCreateOptionsmenu() ist. Vielen Dank an @mckoss für einen guten Teil dieses Codes!

sie können Extension für jede Ansicht erstellen

fun View.hideKeyboard() = this.let {
    val imm = context.getSystemService(Context.INPUT_METHOD_SERVICE) as InputMethodManager
    imm.hideSoftInputFromWindow(windowToken, 0)
}

Beispielanwendung mit Aktivität

window.decorView.hideKeyboard();

Beispielanwendung mit View

etUsername.hideKeyboard();

Happy Coding ...

Rufen Sie diese Methode auf, um die Soft-Tastatur auszublenden

public void hideKeyBoard() {
    View view1 = this.getCurrentFocus();
    if(view!= null){
        InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
        imm.hideSoftInputFromWindow(view1.getWindowToken(), 0);
    }
}

public static void closeInput(final View caller) {  
    caller.postDelayed(new Runnable() {
        @Override
        public void run() {
            InputMethodManager imm = (InputMethodManager) caller.getContext().getSystemService(Context.INPUT_METHOD_SERVICE);
            imm.hideSoftInputFromWindow(caller.getWindowToken(), InputMethodManager.HIDE_NOT_ALWAYS);
        }
    }, 100);
}

Diese Methode funktioniert im Allgemeinen, es gibt jedoch eine Bedingung: Android:windowSoftInputMode="any_of_these" darf nicht gesetzt sein

Trotz all dieser Antworten habe ich, um einfach genug zu sein, eine gängige Methode dafür geschrieben:

/**
 * hide soft keyboard in a activity
 * @param activity
 */
public static void hideKeyboard (Activity activity){
    activity.getWindow().setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_STATE_HIDDEN);
    if (activity.getCurrentFocus() != null) {
        InputMethodManager inputMethodManager = (InputMethodManager) activity.getSystemService(activity.INPUT_METHOD_SERVICE);
        inputMethodManager.hideSoftInputFromWindow(activity.getCurrentFocus().getWindowToken(), 0);
    }
}

Der folgende Code hilft Ihnen, generische Funktionen zu erstellen, die von überall aus aufgerufen werden können. 

import Android.app.Activity
import Android.content.Context
import Android.support.design.widget.Snackbar
import Android.view.View
import Android.view.inputmethod.InputMethodManager

public class KeyboardHider {
    companion object {

        fun hideKeyboard(view: View, context: Context) {
            val inputMethodManager = context.getSystemService(Activity.INPUT_METHOD_SERVICE) as InputMethodManager
            inputMethodManager.hideSoftInputFromWindow(view.windowToken, 0)
        }

    }

}

Rufen Sie die Above-Methode von einer beliebigen Codezeile aus.

CustomSnackbar.hideKeyboard(view, [email protected])

view kann alles sein, zum Beispiel das Root-Layout einer Aktivität.

Hallo, das ist einfach, wenn Sie mit Kotlin arbeiten. Ich glaube, Sie können den Code leicht auch in Java konvertieren. Verwenden Sie diese Funktion, wenn Sie Ihre Aktivität laden, z.

fun hideKeybord (){
val inputManager = getSystemService(Context.INPUT_METHOD_SERVICE) as InputMethodManager
if (inputManager.isAcceptingText){
    inputManager.hideSoftInputFromWindow(currentFocus.windowToken, 0)
}

}

ich erwähne diese Funktion in Ihrer onCreate () -Methode und füge diese Android:windowSoftInputMode="stateAlwaysHidden"-Zeile zu Ihrer Aktivität in der Datei "manafest.xml" hinzu. 

<activity
    Android:name=".Activity.MainActivity"
    Android:label="@string/app_name"
    Android:theme="@style/AppTheme.NoActionBar"
    Android:windowSoftInputMode="stateAlwaysHidden">

Für die Kotlin-Benutzer gibt es eine Kotlin-Erweiterungsmethode, die sich für meine Anwendungsfälle bewährt hat:

fun View.hideKeyboard() {
    val imm = this.context.getSystemService(Activity.INPUT_METHOD_SERVICE) as InputMethodManager
    imm.hideSoftInputFromWindow(windowToken, 0)
}

legen Sie es in eine Datei namens ViewExtensions (oder was haben Sie) und nennen Sie es wie eine normale Methode in Ihren Ansichten.

Wenn Ihre Anwendung auf API Level 21 oder mehr abzielt, gibt es eine zu verwendende Standardmethode:

editTextObj.setShowSoftInputOnFocus(false);

Stellen Sie sicher, dass Sie im EditText XML-Tag den folgenden Code festgelegt haben.

<EditText  
    ....
    Android:enabled="true"
    Android:focusable="true" />

Das war Arbeit für mich. Es ist in Kotlin zum Verstecken der Tastatur.

private fun hideKeyboard() {
        val inputManager = activity?.getSystemService(Context.INPUT_METHOD_SERVICE) as InputMethodManager
        val focusedView = activity?.currentFocus
        if (focusedView != null) {
            inputManager.hideSoftInputFromWindow(focusedView.windowToken,
                    InputMethodManager.HIDE_NOT_ALWAYS)
        }
    }

Dieses Code-Snippet kann helfen:

    final InputMethodManager inputMethodManager = (InputMethodManager) getSystemService(Activity.INPUT_METHOD_SERVICE);
    if (inputMethodManager != null && inputMethodManager.isActive()) {
        if (getCurrentFocus() != null) {
            inputMethodManager.hideSoftInputFromWindow(getCurrentFocus().getWindowToken(), 0);
        }
    }

Es kann je nach Bedarf in verschiedenen Methoden aufgerufen werden (zB onPause, onResume, onRestart ...)

Ich verwende folgende Kotlin Activity-Erweiterungen:

/**
 * Hides soft keyboard if is open.
 */
fun Activity.hideKeyboard() {
    currentFocus?.windowToken?.let {
        (getSystemService(Context.INPUT_METHOD_SERVICE) as? InputMethodManager?)
                ?.hideSoftInputFromWindow(it, InputMethodManager.HIDE_NOT_ALWAYS)
    }
}

/**
 * Shows soft keyboard and request focus to given view.
 */
fun Activity.showKeyboard(view: View) {
    view.requestFocus()
    currentFocus?.windowToken?.let {
        (getSystemService(Context.INPUT_METHOD_SERVICE) as? InputMethodManager?)
                ?.showSoftInput(view, InputMethodManager.SHOW_IMPLICIT)
    }
}

So zeigen Sie die Tastatur beim Start der Anwendung an:

        getWindow().setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_ADJUST_PAN | WindowManager.LayoutParams.SOFT_INPUT_STATE_VISIBLE);
        view.requestFocus();
        new Handler().postDelayed(new Runnable() {
            public void run() {
                getWindow().setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_ADJUST_PAN);
            }
        }, 1000);

Fügen Sie zunächst aus der XML-Datei das Feld add Android: imeOptions hinzu und ändern Sie den Wert in actionUnspecified | actionGo (siehe unten)

 <Android.support.design.widget.TextInputEditText
                    Android:id="@+id/edit_text_id"
                    Android:layout_width="fill_parent"
                    Android:layout_height="@dimen/edit_text_height"
                    Android:imeOptions="actionUnspecified|actionGo"
                    />

Fügen Sie dann in der Klasse Java ein setOnEditorActionListener hinzu und fügen Sie InputMethodManager wie folgt hinzu

enterOrderNumber.setOnEditorActionListener (neuer TextView.OnEditorActionListener () {

    @Override
    public boolean onEditorAction(TextView v, int actionId, KeyEvent event) {
        if (actionId == EditorInfo.IME_ACTION_GO) {
            InputMethodManager imm = (InputMethodManager) getActivity().getSystemService(Activity.INPUT_METHOD_SERVICE);
            imm.toggleSoftInput(InputMethodManager.HIDE_IMPLICIT_ONLY, 0);
            return true;
        }
        return false;
    }
});

Kotlin-Version 

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

umschließen Sie es mit try catch, sodass die Tastatur bereits geschlossen ist. 

try{

View view = this.getCurrentFocus();
if (view != null) {  
    InputMethodManager imm = (InputMethodManager)getSystemService(Context.INPUT_METHOD_SERVICE);
    imm.hideSoftInputFromWindow(view.getWindowToken(), 0);
}
}catch (Exception e)
{
  e.printStackTrace();
}

Ich habe alle Lösungen sehr viel ausprobiert, aber keine Lösung für mich, daher habe ich meine Lösung gefunden:.

public static isKeyboardShowing = false;
InputMethodManager inputMethodManager = (InputMethodManager) getActivity()
            .getSystemService(Context.INPUT_METHOD_SERVICE);

Und bei einem Touchscreen-Ereignis rufen Sie an:

@Override
public boolean onTouchEvent(MotionEvent event) {
    if(keyboardShowing==true){
        inputMethodManager.toggleSoftInput(InputMethodManager.RESULT_UNCHANGED_HIDDEN, 0);
        keyboardShowing = false;
    }
    return super.onTouchEvent(event);
}

Und in EditText steht irgendwo:

yourEditText.setOnClickListener(new OnClickListener() {

        @Override
        public void onClick(View v) {
            yourClass.keyboardShowing = true;

        }
    });

Für Xamarin.Android:

public void HideKeyboard()
{
    var imm = activity.GetSystemService(Context.InputMethodService).JavaCast<InputMethodManager>();
    var view = activity.CurrentFocus ?? new View(activity);
    imm.HideSoftInputFromWindow(view.WindowToken, HideSoftInputFlags.None);
}

Fügen Sie in einer bestimmten Aktivität einfach die folgende Zeile in AndroidManifest hinzu.

<activity
        Android:name=".MainActivity"
        Android:screenOrientation="portrait">
        Android:windowSoftInputMode="adjustPan"/>

Sie müssen nur eine Zeile in Ihr Manifest-Aktivitäts-Tag schreiben

 Android:windowSoftInputMode="stateAlwaysHidden|adjustPan"

und es wird funktionieren.

 fun hideKeyboard(appCompatActivity: AppCompatActivity) {
        val view = appCompatActivity.currentFocus
        val imm = appCompatActivity.getSystemService(Context.INPUT_METHOD_SERVICE) as InputMethodManager
        imm.hideSoftInputFromWindow(view.windowToken, 0)
    }

erstellen Sie einfach eine allgemeine Methode für die gesamte Anwendung in BaseActivity und BaseFragment

in onCreate() initialisieren inputMethodManager

inputMethodManager = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);

machen Sie diese Methoden zum Verstecken und Anzeigen der Tastatur

public void hideKeyBoard(View view) {
     if (view != null) {
         inputMethodManager.hideSoftInputFromWindow(view.getWindowToken(), 0);
      }
 }

public void showKeyboard(View view, boolean isForceToShow) {
      if (isForceToShow)
         inputMethodManager.toggleSoftInput(InputMethodManager.SHOW_FORCED, 0);
      else if (view != null)
           inputMethodManager.showSoftInput(view, 0);
}

use Text watcher instead of EditText.and after you finished entering the input 

sie können verwenden 

InputMethodManager imm = (InputMethodManager)getSystemService(Context.INPUT_METHOD_SERVICE);
    imm.hideSoftInputFromWindow(view.getWindowToken(), 0);

there are two ways to do so...

method 1:in manifest file

define the line **Android:windowSoftInputMode="adjustPan|stateAlwaysHidden"** of code in your manifest.xml file as below...

<activity
            Android:name="packagename.youactivityname"
            Android:screenOrientation="portrait"
            Android:windowSoftInputMode="adjustPan|stateAlwaysHidden" />

Method 2 : in Activity or Java class

 if(getCurrentFocus()!=null) {
            InputMethodManager inputMethodManager = (InputMethodManager) getSystemService(INPUT_METHOD_SERVICE)`enter code here`;
            inputMethodManager.hideSoftInputFromWindow(getCurrentFocus().getWindowToken(), 0);
        }

es wird funktionieren .... @ ASK

/** 
 *
 *   Hide I Said!!!
 *
 */
public static boolean hideSoftKeyboard(@NonNull Activity activity) {
    View currentFocus = activity.getCurrentFocus();
    if (currentFocus == null) {
        currentFocus = activity.getWindow().getDecorView();
        if (currentFocus != null) {
            return getSoftInput(activity).hideSoftInputFromWindow(currentFocus.getWindowToken(), 0, null);
        }
    }
    return false;
}

public static boolean hideSoftKeyboard(@NonNull Context context) {
   if(Activity.class.isAssignableFrom(context.getClass())){
       return hideSoftKeyboard((Activity)context);
   }
   return false;
}

public static InputMethodManager getSoftInput(@NonNull Context context) {
    return (InputMethodManager) context.getSystemService(Activity.INPUT_METHOD_SERVICE);
}

Einige Kotlin-Codes: 

Tastatur vor Aktivität ausblenden:

(currentFocus ?: View(this))
            .apply { (getSystemService(Activity.INPUT_METHOD_SERVICE) as InputMethodManager)
                        .hideSoftInputFromWindow(windowToken, 0) }

Wiki Antwort in Kotlin:

1 - Erstellen Sie eine Top-Level-Funktion innerhalb einer Datei (zum Beispiel eine Datei, die alle Ihre Top-Level-Funktionen enthält):

fun Activity.hideKeyboard(){
    val imm = this.getSystemService(Activity.INPUT_METHOD_SERVICE) as InputMethodManager
    var view = currentFocus
    if (view == null) { view = View(this) }
    imm.hideSoftInputFromWindow(view.windowToken, 0)
}

2 - Dann rufen Sie es bei jeder gewünschten Aktivität auf:

this.hideKeyboard()

public void hideKeyboard() 
{
    if(getCurrentFocus()!=null) 
    {
        InputMethodManager inputMethodManager = (InputMethodManager) getSystemService(INPUT_METHOD_SERVICE);
        inputMethodManager.hideSoftInputFromWindow(getCurrentFocus().getWindowToken(), 0);
    }
}


public void showKeyboard(View mView) {
    InputMethodManager inputMethodManager = (InputMethodManager) getSystemService(INPUT_METHOD_SERVICE);
    mView.requestFocus();
    inputMethodManager.showSoftInput(mView, 0);
}

private void hideSoftKeyboard() {
    View view = getView();
    if (view != null) {
        InputMethodManager inputMethodManager = (InputMethodManager) getActivity()
                .getSystemService(Activity.INPUT_METHOD_SERVICE);
        inputMethodManager.hideSoftInputFromWindow(view.getWindowToken(), 0);
    }
}

Nachdem ich alle Antworten oben und in einem anderen Beitrag gelesen hatte, gelang es mir immer noch nicht, die Tastatur automatisch öffnen zu lassen.

In meinem Projekt habe ich dynamisch einen Dialog (AlertDialog) erstellt (durch Programmieren ohne oder mit minimalem erforderlichen XML-Code).

Also machte ich so etwas wie:

    dialogBuilder = new AlertDialog.Builder(activity);

    if(dialogBuilder==null)
        return false; //error

    inflater      = activity.getLayoutInflater();
    dialogView    = inflater.inflate(layout, null);
    ...

Und nach dem Einrichten aller Ansichten (TextView, ImageView, EditText usw.) habe ich:

        alertDialog = dialogBuilder.create();

        alertDialog.show();

Nachdem ich mit allen Antworten herumgespielt hatte, stellte ich fest, dass die meisten von ihnen IF arbeiten, und Sie wissen WO, um die Anfrage zu stellen ... Und das war der Schlüssel zu allen.

Der Trick besteht also darin, VOR die Erstellung des Dialogs zu setzen: alertDialog.show() In meinem Fall funktionierte das wie ein Zauber:

        alertDialog = dialogBuilder.create();           
        alertDialog.getWindow().setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_STATE_ALWAYS_VISIBLE);

        //And only when everything is finished - let's bring up the window - 
        alertDialog.show();

        //Viola... keyboard is waiting for you open and ready...
        //Just don't forget to request focus for the needed view (i.e. EditText..)

Ich bin mir ziemlich sicher, dass dieses Prinzip bei allen Fenstern gleich ist. Achten Sie also auf die Position Ihres "showKeyboard" -Codes - dies sollte vor dem Start des Fensters geschehen.

Eine kleine Anfrage vom Android SDK-Entwicklerteam:

Ich denke, dass dies alles unnötig ist, da Sie sehen können, dass Tausende von Programmierern aus der ganzen Welt sich mit diesem lächerlichen und trivialen Problem beschäftigen, während seine Lösung sauber und einfach sein sollte: IMHO, wenn ich requestFocus() zu einem eingabeorientierten System bekomme view (z. B. EditText) sollte sich die Tastatur automatisch öffnen, es sei denn, der Benutzer fordert not-to auf. Daher denke ich, dass die requestFocus () -Methode hier der Schlüssel ist und das boolean showSoftKeyboard mit dem Standardwert true akzeptieren sollte: View.requestFocus(boolean showSoftKeyboard);

Hoffe, das hilft anderen wie mir.

Versuchen Sie dies in Kotlin

 private fun hideKeyboard(){
    val imm = activity!!.getSystemService(INPUT_METHOD_SERVICE) as InputMethodManager
    imm.hideSoftInputFromWindow(activity!!.currentFocus!!.windowToken, 0)
}

Versuchen Sie dies in Java

 private void hideKeyboard(){
  InputMethodManager imm =(InputMethodManager)getSystemService(INPUT_METHOD_SERVICE);
  imm.hideSoftInputFromWindow(getCurrentFocus().getWindowToken(), 0);
}