Android: muestre el teclado virtual de forma automática cuando el foco esté en EditText

Estoy mostrando un cuadro de entrada usando AlertDialog . El EditText dentro del cuadro de diálogo se enfoca automáticamente cuando llamo a AlertDialog.show() , pero el teclado AlertDialog.show() no se muestra automáticamente.

¿Cómo hago que el teclado virtual se muestre automáticamente cuando se muestra el cuadro de diálogo? (y no hay un teclado físico / de hardware). De forma similar a como presiono el botón Buscar para invocar la búsqueda global, el teclado virtual se muestra automáticamente.

Puede crear un oyente de enfoque en EditText en el AlertDialog y luego obtener la Window AlertDialog . Desde allí, puede mostrar el teclado setSoftInputMode llamando a setSoftInputMode .

 final AlertDialog dialog = ...; editText.setOnFocusChangeListener(new View.OnFocusChangeListener() { @Override public void onFocusChange(View v, boolean hasFocus) { if (hasFocus) { dialog.getWindow().setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_STATE_ALWAYS_VISIBLE); } } }); 

Para mostrar el uso del teclado:

 InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE); imm.toggleSoftInput(InputMethodManager.SHOW_FORCED,0); 

Para ocultar el uso del teclado:

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

Puede solicitar un teclado virtual justo después de crear el cuadro de diálogo (prueba en SDK – r20)

 // create dialog final AlertDialog dialog = ...; // request keyboard dialog.getWindow().setSoftInputMode (WindowManager.LayoutParams.SOFT_INPUT_STATE_ALWAYS_VISIBLE); 

Tuve el mismo problema y lo resolví con el siguiente código. No estoy seguro de cómo se comportará en un teléfono con teclado de hardware.

 // TextEdit final EditText textEdit = new EditText(this); // Builder AlertDialog.Builder alert = new AlertDialog.Builder(this); alert.setTitle("Enter text"); alert.setView(textEdit); alert.setPositiveButton("Ok", new DialogInterface.OnClickListener() { @Override public void onClick(DialogInterface dialog, int which) { String text = textEdit.getText().toString(); finish(); } }); alert.setNegativeButton("Cancel", new DialogInterface.OnClickListener() { @Override public void onClick(DialogInterface dialog, int which) { finish(); } }); // Dialog AlertDialog dialog = alert.create(); dialog.setOnShowListener(new OnShowListener() { @Override public void onShow(DialogInterface dialog) { InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE); imm.showSoftInput(textEdit, InputMethodManager.SHOW_IMPLICIT); } }); dialog.show(); 

Encontré este ejemplo http://android-codes-examples.blogspot.com/2011/11/show-or-hide-soft-keyboard-on-opening.html . Agregue el siguiente código justo antes de alert.show() .

 InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE); imm.toggleSoftInput(InputMethodManager.SHOW_FORCED,0); 
   

o

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

Los fragmentos de código de otras respuestas funcionan, pero no siempre es obvio dónde colocarlos en el código, especialmente si está utilizando un AlertDialog.Builder y siguió el tutorial de diálogo oficial porque no usa final AlertDialog ... o alertDialog.show() .

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

Es preferible

 InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE); imm.toggleSoftInput(InputMethodManager.SHOW_FORCED,0); 

Porque SOFT_INPUT_STATE_ALWAYS_VISIBLE ocultará el teclado si el foco cambia de EditText, donde SHOW_FORCED mantendrá el teclado mostrado hasta que se rechace explícitamente, incluso si el usuario regresa a la pantalla de inicio o muestra las aplicaciones recientes.

A continuación se muestra el código de trabajo para un AlertDialog creado utilizando un diseño personalizado con un EditText definido en XML. También establece que el teclado tenga una tecla “ir” y le permite activar el botón positivo.

alert_dialog.xml:

      

AlertDialog.java:

 import android.app.Activity; import android.app.Dialog; import android.content.DialogInterface; import android.graphics.drawable.BitmapDrawable; import android.graphics.drawable.Drawable; import android.os.Bundle; import android.support.annotation.NonNull; import android.support.v4.app.DialogFragment; import android.support.v7.app.AlertDialog; import android.support.v7.app.AppCompatDialogFragment; import android.view.KeyEvent; import android.view.LayoutInflater; import android.view.View; import android.view.WindowManager; import android.widget.EditText; public class CreateDialog extends AppCompatDialogFragment { // The public interface is used to send information back to the activity that called CreateDialog. public interface CreateDialogListener { void onCreateDialogCancel(DialogFragment dialog); void onCreateDialogOK(DialogFragment dialog); } CreateDialogListener mListener; // Check to make sure that the activity that called CreateDialog implements both listeners. public void onAttach(Activity activity) { super.onAttach(activity); try { mListener = (CreateDialogListener) activity; } catch (ClassCastException e) { throw new ClassCastException(activity.toString() + " must implement CreateDialogListener."); } } // onCreateDialog requires @NonNull. @Override @NonNull public Dialog onCreateDialog(Bundle savedInstanceState) { AlertDialog.Builder alertDialogBuilder = new AlertDialog.Builder(getActivity()); LayoutInflater customDialogInflater = getActivity().getLayoutInflater(); // Setup dialogBuilder. alertDialogBuilder.setTitle(R.string.title); alertDialogBuilder.setView(customDialogInflater.inflate(R.layout.alert_dialog, null)); alertDialogBuilder.setNegativeButton(R.string.cancel, new DialogInterface.OnClickListener() { @Override public void onClick(DialogInterface dialog, int which) { mListener.onCreateDialogCancel(CreateDialog.this); } }); alertDialogBuilder.setPositiveButton(R.string.ok, new DialogInterface.OnClickListener() { @Override public void onClick(DialogInterface dialog, int which) { mListener.onCreateDialogOK(CreateDialog.this); } }); // Assign the resulting built dialog to an AlertDialog. final AlertDialog alertDialog = alertDialogBuilder.create(); // Show the keyboard when the dialog is displayed on the screen. alertDialog.getWindow().setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_STATE_ALWAYS_VISIBLE); // We need to show alertDialog before we can setOnKeyListener below. alertDialog.show(); EditText editText = (EditText) alertDialog.findViewById(R.id.editText); // Allow the "enter" key on the keyboard to execute "OK". editText.setOnKeyListener(new View.OnKeyListener() { public boolean onKey(View v, int keyCode, KeyEvent event) { // If the event is a key-down event on the "enter" button, select the PositiveButton "OK". if ((event.getAction() == KeyEvent.ACTION_DOWN) && (keyCode == KeyEvent.KEYCODE_ENTER)) { // Trigger the create listener. mListener.onCreateDialogOK(CreateDialog.this); // Manually dismiss alertDialog. alertDialog.dismiss(); // Consume the event. return true; } else { // If any other key was pressed, do not consume the event. return false; } } }); // onCreateDialog requires the return of an AlertDialog. return alertDialog; } } 

Eche un vistazo a esta discusión que trata de ocultar manualmente y mostrar el IME. Sin embargo, mi sensación es que si un EditText enfocado no sube el IME es porque está llamando a AlertDialog.show() en su OnCreate() u otro método que se evoca antes de que se presente la pantalla. Moviéndolo a OnPostResume() debería arreglarlo en ese caso, creo.

Permítanme señalar alguna información adicional a la solución de yuku, ¡porque me resultó difícil hacerlo funcionar! ¿Cómo obtengo el objeto AlertDialog de mi AlertDialog.Builder? Bueno, es el resultado de mi ejecución de alert.show() :

 final AlertDialog.Builder alert = new AlertDialog.Builder(getActivity()); final EditText input = new EditText(getActivity()); alert.setView(input); // do what you need, like setting positive and negative buttons... final AlertDialog dialog = alert.show(); input.setOnFocusChangeListener(new OnFocusChangeListener() { @Override public void onFocusChange(View v, boolean hasFocus) { if(hasFocus) { dialog.getWindow().setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_STATE_ALWAYS_VISIBLE); } } }); 

Bueno, esta es una publicación bastante antigua, todavía hay algo que agregar.
Estos son 2 métodos simples que me ayudan a mantener el teclado bajo control y funcionan perfectamente:

Mostrar teclado

 public void showKeyboard() { InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE); View v = getCurrentFocus(); if (v != null) imm.showSoftInput(v, 0); } 

Ocultar teclado

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

Sí, puede hacerlo con setOnFocusChangeListener lo ayudará.

 editText.setOnFocusChangeListener(new View.OnFocusChangeListener() { @Override public void onFocusChange(View v, boolean hasFocus) { if (hasFocus) { dialog.getWindow().setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_STATE_ALWAYS_VISIBLE); } } }); 

Si alguien está recibiendo:

No se puede hacer una referencia estática al método no estático getSystemService (String) del tipo Activity

Intente agregar contexto a la llamada getSystemService.

Asi que

 InputMethodManager imm = (InputMethodManager) context.getSystemService(Context.INPUT_METHOD_SERVICE); imm.toggleSoftInput(InputMethodManager.SHOW_FORCED,0); 

La pregunta original se refiere a Diálogos y mi EditText está en una vista regular. De todos modos, sospecho que esto también debería funcionar para la mayoría de ustedes. Así que esto es lo que funciona para mí (el método más alto sugerido anteriormente no me sirvió). Aquí hay un EditView personalizado que hace esto (no es necesario crear subclases, pero lo encontré conveniente para mis propósitos ya que también quería captar el foco cuando la vista se vuelve visible).

Esto en realidad es en gran medida lo mismo que la respuesta tidbecks. De hecho, no me di cuenta de su respuesta ya que tenía cero votos. Entonces estaba a punto de comentar su publicación, pero hubiera sido demasiado largo, así que terminé haciendo esta publicación de todos modos. tidbeck señala que no está seguro de cómo funciona con dispositivos que tienen teclados. Puedo confirmar que el comportamiento parece ser exactamente el mismo en ambos casos. Eso es tal que en el modo retrato, el teclado del software aparece y, en el paisaje, no. Tener el teclado físico deslizado o no hace ninguna diferencia en mi teléfono.

Porque, personalmente, me pareció un tanto incómodo el comportamiento que opté por usar: InputMethodManager.SHOW_FORCED . Esto funciona como yo quería que funcione. El teclado se vuelve visible independientemente de la orientación, sin embargo, al menos en mi dispositivo no aparece si el teclado del hardware se ha deslizado.

 import android.app.Service; import android.content.Context; import android.util.AttributeSet; import android.view.View; import android.view.inputmethod.InputMethodManager; import android.widget.EditText; public class BringOutTheSoftInputOnFocusEditTextView extends EditText { protected InputMethodManager inputMethodManager; public BringOutTheSoftInputOnFocusEditTextView(Context context, AttributeSet attrs, int defStyle) { super(context, attrs, defStyle); init(); } public BringOutTheSoftInputOnFocusEditTextView(Context context, AttributeSet attrs) { super(context, attrs); init(); } public BringOutTheSoftInputOnFocusEditTextView(Context context) { super(context); init(); } private void init() { this.inputMethodManager = (InputMethodManager)getContext().getSystemService(Service.INPUT_METHOD_SERVICE); this.setOnFocusChangeListener(new View.OnFocusChangeListener() { @Override public void onFocusChange(View v, boolean hasFocus) { if (hasFocus) { BringOutTheSoftInputOnFocusEditTextView.this.inputMethodManager.showSoftInput(BringOutTheSoftInputOnFocusEditTextView.this, InputMethodManager.SHOW_FORCED); } } }); } @Override protected void onVisibilityChanged(View changedView, int visibility) { super.onVisibilityChanged(changedView, visibility); if (visibility == View.VISIBLE) { BringOutTheSoftInputOnFocusEditTextView.this.requestFocus(); } } } 

El problema parece ser que, dado que el lugar donde ingresa el texto está oculto inicialmente (o nested o algo así), AlertDialog establece automáticamente el indicador WindowManager.LayoutParams.FLAG_ALT_FOCUSABLE_IM o WindowManager.LayoutParams.FLAG_NOT_FOCUSABLE para que las cosas no desencadenen una entrada suave para mostrar.

La forma de solucionar esto es agregar lo siguiente:

 (...) // Create the dialog and show it Dialog dialog = builder.create() dialog.show(); // After show (this is important specially if you have a list, a pager or other view that uses a adapter), clear the flags and set the soft input mode dialog.getWindow().clearFlags(WindowManager.LayoutParams.FLAG_NOT_FOCUSABLE|WindowManager.LayoutParams.FLAG_ALT_FOCUSABLE_IM); dialog.getWindow().setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_STATE_ALWAYS_VISIBLE); 

prueba y usa:

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

Para mostrar el teclado, para mí, tenía que hacer lo siguiente

Android TextField: establece el foco + entrada suave programáticamente

Esencialmente, la solución es la siguiente

 @Override public void onResume() { super.onResume(); //passwordInput.requestFocus(); <-- that doesn't work passwordInput.postDelayed(new ShowKeyboard(), 325); //250 sometimes doesn't run if returning from LockScreen } 

Donde ShowKeyboard es

 private class ShowKeyboard implements Runnable { @Override public void run() { passwordInput.setFocusableInTouchMode(true); //passwordInput.requestFocusFromTouch(); //this gives touch event to launcher in background -_- passwordInput.requestFocus(); getActivity().getWindow().setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_STATE_ALWAYS_VISIBLE); ((InputMethodManager) getActivity().getSystemService(Context.INPUT_METHOD_SERVICE)).showSoftInput(passwordInput, 0); } } 

Después de una entrada exitosa, también me aseguro de ocultar el teclado

 getActivity().getWindow().setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_STATE_HIDDEN); ((InputMethodManager) getActivity().getSystemService(Context.INPUT_METHOD_SERVICE)) .hideSoftInputFromWindow(getView().getWindowToken(), 0); 

Esta es una buena muestra para ti:

              

¿Por qué esta respuesta? Porque la solución anterior mostrará tu teclado pero no se desvanecerá si haces clic en cualquier otro lugar que EditText . Entonces, necesitas hacer algo para que desaparezca EditText cuando EditText pierda el foco.

Puede lograrlo siguiendo estos pasos:

  1. Haga que la vista principal (vista de contenido de su actividad) pueda hacer clic y enfocarse agregando los siguientes atributos

      android:clickable="true" android:focusableInTouchMode="true" 
  2. Implementar un método hideKeyboard ()

      public void hideKeyboard(View view) { InputMethodManager inputMethodManager =(InputMethodManager)getSystemService(Activity.INPUT_METHOD_SERVICE); inputMethodManager.hideSoftInputFromWindow(view.getWindowToken(),InputMethodManager.HIDE_IMPLICIT_ONLY ); } 
  3. Por último, configure el onFocusChangeListener de su texto de edición.

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

Esto es un poco complicado. Lo hice de esta manera y funcionó.

1.En la primera llamada para ocultar la Entrada suave de la ventana. Esto ocultará la entrada suave si el teclado virtual está visible o no hará nada si no lo está.

2. Muestra tu diálogo

3. Luego simplemente llame para alternar la entrada suave.

código:

 InputMethodManager inputManager = (InputMethodManager)getSystemService(Context.INPUT_METHOD_SERVICE); //hiding soft input inputManager.hideSoftInputFromWindow(findViewById(android.R.id.content).getWind‌​owToken(), 0); //show dialog yourDialog.show(); //toggle soft input inputManager.toggleSoftInput(InputMethodManager.SHOW_FORCED,InputMethodManager.SHOW_IMPLICIT); 

Prueba esto

SomeUtils.java

 public static void showKeyboard(Activity activity, boolean show) { InputMethodManager inputMethodManager = (InputMethodManager) activity.getSystemService(Context.INPUT_METHOD_SERVICE); if(show) inputMethodManager.toggleSoftInput(InputMethodManager.SHOW_FORCED,0); else inputMethodManager.toggleSoftInput(InputMethodManager.HIDE_IMPLICIT_ONLY,0); }