when Cerrar/ocultar el teclado suave de Android




ocultar teclado android studio (24)

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?


Para ayudar a aclarar esta locura, me gustaría comenzar disculpándome en nombre de todos los usuarios de Android por el trato absolutamente ridículo de Google del teclado suave. La razón por la que hay tantas respuestas, cada una diferente, para la misma pregunta simple es porque esta API, como muchas otras en Android, está diseñada horriblemente. No se me ocurre ninguna forma educada 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. Debe usar el InputMethodManager para ocultar el teclado. Bien, esta es la API de Android para el teclado. ¡PERO! Debe tener un Context para poder 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 ni necesidad de ningún Context . o Y, lo que es peor, el IMM requiere que especifique qué View (o, peor aún, qué Window ) quiere ocultar el teclado.

Esto es lo que hace tan difícil ocultar el teclado. Estimado Google: Cuando estoy buscando la receta de un pastel, no hay ningún RecipeProvider de RecipeProvider en la Tierra que se niegue a proporcionarme la receta a menos que primero responda QUIÉN se comerá el pastel ¡Y dónde se lo comerá!

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

He creado un método de utilidad estática que puede hacer el trabajo MUY sólidamente, siempre que lo llame desde una 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 una Activity ! El método anterior llama a getCurrentFocus de la Activity destino para obtener el token de ventana adecuado.

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

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

Esto no funcionará porque pasará una referencia a la Activity host del Fragment , que no tendrá un control enfocado mientras se muestre el Fragment . ¡Guauu! Entonces, para ocultar el teclado de los fragmentos, recurro al 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 desperdiciado buscando esta solución:

Acerca de windowSoftInputMode

Hay otro punto de discusión que hay que tener en cuenta. De forma predeterminada, Android asignará automáticamente el enfoque inicial al primer texto de EditText o control EditText en su Activity . Naturalmente, se sigue que InputMethod (normalmente el teclado virtual) responderá al evento de enfoque mostrándose a sí mismo. El atributo windowSoftInputMode 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 se asignen al control focusable="false" y / o focusableInTouchMode="false" ). Aparentemente, la configuración windowSoftInputMode se aplica solo a los eventos de enfoque automático, no a los eventos activados por eventos táctiles.

Por lo tanto, stateAlwaysHidden está MUY pobremente llamado. Tal vez debería llamarse ignoreInitialFocus en ignoreInitialFocus lugar.

Espero que esto ayude.

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

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

Dado un fragmento de 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: Desactive el enfoque para evitar mostrar el teclado nuevamente si abre la aplicación desde el fondo

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

view.clearFocus();


Como alternativa a esta solución general , si desea cerrar el teclado virtual desde cualquier lugar sin tener una referencia al campo (Editar Texto) que se usó para abrir el teclado, pero aún así quería hacerlo si el campo estaba enfocado, podría usar esto (de una actividad):

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

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.


utilizar esta

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

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

Así es como lo haces en Mono para Android (AKA MonoDroid)

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

Las respuestas anteriores funcionan para diferentes escenarios, pero si desea ocultar el teclado dentro de una vista y tener 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, obténgalo del constructor :)

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

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

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.


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

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

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

En algunos casos, este método puede funcionar excepto de todos los demás. Esto me salva el 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);
        }
    }
}

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

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

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

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.


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


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

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


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

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

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

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

Cree una función con la que administrará algunas de las propiedades de EditText :

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

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

Luego, asegúrese de que en Foco del texto de EditText abra / cierre 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, cuando quieras abrir el teclado manualmente llama:

setEditTextFocus(true);

Y para cierre de convocatoria:

setEditTextFocus(false);




soft-keyboard