Fermer / Cacher le clavier Android

vous pouvez forcer Android à cacher le clavier virtuel en utilisant le InputMethodManager , appelant hideSoftInputFromWindow , passer 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 voulez passer de InputMethodManager.HIDE_IMPLICIT_ONLY comme second paramètre à vous assurer que masquer le clavier lorsque l'utilisateur n'a pas explicitement le forcer à apparaissent (en tenant la touche menu).

Note: si vous voulez faire ceci à Kotlin, utilisez: context?.getSystemService(Context.INPUT_METHOD_SERVICE) as InputMethodManager

aussi utile pour cacher le clavier souple est:

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

ceci peut être utilisé pour supprimer le clavier souple 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);

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

la solution de Meier fonctionne pour moi aussi. Dans mon cas, le niveau supérieur de mon application est un tabHost et je veux cacher le mot - clé lors de la commutation des onglets-je reçois 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);
    }
}

s'il Vous Plaît 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). S'il vous plaît 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 souhaiteriez, il y a une autre façon de contrôler manuellement le clavier.

créer une fonction qui gérera certaines des 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 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 appeler manuellement:

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 bons drapeaux, 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 cette recherche, 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 votre OnClick l'auditeur appelle le onEditorAction du EditText avec IME_ACTION_DONE

button.setOnClickListener(new OnClickListener() {

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

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 simple ci-dessus (et généralement dans la plupart des cas communs) vous aurez un EditText qui a / avait la mise au point et il était aussi généralement celui d'invoquer le clavier en premier lieu (il est certainement en mesure de l'invoquer dans de nombreux scénarios courants). De la même manière, it devrait être celui qui libère le clavier, généralement ce qui peut être fait par un ImeAction . Juste voir comment un EditText avec android:imeOptions="actionDone" se comporte, vous voulez obtenir le même comportement par le même moyen.

Cochez cette "1519220920 connexes" réponse

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 faire apparaître le clavier IMM...

en v3.2.4_r1 setSoftInputShownOnFocus(boolean show) a été ajouté pour contrôler la météo ou pour ne pas afficher le clavier quand un TextView obtient la mise au point, mais son encore caché 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 versions plus anciennes, j'ai obtenu de très bons résultats (mais loin d'être parfaits) 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 afficher le clavier pendant une fraction de seconde et abîmer 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: Je viens de trouver ce que les dialogues utilisent pour ne jamais montrer 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 affichées dans le fil et je les ai trouvées manquantes d'une façon ou d'une autre. Mon exigence exacte est d'avoir un bouton qui montrera 100% fiabilité ou cacher le clavier à l'écran. Lorsque le clavier est dans son état caché, l'is ne doit pas réapparaître, peu importe les champs d'entrée sur lesquels l'utilisateur clique. Lorsqu'il est visible, le clavier ne doit pas disparaître, quels que soient les boutons sur lesquels l'utilisateur clique. Ce doit travailler sur Android 2.2+ jusqu'aux derniers appareils.

vous pouvez voir une mise en œuvre de travail de ce dans mon app RPN propre .

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. cacher temporairement le clavier. Il sera ré-apparaissent quand un utilisateur porte un nouveau champ de texte.
2. afficher le clavier quand une activité commence et de mettre un drapeau sur l'activité indiquant qu'ils clavier devrait soyez toujours visibles. Cet indicateur ne peut être réglé que lorsqu'une activité est initialiser.
3. marquer une activité pour ne jamais montrer ou permettre l'utilisation de la clavier. Cet indicateur ne peut être réglé que lorsqu'une activité est initialiser.

pour moi, cacher temporairement le clavier n'est pas suffisant. Sur certains périphériques, il réapparaîtra dès qu'un nouveau champ de texte sera focalisé. Comme mon application utilise plusieurs champs de texte sur une page, la mise au point d'un nouveau champ de texte provoquera la réapparition du clavier caché.

malheureusement, les points 2 et 3 de la liste ne traitent de la fiabilité que lorsqu'une activité est commencée. Une fois que l'activité est devenue visible, vous ne pouvez pas cacher ou afficher le clavier de façon permanente. L'astuce consiste à redémarrer votre activité lorsque l'utilisateur appuie sur le clavier. le bouton à bascule. Dans mon application lorsque l'utilisateur appuie sur l'interrupteur touche 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 fait que l'activité courante est sauvegardée dans un paquet, puis l'activité est commencée, 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 souple doit être affiché, puis le InputMethodManager est chargé d'afficher le clavier et la fenêtre est chargée de rendre l'entrée soft toujours visible. Si le clavier souple 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 que j'ai testés - d'un téléphone HTC de 4 ans fonctionnant sous android 2.2 à un nexus 7 fonctionnant sous 4.2.2. Le seul inconvénient de cette approche est que vous devez être prudent avec la manipulation du bouton arrière. Comme mon application n'a essentiellement qu'un seul écran (c'est une calculatrice), je peux outrepasser onBackPressed() et revenir à l'écran d'accueil des périphériques.

alternativement à this all around solution , si vous voulez fermer le clavier souple de n'importe où sans avoir une référence au champ (EditText) qui a été utilisé pour ouvrir le clavier, mais voulait quand même le faire si le champ était focalisé, vous pouvez utiliser ceci (à partir d'une activité):

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

merci à cette réponse ainsi , j'ai dérivé la suite qui, dans mon cas, fonctionne bien en défilant à travers les 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);
    }
}

ci-dessus les réponses fonctionnent pour différents scénarios mais si vous voulez cacher le clavier dans une vue et lutter pour 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 d'obtenir le contexte de l'extraire de 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 pendant un test unitaire ou fonctionnel, vous pouvez le faire en cliquant sur le" bouton arrière "de votre test:

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

j'ai mis "bouton arrière" entre guillemets, puisque 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 un peu avant de passer à autre chose, car il faut un peu de temps pour fermer le bouton arrière, de sorte que les clics suivants pour les vues, etc., ne sera enregistré qu'après une courte pause (1 seconde est assez longue 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"/>

utiliser cette

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

pour mon cas, j'utilisais le A SearchView dans la barre d'action. Après qu'un utilisateur effectue une recherche, le clavier s'ouvrir de nouveau.

utilisant le InputMethodManager n'a pas fermé le clavier. J'ai dû clearFocus et mettre le focus de la vue de recherche à false:

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

j'ai presque essayé toutes ces réponses, j'ai eu quelques questions aléatoires, surtout avec le samsung galaxy s5.

ce que j'obtiens, c'est forcer le spectacle et le cacher, et ça marche 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 sauf dans d'autres. Cela permet d'économiser de 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, il suffit d'appeler hidekeyboardde(votre activité.this); pour cacher 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);
}

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

j'ai le cas, où mon EditText peut être situé aussi dans un AlertDialog , de sorte que le clavier doit être fermé sur le licenciement. 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 );
}