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

Dans mon application, j'ai un EditTextdont le type d'entrée par défaut est défini android:inputType="textPassword"par deault. Il a un CheckBoxà sa droite, qui, lorsqu'il est coché, change le type d'entrée de ce 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, elle doit à 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 l'orienatation, il définit automatiquement le type d'entrée sur PASSWORD et le texte à l'intérieur est à puces (affiché comme un mot de passe).

Un moyen d'y parvenir?

Juste pour les gens 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);

Pour mot de passe numérique (pin).

password.setInputType(InputType.TYPE_CLASS_NUMBER | InputType.TYPE_NUMBER_VARIATION_PASSWORD);

Assurez-vous également que le curseur se trouve à la fin du texte dans EditText. Parce que, lorsque vous changez le type d'entrée, le curseur sera automatiquement placé au 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

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 un exemple de code complet, consultez http://www.codeproject.com/Tips/518641/Show-hide-password-in-a-edit-text-view-password-ty

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éfinir inputType pour un EditText?

Un autre exemple simple utilisant ImageView pour basculer la visibilité avec moins de code, en raison de l' affectation unique InputType, nous n'avons besoin que d'un 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 un mot plus court.

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());       
                }
            }
        });

Cela a fonctionné pour moi:

mytext.setInputType(InputType.TYPE_CLASS_NUMBER);

Ok Donc, après des heures d'essais, il l'a finalement 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 indiqué. 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 masqué ... faire l'inverse c'est-à-dire cacher le mot de passe, ajuster le curseur et définir le texte comme show. Et c'est tout. Cela fonctionne comme un charme.

Pour les utilisateurs de kotlin:

password.inputType = InputType.TYPE_CLASS_TEXT or InputType.TYPE_TEXT_VARIATION_PASSWORD

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

}
});

Il s'agit du gestionnaire onClick complet pour l'image / le 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);
        }
    };

La fonctionnalité de basculement de la visibilité du mot de passe a été ajoutée pour prendre en charge la version 24.2.0 de la bibliothèque, ce qui vous permet de basculer le mot de passe directement depuis le EditTextsans avoir besoin d'un fichier CheckBox.

Vous pouvez faire en sorte que cela fonctionne en mettant d'abord à jour la version de votre bibliothèque de support vers 24.2.0, puis en définissant un inputTypemot de passe sur le TextInputEditText. Voici comment procéder:

<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é dans la documentation du développeur pour TextInputLayout .

Depuis la bibliothèque de support v24.2.0. vous pouvez y parvenir très facilement

Ce que vous devez faire est juste:

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

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

2. Utiliser TextInputEditTexten conjonction avecTextInputLayout

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

passwordToggleEnabled attribut fera apparaître la bascule du mot de passe

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

4. Vous pouvez personnaliser le basculement de votre mot de passe en utilisant:

app:passwordToggleDrawable- Dessiné à utiliser comme icône de bascule de visibilité d'entrée de 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 d'arrière-plan.

Plus de détails dans la documentation TextInputLayout .

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' TYPE_TEXT_FLAG_NO_SUGGESTIONSindicateur lors du basculement 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 les caractères: et.InputType = Android.Text.InputTypes.TextVariationPassword | Android.Text.InputTypes.ClassText;

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

une situation dynamique holder.edit_pin.setInputType(InputType.TYPE_CLASS_NUMBER);ne fonctionnera pas, il vaut 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 l'utilisation de arrayaapter

Après avoir entré setInputTypeun champ de mot de passe, vous aurez un 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 à la InputType.TYPE_TEXT_VARIATION_PASSWORDplace InputType.TYPE_CLASS_TEXTou HideReturnsTransformationMethodparce que je veux que le clavier affiche à la fois du texte et des chiffres

DEMO

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

Quant au 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 modifier le type d'entrée, puis de le rajouter.

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

Créer une poignée [Tout dessinable ou case à cocher]

en cliquant ou sur Coché / Décoché, é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 réinitialise le curseur à la fin de la ligne.

Je change le type d'entrée sur ma case à cocher, donc OnCheckedChangeListenerje 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. Inversez 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);

Utilisez la méthode de transformation:

Cacher:

editText.transformationMethod = PasswordTransformationMethod.getInstance()

Visible:

editText.transformationMethod = SingleLineTransformationMethod.getInstance()

C'est tout.

Juste un commentaire supplémentaire sur la bonne réponse fournie par @Rajkiran, vous voudrez peut-être ajouter

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

à l'état d'entrée NORMAL afin que les utilisateurs ne soient pas ennuyés par l'auto-suggestion du clavier

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]--;
            }

        }
    });

Basé sur les réponses de neeraj t et Everton Fernandes Rosario, j'ai écrit à Kotlin, où se passwordtrouve un 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)
    }
}