Cambia a livello di codice il tipo di input del EditText da PASSWORD a NORMAL e viceversa

Nella mia applicazione, ho un EditTextcui tipo di input predefinito è impostato android:inputType="textPassword"da deault. Ha una CheckBoxalla sua destra, che è una volta spuntata, cambia il tipo di input di quel EditText in NORMAL PLAIN TEXT. Il codice per quello è

password.setInputType(InputType.TYPE_TEXT_VARIATION_VISIBLE_PASSWORD);

Il mio problema è che quando CheckBox è deselezionato dovrebbe impostare nuovamente il tipo di input su PASSWORD. L'ho fatto usando-

password.setInputType(InputType.TYPE_TEXT_VARIATION_PASSWORD);

Ma il testo all'interno di quel edittext è ancora visibile. E per sorpresa, quando cambio l'orienazione, imposta automaticamente il tipo di input su PASSWORD e il testo all'interno è puntato (mostrato come una password).

Qualche modo per raggiungere questo obiettivo?

Solo per le persone che hanno lo stesso problema. Basta aggiungere un attributo extra a quel EditText a livello di codice e il gioco è fatto.

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

Per password numerica (pin).

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

Inoltre, assicurarsi che il cursore si trovi alla fine del testo in EditText. Perché, quando si cambia il tipo di input, il cursore verrà automaticamente impostato sul punto iniziale. Quindi suggerisco di usare il seguente codice:

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

Quando si utilizza l'associazione dati, è possibile utilizzare il seguente codice

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

Se si utilizza Kotlin,

password.inputType = InputType.TYPE_CLASS_TEXT or InputType.TYPE_TEXT_VARIATION_PASSWORD

usa questo codice per cambiare la password in testo e viceversa

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

per il codice di esempio completo, consultare 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);

Il metodo sopra non ha funzionato davvero per me. La risposta che segue funziona per 2.2 sdk.

password.setTransformationMethod (PasswordTransformationMethod.getInstance ());

Impostare inputType per un EditText?

Un altro semplice esempio che utilizza ImageView per attivare la visibilità con meno codice, a causa della singola assegnazione InputType è necessario solo l'operatore di uguaglianza:

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

Sostituzione:

InputType.TYPE_TEXT_VARIATION_VISIBLE_PASSWORD

Con :

InputType.TYPE_CLASS_TEXT

Fornirà lo stesso risultato ma una parola più breve.

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

Questo ha funzionato per me:

mytext.setInputType(InputType.TYPE_CLASS_NUMBER);

Ok Quindi dopo ore di tentativi finalmente implementato. Di seguito è riportato il codice ..

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

    }
});

Spiegazioni: - Ho un pulsante con testo predefinito come mostra. Dopo l'evento onclick su di esso, verifica se il testo del pulsante è mostrato. Se viene mostrato, cambia il tipo di input, regolando la posizione del cursore e impostando il nuovo testo come nascosto in esso.

Quando è nascosto ... sta facendo il contrario, cioè nascondendo la password, regolando il cursore e impostando il testo come mostra. E questo è tutto. Funziona come un fascino.

Per gli utenti di kotlin:

password.inputType = InputType.TYPE_CLASS_TEXT or InputType.TYPE_TEXT_VARIATION_PASSWORD

Utilizzare questo codice per modificare la password in testo e viceversa. Questo codice ha funzionato perfettamente per me. Prova questo..

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

}
});

Questo è il gestore onClick completo per il pulsante Immagine / per mostrare / nascondere la password.

    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 funzione Attiva / disattiva visibilità password è stata aggiunta per supportare la libreria versione 24.2.0 che consente di attivare o disattivare la password direttamente da EditTextsenza CheckBox.

Puoi farlo funzionare fondamentalmente aggiornando prima la versione della tua libreria di supporto su 24.2.0 e quindi impostando una inputTypepassword su TextInputEditText. Ecco come farlo:

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

Puoi ottenere ulteriori informazioni sulla nuova funzionalità nella documentazione per gli sviluppatori di TextInputLayout .

Dalla libreria di supporto v24.2.0. puoi ottenere questo molto facilmente

Quello che devi fare è solo:

1. Aggiungi la libreria di progettazione alle tue dipendenze

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

2. Utilizzare TextInputEditTextin combinazione conTextInputLayout

   <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 l'attributo farà apparire la password

3. Nel layout di root non dimenticare di aggiungere xmlns:app="http://schemas.android.com/apk/res-auto"

4. Puoi personalizzare la tua password usando:

app:passwordToggleDrawable- Disegnabile da utilizzare come icona di attivazione / disattivazione della visibilità di immissione della password.
app:passwordToggleTint- Icona da utilizzare per attivare / disattivare la visibilità dell'immissione della password.
app:passwordToggleTintMode- Metodo di fusione utilizzato per applicare la tinta di sfondo.

Maggiori dettagli nella documentazione di TextInputLayout .

La mia ricerca di una soluzione simile per Visual Studio / Xamarin mi ha portato a questo thread. Di seguito è ciò che ha funzionato per me con Xamarin. Si noti che questa implementazione mantiene il TYPE_TEXT_FLAG_NO_SUGGESTIONSflag quando si passa da una modalità all'altra.

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

Per mostrare i personaggi: et.InputType = Android.Text.InputTypes.TextVariationVisiblePassword | Android.Text.InputTypes.TextFlagNoSuggestions;

Per nascondere i personaggi: et.InputType = Android.Text.InputTypes.TextVariationPassword | Android.Text.InputTypes.ClassText;

Per impostare la posizione alla fine: int position = et.Text.Length; et.SetSelection(position, position);

qualche situazione dinamica holder.edit_pin.setInputType(InputType.TYPE_CLASS_NUMBER);non funzionerà, quindi meglio usarli entrambi

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

Nota: è adatto per l'uso di controlli dinamici come l'utilizzo di arrayaapter

Dopo aver setInputTyperichiesto un campo password, avrai problemi con FONT
Ecco la mia soluzione per mostrare / nascondere la password senza problemi di font

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

Nota: uso InputType.TYPE_TEXT_VARIATION_PASSWORDinvece di InputType.TYPE_CLASS_TEXTo HideReturnsTransformationMethodperché voglio che la tastiera visualizzi sia il testo che il numero

DEMO

Vorrei rimuovere android:inputType="textPassword"dal tuo layout. Ecco perché sta tornando alla password quando l'orientamento cambia. Perché ogni volta che l'orientamento cambia la vista viene ricreata.

Per quanto riguarda il primo problema, prova questo:

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

fondamentalmente svuotare il testo prima di modificare il tipo di input e quindi aggiungerlo nuovamente.

Codice completo quando si desidera applicare la visibilità della password nel testo di modifica della password.

Crea un handle [Qualsiasi disegno o casella di controllo]

al clic o su Selezionato / Deseleziona scrivi questo:

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

Non dimenticare di scrivere questa riga:

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

Reimposta il cursore alla fine della riga.

Cambio il tipo di input sulla mia casella di controllo, quindi sul mio OnCheckedChangeListenerfaccio:

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

E finalmente ha funzionato.

Sembra un problema booleano con TYPE_TEXT_VARIATION_VISIBLE_PASSWORD. Invertire la bandiera e dovrebbe risolvere il problema.

Nel tuo caso:

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

Usa il metodo di trasformazione:

Nascondere:

editText.transformationMethod = PasswordTransformationMethod.getInstance()

Visibile:

editText.transformationMethod = SingleLineTransformationMethod.getInstance()

Questo è tutto.

Potresti voler aggiungere solo un commento aggiuntivo sulla risposta corretta fornita da @Rajkiran

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

allo stato di input NORMAL in modo che gli utenti non siano infastiditi dal suggerimento automatico della tastiera

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

        }
    });

Sulla base delle risposte di neeraj t e Everton Fernandes Rosario ho scritto in Kotlin, dove passwordè un ID di un EditText nel layout.

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