Comment rendre le texte d'édition non modifiable mais cliquable dans JAVA

Est-il possible de rendre EditTextcliquable mais non modifiable.

Je ne veux pas qu'il soit modifiable (le clavier ne doit pas non plus apparaître et nous ne devons pas pouvoir changer l'indice)

En fait, je veux utiliser Modifier le texte simplement comme une image avec un indice (qui ne peut pas être modifié). Je sais que la manière réelle était d'utiliser un ImageViewet un TextView, mais je veux essayer avec EditTextparce que je n'utiliserai alors qu'une seule vue au lieu de 2. De plus, tout est dynamique, donc pas de XML.

Pour l'exigence ci-dessus, la solution en XML est android:editable="false"mais je veux l'utiliser en Java.

Mais,

Si j'utilise: -

et.setEnabled(false);

ou

 et.setKeyListener(null);

Cela rend le EditTextnon modifiable mais en même temps il le rend non cliquable.

L'astuce ici est: -

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

vous pouvez définir EditTexten utilisant le code java comme jachère: -

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

ou en utilisant le code ci-dessous dans un fichier XML pour EditText.

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

Tel editableest obsolète. vous pouvez utiliser android:inputTypecomme aucun dans la conception de xml ou comme InputType.TYPE_NULL dans le codage.

Conception de 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"/>

Codage

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

Et ci-dessous se trouve l'événement de clic de edittext

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

Vous pouvez utiliser ceci.

android:focusableInTouchMode="false"

pour rendre edittext non modifiable en xml.Et pour les événements cliquables, vous pouvez utiliser l' événement setOnTouchListener () pour faire la même chose que comme ..

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 obsolète mais vous pouvez faire stg comme ci-dessous:

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

J'ai utilisé le cade ci-dessus pour les edittexts dans lesquels j'utilise des sélecteurs pour définir les données. Vous pouvez utiliser la disposition d'entrée avec cela.

Edittext activer et désactiver pour l'édition comme ceci

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

Par le code java

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

Par xml

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

Pour moi, aucune des réponses n'a abouti à une solution complètement fonctionnelle.

Vitrine de mon correctif https://www.youtube.com/watch?v=oUA4Cuxfdqc

Guide (adapté aux noob) , veuillez noter les quelques commentaires dans le code.

Créez une classe Java pour une personnalisation EditTextappelée 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;
    }

}

Référencez le EditTextDispatcheddans votre xml (vous devrez modifier le nom 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" />

Invoquer:

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

Peut-être que tu peux essayer

editText.setEnabled(false);

Je sais que cette question a déjà reçu une réponse, mais pour donner une réponse plus actuelle (c'est-à-dire 2018), voici la configuration que j'utilise pour obtenir l'effet demandé (c'est-à-dire non d'entrée ou modifiable):

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

Oui, c'est ANKO car je n'utilise plus XML dans aucun de mes projets Android. Le 'inputType' prend en charge la dépréciation 'isEditable'.

À partir de 2020, si vous vous souciez également de l'accessibilité, vous devez éviter les paramètres, et.setFocusable(false);car cela rendra le EditText inaccessible à l'aide de la navigation au clavier.

Voici ma solution:

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
}

vous pouvez également le faire android:inputMethod="@null"dans votre EditTextet il n'affichera pas le curseur ou le clavier et vous pourrez alors facilement saisir l'écouteur de réglage de clic.