Carattere suggerimento password in Android

Quando un EditText è in modalità password, sembra che il suggerimento sia mostrato con un carattere diverso (corriere?). Come posso evitarlo? Vorrei che il suggerimento comparisse nello stesso carattere che quando EditText non è in modalità password.

Il mio xml attuale:

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

Anche la modifica del carattere tipografico in XML non ha funzionato sul testo del suggerimento per me. Ho trovato due diverse soluzioni, la seconda delle quali ha un comportamento migliore per me:

1) Rimuovi android:inputType="textPassword"dal tuo file xml e invece, nel set in java:

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

Con questo approccio, il carattere suggerimento sembra buono ma mentre si digita quel campo di modifica, non si vede ogni carattere in testo semplice prima che si trasformi in un punto password. Inoltre, quando si immette a schermo intero, i punti non verranno visualizzati, ma la password in chiaro.

2) Lascia android:inputType="textPassword"nel tuo XML. In Java, impostare ANCHE il carattere tipografico e la password Metodo:

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

Questo approccio mi ha dato il suggerimento che volevo E mi dà il comportamento che voglio con i punti password.

Spero che aiuti!

Ho trovato questo suggerimento utile nella Guida ai dialoghi

Suggerimento: per impostazione predefinita, quando si imposta un elemento EditText per utilizzare il tipo di input "textPassword", la famiglia di caratteri è impostata su monospace, quindi è necessario modificare la famiglia di caratteri in "sans-serif" in modo che entrambi i campi di testo utilizzino un carattere corrispondente stile.

Per esempio

android:fontFamily="sans-serif"

Questo è quello che ho fatto per risolvere questo problema. Per qualche motivo non ho dovuto impostare il metodo di trasformazione, quindi questa potrebbe essere una soluzione migliore:

Nel mio XML:

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

Nel mio Activity:

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

L'approccio setTransformationMethod rompe android: imeOption per me e consente di digitare i ritorni a capo nel campo della password. Invece sto facendo questo:

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

E non sto impostando Android: password = "true" in XML.

La risposta manisha fornita funziona, ma lascia il campo password in uno stato non standard rispetto al valore predefinito. Cioè, il fontface predefinito si applica anche al campo della password, inclusi sia i punti di sostituzione dei punti che i caratteri di anteprima che appaiono prima di essere sostituiti con i punti (così come quando è un campo "password visibile").

Per risolvere il problema e farlo 1) apparire e agire esattamente come il textPasswordtipo di input predefinito , ma anche 2) consentire al testo del suggerimento di apparire in un carattere predefinito (non monospaziale), è necessario avere un TextWatchercampo che può attivare / disattivare fontface correttamente avanti e indietro tra Typeface.DEFAULTe in Typeface.MONOSPACEbase al fatto che sia vuoto o meno. Ho creato una classe di supporto che può essere utilizzata per ottenere ciò:

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

Quindi, per usarlo, tutto ciò che devi fare è chiamare il register(View)metodo statico. Tutto il resto è automatico (incluso saltare la soluzione alternativa se la vista non lo richiede!):

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

Esistono molti modi per risolvere questo problema, ma ogni modo ha pro e contro. Ecco i miei test

Devo affrontare questo problema di carattere solo in alcuni dispositivi (elenco alla fine della mia risposta) quando abilito la password di input da

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

Se uso android:inputType="textPassword", questo problema non si è verificato

Qualcosa che ho provato

1) Utilizzare setTransformationMethodinveceinputType

edtPassword.setTransformationMethod(PasswordTransformationMethod.getInstance());

• Il font funzionerà bene
• Display della tastiera non molto buono (visualizza solo il testo, non visualizzare il numero sopra il testo)

2) Usa Typeface.DEFAULT

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

• Tastiera ben visualizzata ,
• Il carattere potrebbe non funzionare bene . Esempio sans-serif-lightè un carattere predefinito per tutti Viewnella mia applicazione => dopo setTypeface(Typeface.DEFAULT), il EditTextcarattere sembra ancora diverso in alcuni dispositivi

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

• Per alcuni dispositivi, CRASH , controlla la mia risposta qui https://stackoverflow.com/a/52421199/5381331 . E anche il carattere sembra ancora diverso

LA MIA SOLUZIONE

memorizzare nella cache il carattere tipografico prima di setInputTyperiutilizzarlo

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

Test
Alcuni problemi relativi al font del dispositivo sono presenti

• Xiaomi A2 (8.0.1)
• Pixel XL (8.1.0)
• Sony Xperia Z5 Au (SOV32) (6.0)
• Arrow NX (F-04G) (6.0.1)
• Kyocera (S2) (7.0)

Alcuni dispositivi non presentano problemi con i caratteri

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

Le altre risposte sono la soluzione giusta per la maggior parte dei casi.

Tuttavia, se si utilizza una EditTextsottoclasse personalizzata per, ad esempio, applicare un carattere personalizzato per impostazione predefinita, c'è un problema sottile. Se si imposta il carattere personalizzato nel costruttore della sottoclasse, se impostato, verrà comunque sovrascritto dal sistema inputType="textPassword".

In questo caso, sposta lo stile onAttachedToWindowdopo la super.onAttachedToWindowchiamata.

Esempio di implementazione:

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

So che questo potrebbe essere il più vecchio, ma mi sono imbattuto in qualcosa di legato a questo problema quando ho usato InputTypee app:passwordToggleEnabled="true"insieme.

Quindi, scrivendo questo, in quanto potrebbe aiutare qualcuno qui.

Voglio usare un carattere personalizzato per il campo password insieme app:passwordToggleEnabledall'opzione per il campo di immissione della mia password. Ma nella libreria di supporto 27.1.1 (mentre scrivevo questo), stava andando in crash.

Quindi il codice era come sotto,

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

Il codice sopra non è stato inputTypedefinito in XML

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

E in Java, setTransformationMethodmi aiuterà ad acquisire le proprietà del textPasswordtipo di input e sono contento del mio stile di carattere personalizzato.

Ma il crash di seguito riportato si è verificato in tutti i livelli API con la libreria di supporto 27.1.1.

java.lang.NullPointerException: tentativo di invocare il metodo virtuale "void android.support.design.widget.CheckableImageButton.setChecked (boolean)" su un riferimento a oggetto null

Questo stava andando in crash a causa della classe onRestoreInstanceStateinterna TextInputLayout.

Procedura di riproduzione: attiva la visibilità della password, riduci a icona l'app e apri dalle app recenti. Uh, ho schiantato!

Tutto ciò di cui avevo bisogno è l'opzione di attivazione della password predefinita (utilizzando la libreria di supporto) e il carattere personalizzato nel campo di immissione della password.

Dopo qualche tempo, capito facendo come di seguito,

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

In XML, aggiunto 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

Nel codice java sopra,

Ho acquisito il carattere personalizzato dal nome utente EditTexte l'ho applicato al TextInputLayoutcampo della password. Ora non è necessario impostare esplicitamente il carattere tipografico sulla password EditTextpoiché acquisirà la TextInputLayoutproprietà.

Inoltre, ho rimosso password.setTransformationMethod(new PasswordTransformationMethod());

In questo modo, passwordToggleEnabledfunziona, viene applicato anche il carattere personalizzato e arrivederci allo schianto. Spero che questo problema venga risolto nelle prossime versioni dell'assistenza.

Puoi anche utilizzare un widget personalizzato. È molto semplice e non ingombra il tuo codice Attività / Frammento.

Ecco il codice:

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

E il tuo XML sarà simile al seguente:

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

usa la libreria di calligrafia .

quindi non aggiornerà ancora i campi password con il carattere giusto. quindi fallo nel codice non in 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); 

Di recente ho aggiunto la possibilità di attivare / disattivare l'attivazione / disattivazione del monospace in un'estensione di EditText specificamente per le password che può aiutare alcune persone. Non utilizza, android:fontFamilyquindi è compatibile <16.

Puoi anche usare il

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

insieme a

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

Uso questa soluzione per attivare il carattere tipografico in base alla visibilità dei suggerimenti. È simile alla risposta di Joe, ma estende invece EditText:

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

}

Nel caso in cui si stia utilizzando la libreria di calligrafia in combinazione con TextInputLayout e EditText, il codice seguente funziona bene.

    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 caso strano forse, ma ho sperimentato questo e ho scoperto che:

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

ha cambiato la dimensione del carattere del suggerimento invece del carattere stesso! Questo è ancora un effetto indesiderato. Stranamente, l'operazione inversa:

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

Mantiene le stesse dimensioni del carattere.

Ho trovato una soluzione sicura a questo problema

Il modo migliore per Hello, ho trovato una soluzione sicura a questo problema

Il modo migliore è quello di creare un editText personalizzato e salvare il valore del carattere tipografico come temp e quindi applicare il metodo alle modifiche InputType. Infine, riportiamo il valore del face del tipo temp sul editText. così :

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

}

Questo come creare una password di input con un suggerimento che non è stato convertito in * e carattere tipografico predefinito !!.

Su XML:

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

In attività:

inputPassword.setTypeface(Typeface.DEFAULT);

grazie a: mango e rjrjr per l'intuizione: D.

come sopra ma assicurati che i campi non abbiano lo stile grassetto in xml in quanto non sembreranno mai uguali anche con la correzione sopra!