Como tornar o texto de edição não editável, mas clicável em JAVA

É possível tornar EditTextclicável, mas não editável.

Não quero que seja editável (o teclado não deve ser ativado nem devemos alterar a dica)

Na verdade, desejo usar Editar texto simplesmente como uma imagem com uma dica (que não pode ser alterada). Eu sei que a maneira real era usar um ImageViewe um TextView, mas eu quero tentar EditTextporque então estarei usando apenas uma visualização em vez de 2. Além disso, tudo é dinâmico, então nada de XML.

Para o requisito acima, a solução em XML é, android:editable="false"mas eu quero usar isso em Java.

Mas,

Se eu usar: -

et.setEnabled(false);

ou

 et.setKeyListener(null);

Isso o torna EditTextnão editável, mas ao mesmo tempo também o torna não clicável.

O truque aqui é: -

et.setFocusable(false);
et.setClickable(true);

Como editableestá obsoleto. você pode usar android:inputTypecomo nenhum ao projetar xml ou como InputType.TYPE_NULL na codificação.

Projetando XML

<android.support.v7.widget.AppCompatEditText
    android:id="@+id/edt"
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    android:clickable="true"
    android:focusable="false"
    android:inputType="none"
    android:text="EditText"/>

Codificação

edt.setClickable(true);
edt.setFocusable(false);
edt.setInputType(InputType.TYPE_NULL);

E abaixo está o evento click de edittext

edt.setOnClickListener(new View.OnClickListener() {
    @Override
    public void onClick(View v) {
        Toast.makeText(YourActivity.this,"edt click", Toast.LENGTH_LONG).show();
    }
});

você pode definir EditTextusando o código java como seguinte: -

edittext.setFocusable(false);
edittext.setClickable(true);

ou usando o código abaixo no arquivo XML para EditText.

android:editable="false" 
android:inputType="none"  

Você pode usar isso ..

android:focusableInTouchMode="false"

para tornar o texto de edição não editável em xml. E para o evento clicável, você pode usar o evento setOnTouchListener () para fazer a mesma coisa.

editText.setOnTouchListener(new OnTouchListener() {

    @Override
    public boolean onTouch(View v, MotionEvent event) {
        // TODO Auto-generated method stub
                        //do your stuff here..
        return false;
    }
});

android:editable está obsoleto, mas você pode fazer stg como abaixo:

android:editable="false"
android:focusable="false"
android:focusableInTouchMode="false"

Eu usei a cade acima para textos de edição nos quais uso seletores para definir os dados. Você pode usar o layout de entrada com isso.

Edittext habilitar e desabilitar para a edição como esta

EditText edit = (EditText) findviewby(R.id.edittext);

Por meio de código java

edit.setEnabled(false); //non editable
edit.setEnabled(true); //editable

Por meio de xml

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

Para mim, nenhuma das respostas resultou em uma solução completamente funcional.

Demonstração da minha correção https://www.youtube.com/watch?v=oUA4Cuxfdqc

Guia (amigável noob) , observe os poucos comentários no código.

Crie uma classe Java para um personalizado EditTextchamado EditTextDispatched.java

import android.content.Context;
import android.util.AttributeSet;
import android.view.MotionEvent;
import android.widget.RelativeLayout;

/**
 * @author Martin Pfeffer
 * @see <a href="https://celox.io">https://celox.io</a>
 */
public class EditTextDispatched extends android.support.v7.widget.AppCompatEditText {

    private static final String TAG = "DispatchingEditText";

    private boolean editable = true;

    public EditTextDispatched(Context context) {
        super(context);
    }

    public EditTextDispatched(Context context, AttributeSet attrs) {
        super(context, attrs);
    }

    public EditTextDispatched(Context context, AttributeSet attrs, int defStyleAttr) {
        super(context, attrs, defStyleAttr);
    }

    // get the current state
    public boolean isEditable() {
        return editable;
    }

    // set your desired behaviour
    public void setEditable(boolean editable) {
        this.editable = editable;
    }

    @Override
    public boolean dispatchTouchEvent(MotionEvent motionEvent) {

        if (editable) {
            // default behaviour of an EditText
            super.dispatchTouchEvent(motionEvent);
            return true;
        }

        // achieve the click-behaviour of a TextView (it's cuztom)
        ((RelativeLayout) getParent()).onTouchEvent(motionEvent);
        return true;
    }

}

Faça referência a EditTextDispatchedem seu xml (você terá que alterar o nome do pgk):

  <io.celox.brutus.EditTextDispatched
    android:id="@+id/row_field_value"
    style="@style/row_field_text_display"
    android:layout_alignParentBottom="true"
    android:text="@string/sample_field_value" />

Invocar:

private void changeEditTextBehaviour(EditTextDispatched value, boolean editable) {
    value.setEditable(editable);
    value.setEnabled(editable);
}

Talvez você possa tentar

editText.setEnabled(false);

Eu sei que esta pergunta já foi respondida, mas para dar uma resposta mais atual (ou seja, 2018), aqui está a configuração que eu uso para obter o efeito solicitado (ou seja, sem entrada ou editável):

    val etUserLoc: EditText = themedEditText(R.style.Pale_Blue_Text_Bold_13) {
                id = R.id.et_comp_user_keys_var_user_location
                inputType = InputType.TYPE_NULL
                isClickable = true
                isFocusable = false
                textColor = resources.getColor(R.color.magenta)  // overrides the default theme color
                text = Editable.Factory.getInstance().newEditable(resources.getString(R.string.loc_swakopmund))
            }.lparams(width = matchConstraint, height = matchParent) {   }

Sim, este é ANKO, já que não uso mais XML em nenhum dos meus projetos Android. O 'inputType' cuida da reprovação de 'isEditable'.

A partir de 2020, se você também se preocupa com a acessibilidade, deve evitar a configuração, et.setFocusable(false);pois isso tornará o EditText inacessível usando a navegação do teclado.

Aqui está minha solução:

Kotlin

editText.isFocusableInTouchMode = false

editText.isLongClickable = false //this will prevent copy and paste

editText.setOnClickListener {
   // handle the click
   // this will automatically make the edittext clickable = true
}

você também pode fazer android:inputMethod="@null"no seu EditTexte ele não mostrará o cursor ou o teclado e então você pode facilmente pegar o clique através do ouvinte de configuração.