2011-04-01 7 views
15

He creado una aplicación trivial para probar la siguiente funcionalidad. Cuando se inicia mi actividad, debe iniciarse con el teclado abierto.Android show softkeyboard with showSoftInput no funciona?

Mi código no funciona ?!

He intentado varias configuraciones de "estado" en el manifiesto y diferentes banderas en el código para el 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); 
    } 
} 
+0

Hmm ... Acabo de probar esto, con solo la actividad predeterminada "HelloWorld" (es decir, sin incluir el código SHOW_FORCED), en mi teléfono Sprint LG Optimus y funcionó como se esperaba. ¿Es posible que la función sea dependiente del dispositivo (sistema operativo instalado)? Volveré a probar en mis otros dispositivos (HTC, G2 y MyTouch) cuando llegue a casa. – mobibob

+0

Consulte mi respuesta aquí, probé todas las técnicas mencionadas a continuación, pero esto funcionó: http://stackoverflow.com/a/37529370/3900270 – strangetimes

Respuesta

15

Esto es tan sutil, que es criminal Esto funciona en los teléfonos que hacen NOT 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 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 teclado. teclado hasta que toque el campo de edición con el teclado duro cerrado.

+1

NOTA: He experimentado mucho con EditText y InputMethodManager en un intento de forzar el teclado suave para abrir cuando el dispositivo tiene un teclado duro sin éxito. – mobibob

+0

Para cualquiera que esté haciendo el desarrollo de Xamarin en Visual Studio, en el Administrador de AVD puede editar su AVD y hay una configuración etiquetada como "Teclado de hardware presente". Desmarcar esto permitirá que se muestre la entrada suave. –

18

Hola, espero que sigas buscando la respuesta que 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í es mi pregunta que fue respondida: android - show soft keyboard on demand

15

Este trabajó conmigo en un teléfono con teclado físico:

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

genial Me faltaba requestFocus() que estaba deteniendo el teclado para mostrarse por primera vez. –

20

Cuando la actividad lanza Parece que el teclado se muestra inicialmente pero que está oculto por otra cosa, porque funciona lo siguiente (pero en realidad es un trabajo sucio):

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 método

en onCreate a poner en marcha en la actividad de 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 Añadir un código dado a la etiqueta de actividad en el manifiesto. Mostrará el teclado al iniciarse y establecerá el primer foco en la vista que desee.

android:windowSoftInputMode="stateVisible" 
+1

Tengo el mismo problema. Llamar a 'showSoftInput()' inmediatamente no tiene resultado visible, pero publicarlo en un retraso hace que el teclado se visualice correctamente. Inicialmente pensé, como tú, que se estaba mostrando y luego se ocultó rápidamente por otra cosa. Sin embargo, después de un poco de excavación, descubrí que podía pasar un 'ResultReceiver' y registrar los resultados. Cuando publico 'showSoftInput()' en un retraso, el código de resultado devuelto a mi receptor es 'RESULT_SHOWN'. Cuando no uso el retraso, mi receptor no se llama en absoluto. Ahora sospecho que en lugar de estar oculto, no lo muestra en absoluto por alguna razón. –

+1

Gracias hombre. Usó el primer método al solucionar el problema con el teclado que no se muestra la primera vez que se inicia un fragmento de diálogo (con EditText). – Ugo

+3

Otro voto para llamar a 'postDelayed' vs.'post': es probable que haya alguna otra funcionalidad oculta predeterminada que esté causando que el teclado se oculte primero. Mostrar y ocultar el teclado es la API más enormemente rota que existe. – rmirabelle

1

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

4

Esta respuesta puede llegar tarde pero me funciona perfectamente. Tal vez ayude 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 necesita, puede utilizar otras banderas

InputMethodManager.SHOW_FORCED 
WindowManager.LayoutParams.SOFT_INPUT_STATE_ALWAYS_VISIBLE); 
1

muestra el teclado blando es un gran problema. Busqué mucho para llegar a una conclusión final. Gracias a esta respuesta que dio una serie de pistas: https://stackoverflow.com/a/16882749/5903344

Problema:

Normalmente nos llaman showSoftInput tan pronto como inicializar los puntos de vista. En Actividades, esto se realiza principalmente en onCreate, en Fragments onCreateView. Para mostrar el teclado, IMM necesita tener focsedView como activo. Esto se puede verificar utilizando el método isActive (ver) de IMM. Si llamamos a showSoftInput mientras se crean las vistas, es muy probable que la vista no esté activa para IMM. Esa es la razón por la que a veces es difcil mostrar showSoftInput de 50-100 ms. Sin embargo, eso aún no garantiza que después de 100 ms la vista se active. Entonces, en mi comprensión, esto es nuevamente un truco.

Solución:

utilizo la siguiente clase. Esto sigue ejecutándose cada 100 ms hasta que el teclado se haya mostrado con éxito. Realiza varias comprobaciones en cada iteración. Algunos controles pueden detener el ejecutable, algunos 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, solo crea una instancia de esta clase. Pase la actividad principal y la vista de destino que tendrá entrada de teclado y enfoque después. Luego publique la instancia usando un controlador.