web-dev-qa-db-fra.com

Modifier par programme le type d'entrée de EditText de PASSWORD à NORMAL et vice versa

Dans mon application, j'ai un EditText dont le type d'entrée par défaut est défini sur Android:inputType="textPassword" par deault. Il a un CheckBox à sa droite, ce qui, une fois coché, change le type d'entrée de cet EditText en NORMAL PLAIN TEXT. Le code pour cela est

password.setInputType(InputType.TYPE_TEXT_VARIATION_VISIBLE_PASSWORD);

Mon problème est que, lorsque cette case à cocher n'est pas cochée, il faut à nouveau définir le type d'entrée sur PASSWORD. Je l'ai fait en utilisant-

password.setInputType(InputType.TYPE_TEXT_VARIATION_PASSWORD);

Mais, le texte à l'intérieur de cet edittext est toujours visible. Et par surprise, lorsque je change d’orienatation, le type de saisie est automatiquement défini sur PASSWORD et le texte à l’intérieur est marqué d’une puce (affiché comme un mot de passe).

Un moyen d'y parvenir?

androidpasswordsandroid-edittext
173
Rajkiran

Juste pour les personnes qui ont le même problème. Ajoutez simplement un attribut supplémentaire à cet EditText par programme et vous avez terminé.

password.setInputType(InputType.TYPE_CLASS_TEXT |
    InputType.TYPE_TEXT_VARIATION_PASSWORD);

Assurez-vous également que le curseur se trouve à la fin du texte dans le texte d'édition. En effet, lorsque vous modifiez le type d'entrée, le curseur se positionne automatiquement sur le point de départ. Je suggère donc d'utiliser le code suivant:

et_password.setInputType(InputType.TYPE_CLASS_TEXT | 
    InputType.TYPE_TEXT_VARIATION_PASSWORD);
et_password.setSelection(et_password.getText().length());

Lorsque vous utilisez la liaison de données, vous pouvez utiliser le code suivant

<data>
        <import type="Android.text.InputType"/>
.
.
.
<EditText
Android:inputType='@{someViewModel.isMasked ? 
(InputType.TYPE_CLASS_TEXT | InputType.TYPE_TEXT_VARIATION_PASSWORD) :
InputType.TYPE_CLASS_TEXT }'

Si vous utilisez Kotlin,

password.inputType = InputType.TYPE_CLASS_TEXT or InputType.TYPE_TEXT_VARIATION_PASSWORD
303
Rajkiran

utilisez ce code pour changer le mot de passe en texte et vice versa

mCbShowPwd.setOnCheckedChangeListener(new OnCheckedChangeListener() {

            public void onCheckedChanged(CompoundButton buttonView, boolean isChecked) {
                // checkbox status is changed from uncheck to checked.
                if (!isChecked) {
                        // hide password
                    mEtPwd.setTransformationMethod(PasswordTransformationMethod.getInstance());
                } else {
                        // show password
                    mEtPwd.setTransformationMethod(HideReturnsTransformationMethod.getInstance());
                }
            }
        });

pour obtenir un exemple complet de code, reportez-vous à http://www.codeproject.com/Tips/518641/Show-hide-password-in-a-edit-text-view-password-ty

56
neeraj t
password.setInputType(InputType.TYPE_CLASS_TEXT | inputType.TYPE_TEXT_VARIATION_PASSWORD);

La méthode ci-dessus n'a pas vraiment fonctionné pour moi. La réponse ci-dessous fonctionne pour 2.2 sdk.

password.setTransformationMethod (PasswordTransformationMethod.getInstance ());

Définit inputType pour un EditText?

15
ymutlu

Un autre exemple simple utilisant ImageView pour basculer la visibilité avec moins de code, en raison de l'unique InputType, nous n'avons besoin que de l'opérateur d'égalité:

EditText inputPassword = (EditText) findViewById(R.id.loginPassword);
ImageView inputPasswordShow = (ImageView) findViewById(R.id.imagePasswordShow);
inputPasswordShow.setOnClickListener(new View.OnClickListener() {
     @Override
     public void onClick(View view) {
         if(inputPassword.getInputType() == InputType.TYPE_TEXT_VARIATION_VISIBLE_PASSWORD) {
              inputPassword.setInputType( InputType.TYPE_CLASS_TEXT |
                                        InputType.TYPE_TEXT_VARIATION_PASSWORD);
         }else {
              inputPassword.setInputType( InputType.TYPE_TEXT_VARIATION_VISIBLE_PASSWORD );
         }
         inputPassword.setSelection(inputPassword.getText().length());
    }
});

Remplacement:

InputType.TYPE_TEXT_VARIATION_VISIBLE_PASSWORD

Avec :

InputType.TYPE_CLASS_TEXT

Donnera le même résultat mais Word plus court.

12
Roman Polen.
Checkbox.setOnCheckedChangeListener(new OnCheckedChangeListener() {

            public void onCheckedChanged(CompoundButton buttonView, boolean isChecked) {
                // checkbox status is checked.
                if (isChecked) {
                        //password is visible
 PasswordField.setTransformationMethod(HideReturnsTransformationMethod.getInstance());     
                } else {
                        //password gets hided
             passwordField.setTransformationMethod(PasswordTransformationMethod.getInstance());       
                }
            }
        });
11
G murali Madhav

Ok, donc après des heures d’essai a finalement été mis en œuvre. Ci-dessous le code ..

  buttons.get(2).setOnClickListener(new OnClickListener() {
    @Override
    public void onClick(View view) {
       if(buttons.get(2).getText().toString().equalsIgnoreCase(getResources().getString(R.string.show))){
           editTexts.get(1).setInputType(InputType.TYPE_CLASS_TEXT);
           editTexts.get(1).setSelection(editTexts.get(1).getText().length());
           buttons.get(2).setText(getResources().getString(R.string.hide));
        }else{
           editTexts.get(1).setInputType(InputType.TYPE_CLASS_TEXT|InputType.TYPE_TEXT_VARIATION_PASSWORD);
           //editTexts.get(1).setTransformationMethod(PasswordTransformationMethod.getInstance());
           editTexts.get(1).setSelection(editTexts.get(1).getText().length());
           buttons.get(2).setText(getResources().getString(R.string.show));
       }

    }
});

Explications: - J'ai un bouton avec le texte par défaut comme show. Après l'événement onclick, vérifiez si le texte du bouton est affiché. S'il est affiché, changez le type d'entrée, ajustez la position du curseur et définissez le nouveau texte comme masqué.

Quand il est caché ... faire l’inverse, c’est-à-dire cacher le mot de passe, ajuster le curseur et définir le texte comme indiqué. Et c'est tout. Cela fonctionne comme un charme.

6
Debasish Ghosh

Cela a fonctionné pour moi:

mytext.setInputType(InputType.TYPE_CLASS_NUMBER);
5
mav_baumer15

Utilisez ce code pour changer le mot de passe en texte et vice versa. Ce code a parfaitement fonctionné pour moi. Essaye ça..

EditText paswrd=(EditText)view.findViewById(R.id.paswrd);

CheckBox showpass=(CheckBox)view.findViewById(R.id.showpass);
showpass.setOnClickListener(new OnClickListener() {

@Override
public void onClick(View v) {
    if(((CheckBox)v).isChecked()){
        paswrd.setInputType(InputType.TYPE_CLASS_TEXT);

    }else{
        paswrd.setInputType(InputType.TYPE_CLASS_TEXT|InputType.TYPE_TEXT_VARIATION_PASSWORD);
    }

}
});
5
Surya

Pour les utilisateurs de kotlin:

password.inputType = InputType.TYPE_CLASS_TEXT or InputType.TYPE_TEXT_VARIATION_PASSWORD
5
Elisabeth Whiteley

Il s'agit du gestionnaire onClick complet de l'image/du bouton pour afficher/masquer le mot de passe.

    new OnClickListener() {
        @Override
        public void onClick(View v) {
            // current ursor position
            int cursorPosition = edtPassword.getSelectionStart();

            // toggles the control variable
            isPassworsVisible = !isPassworsVisible;

            // sets the image toggler inside edit text
            passwordVisible.setImageDrawable(getResources().getDrawable(isPassworsVisible ? R.drawable.ic_eye_checked : R.drawable.ic_eye_unchecked));

            // apply input type
            edtPassword.setInputType(isPassworsVisible ? InputType.TYPE_TEXT_VARIATION_VISIBLE_PASSWORD : InputType.TYPE_CLASS_TEXT | InputType.TYPE_TEXT_VARIATION_PASSWORD);

            // returns cursor to position
            edtPassword.setSelection(cursorPosition);
        }
    };
3
Everton Fernandes Rosario

La fonctionnalité Basculer la visibilité du mot de passe a été ajoutée pour prendre en charge la version de bibliothèque 24.2.0, vous permettant de basculer le mot de passe directement à partir de la variable EditText sans nécessiter de CheckBox.

Pour ce faire, vous pouvez essentiellement mettre à jour votre version de bibliothèque de support vers 24.2.0, puis définir un inputType de mot de passe sur TextInputEditText. Voici comment faire cela:

<Android.support.design.widget.TextInputLayout
        Android:layout_width="match_parent"
        Android:layout_height="wrap_content">

        <Android.support.design.widget.TextInputEditText
            Android:layout_width="match_parent"
            Android:layout_height="wrap_content"
            Android:hint="@string/password"
            Android:inputType="textPassword"/>
</Android.support.design.widget.TextInputLayout>

Vous pouvez obtenir plus d'informations sur la nouvelle fonctionnalité de la documentation pour développeurs de TextInputLayout .

3
moyheen

Depuis la bibliothèque de support v24.2.0. vous pouvez réaliser cela très facilement

Ce que vous devez faire c'est juste:

  1. Ajoutez la bibliothèque de conception à vos dépendances

    dependencies {
     compile "com.Android.support:design:25.1.0"
}

  2. Utilisez TextInputEditText avec TextInputLayout

    <Android.support.design.widget.TextInputLayout
    Android:id="@+id/etPasswordLayout"
    Android:layout_width="match_parent"
    Android:layout_height="wrap_content"
    app:passwordToggleEnabled="true">

    <Android.support.design.widget.TextInputEditText
        Android:id="@+id/etPassword"
        Android:layout_width="match_parent"
        Android:layout_height="wrap_content"
        Android:hint="@string/password_hint"
        Android:inputType="textPassword"/>
</Android.support.design.widget.TextInputLayout>

L'attribut passwordToggleEnabled fera apparaître le basculement du mot de passe

  1. Dans votre mise en page racine, n'oubliez pas d'ajouter xmlns:app="http://schemas.Android.com/apk/res-auto"

  2. Vous pouvez personnaliser votre bascule de mot de passe en utilisant:

app:passwordToggleDrawable - Peut être utilisé comme icône de bascule de visibilité de saisie du mot de passe.
app:passwordToggleTint - Icône à utiliser pour la bascule de visibilité d'entrée de mot de passe.
app:passwordToggleTintMode - Mode de fusion utilisé pour appliquer la teinte de fond.

Plus de détails dans documentation TextInputLayout . enter image description here

3
Javier Vieira

Ma recherche d'une solution similaire pour Visual Studio/Xamarin m'a conduit à ce fil. Voici ce qui a fonctionné pour moi avec Xamarin. Notez que cette implémentation conserve l'indicateur TYPE_TEXT_FLAG_NO_SUGGESTIONS lors de la commutation entre les modes.

EditText et = FindViewById<EditText>(Resource.Id.ET);

Pour afficher les caractères: et.InputType = Android.Text.InputTypes.TextVariationVisiblePassword | Android.Text.InputTypes.TextFlagNoSuggestions;

Pour masquer des caractères: et.InputType = Android.Text.InputTypes.TextVariationPassword | Android.Text.InputTypes.ClassText;

Pour définir la position à la fin: int position = et.Text.Length;et.SetSelection(position, position);

2
Tony

une situation dynamique holder.edit_pin.setInputType(InputType.TYPE_CLASS_NUMBER); ne fonctionnera pas, donc mieux utiliser les deux comme ça

holder.edit_pin.setInputType(InputType.TYPE_CLASS_NUMBER);
holder.edit_pin.setTransformationMethod(PasswordTransformationMethod.getInstance());

Remarque: cela convient lorsque vous utilisez des contrôles dynamiques comme utiliser arrayaapter

2
Issac Balaji

Après vous setInputType pour un champ de mot de passe, vous aurez problème avec FONT
Voici ma solution pour afficher/masquer le mot de passe sans problème de police

protected void onCreate(Bundle savedInstanceState) {
    ...
    findViewById(R.id.button_show_hide_password).setOnClickListener(new View.OnClickListener() {
        @Override
        public void onClick(View v) {
            if (isPasswordVisible(edtPassword)) {
                enableInputHiddenPassword(edtPassword);
            } else {
                enableInputVisiblePassword(edtPassword);
            }
            edtPassword.setSelection(edtPassword.getText().length());
        }
    });
}

final int INPUT_TYPE_VISIBLE_PASSWORD = InputType.TYPE_CLASS_TEXT | InputType.TYPE_TEXT_VARIATION_VISIBLE_PASSWORD;
final int INPUT_TYPE_HIDDEN_PASSWORD = InputType.TYPE_CLASS_TEXT | InputType.TYPE_TEXT_VARIATION_PASSWORD;

private boolean isPasswordVisible(EditText editText) {
    return editText.getInputType() == INPUT_TYPE_VISIBLE_PASSWORD;
}

private void enableInputVisiblePassword(EditText editText) {
    Typeface cache = editText.getTypeface();
    editText.setInputType(INPUT_TYPE_VISIBLE_PASSWORD);
    editText.setTypeface(cache);
}

private void enableInputHiddenPassword(EditText editText) {
    Typeface cache = editText.getTypeface();
    editText.setInputType(INPUT_TYPE_HIDDEN_PASSWORD);
    editText.setTypeface(cache);
}

Remarque: J'utilise InputType.TYPE_TEXT_VARIATION_PASSWORD au lieu de InputType.TYPE_CLASS_TEXT ou HideReturnsTransformationMethod parce que je veux que le clavier affiche le texte et le nombre.

DÉMO

2
Phan Van Linh

Je change le type d'entrée sur ma case à cocher, donc sur mon OnCheckedChangeListener je fais:

passwordEdit.setInputType(InputType.TYPE_CLASS_TEXT| (isChecked? InputType.TYPE_TEXT_VARIATION_PASSWORD|~InputType.TYPE_TEXT_VARIATION_VISIBLE_PASSWORD : InputType.TYPE_TEXT_VARIATION_VISIBLE_PASSWORD));

Et cela a finalement fonctionné.

Cela ressemble à un problème booléen avec TYPE_TEXT_VARIATION_VISIBLE_PASSWORD. Inverser le drapeau et cela devrait résoudre le problème.

Dans ton cas:

password.setInputType(InputType.TYPE_TEXT_VARIATION_PASSWORD|~InputType.TYPE_TEXT_VARIATION_VISIBLE_PASSWORD);
1
Gugadin

Code complet lorsque vous souhaitez appliquer la visibilité du mot de passe dans Texte de modification du mot de passe.

Créer une poignée [Toute boîte dessinable ou case à cocher]

sur clic ou sur Checked/Uncheck écrivez ceci:

 if (edittext.getInputType() == (InputType.TYPE_CLASS_TEXT |
                    InputType.TYPE_TEXT_VARIATION_VISIBLE_PASSWORD )){

                edittext.setInputType(InputType.TYPE_CLASS_TEXT |
                        InputType.TYPE_TEXT_VARIATION_PASSWORD );
            }else{
                edittext.setInputType(InputType.TYPE_CLASS_TEXT |
                        InputType.TYPE_TEXT_VARIATION_VISIBLE_PASSWORD );
            }

N'oubliez pas d'écrire cette ligne:

 edittext.setSelection(edittext.getText().length());

Il remet le curseur à la fin de la ligne.

0
sud007

Blockquote

final int [] count = {0};

    showandhide.setOnClickListener(new View.OnClickListener() {
        @Override
        public void onClick(View v) {

            if(count[0] ==0)
            {
                password.setInputType(InputType.TYPE_TEXT_VARIATION_PASSWORD);
                count[0]++;
            }
            else {

                password.setInputType(InputType.TYPE_CLASS_TEXT |
                        InputType.TYPE_TEXT_VARIATION_PASSWORD);
                showandhide.setText("Hide");
                count[0]--;
            }

        }
    });
0
gattamaneni venkatanarasimham

Basé sur les réponses de neeraj t et Everton Fernandes Rosario j'ai écrit dans Kotlin, où password est l'identifiant d'un EditText dans votre mise en page.

// Show passwords' symbols.
private fun showPassword() {
    password.run {
        val cursorPosition = selectionStart
        transformationMethod = HideReturnsTransformationMethod.getInstance()
        setSelection(cursorPosition)
    }
}

// Show asterisks.
private fun hidePassword() {
    password.run {
        val cursorPosition = selectionStart
        transformationMethod = PasswordTransformationMethod.getInstance()
        setSelection(cursorPosition)
    }
}
0
CoolMind

Juste un commentaire supplémentaire sur la bonne réponse fournie par @Rajkiran, vous pouvez ajouter

etPassword.setInputType(InputType.TYPE_CLASS_TEXT | InputType.TYPE_TEXT_FLAG_NO_SUGGESTIONS);

à l'état d'entrée NORMAL pour que les utilisateurs ne soient pas dérangés par la suggestion automatique du clavier

0
Z.J. Cong

Je retirerais Android:inputType="textPassword" de votre mise en page. C'est pourquoi il revient au mot de passe lorsque l'orientation change. Parce que chaque fois que l'orientation change, la vue est recréée.

En ce qui concerne le premier problème, essayez ceci:

String text = password.getText();
password.setText("");
password.setInputType(InputType.TYPE_TEXT_VARIATION_PASSWORD);
password.setText(text);

essentiellement vider le texte avant de changer le type d'entrée, puis de le rajouter.

0
bytebender