So zeigen Sie eine Softtastatur an, wenn edittext fokussiert ist

Ich möchte die Soft-Tastatur automatisch anzeigen, wenn eine EditTextfokussiert ist (wenn das Gerät keine physische Tastatur hat), und ich habe zwei Probleme:

1. Wenn my Activityangezeigt wird, ist my EditTextfokussiert, aber die Tastatur wird nicht angezeigt. Ich muss erneut darauf klicken, um die Tastatur anzuzeigen (sie sollte angezeigt werden, wenn my Activityangezeigt wird).

2. Und wenn ich auf der Tastatur auf Fertig klicke, wird die Tastatur nicht angezeigt, aber die Tastatur EditTextbleibt fokussiert und ich möchte nicht (weil meine Bearbeitung abgeschlossen ist).

Um fortzufahren, ist mein Problem, etwas ähnlicheres auf dem iPhone zu haben: das die Tastatur mit meinem EditTextStatus synchronisiert (fokussiert / nicht fokussiert) und natürlich keine Softtastatur präsentiert, wenn es eine physische gibt.

Um das Erscheinen der Softtastatur zu erzwingen, können Sie verwenden

EditText yourEditText= (EditText) findViewById(R.id.yourEditText);
yourEditText.requestFocus();
InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
imm.showSoftInput(yourEditText, InputMethodManager.SHOW_IMPLICIT);

Und um den Fokus zu entfernen EditText, benötigen Sie leider einen DummyView , um den Fokus zu erhalten.

ich hoffe das hilft

Zum Schließen können Sie verwenden

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

Dies funktioniert für die Verwendung in einem Dialogfeld

public void showKeyboard(){
    InputMethodManager inputMethodManager = (InputMethodManager) context.getSystemService(Context.INPUT_METHOD_SERVICE);
    inputMethodManager.toggleSoftInput(InputMethodManager.SHOW_FORCED, 0);
}

public void closeKeyboard(){
    InputMethodManager inputMethodManager = (InputMethodManager) context.getSystemService(Context.INPUT_METHOD_SERVICE);
    inputMethodManager.toggleSoftInput(InputMethodManager.HIDE_IMPLICIT_ONLY, 0);
}

Ich hatte das gleiche Problem. Unmittelbar nach dem Wechsel von editText VISIBILITY von GONE zu VISIBLE musste ich den Fokus einstellen und die Softtastatur anzeigen. Ich habe dies mit dem folgenden Code erreicht:

new Handler().postDelayed(new Runnable() {

    public void run() {
//        ((EditText) findViewById(R.id.et_find)).requestFocus();
//              
        EditText yourEditText= (EditText) findViewById(R.id.et_find);
//        InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
//        imm.showSoftInput(yourEditText, InputMethodManager.SHOW_IMPLICIT);

        yourEditText.dispatchTouchEvent(MotionEvent.obtain(SystemClock.uptimeMillis(), SystemClock.uptimeMillis(), MotionEvent.ACTION_DOWN , 0, 0, 0));
        yourEditText.dispatchTouchEvent(MotionEvent.obtain(SystemClock.uptimeMillis(), SystemClock.uptimeMillis(), MotionEvent.ACTION_UP , 0, 0, 0));                           
    }
}, 200);

Es funktioniert bei mir mit einer Verzögerung von 100 ms, ist jedoch ohne Verzögerung oder nur mit einer Verzögerung von 1 ms fehlgeschlagen.

Der kommentierte Teil des Codes zeigt einen anderen Ansatz, der nur auf einigen Geräten funktioniert. Ich habe auf den Betriebssystemversionen 2.2 (Emulator), 2.2.1 (echtes Gerät) und 1.6 (Emulator) getestet.

Dieser Ansatz ersparte mir viel Schmerz.

Verwenden Sie, um die Tastatur anzuzeigen

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

Diese Methode ist zuverlässiger als das direkte Aufrufen des InputMethodManager.

Verwenden Sie zum Schließen die Option

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

Wenn nichts anderes funktioniert, erzwingen Sie die Anzeige :

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

Und später, wenn Sie es schließen möchten, beispielsweise in onPause (), können Sie Folgendes aufrufen:

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

Der folgende Code stammt aus dem 4.1-Quellcode von Google für SearchView. Scheint zu funktionieren, auch bei kleineren Android-Versionen.

private Runnable mShowImeRunnable = new Runnable() {
    public void run() {
        InputMethodManager imm = (InputMethodManager) getContext()
                .getSystemService(Context.INPUT_METHOD_SERVICE);

        if (imm != null) {
            imm.showSoftInput(editText, 0);
        }
    }
};

private void setImeVisibility(final boolean visible) {
    if (visible) {
        post(mShowImeRunnable);
    } else {
        removeCallbacks(mShowImeRunnable);
        InputMethodManager imm = (InputMethodManager) getContext()
                .getSystemService(Context.INPUT_METHOD_SERVICE);

        if (imm != null) {
            imm.hideSoftInputFromWindow(getWindowToken(), 0);
        }
    }
}

Außerdem muss beim Erstellen der Steuerung / Aktivität der folgende Code hinzugefügt werden. (In meinem Fall handelt es sich eher um ein zusammengesetztes Steuerelement als um eine Aktivität).

this.editText.setOnFocusChangeListener(new View.OnFocusChangeListener() {
    public void onFocusChange(View v, boolean hasFocus) {
        setImeVisibility(hasFocus);
    }
});

android:windowSoftInputMode="stateAlwaysVisible" -> in Manifestdatei.

edittext.requestFocus(); -> im Code.

Dadurch wird die Softtastatur geöffnet, auf der der Bearbeitungstext den Anforderungsfokus hat, wenn die Aktivität angezeigt wird.

Ich hatte in letzter Zeit in einigen einfachen Fällen Glück mit dem folgenden Code. Ich habe noch nicht alle Tests beendet, aber ...

EditText input = (EditText) findViewById(R.id.Input);
input.requestFocus();    
input.dispatchTouchEvent(MotionEvent.obtain(SystemClock.uptimeMillis(), SystemClock.uptimeMillis(), MotionEvent.ACTION_DOWN , 0, 0, 0));
input.dispatchTouchEvent(MotionEvent.obtain(SystemClock.uptimeMillis(), SystemClock.uptimeMillis(), MotionEvent.ACTION_UP , 0, 0, 0));

Und schon wird die Tastatur angezeigt.

Sie können versuchen, das Anzeigen der Softtastatur zu erzwingen. Dies funktioniert bei mir:

...
dialog.show();
input.requestFocus();
InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
imm.toggleSoftInput(InputMethodManager.SHOW_FORCED, 0);

Manchmal funktioniert die Antwort von Raukodraug nicht. Ich habe es auf diese Weise mit einigen Versuchen und Fehlern gemacht:

public static void showKeyboard(Activity activity) {
    if (activity != null) {
        activity.getWindow()
                .setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_STATE_ALWAYS_VISIBLE);
    }
}

public static void hideKeyboard(Activity activity) {
    if (activity != null) {
        activity.getWindow()
                .setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_STATE_ALWAYS_HIDDEN);
    }
}

Und der EditText- Teil:

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

Verwenden Sie diese Option, um die Tastatur auszublenden:

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

und Tastatur zu zeigen:

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

Und für Kotlin verwenden Sie einfach diese Erweiterungen:

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

fun EditText.hideKeyboard() {
    val imm = context.getSystemService(Context.INPUT_METHOD_SERVICE) as InputMethodManager
    imm.hideSoftInputFromWindow(this.windowToken, 0)
}

Stellen Sie sicher, dass das Fragment funktioniert:

 displayName = (EditText) view.findViewById(R.id.displayName);
    InputMethodManager imm = (InputMethodManager) getActivity().getSystemService(Context.INPUT_METHOD_SERVICE);
    imm.toggleSoftInput(InputMethodManager.SHOW_FORCED, 0);

showSoftInput arbeitete überhaupt nicht für mich.

Ich dachte, ich müsste den Eingabemodus einstellen: (hier in der Aktivitätskomponente im Manifest)

android:windowSoftInputMode="stateVisible" 

Ob Sie es glauben oder nicht, mein Problem mit der Soft-Tastatur wurde behoben, als ich feststellte, dass die Animationen für Aktivitäten die Soft-Tastatur deaktivieren können. Wenn Sie die Absicht mit dem anrufen

i.setFlags(Intent.FLAG_ACTIVITY_NO_ANIMATION);

und

overridePendingTransition(0, 0);

Es kann die Soft-Tastatur ausblenden und es gibt keine Möglichkeit, sie anzuzeigen.

Ich hatte das gleiche Problem in verschiedenen Situationen, und die Lösungen, die ich gefunden habe, funktionieren in einigen, funktionieren aber in anderen nicht. Hier ist eine kombinierte Lösung, die in den meisten Situationen funktioniert, die ich gefunden habe:

public static void showVirtualKeyboard(Context context, final View view) {
    if (context != null) {
        final InputMethodManager imm =  (InputMethodManager) context.getSystemService(Context.INPUT_METHOD_SERVICE);
        view.clearFocus();

        if(view.isShown()) {
            imm.showSoftInput(view, 0);
            view.requestFocus();
        } else {
            view.addOnAttachStateChangeListener(new View.OnAttachStateChangeListener() {
                @Override
                public void onViewAttachedToWindow(View v) {
                    view.post(new Runnable() {
                        @Override
                        public void run() {
                            view.requestFocus();
                            imm.showSoftInput(view, 0);
                        }
                    });

                    view.removeOnAttachStateChangeListener(this);
                }

                @Override
                public void onViewDetachedFromWindow(View v) {
                    view.removeOnAttachStateChangeListener(this);
                }
            });
        }
    }
}

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

Ich habe hier alles kombiniert und für mich funktioniert es:

public static void showKeyboardWithFocus(View v, Activity a) {
    try {
        v.requestFocus();
        InputMethodManager imm = (InputMethodManager) a.getSystemService(Context.INPUT_METHOD_SERVICE);
        imm.showSoftInput(v, InputMethodManager.SHOW_IMPLICIT);
        a.getWindow().setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_STATE_VISIBLE);
    } catch (Exception e) {
        e.printStackTrace();
    }
}

Es hat bei mir funktioniert. Sie können damit auch versuchen, die Tastatur anzuzeigen:

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

Code-Auszug . . .

public void hideKeyboard(Context activityContext){

    InputMethodManager imm = (InputMethodManager)
            activityContext.getSystemService(Context.INPUT_METHOD_SERVICE);

    //android.R.id.content ( http://stackoverflow.com/a/12887919/2077479 )
    View rootView = ((Activity) activityContext)
            .findViewById(android.R.id.content).getRootView();

    imm.hideSoftInputFromWindow(rootView.getWindowToken(), 0);
}

public void showKeyboard(Context activityContext, final EditText editText){

    final InputMethodManager imm = (InputMethodManager)
            activityContext.getSystemService(Context.INPUT_METHOD_SERVICE);

    if (!editText.hasFocus()) {
        editText.requestFocus();
    }

    editText.post(new Runnable() {
        @Override
        public void run() {
            imm.showSoftInput(editText, InputMethodManager.SHOW_FORCED);
        }
    });
}

Kotlin Erweiterung zum Anzeigen der Tastatur im Fokus.

Dies ist eine Kombination früherer Antworten, die entweder zu lang oder unvollständig waren.

Diese Erweiterung stellt eine ausführbare Datei in der Nachrichtenwarteschlange bereit, die nach Anforderung des Fokus die Softtastatur anzeigt:

fun View.showSoftKeyboard() {
    post {
        if (this.requestFocus()) {
            val imm = context.getSystemService(Context.INPUT_METHOD_SERVICE) as InputMethodManager
            imm?.showSoftInput(this, InputMethodManager.SHOW_IMPLICIT)
        }
    }
}

Rufen Sie es bei Bedarf aus einer beliebigen Ansicht auf:

editText.showSoftKeyboard()

füge einfach android hinzu: windowSoftInputMode = "stateHidden" in der Manifestdatei ...

final InputMethodManager keyboard = (InputMethodManager) ctx.getSystemService(Context.INPUT_METHOD_SERVICE);
keyboard.toggleSoftInput(InputMethodManager.SHOW_FORCED,0);

In Ihrem Manifest:

android:windowSoftInputMode="stateAlwaysVisible"- ursprünglich gestartete Tastatur. android:windowSoftInputMode="stateAlwaysHidden" - zunächst versteckte Tastatur.

Ich benutze es auch gerne, "adjustPan"weil sich der Bildschirm beim Starten der Tastatur automatisch anpasst.

 <activity
      android:name="YourActivity"
      android:windowSoftInputMode="stateAlwaysHidden|adjustPan"/>

Fügen Sie einfach diese Zeile in Ihre EditText-Ansicht ein:

android:isScrollContainer="true"

und TADA - Tastatur wurde automatisch angezeigt!

Ich hatte ein ähnliches Problem und entdeckte diese einfache und seltsame Lösung.

Wie hier bereits von user3392439 erwähnt, ist das Erscheinen der Tastatur beim Fokussieren irgendwie seltsam mit der Anwesenheit der Bildlaufkomponente in der XML-Datei verbunden.

Selbst wenn eine andere EditText-Ansicht vorhanden ist, die eine der oben genannten Zeilen in demselben XML enthält, wird die Tastatur angezeigt, unabhängig davon, auf welche EditTexts-Version gerade fokussiert ist.

Wenn Ihre XML-Datei mindestens eine sichtbare Ansicht mit einer Bildlaufkomponente enthält, wird die Tastatur automatisch im Fokus angezeigt.

Wenn kein Bildlauf erfolgt, müssen Sie auf EditText klicken, damit die Tastatur angezeigt wird.

Alle oben angegebenen Lösungen ( InputMethodManager- Interaktion im OnFocusChangeListener.onFocusChange- Listener, der an Ihren EditText angehängt ist funktioniert wenn Sie eine einzelne Bearbeitung in der Aktivität haben.

In meinem Fall habe ich zwei Änderungen.

 private EditText tvX, tvY;
 protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
 tvX.setOnFocusChangeListener(this);
    tvY.setOnFocusChangeListener(this);

@Override
public void onFocusChange(View v, boolean hasFocus) {       
    InputMethodManager imm =  (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
    if(tvX.hasFocus() || tvY.hasFocus()) {            
        imm.showSoftInput(v, 0);            
    } else {
        imm.hideSoftInputFromWindow(v.getWindowToken(), 0);         
    }       
};

Ich habe beobachtet, dass onFocusChange für tvX mit hasFocus = true (Tastatur gezeigt) ausgelöst wird, dann aber für tvY mit hasFocus = true (Tastatur ausgeblendet). Am Ende war keine Tastatur sichtbar.

Die allgemeine Lösung sollte die richtige Aussage enthalten, wenn "Tastatur anzeigen, wenn EditText-Text den Fokus hat".

In Ihrem Abschnitt onResume () der Aktivität können Sie die Methode bringKeyboard () aufrufen.

 onResume() {
     EditText yourEditText= (EditText) findViewById(R.id.yourEditText);
     bringKeyboard(yourEditText);
 }


  protected boolean bringKeyboard(EditText view) {
    if (view == null) {
        return false;
    }
    try {
      // Depending if edittext has some pre-filled values you can decide whether to bring up soft keyboard or not
        String value = view.getText().toString();
        if (value == null) {
            InputMethodManager imm = (InputMethodManager)context.getSystemService(Context.INPUT_METHOD_SERVICE);
            imm.hideSoftInputFromWindow(view.getWindowToken(), 0);
            return true;
        }
    } catch (Exception e) {
        Log.e(TAG, "decideFocus. Exception", e);
    }
    return false;
  }

Keine der Antworten hat bei mir funktioniert. Hier ist ein einfacher Weg.

searchEditText.setVisibility(View.VISIBLE);
                final Handler handler=new Handler();
                handler.postDelayed(new Runnable() {
                    @Override
                    public void run() {
                        searchEditText.requestFocus();
                    }
                }, 400);

Ich habe gerade die requestFocus () -Methode um 400 ms verzögert.

Ich habe ein seltsames Verhalten festgestellt, da in einer meiner Apps die Softtastatur beim Aufrufen der Aktivität automatisch angezeigt wurde (in onCreate befindet sich eine editText.requestFocus ()).

Beim weiteren Graben stellte ich fest, dass dies daran liegt, dass sich um das Layout eine ScrollView befindet. Wenn ich die ScrollView entferne, ist das Verhalten wie in der ursprünglichen Problembeschreibung beschrieben: Nur beim Klicken auf den bereits fokussierten editText wird die Softtastatur angezeigt.

Wenn es bei Ihnen nicht funktioniert, versuchen Sie es mit einer ScrollView - es ist sowieso harmlos.

Ich hatte ein ähnliches Problem bei der Verwendung von Ansichtsanimationen . Daher habe ich einen Animations-Listener eingerichtet, um sicherzustellen, dass ich auf das Ende der Animation warte, bevor ich versuche, einen Tastaturzugriff auf den angezeigten Edittext anzufordern.

    bottomUp.setAnimationListener(new Animation.AnimationListener() {
        @Override
        public void onAnimationStart(Animation animation) {
        }

        @Override
        public void onAnimationEnd(Animation animation) {
            if (textToFocus != null) {
                // Position cursor at the end of the text
                textToFocus.setSelection(textToFocus.getText().length());
                // Show keyboard
                InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
                imm.showSoftInput(textToFocus, InputMethodManager.SHOW_IMPLICIT);
            }
        }

        @Override
        public void onAnimationRepeat(Animation animation) {
        }
    });

Ich bin damit einverstanden, dass Raukodraug dafür in einer Swithview verwendet wird, die Sie wie folgt anfordern / klar fokussieren müssen:

    final ViewSwitcher viewSwitcher = (ViewSwitcher) findViewById(R.id.viewSwitcher);
    final View btn = viewSwitcher.findViewById(R.id.address_btn);
    final View title = viewSwitcher.findViewById(R.id.address_value);

    title.setOnClickListener(new View.OnClickListener() {
        @Override
        public void onClick(View view) {
            viewSwitcher.showPrevious();
            btn.requestFocus();
            InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
            imm.showSoftInput(btn, InputMethodManager.SHOW_IMPLICIT);
        }
    });

    // EditText affiche le titre evenement click
    btn.setOnClickListener(new View.OnClickListener() {
        @Override
        public void onClick(View view) {
            btn.clearFocus();
            viewSwitcher.showNext();
            InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
            imm.hideSoftInputFromWindow(btn.getWindowToken(), 0);
            // Enregistre l'adresse.
            addAddress(view);
        }
    });

Grüße.