EditText maxLines ne fonctionne pas - l'utilisateur peut toujours saisir plus de lignes que défini

<EditText 
    android:id="@+id/editText2" 
    android:layout_height="wrap_content" 
    android:layout_width="fill_parent" 
    android:maxLines="5" 
    android:lines="5">
</EditText>

L'utilisateur peut saisir plus de 5 lignes, en appuyant sur la touche Entrée / ligne suivante. Comment puis-je limiter l'entrée utilisateur à un nombre fixe de lignes avec EditText?

L'attribut maxLinescorrespond à la hauteur maximale du EditText, il contrôle les limites extérieures et non les lignes de texte intérieures.

<EditText
    android:id="@+id/edit_text"
    android:layout_width="match_parent"
    android:layout_height="wrap_content"
    android:inputType="text"
    android:maxLines="1" 
/>

Vous devez simplement vous assurer que vous avez défini l'attribut "inputType". Cela ne fonctionne pas sans cette ligne.

android:inputType="text"

Cela ne résout pas le problème général de la limitation à n lignes. Si vous souhaitez limiter votre EditText à une seule ligne de texte, cela peut être très simple.
Vous pouvez définir cela dans le fichier xml.

android:singleLine="true"

ou par programmation

editText.setSingleLine(true);

@Cedekasem vous avez raison, il n'y a pas de "limiteur de ligne" intégré. Mais j'en ai construit un moi-même, donc si quelqu'un est intéressé, le code est ci-dessous. À votre santé.

et.setOnKeyListener(new View.OnKeyListener() {

        @Override
        public boolean onKey(View v, int keyCode, KeyEvent event) {

            // if enter is pressed start calculating
            if (keyCode == KeyEvent.KEYCODE_ENTER
                    && event.getAction() == KeyEvent.ACTION_UP) {

                // get EditText text
                String text = ((EditText) v).getText().toString();

                // find how many rows it cointains
                int editTextRowCount = text.split("\\n").length;

                // user has input more than limited - lets do something
                // about that
                if (editTextRowCount >= 7) {

                    // find the last break
                    int lastBreakIndex = text.lastIndexOf("\n");

                    // compose new text
                    String newText = text.substring(0, lastBreakIndex);

                    // add new text - delete old one and append new one
                    // (append because I want the cursor to be at the end)
                    ((EditText) v).setText("");
                    ((EditText) v).append(newText);

                }
            }

            return false;
        }
});

J'ai fait quelque chose comme vous cherchiez. Voici ma LimitedEditTextclasse.

Fonctionnalités:

• vous pouvez limiter le nombre de lignes dans votre composant LimitedEditText
• vous pouvez limiter le nombre de caractères dans votre composant LimitedEditText
• si vous dépassez la limite de caractères ou de lignes quelque part au milieu du texte, le curseur
  ne vous amènera pas à la fin - il restera où vous étiez.

Je désactive l'écouteur, car chaque appel de setText()méthode appelle de manière récursive ces 3 méthodes de rappel au cas où l'utilisateur dépasserait la limite de caractères ou de lignes.

Code:

import android.content.Context;
import android.text.Editable;
import android.text.TextWatcher;
import android.util.AttributeSet;
import android.util.Log;
import android.widget.EditText;
import android.widget.Toast;

/**
* EditText subclass created to enforce limit of the lines number in editable
* text field
*/
public class LimitedEditText extends EditText {

/**
 * Max lines to be present in editable text field
 */
private int maxLines = 1;

/**
 * Max characters to be present in editable text field
 */
private int maxCharacters = 50;

/**
 * application context;
 */
private Context context;

public int getMaxCharacters() {
    return maxCharacters;
}

public void setMaxCharacters(int maxCharacters) {
    this.maxCharacters = maxCharacters;
}

@Override
public int getMaxLines() {
    return maxLines;
}

@Override
public void setMaxLines(int maxLines) {
    this.maxLines = maxLines;
}

public LimitedEditText(Context context, AttributeSet attrs, int defStyle) {
    super(context, attrs, defStyle);
    this.context = context;
}

public LimitedEditText(Context context, AttributeSet attrs) {
    super(context, attrs);
    this.context = context;
}

public LimitedEditText(Context context) {
    super(context);
    this.context = context;
}

@Override
protected void onFinishInflate() {
    super.onFinishInflate();

    TextWatcher watcher = new TextWatcher() {

        private String text;
        private int beforeCursorPosition = 0;

        @Override
        public void onTextChanged(CharSequence s, int start, int before,
                int count) {                
            //TODO sth
        }

        @Override
        public void beforeTextChanged(CharSequence s, int start, int count,
                int after) {
            text = s.toString();
            beforeCursorPosition = start;
        }

        @Override
        public void afterTextChanged(Editable s) {

            /* turning off listener */
            removeTextChangedListener(this);

            /* handling lines limit exceed */
            if (LimitedEditText.this.getLineCount() > maxLines) {
                LimitedEditText.this.setText(text);
                LimitedEditText.this.setSelection(beforeCursorPosition);
            }

            /* handling character limit exceed */
            if (s.toString().length() > maxCharacters) {
                LimitedEditText.this.setText(text);
                LimitedEditText.this.setSelection(beforeCursorPosition);
                Toast.makeText(context, "text too long", Toast.LENGTH_SHORT)
                        .show();
            }

            /* turning on listener */
            addTextChangedListener(this);

        }
    };

    this.addTextChangedListener(watcher);
}

}

J'ai fait une solution plus simple pour cela: D

// set listeners
    txtSpecialRequests.addTextChangedListener(new TextWatcher() {
        @Override
        public void beforeTextChanged(CharSequence s, int start, int count, int after) {
            lastSpecialRequestsCursorPosition = txtSpecialRequests.getSelectionStart();
        }

        @Override
        public void onTextChanged(CharSequence s, int start, int before, int count) {

        }

        @Override
        public void afterTextChanged(Editable s) {
            txtSpecialRequests.removeTextChangedListener(this);

            if (txtSpecialRequests.getLineCount() > 3) {
                txtSpecialRequests.setText(specialRequests);
                txtSpecialRequests.setSelection(lastSpecialRequestsCursorPosition);
            }
            else
                specialRequests = txtSpecialRequests.getText().toString();

            txtSpecialRequests.addTextChangedListener(this);
        }
    });

Vous pouvez modifier la valeur de 3 en fonction txtSpecialRequests.getLineCount() > 3de vos besoins.

Voici un InputFilter qui limite les lignes autorisées dans EditText:

/**
 * Filter for controlling maximum new lines in EditText.
 */
public class MaxLinesInputFilter implements InputFilter {

  private final int mMax;

  public MaxLinesInputFilter(int max) {
    mMax = max;
  }

  public CharSequence filter(CharSequence source, int start, int end, Spanned dest, int dstart, int dend) {
    int newLinesToBeAdded = countOccurrences(source.toString(), '\n');
    int newLinesBefore = countOccurrences(dest.toString(), '\n');
    if (newLinesBefore >= mMax - 1 && newLinesToBeAdded > 0) {
      // filter
      return "";
    }

    // do nothing
    return null;
  }

  /**
   * @return the maximum lines enforced by this input filter
   */
  public int getMax() {
    return mMax;
  }

  /**
   * Counts the number occurrences of the given char.
   *
   * @param string the string
   * @param charAppearance the char
   * @return number of occurrences of the char
   */
  public static int countOccurrences(String string, char charAppearance) {
    int count = 0;
    for (int i = 0; i < string.length(); i++) {
      if (string.charAt(i) == charAppearance) {
        count++;
      }
    }
    return count;
  }
}

Pour l'ajouter à EditText:

editText.setFilters(new InputFilter[]{new MaxLinesInputFilter(2)});

C'est ce que j'ai utilisé dans mon projet:

editText.addTextChangedListener(new TextWatcher() {
    private String text;

public void onTextChanged(CharSequence arg0, int arg1, int arg2, int arg3) {    
}

public void beforeTextChanged(CharSequence arg0, int arg1, int arg2, int arg3) {
    text = arg0.toString();
    }

public void afterTextChanged(Editable arg0) {
    int lineCount = editText.getLineCount();
    if(lineCount > numberOfLines){
    editText.setText(text);
    }
}
});

editText.setOnKeyListener(new View.OnKeyListener() {

public boolean onKey(View v, int keyCode, KeyEvent event) {

// if enter is pressed start calculating
    if (keyCode == KeyEvent.KEYCODE_ENTER && event.getAction() == KeyEvent.ACTION_DOWN){    
    int editTextLineCount = ((EditText)v).getLineCount();
    if (editTextLineCount >= numberOfLines)
        return true;
}

return false;
}
});

Et cela a fonctionné dans tous les scénarios

définir editText android:inputType="text"

Solution la plus simple:

android:maxLines="3"

...

 @Override
public void afterTextChanged(Editable editable) {
    // limit to 3 lines
    if (editText.getLayout().getLineCount() > 3)
        editText.getText().delete(editText.getText().length() - 1, editText.getText().length());
}

android:inputType="text" (or something different to "none")
android:maxLines="1"  (and this line)

c'est une approche. Pourrait aider quelqu'un.

android:lines="1"
android:maxLines="1"
android:inputType="text

Une autre façon de limiter votre EditTextà une ligne est la suivante:

editText2.setTransformationMethod(new SingleLineTransformationMethod());

Notez qu'après avoir appliqué cette méthode de transformation, la touche Entrée crée des espaces lorsqu'elle est enfoncée. Cela satisfait toujours la question de TS.

Vous pouvez limiter votre texte en fonction de votre nombre de lignes, je dis environ 37 alphabets en une seule ligne

<EditText
    android:layout_width="match_parent"
    android:layout_height="wrap_content"
    android:lines="4"
    android:maxLines="4"
    android:minLines="4"
    android:maxLength="150"
    android:gravity="start"
    android:background="#efeef5"
    android:layout_marginTop="@dimen/pad_10dp"/>

getLineCount () est une option; si vous voulez des valeurs non nulles, assurez-vous que votre vue est mesurée. Pour le clavier logiciel, onKeyListener ne fonctionnera pas, vous devez donc ajouter addTextChangedListener () qui suivra les modifications de texte au fur et à mesure que vous tapez. Dès que vous avez suffisamment de lignes dans ses rappels, faites ce que vous voulez pour le limiter: supprimez les caractères avec getText (), setText () ou quelque chose de plus sophistiqué. Vous pouvez même limiter le nombre de caractères à l'aide d'un filtre.

Une autre option consiste à surveiller la taille du texte avec getLineBounds (). Cela interagira avec la gravité du texte / paddign alors soyez prudent.

Pour un nombre limité de caractères, nous pouvons simplement utiliser la propriété maxLength de EditText car elle ne permettra pas à l'utilisateur d'entrer plus de caractères.

        <EditText
            android:id="@+id/usrusr"
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:layout_gravity="center"
            android:gravity="center"
            android:lines="1"
            android:maxLines="1"
            android:inputType="text"
            android:hint="@string/inventory_no" />

Autre idée: à chaque fois après la saisie, le nouveau texte serait enregistré dans un String lastText, uniquement si le nombre de lignes n'excède pas les MAX_LINES. Si c'est le cas, nous définirions le texte de EditText sur le dernier texte ajouté (de sorte que les modifications seraient supprimées) et informerions l'utilisateur de le garder court.

 // Set listener to wishDescriptionEditText in order to limit line number
    editText.addTextChangedListener(new TextWatcher() {
        @Override
        public void beforeTextChanged(CharSequence s, int start, int count, int after) {
        }

        @Override
        public void onTextChanged(CharSequence s, int start, int before, int count) {
        }

        @Override
        public void afterTextChanged(Editable s) {
            // If line account is higher than MAX_LINES, set text to lastText
            // and notify user (by Toast)
            if (editText.getLineCount() > MAX_LINES) {
                editText.setText(lastText);
                Toast.makeText(getContext(), "Please keep it short", Toast.LENGTH_LONG).show();
            } else {
                lastText = editText.getText().toString();
            }
        }
    });

Ceci est une extension de la réponse d' Indrek Kõue à Kotlin

                input_name.addTextChangedListener(object : TextWatcher {
                override fun afterTextChanged(s: Editable?) {}

                override fun beforeTextChanged(
                    s: CharSequence?,
                    start: Int,
                    count: Int,
                    after: Int
                ) {
                }

                @SuppressLint("SetTextI18n")
                override fun onTextChanged(
                    s: CharSequence?,
                    start: Int,
                    before: Int,
                    count: Int
                ) {
                    val text = (input_name as EditText).text.toString()
                    val editTextRowCount = input_name.lineCount
                    if (editTextRowCount > 15) {
                        val newText = text.substring(0, text.length - 1)
                        input_name.setText("")
                        input_name.append(newText)
                    }
                }
            })

Essayez d'utiliser la combinaison suivante d'attributs du EditText dans le fichier xml:

android:singleLine="true"
android:maxLength="22"