web-dev-qa-db-ger.com

Android: Zeigt die Soft-Tastatur automatisch an, wenn der Fokus auf einem EditText liegt

Ich zeige ein Eingabefeld mit AlertDialog. Die EditText im Dialog selbst wird beim Aufruf von AlertDialog.show() automatisch fokussiert, die Soft-Tastatur wird jedoch nicht automatisch angezeigt.

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

androidkeyboardandroid-edittextsoft-keyboard
304
Randy Sugianto 'Yuku'

Sie können einen Fokuslistener auf EditText auf AlertDialog erstellen und dann die AlertDialog von Window abrufen. Von dort aus können Sie die Soft-Tastatur durch Aufruf von setSoftInputMode anzeigen lassen.

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);
        }
    }
});
288
Randy Sugianto 'Yuku'

Um die Tastaturbenutzung anzuzeigen:

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

Sie können eine Soft-Tastatur direkt nach dem Erstellen des Dialogs anfordern (Test mit SDK-r20)

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

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

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 verhält.

// 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();
24
tidbeck

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

InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
imm.toggleSoftInput(InputMethodManager.SHOW_FORCED,0);
22
Jurie Otto
<activity
    ...
    Android:windowSoftInputMode="stateVisible" >
</activity>

oder

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

Codeausschnitte aus anderen Antworten funktionieren, aber es ist nicht immer offensichtlich, wo sie im Code platziert werden sollen. Dies gilt insbesondere, wenn Sie einen AlertDialog.Builder verwenden und das offizielle Dialog-Tutorial befolgt haben, da es final AlertDialog ... oder alertDialog.show() nicht verwendet.

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 ausblenden wird, wenn der Fokus vom EditText abweicht, bleibt SHOW_FORCED so lange angezeigt, bis die Tastatur explizit abgelehnt wird, selbst wenn der Benutzer zum Startbildschirm zurückkehrt oder die zuletzt verwendeten Apps anzeigt.

Nachfolgend finden Sie den Arbeitscode für einen AlertDialog, der mit einem benutzerdefinierten Layout mit einem in XML definierten EditText erstellt wurde. Die Tastatur wird außerdem so eingestellt, dass sie eine "Los" -Taste hat, und ermöglicht das Auslösen der positiven Taste.

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;
    }
}
13
Soren Stoutner

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 sie funktionieren perfekt:

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

Lassen Sie mich einige zusätzliche Informationen zur Lösung von Yuku verweisen, denn es fiel mir schwer, dies zu erreichen! Wie erhalte ich das AlertDialog-Objekt von meinem AlertDialog.Builder? Nun, es ist das Ergebnis meiner Ausführung von alert.show():

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

Werfen Sie einen Blick auf this discussion, in dem der IME manuell verdeckt und angezeigt wird. Ich habe jedoch das Gefühl, dass, wenn ein fokussierter EditText den IME nicht aktiviert, der Grund dafür ist, dass Sie AlertDialog.show() in Ihrer OnCreate() oder einer anderen Methode aufrufen, die aufgerufen wird, bevor der Bildschirm tatsächlich angezeigt wird. Wenn Sie es auf OnPostResume() verschieben, sollte es in diesem Fall meines Erachtens behoben sein.

7
jqpubliq

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

Wenn jemand bekommt:

Es kann keine statische Referenz auf die nicht statische Methode getSystemService (String) vom Typ Aktivität hergestellt werden

Versuchen Sie, context zum Aufruf von getSystemService hinzuzufügen.

So

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

probiere und verwende:

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

Ich habe Nice-kotlin-esqe-Erweiterungsfunktionen erstellt, sofern alle daran interessiert sind

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)
}
1
i am E

Um Tastatur zu zeigen, musste ich für mich Folgendes tun

Android TextField: Fokus programmiert programmieren

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 einer erfolgreichen Eingabe stelle ich auch sicher, dass die Tastatur ausgeblendet wird

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

Das Problem scheint zu sein, dass AlertDialog automatisch das Flag WindowManager.LayoutParams.FLAG_ALT_FOCUSABLE_IM oder WindowManager.LayoutParams.FLAG_NOT_FOCUSABLE setzt, da der Ort, an dem Sie Text eingeben, anfangs ausgeblendet ist (oder verschachtelt oder in etwas anderem), so dass keine weichen Eingaben ausgelöst werden.

Um dies zu beheben, müssen Sie Folgendes hinzufü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);
1
Allan Veloso

Die ursprüngliche Frage bezieht sich auf Dialoge und mein EditText befindet sich in einer regulären Ansicht. Ich vermute jedoch, dass dies für die meisten von Ihnen auch funktionieren sollte. Also hier ist was für mich funktioniert (die oben empfohlene Methode mit der höchsten Bewertung hat nichts für mich getan). Hier ist eine benutzerdefinierte EditView, die dies tut (Unterklassen ist nicht notwendig, aber ich fand es für meine Zwecke bequem, da ich auch den Fokus nehmen wollte, wenn die Ansicht sichtbar wird).

Dies ist im Wesentlichen die gleiche wie die Antwort von tidbecks. Ich bemerkte seine Antwort überhaupt nicht, 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 bei Geräten mit Tastaturen funktioniert. Ich kann bestätigen, dass das Verhalten in beiden Fällen genau gleich zu sein scheint. Das ist so, dass im Hochformat-Modus die Software-Tastatur aufgetaucht wird und in der Landschaft nicht. Das Herausnehmen der physischen Tastatur hat keinen Einfluss auf mein Handy.

Weil ich persönlich das Verhalten etwas unbeholfen 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, aber zumindest auf meinem Gerät wird sie nicht angezeigt, wenn die Hardwaretastatur herausgeschoben 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();
        }
    }

}
1
Timo

Warum diese Antwort - Weil die obige Lösung Ihre Tastatur anzeigt, aber nicht verschwindet, wenn Sie auf eine andere Stelle als EditText klicken. Sie müssen also etwas tun, um das Keybaord verschwinden zu lassen, wenn EditText den Fokus verliert.

Sie können dies durch folgende Schritte erreichen:

  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. Legen Sie zum Schluss den onFocusChangeListener Ihres Edittext fest.

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

Viele ausprobiert, 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()
0
lorenzo

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

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

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 bearbeiteten Text anzuzeigen

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

kotlin code: muss nur edittext.showKeyboard() aufrufen

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);
      }
    });
  }
0
A.easazadeh

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

1.Stellen Sie beim ersten Aufruf den Soft-Input aus dem Fenster. Dadurch wird die Soft-Eingabe ausgeblendet, wenn die Soft-Tastatur sichtbar ist, oder nichts, wenn dies nicht der Fall ist.

2. Zeigen Sie Ihren Dialog an

3. Dann einfach aufrufen, um die Soft-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);
0
FRR

Wie horkavlna schrieb, 

Umschalten

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

und hide -Tastatur

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

methoden arbeiten. Aber show Varianten funktionieren in meinem Fall nicht. Also in onCreate() stelle ich hideKeyboard(editText); in onStart() und schreibe toggleKeyboard(editText); und in onStop() schreibe ich hideKeyboard(editText);.

Es gibt drei Probleme: 

1) Wenn eine Anwendung mit ausgeschaltetem Bildschirm gestartet wird, wird die Tastatur ausgeblendet. 

2) Jedes Mal, wenn Sie den Bildschirm einschalten, wird die Tastatur angezeigt. 

3) Nach Beendigung der Anwendung sehen Sie die Tastatur im Android-Hauptbildschirm.

Nach mehreren Tests entfernte ich diese Methoden und schrieb in AndroidManifest in activity-Tags Android:windowSoftInputMode="stateVisible" oder Android:windowSoftInputMode="stateAlwaysHidden".

0
CoolMind

Das 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>
0
A.A