Faire En Sorte Que EditText Soit Lu En Lecture Seule

si vous setEnabled(false) alors votre editText aurait l'air désactivé (gris, etc). Vous ne voulez pas changer l'aspect visuel de votre éditeur.

une façon moins intrusive serait d'utiliser setFocusable(false) .

je crois que cela répond à votre question plus proche de votre intention initiale.

XML utiliser

android:editable="false"

exemple:

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

ça marche pour moi:

EditText.setKeyListener(null);

le mieux est d'utiliser TextView à la place.

editText.setInputType(InputType.TYPE_NULL);

selon le docs cela empêche le clavier souple d'être affiché. Il empêche également le collage, permet le défilement et ne modifie pas l'aspect visuel de la vue. Cependant, cela empêche également la sélection et la copie du texte dans la vue.

de mon réglage d'essai setInputType à TYPE_NULL semble être fonctionnellement équivalente à la valeur dépréciée android:editable="false" . En outre, android:inputType="none" semble n'avoir aucun effet notable.

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

cela vous donnera un filtre Édittext non éditable. vous devez d'abord mettre le texte que vous souhaitez sur le editText domaine, puis appliquez ce filtre.

défini en XML

android:inputType="none" 

écrire ces deux lignes est plus que suffisant pour votre travail.

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

essayer d'utiliser

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

android:editable

si défini, spécifie que ce TextView a une méthode d'entrée. Ce sera un texte à moins qu'elle n'ait été spécifiée. Pour TextView , c'est faux par défaut. Pour EditText , c'est true par défaut.

doit être une valeur de boolean , soit true ou false .

il peut également s'agir d'une référence à une ressource (sous la forme @[package:]type:name ) ou à un attribut thématique (sous la forme ?[package:][type:]name ) contenant une valeur de ce type.

correspond au symbole de ressource d'attribut global modifiable.

Méthodes Connexes

android: modifiable= "false" a été déprécié. Par conséquent, vous ne pouvez pas l'utiliser pour rendre le texte d'édition en lecture seule.

j'ai fait cela en utilisant la solution de bellow. Ici j'ai utilisé

android:inputType= "none"

android: textIsSelectable= "true"

android: focalisable= "false"

Donner de l'essayer :)

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

essayez d'annuler l'auditeur onLongClick du menu edit text pour supprimer le menu contextuel:

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

c'est mon implémentation (un peu longue, mais utile pour moi!): Avec ce code, vous pouvez rendre EditView en lecture seule ou normale. même en état de lecture seule, le texte peut être copié par l'utilisateur. vous pouvez changer l'arrière-plan pour le rendre différent d'un texte D'édition 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;
    }
}

l'avantage de ce code est que, l'EditText est affiché comme normal EditText, mais le contenu n'est pas modifiable. La valeur de retour doit être conservée en tant que variable pour un pouvoir revenir en arrière d'état en lecture seule à la normale.

pour faire un EditText en lecture seule, il suffit de le mettre comme:

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

et d'en faire une utilisation normale tw de la déclaration précédente:

setReadOnly(editText, false, tw);

cela a fonctionné pour moi, en tenant compte de plusieurs des suggestions ci-dessus. Rend le TextEdit focalisable, mais si l'utilisateur clique ou se concentre, nous montrons une liste de sélections dans un PopupWindow. (Nous remplaçons le widget wacky Spinner). TextEdit xml est très générique...

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 vous voulez simplement pouvoir copier du texte depuis le contrôle mais ne pas pouvoir l'éditer, vous pouvez utiliser un TextView à la place et définir texte est sélectionnable .

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

La documentation de setTextIsSelectable dit:

quand vous appelez cette méthode pour définir la valeur de textIsSelectable, elle définit les options focusable, focusable intouchmode, clickable, et longClickable à la même valeur...

cependant, j'ai dû mettre explicitement le mode focalisable et focalisable à true pour qu'il fonctionne avec l'entrée tactile.

Je n'ai eu aucun problème à faire en sorte que EditTextPreference soit en lecture seule, en utilisant:

editTextPref.setSelectable(false);

cela fonctionne bien lorsqu'on utilise le champ 'summary' pour afficher des champs en lecture seule (utile pour afficher des informations sur le compte, par exemple). Mise à jour des champs de résumé extraits dynamiquement 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());
        }
    }
}

mettez ceci dans le fichier XML EdiTextView

android:focusable="false"

utilisez ce code:

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

désactiver editText donne une apparence et un comportement en lecture seule, mais change également la couleur du texte en gris, de sorte que le réglage de la couleur du texte est nécessaire.