EditText maxLines nie działa - użytkownik wciąż może wprowadzić więcej wierszy niż ustawione

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

Użytkownik może wprowadzić więcej niż 5 wierszy, naciskając klawisz Enter / następny wiersz. Jak mogę ograniczyć dane wejściowe użytkownika do stałej liczby wierszy za pomocą EditText?

Atrybut maxLinesodpowiada maksymalnej wysokości EditText, kontroluje zewnętrzne granice, a nie wewnętrzne linie tekstu.

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

Musisz tylko upewnić się, że masz ustawiony atrybut „inputType”. Nie działa bez tej linii.

android:inputType="text"

Nie rozwiązuje to ogólnego problemu ograniczenia do n linii. Jeśli chcesz ograniczyć swój EditText do jednej linii tekstu, może to być bardzo proste.
Możesz to ustawić w pliku xml.

android:singleLine="true"

lub programowo

editText.setSingleLine(true);

@Cedekasem masz rację, nie ma wbudowanego "ogranicznika wierszy". Ale zbudowałem samodzielnie, więc jeśli ktoś jest zainteresowany, kod znajduje się poniżej. Twoje zdrowie.

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

Zrobiłem coś, czego szukaliście. Oto moja LimitedEditTextklasa.

Cechy:

• możesz ograniczyć liczbę wierszy w komponencie LimitedEditText
• możesz ograniczyć liczbę znaków w komponencie LimitedEditText
• jeśli przekroczysz limit znaków lub linii gdzieś w środku tekstu, kursor
  nie przeniesie Cię do końca - pozostanie tam, gdzie byłeś.

Wyłączam nasłuchiwanie, ponieważ każde wywołanie setText()metody wywoływałoby rekurencyjnie te 3 metody wywołania zwrotnego w przypadku, gdy użytkownik przekroczył limit znaków lub linii.

Kod:

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

}

Zrobiłem dla tego prostsze rozwiązanie: 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);
        }
    });

Możesz zmienić wartość 3 cali txtSpecialRequests.getLineCount() > 3według swoich potrzeb.

Oto InputFilter, który ogranicza dozwolone linie w 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;
  }
}

Aby dodać go do EditText:

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

Oto, czego użyłem w moim projekcie:

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

I działało we wszystkich scenariuszach

ustaw editText android:inputType="text"

Najprostsze rozwiązanie:

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)

to jest jedno podejście. Może komuś pomóc.

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

Innym sposobem ograniczenia EditTextdo jednej linii jest:

editText2.setTransformationMethod(new SingleLineTransformationMethod());

Zwróć uwagę, że po zastosowaniu tej metody transformacji klawisz Enter tworzy spacje po naciśnięciu. To nadal spełnia pytanie TS.

Możesz ograniczyć swój tekst do liczby linii, mówię około 37 alfabetów w jednej linii

<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 () jest jedną z opcji; jeśli chcesz mieć wartości niezerowe, upewnij się, że Twój widok jest mierzony. W przypadku klawiatury programowej onKeyListener nie działa, więc musisz dodać addTextChangedListener (), który będzie śledzić zmiany tekstu podczas pisania. Jak tylko uzyskasz wystarczającą liczbę wierszy w jego wywołaniach zwrotnych, zrób wszystko, co chcesz, aby je ograniczyć: usuń znaki za pomocą getText (), setText () lub czegoś bardziej wyszukanego. Możesz nawet ograniczyć liczbę znaków za pomocą filtra.

Inną opcją jest monitorowanie rozmiaru tekstu za pomocą metody getLineBounds (). Będzie to oddziaływać z grawitacją / paddign tekstu, więc bądź ostrożny.

Aby ograniczyć liczbę znaków, możemy po prostu użyć właściwości maxLength elementu EditText, ponieważ nie pozwoli to użytkownikowi na wprowadzenie większej liczby znaków.

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

Inny pomysł: za każdym razem po wpisaniu, nowy tekst byłby zapisywany jako String lastText, tylko jeśli liczba linii nie przekracza MAX_LINES. Jeśli tak, ustawilibyśmy tekst EditText na ostatnio dodany tekst (aby zmiany zostały usunięte) i powiadomilibyśmy użytkownika, aby był krótki.

 // 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();
            }
        }
    });

To jest rozszerzenie odpowiedzi Indreka Kõue na temat Kotlina

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

Spróbuj użyć następującej kombinacji atrybutów EditText w pliku xml:

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