Ensemble inputType pour un EditText par programmation?

Comment pouvons-nous définir le type d'entrée pour un EditText par programmation? Je suis en train d'essayer:

mEdit.setInputType(InputType.TYPE_TEXT_VARIATION_PASSWORD);

il ne semble pas avoir d'effet.

InformationsquelleAutor user246114 | 2010-04-06

205

Selon la TextView docs, la programmation de la version d'android:le mot de passe est setTransformationMethod(), pas setInputType(). Donc quelque chose comme:
```
mEdit.setTransformationMethod(PasswordTransformationMethod.getInstance());
```
devrait faire l'affaire.
- Juste pour ajouter à cela, vous devez appeler setTransformationMethod lieu de setInputType. L'appel de setInputType après setTransformationMethod provoque l'EditText de ne pas être dans le mot de passe à nouveau en mode.
- cette réponse est fausse pour la question posée. Cela transforme le texte entré dans la EditText (remplace les caractères d'un mot de points). Cela n'a aucun effet sur ce qui est autorisé à être entré dans la EditText lui-même.
- setInputType finalement appels setTransformationMethod de l'intérieur, donc si vous passez par la TYPE_TEXT_VARIATION_PASSWORD à setInputType il va le faire pour vous. Le problème semble ley en appelant setSingleLine après l'appel de setInputType qui feront appel setTransformationMethod avec la valeur null ou l'unique transformateur de ligne ainsi l'effacement du mot de passe du transformateur.
- après appel setTransformationMethod(PasswordTransformationMethod.getInstance())je ne peux pas en mesure de le modifier
- mais le mot de passe s'affichera dans le texte proposé prochaine fois que le champ est utilisé
InformationsquelleAutor rascalking
393

Pour le réglage du type de signal d'entrée pour un EditText par programmation, vous devez indiquer que l'entrée classe est de type texte.
```
editPass.setInputType(InputType.TYPE_CLASS_TEXT | InputType.TYPE_TEXT_VARIATION_PASSWORD);
```
- Votre astuce a fonctionné parfaitement pour moi! J'ai eu un problème similaire avec un programme définissant le type de saisie multiligne.
- Quelle est l'importance d'avoir un opérateur de bits or ici? Désolé, je suis nouveau sur android.
- Je suis en désaccord InputType.TYPE_TEXT_VARIATION_PASSWORD ne fonctionne pas pour moi, mais setTransformationMethod(PasswordTransformationMethod.getInstance()); ne !
InformationsquelleAutor Amitku
27

j'ai de résoudre tous avec
```
.setInputType(InputType.TYPE_CLASS_NUMBER);
```
pour voir effacer les données et
```
.setInputType(InputType.TYPE_CLASS_NUMBER | InputType.TYPE_NUMBER_VARIATION_PASSWORD);
```
pour voir le nombre de points (si les données sont un certain nombre, il n'est pas le choix de la che d'autres classe)

InformationsquelleAutor skinflint

Voici les différents Types d'Entrée comme indiqué sur le clavier standard.

Ensemble inputType pour un EditText par programmation?

Réglage du type d'entrée par programme

editText.setInputType(InputType.TYPE_CLASS_TEXT);

D'autres options en plus TYPE_CLASS_TEXT peut être trouvé dans la la documentation.

Réglage de l'entrée de type XML

<EditText
    android:inputType="text"
/>

D'autres options en plus text peut être trouvé dans la la documentation.

Code supplémentaire

Voici le code de l'image ci-dessus.

public class MainActivity extends AppCompatActivity {
EditText editText;
TextView textView;
List<InputTypeItem> inputTypes;
int counter = 0;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
editText = findViewById(R.id.editText);
textView = findViewById(R.id.textView);
initArray();
}
public void onChangeInputTypeButtonClick(View view) {
if (counter >= inputTypes.size()) {
startOver();
return;
}
textView.setText(inputTypes.get(counter).name);
editText.setInputType(inputTypes.get(counter).value);
editText.setSelection(editText.getText().length());
counter++;
}
private void startOver() {
counter = 0;
textView.setText("");
editText.setInputType(InputType.TYPE_CLASS_TEXT);
InputMethodManager imm = (InputMethodManager)getSystemService(Context.INPUT_METHOD_SERVICE);
imm.hideSoftInputFromWindow(editText.getWindowToken(), 0);
}
private void initArray() {
inputTypes = new ArrayList<>();
inputTypes.add(new InputTypeItem("date",  InputType.TYPE_CLASS_DATETIME | InputType.TYPE_DATETIME_VARIATION_DATE));
inputTypes.add(new InputTypeItem("datetime", InputType.TYPE_CLASS_DATETIME | InputType.TYPE_DATETIME_VARIATION_NORMAL));
inputTypes.add(new InputTypeItem("none", InputType.TYPE_NULL));
inputTypes.add(new InputTypeItem("number",  InputType.TYPE_CLASS_NUMBER | InputType.TYPE_NUMBER_VARIATION_NORMAL));
inputTypes.add(new InputTypeItem("numberDecimal",  InputType.TYPE_CLASS_NUMBER | InputType.TYPE_NUMBER_FLAG_DECIMAL));
inputTypes.add(new InputTypeItem("numberPassword",  InputType.TYPE_CLASS_NUMBER | InputType.TYPE_NUMBER_VARIATION_PASSWORD));
inputTypes.add(new InputTypeItem("numberSigned", InputType.TYPE_CLASS_NUMBER | InputType.TYPE_NUMBER_FLAG_SIGNED));
inputTypes.add(new InputTypeItem("phone",  InputType.TYPE_CLASS_PHONE));
inputTypes.add(new InputTypeItem("text",  InputType.TYPE_CLASS_TEXT | InputType.TYPE_TEXT_VARIATION_NORMAL));
inputTypes.add(new InputTypeItem("textAutoComplete", InputType.TYPE_TEXT_FLAG_AUTO_COMPLETE));
inputTypes.add(new InputTypeItem("textAutoCorrect",  InputType.TYPE_TEXT_FLAG_AUTO_CORRECT));
inputTypes.add(new InputTypeItem("textCapCharacters",  InputType.TYPE_TEXT_FLAG_CAP_CHARACTERS));
inputTypes.add(new InputTypeItem("textCapSentences",  InputType.TYPE_TEXT_FLAG_CAP_SENTENCES));
inputTypes.add(new InputTypeItem("textCapWords",  InputType.TYPE_TEXT_FLAG_CAP_WORDS));
inputTypes.add(new InputTypeItem("textEmailAddress",  InputType.TYPE_CLASS_TEXT | InputType.TYPE_TEXT_VARIATION_EMAIL_ADDRESS));
inputTypes.add(new InputTypeItem("textEmailSubject", InputType.TYPE_CLASS_TEXT | InputType.TYPE_TEXT_VARIATION_EMAIL_SUBJECT));
inputTypes.add(new InputTypeItem("textFilter",  InputType.TYPE_TEXT_FLAG_IME_MULTI_LINE));
inputTypes.add(new InputTypeItem("textLongMessage",  InputType.TYPE_CLASS_TEXT | InputType.TYPE_TEXT_VARIATION_LONG_MESSAGE));
inputTypes.add(new InputTypeItem("textMultiLine",  InputType.TYPE_TEXT_FLAG_MULTI_LINE));
inputTypes.add(new InputTypeItem("textNoSuggestions", InputType.TYPE_TEXT_FLAG_NO_SUGGESTIONS));
inputTypes.add(new InputTypeItem("textPassword",  InputType.TYPE_CLASS_TEXT | InputType.TYPE_TEXT_VARIATION_PASSWORD));
inputTypes.add(new InputTypeItem("textPersonName", InputType.TYPE_CLASS_TEXT | InputType.TYPE_TEXT_VARIATION_PERSON_NAME));
inputTypes.add(new InputTypeItem("textPhonetic",  InputType.TYPE_CLASS_TEXT | InputType.TYPE_TEXT_VARIATION_PHONETIC));
inputTypes.add(new InputTypeItem("textPostalAddress", InputType.TYPE_CLASS_TEXT | InputType.TYPE_TEXT_VARIATION_POSTAL_ADDRESS));
inputTypes.add(new InputTypeItem("textShortMessage", InputType.TYPE_CLASS_TEXT | InputType.TYPE_TEXT_VARIATION_SHORT_MESSAGE));
inputTypes.add(new InputTypeItem("textUri",  InputType.TYPE_CLASS_TEXT | InputType.TYPE_TEXT_VARIATION_URI));
inputTypes.add(new InputTypeItem("textVisiblePassword",  InputType.TYPE_CLASS_TEXT | InputType.TYPE_TEXT_VARIATION_VISIBLE_PASSWORD));
inputTypes.add(new InputTypeItem("textWebEditText",  InputType.TYPE_CLASS_TEXT | InputType.TYPE_TEXT_VARIATION_WEB_EDIT_TEXT));
inputTypes.add(new InputTypeItem("textWebEmailAddress", InputType.TYPE_CLASS_TEXT | InputType.TYPE_TEXT_VARIATION_WEB_EMAIL_ADDRESS));
inputTypes.add(new InputTypeItem("textWebPassword", InputType.TYPE_CLASS_TEXT | InputType.TYPE_TEXT_VARIATION_WEB_PASSWORD));
inputTypes.add(new InputTypeItem("time", InputType.TYPE_CLASS_DATETIME | InputType.TYPE_DATETIME_VARIATION_TIME));
}
class InputTypeItem {
private String name;
private int value;
InputTypeItem(String name, int value) {
this.name = name;
this.value = value;
}
}
}

Voir aussi

L'obtention de l'actuel InputType

InformationsquelleAutor Suragch

Pour autoriser uniquement les numéros:

password1.setInputType(InputType.TYPE_CLASS_TEXT | InputType.TYPE_CLASS_NUMBER);

De transformer (masquer) le mot de passe:

password1.setTransformationMethod(PasswordTransformationMethod.getInstance());

InformationsquelleAutor slinden77

7
```
editText.setInputType(EditorInfo.TYPE_CLASS_NUMBER);
```
//vous pouvez modifier TYPE_... selon votre condition.

InformationsquelleAutor Ajeet
4

Cela peut aider d'autres personnes comme moi qui voulais alterner entre mot de passe et libre-mode texte. J'ai essayé d'utiliser les méthodes de saisie suggéré, mais il n'a travaillé que dans un seul sens. Je pourrais passer de mot de passe pour le texte, mais je ne pouvais pas revenir. Pour ceux qui essaient de gérer une bascule (par exemple, un show case Mot de passe) utilisation
```
       @Override
public void onClick(View v)
{
if(check.isChecked())
{
edit.setTransformationMethod(HideReturnsTransformationMethod.getInstance());
Log.i(TAG, "Show password");
}
else
{
edit.setTransformationMethod(PasswordTransformationMethod.getInstance());
Log.i(TAG, "Hide password");
}
}
```
J'ai du crédit cette pour la solution. J'avais trouvé qu'il y a quelques heures!

InformationsquelleAutor Brian Reinhold

Pour Kotlin:

    val password = EditText(this)
password.inputType = InputType.TYPE_CLASS_TEXT or InputType.TYPE_TEXT_VARIATION_PASSWORD
password.hint = "Password"

InformationsquelleAutor Ronen

0

Essayez d'ajouter ce point à l'EditText/TextView balise dans votre mise en page
```
android:password="true"
```
Edit: je viens de relire votre post, peut-être vous avez besoin de le faire après la construction. Je ne vois pas pourquoi votre extrait de code ne fonctionne pas.
- Je n'ai pas de fichier de mise en page dans ce cas, les champs sont générés par programmation.
- Oui, c'est fait après la construction, vous ne savez pas pourquoi ça ne fonctionne pas non plus!
- cette option maintenant obsolète!!
- cette chose est un seul qui fonctionne pour les vieux android 2.3, j'ai upvoted la réponse.
InformationsquelleAutor Jim Blackler
0

Je sais que la Réponse attendue est en Java . Mais ici, c'est mon 2 cents de conseils toujours d'essayer de traiter afficher des trucs dans XML (au moins un truc de base) je vous suggère plutôt d'utiliser un xml attribut plutôt que de la manipulation de ce cas d'utilisation dans java
```
    <EditText
android:inputType="textPassword"/>
```
- Dans certains cas, vous pouvez basculer entre les différents types d'entrées, par exemple masquage/affichage de mot de passe entré dans un champ; qui est ce que m'a laissé à cette page
- mais pour cela, il existe une option dans EditText qui vous permettra d'afficher/masquer le mot de passe aucun besoin de le faire sur votre propre aussi il donne une belle animation pour que.
- merci pour l'info, je l'ai vu ici stackoverflow.com/a/41163578/3310235
InformationsquelleAutor pratham kesarkar

Cacher:

edtPassword.setInputType(InputType.TYPE_CLASS_TEXT);
edtPassword.setTransformationMethod(null);

Spectacle:

edtPassword.setInputType(InputType.TYPE_TEXT_VARIATION_PASSWORD);                    
edtPassword.setTransformationMethod(PasswordTransformationMethod.getInstance());

InformationsquelleAutor miragessee

0
```
password.setInputType(InputType.TYPE_CLASS_TEXT |
InputType.TYPE_TEXT_VARIATION_PASSWORD);
```
aussi, vous devez être attentif à ce que le curseur se déplace vers le point de départ de l'editText
après cette fonction est appelée, alors assurez-vous que vous déplacez le curseur vers le point de fin de nouveau.

InformationsquelleAutor Vibhanshu Sharma

Pour afficher le mot de passe:

editText.setInputType(
InputType.TYPE_CLASS_TEXT|
InputType.TYPE_TEXT_VARIATION_VISIBLE_PASSWORD
);

Pour masquer le mot de passe de nouveau:

editText.setTransformationMethod(PasswordTransformationMethod.getInstance());

InformationsquelleAutor Alif

Vous devez vous connecter pour publier un commentaire.