it-swarm.com.de

Schließen/verbergen Sie die Android Soft-Tastatur

Ich habe eine EditText und eine Button in meinem Layout.

Nachdem Sie in das Editierfeld geschrieben und auf Button geklickt haben, 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?

3341
Vidar Vestnes

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 auf dieselbe einfache Frage gibt, ist, dass diese API, wie viele andere in Android, fürchterlich 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 Anweisung zu versehen: Keyboard.hide(). Das Ende. Vielen Dank. Aber Android hat ein Problem. Sie müssen InputMethodManager verwenden, um die Tastatur auszublenden. OK, gut, das ist die Android-API für die Tastatur. ABER! Sie benötigen ein Context, um auf das IMM zugreifen zu können. Jetzt haben wir ein Problem. Möglicherweise möchte ich die Tastatur vor einer statischen oder Utility-Klasse verbergen, die keine Context verwendet oder benötigt. oder Und noch viel schlimmer, das IMM verlangt, dass Sie angeben, vor welchem ​​View (oder noch schlimmer, welchem ​​Window) Sie die Tastatur verbergen möchten.

Das ist es, was das Verstecken der Tastatur so schwierig macht. Sehr geehrte Google, wenn ich das Rezept für einen Kuchen suche, gibt es auf der Erde kein RecipeProvider, das mir das Rezept verweigern würde, es sei denn, ich antworte zuerst, WER den Kuchen gegessen hat UND wo er sein wird gegessen!!

Diese traurige Geschichte endet mit der hässlichen Wahrheit: Um die Android Tastatur zu verbergen, müssen Sie zwei Arten der Identifizierung angeben: eine Context und entweder eine View oder eine Window.

Ich habe eine statische Dienstprogrammmethode erstellt, die die Aufgabe SEHR zuverlässig erledigen kann, vorausgesetzt, Sie rufen sie von einem Activity auf.

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 aufgerufen wird! Die obige Methode ruft getCurrentFocus des Ziels Activity auf, um das richtige Fenstertoken abzurufen.

Angenommen, Sie möchten die Tastatur vor einem EditText verbergen, das sich in einem DialogFragment befindet. Sie können die obige Methode dafür nicht verwenden:

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

Dies funktioniert nicht, da Sie einen Verweis auf den Fragment -Host Activity übergeben, der keine fokussierte Steuerung hat, während Fragment angezeigt 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 Sie erhalten, wenn Sie mehr Zeit damit verschwenden, diese Lösung zu suchen:

Über windowSoftInputMode

Es gibt noch einen weiteren Streitpunkt, dessen man sich bewusst sein muss. Standardmäßig weist Android dem ersten EditText oder fokussierbaren Steuerelement in Ihrem Activity automatisch den anfänglichen Fokus zu. Daraus folgt natürlich, dass die Eingabemethode (normalerweise die Soft-Tastatur) auf das Fokusereignis reagiert, indem sie sich selbst anzeigt. Wenn das windowSoftInputMode -Attribut in AndroidManifest.xml auf stateAlwaysHidden gesetzt ist, wird die Tastatur angewiesen, diesen automatisch zugewiesenen anfänglichen Fokus zu ignorieren.

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

Es ist kaum zu glauben, dass das Öffnen der Tastatur beim Berühren des Steuerelements nicht verhindert wird (es sei denn, dem Steuerelement sind focusable="false" und/oder focusableInTouchMode="false" zugewiesen). Anscheinend gilt die Einstellung windowSoftInputMode nur für automatische Fokusereignisse, nicht für durch Berührungsereignisse ausgelöste Fokusereignisse.

Daher ist stateAlwaysHidden in der Tat SEHR schlecht benannt. Es sollte stattdessen vielleicht ignoreInitialFocus heißen.

Hoffe das hilft.


PDATE: Weitere Möglichkeiten, ein Fenstertoken zu erhalten

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

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

In einer Fragmentklasse:

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

Ein Fragment fragment als Parameter gegeben:

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

Ausgehend von Ihrem Inhaltskörper:

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

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

1675
rmirabelle

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) }
 }
4268
Reto Meier

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.

764
Garnet Ulrich

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.

317
Saurabh Pareek

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

Bitte versuche diesen Code in onCreate().

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

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);
118
protected void hideSoftKeyboard(EditText input) {
    InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
    imm.hideSoftInputFromWindow(input.getWindowToken(), 0);    
}
74
Sreedev R

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

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

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

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

46
Alex.F

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

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);
39
sergio91pt
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);
    }
}
29
shobhan

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.

25
Luke Sleeman

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

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

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();
}
18
Ash

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

17
Peter Ajtai

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

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"/>
13
NickUnuchek

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);
    }
}
13
Asaf Pinhassi

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);
11
tommy chheng

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

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

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);
}
11
Naveed Ahmad

benutze das

this.getWindow().setSoftInputMode(
            WindowManager.LayoutParams.SOFT_INPUT_STATE_ALWAYS_HIDDEN);
11
Atish Agrawal

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 );
}
10
injecteer
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;
    }
});
10
Riser

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);
}
10
Hamid FzM

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

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);
8
Girish Patel

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

8
jasonhudgins

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.

7
user1765048

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

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

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

6
Vishal Yadav

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

5
milad.moafi

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"  />
5
pavel

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
5
Janusz Hain
public static void hideSoftKeyboard(Activity activity) {
    InputMethodManager inputMethodManager = (InputMethodManager)activity.getSystemService(Activity.INPUT_METHOD_SERVICE);
    inputMethodManager.hideSoftInputFromWindow(activity.getCurrentFocus().getWindowToken(), 0);
}
5

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

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();
    }
}
4
Ready Android

einfach Code: Verwenden Sie diesen Code in onCreate ()

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

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

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()
3
Krasavello13
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;
                    }
                });
3
Mr.vicky

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);
    }
}
3
Sagar Badave

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>
3
Daniel Beltrami

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);
        }
    }
3
Joolah
public static void hideSoftKeyboard(Activity activity) {
    InputMethodManager inputMethodManager = (InputMethodManager) activity
            .getSystemService(Activity.INPUT_METHOD_SERVICE);
    inputMethodManager.hideSoftInputFromWindow(activity.getCurrentFocus()
            .getWindowToken(), 0);
}
3

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

2
KarlTheGreat

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);
}
2
Rishabh Saxena

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 

2
Nadeem Bhat

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

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)
    }
2
Qamar

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

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

2
Gaurav Arora

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

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.

1
rupps

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!

1
Azurespot

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);
    }
}
1
Rajneesh Shukla
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

1
Jacek Kwiecień

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);
    }
}
1
Geng Jiawen

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.

1
Arihant Jain

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">
0
hardiBSalih

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.

0
shrewdu

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" />
0
Harpreet

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

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

0
Selman Tosun

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)
    }
}
0
jBegera

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

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

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);
0
Kavin Varnan

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();
}
0
Heena Arora

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;

        }
    });
0
nobjta_9x_tq

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

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"/>
0
Bhavik Nathani

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

 Android:windowSoftInputMode="stateAlwaysHidden|adjustPan"

und es wird funktionieren.

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

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);
}
0
Priyankagb
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);
0
koteswara D K
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);
}
0
ceph3us

Einige Kotlin-Codes: 

Tastatur vor Aktivität ausblenden:

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

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()
0
Phil
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);
}
0
Coldfin Lab
private void hideSoftKeyboard() {
    View view = getView();
    if (view != null) {
        InputMethodManager inputMethodManager = (InputMethodManager) getActivity()
                .getSystemService(Activity.INPUT_METHOD_SERVICE);
        inputMethodManager.hideSoftInputFromWindow(view.getWindowToken(), 0);
    }
}
0
Duna

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.

0
JamesC

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