Fermer / Cacher le clavier Android

j'ai un EditText et un Button dans ma disposition.

après avoir écrit dans le champ edit et cliqué 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 cela?

3195
demandé sur Vidar Vestnes 2009-07-10 15:27:17
la source

30 ответов

pour aider à clarifier cette folie, je voudrais commencer par m'excuser au nom de tous les utilisateurs Android pour le traitement tout à fait ridicule de Google sur le clavier souple. La raison pour laquelle il y a tant de réponses, chacune différente, pour la même question simple est que cette API, comme beaucoup d'autres sous Android, est horriblement conçue. Je ne vois pas de façon polie de l'état.

je veux cacher le clavier. Je m'attends à fournir Android avec la déclaration suivante: Keyboard.hide() . Fin. Je vous remercie beaucoup. Mais Androïde a un problème. Vous devez utiliser le InputMethodManager pour masquer le clavier. Ok, bien, C'est L'API D'Android sur le clavier. Mais! Vous devez avoir un Context pour accéder à L'IMM. Maintenant, nous avons un problème. Je voudrais peut-être Cacher le clavier à une classe statique ou utilitaire qui n'a pas besoin de Context . or et bien pire, le IMM exige que vous spécifiez ce que View (ou encore pire, ce que Window ) vous souhaitez masquer le clavier.

c'est ce qui rend cacher le clavier si difficile. Cher Google: Quand je regarde la recette d'un gâteau, il n'y a pas de RecipeProvider sur terre qui refuserait de me fournir la recette à moins que je ne réponde d'abord par qui le gâteau sera mangé et où il sera mangé!!

cette triste histoire se termine avec la vérité laide: pour cacher le clavier Android, vous serez tenu de fournir 2 formes de identification: un Context et soit un View ou un Window .

j'ai créé une méthode d'utilité statique qui peut faire le travail très solidement, à condition que vous l'appeliez 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);
}

soyez conscient que cette méthode d'utilité ne fonctionne que lorsqu'on l'appelle d'un Activity ! La méthode ci-dessus appelle getCurrentFocus de la cible Activity pour récupérer le jeton de fenêtre approprié.

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

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

cela ne marchera pas parce que vous allez passer une référence à l'hôte Fragment Activity , qui n'aura pas de contrôle focalisé pendant que le Fragment est affiché! Wow! Ainsi, pour cacher le clavier des fragments, Je recourt au niveau inférieur, plus commun, 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);
}

ci-dessous est une informations supplémentaires glanées à partir de plus de temps perdu à la recherche de cette solution:

à propos de windowSoftInputMode

il y a encore un autre point de désaccord dont il faut être conscient. Par défaut, Android assignera automatiquement la mise au point initiale à la première EditText ou le contrôle focalisable dans votre Activity . Il s'ensuit naturellement que la méthode InputMethod (typiquement le clavier souple) répondra à l'événement focus en montrant m'. L'attribut windowSoftInputMode dans AndroidManifest.xml , lorsqu'il est défini à stateAlwaysHidden , indique au clavier d'ignorer cette mise au point initiale automatiquement assignée.

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

presque incroyablement, il semble ne rien faire pour empêcher le clavier de s'ouvrir lorsque vous touchez la commande (sauf si focusable="false" et/ou focusableInTouchMode="false" sont assignés à la commande). Apparemment, le paramètre windowSoftInputMode ne s'applique qu'aux événements de mise au point automatiques, et non aux événements de mise au point déclenchée à partir d'événements tactiles.

par conséquent, stateAlwaysHidden est très mal nommé en effet. Il faudrait peut-être plutôt l'appeler ignoreInitialFocus .

Espérons que cette aide.


mise à jour: plus de façons d'obtenir un jeton de fenêtre

S'il n'y a pas de vue focalisée (par exemple peut se produire si vous venez de changer des fragments), Il ya d'autres vues qui fournira une fenêtre utile jeton.

ce sont des alternatives pour le code ci-dessus if (view == null) view = new View(activity); celles-ci ne se réfèrent pas explicitement à votre activité.

dans une classe de fragments:

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

donne un fragment fragment comme paramètre:

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

à partir de votre corps de contenu:

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

mise à jour 2: Mise Au Point Claire pour éviter d'afficher le clavier encore une fois si vous ouvrez l'application de l'arrière-plan

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

view.clearFocus();

1169
répondu rmirabelle 2018-01-12 17:44:33
la source

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

4204
répondu Reto Meier 2018-06-20 15:38:21
la source

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.

754
répondu Garnet Ulrich 2014-11-24 19:07:40
la source

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.

303
répondu Saurabh Pareek 2016-06-27 18:26:34
la source

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);
    }
}
132
répondu mckoss 2014-11-24 18:54:56
la source

s'il Vous Plaît essayer ce code ci-dessous dans onCreate()

EditText edtView=(EditText)findViewById(R.id.editTextConvertValue);
edtView.setInputType(0);
120
répondu Jeyavel 2018-05-24 21:15:06
la source

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);
113
répondu Nguyen Minh Binh 2017-05-23 15:10:54
la source
protected void hideSoftKeyboard(EditText input) {
    input.setInputType(0);
    InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
    imm.hideSoftInputFromWindow(input.getWindowToken(), 0);    
}
67
répondu Sreedev R 2015-09-30 13:42:26
la source

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);
60
répondu Rotemmiz 2014-11-24 18:55:42
la source

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 ... */
}
51
répondu Alex 2017-05-23 14:55:19
la source

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);
48
répondu shontauro 2015-04-25 00:09:51
la source

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

42
répondu Alex.F 2017-05-23 15:10:54
la source

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);
40
répondu slinden77 2016-07-15 17:51:17
la source

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);
38
répondu sergio91pt 2012-05-29 00:48:33
la source
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);
    }
}
29
répondu shobhan 2015-06-01 16:36:12
la source

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.

25
répondu Luke Sleeman 2018-03-06 10:10:29
la source

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);
}
24
répondu Saran 2017-05-23 15:10:54
la source

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);
    }
}
21
répondu ban-geoengineering 2017-05-23 15:34:58
la source

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();
}
18
répondu Ash 2015-04-25 00:10:37
la source

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

17
répondu Peter Ajtai 2011-12-14 01:55:41
la source

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);
14
répondu BahaiResearch.com 2012-05-15 05:36:10
la source

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);
    }
}
13
répondu Pinhassi 2015-04-25 00:11:16
la source

ajoutez à votre activité android:windowSoftInputMode="stateHidden" dans le fichier manifeste. Exemple:

<activity
            android:name=".ui.activity.MainActivity"
            android:label="@string/mainactivity"
            android:windowSoftInputMode="stateHidden"/>
13
répondu NickUnuchek 2016-02-04 15:21:40
la source

utiliser cette

this.getWindow().setSoftInputMode(
            WindowManager.LayoutParams.SOFT_INPUT_STATE_ALWAYS_HIDDEN);
11
répondu Atish Agrawal 2013-08-09 17:42:00
la source

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);
11
répondu tommy chheng 2015-04-25 00:10:48
la source

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);
}
11
répondu ahmed_khan_89 2015-05-15 15:40:06
la source

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);
        }
    }
}
11
répondu iscariot 2016-02-04 14:46:12
la source

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);
}
11
répondu Naveed Ahmad 2017-02-21 09:52:20
la source

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);
}
10
répondu Hamid FzM 2015-04-25 00:11:54
la source

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 );
}
10
répondu injecteer 2015-04-25 00:12:20
la source