lorsque l'activité se lance, il semble que le clavier soit initialement affiché mais caché par quelque chose d'autre, parce que les travaux suivants (mais est en fait un sale tour):

Première Méthode

InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
editText.postDelayed(new Runnable()
{
    @Override
    public void run()
    {
        editText.requestFocus();
        imm.showSoftInput(editText, 0);
    }
}, 100);

deuxième méthode

dans le onCreate de la lancer sur l'activité de créer des

new Handler().postDelayed(new Runnable() {
    @Override
    public void run() 
    {
    //  InputMethodManager inputMethodManager=(InputMethodManager)getSystemService(Context.INPUT_METHOD_SERVICE);
    //    inputMethodManager.toggleSoftInputFromWindow(EnterYourViewHere.getApplicationWindowToken(), InputMethodManager.SHOW_FORCED, 0);

        if (inputMethodManager != null)
        {
            inputMethodManager.toggleSoftInput(InputMethodManager.SHOW_FORCED,0);
        } 
    }
}, 200);

Troisième Méthode AJOUTER donné code à étiquette d'activité dans le Manifeste. Il affichera le clavier au lancement, et définira le premier focus à votre vue de désir.

android:windowSoftInputMode="stateVisible"

Hey j'espère que vous êtes toujours à la recherche de la réponse comme je l'ai trouvé en testant mon code. voici le code:

InputMethodManager imm = (InputMethodManager)_context.getSystemService(Context.INPUT_METHOD_SERVICE);

imm.toggleSoftInput(0, 0);

voici ma question à laquelle on a répondu: android - show clavier souple à la demande

cela a fonctionné avec moi sur un téléphone avec clavier dur:

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

cette réponse peut-être tardive mais elle fonctionne parfaitement pour moi. Peut-être que ça aide quelqu'un :)

public void showSoftKeyboard(View view) {
    if (view.requestFocus()) {
        InputMethodManager imm = (InputMethodManager)
                getSystemService(Context.INPUT_METHOD_SERVICE);
        boolean isShowing = imm.showSoftInput(view, InputMethodManager.SHOW_IMPLICIT);
        if (!isShowing)
            getWindow().setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_STATE_VISIBLE);
    }
}

dépend de vos besoins, vous pouvez utiliser d'autres drapeaux

InputMethodManager.SHOW_FORCED
WindowManager.LayoutParams.SOFT_INPUT_STATE_ALWAYS_VISIBLE);

affichage du clavier souple est un gros problème. J'ai cherché beaucoup pour en arriver à une conclusion finale. Grâce à cette réponse qui a donné un certain nombre d'indices: https://stackoverflow.com/a/16882749/5903344

problème:

Normalement nous appelons showSoftInput dès que nous initialisons les vues. Dans les activités, il s'agit le plus souvent en oncréation, en Fragments ou en visionnage. Pour afficher le clavier, IMM doit: avoir la vue focsedView active. Ceci peut être vérifié en utilisant la méthode isActive(view) de IMM. Si nous appelons showSoftInput pendant que les vues sont créées, il y a de bonnes chances que la vue ne soit pas active pour IMM. C'est la raison pour laquelle parfois un showSoftInput différé de 50-100 ms est utile. Cependant, cela ne garantit pas encore qu'après 100 ms la vue deviendra active. Donc, dans ma compréhension, c'est encore un hack.

Solution:

j'utilise la classe suivante. Cela continue à fonctionner tous les 100 ms jusqu'à ce que le clavier ait été montré avec succès. Il effectue divers contrôles à chaque itération. Certaines vérifications peuvent arrêter le runnable, d'autres le postent après 100 ms.

public class KeyboardRunnable extends Runnable
{
    // ----------------------- Constants ----------------------- //
    private static final String TAG = "KEYBOARD_RUNNABLE";

    // Runnable Interval
    private static final int INTERVAL_MS = 100;

    // ----------------------- Classes ---------------------------//
    // ----------------------- Interfaces ----------------------- //
    // ----------------------- Globals ----------------------- //
    private Activity parentActivity = null;
    private View targetView = null;

    // ----------------------- Constructor ----------------------- //
    public KeyboardRunnable(Activity parentActivity, View targetView)
    {
        this.parentActivity = parentActivity;
        this.targetView = targetView;
    }

    // ----------------------- Overrides ----------------------- //
    @Override
    public void run()
    {
        // Validate Params
        if ((parentActivity == null) || (targetView == null))
        {
            Dbg.error(TAG, "Invalid Params");
            return;
        }

        // Get Input Method Manager
        InputMethodManager imm = (InputMethodManager) parentActivity.getSystemService(Context.INPUT_METHOD_SERVICE);

        // Check view is focusable
        if (!(targetView.isFocusable() && targetView.isFocusableInTouchMode()))
        {
            Dbg.error(TAG, "Non focusable view");
            return;
        }
        // Try focusing
        else if (!targetView.requestFocus())
        {
            Dbg.error(TAG, "Cannot focus on view");
            Post();
        }
        // Check if Imm is active with this view
        else if (!imm.isActive(targetView))
        {
            Dbg.error(TAG, "IMM is not active");
            Post();
        }
        // Show Keyboard
       else if (!imm.showSoftInput(targetView, InputMethodManager.SHOW_IMPLICIT))
        {
            Dbg.error(TAG, "Unable to show keyboard");
            Post();
        }
    }

    // ----------------------- Public APIs ----------------------- //
    public static void Hide(Activity parentActivity)
    {
        if (parentActivity != null)
        {
            InputMethodManager imm = (InputMethodManager) parentActivity.getSystemService(Context.INPUT_METHOD_SERVICE);
            imm.hideSoftInputFromWindow(parentActivity.findViewById(android.R.id.content).getWindowToken(), 0);
        }
        else
        {
            Dbg.error(TAG, "Invalid params to hide keyboard");
        }
    }

    // ----------------------- Private APIs ----------------------- //
    protected void Post()
    {
        // Post this aftr 100 ms
        handler.postDelayed(this, INTERVAL_MS);
    }
}

pour utiliser ceci, créez simplement une instance de cette classe. Transmettez-lui l'activité mère et targetView qui auraient ensuite une entrée clavier et une mise au point. Ensuite, postez l'instance en utilisant un Handler.

mon code contenait la bascule, mais pas postDelayed. J'avais essayé postDelayed pour les showSoftInput sans succès et j'ai depuis essayé votre solution suggérée. J'étais sur le point de le rejeter comme une autre solution potentielle ratée jusqu'à ce que je décide d'augmenter le délai. Il fonctionne pour moi jusqu'à 200 ms à quel point ça ne fonctionne pas, du moins pas sur les téléphones physiques. Donc, avant que vous pauvres Développeurs android jeter cette réponse, essayer d'augmenter le délai pour un succès solution. Il peut payer pour ajouter un peu pour les anciens ralentissement de téléphones. Grâce tas, a été de travailler sur celui-ci pendant des heures.

ça marche pour moi:

public void requestFocusAndShowSoftInput(View view){
    view.requestFocus();
    InputMethodManager inputMethodManager = (InputMethodManager) getSystemService(INPUT_METHOD_SERVICE);
    inputMethodManager.showSoftInput(view, InputMethodManager.SHOW_IMPLICIT);
}

Solution pour les développeurs Xamarin (_digit1 == EditText):

        var focussed = _digit1.RequestFocus();
        if (focussed)
        {
            Window.SetSoftInputMode(SoftInput.StateAlwaysVisible);
            var imm = (InputMethodManager)GetSystemService(InputMethodService);
            imm.ToggleSoftInput(ShowFlags.Forced, 0);
        }