para - teclado virtual android apk

Cómo mostrar el teclado virtual cuando el texto de edición está enfocado

Question

Quiero mostrar automáticamente el teclado EditText cuando se enfoca un texto de EditText (si el dispositivo no tiene un teclado físico) y tengo dos problemas:

1. Cuando se muestra mi Activity , mi texto de EditText está enfocado pero no se muestra el teclado, necesito volver a hacer clic en él para mostrar el teclado (debe aparecer cuando se muestra mi Activity ).

2. Y cuando hago clic en "Hecho en el teclado", el teclado desaparece, pero el EditText mantiene enfocado y no desea (porque mi edición está terminada).

Para resumir, mi problema es tener algo más como en el iPhone: que mantiene la sincronización del teclado con mi estado de EditText (enfocado / no enfocado) y, por supuesto, no presenta un teclado suave si hay uno físico.

Answer 1

A veces la respuesta de raukodraug no funciona. Lo he hecho de esta manera con algunas pruebas y errores:

public static void showKeyboard(Activity activity) {
    if (activity != null) {
        activity.getWindow()
                .setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_STATE_ALWAYS_VISIBLE);
    }
}

public static void hideKeyboard(Activity activity) {
    if (activity != null) {
        activity.getWindow()
                .setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_STATE_ALWAYS_HIDDEN);
    }
}

Y la parte EditText :

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

Answer 2

Combiné todo aquí y para mí funciona:

public static void showKeyboardWithFocus(View v, Activity a) {
    try {
        v.requestFocus();
        InputMethodManager imm = (InputMethodManager) a.getSystemService(Context.INPUT_METHOD_SERVICE);
        imm.showSoftInput(v, InputMethodManager.SHOW_IMPLICIT);
        a.getWindow().setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_STATE_VISIBLE);
    } catch (Exception e) {
        e.printStackTrace();
    }
}

Answer 3

Creo que, o no, mi problema con el teclado suave se resolvió cuando descubrí que las animaciones de Actividades pueden desactivar el teclado suave. Cuando llamas a la intención con la

i.setFlags(Intent.FLAG_ACTIVITY_NO_ANIMATION);

y

overridePendingTransition(0, 0);

Puede ocultar el teclado suave y no hay una forma de mostrarlo.

Answer 4

Cuando nada más funcione, obliga a que se muestre :

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

Answer 5

Dentro de tu manifiesto:

android:windowSoftInputMode="stateAlwaysVisible" - teclado lanzado inicialmente. android:windowSoftInputMode="stateAlwaysHidden" - teclado inicialmente oculto.

También me gusta usar "adjustPan" porque cuando se inicia el teclado, la pantalla se ajusta automáticamente.

 <activity
      android:name="YourActivity"
      android:windowSoftInputMode="stateAlwaysHidden|adjustPan"/>

Answer 6

Descubrí un comportamiento extraño, ya que en una de mis aplicaciones, el teclado virtual se mostraba automáticamente al ingresar a la actividad (hay un editText.requestFocus () en onCreate).

Al seguir investigando, descubrí que esto se debía a que hay un ScrollView alrededor del diseño. Si quito el ScrollView, el comportamiento es como se describe en la declaración del problema original: solo al hacer clic en el editText ya enfocado aparece el teclado virtual.

Si no funciona para usted, intente colocar un ScrollView; de todos modos, es inofensivo.

Answer 7

El siguiente código es saqueado del código fuente de Google 4.1 para SearchView. Parece funcionar, bien en versiones menores de Android también.

private Runnable mShowImeRunnable = new Runnable() {
    public void run() {
        InputMethodManager imm = (InputMethodManager) getContext()
                .getSystemService(Context.INPUT_METHOD_SERVICE);

        if (imm != null) {
            imm.showSoftInput(editText, 0);
        }
    }
};

private void setImeVisibility(final boolean visible) {
    if (visible) {
        post(mShowImeRunnable);
    } else {
        removeCallbacks(mShowImeRunnable);
        InputMethodManager imm = (InputMethodManager) getContext()
                .getSystemService(Context.INPUT_METHOD_SERVICE);

        if (imm != null) {
            imm.hideSoftInputFromWindow(getWindowToken(), 0);
        }
    }
}

Luego, además, se debe agregar el siguiente código a medida que se crea el Control / Actividad. (En mi caso es un control compuesto, en lugar de una actividad).

this.editText.setOnFocusChangeListener(new View.OnFocusChangeListener() {
    public void onFocusChange(View v, boolean hasFocus) {
        setImeVisibility(hasFocus);
    }
});

Answer 8

En la sección onResume () de la Actividad, puede hacer lo que debe llamar al método bringKeyboard ();

 onResume() {
     EditText yourEditText= (EditText) findViewById(R.id.yourEditText);
     bringKeyboard(yourEditText);
 }


  protected boolean bringKeyboard(EditText view) {
    if (view == null) {
        return false;
    }
    try {
      // Depending if edittext has some pre-filled values you can decide whether to bring up soft keyboard or not
        String value = view.getText().toString();
        if (value == null) {
            InputMethodManager imm = (InputMethodManager)context.getSystemService(Context.INPUT_METHOD_SERVICE);
            imm.hideSoftInputFromWindow(view.getWindowToken(), 0);
            return true;
        }
    } catch (Exception e) {
        Log.e(TAG, "decideFocus. Exception", e);
    }
    return false;
  }

Answer 9

Estoy de acuerdo con raukodraug, por lo tanto, para usar en una vista debe solicitar / aclarar un enfoque como este:

    final ViewSwitcher viewSwitcher = (ViewSwitcher) findViewById(R.id.viewSwitcher);
    final View btn = viewSwitcher.findViewById(R.id.address_btn);
    final View title = viewSwitcher.findViewById(R.id.address_value);

    title.setOnClickListener(new View.OnClickListener() {
        @Override
        public void onClick(View view) {
            viewSwitcher.showPrevious();
            btn.requestFocus();
            InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
            imm.showSoftInput(btn, InputMethodManager.SHOW_IMPLICIT);
        }
    });

    // EditText affiche le titre evenement click
    btn.setOnClickListener(new View.OnClickListener() {
        @Override
        public void onClick(View view) {
            btn.clearFocus();
            viewSwitcher.showNext();
            InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
            imm.hideSoftInputFromWindow(btn.getWindowToken(), 0);
            // Enregistre l''adresse.
            addAddress(view);
        }
    });

Saludos.

Answer 10

Funcionó para mí. Puedes probar con esto también para mostrar el teclado:

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

Answer 11

He tenido un poco de suerte recientemente en algunos casos simples con el código de abajo. No he terminado todas las pruebas pero ...

EditText input = (EditText) findViewById(R.id.Input);
input.requestFocus();    
input.dispatchTouchEvent(MotionEvent.obtain(SystemClock.uptimeMillis(), SystemClock.uptimeMillis(), MotionEvent.ACTION_DOWN , 0, 0, 0));
input.dispatchTouchEvent(MotionEvent.obtain(SystemClock.uptimeMillis(), SystemClock.uptimeMillis(), MotionEvent.ACTION_UP , 0, 0, 0));

Y presto aparece el teclado.

Answer 12

Hice esta clase de ayuda. Simplemente pase el contexto y la Vista que desea enfocar y mostrar el teclado y luego oculte el teclado. Espero que ayude.

public class FocusKeyboardHelper {

private View view;
private Context context;
private InputMethodManager imm;

public FocusKeyboardHelper(Context context, View view){
    this.view = view;
    this.context = context;
    imm = (InputMethodManager) context.getSystemService(context.INPUT_METHOD_SERVICE);
}

public void focusAndShowKeyboard(){

    view.requestFocus();
    imm.toggleSoftInput(InputMethodManager.SHOW_FORCED, InputMethodManager.HIDE_IMPLICIT_ONLY);

}

public void hideKeyBoard(){
    imm.hideSoftInputFromWindow(view.getWindowToken(), 0);
}

}

Answer 13

Para forzar la aparición del teclado virtual, puede utilizar

EditText yourEditText= (EditText) findViewById(R.id.yourEditText);
InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
imm.showSoftInput(yourEditText, InputMethodManager.SHOW_IMPLICIT);

Y para eliminar el foco en EditText , lamentablemente necesita tener una View ficticia para captar el foco.

espero que esto ayude

Para cerrarla puedes usar

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

Answer 14

Para hacer que aparezca el teclado, use

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

Este método es más confiable que invocar el InputMethodManager directamente.

Para cerrarla, use

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

Answer 15

Para ocultar el teclado, use este:

getActivity().getWindow().setSoftInputMode(
    WindowManager.LayoutParams.SOFT_INPUT_STATE_ALWAYS_HIDDEN);

y para mostrar el teclado:

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

Answer 16

Por fragmento, seguro que funciona:

 displayName = (EditText) view.findViewById(R.id.displayName);
    InputMethodManager imm = (InputMethodManager) getActivity().getSystemService(Context.INPUT_METHOD_SERVICE);
    imm.toggleSoftInput(InputMethodManager.SHOW_FORCED, 0);

Answer 17

Puedes intentar forzar la aparición del teclado suave, funciona para mí:

...
dialog.show();
input.requestFocus();
InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
imm.toggleSoftInput(InputMethodManager.SHOW_FORCED, 0);

Answer 18

También puede crear una extensión personalizada del EditText que sepa cómo abrir el teclado virtual cuando recibe el foco. Eso es lo que he terminado haciendo. Esto es lo que funcionó para mí:

public class WellBehavedEditText extends EditText {
    private InputMethodManager inputMethodManager;
    private boolean showKeyboard = false;

    public WellBehavedEditText(Context context) {
        super(context);
        this.initializeWellBehavedEditText(context);
    }

    public WellBehavedEditText(Context context, AttributeSet attributes) {
        super(context, attributes);
        this.initializeWellBehavedEditText(context);
    }

    public WellBehavedEditText(Context context, AttributeSet attributes, int defStyleAttr) {
        super(context, attributes, defStyleAttr);
        this.initializeWellBehavedEditText(context);
    }

    public WellBehavedEditText(Context context, AttributeSet attributes, int defStyleAttr, int defStyleRes) {
        super(context, attributes, defStyleAttr, defStyleRes);
        this.initializeWellBehavedEditText(context);
    }

    private void initializeWellBehavedEditText(Context context) {
        this.inputMethodManager = (InputMethodManager)context.getSystemService(Context.INPUT_METHOD_SERVICE);

        final WellBehavedEditText editText = this;
        this.getViewTreeObserver().addOnGlobalLayoutListener(new ViewTreeObserver.OnGlobalLayoutListener() {
            @Override
            public void onGlobalLayout() {
                if(showKeyboard) {
                    showKeyboard = !(inputMethodManager.showSoftInput(editText, InputMethodManager.SHOW_FORCED));
                }
            }
        });
    }

    @Override
    protected void onFocusChanged(boolean focused, int direction, Rect previouslyFocusedRect) {
        if(!focused) this.showKeyboard = false;
        super.onFocusChanged(focused, direction, previouslyFocusedRect);
    }

    @Override
    public boolean requestFocus(int direction, Rect previouslyFocusedRect) {
        boolean result = super.requestFocus(direction, previouslyFocusedRect);
        this.showKeyboard = true;
        final WellBehavedEditText self = this;
        this.post(new Runnable() {
            @Override
            public void run() {
                showKeyboard = !(inputMethodManager.showSoftInput(self, InputMethodManager.SHOW_FORCED));
            }
        });
        return result;
    }
}

Answer 19

Todas las soluciones dadas anteriormente (la interacción InputMethodManager en OnFocusChangeListener.onFocusChange oyente adjunta a su EditText funciona bien si tiene una única edición en la actividad.

En mi caso tengo dos ediciones.

 private EditText tvX, tvY;
 protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
 tvX.setOnFocusChangeListener(this);
    tvY.setOnFocusChangeListener(this);

@Override
public void onFocusChange(View v, boolean hasFocus) {       
    InputMethodManager imm =  (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
    if(tvX.hasFocus() || tvY.hasFocus()) {            
        imm.showSoftInput(v, 0);            
    } else {
        imm.hideSoftInputFromWindow(v.getWindowToken(), 0);         
    }       
};

He observado que onFocusChange se activa para tvX con hasFocus = true (se muestra el teclado) pero luego para tvY con hasFocus = true (teclado oculto). Al final, ningún teclado era visible.

La solución general debe tener una declaración correcta si "muestra el teclado si el texto del texto de edición está enfocado"

Answer 20

Tuve el mismo problema en diferentes situaciones, y las soluciones que he encontrado funcionan en algunas, pero no en otras, así que aquí hay una solución combinada que funciona en la mayoría de las situaciones que he encontrado

public static void showVirtualKeyboard(Context context, final View view) {
    if (context != null) {
        final InputMethodManager imm =  (InputMethodManager) context.getSystemService(Context.INPUT_METHOD_SERVICE);
        view.clearFocus();

        if(view.isShown()) {
            imm.showSoftInput(view, 0);
            view.requestFocus();
        } else {
            view.addOnAttachStateChangeListener(new View.OnAttachStateChangeListener() {
                @Override
                public void onViewAttachedToWindow(View v) {
                    view.post(new Runnable() {
                        @Override
                        public void run() {
                            view.requestFocus();
                            imm.showSoftInput(view, 0);
                        }
                    });

                    view.removeOnAttachStateChangeListener(this);
                }

                @Override
                public void onViewDetachedFromWindow(View v) {
                    view.removeOnAttachStateChangeListener(this);
                }
            });
        }
    }
}

Answer 21

Tuve un problema similar al usar animaciones de vista . Así que puse un oyente de animación para asegurarme de que esperaría a que terminara la animación antes de intentar solicitar un acceso al teclado en el texto de edición que se muestra.

    bottomUp.setAnimationListener(new Animation.AnimationListener() {
        @Override
        public void onAnimationStart(Animation animation) {
        }

        @Override
        public void onAnimationEnd(Animation animation) {
            if (textToFocus != null) {
                // Position cursor at the end of the text
                textToFocus.setSelection(textToFocus.getText().length());
                // Show keyboard
                InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
                imm.showSoftInput(textToFocus, InputMethodManager.SHOW_IMPLICIT);
            }
        }

        @Override
        public void onAnimationRepeat(Animation animation) {
        }
    });

Answer 22

Usando Xamarin, esto me funciona dentro de un Fragmento:

using Android.Views.InputMethods;
using Android.Content;

...

if ( _txtSearch.RequestFocus() ) {
  var inputManager = (InputMethodManager) Activity.GetSystemService( Context.InputMethodService );
  inputManager.ShowSoftInput( _txtSearch, ShowFlags.Implicit );
}

Answer 23

Yo tuve el mismo problema. Inmediatamente después de la modificación de VISIBILIDAD en el texto de texto, se cambió de GONE a VISIBLE, tuve que establecer el enfoque y mostrar el teclado virtual. Logré esto usando el siguiente código:

new Handler().postDelayed(new Runnable() {

    public void run() {
//        ((EditText) findViewById(R.id.et_find)).requestFocus();
//              
        EditText yourEditText= (EditText) findViewById(R.id.et_find);
//        InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
//        imm.showSoftInput(yourEditText, InputMethodManager.SHOW_IMPLICIT);

        yourEditText.dispatchTouchEvent(MotionEvent.obtain(SystemClock.uptimeMillis(), SystemClock.uptimeMillis(), MotionEvent.ACTION_DOWN , 0, 0, 0));
        yourEditText.dispatchTouchEvent(MotionEvent.obtain(SystemClock.uptimeMillis(), SystemClock.uptimeMillis(), MotionEvent.ACTION_UP , 0, 0, 0));                           
    }
}, 200);

Funciona para mí con un retraso de 100 ms, pero falló sin demora o solo con un retraso de 1 ms.

La parte comentada del código muestra otro enfoque, que funciona solo en algunos dispositivos. Probé en versiones de sistema operativo 2.2 (emulador), 2.2.1 (dispositivo real) y 1.6 (emulador).

Este enfoque me ahorró mucho dolor.

Answer 24

fragmento de código . . .

public void hideKeyboard(Context activityContext){

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

    //android.R.id.content ( http://.com/a/12887919/2077479 )
    View rootView = ((Activity) activityContext)
            .findViewById(android.R.id.content).getRootView();

    imm.hideSoftInputFromWindow(rootView.getWindowToken(), 0);
}

public void showKeyboard(Context activityContext, final EditText editText){

    final InputMethodManager imm = (InputMethodManager)
            activityContext.getSystemService(Context.INPUT_METHOD_SERVICE);

    if (!editText.hasFocus()) {
        editText.requestFocus();
    }

    editText.post(new Runnable() {
        @Override
        public void run() {
            imm.showSoftInput(editText, InputMethodManager.SHOW_FORCED);
        }
    });
}

Answer 25

solo agregue android: windowSoftInputMode = "stateHidden" en el archivo de manifiesto ...

Answer 26

android:windowSoftInputMode="stateAlwaysVisible" -> en el archivo de manifiesto.

edittext.requestFocus(); -> en el código.

Esto abrirá el teclado virtual en el que el texto de edición tiene un foco de solicitud a medida que aparece la actividad.

Answer 27

showSoftInput no estaba funcionando para mí en absoluto.

Pensé que necesitaba establecer el modo de entrada: (aquí en el componente Actividad en el manifiesto)

android:windowSoftInputMode="stateVisible" 

Answer 28

 void requestFocus(View editText, Activity activity)
{
    try {
        editText.requestFocus();
        InputMethodManager imm = (InputMethodManager) a.getSystemService(Context.INPUT_METHOD_SERVICE);
        imm.showSoftInput(editText, InputMethodManager.SHOW_IMPLICIT);
        activity.getWindow().setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_STATE_VISIBLE);
    } catch (Exception e) {
        e.printStackTrace();
    }

}

Añade esta linea tambien no olvides

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

Answer 29

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

Answer 30

final InputMethodManager keyboard = (InputMethodManager) ctx.getSystemService(Context.INPUT_METHOD_SERVICE);
keyboard.toggleSoftInput(InputMethodManager.SHOW_FORCED,0);