Android: affiche automatiquement le clavier logiciel lorsque le focus est sur un EditText


341

Je montre une zone de saisie en utilisant AlertDialog. L' EditTextintérieur de la boîte de dialogue se concentre automatiquement lorsque j'appelle AlertDialog.show(), mais le clavier virtuel n'est pas automatiquement affiché.

Comment afficher automatiquement le clavier virtuel lorsque la boîte de dialogue s'affiche? (et il n'y a pas de clavier physique / matériel). Comme lorsque j'appuie sur le bouton Rechercher pour appeler la recherche globale, le clavier virtuel s'affiche automatiquement.


1
Cela devrait se produire automatiquement, selon le commentaire de Ted ci-dessous. Vérifiez d'abord!
Cheezmeister

Cette réponse est la plus simple et fonctionne très bien: stackoverflow.com/a/8018630/89818
caw


1
Je suis revenu à cette réponse plusieurs fois au fil des ans. C'est toujours dans un dialogue que j'ai des problèmes, jamais un fragment ou une activité.
tir38

Réponses:


305

Vous pouvez créer un auditeur de se concentrer sur le EditTextle AlertDialog, puis obtenir le AlertDialog« s Window. De là, vous pouvez faire apparaître le clavier virtuel en appelant setSoftInputMode.

final AlertDialog dialog = ...;

editText.setOnFocusChangeListener(new View.OnFocusChangeListener() {
    @Override
    public void onFocusChange(View v, boolean hasFocus) {
        if (hasFocus) {
            dialog.getWindow().setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_STATE_ALWAYS_VISIBLE);
        }
    }
});

5
Comment pourrais-je le faire en utilisant AlertDialog.Builder? ... final AlertDialog.Builder alert = new AlertDialog.Builder (Main.this);
Stephen

6
@Stephen vous pouvez obtenir la boîte de dialogue du générateur en utilisant final AlertDialog dialog = builder.create()puis showsur la boîte de dialogue au lieu du générateur.
tidbeck

30
JE RETRACTE MON COMMENTAIRE CI-DESSUS J'ai découvert que si vous ne pouvez pas vous concentrer correctement, jetez un œil à votre XML! Si vous voyez la balise <requestFocus> </requestFocus> là-dedans - supprimez-la. Il semble que la balise donnera le focus à l'EditText, puis votre auditeur ne sera pas renvoyé car l'EditText a déjà le focus.
Ted

11
Comment ne pas faire cela si l'appareil dispose d'un clavier matériel? On dirait que c'est ennuyeux pour ces utilisateurs.
mxcl

8
Je ne comprends vraiment pas pourquoi ce n'est pas le comportement par défaut dans le SDK. Si une vue qui nécessite une saisie de texte affiche un curseur clignotant, pourquoi quelqu'un ne voudrait-il pas voir le clavier pour saisir du texte? Ça me fait tellement mal d'un UX
Christian García

240

Pour afficher l'utilisation du clavier:

InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
imm.toggleSoftInput(InputMethodManager.SHOW_FORCED,0);

Pour masquer l'utilisation du clavier:

InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
imm.hideSoftInputFromWindow(view.getWindowToken(),0); 

3
Cela fonctionne particulièrement bien lorsque vous souhaitez afficher / masquer le clavier virtuel basé sur le basculement de la visibilité d'une vue dans votre mise en page entre VISIBLE et GONE.
PacificSky

38
Je suggérerais d'utiliser le drapeau SHOW_IMPLICIT à la place, car cela signifie que changer d'activité ou d'application masquera automatiquement le clavier comme prévu.
drspaceboo

6
@drspaceboo L'utilisation de SHOW_IMPLICIT ne fonctionne pas du tout pour moi, je dois utiliser SHOW_FORCED, je ne sais pas pourquoi ...
Yoann Hercouet

1
Quand faut-il exécuter le code ci-dessus? J'ai essayé de le faire peu de temps après avoir ajouté ma disposition à son parent. Ça n'a pas marché. Mais si je l'ai fait après la mise en page pendant un certain temps, cela a fonctionné. Y a-t-il donc un rappel qui me dira "Si vous essayez de montrer le clavier maintenant, cela fonctionnera réellement"?
William Jockusch

1
toggleSoftInput (InputMethodManager.SHOW_FORCED, 0) bascule le clavier virtuel. Si vous voulez vous assurer que le clavier apparaît, vous pouvez utiliser imm.showSoftInput (vue, InputMethodManager.SHOW_IMPLICIT) à la place, où vue est la vue qui obtiendra l'entrée.
PJ_Finnegan

111

Vous pouvez demander un clavier logiciel juste après avoir créé la boîte de dialogue (test sur SDK - r20)

// create dialog
final AlertDialog dialog = ...; 

// request keyboard   
dialog.getWindow().setSoftInputMode (WindowManager.LayoutParams.SOFT_INPUT_STATE_ALWAYS_VISIBLE);

Pour tous ceux qui se demandent, cette méthode n'ouvre pas le clavier logiciel lorsqu'un clavier matériel est connecté. Je viens de tester avec un câble USB On-The-Go. Parfait!
13rac1

Cela ne fait rien pour moi.
JohnyTex

Je n'ai pas de clavier matériel. Peut-être configuration (?)
JohnyTex

25

J'ai eu le même problème et l'ai résolu avec le code suivant. Je ne sais pas comment il se comportera sur un téléphone avec clavier matériel.

// TextEdit
final EditText textEdit = new EditText(this);

// Builder
AlertDialog.Builder alert = new AlertDialog.Builder(this);
alert.setTitle("Enter text");
alert.setView(textEdit);

alert.setPositiveButton("Ok", new DialogInterface.OnClickListener() {
    @Override
    public void onClick(DialogInterface dialog, int which) {
        String text = textEdit.getText().toString();
        finish();
    }
});

alert.setNegativeButton("Cancel", new DialogInterface.OnClickListener() {
    @Override
    public void onClick(DialogInterface dialog, int which) {
        finish();
    }
});

// Dialog
AlertDialog dialog = alert.create();
dialog.setOnShowListener(new OnShowListener() {

    @Override
    public void onShow(DialogInterface dialog) {
        InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
        imm.showSoftInput(textEdit, InputMethodManager.SHOW_IMPLICIT);
    }
});

dialog.show();

C'est dans l' API de classe Dialog niveau 8.
tidbeck

doit avoir été retiré plus tard: /
Jacek Kwiecień

@Xylian c'est toujours dans la documentation Dialog.setOnShowListener ()
tidbeck


18
<activity
    ...
    android:windowSoftInputMode="stateVisible" >
</activity>

ou

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

Merci beaucoup mon ami, c'était génial, j'ai utilisé les deux pour résoudre mon problème, j'ai eu une situation où si l'utilisateur est en mode ajout, alors j'ai besoin de montrer le clavier au début de l'activité, et pour le mode de mise à jour, aucun clavier n'était requis par défaut. Donc, dans le manifeste d'activité que j'ai défini stateHiddenet lorsque je détecte que l'utilisateur crée un nouvel élément, j'ai affiché le clavier en utilisant la ligne de code que vous avez mentionnée. :) Encore une fois merci.
PHP Avenger

J'obtiens un message «impossible de résoudre getWindow ()». j'ai essayé de mettre «ça». et d'autres choses avant. je veux obtenir le clavier sans utiliser un edittext, juste en cliquant dans une certaine partie de l'écran.
Androidcoder

1
@Androidcoder, cela fait partie de Activity, alors ajoutez quelque chose comme ((Activity) context).getWindow().....
CoolMind

15

Les extraits de code d'autres réponses fonctionnent, mais il n'est pas toujours évident de les placer dans le code, surtout si vous utilisez un AlertDialog.Builderet avez suivi le didacticiel de dialogue officiel car il n'utilise pas final AlertDialog ...ou alertDialog.show().

alertDialog.getWindow().setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_STATE_ALWAYS_VISIBLE);

Est préférable à

InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
imm.toggleSoftInput(InputMethodManager.SHOW_FORCED,0);

Parce que SOFT_INPUT_STATE_ALWAYS_VISIBLE masquera le clavier si le focus s'éloigne de EditText, où SHOW_FORCED gardera le clavier affiché jusqu'à ce qu'il soit explicitement fermé, même si l'utilisateur retourne à l'écran d'accueil ou affiche les applications récentes.

Vous trouverez ci-dessous le code de travail d'un AlertDialog créé à l'aide d'une mise en page personnalisée avec un EditText défini en XML. Il définit également le clavier pour avoir une touche "go" et lui permet de déclencher le bouton positif.

alert_dialog.xml:

<RelativeLayout
android:id="@+id/dialogRelativeLayout"
xmlns:android="http://schemas.android.com/apk/res/android"
android:layout_width="match_parent"
android:layout_height="wrap_content" >

    <!-- android:imeOptions="actionGo" sets the keyboard to have a "go" key instead of a "new line" key. -->
    <!-- android:inputType="textUri" disables spell check in the EditText and changes the "go" key from a check mark to an arrow. -->
    <EditText
        android:id="@+id/editText"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:layout_marginTop="16dp"
        android:layout_marginLeft="4dp"
        android:layout_marginRight="4dp"
        android:layout_marginBottom="16dp"
        android:imeOptions="actionGo"
        android:inputType="textUri"/>

</RelativeLayout>

AlertDialog.java:

import android.app.Activity;
import android.app.Dialog;
import android.content.DialogInterface;
import android.graphics.drawable.BitmapDrawable;
import android.graphics.drawable.Drawable;
import android.os.Bundle;
import android.support.annotation.NonNull;
import android.support.v4.app.DialogFragment;
import android.support.v7.app.AlertDialog;
import android.support.v7.app.AppCompatDialogFragment;
import android.view.KeyEvent;
import android.view.LayoutInflater;
import android.view.View;
import android.view.WindowManager;
import android.widget.EditText;

public class CreateDialog extends AppCompatDialogFragment {
    // The public interface is used to send information back to the activity that called CreateDialog.
    public interface CreateDialogListener {
        void onCreateDialogCancel(DialogFragment dialog);    
        void onCreateDialogOK(DialogFragment dialog);
    }

    CreateDialogListener mListener;

    // Check to make sure that the activity that called CreateDialog implements both listeners.
    public void onAttach(Activity activity) {
        super.onAttach(activity);
        try {
            mListener = (CreateDialogListener) activity;
        } catch (ClassCastException e) {
            throw new ClassCastException(activity.toString() + " must implement CreateDialogListener.");
        }
    }

    // onCreateDialog requires @NonNull.
    @Override
    @NonNull
    public Dialog onCreateDialog(Bundle savedInstanceState) {
        AlertDialog.Builder alertDialogBuilder = new AlertDialog.Builder(getActivity());
        LayoutInflater customDialogInflater = getActivity().getLayoutInflater();

        // Setup dialogBuilder.
        alertDialogBuilder.setTitle(R.string.title);
        alertDialogBuilder.setView(customDialogInflater.inflate(R.layout.alert_dialog, null));
        alertDialogBuilder.setNegativeButton(R.string.cancel, new DialogInterface.OnClickListener() {
            @Override
            public void onClick(DialogInterface dialog, int which) {
                mListener.onCreateDialogCancel(CreateDialog.this);
            }
        });
        alertDialogBuilder.setPositiveButton(R.string.ok, new DialogInterface.OnClickListener() {
            @Override
            public void onClick(DialogInterface dialog, int which) {
                mListener.onCreateDialogOK(CreateDialog.this);
            }
        });

        // Assign the resulting built dialog to an AlertDialog.
        final AlertDialog alertDialog = alertDialogBuilder.create();

        // Show the keyboard when the dialog is displayed on the screen.
        alertDialog.getWindow().setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_STATE_ALWAYS_VISIBLE);

        // We need to show alertDialog before we can setOnKeyListener below.
        alertDialog.show();

        EditText editText = (EditText) alertDialog.findViewById(R.id.editText);

        // Allow the "enter" key on the keyboard to execute "OK".
        editText.setOnKeyListener(new View.OnKeyListener() {
            public boolean onKey(View v, int keyCode, KeyEvent event) {
                // If the event is a key-down event on the "enter" button, select the PositiveButton "OK".
                if ((event.getAction() == KeyEvent.ACTION_DOWN) && (keyCode == KeyEvent.KEYCODE_ENTER)) {
                    // Trigger the create listener.
                    mListener.onCreateDialogOK(CreateDialog.this);

                    // Manually dismiss alertDialog.
                    alertDialog.dismiss();

                    // Consume the event.
                    return true;
                } else {
                    // If any other key was pressed, do not consume the event.
                    return false;
                }
            }
        });

        // onCreateDialog requires the return of an AlertDialog.
        return alertDialog;
    }
}

11

Eh bien, c'est un assez vieux post, il y a encore quelque chose à ajouter.
Ce sont 2 méthodes simples qui m'aident à garder le clavier sous contrôle et elles fonctionnent parfaitement:

Afficher le clavier

public void showKeyboard() {
    InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
    View v = getCurrentFocus();
    if (v != null)
        imm.showSoftInput(v, 0);
}

Masquer le clavier

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

Qu'est-ce que c'est getCurrentFocus()?
CoolMind

Je vois, c'est une méthode d'un Activity.
CoolMind

10

Permettez-moi de pointer quelques informations supplémentaires sur la solution de yuku, car j'ai eu du mal à faire fonctionner cela! Comment puis-je obtenir l'objet AlertDialog de mon AlertDialog.Builder? Eh bien, c'est le résultat de mon alert.show()exécution:

final AlertDialog.Builder alert = new AlertDialog.Builder(getActivity());
final EditText input = new EditText(getActivity());
alert.setView(input);

// do what you need, like setting positive and negative buttons...

final AlertDialog dialog = alert.show();

input.setOnFocusChangeListener(new OnFocusChangeListener() {
   @Override
   public void onFocusChange(View v, boolean hasFocus) {
      if(hasFocus) {
         dialog.getWindow().setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_STATE_ALWAYS_VISIBLE);
      }
   }
});

7

Jetez un œil à cette discussion qui gère le masquage et l'affichage manuels de l'IME. Cependant, mon sentiment est que si un focus EditTextne fait pas monter l'IME, c'est parce que vous appelez AlertDialog.show()votre OnCreate()ou une autre méthode qui est évoquée avant que l'écran ne soit réellement présenté. Le déplacer OnPostResume()devrait le corriger dans ce cas, je crois.


6

Oui, vous pouvez le faire, setOnFocusChangeListenercela vous aidera.

editText.setOnFocusChangeListener(new View.OnFocusChangeListener() {
    @Override
    public void onFocusChange(View v, boolean hasFocus) {
        if (hasFocus) {
            dialog.getWindow().setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_STATE_ALWAYS_VISIBLE);
        }
    }
});

4

Je sais que cette question est ancienne car je pense que l'utilisation d'une fonction d'extension est un plus joli moyen d'afficher le clavier pour un texte d'édition

voici la méthode que j'utilise pour montrer le clavier pour un edittext.

code kotlin: il suffit d'appeleredittext.showKeyboard()

fun EditText.showKeyboard() {
  post {
    requestFocus()
    val imm = context.getSystemService(Context.INPUT_METHOD_SERVICE) as InputMethodManager
    imm.showSoftInput(this, InputMethodManager.SHOW_IMPLICIT)
  }
}

le code java:

public static void showKeyboard(EditText editText) {
    editText.post(new Runnable() {
      @Override
      public void run() {
        editText.requestFocus();
        InputMethodManager imm = (InputMethodManager) editText.getContext()
            .getSystemService(Context.INPUT_METHOD_SERVICE);
        imm.showSoftInput(editText, InputMethodManager.SHOW_IMPLICIT);
      }
    });
  }

3

Si quelqu'un reçoit:

Impossible de faire une référence statique à la méthode non statique getSystemService (String) du type Activity

Essayez d'ajouter du contexte à l'appel getSystemService.

Alors

InputMethodManager imm = 
(InputMethodManager) context.getSystemService(Context.INPUT_METHOD_SERVICE);
imm.toggleSoftInput(InputMethodManager.SHOW_FORCED,0);

1

La question d'origine concerne les dialogues et mon EditText est sur une vue régulière. Quoi qu'il en soit, je pense que cela devrait aussi fonctionner pour la plupart d'entre vous. Voici donc ce qui fonctionne pour moi (la méthode la plus élevée suggérée ci-dessus n'a rien fait pour moi). Voici un EditView personnalisé qui fait cela (le sous-classement n'est pas nécessaire, mais je l'ai trouvé pratique pour mes besoins car je voulais également saisir le focus lorsque la vue devient visible).

C'est en fait largement le même que la réponse des tidbecks. En fait, je n'ai pas du tout remarqué sa réponse car il n'y avait aucun vote. Ensuite, j'étais sur le point de commenter son post, mais cela aurait été trop long, j'ai donc fini de faire ce post de toute façon. tidbeck souligne qu'il ne sait pas comment cela fonctionne avec les appareils dotés de claviers. Je peux confirmer que le comportement semble être exactement le même dans les deux cas. Cela étant, en mode portrait, le clavier du logiciel apparaît et en paysage, il ne le fait pas. Avoir le clavier physique glissé ou non ne fait aucune différence sur mon téléphone.

Parce que, personnellement, je trouve le comportement un peu bizarre j'ai opté pour l' utilisation: InputMethodManager.SHOW_FORCED. Cela fonctionne comme je le voulais. Le clavier devient visible quelle que soit l'orientation, cependant, au moins sur mon appareil, il ne s'affiche pas si le clavier matériel a été glissé.

import android.app.Service;
import android.content.Context;
import android.util.AttributeSet;
import android.view.View;
import android.view.inputmethod.InputMethodManager;
import android.widget.EditText;

public class BringOutTheSoftInputOnFocusEditTextView extends EditText {

    protected InputMethodManager inputMethodManager;

    public BringOutTheSoftInputOnFocusEditTextView(Context context, AttributeSet attrs, int defStyle) {
        super(context, attrs, defStyle);
        init();
    }

    public BringOutTheSoftInputOnFocusEditTextView(Context context, AttributeSet attrs) {
        super(context, attrs);
        init();
    }

    public BringOutTheSoftInputOnFocusEditTextView(Context context) {
        super(context);
        init();
    }

    private void init() {
        this.inputMethodManager = (InputMethodManager)getContext().getSystemService(Service.INPUT_METHOD_SERVICE);
        this.setOnFocusChangeListener(new View.OnFocusChangeListener() {
            @Override
            public void onFocusChange(View v, boolean hasFocus) {
                if (hasFocus) {
                    BringOutTheSoftInputOnFocusEditTextView.this.inputMethodManager.showSoftInput(BringOutTheSoftInputOnFocusEditTextView.this, InputMethodManager.SHOW_FORCED);
                }
            }
        });
    }

    @Override
    protected void onVisibilityChanged(View changedView, int visibility) {
        super.onVisibilityChanged(changedView, visibility);
        if (visibility == View.VISIBLE) {
            BringOutTheSoftInputOnFocusEditTextView.this.requestFocus();
        }
    }

}

1

Le problème semble être que puisque l'endroit où vous entrez du texte est initialement caché (ou imbriqué ou quelque chose), AlertDialog définit automatiquement le drapeau WindowManager.LayoutParams.FLAG_ALT_FOCUSABLE_IMou WindowManager.LayoutParams.FLAG_NOT_FOCUSABLEpour que les choses ne déclenchent pas une entrée logicielle à afficher.

La façon de résoudre ce problème consiste à ajouter ce qui suit:

(...)
// Create the dialog and show it
Dialog dialog = builder.create()
dialog.show();

// After show (this is important specially if you have a list, a pager or other view that uses a adapter), clear the flags and set the soft input mode
dialog.getWindow().clearFlags(WindowManager.LayoutParams.FLAG_NOT_FOCUSABLE|WindowManager.LayoutParams.FLAG_ALT_FOCUSABLE_IM);
dialog.getWindow().setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_STATE_ALWAYS_VISIBLE);

1

essayez et utilisez:

editText.requestFocus();
InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
imm.toggleSoftInput(InputMethodManager.SHOW_FORCED, InputMethodManager.HIDE_IMPLICIT_ONLY);

1

Pour montrer le clavier, pour moi, je devais faire ce qui suit

Android TextField: définissez le focus + la saisie logicielle par programmation

La solution est essentiellement la suivante

@Override
public void onResume() {
    super.onResume();
    //passwordInput.requestFocus(); <-- that doesn't work
    passwordInput.postDelayed(new ShowKeyboard(), 325); //250 sometimes doesn't run if returning from LockScreen
}

ShowKeyboardest

private class ShowKeyboard implements Runnable {
    @Override
    public void run() {
        passwordInput.setFocusableInTouchMode(true);
        //passwordInput.requestFocusFromTouch(); //this gives touch event to launcher in background -_-
        passwordInput.requestFocus();
        getActivity().getWindow().setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_STATE_ALWAYS_VISIBLE);
        ((InputMethodManager) getActivity().getSystemService(Context.INPUT_METHOD_SERVICE)).showSoftInput(passwordInput, 0);
    }
}

Après une entrée réussie, je m'assure également de cacher le clavier

getActivity().getWindow().setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_STATE_HIDDEN);
((InputMethodManager) getActivity().getSystemService(Context.INPUT_METHOD_SERVICE))
                    .hideSoftInputFromWindow(getView().getWindowToken(), 0);

1

Mettez ces méthodes dans votre classe Util et utilisez-les n'importe où.

Kotlin

fun hideKeyboard(activity: Activity) {
    val view = activity.currentFocus
    val methodManager = activity.getSystemService(Context.INPUT_METHOD_SERVICE) as InputMethodManager
    assert(view != null)
    methodManager.hideSoftInputFromWindow(view!!.windowToken, InputMethodManager.HIDE_NOT_ALWAYS)
}

private fun showKeyboard(activity: Activity) {
    val view = activity.currentFocus
    val methodManager = activity.getSystemService(Context.INPUT_METHOD_SERVICE) as InputMethodManager
    assert(view != null)
    methodManager.showSoftInput(view, InputMethodManager.SHOW_IMPLICIT)
}

Java

public static void hideKeyboard(Activity activity) {
    View view = activity.getCurrentFocus();
    InputMethodManager methodManager = (InputMethodManager) activity.getSystemService(Context.INPUT_METHOD_SERVICE);
    assert methodManager != null && view != null;
    methodManager.hideSoftInputFromWindow(view.getWindowToken(), InputMethodManager.HIDE_NOT_ALWAYS);
}

private static void showKeyboard(Activity activity) {
    View view = activity.getCurrentFocus();
    InputMethodManager methodManager = (InputMethodManager) activity.getSystemService(Context.INPUT_METHOD_SERVICE);
    assert methodManager != null && view != null;
    methodManager.showSoftInput(view, InputMethodManager.SHOW_IMPLICIT);
}

1

J'ai créé de jolies fonctions d'extension kotlin-esqe au cas où quiconque serait intéressé

fun Activity.hideKeyBoard() {
    val view = this.currentFocus
    val methodManager = this.getSystemService(Context.INPUT_METHOD_SERVICE) as InputMethodManager
    assert(view != null)
    methodManager.hideSoftInputFromWindow(view!!.windowToken, InputMethodManager.HIDE_NOT_ALWAYS)
}

fun Activity.showKeyboard() {
    val view = this.currentFocus
    val methodManager = this.getSystemService(Context.INPUT_METHOD_SERVICE) as InputMethodManager
    assert(view != null)
    methodManager.showSoftInput(view, InputMethodManager.SHOW_IMPLICIT)
}

0

C'est un bon échantillon pour vous:

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="vertical" >

    <ScrollView
        android:id="@+id/scrollID"
        android:layout_width="fill_parent"
        android:layout_height="0dip"
        android:layout_weight="1" >

        <LinearLayout
            android:id="@+id/test"
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:orientation="vertical" >
        </LinearLayout>
    </ScrollView>

    <LinearLayout
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:baselineAligned="true"
        android:orientation="horizontal"
        android:paddingBottom="5dp"
        android:paddingLeft="5dp"
        android:paddingRight="5dp"
        android:weightSum="1" >

        <EditText
            android:id="@+id/txtInpuConversation"
            android:layout_width="0dip"
            android:layout_height="wrap_content"
            android:layout_weight="0.5"
            android:hint="@string/edt_Conversation" >

            <requestFocus />
        </EditText>

        <Button
            android:id="@+id/btnSend"
            android:layout_width="0dip"
            android:layout_height="wrap_content"
            android:layout_weight="0.5"
            android:text="@string/btn_Conversation" />
    </LinearLayout>

</LinearLayout>

0

Pourquoi cette réponse - Parce que la solution ci-dessus montrera votre clavier mais elle ne disparaîtra pas si vous cliquez ailleurs EditText. Vous devez donc faire quelque chose pour faire disparaître le clavier lorsque vous perdez le EditTextfocus.

Vous pouvez y parvenir en procédant comme suit:

  1. Rendre la vue parent (vue de contenu de votre activité) cliquable et focalisable en ajoutant les attributs suivants

        android:clickable="true" 
        android:focusableInTouchMode="true" 
  2. Implémenter une méthode hideKeyboard ()

        public void hideKeyboard(View view) {
            InputMethodManager inputMethodManager =(InputMethodManager)getSystemService(Activity.INPUT_METHOD_SERVICE);
            inputMethodManager.hideSoftInputFromWindow(view.getWindowToken(),InputMethodManager.HIDE_IMPLICIT_ONLY );
        }
  3. Enfin, définissez le onFocusChangeListener de votre edittext.

        edittext.setOnFocusChangeListener(new View.OnFocusChangeListener() {
            @Override
            public void onFocusChange(View v, boolean hasFocus) {
                if (!hasFocus) {
                    hideKeyboard(v);
                }
            }
        });

0

C'est un peu délicat. Je l'ai fait de cette façon et cela a fonctionné.

1.Au premier appel pour masquer l'entrée logicielle de la fenêtre. Cela masquera l'entrée logicielle si le clavier logiciel est visible ou ne fera rien s'il ne l'est pas.

2.Affichez votre dialogue

3.Appelez ensuite simplement pour basculer la saisie logicielle.

code:

InputMethodManager inputManager = (InputMethodManager)getSystemService(Context.INPUT_METHOD_SERVICE); 
//hiding soft input
inputManager.hideSoftInputFromWindow(findViewById(android.R.id.content).getWind‌​owToken(), 0);
//show dialog
yourDialog.show();
//toggle soft input
inputManager.toggleSoftInput(InputMethodManager.SHOW_FORCED,InputMethodManager.SHOW_IMPLICIT);

0

Essaye ça

SomeUtils.java

public static void showKeyboard(Activity activity, boolean show) {
    InputMethodManager inputMethodManager = (InputMethodManager) activity.getSystemService(Context.INPUT_METHOD_SERVICE);

    if(show)
        inputMethodManager.toggleSoftInput(InputMethodManager.SHOW_FORCED,0);
    else
        inputMethodManager.toggleSoftInput(InputMethodManager.HIDE_IMPLICIT_ONLY,0);
}

0

J'ai essayé beaucoup mais c'est ce qui a fonctionné pour moi (kotlin):

        val dialog = builder.create()
        dialog.setOnShowListener {
            nameEditText.requestFocus()
            val s = ContextCompat.getSystemService(requireContext(), InputMethodManager::class.java)
            s?.toggleSoftInput(InputMethodManager.SHOW_FORCED, 0)
        }

        dialog.setOnDismissListener {
            val s = ContextCompat.getSystemService(requireContext(), InputMethodManager::class.java)
            s?.toggleSoftInput(InputMethodManager.HIDE_IMPLICIT_ONLY, 0)
        }

        dialog.show()

0

En regardant https://stackoverflow.com/a/39144104/2914140 j'ai simplifié un peu:

// In onCreateView():
view.edit_text.run {
    requestFocus()
    post { showKeyboard(this) }
}

fun showKeyboard(view: View) {
    val imm = view.context.getSystemService(
        Context.INPUT_METHOD_SERVICE) as InputMethodManager?
    imm?.showSoftInput(view, InputMethodManager.SHOW_IMPLICIT)
}

C'est mieux que https://stackoverflow.com/a/11155404/2914140 :

InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
imm.toggleSoftInput(InputMethodManager.SHOW_FORCED, 0);

car lorsque vous appuyez sur le bouton Accueil et passez à l'écran d'accueil, le clavier reste ouvert.


-1
getWindow().setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_STATE_ALWAYS_VISIBLE);

J'appelle cela dans onCreate () pour afficher automatiquement le clavier lorsque je suis entré dans l'activité.

En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.