Police d'indication de mot de passe dans Android

Lorsqu'un EditText est en mode mot de passe, il semble que l'indice soit affiché dans une police différente (courrier?). Comment puis-je éviter ça? Je voudrais que l'indice apparaisse dans la même police que lorsque le EditText n'est pas en mode mot de passe.

Mon xml actuel:

<EditText 
android:hint="@string/edt_password_hint"
android:layout_width="fill_parent"
android:layout_height="wrap_content" 
android:password="true"
android:singleLine="true" />

Changer la police de caractères en xml n'a pas fonctionné non plus pour moi sur le texte de l'indice. J'ai trouvé deux solutions différentes, dont la seconde a un meilleur comportement pour moi:

1) Supprimer android:inputType="textPassword"de votre fichier xml et au lieu de cela, définissez-le en java:

EditText password = (EditText) findViewById(R.id.password_text);
password.setTransformationMethod(new PasswordTransformationMethod());

Avec cette approche, la police de conseil semble bonne, mais lorsque vous saisissez ce champ d'édition, vous ne voyez pas chaque caractère en texte brut avant qu'il ne se transforme en point de mot de passe. De plus, lors de la saisie en plein écran, les points n'apparaissent pas, mais le mot de passe en texte clair.

2) Laissez android:inputType="textPassword"votre xml. En Java, définissez également la police et le mot de passe

EditText password = (EditText) findViewById(R.id.register_password_text);
password.setTypeface(Typeface.DEFAULT);
password.setTransformationMethod(new PasswordTransformationMethod());

Cette approche m'a donné la police d'indice que je voulais ET me donne le comportement que je veux avec les points de mot de passe.

J'espère que cela pourra aider!

J'ai trouvé cette astuce utile dans le Guide des dialogues

Conseil: Par défaut, lorsque vous définissez un élément EditText pour utiliser le type d'entrée "textPassword", la famille de polices est définie sur monospace, vous devez donc changer sa famille de polices en "sans-serif" afin que les deux champs de texte utilisent une police correspondante style.

Par exemple

android:fontFamily="sans-serif"

C'est ce que j'ai fait pour résoudre ce problème. Pour une raison quelconque, je n'ai pas eu à définir la méthode de transformation, cela peut donc être une meilleure solution:

Dans mon xml:

<EditText
    android:id="@+id/password_edit_field"
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    android:hint="Password"
    android:inputType="textPassword" />

Dans mon Activity:

EditText password = (EditText) findViewById( R.id.password_edit_field );
password.setTypeface( Typeface.DEFAULT );

L'approche setTransformationMethod brise Android: imeOption pour moi et permet de taper les retours chariot dans le champ du mot de passe. Au lieu de cela, je fais ceci:

setInputType(InputType.TYPE_CLASS_TEXT | InputType.TYPE_TEXT_VARIATION_PASSWORD);
setTypeface(Typeface.DEFAULT);

Et je ne mets pas android: password = "true" en XML.

La réponse fournie par manisha fonctionne, mais elle laisse le champ de mot de passe dans un état non standard par rapport à la valeur par défaut. Autrement dit, la police par défaut s'applique également au champ de mot de passe, y compris les remplacements de points et les caractères d'aperçu qui apparaissent avant d'être remplacés par les points (ainsi que lorsqu'il s'agit d'un champ "mot de passe visible").

Pour résoudre ce problème et le faire 1) ressembler et agir exactement comme le textPasswordtype d'entrée par défaut , mais aussi 2) permettre au texte de conseil d'apparaître dans une police par défaut (non monospace), vous devez avoir un TextWatchersur le champ qui peut basculer le fontface correctement dans les deux sens entre Typeface.DEFAULTet Typeface.MONOSPACEselon qu'il est vide ou non. J'ai créé une classe d'aide qui peut être utilisée pour accomplir cela:

import android.graphics.Typeface;
import android.text.Editable;
import android.text.TextWatcher;
import android.view.inputmethod.EditorInfo;
import android.widget.TextView;

/**
 * This class watches the text input in a password field in order to toggle the field's font so that the hint text
 * appears in a normal font and the password appears as monospace.
 *
 * <p />
 * Works around an issue with the Hint typeface.
 *
 * @author jhansche
 * @see <a
 * href="http://stackoverflow.com/questions/3406534/password-hint-font-in-android">http://stackoverflow.com/questions/3406534/password-hint-font-in-android</a>
 */
public class PasswordFontfaceWatcher implements TextWatcher {
    private static final int TEXT_VARIATION_PASSWORD =
            (EditorInfo.TYPE_CLASS_TEXT | EditorInfo.TYPE_TEXT_VARIATION_PASSWORD);
    private TextView mView;

    /**
     * Register a new watcher for this {@code TextView} to alter the fontface based on the field's contents.
     *
     * <p />
     * This is only necessary for a textPassword field that has a non-empty hint text. A view not meeting these
     * conditions will incur no side effects.
     *
     * @param view
     */
    public static void register(TextView view) {
        final CharSequence hint = view.getHint();
        final int inputType = view.getInputType();
        final boolean isPassword = ((inputType & (EditorInfo.TYPE_MASK_CLASS | EditorInfo.TYPE_MASK_VARIATION))
                == TEXT_VARIATION_PASSWORD);

        if (isPassword && hint != null && !"".equals(hint)) {
            PasswordFontfaceWatcher obj = new PasswordFontfaceWatcher(view);
            view.addTextChangedListener(obj);

            if (view.length() > 0) {
                obj.setMonospaceFont();
            } else {
                obj.setDefaultFont();
            }
        }
    }

    public PasswordFontfaceWatcher(TextView view) {
        mView = view;
    }

    public void onTextChanged(final CharSequence s, final int start, final int before, final int count) {
        // Not needed
    }

    public void beforeTextChanged(final CharSequence s, final int start, final int count, final int after) {
        if (s.length() == 0 && after > 0) {
            // Input field went from empty to non-empty
            setMonospaceFont();
        }
    }

    public void afterTextChanged(final Editable s) {
        if (s.length() == 0) {
            // Input field went from non-empty to empty
            setDefaultFont();
        }
    }

    public void setDefaultFont() {
        mView.setTypeface(Typeface.DEFAULT);
    }

    public void setMonospaceFont() {
        mView.setTypeface(Typeface.MONOSPACE);
    }
}

Pour l'utiliser, il vous suffit d'appeler la register(View)méthode statique. Tout le reste est automatique (y compris sauter la solution de contournement si la vue ne l'exige pas!):

    final EditText txtPassword = (EditText) view.findViewById(R.id.txt_password);
    PasswordFontfaceWatcher.register(txtPassword);

Il existe de nombreuses façons de résoudre ce problème, mais chacune a ses avantages et ses inconvénients. Voici mes tests

Je ne fais face à ce problème de police que sur certains appareils (liste à la fin de ma réponse) lorsque j'active le mot de passe d'entrée en

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

Si j'utilise android:inputType="textPassword", ce problème ne s'est pas produit

Quelque chose que j'ai essayé

1) Utilisez setTransformationMethodplutôtinputType

edtPassword.setTransformationMethod(PasswordTransformationMethod.getInstance());

• La police fonctionnera bien
• L'affichage du clavier n'est pas très bien (il n'affiche que le texte, n'affiche pas le numéro en haut du texte)

2) Utilisation Typeface.DEFAULT

setInputType(InputType.TYPE_CLASS_TEXT | InputType.TYPE_TEXT_VARIATION_PASSWORD);
setTypeface(Typeface.DEFAULT);

• Affichage du clavier bien ,
• La police peut ne pas fonctionner correctement . L'exemple sans-serif-lightest une police par défaut pour tous Viewdans mon application => après setTypeface(Typeface.DEFAULT), la EditTextpolice est toujours différente sur certains appareils

3) Utilisation android:fontFamily="sans-serif"

• Pour certains appareils, il CRASH , vérifiez ma réponse ici https://stackoverflow.com/a/52421199/5381331 . Et la police est toujours différente

MA SOLUTION

mettre en cache la police avant de la setInputTyperéutiliser

Typeface cache = edtPassword.getTypeface();
edtPassword.setInputType(InputType.TYPE_CLASS_TEXT | InputType.TYPE_TEXT_VARIATION_PASSWORD);
edtPassword.setTypeface(cache);

Test de
certains problèmes de police de visage d'appareil

• Xiaomi A2 (8.0.1)
• Pixel XL (8.1.0)
• Sony Xperia Z5 Au (SOV32) (6.0)
• Flèche NX (F-04G) (6.0.1)
• Kyocera (S2) (7,0)

Certains appareils ne rencontrent pas de problème de police

• Samsung S4 (SC-04E) (5.0.1)
• Samsung Galaxy Node 5 (5.1.1)
• Samsung S7 Edge (SM-G935F) (7.0)

Les autres réponses sont la bonne solution pour la plupart des cas.

Cependant, si vous utilisez une EditTextsous-classe personnalisée pour, par exemple, appliquer une police personnalisée par défaut, il y a un problème subtil. Si vous définissez la police personnalisée dans le constructeur de votre sous-classe, elle sera toujours remplacée par le système si vous la définissez inputType="textPassword".

Dans ce cas, déplacez votre style onAttachedToWindowaprès votre super.onAttachedToWindowappel.

Exemple d'implémentation:

package net.petosky.android.ui;

import android.content.Context;
import android.graphics.Typeface;
import android.util.AttributeSet;
import android.widget.EditText;

/**
 * An EditText that applies a custom font.
 *
 * @author cory@petosky.net
 */
public class EditTextWithCustomFont extends EditText {

    private static Typeface customTypeface;

    public EditTextWithCustomFont(Context context) {
        super(context);
    }

    public EditTextWithCustomFont(Context context, AttributeSet attrs) {
        super(context, attrs);
    }

    public EditTextWithCustomFont(
            Context context, AttributeSet attrs, int defStyleAttr) {
        super(context, attrs, defStyleAttr);
    }

    /**
     * Load and store the custom typeface for this app.
     *
     * You should have a font file in: project-root/assets/fonts/
     */
    private static Typeface getTypeface(Context context) {
        if (customTypeface == null) {
            customTypeface = Typeface.createFromAsset(
                    context.getAssets(), "fonts/my_font.ttf");
        }
        return customTypeface;
    }

    /**
     * Set a custom font for our EditText.
     *
     * We do this in onAttachedToWindow instead of the constructor to support
     * password input types. Internally in TextView, setting the password
     * input type overwrites the specified typeface with the system default
     * monospace.
     */
    @Override protected void onAttachedToWindow() {
        super.onAttachedToWindow();
        // Our fonts aren't present in developer tools, like live UI
        // preview in AndroidStudio.
        if (!isInEditMode()) {
            setTypeface(getTypeface(getContext()));
        }
    }
}

Je sais que c'est peut-être le plus ancien, mais je suis tombé sur quelque chose en rapport avec ce problème lorsque j'ai utilisé InputTypeet app:passwordToggleEnabled="true"ensemble.

Donc, écrivez ceci, car cela peut aider quelqu'un ici.

Je veux utiliser une police personnalisée pour le champ de mot de passe ainsi qu'une app:passwordToggleEnabledoption pour mon champ de saisie de mot de passe. Mais dans la bibliothèque de support 27.1.1 (lors de l'écriture), elle plantait.

Donc, le code était comme ci-dessous,

<android.support.design.widget.TextInputLayout
        android:id="@+id/input_password"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:layout_marginBottom="@dimen/_10dp"
        android:layout_marginTop="@dimen/_32dp"
        android:hint="@string/current_password"
        android:textColorHint="@color/hint_text_color"
        app:layout_constraintEnd_toEndOf="parent"
        app:layout_constraintStart_toStartOf="parent"
        app:layout_constraintTop_toTopOf="parent"
        app:passwordToggleEnabled="true"
        app:passwordToggleTint="@color/black">


        <EditText
            android:id="@+id/password"
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:layout_gravity="start|left"
            android:maxLines="1"
            android:textAlignment="viewStart"
            android:textColor="@color/black"
            android:textColorHint="@color/camel"
            android:textSize="@dimen/txt_16sp"
            app:font_style="regular"
            app:drawableEnd="@drawable/ic_remove_eye" />

    </android.support.design.widget.TextInputLayout>

Le code ci-dessus n'a pas inputTypedéfini en XML

EditText password = (EditText) findViewById(R.id.password);
password.setTransformationMethod(new PasswordTransformationMethod());

Et en Java, setTransformationMethodcela m'aidera à acquérir les propriétés du textPasswordtype d'entrée et je suis également satisfait de mon style de police personnalisé.

Mais le crash mentionné ci-dessous s'est produit à tous les niveaux d'API avec la bibliothèque de support 27.1.1.

java.lang.NullPointerException: tentative d'appeler la méthode virtuelle 'void android.support.design.widget.CheckableImageButton.setChecked (boolean)' sur une référence d'objet null

Cela plantait à cause de la classe onRestoreInstanceStateinterne TextInputLayout.

Reproduire les étapes: basculez la visibilité du mot de passe et réduisez l'application et ouvrez-la à partir des applications récentes. Euh, ho Crashed!

Tout ce dont j'avais besoin est une option de bascule de mot de passe par défaut (en utilisant la bibliothèque de support) et une police personnalisée dans le champ de saisie du mot de passe.

Après un certain temps, compris en faisant comme ci-dessous,

<android.support.design.widget.TextInputLayout
        android:id="@+id/input_password"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:layout_marginBottom="@dimen/_10dp"
        android:layout_marginTop="@dimen/_32dp"
        android:hint="@string/current_password"
        android:textColorHint="@color/hint_text_color"
        app:layout_constraintEnd_toEndOf="parent"
        app:layout_constraintStart_toStartOf="parent"
        app:layout_constraintTop_toTopOf="parent"
        app:passwordToggleEnabled="true"
        app:passwordToggleTint="@color/black">


        <EditText
            android:id="@+id/password"
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:layout_gravity="start|left"
            android:maxLines="1"
            android:textAlignment="viewStart"
            android:textColor="@color/black"
            android:textColorHint="@color/camel"
            android:textSize="@dimen/txt_16sp"
            app:font_style="regular"
            app:drawableEnd="@drawable/ic_remove_eye"
            android:inputType="textPassword" />

    </android.support.design.widget.TextInputLayout>

En XML, ajouté android:inputType="textPassword"

TextInputLayout inputPassword = findViewById(R.id.input_password);
EditText password = findViewById(R.id.password);
EditText userName = findViewById(R.id.user_name);
// Get the typeface of user name or other edit text
Typeface typeface = userName.getTypeface();
if (typeface != null)
   inputLayout.setTypeface(typeface); // set to password text input layout

Dans le code java ci-dessus,

J'ai acquis la police de caractères personnalisée du nom d'utilisateur EditTextet l' ai appliquée au TextInputLayoutchamp de mot de passe. Désormais, vous n'avez plus besoin de définir explicitement la police de caractères sur le mot EditTextde passe car elle acquiert la TextInputLayoutpropriété.

Aussi, j'ai supprimé password.setTransformationMethod(new PasswordTransformationMethod());

De cette façon, passwordToggleEnabledfonctionne, la police personnalisée est également appliquée et bye-bye au crash. J'espère que ce problème sera résolu dans les prochaines versions de support.

Vous pouvez également utiliser un widget personnalisé. C'est très simple et cela n'encombre pas votre code d'activité / fragment.

Voici le code:

public class PasswordEditText extends EditText {

  public PasswordEditText(Context context) {
    super(context);
    init();
  }

  public PasswordEditText(Context context, AttributeSet attrs) {
    super(context, attrs);
    init();

  }

  public PasswordEditText(Context context, AttributeSet attrs, int defStyle) {
    super(context, attrs, defStyle);
    init();
  }

  private void init() {
    setTypeface(Typeface.DEFAULT);
  }
}

Et votre XML ressemblera à ceci:

<com.sample.PasswordEditText
  android:id="@+id/password_edit_field"
  android:layout_width="wrap_content"
  android:layout_height="wrap_content"
  android:hint="Password"
  android:inputType="textPassword"
  android:password="true" />

utilisez la bibliothèque de calligraphie .

alors il ne mettra toujours pas à jour les champs de mot de passe avec la bonne police. faites donc ceci dans le code pas dans xml:

Typeface typeface_temp = editText.getTypeface();
editText.setInputType(inputType); /*whatever inputType you want like "TYPE_TEXT_FLAG_NO_SUGGESTIONS"*/
//font is now messed up ..set it back with the below call
editText.setTypeface(typeface_temp); 

J'ai récemment ajouté la possibilité de basculer monospace on / off sur une extension de EditText spécifiquement pour les mots de passe, cela peut aider certaines personnes. Il n'utilise pas android:fontFamilyet est donc compatible <16.

Vous pouvez également utiliser le

<android.support.design.widget.TextInputLayout/>

ensemble avec

<android.support.v7.widget.AppCompatEditText/>

J'utilise cette solution pour basculer la police de caractères en fonction de la visibilité des indices. C'est similaire à la réponse de Joe, mais en étendant EditText à la place:

public class PasswordEditText extends android.support.v7.widget.AppCompatEditText {

    public PasswordEditText(Context context) {
        super(context);
    }

    public PasswordEditText(Context context, AttributeSet attrs) {
        super(context, attrs);
    }

    public PasswordEditText(Context context, AttributeSet attrs, int defStyleAttr) {
        super(context, attrs, defStyleAttr);
    }

    @Override
    protected void onTextChanged(CharSequence text, int start, int lengthBefore, int lengthAfter) {
        super.onTextChanged(text, start, lengthBefore, lengthAfter);
        if (text.length() > 0) setTypeface(Typeface.MONOSPACE);
        else setTypeface(Typeface.DEFAULT);
    }

}

Dans le cas où vous utilisez la bibliothèque de calligraphie en combinaison avec un TextInputLayout et un EditText, le code suivant fonctionne bien.

    EditText password = (EditText) findViewById(R.id.password);
    TextInputLayout passwordLayout = (TextInputLayout) findViewById(R.id.passwordLayout);

    Typeface typeface_temp = password.getTypeface();
    password.setInputType(InputType.TYPE_CLASS_TEXT |
            InputType.TYPE_TEXT_VARIATION_PASSWORD); 

    password.setTypeface(typeface_temp);
    passwordLayout.setTypeface(typeface_temp);

Un cas étrange peut-être, mais j'ai expérimenté cela et j'ai découvert que:

password.setInputType(InputType.TYPE_TEXT_VARIATION_PASSWORD);
password.setTransformationMethod(new PasswordTransformationMethod());

changé la taille de la police de l'indice au lieu de la police elle-même! C'est toujours un effet indésirable. Curieusement, l'opération inverse:

password.setTransformationMethod(new PasswordTransformationMethod());
password.setInputType(InputType.TYPE_TEXT_VARIATION_PASSWORD);

Conserve la même taille de police.

J'ai trouvé une solution sûre à ce problème

La meilleure façon de Bonjour, j'ai trouvé une solution sûre à ce problème

La meilleure façon est de créer un editText personnalisé et d'enregistrer la valeur de la police en tant que temp, puis d'appliquer la méthode aux modifications InputType. Enfin, nous redéfinissons la valeur du type de temp sur le editText. ainsi :

public class AppCompatPasswordEditText extends AppCompatEditText {


    public AppCompatPasswordEditText(Context context) {
        super(context);
    }

    public AppCompatPasswordEditText(Context context, AttributeSet attrs) {
        super(context, attrs);
    }

    public AppCompatPasswordEditText(Context context, AttributeSet attrs, int defStyleAttr) {
        super(context, attrs, defStyleAttr);
    }


    @Override
    protected void onAttachedToWindow() {
        super.onAttachedToWindow();
        // Our fonts aren't present in developer tools, like live UI
        // preview in AndroidStudio.
        Typeface cache = getTypeface();

        if (!isInEditMode() && cache != null) {
            setInputType(InputType.TYPE_CLASS_TEXT | InputType.TYPE_TEXT_VARIATION_PASSWORD);
            setTypeface(cache);
        }
    }

}

Voici comment créer un mot de passe qui a un indice qui n'a pas été converti en * et une police par défaut !!.

Sur XML:

android:inputType="textPassword"
android:gravity="center"
android:ellipsize="start"
android:hint="Input Password !."

En activité:

inputPassword.setTypeface(Typeface.DEFAULT);

merci à: mango et rjrjr pour la perspicacité: D.

comme ci-dessus mais assurez-vous que les champs n'ont pas le style gras en xml car ils ne seront jamais identiques même avec le correctif ci-dessus!