Comment afficher le clavier logiciel quand edittext est activé
Je souhaite afficher automatiquement le clavier logiciel lorsqu'une EditText est sélectionnée (si le périphérique ne possède pas de clavier physique) et que je rencontre deux problèmes:
Lorsque ma
Activityest affichée, maEditTextest activée, mais le clavier ne s'affiche pas. Je dois cliquer à nouveau dessus pour afficher le clavier (il devrait être affiché lorsque maActivityest affichée).Et lorsque je clique sur done sur le clavier, le clavier est supprimé mais la
EditTextreste focalisée et y ne veut pas (car ma modification est terminée).
Pour résumer, mon problème est d’avoir quelque chose de plus semblable à l’iPhone: garder le clavier synchronisé avec mon état EditText (focalisé/non focalisé) et, bien sûr, ne pas présenter de clavier logiciel s'il existe un clavier physique.
Pour forcer le clavier logiciel à apparaître, vous pouvez utiliser
EditText yourEditText= (EditText) findViewById(R.id.yourEditText);
InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
imm.showSoftInput(yourEditText, InputMethodManager.SHOW_IMPLICIT);
Et pour supprimer le focus sur EditText, malheureusement, vous devez avoir une valeur factice View pour attirer l'attention.
J'espère que ça aide
Pour le fermer, vous pouvez utiliser
InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
imm.hideSoftInputFromWindow(yourEditText.getWindowToken(), 0);
Cela fonctionne pour l'utiliser dans un dialogue
public void showKeyboard(){
InputMethodManager inputMethodManager = (InputMethodManager) context.getSystemService(Context.INPUT_METHOD_SERVICE);
inputMethodManager.toggleSoftInput(InputMethodManager.SHOW_FORCED, 0);
}
public void closeKeyboard(){
InputMethodManager inputMethodManager = (InputMethodManager) context.getSystemService(Context.INPUT_METHOD_SERVICE);
inputMethodManager.toggleSoftInput(InputMethodManager.HIDE_IMPLICIT_ONLY, 0);
}
J'ai eu le même problème. Immédiatement après que editText VISIBILITY soit passé de GONE à VISIBLE, je devais définir le focus et afficher le clavier virtuel. J'ai réalisé ceci en utilisant le code suivant:
new Handler().postDelayed(new Runnable() {
public void run() {
// ((EditText) findViewById(R.id.et_find)).requestFocus();
//
EditText yourEditText= (EditText) findViewById(R.id.et_find);
// InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
// imm.showSoftInput(yourEditText, InputMethodManager.SHOW_IMPLICIT);
yourEditText.dispatchTouchEvent(MotionEvent.obtain(SystemClock.uptimeMillis(), SystemClock.uptimeMillis(), MotionEvent.ACTION_DOWN , 0, 0, 0));
yourEditText.dispatchTouchEvent(MotionEvent.obtain(SystemClock.uptimeMillis(), SystemClock.uptimeMillis(), MotionEvent.ACTION_UP , 0, 0, 0));
}
}, 200);
Cela fonctionne pour moi avec un délai de 100 ms, mais a échoué sans délai ou avec un retard de 1 ms seulement.
La partie commentée du code montre une autre approche qui ne fonctionne que sur certains périphériques. J'ai testé sur les versions de système d'exploitation 2.2 (émulateur), 2.2.1 (périphérique réel) et 1.6 (émulateur).
Cette approche m'a évité beaucoup de douleur.
Pour que le clavier apparaisse, utilisez
getWindow().setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_STATE_VISIBLE);
Cette méthode est plus fiable que d'appeler directement InputMethodManager.
Pour le fermer, utilisez
getWindow().setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_STATE_HIDDEN);
Le code suivant est extrait du code source 4.1 de Google pour SearchView. Semble fonctionner, très bien sur les versions moins d'Android.
private Runnable mShowImeRunnable = new Runnable() {
public void run() {
InputMethodManager imm = (InputMethodManager) getContext()
.getSystemService(Context.INPUT_METHOD_SERVICE);
if (imm != null) {
imm.showSoftInput(editText, 0);
}
}
};
private void setImeVisibility(final boolean visible) {
if (visible) {
post(mShowImeRunnable);
} else {
removeCallbacks(mShowImeRunnable);
InputMethodManager imm = (InputMethodManager) getContext()
.getSystemService(Context.INPUT_METHOD_SERVICE);
if (imm != null) {
imm.hideSoftInputFromWindow(getWindowToken(), 0);
}
}
}
Ensuite, le code suivant doit être ajouté lors de la création du contrôle/activité. (Dans mon cas, il s'agit d'un contrôle composite plutôt que d'une activité).
this.editText.setOnFocusChangeListener(new View.OnFocusChangeListener() {
public void onFocusChange(View v, boolean hasFocus) {
setImeVisibility(hasFocus);
}
});
Quand rien ne fonctionne,force l’affichage:
editText.requestFocus();
InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
imm.toggleSoftInput(InputMethodManager.SHOW_FORCED, InputMethodManager.HIDE_IMPLICIT_ONLY);
Android:windowSoftInputMode="stateAlwaysVisible" -> dans le fichier manifeste.
edittext.requestFocus(); -> in code.
Cela ouvrira le clavier virtuel sur lequel le texte édité a le focus de la demande lorsque l'activité apparaît.
J'ai eu un peu de chance récemment dans quelques cas simples avec le code Ci-dessous. Je n'ai pas fini tous les tests mais ...
EditText input = (EditText) findViewById(R.id.Input);
input.requestFocus();
input.dispatchTouchEvent(MotionEvent.obtain(SystemClock.uptimeMillis(), SystemClock.uptimeMillis(), MotionEvent.ACTION_DOWN , 0, 0, 0));
input.dispatchTouchEvent(MotionEvent.obtain(SystemClock.uptimeMillis(), SystemClock.uptimeMillis(), MotionEvent.ACTION_UP , 0, 0, 0));
Et hop, le clavier apparaît.
Vous pouvez essayer de forcer le clavier logiciel à apparaître, cela fonctionne pour moi:
...
dialog.show();
input.requestFocus();
InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
imm.toggleSoftInput(InputMethodManager.SHOW_FORCED, 0);
Pour masquer le clavier, utilisez celui-ci:
getActivity().getWindow().setSoftInputMode(
WindowManager.LayoutParams.SOFT_INPUT_STATE_ALWAYS_HIDDEN);
et pour afficher le clavier:
getActivity().getWindow().setSoftInputMode(
WindowManager.LayoutParams.SOFT_INPUT_STATE_ALWAYS_VISIBLE);
Parfois, la réponse de Raukodraug ne fonctionne pas. Je l'ai fait de cette manière avec quelques essais et erreurs:
public static void showKeyboard(Activity activity) {
if (activity != null) {
activity.getWindow()
.setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_STATE_ALWAYS_VISIBLE);
}
}
public static void hideKeyboard(Activity activity) {
if (activity != null) {
activity.getWindow()
.setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_STATE_ALWAYS_HIDDEN);
}
}
Et le EditText part:
editText.setOnFocusChangeListener(new View.OnFocusChangeListener() {
@Override
public void onFocusChange(View v, boolean hasFocus) {
if (!hasFocus) {
hideKeyboard(getActivity());
} else {
showKeyboard(getActivity());
}
}
});
showSoftInput ne fonctionnait pas du tout pour moi.
J'ai pensé que j'avais besoin de définir le mode de saisie:
Android:windowSoftInputMode="stateVisible"
Pour fragment, assurez-vous que cela fonctionne:
displayName = (EditText) view.findViewById(R.id.displayName);
InputMethodManager imm = (InputMethodManager) getActivity().getSystemService(Context.INPUT_METHOD_SERVICE);
imm.toggleSoftInput(InputMethodManager.SHOW_FORCED, 0);
J'ai tout combiné ici et pour moi ça marche:
public static void showKeyboardWithFocus(View v, Activity a) {
try {
v.requestFocus();
InputMethodManager imm = (InputMethodManager) a.getSystemService(Context.INPUT_METHOD_SERVICE);
imm.showSoftInput(v, InputMethodManager.SHOW_IMPLICIT);
a.getWindow().setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_STATE_VISIBLE);
} catch (Exception e) {
e.printStackTrace();
}
}
J'ai eu le même problème dans différentes situations, et les solutions que j'ai trouvées fonctionnent dans certains cas mais ne fonctionnent pas dans d'autres alors voici une solution combinant qui fonctionne dans la plupart des situations que j'ai trouvées:
public static void showVirtualKeyboard(Context context, final View view) {
if (context != null) {
final InputMethodManager imm = (InputMethodManager) context.getSystemService(Context.INPUT_METHOD_SERVICE);
view.clearFocus();
if(view.isShown()) {
imm.showSoftInput(view, 0);
view.requestFocus();
} else {
view.addOnAttachStateChangeListener(new View.OnAttachStateChangeListener() {
@Override
public void onViewAttachedToWindow(View v) {
view.post(new Runnable() {
@Override
public void run() {
view.requestFocus();
imm.showSoftInput(view, 0);
}
});
view.removeOnAttachStateChangeListener(this);
}
@Override
public void onViewDetachedFromWindow(View v) {
view.removeOnAttachStateChangeListener(this);
}
});
}
}
}
Croyez-le ou non, mon problème avec Soft Keyboard a été résolu lorsque j'ai découvert que les animations Activités pouvaient désactiver le clavier. Lorsque vous appelez l'intention avec le
i.setFlags(Intent.FLAG_ACTIVITY_NO_ANIMATION);
et
overridePendingTransition(0, 0);
Il peut cacher le clavier virtuel et il n’ya aucun moyen de le montrer.
Cela a fonctionné pour moi. Vous pouvez essayer avec cela aussi de montrer le clavier:
getWindow().setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_ADJUST_RESIZE);
extrait de code . . .
public void hideKeyboard(Context activityContext){
InputMethodManager imm = (InputMethodManager)
activityContext.getSystemService(Context.INPUT_METHOD_SERVICE);
//Android.R.id.content ( http://stackoverflow.com/a/12887919/2077479 )
View rootView = ((Activity) activityContext)
.findViewById(Android.R.id.content).getRootView();
imm.hideSoftInputFromWindow(rootView.getWindowToken(), 0);
}
public void showKeyboard(Context activityContext, final EditText editText){
final InputMethodManager imm = (InputMethodManager)
activityContext.getSystemService(Context.INPUT_METHOD_SERVICE);
if (!editText.hasFocus()) {
editText.requestFocus();
}
editText.post(new Runnable() {
@Override
public void run() {
imm.showSoftInput(editText, InputMethodManager.SHOW_FORCED);
}
});
}
editText.post(new Runnable() {
@Override
public void run() {
InputMethodManager imm = (InputMethodManager) getActivity().getSystemService(Context.INPUT_METHOD_SERVICE);
imm.showSoftInput(editText, InputMethodManager.SHOW_IMPLICIT);
}
});
final InputMethodManager keyboard = (InputMethodManager) ctx.getSystemService(Context.INPUT_METHOD_SERVICE);
keyboard.toggleSoftInput(InputMethodManager.SHOW_FORCED,0);
ajoutez simplement Android: windowSoftInputMode = "stateHidden" dans le fichier manifeste ...
Toutes les solutions données ci-dessus ( InputMethodManager interaction dans OnFocusChangeListener.onFocusChange listener attaché à votre EditText fonctionne bien si vous avez une édition unique dans l'activité.
Dans mon cas, j'ai deux modifications.
private EditText tvX, tvY;
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
tvX.setOnFocusChangeListener(this);
tvY.setOnFocusChangeListener(this);
@Override
public void onFocusChange(View v, boolean hasFocus) {
InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
if(tvX.hasFocus() || tvY.hasFocus()) {
imm.showSoftInput(v, 0);
} else {
imm.hideSoftInputFromWindow(v.getWindowToken(), 0);
}
};
J'ai observé que onFocusChange est déclenché pour tvX avec hasFocus = true (clavier affiché) mais ensuite pour tvY avec hasFocus = true (clavier masqué). En fin de compte, aucun clavier n'était visible.
La solution générale doit avoir la déclaration correcte si "affiche le clavier si le texte EditText a le focus"
Dans votre section onResume () de l'activité, vous pouvez appeler la méthode bringKeyboard ();
onResume() {
EditText yourEditText= (EditText) findViewById(R.id.yourEditText);
bringKeyboard(yourEditText);
}
protected boolean bringKeyboard(EditText view) {
if (view == null) {
return false;
}
try {
// Depending if edittext has some pre-filled values you can decide whether to bring up soft keyboard or not
String value = view.getText().toString();
if (value == null) {
InputMethodManager imm = (InputMethodManager)context.getSystemService(Context.INPUT_METHOD_SERVICE);
imm.hideSoftInputFromWindow(view.getWindowToken(), 0);
return true;
}
} catch (Exception e) {
Log.e(TAG, "decideFocus. Exception", e);
}
return false;
}
Dans votre manifeste:
Android:windowSoftInputMode="stateAlwaysVisible" - clavier initialement lancé .Android:windowSoftInputMode="stateAlwaysHidden" - clavier initialement masqué.
J'aime aussi utiliser "adjustPan" car lorsque le clavier est lancé, l'écran s'ajuste automatiquement.
<activity
Android:name="YourActivity"
Android:windowSoftInputMode="stateAlwaysHidden|adjustPan"/>
J'ai eu un problème similaire avec les animations de vue. J'ai donc mis un écouteur d'animation pour m'assurer que je j'attends la fin de l'animation avant d'essayer de demander un accès au clavier sur le texte affiché.
bottomUp.setAnimationListener(new Animation.AnimationListener() {
@Override
public void onAnimationStart(Animation animation) {
}
@Override
public void onAnimationEnd(Animation animation) {
if (textToFocus != null) {
// Position cursor at the end of the text
textToFocus.setSelection(textToFocus.getText().length());
// Show keyboard
InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
imm.showSoftInput(textToFocus, InputMethodManager.SHOW_IMPLICIT);
}
}
@Override
public void onAnimationRepeat(Animation animation) {
}
});
Je suis d'accord avec raukodraug pour cela, en utilisant dans un aperçu, vous devez demander/mettre au point clairement comme ceci:
final ViewSwitcher viewSwitcher = (ViewSwitcher) findViewById(R.id.viewSwitcher);
final View btn = viewSwitcher.findViewById(R.id.address_btn);
final View title = viewSwitcher.findViewById(R.id.address_value);
title.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View view) {
viewSwitcher.showPrevious();
btn.requestFocus();
InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
imm.showSoftInput(btn, InputMethodManager.SHOW_IMPLICIT);
}
});
// EditText affiche le titre evenement click
btn.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View view) {
btn.clearFocus();
viewSwitcher.showNext();
InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
imm.hideSoftInputFromWindow(btn.getWindowToken(), 0);
// Enregistre l'adresse.
addAddress(view);
}
});
Cordialement.
J'ai découvert un comportement étrange, car dans l'une de mes applications, le clavier virtuel était automatiquement affiché lors de la saisie de l'activité (il existe un editText.requestFocus () dans onCreate).
En creusant plus loin, j'ai découvert que c'était parce qu'il y avait un ScrollView autour de la disposition. Si je supprime ScrollView, le comportement est tel que décrit dans la déclaration du problème d'origine: le clavier logiciel n'apparaît que lorsque l'on clique sur le editText déjà sélectionné.
Si cela ne fonctionne pas pour vous, essayez d’utiliser une ScrollView - c’est quand même inoffensif.
Si EditText se trouve dans Recycler ou ListView et/ou si l'état de l'utilisation est désactivé sous le code.
public static void showKeyboardByFocus(final View view)
{
view.requestFocus();
InputMethodManager keyboard = SystemMaster.getInputMethodManager();
keyboard.showSoftInput(view, InputMethodManager.SHOW_IMPLICIT);
Runnable re = new Runnable()
{
@Override
public void run()
{
view.setEnabled(true);
view.requestFocus();
}
};
Handler h = new Handler(Looper.getMainLooper());
h.postDelayed(re, 360);
}
Ajoutez simplement cette ligne dans votre vue EditText:
Android:isScrollContainer="true"
et TADA - le clavier a commencé à apparaître automatiquement!
J'ai eu un problème similaire et découvert cette solution simple et étrange.
Comme déjà mentionné ici par user3392439, l'apparence du clavier lors de la mise au point était étrangement liée à la présence du composant de défilement dans le fichier XML.
Même la présence de autre La vue EditText comprenant la ligne susmentionnée dans le même code XML fait apparaître le clavier, quel que soit le type de EditTexts actuellement sélectionné.
Si vous avez au moins une vue visible comprenant le composant de défilement dans votre fichier XML, le clavier apparaîtra automatiquement au premier plan.
Si pas de défilement - alors vous devez cliquer sur EditText pour faire apparaître le clavier.
En utilisant Xamarin, cela fonctionne pour moi dans un fragment:
using Android.Views.InputMethods;
using Android.Content;
...
if ( _txtSearch.RequestFocus() ) {
var inputManager = (InputMethodManager) Activity.GetSystemService( Context.InputMethodService );
inputManager.ShowSoftInput( _txtSearch, ShowFlags.Implicit );
}
appelez la méthode requestFocus () sur editText dans la méthode onCrete () de activity () et appelez la méthode clearFocus () sur le même editText lorsque vous cliquez sur le clavier.
C'est sauvage, mais ça marche vraiment
fun showKeyboard(view: View) {
try {
InputMethodManager::class.Java.getMethod(
"showSoftInputUnchecked",
Int::class.javaPrimitiveType,
ResultReceiver::class.Java
).apply {
isAccessible = true
invoke(view.context.inputMethodManager, 0, null)
}
}
catch (e: Exception) {
e.printStackTrace()
}
}
Vous pouvez également créer une extension personnalisée de EditText qui sait ouvrir le clavier logiciel quand il reçoit le focus. C'est ce que j'ai fini par faire. Voici ce qui a fonctionné pour moi:
public class WellBehavedEditText extends EditText {
private InputMethodManager inputMethodManager;
private boolean showKeyboard = false;
public WellBehavedEditText(Context context) {
super(context);
this.initializeWellBehavedEditText(context);
}
public WellBehavedEditText(Context context, AttributeSet attributes) {
super(context, attributes);
this.initializeWellBehavedEditText(context);
}
public WellBehavedEditText(Context context, AttributeSet attributes, int defStyleAttr) {
super(context, attributes, defStyleAttr);
this.initializeWellBehavedEditText(context);
}
public WellBehavedEditText(Context context, AttributeSet attributes, int defStyleAttr, int defStyleRes) {
super(context, attributes, defStyleAttr, defStyleRes);
this.initializeWellBehavedEditText(context);
}
private void initializeWellBehavedEditText(Context context) {
this.inputMethodManager = (InputMethodManager)context.getSystemService(Context.INPUT_METHOD_SERVICE);
final WellBehavedEditText editText = this;
this.getViewTreeObserver().addOnGlobalLayoutListener(new ViewTreeObserver.OnGlobalLayoutListener() {
@Override
public void onGlobalLayout() {
if(showKeyboard) {
showKeyboard = !(inputMethodManager.showSoftInput(editText, InputMethodManager.SHOW_FORCED));
}
}
});
}
@Override
protected void onFocusChanged(boolean focused, int direction, Rect previouslyFocusedRect) {
if(!focused) this.showKeyboard = false;
super.onFocusChanged(focused, direction, previouslyFocusedRect);
}
@Override
public boolean requestFocus(int direction, Rect previouslyFocusedRect) {
boolean result = super.requestFocus(direction, previouslyFocusedRect);
this.showKeyboard = true;
final WellBehavedEditText self = this;
this.post(new Runnable() {
@Override
public void run() {
showKeyboard = !(inputMethodManager.showSoftInput(self, InputMethodManager.SHOW_FORCED));
}
});
return result;
}
}
void requestFocus(View editText, Activity activity)
{
try {
editText.requestFocus();
InputMethodManager imm = (InputMethodManager) a.getSystemService(Context.INPUT_METHOD_SERVICE);
imm.showSoftInput(editText, InputMethodManager.SHOW_IMPLICIT);
activity.getWindow().setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_STATE_VISIBLE);
} catch (Exception e) {
e.printStackTrace();
}
}
ajoutez cette ligne aussi n'oubliez pas
activity.getWindow().setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_STATE_VISIBLE);
Et pour Kotlin, utilisez simplement ces extensions:
fun EditText.showKeyboard() {
val imm = context.getSystemService(Context.INPUT_METHOD_SERVICE) as InputMethodManager
imm.showSoftInput(this, InputMethodManager.SHOW_IMPLICIT)
}
fun EditText.hideKeyboard() {
val imm = context.getSystemService(Context.INPUT_METHOD_SERVICE) as InputMethodManager
imm.hideSoftInputFromWindow(this.windowToken, 0)
}
J'utilise la minuterie. Le clavier peut montrer quand edittext est focalisé.
edittext = (EditText) findViewById(R.id.edittext );
edittext.requestFocus();
edittext.setFocusableInTouchMode(true);
if (edittext.requestFocus()) {
final Thread timer = new Thread() {
public void run() {
try{
sleep(500);
InputMethodManager imm =(InputMethodManager) getApplicationContext().getSystemService(INPUT_METHOD_SERVICE);
imm.showSoftInput(edittext, SHOW_IMPLICIT);
} catch (Exception e) {
e.printStackTrace();
}
}
};
timer.start();
J'ai créé cette classe d'aide . Il suffit de passer le contexte et la vue sur laquelle vous souhaitez vous concentrer et d'afficher le clavier, puis de masquer le clavier .
public class FocusKeyboardHelper {
private View view;
private Context context;
private InputMethodManager imm;
public FocusKeyboardHelper(Context context, View view){
this.view = view;
this.context = context;
imm = (InputMethodManager) context.getSystemService(context.INPUT_METHOD_SERVICE);
}
public void focusAndShowKeyboard(){
view.requestFocus();
imm.toggleSoftInput(InputMethodManager.SHOW_FORCED, InputMethodManager.HIDE_IMPLICIT_ONLY);
}
public void hideKeyBoard(){
imm.hideSoftInputFromWindow(view.getWindowToken(), 0);
}
}