tablette ma sur plus n'apparait Fermer / cacher le clavier virtuel Android




15 Answers

Vous pouvez forcer Android à masquer le clavier virtuel à l'aide de InputMethodManager , en appelant hideSoftInputFromWindow , en transmettant 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 souhaiterez passer InputMethodManager.HIDE_IMPLICIT_ONLY en InputMethodManager.HIDE_IMPLICIT_ONLY que deuxième paramètre pour vous assurer de ne masquer le clavier que lorsque l'utilisateur ne l'a pas forcé explicitement à apparaître (en maintenant le menu enfoncé).

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

masquer clavier android

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

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




J'ai encore une solution pour cacher le clavier:

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

Ici, passez HIDE_IMPLICIT_ONLY à la position de showFlag et 0 à la position de hiddenFlag . Il fermera avec force le clavier logiciel.




S'il vous plaît essayez ce code ci-dessous dans onCreate()

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



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



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

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



La réponse courte

Dans votre écouteur OnClick appelez onEditorAction de EditText avec IME_ACTION_DONE

button.setOnClickListener(new OnClickListener() {

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

Le forage

Je pense que cette méthode est meilleure, plus simple et plus alignée sur 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 / avait le focus et c’est également celui qui EditText le clavier en premier lieu (il est certainement capable de l’invoquer de nombreux scénarios courants). De la même manière, ce devrait être celui qui ImeAction le clavier, ce qui peut généralement ê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 liée




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

Dans la v3.2.4_r1, setSoftInputShownOnFocus(boolean show) été ajouté pour contrôler la météo ou ne pas afficher le clavier lorsqu'un TextView est activé, mais son masquage restant masqué, vous devez utiliser la réflexion:

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 OnGlobalLayoutListener , ajouté à l’aide d’un ViewTreeObserver partir de ma vue racine, puis en vérifiant 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 perturber les poignées de sélection.

Lorsque le clavier passe 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 quels dialogues utilisent pour ne jamais afficher le clavier et fonctionnent dans toutes les versions:

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



J'ai passé plus de deux jours à examiner toutes les solutions affichées dans le fil de discussion et je les ai trouvées manquantes d'une manière ou d'une autre. Mon exigence exacte est d’avoir un bouton qui affiche avec une fiabilité à 100% ou masque le clavier à l’écran. Lorsque le clavier est dans son état masqué, il ne devrait pas réapparaître, quels que soient les champs de saisie 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. Cela doit fonctionner sur Android 2.2+ jusqu'aux derniers appareils.

Vous pouvez voir une implémentation fonctionnelle de cela dans mon RPN propre à l' application.

Après avoir testé de nombreuses réponses suggérées sur un certain nombre de téléphones (y compris des 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 à nouveau lorsqu'un utilisateur concentrera un nouveau champ de texte.
  2. Affichez le clavier au début d’une activité et définissez un indicateur indiquant que le clavier doit toujours être visible. Cet indicateur ne peut être défini que lorsqu’une activité est en cours d’initialisation.
  3. Marquer une activité pour ne jamais montrer ou permettre l'utilisation du clavier. Cet indicateur ne peut être défini que lorsqu’une activité est en cours d’initialisation.

Pour moi, masquer temporairement le clavier ne suffit pas. Sur certains appareils, il réapparaît dès qu'un nouveau champ de texte est sélectionné. Étant donné que mon application utilise plusieurs champs de texte sur une page, la mise au point d'un nouveau champ de texte provoque la restauration du clavier masqué.

Malheureusement, les points 2 et 3 de la liste ne fonctionnent que lorsque le démarrage d’une activité est fiable. Une fois que l'activité est devenue visible, vous ne pouvez plus masquer ou afficher le clavier. L'astuce consiste à relancer 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);
    }
}

Ainsi, l’activité en cours voit son état sauvegardé dans un ensemble, puis elle est démarré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 logiciel doit être affiché, alors InputMethodManager est invité à afficher le clavier et la fenêtre est configurée pour que l'entrée logicielle soit toujours visible. Si le clavier logiciel doit être masqué, le paramètre 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 vieux de 4 ans sous Android 2.2 à un Nexus 7 sous 4.2.2. Le seul inconvénient de cette approche est que vous devez manipuler avec soin le bouton de retour. Étant donné que mon application ne comporte quasiment qu’un seul écran (c’est une calculatrice), je peux remplacer onBackPressed () et revenir à l’écran d’accueil des appareils.




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



Si vous souhaitez fermer le clavier logiciel pendant un test unitaire ou fonctionnel, vous pouvez le faire en cliquant sur le bouton "Précédent" de votre test:

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

Je mets le "bouton de retour" entre guillemets, car ce qui précède ne déclenche pas onBackPressed()l'activité de l'activité en question. Cela ferme simplement le clavier.

Assurez-vous de faire une pause un peu avant de passer, car il faut un peu de temps pour fermer le bouton Précédent. Ainsi, les clics ultérieurs sur Vues, ​​etc., ne seront enregistrés qu'après une courte pause (une seconde est suffisamment longue). ).




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



utilisez ceci

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



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 est de forcer le spectacle et de le cacher, 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);
}



Méthode simple et facile à utiliser, il suffit d'appeler hideKeyboardFrom (YourActivity.this); 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);
}



J'ai le cas, où mon EditTextpeut être situé également 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 );
}





Related