Fermer / cacher le clavier souple Android

https://stackoverflow.com/questions/1109022

12-09-2019
|

Question

J'ai un EditText et un Button dans ma mise en page.

Après avoir écrit dans le champ d'édition et en cliquant sur le Button, je veux cacher le clavier virtuel. Je suppose que c'est un simple morceau de code, mais où puis-je trouver un exemple de celui-ci?

La solution

Pour aider à clarifier cette folie, je voudrais commencer par présenter des excuses au nom de tous les utilisateurs d'Android pour le traitement tout à fait ridicule de Google du clavier tactile. La raison pour laquelle il y a tant de réponses, toutes différentes, pour la même question simple car cette API, comme beaucoup d'autres dans Android, est horriblement conçu. Je ne peux penser à aucune façon polie de le dire.

Je veux cacher le clavier. Je pense à fournir Android avec l'énoncé suivant: Keyboard.hide(). La fin. Merci beaucoup. Mais Android a un problème. Vous devez utiliser le InputMethodManager pour masquer le clavier. OK, très bien, c'est l'API Android au clavier. MAIS! Vous devez avoir un Context afin d'obtenir l'accès à l'IMM. Maintenant, nous avons un problème. Je veux cacher le clavier d'une classe statique ou utilitaire qui n'a pas d'utilité ou le besoin d'une Context. ou Et bien pire, l'IMM exige que vous spécifiez ce View (ou pire encore, ce Window) que vous voulez masquer le clavier de.

C'est ce qui cache le clavier si difficile. Cher Google: Quand je suis à la recherche la recette pour un gâteau, il n'y a pas RecipeProvider sur la Terre qui refuse de me donner la recette à moins que je réponds d'abord l'OMS le gâteau sera mangé par et où il sera mangé !!

Cette triste histoire se termine par la triste vérité: pour cacher le clavier Android, vous devrez fournir 2 pièces d'identité:. Un Context et soit un View ou Window

J'ai créé une méthode utilitaire statique qui peut faire le travail très solide, à condition que vous appelez d'un 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);
}

Sachez que cette méthode utilitaire ne fonctionne que lorsqu'il est appelé à partir d'un Activity! La méthode ci-dessus appelle getCurrentFocus du Activity cible pour aller chercher le bon jeton de fenêtre.

Mais supposons que vous voulez cacher le clavier d'un EditText hébergé dans un DialogFragment? Vous ne pouvez pas utiliser la méthode ci-dessus pour que:

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

Cela ne fonctionnera pas parce que vous passerez une référence à la Fragment hôte du Activity, qui aura aucun contrôle ciblé alors que le Fragment est montré! Hou la la! Donc, pour cacher le clavier à partir de fragments, je recours au niveau inférieur, plus fréquent et plus laid:

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

Voici quelques informations supplémentaires glanées plus de temps perdu chassant cette solution:

A propos de windowSoftInputMode

Il y a encore un autre point de discorde pour être au courant. Par défaut, Android attribuera automatiquement focus initial sur le premier ou le contrôle EditText focusable dans votre Activity. Il en résulte naturellement que le InputMethod (généralement le clavier doux) répondra à l'événement de mise au point en se montrant. L'attribut windowSoftInputMode dans AndroidManifest.xml, lorsqu'il est réglé sur stateAlwaysHidden, charge le clavier d'ignorer cette mise au point initial automatiquement attribué.

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

Presque incroyable, il semble ne rien faire pour empêcher le clavier de l'ouverture lorsque vous touchez le contrôle (à moins focusable="false" et / ou focusableInTouchMode="false" sont affectés au contrôle). Apparemment, le réglage de windowSoftInputMode applique uniquement aux événements de mise au point automatique, et non de se concentrer les événements déclenchés par des événements tactiles.

Par conséquent, stateAlwaysHidden est très mal nommé en effet. Il faudrait peut-être appelé ignoreInitialFocus à la place.

Hope this helps.

MISE À JOUR: D'autres façons d'obtenir un jeton de fenêtre

S'il n'y a pas de vue ciblée (par exemple peut se produire si vous venez de fragments changé), il y a d'autres points de vue qui fournira un jeton de fenêtre utile.

Ce sont des solutions de rechange pour le code ci-dessus if (view == null) view = new View(activity); Ceux-ci ne font pas explicitement référence à votre activité.

Dans une classe de fragments:

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

Etant donné un fragment de fragment comme paramètre:

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

A partir de votre corps contenu:

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

Mise à jour 2: Une orientation claire pour éviter de montrer à nouveau clavier si vous ouvrez l'application de l'arrière-plan

Ajoutez cette ligne à la fin de la méthode:

view.clearFocus();

Autres conseils

Vous pouvez forcer Android pour masquer le clavier virtuel en utilisant le InputMethodManager , appelant hideSoftInputFromWindow , en passant dans le jeton de la fenêtre contenant votre point de vue ciblée.

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

Cela forcera le clavier à être caché dans toutes les situations. Dans certains cas, vous voulez passer InputMethodManager.HIDE_IMPLICIT_ONLY comme second paramètre pour vous assurer que masquer le clavier lorsque l'utilisateur ne forcez pas explicitement apparaître (en tenant menu déroulant).

Remarque: Si vous voulez faire en Kotlin, utilisez: context?.getSystemService(Context.INPUT_METHOD_SERVICE) as InputMethodManager

Kotlin Syntaxe

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

Aussi utile pour masquer le clavier virtuel est:

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

Il peut être utilisé pour supprimer le clavier doux jusqu'à ce que l'utilisateur touche réellement le editText View.

Je suis une autre solution pour cacher le clavier:

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

passer ici HIDE_IMPLICIT_ONLY à la position de showFlag et 0 à la position de hiddenFlag. Il forcera la fermeture du clavier souple.

La solution de Meier travaille pour moi aussi. Dans mon cas, le haut niveau de mon application est un tabHost et je veux cacher le mot-clé lors du passage des onglets -. Je reçois le jeton de la fenêtre de la tabHost Voir

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

S'il vous plaît essayer ci-dessous le code dans onCreate()

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

Mise à jour: Je ne sais pas pourquoi cette solution est pas un travail plus (je viens de tester sur Android 23). S'il vous plaît utiliser la solution de Saurabh Pareek à la place. Ici, il est:

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

Ancienne réponse:

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

Si toutes les autres réponses ici ne fonctionnent pas pour vous que vous voulez les voir, il y a une autre façon de contrôler manuellement le clavier.

Créer une fonction avec qui va gérer certaines propriétés du EditText:

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

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

Ensuite, assurez-vous que onFocus du EditText vous ouvrir / fermer le clavier:

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

Maintenant, chaque fois que vous voulez ouvrir le clavier manuellement:

setEditTextFocus(true);

Et pour l'appel de clôture:

setEditTextFocus(false);

Saurabh Pareek a la meilleure réponse à ce jour.

Aussi bien utiliser les drapeaux corrects, cependant.

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

Exemple d'utilisation réelle

/* 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 la recherche si, ici j'ai trouvé une réponse qui fonctionne pour moi

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

La réponse courte

Dans l'écouteur d'OnClick appeler le onEditorAction du EditText avec IME_ACTION_DONE

button.setOnClickListener(new OnClickListener() {

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

La drill-down

Je pense que cette méthode est meilleure, plus simple et plus aligné avec le modèle de conception d'Android. Dans l'exemple ci-dessus simples (et le plus souvent dans la plupart des cas communs) vous aurez un EditText qui a / avait mise au point et il est habituellement aussi était celui d'invoquer le clavier en premier lieu (il est certainement en mesure de l'invoquer de nombreux scénarios communs). De cette même manière, il devrait être celui de libérer le clavier, généralement que peut être fait par un ImeAction. Il suffit de voir comment un EditText avec android:imeOptions="actionDone" se comporte, vous voulez atteindre le même comportement par les mêmes moyens.

Cochez cette réponse concernant

Cela devrait fonctionner:

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

J'utilise un clavier personnalisé pour entrer un numéro hexadécimal donc je ne peux pas avoir le clavier IMM affiché ...

Dans v3.2.4_r1 setSoftInputShownOnFocus(boolean show) a été ajouté pour contrôler le temps ou pas pour afficher le clavier quand un TextView obtient le focus, mais il est encore caché si la réflexion doit être utilisé:

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

Pour les anciennes versions, je me suis de très bons résultats (mais loin d'être parfait) avec un OnGlobalLayoutListener, ajouté à l'aide d'un ViewTreeObserver de mon point de vue racine, puis vérifier si le clavier est affichée comme ceci:

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

Cette dernière solution peut afficher le clavier pour une fraction de seconde et salit avec les poignées de sélection.

Lorsque le clavier pénètre plein écran, onGlobalLayout est pas appelé. Pour éviter cela, utilisez TextView # setImeOptions (int) ou dans la déclaration XML TextView:

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

Mise à jour: Je viens de trouver ce que les dialogues utiliser pour montrer jamais le clavier et fonctionne dans toutes les versions:

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

J'ai passé plus de deux jours ouvrables à travers toutes les solutions affichées dans le fil et les ai trouvés manque d'une manière ou d'une autre. Mon exigence exacte est d'avoir un bouton qui avec émission de fiabilité à 100% ou masquer le clavier à l'écran. Lorsque le clavier est dans son état caché est ne devrait pas réapparaître, peu importe ce que les champs d'entrée l'utilisateur clique sur. Quand il est dans son état visible le clavier ne doit pas disparaître, peu importe ce que les boutons que l'utilisateur clique. Cela doit fonctionner sur Android 2.2+ tout le chemin jusqu'à les derniers périphériques.

Vous pouvez voir une mise en œuvre de ce travail dans mon application RPN propre.

Après avoir testé plusieurs des réponses proposées sur un certain nombre de téléphones (y compris les dispositifs de froyo et pain d'épice), il est devenu évident que les applications Android de manière fiable:

masquer temporairement le clavier. Il réapparaît à nouveau lorsqu'un utilisateur concentre un nouveau champ de texte.
Afficher le clavier quand une activité commence et définir un indicateur sur l'activité indiquant qu'ils devraient clavier toujours visible. Ce drapeau ne peut être réglé lorsqu'une activité est initialisant.
Marquer une activité à ne jamais afficher ou permettre l'utilisation du clavier. Ce drapeau ne peut être réglé lorsqu'une activité est initialisant.

Pour moi, cachant temporairement le clavier ne suffit pas. Sur certains appareils, il réapparaîtra dès qu'un nouveau champ de texte se concentre. Comme mon application utilise plusieurs champs de texte sur une page, en se concentrant un nouveau champ de texte provoque le clavier caché à la pop revenir à nouveau.

Malheureusement, le point 2 et 3 sur la liste ne fonctionnent fiabilité quand une activité est en cours de démarrage. Une fois que l'activité est devenue visible, vous ne pouvez pas cacher de façon permanente ou afficher le clavier. L'astuce consiste à redémarrer réellement votre activité lorsque l'utilisateur appuie sur le bouton à bascule du clavier. Dans mon application lorsque l'utilisateur appuie sur le bouton du clavier à bascule, le code suivant fonctionne:

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

Cela provoque l'activité actuelle d'avoir son état enregistré en un faisceau, puis l'activité est lancée, en passant par un booléen qui indique si le clavier doit être affiché ou masqué.

Dans la méthode onCreate le code suivant est exécuté:

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

Si le clavier souple doit être affiché, le InputMethodManager est dit de montrer le clavier et la fenêtre est chargé de rendre l'entrée douce toujours visible. Si le clavier souple doit être caché alors le WindowManager.LayoutParams.FLAG_ALT_FOCUSABLE_IM est réglé.

Cette approche fonctionne de manière fiable sur tous les appareils que j'ai testé sur - à partir d'un téléphone HTC 4 ans fonctionnant sous Android 2.2 à un lien 7 en cours d'exécution 4.2.2. Le seul inconvénient de cette approche est que vous devez faire attention à la manipulation du bouton de retour. Comme mon application essentiellement n'a qu'un seul écran (son une calculatrice) Je peux passer outre onBackPressed () et revenir à l'écran d'accueil périphériques.

Vous pouvez également à href="https://stackoverflow.com/a/9494042/451962"> , si vous voulez fermer le clavier souple où que vous soyez sans avoir une référence à la (EditText) champ qui a été utilisé pour ouvrir le clavier, mais toujours voulu le faire si le champ était concentré, vous pouvez utiliser ce (à partir d'une activité):

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

Merci cela fonctionne SO répondre , je tirais les éléments suivants qui, dans mon cas, bien lorsque vous faites défiler le la des fragments d'un 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);
    }
}

Au-dessus de réponses fonctionnent pour différents scénarios de mais Si vous voulez masquer le clavier dans une vue et la difficulté à obtenir le bon contexte, essayez ceci:

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

et pour l'obtenir chercher le contexte du constructeur :)

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

Si vous voulez fermer le clavier souple lors d'une unité ou un test fonctionnel, vous pouvez le faire en cliquant sur le bouton « retour » de votre test:

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

entre guillemets, puisque le ci-dessus ne déclenche pas l'onBackPressed() pour l'activité en question que je bouton « retour ». Il ferme juste le clavier.

Assurez-vous de faire une pause pendant un moment avant de passer, car il faut un peu de temps pour fermer le bouton de retour, de sorte que les clics suivants à vues, etc., ne seront pas enregistrées après une courte pause (1 seconde est assez longtemps ime).

Voici comment vous le faites dans Mono pour Android (AKA MonoDroid)

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

Cela a fonctionné pour moi tout le comportement du clavier bizarre

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

Ajoutez à votre android:windowSoftInputMode="stateHidden" d'activité dans le fichier Manifest. Exemple:

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

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

après appel onTouchListener:

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

utiliser

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

Pour mon cas, j'utilisais l'un SearchView dans le actionbar. Une fois qu'un utilisateur effectue une recherche, le clavier sauterait à nouveau ouvert.

Utilisation de la InputMethodManager ne pas fermer le clavier. Je devais clearfocus et définir les focusable de la vue de la recherche sur false:

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

Il suffit d'utiliser ce code optimisé dans votre activité:

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

Je le cas où mon EditText peut être également situé dans un AlertDialog, de sorte que le clavier doit être fermé le rejeter. Le code suivant semble fonctionner partout:

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

J'ai presque essayé toutes ces réponses, j'ai eu quelques problèmes au hasard en particulier avec la Samsung Galaxy s5.

Ce que je finis avec force le spectacle et se cacher, et il fonctionne parfaitement:

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

Dans certains cas, ces méthodes peuvent, à l'exception des œuvres de tous les autres. Cela permet d'économiser mon jour:)

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

Licencié sous: CC-BY-SA avec attribution

Non affilié à StackOverflow