android ellipsize 多行文本视图

android ellipsize multiline textview

提问by Arutha

I need to ellipsize a multi-line textview. My component is large enough to display at least 4 lines with the ellipse, but only 2 lines are displayed. I tried to change the minimum and maximum number of rows of the component but it changes nothing.

我需要椭圆化多行文本视图。我的组件足够大，可以用椭圆显示至少 4 行，但只显示 2 行。我试图更改组件的最小和最大行数，但没有任何改变。

回答by Micah Hainline

Here is a solution to the problem. It is a subclass of TextView that actually works for ellipsizing. The android-textview-multiline-ellipse code listed in an earlier answer I have found to be buggy in certain circumstances, as well as being under GPL, which doesn't really work for most of us. Feel free to use this code freely and without attribution, or under the Apache license if you would prefer. Note that there is a listener to notify you when the text becomes ellipsized, which I found quite useful myself.

这是问题的解决方案。它是 TextView 的一个子类，实际上适用于省略号。我发现在早期答案中列出的 android-textview-multiline-ellipse 代码在某些情况下有问题，并且在 GPL 下，这对我们大多数人来说并不真正有效。随意使用此代码，无需署名，或者如果您愿意，也可以在 Apache 许可下使用。请注意，当文本变成椭圆时，有一个侦听器会通知您，我自己发现这非常有用。

import java.util.ArrayList;
import java.util.List;

import android.content.Context;
import android.graphics.Canvas;
import android.text.Layout;
import android.text.Layout.Alignment;
import android.text.StaticLayout;
import android.text.TextUtils.TruncateAt;
import android.util.AttributeSet;
import android.widget.TextView;

public class EllipsizingTextView extends TextView {
    private static final String ELLIPSIS = "...";

    public interface EllipsizeListener {
        void ellipsizeStateChanged(boolean ellipsized);
    }

    private final List<EllipsizeListener> ellipsizeListeners = new ArrayList<EllipsizeListener>();
    private boolean isEllipsized;
    private boolean isStale;
    private boolean programmaticChange;
    private String fullText;
    private int maxLines = -1;
    private float lineSpacingMultiplier = 1.0f;
    private float lineAdditionalVerticalPadding = 0.0f;

    public EllipsizingTextView(Context context) {
        super(context);
    }

    public EllipsizingTextView(Context context, AttributeSet attrs) {
        super(context, attrs);
    }

    public EllipsizingTextView(Context context, AttributeSet attrs, int defStyle) {
        super(context, attrs, defStyle);
    }

    public void addEllipsizeListener(EllipsizeListener listener) {
        if (listener == null) {
            throw new NullPointerException();
        }
        ellipsizeListeners.add(listener);
    }

    public void removeEllipsizeListener(EllipsizeListener listener) {
        ellipsizeListeners.remove(listener);
    }

    public boolean isEllipsized() {
        return isEllipsized;
    }

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

    public int getMaxLines() {
        return maxLines;
    }

    @Override
    public void setLineSpacing(float add, float mult) {
        this.lineAdditionalVerticalPadding = add;
        this.lineSpacingMultiplier = mult;
        super.setLineSpacing(add, mult);
    }

    @Override
    protected void onTextChanged(CharSequence text, int start, int before, int after) {
        super.onTextChanged(text, start, before, after);
        if (!programmaticChange) {
            fullText = text.toString();
            isStale = true;
        }
    }

    @Override
    protected void onDraw(Canvas canvas) {
        if (isStale) {
            super.setEllipsize(null);
            resetText();
        }
        super.onDraw(canvas);
    }

    private void resetText() {
        int maxLines = getMaxLines();
        String workingText = fullText;
        boolean ellipsized = false;
        if (maxLines != -1) {
            Layout layout = createWorkingLayout(workingText);
            if (layout.getLineCount() > maxLines) {
                workingText = fullText.substring(0, layout.getLineEnd(maxLines - 1)).trim();
                while (createWorkingLayout(workingText + ELLIPSIS).getLineCount() > maxLines) {
                    int lastSpace = workingText.lastIndexOf(' ');
                    if (lastSpace == -1) {
                        break;
                    }
                    workingText = workingText.substring(0, lastSpace);
                }
                workingText = workingText + ELLIPSIS;
                ellipsized = true;
            }
        }
        if (!workingText.equals(getText())) {
            programmaticChange = true;
            try {
                setText(workingText);
            } finally {
                programmaticChange = false;
            }
        }
        isStale = false;
        if (ellipsized != isEllipsized) {
            isEllipsized = ellipsized;
            for (EllipsizeListener listener : ellipsizeListeners) {
                listener.ellipsizeStateChanged(ellipsized);
            }
        }
    }

    private Layout createWorkingLayout(String workingText) {
        return new StaticLayout(workingText, getPaint(), getWidth() - getPaddingLeft() - getPaddingRight(),
                Alignment.ALIGN_NORMAL, lineSpacingMultiplier, lineAdditionalVerticalPadding, false);
    }

    @Override
    public void setEllipsize(TruncateAt where) {
        // Ellipsize settings are not respected
    }
}

回答by hooloovoo

In my app, I had similar problem: 2 line of string and, eventually, add "..." if the string was too long. I used this code in xml file into textview tag:

在我的应用程序中，我遇到了类似的问题：2 行字符串，如果字符串太长，最终添加“...”。我在 xml 文件中将此代码用于 textview 标记：

android:maxLines="2"
android:ellipsize="end"
android:singleLine="false"

回答by Lysogen

Try this, it works for me, I have 4 lines and it adds the "..." to the end of the last/fourth line. Its the same as morale's answer but i have singeLine="false" in there.

试试这个，它对我有用，我有 4 行，它在最后/第四行的末尾添加了“...”。它与士气的答案相同，但我在那里有 singeLine="false" 。

<TextView 
android:layout_width="fill_parent" 
android:layout_height="wrap_content" 
android:maxLines="4" 
android:ellipsize="marquee" 
android:singleLine="false" 
android:text="Hi make this a very long string that wraps at least 4 lines, seriously make it really really long so it gets cut off at the fourth line not joke.  Just do it!" />

回答by Robert Nekic

I've run into this problem, too. There's a rather old bug about it that remains unanswered: Bug 2254

我也遇到过这个问题。有一个相当古老的错误仍未得到解答：错误 2254

回答by Percuss

Got this problem to, and finaly, I build myself a short solution. You just have to ellipsize manually the line you want, your maxLine attribute will cut your text.

解决了这个问题，最后，我为自己建立了一个简短的解决方案。你只需要手动椭圆你想要的线，你的 maxLine 属性会剪切你的文本。

This example cut your text for 3 lines max

此示例最多将文本剪切 3 行

        final TextView title = (TextView)findViewById(R.id.text);
        title.setText("A really long text");
        ViewTreeObserver vto = title.getViewTreeObserver();
        vto.addOnGlobalLayoutListener(new OnGlobalLayoutListener() {

            @Override
            public void onGlobalLayout() {
                ViewTreeObserver obs = title.getViewTreeObserver();
                obs.removeGlobalOnLayoutListener(this);
                if(title.getLineCount() > 3){
                    Log.d("","Line["+title.getLineCount()+"]"+title.getText());
                    int lineEndIndex = title.getLayout().getLineEnd(2);
                    String text = title.getText().subSequence(0, lineEndIndex-3)+"...";
                    title.setText(text);
                    Log.d("","NewText:"+text);
                }

            }
        });

回答by shayousefi

I combined the solutions by Micah Hainline, Alex B?lu?, and Paul Imhoff to create an ellipsizing multiline TextViewthat also supports Spannedtext.

我结合了 Micah Hainline、Alex B?lu? 和 Paul Imhoff 的解决方案，创建了一个TextView也支持Spanned文本的椭圆化多行。

You only need to set android:ellipsizeand android:maxLines.

您只需要设置android:ellipsize和android:maxLines。

/*
 * Copyright (C) 2011 Micah Hainline
 * Copyright (C) 2012 Triposo
 * Copyright (C) 2013 Paul Imhoff
 * Copyright (C) 2014 Shahin Yousefi
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

import android.annotation.SuppressLint;
import android.content.Context;
import android.content.res.TypedArray;
import android.graphics.Canvas;
import android.support.annotation.NonNull;
import android.text.Layout;
import android.text.Layout.Alignment;
import android.text.SpannableStringBuilder;
import android.text.Spanned;
import android.text.StaticLayout;
import android.text.TextUtils;
import android.text.TextUtils.TruncateAt;
import android.util.AttributeSet;
import android.widget.TextView;

import java.util.ArrayList;
import java.util.List;
import java.util.regex.Pattern;

public class EllipsizingTextView extends TextView {
    private static final CharSequence ELLIPSIS = "\u2026";
    private static final Pattern DEFAULT_END_PUNCTUATION
            = Pattern.compile("[\.!?,;:\u2026]*$", Pattern.DOTALL);
    private final List<EllipsizeListener> mEllipsizeListeners = new ArrayList<>();
    private EllipsizeStrategy mEllipsizeStrategy;
    private boolean isEllipsized;
    private boolean isStale;
    private boolean programmaticChange;
    private CharSequence mFullText;
    private int mMaxLines;
    private float mLineSpacingMult = 1.0f;
    private float mLineAddVertPad = 0.0f;

    private Pattern mEndPunctPattern;

    public EllipsizingTextView(Context context) {
        this(context, null);
    }


    public EllipsizingTextView(Context context, AttributeSet attrs) {
        this(context, attrs, android.R.attr.textViewStyle);
    }


    public EllipsizingTextView(Context context, AttributeSet attrs, int defStyle) {
        super(context, attrs, defStyle);
        TypedArray a = context.obtainStyledAttributes(attrs,
                new int[]{ android.R.attr.maxLines }, defStyle, 0);
        setMaxLines(a.getInt(0, Integer.MAX_VALUE));
        a.recycle();
        setEndPunctuationPattern(DEFAULT_END_PUNCTUATION);
    }

    public void setEndPunctuationPattern(Pattern pattern) {
        mEndPunctPattern = pattern;
    }

    public void addEllipsizeListener(@NonNull EllipsizeListener listener) {
        mEllipsizeListeners.add(listener);
    }

    public void removeEllipsizeListener(EllipsizeListener listener) {
        mEllipsizeListeners.remove(listener);
    }

    public boolean isEllipsized() {
        return isEllipsized;
    }

    @SuppressLint("Override")
    public int getMaxLines() {
        return mMaxLines;
    }

    @Override
    public void setMaxLines(int maxLines) {
        super.setMaxLines(maxLines);
        mMaxLines = maxLines;
        isStale = true;
    }

    public boolean ellipsizingLastFullyVisibleLine() {
        return mMaxLines == Integer.MAX_VALUE;
    }

    @Override
    public void setLineSpacing(float add, float mult) {
        mLineAddVertPad = add;
        mLineSpacingMult = mult;
        super.setLineSpacing(add, mult);
    }

    @Override
    public void setText(CharSequence text, BufferType type) {
        if (!programmaticChange) {
            mFullText = text;
            isStale = true;
        }
        super.setText(text, type);
    }

    @Override
    protected void onSizeChanged(int w, int h, int oldw, int oldh) {
        super.onSizeChanged(w, h, oldw, oldh);
        if (ellipsizingLastFullyVisibleLine()) isStale = true;
    }

    @Override
    public void setPadding(int left, int top, int right, int bottom) {
        super.setPadding(left, top, right, bottom);
        if (ellipsizingLastFullyVisibleLine()) isStale = true;
    }

    @Override
    protected void onDraw(@NonNull Canvas canvas) {
        if (isStale) resetText();
        super.onDraw(canvas);
    }

    private void resetText() {
        int maxLines = getMaxLines();
        CharSequence workingText = mFullText;
        boolean ellipsized = false;

        if (maxLines != -1) {
            if (mEllipsizeStrategy == null) setEllipsize(null);
            workingText = mEllipsizeStrategy.processText(mFullText);
            ellipsized = !mEllipsizeStrategy.isInLayout(mFullText);
        }

        if (!workingText.equals(getText())) {
            programmaticChange = true;
            try {
                setText(workingText);
            } finally {
                programmaticChange = false;
            }
        }

        isStale = false;
        if (ellipsized != isEllipsized) {
            isEllipsized = ellipsized;
            for (EllipsizeListener listener : mEllipsizeListeners) {
                listener.ellipsizeStateChanged(ellipsized);
            }
        }
    }

    @Override
    public void setEllipsize(TruncateAt where) {
        if (where == null) {
            mEllipsizeStrategy = new EllipsizeNoneStrategy();
            return;
        }

        switch (where) {
            case END:
                mEllipsizeStrategy = new EllipsizeEndStrategy();
                break;
            case START:
                mEllipsizeStrategy = new EllipsizeStartStrategy();
                break;
            case MIDDLE:
                mEllipsizeStrategy = new EllipsizeMiddleStrategy();
                break;
            case MARQUEE:
                super.setEllipsize(where);
                isStale = false;
            default:
                mEllipsizeStrategy = new EllipsizeNoneStrategy();
                break;
        }
    }

    public interface EllipsizeListener {
        void ellipsizeStateChanged(boolean ellipsized);
    }

    private abstract class EllipsizeStrategy {
        public CharSequence processText(CharSequence text) {
            return !isInLayout(text) ? createEllipsizedText(text) : text;
        }

        public boolean isInLayout(CharSequence text) {
            Layout layout = createWorkingLayout(text);
            return layout.getLineCount() <= getLinesCount();
        }

        protected Layout createWorkingLayout(CharSequence workingText) {
            return new StaticLayout(workingText, getPaint(),
                    getMeasuredWidth() - getPaddingLeft() - getPaddingRight(),
                    Alignment.ALIGN_NORMAL, mLineSpacingMult,
                    mLineAddVertPad, false /* includepad */);
        }

        protected int getLinesCount() {
            if (ellipsizingLastFullyVisibleLine()) {
                int fullyVisibleLinesCount = getFullyVisibleLinesCount();
                return fullyVisibleLinesCount == -1 ? 1 : fullyVisibleLinesCount;
            } else {
                return mMaxLines;
            }
        }

        protected int getFullyVisibleLinesCount() {
            Layout layout = createWorkingLayout("");
            int height = getHeight() - getCompoundPaddingTop() - getCompoundPaddingBottom();
            int lineHeight = layout.getLineBottom(0);
            return height / lineHeight;
        }

        protected abstract CharSequence createEllipsizedText(CharSequence fullText);
    }

    private class EllipsizeNoneStrategy extends EllipsizeStrategy {
        @Override
        protected CharSequence createEllipsizedText(CharSequence fullText) {
            return fullText;
        }
    }

    private class EllipsizeEndStrategy extends EllipsizeStrategy {
        @Override
        protected CharSequence createEllipsizedText(CharSequence fullText) {
            Layout layout = createWorkingLayout(fullText);
            int cutOffIndex = layout.getLineEnd(mMaxLines - 1);
            int textLength = fullText.length();
            int cutOffLength = textLength - cutOffIndex;
            if (cutOffLength < ELLIPSIS.length()) cutOffLength = ELLIPSIS.length();
            String workingText = TextUtils.substring(fullText, 0, textLength - cutOffLength).trim();
            String strippedText = stripEndPunctuation(workingText);

            while (!isInLayout(strippedText + ELLIPSIS)) {
                int lastSpace = workingText.lastIndexOf(' ');
                if (lastSpace == -1) break;
                workingText = workingText.substring(0, lastSpace).trim();
                strippedText = stripEndPunctuation(workingText);
            }

            workingText = strippedText + ELLIPSIS;
            SpannableStringBuilder dest = new SpannableStringBuilder(workingText);

            if (fullText instanceof Spanned) {
                TextUtils.copySpansFrom((Spanned) fullText, 0, workingText.length(), null, dest, 0);
            }
            return dest;
        }

        public String stripEndPunctuation(CharSequence workingText) {
            return mEndPunctPattern.matcher(workingText).replaceFirst("");
        }
    }

    private class EllipsizeStartStrategy extends EllipsizeStrategy {
        @Override
        protected CharSequence createEllipsizedText(CharSequence fullText) {
            Layout layout = createWorkingLayout(fullText);
            int cutOffIndex = layout.getLineEnd(mMaxLines - 1);
            int textLength = fullText.length();
            int cutOffLength = textLength - cutOffIndex;
            if (cutOffLength < ELLIPSIS.length()) cutOffLength = ELLIPSIS.length();
            String workingText = TextUtils.substring(fullText, cutOffLength, textLength).trim();

            while (!isInLayout(ELLIPSIS + workingText)) {
                int firstSpace = workingText.indexOf(' ');
                if (firstSpace == -1) break;
                workingText = workingText.substring(firstSpace, workingText.length()).trim();
            }

            workingText = ELLIPSIS + workingText;
            SpannableStringBuilder dest = new SpannableStringBuilder(workingText);

            if (fullText instanceof Spanned) {
                TextUtils.copySpansFrom((Spanned) fullText, textLength - workingText.length(),
                        textLength, null, dest, 0);
            }
            return dest;
        }
    }

    private class EllipsizeMiddleStrategy extends EllipsizeStrategy {
        @Override
        protected CharSequence createEllipsizedText(CharSequence fullText) {
            Layout layout = createWorkingLayout(fullText);
            int cutOffIndex = layout.getLineEnd(mMaxLines - 1);
            int textLength = fullText.length();
            int cutOffLength = textLength - cutOffIndex;
            if (cutOffLength < ELLIPSIS.length()) cutOffLength = ELLIPSIS.length();
            cutOffLength += cutOffIndex % 2;    // Make it even.
            String firstPart = TextUtils.substring(
                    fullText, 0, textLength / 2 - cutOffLength / 2).trim();
            String secondPart = TextUtils.substring(
                    fullText, textLength / 2 + cutOffLength / 2, textLength).trim();

            while (!isInLayout(firstPart + ELLIPSIS + secondPart)) {
                int lastSpaceFirstPart = firstPart.lastIndexOf(' ');
                int firstSpaceSecondPart = secondPart.indexOf(' ');
                if (lastSpaceFirstPart == -1 || firstSpaceSecondPart == -1) break;
                firstPart = firstPart.substring(0, lastSpaceFirstPart).trim();
                secondPart = secondPart.substring(firstSpaceSecondPart, secondPart.length()).trim();
            }

            SpannableStringBuilder firstDest = new SpannableStringBuilder(firstPart);
            SpannableStringBuilder secondDest = new SpannableStringBuilder(secondPart);

            if (fullText instanceof Spanned) {
                TextUtils.copySpansFrom((Spanned) fullText, 0, firstPart.length(),
                        null, firstDest, 0);
                TextUtils.copySpansFrom((Spanned) fullText, textLength - secondPart.length(),
                        textLength, null, secondDest, 0);
            }
            return TextUtils.concat(firstDest, ELLIPSIS, secondDest);
        }
    }
}

Complete source: EllipsizingTextView.java

完整来源：EllipsizingTextView.java

回答by Timo B?hr

In my case, there is no need to code this in Java. Everything works as expected. No need for something like android:singleLine="false".

就我而言，无需在 Java 中对此进行编码。一切都按预期工作。不需要像android:singleLine="false".

<TextView
  android:layout_width="match_parent"
  android:layout_height="wrap_content"
  android:ellipsize="end"
  android:maxLines="4"
  android:text="@string/very_long_text" />

But there seems to be a bug in the layout preview of Android Studio (v3.0):

但是Android Studio（v3.0）的布局预览似乎有一个bug：

Given Android 7.1.1 on my device this is working:

鉴于我的设备上的 Android 7.1.1 这是有效的：

回答by Kirk Woll

For those who are interested, here's a C# Xamarin.Android port of Micah's lovely solution:

对于那些感兴趣的人，这里是 Micah 可爱解决方案的 C# Xamarin.Android 端口：

public delegate void EllipsizeEvent(bool ellipsized);

public class EllipsizingTextView : TextView
{
    private const string Ellipsis = "...";

    public event EllipsizeEvent EllipsizeStateChanged;

    private bool isEllipsized;
    private bool isStale;
    private bool programmaticChange;
    private string fullText;
    private int maxLines = -1;
    private float lineSpacingMultiplier = 1.0f;
    private float lineAdditionalVerticalPadding;

    public EllipsizingTextView(Context context) : base(context) 
    {
    }

    public EllipsizingTextView(Context context, IAttributeSet attrs) : base(context, attrs) 
    {
    }

    public EllipsizingTextView(Context context, IAttributeSet attrs, int defStyle) : base(context, attrs, defStyle) 
    {
    }

    public EllipsizingTextView(IntPtr javaReference, JniHandleOwnership transfer) : base(javaReference, transfer)
    {
    }

    public bool IsEllipsized 
    {
        get { return isEllipsized; }
    }

    public override void SetMaxLines(int maxLines) {
        base.SetMaxLines(maxLines);
        this.maxLines = maxLines;
        isStale = true;
    }

    public int GetMaxLines() 
    {
        return maxLines;
    }

    public override void SetLineSpacing(float add, float mult) 
    {
        lineAdditionalVerticalPadding = add;
        lineSpacingMultiplier = mult;
        base.SetLineSpacing(add, mult);
    }

    protected override void OnTextChanged(ICharSequence text, int start, int before, int after) 
    {
        base.OnTextChanged(text, start, before, after);
        if (!programmaticChange) 
        {
            fullText = text.ToString();
            isStale = true;
        }
    }

    protected override void OnDraw(Canvas canvas) 
    {
        if (isStale) 
        {
            base.Ellipsize = null;
            ResetText();
        }
        base.OnDraw(canvas);
    }

    private void ResetText() 
    {
        int maxLines = GetMaxLines();
        string workingText = fullText;
        bool ellipsized = false;
        if (maxLines != -1) 
        {
            Layout layout = CreateWorkingLayout(workingText);
            if (layout.LineCount > maxLines) 
            {
                workingText = fullText.Substring(0, layout.GetLineEnd(maxLines - 1)).Trim();
                while (CreateWorkingLayout(workingText + Ellipsis).LineCount > maxLines) 
                {
                    int lastSpace = workingText.LastIndexOf(' ');
                    if (lastSpace == -1) 
                    {
                        break;
                    }
                    workingText = workingText.Substring(0, lastSpace);
                }
                workingText = workingText + Ellipsis;
                ellipsized = true;
            }
        }
        if (workingText != Text) 
        {
            programmaticChange = true;
            try 
            {
                Text = workingText;
            } 
            finally 
            {
                programmaticChange = false;
            }
        }
        isStale = false;
        if (ellipsized != isEllipsized) 
        {
            isEllipsized = ellipsized;
            if (EllipsizeStateChanged != null)
                EllipsizeStateChanged(ellipsized);
        }
    }

    private Layout CreateWorkingLayout(string workingText) 
    {
        return new StaticLayout(workingText, Paint, Width - PaddingLeft - PaddingRight, Layout.Alignment.AlignNormal, lineSpacingMultiplier, lineAdditionalVerticalPadding, false);
    }

    public override TextUtils.TruncateAt Ellipsize
    {
        get 
        { 
            return base.Ellipsize;
        }
        set 
        { 
        }
    }
}

回答by Till

Based on the solutions by Micah Hainline and alebs comment, I came of with the following approach that works with Spanned texts, so that e.g. myTextView.setText(Html.fromHtml("<b>Testheader</b> - Testcontent"));works! Note that this only works with Spannedright now. It could maybe be modified to work with Stringand Spannedeither way.

基于 Micah Hainline 和 alebs 评论的解决方案，我提出了以下适用于跨区文本的方法，以便例如myTextView.setText(Html.fromHtml("<b>Testheader</b> - Testcontent"));工作！请注意，这仅适用于Spanned现在。它也许可以被修改为与工作String和Spanned两种方式。

public class EllipsizingTextView extends TextView {
    private static final Spanned ELLIPSIS = new SpannedString("…");

      public interface EllipsizeListener {
        void ellipsizeStateChanged(boolean ellipsized);
      }

      private final List<EllipsizeListener> ellipsizeListeners = new ArrayList<EllipsizeListener>();
      private boolean isEllipsized;
      private boolean isStale;
      private boolean programmaticChange;
      private Spanned fullText;
      private int maxLines;
      private float lineSpacingMultiplier = 1.0f;
      private float lineAdditionalVerticalPadding = 0.0f;

      public EllipsizingTextView(Context context) {
        this(context, null);
      }

      public EllipsizingTextView(Context context, AttributeSet attrs) {
        this(context, attrs, 0);
      }

      public EllipsizingTextView(Context context, AttributeSet attrs, int defStyle) {
        super(context, attrs, defStyle);
        super.setEllipsize(null);
        TypedArray a = context.obtainStyledAttributes(attrs, new int[] { android.R.attr.maxLines });
        setMaxLines(a.getInt(0, Integer.MAX_VALUE));
      }

      public void addEllipsizeListener(EllipsizeListener listener) {
        if (listener == null) {
          throw new NullPointerException();
        }
        ellipsizeListeners.add(listener);
      }

      public void removeEllipsizeListener(EllipsizeListener listener) {
        ellipsizeListeners.remove(listener);
      }

      public boolean isEllipsized() {
        return isEllipsized;
      }

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

      public int getMaxLines() {
        return maxLines;
      }

      public boolean ellipsizingLastFullyVisibleLine() {
        return maxLines == Integer.MAX_VALUE;
      }

      @Override
      public void setLineSpacing(float add, float mult) {
        this.lineAdditionalVerticalPadding = add;
        this.lineSpacingMultiplier = mult;
        super.setLineSpacing(add, mult);
      }

      @Override
    public void setText(CharSequence text, BufferType type) {
          if (!programmaticChange && text instanceof Spanned) {
              fullText = (Spanned) text;
              isStale = true;
            }
        super.setText(text, type);
    }

      @Override
      protected void onSizeChanged(int w, int h, int oldw, int oldh) {
        super.onSizeChanged(w, h, oldw, oldh);
        if (ellipsizingLastFullyVisibleLine()) {
          isStale = true;
        }
      }

      public void setPadding(int left, int top, int right, int bottom) {
        super.setPadding(left, top, right, bottom);
        if (ellipsizingLastFullyVisibleLine()) {
          isStale = true;
        }
      }

      @Override
      protected void onDraw(Canvas canvas) {
        if (isStale) {
          resetText();
        }
        super.onDraw(canvas);
      }

      private void resetText() {
        Spanned workingText = fullText;
        boolean ellipsized = false;
        Layout layout = createWorkingLayout(workingText);
        int linesCount = getLinesCount();
        if (layout.getLineCount() > linesCount) {
          // We have more lines of text than we are allowed to display.
          workingText = (Spanned) fullText.subSequence(0, layout.getLineEnd(linesCount - 1));
          while (createWorkingLayout((Spanned) TextUtils.concat(workingText, ELLIPSIS)).getLineCount() > linesCount) {
            int lastSpace = workingText.toString().lastIndexOf(' ');
            if (lastSpace == -1) {
              break;
            }
            workingText = (Spanned) workingText.subSequence(0, lastSpace);
          }
          workingText = (Spanned) TextUtils.concat(workingText, ELLIPSIS);
          ellipsized = true;
        }
        if (!workingText.equals(getText())) {
          programmaticChange = true;
          try {
            setText(workingText);
          } finally {
            programmaticChange = false;
          }
        }
        isStale = false;
        if (ellipsized != isEllipsized) {
          isEllipsized = ellipsized;
          for (EllipsizeListener listener : ellipsizeListeners) {
            listener.ellipsizeStateChanged(ellipsized);
          }
        }
      }

      /**
       * Get how many lines of text we are allowed to display.
       */
      private int getLinesCount() {
        if (ellipsizingLastFullyVisibleLine()) {
          int fullyVisibleLinesCount = getFullyVisibleLinesCount();
          if (fullyVisibleLinesCount == -1) {
            return 1;
          } else {
            return fullyVisibleLinesCount;
          }
        } else {
          return maxLines;
        }
      }

      /**
       * Get how many lines of text we can display so their full height is visible.
       */
      private int getFullyVisibleLinesCount() {
        Layout layout = createWorkingLayout(new SpannedString(""));
        int height = getHeight() - getPaddingTop() - getPaddingBottom();
        int lineHeight = layout.getLineBottom(0);
        return height / lineHeight;
      }

      private Layout createWorkingLayout(Spanned workingText) {
        return new StaticLayout(workingText, getPaint(),
            getWidth() - getPaddingLeft() - getPaddingRight(),
            Alignment.ALIGN_NORMAL, lineSpacingMultiplier,
            lineAdditionalVerticalPadding, false /* includepad */);
      }

      @Override
      public void setEllipsize(TruncateAt where) {
        // Ellipsize settings are not respected
      }
}

回答by Igor SKRYL

To add ...in the end of the second line, saving 1 line if text is short:

要添加...到第二行的末尾，如果文本很短，则保存 1 行：

android:maxLines="2"
android:ellipsize="end"