Cómo mostrar el teclado virtual cuando edittext está enfocado

Quiero mostrar automáticamente el teclado virtual cuando un EditTextfoco está enfocado (si el dispositivo no tiene un teclado físico) y tengo dos problemas:

1. Cuando Activityse muestra my, mi EditTextestá enfocado pero el teclado no se muestra, necesito hacer clic nuevamente para mostrar el teclado (debe mostrarse cuando Activityse muestra my ).

2. Y cuando hago clic en Listo en el teclado, el teclado se descarta pero EditTextpermanece enfocado y no quiero (porque mi edición está hecha).

Para resumir, mi problema es tener algo más parecido al iPhone: que mantiene la sincronización del teclado con mi EditTextestado (enfocado / no enfocado) y, por supuesto, no presenta un teclado virtual si hay uno físico.

Para forzar la aparición del teclado virtual, puede usar

EditText yourEditText= (EditText) findViewById(R.id.yourEditText);
yourEditText.requestFocus();
InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
imm.showSoftInput(yourEditText, InputMethodManager.SHOW_IMPLICIT);

Y para eliminar el enfoque EditText, lamentablemente necesita tener un maniquí Viewpara enfocar.

espero que esto ayude

Para cerrarlo puedes usar

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

Esto funciona para usarlo en un diálogo

public void showKeyboard(){
    InputMethodManager inputMethodManager = (InputMethodManager) context.getSystemService(Context.INPUT_METHOD_SERVICE);
    inputMethodManager.toggleSoftInput(InputMethodManager.SHOW_FORCED, 0);
}

public void closeKeyboard(){
    InputMethodManager inputMethodManager = (InputMethodManager) context.getSystemService(Context.INPUT_METHOD_SERVICE);
    inputMethodManager.toggleSoftInput(InputMethodManager.HIDE_IMPLICIT_ONLY, 0);
}

Yo tuve el mismo problema. Inmediatamente después de que editText VISIBILITY cambiara de GONE a VISIBLE, tuve que establecer el enfoque y mostrar el teclado virtual. Lo logré usando el siguiente código:

new Handler().postDelayed(new Runnable() {

    public void run() {
//        ((EditText) findViewById(R.id.et_find)).requestFocus();
//              
        EditText yourEditText= (EditText) findViewById(R.id.et_find);
//        InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
//        imm.showSoftInput(yourEditText, InputMethodManager.SHOW_IMPLICIT);

        yourEditText.dispatchTouchEvent(MotionEvent.obtain(SystemClock.uptimeMillis(), SystemClock.uptimeMillis(), MotionEvent.ACTION_DOWN , 0, 0, 0));
        yourEditText.dispatchTouchEvent(MotionEvent.obtain(SystemClock.uptimeMillis(), SystemClock.uptimeMillis(), MotionEvent.ACTION_UP , 0, 0, 0));                           
    }
}, 200);

Funciona para mí con un retraso de 100 ms, pero falló sin demora o solo con un retraso de 1 ms.

La parte comentada del código muestra otro enfoque, que funciona solo en algunos dispositivos. Probé en las versiones del sistema operativo 2.2 (emulador), 2.2.1 (dispositivo real) y 1.6 (emulador).

Este enfoque me ahorró mucho dolor.

Para que aparezca el teclado, use

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

Este método es más confiable que invocar directamente InputMethodManager.

Para cerrarlo, use

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

Cuando nada más funciona, obliga a que se muestre :

editText.requestFocus();
InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
imm.toggleSoftInput(InputMethodManager.SHOW_FORCED, InputMethodManager.HIDE_IMPLICIT_ONLY);

Y luego, si desea cerrarlo, en onPause (), por ejemplo, puede llamar a:

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

El siguiente código es sacado del código fuente 4.1 de Google para SearchView. Parece funcionar, bien en versiones menores de Android también.

private Runnable mShowImeRunnable = new Runnable() {
    public void run() {
        InputMethodManager imm = (InputMethodManager) getContext()
                .getSystemService(Context.INPUT_METHOD_SERVICE);

        if (imm != null) {
            imm.showSoftInput(editText, 0);
        }
    }
};

private void setImeVisibility(final boolean visible) {
    if (visible) {
        post(mShowImeRunnable);
    } else {
        removeCallbacks(mShowImeRunnable);
        InputMethodManager imm = (InputMethodManager) getContext()
                .getSystemService(Context.INPUT_METHOD_SERVICE);

        if (imm != null) {
            imm.hideSoftInputFromWindow(getWindowToken(), 0);
        }
    }
}

Luego, además, se debe agregar el siguiente código a medida que se crea Control / Activity. (En mi caso, es un control compuesto, en lugar de una actividad).

this.editText.setOnFocusChangeListener(new View.OnFocusChangeListener() {
    public void onFocusChange(View v, boolean hasFocus) {
        setImeVisibility(hasFocus);
    }
});

android:windowSoftInputMode="stateAlwaysVisible" -> en archivo de manifiesto.

edittext.requestFocus(); -> en código.

Esto abrirá un teclado virtual en el que editar texto tiene el foco de solicitud a medida que aparece la actividad.

He tenido algo de suerte reciente en algunos casos simples con el código a continuación. No he terminado todas las pruebas pero ...

EditText input = (EditText) findViewById(R.id.Input);
input.requestFocus();    
input.dispatchTouchEvent(MotionEvent.obtain(SystemClock.uptimeMillis(), SystemClock.uptimeMillis(), MotionEvent.ACTION_DOWN , 0, 0, 0));
input.dispatchTouchEvent(MotionEvent.obtain(SystemClock.uptimeMillis(), SystemClock.uptimeMillis(), MotionEvent.ACTION_UP , 0, 0, 0));

Y presto aparece el teclado.

Puedes intentar forzar la aparición del teclado virtual, funciona para mí:

...
dialog.show();
input.requestFocus();
InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
imm.toggleSoftInput(InputMethodManager.SHOW_FORCED, 0);

A veces la respuesta de raukodraug no funciona. Lo hice de esta manera con algunas pruebas y errores:

public static void showKeyboard(Activity activity) {
    if (activity != null) {
        activity.getWindow()
                .setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_STATE_ALWAYS_VISIBLE);
    }
}

public static void hideKeyboard(Activity activity) {
    if (activity != null) {
        activity.getWindow()
                .setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_STATE_ALWAYS_HIDDEN);
    }
}

Y la parte EditText :

    editText.setOnFocusChangeListener(new View.OnFocusChangeListener() {
        @Override
        public void onFocusChange(View v, boolean hasFocus) {
            if (!hasFocus) {
                hideKeyboard(getActivity());
            } else {
                showKeyboard(getActivity());
            }
        }
    });

Para ocultar el teclado, use este:

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

y para mostrar el teclado:

getActivity().getWindow().setSoftInputMode(
    WindowManager.LayoutParams.SOFT_INPUT_STATE_ALWAYS_VISIBLE);

Y para Kotlin solo use estas extensiones:

fun EditText.showKeyboard() {
    val imm = context.getSystemService(Context.INPUT_METHOD_SERVICE) as InputMethodManager
    imm.showSoftInput(this, InputMethodManager.SHOW_IMPLICIT)
}

fun EditText.hideKeyboard() {
    val imm = context.getSystemService(Context.INPUT_METHOD_SERVICE) as InputMethodManager
    imm.hideSoftInputFromWindow(this.windowToken, 0)
}

Por fragmento, seguro que está funcionando:

 displayName = (EditText) view.findViewById(R.id.displayName);
    InputMethodManager imm = (InputMethodManager) getActivity().getSystemService(Context.INPUT_METHOD_SERVICE);
    imm.toggleSoftInput(InputMethodManager.SHOW_FORCED, 0);

showSoftInput no estaba funcionando para mí en absoluto.

Pensé que necesitaba establecer el modo de entrada: (aquí en el componente Actividad en el manifiesto)

android:windowSoftInputMode="stateVisible" 

Creer o no mi problema con Soft Keyboard se resolvió cuando descubrí que las animaciones de Actividades pueden deshabilitar el Soft Keyboard. Cuando llamas a la intención con el

i.setFlags(Intent.FLAG_ACTIVITY_NO_ANIMATION);

y

overridePendingTransition(0, 0);

Puede ocultar el teclado suave y no hay forma de mostrarlo.

Tuve el mismo problema en varias situaciones diferentes, y las soluciones que encontré funcionan en algunas, pero no funcionan en otras, así que aquí hay una solución combinada que funciona en la mayoría de las situaciones que he encontrado:

public static void showVirtualKeyboard(Context context, final View view) {
    if (context != null) {
        final InputMethodManager imm =  (InputMethodManager) context.getSystemService(Context.INPUT_METHOD_SERVICE);
        view.clearFocus();

        if(view.isShown()) {
            imm.showSoftInput(view, 0);
            view.requestFocus();
        } else {
            view.addOnAttachStateChangeListener(new View.OnAttachStateChangeListener() {
                @Override
                public void onViewAttachedToWindow(View v) {
                    view.post(new Runnable() {
                        @Override
                        public void run() {
                            view.requestFocus();
                            imm.showSoftInput(view, 0);
                        }
                    });

                    view.removeOnAttachStateChangeListener(this);
                }

                @Override
                public void onViewDetachedFromWindow(View v) {
                    view.removeOnAttachStateChangeListener(this);
                }
            });
        }
    }
}

editText.post(new Runnable() {
    @Override
    public void run() {
        InputMethodManager imm = (InputMethodManager) getActivity().getSystemService(Context.INPUT_METHOD_SERVICE);
        imm.showSoftInput(editText, InputMethodManager.SHOW_IMPLICIT);
    }
});

Combiné todo aquí y para mí funciona:

public static void showKeyboardWithFocus(View v, Activity a) {
    try {
        v.requestFocus();
        InputMethodManager imm = (InputMethodManager) a.getSystemService(Context.INPUT_METHOD_SERVICE);
        imm.showSoftInput(v, InputMethodManager.SHOW_IMPLICIT);
        a.getWindow().setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_STATE_VISIBLE);
    } catch (Exception e) {
        e.printStackTrace();
    }
}

Funcionó para mi. Puedes probar con esto también para mostrar el teclado:

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

fragmento de código . . .

public void hideKeyboard(Context activityContext){

    InputMethodManager imm = (InputMethodManager)
            activityContext.getSystemService(Context.INPUT_METHOD_SERVICE);

    //android.R.id.content ( http://stackoverflow.com/a/12887919/2077479 )
    View rootView = ((Activity) activityContext)
            .findViewById(android.R.id.content).getRootView();

    imm.hideSoftInputFromWindow(rootView.getWindowToken(), 0);
}

public void showKeyboard(Context activityContext, final EditText editText){

    final InputMethodManager imm = (InputMethodManager)
            activityContext.getSystemService(Context.INPUT_METHOD_SERVICE);

    if (!editText.hasFocus()) {
        editText.requestFocus();
    }

    editText.post(new Runnable() {
        @Override
        public void run() {
            imm.showSoftInput(editText, InputMethodManager.SHOW_FORCED);
        }
    });
}

Kotlin extensión para mostrar el teclado en foco.

Esta es una combinación de respuestas anteriores, que eran demasiado largas o incompletas.

Esta extensión publica un ejecutable en la cola de mensajes que muestra el teclado virtual después de solicitar el foco:

fun View.showSoftKeyboard() {
    post {
        if (this.requestFocus()) {
            val imm = context.getSystemService(Context.INPUT_METHOD_SERVICE) as InputMethodManager
            imm?.showSoftInput(this, InputMethodManager.SHOW_IMPLICIT)
        }
    }
}

Llámalo desde cualquier vista cuando sea necesario después:

editText.showSoftKeyboard()

simplemente agregue android: windowSoftInputMode = "stateHidden" en el archivo de manifiesto ...

final InputMethodManager keyboard = (InputMethodManager) ctx.getSystemService(Context.INPUT_METHOD_SERVICE);
keyboard.toggleSoftInput(InputMethodManager.SHOW_FORCED,0);

Dentro de tu manifiesto:

android:windowSoftInputMode="stateAlwaysVisible"- Teclado lanzado inicialmente. android:windowSoftInputMode="stateAlwaysHidden" - Teclado inicialmente oculto.

También me gusta usarlo "adjustPan"porque cuando se inicia el teclado, la pantalla se ajusta automáticamente.

 <activity
      android:name="YourActivity"
      android:windowSoftInputMode="stateAlwaysHidden|adjustPan"/>

Simplemente agregue esta línea en su vista EditText:

android:isScrollContainer="true"

y TADA: ¡el teclado comenzó a aparecer automáticamente!

Tuve un problema similar y descubrí esta solución simple y extraña.

Como ya se mencionó aquí por el usuario 3392439, la apariencia del teclado al enfocarse de alguna manera extrañamente conectada con la presencia del componente de desplazamiento en el archivo XML.

Incluso la presencia de otra vista EditText que comprende la línea mencionada anteriormente en el mismo XML hace que el teclado aparezca sin importar cuál de EditTexts esté enfocado actualmente.

Si tiene al menos una vista visible que comprende un componente de desplazamiento en su archivo XML, el teclado aparecerá automáticamente en foco.

Si no hay desplazamiento, debe hacer clic en Editar texto para que aparezca el teclado.

Todas las soluciones dadas anteriormente (la interacción InputMethodManager en OnFocusChangeListener.onFocusChange oyente adjunto a su EditText funciona bien si tiene edición única en la actividad.

En mi caso tengo dos ediciones.

 private EditText tvX, tvY;
 protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
 tvX.setOnFocusChangeListener(this);
    tvY.setOnFocusChangeListener(this);

@Override
public void onFocusChange(View v, boolean hasFocus) {       
    InputMethodManager imm =  (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
    if(tvX.hasFocus() || tvY.hasFocus()) {            
        imm.showSoftInput(v, 0);            
    } else {
        imm.hideSoftInputFromWindow(v.getWindowToken(), 0);         
    }       
};

He observado que onFocusChange se activa para tvX con hasFocus = true (se muestra el teclado) pero luego para tvY con hasFocus = true (teclado oculto). Al final, no se veía ningún teclado.

La solución general debe tener una declaración correcta en if "show keyboard if EditText text is focus"

En su sección onResume () de la Actividad, puede llamar al método bringKeyboard ();

 onResume() {
     EditText yourEditText= (EditText) findViewById(R.id.yourEditText);
     bringKeyboard(yourEditText);
 }


  protected boolean bringKeyboard(EditText view) {
    if (view == null) {
        return false;
    }
    try {
      // Depending if edittext has some pre-filled values you can decide whether to bring up soft keyboard or not
        String value = view.getText().toString();
        if (value == null) {
            InputMethodManager imm = (InputMethodManager)context.getSystemService(Context.INPUT_METHOD_SERVICE);
            imm.hideSoftInputFromWindow(view.getWindowToken(), 0);
            return true;
        }
    } catch (Exception e) {
        Log.e(TAG, "decideFocus. Exception", e);
    }
    return false;
  }

Ninguna de las respuestas funcionó para mí. Aquí hay una manera simple.

searchEditText.setVisibility(View.VISIBLE);
                final Handler handler=new Handler();
                handler.postDelayed(new Runnable() {
                    @Override
                    public void run() {
                        searchEditText.requestFocus();
                    }
                }, 400);

Solo retrasé el método requestFocus () durante 400 ms.

Descubrí un comportamiento extraño, ya que en una de mis aplicaciones, el teclado virtual se mostraba automáticamente al ingresar a la actividad (hay un editText.requestFocus () en onCreate).

Al investigar más, descubrí que esto se debía a que hay un ScrollView alrededor del diseño. Si elimino el ScrollView, el comportamiento es como se describe en la declaración del problema original: solo al hacer clic en editText ya enfocado aparece el teclado virtual.

Si no funciona para usted, intente poner un ScrollView, de todos modos es inofensivo.

Tuve un problema similar al usar animaciones de vista . Así que puse un oyente de animación para asegurarme de que esperaría a que terminara la animación antes de intentar solicitar un acceso de teclado en el texto de edición que se muestra.

    bottomUp.setAnimationListener(new Animation.AnimationListener() {
        @Override
        public void onAnimationStart(Animation animation) {
        }

        @Override
        public void onAnimationEnd(Animation animation) {
            if (textToFocus != null) {
                // Position cursor at the end of the text
                textToFocus.setSelection(textToFocus.getText().length());
                // Show keyboard
                InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
                imm.showSoftInput(textToFocus, InputMethodManager.SHOW_IMPLICIT);
            }
        }

        @Override
        public void onAnimationRepeat(Animation animation) {
        }
    });

Estoy de acuerdo con el raukodraug para usarlo en una vista rápida, debe solicitar / enfocar de esta manera:

    final ViewSwitcher viewSwitcher = (ViewSwitcher) findViewById(R.id.viewSwitcher);
    final View btn = viewSwitcher.findViewById(R.id.address_btn);
    final View title = viewSwitcher.findViewById(R.id.address_value);

    title.setOnClickListener(new View.OnClickListener() {
        @Override
        public void onClick(View view) {
            viewSwitcher.showPrevious();
            btn.requestFocus();
            InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
            imm.showSoftInput(btn, InputMethodManager.SHOW_IMPLICIT);
        }
    });

    // EditText affiche le titre evenement click
    btn.setOnClickListener(new View.OnClickListener() {
        @Override
        public void onClick(View view) {
            btn.clearFocus();
            viewSwitcher.showNext();
            InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
            imm.hideSoftInputFromWindow(btn.getWindowToken(), 0);
            // Enregistre l'adresse.
            addAddress(view);
        }
    });

Saludos.