Mam A EditText
i A Button
w moim układzie.
Po wpisaniu w polu edycji i kliknięciu przycisku Button
chcę ukryć wirtualną klawiaturę. Zakładam, że jest to prosty fragment kodu, ale gdzie mogę znaleźć przykład?
Podczas dotykania poza klawiaturą.
Mam A EditText
i A Button
w moim układzie.
Po wpisaniu w polu edycji i kliknięciu przycisku Button
chcę ukryć wirtualną klawiaturę. Zakładam, że jest to prosty fragment kodu, ale gdzie mogę znaleźć przykład?
Podczas dotykania poza klawiaturą.
Odpowiedzi:
Aby pomóc wyjaśnić to szaleństwo, chciałbym zacząć od przeprosin w imieniu wszystkich użytkowników Androida za wręcz absurdalne traktowanie przez Google miękkiej klawiatury. Powodem jest tak wiele odpowiedzi, z których każda jest inna, na to samo proste pytanie, ponieważ ten interfejs API, podobnie jak wiele innych w Androidzie, jest strasznie zaprojektowany. Nie potrafię wymyślić żadnego grzecznego sposobu na wyrażenie tego.
Chcę ukryć klawiaturę. Spodziewam się, aby zapewnić Android z następującym stwierdzeniem: Keyboard.hide()
. Koniec. Dziękuję Ci bardzo. Ale Android ma problem. Musisz użyć, InputMethodManager
aby ukryć klawiaturę. OK, w porządku, to jest interfejs API Androida do klawiatury. ALE! Musisz mieć Context
, aby uzyskać dostęp do IMM. Teraz mamy problem. Mogę chcieć ukryć klawiaturę przed klasą statyczną lub użytkową, która nie jest potrzebna ani potrzebna Context
. lub I DALEKO gorzej, IMM wymaga określenia, coView
(lub jeszcze gorzej, co Window
) chcesz ukryć przed klawiaturą.
Właśnie dlatego ukrywanie klawiatury jest tak trudne. Drogi Google: Kiedy szukam przepisu na ciasto, nie maRecipeProvider
na Ziemi która nie odmówiłaby podania mi przepisu, chyba że najpierw odpowiem KTO, przez co ciasto zostanie zjedzone ORAZ gdzie zostanie zjedzone !!
Ta smutna historia kończy się brzydką prawdą: aby ukryć klawiaturę Androida, musisz podać 2 formy identyfikacji: a Context
i a View
lub aWindow
.
Stworzyłem statyczną metodę narzędzia, która może wykonać zadanie BARDZO solidnie, pod warunkiem, że wywołasz go z Activity
.
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);
}
Należy pamiętać, że ta metoda narzędzia działa TYLKO po wywołaniu z Activity
! Powyższe wywołania metody getCurrentFocus
celu w Activity
celu pobrania odpowiedniego tokena okna.
Ale załóżmy, że chcesz ukryć klawiaturę przed EditText
hostowanym w DialogFragment
? Nie możesz użyć powyższej metody do tego:
hideKeyboard(getActivity()); //won't work
To nie zadziała, ponieważ przekażesz referencję do Fragment
hosta Activity
, który nie będzie miał żadnej skoncentrowanej kontroli, gdy Fragment
zostanie wyświetlony! Łał! Aby ukryć klawiaturę przed fragmentami, uciekam się do niższego poziomu, bardziej powszechnego i brzydszego:
public static void hideKeyboardFrom(Context context, View view) {
InputMethodManager imm = (InputMethodManager) context.getSystemService(Activity.INPUT_METHOD_SERVICE);
imm.hideSoftInputFromWindow(view.getWindowToken(), 0);
}
Poniżej znajduje się kilka dodatkowych informacji zebranych po dłuższym marnowaniu czasu na pogoń za tym rozwiązaniem:
Informacje o windowSoftInputMode
Jest jeszcze jeden punkt sporny, o którym należy pamiętać. Domyślnie Android automatycznie przypisze początkowy fokus do pierwszej EditText
lub sterowalnej fokusu w twoim Activity
. Wynika z tego naturalnie, że InputMethod (zazwyczaj miękka klawiatura) zareaguje na zdarzenie skupienia, pokazując się. windowSoftInputMode
Atrybut AndroidManifest.xml
, gdy ustawiony stateAlwaysHidden
, instruuje klawiaturę do ignorowania tego automatycznie przypisany początkowej ostrości.
<activity
android:name=".MyActivity"
android:windowSoftInputMode="stateAlwaysHidden"/>
Niemal niewiarygodne wydaje się, że nie robi nic, aby uniemożliwić otwarcie klawiatury po dotknięciu kontrolki (chyba że focusable="false"
i / lub focusableInTouchMode="false"
są przypisane do kontrolki). Najwyraźniej ustawienie windowSoftInputMode dotyczy tylko zdarzeń automatycznego fokusa, a nie zdarzeń fokusa wyzwalanych przez zdarzenia dotykowe.
Dlatego stateAlwaysHidden
jest BARDZO źle nazwany. Być może należy to nazwać ignoreInitialFocus
zamiast tego.
Mam nadzieję że to pomoże.
AKTUALIZACJA: Więcej sposobów na uzyskanie tokena okna
Jeśli nie ma skupionego widoku (np. Może się zdarzyć, jeśli właśnie zmieniłeś fragmenty), istnieją inne widoki, które dostarczą przydatnego tokena okna.
Są to alternatywy dla powyższego kodu. if (view == null) view = new View(activity);
Nie odnoszą się one wprost do Twojej aktywności.
Wewnątrz klasy fragmentu:
view = getView().getRootView().getWindowToken();
Biorąc pod uwagę fragment fragment
jako parametr:
view = fragment.getView().getRootView().getWindowToken();
Począwszy od treści treści:
view = findViewById(android.R.id.content).getRootView().getWindowToken();
AKTUALIZACJA 2: Wyczyść fokus, aby uniknąć ponownego wyświetlania klawiatury, jeśli otworzysz aplikację z tła
Dodaj ten wiersz na końcu metody:
view.clearFocus();
Fragment
Wydaje się, że możesz użyćgetActivity().getWindow().getDecorView()
Keyboard.hide();
narzędzie
Możesz zmusić Androida do ukrycia wirtualnej klawiatury za pomocą InputMethodManager , wywołując hideSoftInputFromWindow
, przekazując token okna zawierającego skupiony widok.
// 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);
}
Wymusi to ukrycie klawiatury we wszystkich sytuacjach. W niektórych przypadkach będziesz chciał przekazać InputMethodManager.HIDE_IMPLICIT_ONLY
jako drugi parametr, aby mieć pewność, że ukryjesz klawiaturę tylko wtedy, gdy użytkownik nie wymusił jej jawnego wyświetlenia (przytrzymując menu).
Uwaga: Jeśli chcesz to zrobić w Kotlin, użyj:
context?.getSystemService(Context.INPUT_METHOD_SERVICE) as InputMethodManager
Składnia Kotlina
// Check if no view has focus:
val view = this.currentFocus
view?.let { v ->
val imm = getSystemService(Context.INPUT_METHOD_SERVICE) as? InputMethodManager
imm?.hideSoftInputFromWindow(v.windowToken, 0)
}
editText.clearFocus()
wtedy InputMethodManager.HIDE_IMPLICIT_ONLY
działa nawet dalej4.1
View focused = getCurrentFocus()
na uzyskaniu tego, co zdecydowanie jest aktualnie skupionym widokiem, wywoływaniem focused.clearFocus()
, a następnie inputMethodManager.hideSoftInputFromWindow(focused.getWindowToken(), 0)
(z wyraźnymi flagami).
Przydatne również do ukrywania klawiatury programowej jest:
getWindow().setSoftInputMode(
WindowManager.LayoutParams.SOFT_INPUT_STATE_ALWAYS_HIDDEN
);
Można tego użyć, aby wyłączyć klawiaturę ekranową, dopóki użytkownik nie dotknie widoku edycji tekstu.
Mam jeszcze jedno rozwiązanie, aby ukryć klawiaturę:
InputMethodManager imm = (InputMethodManager) getSystemService(Activity.INPUT_METHOD_SERVICE);
imm.toggleSoftInput(InputMethodManager.HIDE_IMPLICIT_ONLY, 0);
Tutaj przechodzą HIDE_IMPLICIT_ONLY
w pozycji showFlag
i 0
w pozycji hiddenFlag
. Mocno zamknie miękką klawiaturę.
Rozwiązanie Meiera również działa dla mnie. W moim przypadku najwyższym poziomem mojej aplikacji jest tabHost i chcę ukryć słowo kluczowe podczas przełączania kart - otrzymuję token okna z widoku tabHost.
tabHost.setOnTabChangedListener(new OnTabChangeListener() {
public void onTabChanged(String tabId) {
InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
imm.hideSoftInputFromWindow(tabHost.getApplicationWindowToken(), 0);
}
}
Spróbuj tego poniżej kodu w onCreate()
EditText edtView=(EditText)findViewById(R.id.editTextConvertValue);
edtView.setInputType(0);
editView.setInputType(InputType.TYPE_NULL);
Aktualizacja: Nie wiem, dlaczego to rozwiązanie już nie działa (właśnie testowałem na Androidzie 23). Zamiast tego skorzystaj z rozwiązania Saurabh Pareek . Oto on:
InputMethodManager imm = (InputMethodManager) getSystemService(Activity.INPUT_METHOD_SERVICE);
//Hide:
imm.toggleSoftInput(InputMethodManager.HIDE_IMPLICIT_ONLY, 0);
//Show
imm.toggleSoftInput(InputMethodManager.SHOW_IMPLICIT, 0);
Stara odpowiedź:
//Show soft-keyboard:
getWindow().setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_STATE_ALWAYS_VISIBLE);
//hide keyboard :
getWindow().setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_STATE_ALWAYS_HIDDEN);
I don't know why this solution is not work any more
- ponieważ jest to Android , wszystko będzie w stanie się zmienić, być może częściowo złego projektu ... Piszemy niedbale, a następnie przekreślamy wszystko i przepisujemy wszystko.
protected void hideSoftKeyboard(EditText input) {
InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
imm.hideSoftInputFromWindow(input.getWindowToken(), 0);
}
input.getContext().getSystemService(Context.INPUT_METHOD_SERVICE)
.
input.setInputType(0);
z tego kodu. Zmieniło zachowanie klawiatury i inputType
dla EditText
.
Jeśli wszystkie inne odpowiedzi tutaj nie działają tak, jak chcesz, istnieje inny sposób ręcznego sterowania klawiaturą.
Utwórz funkcję, która będzie zarządzać niektórymi EditText
właściwościami:
public void setEditTextFocus(boolean isFocused) {
searchEditText.setCursorVisible(isFocused);
searchEditText.setFocusable(isFocused);
searchEditText.setFocusableInTouchMode(isFocused);
if (isFocused) {
searchEditText.requestFocus();
}
}
Następnie upewnij się, że onFocus EditText
ciebie otwiera / zamyka klawiaturę:
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);
}
}
}
});
Teraz, gdy chcesz ręcznie otworzyć klawiaturę, zadzwoń:
setEditTextFocus(true);
I do zakończenia połączenia:
setEditTextFocus(false);
Saurabh Pareek ma najlepszą jak dotąd odpowiedź.
Może jednak również użyć poprawnych flag.
/* 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);
Przykład rzeczywistego użycia
/* 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 ... */
}
fragment.getActivity().getSystemService();
po tak poszukiwaniach znalazłem odpowiedź, która działa dla mnie
// 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);
W swoim OnClick
słuchaczu zadzwoń onEditorAction
za EditText
pomocąIME_ACTION_DONE
button.setOnClickListener(new OnClickListener() {
@Override
public void onClick(View v) {
someEditText.onEditorAction(EditorInfo.IME_ACTION_DONE)
}
});
Wydaje mi się, że ta metoda jest lepsza, prostsza i bardziej zgodna ze wzorcem projektowym Androida. W powyższym prostym przykładzie (i zwykle w większości typowych przypadków) będziesz mieć, EditText
który był / miał fokus, a także zwykle to on w pierwszej kolejności wywoływał klawiaturę (zdecydowanie jest w stanie wywołać ją w wielu przypadkach typowe scenariusze). W tej samej drodze, to powinno być jedno, aby zwolnić klawiaturę, zazwyczaj, które mogą być wykonywane przez ImeAction
. Zobacz, jak to EditText
działaandroid:imeOptions="actionDone"
zachowuje się „ , i chcesz osiągnąć to samo zachowanie w ten sam sposób.
Sprawdź tę powiązaną odpowiedź
To powinno działać:
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);
hide()
i show()
metodami, aby mieć większą kontrolę nad tym, kiedy powinna się ona pokazywać, a kiedy nie. Działa dla mnie, ja też to zrobiłem :)
KeyBoard.toggle(fragment.getActivity())
Fragment
, jak w komentarzu. Dowiedz się, jak korzystać z metod, a następnie wróć.
Używam niestandardowej klawiatury do wprowadzenia numeru szesnastkowego, więc nie mogę wyświetlić klawiatury IMM ...
W wersji 3.2.4_r1 setSoftInputShownOnFocus(boolean show)
dodano, aby kontrolować pogodę lub nie wyświetlać klawiatury, gdy obiekt TextView zostanie ustawiony, ale nadal jest ukryty, więc należy użyć odbicia:
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
}
}
W przypadku starszych wersji uzyskałem bardzo dobre wyniki (ale dalekie od ideału) za pomocą a OnGlobalLayoutListener
, dodanego za pomocą a ViewTreeObserver
z mojego widoku głównego, a następnie sprawdzenia, czy klawiatura jest wyświetlana w następujący sposób:
@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);
}
}
To ostatnie rozwiązanie może pokazywać klawiaturę na ułamek sekundy i zadziera z uchwytami wyboru.
Kiedy na klawiaturze pojawia się pełny ekran, onGlobalLayout nie jest wywoływany. Aby tego uniknąć, użyj TextView # setImeOptions (int) lub w deklaracji XML TextView :
android:imeOptions="actionNone|actionUnspecified|flagNoFullscreen|flagNoExtractUi"
Aktualizacja: Właśnie znalazłem okna dialogowe, które nigdy nie pokazują klawiatury i działają we wszystkich wersjach:
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);
}
}
Spędziłem ponad dwa dni pracując nad wszystkimi rozwiązaniami opublikowanymi w wątku i stwierdziłem, że brakuje im w ten czy inny sposób. Moim dokładnym wymaganiem jest mieć przycisk, który ze 100% niezawodnością pokaże lub ukryje klawiaturę ekranową. Gdy klawiatura jest w stanie ukrytym, nie powinna się ponownie pojawiać, bez względu na pola wejściowe, które kliknie użytkownik. Gdy jest w stanie widocznym, klawiatura nie powinna zniknąć bez względu na to, jakie przyciski użytkownik kliknie. To musi działać na Androidzie 2.2+ aż do najnowszych urządzeń.
Możesz zobaczyć działającą implementację tego w mojej aplikacji czystym RPN .
Po przetestowaniu wielu sugerowanych odpowiedzi na wielu różnych telefonach (w tym na urządzeniach froyo i piernikowych) stało się jasne, że aplikacje na Androida mogą niezawodnie:
Dla mnie chwilowe ukrywanie klawiatury nie wystarczy. Na niektórych urządzeniach pojawi się ponownie, gdy tylko nowe pole tekstowe zostanie zogniskowane. Ponieważ moja aplikacja korzysta z wielu pól tekstowych na jednej stronie, skupienie nowego pola tekstowego spowoduje ponowne pojawienie się ukrytej klawiatury.
Niestety pozycje 2 i 3 na liście działają tylko wtedy, gdy działanie jest rozpoczęte. Gdy aktywność stanie się widoczna, nie można trwale ukryć ani pokazać klawiatury. Sztuką jest zrestartowanie aktywności, gdy użytkownik naciśnie przycisk przełączania klawiatury. W mojej aplikacji, gdy użytkownik naciśnie przycisk przełączania klawiatury, uruchamia się następujący kod:
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);
}
}
Powoduje to, że bieżąca aktywność zostaje zapisana w pakiecie, a następnie aktywność jest uruchamiana, przechodząc przez wartość logiczną, która wskazuje, czy klawiatura powinna być pokazana, czy ukryta.
Wewnątrz metody onCreate uruchamiany jest następujący kod:
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);
}
Jeśli powinna zostać wyświetlona klawiatura programowa, wówczas InputMethodManager ma wyświetlać klawiaturę, a okno jest instruowane, aby program był zawsze widoczny. Jeśli miękka klawiatura powinna być ukryta, wówczas ustawiany jest WindowManager.LayoutParams.FLAG_ALT_FOCUSABLE_IM.
To podejście działa niezawodnie na wszystkich urządzeniach, na których testowałem - od 4-letniego telefonu HTC z Androidem 2.2 do Nexusa 7 z 4.2.2. Jedyną wadą tego podejścia jest ostrożność przy posługiwaniu się przyciskiem Wstecz. Ponieważ moja aplikacja zasadniczo ma tylko jeden ekran (jest to kalkulator), mogę zastąpić onBackPressed () i wrócić do ekranu głównego urządzeń.
Alternatywnie do tego wszechstronnego rozwiązania , jeśli chcesz zamknąć klawiaturę programową z dowolnego miejsca bez odniesienia do pola (EditText), które było użyte do otwarcia klawiatury, ale nadal chciałbyś to zrobić, jeśli pole było skupione, możesz użyć to (z działania):
if (getCurrentFocus() != null) {
InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
imm.hideSoftInputFromWindow(getCurrentFocus().getWindowToken(), 0);
}
Dzięki tej odpowiedzi SO wyprowadziłem następujące, które w moim przypadku działa ładnie podczas przewijania fragmentów ViewPager ...
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);
}
}
Powyższe odpowiedzi działają w różnych scenariuszach, ale jeśli chcesz ukryć klawiaturę w widoku i próbujesz uzyskać właściwy kontekst, spróbuj tego:
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);
}
}
i pobierz kontekst, pobierz go z konstruktora :)
public View/RelativeLayout/so and so (Context context, AttributeSet attrs, int defStyle) {
super(context, attrs, defStyle);
this.context = context;
init();
}
Jeśli chcesz zamknąć klawiaturę programową podczas testu jednostkowego lub funkcjonalnego, możesz to zrobić, klikając przycisk „Wstecz” w teście:
// Close the soft keyboard from a Test
getInstrumentation().sendKeyDownUpSync(KeyEvent.KEYCODE_BACK);
W cudzysłowie wstawiam „przycisk Wstecz”, ponieważ powyższe nie uruchamia onBackPressed()
danego działania. Po prostu zamyka klawiaturę.
Pamiętaj, aby zatrzymać się na chwilę przed przejściem dalej, ponieważ zamknięcie przycisku wstecz zajmuje trochę czasu, więc kolejne kliknięcia w Widoki itp. Nie zostaną zarejestrowane, dopóki nie nastąpi krótka pauza (1 sekunda jest wystarczająco długa ).
To zadziałało w przypadku wszystkich dziwnych zachowań klawiatury
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);
}
}
Dodaj do swojej aktywności android:windowSoftInputMode="stateHidden"
w pliku manifestu. Przykład:
<activity
android:name=".ui.activity.MainActivity"
android:label="@string/mainactivity"
android:windowSoftInputMode="stateHidden"/>
Prosta i łatwa w użyciu metoda, wystarczy wywołać hideKeyboardFrom (YourActivity.this); ukryć klawiaturę
/**
* 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);
}
Po prostu użyj tego zoptymalizowanego kodu w swojej działalności:
if (this.getCurrentFocus() != null) {
InputMethodManager inputManager = (InputMethodManager) this.getSystemService(Context.INPUT_METHOD_SERVICE);
inputManager.hideSoftInputFromWindow(this.getCurrentFocus().getWindowToken(), InputMethodManager.HIDE_NOT_ALWAYS);
}
public static void hideSoftKeyboard(Activity activity) {
InputMethodManager inputMethodManager = (InputMethodManager) activity.getSystemService(Activity.INPUT_METHOD_SERVICE);
inputMethodManager.hideSoftInputFromWindow(activity.getCurrentFocus().getWindowToken(), 0);
}
po tym wywołaniu onTouchListener:
findViewById(android.R.id.content).setOnTouchListener(new OnTouchListener() {
@Override
public boolean onTouch(View v, MotionEvent event) {
Utils.hideSoftKeyboard(activity);
return false;
}
});
Użyj tego
this.getWindow().setSoftInputMode(
WindowManager.LayoutParams.SOFT_INPUT_STATE_ALWAYS_HIDDEN);
W moim przypadku korzystałem z SearchView na pasku akcji. Po przeprowadzeniu wyszukiwania przez użytkownika klawiatura ponownie się otworzy.
Użycie InputMethodManager nie zamknęło klawiatury. Musiałem wyczyścić Focus i ustawić fokus widoku wyszukiwania na false:
mSearchView.clearFocus();
mSearchView.setFocusable(false);
clearFocus()
na stronach interfejsu API Androida, więc nie działało to dla mnie, ale zadziałało inne rozwiązanie (patrz moja odpowiedź poniżej).
Mam skrzynkę, w której mój EditText
może być umieszczony również w AlertDialog
, więc klawiatura powinna być zamknięta po zwolnieniu. Następujący kod wydaje się działać wszędzie:
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 );
}
Prawie wypróbowałem wszystkie te odpowiedzi, miałem kilka przypadkowych problemów, szczególnie z Samsung Galaxy S5.
Skończyło się na wymuszeniu pokazu i ukrycia, i działa idealnie:
/**
* 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);
}