EditText maxLines çalışmıyor - kullanıcı yine de ayarlanandan daha fazla satır girebilir

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

Kullanıcı, enter / sonraki satır tuşuna basarak 5'ten fazla satır girebilir. EditText ile kullanıcı girişini sabit sayıda satırla nasıl sınırlayabilirim?

Öznitelik maxLinesmaksimum yüksekliğine karşılık gelir EditText, iç metin satırlarını değil dış sınırları kontrol eder.

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

"İnputType" özelliğinin ayarlandığından emin olmanız yeterlidir. Bu çizgi olmadan çalışmaz.

android:inputType="text"

Bu, n satırla sınırlama genel sorununu çözmez. EditText'inizi yalnızca 1 satır metin alacak şekilde sınırlamak istiyorsanız, bu çok kolay olabilir.
Bunu xml dosyasında ayarlayabilirsiniz.

android:singleLine="true"

veya programlı olarak

editText.setSingleLine(true);

@Cedekasem haklısınız, yerleşik bir "satır sınırlayıcı" yok. Ama ben bir tane yaptım, bu yüzden ilgilenen varsa kod aşağıdadır. Şerefe.

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

Sizin aradığınız gibi bir şey yaptım. İşte benim LimitedEditTextsınıfım.

Özellikleri:

• LimitedEditText bileşeninizdeki satır sayısını sınırlayabilirsiniz
• LimitedEditText bileşeninizdeki karakter sayısını sınırlayabilirsiniz
• Metnin ortasında bir yerde karakter veya satır sınırını aşarsanız, imleç
  sizi sona götürmez - bulunduğunuz yerde kalır.

Dinleyiciyi kapatıyorum, çünkü her setText()yöntem çağrısı, kullanıcının karakter veya satır sınırını aşması durumunda bu 3 geri çağrı yöntemini özyinelemeli olarak çağırır.

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

}

Bunun için daha basit bir çözüm yaptım: 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);
        }
    });

3 in değerini txtSpecialRequests.getLineCount() > 3ihtiyaçlarınıza göre değiştirebilirsiniz.

İşte EditText'te izin verilen satırları sınırlayan bir InputFilter:

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

EditText'e eklemek için:

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

Projemde kullandığım şey bu:

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

Ve tüm senaryolarda çalıştı

editText ayarla android:inputType="text"

En basit çözüm:

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)

bu bir yaklaşımdır. Birine yardımcı olabilir.

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

Numaranızı EditTextbir satırla sınırlamanın başka bir yolu şudur:

editText2.setTransformationMethod(new SingleLineTransformationMethod());

Bu dönüştürme yöntemini uyguladıktan sonra, enter tuşuna basıldığında boşluklar oluşturduğuna dikkat edin. Bu hala TS'nin sorusunu tatmin ediyor.

Tek satırda 37 alfabe dediğim satır sayınıza göre metninizi sınırlayabilirsiniz

<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 () bir seçenektir; sıfır olmayan değerler istiyorsanız, görünümünüzün ölçüldüğünden emin olun. Yazılım klavyesi için onKeyListener çalışmaz, bu nedenle siz yazarken metin değişikliklerini izleyecek addTextChangedListener () eklemeniz gerekir. Geri aramalarında yeterince satır alır almaz, sınırlamak istediğinizi yapın: getText (), setText () veya daha süslü bir şey ile karakterleri silin. Hatta bir filtre kullanarak karakter sayısını sınırlayabilirsiniz.

Diğer bir seçenek de metnin boyutunu getLineBounds () ile izlemektir. Bu, metin yerçekimi / paddign ile etkileşime girecektir, bu yüzden dikkatli olun.

Sınırlı karakter sayısı için, kullanıcının daha fazla karakter girmesine izin vermeyeceğinden, EditText'in maxLength özelliğini kullanabiliriz.

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

Başka bir fikir: Her yazdıktan sonra, yeni metin yalnızca satır sayısı MAX_LINES'i aşmıyorsa String lastText'e kaydedilir. Varsa, EditText metnini son eklenen metne ayarlar (böylece değişiklikler silinir) ve kullanıcıyı kısa tutması için bilgilendiririz.

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

Bu, Indrek Kõue'nun Kotlin'e cevabının bir uzantısıdır

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

Xml dosyası içindeki EditText özniteliklerinin aşağıdaki kombinasyonunu kullanmayı deneyin:

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