studio - Feche/oculte o teclado virtual do Android




ocultar teclado android developer (20)

A resposta curta

Em seu ouvinte OnClick chame o onEditorAction do IME_ACTION_DONE com IME_ACTION_DONE

button.setOnClickListener(new OnClickListener() {

    @Override
    public void onClick(View v) {
        someEditText.onEditorAction(EditorInfo.IME_ACTION_DONE)
    }
});

O drill-down

Eu sinto que este método é melhor, mais simples e mais alinhado com o padrão de design do Android. No exemplo simples acima (e geralmente na maioria dos casos comuns) você terá um EditText que tem / teve foco e também costumava ser o único a invocar o teclado em primeiro lugar (é definitivamente capaz de invocá-lo em muitos cenários comuns). Da mesma forma, deve ser o único a liberar o teclado, geralmente isso pode ser feito por um ImeAction . Basta ver como um EditText com android:imeOptions="actionDone" se comporta, você deseja obter o mesmo comportamento da mesma maneira.

Confira esta resposta relacionada

Eu tenho um EditText e um Button no meu layout.

Depois de escrever no campo de edição e clicar no Button , quero ocultar o teclado virtual. Eu suponho que este é um simples pedaço de código, mas onde posso encontrar um exemplo disso?


A solução de Meier também funciona para mim. No meu caso, o nível superior do meu aplicativo é um tabHost e eu quero esconder a palavra-chave ao alternar as guias - eu recebo o token da janela do tabHost View.

tabHost.setOnTabChangedListener(new OnTabChangeListener() {
    public void onTabChanged(String tabId) {
        InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
        imm.hideSoftInputFromWindow(tabHost.getApplicationWindowToken(), 0);
    }
}

Eu tenho mais uma solução para esconder o teclado:

InputMethodManager imm = (InputMethodManager) getSystemService(Activity.INPUT_METHOD_SERVICE);
imm.toggleSoftInput(InputMethodManager.HIDE_IMPLICIT_ONLY, 0);

Aqui passe HIDE_IMPLICIT_ONLY na posição de showFlag e 0 na posição de hiddenFlag . Ele irá fechar com força o teclado suave.


Isso deve funcionar:

public class KeyBoard {

    public static void show(Activity activity){
        InputMethodManager imm = (InputMethodManager) activity.getSystemService(Activity.INPUT_METHOD_SERVICE);
        imm.toggleSoftInput(0, InputMethodManager.HIDE_IMPLICIT_ONLY); // show
    }

    public static void hide(Activity activity){
        InputMethodManager imm = (InputMethodManager) activity.getSystemService(Activity.INPUT_METHOD_SERVICE);
        imm.toggleSoftInput(InputMethodManager.HIDE_IMPLICIT_ONLY, 0); // hide
    }

    public static void toggle(Activity activity){
        InputMethodManager imm = (InputMethodManager) activity.getSystemService(Activity.INPUT_METHOD_SERVICE);
        if (imm.isActive()){
            hide(activity); 
        } else {
            show(activity); 
        }
    }
}

KeyBoard.toggle(activity);

Passei mais de dois dias trabalhando em todas as soluções postadas no tópico e descobri que elas estão faltando de uma forma ou de outra. Minha exigência exata é ter um botão que mostre 100% de confiabilidade ou oculte o teclado na tela. Quando o teclado está em seu estado oculto, ele não deve reaparecer, não importa em quais campos de entrada o usuário clica. Quando está no estado visível, o teclado não deve desaparecer, independentemente dos botões em que o usuário clicar. Isso precisa funcionar no Android 2.2+ até os dispositivos mais recentes.

Você pode ver uma implementação funcional disso em meu aplicativo RPN limpo .

Depois de testar muitas das respostas sugeridas em vários telefones diferentes (incluindo dispositivos froyo e gingerbread), ficou claro que os aplicativos para Android podem:

  1. Esconda temporariamente o teclado. Ele reaparecerá novamente quando um usuário focar um novo campo de texto.
  2. Mostre o teclado quando uma atividade iniciar e defina um sinalizador na atividade, indicando que o teclado deve estar sempre visível. Esse sinalizador só pode ser definido quando uma atividade está sendo inicializada.
  3. Marque uma atividade para nunca mostrar ou permitir o uso do teclado. Esse sinalizador só pode ser definido quando uma atividade está sendo inicializada.

Para mim, esconder temporariamente o teclado não é suficiente. Em alguns dispositivos, ele reaparecerá assim que um novo campo de texto for focalizado. Como meu aplicativo usa vários campos de texto em uma página, o foco em um novo campo de texto fará com que o teclado oculto apareça novamente.

Infelizmente, os itens 2 e 3 da lista só funcionam com confiabilidade quando uma atividade está sendo iniciada. Quando a atividade se tornar visível, você não poderá ocultar ou mostrar permanentemente o teclado. O truque é realmente reiniciar sua atividade quando o usuário pressiona o botão de alternância do teclado. No meu aplicativo, quando o usuário pressiona o botão do teclado de alternância, o código a seguir é executado:

private void toggleKeyboard(){

    if(keypadPager.getVisibility() == View.VISIBLE){
        Intent i = new Intent(this, MainActivity.class);
        i.addFlags(Intent.FLAG_ACTIVITY_NO_ANIMATION);
        Bundle state = new Bundle();
        onSaveInstanceState(state);
        state.putBoolean(SHOW_KEYBOARD, true);
        i.putExtras(state);

        startActivity(i);
    }
    else{
        Intent i = new Intent(this, MainActivity.class);
        i.addFlags(Intent.FLAG_ACTIVITY_NO_ANIMATION);
        Bundle state = new Bundle();
        onSaveInstanceState(state);
        state.putBoolean(SHOW_KEYBOARD, false);
        i.putExtras(state);

        startActivity(i);
    }
}

Isso faz com que a atividade atual tenha seu estado salvo em um Bundle e, em seguida, a atividade é iniciada, passando por um booleano que indica se o teclado deve ser mostrado ou oculto.

Dentro do método onCreate, o seguinte código é executado:

if(bundle.getBoolean(SHOW_KEYBOARD)){
    ((InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE)).showSoftInput(newEquationText,0);
    getWindow().setSoftInputMode(LayoutParams.SOFT_INPUT_STATE_ALWAYS_VISIBLE);
}
else{
    getWindow().setFlags(WindowManager.LayoutParams.FLAG_ALT_FOCUSABLE_IM,
            WindowManager.LayoutParams.FLAG_ALT_FOCUSABLE_IM);
}

Se o teclado virtual deve ser mostrado, o InputMethodManager é instruído a mostrar o teclado e a janela é instruída para tornar a entrada suave sempre visível. Se o teclado virtual deve estar oculto, o WindowManager.LayoutParams.FLAG_ALT_FOCUSABLE_IM é definido.

Esta abordagem funciona de forma confiável em todos os dispositivos que eu testei - a partir de um telefone HTC de 4 anos rodando o Android 2.2 até um nexo 7 rodando 4.2.2. A única desvantagem dessa abordagem é que você precisa ter cuidado ao manusear o botão Voltar. Como o meu aplicativo basicamente tem apenas uma tela (é uma calculadora), posso substituir onBackPressed () e retornar à tela inicial dos dispositivos.


Por favor, tente este código abaixo em onCreate()

EditText edtView=(EditText)findViewById(R.id.editTextConvertValue);
edtView.setInputType(0);

Também é útil para ocultar o teclado virtual:

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

Isso pode ser usado para suprimir o teclado virtual até que o usuário realmente toque na exibição editText.


Você pode forçar o Android a ocultar o teclado virtual usando o InputMethodManager , chamando hideSoftInputFromWindow , passando o token da janela que contém a visualização em foco.

// Check if no view has focus:
View view = this.getCurrentFocus();
if (view != null) {  
    InputMethodManager imm = (InputMethodManager)getSystemService(Context.INPUT_METHOD_SERVICE);
    imm.hideSoftInputFromWindow(view.getWindowToken(), 0);
}

Isso forçará o teclado a ficar oculto em todas as situações. Em alguns casos, você desejará passar InputMethodManager.HIDE_IMPLICIT_ONLY como o segundo parâmetro para garantir que você apenas oculte o teclado quando o usuário não forçar explicitamente a exibição (mantendo pressionado o menu).

Nota: Se você quiser fazer isso no Kotlin, use: context?.getSystemService(Context.INPUT_METHOD_SERVICE) as InputMethodManager


Atualização: Não sei porque esta solução não funciona mais (acabei de testar no Android 23). Por favor, use a solução de Saurabh Pareek . Aqui está:

InputMethodManager imm = (InputMethodManager) getSystemService(Activity.INPUT_METHOD_SERVICE);
//Hide:
imm.toggleSoftInput(InputMethodManager.HIDE_IMPLICIT_ONLY, 0);
//Show
imm.toggleSoftInput(InputMethodManager.SHOW_IMPLICIT, 0);

Resposta antiga:

//Show soft-keyboard:
getWindow().setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_STATE_ALWAYS_VISIBLE);
//hide keyboard :
 getWindow().setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_STATE_ALWAYS_HIDDEN);

Basta usar este código otimizado em sua atividade:

if (this.getCurrentFocus() != null) {
    InputMethodManager inputManager = (InputMethodManager) this.getSystemService(Context.INPUT_METHOD_SERVICE);
    inputManager.hideSoftInputFromWindow(this.getCurrentFocus().getWindowToken(), InputMethodManager.HIDE_NOT_ALWAYS);
}

Isso funcionou para mim por todo o comportamento do teclado bizarro

private boolean isKeyboardVisible() {
    Rect r = new Rect();
    //r will be populated with the coordinates of your view that area still visible.
    mRootView.getWindowVisibleDisplayFrame(r);

    int heightDiff = mRootView.getRootView().getHeight() - (r.bottom - r.top);
    return heightDiff > 100; // if more than 100 pixels, its probably a keyboard...
}

protected void showKeyboard() {
    if (isKeyboardVisible())
        return;
    InputMethodManager inputMethodManager = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
    if (getCurrentFocus() == null) {
        inputMethodManager.toggleSoftInput(InputMethodManager.SHOW_FORCED, 0);
    } else {
        View view = getCurrentFocus();
        inputMethodManager.showSoftInput(view, InputMethodManager.SHOW_FORCED);
    }
}

protected void hideKeyboard() {
    if (!isKeyboardVisible())
        return;
    InputMethodManager inputMethodManager = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
    View view = getCurrentFocus();
    if (view == null) {
        if (inputMethodManager.isAcceptingText())
            inputMethodManager.toggleSoftInput(InputMethodManager.HIDE_NOT_ALWAYS, 0);
    } else {
        if (view instanceof EditText)
            ((EditText) view).setText(((EditText) view).getText().toString()); // reset edit text bug on some keyboards bug
        inputMethodManager.hideSoftInputFromInputMethod(view.getWindowToken(), InputMethodManager.HIDE_NOT_ALWAYS);
    }
}

Saurabh Pareek tem a melhor resposta até agora.

Pode também usar os sinalizadores corretos, no entanto.

/* hide keyboard */
((InputMethodManager) getSystemService(Activity.INPUT_METHOD_SERVICE))
    .toggleSoftInput(InputMethodManager.SHOW_IMPLICIT, 0);

/* show keyboard */
((InputMethodManager) getSystemService(Activity.INPUT_METHOD_SERVICE))
    .toggleSoftInput(0, InputMethodManager.HIDE_IMPLICIT_ONLY);

Exemplo de uso real

/* click button */
public void onClick(View view) {      
  /* hide keyboard */
  ((InputMethodManager) getSystemService(Activity.INPUT_METHOD_SERVICE))
      .toggleSoftInput(InputMethodManager.SHOW_IMPLICIT, 0);

  /* start loader to check parameters ... */
}

/* loader finished */
public void onLoadFinished(Loader<Object> loader, Object data) {
    /* parameters not valid ... */

    /* show keyboard */
    ((InputMethodManager) getSystemService(Activity.INPUT_METHOD_SERVICE))
        .toggleSoftInput(0, InputMethodManager.HIDE_IMPLICIT_ONLY);

    /* parameters valid ... */
}

Veja como você faz isso no Mono para Android (AKA MonoDroid)

InputMethodManager imm = GetSystemService (Context.InputMethodService) as InputMethodManager;
if (imm != null)
    imm.HideSoftInputFromWindow (searchbox.WindowToken , 0);

usa isto

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

As respostas acima funcionam para cenários diferentes, mas se você quiser ocultar o teclado dentro de uma visualização e se esforçar para obter o contexto correto, tente o seguinte:

setOnClickListener(new OnClickListener() {
    @Override
    public void onClick(View v) {
        hideSoftKeyBoardOnTabClicked(v);
    }
}

private void hideSoftKeyBoardOnTabClicked(View v) {
    if (v != null && context != null) {
        InputMethodManager imm = (InputMethodManager) context.getSystemService(Context.INPUT_METHOD_SERVICE);
        imm.hideSoftInputFromWindow(v.getApplicationWindowToken(), InputMethodManager.HIDE_NOT_ALWAYS);
    }
}

e para obter o contexto buscá-lo do construtor :)

public View/RelativeLayout/so and so (Context context, AttributeSet attrs, int defStyle) {
    super(context, attrs, defStyle);
    this.context = context;
    init();
}

Como alternativa a essa solução completa , se você quiser fechar o teclado virtual de qualquer lugar sem ter uma referência ao campo (EditText) que foi usado para abrir o teclado, mas ainda assim quiser fazê-lo se o campo estivesse focado, você poderia usar isso (de uma atividade):

if (getCurrentFocus() != null) {
    InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
    imm.hideSoftInputFromWindow(getCurrentFocus().getWindowToken(), 0);
}

Eu tenho o caso, onde o meu também EditTextpode ser localizado em um AlertDialog, então o teclado deve ser fechado ao ser dispensado. O código a seguir parece estar funcionando em qualquer lugar:

public static void hideKeyboard( Activity activity ) {
    InputMethodManager imm = (InputMethodManager)activity.getSystemService( Context.INPUT_METHOD_SERVICE );
    View f = activity.getCurrentFocus();
    if( null != f && null != f.getWindowToken() && EditText.class.isAssignableFrom( f.getClass() ) )
        imm.hideSoftInputFromWindow( f.getWindowToken(), 0 );
    else 
        activity.getWindow().setSoftInputMode( WindowManager.LayoutParams.SOFT_INPUT_STATE_ALWAYS_HIDDEN );
}

Graças a esta resposta , eu deduzi o seguinte que, no meu caso, funciona muito bem ao percorrer os fragmentos de um ViewPager ...

private void hideKeyboard() {   
    // Check if no view has focus:
    View view = this.getCurrentFocus();
    if (view != null) {
        InputMethodManager inputManager = (InputMethodManager) this.getSystemService(Context.INPUT_METHOD_SERVICE);
        inputManager.hideSoftInputFromWindow(view.getWindowToken(), InputMethodManager.HIDE_NOT_ALWAYS);
    }
}

private void showKeyboard() {   
    // Check if no view has focus:
    View view = this.getCurrentFocus();
    if (view != null) {
        InputMethodManager inputManager = (InputMethodManager) this.getSystemService(Context.INPUT_METHOD_SERVICE);
        inputManager.showSoftInput(view, InputMethodManager.SHOW_IMPLICIT);
    }
}

Simples e fácil de usar método, basta chamar hideKeyboardFrom (YourActivity.this); esconder o teclado

/**
 * This method is used to hide keyboard
 * @param activity
 */
public static void hideKeyboardFrom(Activity activity) {
    InputMethodManager imm = (InputMethodManager) activity.getSystemService(Activity.INPUT_METHOD_SERVICE);
    imm.hideSoftInputFromWindow(activity.getCurrentFocus().getWindowToken(), 0);
}

protected void hideSoftKeyboard(EditText input) {
    input.setInputType(0);
    InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
    imm.hideSoftInputFromWindow(input.getWindowToken(), 0);    
}




soft-keyboard