Fechar / ocultar o teclado virtual Android

Question

Eu tenho um EditText e uma Button no meu layout.

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

Answer 1

Para ajudar a esclarecer essa loucura, eu gostaria de começar por pedir desculpa em nome de todos os usuários do Android para o tratamento simplesmente ridícula do Google no teclado virtual. A razão há tantas respostas, cada um diferente, para a mesma pergunta simples, porque esta API, como muitos outros em Android, é horrivelmente projetado. Eu posso pensar em nenhuma maneira educada para indicá-lo.

Eu quero esconder o teclado. Espero para fornecer Android com a seguinte afirmação: Keyboard.hide(). O fim. Muito obrigado. Mas o Android tem um problema. Você deve usar o InputMethodManager para ocultar o teclado. OK, bem, esta é a API do Android para o teclado. MAS! Você é obrigado a ter um Context a fim de obter acesso ao IMM. Agora nós temos um problema. I pode querer ocultar o teclado de uma classe estática ou utilitário que não tem nenhum uso ou necessidade de qualquer Context. ou E muito pior, o IMM requer que você especifique o que View (ou pior ainda, que Window) você deseja ocultar o teclado.

Este é o que faz escondendo o teclado de modo desafiador. Caro Google: Quando eu estou olhando para cima a receita para um bolo, não há RecipeProvider na Terra, que se recusam a fornecer-me com a receita a menos que primeiro responder a OMS o bolo vai ser comido por E onde vai ser comido !!

Isto termina triste história com a verdade feia: para ocultar o teclado Android, você vai ser obrigado a fornecer 2 formas de identificação:. Um Context e quer um View ou um Window

Eu criei um método utilitário estático, que pode fazer o trabalho muito solidamente, desde que você chamá-lo de um Activity.

public static void hideKeyboard(Activity activity) {
    InputMethodManager imm = (InputMethodManager) activity.getSystemService(Activity.INPUT_METHOD_SERVICE);
    //Find the currently focused view, so we can grab the correct window token from it.
    View view = activity.getCurrentFocus();
    //If no view currently has focus, create a new one, just so we can grab a window token from it
    if (view == null) {
        view = new View(activity);
    }
    imm.hideSoftInputFromWindow(view.getWindowToken(), 0);
}

Esteja ciente de que este método utilitário só funciona quando chamado a partir de um Activity! As chamadas de método acima getCurrentFocus do Activity alvo para buscar o token janela adequada.

Mas suponha que você queira ocultar o teclado de um EditText hospedado em um DialogFragment? Você não pode usar o método acima para isso:

hideKeyboard(getActivity()); //won't work

Isso não vai funcionar porque você estará passando uma referência para Fragment host do Activity, que não terá nenhum controle focado enquanto o Fragment é mostrado! Uau! Então, para esconder o teclado a partir de fragmentos, eu recorrer ao de nível inferior, mais comum, e mais feio:

public static void hideKeyboardFrom(Context context, View view) {
    InputMethodManager imm = (InputMethodManager) context.getSystemService(Activity.INPUT_METHOD_SERVICE);
    imm.hideSoftInputFromWindow(view.getWindowToken(), 0);
}

A seguir está algumas informações adicionais recolhidas de mais tempo desperdiçado perseguindo esta solução:

Sobre windowSoftInputMode

Há ainda um outro ponto de discórdia para estar ciente. Por padrão, o Android irá atribuir automaticamente o foco inicial para o primeiro EditText ou controle focusable em sua Activity. Segue-se naturalmente que o InputMethod (normalmente o teclado virtual) responderá ao evento de foco, mostrando-se. O atributo windowSoftInputMode em AndroidManifest.xml, quando definido como stateAlwaysHidden, instrui o teclado para ignorar este foco inicial atribuída automaticamente.

<activity
    android:name=".MyActivity"
    android:windowSoftInputMode="stateAlwaysHidden"/>

Quase inacreditavelmente, parece fazer nada para impedir que o teclado seja aberto quando você toca o controle (a menos que focusable="false" e / ou focusableInTouchMode="false" são atribuídos ao controle). Aparentemente, a definição windowSoftInputMode só se aplica a eventos de foco automático, não foco eventos desencadeados por eventos de toque.

Portanto, stateAlwaysHidden é muito mal nomeado de fato. Talvez deva ser chamado ignoreInitialFocus vez.

Espero que isso ajude.

---

UPDATE: Mais maneiras de obter uma janela de token

Se não há uma visão focada (por exemplo, pode acontecer se você apenas mudou fragmentos), existem outros pontos de vista que irão fornecer um símbolo janela útil.

Estes são alternativas para a if (view == null) view = new View(activity); código acima Estes não se referem explicitamente à sua actividade.

Dentro de uma classe fragmento:

view = getView().getRootView().getWindowToken();

Dada uma fragment fragmento como um parâmetro:

view = fragment.getView().getRootView().getWindowToken();

A partir de seu corpo conteúdo:

view = findViewById(android.R.id.content).getRootView().getWindowToken();

---

UPDATE 2: Limpar o foco para evitar mostrar teclado novamente se você abrir o aplicativo a partir do fundo

Adicione esta linha ao final do método:

view.clearFocus();

Answer 2

Você pode forçar o Android para ocultar o teclado virtual usando o InputMethodManager , chamando hideSoftInputFromWindow , passando o token da janela que contém a sua visão focada.

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

Isto irá forçar o teclado para ser escondido em todas as situações. Em alguns casos, você vai querer passar em InputMethodManager.HIDE_IMPLICIT_ONLY como o segundo parâmetro para garantir só ocultar o teclado quando o usuário não forçá-lo explicitamente para aparecer (mantendo-down menu).

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

Kotlin Sintaxe

// Check if no view has focus:
 val view = this.currentFocus
 view?.let { v ->
  val imm = getSystemService(Context.INPUT_METHOD_SERVICE) as? InputMethodManager 
  imm?.let { it.hideSoftInputFromWindow(v.windowToken, 0) }
 }

Answer 3

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

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

Isto pode ser usado para suprimir o teclado virtual até que o usuário realmente toca o EditText View.

Answer 4

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

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

Aqui passar HIDE_IMPLICIT_ONLY na posição de showFlag e 0 na posição de hiddenFlag. Ele irá teclado com força perto macio.

Answer 5

A solução de Meier funciona para mim também. No meu caso o nível mais alto da minha App é um TabHost e quero esconder a palavra-chave quando se muda guias -. Tenho a janela token do TabHost Ver

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

Answer 6

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

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

Answer 7

Update: Eu não sei por que essa solução não é trabalhar mais (eu só testado em Android 23). Utilize 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);

Answer 8

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

Answer 9

Se todas as outras respostas aqui não funcionam para você como você gostaria que eles, não há outra maneira de controlar manualmente o teclado.

Criar uma função com que irá gerir algumas das propriedades do EditText:

public void setEditTextFocus(boolean isFocused) {
    searchEditText.setCursorVisible(isFocused);
    searchEditText.setFocusable(isFocused);
    searchEditText.setFocusableInTouchMode(isFocused);

    if (isFocused) {
        searchEditText.requestFocus();
    }
}

Em seguida, certifique-se de que onFocus do EditText abrir / fechar o teclado:

searchEditText.setOnFocusChangeListener(new OnFocusChangeListener() {
    @Override
    public void onFocusChange(View v, boolean hasFocus) {
        if (v == searchEditText) {
            if (hasFocus) {
                // Open keyboard
                ((InputMethodManager) context.getSystemService(Context.INPUT_METHOD_SERVICE)).showSoftInput(searchEditText, InputMethodManager.SHOW_FORCED);
            } else {
                // Close keyboard
                ((InputMethodManager) context.getSystemService(Context.INPUT_METHOD_SERVICE)).hideSoftInputFromWindow(searchEditText.getWindowToken(), 0);
            }
        }
    }
});

Agora, sempre que você quiser abrir o teclado manualmente chamar:

setEditTextFocus(true);

E para call de fechamento:

setEditTextFocus(false);

Answer 10

Saurabh Pareek tem a melhor resposta até agora.

Pode também usar as bandeiras corretos, apesar de tudo.

/* 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 real de uso

/* 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 ... */
}

Answer 11

a partir de então, pesquisar, aqui eu encontrei uma resposta que funciona para mim

// Show soft-keyboard:
InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
imm.toggleSoftInput(InputMethodManager.SHOW_FORCED, 0);

// Hide soft-keyboard:
getWindow().setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_STATE_ALWAYS_HIDDEN);

Answer 12

A resposta curta

Em seu ouvinte OnClick chamar o onEditorAction do EditText 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 padrão de design do Android. No exemplo acima simples (e, geralmente, na maioria dos casos comuns) você terá uma EditText que tem / teve foco e também normalmente foi o único a invocar o teclado em primeiro lugar (é definitivamente capaz de invocá-lo em muitos cenários comuns). No mesmo caminho, it deve ser o único a liberar o teclado, geralmente, que pode ser feito por um ImeAction. Basta ver como um EditText com comporta android:imeOptions="actionDone", você quer conseguir o mesmo comportamento pelos mesmos meios.

---

Verifique esta resposta relacionada

Answer 13

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

Answer 14

Eu estou usando um teclado personalizado para introduzir um número de Hex por isso não pode ter o teclado IMM aparecer ...

Em setSoftInputShownOnFocus(boolean show) v3.2.4_r1 foi adicionado para controlar o clima ou não para exibir o teclado quando um TextView recebe foco, mas ainda escondido para reflexão deve ser utilizado:

if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.HONEYCOMB_MR2) {
    try {
        Method method = TextView.class.getMethod("setSoftInputShownOnFocus", boolean.class);
        method.invoke(mEditText, false);
    } catch (Exception e) {
        // Fallback to the second method
    }
}

---

Para versões mais antigas, eu consegui resultados muito bons (mas longe de ser perfeito) com um OnGlobalLayoutListener, adicionados com a ajuda de um ViewTreeObserver de minha exibição de raiz e em seguida, verificar se o teclado é mostrado como isto:

@Override
public void onGlobalLayout() {
    Configuration config = getResources().getConfiguration();

    // Dont allow the default keyboard to show up
    if (config.keyboardHidden != Configuration.KEYBOARDHIDDEN_YES) {
        InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
        imm.hideSoftInputFromWindow(mRootView.getWindowToken(), 0);
    }
}

Esta última solução pode mostrar o teclado para uma fração de segundo e messes com as alças de seleção.

Quando no teclado entra tela cheia, onGlobalLayout não é chamado. Para evitar isso, use TextView # setImeOptions (int) ou na declaração XML TextView:

android:imeOptions="actionNone|actionUnspecified|flagNoFullscreen|flagNoExtractUi"

Update: Apenas encontrado o que diálogos usar para nunca mostrar o teclado e obras em todas as versões:

getWindow().setFlags(WindowManager.LayoutParams.FLAG_ALT_FOCUSABLE_IM,
        WindowManager.LayoutParams.FLAG_ALT_FOCUSABLE_IM);

Answer 15

public void setKeyboardVisibility(boolean show) {
    InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
    if(show){
        imm.toggleSoftInput(InputMethodManager.SHOW_FORCED, 0);
    }else{
        imm.hideSoftInputFromWindow(getCurrentFocus().getWindowToken(),0);
    }
}

Answer 16

Eu passei mais de dois dias a trabalhar através de todas as soluções postadas no tópico e encontraram-los falta de uma forma ou de outra. Minha exigência exata é ter um botão que vai com show de fiabilidade de 100% ou ocultar o teclado na tela. Quando o teclado está em seu estado oculto é não deve voltar a aparecer, não importa o que campos de entrada o usuário clica em. Quando se está em seu estado visível o teclado não deve desaparecer, não importa quais botões o usuário clica. Isso precisa trabalhar no Android 2.2 + todo o caminho até os mais recentes dispositivos.

Você pode ver um trabalho de implementação isso em meu aplicativo limpa RPN .

Depois de testar muitas das respostas sugeridas em um número de telefones diferentes (incluindo dispositivos Froyo e Gingerbread) tornou-se evidente que os aplicativos Android pode de forma confiável:

1. Temporariamente ocultar o teclado. Ele vai voltar a aparecer novamente quando um usuário focaliza um novo campo de texto.
2. Mostrar o teclado quando uma atividade começa e definir um sinalizador na atividade indicando que eles teclado deve estar sempre visível. Esta bandeira só pode ser definida quando uma actividade inicializar.
3. Mark uma atividade para nunca mostrar ou permitir o uso do teclado. Esta bandeira só pode ser definida quando uma actividade inicializar.

Para mim, escondendo temporariamente o teclado não é suficiente. Em alguns dispositivos que vai voltar a aparecer assim que um novo campo de texto está focada. Como meu aplicativo usa vários campos de texto em uma página, concentrando-se um novo campo de texto fará com que o teclado escondido pop volta para cima novamente.

Infelizmente o item 2 e 3 na lista única confiabilidade do trabalho quando uma atividade está sendo iniciado. Uma vez que a atividade tornou-se visível não pode se esconder de forma permanente ou mostrar o teclado. O truque é realmente reiniciar sua atividade quando o usuário pressiona o teclado botão de alternância. Em meu aplicativo quando o usuário pressiona sobre o botão do teclado de alternância, o seguinte código é 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 para ter seu estado guardado em um pacote, e então a atividade é iniciada, passando por um booleano que indica se o teclado deve ser mostrada ou escondida.

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 mostrada, então o InputMethodManager é dito para mostrar o teclado ea janela é instruído a fazer a entrada suave sempre visível. Se o teclado virtual deve ser escondido em seguida, o WindowManager.LayoutParams.FLAG_ALT_FOCUSABLE_IM está definido.

Esta abordagem funciona de forma confiável em todos os dispositivos que eu testei em - de 4 anos telefone HTC com Android 2.2 até um Nexus 7 em execução 4.2.2. A única desvantagem dessa abordagem é que você precisa ter cuidado com a manipulação do botão de volta. Como meu aplicativo essencialmente só tem uma tela (seu uma calculadora) Posso substituir onBackPressed () e retorno à tela de dispositivos de casa.

Answer 17

Como alternativa para este toda a solução em torno , se você queria fechar o teclado virtual em qualquer lugar sem ter uma referência para o campo (EditText) que foi usado para abrir o teclado, mas ainda queria fazê-lo se o campo estava focado, você poderia usar isso (a partir de uma atividade):

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

Answer 18

Graças à este SO resposta , eu derivado o seguinte que, no meu caso, funciona muito bem quando percorre a do 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);
    }
}

Answer 19

Acima responde trabalho para diferentes cenários de mas Se você quiser ocultar o teclado dentro de uma visão e lutando para obter o contexto certo 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á-la a partir de construtor :)

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

Answer 20

Se você quiser fechar o teclado virtual durante uma unidade ou teste funcional, você pode fazê-lo clicando no botão "voltar" do seu teste:

// Close the soft keyboard from a Test
getInstrumentation().sendKeyDownUpSync(KeyEvent.KEYCODE_BACK);

Eu coloquei "botão voltar" entre aspas, já que o anterior não acionar o onBackPressed() para a actividade em questão. Ele apenas fecha o teclado.

Certifique-se de fazer uma pausa por um tempo antes de avançar, uma vez que leva um pouco de tempo para fechar o botão voltar, cliques tão subsequentes para Visualizações, etc., não serão registrados até depois de uma breve pausa (1 segundo é ime tempo suficiente).

Answer 21

Aqui está como você fazê-lo em Mono para Android (AKA MonoDroid)

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

Answer 22

Isso funcionou para mim para 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);
    }
}

Answer 23

Adicione à sua android:windowSoftInputMode="stateHidden" atividade no arquivo de manifesto. Exemplo:

<activity
            android:name=".ui.activity.MainActivity"
            android:label="@string/mainactivity"
            android:windowSoftInputMode="stateHidden"/>

Answer 24

public static void hideSoftKeyboard(Activity activity) {
    InputMethodManager inputMethodManager = (InputMethodManager)  activity.getSystemService(Activity.INPUT_METHOD_SERVICE);
    inputMethodManager.hideSoftInputFromWindow(activity.getCurrentFocus().getWindowToken(), 0);
}

depois que invocam o onTouchListener:

findViewById(android.R.id.content).setOnTouchListener(new OnTouchListener() {
    @Override
    public boolean onTouch(View v, MotionEvent event) {
        Utils.hideSoftKeyboard(activity);
        return false;
    }
});

Answer 25

Use esta

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

Answer 26

Para o meu caso, eu estava usando a um SearchView na ActionBar. Depois que um usuário realiza uma pesquisa, o teclado seria pop aberta novamente.

Usando o InputMethodManager não fechar o teclado. Eu tive que clearFocus e definir o focalizável da exibição de pesquisa para false:

mSearchView.clearFocus();
mSearchView.setFocusable(false);

Answer 27

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

Answer 28

Eu tenho o caso, onde o meu EditText pode ser localizada também em uma AlertDialog, de modo que o teclado deve ser fechado em demitir. O código a seguir parece estar trabalhando 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 );
}

Answer 29

Eu quase tentou de todas essas respostas, eu tive alguns problemas aleatórios especialmente com o Samsung Galaxy S5.

O que eu acabar com está forçando o show e se esconder, e ele funciona perfeitamente:

/**
 * Force show softKeyboard.
 */
public static void forceShow(@NonNull Context context) {
    InputMethodManager imm = (InputMethodManager) context.getSystemService(Context.INPUT_METHOD_SERVICE);
    imm.toggleSoftInput(InputMethodManager.SHOW_FORCED, 0);
}

/**
 * Force hide softKeyboard.
 */
public static void forceHide(@NonNull Activity activity, @NonNull EditText editText) {
    if (activity.getCurrentFocus() == null || !(activity.getCurrentFocus() instanceof EditText)) {
        editText.requestFocus();
    }
    InputMethodManager imm = (InputMethodManager) activity.getSystemService(Context.INPUT_METHOD_SERVICE);
    imm.hideSoftInputFromWindow(editText.getWindowToken(), 0);
    activity.getWindow().setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_STATE_ALWAYS_HIDDEN);
}

Answer 30

Em alguns casos, estes métodos podem obras, exceto de todos os outros. Isso economiza o meu dia;)

public static void hideSoftKeyboard(Activity activity) {
    if (activity != null) {
        InputMethodManager inputManager = (InputMethodManager) activity.getSystemService(Context.INPUT_METHOD_SERVICE);
        if (activity.getCurrentFocus() != null && inputManager != null) {
            inputManager.hideSoftInputFromWindow(activity.getCurrentFocus().getWindowToken(), 0);
            inputManager.hideSoftInputFromInputMethod(activity.getCurrentFocus().getWindowToken(), 0);
        }
    }
}

public static void hideSoftKeyboard(View view) {
    if (view != null) {
        InputMethodManager inputManager = (InputMethodManager) view.getContext().getSystemService(Context.INPUT_METHOD_SERVICE);
        if (inputManager != null) {
            inputManager.hideSoftInputFromWindow(view.getWindowToken(), 0);
        }
    }
}