open - Android show softkeyboard con showSoftInput no funciona?

open keyboard android studio

Question

He creado una aplicación trivial para probar la siguiente funcionalidad. Cuando se inicie mi actividad, debe iniciarse con el softkeyboard abierto.

Mi código no funciona ?!

He intentado varias configuraciones de "estado" en el manifiesto y diferentes banderas en el código al InputMethodManager (imm).

He incluido la configuración en el AndroidManifest.xml e invocado explícitamente en el onCreate de la única actividad.

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
      package="com.mycompany.android.studyIme"
      android:versionCode="1"
      android:versionName="1.0">
    <uses-sdk android:minSdkVersion="7" />

    <application android:icon="@drawable/icon" android:label="@string/app_name">
        <activity android:name=".StudyImeActivity"
                  android:label="@string/app_name" 
                  android:windowSoftInputMode="stateAlwaysVisible">
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />
                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>

    </application>
</manifest>

... el diseño principal (main.xml) ...

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:orientation="vertical"
    android:layout_width="fill_parent"
    android:layout_height="fill_parent"
    >
    <TextView  
        android:layout_width="fill_parent" 
        android:layout_height="wrap_content" 
        android:text="@string/hello"
        />
    <EditText
        android:id="@+id/edit_sample_text"
        android:layout_width="fill_parent" 
        android:layout_height="wrap_content"
        android:hint="@string/hello"
        android:inputType="textShortMessage"
    />
</LinearLayout>

... y el código ...

public class StudyImeActivity extends Activity {
    private EditText mEditTextStudy;

    /** Called when the activity is first created. */
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);

        mEditTextStudy = (EditText) findViewById(R.id.edit_study);
        InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
        imm.showSoftInput(mEditTextStudy, InputMethodManager.SHOW_FORCED);
    }
}

Answer 1

Cuando se inicia la actividad Parece que el teclado se muestra inicialmente pero está oculto por otra cosa, porque lo siguiente funciona (pero en realidad es una solución sucia):

Primer método

InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
editText.postDelayed(new Runnable()
{
    @Override
    public void run()
    {
        editText.requestFocus();
        imm.showSoftInput(editText, 0);
    }
}, 100);

Segundo metodo

en onCreate para lanzarlo en la actividad crear

new Handler().postDelayed(new Runnable() {
    @Override
    public void run() 
    {
    //  InputMethodManager inputMethodManager=(InputMethodManager)getSystemService(Context.INPUT_METHOD_SERVICE);
    //    inputMethodManager.toggleSoftInputFromWindow(EnterYourViewHere.getApplicationWindowToken(), InputMethodManager.SHOW_FORCED, 0);

        if (inputMethodManager != null)
        {
            inputMethodManager.toggleSoftInput(InputMethodManager.SHOW_FORCED,0);
        } 
    }
}, 200);

Tercer método AGREGAR código dado a etiqueta de actividad en Manifiesto. Mostrará el teclado en el inicio y establecerá el primer enfoque en la vista que desee.

android:windowSoftInputMode="stateVisible"

Answer 2

Esta respuesta tal vez tarde pero funciona perfectamente para mí. Tal vez ayuda a alguien :)

public void showSoftKeyboard(View view) {
    if (view.requestFocus()) {
        InputMethodManager imm = (InputMethodManager)
                getSystemService(Context.INPUT_METHOD_SERVICE);
        boolean isShowing = imm.showSoftInput(view, InputMethodManager.SHOW_IMPLICIT);
        if (!isShowing)
            getWindow().setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_STATE_VISIBLE);
    }
}

Depende de lo que necesites, puedes usar otras banderas.

InputMethodManager.SHOW_FORCED
WindowManager.LayoutParams.SOFT_INPUT_STATE_ALWAYS_VISIBLE);

Answer 3

Esto es tan sutil, que es criminal. Esto funciona en los teléfonos que NO tienen un teclado duro deslizable. Los teléfonos con un teclado duro no se abrirán automáticamente con esta llamada. Mi LG y el antiguo Nexus One no tienen teclado; por lo tanto, el teclado virtual se abre cuando se inicia la actividad (eso es lo que quiero), pero los teléfonos MyTouch y HTC G2 que tienen teclados deslizables no abren el software Teclado hasta que toque el campo de edición con el teclado duro cerrado.

Answer 4

Esto funcionó conmigo en un teléfono con teclado duro:

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

Answer 5

Esto funciona para mí:

public void requestFocusAndShowSoftInput(View view){
    view.requestFocus();
    InputMethodManager inputMethodManager = (InputMethodManager) getSystemService(INPUT_METHOD_SERVICE);
    inputMethodManager.showSoftInput(view, InputMethodManager.SHOW_IMPLICIT);
}

Answer 6

Hey, espero que sigas buscando la respuesta, ya que la encontré al probar mi código. Aquí está el código:

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

imm.toggleSoftInput(0, 0);

Aquí está mi pregunta que fue respondida: android - mostrar teclado suave a pedido

Answer 7

Los siguientes me han funcionado:

    mEditTextStudy.requestFocus();
    mEditTextStudy.post(
            new Runnable() {
                @Override
                public void run() {
                    InputMethodManager imm =
                            (InputMethodManager)
                                    getActivity()
                                            .getSystemService(Context.INPUT_METHOD_SERVICE);
                    if (imm != null) {
                        imm.showSoftInput(mEditTextStudy, SHOW_FORCED);
                    }
                }
            });

Answer 8

Mi código tenía el conmutador en él, pero no PostDelayed. Intenté postDelayed para showSoftInput sin éxito y desde entonces he intentado la solución sugerida. Estaba a punto de descartarlo como otra solución potencial fallida hasta que decidí aumentar el tiempo de retardo. Funciona para mí hasta 200 ms, momento en el que no funciona, al menos no en los teléfonos físicos. Entonces, antes de que los pobres desarrolladores de Android abandonen esta respuesta, intente aumentar el retraso para obtener una solución exitosa. Puede ser conveniente agregar un poco para teléfonos más viejos y lentos. Muchas gracias, estaba trabajando en esto por horas.

Answer 9

Mostrar el teclado suave es un gran problema. Busqué mucho para llegar a una conclusión final. Gracias a esta respuesta que dio varias pistas: https://.com/a/16882749/5903344

Problema:

Normalmente llamamos showSoftInput tan pronto como inicializamos las vistas. En Actividades, esto es principalmente en onCreate, en Fragmentos enCreateView. Para mostrar el teclado, IMM necesita tener el foco de vista activo. Esto se puede verificar mediante el método isActive (ver) de IMM. Si llamamos a showSoftInput mientras se crean las vistas, existe una gran posibilidad de que la vista no esté activa para IMM. Esa es la razón por la que a veces es útil un showSoftInput retardado de 50-100 ms. Sin embargo, eso todavía no garantiza que después de 100 ms la vista se active. Así que en mi entendimiento, esto es de nuevo un hack.

Solución:

Yo uso la siguiente clase. Esto se sigue ejecutando cada 100 ms hasta que el teclado se muestra correctamente. Realiza varias comprobaciones en cada iteración. Algunas comprobaciones pueden detener el funcionamiento, otras lo publican después de 100 ms.

public class KeyboardRunnable extends Runnable
{
    // ----------------------- Constants ----------------------- //
    private static final String TAG = "KEYBOARD_RUNNABLE";

    // Runnable Interval
    private static final int INTERVAL_MS = 100;

    // ----------------------- Classes ---------------------------//
    // ----------------------- Interfaces ----------------------- //
    // ----------------------- Globals ----------------------- //
    private Activity parentActivity = null;
    private View targetView = null;

    // ----------------------- Constructor ----------------------- //
    public KeyboardRunnable(Activity parentActivity, View targetView)
    {
        this.parentActivity = parentActivity;
        this.targetView = targetView;
    }

    // ----------------------- Overrides ----------------------- //
    @Override
    public void run()
    {
        // Validate Params
        if ((parentActivity == null) || (targetView == null))
        {
            Dbg.error(TAG, "Invalid Params");
            return;
        }

        // Get Input Method Manager
        InputMethodManager imm = (InputMethodManager) parentActivity.getSystemService(Context.INPUT_METHOD_SERVICE);

        // Check view is focusable
        if (!(targetView.isFocusable() && targetView.isFocusableInTouchMode()))
        {
            Dbg.error(TAG, "Non focusable view");
            return;
        }
        // Try focusing
        else if (!targetView.requestFocus())
        {
            Dbg.error(TAG, "Cannot focus on view");
            Post();
        }
        // Check if Imm is active with this view
        else if (!imm.isActive(targetView))
        {
            Dbg.error(TAG, "IMM is not active");
            Post();
        }
        // Show Keyboard
       else if (!imm.showSoftInput(targetView, InputMethodManager.SHOW_IMPLICIT))
        {
            Dbg.error(TAG, "Unable to show keyboard");
            Post();
        }
    }

    // ----------------------- Public APIs ----------------------- //
    public static void Hide(Activity parentActivity)
    {
        if (parentActivity != null)
        {
            InputMethodManager imm = (InputMethodManager) parentActivity.getSystemService(Context.INPUT_METHOD_SERVICE);
            imm.hideSoftInputFromWindow(parentActivity.findViewById(android.R.id.content).getWindowToken(), 0);
        }
        else
        {
            Dbg.error(TAG, "Invalid params to hide keyboard");
        }
    }

    // ----------------------- Private APIs ----------------------- //
    protected void Post()
    {
        // Post this aftr 100 ms
        handler.postDelayed(this, INTERVAL_MS);
    }
}

Para usar esto, simplemente crea una instancia de esta clase. Pásale la actividad principal y el targetView que tendrá entrada de teclado y enfoque después. A continuación, publique la instancia utilizando un controlador.

Answer 10

Solución para desarrolladores de Xamarin (_digit1 == EditText):

        var focussed = _digit1.RequestFocus();
        if (focussed)
        {
            Window.SetSoftInputMode(SoftInput.StateAlwaysVisible);
            var imm = (InputMethodManager)GetSystemService(InputMethodService);
            imm.ToggleSoftInput(ShowFlags.Forced, 0);
        }