Police d'indice de mot de passe dans Android

Question

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

Answer 1

Changer la police de caractères dans le format xml n'a pas de travail sur le texte d'instruction pour moi non plus. J'ai trouvé deux solutions différentes, la seconde a un meilleur comportement pour moi:

1) Retirez android:password="true" de votre fichier xml et au lieu de cela, dans le régler en java:

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

Avec cette approche, l'indice de la police semble bon, mais comme vous êtes à taper dans ce champ d'édition, vous ne voyez pas chaque caractère du texte brut avant qu'il se transforme en un mot de passe point. Aussi lors de la prise de d'entrée en plein écran, les points n'apparaissent pas, mais le passoword en texte clair.

2) Laissez android:password="true" dans votre xml. En Java, AUSSI définir la police et passwordMethod:

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

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

Espérons que ça aide!

Answer 2

J'ai trouvé cette astuce utile du Guide des dialogues

Astuce: Par défaut, lorsque vous définissez un élément EditText pour utiliser le type de saisie "textPassword", la famille de polices est définie sur monospace. Vous devez donc remplacer sa famille de polices par "sans-serif" afin que les deux champs de texte correspondent. style.

---

Par exemple

 android:fontFamily="sans-serif"
 

Answer 3

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, donc cela pourrait ê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 );
 

Answer 4

L'approche setTransformationMethod casse android: imeOption pour moi, et permet de saisir les retours chariot dans le champ mot de passe. Au lieu de cela, je fais ceci:

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

Et ne suis pas en train de configurer Android: password = "true" en XML.

Answer 5

La réponse manisha fourni fonctionne, mais il laisse le champ mot de passe dans un autre état par rapport à la valeur par défaut. C'est, par défaut fontface puis s'applique également pour le champ mot de passe, y compris le point de remplacements et de l'aperçu de caractères qui s'affiche avant d'être remplacé par des points (comme lorsqu'il est un "mot de passe").

Pour résoudre ce problème et rendre 1) examiner et d'agir exactement comme la valeur par défaut textPassword type d'entrée, mais aussi 2) permettre à l'indice de texte par défaut (non-monospace) la police, vous devez avoir un TextWatcher sur le terrain qui permet de basculer la fontface correctement-et-vient entre Typeface.DEFAULT et Typeface.MONOSPACE selon si elle est vide ou pas. J'ai créé une classe d'assistance qui peuvent être utilisés pour la réaliser:

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

Ensuite pour l'utiliser, tout ce que vous devez faire est d'appeler l' register(View) méthode statique. Tout le reste est automatique (y compris sauter la solution de contournement si la vue n'en a pas besoin!):

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