android-layout close - Schließen / verbergen Sie die Android Soft-Tastatur




keyboard on (25)

Ich habe einen EditText und einen Button in meinem Layout.

Nach dem Schreiben in das Bearbeitungsfeld und dem Klicken auf die Button 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?


Answers

Ich habe den Fall, wo sich meine EditTextauch in einem befinden kann AlertDialog, 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 );
}

protected void hideSoftKeyboard(EditText input) {
    input.setInputType(0);
    InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
    imm.hideSoftInputFromWindow(input.getWindowToken(), 0);    
}

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

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

So machen Sie es in Mono für Android (AKA MonoDroid)

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

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

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

Dank dieser SO-Antwort habe ich Folgendes abgeleitet, das 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);
    }
}

Ich habe mehr als zwei Tage damit verbracht, alle im Thread veröffentlichten Lösungen durchzuarbeiten und habe festgestellt, dass sie auf die eine oder andere Art und 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. Im sichtbaren Zustand 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 Handys getestet wurden (einschließlich Froyo- und Lebkuchengerä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 eine Markierung 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 der Benutzer in meiner App 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 aufgefordert, 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 dieser Vorgehensweise besteht darin, dass Sie beim Zurücktasten 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.


Wenn alle anderen Antworten hier nicht für Sie funktionieren, können Sie die Tastatur manuell steuern.

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

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

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

EditText Sie dann sicher, dass Sie bei onFocus des 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);

Alternativ zu dieser Rundum-Lösung : Wenn Sie die Soft-Tastatur von überall aus schließen möchten, ohne einen Verweis auf das Feld (EditText) zu haben, das zum Öffnen der Tastatur verwendet wurde, dies jedoch tun wollte, wenn das Feld fokussiert war, können Sie es verwenden dies (aus einer Aktivität):

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

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

if (this.getCurrentFocus() != null) {
    InputMethodManager inputManager = (InputMethodManager) this.getSystemService(Context.INPUT_METHOD_SERVICE);
    inputManager.hideSoftInputFromWindow(this.getCurrentFocus().getWindowToken(), InputMethodManager.HIDE_NOT_ALWAYS);
}

Ich habe eine weitere Lösung zum Verstecken der Tastatur:

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 . Es wird die weiche Tastatur mit Gewalt schließen.


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 Einsatz

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

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

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

Bitte versuche diesen Code in onCreate()

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

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

Was ich am Ende ende, zwingt die Show und das Hide, 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);
}

Das funktionierte für mich bei all dem bizarren Tastaturverhalten

private boolean isKeyboardVisible() {
    Rect r = new Rect();
    //r will be populated with the coordinates of your view that area still visible.
    mRootView.getWindowVisibleDisplayFrame(r);

    int heightDiff = mRootView.getRootView().getHeight() - (r.bottom - r.top);
    return heightDiff > 100; // if more than 100 pixels, its probably a keyboard...
}

protected void showKeyboard() {
    if (isKeyboardVisible())
        return;
    InputMethodManager inputMethodManager = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
    if (getCurrentFocus() == null) {
        inputMethodManager.toggleSoftInput(InputMethodManager.SHOW_FORCED, 0);
    } else {
        View view = getCurrentFocus();
        inputMethodManager.showSoftInput(view, InputMethodManager.SHOW_FORCED);
    }
}

protected void hideKeyboard() {
    if (!isKeyboardVisible())
        return;
    InputMethodManager inputMethodManager = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
    View view = getCurrentFocus();
    if (view == null) {
        if (inputMethodManager.isAcceptingText())
            inputMethodManager.toggleSoftInput(InputMethodManager.HIDE_NOT_ALWAYS, 0);
    } else {
        if (view instanceof EditText)
            ((EditText) view).setText(((EditText) view).getText().toString()); // reset edit text bug on some keyboards bug
        inputMethodManager.hideSoftInputFromInputMethod(view.getWindowToken(), InputMethodManager.HIDE_NOT_ALWAYS);
    }
}

Um diesen Wahnsinn zu klären, möchte ich mich zunächst bei allen Android-Nutzern für die geradezu lächerliche Behandlung der Soft-Tastatur von Google entschuldigen. Der Grund, warum es so viele Antworten gibt, jede für sich, für die gleiche einfache Frage ist, dass diese API, wie viele andere in Android, fürchterlich gestaltet ist. Ich kann mir keine höfliche Art und Weise vorstellen, es auszudrücken.

Ich möchte die Tastatur ausblenden. Ich erwarte, Android die folgende Aussage zu geben: Keyboard.hide() . Das Ende. Vielen Dank. Aber Android hat ein Problem. Sie müssen den InputMethodManager , um die Tastatur auszublenden. OK, gut, das ist die API von Android für die Tastatur. ABER! Sie benötigen einen Context , um auf das IMM zugreifen zu können. Jetzt haben wir ein Problem. Ich möchte die Tastatur vor einer statischen oder Dienstprogrammklasse ausblenden, die keinen Context hat oder benötigt. oder VIEL schlechter ist, dass das IMM verlangt, dass Sie angeben, aus welcher View (oder noch schlimmer, aus welchem Window ) Sie die Tastatur HERAUS ausblenden möchten.

Dies macht das Verstecken der Tastatur so schwierig. Sehr geehrtes Google: Wenn ich nach dem Rezept für einen Kuchen RecipeProvider , gibt es keinen RecipeProvider auf der Erde, der sich weigern würde, mir das Rezept zur Verfügung zu stellen, es sei denn, ich antworte zuerst, WENN der Kuchen von AND gegessen wird und wo er gegessen wird !!

Diese traurige Geschichte endet mit der hässlichen Wahrheit: Um die Android-Tastatur zu verbergen, müssen Sie zwei Formen der Identifikation Context : einen Context und entweder eine View oder ein Window .

Ich habe eine statische Dienstprogrammmethode erstellt, die den Job sehr zuverlässig erledigen kann, vorausgesetzt, Sie rufen sie aus einer Activity .

public static void hideKeyboard(Activity activity) {
    InputMethodManager imm = (InputMethodManager) activity.getSystemService(Activity.INPUT_METHOD_SERVICE);
    //Find the currently focused view, so we can grab the correct window token from it.
    View view = activity.getCurrentFocus();
    //If no view currently has focus, create a new one, just so we can grab a window token from it
    if (view == null) {
        view = new View(activity);
    }
    imm.hideSoftInputFromWindow(view.getWindowToken(), 0);
}

Beachten Sie, dass diese Dienstprogrammmethode NUR beim Aufruf aus einer Activity funktioniert! Die obige Methode ruft getCurrentFocus der getCurrentFocus auf, um das richtige Fenstertoken abzurufen.

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

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

Dies funktioniert nicht, da Sie einen Verweis auf die Host- Activity des Fragment , die keine fokussierte Kontrolle hat, während das Fragment angezeigt wird! Beeindruckend! Um die Tastatur vor Fragmenten zu verstecken, greife ich auf die untergeordnete Ebene, häufiger und hässlicher:

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

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

Über windowSoftInputMode

Es gibt noch einen weiteren Streitpunkt, den Sie beachten sollten. Standardmäßig weist Android dem ersten EditText oder fokussierbaren Steuerelement in Ihrer Activity automatisch den Anfangsfokus zu. Daraus folgt natürlich, dass die InputMethod (normalerweise die Soft-Tastatur) auf das Fokusereignis reagiert, indem sie sich selbst anzeigt. windowSoftInputMode das windowSoftInputMode Attribut in AndroidManifest.xml auf stateAlwaysHidden , weist es die Tastatur an, diesen automatisch zugewiesenen anfänglichen Fokus zu ignorieren.

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

Es scheint fast unglaublich, dass die Tastatur nicht daran focusable="false" beim Berühren des Steuerelements zu focusable="false" (es sei denn, dem Steuerelement sind focusable="false" und / oder focusableInTouchMode="false" zugewiesen). Offenbar gilt die Einstellung windowSoftInputMode nur für automatische Fokusereignisse, nicht für Fokusereignisse, die von Berührungsereignissen ausgelöst werden.

stateAlwaysHidden ist daher SEHR schlecht benannt. Es sollte stattdessen vielleicht ignoreInitialFocus heißen.

Hoffe das hilft.

UPDATE: Weitere Möglichkeiten, ein Fenstertoken zu erhalten

Wenn keine fokussierte Ansicht vorliegt (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.

Innerhalb einer Fragmentklasse:

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

Ein Fragmentfragment als Parameter gegeben:

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

Ausgehend von Ihrem Inhaltskörper:

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

UPDATE 2: Löschen Sie den Fokus, um zu vermeiden, dass die Tastatur erneut angezeigt wird, wenn Sie die App im Hintergrund öffnen

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

view.clearFocus();


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 eine TextView den Fokus erhält. Der Text ist jedoch 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 habe ich mit einem OnGlobalLayoutListener sehr gute Ergebnisse erzielt (aber weit davon entfernt, perfekt zu sein), die mithilfe eines ViewTreeObserver aus meiner Root-Ansicht hinzugefügt wurden und dann prüfte, 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);

Die obigen Antworten funktionieren für verschiedene Szenarien. Wenn Sie jedoch die Tastatur in einer Ansicht ausblenden möchten und versuchen, den richtigen Kontext zu ermitteln, 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();
}

benutze das

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

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

Sie können Android zwingen, die virtuelle Tastatur mit dem InputMethodManager . Rufen Sie hideSoftInputFromWindow und übergeben Sie das Token des Fensters, 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 sollten Sie InputMethodManager.HIDE_IMPLICIT_ONLY als zweiten Parameter übergeben, um sicherzustellen, dass Sie die Tastatur nur ausblenden, wenn der Benutzer sie nicht explizit InputMethodManager.HIDE_IMPLICIT_ONLY (indem Sie das Menü InputMethodManager.HIDE_IMPLICIT_ONLY halten).

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


Die Lösung von Meier 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);
    }
}

Es gibt eine lustige benannte Methode / Konstante / was auch immer in jeder Android-Version.

Die einzige praktische Anwendung, die ich je gesehen habe, war im letzten Aufruf zum Google I / O- Wettbewerb, in dem sie gefragt wurden, was für eine bestimmte Version es ist, um zu sehen, ob die Teilnehmer den API-Diff-Bericht für jede Version lesen. Der Wettbewerb hatte auch Programmierprobleme, aber im Allgemeinen einige Kleinigkeiten, die zuerst automatisch bewertet werden konnten, um die Anzahl der Einsendungen auf vernünftige Beträge zu bringen, die einfacher zu überprüfen wären.





android android-layout android-softkeyboard android-input-method soft-keyboard