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




15 Answers

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

on button click

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?




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.




Bitte versuche diesen Code in onCreate()

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



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



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



Die kurze Antwort

OnClick in Ihrem OnClick Listener 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 Drilldown

Diese Methode ist meiner Meinung nach besser, einfacher und eher auf das Designmuster von Android abgestimmt. In dem einfachen Beispiel oben (und normalerweise in den meisten häufigen Fällen) haben Sie einen EditText , der den Fokus hat / hatte, und normalerweise war es auch derjenige, der die Tastatur an erster Stelle EditText (sie kann sie definitiv in aufrufen.) viele gängige Szenarien). Auf dieselbe Weise sollte es die Tastatur sein, die normalerweise von einer ImeAction . Sehen Sie sich einfach an, wie sich ein EditText mit android:imeOptions="actionDone" verhält android:imeOptions="actionDone" , Sie möchten mit den gleichen Mitteln dasselbe Verhalten erzielen.

Überprüfen Sie diese verwandte Antwort




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



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.




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



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 die oben genannten nicht onBackPressed()für die betreffende Aktivität ausgelöst werden . 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 lange genug) ).




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



benutze das

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



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

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



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



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



Related