Ich habe eine EditText
und eine Button
in meinem Layout.
Nachdem Sie in das Editierfeld geschrieben und auf Button
geklickt haben, möchte ich die virtuelle Tastatur ausblenden. Ich gehe davon aus, dass dies ein einfacher Code ist, aber wo finde ich ein Beispiel dafür?
Um diesen Wahnsinn zu klären, möchte ich mich zunächst im Namen aller Android Nutzer für Googles geradezu lächerliche Behandlung der Softtastatur entschuldigen. Der Grund, warum es so viele unterschiedliche Antworten auf dieselbe einfache Frage gibt, ist, dass diese API, wie viele andere in Android, fürchterlich gestaltet ist. Ich kann mir keinen höflichen Weg vorstellen, es auszudrücken.
Ich möchte die Tastatur verstecken. Ich erwarte, Android mit der folgenden Anweisung zu versehen: Keyboard.hide()
. Das Ende. Vielen Dank. Aber Android hat ein Problem. Sie müssen InputMethodManager
verwenden, um die Tastatur auszublenden. OK, gut, das ist die Android-API für die Tastatur. ABER! Sie benötigen ein Context
, um auf das IMM zugreifen zu können. Jetzt haben wir ein Problem. Möglicherweise möchte ich die Tastatur vor einer statischen oder Utility-Klasse verbergen, die keine Context
verwendet oder benötigt. oder Und noch viel schlimmer, das IMM verlangt, dass Sie angeben, vor welchem View
(oder noch schlimmer, welchem Window
) Sie die Tastatur verbergen möchten.
Das ist es, was das Verstecken der Tastatur so schwierig macht. Sehr geehrte Google, wenn ich das Rezept für einen Kuchen suche, gibt es auf der Erde kein RecipeProvider
, das mir das Rezept verweigern würde, es sei denn, ich antworte zuerst, WER den Kuchen gegessen hat UND wo er sein wird gegessen!!
Diese traurige Geschichte endet mit der hässlichen Wahrheit: Um die Android Tastatur zu verbergen, müssen Sie zwei Arten der Identifizierung angeben: eine Context
und entweder eine View
oder eine Window
.
Ich habe eine statische Dienstprogrammmethode erstellt, die die Aufgabe SEHR zuverlässig erledigen kann, vorausgesetzt, Sie rufen sie von einem Activity
auf.
public static void hideKeyboard(Activity activity) {
InputMethodManager imm = (InputMethodManager) activity.getSystemService(Activity.INPUT_METHOD_SERVICE);
//Find the currently focused view, so we can grab the correct window token from it.
View view = activity.getCurrentFocus();
//If no view currently has focus, create a new one, just so we can grab a window token from it
if (view == null) {
view = new View(activity);
}
imm.hideSoftInputFromWindow(view.getWindowToken(), 0);
}
Beachten Sie, dass diese Dienstprogrammmethode NUR funktioniert, wenn sie von einem Activity
aufgerufen wird! Die obige Methode ruft getCurrentFocus
des Ziels Activity
auf, um das richtige Fenstertoken abzurufen.
Angenommen, Sie möchten die Tastatur vor einem EditText
verbergen, das sich in einem DialogFragment
befindet. Sie können die obige Methode dafür nicht verwenden:
hideKeyboard(getActivity()); //won't work
Dies funktioniert nicht, da Sie einen Verweis auf den Fragment
-Host Activity
übergeben, der keine fokussierte Steuerung hat, während Fragment
angezeigt wird! Beeindruckend! Um die Tastatur vor Fragmenten zu verbergen, greife ich auf die niedrigere, häufigere und hässlichere Ebene zurück:
public static void hideKeyboardFrom(Context context, View view) {
InputMethodManager imm = (InputMethodManager) context.getSystemService(Activity.INPUT_METHOD_SERVICE);
imm.hideSoftInputFromWindow(view.getWindowToken(), 0);
}
Im Folgenden finden Sie einige zusätzliche Informationen, die Sie erhalten, wenn Sie mehr Zeit damit verschwenden, diese Lösung zu suchen:
Über windowSoftInputMode
Es gibt noch einen weiteren Streitpunkt, dessen man sich bewusst sein muss. Standardmäßig weist Android dem ersten EditText
oder fokussierbaren Steuerelement in Ihrem Activity
automatisch den anfänglichen Fokus zu. Daraus folgt natürlich, dass die Eingabemethode (normalerweise die Soft-Tastatur) auf das Fokusereignis reagiert, indem sie sich selbst anzeigt. Wenn das windowSoftInputMode
-Attribut in AndroidManifest.xml
auf stateAlwaysHidden
gesetzt ist, wird die Tastatur angewiesen, diesen automatisch zugewiesenen anfänglichen Fokus zu ignorieren.
<activity
Android:name=".MyActivity"
Android:windowSoftInputMode="stateAlwaysHidden"/>
Es ist kaum zu glauben, dass das Öffnen der Tastatur beim Berühren des Steuerelements nicht verhindert wird (es sei denn, dem Steuerelement sind focusable="false"
und/oder focusableInTouchMode="false"
zugewiesen). Anscheinend gilt die Einstellung windowSoftInputMode nur für automatische Fokusereignisse, nicht für durch Berührungsereignisse ausgelöste Fokusereignisse.
Daher ist stateAlwaysHidden
in der Tat SEHR schlecht benannt. Es sollte stattdessen vielleicht ignoreInitialFocus
heißen.
Hoffe das hilft.
PDATE: Weitere Möglichkeiten, ein Fenstertoken zu erhalten
Wenn es keine fokussierte Ansicht gibt (z. B. wenn Sie gerade Fragmente geändert haben), gibt es andere Ansichten, die ein nützliches Fenstertoken liefern.
Dies sind Alternativen für den obigen Code if (view == null) view = new View(activity);
Diese beziehen sich nicht explizit auf Ihre Aktivität.
In einer Fragmentklasse:
view = getView().getRootView().getWindowToken();
Ein Fragment fragment
als Parameter gegeben:
view = fragment.getView().getRootView().getWindowToken();
Ausgehend von Ihrem Inhaltskörper:
view = findViewById(Android.R.id.content).getRootView().getWindowToken();
PDATE 2: Deaktivieren Sie den Fokus, um zu vermeiden, dass die Tastatur erneut angezeigt wird, wenn Sie die App über den Hintergrund öffnen.
Fügen Sie diese Zeile am Ende der Methode hinzu:
view.clearFocus();
Sie können Android dazu zwingen, die virtuelle Tastatur mithilfe des Befehls InputMethodManager , Aufruf von hideSoftInputFromWindow
auszublenden, indem Sie das Token des Fensters übergeben, das Ihre fokussierte Ansicht enthält.
// Check if no view has focus:
View view = this.getCurrentFocus();
if (view != null) {
InputMethodManager imm = (InputMethodManager)getSystemService(Context.INPUT_METHOD_SERVICE);
imm.hideSoftInputFromWindow(view.getWindowToken(), 0);
}
Dadurch wird die Tastatur in allen Situationen ausgeblendet. In einigen Fällen möchten Sie InputMethodManager.HIDE_IMPLICIT_ONLY
als zweiten Parameter übergeben, um sicherzustellen, dass Sie die Tastatur nur ausblenden, wenn der Benutzer sie nicht explizit erzwungen hat (durch Halten des Menüs).
Hinweis: Wenn Sie dies in Kotlin tun möchten, verwenden Sie: context?.getSystemService(Context.INPUT_METHOD_SERVICE) as InputMethodManager
Kotlin-Syntax
// Check if no view has focus:
val view = this.currentFocus
view?.let { v ->
val imm = getSystemService(Context.INPUT_METHOD_SERVICE) as? InputMethodManager
imm?.let { it.hideSoftInputFromWindow(v.windowToken, 0) }
}
Auch zum Ausblenden der Soft-Tastatur ist Folgendes hilfreich:
getWindow().setSoftInputMode(
WindowManager.LayoutParams.SOFT_INPUT_STATE_ALWAYS_HIDDEN
);
Dies kann verwendet werden, um die Soft-Tastatur zu unterdrücken, bis der Benutzer die editText-Ansicht tatsächlich berührt.
Ich habe eine weitere Lösung, um die Tastatur zu verbergen:
InputMethodManager imm = (InputMethodManager) getSystemService(Activity.INPUT_METHOD_SERVICE);
imm.toggleSoftInput(InputMethodManager.HIDE_IMPLICIT_ONLY, 0);
Hier übergeben Sie HIDE_IMPLICIT_ONLY
an der Position von showFlag
und 0
an der Position von hiddenFlag
. Die Soft-Tastatur wird mit Gewalt geschlossen.
Meiers Lösung funktioniert auch für mich. In meinem Fall ist die oberste Ebene meiner App ein tabHost, und ich möchte das Schlüsselwort ausblenden, wenn Sie zwischen Registerkarten wechseln. Ich erhalte das Fenstertoken aus der tabHost-Ansicht.
tabHost.setOnTabChangedListener(new OnTabChangeListener() {
public void onTabChanged(String tabId) {
InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
imm.hideSoftInputFromWindow(tabHost.getApplicationWindowToken(), 0);
}
}
Bitte versuche diesen Code in onCreate()
.
EditText edtView=(EditText)findViewById(R.id.editTextConvertValue);
edtView.setInputType(0);
Update: Ich weiß nicht, warum diese Lösung nicht mehr funktioniert (ich habe gerade auf Android 23 getestet). Bitte verwenden Sie stattdessen die Lösung von Saurabh Pareek . Hier ist es:
InputMethodManager imm = (InputMethodManager) getSystemService(Activity.INPUT_METHOD_SERVICE);
//Hide:
imm.toggleSoftInput(InputMethodManager.HIDE_IMPLICIT_ONLY, 0);
//Show
imm.toggleSoftInput(InputMethodManager.SHOW_IMPLICIT, 0);
Alte Antwort:
//Show soft-keyboard:
getWindow().setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_STATE_ALWAYS_VISIBLE);
//hide keyboard :
getWindow().setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_STATE_ALWAYS_HIDDEN);
protected void hideSoftKeyboard(EditText input) {
InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
imm.hideSoftInputFromWindow(input.getWindowToken(), 0);
}
Wenn alle anderen Antworten hier nicht für Sie funktionieren, können Sie die Tastatur manuell steuern.
Erstellen Sie eine Funktion, mit der einige der EditText
-Eigenschaften verwaltet werden:
public void setEditTextFocus(boolean isFocused) {
searchEditText.setCursorVisible(isFocused);
searchEditText.setFocusable(isFocused);
searchEditText.setFocusableInTouchMode(isFocused);
if (isFocused) {
searchEditText.requestFocus();
}
}
Stellen Sie dann sicher, dass Sie bei onFocus der EditText
die Tastatur öffnen/schließen:
searchEditText.setOnFocusChangeListener(new OnFocusChangeListener() {
@Override
public void onFocusChange(View v, boolean hasFocus) {
if (v == searchEditText) {
if (hasFocus) {
// Open keyboard
((InputMethodManager) context.getSystemService(Context.INPUT_METHOD_SERVICE)).showSoftInput(searchEditText, InputMethodManager.SHOW_FORCED);
} else {
// Close keyboard
((InputMethodManager) context.getSystemService(Context.INPUT_METHOD_SERVICE)).hideSoftInputFromWindow(searchEditText.getWindowToken(), 0);
}
}
}
});
Wenn Sie nun die Tastatur manuell öffnen möchten, rufen Sie Folgendes auf:
setEditTextFocus(true);
Und zum Schlußruf:
setEditTextFocus(false);
Saurabh Pareek hat bisher die beste Antwort.
Könnte aber auch die korrekten Flaggen verwenden.
/* hide keyboard */
((InputMethodManager) getSystemService(Activity.INPUT_METHOD_SERVICE))
.toggleSoftInput(InputMethodManager.SHOW_IMPLICIT, 0);
/* show keyboard */
((InputMethodManager) getSystemService(Activity.INPUT_METHOD_SERVICE))
.toggleSoftInput(0, InputMethodManager.HIDE_IMPLICIT_ONLY);
Beispiel für den realen Gebrauch
/* click button */
public void onClick(View view) {
/* hide keyboard */
((InputMethodManager) getSystemService(Activity.INPUT_METHOD_SERVICE))
.toggleSoftInput(InputMethodManager.SHOW_IMPLICIT, 0);
/* start loader to check parameters ... */
}
/* loader finished */
public void onLoadFinished(Loader<Object> loader, Object data) {
/* parameters not valid ... */
/* show keyboard */
((InputMethodManager) getSystemService(Activity.INPUT_METHOD_SERVICE))
.toggleSoftInput(0, InputMethodManager.HIDE_IMPLICIT_ONLY);
/* parameters valid ... */
}
von dieser Suche habe ich hier eine Antwort gefunden, die für mich funktioniert
// Show soft-keyboard:
InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
imm.toggleSoftInput(InputMethodManager.SHOW_FORCED, 0);
// Hide soft-keyboard:
getWindow().setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_STATE_ALWAYS_HIDDEN);
Rufen Sie in Ihrem OnClick
-Listener das onEditorAction
des EditText
mit IME_ACTION_DONE
auf
button.setOnClickListener(new OnClickListener() {
@Override
public void onClick(View v) {
someEditText.onEditorAction(EditorInfo.IME_ACTION_DONE)
}
});
Ich denke, diese Methode ist besser, einfacher und besser auf das Designmuster von Android abgestimmt. In dem einfachen Beispiel oben (und normalerweise in den meisten häufigen Fällen) haben Sie eine EditText
, die den Fokus hatte/hatte und dies normalerweise auch war Die Tastatur wird in erster Linie aufgerufen (sie kann sie definitiv in vielen gängigen Szenarien aufrufen). Auf dieselbe Art und Weise sollte it die Tastatur freigeben, die normalerweise von einer ImeAction
ausgeführt werden kann. Sie müssen nur sehen, wie sich ein EditText
mit Android:imeOptions="actionDone"
verhält. Sie möchten dasselbe Verhalten mit den gleichen Mitteln erreichen.
Überprüfen Sie diese bezogene Antwort
Das sollte funktionieren:
public class KeyBoard {
public static void show(Activity activity){
InputMethodManager imm = (InputMethodManager) activity.getSystemService(Activity.INPUT_METHOD_SERVICE);
imm.toggleSoftInput(0, InputMethodManager.HIDE_IMPLICIT_ONLY); // show
}
public static void hide(Activity activity){
InputMethodManager imm = (InputMethodManager) activity.getSystemService(Activity.INPUT_METHOD_SERVICE);
imm.toggleSoftInput(InputMethodManager.HIDE_IMPLICIT_ONLY, 0); // hide
}
public static void toggle(Activity activity){
InputMethodManager imm = (InputMethodManager) activity.getSystemService(Activity.INPUT_METHOD_SERVICE);
if (imm.isActive()){
hide(activity);
} else {
show(activity);
}
}
}
KeyBoard.toggle(activity);
Ich verwende eine benutzerdefinierte Tastatur, um eine Hex-Nummer einzugeben, sodass die IMM-Tastatur nicht angezeigt werden kann.
In v3.2.4_r1 wurde setSoftInputShownOnFocus(boolean show)
hinzugefügt, um das Wetter zu steuern oder die Tastatur nicht anzuzeigen, wenn ein TextView den Fokus erhält, aber es ist immer noch ausgeblendet, sodass die Reflektion verwendet werden muss:
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.HONEYCOMB_MR2) {
try {
Method method = TextView.class.getMethod("setSoftInputShownOnFocus", boolean.class);
method.invoke(mEditText, false);
} catch (Exception e) {
// Fallback to the second method
}
}
Bei älteren Versionen erhielt ich sehr gute Ergebnisse (aber weit davon entfernt, perfekt zu sein), mit einer OnGlobalLayoutListener
, die mithilfe einer ViewTreeObserver
aus meiner Root-Ansicht hinzugefügt wurde. Anschließend wurde überprüft, ob die Tastatur folgendermaßen angezeigt wird:
@Override
public void onGlobalLayout() {
Configuration config = getResources().getConfiguration();
// Dont allow the default keyboard to show up
if (config.keyboardHidden != Configuration.KEYBOARDHIDDEN_YES) {
InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
imm.hideSoftInputFromWindow(mRootView.getWindowToken(), 0);
}
}
Diese letzte Lösung kann die Tastatur für einen Sekundenbruchteil anzeigen und die Auswahlgriffe durcheinanderbringen.
Wenn auf der Tastatur der Vollbildschirm angezeigt wird, wird onGlobalLayout nicht aufgerufen. Um dies zu vermeiden, verwenden Sie TextView # setImeOptions (int) oder in der XML-Deklaration von TextView:
Android:imeOptions="actionNone|actionUnspecified|flagNoFullscreen|flagNoExtractUi"
Update: Ich habe gerade gefunden, was Dialoge verwenden, um die Tastatur nie anzuzeigen, und funktioniert in allen Versionen:
getWindow().setFlags(WindowManager.LayoutParams.FLAG_ALT_FOCUSABLE_IM,
WindowManager.LayoutParams.FLAG_ALT_FOCUSABLE_IM);
public void setKeyboardVisibility(boolean show) {
InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
if(show){
imm.toggleSoftInput(InputMethodManager.SHOW_FORCED, 0);
}else{
imm.hideSoftInputFromWindow(getCurrentFocus().getWindowToken(),0);
}
}
Ich habe mehr als zwei Tage damit verbracht, alle im Thread veröffentlichten Lösungen durchzuarbeiten, und ich habe festgestellt, dass sie auf die eine oder andere Weise fehlen. Meine genaue Anforderung ist, eine Schaltfläche zu haben, die die Bildschirmtastatur mit 100% iger Zuverlässigkeit anzeigen oder ausblenden kann. Wenn sich die Tastatur in ausgeblendetem Zustand befindet, sollte sie nicht erneut angezeigt werden, unabhängig davon, welche Eingabefelder der Benutzer anklickt. Wenn es sichtbar ist, sollte die Tastatur nicht verschwinden, unabhängig davon, welche Schaltflächen der Benutzer anklickt. Dies muss auf Android 2.2 und den neuesten Geräten bis zu den neuesten Geräten funktionieren.
Sie können eine funktionierende Implementierung davon in meiner App clean RPN sehen.
Nachdem viele der vorgeschlagenen Antworten auf verschiedenen Telefonen getestet wurden (einschließlich Froyo- und Gingerbread-Geräten), stellte sich heraus, dass Android-Apps zuverlässig funktionieren können:
Für mich reicht das temporäre Verstecken der Tastatur nicht aus. Bei einigen Geräten wird es erneut angezeigt, sobald ein neues Textfeld fokussiert ist. Da meine App mehrere Textfelder auf einer Seite verwendet, fokussiert ein neues Textfeld die verborgene Tastatur wieder.
Leider sind die Punkte 2 und 3 der Liste nur dann zuverlässig, wenn eine Aktivität gestartet wird. Sobald die Aktivität sichtbar ist, können Sie die Tastatur nicht dauerhaft ausblenden oder anzeigen. Der Trick besteht darin, Ihre Aktivität tatsächlich neu zu starten, wenn der Benutzer die Tastaturumschalttaste drückt. Wenn in meiner App der Benutzer auf die umschaltbare Tastaturtaste drückt, wird der folgende Code ausgeführt:
private void toggleKeyboard(){
if(keypadPager.getVisibility() == View.VISIBLE){
Intent i = new Intent(this, MainActivity.class);
i.addFlags(Intent.FLAG_ACTIVITY_NO_ANIMATION);
Bundle state = new Bundle();
onSaveInstanceState(state);
state.putBoolean(SHOW_KEYBOARD, true);
i.putExtras(state);
startActivity(i);
}
else{
Intent i = new Intent(this, MainActivity.class);
i.addFlags(Intent.FLAG_ACTIVITY_NO_ANIMATION);
Bundle state = new Bundle();
onSaveInstanceState(state);
state.putBoolean(SHOW_KEYBOARD, false);
i.putExtras(state);
startActivity(i);
}
}
Dadurch wird der Status der aktuellen Aktivität in einem Bundle gespeichert. Anschließend wird die Aktivität gestartet, wobei ein Boolean durchlaufen wird, der angibt, ob die Tastatur angezeigt oder verborgen werden soll.
In der onCreate-Methode wird der folgende Code ausgeführt:
if(bundle.getBoolean(SHOW_KEYBOARD)){
((InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE)).showSoftInput(newEquationText,0);
getWindow().setSoftInputMode(LayoutParams.SOFT_INPUT_STATE_ALWAYS_VISIBLE);
}
else{
getWindow().setFlags(WindowManager.LayoutParams.FLAG_ALT_FOCUSABLE_IM,
WindowManager.LayoutParams.FLAG_ALT_FOCUSABLE_IM);
}
Wenn die Soft-Tastatur angezeigt werden soll, wird der InputMethodManager angewiesen, die Tastatur anzuzeigen, und das Fenster wird aufgefordert, die Soft-Eingabe immer sichtbar zu machen. Wenn die Soft-Tastatur ausgeblendet werden soll, wird der WindowManager.LayoutParams.FLAG_ALT_FOCUSABLE_IM gesetzt.
Dieser Ansatz funktioniert zuverlässig auf allen Geräten, auf denen ich getestet habe - von einem 4 Jahre alten HTC-Telefon mit Android 2.2 bis zu einem Nexus 7 mit 4.2.2. Der einzige Nachteil bei diesem Ansatz besteht darin, dass Sie beim Umgang mit der Rücktaste vorsichtig sein müssen. Da meine App im Wesentlichen nur einen Bildschirm (einen Taschenrechner) hat, kann ich onBackPressed () überschreiben und zum Startbildschirm des Geräts zurückkehren.
Alternativ zu diese Rundum-Lösung , wenn Sie die Soft-Tastatur von einer beliebigen Stelle aus schließen möchten, ohne einen Verweis auf das Feld (EditText) zu haben, das zum Öffnen der Tastatur verwendet wurde, dies aber dennoch tun würde, wenn Das Feld war fokussiert, Sie können dies (aus einer Aktivität) verwenden:
if (getCurrentFocus() != null) {
InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
imm.hideSoftInputFromWindow(getCurrentFocus().getWindowToken(), 0);
}
Dank dieser SO Antwort habe ich Folgendes abgeleitet, was in meinem Fall beim Scrollen durch die Fragmente eines ViewPagers gut funktioniert ...
private void hideKeyboard() {
// Check if no view has focus:
View view = this.getCurrentFocus();
if (view != null) {
InputMethodManager inputManager = (InputMethodManager) this.getSystemService(Context.INPUT_METHOD_SERVICE);
inputManager.hideSoftInputFromWindow(view.getWindowToken(), InputMethodManager.HIDE_NOT_ALWAYS);
}
}
private void showKeyboard() {
// Check if no view has focus:
View view = this.getCurrentFocus();
if (view != null) {
InputMethodManager inputManager = (InputMethodManager) this.getSystemService(Context.INPUT_METHOD_SERVICE);
inputManager.showSoftInput(view, InputMethodManager.SHOW_IMPLICIT);
}
}
Die obigen Antworten funktionieren für verschiedene Szenarien, aber Wenn Sie die Tastatur in einer Ansicht ausblenden möchten und versuchen, den richtigen Kontext zu erhalten, versuchen Sie Folgendes:
setOnClickListener(new OnClickListener() {
@Override
public void onClick(View v) {
hideSoftKeyBoardOnTabClicked(v);
}
}
private void hideSoftKeyBoardOnTabClicked(View v) {
if (v != null && context != null) {
InputMethodManager imm = (InputMethodManager) context.getSystemService(Context.INPUT_METHOD_SERVICE);
imm.hideSoftInputFromWindow(v.getApplicationWindowToken(), InputMethodManager.HIDE_NOT_ALWAYS);
}
}
und um den Kontext vom Konstruktor abzurufen :)
public View/RelativeLayout/so and so (Context context, AttributeSet attrs, int defStyle) {
super(context, attrs, defStyle);
this.context = context;
init();
}
Wenn Sie die Softtastatur während eines Geräte- oder Funktionstests schließen möchten, klicken Sie in Ihrem Test auf die Schaltfläche "Zurück".
// Close the soft keyboard from a Test
getInstrumentation().sendKeyDownUpSync(KeyEvent.KEYCODE_BACK);
Ich füge "Anführungszeichen" in Anführungszeichen ein, da das oben genannte die onBackPressed()
für die betreffende Aktivität nicht auslöst. Es schließt nur die Tastatur.
Stellen Sie sicher, dass Sie eine kurze Pause einlegen, bevor Sie fortfahren, da das Schließen der Zurück-Schaltfläche einige Zeit dauert. Nachfolgende Klicks auf Ansichten usw. werden erst nach einer kurzen Pause registriert (1 Sekunde ist lang genug ).
So geht's in Mono für Android (AKA MonoDroid)
InputMethodManager imm = GetSystemService (Context.InputMethodService) as InputMethodManager;
if (imm != null)
imm.HideSoftInputFromWindow (searchbox.WindowToken , 0);
Fügen Sie Ihrer Aktivität Android:windowSoftInputMode="stateHidden"
in der Manifestdatei hinzu. Beispiel:
<activity
Android:name=".ui.activity.MainActivity"
Android:label="@string/mainactivity"
Android:windowSoftInputMode="stateHidden"/>
Dies funktionierte für mich bei all dem bizarren Verhalten der Tastatur
private boolean isKeyboardVisible() {
Rect r = new Rect();
//r will be populated with the coordinates of your view that area still visible.
mRootView.getWindowVisibleDisplayFrame(r);
int heightDiff = mRootView.getRootView().getHeight() - (r.bottom - r.top);
return heightDiff > 100; // if more than 100 pixels, its probably a keyboard...
}
protected void showKeyboard() {
if (isKeyboardVisible())
return;
InputMethodManager inputMethodManager = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
if (getCurrentFocus() == null) {
inputMethodManager.toggleSoftInput(InputMethodManager.SHOW_FORCED, 0);
} else {
View view = getCurrentFocus();
inputMethodManager.showSoftInput(view, InputMethodManager.SHOW_FORCED);
}
}
protected void hideKeyboard() {
if (!isKeyboardVisible())
return;
InputMethodManager inputMethodManager = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
View view = getCurrentFocus();
if (view == null) {
if (inputMethodManager.isAcceptingText())
inputMethodManager.toggleSoftInput(InputMethodManager.HIDE_NOT_ALWAYS, 0);
} else {
if (view instanceof EditText)
((EditText) view).setText(((EditText) view).getText().toString()); // reset edit text bug on some keyboards bug
inputMethodManager.hideSoftInputFromInputMethod(view.getWindowToken(), InputMethodManager.HIDE_NOT_ALWAYS);
}
}
Für meinen Fall habe ich eine SearchView in der Aktionsleiste verwendet. Nachdem ein Benutzer eine Suche ausgeführt hat, öffnet sich die Tastatur erneut.
Mit dem InputMethodManager wurde die Tastatur nicht geschlossen. Ich musste clearFocus einstellen und den Fokus der Suchansicht auf false setzen:
mSearchView.clearFocus();
mSearchView.setFocusable(false);
Ich habe fast alle diese Antworten ausprobiert, ich hatte einige zufällige Probleme, insbesondere mit der Samsung Galaxy S5.
Was ich am Ende erhalte, ist das Zeigen und Verbergen, und es funktioniert perfekt:
/**
* Force show softKeyboard.
*/
public static void forceShow(@NonNull Context context) {
InputMethodManager imm = (InputMethodManager) context.getSystemService(Context.INPUT_METHOD_SERVICE);
imm.toggleSoftInput(InputMethodManager.SHOW_FORCED, 0);
}
/**
* Force hide softKeyboard.
*/
public static void forceHide(@NonNull Activity activity, @NonNull EditText editText) {
if (activity.getCurrentFocus() == null || !(activity.getCurrentFocus() instanceof EditText)) {
editText.requestFocus();
}
InputMethodManager imm = (InputMethodManager) activity.getSystemService(Context.INPUT_METHOD_SERVICE);
imm.hideSoftInputFromWindow(editText.getWindowToken(), 0);
activity.getWindow().setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_STATE_ALWAYS_HIDDEN);
}
In einigen Fällen können diese Methoden mit Ausnahme aller anderen funktionieren. Das spart meinen Tag :)
public static void hideSoftKeyboard(Activity activity) {
if (activity != null) {
InputMethodManager inputManager = (InputMethodManager) activity.getSystemService(Context.INPUT_METHOD_SERVICE);
if (activity.getCurrentFocus() != null && inputManager != null) {
inputManager.hideSoftInputFromWindow(activity.getCurrentFocus().getWindowToken(), 0);
inputManager.hideSoftInputFromInputMethod(activity.getCurrentFocus().getWindowToken(), 0);
}
}
}
public static void hideSoftKeyboard(View view) {
if (view != null) {
InputMethodManager inputManager = (InputMethodManager) view.getContext().getSystemService(Context.INPUT_METHOD_SERVICE);
if (inputManager != null) {
inputManager.hideSoftInputFromWindow(view.getWindowToken(), 0);
}
}
}
Einfache und benutzerfreundliche Methode, rufen Sie einfach hideKeyboardFrom (YourActivity.this) auf; um die Tastatur auszublenden
/**
* This method is used to hide keyboard
* @param activity
*/
public static void hideKeyboardFrom(Activity activity) {
InputMethodManager imm = (InputMethodManager) activity.getSystemService(Activity.INPUT_METHOD_SERVICE);
imm.hideSoftInputFromWindow(activity.getCurrentFocus().getWindowToken(), 0);
}
benutze das
this.getWindow().setSoftInputMode(
WindowManager.LayoutParams.SOFT_INPUT_STATE_ALWAYS_HIDDEN);
Ich habe den Fall, dass sich meine EditText
auch in einer AlertDialog
befinden kann, also sollte die Tastatur beim Schließen geschlossen werden. Der folgende Code scheint überall zu funktionieren:
public static void hideKeyboard( Activity activity ) {
InputMethodManager imm = (InputMethodManager)activity.getSystemService( Context.INPUT_METHOD_SERVICE );
View f = activity.getCurrentFocus();
if( null != f && null != f.getWindowToken() && EditText.class.isAssignableFrom( f.getClass() ) )
imm.hideSoftInputFromWindow( f.getWindowToken(), 0 );
else
activity.getWindow().setSoftInputMode( WindowManager.LayoutParams.SOFT_INPUT_STATE_ALWAYS_HIDDEN );
}
public static void hideSoftKeyboard(Activity activity) {
InputMethodManager inputMethodManager = (InputMethodManager) activity.getSystemService(Activity.INPUT_METHOD_SERVICE);
inputMethodManager.hideSoftInputFromWindow(activity.getCurrentFocus().getWindowToken(), 0);
}
danach rufen Sie onTouchListener auf:
findViewById(Android.R.id.content).setOnTouchListener(new OnTouchListener() {
@Override
public boolean onTouch(View v, MotionEvent event) {
Utils.hideSoftKeyboard(activity);
return false;
}
});
Verwenden Sie einfach diesen optimierten Code in Ihrer Aktivität:
if (this.getCurrentFocus() != null) {
InputMethodManager inputManager = (InputMethodManager) this.getSystemService(Context.INPUT_METHOD_SERVICE);
inputManager.hideSoftInputFromWindow(this.getCurrentFocus().getWindowToken(), InputMethodManager.HIDE_NOT_ALWAYS);
}
Funktioniert jedes Mal wie eine magische Berührung
private void closeKeyboard() {
InputMethodManager inputManager = (InputMethodManager)getActivity().getSystemService(Context.INPUT_METHOD_SERVICE);
inputManager.hideSoftInputFromWindow(getActivity().getCurrentFocus().getWindowToken(), InputMethodManager.HIDE_NOT_ALWAYS);
}
private void openKeyboard() {
InputMethodManager imm = (InputMethodManager) getActivity().getSystemService(Context.INPUT_METHOD_SERVICE);
if(imm != null){
imm.toggleSoftInput(InputMethodManager.SHOW_IMPLICIT, 0);
}
}
Für Open Keyboard:
InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
imm.showSoftInput(edtView, InputMethodManager.SHOW_IMPLICIT);
Zum Schließen/Verbergen der Tastatur:
InputMethodManager imm = (InputMethodManager)getSystemService(Context.INPUT_METHOD_SERVICE);
imm.hideSoftInputFromWindow(edtView.getWindowToken(), 0);
Sie können auch mit setImeOption im EditText nachschauen.
Ich hatte gerade eine sehr ähnliche Situation, in der mein Layout einen EditText und eine Suchschaltfläche enthielt. Als ich herausfand, dass ich die Option "ime" auf "editSearch" setzen konnte, wurde mir klar, dass ich nicht einmal einen Suchknopf mehr brauchte. Die Soft-Tastatur (in diesem Modus) verfügt über ein Suchsymbol, mit dem die Suche gestartet werden kann (und die Tastatur schließt sich wie erwartet).
manchmal brauchen Sie nur die Eingabetaste, um die keyboard
.__ zu falten. Geben Sie die EditText
-Box ein, in der Sie das Attribut haben
Android:imeOptions="actionDone"
dadurch wird die Eingabetaste in eine Fertig-Schaltfläche geändert, mit der die Tastatur geschlossen wird.
Für mich geht das..
EditText editText=(EditText)findViewById(R.id.edittext1);
in onClick () unter der Codezeile einfügen
editText.setFocusable(false);
editText.setFocusableInTouchMode(true);
verbergen Sie die Tastatur, wenn Sie auf die Schaltfläche klicken. Wenn Sie die Schaltfläche berühren, wird die EditText-Tastatur angezeigt.
(ODER)
getWindow().setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_STATE_ALWAYS_HIDDEN);
Manchmal kann eine Aktivität vorhanden sein, die eine Listenansicht mit Zeilen enthält, die editText enthält. Sie müssen also das Manifest SOFT_INPUT_ADJUST_PAN
einrichten. Dann wird die Tastatur angezeigt, was ärgerlich ist.
Der folgende Workarround funktioniert, wenn Sie ihn am Ende von onCreate
platzieren.
getWindow().setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_STATE_ALWAYS_HIDDEN);
new Handler().postDelayed(new Runnable() {
@Override
public void run() {
getWindow().setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_ADJUST_PAN);
}
},100);
Activity
aufrufen public static void hideKeyboardwithoutPopulate(Activity activity) {
InputMethodManager inputMethodManager =
(InputMethodManager) activity.getSystemService(
Activity.INPUT_METHOD_SERVICE);
inputMethodManager.hideSoftInputFromWindow(
activity.getCurrentFocus().getWindowToken(), 0);
}
MainActivitiy
auf hideKeyboardwithoutPopulate(MainActivity.this);
In AndroidManifest.xml
unter <activity..>
setzen Sie Android:windowSoftInputMode="stateAlwaysHidden"
Wenn Sie die Tastatur mit Java-Code ausblenden möchten, verwenden Sie Folgendes:
InputMethodManager imm = (InputMethodManager)this.getSystemService(Context.INPUT_METHOD_SERVICE);
imm.hideSoftInputFromWindow(fEmail.getWindowToken(), 0);
Oder wenn Sie die Tastatur immer ausblenden möchten, verwenden Sie dies in Ihrem AndroidManifest:
<activity
Android:name=".activities.MyActivity"
Android:configChanges="keyboardHidden" />
Ich habe eine kleine Erweiterung für Kotlin geschrieben, falls es jemanden interessiert, der nicht viel getestet hat:
fun Fragment.hideKeyboard(context: Context = App.instance) {
val windowToken = view?.rootView?.windowToken
windowToken?.let {
val imm = context.getSystemService(Activity.INPUT_METHOD_SERVICE) as InputMethodManager
imm.hideSoftInputFromWindow(windowToken, 0)
}
}
App.instanz ist statisch "dieses" Anwendungsobjekt, das in der Anwendung gespeichert ist
Update: In einigen Fällen ist windowToken null. Ich habe eine zusätzliche Möglichkeit zum Schließen der Tastatur mit Reflektion hinzugefügt, um festzustellen, ob die Tastatur geschlossen ist
/**
* If no window token is found, keyboard is checked using reflection to know if keyboard visibility toggle is needed
*
* @param useReflection - whether to use reflection in case of no window token or not
*/
fun Fragment.hideKeyboard(context: Context = MainApp.instance, useReflection: Boolean = true) {
val windowToken = view?.rootView?.windowToken
val imm = context.getSystemService(Context.INPUT_METHOD_SERVICE) as InputMethodManager
windowToken?.let {
imm.hideSoftInputFromWindow(windowToken, 0)
} ?: run {
if (useReflection) {
try {
if (getKeyboardHeight(imm) > 0) {
imm.toggleSoftInput(0, InputMethodManager.HIDE_NOT_ALWAYS)
}
} catch (exception: Exception) {
Timber.e(exception)
}
}
}
}
fun getKeyboardHeight(imm: InputMethodManager): Int = InputMethodManager::class.Java.getMethod("getInputMethodWindowVisibleHeight").invoke(imm) as Int
public static void hideSoftKeyboard(Activity activity) {
InputMethodManager inputMethodManager = (InputMethodManager)activity.getSystemService(Activity.INPUT_METHOD_SERVICE);
inputMethodManager.hideSoftInputFromWindow(activity.getCurrentFocus().getWindowToken(), 0);
}
das funktioniert ..
Übergeben Sie einfach Ihre aktuelle Aktivitätsinstanz in der Funktion
public void isKeyBoardShow(Activity activity) {
InputMethodManager imm = (InputMethodManager) activity.getSystemService(Activity.INPUT_METHOD_SERVICE);
if (imm.isActive()) {
imm.toggleSoftInput(InputMethodManager.HIDE_IMPLICIT_ONLY, 0); // hide
} else {
imm.toggleSoftInput(0, InputMethodManager.HIDE_IMPLICIT_ONLY); // show
}
}
Eigentlich gibt Android-Autorität immer neue Updates, aber sie behandeln nicht ihre alten Nachteile, mit denen alle Android-Entwickler in ihrer Entwicklung konfrontiert sind. Diese sollte standardmäßig von Android-Autoritäten gehandhabt werden. Wenn Sie den Fokus von EditText ändern, sollten Sie die Soft-Input-Tastaturoption ein-/ausblenden. Tut mir leid, aber sie schaffen es nicht. OK lass es.
Nachfolgend finden Sie die Lösungen zum Anzeigen/Ausblenden/Umschalten einer Tastaturoption in Aktivität oder Fragment.
Tastatur für die Ansicht anzeigen:
/**
* open soft keyboard.
*
* @param context
* @param view
*/
public static void showKeyBoard(Context context, View view) {
try {
InputMethodManager keyboard = (InputMethodManager) context.getSystemService(Context.INPUT_METHOD_SERVICE);
keyboard.showSoftInput(view, 0);
} catch (Exception e) {
e.printStackTrace();
}
}
Tastatur mit Aktivitätskontext anzeigen:
/**
* open soft keyboard.
*
* @param mActivity context
*/
public static void showKeyBoard(Activity mActivity) {
try {
View view = mActivity.getCurrentFocus();
if (view != null) {
InputMethodManager keyboard = (InputMethodManager) mActivity.getSystemService(Context.INPUT_METHOD_SERVICE);
keyboard.showSoftInputFromInputMethod(view.getWindowToken(), InputMethodManager.SHOW_FORCED);
}
} catch (Exception e) {
e.printStackTrace();
}
}
Tastatur mit Fragmentkontext anzeigen:
/**
* open soft keyboard.
*
* @param mFragment context
*/
public static void showKeyBoard(Fragment mFragment) {
try {
if (mFragment == null || mFragment.getActivity() == null) {
return;
}
View view = mFragment.getActivity().getCurrentFocus();
if (view != null) {
InputMethodManager keyboard = (InputMethodManager) mFragment.getActivity().getSystemService(Context.INPUT_METHOD_SERVICE);
keyboard.showSoftInputFromInputMethod(view.getWindowToken(), InputMethodManager.SHOW_FORCED);
}
} catch (Exception e) {
e.printStackTrace();
}
}
Tastatur für die Ansicht ausblenden:
/**
* close soft keyboard.
*
* @param context
* @param view
*/
public static void hideKeyBoard(Context context, View view) {
try {
InputMethodManager keyboard = (InputMethodManager) context.getSystemService(Context.INPUT_METHOD_SERVICE);
keyboard.hideSoftInputFromWindow(view.getWindowToken(), 0);
} catch (Exception e) {
e.printStackTrace();
}
}
Tastatur mit Aktivitätskontext ausblenden:
/**
* close opened soft keyboard.
*
* @param mActivity context
*/
public static void hideSoftKeyboard(Activity mActivity) {
try {
View view = mActivity.getCurrentFocus();
if (view != null) {
InputMethodManager inputManager = (InputMethodManager) mActivity.getSystemService(Context.INPUT_METHOD_SERVICE);
inputManager.hideSoftInputFromWindow(view.getWindowToken(), 0);
}
} catch (Exception e) {
e.printStackTrace();
}
}
Tastatur mit Fragmentkontext ausblenden:
/**
* close opened soft keyboard.
*
* @param mFragment context
*/
public static void hideSoftKeyboard(Fragment mFragment) {
try {
if (mFragment == null || mFragment.getActivity() == null) {
return;
}
View view = mFragment.getActivity().getCurrentFocus();
if (view != null) {
InputMethodManager inputManager = (InputMethodManager) mFragment.getActivity().getSystemService(Context.INPUT_METHOD_SERVICE);
inputManager.hideSoftInputFromWindow(view.getWindowToken(), 0);
}
} catch (Exception e) {
e.printStackTrace();
}
}
Tastatur umschalten:
/**
* toggle soft keyboard.
*
* @param context
*/
public static void toggleSoftKeyboard(Context context) {
try {
InputMethodManager imm = (InputMethodManager) context.getSystemService(Activity.INPUT_METHOD_SERVICE);
imm.toggleSoftInput(InputMethodManager.HIDE_IMPLICIT_ONLY, 0);
} catch (Exception e) {
e.printStackTrace();
}
}
einfach Code: Verwenden Sie diesen Code in onCreate ()
getWindow().setSoftInputMode(
WindowManager.LayoutParams.SOFT_INPUT_STATE_ALWAYS_HIDDEN
);
Hier sind beide Methoden zum Verbergen und Anzeigen.
fun hideKeyboard(activity: Activity) {
val v = activity.currentFocus
val imm = activity.getSystemService(Context.INPUT_METHOD_SERVICE) as InputMethodManager
assert(v != null)
imm.hideSoftInputFromWindow(v!!.windowToken, InputMethodManager.HIDE_NOT_ALWAYS)
}
private fun showKeyboard(activity: Activity) {
val v = activity.currentFocus
val imm = activity.getSystemService(Context.INPUT_METHOD_SERVICE) as InputMethodManager
assert(v != null)
imm.showSoftInput(v, InputMethodManager.SHOW_IMPLICIT)
}
public static void hideKeyboard(Activity activity) {
View v = activity.getCurrentFocus();
InputMethodManager imm = (InputMethodManager) activity.getSystemService(Context.INPUT_METHOD_SERVICE);
assert imm != null && v != null;
imm.hideSoftInputFromWindow(v.getWindowToken(), InputMethodManager.HIDE_NOT_ALWAYS);
}
private static void showKeyboard(Activity activity) {
View v = activity.getCurrentFocus();
InputMethodManager imm = (InputMethodManager) activity.getSystemService(Context.INPUT_METHOD_SERVICE);
assert imm != null && v != null;
imm.showSoftInput(v, InputMethodManager.SHOW_IMPLICIT);
}
Wenn Sie Kotlin für die Entwicklung Ihrer Anwendung verwenden, ist dies sehr einfach.
Fügen Sie diese Erweiterungsfunktionen hinzu:
Für Aktivität:
fun Activity.hideKeyboard() {
val inputManager = getSystemService(Context.INPUT_METHOD_SERVICE) as InputMethodManager
val view = currentFocus
if (view != null) {
inputManager.hideSoftInputFromWindow(view.windowToken, InputMethodManager.HIDE_NOT_ALWAYS)
}
}
Für Fragment:
fun Fragment.hideKeyboard() {
activity?.let {
val inputManager = it.getSystemService(Context.INPUT_METHOD_SERVICE) as InputMethodManager
val view = it.currentFocus
if (view != null) {
inputManager.hideSoftInputFromWindow(view.windowToken, InputMethodManager.HIDE_NOT_ALWAYS)
}
}
}
Jetzt können Sie Ihr Fragment oder Ihre Aktivität einfach aufrufen:
hideKeyboard()
final RelativeLayout llLogin = (RelativeLayout) findViewById(R.id.rl_main);
llLogin.setOnTouchListener(
new View.OnTouchListener() {
@Override
public boolean onTouch(View view, MotionEvent ev) {
InputMethodManager imm = (InputMethodManager) this.getSystemService(
Context.INPUT_METHOD_SERVICE);
imm.hideSoftInputFromWindow(this.getCurrentFocus().getWindowToken(), 0);
return false;
}
});
Probier diese
public void disableSoftKeyboard(final EditText v) {
if (Build.VERSION.SDK_INT >= 11) {
v.setRawInputType(InputType.TYPE_CLASS_TEXT);
v.setTextIsSelectable(true);
} else {
v.setRawInputType(InputType.TYPE_NULL);
v.setFocusable(true);
}
}
Sehr einfacher Weg
Ich mache das in all meinen Projekten und arbeite wie ein Traum. Fügen Sie in Ihren Deklarationen layout.xml
einfach diese Zeile ein:
Android:focusableInTouchMode="true"
Vollständiger Codebeispiel:
<?xml version="1.0" encoding="utf-8"?>
<Android.support.constraint.ConstraintLayout
xmlns:app="http://schemas.Android.com/apk/res-auto"
Android:layout_width="match_parent"
Android:layout_height="match_parent"
Android:focusableInTouchMode="true">
<EditText
Android:layout_width="match_parent"
Android:layout_height="wrap_content" />
<ListView
Android:layout_width="match_parent"
Android:layout_height="wrap_content">
</ListView>
</Android.support.constraint.ConstraintLayout>
Hier sind die besten Lösungen
Lösung 1) Stellen Sie den inputType auf "text"
<EditText
Android:id="@+id/my_edit_text"
Android:layout_width="fill_parent"
Android:layout_height="wrap_content"
Android:hint="Tap here to type"
Android:inputType="text" />
Dies kann auch programmgesteuert über erfolgen. die Methode setInputType () (von TextView geerbt).
EditText editText = (EditText) findViewById(R.id.my_edit_text);
editText.setRawInputType(InputType.TYPE_CLASS_TEXT |
InputType.TYPE_TEXT_VARIATION_NORMAL);
Lösung 2) Verwenden Sie InputMethodManager.hideSoftInputFromWindow ().
InputMethodManager imm =
(InputMethodManager)getSystemService(Context.INPUT_METHOD_SERVICE);
imm.hideSoftInputFromWindow(myEditText.getWindowToken(), 0);
oder
InputMethodManager imm = (InputMethodManager)
getSystemService(Context.INPUT_METHOD_SERVICE);
imm.hideSoftInputFromWindow(myEditText.getWindowToken(),
InputMethodManager.HIDE_NOT_ALWAYS);
einfache Methode Jungs: versuchen Sie dies ...
private void closeKeyboard(boolean b) {
View view = this.getCurrentFocus();
if(b) {
if (view != null) {
InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
imm.hideSoftInputFromWindow(view.getWindowToken(), 0);
}
}
else {
InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
imm.showSoftInput(view, 0);
}
}
public static void hideSoftKeyboard(Activity activity) {
InputMethodManager inputMethodManager = (InputMethodManager) activity
.getSystemService(Activity.INPUT_METHOD_SERVICE);
inputMethodManager.hideSoftInputFromWindow(activity.getCurrentFocus()
.getWindowToken(), 0);
}
Eine einfache Problemumgehung besteht darin, nur editText.setEnabled(false);editText.setEnabled(true);
in Ihrer Button onClick()
-Methode anzugeben.
Wenn Sie die Tastatur bei Betätigung der Schaltfläche manuell ausblenden möchten, klicken Sie auf:
/**
* Hides the already popped up keyboard from the screen.
*
*/
public void hideKeyboard() {
try {
// use application level context to avoid unnecessary leaks.
InputMethodManager inputManager = (InputMethodManager) getApplicationContext().getSystemService(Context.INPUT_METHOD_SERVICE);
assert inputManager != null;
inputManager.hideSoftInputFromWindow(getCurrentFocus().getWindowToken(), InputMethodManager.HIDE_NOT_ALWAYS);
} catch (Exception e) {
e.printStackTrace();
}
}
Wenn Sie die Tastatur an einer beliebigen Stelle ausblenden möchten, auf die Sie klicken, außer edittext .
@Override
public boolean dispatchTouchEvent(MotionEvent ev) {
View view = getCurrentFocus();
if (view != null && (ev.getAction() == MotionEvent.ACTION_UP || ev.getAction() == MotionEvent.ACTION_MOVE) && view instanceof EditText && !view.getClass().getName().startsWith("Android.webkit.")) {
int scrcoords[] = new int[2];
view.getLocationOnScreen(scrcoords);
float x = ev.getRawX() + view.getLeft() - scrcoords[0];
float y = ev.getRawY() + view.getTop() - scrcoords[1];
if (x < view.getLeft() || x > view.getRight() || y < view.getTop() || y > view.getBottom())
((InputMethodManager)this.getSystemService(Context.INPUT_METHOD_SERVICE)).hideSoftInputFromWindow((this.getWindow().getDecorView().getApplicationWindowToken()), 0);
}
return super.dispatchTouchEvent(ev);
}
In Android können Sie das Vkeyboard mithilfe von InputMethodManage ausblenden, indem Sie das Token des Fensters übergeben, das Ihre fokussierte Ansicht enthält.
View view = this.getCurrentFocus();
if (view != null) {
InputMethodManager im =
(InputMethodManager)getSystemService(Context.INPUT_METHOD_SERVICE);
im.hideSoftInputFromWindow(view.getWindowToken(), 0);
}
Durch den Aufruf von editText.clearFocus () und dann InputMethodManager.HIDE_IMPLICIT_ONLY funktioniert sogar
sie können diesen Code einfach dort einfügen, wo Sie die Soft-Tastatur ausblenden möchten. "
// Check if no view has focus:
View view = getCurrentFocus();
if (view != null) {
InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
imm.hideSoftInputFromWindow(view.getWindowToken(), 0);
}
In Kotlin
fun hideKeyboard(activity: BaseActivity) {
val view = activity.currentFocus?: View(activity)
val imm = activity.getSystemService(Activity.INPUT_METHOD_SERVICE) as InputMethodManager
imm.hideSoftInputFromWindow(view.windowToken, 0)
}
Ich habe ein Layout teilweise aus XML und teilweise aus einer benutzerdefinierten Layout-Engine erstellt, die alle im Code verarbeitet wird. Das einzige, was für mich funktionierte, war zu verfolgen, ob die Tastatur geöffnet war oder nicht, und die Tastaturumschaltmethode wie folgt zu verwenden:
public class MyActivity extends Activity
{
/** This maintains true if the keyboard is open. Otherwise, it is false. */
private boolean isKeyboardOpen = false;
@Override
public void onCreate(Bundle savedInstanceState)
{
super.onCreate(savedInstanceState);
LayoutInflater inflater;
inflater = (LayoutInflater) getSystemService(Context.LAYOUT_INFLATER_SERVICE);
View contentView = inflater.inflate(context.getResources().getIdentifier("main", "layout", getPackageName()), null);
setContentView(contentView);
contentView.getViewTreeObserver().addOnGlobalLayoutListener(new OnGlobalLayoutListener()
{
public void onGlobalLayout()
{
Rect r = new Rect();
contentView.getWindowVisibleDisplayFrame(r);
int heightDiff = contentView.getRootView().getHeight() - (r.bottom - r.top);
if (heightDiff > 100)
isKeyboardVisible = true;
else
isKeyboardVisible = false;
});
}
}
public void closeKeyboardIfOpen()
{
InputMethodManager imm;
imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
if (isKeyboardVisible)
imm.toggleSoftInput(InputMethodManager.HIDE_IMPLICIT_ONLY, 0);
}
}
Diese Methode funktioniert immer um jeden Preis. Verwenden Sie es einfach überall, wo Sie die Tastatur ausblenden möchten
public static void hideSoftKeyboard(Context mContext,EditText username){
if(((Activity) mContext).getCurrentFocus()!=null && ((Activity) mContext).getCurrentFocus() instanceof EditText){
InputMethodManager imm = (InputMethodManager)mContext.getSystemService(Context.INPUT_METHOD_SERVICE);
imm.hideSoftInputFromWindow(username.getWindowToken(), 0);
}
}
Verwenden Sie es so:
Was ist die Android-Version? Diese Methode wird sicherlich funktionieren
Das hat bei mir funktioniert.
public static void hideKeyboard(Activity act, EditText et){
Context c = act.getBaseContext();
View v = et.findFocus();
if(v == null)
return;
InputMethodManager inputManager = (InputMethodManager) c.getSystemService(Context.INPUT_METHOD_SERVICE);
inputManager.hideSoftInputFromWindow(v.getWindowToken(), InputMethodManager.HIDE_NOT_ALWAYS);
}
Versucht alles hier in Verzweiflung, kombiniert alle Methoden und natürlich wird die Tastatur in Android 4.0.3 nicht geschlossen (es funktionierte in Honeicomb AFAIR).
Dann fand ich plötzlich eine scheinbar gewinnende Kombination:
textField.setRawInputType(InputType.TYPE_CLASS_TEXT |InputType.TYPE_TEXT_VARIATION_NORMAL);
kombiniert mit Ihren üblichen Rezepten
blahblaj.hideSoftInputFromWindow ...
ich hoffe, das hindert jemanden daran, Selbstmord zu begehen. Ich war nah dran. Ich habe natürlich keine Ahnung, warum es funktioniert.
Eine Alternative zur Verwendung von SearchView
wäre die Verwendung dieses Codes:
searchView = (SearchView) searchItem.getActionView();
searchView.setOnQueryTextListener(new OnQueryTextListener() {
@Override
public boolean onQueryTextSubmit(String query) {
InputMethodManager imm = (InputMethodManager)
getSystemService(getApplicationContext().INPUT_METHOD_SERVICE);
imm.hideSoftInputFromWindow(searchView.getApplicationWindowToken(), 0);
}
}
Dies ist ein SearchView-Suchfeld in der Aktionsleiste. Wenn der Text aus der Abfrage übermittelt wird (der Benutzer drückt entweder die Enter
-Taste oder eine Suchschaltfläche/ein Symbol), wird der InputMethodManager
-Code aktiviert und die Soft-Tastatur wird heruntergefahren. Dieser Code wurde in meine onCreateOptionsMenu()
eingefügt. searchItem
ist von MenuItem
, was Teil des Standardcodes für die onCreateOptionsmenu()
ist. Vielen Dank an @mckoss für einen guten Teil dieses Codes!
sie können Extension für jede Ansicht erstellen
fun View.hideKeyboard() = this.let {
val imm = context.getSystemService(Context.INPUT_METHOD_SERVICE) as InputMethodManager
imm.hideSoftInputFromWindow(windowToken, 0)
}
Beispielanwendung mit Aktivität
window.decorView.hideKeyboard();
Beispielanwendung mit View
etUsername.hideKeyboard();
Happy Coding ...
Rufen Sie diese Methode auf, um die Soft-Tastatur auszublenden
public void hideKeyBoard() {
View view1 = this.getCurrentFocus();
if(view!= null){
InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
imm.hideSoftInputFromWindow(view1.getWindowToken(), 0);
}
}
public static void closeInput(final View caller) {
caller.postDelayed(new Runnable() {
@Override
public void run() {
InputMethodManager imm = (InputMethodManager) caller.getContext().getSystemService(Context.INPUT_METHOD_SERVICE);
imm.hideSoftInputFromWindow(caller.getWindowToken(), InputMethodManager.HIDE_NOT_ALWAYS);
}
}, 100);
}
Diese Methode funktioniert im Allgemeinen, es gibt jedoch eine Bedingung: Android:windowSoftInputMode="any_of_these"
darf nicht gesetzt sein
Trotz all dieser Antworten habe ich, um einfach genug zu sein, eine gängige Methode dafür geschrieben:
/**
* hide soft keyboard in a activity
* @param activity
*/
public static void hideKeyboard (Activity activity){
activity.getWindow().setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_STATE_HIDDEN);
if (activity.getCurrentFocus() != null) {
InputMethodManager inputMethodManager = (InputMethodManager) activity.getSystemService(activity.INPUT_METHOD_SERVICE);
inputMethodManager.hideSoftInputFromWindow(activity.getCurrentFocus().getWindowToken(), 0);
}
}
Der folgende Code hilft Ihnen, generische Funktionen zu erstellen, die von überall aus aufgerufen werden können.
import Android.app.Activity
import Android.content.Context
import Android.support.design.widget.Snackbar
import Android.view.View
import Android.view.inputmethod.InputMethodManager
public class KeyboardHider {
companion object {
fun hideKeyboard(view: View, context: Context) {
val inputMethodManager = context.getSystemService(Activity.INPUT_METHOD_SERVICE) as InputMethodManager
inputMethodManager.hideSoftInputFromWindow(view.windowToken, 0)
}
}
}
Rufen Sie die Above-Methode von einer beliebigen Codezeile aus.
CustomSnackbar.hideKeyboard(view, [email protected])
view kann alles sein, zum Beispiel das Root-Layout einer Aktivität.
Hallo, das ist einfach, wenn Sie mit Kotlin arbeiten. Ich glaube, Sie können den Code leicht auch in Java konvertieren. Verwenden Sie diese Funktion, wenn Sie Ihre Aktivität laden, z.
fun hideKeybord (){
val inputManager = getSystemService(Context.INPUT_METHOD_SERVICE) as InputMethodManager
if (inputManager.isAcceptingText){
inputManager.hideSoftInputFromWindow(currentFocus.windowToken, 0)
}
}
ich erwähne diese Funktion in Ihrer onCreate () -Methode und füge diese Android:windowSoftInputMode="stateAlwaysHidden"
-Zeile zu Ihrer Aktivität in der Datei "manafest.xml" hinzu.
<activity
Android:name=".Activity.MainActivity"
Android:label="@string/app_name"
Android:theme="@style/AppTheme.NoActionBar"
Android:windowSoftInputMode="stateAlwaysHidden">
Für die Kotlin-Benutzer gibt es eine Kotlin-Erweiterungsmethode, die sich für meine Anwendungsfälle bewährt hat:
fun View.hideKeyboard() {
val imm = this.context.getSystemService(Activity.INPUT_METHOD_SERVICE) as InputMethodManager
imm.hideSoftInputFromWindow(windowToken, 0)
}
legen Sie es in eine Datei namens ViewExtensions (oder was haben Sie) und nennen Sie es wie eine normale Methode in Ihren Ansichten.
Wenn Ihre Anwendung auf API Level 21 oder mehr abzielt, gibt es eine zu verwendende Standardmethode:
editTextObj.setShowSoftInputOnFocus(false);
Stellen Sie sicher, dass Sie im EditText
XML-Tag den folgenden Code festgelegt haben.
<EditText
....
Android:enabled="true"
Android:focusable="true" />
Das war Arbeit für mich. Es ist in Kotlin zum Verstecken der Tastatur.
private fun hideKeyboard() {
val inputManager = activity?.getSystemService(Context.INPUT_METHOD_SERVICE) as InputMethodManager
val focusedView = activity?.currentFocus
if (focusedView != null) {
inputManager.hideSoftInputFromWindow(focusedView.windowToken,
InputMethodManager.HIDE_NOT_ALWAYS)
}
}
Dieses Code-Snippet kann helfen:
final InputMethodManager inputMethodManager = (InputMethodManager) getSystemService(Activity.INPUT_METHOD_SERVICE);
if (inputMethodManager != null && inputMethodManager.isActive()) {
if (getCurrentFocus() != null) {
inputMethodManager.hideSoftInputFromWindow(getCurrentFocus().getWindowToken(), 0);
}
}
Es kann je nach Bedarf in verschiedenen Methoden aufgerufen werden (zB onPause, onResume, onRestart ...)
Ich verwende folgende Kotlin Activity-Erweiterungen:
/**
* Hides soft keyboard if is open.
*/
fun Activity.hideKeyboard() {
currentFocus?.windowToken?.let {
(getSystemService(Context.INPUT_METHOD_SERVICE) as? InputMethodManager?)
?.hideSoftInputFromWindow(it, InputMethodManager.HIDE_NOT_ALWAYS)
}
}
/**
* Shows soft keyboard and request focus to given view.
*/
fun Activity.showKeyboard(view: View) {
view.requestFocus()
currentFocus?.windowToken?.let {
(getSystemService(Context.INPUT_METHOD_SERVICE) as? InputMethodManager?)
?.showSoftInput(view, InputMethodManager.SHOW_IMPLICIT)
}
}
So zeigen Sie die Tastatur beim Start der Anwendung an:
getWindow().setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_ADJUST_PAN | WindowManager.LayoutParams.SOFT_INPUT_STATE_VISIBLE);
view.requestFocus();
new Handler().postDelayed(new Runnable() {
public void run() {
getWindow().setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_ADJUST_PAN);
}
}, 1000);
Fügen Sie zunächst aus der XML-Datei das Feld add Android: imeOptions hinzu und ändern Sie den Wert in actionUnspecified | actionGo (siehe unten)
<Android.support.design.widget.TextInputEditText
Android:id="@+id/edit_text_id"
Android:layout_width="fill_parent"
Android:layout_height="@dimen/edit_text_height"
Android:imeOptions="actionUnspecified|actionGo"
/>
Fügen Sie dann in der Klasse Java ein setOnEditorActionListener hinzu und fügen Sie InputMethodManager wie folgt hinzu
enterOrderNumber.setOnEditorActionListener (neuer TextView.OnEditorActionListener () {
@Override
public boolean onEditorAction(TextView v, int actionId, KeyEvent event) {
if (actionId == EditorInfo.IME_ACTION_GO) {
InputMethodManager imm = (InputMethodManager) getActivity().getSystemService(Activity.INPUT_METHOD_SERVICE);
imm.toggleSoftInput(InputMethodManager.HIDE_IMPLICIT_ONLY, 0);
return true;
}
return false;
}
});
Kotlin-Version
val imm: InputMethodManager = getSystemService(Activity.INPUT_METHOD_SERVICE) as InputMethodManager
//Hide:
imm.toggleSoftInput(InputMethodManager.HIDE_IMPLICIT_ONLY, 0);
//Show
imm.toggleSoftInput(InputMethodManager.SHOW_IMPLICIT, 0);
umschließen Sie es mit try catch, sodass die Tastatur bereits geschlossen ist.
try{
View view = this.getCurrentFocus();
if (view != null) {
InputMethodManager imm = (InputMethodManager)getSystemService(Context.INPUT_METHOD_SERVICE);
imm.hideSoftInputFromWindow(view.getWindowToken(), 0);
}
}catch (Exception e)
{
e.printStackTrace();
}
Ich habe alle Lösungen sehr viel ausprobiert, aber keine Lösung für mich, daher habe ich meine Lösung gefunden:.
public static isKeyboardShowing = false;
InputMethodManager inputMethodManager = (InputMethodManager) getActivity()
.getSystemService(Context.INPUT_METHOD_SERVICE);
Und bei einem Touchscreen-Ereignis rufen Sie an:
@Override
public boolean onTouchEvent(MotionEvent event) {
if(keyboardShowing==true){
inputMethodManager.toggleSoftInput(InputMethodManager.RESULT_UNCHANGED_HIDDEN, 0);
keyboardShowing = false;
}
return super.onTouchEvent(event);
}
Und in EditText steht irgendwo:
yourEditText.setOnClickListener(new OnClickListener() {
@Override
public void onClick(View v) {
yourClass.keyboardShowing = true;
}
});
Für Xamarin.Android:
public void HideKeyboard()
{
var imm = activity.GetSystemService(Context.InputMethodService).JavaCast<InputMethodManager>();
var view = activity.CurrentFocus ?? new View(activity);
imm.HideSoftInputFromWindow(view.WindowToken, HideSoftInputFlags.None);
}
Fügen Sie in einer bestimmten Aktivität einfach die folgende Zeile in AndroidManifest hinzu.
<activity
Android:name=".MainActivity"
Android:screenOrientation="portrait">
Android:windowSoftInputMode="adjustPan"/>
Sie müssen nur eine Zeile in Ihr Manifest-Aktivitäts-Tag schreiben
Android:windowSoftInputMode="stateAlwaysHidden|adjustPan"
und es wird funktionieren.
fun hideKeyboard(appCompatActivity: AppCompatActivity) {
val view = appCompatActivity.currentFocus
val imm = appCompatActivity.getSystemService(Context.INPUT_METHOD_SERVICE) as InputMethodManager
imm.hideSoftInputFromWindow(view.windowToken, 0)
}
erstellen Sie einfach eine allgemeine Methode für die gesamte Anwendung in BaseActivity und BaseFragment
in onCreate()
initialisieren inputMethodManager
inputMethodManager = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
machen Sie diese Methoden zum Verstecken und Anzeigen der Tastatur
public void hideKeyBoard(View view) {
if (view != null) {
inputMethodManager.hideSoftInputFromWindow(view.getWindowToken(), 0);
}
}
public void showKeyboard(View view, boolean isForceToShow) {
if (isForceToShow)
inputMethodManager.toggleSoftInput(InputMethodManager.SHOW_FORCED, 0);
else if (view != null)
inputMethodManager.showSoftInput(view, 0);
}
use Text watcher instead of EditText.and after you finished entering the input
sie können verwenden
InputMethodManager imm = (InputMethodManager)getSystemService(Context.INPUT_METHOD_SERVICE);
imm.hideSoftInputFromWindow(view.getWindowToken(), 0);
there are two ways to do so...
method 1:in manifest file
define the line **Android:windowSoftInputMode="adjustPan|stateAlwaysHidden"** of code in your manifest.xml file as below...
<activity
Android:name="packagename.youactivityname"
Android:screenOrientation="portrait"
Android:windowSoftInputMode="adjustPan|stateAlwaysHidden" />
Method 2 : in Activity or Java class
if(getCurrentFocus()!=null) {
InputMethodManager inputMethodManager = (InputMethodManager) getSystemService(INPUT_METHOD_SERVICE)`enter code here`;
inputMethodManager.hideSoftInputFromWindow(getCurrentFocus().getWindowToken(), 0);
}
es wird funktionieren .... @ ASK
/**
*
* Hide I Said!!!
*
*/
public static boolean hideSoftKeyboard(@NonNull Activity activity) {
View currentFocus = activity.getCurrentFocus();
if (currentFocus == null) {
currentFocus = activity.getWindow().getDecorView();
if (currentFocus != null) {
return getSoftInput(activity).hideSoftInputFromWindow(currentFocus.getWindowToken(), 0, null);
}
}
return false;
}
public static boolean hideSoftKeyboard(@NonNull Context context) {
if(Activity.class.isAssignableFrom(context.getClass())){
return hideSoftKeyboard((Activity)context);
}
return false;
}
public static InputMethodManager getSoftInput(@NonNull Context context) {
return (InputMethodManager) context.getSystemService(Activity.INPUT_METHOD_SERVICE);
}
Einige Kotlin-Codes:
Tastatur vor Aktivität ausblenden:
(currentFocus ?: View(this))
.apply { (getSystemService(Activity.INPUT_METHOD_SERVICE) as InputMethodManager)
.hideSoftInputFromWindow(windowToken, 0) }
Wiki Antwort in Kotlin:
1 - Erstellen Sie eine Top-Level-Funktion innerhalb einer Datei (zum Beispiel eine Datei, die alle Ihre Top-Level-Funktionen enthält):
fun Activity.hideKeyboard(){
val imm = this.getSystemService(Activity.INPUT_METHOD_SERVICE) as InputMethodManager
var view = currentFocus
if (view == null) { view = View(this) }
imm.hideSoftInputFromWindow(view.windowToken, 0)
}
2 - Dann rufen Sie es bei jeder gewünschten Aktivität auf:
this.hideKeyboard()
public void hideKeyboard()
{
if(getCurrentFocus()!=null)
{
InputMethodManager inputMethodManager = (InputMethodManager) getSystemService(INPUT_METHOD_SERVICE);
inputMethodManager.hideSoftInputFromWindow(getCurrentFocus().getWindowToken(), 0);
}
}
public void showKeyboard(View mView) {
InputMethodManager inputMethodManager = (InputMethodManager) getSystemService(INPUT_METHOD_SERVICE);
mView.requestFocus();
inputMethodManager.showSoftInput(mView, 0);
}
private void hideSoftKeyboard() {
View view = getView();
if (view != null) {
InputMethodManager inputMethodManager = (InputMethodManager) getActivity()
.getSystemService(Activity.INPUT_METHOD_SERVICE);
inputMethodManager.hideSoftInputFromWindow(view.getWindowToken(), 0);
}
}
Nachdem ich alle Antworten oben und in einem anderen Beitrag gelesen hatte, gelang es mir immer noch nicht, die Tastatur automatisch öffnen zu lassen.
In meinem Projekt habe ich dynamisch einen Dialog (AlertDialog
) erstellt (durch Programmieren ohne oder mit minimalem erforderlichen XML-Code).
Also machte ich so etwas wie:
dialogBuilder = new AlertDialog.Builder(activity);
if(dialogBuilder==null)
return false; //error
inflater = activity.getLayoutInflater();
dialogView = inflater.inflate(layout, null);
...
Und nach dem Einrichten aller Ansichten (TextView, ImageView, EditText usw.) habe ich:
alertDialog = dialogBuilder.create();
alertDialog.show();
Nachdem ich mit allen Antworten herumgespielt hatte, stellte ich fest, dass die meisten von ihnen IF arbeiten, und Sie wissen WO, um die Anfrage zu stellen ... Und das war der Schlüssel zu allen.
Der Trick besteht also darin, VOR die Erstellung des Dialogs zu setzen: alertDialog.show()
In meinem Fall funktionierte das wie ein Zauber:
alertDialog = dialogBuilder.create();
alertDialog.getWindow().setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_STATE_ALWAYS_VISIBLE);
//And only when everything is finished - let's bring up the window -
alertDialog.show();
//Viola... keyboard is waiting for you open and ready...
//Just don't forget to request focus for the needed view (i.e. EditText..)
Ich bin mir ziemlich sicher, dass dieses Prinzip bei allen Fenstern gleich ist. Achten Sie also auf die Position Ihres "showKeyboard" -Codes - dies sollte vor dem Start des Fensters geschehen.
Eine kleine Anfrage vom Android SDK-Entwicklerteam:
Ich denke, dass dies alles unnötig ist, da Sie sehen können, dass Tausende von Programmierern aus der ganzen Welt sich mit diesem lächerlichen und trivialen Problem beschäftigen, während seine Lösung sauber und einfach sein sollte: IMHO, wenn ich requestFocus()
zu einem eingabeorientierten System bekomme view (z. B. EditText
) sollte sich die Tastatur automatisch öffnen, es sei denn, der Benutzer fordert not-to auf. Daher denke ich, dass die requestFocus () -Methode hier der Schlüssel ist und das boolean showSoftKeyboard mit dem Standardwert true
akzeptieren sollte: View.requestFocus(boolean showSoftKeyboard);
Hoffe, das hilft anderen wie mir.
Versuchen Sie dies in Kotlin
private fun hideKeyboard(){
val imm = activity!!.getSystemService(INPUT_METHOD_SERVICE) as InputMethodManager
imm.hideSoftInputFromWindow(activity!!.currentFocus!!.windowToken, 0)
}
Versuchen Sie dies in Java
private void hideKeyboard(){
InputMethodManager imm =(InputMethodManager)getSystemService(INPUT_METHOD_SERVICE);
imm.hideSoftInputFromWindow(getCurrentFocus().getWindowToken(), 0);
}