Android: anzeigen Soft-Tastatur automatisch, wenn der Fokus auf einem EditText

https://stackoverflow.com/questions/2403632

18-09-2019
|

Frage

Ich zeige ein Eingabefeld mit AlertDialog. Die EditText innerhalb des Dialogs selbst wird automatisch fokussiert, wenn ich AlertDialog.show() nennen, aber die Soft-Tastatur wird nicht automatisch angezeigt.

Wie kann ich die Soft-Tastatur wird automatisch angezeigt, wenn der Dialog angezeigt wird? (Und es gibt keine physische / Hardware-Tastatur). Ähnlich wie wenn ich die Suchtaste drücken, um die globale Suche, die Soft-Tastatur aufzurufen automatisch angezeigt.

Lösung

Sie können einen Fokus Zuhörer auf dem EditText auf dem AlertDialog erstellen, dann die AlertDialog des Window bekommen. Von dort können Sie die Soft-Tastatur-Show machen, indem setSoftInputMode aufrufen.

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

Andere Tipps

mit Tastatur Verwendung:

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

Für versteckte Tastatur verwenden:

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

Sie können eine Soft-Tastatur anfordern direkt nach dem Dialog (Test auf SDK - r20) Erstellen

// 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 mir nicht sicher, wie es auf einem Telefon mit Hardware-Tastatur 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 dieses Beispiel gefunden

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

oder

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

Code-Schnipsel aus anderen Antworten arbeiten, aber es ist nicht immer klar, wo sie in dem Code zu setzen, vor allem, wenn Sie eine AlertDialog.Builder verwenden und anschließend das offizieller Dialog Tutorial , weil es nicht verwendet final AlertDialog ... oder 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);

Da SOFT_INPUT_STATE_ALWAYS_VISIBLE die Tastatur ausgeblendet, wenn der Fokus von dem EditText Schalter entfernt, wo SHOW_FORCED die Tastatur hält angezeigt, bis es ausdrücklich zurückgewiesen wird, auch wenn der Benutzer kehrt zum Startbildschirm oder zeigt die zuletzt verwendeten Anwendungen.

Im Folgenden arbeitet Code für eine Alertdialog erstellt ein benutzerdefiniertes Layout mit einer EditText Verwendung in XML definiert. Es setzt auch die Tastatur hat eine „go“ -Taste gedrückt und ermöglicht es, die positive Taste 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, das ist eine ziemlich alte Post, noch gibt es etwas hinzuzufügen
Dies sind zwei einfache Methoden, die mir helfen Tastatur unter Kontrolle zu halten, und sie arbeiten einfach perfekt.

anzeigen Tastatur

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

ausblenden Tastatur

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 auf die Lösung von yuku einige zusätzliche Informationen verweisen, weil ich es schwer zu bekommen diese Arbeit gefunden! Wie bekomme ich das Objekt aus meinem Alertdialog AlertDialog.Builder? Nun, es ist das Ergebnis meiner alert.show() Ausführung:

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

Werfen Sie einen Blick auf diese Diskussion, die manuell behandelt versteckt und das IME zeigt. Allerdings ist mein Gefühl, dass, wenn ein fokussierter EditText nicht die IME Erziehung ist es, weil Sie AlertDialog.show() in Ihrem OnCreate() oder eine andere Methode aufrufen, die evoziert wird, bevor der Bildschirm tatsächlich vorgestellt. Bewegen sie OnPostResume() sollte es beheben in diesem Fall glaube ich.

Ja, Sie mit setOnFocusChangeListener tun können, es 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);
        }
    }
});

Wenn jemand bekommen:

Es kann keine statische Verweis auf die nicht-statische Methode getSystemService (String) vom Typ Aktivität machen

Versuchen Sie, Kontext zu getSystemService Anruf.

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

Die ursprüngliche Frage betrifft Dialoge und meine EditText ist auf einer regulären Ansicht. Wie auch immer, ich vermuten, dass dies auch für die meisten von euch arbeiten sollte. Also hier ist was für mich (die oben vorgeschlagen bestbewertesten Methode tat nichts für mich). Hier ist eine individuelle EditView, das tut dies (Subklassifizieren nicht notwendig ist, aber ich fand es praktisch für meine Zwecke, wie ich den Fokus auch greifen wollte, wenn die Ansicht sichtbar wird).

Dies ist eigentlich weitgehend die gleiche wie die tidbecks beantworten. Ich bemerkte eigentlich nicht seine Antwort auf alles, wie es null bis Stimmen hatte. Dann war ich nur seinen Posten Kommentar, aber es wäre zu lang gewesen, so landete ich sowieso diesen Beitrag zu tun. tidbeck weist darauf hin, dass er sich nicht sicher ist, wie es mit den Geräten, Tastaturen haben. Ich kann bestätigen, dass das Verhalten in beiden Fällen genau gleich zu sein scheint. Dass eine solche ist, dass auf Portrait-Modus wird die Software-Tastatur aufgetaucht und auf die Landschaft nicht. macht keinen Unterschied, auf meinem Handy geschoben oder nicht die physische Tastatur hat.

Weil ich persönlich finde das Verhalten ein wenig umständlich ich für die Verwendung entschieden: InputMethodManager.SHOW_FORCED. Dies funktioniert, wie ich es arbeiten wollte. Die Tastatur sichtbar wird unabhängig von der Ausrichtung, jedoch zumindest auf meinem Gerät nicht hoch ist Pop, wenn die Hardware-Tastatur ist aus geschoben worden ist.

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, dass seit dem Ort, an dem Sie Text eingeben versteckte zunächst (oder verschachtelt oder etwas), wird automatisch die Flag Alertdialog WindowManager.LayoutParams.FLAG_ALT_FOCUSABLE_IM oder WindowManager.LayoutParams.FLAG_NOT_FOCUSABLE Einstellung so, dass die Dinge nicht über einen Soft-Input auslösen zu zeigen.

Die Art und Weise, dies zu beheben, ist folgendes hinzuzufügen:

(...)
// 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 Verwendung:

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

Tastatur zu zeigen, für mich, ich hatte den folgenden

zu tun

Android TextField-: set Fokus + Soft-Input-programmatisch

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 ShowKeyboard ist

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 erfolgreicher Eingabe, ich auch sicher, dass ich die Tastatur verbergen

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

Setzen Sie

diese Methoden in Ihrer Util Klasse und überall verwenden.

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 schöne Kotlin-esqe Erweiterungsfunktionen Incase jemand interessiert ist

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

Das ist eine gute Probe 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 obige Lösung wird Ihre Tastatur zeigen, aber es wird nicht verschwinden, wenn Sie irgendwo anders, dass EditText klicken. Sie müssen also etwas tun, um das zu machen keybaord verschwinden, wenn EditText Fokus verliert.

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

Machen Sie die übergeordnete Ansicht (Inhalt Ansicht Ihrer Aktivität) anklickbar und fokussierbar durch folgende Attribute hinzugefügt
```
    android:clickable="true" 
    android:focusableInTouchMode="true" 
```

Implementieren eines hideKeyboard () Methode

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

Schließlich stellen Sie die onFocusChangeListener Ihrer EditText.

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

Das ist etwas schwierig. Ich habe auf diese Weise und es hat funktioniert.

1.At ersten Aufruf des Soft-Input aus dem Fenster zu verstecken. Dadurch wird den Soft-Input verstecken, wenn die Soft-Tastatur sichtbar ist oder nichts tun, wenn es nicht ist.

2.Show Ihr dialog

3.Then rufen Sie einfach an Soft-Input zu wechseln.

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

Versuchen Sie, diese

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

Versuchen viele, aber das ist, was für mich gearbeitet (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()

Mit Blick auf https://stackoverflow.com/a/39144104/2914140 vereinfachte ich ein bisschen:

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

, weil, wenn Sie Home-Taste drücken und auf dem Startbildschirm bewegen, wird die Tastatur geöffnet bleiben.

Ich weiß, diese Frage ist alt von Ich denke, der als Erweiterung eine schönere Art und Weise ist Tastatur für einen Text bearbeiten zu zeigen

Hier ist die Methode, die ich Tastatur zu zeigen, für eine EditText verwenden.

Kotlin Code: nur müssen edittext.showKeyboard() anrufen

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

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

Ich nenne dies in onCreate () Tastatur automatisch zu zeigen, wenn ich in der Aktivität kam.

Lizenziert unter: CC-BY-SA mit Zuschreibung

Nicht verbunden mit StackOverflow