Cambie programáticamente el tipo de entrada de EditText de CONTRASEÑA a NORMAL y viceversa

En mi aplicación, tengo un EditTexttipo de entrada predeterminado cuya configuración predeterminada es android:inputType="textPassword"deault. Tiene un CheckBoxsigno a su derecha, que cuando se marca, cambia el tipo de entrada de ese EditText a TEXTO NORMAL PLANO. Código para eso es

password.setInputType(InputType.TYPE_TEXT_VARIATION_VISIBLE_PASSWORD);

Mi problema es que cuando esa casilla de verificación no está marcada, debería volver a establecer el tipo de entrada en CONTRASEÑA. Lo he hecho usando

password.setInputType(InputType.TYPE_TEXT_VARIATION_PASSWORD);

Pero, el texto dentro de ese texto de edición todavía es visible. Y para sorpresa, cuando cambio la orientación, establece automáticamente el tipo de entrada en CONTRASEÑA y el texto dentro aparece con viñetas (se muestra como una contraseña).

¿Alguna forma de lograr esto?

Solo para las personas que tienen el mismo problema. Simplemente agregue un atributo adicional a ese EditText mediante programación y ya está.

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

Para contraseña numérica (pin).

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

Además, asegúrese de que el cursor esté al final del texto en EditText. Porque, cuando cambia el tipo de entrada, el cursor se establecerá automáticamente en el punto de partida. Así que sugiero usar el siguiente código:

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

Al usar Enlace de datos, puede utilizar el siguiente 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 }'

Si usa Kotlin,

password.inputType = InputType.TYPE_CLASS_TEXT or InputType.TYPE_TEXT_VARIATION_PASSWORD

use este código para cambiar la contraseña a texto y 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());
                }
            }
        });

para obtener el código de muestra 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);

El método anterior realmente no funcionó para mí. La respuesta a continuación funciona para 2.2 sdk.

password.setTransformationMethod (PasswordTransformationMethod.getInstance ());

Establecer inputType para un EditText?

Otro ejemplo simple que usa ImageView para alternar la visibilidad con menos código, debido a la asignación de InputType solo necesitamos un operador de igualdad:

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

Sustitución:

InputType.TYPE_TEXT_VARIATION_VISIBLE_PASSWORD

Con :

InputType.TYPE_CLASS_TEXT

Dará el mismo resultado pero una palabra más corta.

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

Esto funcionó para mí:

mytext.setInputType(InputType.TYPE_CLASS_NUMBER);

Ok, así que después de horas de intentarlo finalmente lo implementé. Debajo está el 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));
       }

    }
});

Explicaciones: - Tengo un botón con el texto predeterminado como se muestra. Después del evento onclick, verifica si se muestra el texto del botón. Si se muestra, cambie el tipo de entrada, ajuste la posición del cursor y configure el nuevo texto como oculto en él.

Cuando está oculto ... haciendo reversa, es decir, ocultando la contraseña, ajustando el cursor y configurando el texto como se muestra. Y eso es. Está funcionando como un encanto.

Para usuarios de kotlin:

password.inputType = InputType.TYPE_CLASS_TEXT or InputType.TYPE_TEXT_VARIATION_PASSWORD

Use este código para cambiar la contraseña a texto y viceversa. Este código funcionó perfectamente para mí. Prueba esto..

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 es el controlador onClick completo para la Imagen / Botón para mostrar / ocultar la contraseña.

    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 función de alternancia de visibilidad de la contraseña se ha agregado para admitir la versión 24.2.0 de la biblioteca, lo que le permite alternar la contraseña directamente EditTextsin necesidad de a CheckBox.

Básicamente, puede hacer que funcione actualizando primero la versión de su biblioteca de soporte a 24.2.0 y luego estableciendo una inputTypecontraseña en TextInputEditText. Aquí se explica cómo hacerlo:

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

Puede obtener más información sobre la nueva función en la documentación del desarrollador para TextInputLayout .

Desde la biblioteca de soporte v24.2.0. puedes lograr esto muy fácil

Lo que debes hacer es simplemente:

1. Agregue la biblioteca de diseño a sus dependencias

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

2. Usar TextInputEditTexten conjunto 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 el atributo hará que aparezca el cambio de contraseña

3. En su diseño raíz, no olvide agregar xmlns:app="http://schemas.android.com/apk/res-auto"

4. Puede personalizar el cambio de contraseña usando:

app:passwordToggleDrawable- Dibujable para usar como el icono de alternancia de visibilidad de entrada de contraseña.
app:passwordToggleTint- Icono para usar para alternar la visibilidad de entrada de contraseña.
app:passwordToggleTintMode- Modo de fusión utilizado para aplicar el tinte de fondo.

Más detalles en la documentación de TextInputLayout .

Mi búsqueda de una solución similar para Visual Studio / Xamarin me llevó a este hilo. A continuación se muestra lo que funcionó para mí con Xamarin. Tenga en cuenta que esta implementación retiene el TYPE_TEXT_FLAG_NO_SUGGESTIONSindicador al cambiar de modo.

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

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

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

Para establecer la posición para finalizar: int position = et.Text.Length; et.SetSelection(position, position);

alguna situación dinámica holder.edit_pin.setInputType(InputType.TYPE_CLASS_NUMBER);no funcionará, así que mejor usa ambas cosas así

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

Nota: esto es adecuado para cuando utiliza controles dinámicos como el uso de arrayaapter

Después setInputTypede un campo de contraseña, tendrá un problema con FONT.
Aquí está mi solución para mostrar / ocultar contraseña sin problema de fuente

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 en InputType.TYPE_TEXT_VARIATION_PASSWORDlugar de InputType.TYPE_CLASS_TEXTo HideReturnsTransformationMethodporque quiero que el teclado muestre texto y número

MANIFESTACIÓN

Yo quitaría android:inputType="textPassword" de su diseño. Es por eso que está volviendo a la contraseña cuando cambia la orientación. Porque cada vez que cambia la orientación, se vuelve a crear la vista.

En cuanto al primer problema, intente esto:

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

básicamente vaciando el texto antes de cambiar el tipo de entrada y luego volver a agregarlo.

Complete el código cuando desee aplicar la visibilidad de contraseña en el texto de edición de contraseña.

Crear un identificador [Cualquier dibujo o casilla de verificación]

al hacer clic o al marcar / desmarcar, escriba esto:

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

No olvides escribir esta línea:

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

Restablece el cursor al final de la línea.

Cambio el tipo de entrada en mi casilla de verificación, así que en mi OnCheckedChangeListenersí:

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

Y finalmente funcionó.

Parece un problema booleano con TYPE_TEXT_VARIATION_VISIBLE_PASSWORD. Invierta la bandera y debería solucionar el problema.

En tu caso:

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

Utilice el método de transformación:

Esconder:

editText.transformationMethod = PasswordTransformationMethod.getInstance()

A visible:

editText.transformationMethod = SingleLineTransformationMethod.getInstance()

Eso es.

Solo un comentario adicional sobre la respuesta correcta proporcionada por @Rajkiran, es posible que desee agregar

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

al estado de entrada NORMAL para que los usuarios no se molesten por la sugerencia automática del teclado

Blockquote

final int [] cuenta = {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]--;
            }

        }
    });

Sobre la base de las respuestas de neeraj t y Everton Fernandes Rosario he escrito en Kotlin, donde passwordes un identificador de un EditarTexto en su diseño.

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