studio Cerrar / ocultar el teclado suave de Android




15 Answers

Puede forzar a Android a ocultar el teclado virtual usando el InputMethodManager , llamando a 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 hará que el teclado se oculte en todas las situaciones. En algunos casos, querrá pasar InputMethodManager.HIDE_IMPLICIT_ONLY como segundo parámetro para asegurarse de que solo oculta el teclado cuando el usuario no lo obligó explícitamente a aparecer (al mantener presionado el menú).

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

android hide keyboard on button click

Tengo un texto de 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 este es un simple código, pero ¿dónde puedo encontrar un ejemplo?




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




Por favor, intente este código a continuación en onCreate()

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



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



Saurabh Pareek tiene la mejor respuesta hasta ahora.

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



La respuesta corta

En su oyente OnClick llame a onEditorAction del EditText con IME_ACTION_DONE

button.setOnClickListener(new OnClickListener() {

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

El desglose

Creo 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 / tuvo el enfoque y también fue el que invocó el teclado en primer lugar (definitivamente es capaz de invocarlo en muchos escenarios comunes). De la misma manera, debe ser el que suelte el teclado, generalmente puede ser realizado por un ImeAction . Solo vea cómo se EditText un EditText con android:imeOptions="actionDone" , desea lograr el mismo comportamiento por los mismos medios.

Marque esta respuesta relacionada




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 se agregó setSoftInputShownOnFocus(boolean show) 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 versiones anteriores, obtuve muy buenos resultados (pero lejos de ser perfectos) con un OnGlobalLayoutListener , agregado 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 durante una fracción de segundo y desordenar los controles de selección.

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

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

Actualización: acabo de encontrar qué diálogos se usan para no mostrar nunca el teclado y funciona en todas las versiones:

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



He pasado más de dos días trabajando con todas las soluciones publicadas en el hilo y las he encontrado de una forma u otra. Mi requisito exacto es tener un botón que muestre u oculte el 100% de confiabilidad el teclado en pantalla. Cuando el teclado está en su estado oculto, no debe volver a aparecer, independientemente de los campos de entrada en los que el usuario haga clic. 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 RPN limpio .

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 confiablemente:

  1. Oculta temporalmente el teclado. Volverá a aparecer cuando un usuario enfoque un nuevo campo de texto.
  2. Muestre el teclado cuando comience una actividad y establezca un indicador en la actividad que indique que el teclado siempre debe estar visible. Este indicador solo se puede establecer cuando una actividad se está inicializando.
  3. Marque una actividad para nunca mostrar o permitir el uso del teclado. Este indicador solo se puede establecer cuando una actividad se está inicializando.

Para mí, esconder 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 utiliza varios campos de texto en una página, al enfocar un nuevo campo de texto, el teclado oculto volverá 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 o mostrar el teclado de forma permanente. El truco consiste en reiniciar su actividad cuando el usuario presiona el botón de activación del teclado. En mi aplicación, cuando el usuario presiona el botón 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 a través de 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 indica al InputMethodManager que muestre el teclado y se le indica a la ventana que haga que la entrada suave siempre esté visible. Si el teclado virtual debería estar oculto, se configurará el WindowManager.LayoutParams.FLAG_ALT_FOCUSABLE_IM.

Este enfoque funciona de manera confiable en todos los dispositivos 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 debe tener cuidado al manejar el botón Atrás. Como mi aplicación esencialmente solo tiene una pantalla (es una calculadora), puedo anular onBackPressed () y volver a la pantalla de inicio del dispositivo.




Gracias a esta respuesta SO , obtuve lo siguiente que, en mi caso, funciona bien cuando se desplaza 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);
    }
}



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

Pongo el botón "Atrás" entre comillas, ya que lo anterior no activa onBackPressed()la Actividad en cuestión. Solo 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 lo suficiente ).




Esto me funcionó para 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);
    }
}



utilizar esta

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



Casi he intentado todas estas respuestas, tuve algunos problemas aleatorios, especialmente con el Samsung Galaxy S5.

Lo que termino es forzar el show y el ocultamiento, 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);
}



Método simple y fácil de usar, simplemente llame a 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);
}



Tengo el caso, donde EditTextse puede ubicar también en una AlertDialog, por lo que el teclado debe cerrarse al cerrar. 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 );
}





Related