¿Cómo se cierra / oculta el teclado virtual de Android usando Java?

Tengo una EditText y una 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 al tocar fuera del teclado. Supongo que se trata de un código simple, pero ¿dónde puedo encontrar un ejemplo?

preguntado el 10 de julio de 09 a las 11:07

¿Qué sucede si solo tiene un EditText y varios botones, como casillas de verificación y radios? El único lugar donde necesita el teclado es en el único EditText. ¿Cómo se registra para saber que se eligió o se hizo clic en otra cosa para ocultar el teclado? -

me siento estupido. No puedo ocultar el teclado en ICS. Probé todos los métodos aquí y combinaciones de ellos. De ninguna manera. El método para mostrarlo funciona, pero no puedo ocultarlo sin importar el token de viento, ocultar banderas, manifestar configuraciones o velas a los santos. En el programa de teclado siempre veo esto: I / LatinIME (396): InputType.TYPE_NULL se especifica W / LatinIME (396): Clase de entrada inesperada: inputType = 0x00000000 imeOptions = 0x00000000 -

/ ** * Este método se utiliza para ocultar el teclado virtual. * @param actividad * / public void hideSoftKeyboard (Actividad de actividad) {InputMethodManager inputMethodManager = (InputMethodManager) activity.getSystemService (Activity.INPUT_METHOD_SERVICE); inputMethodManager.hideSoftInputFromWindow (activity.getCurrentFocus (). getWindowToken (), 0); } -

este trabajó para mi -

Con los dispositivos que aumentan el tamaño y la resolución de la pantalla, la ocultación del teclado virtual es cada vez menos importante. -

30 Respuestas

Para ayudar a aclarar esta locura, me gustaría comenzar disculpándome en nombre de todos los usuarios de Android por el tratamiento francamente ridículo de Google del teclado en pantalla. La razón por la que hay tantas respuestas, cada una diferente, para la misma pregunta simple es que esta API, como muchas otras en Android, está horriblemente diseñada. No se me ocurre ninguna forma cortés de decirlo.

Quiero ocultar el teclado. Espero proporcionar a Android la siguiente declaración: Keyboard.hide(). El fin. Muchas gracias. Pero Android tiene un problema. Debes usar el InputMethodManager para ocultar el teclado. Está bien, esta es la API de Android para el teclado. ¡PERO! Debes tener un Context para acceder al IMM. Ahora tenemos un problema. Es posible que desee ocultar el teclado de una clase estática o de utilidad que no tiene uso o necesidad de ningún Context. o Y MUCHO peor, el IMM requiere que especifique qué View (o peor aún, qué Window) desea ocultar el teclado DE.

Esto es lo que hace que esconder el teclado sea tan difícil. Estimado Google: Cuando busco la receta de un pastel, no hay RecipeProvider en la Tierra que se negaría a darme la receta a menos que primero responda por QUIÉN se comerá el pastel Y dónde se comerá.

Esta triste historia termina con la fea verdad: para ocultar el teclado de Android, se le pedirá que proporcione 2 formas de identificación: a Context y o bien un View o Window.

He creado un método de utilidad estática que puede hacer el trabajo MUY sólidamente, siempre que lo llame 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 SOLO funciona cuando se llama desde un Activity! El método anterior llama getCurrentFocus del objetivo Activity para recuperar el token de ventana adecuado.

Pero suponga que desea ocultar el teclado a un EditText alojado en un DialogFragment? No puede usar el método anterior para eso:

hideKeyboard(getActivity()); //won't work

Esto no funcionará porque pasará una referencia al Fragmentanfitrión Activity, que no tendrá control enfocado mientras el Fragment ¡se muestra! ¡Guau! Entonces, para ocultar el teclado de los fragmentos, recurro al nivel más bajo, 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 muestra información adicional obtenida de más tiempo perdido persiguiendo esta solución:

Acerca de windowSoftInputMode

Hay otro punto de discordia que hay que tener en cuenta. De forma predeterminada, Android asignará automáticamente el enfoque inicial a la primera EditText o control enfocable en su Activity. Naturalmente, se deduce que InputMethod (normalmente el teclado virtual) responderá al evento de enfoque mostrándose a sí mismo. La windowSoftInputMode atributo en AndroidManifest.xml, cuando se establece en stateAlwaysHidden, indica al teclado que ignore este enfoque inicial asignado automáticamente.

<activity
    android:name=".MyActivity"
    android:windowSoftInputMode="stateAlwaysHidden"/>

Casi increíblemente, parece que no hace nada para evitar que el teclado se abra cuando toca el control (a menos que focusable="false" y/o focusableInTouchMode="false" están asignados al control). Aparentemente, la configuración windowSoftInputMode se aplica solo a eventos de enfoque automático, no a eventos de enfoque activados por eventos táctiles.

Por lo tanto, stateAlwaysHidden está MUY mal nombrado de hecho. Quizás debería llamarse ignoreInitialFocus en vez.


ACTUALIZACIÓN: Más formas de obtener un token de ventana

Si no hay una vista enfocada (por ejemplo, puede suceder si acaba de cambiar fragmentos), hay otras vistas que proporcionarán un token de ventana útil.

Estas son alternativas para el código anterior if (view == null) view = new View(activity); Estos no se refieren explícitamente a su actividad.

Dentro de una clase de fragmento:

view = getView().getRootView().getWindowToken();

Dado un fragmento fragment como parámetro:

view = fragment.getView().getRootView().getWindowToken();

A partir de su cuerpo de contenido:

view = findViewById(android.R.id.content).getRootView().getWindowToken();

ACTUALIZACIÓN 2: enfoque claro para evitar volver a mostrar el teclado si abre la aplicación desde el fondo

Agregue esta línea al final del método:

view.clearFocus();

respondido 12 mar '21, 05:03

Por que necesita getRootView() por qué no getView() ¿solo? - ILW

Puede forzar a Android a ocultar el teclado virtual usando el InputMethodManagerllamando hideSoftInputFromWindow, pasando el token de la ventana que contiene su 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 obligará a ocultar el teclado en todas las situaciones. En algunos casos, querrá pasar InputMethodManager.HIDE_IMPLICIT_ONLY como segundo parámetro para garantizar que solo oculte el teclado cuando el usuario no lo obligó explícitamente a aparecer (manteniendo presionado el menú).

Nota: Si desea hacer esto en Kotlin, use: context?.getSystemService(Context.INPUT_METHOD_SERVICE) as InputMethodManager

Sintaxis de Kotlin

// Only runs if there is a view that is currently focused
this.currentFocus?.let { view ->
    val imm = getSystemService(Context.INPUT_METHOD_SERVICE) as? InputMethodManager
    imm?.hideSoftInputFromWindow(view.windowToken, 0)
}

Respondido 21 Feb 21, 12:02

También es útil para ocultar el teclado virtual:

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

Esto se puede usar para suprimir el teclado virtual hasta que el usuario realmente toque la vista editText.

respondido 24 nov., 14:19

Este fue el único que funcionó en 2020. Tengo un texto de edición en la actividad principal y no quiero que aparezca el teclado al iniciar la aplicación. - Brian M

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í pasa HIDE_IMPLICIT_ONLY en la posición de showFlag y 0 en la posición de hiddenFlag. Se cerrará con fuerza el teclado suave.

Respondido el 27 de junio de 16 a las 18:06

Estás usando una bandera oculta en el parámetro showflags. Esto solo funciona porque las constantes usan los mismos números enteros. Ejemplo usando las banderas correctas - Alex

probado en Android 4.0, me gusta esta solución, porque tengo varios textos de edición, botones en esa actividad, que pueden tener foco - user529543

Esto funciona para mí, no tengo ningún cuadro de texto ni nada que realmente tenga enfoque. - Basilio alemán

@Mark: Porque el método se llama "toggleSoftInput", no "hideSoftInput" :) - Sver

La solución de Meier también funciona para mí. En mi caso, el nivel superior de mi aplicación es un host de pestaña y quiero ocultar la palabra clave al cambiar de pestaña; obtengo el token de ventana de la vista del host de pestaña.

tabHost.setOnTabChangedListener(new OnTabChangeListener() {
    public void onTabChanged(String tabId) {
        InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
        imm.hideSoftInputFromWindow(tabHost.getApplicationWindowToken(), 0);
    }
}

Respondido el 11 de junio de 20 a las 07:06

También conseguí que esto funcionara con SearchView. Vea a continuación mi respuesta. ¡Gracias mckoss! - Azurespot

Por favor, intente con el siguiente código en onCreate()

EditText edtView = (EditText) findViewById(R.id.editTextConvertValue);
edtView.setInputType(InputType.TYPE_NULL);

Respondido 09 Oct 20, 01:10

Este método funciona como un medio para evitar el error "no se puede ocultar el teclado virtual" en 2.0 y 2.1 como se describe en code.google.com/p/android/issues/detail?id=7115 ... el método hideSoftInputFromWindow enumerado anteriormente no funcionó cuando lo probé, pero editView.setInputType (0) sí. - Spike Williams

Esto es legítimo por Javadoc (no un truco) aunque reescribiría el método como editView.setInputType(InputType.TYPE_NULL); - Bostone

esto funciona, sin embargo, oculta el android: hint. estoy usando Android 1.5 - Tirtha

esto es ideal para cuando necesita cerrar el teclado desde un cuadro de diálogo, no necesita obtener una instancia ni nada y puede asignar esto a todos los textos de edición cuando el usuario presiona un botón que cierra el cuadro de diálogo - Estoy con estúpido

Funciona, pero también oculta el cursor. Necesito el cursor, pero no el teclado del sistema. - Stefan Brendle

Actualizar: No sé por qué esta solución ya no funciona (acabo de probar en Android 23). Utilice la solución de Saurabh Pareek en lugar de. Aquí lo tienes:

InputMethodManager imm = (InputMethodManager) getSystemService(Activity.INPUT_METHOD_SERVICE);
//Hide:
imm.toggleSoftInput(InputMethodManager.HIDE_IMPLICIT_ONLY, 0);
//Show
imm.toggleSoftInput(InputMethodManager.SHOW_IMPLICIT, 0);

Respuesta anterior:

//Show soft-keyboard:
getWindow().setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_STATE_ALWAYS_VISIBLE);
//hide keyboard :
 getWindow().setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_STATE_ALWAYS_HIDDEN);

contestado el 23 de mayo de 17 a las 15:05

¿Dónde debo colocar este código? Intenté pegar getWindow (). SetSoftInputMode (WindowManager.LayoutParams.SOFT_INPUT_STATE_ALWAYS_HIDDEN); en onCreate () pero el teclado nunca está oculto - user2236096

no funciona, probado en radioGroup.setOnCheckedChangeListener, API 23 - Christian Schäfer

Si miras más de cerca, InputMethodManager.HIDE_IMPLICIT_ONLY y InputMethodManager.SHOW_IMPLICIT tienen el mismo valor, que es "1", por lo que no hay diferencia entre estas llamadas. => no funciona - Palejandro

si llama a imm.toggleSoftInput (InputMethodManager.HIDE_IMPLICIT_ONLY, 0); luego el teclado se mostrará en la pantalla :) La mejor implementación es: github.com/ravindu1024/android-keyboardlistener Vergüenza en Android SDK - Duna

I don't know why this solution is not work any more - porque es Android, todo podrá cambiar, quizás en parte por mal diseño ... Escribimos descuidadamente, luego tachamos todo y reescribimos todo. - Rey rey

protected void hideSoftKeyboard(EditText input) {
    InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
    imm.hideSoftInputFromWindow(input.getWindowToken(), 0);    
}

respondido 28 nov., 18:13

¡Esto funcionó para mí! Pero por que pusiste input.setInputType (0) ? No pude interactuar con el EditTextView cuando tuve esa línea de código (funcionó cuando la eliminé). - ymerdrengene

Probablemente input.getContext().getSystemService(Context.INPUT_METHOD_SERVICE). - CoolMind

quite input.setInputType(0); de este código. Cambió el comportamiento del teclado y inputType para EditText. - CoolMind

Si todas las otras respuestas aquí no funcionan para usted como le gustaría, hay otra forma de controlar manualmente el teclado.

Cree una función con la que administre algunos de los EditTextpropiedades de:

public void setEditTextFocus(boolean isFocused) {
    searchEditText.setCursorVisible(isFocused);
    searchEditText.setFocusable(isFocused);
    searchEditText.setFocusableInTouchMode(isFocused);

    if (isFocused) {
        searchEditText.requestFocus();
    }
}

Luego, asegúrese de que en el Enfoque del EditText abres / cierras 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, siempre que desee abrir el teclado manualmente, llame a:

setEditTextFocus(true);

Y para cerrar la convocatoria:

setEditTextFocus(false);

respondido 24 nov., 14:18

+1: si desea iniciar una actividad con el teclado cerrado, use esta solución y agregue un onclicklistener que establece setEditTextFocus (verdadero). ¡Funciona como encanto! - Schlingel

Tengo 'No se puede resolver el contexto del símbolo', en la séptima y décima línea del segundo bloque de código. - dame

Use getContext () en su lugar - Rotemmiz

Saurabh Pareek tiene la mejor respuesta hasta ahora.

Sin embargo, también podría usar las banderas correctas.

/* 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 ... */
}

contestado el 23 de mayo de 17 a las 14:05

Este es el más eficiente para la última versión. Siempre será necesario modificarlo para versiones anteriores. Especialmente antes de v3. - Alex

@Mazen: usar fragment.getActivity().getSystemService(); - Johan s

Esta es la respuesta más completa, que cubre tanto mostrar como ocultar. - André Staltz

No. En mi Samsung Tab, Android 5.0, el código "ocultar teclado" anterior CAMBIARÁ el teclado virtual; si ya está oculto, lo mostrará. Hay una razón por la que esta función tiene TOGGLE en el nombre. - ToolmakerSteve

De tanto buscar, aquí encontré una respuesta que me funciona

// 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);

Respondido 25 Abr '15, 00:04

El único que me funcionó para un Motorola con Android 5.1 - GMX

La respuesta corta

En su OnClick el oyente llama al onEditorAction de los EditText con IME_ACTION_DONE

button.setOnClickListener(new OnClickListener() {

    @Override
    public void onClick(View v) {
        someEditText.onEditorAction(EditorInfo.IME_ACTION_DONE)
    }
});

El desglose

Siento que este método es mejor, más simple y más alineado con el patrón de diseño de Android. En el ejemplo simple anterior (y generalmente en la mayoría de los casos comunes) tendrá un EditText que tiene / ha tenido foco y también suele ser el que invoca el teclado en primer lugar (definitivamente es capaz de invocarlo en muchos escenarios comunes). De la misma manera it debe ser el que suelte el teclado, por lo general, puede hacerlo un ImeAction. Solo mira como un EditText con android:imeOptions="actionDone" se comporta, desea lograr el mismo comportamiento por los mismos medios.


Mira esto respuesta relacionada

contestado el 23 de mayo de 17 a las 15:05

Esta es la respuesta. Único método que funciona en versión cruzada. Regresé a esta pregunta para publicar esta respuesta porque no creía que nadie más lo supiera. Noah Passalacqua

Esta debería ser la respuesta correcta. En lugar de engañar a Android para que oculte el teclado cuando realmente debería estar allí, le decimos que el usuario ha terminado, lo que a su vez activa la misma ImeAction [nombre estúpido, lo admito] como si el usuario hubiera hecho clic en "HECHO" en el teclado . De esta forma, no importa si el usuario confirma la entrada en el teclado o toca el botón de la interfaz de usuario. - Oliver Hausler

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

Respondido 15 Jul 16, 17:07

Funcionó en parte, incluso si el teclado estaba oculto "isActive ()" devuelve falso! - xpto

Por supuesto que sí, se supone que debe hacerlo. O tal vez no te entiendo. De todos modos, podrías complementar la clase con hide() y show() métodos para tener más control sobre cuándo debería mostrarse y cuándo no. Funciona para mí, yo también lo hice :) Editaré un ejemplo - slinden77

@YoushaAleayoub sí lo hará. KeyBoard.toggle(fragment.getActivity()) - slinden77

@ slinden77, jejeje, estoy hablando de tu respuesta ... no esta que has comentado. Entonces esa respuesta aún NO funcionará. - Yousha Aleayoub

@YoushaAleayoub uhm sí lo hará. La pregunta original no menciona fragmentos, eres tú quien mencionó fragmentos. Entonces mi respuesta es perfectamente válida. Para usarlo con fragmentos, llame al método de manera diferente a un Fragment, como comentó un. Aprenda a usar los métodos y luego regrese. Estás confundiendo a la gente con tus tontas respuestas. slinden77

Estoy usando un teclado personalizado para ingresar un número hexadecimal, por lo que no puedo mostrar el teclado IMM ...

En v3.2.4_r1 setSoftInputShownOnFocus(boolean show) se agregó para controlar el clima o no para mostrar el teclado cuando un TextView se enfoca, pero aún está oculto, por lo que se debe usar 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
    }
}

Para las versiones anteriores, obtuve muy buenos resultados (pero lejos de ser perfectos) con un OnGlobalLayoutListener, añadido con la ayuda de un ViewTreeObserver desde mi vista raíz y luego verificando si el teclado se muestra así:

@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 por una fracción de segundo y se enreda con los controles de selección.

Cuando en el teclado ingresa a pantalla completa, no se llama a onGlobalLayout. Para evitar eso, use TextView # setImeOptions (int) o en la declaración XML de TextView:

android:imeOptions="actionNone|actionUnspecified|flagNoFullscreen|flagNoExtractUi"

Actualizar: Acabo de encontrar qué diálogos usan para nunca mostrar el teclado y funciona en todas las versiones:

getWindow().setFlags(WindowManager.LayoutParams.FLAG_ALT_FOCUSABLE_IM,
        WindowManager.LayoutParams.FLAG_ALT_FOCUSABLE_IM);

contestado el 29 de mayo de 12 a las 00:05

Gracias. Las dos banderas FLAG_ALT_FOCUSABLE_IM y FLAG_ALT_FOCUSABLE_IM son en realidad lo único que ayudó en mi caso. No quería que se mostrara un teclado en mi actividad, ni siquiera cuando el usuario hacía clic en un texto de edición. (Hice mi propio "teclado"). - Daniel Novak

Sin embargo, una solución genial, si su actividad frontal no es de pantalla completa, el teclado es visible detrás de ella. Además, la ayuda de movimiento del cursor del teclado también sigue siendo visible. Y no se puede desollar. - halxinar

Secundo que. De todas las formas posibles, solo funciona el método getWindow (). SetFlags (), al menos en Android 5.1. Tenga en cuenta que setSoftInputShownOnFocus () ahora es setShowSoftInputOnFocus () y ya no está oculto pero no funciona, al menos no cuando el usuario toca el campo. - olefevre

Tu "actualización" fue la única solución que funcionaba para mí. Estoy buscando una solución al menos dos horas :) - Stefan Brendle

Ojalá pudiera votarte más de una vez, ¡la última línea fue la única que funcionó para mí! - Kibi

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

Respondido el 01 de junio de 15 a las 16:06

He pasado más de dos días trabajando en todas las soluciones publicadas en el hilo y he descubierto que faltan de una forma u otra. Mi requisito exacto es tener un botón que muestre u oculte con 100% de fiabilidad el teclado en pantalla. Cuando el teclado está en su estado oculto, no debería volver a aparecer, sin importar en qué campos de entrada haga clic el usuario. Cuando está en su estado visible, el teclado no debería desaparecer sin importar en qué botones haga clic el usuario. Esto debe funcionar en Android 2.2+ hasta los últimos dispositivos.

Puedes ver una implementación funcional de esto en mi aplicación. limpiar RPN.

Después de probar muchas de las respuestas sugeridas en varios teléfonos diferentes (incluidos los dispositivos froyo y gingerbread), se hizo evidente que las aplicaciones de Android pueden:

  1. Oculte temporalmente el teclado. Volverá a aparecer cuando un usuario enfoque un nuevo campo de texto.
  2. Muestre el teclado cuando comience una actividad y coloque una bandera en la actividad que indique que el teclado siempre debe estar visible. Esta bandera solo se puede configurar cuando se está inicializando una actividad.
  3. Marque una actividad para que nunca se muestre o permita el uso del teclado. Esta bandera solo se puede configurar cuando se está inicializando una actividad.

Para mí, ocultar temporalmente el teclado no es suficiente. En algunos dispositivos, volverá a aparecer tan pronto como se enfoque un nuevo campo de texto. Como mi aplicación usa múltiples campos de texto en una página, enfocar un nuevo campo de texto hará que el teclado oculto vuelva a aparecer.

Lamentablemente, los elementos 2 y 3 de la lista solo funcionan con fiabilidad cuando se inicia una actividad. Una vez que la actividad se ha hecho visible, no puede ocultar ni mostrar el teclado de forma permanente. El truco consiste en reiniciar su actividad cuando el usuario presiona el botón de alternancia del teclado. En mi aplicación, cuando el usuario presiona el botón de alternancia del teclado, se ejecuta el siguiente código:

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 tenga su estado guardado en un paquete, y luego se inicia la actividad, pasando por un booleano que indica si el teclado debe mostrarse u ocultarse.

Dentro del método onCreate se ejecuta el siguiente código:

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 se debe mostrar el teclado virtual, entonces se le dice al InputMethodManager que muestre el teclado y se le indica a la ventana que haga que la entrada suave esté siempre visible. Si el teclado virtual debe estar oculto, se establece WindowManager.LayoutParams.FLAG_ALT_FOCUSABLE_IM.

Este enfoque funciona de manera confiable en todos los dispositivos en los que he probado, desde un teléfono HTC de 4 años con Android 2.2 hasta un nexus 7 con 4.2.2. La única desventaja de este enfoque es que debes tener cuidado al manipular el botón de retroceso. Como mi aplicación esencialmente solo tiene una pantalla (es una calculadora), puedo anular onBackPressed () y regresar a la pantalla de inicio del dispositivo.

respondido 06 mar '18, 10:03

solución elaborada, pero creo que es demasiado, recrear miles de objetos solo para ocultar el teclado. No sé quién diseñó el IMM para Android, pero huele a una APi de Windows. En mi opinión, un buen IME debería tener dos métodos: ocultar y mostrar :-) - rompe

Todo es cierto, pero mi solución tiene una ventaja: ¡siempre funciona! No hay otra solución que pude encontrar que siempre alternaría el teclado, independientemente de los campos de la interfaz de usuario que tengan el foco, lo que el usuario haya hecho para alternar y el teclado y qué versión de Android estén ejecutando: - \ - Luke Sleeman

Hombre, estoy totalmente desesperado por ocultar el teclado. Probé miles de cosas y nadie funciona. Pero su solución es demasiado para mí, tendría que recrear como 10 fragmentos, inicializar servicios, eliminar muchas WeakReferences ... ¿sabe? el GC simplemente se tiraría como 25mb: S ... Todavía estoy buscando una forma confiable de hacerlo :( - rompe

@Dmitry bueno, no es un hola mundo ... es una aplicación compleja para tabletas. Me niego a descargarlo totalmente de la memoria solo para esconder un teclado tonto ... De todos modos encontré algo que funciona combinando las mil soluciones propuestas aquí :) - rompe

Alternativamente a esta solución completa, si desea cerrar el teclado virtual de donde sea sin tener una referencia al campo (EditText) que se usó para abrir el teclado, pero aún quería hacerlo si el campo estaba enfocado, puede usar esto (de una actividad):

if (getCurrentFocus() != null) {
    InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
    imm.hideSoftInputFromWindow(getCurrentFocus().getWindowToken(), 0);
}

contestado el 23 de mayo de 17 a las 15:05

Gracias a esta SO respuesta, Obtuve lo siguiente que, en mi caso, funciona bien al desplazarse por los 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);
    }
}

contestado el 23 de mayo de 17 a las 15:05

Las respuestas anteriores funcionan para diferentes escenarios, pero Si desea ocultar el teclado dentro de una vista y tiene dificultades para obtener el contexto correcto, 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, búscalo del constructor :)

public View/RelativeLayout/so and so (Context context, AttributeSet attrs, int defStyle) {
    super(context, attrs, defStyle);
    this.context = context;
    init();
}

Respondido 25 Abr '15, 00:04

Si desea cerrar el teclado virtual durante una unidad o prueba funcional, 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);

Puse "botón de retroceso" entre comillas, ya que lo anterior no activa el onBackPressed() para la actividad en cuestión. Simplemente cierra el teclado.

Asegúrese de hacer una pausa por un momento antes de continuar, ya que se tarda un poco en cerrar el botón Atrás, por lo que los clics posteriores en Vistas, etc., no se registrarán hasta después de una breve pausa (1 segundo es suficiente tiempo. ).

Respondido el 14 de diciembre de 11 a las 01:12

Así es como se hace en Mono para Android (también conocido como MonoDroid)

InputMethodManager imm = GetSystemService (Context.InputMethodService) as InputMethodManager;
if (imm != null)
    imm.HideSoftInputFromWindow (searchbox.WindowToken , 0);

contestado el 15 de mayo de 12 a las 05:05

¿Qué es? searchbox en el fragmento? - PCoder

Esto funcionó para mí por todo el extraño comportamiento del teclado.

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

Respondido 25 Abr '15, 00:04

Creo que probé 10 respuestas antes de esta. Había perdido la esperanza. Gracias hombre. - Bolling

¿Qué es mRootView? - justdan0227

Método simple y fácil de usar, solo llame hideKeyboardFrom (YourActivity.this); para ocultar el teclado

/**
 * 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);
}

Respondido 21 Feb 17, 09:02

Agregue 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"/>

Respondido 04 Feb 16, 15:02

Para teclado abierto:

InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
imm.showSoftInput(edtView, InputMethodManager.SHOW_IMPLICIT);

Para cerrar / ocultar teclado:

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

Respondido 05 Feb 15, 15:02

Simplemente use este 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);
}

Respondido 25 Abr '15, 00:04

Funciona bien. Gracias - Alif

Tengo el caso, donde mi EditText se puede ubicar también en un AlertDialog, por lo que el teclado debe cerrarse al descartar. El siguiente código parece estar funcionando 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 );
}

Respondido 25 Abr '15, 00:04

Esta solución es mejor porque no tiene que controlar qué EditText pasa como parámetro al método hideSoftInputFromWindow (). ¡Funciona muy bien! - Billyjoker

Funciona como un toque mágico cada vez

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

Respondido 03 Jul 17, 16:07

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 a onTouchListener:

findViewById(android.R.id.content).setOnTouchListener(new OnTouchListener() {
    @Override
    public boolean onTouch(View v, MotionEvent event) {
        Utils.hideSoftKeyboard(activity);
        return false;
    }
});

contestado el 18 de mayo de 13 a las 08:05

Pruebe esto también, esto funcionó para mí: InputMethodManager imm = ((InputMethodManager) getSystemService (Activity.INPUT_METHOD_SERVICE)); imm.hideSoftInputFromWindow (getWindow (). getCurrentFocus (). getWindowToken (), 0); - zmicer

utilizar este

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

Respondido 09 ago 13, 17:08

No es la respuesta que estás buscando? Examinar otras preguntas etiquetadas or haz tu propia pregunta.