Fermer / masquer le clavier logiciel Android

Vous pouvez forcer Android à masquer le clavier virtuel en utilisant le InputMethodManager , en appelant hideSoftInputFromWindow, en passant dans le jeton de la fenêtre contenant votre vue focalisé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 voudrez passer InputMethodManager.HIDE_IMPLICIT_ONLY comme deuxième paramètre pour vous assurer que vous ne masquez le clavier que lorsque l'utilisateur ne l'a pas explicitement forcé à apparaître (en maintenant menu enfoncé).

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

Aussi utile pour cacher le clavier logiciel est:

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

Cela peut être utilisé pour supprimer le clavier logiciel jusqu'à ce que l'utilisateur touche réellement la vue editText.

J'ai une autre solution pour cacher le clavier:

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

Passent Ici HIDE_IMPLICIT_ONLY, à showFlag et 0, à hiddenFlag. Il fermera avec force le clavier logiciel.

La solution de Meier fonctionne aussi pour moi. Dans mon cas, le niveau supérieur de mon application est un tabHost et je souhaite masquer le mot - clé lors du changement d'onglet-j'obtiens le jeton de fenêtre de la vue tabHost.

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

Veuillez essayer ce code ci-dessous dans onCreate()

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

Mise à Jour: Je ne sais pas pourquoi cette solution ne fonctionne plus ( je viens de tester sur Android 23). Veuillez utiliser la solution de Saurabh Pareek à la place. Le voici:

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) {
    input.setInputType(0);
    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 comme vous le souhaitez, il existe un autre moyen de contrôler manuellement le clavier.

Créez une fonction avec qui gérera certaines des propriétés de EditText:

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

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

Ensuite, assurez-vous que Surfocus du EditText vous ouvrez/fermez 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 appel:

setEditTextFocus(true);

Et pour l'appel de clôture:

setEditTextFocus(false);

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

Pourrait aussi bien utiliser les indicateurs 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 ... */
}

À partir de cette recherche, j'ai trouvé ici 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 votre écouteur OnClick appelez 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

Je pense que cette méthode est meilleure, plus simple et plus alignée avec le modèle de conception d'Android. Dans l'exemple simple ci-dessus (et généralement dans la plupart des cas courants), vous aurez un EditText qui a/a eu le focus et c'est aussi généralement celui qui appelle le clavier en premier lieu (il est certainement capable de l'invoquer dans de nombreux scénarios courants). De la même façon, ce devrait être celui qui libère le clavier, généralement cela peut être fait par un ImeAction. Il suffit de voir comment un EditText avec android:imeOptions="actionDone" se comporte, vous voulez obtenir le même comportement, par les mêmes moyens.

Vérifiez cette réponse connexe

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 saisir un numéro hexadécimal, donc je ne peux pas afficher le clavier IMM...

Dans v3.2. 4_r1 setSoftInputShownOnFocus(boolean show) a été ajouté pour contrôler la météo ou ne pas afficher le clavier lorsqu'un TextView obtient le focus, mais il est toujours caché, donc la réflexion doit être utilisée:

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, j'ai obtenu de très bons résultats (mais loin d'être parfait), avec un OnGlobalLayoutListener, ajouté à l'aide d'un ViewTreeObserver de ma vue racine et ensuite vérifier si le clavier est affiché 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 montrer le clavier pendant une fraction de seconde et mess avec les poignées de sélection.

Lorsque le clavier entre en plein écran, onGlobalLayout n'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: Vient de trouver ce que les boîtes de dialogue utilisent pour ne jamais afficher 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 à travailler sur toutes les solutions publiées dans le fil et je les ai trouvées manquantes d'une manière ou d'une autre. Mon exigence exacte est d'avoir un bouton qui, avec une fiabilité à 100%, affichera ou masquera le clavier à l'écran. Lorsque le clavier est dans son état caché, il ne doit pas réapparaître, quels que soient les champs de saisie sur lesquels l'utilisateur clique. Lorsqu'il est dans son état visible, le clavier ne doit pas disparaître, quels que soient les boutons sur lesquels l'utilisateur clique. Ce doit travaillez sur Android 2.2 + jusqu'aux derniers appareils.

Vous pouvez voir une implémentation de travail de cela dans mon application clean RPN.

Après avoir testé de nombreuses réponses suggérées sur un certain nombre de téléphones différents (y compris les appareils froyo et gingerbread), il est devenu évident que les applications Android peuvent de manière fiable:

1. Masquer temporairement le clavier. Il réapparaîtra quand un utilisateur porte un nouveau champ de texte.
2. Affiche le clavier lorsqu'une activité démarre et définissez un indicateur sur l'activité indiquant que le clavier doit soyez toujours visible. Cet indicateur ne peut être défini que lorsqu'une activité initialiser.
3. Marquer une activité pour ne jamais afficher ou autoriser clavier. Cet indicateur ne peut être défini que lorsqu'une activité initialiser.

Pour moi, cacher temporairement le clavier ne suffit pas. Sur certains appareils, il réapparaîtra dès qu'un nouveau champ de texte sera mis au point. Comme mon application utilise plusieurs champs de texte sur une page, en concentrant un nouveau champ de texte provoquera le clavier caché pour pop back up à nouveau.

Malheureusement, les éléments 2 et 3 de la liste ne fonctionnent que lorsqu'une activité est en cours de démarrage. Une fois que l'activité est devenue visible, vous ne pouvez pas masquer ou afficher définitivement le clavier. L'astuce consiste à redémarrer votre activité lorsque l'utilisateur appuie sur le bouton bascule du clavier. Dans mon application lorsque l'utilisateur appuie sur le bouton bascule du clavier, le code suivant s'exécute:

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é en cours pour avoir son état enregistré dans un Bundle, puis l'activité est démarrée, en passant par un booléen qui indique si le clavier doit être affiché ou caché.

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 logiciel doit être affiché, le InputMethodManager est invité à afficher le clavier et la fenêtre est chargée de rendre l'entrée logicielle toujours visible. Si le clavier logiciel doit être caché alors le WindowManager.LayoutParams.FLAG_ALT_FOCUSABLE_IM est défini.

Cette approche fonctionne de manière fiable sur tous les appareils sur lesquels j'ai testé - d'un téléphone HTC de 4 ans fonctionnant sous Android 2.2 jusqu'à un nexus 7 fonctionnant sous 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 n'a essentiellement qu'un seul écran (c'est une calculatrice), je peux remplacer onBackPressed() et revenir à l'écran d'accueil des appareils.

Alternativement à cette solution complète , si vous vouliez fermer le clavier logiciel de n'importe où sans avoir de référence au champ (EditText) utilisé pour ouvrir le clavier, mais que vous vouliez toujours le faire si le champ était concentré, vous pouvez utiliser ceci (à partir d'une activité):

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

Grâce à cette réponse SO , j'ai dérivé ce qui suit qui, dans mon cas, fonctionne bien lors du défilement 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);
    }
}

Les réponses ci-dessus fonctionnent pour différents scénarios mais Si vous souhaitez masquer le clavier dans une vue et que vous avez du mal à 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 obtenir le contexte, récupérez-le du constructeur:)

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

Si vous souhaitez fermer le clavier logiciel pendant un test d'unité ou 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);

J'ai mis "back button" entre guillemets, car ce qui précède ne déclenche pas le onBackPressed() pour l'activité en question. Il ferme juste le clavier.

Assurez-vous de faire une pause pendant un peu de temps avant de continuer, car il faut un peu de temps pour fermer le bouton de retour, donc les clics ultérieurs sur les vues, etc., ne sera enregistré qu'après une courte pause (1 deuxième est assez long ime).

Voici comment vous le faites en 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 pour tout le comportement bizarre du clavier

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 activité android:windowSoftInputMode="stateHidden" dans le fichier Manifeste. Exemple:

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

Utilisez ceci

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

Pour mon cas, j'utilisais le a SearchView dans la barre d'action. Une fois qu'un utilisateur effectue une recherche, le clavier s'ouvre à nouveau.

L'utilisation de InputMethodManager n'a pas fermé le clavier. J'ai dû clearFocus et définir le focalisable de la vue de recherche sur false:

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

J'ai presque essayé toutes ces réponses, j'ai eu quelques problèmes aléatoires en particulier avec le samsung galaxy s5.

Ce que je finis par forcer le show et le hide, et cela 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, cette méthode peut fonctionner à l'exception de toutes les autres. Cela sauve ma journée:)

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

Méthode simple et facile à utiliser, appelez simplement hideKeyboardFrom(YourActivity.ceci); pour masquer le clavier

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

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

J'ai le cas, où mon EditText peut être situé également dans un AlertDialog, donc le clavier doit être fermé lors du rejet. Le code suivant semble fonctionner n'importe où:

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