Android: muestra el teclado virtual automáticamente cuando el foco está en EditText


340

Estoy mostrando un cuadro de entrada usando AlertDialog. El EditTextinterior del cuadro de diálogo se enfoca automáticamente cuando llamo AlertDialog.show(), pero el teclado virtual 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 teclado físico / hardware). Similar a cómo cuando presiono el botón Buscar para invocar la búsqueda global, el teclado virtual se muestra automáticamente.


1
Esto debería suceder automáticamente, según el comentario de Ted a continuación. ¡Comprueba eso primero!
Cheezmeister el

Esta respuesta es muy simple y funciona bien: stackoverflow.com/a/8018630/89818
caw


1
He vuelto a esta respuesta varias veces a lo largo de los años. Siempre está dentro de un Diálogo que tengo este problema, nunca Fragmento o Actividad.
tir38

Respuestas:


304

Puede crear un oyente de enfoque EditTexten el AlertDialog, luego obtener el AlertDialog's Window. Desde allí se puede hacer el espectáculo teclado de software llamando 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);
        }
    }
});

55
¿Cómo lo haría usando AlertDialog.Builder? ... alerta final de AlertDialog.Builder = nuevo AlertDialog.Builder (Main.this);
Stephen

66
@Stephen puede obtener el diálogo del generador utilizando final AlertDialog dialog = builder.create()y luego showen el diálogo en lugar del generador.
tidbeck

30
RECUPERO MI COMENTARIO ANTERIOR ¡ Descubrí que si no puede enfocar correctamente, eche un vistazo a su XML! Si ve la etiqueta <requestFocus> </requestFocus> allí, elimínela. Parece que la etiqueta enfocará el EditText, y luego su oyente no será despedido ya que el EditText ya tiene el foco.
Ted

11
¿Cómo no haces esto si el dispositivo tiene un teclado de hardware? Parece que esto es molesto para esos usuarios.
mxcl

8
Realmente no entiendo por qué este no es el comportamiento predeterminado en el SDK. Si una vista que necesita ingreso de texto muestra un cursor parpadeante, ¿por qué alguien no querría ver el teclado para ingresar texto? Se siente tan mal de UX para mí
Christian García

240

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

3
Esto funciona particularmente bien cuando desea mostrar / ocultar el teclado virtual basado en alternar la visibilidad de una vista en su diseño entre VISIBLE y GONE.
PacificSky

38
Sugeriría usar el indicador SHOW_IMPLICIT en su lugar, ya que significa que cambiar la actividad o la aplicación ocultará automáticamente el teclado como se esperaba.
drspaceboo

66
@drspaceboo Usar SHOW_IMPLICIT no funciona para mí, tengo que usar SHOW_FORCED, no estoy seguro de por qué ...
Yoann Hercouet

1
¿Cuándo se debe ejecutar el código anterior? Intenté hacerlo poco después de agregar mi diseño a su padre. Eso no funcionó. Pero si lo hice después de que el diseño hubiera existido por un tiempo, funcionó. Entonces, ¿hay una devolución de llamada que me diga "Si intentas mostrar el teclado ahora, realmente funcionará"?
William Jockusch

1
toggleSoftInput (InputMethodManager.SHOW_FORCED, 0) alterna el teclado virtual. Si desea asegurarse de que aparezca el teclado, puede usar imm.showSoftInput (view, InputMethodManager.SHOW_IMPLICIT) en su lugar, donde view es la vista que obtendrá la entrada.
PJ_Finnegan

111

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

// create dialog
final AlertDialog dialog = ...; 

// request keyboard   
dialog.getWindow().setSoftInputMode (WindowManager.LayoutParams.SOFT_INPUT_STATE_ALWAYS_VISIBLE);

Para cualquiera que se pregunte, este método no abre el teclado virtual cuando se conecta un teclado de hardware. Acabo de probar con un cable USB On-The-Go. ¡Perfecto!
13rac1

Esto no hace nada por mí.
JohnyTex

No tengo teclado de hardware. Tal vez configuración (?)
JohnyTex

25

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

Está en la clase de diálogo API nivel 8.
tidbeck

debe haber sido eliminado más tarde: /
Jacek Kwiecień

@Xylian todavía está en la documentación Dialog.setOnShowListener ()
tidbeck


18
<activity
    ...
    android:windowSoftInputMode="stateVisible" >
</activity>

o

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

Muchas gracias amigo, esto fue increíble, en realidad los utilicé a ambos para resolver mi problema, tuve una situación en la que si el usuario está en modo agregar, entonces necesito mostrar el teclado al inicio de la actividad, y para el modo de actualización no se requiere teclado por defecto. Entonces, en el manifiesto para la actividad que configuré stateHiddeny cuando detecto que el usuario está creando un nuevo elemento, entonces visualizo el teclado usando la línea de código que ha mencionado. :) Una vez más, gracias.
PHP Avenger

Recibo el mensaje 'no se puede resolver getWindow ()'. He intentado poner 'esto'. y otras cosas antes de eso. Quiero obtener el teclado sin usar un texto de edición, simplemente haciendo clic en cierta parte de la pantalla.
Androidcoder

1
@Androidcoder, es parte de Activity, así que agrega algo como ((Activity) context).getWindow().....
CoolMind

15

Fragmentos de código de otras respuestas funcionan, pero no siempre es obvio dónde ubicarlos en el código, especialmente si está usando un AlertDialog.Buildery 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 a

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

Debido a que SOFT_INPUT_STATE_ALWAYS_VISIBLE ocultará el teclado si el foco se aleja del EditText, donde SHOW_FORCED mantendrá el teclado visualizado hasta que se cierre 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 usando un diseño personalizado con un EditText definido en XML. También configura el teclado para que tenga una tecla "ir" y le permite activar el botón positivo.

alert_dialog.xml:

<RelativeLayout
android:id="@+id/dialogRelativeLayout"
xmlns:android="http://schemas.android.com/apk/res/android"
android:layout_width="match_parent"
android:layout_height="wrap_content" >

    <!-- android:imeOptions="actionGo" sets the keyboard to have a "go" key instead of a "new line" key. -->
    <!-- android:inputType="textUri" disables spell check in the EditText and changes the "go" key from a check mark to an arrow. -->
    <EditText
        android:id="@+id/editText"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:layout_marginTop="16dp"
        android:layout_marginLeft="4dp"
        android:layout_marginRight="4dp"
        android:layout_marginBottom="16dp"
        android:imeOptions="actionGo"
        android:inputType="textUri"/>

</RelativeLayout>

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

11

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

¿Qué es getCurrentFocus()?
CoolMind

Ya veo, ese es un método de un Activity.
CoolMind

10

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

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

Esta debería ser la respuesta aceptada.
Cristiano Coelho

7

Eche un vistazo a esta discusión que se encarga de ocultar y mostrar manualmente el IME. Sin embargo, tengo la sensación de que si un enfocado EditTextno está activando el IME es porque está llamando AlertDialog.show()a su OnCreate()o algún otro método que se evoca antes de que se presente la pantalla. Moverlo OnPostResume()debería solucionarlo en ese caso, creo.


6

Sí, puedes hacerlo setOnFocusChangeListener, te 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);
        }
    }
});

4

Sé que esta pregunta es antigua porque creo que usar una función de extensión es una forma más bonita de mostrar el teclado para editar texto

Aquí está el método que uso para mostrar el teclado para un texto de edición.

código kotlin: solo necesito llamaredittext.showKeyboard()

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

el código de java:

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

3

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.

Entonces

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

1

La pregunta original se refiere a Diálogos y mi EditText está en una vista normal. De todos modos, sospecho que esto debería funcionar para la mayoría de ustedes también. Entonces, esto es lo que funciona para mí (el método de mayor calificación sugerido anteriormente no hizo nada para mí). Aquí hay un EditView personalizado que hace esto (la subclasificación no es necesaria, pero me pareció conveniente para mis propósitos, ya que también quería tomar el foco cuando la vista se hace visible).

En realidad, esto es en gran medida lo mismo que la respuesta tidbecks. De hecho, no noté su respuesta en absoluto, ya que tenía cero votos. Luego estaba a punto de comentar su publicación, pero hubiera sido demasiado tiempo, así que terminé haciendo esta publicación de todos modos. tidbeck señala que no está seguro de cómo funciona con los dispositivos que tienen teclados. Puedo confirmar que el comportamiento parece ser exactamente el mismo en cualquier caso. Dicho esto, en el modo vertical, 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, Yo he encontrado el comportamiento un poco extraño que opté por usar: InputMethodManager.SHOW_FORCED. Esto funciona como quería que funcionara. El teclado se vuelve visible independientemente de la orientación, sin embargo, al menos en mi dispositivo no aparece si el teclado de hardware se ha deslizado hacia afuera.

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

}

1

El problema parece ser que, dado que el lugar donde ingresa el texto está oculto inicialmente (o anidado o algo así), AlertDialog está configurando automáticamente el indicador WindowManager.LayoutParams.FLAG_ALT_FOCUSABLE_IMo WindowManager.LayoutParams.FLAG_NOT_FOCUSABLEpara que las cosas no activen una entrada suave para que aparezca.

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

1

prueba y usa:

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

1

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

Android TextField: establece foco + entrada suave mediante programación

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 ShowKeyboardesta

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

1

Ponga estos métodos en su clase Util y úselos en cualquier lugar.

Kotlin

fun hideKeyboard(activity: Activity) {
    val view = activity.currentFocus
    val methodManager = activity.getSystemService(Context.INPUT_METHOD_SERVICE) as InputMethodManager
    assert(view != null)
    methodManager.hideSoftInputFromWindow(view!!.windowToken, InputMethodManager.HIDE_NOT_ALWAYS)
}

private fun showKeyboard(activity: Activity) {
    val view = activity.currentFocus
    val methodManager = activity.getSystemService(Context.INPUT_METHOD_SERVICE) as InputMethodManager
    assert(view != null)
    methodManager.showSoftInput(view, InputMethodManager.SHOW_IMPLICIT)
}

Java

public static void hideKeyboard(Activity activity) {
    View view = activity.getCurrentFocus();
    InputMethodManager methodManager = (InputMethodManager) activity.getSystemService(Context.INPUT_METHOD_SERVICE);
    assert methodManager != null && view != null;
    methodManager.hideSoftInputFromWindow(view.getWindowToken(), InputMethodManager.HIDE_NOT_ALWAYS);
}

private static void showKeyboard(Activity activity) {
    View view = activity.getCurrentFocus();
    InputMethodManager methodManager = (InputMethodManager) activity.getSystemService(Context.INPUT_METHOD_SERVICE);
    assert methodManager != null && view != null;
    methodManager.showSoftInput(view, InputMethodManager.SHOW_IMPLICIT);
}

1

Creé buenas funciones de extensión kotlin-esqe en caso de que alguien esté interesado

fun Activity.hideKeyBoard() {
    val view = this.currentFocus
    val methodManager = this.getSystemService(Context.INPUT_METHOD_SERVICE) as InputMethodManager
    assert(view != null)
    methodManager.hideSoftInputFromWindow(view!!.windowToken, InputMethodManager.HIDE_NOT_ALWAYS)
}

fun Activity.showKeyboard() {
    val view = this.currentFocus
    val methodManager = this.getSystemService(Context.INPUT_METHOD_SERVICE) as InputMethodManager
    assert(view != null)
    methodManager.showSoftInput(view, InputMethodManager.SHOW_IMPLICIT)
}

0

Esta es una buena muestra para ti:

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="vertical" >

    <ScrollView
        android:id="@+id/scrollID"
        android:layout_width="fill_parent"
        android:layout_height="0dip"
        android:layout_weight="1" >

        <LinearLayout
            android:id="@+id/test"
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:orientation="vertical" >
        </LinearLayout>
    </ScrollView>

    <LinearLayout
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:baselineAligned="true"
        android:orientation="horizontal"
        android:paddingBottom="5dp"
        android:paddingLeft="5dp"
        android:paddingRight="5dp"
        android:weightSum="1" >

        <EditText
            android:id="@+id/txtInpuConversation"
            android:layout_width="0dip"
            android:layout_height="wrap_content"
            android:layout_weight="0.5"
            android:hint="@string/edt_Conversation" >

            <requestFocus />
        </EditText>

        <Button
            android:id="@+id/btnSend"
            android:layout_width="0dip"
            android:layout_height="wrap_content"
            android:layout_weight="0.5"
            android:text="@string/btn_Conversation" />
    </LinearLayout>

</LinearLayout>

0

¿Por qué esta respuesta? Porque la solución anterior mostrará su teclado, pero no desaparecerá si hace clic en cualquier otro lado EditText. Por lo tanto, debe hacer algo para que el teclado desaparezca cuando EditTextpierda el foco.

Puede lograr esto siguiendo los siguientes pasos:

  1. Haga que la vista principal (vista de contenido de su actividad) sea clicable y enfocable agregando los siguientes atributos

        android:clickable="true" 
        android:focusableInTouchMode="true" 
  2. Implemente 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 onFocusChangeListener de su texto de edición.

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

0

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

0

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

0

Intenté muchos, pero esto es lo que funcionó para mí (kotlin):

        val dialog = builder.create()
        dialog.setOnShowListener {
            nameEditText.requestFocus()
            val s = ContextCompat.getSystemService(requireContext(), InputMethodManager::class.java)
            s?.toggleSoftInput(InputMethodManager.SHOW_FORCED, 0)
        }

        dialog.setOnDismissListener {
            val s = ContextCompat.getSystemService(requireContext(), InputMethodManager::class.java)
            s?.toggleSoftInput(InputMethodManager.HIDE_IMPLICIT_ONLY, 0)
        }

        dialog.show()

0

Mirando https://stackoverflow.com/a/39144104/2914140 simplifiqué un poco:

// In onCreateView():
view.edit_text.run {
    requestFocus()
    post { showKeyboard(this) }
}

fun showKeyboard(view: View) {
    val imm = view.context.getSystemService(
        Context.INPUT_METHOD_SERVICE) as InputMethodManager?
    imm?.showSoftInput(view, InputMethodManager.SHOW_IMPLICIT)
}

Es mejor que https://stackoverflow.com/a/11155404/2914140 :

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

porque cuando presiona el botón Inicio y se mueve a la pantalla de inicio, el teclado permanecerá abierto.


-1
getWindow().setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_STATE_ALWAYS_VISIBLE);

Llamo a esto en onCreate () para mostrar el teclado automáticamente, cuando entré en la Actividad.

Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.
Licensed under cc by-sa 3.0 with attribution required.