Cómo cambiar entre ocultar y ver contraseña

¿Existe una manera inteligente de permitir que el usuario cambie entre ocultar y ver la contraseña en un Android EditText? Varias aplicaciones basadas en PC permiten al usuario hacer esto.

Puede cambiar dinámicamente los atributos de un TextView. Si configurara el Atributo XML android:passworden verdadero, la vista mostraría puntos si lo configura en falso, se mostrará el texto.

Con el método setTransformationMethod deberías poder cambiar estos atributos del código. (Descargo de responsabilidad: no he probado si el método aún funciona después de que se muestra la vista. Si encuentra problemas con eso, déjeme un comentario para que lo sepa).

El código de muestra completo sería

yourTextView.setTransformationMethod(new PasswordTransformationMethod());

para ocultar la contraseña Para mostrar la contraseña, puede establecer uno de los métodos de transformación existentes o implementar un Método de transformación vacío que no hace nada con el texto de entrada.

yourTextView.setTransformationMethod(new DoNothingTransformation());

Es realmente fácil de lograr desde la Biblioteca de soporte v24.2.0.

Lo que debes hacer es simplemente:

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

   dependencies {
        compile "com.android.support:design:24.2.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:layout_marginBottom="@dimen/login_spacing_bottom">
   
       <android.support.design.widget.TextInputEditText
           android:id="@+id/etPassword"
           android:layout_width="match_parent"
           android:layout_height="wrap_content"
           android:hint="@string/fragment_login_password_hint"
           android:inputType="textPassword"/>
   </android.support.design.widget.TextInputLayout>

¡El passwordToggleEnabledatributo hará el trabajo!

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 .

Para AndroidX

• Reemplazar android.support.design.widget.TextInputLayoutconcom.google.android.material.textfield.TextInputLayout

• Reemplazar android.support.design.widget.TextInputEditTextconcom.google.android.material.textfield.TextInputEditText

Para mostrar los puntos en lugar de la contraseña, configure el Método de transformación de contraseña:

yourEditText.setTransformationMethod(new PasswordTransformationMethod());

por supuesto, puede configurar esto de manera predeterminada en su elemento edittext en el diseño xml con

android:password

Para volver a mostrar la contraseña legible, simplemente pase nulo como método de transformación:

yourEditText.setTransformationMethod(null);

Mostrar:

editText.setInputType(InputType.TYPE_TEXT_VARIATION_VISIBLE_PASSWORD);

Esconder:

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

Después de cada uno de estos, el cursor se reinicia, entonces:

editText.setSelection(editText.length());

Puedes usar app:passwordToggleEnabled="true"

Aquí hay un ejemplo a continuación

<android.support.design.widget.TextInputLayout
        android:id="@+id/password"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        app:passwordToggleEnabled="true"
        android:textColorHint="@color/colorhint"
        android:textColor="@color/colortext">

Use la casilla de verificación y cambie el tipo de entrada en consecuencia.

public void onCheckedChanged(CompoundButton buttonView, boolean isChecked) {
    int start,end;
    Log.i("inside checkbox chnge",""+isChecked);
    if(!isChecked){
        start=passWordEditText.getSelectionStart();
        end=passWordEditText.getSelectionEnd();
        passWordEditText.setTransformationMethod(new PasswordTransformationMethod());;
        passWordEditText.setSelection(start,end);
    }else{
        start=passWordEditText.getSelectionStart();
        end=passWordEditText.getSelectionEnd();
        passWordEditText.setTransformationMethod(null);
        passWordEditText.setSelection(start,end);
    }
}

private boolean isPasswordVisible;

private TextInputEditText firstEditText;

...

firstEditText = findViewById(R.id.et_first);

...

    private void togglePassVisability() {
    if (isPasswordVisible) {
        String pass = firstEditText.getText().toString();
        firstEditText.setTransformationMethod(PasswordTransformationMethod.getInstance());
        firstEditText.setInputType(InputType.TYPE_CLASS_TEXT | InputType.TYPE_TEXT_VARIATION_PASSWORD);
        firstEditText.setText(pass);
        firstEditText.setSelection(pass.length());           
    } else {
        String pass = firstEditText.getText().toString();
        firstEditText.setTransformationMethod(HideReturnsTransformationMethod.getInstance());
        firstEditText.setInputType(InputType.TYPE_CLASS_TEXT);
        firstEditText.setText(pass);
        firstEditText.setSelection(pass.length());
    }
    isPasswordVisible= !isPasswordVisible;
}

Es un trabajo para mí. Esto definitivamente te ayudará

showpass.setOnCheckedChangeListener(new OnCheckedChangeListener() {

            @Override
            public void onCheckedChanged(CompoundButton buttonView, boolean isChecked) {
                    if(!isChecked){

                    // show password
                    password_login.setTransformationMethod(PasswordTransformationMethod.getInstance());

                    Log.i("checker", "true");
                }

                else{
                    Log.i("checker", "false");

                     // hide password
    password_login.setTransformationMethod(HideReturnsTransformationMethod.getInstance());
                }

            }
        });

Siento que quiero responder a esta pregunta, incluso allí hay algunas buenas respuestas,

de acuerdo con la documentación Método de transformación hacer nuestra misión

Método de transformación

TextView usa TransformationMethods para hacer cosas como reemplazar los caracteres de las contraseñas con puntos, o evitar que los caracteres de nueva línea causen saltos de línea en los campos de texto de una sola línea.

Tenga en cuenta que uso un cuchillo de mantequilla, pero es lo mismo si la verificación del usuario muestra la contraseña

@OnCheckedChanged(R.id.showpass)
    public void onChecked(boolean checked){
        if(checked){
            et_password.setTransformationMethod(null);
        }else {
            et_password.setTransformationMethod(new PasswordTransformationMethod());
            
        }
       // cursor reset his position so we need set position to the end of text
        et_password.setSelection(et_password.getText().length());
    }

Puedo agregar el código ShowPassword / HidePassword con solo unas pocas líneas, independientes en un bloque:

protected void onCreate(Bundle savedInstanceState) {
    ...
    etPassword = (EditText)findViewById(R.id.password);
    etPassword.setTransformationMethod(new PasswordTransformationMethod()); // Hide password initially

    checkBoxShowPwd = (CheckBox)findViewById(R.id.checkBoxShowPwd);
    checkBoxShowPwd.setText(getString(R.string.label_show_password)); // Hide initially, but prompting "Show Password"
    checkBoxShowPwd.setOnCheckedChangeListener( new CompoundButton.OnCheckedChangeListener() {
        public void onCheckedChanged(CompoundButton arg0, boolean isChecked) {
            if (isChecked) {
                etPassword.setTransformationMethod(null); // Show password when box checked
                checkBoxShowPwd.setText(getString(R.string.label_hide_password)); // Prompting "Hide Password"
            } else {
                etPassword.setTransformationMethod(new PasswordTransformationMethod()); // Hide password when box not checked
                checkBoxShowPwd.setText(getString(R.string.label_show_password)); // Prompting "Show Password"
            }
        }
    } );
    ...

Tuve el mismo problema y es muy fácil de implementar.

Todo lo que tiene que hacer es ajustar su campo EditText en un (com.google.android.material.textfield.TextInputLayout) y en ese complemento (app: passwordToggleEnabled = "true").

Esto mostrará el ojo en el campo EditText y cuando haga clic en él, la contraseña aparecerá y desaparecerá al hacer clic nuevamente.

<com.google.android.material.textfield.TextInputLayout
                android:layout_width="match_parent"
                android:layout_height="match_parent"
                android:textColorHint="#B9B8B8"
                app:passwordToggleEnabled="true">

                <EditText
                    android:id="@+id/register_password"
                    android:layout_width="match_parent"
                    android:layout_height="wrap_content"
                    android:layout_marginLeft="24dp"
                    android:layout_marginRight="44dp"
                    android:backgroundTint="#BEBEBE"
                    android:hint="Password"
                    android:inputType="textPassword"
                    android:padding="16dp"
                    android:textSize="18sp" />
            </com.google.android.material.textfield.TextInputLayout>

private int passwordNotVisible=1; 
  @Override
  protected void onCreate(Bundle savedInstanceState) {
 showPassword = (ImageView) findViewById(R.id.show_password);
    showPassword.setOnClickListener(new View.OnClickListener() {
        @Override
        public void onClick(View v) {
            EditText paswword = (EditText) findViewById(R.id.Password);
            if (passwordNotVisible == 1) {
                paswword.setInputType(InputType.TYPE_TEXT_VARIATION_VISIBLE_PASSWORD);
                passwordNotVisible = 0;
            } else {

                paswword.setInputType(InputType.TYPE_CLASS_TEXT | InputType.TYPE_TEXT_VARIATION_PASSWORD);
                passwordNotVisible = 1;
            }


            paswword.setSelection(paswword.length());

        }
    });
}

En forma muy simple:

private fun updatePasswordVisibility(editText: AppCompatEditText) {
        if (editText.transformationMethod is PasswordTransformationMethod) {
            editText.transformationMethod = null
        } else {
            editText.transformationMethod = PasswordTransformationMethod()
        }
        editText.setSelection(editText.length())
    }

Espero eso ayude.

Puede MOSTRAR / OCULTAR la contraseña utilizando este código a continuación:

CÓDIGO XML:

<EditText
        android:id="@+id/etPassword"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_marginLeft="21dp"
        android:layout_marginTop="14dp"
        android:ems="10"
        android:inputType="textPassword" >
        <requestFocus />
    </EditText>
    <CheckBox
        android:id="@+id/cbShowPwd"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_alignLeft="@+id/etPassword"
        android:layout_below="@+id/etPassword"
        android:text="@string/show_pwd" />

CÓDIGO JAVA:

EditText mEtPwd;
CheckBox mCbShowPwd;


mEtPwd = (EditText) findViewById(R.id.etPassword);
mCbShowPwd = (CheckBox) findViewById(R.id.cbShowPwd);

mCbShowPwd.setOnCheckedChangeListener(new CompoundButton.OnCheckedChangeListener() {
    @Override
    public void onCheckedChanged(CompoundButton buttonView, boolean isChecked) {
        // checkbox status is changed from uncheck to checked.
        if (!isChecked) {
            // show password
            mEtPwd.setTransformationMethod(PasswordTransformationMethod.getInstance());
        } else {
            // hide password
            mEtPwd.setTransformationMethod(HideReturnsTransformationMethod.getInstance());
        }
    }
});

Prueba esto:

Primero defina una bandera como global de esta manera:

private boolean isShowPassword = false;

Y configure el oyente para que maneje el botón Mostrar y ocultar el botón de contraseña:

imgPassword.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                if (isShowPassword) {
                    etPassword.setTransformationMethod(new PasswordTransformationMethod());
                    imgPassword.setImageDrawable(getResources().getDrawable(R.drawable.ic_eye_hide));
                    isShowPassword = false;
                }else{
                    etPassword.setTransformationMethod(null);
                    imgPassword.setImageDrawable(getResources().getDrawable(R.drawable.ic_eye_show));
                    isShowPassword = true;
                }
            }
        });

Pruebe el proyecto https://github.com/maksim88/PasswordEditText en github. Ni siquiera necesita cambiar su código Java utilizándolo. Solo cambia

Editar texto

etiquetar a

com.maksim88.passwordedittext.PasswordEditText

en tu archivo XML.

mostrar y ocultar contraseña Edit_Text con casilla de verificación

XML

<?xml version="1.0" encoding="utf-8"?>
<RelativeLayout
    xmlns:android="http://schemas.android.com/apk/res/android" android:layout_width="match_parent"
    android:layout_height="match_parent">

    <EditText
        android:inputType="textPassword"
        android:id="@+id/edtPass"
        android:textSize="20dp"
        android:hint="password"
        android:padding="20dp"
        android:background="#efeaea"
        android:layout_width="match_parent"
        android:layout_margin="20dp"
        android:layout_height="wrap_content" />

    <CheckBox
        android:background="#ff4"
        android:layout_centerInParent="true"
        android:textSize="25dp"
        android:text="show password"
        android:layout_below="@id/edtPass"
        android:id="@+id/showPassword"
        android:layout_marginTop="20dp"
        android:layout_width="wrap_content"
        android:gravity="top|right"
        android:layout_height="wrap_content" />

</RelativeLayout>

código java

package com.example.root.sql2;

import android.annotation.SuppressLint;
import android.os.Bundle;
import android.support.design.widget.FloatingActionButton;
import android.support.design.widget.Snackbar;
import android.support.v7.app.AppCompatActivity;
import android.support.v7.widget.AppCompatCheckBox;
import android.support.v7.widget.Toolbar;
import android.text.method.HideReturnsTransformationMethod;
import android.text.method.PasswordTransformationMethod;
import android.view.View;
import android.widget.CheckBox;
import android.widget.CompoundButton;
import android.widget.EditText;

public class password extends AppCompatActivity {


    EditText password;
    CheckBox show_hide_password;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.hide);
        findViewById();
        show_hide_pass();



    }//end onCreate



    public void show_hide_pass(){
        show_hide_password.setOnCheckedChangeListener(new CompoundButton.OnCheckedChangeListener() {
            @Override
            public void onCheckedChanged(CompoundButton compoundButton, boolean b) {
                if (!b){
                    // hide password
                    password.setTransformationMethod(PasswordTransformationMethod.getInstance());

                }else{
                    // show password
                    password.setTransformationMethod(HideReturnsTransformationMethod.getInstance());
                }
            }
        });
    } // end show_hide_pass




    public void findViewById(){ //  find ids ui and
        password = (EditText) findViewById(R.id.edtPass);
        show_hide_password = (CheckBox) findViewById(R.id.showPassword);
    }//end findViewById



}// end class

¿Intentaste con setTransformationMethod? Se hereda de TextView y desea un TransformationMethod como parámetro.

Puede encontrar más información sobre los métodos de transformación aquí .

También tiene algunas características interesantes, como el reemplazo de personajes.

Lo que hice fue

1. Crear una vista de edición de texto y una vista de texto normal
2. Haga que se superpongan entre sí mediante el diseño de restricción (al igual que la pantalla de inicio de sesión de la aplicación de Facebook)
3. Adjunte un onClickListener a la vista de texto normal para que cambie el tipo de entrada de la vista de edición de texto en consecuencia (Visible / No visible)

Puede ver este video para ver los pasos y explicaciones más detallados https://youtu.be/md3eVaRzdIM

Espero eso ayude :)

Aquí está mi solución sin usar TextInputEditText y el método de transformación.

XML

<LinearLayout
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:orientation="vertical">

        <TextView
            style="@style/FormLabel"
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:text="@string/username" />

        <EditText
            android:id="@+id/loginUsername"
            style="@style/EditTextStyle"
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:drawableLeft="@drawable/ic_person_outline_black_24dp"
            android:drawableStart="@drawable/ic_person_outline_black_24dp"
            android:inputType="textEmailAddress"
            android:textColor="@color/black" />

        <TextView
            style="@style/FormLabel"
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:layout_marginTop="20dp"
            android:text="@string/password" />

        <EditText
            android:id="@+id/loginPassword"
            style="@style/EditTextStyle"
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:drawableEnd="@drawable/ic_visibility_off_black_24dp"
            android:drawableLeft="@drawable/ic_lock_outline_black_24dp"
            android:drawableRight="@drawable/ic_visibility_off_black_24dp"
            android:drawableStart="@drawable/ic_lock_outline_black_24dp"
            android:inputType="textPassword"
            android:textColor="@color/black" />
    </LinearLayout>

Código Java

boolean VISIBLE_PASSWORD = false;  //declare as global variable befor onCreate() 
loginPassword = (EditText)findViewById(R.id.loginPassword);
loginPassword.setOnTouchListener(new View.OnTouchListener() {
        public boolean onTouch(View v, MotionEvent event) {
            final int DRAWABLE_LEFT = 0;
            final int DRAWABLE_TOP = 1;
            final int DRAWABLE_RIGHT = 2;
            final int DRAWABLE_BOTTOM = 3;

            if (event.getAction() == MotionEvent.ACTION_UP) {
                if (event.getRawX() >= (loginPassword.getRight() - loginPassword.getCompoundDrawables()[DRAWABLE_RIGHT].getBounds().width())) {
                    // your action here
                    //Helper.toast(LoginActivity.this, "Toggle visibility");
                    if (VISIBLE_PASSWORD) {
                        VISIBLE_PASSWORD = false;
                        loginPassword.setInputType(InputType.TYPE_CLASS_TEXT | InputType.TYPE_TEXT_VARIATION_PASSWORD);
                        loginPassword.setCompoundDrawablesWithIntrinsicBounds(R.drawable.ic_lock_outline_black_24dp, 0, R.drawable.ic_visibility_off_black_24dp, 0);
                    } else {
                        VISIBLE_PASSWORD = true;
                        loginPassword.setInputType(InputType.TYPE_CLASS_TEXT);
                        loginPassword.setCompoundDrawablesWithIntrinsicBounds(R.drawable.ic_lock_outline_black_24dp, 0, R.drawable.ic_visibility_black_24dp, 0);
                    }
                    return false;
                }
            }
            return false;
        }
    });

Según esta fuente , si ha migrado su proyecto a AndroidX, puede reemplazar

compile "com.android.support:design:24.2.0"

con

implementation "com.google.android.material:material:1.0.0"

Entonces todo lo que tiene que hacer es poner el código a continuación en su archivo de diseño:

<com.google.android.material.textfield.TextInputLayout
    android:layout_width="match_parent"
    android:layout_height="wrap_content"
    app:passwordToggleEnabled="true"
    android:hint="@string/hint_text">

  <com.google.android.material.textfield.TextInputEditText
      android:layout_width="match_parent"
      android:layout_height="wrap_content"/>

</com.google.android.material.textfield.TextInputLayout>

TextInputLayoutPuede encontrar más información sobre el material aquí .

A esta fuente , se recomienda migrar a AndroidX desde la Biblioteca de soporte de Android:

AndroidX es el proyecto de código abierto que el equipo de Android utiliza para desarrollar, probar, empaquetar, versionar y lanzar bibliotecas dentro de Jetpack.

AndroidX es una mejora importante para la biblioteca original de soporte de Android. Al igual que la Biblioteca de soporte, AndroidX se envía por separado del sistema operativo Android y ofrece compatibilidad con versiones anteriores de Android. AndroidX reemplaza completamente la Biblioteca de soporte al proporcionar paridad de funciones y nuevas bibliotecas. Además, AndroidX incluye las siguientes características:

Todos los paquetes en AndroidX viven en un espacio de nombres consistente que comienza con la cadena androidx. Los paquetes de la biblioteca de soporte se han mapeado en los correspondientes paquetes androidx. *. Para obtener una asignación completa de todas las clases antiguas y crear artefactos con las nuevas, consulte la página Refactorización de paquetes.

A diferencia de la Biblioteca de soporte, los paquetes de AndroidX se mantienen y actualizan por separado. Los paquetes de androidx usan versiones semánticas estrictas a partir de la versión 1.0.0. Puede actualizar las bibliotecas de AndroidX en su proyecto de forma independiente.

Todo el nuevo desarrollo de la biblioteca de soporte se realizará en la biblioteca de AndroidX. Esto incluye el mantenimiento de los artefactos originales de la Biblioteca de soporte y la introducción de nuevos componentes de Jetpack.

Al principio, esta es la pantalla cargada con un vector de imagen de visibilidad de activos

al hacer clic cambiará a esta visibilidad de imagen desactivada

código para el cambio de contraseña anterior (código xml)

<androidx.constraintlayout.widget.ConstraintLayout
    android:id="@+id/laypass"
    android:layout_width="330dp"
    android:layout_height="50dp"
    android:layout_marginTop="24dp"
    app:layout_constraintEnd_toEndOf="@+id/editText3"
    app:layout_constraintStart_toStartOf="@+id/editText3"
    app:layout_constraintTop_toBottomOf="@+id/editText3">

    <EditText
        android:id="@+id/edit_password"
        style="@style/EditTextTheme"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:background="@drawable/round"
        android:drawableLeft="@drawable/ic_password"
        android:drawablePadding="10dp"
        android:ems="10"
        android:hint="Password"
        android:inputType="textPassword"
        android:paddingLeft="10dp"
        android:paddingRight="15dp"
        android:textColor="@color/cyan92a6"
        android:textColorHint="@color/cyan92a6"
        android:textCursorDrawable="@null"
        android:textSize="18sp"
        />

    <ImageView
        android:id="@+id/show_pass_btn"
        android:layout_width="40dp"
        android:layout_height="40dp"
        android:layout_alignParentRight="true"
        android:layout_centerVertical="true"
        android:layout_marginEnd="8dp"
        android:alpha=".5"
        android:onClick="ShowHidePass"
        android:padding="5dp"
        android:src="@drawable/ic_visibility"
        app:layout_constraintBottom_toBottomOf="parent"
        app:layout_constraintEnd_toEndOf="@+id/laypass"
        app:layout_constraintTop_toTopOf="@+id/edit_password" /> 
 </androidx.constraintlayout.widget.ConstraintLayout>

Código Java para operación de botones

public void ShowHidePass(View view) {

    if(view.getId()==R.id.show_pass_btn){
        if(edit_password.getTransformationMethod().equals(PasswordTransformationMethod.getInstance())){
            ((ImageView)(view)).setImageResource(R.drawable.ic_visibility_off);
            //Show Password
            edit_password.setTransformationMethod(HideReturnsTransformationMethod.getInstance());
        }
        else{
            ((ImageView)(view)).setImageResource(R.drawable.ic_visibility);
            //Hide Password
            edit_password.setTransformationMethod(PasswordTransformationMethod.getInstance());
        }
    }
}

En XML haz esto

    <LinearLayout
          android:layout_height="wrap_content"
          android:layout_width="fill_parent"
          android:orientation="vertical"
          >
          <RelativeLayout
              android:id="@+id/REFReLayTellFriend"
              android:layout_width="match_parent"
              android:layout_height="wrap_content"
              android:orientation="horizontal"
              >
          <EditText
              android:id="@+id/etpass1"
              android:layout_width="fill_parent"
              android:layout_height="wrap_content"
              android:background="@android:color/transparent"
              android:bottomLeftRadius="10dp"
              android:bottomRightRadius="50dp"
              android:fontFamily="@font/frutiger"
              android:gravity="start"
              android:inputType="textPassword"
              android:hint="@string/regpass_pass1"
              android:padding="20dp"
              android:paddingBottom="10dp"
              android:textColor="#000000"
              android:textColorHint="#d3d3d3"
              android:textSize="14sp"
              android:topLeftRadius="10dp"
              android:topRightRadius="10dp"/>
              <ImageButton
                  android:id="@+id/imgshowhide1"
                  android:layout_width="40dp"
                  android:layout_height="20dp"
                  android:layout_marginTop="20dp"
                  android:layout_marginRight="10dp"
                  android:background="@drawable/showpass"
                  android:layout_alignRight="@+id/etpass1"/>
          </RelativeLayout>    

 boolean show=true;
 //on image click inside password do this
 if(show){
                imgshowhide2.setBackgroundResource(0);
                imgshowhide2.setBackgroundResource(R.drawable.hide);
                etpass2.setInputType(InputType.TYPE_TEXT_VARIATION_VISIBLE_PASSWORD);
                etpass2.setSelection(etpass2.getText().length());

                show=false;
            }else{
                imgshowhide2.setBackgroundResource(0);
                imgshowhide2.setBackgroundResource(R.drawable.showpass);
                //etpass1.setInputType(InputType.TYPE_TEXT);
                etpass2.setInputType(InputType.TYPE_CLASS_TEXT |
                        InputType.TYPE_TEXT_VARIATION_PASSWORD);
                etpass2.setSelection(etpass2.getText().length());
                show=true;
            }

Mi extensión de Kotlin. escribir una vez usar en todas partes

fun EditText.tooglePassWord() {
this.tag = !((this.tag ?: false) as Boolean)
this.inputType = if (this.tag as Boolean)
    InputType.TYPE_TEXT_VARIATION_PASSWORD
else
    (InputType.TYPE_CLASS_TEXT or InputType.TYPE_TEXT_VARIATION_PASSWORD)

this.setSelection(this.length()) }

Puede mantener este método en cualquier archivo y usarlo en todas partes, usarlo así

ivShowPassword.click { etPassword.tooglePassWord() }

donde ivShowPassword se hace clic en la vista de imagen (ojo) y etPassword es Editext

Una buena solucion. Configure un botón, luego use este código:

public void showPassword(View v)
{

    TextView showHideBtnText = (TextView) findViewById(R.id.textView1);

    if(showHideBtnText.getText().toString().equals("Show Password")){
        password.setTransformationMethod(null);
        showHideBtnText.setText("Hide");
    } else{
        password.setTransformationMethod(new PasswordTransformationMethod());
        showHideBtnText.setText("Show Password");
    }


}

Agrega este método:

fun EditText.revertTransformation() {
    transformationMethod = when(transformationMethod) {
        is PasswordTransformationMethod -> SingleLineTransformationMethod.getInstance()
        else -> PasswordTransformationMethod.getInstance()
    }
}

Llamarlo cambiará entre el estado del tipo de entrada (puede cambiar la transformación de una sola línea a su favorito). Ejemplo de uso:

editText.revertTransformation()

1> Make a selector file "show_password_selector.xml".

<selector xmlns:android="http://schemas.android.com/apk/res/android">
    <item android:drawable="@drawable/pwd_hide"
        android:state_selected="true"/>
    <item android:drawable="@drawable/pwd_show"
        android:state_selected="false" />
</selector>

2>set "show_password_selector" file into imageview.

<ImageView
                        android:id="@+id/iv_pwd"
                        android:layout_width="@dimen/_35sdp"
                        android:layout_height="@dimen/_25sdp"
                        android:layout_alignParentRight="true"
                        android:layout_centerVertical="true"
                        android:layout_marginRight="@dimen/_15sdp"
                        android:src="@drawable/show_password_selector" />

3> put below code in java file.
  iv_new_pwd.setOnClickListener(new View.OnClickListener() {
        @Override
        public void onClick(View v) {
            if (iv_new_pwd.isSelected()) {
                iv_new_pwd.setSelected(false);
                Log.d("mytag", "in case 1");
                edt_new_pwd.setInputType(InputType.TYPE_CLASS_TEXT);
            } else {
                Log.d("mytag", "in case 1");
                iv_new_pwd.setSelected(true);
                edt_new_pwd.setInputType(InputType.TYPE_CLASS_TEXT | InputType.TYPE_TEXT_VARIATION_PASSWORD);
            }
        }
    });

1> Make a selector file "show_password_selector.xml".

<selector xmlns:android="http://schemas.android.com/apk/res/android">
    <item android:drawable="@drawable/pwd_hide"
        android:state_selected="true"/>
    <item android:drawable="@drawable/pwd_show"
        android:state_selected="false" />
</selector>

2>set "show_password_selector" file into imageview.

<ImageView
                        android:id="@+id/iv_pwd"
                        android:layout_width="@dimen/_35sdp"
                        android:layout_height="@dimen/_25sdp"
                        android:layout_alignParentRight="true"
                        android:layout_centerVertical="true"
                        android:layout_marginRight="@dimen/_15sdp"
                        android:src="@drawable/show_password_selector" />

3> put below code in java file.
  iv_new_pwd.setOnClickListener(new View.OnClickListener() {
        @Override
        public void onClick(View v) {
            if (iv_new_pwd.isSelected()) {
                iv_new_pwd.setSelected(false);
                Log.d("mytag", "in case 1");
                edt_new_pwd.setInputType(InputType.TYPE_CLASS_TEXT);
            } else {
                Log.d("mytag", "in case 1");
                iv_new_pwd.setSelected(true);
                edt_new_pwd.setInputType(InputType.TYPE_CLASS_TEXT | InputType.TYPE_TEXT_VARIATION_PASSWORD);
            }
        }
    });

if (inputPassword.getTransformationMethod() == PasswordTransformationMethod.getInstance()) {
 //password is visible
                inputPassword.setTransformationMethod(HideReturnsTransformationMethod.getInstance());
            }
else if(inputPassword.getTransformationMethod() == HideReturnsTransformationMethod.getInstance()) {
 //password is hidden
                inputPassword.setTransformationMethod(PasswordTransformationMethod.getInstance());
            }