open - show keyboard android programmatically

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

Question

Estoy mostrando un cuadro de entrada usando AlertDialog . El texto de EditText dentro del diálogo mismo se enfoca automáticamente cuando llamo 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 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.

Answer 1

Bueno, este es un post bastante antiguo, todavía hay algo que añadir.
Estos son dos 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);
}

Answer 2

Como escribió horkavlna ,

palanca

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

y ocultar teclado

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

Los métodos funcionan. Pero mostrar variantes no funcionan en mi caso. Así que en onCreate() pongo hideKeyboard(editText); luego en onStart() escribo toggleKeyboard(editText); y en onStop() escribo hideKeyboard(editText); .

Hay tres problemas:

1) cuando una aplicación comienza con la pantalla apagada, ocultará el teclado,

2) cada vez que encienda la pantalla se mostrará el teclado,

3) una vez finalizada la aplicación, puede ver el teclado en la pantalla principal de Android.

Después de varias pruebas android:windowSoftInputMode="stateVisible" estos métodos y en AndroidManifest en las etiquetas de activity escribí android:windowSoftInputMode="stateVisible" o android:windowSoftInputMode="stateAlwaysHidden" .

Answer 3

Creé agradables 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)
}

Answer 4

Déjame apuntar información adicional a la solución de yuku, ¡porque me resultó difícil hacer que esto funcione! ¿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);
      }
   }
});

Answer 5

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

Answer 6

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

La forma en que se soluciona 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);

Answer 7

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

Answer 8

Esta es una buena muestra para usted:

<?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>

Answer 9

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

Answer 10

La pregunta original se refiere a los diálogos y mi EditText está en una vista regular. De todos modos, sospecho que esto debería funcionar para la mayoría de ustedes también. Así que esto es lo que funciona para mí (el método más alto sugerido anteriormente no hizo nada por mí). Aquí hay una vista de edición personalizada que hace esto (la subclasificación no es necesaria, pero me pareció conveniente para mis propósitos, ya que también quería captar el foco cuando la vista se hace visible).

Esto es en realidad en gran medida lo mismo que la respuesta tidbecks. En realidad no me di cuenta de su respuesta en absoluto, ya que tenía cero votos arriba. Luego estaba a punto de comentar su publicación, pero hubiera sido demasiado larga, 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 ambos casos. Por eso, en el modo vertical, el teclado del software se abre 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 poco incómodo el comportamiento que opté por usar: InputMethodManager.SHOW_FORCED . Esto funciona como yo 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();
        }
    }

}

Answer 11

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 oficial del diálogo porque no usa el 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);

Debido a que SOFT_INPUT_STATE_ALWAYS_VISIBLE ocultará el teclado si el foco se aleja del texto de edición, donde SHOW_FORCED mantendrá el teclado en pantalla hasta que se descarte 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;
    }
}

Answer 12

Para mostrar el teclado, para mi, tuve que hacer lo siguiente

Android TextField: establece enfoque + 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 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);

Answer 13

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

Answer 14

Ponga estos métodos en su clase de Util y utilícelos 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);
}

Answer 15

Por qué esta respuesta: porque la solución anterior mostrará su teclado, pero no se desvanecerá si hace clic en cualquier otro lugar que no sea EditText . Por lo tanto, debe hacer algo para que desaparezca el Keybaord cuando EditText pierde el enfoque.

Puedes lograr esto haciendo los siguientes pasos:

1. Haga que la vista principal (vista de contenido de su actividad) se pueda hacer clic y enfocar 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 edittext.

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

Answer 16

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

Answer 17

Puede crear una escucha de enfoque en el EditText en el AlertDialog , luego obtener la Window AlertDialog . Desde allí puede hacer que se muestre 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);
        }
    }
});

Answer 18

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

Answer 19

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

Answer 20

Si alguien está recibiendo:

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

Intente agregar contexto a la llamada a getSystemService.

Asi que

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

Answer 21

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

Answer 22

prueba y usa

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

Answer 23

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

o

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

Answer 24

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.