Android: Weiche Tastatur automatisch anzeigen, wenn der Fokus auf einem EditText liegt

Ich zeige ein Eingabefeld mit AlertDialog. Das EditTextInnere des Dialogfelds selbst wird automatisch fokussiert, wenn ich anrufe AlertDialog.show(), aber die Softtastatur wird nicht automatisch angezeigt.

Wie kann ich die Softtastatur automatisch anzeigen lassen, wenn der Dialog angezeigt wird? (und es gibt keine physische / Hardware-Tastatur). Ähnlich wie beim Drücken der Suchtaste zum Aufrufen der globalen Suche wird die Softtastatur automatisch angezeigt.

Sie können einen Fokus-Listener für das EditTextOn erstellen AlertDialogund dann das AlertDialog's abrufenWindow . Von dort aus können Sie die Softtastatur anzeigen lassen, indem Sie anrufen setSoftInputMode.

final AlertDialog dialog = ...;

editText.setOnFocusChangeListener(new View.OnFocusChangeListener() {
    @Override
    public void onFocusChange(View v, boolean hasFocus) {
        if (hasFocus) {
            dialog.getWindow().setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_STATE_ALWAYS_VISIBLE);
        }
    }
});

Zum Anzeigen der Tastatur:

InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
imm.toggleSoftInput(InputMethodManager.SHOW_FORCED,0);

Zum Ausblenden der Tastatur verwenden Sie:

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

Sie können direkt nach dem Erstellen des Dialogfelds eine Softtastatur anfordern (Test auf SDK - r20).

// create dialog
final AlertDialog dialog = ...; 

// request keyboard   
dialog.getWindow().setSoftInputMode (WindowManager.LayoutParams.SOFT_INPUT_STATE_ALWAYS_VISIBLE);

Ich hatte das gleiche Problem und löste es mit dem folgenden Code. Ich bin nicht sicher, wie es sich auf einem Telefon mit Hardwaretastatur verhalten wird.

// TextEdit
final EditText textEdit = new EditText(this);

// Builder
AlertDialog.Builder alert = new AlertDialog.Builder(this);
alert.setTitle("Enter text");
alert.setView(textEdit);

alert.setPositiveButton("Ok", new DialogInterface.OnClickListener() {
    @Override
    public void onClick(DialogInterface dialog, int which) {
        String text = textEdit.getText().toString();
        finish();
    }
});

alert.setNegativeButton("Cancel", new DialogInterface.OnClickListener() {
    @Override
    public void onClick(DialogInterface dialog, int which) {
        finish();
    }
});

// Dialog
AlertDialog dialog = alert.create();
dialog.setOnShowListener(new OnShowListener() {

    @Override
    public void onShow(DialogInterface dialog) {
        InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
        imm.showSoftInput(textEdit, InputMethodManager.SHOW_IMPLICIT);
    }
});

dialog.show();

Ich habe dieses Beispiel gefunden: http://android-codes-examples.blogspot.com/2011/11/show-or-hide-soft-keyboard-on-opening.html . Fügen Sie kurz zuvor den folgenden Code hinzu alert.show().

InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
imm.toggleSoftInput(InputMethodManager.SHOW_FORCED,0);

<activity
    ...
    android:windowSoftInputMode="stateVisible" >
</activity>

oder

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

Codeausschnitte aus anderen Antworten funktionieren, aber es ist nicht immer klar, wo sie im Code platziert werden sollen, insbesondere wenn Sie ein verwenden AlertDialog.Builderund dem offiziellen Dialog-Tutorial folgen, weil es nicht final AlertDialog ...oder verwendet alertDialog.show().

alertDialog.getWindow().setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_STATE_ALWAYS_VISIBLE);

Ist vorzuziehen

InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
imm.toggleSoftInput(InputMethodManager.SHOW_FORCED,0);

Weil SOFT_INPUT_STATE_ALWAYS_VISIBLE die Tastatur ausblendet, wenn der Fokus vom EditText abweicht, wobei SHOW_FORCED die Tastatur so lange anzeigt, bis sie explizit geschlossen wird, selbst wenn der Benutzer zum Startbildschirm zurückkehrt oder die letzten Apps anzeigt.

Unten finden Sie Arbeitscode für einen AlertDialog, der mithilfe eines benutzerdefinierten Layouts mit einem in XML definierten EditText erstellt wurde. Außerdem wird die Tastatur so eingestellt, dass sie eine "Go" -Taste hat, und die positive Taste kann ausgelöst werden.

alert_dialog.xml:

<RelativeLayout
android:id="@+id/dialogRelativeLayout"
xmlns:android="http://schemas.android.com/apk/res/android"
android:layout_width="match_parent"
android:layout_height="wrap_content" >

    <!-- android:imeOptions="actionGo" sets the keyboard to have a "go" key instead of a "new line" key. -->
    <!-- android:inputType="textUri" disables spell check in the EditText and changes the "go" key from a check mark to an arrow. -->
    <EditText
        android:id="@+id/editText"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:layout_marginTop="16dp"
        android:layout_marginLeft="4dp"
        android:layout_marginRight="4dp"
        android:layout_marginBottom="16dp"
        android:imeOptions="actionGo"
        android:inputType="textUri"/>

</RelativeLayout>

AlertDialog.java:

import android.app.Activity;
import android.app.Dialog;
import android.content.DialogInterface;
import android.graphics.drawable.BitmapDrawable;
import android.graphics.drawable.Drawable;
import android.os.Bundle;
import android.support.annotation.NonNull;
import android.support.v4.app.DialogFragment;
import android.support.v7.app.AlertDialog;
import android.support.v7.app.AppCompatDialogFragment;
import android.view.KeyEvent;
import android.view.LayoutInflater;
import android.view.View;
import android.view.WindowManager;
import android.widget.EditText;

public class CreateDialog extends AppCompatDialogFragment {
    // The public interface is used to send information back to the activity that called CreateDialog.
    public interface CreateDialogListener {
        void onCreateDialogCancel(DialogFragment dialog);    
        void onCreateDialogOK(DialogFragment dialog);
    }

    CreateDialogListener mListener;

    // Check to make sure that the activity that called CreateDialog implements both listeners.
    public void onAttach(Activity activity) {
        super.onAttach(activity);
        try {
            mListener = (CreateDialogListener) activity;
        } catch (ClassCastException e) {
            throw new ClassCastException(activity.toString() + " must implement CreateDialogListener.");
        }
    }

    // onCreateDialog requires @NonNull.
    @Override
    @NonNull
    public Dialog onCreateDialog(Bundle savedInstanceState) {
        AlertDialog.Builder alertDialogBuilder = new AlertDialog.Builder(getActivity());
        LayoutInflater customDialogInflater = getActivity().getLayoutInflater();

        // Setup dialogBuilder.
        alertDialogBuilder.setTitle(R.string.title);
        alertDialogBuilder.setView(customDialogInflater.inflate(R.layout.alert_dialog, null));
        alertDialogBuilder.setNegativeButton(R.string.cancel, new DialogInterface.OnClickListener() {
            @Override
            public void onClick(DialogInterface dialog, int which) {
                mListener.onCreateDialogCancel(CreateDialog.this);
            }
        });
        alertDialogBuilder.setPositiveButton(R.string.ok, new DialogInterface.OnClickListener() {
            @Override
            public void onClick(DialogInterface dialog, int which) {
                mListener.onCreateDialogOK(CreateDialog.this);
            }
        });

        // Assign the resulting built dialog to an AlertDialog.
        final AlertDialog alertDialog = alertDialogBuilder.create();

        // Show the keyboard when the dialog is displayed on the screen.
        alertDialog.getWindow().setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_STATE_ALWAYS_VISIBLE);

        // We need to show alertDialog before we can setOnKeyListener below.
        alertDialog.show();

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

        // Allow the "enter" key on the keyboard to execute "OK".
        editText.setOnKeyListener(new View.OnKeyListener() {
            public boolean onKey(View v, int keyCode, KeyEvent event) {
                // If the event is a key-down event on the "enter" button, select the PositiveButton "OK".
                if ((event.getAction() == KeyEvent.ACTION_DOWN) && (keyCode == KeyEvent.KEYCODE_ENTER)) {
                    // Trigger the create listener.
                    mListener.onCreateDialogOK(CreateDialog.this);

                    // Manually dismiss alertDialog.
                    alertDialog.dismiss();

                    // Consume the event.
                    return true;
                } else {
                    // If any other key was pressed, do not consume the event.
                    return false;
                }
            }
        });

        // onCreateDialog requires the return of an AlertDialog.
        return alertDialog;
    }
}

Nun, dies ist ein ziemlich alter Beitrag, aber es gibt noch etwas hinzuzufügen.
Dies sind zwei einfache Methoden, mit denen ich die Tastatur unter Kontrolle halten kann und die perfekt funktionieren:

Tastatur anzeigen

public void showKeyboard() {
    InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
    View v = getCurrentFocus();
    if (v != null)
        imm.showSoftInput(v, 0);
}

Tastatur ausblenden

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

Lassen Sie mich einige zusätzliche Informationen zur Lösung von Yuku geben, da ich es schwierig fand, dies zum Laufen zu bringen! Wie erhalte ich das AlertDialog-Objekt von meinem AlertDialog.Builder? Nun, es ist das Ergebnis meiner alert.show()Hinrichtung:

final AlertDialog.Builder alert = new AlertDialog.Builder(getActivity());
final EditText input = new EditText(getActivity());
alert.setView(input);

// do what you need, like setting positive and negative buttons...

final AlertDialog dialog = alert.show();

input.setOnFocusChangeListener(new OnFocusChangeListener() {
   @Override
   public void onFocusChange(View v, boolean hasFocus) {
      if(hasFocus) {
         dialog.getWindow().setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_STATE_ALWAYS_VISIBLE);
      }
   }
});

Schauen Sie sich diese Diskussion an, in der das IME manuell ausgeblendet und angezeigt wird. Ich habe jedoch das Gefühl, dass ein fokussierter EditTextIME nicht angezeigt wird, weil Sie AlertDialog.show()Ihre OnCreate()oder eine andere Methode aufrufen, die aufgerufen wird, bevor der Bildschirm tatsächlich angezeigt wird. Wenn Sie es verschieben, OnPostResume()sollte es in diesem Fall behoben sein, glaube ich.

Ja, Sie können damit tun setOnFocusChangeListener, wird Ihnen helfen.

editText.setOnFocusChangeListener(new View.OnFocusChangeListener() {
    @Override
    public void onFocusChange(View v, boolean hasFocus) {
        if (hasFocus) {
            dialog.getWindow().setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_STATE_ALWAYS_VISIBLE);
        }
    }
});

Ich weiß, dass diese Frage alt ist, da ich denke, dass die Verwendung einer Erweiterungsfunktion eine schönere Möglichkeit ist, die Tastatur für einen Bearbeitungstext anzuzeigen

Hier ist die Methode, mit der ich die Tastatur für einen Edittext zeige.

Kotlin-Code: Ich muss nur anrufenedittext.showKeyboard()

fun EditText.showKeyboard() {
  post {
    requestFocus()
    val imm = context.getSystemService(Context.INPUT_METHOD_SERVICE) as InputMethodManager
    imm.showSoftInput(this, InputMethodManager.SHOW_IMPLICIT)
  }
}

der Java-Code:

public static void showKeyboard(EditText editText) {
    editText.post(new Runnable() {
      @Override
      public void run() {
        editText.requestFocus();
        InputMethodManager imm = (InputMethodManager) editText.getContext()
            .getSystemService(Context.INPUT_METHOD_SERVICE);
        imm.showSoftInput(editText, InputMethodManager.SHOW_IMPLICIT);
      }
    });
  }

Wenn jemand bekommt:

Es kann kein statischer Verweis auf die nicht statische Methode getSystemService (String) vom Typ Activity erstellt werden

Versuchen Sie, dem getSystemService-Aufruf einen Kontext hinzuzufügen.

Damit

InputMethodManager imm = 
(InputMethodManager) context.getSystemService(Context.INPUT_METHOD_SERVICE);
imm.toggleSoftInput(InputMethodManager.SHOW_FORCED,0);

Die ursprüngliche Frage betrifft Dialoge und mein EditText wird regelmäßig angezeigt. Jedenfalls vermute ich, dass dies auch für die meisten von Ihnen funktionieren sollte. Hier ist also, was für mich funktioniert (die oben vorgeschlagene Methode mit der höchsten Bewertung hat nichts für mich getan). Hier ist eine benutzerdefinierte EditView, die dies tut (Unterklassen sind nicht erforderlich, aber ich fand es für meine Zwecke praktisch, da ich auch den Fokus erfassen wollte, wenn die Ansicht sichtbar wird).

Dies ist eigentlich weitgehend das gleiche wie die Antwort der Leckerbissen. Ich habe seine Antwort überhaupt nicht bemerkt, da sie null Stimmen hatte. Dann wollte ich gerade seinen Beitrag kommentieren, aber es wäre zu lang gewesen, also habe ich diesen Beitrag trotzdem beendet. tidbeck weist darauf hin, dass er sich nicht sicher ist, wie es mit Geräten mit Tastatur funktioniert. Ich kann bestätigen, dass das Verhalten in beiden Fällen genau das gleiche zu sein scheint. Dies bedeutet, dass im Hochformat die Softwaretastatur angezeigt wird und im Querformat nicht. Das Herausrutschen der physischen Tastatur macht auf meinem Telefon keinen Unterschied.

Weil ich persönlich das Verhalten etwas umständlich fand, entschied ich mich für : InputMethodManager.SHOW_FORCED. Das funktioniert so, wie ich es wollte. Die Tastatur wird unabhängig von der Ausrichtung sichtbar. Zumindest auf meinem Gerät wird sie jedoch nicht angezeigt, wenn die Hardwaretastatur herausgezogen wurde.

import android.app.Service;
import android.content.Context;
import android.util.AttributeSet;
import android.view.View;
import android.view.inputmethod.InputMethodManager;
import android.widget.EditText;

public class BringOutTheSoftInputOnFocusEditTextView extends EditText {

    protected InputMethodManager inputMethodManager;

    public BringOutTheSoftInputOnFocusEditTextView(Context context, AttributeSet attrs, int defStyle) {
        super(context, attrs, defStyle);
        init();
    }

    public BringOutTheSoftInputOnFocusEditTextView(Context context, AttributeSet attrs) {
        super(context, attrs);
        init();
    }

    public BringOutTheSoftInputOnFocusEditTextView(Context context) {
        super(context);
        init();
    }

    private void init() {
        this.inputMethodManager = (InputMethodManager)getContext().getSystemService(Service.INPUT_METHOD_SERVICE);
        this.setOnFocusChangeListener(new View.OnFocusChangeListener() {
            @Override
            public void onFocusChange(View v, boolean hasFocus) {
                if (hasFocus) {
                    BringOutTheSoftInputOnFocusEditTextView.this.inputMethodManager.showSoftInput(BringOutTheSoftInputOnFocusEditTextView.this, InputMethodManager.SHOW_FORCED);
                }
            }
        });
    }

    @Override
    protected void onVisibilityChanged(View changedView, int visibility) {
        super.onVisibilityChanged(changedView, visibility);
        if (visibility == View.VISIBLE) {
            BringOutTheSoftInputOnFocusEditTextView.this.requestFocus();
        }
    }

}

Das Problem scheint zu sein, dass AlertDialog, da die Stelle, an der Sie Text eingeben, anfänglich ausgeblendet ist (oder verschachtelt ist oder so), automatisch das Flag setzt WindowManager.LayoutParams.FLAG_ALT_FOCUSABLE_IModer WindowManager.LayoutParams.FLAG_NOT_FOCUSABLEso, dass keine weiche Eingabe ausgelöst wird.

Um dies zu beheben, fügen Sie Folgendes hinzu:

(...)
// Create the dialog and show it
Dialog dialog = builder.create()
dialog.show();

// After show (this is important specially if you have a list, a pager or other view that uses a adapter), clear the flags and set the soft input mode
dialog.getWindow().clearFlags(WindowManager.LayoutParams.FLAG_NOT_FOCUSABLE|WindowManager.LayoutParams.FLAG_ALT_FOCUSABLE_IM);
dialog.getWindow().setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_STATE_ALWAYS_VISIBLE);

versuchen und verwenden:

editText.requestFocus();
InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
imm.toggleSoftInput(InputMethodManager.SHOW_FORCED, InputMethodManager.HIDE_IMPLICIT_ONLY);

Um die Tastatur zu zeigen, musste ich Folgendes tun

Android TextField: Fokus + Soft Input programmgesteuert einstellen

Im Wesentlichen ist die Lösung die folgende

@Override
public void onResume() {
    super.onResume();
    //passwordInput.requestFocus(); <-- that doesn't work
    passwordInput.postDelayed(new ShowKeyboard(), 325); //250 sometimes doesn't run if returning from LockScreen
}

Wo ShowKeyboardist

private class ShowKeyboard implements Runnable {
    @Override
    public void run() {
        passwordInput.setFocusableInTouchMode(true);
        //passwordInput.requestFocusFromTouch(); //this gives touch event to launcher in background -_-
        passwordInput.requestFocus();
        getActivity().getWindow().setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_STATE_ALWAYS_VISIBLE);
        ((InputMethodManager) getActivity().getSystemService(Context.INPUT_METHOD_SERVICE)).showSoftInput(passwordInput, 0);
    }
}

Nach einer erfolgreichen Eingabe stelle ich auch sicher, dass ich die Tastatur verstecke

getActivity().getWindow().setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_STATE_HIDDEN);
((InputMethodManager) getActivity().getSystemService(Context.INPUT_METHOD_SERVICE))
                    .hideSoftInputFromWindow(getView().getWindowToken(), 0);

Fügen Sie diese Methoden in Ihre Util-Klasse ein und verwenden Sie sie überall.

Kotlin

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

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

Java

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

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

Ich habe nette kotlin-esqe-Erweiterungsfunktionen erstellt, falls sich jemand dafür interessiert

fun Activity.hideKeyBoard() {
    val view = this.currentFocus
    val methodManager = this.getSystemService(Context.INPUT_METHOD_SERVICE) as InputMethodManager
    assert(view != null)
    methodManager.hideSoftInputFromWindow(view!!.windowToken, InputMethodManager.HIDE_NOT_ALWAYS)
}

fun Activity.showKeyboard() {
    val view = this.currentFocus
    val methodManager = this.getSystemService(Context.INPUT_METHOD_SERVICE) as InputMethodManager
    assert(view != null)
    methodManager.showSoftInput(view, InputMethodManager.SHOW_IMPLICIT)
}

Dies ist ein gutes Beispiel für Sie:

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="vertical" >

    <ScrollView
        android:id="@+id/scrollID"
        android:layout_width="fill_parent"
        android:layout_height="0dip"
        android:layout_weight="1" >

        <LinearLayout
            android:id="@+id/test"
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:orientation="vertical" >
        </LinearLayout>
    </ScrollView>

    <LinearLayout
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:baselineAligned="true"
        android:orientation="horizontal"
        android:paddingBottom="5dp"
        android:paddingLeft="5dp"
        android:paddingRight="5dp"
        android:weightSum="1" >

        <EditText
            android:id="@+id/txtInpuConversation"
            android:layout_width="0dip"
            android:layout_height="wrap_content"
            android:layout_weight="0.5"
            android:hint="@string/edt_Conversation" >

            <requestFocus />
        </EditText>

        <Button
            android:id="@+id/btnSend"
            android:layout_width="0dip"
            android:layout_height="wrap_content"
            android:layout_weight="0.5"
            android:text="@string/btn_Conversation" />
    </LinearLayout>

</LinearLayout>

Warum diese Antwort - Weil die obige Lösung Ihre Tastatur anzeigt, aber nicht verschwindet, wenn Sie auf eine andere Stelle klicken EditText. Sie müssen also etwas tun, damit das Keybaord verschwindet, wenn EditTextder Fokus verloren geht.

Sie können dies erreichen, indem Sie die folgenden Schritte ausführen:

1. Machen Sie die übergeordnete Ansicht (Inhaltsansicht Ihrer Aktivität) anklickbar und fokussierbar, indem Sie die folgenden Attribute hinzufügen

       android:clickable="true" 
       android:focusableInTouchMode="true" 

2. Implementieren Sie eine hideKeyboard () -Methode

       public void hideKeyboard(View view) {
           InputMethodManager inputMethodManager =(InputMethodManager)getSystemService(Activity.INPUT_METHOD_SERVICE);
           inputMethodManager.hideSoftInputFromWindow(view.getWindowToken(),InputMethodManager.HIDE_IMPLICIT_ONLY );
       }

3. Zuletzt legen Sie den onFocusChangeListener Ihres Edittextes fest.

       edittext.setOnFocusChangeListener(new View.OnFocusChangeListener() {
           @Override
           public void onFocusChange(View v, boolean hasFocus) {
               if (!hasFocus) {
                   hideKeyboard(v);
               }
           }
       });

Das ist etwas knifflig. Ich habe es so gemacht und es hat funktioniert.

1. Beim ersten Aufruf, um die weiche Eingabe aus dem Fenster auszublenden. Dadurch wird die weiche Eingabe ausgeblendet, wenn die weiche Tastatur sichtbar ist, oder es wird nichts unternommen, wenn dies nicht der Fall ist.

2. Zeigen Sie Ihren Dialog

3. Rufen Sie dann einfach auf, um die weiche Eingabe umzuschalten.

Code:

InputMethodManager inputManager = (InputMethodManager)getSystemService(Context.INPUT_METHOD_SERVICE); 
//hiding soft input
inputManager.hideSoftInputFromWindow(findViewById(android.R.id.content).getWind‌​owToken(), 0);
//show dialog
yourDialog.show();
//toggle soft input
inputManager.toggleSoftInput(InputMethodManager.SHOW_FORCED,InputMethodManager.SHOW_IMPLICIT);

Versuche dies

SomeUtils.java

public static void showKeyboard(Activity activity, boolean show) {
    InputMethodManager inputMethodManager = (InputMethodManager) activity.getSystemService(Context.INPUT_METHOD_SERVICE);

    if(show)
        inputMethodManager.toggleSoftInput(InputMethodManager.SHOW_FORCED,0);
    else
        inputMethodManager.toggleSoftInput(InputMethodManager.HIDE_IMPLICIT_ONLY,0);
}

Versuchte viele, aber das hat bei mir funktioniert (kotlin):

        val dialog = builder.create()
        dialog.setOnShowListener {
            nameEditText.requestFocus()
            val s = ContextCompat.getSystemService(requireContext(), InputMethodManager::class.java)
            s?.toggleSoftInput(InputMethodManager.SHOW_FORCED, 0)
        }

        dialog.setOnDismissListener {
            val s = ContextCompat.getSystemService(requireContext(), InputMethodManager::class.java)
            s?.toggleSoftInput(InputMethodManager.HIDE_IMPLICIT_ONLY, 0)
        }

        dialog.show()

Unter https://stackoverflow.com/a/39144104/2914140 habe ich etwas vereinfacht:

// In onCreateView():
view.edit_text.run {
    requestFocus()
    post { showKeyboard(this) }
}

fun showKeyboard(view: View) {
    val imm = view.context.getSystemService(
        Context.INPUT_METHOD_SERVICE) as InputMethodManager?
    imm?.showSoftInput(view, InputMethodManager.SHOW_IMPLICIT)
}

Es ist besser als https://stackoverflow.com/a/11155404/2914140 :

InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
imm.toggleSoftInput(InputMethodManager.SHOW_FORCED, 0);

Wenn Sie die Home-Taste drücken und zum Startbildschirm wechseln, bleibt die Tastatur geöffnet.

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

Ich rufe dies in onCreate () auf, um die Tastatur automatisch anzuzeigen, wenn ich in die Aktivität kam.