Altere programaticamente o tipo de entrada do EditText de PASSWORD para NORMAL e vice-versa

No meu aplicativo, eu tenho um EditTextcujo tipo de entrada padrão é definido android:inputType="textPassword"por deault. Ele tem um CheckBoxà sua direita, que é quando marcado, altera o tipo de entrada desse EditText para NORMAL PLAIN TEXT. Código para isso é

password.setInputType(InputType.TYPE_TEXT_VARIATION_VISIBLE_PASSWORD);

Meu problema é que, quando essa caixa de seleção está desmarcada, ela deve definir novamente o tipo de entrada como SENHA. Eu fiz isso usando-

password.setInputType(InputType.TYPE_TEXT_VARIATION_PASSWORD);

Mas o texto dentro desse edittext ainda é visível. E, para surpresa, quando altero a orientação, ele define automaticamente o tipo de entrada como PASSWORD e o texto é marcado com marcadores (mostrado como uma senha).

Alguma maneira de conseguir isso?

Apenas para as pessoas que estão tendo o mesmo problema. Basta adicionar um atributo extra a esse EditText programaticamente e pronto.

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

Para senha numérica (alfinete).

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

Além disso, verifique se o cursor está no final do texto no EditText. Porque, quando você altera o tipo de entrada, o cursor é automaticamente definido como o ponto inicial. Então, sugiro usar o seguinte código:

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

Ao usar a associação de dados, você pode usar o seguinte código

<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 estiver usando o Kotlin,

password.inputType = InputType.TYPE_CLASS_TEXT or InputType.TYPE_TEXT_VARIATION_PASSWORD

use este código para alterar a senha para texto e 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());
                }
            }
        });

para obter um código de exemplo completo, consulte 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);

O método acima realmente não funcionou para mim. A resposta abaixo funciona para 2,2 sdk.

password.setTransformationMethod (PasswordTransformationMethod.getInstance ());

Definir inputType para um EditText?

Outro exemplo simples usando o ImageView para alternar a visibilidade com menos código, devido à única atribuição InputType , precisamos apenas do operador de igualdade:

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

Substituindo:

InputType.TYPE_TEXT_VARIATION_VISIBLE_PASSWORD

Com:

InputType.TYPE_CLASS_TEXT

Vai dar o mesmo resultado, mas palavra mais curta.

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

Isso funcionou para mim:

mytext.setInputType(InputType.TYPE_CLASS_NUMBER);

Ok Então, depois de horas tentando finalmente implementou. Abaixo está o código ..

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

    }
});

Explicações: - Eu tenho um botão com texto padrão como mostrado. Após o evento onclick, verificando se o texto do botão é exibido. Se for exibido, altere o tipo de entrada, ajuste a posição do cursor e defina o novo texto como oculto.

Quando está oculto ... fazendo reversão, ou seja, ocultando a senha, ajustando o cursor e definindo o texto como mostrado. E é isso. Está funcionando como um encanto.

Para usuários do kotlin:

password.inputType = InputType.TYPE_CLASS_TEXT or InputType.TYPE_TEXT_VARIATION_PASSWORD

Use este código para alterar a senha para texto e vice-versa. Este código funcionou perfeitamente para mim. Tente isso ..

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

}
});

Este é o manipulador onClick completo do Image / Button para mostrar / ocultar a senha.

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

O recurso Alternância de visibilidade da senha foi adicionado ao suporte à versão da biblioteca 24.2.0, permitindo que você alterne a senha diretamente da EditTextsem necessidade de umCheckBox .

Você pode fazer isso funcionar basicamente atualizando sua versão da biblioteca de suporte para 24.2.0 e depois definindo uma inputTypesenha no TextInputEditText. Veja como fazer isso:

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

Você pode obter mais informações sobre o novo recurso na documentação do desenvolvedor para TextInputLayout .

Desde a Biblioteca de suporte v24.2.0. você pode conseguir isso muito fácil

O que você precisa fazer é apenas:

1. Adicione a biblioteca de design às suas dependências

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

2. Use TextInputEditTextem conjunto comTextInputLayout

   <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 atributo fará a alternância da senha aparecer

3. No seu layout raiz, não se esqueça de adicionar xmlns:app="http://schemas.android.com/apk/res-auto"

4. Você pode personalizar sua alternância de senha usando:

app:passwordToggleDrawable- Drawable para usar como ícone de alternância da visibilidade da entrada de senha.
app:passwordToggleTint- Ícone a ser usado para alternar a visibilidade da entrada de senha.
app:passwordToggleTintMode- Modo de mesclagem usado para aplicar a tonalidade de fundo.

Mais detalhes na documentação do TextInputLayout .

Minha busca por uma solução semelhante para o Visual Studio / Xamarin me levou a esse segmento. Abaixo está o que funcionou para mim com o Xamarin. Observe que essa implementação mantém o TYPE_TEXT_FLAG_NO_SUGGESTIONSsinalizador ao alternar entre os modos.

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

Para mostrar caracteres: et.InputType = Android.Text.InputTypes.TextVariationVisiblePassword | Android.Text.InputTypes.TextFlagNoSuggestions;

Para ocultar caracteres: et.InputType = Android.Text.InputTypes.TextVariationPassword | Android.Text.InputTypes.ClassText;

Para definir a posição para terminar: int position = et.Text.Length; et.SetSelection(position, position);

alguma situação dinâmica holder.edit_pin.setInputType(InputType.TYPE_CLASS_NUMBER);não funcionará, portanto, use ambos melhor assim

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

Nota: isso é adequado para quando você estiver usando controles dinâmicos, como o arrayaapter

Depois de setInputTypeprocurar um campo de senha, você terá problemas com o FONT.
Aqui está minha solução para mostrar / ocultar senha sem problema de fonte

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 em InputType.TYPE_TEXT_VARIATION_PASSWORDvez de InputType.TYPE_CLASS_TEXTou HideReturnsTransformationMethodporque quero que o teclado exiba texto e número

DEMO

Eu removeria android:inputType="textPassword"do seu layout. É por isso que está voltando à senha quando a orientação muda. Porque cada vez que a orientação muda, a exibição está sendo recriada.

Quanto ao primeiro problema, tente o seguinte:

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

basicamente esvaziando o texto antes de alterar o tipo de entrada e adicioná-lo novamente.

Código completo quando você deseja aplicar a visibilidade da senha no texto de edição da senha.

Crie um identificador [Qualquer drawable ou Checkbox]

ao clicar ou em Marcado / Desmarcar escreva:

 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ão se esqueça de escrever esta linha:

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

Redefine o cursor para o final da linha.

Eu mudo o tipo de entrada na minha caixa de seleção, assim como OnCheckedChangeListenereu faço:

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

Parece um problema booleano com TYPE_TEXT_VARIATION_VISIBLE_PASSWORD. Inverta a bandeira e deve corrigir o problema.

No seu caso:

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

Use o método de transformação:

Esconder:

editText.transformationMethod = PasswordTransformationMethod.getInstance()

Para visível:

editText.transformationMethod = SingleLineTransformationMethod.getInstance()

É isso aí.

Apenas um comentário adicional sobre a resposta correta fornecida por @Rajkiran, você pode adicionar

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

para o estado de entrada NORMAL, para que os usuários não fiquem incomodados com a sugestão automática do teclado

Bloco de citação

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

        }
    });

Com base nas respostas de neeraj t e Everton Fernandes Rosario escrevi na Kotlin, onde passwordé um id de um EditText em seu 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)
    }
}