Fechar / ocultar o teclado virtual android

Eu tenho um EditTexte um Buttonno meu layout.

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

Ao tocar fora do teclado.

Para ajudar a esclarecer essa loucura, gostaria de começar pedindo desculpas, em nome de todos os usuários do Android, pelo tratamento ridículo do Google com o teclado virtual. A razão pela qual existem tantas respostas, cada uma diferente, para a mesma pergunta simples é porque essa API, como muitas outras no Android, é horrivelmente projetada. Não consigo pensar em nenhuma maneira educada de dizer isso.

Eu quero esconder o teclado. Espero para fornecer Android com a seguinte declaração: Keyboard.hide(). O fim. Muito obrigado. Mas o Android tem um problema. Você deve usar o InputMethodManagerpara ocultar o teclado. OK, tudo bem, esta é a API do Android para o teclado. MAS! Você precisa ter um Contextpara obter acesso ao IMM. Agora nós temos um problema. Talvez eu queira ocultar o teclado de uma classe estática ou de utilitário que não tenha utilidade ou necessidade Context. ou E Pior ainda, o IMM exige que você especifique o que View(ou pior, o que Window) deseja ocultar do teclado.

É isso que torna a ocultação do teclado um desafio. Caro Google: Quando estou pesquisando a receita de um bolo, não há RecipeProviderna Terra que se recusaria a me fornecer a receita, a menos que eu responda primeiro a QUEM o bolo será comido E onde será comido !!

Essa triste história termina com a feia verdade: para ocultar o teclado do Android, você precisará fornecer duas formas de identificação: Contextae a Viewou a ou a Window.

Eu criei um método de utilitário estático que pode fazer o trabalho MUITO solidamente, desde que você o chame de 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 de um Activity! O método acima chama getCurrentFocuso destino Activitypara buscar o token de janela apropriado.

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

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

Isso não funcionará porque você passará uma referência ao Fragmenthost do Activityque não terá controle focado enquanto o Fragmenté mostrado! Uau! Portanto, para ocultar fragmentos do teclado, recorro ao 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);
}

Abaixo estão algumas informações adicionais obtidas com mais tempo desperdiçado na busca desta solução:

Sobre windowSoftInputMode

Há ainda outro ponto de discórdia a ter em conta. Por padrão, o Android atribui automaticamente o foco inicial ao primeiro EditTextou controle focalizável no seu Activity. Segue-se naturalmente que o InputMethod (normalmente o teclado virtual) responderá ao evento de foco, mostrando-se. O windowSoftInputModeatributo em AndroidManifest.xml, quando definido como stateAlwaysHidden, instrui o teclado a ignorar esse foco inicial atribuído automaticamente.

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

Quase inacreditavelmente, parece não fazer nada para impedir a abertura do teclado quando você toca no controle (a menos que focusable="false"e / ou focusableInTouchMode="false"esteja atribuído ao controle). Aparentemente, a configuração windowSoftInputMode se aplica apenas a eventos de foco automático, não a eventos de foco acionados por eventos de toque.

Portanto, stateAlwaysHiddené MUITO mal nomeado de fato. Talvez devesse ser chamado em seu ignoreInitialFocuslugar.

Espero que isto ajude.

UPDATE: Mais maneiras de obter um token de janela

Se não houver uma visão focada (por exemplo, pode acontecer se você acabou de alterar fragmentos), existem outras visualizações que fornecerão um token de janela útil.

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

Dentro de uma classe de fragmento:

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

Dado um fragmento fragmentcomo parâmetro:

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

A partir do seu corpo de conteúdo:

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

ATUALIZAÇÃO 2: foco claro para evitar a exibição do teclado novamente se você abrir o aplicativo a partir do segundo plano

Adicione esta linha ao final do método:

view.clearFocus();

Você pode forçar o Android a ocultar o teclado virtual usando o InputMethodManager , chamando hideSoftInputFromWindow, passando o token da janela que contém sua exibiçã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);
}

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

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

Sintaxe de Kotlin

// Check if no view has focus:
 val view = this.currentFocus
 view?.let { v ->
  val imm = getSystemService(Context.INPUT_METHOD_SERVICE) as? InputMethodManager 
  imm?.hideSoftInputFromWindow(v.windowToken, 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 visualização EditText.

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

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

Aqui passe HIDE_IMPLICIT_ONLYna posição de showFlage 0na posição de hiddenFlag. Ele fechará com força o teclado virtual.

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

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

Tente este código abaixo em onCreate()

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

Atualização: não sei por que essa 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);

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

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

Crie uma função que gerencie algumas das EditTextpropriedades de:

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

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

Em seguida, certifique-se de que, ao focar, EditTextabra / feche 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, ligue para:

setEditTextFocus(true);

E para fechar a chamada:

setEditTextFocus(false);

Saurabh Pareek tem a melhor resposta até agora.

No entanto, é melhor usar as bandeiras corretas.

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

de tão pesquisando, aqui 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);

A resposta curta

No seu OnClickouvinte, chame o onEditorActionde EditTextcomIME_ACTION_DONE

button.setOnClickListener(new OnClickListener() {

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

O detalhamento

Eu sinto que esse 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 EditTextfoco que teve / teve e também foi o primeiro a invocar o teclado em primeiro lugar (é definitivamente capaz de invocá-lo em muitos cenários comuns). No mesmo caminho, ele deve ser o único a liberar o teclado, geralmente, que pode ser feito por um ImeAction. Basta ver como um EditTextcom android:imeOptions="actionDone"se comporta, você quer conseguir o mesmo comportamento pelos mesmos meios.

Verifique esta resposta relacionada

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

Estou usando um teclado personalizado para inserir um número hexadecimal, para que o teclado IMM não seja exibido ...

Na v3.2.4_r1, setSoftInputShownOnFocus(boolean show)foi adicionado para controlar o clima ou não para exibir o teclado quando um TextView obtém o foco, mas ainda está oculto, portanto a reflexão deve ser usada:

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, obtive resultados muito bons (mas longe de serem perfeitos) com a OnGlobalLayoutListener, adicionados com a ajuda de a ViewTreeObserverda minha visualização raiz e verificando se o teclado é mostrado assim:

@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 por uma fração de segundo e mexer com as alças de seleção.

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

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

Atualização: Acabei de descobrir quais caixas de diálogo são usadas para nunca mostrar o teclado e funcionam em todas as versões:

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

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

Passei mais de dois dias trabalhando em todas as soluções postadas no segmento e as encontrei ausentes de uma maneira ou de outra. Meu requisito exato é ter um botão que mostre com 100% de confiabilidade ou oculte o teclado na tela. Quando o teclado está no estado oculto, ele não deve reaparecer, independentemente dos campos de entrada nos quais 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 clica. Isso precisa funcionar no Android 2.2 ou superior até os dispositivos mais recentes.

Você pode ver uma implementação funcional disso no 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. Ocultar temporariamente o teclado. Aparecerá novamente quando um usuário focalizar 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. Este sinalizador só pode ser definido quando uma atividade está sendo inicializada.
3. Marque uma atividade para nunca mostrar ou permitir o uso do teclado. Este sinalizador só pode ser definido quando uma atividade está sendo inicializada.

Para mim, ocultar temporariamente o teclado não é suficiente. Em alguns dispositivos, ele reaparece assim que um novo campo de texto é focado. 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 volte a aparecer.

Infelizmente, os itens 2 e 3 da lista só funcionam com confiabilidade quando uma atividade está sendo iniciada. Depois que 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 pressionar o botão de alternância do teclado. No meu aplicativo, quando o usuário pressiona o botão de alternância do teclado, 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 tenha seu estado salvo em um pacote 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 for mostrado, o InputMethodManager é instruído a mostrar o teclado e a janela é instruída a tornar a entrada virtual sempre visível. Se o teclado virtual estiver oculto, o WindowManager.LayoutParams.FLAG_ALT_FOCUSABLE_IM está definido.

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

Como alternativa a essa solução geral , se você deseja fechar o teclado virtual de qualquer lugar sem ter uma referência ao campo (EditText) usado para abrir o teclado, mas ainda assim deseja fazê-lo se o campo estiver focado, você poderá usar this (de uma atividade):

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

Graças a esta resposta do SO , deduzi o seguinte que, no meu caso, funciona bem ao rolar pelos 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);
    }
}

As respostas acima funcionam para cenários diferentes, mas se você deseja ocultar o teclado dentro de uma visualização e se esforçando 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, busque-o no construtor :)

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

Se você deseja fechar o teclado virtual durante uma unidade ou teste funcional, clique no "botão voltar" do seu teste:

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

Coloquei o "botão voltar" entre aspas, pois o acima não aciona o onBackPressed()da Atividade em questão. Apenas fecha o teclado.

Faça uma pausa por um tempo antes de prosseguir, pois leva um pouco para fechar o botão Voltar, para que cliques subsequentes em Visualizações, etc., não sejam registrados até depois de uma breve pausa (1 segundo é o suficiente) )

Veja como fazer isso no Mono para Android (AKA MonoDroid)

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

Isso funcionou para mim em todo o comportamento bizarro do teclado

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

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

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

Método simples e fácil de usar, 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);
}

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

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

após essa chamada no onTouchListener:

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

usa isto

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

Para o meu caso, eu estava usando o a SearchView na barra de ação. Depois que um usuário realiza uma pesquisa, o teclado é aberto novamente.

O uso do InputMethodManager não fechou o teclado. Eu tive que limpar o Focus e definir o foco da visualização de pesquisa como false:

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

Eu tenho o caso, onde meu também EditTextpode ser localizado em um AlertDialog, portanto, o teclado deve ser fechado ao ser descartado. 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 );
}

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

Acabo forçando o show e me escondendo, e 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);
}