Hacer que EditText sea de solo lectura

Quiero hacer una EditTextvista de solo lectura . El XML para hacer este código parece serlo android:editable="false", pero quiero hacerlo en código.

¿Cómo puedo hacer esto?

Utilice este código.

Edittext.setEnabled(false);

Si setEnabled(false)entonces editTextse verá deshabilitado (gris, etc.). Es posible que no desee cambiar el aspecto visual de su editor.

Una forma menos intrusiva sería usar setFocusable(false).

Creo que esto responde a su pregunta más cerca de su intención inicial.

En XMLuso:

android:editable="false"

Como ejemplo:

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

Esto funciona para mi:

EditText.setKeyListener(null);

Lo mejor es usar en su TextViewlugar.

editText.setInputType(InputType.TYPE_NULL);

Según los documentos, esto evita que se muestre el teclado virtual. También evita el pegado, permite el desplazamiento y no altera el aspecto visual de la vista. Sin embargo, esto también evita la selección y copia del texto dentro de la vista.

De mis pruebas establecer setInputTypea TYPE_NULLque parece ser funcionalmente equivalente a la depreciado android:editable="false". Además, android:inputType="none"parece no tener ningún efecto notable.

android: editable = "false" ha quedado obsoleto. Por lo tanto, no puede usarlo para hacer que el texto editado sea de solo lectura.

He hecho esto usando la siguiente solución. Aquí he usado

android: inputType = "ninguno"

android: textIsSelectable = "true"

android: focusable = "falso"

Pruébalo :)

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

Esto le dará un filtro EditText no editable. primero debe poner el texto que desea en el campo editText y luego aplicar este filtro.

escribir estas dos líneas es más que suficiente para tu trabajo.

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

establecido en XML

android:inputType="none" 

Intenta usar

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

android:editable

Si se establece, especifica que TextViewtiene un método de entrada. Será textual a menos que se especifique lo contrario. Porque TextViewesto es falso por defecto. Porque EditTextes cierto por defecto.

Debe ser un booleanvalor, ya sea trueo false.

Esto también puede ser una referencia a un recurso (en el formulario @[package:]type:name) o atributo de tema (en el formulario ?[package:][type:]name) que contiene un valor de este tipo.

Esto corresponde al símbolo de recurso de atributo global editable.

Métodos relacionados

Intente anular el oyente onLongClick del texto de edición para eliminar el menú contextual:

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

Utilice este código:

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

La desactivación editTextproporciona un aspecto y un comportamiento de solo lectura, pero también cambia text-colora gris, por lo que es necesario configurar el color del texto.

esta es mi implementación (un poco larga, ¡pero útil para mí!): Con este código puede hacer que EditView sea de solo lectura o Normal. incluso en estado de solo lectura, el usuario puede copiar el texto. puede cambiar el fondo para que se vea diferente de un EditText normal.

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

el beneficio de este código es que EditText se muestra como EditText normal pero el contenido no se puede cambiar. El valor de retorno debe mantenerse como una variable para que uno pueda volver del estado de solo lectura a normal.

para hacer un EditText de solo lectura, simplemente póngalo como:

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

y para que sea normal, use tw de la declaración anterior:

setReadOnly(editText, false, tw);

Esto funcionó para mí, teniendo en cuenta varias de las sugerencias anteriores. Hace que TextEdit se pueda enfocar, pero si el usuario hace clic o enfoca, mostramos una lista de selecciones en una ventana emergente. (Estamos reemplazando el loco widget Spinner). TextEdit xml es muy genérico ...

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

Si solo desea poder copiar texto del control pero no puede editarlo, es posible que desee usar un TextView en su lugar y establecer que el texto sea seleccionable .

código:

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

La documentación de setTextIsSelectable dice:

Cuando llama a este método para establecer el valor de textIsSelectable, establece los indicadores focusable, focusableInTouchMode, clickable y longClickable en el mismo valor ...

Sin embargo, tuve que establecer explícitamente focusable y focusableInTouchMode en true para que funcionara con la entrada táctil.

Esta fue la única solución completa y simple para mí.

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

No tuve ningún problema para hacer EditTextPreference de solo lectura, usando:

editTextPref.setSelectable(false);

Esto funciona bien cuando se combina con el uso del campo 'resumen' para mostrar campos de solo lectura (útil para mostrar información de cuenta, por ejemplo). Actualización de los campos de resumen extraídos dinámicamente de 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());
        }
    }
}

Establezca esto en el archivo xml EdiTextView

android:focusable="false"

Como android:editable=""está en desuso,

Setting

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

lo hará "de sólo lectura".

Sin embargo, los usuarios aún podrán pegar en el campo o realizar cualquier otra acción de clic largo. Para deshabilitar esto, simplemente anule onLongClickListener ().
En Kotlin:

• myEditText.setOnLongClickListener { true }

es suficiente.

Mi enfoque para esto ha sido crear una clase TextWatcher personalizada de la siguiente manera:

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

Luego, simplemente agregue ese observador a cualquier campo que desee que sea de solo lectura a pesar de estar habilitado:

editText.addTextChangedListener(new ReadOnlyTextWatcher(editText));