Ustaw EditText jako tylko do odczytu

Chcę utworzyć EditTextwidok tylko do odczytu . Wygląda na to android:editable="false", że XML do wykonania tego kodu jest , ale chcę to zrobić w kodzie.

W jaki sposób mogę to zrobić?

Użyj tego kodu.

Edittext.setEnabled(false);

Jeśli setEnabled(false)wówczas editTextwyglądałaby wyłączony (szary, itp). Możesz nie chcieć zmieniać wizualnego aspektu swojego edytora.

Mniej inwazyjnym sposobem byłoby użycie setFocusable(false).

Uważam, że to odpowiada na twoje pytanie bliżej twojego pierwotnego zamiaru.

W XMLużyciu:

android:editable="false"

Jako przykład:

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

To działa dla mnie:

EditText.setKeyListener(null);

Najlepiej jest używać TextViewzamiast tego.

editText.setInputType(InputType.TYPE_NULL);

Zgodnie z dokumentacją zapobiega to wyświetlaniu klawiatury programowej. Zapobiega również wklejaniu, umożliwia przewijanie i nie zmienia wizualnego aspektu widoku. Jednak zapobiega to również zaznaczaniu i kopiowaniu tekstu w widoku.

Z moich testów ustawienie setInputTypena TYPE_NULLwydaje się być funkcjonalnym odpowiednikiem amortyzacji android:editable="false". Dodatkowo android:inputType="none"wydaje się nie mieć zauważalnego efektu.

android: editable = "false" został wycofany. Dlatego nie możesz go użyć, aby tekst edycji był tylko do odczytu.

Zrobiłem to za pomocą poniższego rozwiązania. Tutaj użyłem

android: inputType = "none"

android: textIsSelectable = "true"

android: focusable = "false"

Spróbuj :)

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

To da ci nieedytowalny filtr EditText. najpierw musisz umieścić żądany tekst w polu editText, a następnie zastosować ten filtr.

napisanie tych dwóch wierszy jest więcej niż wystarczające do twojej pracy.

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

ustawione w XML

android:inputType="none" 

Spróbuj użyć

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

android:editable

Jeśli jest ustawiona, określa, że TextViewma metodę wprowadzania. Będzie to tekst tekstowy, chyba że określono inaczej. Ponieważ TextViewjest to domyślnie fałszywe. Ponieważ EditTextjest to domyślnie prawda.

Musi być booleanwartość, albo truealbo false.

Może to być również odniesienie do zasobu (w formularzu @[package:]type:name) lub atrybutu motywu (w formularzu ?[package:][type:]name) zawierającego wartość tego typu.

Odpowiada to edytowalnemu globalnemu symbolowi zasobu atrybutu.

Powiązane metody

Spróbuj zastąpić detektor onLongClick tekstu edycji, aby usunąć menu kontekstowe:

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

Użyj tego kodu:

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

Wyłączenie editTextzapewnia wygląd i zachowanie tylko do odczytu, ale także zmienia text-colorkolor na szary, więc konieczne jest ustawienie koloru tekstu.

to jest moja implementacja (trochę długa, ale przydatna dla mnie!): Za pomocą tego kodu możesz ustawić EditView jako tylko do odczytu lub Normalny. nawet w stanie tylko do odczytu tekst może być kopiowany przez użytkownika. możesz zmienić tło, aby wyglądało inaczej niż zwykły tekst edycji.

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

Zaletą tego kodu jest to, że EditText jest wyświetlany jako normalny EditText, ale zawartość nie jest zmienna. Wartość zwracana powinna być zachowana jako zmienna, aby umożliwić powrót ze stanu tylko do odczytu do normalnego.

aby uczynić EditText tylko do odczytu, po prostu umieść go jako:

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

i aby to było normalne użyj tw z poprzedniego oświadczenia:

setReadOnly(editText, false, tw);

To zadziałało w moim przypadku, biorąc pod uwagę kilka z powyższych sugestii. Sprawia, że ​​TextEdit jest fokusem, ale jeśli użytkownik kliknie lub ustawi fokus, wyświetlimy listę wyborów w PopupWindow. (Zastępujemy zwariowany widżet Spinner). TextEdit xml jest bardzo ogólny ...

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

Jeśli chcesz tylko skopiować tekst z kontrolki, ale nie możesz go edytować, możesz zamiast tego użyć TextView i ustawić tekst, który można zaznaczyć .

kod:

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

Dokumentacja setTextIsSelectable mówi:

Kiedy wywołujesz tę metodę, aby ustawić wartość textIsSelectable, ustawia ona flagi focusable, focusableInTouchMode, clickable i longClickable na tę samą wartość ...

Jednak musiałem jawnie ustawić focusable i focusableInTouchMode na true, aby działał z wprowadzaniem dotykowym.

To było dla mnie jedyne w pełni proste rozwiązanie.

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

Nie miałem problemu, aby EditTextPreference był tylko do odczytu, używając:

editTextPref.setSelectable(false);

Działa to dobrze w połączeniu z użyciem pola „podsumowanie” do wyświetlania pól tylko do odczytu (przydatne na przykład do wyświetlania informacji o koncie). Aktualizowanie pól podsumowań dynamicznie pobieranych z http://gmariotti.blogspot.com/2013/01/preferenceactivity-preferencefragment.html

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

Ustaw to w pliku EdiTextView xml

android:focusable="false"

Jak android:editable=""jest przestarzałe,

ustawienie

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

uczyni go „tylko do odczytu”.

Jednak użytkownicy nadal będą mogli wklejać w pole lub wykonywać inne długie kliknięcia. Aby to wyłączyć, po prostu zastąp onLongClickListener ().
W Kotlinie:

• myEditText.setOnLongClickListener { true }

wystarczy.

Moje podejście do tego polegało na utworzeniu niestandardowej klasy TextWatcher w następujący sposób:

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

Następnie wystarczy dodać tego obserwatora do dowolnego pola, które ma być tylko do odczytu, mimo że jest włączone:

editText.addTextChangedListener(new ReadOnlyTextWatcher(editText));