Machen Sie EditText ReadOnly

Ich möchte eine schreibgeschützte EditTextAnsicht erstellen. Das XML für diesen Code scheint zu sein android:editable="false", aber ich möchte dies im Code tun.

Wie kann ich das machen?

Bitte benutzen Sie diesen Code ..

Edittext.setEnabled(false);

Wenn Sie setEnabled(false)dann editTextdeaktiviert aussehen würden (grau usw.). Möglicherweise möchten Sie den visuellen Aspekt Ihres Editors nicht ändern.

Ein weniger aufdringlicher Weg wäre zu verwenden setFocusable(false).

Ich glaube, dass dies Ihre Frage näher an Ihrer ursprünglichen Absicht beantwortet.

In XMLGebrauch:

android:editable="false"

Als Beispiel:

<EditText
    android:id="@+id/EditText1"
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    android:editable="false" />

Das funktioniert bei mir:

EditText.setKeyListener(null);

Das Beste ist, TextViewstattdessen zu verwenden.

editText.setInputType(InputType.TYPE_NULL);

Gemäß den Dokumenten dadurch verhindert, dass die Softtastatur angezeigt wird. Es verhindert auch das Einfügen, ermöglicht das Scrollen und ändert den visuellen Aspekt der Ansicht nicht. Dies verhindert jedoch auch das Auswählen und Kopieren des Texts in der Ansicht.

Aus meinen -tests setInputTypezu TYPE_NULLscheint funktional äquivalent zu dem abgeschrieben zu werden android:editable="false". Darüber hinaus android:inputType="none"scheint keine spürbare Wirkung zu haben.

android: editable = "false" ist veraltet. Daher können Sie es nicht verwenden, um den Bearbeitungstext schreibgeschützt zu machen.

Ich habe dies mit der folgenden Lösung gemacht. Hier habe ich benutzt

android: inputType = "keine"

android: textIsSelectable = "true"

android: focusable = "false"

Probieren Sie es aus :)

<EditText
         android:id="@+id/et_newsgpa_university"
         android:layout_height="wrap_content"
         android:layout_width="match_parent"
         android:hint="@string/hint_educational_institute"
         android:textSize="@dimen/regular_text"
         android:inputType="none"
         android:textIsSelectable="true"
         android:focusable="false"
         android:maxLines="1"
         android:imeOptions="actionNext"/>

editText.setEnabled(false);
editText.setFilters(new InputFilter[] { new InputFilter() {
    public CharSequence filter(CharSequence src, int start, int end,
            Spanned dst, int dstart, int dend) {
        return src.length() < 1 ? dst.subSequence(dstart, dend) : "";
    }
} });

Dadurch erhalten Sie einen nicht bearbeitbaren EditText-Filter. Sie müssen zuerst den gewünschten Text in das Feld editText einfügen und dann diesen Filter anwenden.

Das Schreiben dieser beiden Zeilen ist mehr als genug für Ihre Arbeit.

yourEditText.setKeyListener(null); 
yourEditText.setEnabled(false);

in XML eingestellt

android:inputType="none" 

Versuchen Sie es mit

editText.setEnabled(false);
editText.setClickable(false);

android:editable

Wenn gesetzt, gibt dies an, dass dies TextVieweine Eingabemethode hat. Sofern nicht anders angegeben, handelt es sich um einen Text. Für TextView, ist dies standardmäßig falsch. Denn EditTextes ist standardmäßig wahr.

Muss ein booleanWert sein, entweder trueoder false.

Dies kann auch ein Verweis auf eine Ressource (im Formular @[package:]type:name) oder ein Themenattribut (im Formular ?[package:][type:]name) sein, die einen Wert dieses Typs enthält.

Dies entspricht dem bearbeitbaren globalen Attributressourcensymbol.

Verwandte Methoden

Versuchen Sie, den onLongClick-Listener des Bearbeitungstextes zu überschreiben, um das Kontextmenü zu entfernen:

EditText myTextField = (EditText)findViewById(R.id.my_edit_text_id);
myTextField.setOnLongClickListener(new OnLongClickListener() {
    @Override
    public boolean onLongClick(View v) {
        return true;
    }
});

Verwenden Sie diesen Code:

editText.setEnabled(false);
editText.setTextColor(ContextCompat.getColor(context, R.color.black);

Deaktivieren editText wird ein schreibgeschütztes Erscheinungsbild das jedoch auch text-colorin Grau geändert wird , sodass die Textfarbe festgelegt werden muss.

Dies ist meine Implementierung (etwas lang, aber nützlich für mich!): Mit diesem Code können Sie EditView schreibgeschützt oder normal machen. Selbst im schreibgeschützten Zustand kann der Text vom Benutzer kopiert werden. Sie können den Hintergrund ändern, damit er sich von einem normalen EditText unterscheidet.

public static TextWatcher setReadOnly(final EditText edt, final boolean readOnlyState, TextWatcher remove) {
    edt.setCursorVisible(!readOnlyState);
    TextWatcher tw = null;
    final String text = edt.getText().toString();
    if (readOnlyState) {
            tw = new TextWatcher();

            @Override
            public void afterTextChanged(Editable s) {

            }
            @Override
            //saving the text before change
            public void beforeTextChanged(CharSequence s, int start, int count, int after) {
            }

            @Override
            // and replace it with content if it is about to change
            public void onTextChanged(CharSequence s, int start,int before, int count) {
                edt.removeTextChangedListener(this);
                edt.setText(text);
                edt.addTextChangedListener(this);
            }
        };
        edt.addTextChangedListener(tw);
        return tw;
    } else {
        edt.removeTextChangedListener(remove);
        return remove;
    }
}

Der Vorteil dieses Codes besteht darin, dass der EditText als normaler EditText angezeigt wird, der Inhalt jedoch nicht geändert werden kann. Der Rückgabewert sollte als Variable beibehalten werden, damit der schreibgeschützte Zustand wieder normal wird.

Um einen EditText schreibgeschützt zu machen, geben Sie ihn einfach wie folgt ein:

TextWatcher tw = setReadOnly(editText, true, null);

und um es normal zu machen, benutze tw aus der vorherigen Aussage:

setReadOnly(editText, false, tw);

Dies funktionierte für mich unter Berücksichtigung einiger der oben genannten Vorschläge. Macht das TextEdit fokussierbar, aber wenn der Benutzer klickt oder fokussiert, wird eine Liste mit Auswahlen in einem Popup-Fenster angezeigt. (Wir ersetzen das verrückte Spinner-Widget). TextEdit xml ist sehr allgemein ...

public void onCreate(Bundle savedInstanceState) {
    ....  
    fEditState = (EditText) findViewById(R.id.state_edit);

    fEditState.setLongClickable(false);
    fEditState.setKeyListener(null);
    fEditState.setFocusable(true);

    fEditState.setOnFocusChangeListener(new View.OnFocusChangeListener() {
        public void onFocusChange(View v, boolean hasFocus)
        {
            if (hasFocus)
            {
               showStatesPopup();

            }
        }
    });

    fEditState.setOnClickListener(new Button.OnClickListener(){

        public void onClick(View arg0)
        {
           showStatesPopup();
        }
    });
    ....
}

private void showStatesPopup()
{
    // fPopupWindowStates instantiated in OnCreate()

    if (!fPopupWindowStates.isShowing()) {
        // show the list view as dropdown
        fPopupWindowStates.showAsDropDown(fEditState, -5, 0);
    }
}  

Wenn Sie nur in der Lage sein wollen , um Text von der Steuerung zu kopieren , aber nicht bearbeiten zu können , um es Sie vielleicht einen verwenden möchten Textview statt und Set Text ist frei wählbar .

Code:

myTextView.setTextIsSelectable(true);
myTextView.setFocusable(true);
myTextView.setFocusableInTouchMode(true);
// myTextView.setSelectAllOnFocus(true);

xml:

<TextView
    android:textIsSelectable="true"
    android:focusable="true"
    android:focusableInTouchMode="true"     
    ...
/>
<!--android:selectAllOnFocus="true"-->

Die Dokumentation von setTextIsSelectable lautet:

Wenn Sie diese Methode aufrufen, um den Wert von textIsSelectable festzulegen, werden die Flags focusable, focusableInTouchMode, clickable und longClickable auf denselben Wert gesetzt ...

Allerdings musste ich focusable und focusableInTouchMode explizit auf true setzen, damit es mit Berührungseingaben funktioniert.

Dies war die einzige einfache Lösung für mich.

editText.setEnabled(false);   // Prevents data entry
editText.setFocusable(false); // Prevents being able to tab to it from keyboard

Ich hatte kein Problem damit, EditTextPreference schreibgeschützt zu machen, indem ich Folgendes verwendete:

editTextPref.setSelectable(false);

Dies funktioniert gut, wenn das Feld "Zusammenfassung" zum Anzeigen schreibgeschützter Felder verwendet wird (nützlich zum Beispiel zum Anzeigen von Kontoinformationen). Das dynamische Aktualisieren der Zusammenfassungsfelder wurde von http://gmariotti.blogspot.com/2013/01/preferenceactivity-preferencefragment.html abgerufen

private static final List<String> keyList;

static {
    keyList = new ArrayList<String>();
    keyList.add("field1");
    keyList.add("field2");
    keyList.add("field3");
}

@Override
public void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    addPreferencesFromResource(R.xml.preferences);

    for(int i=0;i<getPreferenceScreen().getPreferenceCount();i++){
        initSummary(getPreferenceScreen().getPreference(i));
    }
}

private void initSummary(Preference p) {
    if (p instanceof PreferenceCategory) {
        PreferenceCategory pCat = (PreferenceCategory) p;
        for (int i = 0; i < pCat.getPreferenceCount(); i++) {
            initSummary(pCat.getPreference(i));
        }
    } else {
        updatePrefSummary(p);
    }
}

private void updatePrefSummary(Preference p) {
    if (p instanceof ListPreference) {
        ListPreference listPref = (ListPreference) p;
        p.setSummary(listPref.getEntry());
    }
    if (p instanceof EditTextPreference) {
        EditTextPreference editTextPref = (EditTextPreference) p;
        //editTextPref.setEnabled(false); // this can be used to 'gray out' as well
        editTextPref.setSelectable(false);
        if (keyList.contains(p.getKey())) {
            p.setSummary(editTextPref.getText());
        }
    }
}

Stellen Sie dies in der EdiTextView-XML-Datei ein

android:focusable="false"

Wie android:editable=""veraltet,

Einstellung

• android:clickable="false"
• android:focusable="false"
• android:inputType="none"
• android:cursorVisible="false"

macht es "schreibgeschützt".

Benutzer können jedoch weiterhin in das Feld einfügen oder andere Aktionen mit langen Klicks ausführen. Um dies zu deaktivieren, überschreiben Sie einfach onLongClickListener ().
In Kotlin:

• myEditText.setOnLongClickListener { true }

genügt.

Mein Ansatz hierfür war das Erstellen einer benutzerdefinierten TextWatcher-Klasse wie folgt:

class ReadOnlyTextWatcher implements TextWatcher {
    private final EditText textEdit;
    private String originalText;
    private boolean mustUndo = true;

    public ReadOnlyTextWatcher(EditText textEdit) {
        this.textEdit = textEdit;
    }

    @Override
    public void beforeTextChanged(CharSequence charSequence, int i, int i1, int i2) {
        if (mustUndo) {
            originalText = charSequence.toString();
        }
    }

    @Override
    public void onTextChanged(CharSequence charSequence, int i, int i1, int i2) {

    }

    @Override
    public void afterTextChanged(Editable editable) {
        if (mustUndo) {
            mustUndo = false;
            textEdit.setText(originalText);
        } else {
            mustUndo = true;
        }
    }
}

Dann fügen Sie diesen Watcher einfach zu jedem Feld hinzu, das trotz Aktivierung schreibgeschützt werden soll:

editText.addTextChangedListener(new ReadOnlyTextWatcher(editText));