Ändern Sie programmgesteuert den Eingabetyp des EditText von PASSWORD in NORMAL und umgekehrt

In meiner Anwendung habe ich einen, EditTextdessen Standardeingabetyp android:inputType="textPassword"von deault eingestellt ist. Es hat eine CheckBoxauf ihr Recht, die , wenn sie aktiviert ist, ändert sich die Eingabetyp des EditText auf NORMAL KLARTEXT. Code dafür ist

password.setInputType(InputType.TYPE_TEXT_VARIATION_VISIBLE_PASSWORD);

Mein Problem ist, wenn diese CheckBox deaktiviert ist, sollte sie den Eingabetyp wieder auf PASSWORD setzen. Ich habe es gemacht mit-

password.setInputType(InputType.TYPE_TEXT_VARIATION_PASSWORD);

Der Text in diesem Edittext ist jedoch weiterhin sichtbar. Und überraschenderweise wird beim Ändern der Ausrichtung der Eingabetyp automatisch auf PASSWORT gesetzt, und der darin enthaltene Text wird mit Aufzählungszeichen versehen (wie ein Kennwort angezeigt).

Wie kann man das erreichen?

Nur für die Leute, die das gleiche Problem haben. Fügen Sie diesem EditText einfach programmgesteuert ein zusätzliches Attribut hinzu, und schon sind Sie fertig.

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

Für numerisches Passwort (PIN).

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

Stellen Sie außerdem sicher, dass sich der Cursor am Ende des Textes im EditText befindet. Denn wenn Sie den Eingabetyp ändern, wird der Cursor automatisch auf den Startpunkt gesetzt. Daher schlage ich vor, den folgenden Code zu verwenden:

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

Bei Verwendung der Datenbindung können Sie den folgenden Code verwenden

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

Wenn Sie Kotlin verwenden,

password.inputType = InputType.TYPE_CLASS_TEXT or InputType.TYPE_TEXT_VARIATION_PASSWORD

Verwenden Sie diesen Code, um das Passwort in Text zu ändern und umgekehrt

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

Den vollständigen Beispielcode finden Sie unter 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);

Die obige Methode hat bei mir nicht wirklich funktioniert. Antwort unten funktioniert für 2.2 sdk.

password.setTransformationMethod (PasswordTransformationMethod.getInstance ());

InputType für einen EditText festlegen?

Ein weiteres einfaches Beispiel für die Verwendung von ImageView zum Umschalten der Sichtbarkeit mit weniger Code. Aufgrund der einzelnen Zuweisung von InputType benötigen wir nur den Gleichheitsoperator:

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

Ersetzen:

InputType.TYPE_TEXT_VARIATION_VISIBLE_PASSWORD

Mit:

InputType.TYPE_CLASS_TEXT

Gibt das gleiche Ergebnis, aber kürzeres Wort.

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

Das hat bei mir funktioniert:

mytext.setInputType(InputType.TYPE_CLASS_NUMBER);

Ok Also nach stundenlangem Versuch endlich implementiert. Unten ist der Code ..

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

    }
});

Erläuterungen: - Ich habe eine Schaltfläche mit Standardtext als Show. Nach dem Klicken auf das Ereignis wird überprüft, ob der Text der Schaltfläche angezeigt wird. Wenn es angezeigt wird, ändern Sie den Eingabetyp, passen Sie die Cursorposition an und setzen Sie neuen Text als darin ausgeblendet.

Wenn es ausgeblendet ist ... machen Sie es umgekehrt, dh verstecken Sie das Passwort, passen Sie den Cursor an und setzen Sie den Text wie gezeigt. Und das ist es. Es funktioniert wie ein Zauber.

Für Kotlin-Benutzer:

password.inputType = InputType.TYPE_CLASS_TEXT or InputType.TYPE_TEXT_VARIATION_PASSWORD

Verwenden Sie diesen Code, um das Passwort in Text zu ändern und umgekehrt. Dieser Code hat bei mir perfekt funktioniert. Versuche dies..

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

}
});

Dies ist der vollständige onClick-Handler für das Bild / die Schaltfläche zum Ein- / Ausblenden des Kennworts.

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

Die Funktion zum Umschalten der Kennwortsichtbarkeit wurde hinzugefügt, um die Bibliotheksversion 24.2.0 zu unterstützen, mit der Sie das Kennwort direkt von der umschalten können, EditTextohne dass ein erforderlich ist CheckBox.

Sie können dies im Grunde tun, indem Sie zuerst Ihre Support-Bibliotheksversion auf 24.2.0 aktualisieren und dann ein inputTypeKennwort für das festlegen TextInputEditText. So geht's:

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

Weitere Informationen zu der neuen Funktion finden Sie in der Entwicklerdokumentation für TextInputLayout .

Seit der Support Library v24.2.0. Sie können dies sehr einfach erreichen

Was Sie tun müssen, ist nur:

1. Fügen Sie die Designbibliothek Ihren Abhängigkeiten hinzu

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

2. Verwendung TextInputEditTextin Verbindung mitTextInputLayout

   <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 Durch das Attribut wird das Umschalten des Kennworts angezeigt

3. Vergessen Sie nicht, in Ihrem Root-Layout hinzuzufügen xmlns:app="http://schemas.android.com/apk/res-auto"

4. Sie können Ihr Passwort umschalten, indem Sie Folgendes verwenden:

app:passwordToggleDrawable- Zeichnbar, um als Symbol für die Sichtbarkeit der Passworteingabe verwendet zu werden.
app:passwordToggleTint- Symbol zum Umschalten der Sichtbarkeit der Passworteingabe.
app:passwordToggleTintMode- Mischmodus zum Anwenden der Hintergrundfarbe.

Weitere Details finden Sie in der TextInputLayout-Dokumentation .

Meine Suche nach einer ähnlichen Lösung für Visual Studio / Xamarin führte mich zu diesem Thread. Nachfolgend sehen Sie, was bei mir mit Xamarin funktioniert hat. Beachten Sie, dass diese Implementierung TYPE_TEXT_FLAG_NO_SUGGESTIONSbeim Umschalten zwischen den Modi das Flag beibehält .

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

So zeigen Sie Charaktere an: et.InputType = Android.Text.InputTypes.TextVariationVisiblePassword | Android.Text.InputTypes.TextFlagNoSuggestions;

So verstecken Sie Zeichen: et.InputType = Android.Text.InputTypes.TextVariationPassword | Android.Text.InputTypes.ClassText;

So setzen Sie die Position auf Ende: int position = et.Text.Length; et.SetSelection(position, position);

Einige dynamische Situationen holder.edit_pin.setInputType(InputType.TYPE_CLASS_NUMBER);funktionieren nicht, also nutzen Sie beide so besser

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

Hinweis: Dies ist geeignet, wenn Sie dynamische Steuerelemente wie Arrayaapter verwenden

Nachdem Sie setInputTypeein Passwortfeld eingegeben haben, haben Sie ein Problem mit FONT.
Hier ist meine Lösung für das Ein- / Ausblenden von Passwörtern ohne Schriftartproblem

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

Hinweis: Ich verwende InputType.TYPE_TEXT_VARIATION_PASSWORDanstelle von InputType.TYPE_CLASS_TEXToder, HideReturnsTransformationMethodweil die Tastatur sowohl Text als auch Zahlen anzeigen soll

DEMO

Ich würde entfernen android:inputType="textPassword" aus Ihrem Layout . Aus diesem Grund wird beim Ändern der Ausrichtung wieder auf das Kennwort umgeschaltet. Denn jedes Mal, wenn sich die Ausrichtung ändert, wird die Ansicht neu erstellt.

Versuchen Sie Folgendes für das erste Problem:

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

Entleeren Sie im Grunde den Text, bevor Sie den Eingabetyp ändern und ihn dann wieder hinzufügen.

Vervollständigen Sie den Code, wenn Sie die Kennwortsichtbarkeit im Text zum Bearbeiten von Kennwörtern anwenden möchten.

Erstellen Sie ein Handle [Beliebiges Zeichen- oder Kontrollkästchen]

Klicken Sie auf oder auf Aktiviert / Deaktiviert und schreiben Sie Folgendes:

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

Vergessen Sie nicht, diese Zeile zu schreiben:

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

Der Cursor wird auf das Zeilenende zurückgesetzt.

Ich ändere den Eingabetyp in meinem Kontrollkästchen, also OnCheckedChangeListenermache ich Folgendes :

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

Und es hat endlich funktioniert.

Scheint ein boolesches Problem mit TYPE_TEXT_VARIATION_VISIBLE_PASSWORD . Invertieren Sie das Flag und es sollte das Problem beheben.

In deinem Fall:

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

Transformationsmethode verwenden:

Verstecken:

editText.transformationMethod = PasswordTransformationMethod.getInstance()

Zu sehen:

editText.transformationMethod = SingleLineTransformationMethod.getInstance()

Das ist es.

Nur ein zusätzlicher Kommentar zur richtigen Antwort von @Rajkiran, möchten Sie vielleicht hinzufügen

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

in den NORMAL-Eingabestatus, damit sich die Benutzer nicht über den automatischen Vorschlag der Tastatur ärgern

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

        }
    });

Basierend auf den Antworten von neeraj t und Everton Fernandes Rosario habe ich in Kotlin geschrieben, wo passwordsich eine ID eines EditText in Ihrem Layout befindet.

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