Fermer/cacher le clavier virtuel Android
J'ai une EditText et une Button dans ma mise en page.
Après avoir écrit dans le champ de saisie et cliqué sur Button, je souhaite masquer le clavier virtuel. Je suppose que c'est un simple morceau de code, mais où puis-je trouver un exemple?
Pour clarifier cette folie, je voudrais commencer par m'excuser au nom de tous les Android utilisateurs du traitement carrément ridicule du clavier logiciel par Google. La raison pour laquelle il y a tant de réponses, chacune différente, pour la même question simple parce que cette API, comme beaucoup d'autres dans Android, est horriblement conçue. Je peux penser à aucun moyen poli de le dire.
Je veux cacher le clavier. Je compte fournir à Android l'instruction suivante: Keyboard.hide(). La fin. Merci beaucoup. Mais Android a un problème. Vous devez utiliser InputMethodManager pour masquer le clavier. OK, d'accord, c'est l'API d'Android au clavier. MAIS! Vous devez disposer d'un Context pour pouvoir accéder au module de gestion intégré. Maintenant nous avons un problème. Il se peut que je veuille cacher le clavier d’une classe statique ou d’utilité qui n’a ni utilité ni besoin de Context. ou Pire encore, le module de gestion de l'intégrité requiert que vous spécifiiez quelle View (ou pire, ce que Window) vous souhaitez masquer le clavier.
C’est ce qui rend difficile de cacher le clavier. Cher Google, Lorsque je cherche la recette d’un gâteau, il n’ya pas de RecipeProvider sur Terre qui refuserait de me fournir la recette à moins que je ne réponde au préalable QUI le gâteau sera mangé ET là où il sera mangé!!
Cette triste histoire se termine par la triste vérité: pour masquer le clavier Android, vous devrez fournir 2 formes d'identification: une Context et une View ou un Window.
J'ai créé une méthode utilitaire statique qui peut effectuer le travail TRÈS solidement, à condition que vous l'appeliez à partir 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 d’utilitaire ne fonctionne UNIQUEMENT que si elle est appelée depuis un Activity! La méthode ci-dessus appelle getCurrentFocus de la cible Activity pour extraire le jeton de fenêtre approprié.
Mais supposons que vous vouliez masquer 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 fonctionnera pas car vous passerez une référence à l'hôte Fragment de Activity, qui n'aura aucun contrôle focalisé tant que le Fragment sera affiché! Hou la la! Donc, 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);
}
Vous trouverez ci-dessous des informations supplémentaires issues de la perte de temps supplémentaire liée à cette solution:
À propos de windowSoftInputMode
Il y a encore un autre point de discorde à prendre en compte. Par défaut, Android attribuera automatiquement le focus initial au premier EditText ou au contrôle de mise au point de votre Activity. Il s'ensuit naturellement que le InputMethod (généralement le clavier logiciel) répondra à l'événement de focus en se montrant. L'attribut windowSoftInputMode dans AndroidManifest.xml, lorsqu'il est défini sur stateAlwaysHidden, indique au clavier d'ignorer ce focus initial attribué automatiquement.
<activity
Android:name=".MyActivity"
Android:windowSoftInputMode="stateAlwaysHidden"/>
Presque incroyablement, cela ne semble en aucun cas empêcher le clavier de s'ouvrir lorsque vous touchez le contrôle (sauf si focusable="false" et/ou focusableInTouchMode="false" sont attribués au contrôle). Apparemment, le paramètre windowSoftInputMode s'applique uniquement aux événements de mise au point automatique, et non aux événements de mise au point déclenchés par des événements tactiles.
Par conséquent, stateAlwaysHidden est TRES mal nommé. Cela devrait peut-être s'appeler ignoreInitialFocus à la place.
J'espère que cela t'aides.
PDATE: Autres moyens d'obtenir un jeton de fenêtre
S'il n'y a pas de vue focalisée (par exemple, cela peut arriver si vous venez de modifier des fragments), d'autres vues fourniront un jeton de fenêtre utile.
Ce sont des alternatives pour le code ci-dessus if (view == null) view = new View(activity); Celles-ci ne font pas explicitement référence à votre activité.
Dans une classe de fragments:
view = getView().getRootView().getWindowToken();
Étant donné un fragment fragment en tant que paramètre:
view = fragment.getView().getRootView().getWindowToken();
À partir de votre corps de contenu:
view = findViewById(Android.R.id.content).getRootView().getWindowToken();
PDATE 2: effacez le focus pour éviter d'afficher à nouveau le clavier si vous ouvrez l'application depuis l'arrière-plan
Ajoutez cette ligne à la fin de la méthode:
view.clearFocus();
Vous pouvez forcer Android à masquer le clavier virtuel à l’aide de InputMethodManager , appelez 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 voudrez passer InputMethodManager.HIDE_IMPLICIT_ONLY en tant 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é).
Note: Si vous voulez faire cela dans Kotlin, utilisez: context?.getSystemService(Context.INPUT_METHOD_SERVICE) as InputMethodManager
Syntaxe Kotlin
// 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) }
}
Également utile pour masquer le clavier virtuel est:
getWindow().setSoftInputMode(
WindowManager.LayoutParams.SOFT_INPUT_STATE_ALWAYS_HIDDEN
);
Cela peut être utilisé pour supprimer le clavier virtuel jusqu'à ce que l'utilisateur touche réellement la vue editText.
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.
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. 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 essayez ce code ci-dessous dans onCreate()
EditText edtView=(EditText)findViewById(R.id.editTextConvertValue);
edtView.setInputType(0);
Update: 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. C'est ici:
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 ne vous conviennent pas, il existe un autre moyen de contrôler manuellement le clavier.
Créez une fonction avec qui gérera certaines propriétés de la EditText:
public void setEditTextFocus(boolean isFocused) {
searchEditText.setCursorVisible(isFocused);
searchEditText.setFocusable(isFocused);
searchEditText.setFocusableInTouchMode(isFocused);
if (isFocused) {
searchEditText.requestFocus();
}
}
Ensuite, assurez-vous que l’onFocus de la EditText ouvre/ferme 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, appelez:
setEditTextFocus(true);
Et pour la fermeture de l'appel:
setEditTextFocus(false);
Saurabh Pareek a la meilleure réponse jusqu'à présent.
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 ... */
}
de chercher 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 votre auditeur OnClick, appelez la onEditorAction de la 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 conforme au modèle de conception d'Android . Dans l'exemple simple ci-dessus (et généralement dans la plupart des cas courants), vous aurez une EditText qui a/avait le focus et qui était 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 manière, it devrait être celui qui relâche le clavier, ce qui peut généralement être fait avec un ImeAction. Voyez comment se comporte une EditText avec Android:imeOptions="actionDone", vous voulez obtenir le même comportement avec les mêmes moyens.
Cochez cette réponse associée
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, je ne peux donc pas afficher le clavier IMM ...
Dans la v3.2.4_r1, setSoftInputShownOnFocus(boolean show) a été ajouté pour contrôler la météo ou pour ne pas afficher le clavier lorsqu'un TextView est activé, mais il est toujours masqué, vous devez donc 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 un OnGlobalLayoutListener, ajouté à l’aide d’un ViewTreeObserver 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.
Quand 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"
Update: 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 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 application clean RPN .
Après avoir testé de nombreuses réponses suggérées sur un certain nombre de téléphones (y compris les appareils Froyo et Gingerbread), il est devenu évident que les applications Android peuvent de manière fiable:
- Masquer temporairement le clavier. Il réapparaîtra à nouveau lorsqu'un utilisateur Concentrera un nouveau champ de texte.
- Montre le clavier quand une activité commence Et place un drapeau sur l'activité indiquant que le clavier devrait Toujours visible. Cet indicateur ne peut être activé que lorsqu'une activité est en cours d'initialisation.
- Marquer une activité pour ne jamais montrer ou permettre l'utilisation du clavier Cet indicateur ne peut être activé que lorsqu'une activité est en cours d'initialisation.
Pour moi, cacher 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 enregistré 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 dispose généralement que d’un seul écran (c’est une calculatrice), je peux remplacer onBackPressed () et revenir à l’écran d’accueil des appareils.
Alternativement à cette solution globale , si vous vouliez fermer le clavier virtuel de n’importe où sans avoir une référence au champ (EditText) utilisé pour ouvrir le clavier, mais souhaitiez le faire si le champ était ciblé, 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 SO réponse , j'ai obtenu 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 auprès 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 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" entre guillemets, car ce qui précède ne déclenche pas le onBackPressed() pour 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. ).
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);
Ajoutez à votre activité Android:windowSoftInputMode="stateHidden" dans le fichier manifeste. Exemple:
<activity
Android:name=".ui.activity.MainActivity"
Android:label="@string/mainactivity"
Android:windowSoftInputMode="stateHidden"/>
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);
}
}
Pour mon cas, j'utilisais le SearchView dans la barre d’action. Lorsqu'un utilisateur effectue une recherche, le clavier s'ouvre à nouveau.
L'utilisation de InputMethodManager n'a pas fermé le clavier. Je devais effacerFocus et définir la focalisation 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, c'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);
}
Dans certains cas, ces méthodes peuvent fonctionner sauf 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, 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);
}
utilisez ceci
this.getWindow().setSoftInputMode(
WindowManager.LayoutParams.SOFT_INPUT_STATE_ALWAYS_HIDDEN);
J'ai le cas, où ma EditText peut également être localisée dans une AlertDialog, de sorte que le clavier devrait être fermé en cas de 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 );
}
public static void hideSoftKeyboard(Activity activity) {
InputMethodManager inputMethodManager = (InputMethodManager) activity.getSystemService(Activity.INPUT_METHOD_SERVICE);
inputMethodManager.hideSoftInputFromWindow(activity.getCurrentFocus().getWindowToken(), 0);
}
après cet appel sur onTouchListener:
findViewById(Android.R.id.content).setOnTouchListener(new OnTouchListener() {
@Override
public boolean onTouch(View v, MotionEvent event) {
Utils.hideSoftKeyboard(activity);
return false;
}
});
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);
}
Fonctionne comme une touche magique à chaque fois
private void closeKeyboard() {
InputMethodManager inputManager = (InputMethodManager)getActivity().getSystemService(Context.INPUT_METHOD_SERVICE);
inputManager.hideSoftInputFromWindow(getActivity().getCurrentFocus().getWindowToken(), InputMethodManager.HIDE_NOT_ALWAYS);
}
private void openKeyboard() {
InputMethodManager imm = (InputMethodManager) getActivity().getSystemService(Context.INPUT_METHOD_SERVICE);
if(imm != null){
imm.toggleSoftInput(InputMethodManager.SHOW_IMPLICIT, 0);
}
}
Pour le clavier ouvert:
InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
imm.showSoftInput(edtView, InputMethodManager.SHOW_IMPLICIT);
Pour fermer/masquer le clavier:
InputMethodManager imm = (InputMethodManager)getSystemService(Context.INPUT_METHOD_SERVICE);
imm.hideSoftInputFromWindow(edtView.getWindowToken(), 0);
Vous pouvez également envisager d'utiliser setImeOption sur EditText.
Je viens d'avoir une situation très similaire où ma mise en page contenait un EditText et un bouton de recherche. Lorsque j'ai découvert que je pouvais simplement définir l'option ime sur "actionSearch" sur mon editText, j'ai réalisé que je n'avais même plus besoin d'un bouton de recherche. Le clavier virtuel (dans ce mode) a une icône de recherche, qui peut être utilisée pour lancer la recherche (et le clavier se ferme comme prévu).
parfois, tout ce que vous voulez, c’est le bouton Entrée pour plier la keyboard donner à la case EditText votre attribut
Android:imeOptions="actionDone"
cela changera le bouton Entrée en un bouton Terminé qui fermera le clavier.
Ça marche pour moi..
EditText editText=(EditText)findViewById(R.id.edittext1);
mettre sous la ligne de code dans onClick ()
editText.setFocusable(false);
editText.setFocusableInTouchMode(true);
ici cacher le clavier quand on clique sur le bouton et quand on touche le clavier EditText sera affiché.
(OU)
getWindow().setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_STATE_ALWAYS_HIDDEN);
Parfois, une activité contenant une liste et des lignes contenant editText doit être configurée dans manifest SOFT_INPUT_ADJUST_PAN, puis le clavier apparaît, ce qui est agaçant.
La solution suivante fonctionne si vous la placez à la fin de onCreate
getWindow().setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_STATE_ALWAYS_HIDDEN);
new Handler().postDelayed(new Runnable() {
@Override
public void run() {
getWindow().setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_ADJUST_PAN);
}
},100);
Essaye ça
- Simple, vous pouvez appeler votre
Activity
public static void hideKeyboardwithoutPopulate(Activity activity) {
InputMethodManager inputMethodManager =
(InputMethodManager) activity.getSystemService(
Activity.INPUT_METHOD_SERVICE);
inputMethodManager.hideSoftInputFromWindow(
activity.getCurrentFocus().getWindowToken(), 0);
}
- Dans votre
MainActivitiyappelez ceci
hideKeyboardwithoutPopulate(MainActivity.this);
Dans AndroidManifest.xml sous <activity..>, définissez Android:windowSoftInputMode="stateAlwaysHidden"
Si vous souhaitez masquer le clavier à l'aide de code Java, utilisez ceci:
InputMethodManager imm = (InputMethodManager)this.getSystemService(Context.INPUT_METHOD_SERVICE);
imm.hideSoftInputFromWindow(fEmail.getWindowToken(), 0);
Ou si vous voulez toujours masquer le clavier, utilisez ceci dans votre AndroidManifest:
<activity
Android:name=".activities.MyActivity"
Android:configChanges="keyboardHidden" />
J'ai écrit une petite extension pour Kotlin si quelqu'un intéressé ne le testait pas beaucoup:
fun Fragment.hideKeyboard(context: Context = App.instance) {
val windowToken = view?.rootView?.windowToken
windowToken?.let {
val imm = context.getSystemService(Activity.INPUT_METHOD_SERVICE) as InputMethodManager
imm.hideSoftInputFromWindow(windowToken, 0)
}
}
App.instance est statique "this" objet Application stocké dans Application.
Mise à jour: Dans certains cas, windowToken est null. J'ai ajouté un moyen supplémentaire de fermer le clavier en utilisant la réflexion pour détecter si le clavier est fermé
/**
* If no window token is found, keyboard is checked using reflection to know if keyboard visibility toggle is needed
*
* @param useReflection - whether to use reflection in case of no window token or not
*/
fun Fragment.hideKeyboard(context: Context = MainApp.instance, useReflection: Boolean = true) {
val windowToken = view?.rootView?.windowToken
val imm = context.getSystemService(Context.INPUT_METHOD_SERVICE) as InputMethodManager
windowToken?.let {
imm.hideSoftInputFromWindow(windowToken, 0)
} ?: run {
if (useReflection) {
try {
if (getKeyboardHeight(imm) > 0) {
imm.toggleSoftInput(0, InputMethodManager.HIDE_NOT_ALWAYS)
}
} catch (exception: Exception) {
Timber.e(exception)
}
}
}
}
fun getKeyboardHeight(imm: InputMethodManager): Int = InputMethodManager::class.Java.getMethod("getInputMethodWindowVisibleHeight").invoke(imm) as Int
public static void hideSoftKeyboard(Activity activity) {
InputMethodManager inputMethodManager = (InputMethodManager)activity.getSystemService(Activity.INPUT_METHOD_SERVICE);
inputMethodManager.hideSoftInputFromWindow(activity.getCurrentFocus().getWindowToken(), 0);
}
cela fonctionne ..
Il suffit de passer votre instance d'activité actuelle dans la fonction
public void isKeyBoardShow(Activity activity) {
InputMethodManager imm = (InputMethodManager) activity.getSystemService(Activity.INPUT_METHOD_SERVICE);
if (imm.isActive()) {
imm.toggleSoftInput(InputMethodManager.HIDE_IMPLICIT_ONLY, 0); // hide
} else {
imm.toggleSoftInput(0, InputMethodManager.HIDE_IMPLICIT_ONLY); // show
}
}
En fait, toujours l'autorité Android donne de nouvelles mises à jour, mais ils ne traitent pas leurs anciens inconvénients auxquels tous les développeurs Android sont confrontés dans leur développement. Cela devrait être traité par l'autorité Android par défaut. Mais désolé, ils ne gèrent pas. Ok! Laissez.
Vous trouverez ci-dessous les solutions pour afficher/masquer/activer une option de clavier dans Activité ou Fragment.
Afficher le clavier pour la vue:
/**
* open soft keyboard.
*
* @param context
* @param view
*/
public static void showKeyBoard(Context context, View view) {
try {
InputMethodManager keyboard = (InputMethodManager) context.getSystemService(Context.INPUT_METHOD_SERVICE);
keyboard.showSoftInput(view, 0);
} catch (Exception e) {
e.printStackTrace();
}
}
Afficher le clavier avec le contexte d'activité:
/**
* open soft keyboard.
*
* @param mActivity context
*/
public static void showKeyBoard(Activity mActivity) {
try {
View view = mActivity.getCurrentFocus();
if (view != null) {
InputMethodManager keyboard = (InputMethodManager) mActivity.getSystemService(Context.INPUT_METHOD_SERVICE);
keyboard.showSoftInputFromInputMethod(view.getWindowToken(), InputMethodManager.SHOW_FORCED);
}
} catch (Exception e) {
e.printStackTrace();
}
}
Afficher le clavier avec le contexte Fragment:
/**
* open soft keyboard.
*
* @param mFragment context
*/
public static void showKeyBoard(Fragment mFragment) {
try {
if (mFragment == null || mFragment.getActivity() == null) {
return;
}
View view = mFragment.getActivity().getCurrentFocus();
if (view != null) {
InputMethodManager keyboard = (InputMethodManager) mFragment.getActivity().getSystemService(Context.INPUT_METHOD_SERVICE);
keyboard.showSoftInputFromInputMethod(view.getWindowToken(), InputMethodManager.SHOW_FORCED);
}
} catch (Exception e) {
e.printStackTrace();
}
}
Masquer le clavier pour la vue:
/**
* close soft keyboard.
*
* @param context
* @param view
*/
public static void hideKeyBoard(Context context, View view) {
try {
InputMethodManager keyboard = (InputMethodManager) context.getSystemService(Context.INPUT_METHOD_SERVICE);
keyboard.hideSoftInputFromWindow(view.getWindowToken(), 0);
} catch (Exception e) {
e.printStackTrace();
}
}
Masquer le clavier avec le contexte d'activité:
/**
* close opened soft keyboard.
*
* @param mActivity context
*/
public static void hideSoftKeyboard(Activity mActivity) {
try {
View view = mActivity.getCurrentFocus();
if (view != null) {
InputMethodManager inputManager = (InputMethodManager) mActivity.getSystemService(Context.INPUT_METHOD_SERVICE);
inputManager.hideSoftInputFromWindow(view.getWindowToken(), 0);
}
} catch (Exception e) {
e.printStackTrace();
}
}
Masquer le clavier avec le contexte Fragment:
/**
* close opened soft keyboard.
*
* @param mFragment context
*/
public static void hideSoftKeyboard(Fragment mFragment) {
try {
if (mFragment == null || mFragment.getActivity() == null) {
return;
}
View view = mFragment.getActivity().getCurrentFocus();
if (view != null) {
InputMethodManager inputManager = (InputMethodManager) mFragment.getActivity().getSystemService(Context.INPUT_METHOD_SERVICE);
inputManager.hideSoftInputFromWindow(view.getWindowToken(), 0);
}
} catch (Exception e) {
e.printStackTrace();
}
}
Bascule clavier:
/**
* toggle soft keyboard.
*
* @param context
*/
public static void toggleSoftKeyboard(Context context) {
try {
InputMethodManager imm = (InputMethodManager) context.getSystemService(Activity.INPUT_METHOD_SERVICE);
imm.toggleSoftInput(InputMethodManager.HIDE_IMPLICIT_ONLY, 0);
} catch (Exception e) {
e.printStackTrace();
}
}
simplement code: utilisez ce code dans onCreate ()
getWindow().setSoftInputMode(
WindowManager.LayoutParams.SOFT_INPUT_STATE_ALWAYS_HIDDEN
);
Voici les méthodes hide & show.
Kotlin
fun hideKeyboard(activity: Activity) {
val v = activity.currentFocus
val imm = activity.getSystemService(Context.INPUT_METHOD_SERVICE) as InputMethodManager
assert(v != null)
imm.hideSoftInputFromWindow(v!!.windowToken, InputMethodManager.HIDE_NOT_ALWAYS)
}
private fun showKeyboard(activity: Activity) {
val v = activity.currentFocus
val imm = activity.getSystemService(Context.INPUT_METHOD_SERVICE) as InputMethodManager
assert(v != null)
imm.showSoftInput(v, InputMethodManager.SHOW_IMPLICIT)
}
Java
public static void hideKeyboard(Activity activity) {
View v = activity.getCurrentFocus();
InputMethodManager imm = (InputMethodManager) activity.getSystemService(Context.INPUT_METHOD_SERVICE);
assert imm != null && v != null;
imm.hideSoftInputFromWindow(v.getWindowToken(), InputMethodManager.HIDE_NOT_ALWAYS);
}
private static void showKeyboard(Activity activity) {
View v = activity.getCurrentFocus();
InputMethodManager imm = (InputMethodManager) activity.getSystemService(Context.INPUT_METHOD_SERVICE);
assert imm != null && v != null;
imm.showSoftInput(v, InputMethodManager.SHOW_IMPLICIT);
}
Si vous utilisez Kotlin pour développer votre application, c'est très facile à faire.
Ajoutez ces fonctions d'extensions:
Pour l'activité:
fun Activity.hideKeyboard() {
val inputManager = getSystemService(Context.INPUT_METHOD_SERVICE) as InputMethodManager
val view = currentFocus
if (view != null) {
inputManager.hideSoftInputFromWindow(view.windowToken, InputMethodManager.HIDE_NOT_ALWAYS)
}
}
Pour le fragment:
fun Fragment.hideKeyboard() {
activity?.let {
val inputManager = it.getSystemService(Context.INPUT_METHOD_SERVICE) as InputMethodManager
val view = it.currentFocus
if (view != null) {
inputManager.hideSoftInputFromWindow(view.windowToken, InputMethodManager.HIDE_NOT_ALWAYS)
}
}
}
Maintenant, vous pouvez simplement appeler votre fragment ou activité:
hideKeyboard()
final RelativeLayout llLogin = (RelativeLayout) findViewById(R.id.rl_main);
llLogin.setOnTouchListener(
new View.OnTouchListener() {
@Override
public boolean onTouch(View view, MotionEvent ev) {
InputMethodManager imm = (InputMethodManager) this.getSystemService(
Context.INPUT_METHOD_SERVICE);
imm.hideSoftInputFromWindow(this.getCurrentFocus().getWindowToken(), 0);
return false;
}
});
Essaye celui-là
public void disableSoftKeyboard(final EditText v) {
if (Build.VERSION.SDK_INT >= 11) {
v.setRawInputType(InputType.TYPE_CLASS_TEXT);
v.setTextIsSelectable(true);
} else {
v.setRawInputType(InputType.TYPE_NULL);
v.setFocusable(true);
}
}
Manière très simple
Je le fais dans tous mes projets et je travaille comme un rêve. Dans vos déclarations layout.xml, ajoutez simplement cette ligne:
Android:focusableInTouchMode="true"
Exemple de code complet:
<?xml version="1.0" encoding="utf-8"?>
<Android.support.constraint.ConstraintLayout
xmlns:app="http://schemas.Android.com/apk/res-auto"
Android:layout_width="match_parent"
Android:layout_height="match_parent"
Android:focusableInTouchMode="true">
<EditText
Android:layout_width="match_parent"
Android:layout_height="wrap_content" />
<ListView
Android:layout_width="match_parent"
Android:layout_height="wrap_content">
</ListView>
</Android.support.constraint.ConstraintLayout>
Voici les meilleures solutions
Solution 1) Définissez inputType sur “text”
<EditText
Android:id="@+id/my_edit_text"
Android:layout_width="fill_parent"
Android:layout_height="wrap_content"
Android:hint="Tap here to type"
Android:inputType="text" />
Cela peut aussi être fait par programme via. la méthode setInputType () (héritée de TextView).
EditText editText = (EditText) findViewById(R.id.my_edit_text);
editText.setRawInputType(InputType.TYPE_CLASS_TEXT |
InputType.TYPE_TEXT_VARIATION_NORMAL);
Solution 2) Utilisez le paramètre InputMethodManager.hideSoftInputFromWindow ()
InputMethodManager imm =
(InputMethodManager)getSystemService(Context.INPUT_METHOD_SERVICE);
imm.hideSoftInputFromWindow(myEditText.getWindowToken(), 0);
ou
InputMethodManager imm = (InputMethodManager)
getSystemService(Context.INPUT_METHOD_SERVICE);
imm.hideSoftInputFromWindow(myEditText.getWindowToken(),
InputMethodManager.HIDE_NOT_ALWAYS);
méthode simple les gars: essayez ceci ...
private void closeKeyboard(boolean b) {
View view = this.getCurrentFocus();
if(b) {
if (view != null) {
InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
imm.hideSoftInputFromWindow(view.getWindowToken(), 0);
}
}
else {
InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
imm.showSoftInput(view, 0);
}
}
public static void hideSoftKeyboard(Activity activity) {
InputMethodManager inputMethodManager = (InputMethodManager) activity
.getSystemService(Activity.INPUT_METHOD_SERVICE);
inputMethodManager.hideSoftInputFromWindow(activity.getCurrentFocus()
.getWindowToken(), 0);
}
Une solution de contournement facile consiste à simplement editText.setEnabled(false);editText.setEnabled(true); dans votre méthode Button onClick().
Lorsque vous souhaitez masquer le clavier manuellement sur l'action d'un clic de bouton:
/**
* Hides the already popped up keyboard from the screen.
*
*/
public void hideKeyboard() {
try {
// use application level context to avoid unnecessary leaks.
InputMethodManager inputManager = (InputMethodManager) getApplicationContext().getSystemService(Context.INPUT_METHOD_SERVICE);
assert inputManager != null;
inputManager.hideSoftInputFromWindow(getCurrentFocus().getWindowToken(), InputMethodManager.HIDE_NOT_ALWAYS);
} catch (Exception e) {
e.printStackTrace();
}
}
Lorsque vous souhaitez masquer le clavier lorsque vous cliquez sur l'écran à l'exception de edittext .__, remplacez cette méthode dans votre activité:
@Override
public boolean dispatchTouchEvent(MotionEvent ev) {
View view = getCurrentFocus();
if (view != null && (ev.getAction() == MotionEvent.ACTION_UP || ev.getAction() == MotionEvent.ACTION_MOVE) && view instanceof EditText && !view.getClass().getName().startsWith("Android.webkit.")) {
int scrcoords[] = new int[2];
view.getLocationOnScreen(scrcoords);
float x = ev.getRawX() + view.getLeft() - scrcoords[0];
float y = ev.getRawY() + view.getTop() - scrcoords[1];
if (x < view.getLeft() || x > view.getRight() || y < view.getTop() || y > view.getBottom())
((InputMethodManager)this.getSystemService(Context.INPUT_METHOD_SERVICE)).hideSoftInputFromWindow((this.getWindow().getDecorView().getApplicationWindowToken()), 0);
}
return super.dispatchTouchEvent(ev);
}
Dans Android pour masquer le Vkeyboard par InputMethodManage, vous pouvez caler hideSoftInputFromWindow en transmettant le jeton de la fenêtre contenant votre vue active.
View view = this.getCurrentFocus();
if (view != null) {
InputMethodManager im =
(InputMethodManager)getSystemService(Context.INPUT_METHOD_SERVICE);
im.hideSoftInputFromWindow(view.getWindowToken(), 0);
}
En appelant editText.clearFocus () puis InputMethodManager.HIDE_IMPLICIT_ONLY, même fonctionne
vous pouvez simplement ajouter ce code là où vous voulez cacher le clavier logiciel "
// Check if no view has focus:
View view = getCurrentFocus();
if (view != null) {
InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
imm.hideSoftInputFromWindow(view.getWindowToken(), 0);
}
À Kotlin
fun hideKeyboard(activity: BaseActivity) {
val view = activity.currentFocus?: View(activity)
val imm = activity.getSystemService(Activity.INPUT_METHOD_SERVICE) as InputMethodManager
imm.hideSoftInputFromWindow(view.windowToken, 0)
}
J'ai créé une présentation partiellement à partir de xml et partiellement à partir d'un moteur de présentation personnalisé, qui est entièrement géré en code. La seule chose qui a fonctionné pour moi a été de savoir si le clavier était ouvert ou non et d'utiliser la méthode de basculement du clavier comme suit:
public class MyActivity extends Activity
{
/** This maintains true if the keyboard is open. Otherwise, it is false. */
private boolean isKeyboardOpen = false;
@Override
public void onCreate(Bundle savedInstanceState)
{
super.onCreate(savedInstanceState);
LayoutInflater inflater;
inflater = (LayoutInflater) getSystemService(Context.LAYOUT_INFLATER_SERVICE);
View contentView = inflater.inflate(context.getResources().getIdentifier("main", "layout", getPackageName()), null);
setContentView(contentView);
contentView.getViewTreeObserver().addOnGlobalLayoutListener(new OnGlobalLayoutListener()
{
public void onGlobalLayout()
{
Rect r = new Rect();
contentView.getWindowVisibleDisplayFrame(r);
int heightDiff = contentView.getRootView().getHeight() - (r.bottom - r.top);
if (heightDiff > 100)
isKeyboardVisible = true;
else
isKeyboardVisible = false;
});
}
}
public void closeKeyboardIfOpen()
{
InputMethodManager imm;
imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
if (isKeyboardVisible)
imm.toggleSoftInput(InputMethodManager.HIDE_IMPLICIT_ONLY, 0);
}
}
Cette méthode fonctionnera toujours à tout prix. Utilisez-le simplement où vous voulez cacher le clavier
public static void hideSoftKeyboard(Context mContext,EditText username){
if(((Activity) mContext).getCurrentFocus()!=null && ((Activity) mContext).getCurrentFocus() instanceof EditText){
InputMethodManager imm = (InputMethodManager)mContext.getSystemService(Context.INPUT_METHOD_SERVICE);
imm.hideSoftInputFromWindow(username.getWindowToken(), 0);
}
}
Utilisez-le comme ceci:
Quelle que soit la version d'Android. Cette méthode fonctionnera sûrement
Cela a fonctionné pour moi.
public static void hideKeyboard(Activity act, EditText et){
Context c = act.getBaseContext();
View v = et.findFocus();
if(v == null)
return;
InputMethodManager inputManager = (InputMethodManager) c.getSystemService(Context.INPUT_METHOD_SERVICE);
inputManager.hideSoftInputFromWindow(v.getWindowToken(), InputMethodManager.HIDE_NOT_ALWAYS);
}
Essayé tous ici en désespoir de cause, combinant toutes les méthodes, et bien sûr le clavier ne se fermera pas dans Android 4.0.3 (cela a fonctionné dans Honeicomb AFAIR).
Puis tout à coup j'ai trouvé une combinaison apparemment gagnante:
textField.setRawInputType(InputType.TYPE_CLASS_TEXT |InputType.TYPE_TEXT_VARIATION_NORMAL);
combiné avec vos recettes habituelles
blahblaj.hideSoftInputFromWindow ...
j'espère que cela empêchera quelqu'un de se suicider. J'étais proche de ça. Bien sûr, je ne sais pas pourquoi cela fonctionne.
Une alternative utilisant SearchView serait d'utiliser ce code:
searchView = (SearchView) searchItem.getActionView();
searchView.setOnQueryTextListener(new OnQueryTextListener() {
@Override
public boolean onQueryTextSubmit(String query) {
InputMethodManager imm = (InputMethodManager)
getSystemService(getApplicationContext().INPUT_METHOD_SERVICE);
imm.hideSoftInputFromWindow(searchView.getApplicationWindowToken(), 0);
}
}
Il s’agit d’un champ de recherche SearchView dans la barre d’action qui indique que lorsque le texte de la requête est soumis (l’utilisateur appuie sur la touche Enter ou sur un bouton/icône de recherche), le code InputMethodManager est activé et votre clavier logiciel s’affaiblit. Ce code a été mis dans ma onCreateOptionsMenu(). searchItem provient de MenuItem qui fait partie du code par défaut de la onCreateOptionsmenu(). Merci à @mckoss pour une bonne partie de ce code!
vous pouvez créer Extension function pour n’importe quelle vue
fun View.hideKeyboard() = this.let {
val imm = context.getSystemService(Context.INPUT_METHOD_SERVICE) as InputMethodManager
imm.hideSoftInputFromWindow(windowToken, 0)
}
Exemple d'utilisation avec Activity
window.decorView.hideKeyboard();
Exemple d'utilisation avec View
etUsername.hideKeyboard();
Bonne codage ...
Appelez cette méthode pour masquer le clavier logiciel
public void hideKeyBoard() {
View view1 = this.getCurrentFocus();
if(view!= null){
InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
imm.hideSoftInputFromWindow(view1.getWindowToken(), 0);
}
}
public static void closeInput(final View caller) {
caller.postDelayed(new Runnable() {
@Override
public void run() {
InputMethodManager imm = (InputMethodManager) caller.getContext().getSystemService(Context.INPUT_METHOD_SERVICE);
imm.hideSoftInputFromWindow(caller.getWindowToken(), InputMethodManager.HIDE_NOT_ALWAYS);
}
}, 100);
}
Cette méthode fonctionne généralement, mais il y a une condition: vous ne pouvez pas avoir Android:windowSoftInputMode="any_of_these" set
En dépit de toutes ces réponses, pour être assez simple, j’ai écrit une méthode commune pour le faire:
/**
* hide soft keyboard in a activity
* @param activity
*/
public static void hideKeyboard (Activity activity){
activity.getWindow().setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_STATE_HIDDEN);
if (activity.getCurrentFocus() != null) {
InputMethodManager inputMethodManager = (InputMethodManager) activity.getSystemService(activity.INPUT_METHOD_SERVICE);
inputMethodManager.hideSoftInputFromWindow(activity.getCurrentFocus().getWindowToken(), 0);
}
}
Le code ci-dessous vous aidera à créer une fonction générique pouvant être appelée de n’importe où.
import Android.app.Activity
import Android.content.Context
import Android.support.design.widget.Snackbar
import Android.view.View
import Android.view.inputmethod.InputMethodManager
public class KeyboardHider {
companion object {
fun hideKeyboard(view: View, context: Context) {
val inputMethodManager = context.getSystemService(Activity.INPUT_METHOD_SERVICE) as InputMethodManager
inputMethodManager.hideSoftInputFromWindow(view.windowToken, 0)
}
}
}
Appelez la méthode ci-dessus de n'importe où en utilisant une seule ligne de code.
CustomSnackbar.hideKeyboard(view, this@ActivityName)
la vue peut être n'importe quoi, par exemple la disposition racine d’une activité.
Bonjour, c’est simple si vous travaillez avec Kotlin, mais j’espère que vous pouvez facilement convertir le code en Java aussi dans votre activité. Utilisez cette fonction lorsque votre activité est chargée, par exemple dans l’appel onCreate ().
fun hideKeybord (){
val inputManager = getSystemService(Context.INPUT_METHOD_SERVICE) as InputMethodManager
if (inputManager.isAcceptingText){
inputManager.hideSoftInputFromWindow(currentFocus.windowToken, 0)
}
}
comme je l'ai mentionné, appelez cette fonction dans votre méthode onCreate (), puis ajoutez cette ligne Android:windowSoftInputMode="stateAlwaysHidden" à votre activité dans le fichier manafest.xml.
<activity
Android:name=".Activity.MainActivity"
Android:label="@string/app_name"
Android:theme="@style/AppTheme.NoActionBar"
Android:windowSoftInputMode="stateAlwaysHidden">
Pour les utilisateurs de kotlin, il existe une méthode d'extension kotlin qui a fonctionné pour mes cas d'utilisation:
fun View.hideKeyboard() {
val imm = this.context.getSystemService(Activity.INPUT_METHOD_SERVICE) as InputMethodManager
imm.hideSoftInputFromWindow(windowToken, 0)
}
mettez-le dans un fichier appelé ViewExtensions (ou ce que vous avez) et appelez-le sur vos vues comme s'il s'agissait d'une méthode normale.
Si votre application cible API de niveau 21 ou plus , il existe une méthode par défaut à utiliser:
editTextObj.setShowSoftInputOnFocus(false);
Assurez-vous que vous avez défini le code ci-dessous dans la balise XML EditText.
<EditText
....
Android:enabled="true"
Android:focusable="true" />
C'était un travail pour moi. Il est à Kotlin pour cacher le clavier.
private fun hideKeyboard() {
val inputManager = activity?.getSystemService(Context.INPUT_METHOD_SERVICE) as InputMethodManager
val focusedView = activity?.currentFocus
if (focusedView != null) {
inputManager.hideSoftInputFromWindow(focusedView.windowToken,
InputMethodManager.HIDE_NOT_ALWAYS)
}
}
Cet extrait de code peut aider à:
final InputMethodManager inputMethodManager = (InputMethodManager) getSystemService(Activity.INPUT_METHOD_SERVICE);
if (inputMethodManager != null && inputMethodManager.isActive()) {
if (getCurrentFocus() != null) {
inputMethodManager.hideSoftInputFromWindow(getCurrentFocus().getWindowToken(), 0);
}
}
Il peut être appelé de différentes manières en fonction des besoins (ex. OnPause, onResume, onRestart ...)
J'utilise les extensions d'activité Kotlin suivantes:
/**
* Hides soft keyboard if is open.
*/
fun Activity.hideKeyboard() {
currentFocus?.windowToken?.let {
(getSystemService(Context.INPUT_METHOD_SERVICE) as? InputMethodManager?)
?.hideSoftInputFromWindow(it, InputMethodManager.HIDE_NOT_ALWAYS)
}
}
/**
* Shows soft keyboard and request focus to given view.
*/
fun Activity.showKeyboard(view: View) {
view.requestFocus()
currentFocus?.windowToken?.let {
(getSystemService(Context.INPUT_METHOD_SERVICE) as? InputMethodManager?)
?.showSoftInput(view, InputMethodManager.SHOW_IMPLICIT)
}
}
Pour afficher le clavier au démarrage de l'application:
getWindow().setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_ADJUST_PAN | WindowManager.LayoutParams.SOFT_INPUT_STATE_VISIBLE);
view.requestFocus();
new Handler().postDelayed(new Runnable() {
public void run() {
getWindow().setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_ADJUST_PAN);
}
}, 1000);
Tout d'abord, vous devez ajouter à partir du fichier XML le champ Android: imeOptions et changer sa valeur en actionUnspecified | actionGo comme ci-dessous.
<Android.support.design.widget.TextInputEditText
Android:id="@+id/edit_text_id"
Android:layout_width="fill_parent"
Android:layout_height="@dimen/edit_text_height"
Android:imeOptions="actionUnspecified|actionGo"
/>
Ensuite, dans la classe Java, ajoutez un setOnEditorActionListener et ajoutez InputMethodManager comme ci-dessous.
enterOrderNumber.setOnEditorActionListener (new TextView.OnEditorActionListener () {
@Override
public boolean onEditorAction(TextView v, int actionId, KeyEvent event) {
if (actionId == EditorInfo.IME_ACTION_GO) {
InputMethodManager imm = (InputMethodManager) getActivity().getSystemService(Activity.INPUT_METHOD_SERVICE);
imm.toggleSoftInput(InputMethodManager.HIDE_IMPLICIT_ONLY, 0);
return true;
}
return false;
}
});
Version Kotlin
val imm: InputMethodManager = getSystemService(Activity.INPUT_METHOD_SERVICE) as InputMethodManager
//Hide:
imm.toggleSoftInput(InputMethodManager.HIDE_IMPLICIT_ONLY, 0);
//Show
imm.toggleSoftInput(InputMethodManager.SHOW_IMPLICIT, 0);
entourez-le avec try catch, de sorte que le clavier est déjà fermé, l'application ne planterait pas:
try{
View view = this.getCurrentFocus();
if (view != null) {
InputMethodManager imm = (InputMethodManager)getSystemService(Context.INPUT_METHOD_SERVICE);
imm.hideSoftInputFromWindow(view.getWindowToken(), 0);
}
}catch (Exception e)
{
e.printStackTrace();
}
J'ai beaucoup essayé toutes les solutions mais aucune solution ne fonctionne, donc j'ai trouvé ma solution: Vous devriez avoir des variables booléennes comme:
public static isKeyboardShowing = false;
InputMethodManager inputMethodManager = (InputMethodManager) getActivity()
.getSystemService(Context.INPUT_METHOD_SERVICE);
Et dans un événement à écran tactile, vous appelez:
@Override
public boolean onTouchEvent(MotionEvent event) {
if(keyboardShowing==true){
inputMethodManager.toggleSoftInput(InputMethodManager.RESULT_UNCHANGED_HIDDEN, 0);
keyboardShowing = false;
}
return super.onTouchEvent(event);
}
Et dans EditText se trouve n'importe où:
yourEditText.setOnClickListener(new OnClickListener() {
@Override
public void onClick(View v) {
yourClass.keyboardShowing = true;
}
});
Pour Xamarin.Android:
public void HideKeyboard()
{
var imm = activity.GetSystemService(Context.InputMethodService).JavaCast<InputMethodManager>();
var view = activity.CurrentFocus ?? new View(activity);
imm.HideSoftInputFromWindow(view.WindowToken, HideSoftInputFlags.None);
}
Ajoutez simplement la ligne suivante dans AndroidManifest dans une activité spécifique.
<activity
Android:name=".MainActivity"
Android:screenOrientation="portrait">
Android:windowSoftInputMode="adjustPan"/>
Il vous suffit d'écrire une ligne dans votre balise d'activité du manifeste
Android:windowSoftInputMode="stateAlwaysHidden|adjustPan"
et ça va marcher.
fun hideKeyboard(appCompatActivity: AppCompatActivity) {
val view = appCompatActivity.currentFocus
val imm = appCompatActivity.getSystemService(Context.INPUT_METHOD_SERVICE) as InputMethodManager
imm.hideSoftInputFromWindow(view.windowToken, 0)
}
il suffit de créer une méthode commune pour une application complète dans BaseActivity et BaseFragment
dans onCreate() initialize inputMethodManager
inputMethodManager = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
faire cette méthodes pour masquer et afficher le clavier
public void hideKeyBoard(View view) {
if (view != null) {
inputMethodManager.hideSoftInputFromWindow(view.getWindowToken(), 0);
}
}
public void showKeyboard(View view, boolean isForceToShow) {
if (isForceToShow)
inputMethodManager.toggleSoftInput(InputMethodManager.SHOW_FORCED, 0);
else if (view != null)
inputMethodManager.showSoftInput(view, 0);
}
use Text watcher instead of EditText.and after you finished entering the input
vous pouvez utiliser
InputMethodManager imm = (InputMethodManager)getSystemService(Context.INPUT_METHOD_SERVICE);
imm.hideSoftInputFromWindow(view.getWindowToken(), 0);
there are two ways to do so...
method 1:in manifest file
define the line **Android:windowSoftInputMode="adjustPan|stateAlwaysHidden"** of code in your manifest.xml file as below...
<activity
Android:name="packagename.youactivityname"
Android:screenOrientation="portrait"
Android:windowSoftInputMode="adjustPan|stateAlwaysHidden" />
Method 2 : in Activity or Java class
if(getCurrentFocus()!=null) {
InputMethodManager inputMethodManager = (InputMethodManager) getSystemService(INPUT_METHOD_SERVICE)`enter code here`;
inputMethodManager.hideSoftInputFromWindow(getCurrentFocus().getWindowToken(), 0);
}
cela fonctionnera .... @ DEMANDEZ
/**
*
* Hide I Said!!!
*
*/
public static boolean hideSoftKeyboard(@NonNull Activity activity) {
View currentFocus = activity.getCurrentFocus();
if (currentFocus == null) {
currentFocus = activity.getWindow().getDecorView();
if (currentFocus != null) {
return getSoftInput(activity).hideSoftInputFromWindow(currentFocus.getWindowToken(), 0, null);
}
}
return false;
}
public static boolean hideSoftKeyboard(@NonNull Context context) {
if(Activity.class.isAssignableFrom(context.getClass())){
return hideSoftKeyboard((Activity)context);
}
return false;
}
public static InputMethodManager getSoftInput(@NonNull Context context) {
return (InputMethodManager) context.getSystemService(Activity.INPUT_METHOD_SERVICE);
}
Un code kotlin:
Masquer le clavier de l'activité:
(currentFocus ?: View(this))
.apply { (getSystemService(Activity.INPUT_METHOD_SERVICE) as InputMethodManager)
.hideSoftInputFromWindow(windowToken, 0) }
Wiki répond à Kotlin:
1 - Créez une fonction de niveau supérieur dans un fichier (par exemple, un fichier contenant toutes vos fonctions de niveau supérieur):
fun Activity.hideKeyboard(){
val imm = this.getSystemService(Activity.INPUT_METHOD_SERVICE) as InputMethodManager
var view = currentFocus
if (view == null) { view = View(this) }
imm.hideSoftInputFromWindow(view.windowToken, 0)
}
2 - Puis appelez-le dans n'importe quelle activité dont vous aviez besoin:
this.hideKeyboard()
public void hideKeyboard()
{
if(getCurrentFocus()!=null)
{
InputMethodManager inputMethodManager = (InputMethodManager) getSystemService(INPUT_METHOD_SERVICE);
inputMethodManager.hideSoftInputFromWindow(getCurrentFocus().getWindowToken(), 0);
}
}
public void showKeyboard(View mView) {
InputMethodManager inputMethodManager = (InputMethodManager) getSystemService(INPUT_METHOD_SERVICE);
mView.requestFocus();
inputMethodManager.showSoftInput(mView, 0);
}
private void hideSoftKeyboard() {
View view = getView();
if (view != null) {
InputMethodManager inputMethodManager = (InputMethodManager) getActivity()
.getSystemService(Activity.INPUT_METHOD_SERVICE);
inputMethodManager.hideSoftInputFromWindow(view.getWindowToken(), 0);
}
}
Après avoir lu toutes les réponses ci-dessus et dans un autre article, je n’ai toujours pas réussi à ouvrir le clavier automatiquement.
Dans mon projet, j'ai créé un dialogue (AlertDialog) de manière dynamique (en le programmant sans ou avec le minimum de XML nécessaire).
Alors je faisais quelque chose comme:
dialogBuilder = new AlertDialog.Builder(activity);
if(dialogBuilder==null)
return false; //error
inflater = activity.getLayoutInflater();
dialogView = inflater.inflate(layout, null);
...
Et après avoir fini de configurer toutes les vues (TextView, ImageView, EditText, etc.), je l’ai fait:
alertDialog = dialogBuilder.create();
alertDialog.show();
Après avoir jonglé avec toutes les réponses, j’ai découvert que la plupart d’entre elles marchaientSIvous savezO&UGRAVE;pour faire la demande ... Et c’était la clé pour tous.
Le truc est donc de le mettreAVANTla création du dialogue: alertDialog.show() dans mon cas, cela a fonctionné à merveille:
alertDialog = dialogBuilder.create();
alertDialog.getWindow().setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_STATE_ALWAYS_VISIBLE);
//And only when everything is finished - let's bring up the window -
alertDialog.show();
//Viola... keyboard is waiting for you open and ready...
//Just don't forget to request focus for the needed view (i.e. EditText..)
Je suis à peu près sûr que ce principe est le même avec toutes les fenêtres, alors faites attention à l'emplacement de votre code "showKeyboard" - il devrait l'être avant le lancement de la fenêtre.
Une petite demande de l'équipe de développement Android SDK:
Je pense que tout cela est inutile car vous pouvez voir que des milliers de programmeurs du monde entier traitent ce problème ridicule et trivial, alors que sa solution devrait être propre et simple: IMHO si je fonctionne avec un requestFocus() (par exemple, EditText), le clavier devrait s'ouvrir automatiquement, à moins que l'utilisateur ne demande pas à, alors je pense que la méthode requestFocus () est la clé ici et doit accepter boolean showSoftKeyboard avec la valeur par défaut de true: View.requestFocus(boolean showSoftKeyboard);
J'espère que cela aidera d'autres personnes comme moi.
Essayez ceci à Kotlin
private fun hideKeyboard(){
val imm = activity!!.getSystemService(INPUT_METHOD_SERVICE) as InputMethodManager
imm.hideSoftInputFromWindow(activity!!.currentFocus!!.windowToken, 0)
}
Essayez ceci en Java
private void hideKeyboard(){
InputMethodManager imm =(InputMethodManager)getSystemService(INPUT_METHOD_SERVICE);
imm.hideSoftInputFromWindow(getCurrentFocus().getWindowToken(), 0);
}