Schließen / verstecken die Android Soft-Tastatur

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

Frage

Ich habe eine EditText und Button in meinem Layout.

Nachdem in dem Eingabefeld schreiben und auf dem Button, mag ich die virtuelle Tastatur verstecken. Ich gehe davon aus, dass dies ein einfaches Stück Code ist, aber wo kann ich ein Beispiel dafür finden?

War es hilfreich?

Lösung

Um diesen Wahnsinn helfen zu klären, würde Ich mag von entschuldigend im Namen aller Android-Nutzer für Googles geradezu lächerlich Behandlung der Soft-Tastatur beginnen. Der Grund, es gibt so viele Antworten, die jeweils unterschiedlichen, für die gleiche einfache Frage, da diese API, wie viele andere in Android, ist schrecklich gestaltet. Ich kann mir keine höfliche Art und Weise denken, um es zu angeben.

Ich möchte die Tastatur auszublenden. Ich erwarte, dass Android mit der folgenden Aussage bieten: Keyboard.hide(). Das Ende. Vielen Dank. Aber Android hat ein Problem. Sie müssen die InputMethodManager verwenden, um die Tastatur auszublenden. OK, gut, das ist Android API auf der Tastatur. ABER! Sie sind verpflichtet, eine Context haben, um Zugriff auf das IMM zu bekommen. Jetzt haben wir ein Problem. Ich mag kann die Tastatur von einer statischen oder Utility-Klasse verbergen, die keine Verwendung oder Notwendigkeit für ein Context hat. oder Und viel schlimmer, das IMM erfordert, dass Sie angeben, welche View (oder noch schlimmer, was Window) Sie die Tastatur aus ausblenden möchten.

Dies ist, was die Tastatur macht versteckt so herausfordernd. Lieber Google: Wenn ich das Rezept für einen Kuchen bin auf der Suche nach oben, gibt es keine RecipeProvider auf der Erde, die mich mit dem Rezept zu schaffen, würde sich weigern, es sei denn, ich zuerst beantworten, wer der Kuchen durch gegessen wird und wo es gegessen wird !!

Diese traurige Geschichte mit der hässlichen Wahrheit endet: die Android-Tastatur zu verbergen, werden Sie aufgefordert 2 Formen der Identifikation zu schaffen: a. Context und entweder ein View oder ein Window

Ich habe eine statische Hilfsmethode geschaffen, die den Job fest VERY tun können, sofern Sie es von einem Activity nennen. 

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

Bitte beachten Sie, dass diese Dienstprogramm Methode funktioniert nur, wenn sie von einem Activity genannt! Die obige Methode ruft getCurrentFocus des Ziel Activity das richtige Fenster Token zu holen.

Aber wenn Sie die Tastatur von einem EditText in einem DialogFragment gehostet verstecken wollen? Sie können nicht die oben beschriebene Methode für die Verwendung: 

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

Das wird nicht funktionieren, weil Sie einen Verweis geben werden, um den Host-Fragment des Activity, die keine gezielte Kontrolle, während die Fragment gezeigt hat! Beeindruckend! Also, für die Tastatur aus Fragmenten versteckt, ich zurückgreifen auf die untere Ebene, die häufigen und hässliche: 

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 von mehr Zeit aufgelesen verschwendet diese Lösung zu jagen:

Über windowSoftInputMode

Es ist noch ein weiterer Punkt des Anstoßes bewusst zu sein. Standardmäßig wird Android zuweisen automatisch anfänglichen Fokus auf dem ersten EditText oder fokussierbar Kontrolle in Ihrem Activity. Daraus folgt natürlich, dass die Inputmethod (in der Regel der Soft-Tastatur) mit dem Fokus Ereignisse selbst, indem zeigen reagieren. Das windowSoftInputMode Attribut in AndroidManifest.xml, wenn auf stateAlwaysHidden, weist die Tastatur diesen automatisch zugewiesene anfänglichen Fokus zu ignorieren. 

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

Fast unglaublich, scheint es nichts zu tun, um die Tastatur von der Öffnung zu verhindern, wenn Sie die Kontrolle berühren (es sei denn focusable="false" und / oder focusableInTouchMode="false" an die Steuerung zugeordnet sind). Offenbar gilt die windowSoftInputMode Einstellung nur für die automatischen Fokus-Ereignisse, Ereignisse nicht durch Touch-Ereignisse ausgelöst zu konzentrieren.

Daher ist stateAlwaysHidden sehr schlecht in der Tat genannt. Es sollte vielleicht ignoreInitialFocus stattdessen aufgerufen werden.

Hope, das hilft.

UPDATE: Mehr Möglichkeiten, um ein Fenster Token

zu bekommen

Wenn es keine fokussierte Sicht ist (zum Beispiel kann passieren, wenn Sie Fragmente nur geändert), es gibt auch andere Ansichten, die einen nützlichen Fenster Token liefern werden.

Dies sind Alternativen für die oben genannten Code if (view == null) view = new View(activity); Diese müssen nicht explizit auf Ihre Tätigkeit beziehen.

In einem Fragment Klasse:

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

ein Fragment fragment als Parameter angegeben: 

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

Starten von Ihrem Inhalt Körper: 

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

UPDATE 2: Klarer Fokus zu vermeiden Tastatur zeigt wieder, wenn Sie die App aus dem Hintergrund öffnen

Fügen Sie diese Zeile am Ende des Verfahrens:

view.clearFocus();

Andere Tipps

Sie können Android zwingen die virtuelle Tastatur mit dem InputMethodManager , ruft hideSoftInputFromWindow , in dem Token des Fensters, indem Sie Ihre fokussierte Sicht 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);
}

Dies wird die Tastatur zwingen, in allen Situationen verborgen werden. In einigen Fällen werden Sie in InputMethodManager.HIDE_IMPLICIT_ONLY als zweiten Parameter übergeben nur, um sicherzustellen, Sie auf die Tastatur verstecken, wenn der Benutzer es nicht explizit erscheint Kraft hat (durch Menü gedrückt halten).

Hinweis: Wenn Sie in Kotlin, dies zu tun, 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 nützlich für das Verstecken der Soft-Tastatur ist: 

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

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

Ich habe eine weitere Lösung Tastatur auszublenden: 

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

Hier passiert HIDE_IMPLICIT_ONLY an der Position der showFlag und 0 an der Position der hiddenFlag. Es wird mit Nachdruck Soft-Tastatur schließen.

Meier-Lösung funktioniert auch für mich. In meinem Fall die oberste Ebene meiner App ist ein TabHost und ich möchte das Stichwort verstecken, wenn Tabs Schale -. Ich das Fenster Token aus der TabHost Ansicht erhalten 

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

Bitte versuchen Sie dies unter Code in onCreate() 

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

Update: Ich weiß nicht, warum diese Lösung nicht mehr wird funktionieren (ich auf Android nur getestet 23). Bitte verwenden Sie die Lösung von Saurabh Pareek statt . Hier ist sie: 

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 arbeiten, wie Sie sie möchten, gibt es eine weitere Möglichkeit, die Tastatur manuell zu steuern.

Erstellen Sie eine Funktion mit, dass einige der EditText Eigenschaften verwalten: 

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

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

Dann stellen Sie sicher, dass onFocus der EditText Öffnen / Schließen der Tastatur: 

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

Nun, wenn Sie auf der Tastatur öffnen möchten manuell aufrufen: 

setEditTextFocus(true);

Und zum Schließen Aufruf: 

setEditTextFocus(false);

Saurabh Pareek hat die beste Antwort so weit.

Es könnte aber auch verwenden, um die richtigen Flags, though. 

/* 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 realer Verwendung 

/* click button */
public void onClick(View view) {      
  /* hide keyboard */
  ((InputMethodManager) getSystemService(Activity.INPUT_METHOD_SERVICE))
      .toggleSoftInput(InputMethodManager.SHOW_IMPLICIT, 0);

  /* start loader to check parameters ... */
}

/* loader finished */
public void onLoadFinished(Loader<Object> loader, Object data) {
    /* parameters not valid ... */

    /* show keyboard */
    ((InputMethodManager) getSystemService(Activity.INPUT_METHOD_SERVICE))
        .toggleSoftInput(0, InputMethodManager.HIDE_IMPLICIT_ONLY);

    /* parameters valid ... */
}

von so suchen, hier fand ich eine Antwort, 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

In Ihrem OnClick Hörer rufen Sie die onEditorAction des EditText mit IME_ACTION_DONE 

button.setOnClickListener(new OnClickListener() {

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

Der Drill-down

Ich fühle mich diese Methode ist besser, einfacher und ausgerichtet mit Android Design-Muster. In dem einfachen Beispiel oben (und in der Regel in den meisten gängigen Fälle) erhalten Sie eine EditText haben, hatte / konzentrieren und es war auch in der Regel derjenige, der die Tastatur in erster Linie zu berufen (es ist definitiv in der Lage, es zu berufen, in viele gängige Szenarien). In derselben Art und Weise, es sollte derjenige sein, um die Tastatur freizugeben, das kann in der Regel durch eine ImeAction erfolgen. sehen, wie ein EditText mit android:imeOptions="actionDone" verhält, können Sie das gleiche Verhalten mit den gleichen Mitteln erreichen wollen.

Überprüfen Sie diese bezogene Antwort

Dies 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 zur Eingabe einer Hex-Nummer, so kann ich nicht die IMM-Tastatur angezeigt habe ...

In v3.2.4_r1 setSoftInputShownOnFocus(boolean show) wurde hinzugefügt Wetter zu kontrollieren oder die Tastatur nicht angezeigt werden, wenn ein Textview den Fokus erhält, aber es ist immer noch versteckt, so Reflexion verwendet werden muss: 

if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.HONEYCOMB_MR2) {
    try {
        Method method = TextView.class.getMethod("setSoftInputShownOnFocus", boolean.class);
        method.invoke(mEditText, false);
    } catch (Exception e) {
        // Fallback to the second method
    }
}

Für ältere Versionen, ich hätte sehr gute Ergebnisse (aber bei weitem nicht perfekt) mit einem OnGlobalLayoutListener aufgenommen mit Hilfe eines ViewTreeObserver aus meiner Stammansicht und dann überprüfen, ob die Tastatur wie folgt dargestellt: 

@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 Bruchteil einer Sekunde und Verwirrungen mit den Auswahlpunkten zeigen.

Wenn in der Tastatur Vollbild eingibt, wird onGlobalLayout nicht genannt. Um zu vermeiden, dass, verwenden Sie Textview # setImeOptions (int) oder in der Textview XML-Deklaration: 

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

Update: gefunden einfach, welche Dialoge verwenden, um nie die Tastatur anzeigen und arbeitet 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 lang durch alle Lösungen arbeiten im Thread geschrieben und haben sie in der einen oder anderen fehlt gefunden. Meine genaue Anforderung ist es, eine Taste zu haben, die mit 100% Zuverlässigkeit Show werden oder versteckt die Tastatur auf dem Bildschirm. Wenn die Tastatur in seinen versteckten Zustand ist nicht wieder erscheinen, unabhängig davon, welche Eingabefelder der Benutzer klickt. Wenn es in seinem sichtbaren Zustand ist, sollte die Tastatur nicht ganz gleich verschwindet welche Tasten der Benutzer klickt. Dies muss auf Android arbeiten 2.2+ den ganzen Weg bis zu den neuesten Geräten.

Sie können eine funktionierende Implementierung dieser in meiner app sehen sauber RPN .

Nach dem Einschalten einer Reihe von verschiedenen Telefonen viele der vorgeschlagenen Antworten Prüfung (einschließlich Froyo und Lebkuchen-Geräte) wurde deutlich, dass Android Apps zuverlässig:

  1. verstecken vorübergehend die Tastatur. Es wird wieder erscheinen wieder, wenn ein Benutzer konzentriert sich ein neues Textfeld.
  2. die Tastatur anzeigen, wenn eine Tätigkeit beginnt und stellen Sie eine Flagge auf der Aktivität anzeigt, dass sie Tastatur sollte immer sichtbar sein. Dieses Flag kann nur eingestellt werden, wenn eine Tätigkeit Initialisierung.
  3. Mark eine Tätigkeit, nie die Verwendung der Show oder zulassen Tastatur. Dieses Flag kann nur eingestellt werden, wenn eine Tätigkeit Initialisierung.

Für mich vorübergehend die Tastatur versteckt ist nicht genug. Bei einigen Geräten wird es wieder angezeigt, sobald ein neues Textfeld fokussiert ist. Da meine app mehr Textfelder auf einer Seite verwendet, wird ein neues Textfeld fokussieren, um die verborgene Tastatur führt wieder Pop zurück.

Leider Punkt 2 und 3 auf der Liste nur die Zuverlässigkeit arbeiten, wenn eine Aktivität gestartet wird. Sobald die Aktivität sichtbar geworden ist, kann man nicht dauerhaft verstecken oder die Tastatur zeigen. Der Trick ist, um tatsächlich Ihre Aktivität neu starten, wenn der Benutzer die Tastatur Toggle-Knopf drückt. In meiner Anwendung, wenn der Benutzer drückt auf der Toggle-Tastatur-Taste wird folgender 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);
    }
}

Dies bewirkt, dass die aktuelle Aktivität seines Zustand in ein Bündel gespeichert haben, und dann wird die Aktivität gestartet, durch eine boolean vorbei, das anzeigt, wenn die Tastatur angezeigt oder verborgen werden soll.

Im Innern der onCreate Methode der folgende Code ausgeführt wird: 

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, dann wird der InputMethodManager sagt die Tastatur zu zeigen, und das Fenster wird angewiesen, den Soft-Input immer sichtbar zu machen. Wenn die Soft-Tastatur versteckt werden sollte dann die WindowManager.LayoutParams.FLAG_ALT_FOCUSABLE_IM gesetzt.

Dieser Ansatz funktioniert zuverlässig auf allen Geräten ich getestet haben - von einem 4 Jahre alten HTC Handy mit Android 2.2 bis zu einem Nexus 7 läuft 4.2.2. Der einzige Nachteil bei diesem Ansatz ist, dass Sie mit der Handhabung der Zurück-Taste vorsichtig sein müssen. Da meine App im Wesentlichen nur einen Bildschirm (es ist ein Rechner) Ich kann onBackPressed () überschreiben und zurück zum Geräte Home-Bildschirm.

Alternativ href="https://stackoverflow.com/a/9494042/451962"> diese rundum Lösung von überall ohne (EditText) Feld eine Referenz aufweist, die verwendet wurde, um die Tastatur zu öffnen, wollte aber nach wie vor konzentriert war es, wenn das Feld zu tun, werden Sie dies (von einer Aktivität) verwenden: 

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

Dank diese SO beantworten , abgeleitet ich die folgenden, die in meinem Fall, funktioniert gut, wenn sie durch das Scrollen der Fragmente eines ViewPager ... 

private void hideKeyboard() {   
    // Check if no view has focus:
    View view = this.getCurrentFocus();
    if (view != null) {
        InputMethodManager inputManager = (InputMethodManager) this.getSystemService(Context.INPUT_METHOD_SERVICE);
        inputManager.hideSoftInputFromWindow(view.getWindowToken(), InputMethodManager.HIDE_NOT_ALWAYS);
    }
}

private void showKeyboard() {   
    // Check if no view has focus:
    View view = this.getCurrentFocus();
    if (view != null) {
        InputMethodManager inputManager = (InputMethodManager) this.getSystemService(Context.INPUT_METHOD_SERVICE);
        inputManager.showSoftInput(view, InputMethodManager.SHOW_IMPLICIT);
    }
}

Über Antworten arbeiten für verschiedene Szenarien, aber Wenn Sie die Tastatur in einer Ansicht verbergen wollen und kämpfen, die richtigen Kontext dies zu umgehen versuchen: 

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 erhalten den Kontext aus Konstruktor holen :) 

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

Wenn Sie die Soft-Tastatur während einer Einheit oder Funktionstest schließen möchten, können Sie dies tun, indem Sie die „Zurück-Button“ aus dem Test klicken: 

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

Ich habe „Zurück-Button“ in Anführungszeichen, da die oben nicht die onBackPressed() für die betreffende Tätigkeit auslöst. Es schließt nur die Tastatur.

Achten Sie darauf, für eine Weile pausieren, bevor er auf, da es eine Weile dauert die Zurück-Taste zu schließen, so dass nachfolgende Klicks Ansichten etc. wird erst nach einer kurzen Pause registriert werden (1 Sekunde lange genug ime).

Hier ist, wie Sie es in Mono für Android (AKA MonoDroid) tun 

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

Das funktionierte für mich für die ganze bizarre 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);
    }
}

in Ihrer Aktivität android:windowSoftInputMode="stateHidden" in Manifest-Datei. Beispiel: 

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

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

nach diesem Anruf auf onTouchListener: 

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

verwenden diese 

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

Für meinen Fall wurde ich mit dem einem Suche in der Aktionsleiste. Nachdem ein Benutzer eine Suche durchführt, würde die Tastatur wieder aufspringen.

die InputMethodManager Verwendung nicht die Tastatur schließen. Ich musste clearFocus und stellen Sie die fokussierbare der Suchansicht auf false: 

mSearchView.clearFocus();
mSearchView.setFocusable(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);
}

Ich habe den Fall, wo mein EditText kann auch in einem AlertDialog angeordnet werden, so sollte die Tastatur auf entlassen geschlossen werden. Der folgende Code scheint überall zu funktionieren: 

public static void hideKeyboard( Activity activity ) {
    InputMethodManager imm = (InputMethodManager)activity.getSystemService( Context.INPUT_METHOD_SERVICE );
    View f = activity.getCurrentFocus();
    if( null != f && null != f.getWindowToken() && EditText.class.isAssignableFrom( f.getClass() ) )
        imm.hideSoftInputFromWindow( f.getWindowToken(), 0 );
    else 
        activity.getWindow().setSoftInputMode( WindowManager.LayoutParams.SOFT_INPUT_STATE_ALWAYS_HIDDEN );
}

ich fast alle diese Antworten versucht haben, ich hatte einige zufällige Probleme vor allem mit dem Samsung Galaxy s5.

Was ich am Ende mit der Show zwingt und zu 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 diese Methoden können Werke außer allen anderen. 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);
        }
    }
}
Lizenziert unter: CC-BY-SA mit Zuschreibung
Nicht verbunden mit StackOverflow
scroll top