Java Android setEllipsize在扩展EditText的类上不起作用

我有一个扩展EditText的类，在这个类上，我试图使文本在文本太长时设置为setEllipsize。由于某种原因，我所有的努力都没有成功。 似乎我可以在文本视图中水平滚动文本。。。 有人能给我建议如何使它起作用吗。 （到目前为止，我已经尝试过将这些功能和 这是我在代码中的角色：

public class LMEditTextAutoSize extends EditText {
private boolean autoSize;

public LMEditTextAutoSize(Context context, AttributeSet attrs, int defStyle) {
    super(context, attrs, defStyle);
    mTextSize = getTextSize();
    mMaxTextSize = getTextSize();
}

public LMEditTextAutoSize(Context context, AttributeSet attrs) {
    super(context, attrs);
    mTextSize = getTextSize();
    mMaxTextSize = getTextSize();
}

public LMEditTextAutoSize(Context context) {
    super(context);
    mTextSize = getTextSize();
    mMaxTextSize = getTextSize();
}

public void setAutoSize(boolean autoSize) {
    this.autoSize = autoSize;
    resetTextSize();
}

// Minimum text size for this text view
public static final float MIN_TEXT_SIZE = 50;

// Interface for resize notifications
public interface OnTextResizeListener {
    public void onTextResize(TextView textView, float oldSize, float newSize);
}

// Our ellipse string
private static final String mEllipsis = "...";

// Registered resize listener
private OnTextResizeListener mTextResizeListener;

// Flag for text and/or size changes to force a resize
private boolean mNeedsResize = false;

// Text size that is set from code. This acts as a starting point for resizing
private float mTextSize;

// Temporary upper bounds on the starting text size
private float mMaxTextSize = 0;

// Lower bounds for text size
private float mMinTextSize = MIN_TEXT_SIZE;

// Text view line spacing multiplier
private float mSpacingMult = 1.0f;

// Text view additional line spacing
private float mSpacingAdd = 0.0f;

// Add ellipsis to text that overflows at the smallest text size
private boolean mAddEllipsis = true;

private int widthLimit;

private int heightLimit;

/**
 * When text changes, set the force resize flag to true and reset the text size.
 */
@Override
protected void onTextChanged(final CharSequence text, final int start, final int before, final int after) {
    mNeedsResize = true;
    // Since this view may be reused, it is good to reset the text size
    resetTextSize();

}

/**
 * If the text view size changed, set the force resize flag to true
 */
@Override
protected void onSizeChanged(int w, int h, int oldw, int oldh) {
    if (w != oldw || h != oldh) {
        mNeedsResize = true;
    }
}

/**
 * Register listener to receive resize notifications
 * 
 * @param listener
 */
public void setOnResizeListener(OnTextResizeListener listener) {
    mTextResizeListener = listener;
}

/**
 * Override the set text size to update our internal reference values
 */
@Override
public void setTextSize(float size) {
    super.setTextSize(size);
    mTextSize = getTextSize();
}

/**
 * Override the set text size to update our internal reference values
 */
@Override
public void setTextSize(int unit, float size) {
    super.setTextSize(unit, size);
    mTextSize = getTextSize();
}

/**
 * Override the set line spacing to update our internal reference values
 */
@Override
public void setLineSpacing(float add, float mult) {
    super.setLineSpacing(add, mult);
    mSpacingMult = mult;
    mSpacingAdd = add;
}

/**
 * Set the upper text size limit and invalidate the view
 * 
 * @param maxTextSize
 */
public void setMaxTextSize(float maxTextSize) {
    mMaxTextSize = maxTextSize;
    requestLayout();
    invalidate();
}

/**
 * Return upper text size limit
 * 
 * @return
 */
public float getMaxTextSize() {
    return mMaxTextSize;
}

/**
 * Set the lower text size limit and invalidate the view
 * 
 * @param minTextSize
 */
public void setMinTextSize(float minTextSize) {
    mMinTextSize = minTextSize;
    requestLayout();
    invalidate();
}

/**
 * Return lower text size limit
 * 
 * @return
 */
public float getMinTextSize() {
    return mMinTextSize;
}

/**
 * Set flag to add ellipsis to text that overflows at the smallest text size
 * 
 * @param addEllipsis
 */
public void setAddEllipsis(boolean addEllipsis) {
    mAddEllipsis = addEllipsis;
}

/**
 * Return flag to add ellipsis to text that overflows at the smallest text size
 * 
 * @return
 */
public boolean getAddEllipsis() {
    return mAddEllipsis;
}

/**
 * Reset the text to the original size
 */
public void resetTextSize() {
    if (autoSize) {
        if (mTextSize > 0) {
            super.setTextSize(TypedValue.COMPLEX_UNIT_PX, mMaxTextSize);
            mTextSize = mMaxTextSize;
        }
    }
}

/**
 * Resize text after measuring
 */
@Override
protected void onLayout(boolean changed, int left, int top, int right, int bottom) {
    if (changed || mNeedsResize) {
        widthLimit = (right - left) - getCompoundPaddingLeft() - getCompoundPaddingRight();
        heightLimit = (bottom - top) - getCompoundPaddingBottom() - getCompoundPaddingTop();
        resizeText(widthLimit, heightLimit);
    }
    super.onLayout(changed, left, top, right, bottom);
}

/**
 * Resize the text size with specified width and height
 * 
 * @param width
 * @param height
 */
public void resizeText(int width, int height) {
    if (autoSize) {
        CharSequence text = getText();
        int oneLineWidth = width;
        int lineCount = getLineCount();
        int minTextHeight = getTextHeight("oo", getPaint(), width, mMinTextSize);
        int maxLineInHeight = height / minTextHeight;
        lineCount = lineCount > maxLineInHeight ? maxLineInHeight : lineCount;
        if (lineCount > 1) {
            width = width * lineCount;
        }
        // Do not resize if the view does not have dimensions or there is no text
        if (text == null || text.length() == 0 || height <= 0 || width <= 0 || mTextSize == 0) {
            return;
        }

        // Get the text view's paint object
        TextPaint textPaint = getPaint();

        // Store the current text size
        float oldTextSize = textPaint.getTextSize();
        // If there is a max text size set, use the lesser of that and the default text size
        float targetTextSize = mMaxTextSize > 0 ? Math.min(mTextSize, mMaxTextSize) : mTextSize;

        // Get the required text height
        int textHeight = getTextHeight(text, textPaint, width, targetTextSize);

        // Until we either fit within our text view or we had reached our min text size, incrementally try smaller sizes
        while (textHeight > height && targetTextSize > mMinTextSize) {
            targetTextSize = Math.max(targetTextSize - 2, mMinTextSize);
            textHeight = getTextHeight(text, textPaint, width, targetTextSize);
        }
        TextPaint paintCopy = new TextPaint(textPaint);
        paintCopy.setTextSize(targetTextSize);
        float textWidte = paintCopy.measureText(text, 0, text.length());
        while (textWidte > width && targetTextSize > mMinTextSize) {
            targetTextSize = Math.max(targetTextSize - 2, mMinTextSize);
            paintCopy.setTextSize(targetTextSize);
            textWidte = paintCopy.measureText(text, 0, text.length());
        }

        if (lineCount > 1) {
            int textHeightforLine = getTextHeight(text, textPaint, oneLineWidth, targetTextSize);
            while (textHeightforLine > height && targetTextSize > mMinTextSize) {
                targetTextSize = Math.max(targetTextSize - 2, mMinTextSize);
                textHeightforLine = getTextHeight(text, textPaint, oneLineWidth, targetTextSize);
            }
        }

        // If we had reached our minimum text size and still don't fit, append an ellipsis
        if (mAddEllipsis && targetTextSize == mMinTextSize && textHeight > height) {
            // Draw using a static layout
            // modified: use a copy of TextPaint for measuring
            TextPaint paint = new TextPaint(textPaint);
            paint.setTextSize(mMinTextSize);
            // Draw using a static layout
            StaticLayout layout = new StaticLayout(text, paint, width, Alignment.ALIGN_NORMAL, mSpacingMult, mSpacingAdd, false);
            // Check that we have a least one line of rendered text
            if (layout.getLineCount() > 0) {
                // Since the line at the specific vertical position would be cut off,
                // we must trim up to the previous line
                int lastLine = layout.getLineForVertical(height) - 1;
                // If the text would not even fit on a single line, clear it
                if (lastLine < 0) {
                    setText("");
                }
                // Otherwise, trim to the previous line and add an ellipsis
                else {
                    int start = layout.getLineStart(lastLine);
                    int end = layout.getLineEnd(lastLine);
                    float lineWidth = layout.getLineWidth(lastLine);
                    float ellipseWidth = textPaint.measureText(mEllipsis);

                    // Trim characters off until we have enough room to draw the ellipsis
                    while (width < lineWidth + ellipseWidth) {
                        lineWidth = textPaint.measureText(text.subSequence(start, --end + 1).toString());
                    }
                    if (end != 0) {
                        setInputType(InputType.TYPE_CLASS_TEXT);
                        setSingleLine(true);
                        setLines(1);
                        setMaxLines(1);
                        setEllipsize(TextUtils.TruncateAt.END);
                        setSelected(true);
                        setText(text);
                    }
                }
            }

        }

        // Some devices try to auto adjust line spacing, so force default line spacing
        // and invalidate the layout as a side effect
        setTextSize(TypedValue.COMPLEX_UNIT_PX, targetTextSize);
        setLineSpacing(mSpacingAdd, mSpacingMult);

        // Notify the listener if registered
        if (mTextResizeListener != null) {
            mTextResizeListener.onTextResize(this, oldTextSize, targetTextSize);
        }

        // Reset force resize flag
        mNeedsResize = false;
    }
}

// Set the text size of the text paint object and use a static layout to render text off screen before measuring
private int getTextHeight(CharSequence source, TextPaint paint, int width, float textSize) {
    TextPaint paintCopy = new TextPaint(paint);
    paintCopy.setTextSize(textSize);
    StaticLayout layout = new StaticLayout(source, paintCopy, width, Alignment.ALIGN_NORMAL, mSpacingMult, mSpacingAdd, true);
    return layout.getHeight();
}

公共类LMEditTextAutoSize扩展了EditText{
私有布尔值自动调整；
公共LMEditTextAutoSize（上下文上下文、属性集属性、int-defStyle）{
超级（上下文、属性、定义样式）；
mTextSize=getTextSize（）；
mmaxtsize=getTextSize（）；
}
公共LMEditTextAutoSize（上下文、属性集属性）{
超级（上下文，attrs）；
mTextSize=getTextSize（）；
mmaxtsize=getTextSize（）；
}
公共LMEditTextAutoSize（上下文）{
超级（上下文）；
mTextSize=getTextSize（）；
mmaxtsize=getTextSize（）；
}
public void setAutoSize（布尔值自动大小）{
this.autoSize=自动调整大小；
resetTextSize（）；
}
//此文本视图的最小文本大小
公共静态最终浮动最小文本大小=50；
//调整大小通知的接口
公共接口OnTextResizeListener{
public void onTextResize（TextView TextView、float oldSize、float newSize）；
}
//我们的椭圆弦
私有静态最终字符串mEllipsis=“…”；
//注册调整侦听器大小
私有OnTextResizeListener mTextResizeListener；
//文本和/或大小更改的标志，以强制调整大小
私有布尔值mNeedsResize=false；
//根据代码设置的文本大小。这是调整大小的起点
私有浮动mTextSize；
//起始文本大小的临时上限
私有浮点mMaxTextSize=0；
//文本大小的下限
私有浮点mMinTextSize=MIN\u TEXT\u SIZE；
//文本视图行距倍增器
私人浮动mSpacingMult=1.0f；
//文本视图附加行间距
私人浮动mSpacingAdd=0.0f；
//将省略号添加到以最小文本大小溢出的文本中
私有布尔mAddEllipsis=true；
私人有限公司；
私人内部高度限制；
/**
*文本更改时，请将“强制调整大小”标志设置为true并重置文本大小。
*/
@凌驾
受保护的void onTextChanged（最终字符序列文本、最终整数开始、最终整数之前、最终整数之后）{
mNeedsResize=true；
//由于此视图可以重用，因此最好重置文本大小
resetTextSize（）；
}
/**
*如果文字视图大小已更改，请将“强制调整大小”标志设置为true
*/
@凌驾
已更改尺寸的受保护空心（整数w、整数h、整数oldw、整数oldh）{
如果（w！=oldw | | h！=oldh）{
mNeedsResize=true；
}
}
/**
*注册侦听器以接收调整大小通知
* 
*@param侦听器
*/
public void setOnResizeListener（OnTextResizeListener侦听器）{
mTextResizeListener=监听器；
}
/**
*覆盖设置的文本大小以更新内部参考值
*/
@凌驾
公共void setTextSize（浮动大小）{
super.setTextSize（大小）；
mTextSize=getTextSize（）；
}
/**
*覆盖设置的文本大小以更新内部参考值
*/
@凌驾
公共void setTextSize（整数单位，浮点大小）{
super.setTextSize（单位，大小）；
mTextSize=getTextSize（）；
}
/**
*覆盖设置的行距以更新内部参考值
*/
@凌驾
公共void设置行间距（浮动添加、浮动多个）{
super.setlinespace（添加，多个）；
mSpacingMult=mult；
mSpacingAdd=添加；
}
/**
*设置文本大小上限并使视图无效
* 
*@param maxTextSize
*/
公共void setMaxTextSize（浮动maxTextSize）{
mmaxtsize=maxTextSize；
requestLayout（）；
使无效（）；
}
/**
*返回文本大小上限
* 
*@返回
*/
公共浮点getMaxTextSize（）{
返回mMaxTextSize；
}
/**
*设置较低的文本大小限制并使视图无效
* 
*@param minTextSize
*/
公共void setMinTextSize（浮点minTextSize）{
mMinTextSize=minTextSize；
requestLayout（）；
使无效（）；
}
/**
*返回较低的文本大小限制
* 
*@返回
*/
公共浮点getMinTextSize（）{
返回mMinTextSize；
}
/**
*设置标志以向溢出的最小文本大小的文本添加省略号
* 
*@param addEllipsis
*/
public void setAddEllipsis（布尔addEllipsis）{
mAddEllipsis=addEllipsis；
}
/**
*返回标志，用于向溢出的最小文本大小的文本添加省略号
* 
*@返回
*/
公共布尔getAddEllipsis（）{
回归疯癫；
}
/**
*将文本重置为原始大小
*/
public void resetTextSize（）{
如果（自动调整大小）{
如果（mTextSize>0）{
super.setTextSize（TypedValue.COMPLEX\u UNIT\u PX，mmaxtsize）；
mTextSize=mmaxtsize；
}
}
}
/**
*测量后调整文本大小
*/
@凌驾
仅限受保护的空心布局（布尔值已更改、整数左侧、整数顶部、整数右侧、整数底部）{
如果（已更改| | mNeedsResize）{
宽度限制=（右-左）-getCompoundPaddingLeft（）-getCompoundPaddingRight（）；
高度限制=（底部-顶部）-getCompoundPaddingBottom（）-getCompoundPaddingTop（）；
resizeText（宽度限制、高度限制）；
}
超级。仅限布局（已更改、左、上、右、下）；
}
/**
*使用指定的宽度和高度调整文本大小
* 
*@参数宽度
*@param高度
*/
公共空白重设文字（整幅宽度、整幅高度）{
如果（自动调整大小）{
CharSequence text=getText（）；
int oneLineWidth=宽度；
int lineCount=getLineCount（）；
int minTextHeight=getTextHeight（“oo”，getPaint（），宽度，mMinTextSize）；
int MAXLINHEIGH=高度/MINTEXTHEIGH；
lineCount=lineCount>maxLineInHeight？maxLineInHeight:lineCount；
如果（行数>1）{
宽度=宽度*行数；
}
//如果视图没有尺寸标注或没有文字，请不要调整大小
if（text==null | | text.length（）==0 | | height）{
//使用静态布局绘制