Cerca de/ocultar el Teclado para Android
https://stackoverflow.com/questions/1109022
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianPregunta
Tengo una EditText y un Button en mi diseño.
Después de escribir en el campo de edición y hacer clic en el Button, Quiero ocultar el teclado virtual.Supongo que esto es un simple trozo de código, pero donde puedo encontrar un ejemplo de ello?
Solución
Para ayudar a aclarar esta locura, me gustaría empezar por pedir disculpas en nombre de todos los usuarios de Android para el tratamiento francamente ridícula de Google de la pantalla táctil. La razón hay tantas respuestas, cada una diferente, para la misma pregunta simple porque esta API, como muchos otros en Android, está diseñado horrible. No puedo pensar en ninguna forma educada para decirlo.
Quiero ocultar el teclado. Espero para proporcionar Android con la siguiente afirmación: Keyboard.hide(). El fin. Muchas gracias. Sin embargo, Android tiene un problema. Debe utilizar el InputMethodManager para ocultar el teclado. OK, bien, esta es la API de Android para el teclado. ¡PERO! Usted está obligado a tener un Context con el fin de obtener acceso a la IMM. Ahora tenemos un problema. Puede que desee ocultar el teclado de una clase estática o utilidad que no tiene ningún uso o necesidad para cualquier Context. o Y mucho peor, la IMM requiere que se especifique lo View (o lo que es peor, lo Window) que desea ocultar el teclado.
Esto es lo que hace ocultar el teclado de modo desafiante. Estimado Google: cuando estoy buscando la receta para un pastel, no hay RecipeProvider en la Tierra que se niegan a darme la receta a menos que la primera respuesta de la OMS el pastel será comido por Y donde va a ser comido !!
Esta triste historia termina con la horrible verdad: para ocultar el teclado de Android, se le solicitará que proporcione 2 formas de identificación:. Un Context y, o bien un View o una Window
He creado un método de utilidad estática que puede hacer el trabajo muy sólida, siempre y cuando se llama desde un 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);
}
Tenga en cuenta que este método de utilidad sólo funciona cuando se llama desde un Activity! El método anterior llama getCurrentFocus del Activity objetivo a buscar el token ventana adecuada.
Pero supongamos que desea ocultar el teclado de un EditText alojada en un DialogFragment? No se puede utilizar el método anterior para que:
hideKeyboard(getActivity()); //won't work
Esto no funcionará porque estará pasando una referencia a Fragment host del Activity, que no tienen ningún control enfocada mientras se muestra la Fragment! ¡Guauu! Por lo tanto, para ocultar el teclado a partir de fragmentos, recurro a la de nivel inferior, más común y más feo:
public static void hideKeyboardFrom(Context context, View view) {
InputMethodManager imm = (InputMethodManager) context.getSystemService(Activity.INPUT_METHOD_SERVICE);
imm.hideSoftInputFromWindow(view.getWindowToken(), 0);
}
A continuación se incluye información adicional obtenida de más tiempo pierde tiempo buscando esta solución:
Acerca de windowSoftInputMode
Hay otro punto de contención a tener en cuenta. Por defecto, Android asignará automáticamente el enfoque inicial para el primer EditText o control enfocable en su Activity. Lo que es evidente que el InputMethod (normalmente el teclado en pantalla) responderá al evento de foco, mostrando en sí. El atributo windowSoftInputMode en AndroidManifest.xml, cuando se establece en stateAlwaysHidden, encarga al teclado para ignorar este enfoque inicial asignado de forma automática.
<activity
android:name=".MyActivity"
android:windowSoftInputMode="stateAlwaysHidden"/>
Casi increíblemente, parece no hacer nada para evitar que el teclado se abra cuando se toca el control (a menos focusable="false" y / o focusableInTouchMode="false" se asignan al control). Al parecer, el ajuste windowSoftInputMode se aplica sólo a los eventos automáticos de enfoque, no centrarse acontecimientos desencadenados por eventos de toque.
Por lo tanto, es muy mal stateAlwaysHidden nombrado por cierto. Tal vez debería llamarse ignoreInitialFocus lugar.
Espero que esto ayude.
ACTUALIZACIÓN: Más formas de obtener una muestra de ventana
Si no hay una visión enfocada (por ejemplo, puede suceder si los fragmentos acaba de cambiar), hay otros puntos de vista que suministrarán una muestra útil ventana.
Estas son alternativas para el código anterior if (view == null) view = new View(activity); Estos no hacen referencia explícita a su actividad.
Dentro de una clase de fragmento:
view = getView().getRootView().getWindowToken();
Dado un fragment fragmento como un parámetro:
view = fragment.getView().getRootView().getWindowToken();
A partir de su cuerpo contenido:
view = findViewById(android.R.id.content).getRootView().getWindowToken();
Actualización 2: enfoque claro para evitar que muestra el teclado de nuevo si se abre la aplicación del fondo
Añadir esta línea al final del método:
view.clearFocus();
Otros consejos
Puede forzar Android para ocultar el teclado virtual utilizando la InputMethodManager , llamando hideSoftInputFromWindow , pasando el símbolo de la ventana que contiene la vista enfocada.
// 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);
}
Esto forzará el teclado que se oculta en todas las situaciones. En algunos casos tendrá que pasar en InputMethodManager.HIDE_IMPLICIT_ONLY como segundo parámetro para asegurarse de que sólo se oculta el teclado cuando el usuario no forzó explícitamente a aparecer (manteniendo pulsada la tecla de menú).
Nota: Si usted quiere hacer esto en Kotlin, utilice:
context?.getSystemService(Context.INPUT_METHOD_SERVICE) as InputMethodManager
Kotlin Sintaxis
// 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) }
}
También es útil para ocultar el soft-teclado es:
getWindow().setSoftInputMode(
WindowManager.LayoutParams.SOFT_INPUT_STATE_ALWAYS_HIDDEN
);
Esto puede ser usado para suprimir el teclado de software hasta que el usuario toca realmente el EDITTEXT Ver.
Tengo una solución más para ocultar el teclado:
InputMethodManager imm = (InputMethodManager) getSystemService(Activity.INPUT_METHOD_SERVICE);
imm.toggleSoftInput(InputMethodManager.HIDE_IMPLICIT_ONLY, 0);
Aquí pasar HIDE_IMPLICIT_ONLY en la posición de showFlag y 0 en la posición de hiddenFlag. Se va a cerrar con fuerza teclado en pantalla.
La solución de Meier funciona para mí también. En mi caso, el nivel superior de mi aplicación es una tabHost y quiero ocultar la palabra clave cuando se cambia de pestañas -. Me da la señal de la ventana tabHost Ver
tabHost.setOnTabChangedListener(new OnTabChangeListener() {
public void onTabChanged(String tabId) {
InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
imm.hideSoftInputFromWindow(tabHost.getApplicationWindowToken(), 0);
}
}
Por favor, intente esto más adelante en el código onCreate()
EditText edtView=(EditText)findViewById(R.id.editTextConvertValue);
edtView.setInputType(0);
Actualización: No sé por qué esta solución no es el trabajo más (Acabo de prueba en Android 23). Por favor utilice la solución de Saurabh Pareek lugar. Aquí está:
InputMethodManager imm = (InputMethodManager) getSystemService(Activity.INPUT_METHOD_SERVICE);
//Hide:
imm.toggleSoftInput(InputMethodManager.HIDE_IMPLICIT_ONLY, 0);
//Show
imm.toggleSoftInput(InputMethodManager.SHOW_IMPLICIT, 0);
vieja respuesta:
//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);
}
Si todas las otras respuestas aquí no funcionan para usted como le gustaría a ellos, hay otra manera de controlar manualmente el teclado.
Crea una función con que va a gestionar algunas de las propiedades de la EditText:
public void setEditTextFocus(boolean isFocused) {
searchEditText.setCursorVisible(isFocused);
searchEditText.setFocusable(isFocused);
searchEditText.setFocusableInTouchMode(isFocused);
if (isFocused) {
searchEditText.requestFocus();
}
}
A continuación, asegúrese de que onFocus del EditText abrir / cerrar el teclado:
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);
}
}
}
});
Ahora, cada vez que desee abrir el teclado llamar manualmente:
setEditTextFocus(true);
Y para call de cierre:
setEditTextFocus(false);
Saurabh Pareek tiene la mejor respuesta hasta el momento.
La fuerza utilizar bien las banderas correctas, sin embargo.
/* 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);
Ejemplo de uso real
/* 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 ... */
}
de lo que buscar, aquí encontré una respuesta que funciona para mí
// 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);
La respuesta corta
En su OnClick escucha la llamada onEditorAction de la EditText con IME_ACTION_DONE
button.setOnClickListener(new OnClickListener() {
@Override
public void onClick(View v) {
someEditText.onEditorAction(EditorInfo.IME_ACTION_DONE)
}
});
El drill-down
Siento que este método es mejor, más simple y más alineado con Android del patrón de diseño.En el sencillo ejemplo anterior (y por lo general en la mayoría de los casos comunes) tendrá un EditText que tiene/tenía el foco y también por lo general era la de invocar el teclado en el primer lugar (que es sin duda capaz de invocar en muchos escenarios comunes).De la misma manera, es debe ser el uno para liberar el teclado, que por lo general puede ser realizado por un ImeAction.Sólo hay que ver cómo un EditText con android:imeOptions="actionDone" se comporta, usted desea conseguir el mismo comportamiento por el mismo medio.
Marque esta relacionados con la respuesta
Esto debería funcionar:
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);
Estoy usando un teclado personalizado para introducir un número hexadecimal por lo que no puede tener el teclado IMM aparecer ...
se añadió En setSoftInputShownOnFocus(boolean show) v3.2.4_r1 para controlar el tiempo o no para mostrar el teclado cuando un TextView obtiene foco, pero aún así es necesario que oculta utilizar la reflexión:
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
}
}
En versiones anteriores, me dieron muy buenos resultados (pero lejos de ser perfecto) con un OnGlobalLayoutListener, añade con la ayuda de un ViewTreeObserver de mi vista raíz y luego comprobar si el teclado se muestra como esto:
@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);
}
}
Esta última solución puede mostrar el teclado durante una fracción de segundo y se mete con los controladores de selección.
Cuando en el teclado entra en pantalla completa, onGlobalLayout no se llama. Para evitar esto, utilizar TextView # setImeOptions (int) o en la declaración de Vista de Texto XML:
android:imeOptions="actionNone|actionUnspecified|flagNoFullscreen|flagNoExtractUi"
Actualización: Sólo diálogos encontrado lo utilice nunca para mostrar el teclado y funciona en todas las versiones:
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);
}
}
He pasado más de dos días de trabajo a través de todas las soluciones publicadas en el hilo y los he encontrado falto de una manera u otra. Mi requisito exacto es tener un botón que hará con el 100% muestran fiabilidad u ocultar el teclado en pantalla. Cuando el teclado está en su estado oculto es no debe volver a aparecer, no importa qué campos de entrada que el usuario hace clic en. Cuando se encuentra en su estado visible el teclado no debe desaparecer, no importa qué botones el usuario hace clic. Esto tiene que trabajar en Android 2.2 + todo el camino hasta los últimos dispositivos.
Se puede ver una aplicación de trabajo de este en mi aplicación limpia RPN .
Después de probar muchas de las respuestas sugeridas en un número de diferentes teléfonos (incluyendo dispositivos Froyo y Gingerbread) se puso de manifiesto que las aplicaciones de Android pueden fiable:
- Temporalmente ocultar el teclado. Se volverá a aparecer de nuevo cuando un usuario centra un nuevo campo de texto.
- Mostrar el teclado cuando se inicia una actividad y establecer un indicador de la actividad lo que indica que el teclado deben siempre será visible. Esta bandera sólo se puede establecer cuando una actividad es inicialización.
- Marcar una actividad para no mostrar o permitir el uso de la teclado. Esta bandera sólo se puede establecer cuando una actividad es inicialización.
Para mí, ocultando temporalmente el teclado no es suficiente. En algunos dispositivos que volverá a aparecer tan pronto como un nuevo campo de texto se centra. Como mi aplicación utiliza múltiples campos de texto en una página, se centra un nuevo campo de texto hará que el teclado escondido para que aparezca de nuevo otra vez.
Desafortunadamente el punto 2 y 3 en la lista sólo funcionan fiabilidad cuando se va a iniciar una actividad. Una vez que la actividad se ha hecho visible no se puede ocultar o mostrar de forma permanente el teclado. El truco consiste en reiniciar realmente su actividad cuando el usuario presiona el botón de activación teclado. En mi aplicación cuando el usuario presiona el botón del teclado de palanca, el código siguiente ejecuta:
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);
}
}
Esto hace que la actividad actual ha de tener el estado guardado en un haz, y después se inicia la actividad, pasando a través de un valor booleano que indica si el teclado debe mostrar u ocultar.
Dentro del método onCreate se ejecuta el código siguiente:
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);
}
Si el teclado en pantalla se debe mostrar, entonces el InputMethodManager se cuenta para mostrar el teclado y la ventana es instruido para hacer la entrada de software siempre visible. Si el teclado en pantalla debe estar oculto entonces el WindowManager.LayoutParams.FLAG_ALT_FOCUSABLE_IM se establece.
Este enfoque funciona de forma fiable en todos los dispositivos que he probado en - de un niño de 4 años de teléfono HTC con Android 2.2 hasta un nexo 7 corriendo 4.2.2. La única desventaja de este enfoque es que hay que tener cuidado con el manejo del botón de retroceso. Como mi aplicación esencialmente sólo tiene una pantalla (es una calculadora) puedo anular onBackPressed () y volver a la pantalla de los dispositivos de casa.
Como alternativa a esta solución todo , si desea cerrar el teclado en pantalla desde cualquier lugar sin tener una referencia al campo (EditarTexto) que se utilizó para abrir el teclado, pero todavía quería hacerlo si el campo se centra, se podría utilizar esta (de una actividad):
if (getCurrentFocus() != null) {
InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
imm.hideSoftInputFromWindow(getCurrentFocus().getWindowToken(), 0);
}
Gracias a este Así que la respuesta , Derivé los siguientes elementos que, en mi caso, funciona muy bien cuando se desplaza a través de la la fragmentos de un 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);
}
}
Por encima de respuestas funcionan para diferentes escenarios de pero Si desea ocultar el teclado en el interior de una vista y luchando para conseguir el contexto adecuado intente esto:
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);
}
}
y para obtener el contexto buscarla a constructor :)
public View/RelativeLayout/so and so (Context context, AttributeSet attrs, int defStyle) {
super(context, attrs, defStyle);
this.context = context;
init();
}
Si desea cerrar el teclado en pantalla durante una unidad o prueba de funcionamiento, puede hacerlo haciendo clic en el botón "atrás" de su prueba:
// Close the soft keyboard from a Test
getInstrumentation().sendKeyDownUpSync(KeyEvent.KEYCODE_BACK);
Me puse botón "atrás" entre comillas, ya que lo anterior no da lugar a la onBackPressed() para la actividad en cuestión. Simplemente cierra el teclado.
Asegúrese de hacer una pausa por un tiempo antes de pasar, ya que se tarda un poco de tiempo para cerrar el botón de retroceso, por lo que los clics posteriores a Vistas, etc., no se registrarán hasta después de una breve pausa (1 segundo es ime lo suficientemente largo).
He aquí cómo lo haces en Mono para Android (También conocido como MonoDroid)
InputMethodManager imm = GetSystemService (Context.InputMethodService) as InputMethodManager;
if (imm != null)
imm.HideSoftInputFromWindow (searchbox.WindowToken , 0);
Esto funcionó para mí durante todo el comportamiento del teclado extraña
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);
}
}
Añadir a su actividad android:windowSoftInputMode="stateHidden" en el archivo de manifiesto. Ejemplo:
<activity
android:name=".ui.activity.MainActivity"
android:label="@string/mainactivity"
android:windowSoftInputMode="stateHidden"/>
public static void hideSoftKeyboard(Activity activity) {
InputMethodManager inputMethodManager = (InputMethodManager) activity.getSystemService(Activity.INPUT_METHOD_SERVICE);
inputMethodManager.hideSoftInputFromWindow(activity.getCurrentFocus().getWindowToken(), 0);
}
después de esa llamada en onTouchListener:
findViewById(android.R.id.content).setOnTouchListener(new OnTouchListener() {
@Override
public boolean onTouch(View v, MotionEvent event) {
Utils.hideSoftKeyboard(activity);
return false;
}
});
utilizar este
this.getWindow().setSoftInputMode(
WindowManager.LayoutParams.SOFT_INPUT_STATE_ALWAYS_HIDDEN);
En mi caso, yo estaba usando la una SearchView en la barra de acción. Después de que un usuario realiza una búsqueda, el teclado podría estallar abierto de nuevo.
Uso de la InputMethodManager no cerrar el teclado. Tenía que clearFocus y establecer el enfocable de la vista de búsqueda en false:
mSearchView.clearFocus();
mSearchView.setFocusable(false);
Sólo tiene que utilizar el código optimizado en su actividad:
if (this.getCurrentFocus() != null) {
InputMethodManager inputManager = (InputMethodManager) this.getSystemService(Context.INPUT_METHOD_SERVICE);
inputManager.hideSoftInputFromWindow(this.getCurrentFocus().getWindowToken(), InputMethodManager.HIDE_NOT_ALWAYS);
}
Tengo el caso, donde mi EditText se puede situar también en una AlertDialog, por lo que el teclado debe estar cerrada en descartar. El siguiente código parece estar trabajando en cualquier lugar:
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 );
}
Casi he probado todas estas respuestas, tuve algunos problemas al azar sobre todo con el Samsung Galaxy S5.
Lo que termino con la está obligando a mostrar y ocultar, y funciona perfectamente:
/**
* 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);
}
En algunos casos estos métodos puede trabajar con excepción de todos los demás. Esto ahorra mi día;)
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);
}
}
}
