Rendre EditText ReadOnly

Je souhaite créer une vue en lecture seule EditText. Le XML pour faire ce code semble être android:editable="false", mais je veux le faire dans le code.

Comment puis-je faire ceci?

Veuillez utiliser ce code.

Edittext.setEnabled(false);

Si vous avez setEnabled(false)alors l' editTextair désactivé (gris, etc.). Vous ne souhaiterez peut-être pas modifier l'aspect visuel de votre éditeur.

Une manière moins intrusive serait d'utiliser setFocusable(false).

Je pense que cela répond à votre question plus proche de votre intention initiale.

En cours d' XMLutilisation:

android:editable="false"

Par exemple:

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

Cela fonctionne pour moi:

EditText.setKeyListener(null);

Le mieux est d'utiliser à la TextViewplace.

editText.setInputType(InputType.TYPE_NULL);

Selon la documentation, cela empêche le clavier virtuel 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 mes tests réglage setInputTypeà TYPE_NULLsemble être fonctionnellement équivalente à la dépréciée android:editable="false". De plus, android:inputType="none"semble n'avoir aucun effet notable.

android: editable = "false" est obsolète. 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 ci-dessous. Ici, j'ai utilisé

android: inputType = "aucun"

android: textIsSelectable = "true"

android: focusable = "faux"

Essayez-le :)

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

Cela vous donnera un filtre EditText non modifiable. vous devez d'abord mettre le texte souhaité dans le champ editText, puis appliquer ce filtre.

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

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

défini en XML

android:inputType="none" 

Essayez d'utiliser

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

android:editable

S'il est défini, spécifie qu'il TextViewpossède une méthode d'entrée. Ce sera un texte, sauf indication contraire. Pour TextView, c'est faux par défaut. Car EditText, c'est vrai par défaut.

Doit être une booleanvaleur, soit trueou false.

Cela peut également être une référence à une ressource (dans le formulaire @[package:]type:name) ou à un attribut de thème (dans le formulaire ?[package:][type:]name) contenant une valeur de ce type.

Cela correspond au symbole de ressource attribut global modifiable.

Méthodes connexes

Essayez de remplacer l'écouteur onLongClick du texte d'édition 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;
    }
});

Utilisez ce code:

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

La désactivation editTextdonne un aspect et un comportement en lecture seule , mais change également le text-colorgris, il est donc nécessaire de définir sa couleur de texte.

voici mon implémentation (un peu longue, mais utile pour moi!): Avec ce code vous pouvez rendre EditView Read-only ou Normal. même en lecture seule, le texte peut être copié par l'utilisateur. vous pouvez changer le backgroud pour le rendre différent d'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;
    }
}

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

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

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

et pour le rendre normal, utilisez 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 focusable, mais si l'utilisateur clique ou se concentre, nous affichons une liste de sélections dans une PopupWindow. (Nous remplaçons le widget farfelu 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 souhaitez simplement pouvoir copier du texte à partir du contrôle sans pouvoir le modifier, vous pouvez utiliser un TextView à la place et définir le 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:

Lorsque vous appelez cette méthode pour définir la valeur de textIsSelectable, elle définit les indicateurs focusable, focusableInTouchMode, clickable et longClickable sur la même valeur ...

Cependant, j'ai dû définir explicitement focusable et focusableInTouchMode sur true pour le faire fonctionner avec la saisie tactile.

C'était la seule solution simple et complète pour moi.

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

Je n'ai eu aucun problème à rendre EditTextPreference en lecture seule, en utilisant:

editTextPref.setSelectable(false);

Cela fonctionne bien lorsqu'il est associé à l'utilisation du champ «résumé» pour afficher des champs en lecture seule (utile pour afficher les informations de 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());
        }
    }
}

Définissez ceci dans le fichier xml EdiTextView

android:focusable="false"

Comme il android:editable=""est obsolète, le

paramètre

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

le rendra "en lecture seule".

Cependant, les utilisateurs pourront toujours coller dans le champ ou effectuer toute autre action de clic long. Pour désactiver cela, remplacez simplement onLongClickListener ().
À Kotlin:

• myEditText.setOnLongClickListener { true }

suffit.

Mon approche à ce sujet a été de créer une classe TextWatcher personnalisée comme suit:

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

Ensuite, vous ajoutez simplement cet observateur à n'importe quel champ que vous souhaitez être en lecture seule malgré son activation:

editText.addTextChangedListener(new ReadOnlyTextWatcher(editText));