web-dev-qa-db-fra.com

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

Je montre une zone de saisie en utilisant AlertDialog. La EditText de la boîte de dialogue elle-même est automatiquement activée lorsque j'appelle AlertDialog.show(), mais le clavier virtuel n'est pas affiché automatiquement.

Comment faire en sorte que le clavier logiciel s'affiche automatiquement lorsque la boîte de dialogue est affichée? (et il n'y a pas de clavier physique/matériel). De la même manière que lorsque j'appuie sur le bouton Rechercher pour lancer la recherche globale, le clavier virtuel est automatiquement affiché.

androidkeyboardandroid-edittextsoft-keyboard
304
Randy Sugianto 'Yuku'

Vous pouvez créer un écouteur de focus sur la EditText sur la AlertDialog, puis obtenir la AlertDialog's Window. À partir de là, vous pouvez afficher 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);
        }
    }
});
288
Randy Sugianto 'Yuku'

Pour montrer 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);
207
horkavlna

Vous pouvez demander un clavier logiciel juste après la création de 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);
105
Bao Le

J'ai eu le même problème et l'ai résolu avec le code suivant. Je ne sais pas comment cela se comportera sur un téléphone doté d'un 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();
24
tidbeck

J'ai trouvé cet exemple http://Android-codes-examples.blogspot.com/2011/11/show-or-hide-soft-keyboard-on-opening.html . Ajoutez le code suivant juste avant alert.show().

InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
imm.toggleSoftInput(InputMethodManager.SHOW_FORCED,0);
22
Jurie Otto
<activity
    ...
    Android:windowSoftInputMode="stateVisible" >
</activity>

ou

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

Des extraits de code provenant d’autres réponses fonctionnent, mais il n’est pas toujours évident de les placer dans le code, en particulier si vous utilisez un AlertDialog.Builder et suivez le tutoriel de dialogue officiel car il n’utilise pas final AlertDialog ... ni 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 est abandonné par EditText, où SHOW_FORCED maintiendra le clavier affiché jusqu'à ce qu'il soit explicitement ignoré, même si l'utilisateur revient à 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 présentation personnalisée avec un EditText défini en XML. Il configure également le clavier pour avoir une touche "aller" 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;
    }
}
13
Soren Stoutner

Eh bien, c’est un très vieux billet, il ya encore quelque chose à ajouter.
Voici deux méthodes simples qui m'aident à garder le clavier sous contrôle et qui 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);
}
9
sberezin

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

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

Jetez un coup d'œil à this discussion qui gère la dissimulation manuelle et l'affichage de l'IME. Cependant, j’ai le sentiment que si une EditText focalisée n’amène pas l’IME, c’est parce que vous appelez AlertDialog.show() dans votre OnCreate() ou une autre méthode évoquée avant que l’écran ne soit réellement présenté. Le déplacer vers OnPostResume() devrait résoudre le problème dans ce cas, je crois.

7
jqpubliq

Oui, vous pouvez faire avec setOnFocusChangeListener cela 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);
        }
    }
});
5
Sachin Surjan

Si quelqu'un devient:

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

Essayez d'ajouter context à l'appel getSystemService.

Alors

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

essayez et utilisez:

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

J'ai créé les fonctions d'extension Nice kotlin-esqe au cas où tout le monde 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)
}
1
i am E

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

Android TextField: définir le focus + entrée logicielle par programme

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
}

Où ShowKeyboard est

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 saisie 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
EpicPandaForce

Le problème semble être que, puisque l'emplacement où vous saisissez le texte est initialement masqué (ou imbriqué ou quelque chose de ce genre), AlertDialog définit automatiquement l'indicateur WindowManager.LayoutParams.FLAG_ALT_FOCUSABLE_IM ou WindowManager.LayoutParams.FLAG_NOT_FOCUSABLE afin que rien ne déclenche l'affichage d'une entrée souple.

Pour résoudre ce problème, il faut 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
Allan Veloso

La question initiale concerne les boîtes de dialogue et mon EditText est affiché régulièrement. Quoi qu'il en soit, je pense que cela devrait également fonctionner pour la plupart d'entre vous. Alors, voici ce qui fonctionne pour moi (la méthode la mieux notée suggérée ci-dessus ne m'a rien donné). 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 capturer le focus lorsque la vue devient visible).

C'est en fait en grande partie la même chose que la réponse de tidbeck. En fait, je n'ai pas du tout remarqué sa réponse car il y avait zéro vote. Ensuite, j'étais sur le point de commenter son post, mais comme cela aurait été trop long, j'ai fini par le faire de toute façon. Tidbeck fait remarquer 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 tel qu'en mode portrait, le clavier logiciel est affiché et en mode paysage, ce n'est pas le cas. Que le clavier physique soit sorti ou non ne change rien à mon téléphone.

Personnellement, j’ai trouvé le comportement un peu gênant et j’ai opté pour: 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é retiré.

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
Timo

Pourquoi cette réponse - Parce que la solution ci-dessus montrera votre clavier mais ne disparaîtra pas si vous cliquez n'importe où ailleurs que EditText. Vous devez donc faire quelque chose pour que le clavier disparaisse lorsque EditText perd le focus.

Vous pouvez y parvenir en procédant comme suit:

  1. Rendre la vue parent (vue du 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 onFocusChangeListener de votre edittext.

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

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
lorenzo

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

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
GameBug

Je sais que cette question est ancienne de, je pense que l'utilisation d'une fonction d'extension est un moyen plus joli de montrer le clavier pour un texte édité

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

code kotlin: juste besoin d'appeler edittext.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);
      }
    });
  }
0
A.easazadeh

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

1. Au premier appel, masquez l'entrée logicielle de la fenêtre. Cela masquera l'entrée logicielle si le clavier logiciel est visible ou ne fait rien si ce n'est pas le cas.

2. Affichez votre dialogue

3.Puis appelez simplement pour basculer l'entrée 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
FRR

Comme horkavlna a écrit, 

bascule

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

et masquer clavier

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

les méthodes fonctionnent. Mais les variantes show ne fonctionnent pas dans mon cas. Donc dans onCreate() je mets hideKeyboard(editText); puis dans onStart() j'écris toggleKeyboard(editText); et dans onStop() j'écris hideKeyboard(editText);.

Il y a trois problèmes: 

1) lorsqu'une application démarre avec l'écran éteint, le clavier est masqué, 

2) chaque fois que vous allumez l'écran, il affichera le clavier, 

3) une fois l'application terminée, vous pouvez voir le clavier sur l'écran principal d'Android.

Après plusieurs tests, j'ai supprimé ces méthodes et dans AndroidManifest dans les balises activity, j'ai écrit Android:windowSoftInputMode="stateVisible" ou Android:windowSoftInputMode="stateAlwaysHidden".

0
CoolMind

C'est 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
A.A