在XMLAndroid中使用自定义小部件/类

我在Chase的网站上找到了一个自定义的TextView类，但我无法让它正常工作。我到处找，显然我做错了什么

我想我基本上可以用

带有id参数等

但是。。。它不起作用了。我已经把他的密码贴在下面了。请，任何帮助将不胜感激，正确的答案将被标记为这样

又是唐克斯

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

/**
 * Text view that auto adjusts text size to fit within the view.
 * If the text size equals the minimum text size and still does not
 * fit, append with an ellipsis. 
 * 
 * @author Chase Colburn
 * @since Apr 4, 2011
 */
public class AutoResizeTextView extends TextView {

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

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

    // Off screen canvas for text size rendering
    private static final Canvas sTextResizeCanvas = new Canvas();

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

    // Default constructor override
    public AutoResizeTextView(Context context) {
        this(context, null);
    }

    // Default constructor when inflating from XML file
    public AutoResizeTextView(Context context, AttributeSet attrs) {
        this(context, attrs, 0);
    }

    // Default constructor override
    public AutoResizeTextView(Context context, AttributeSet attrs, int defStyle) {
        super(context, attrs, defStyle);
        mTextSize = getTextSize();
    }

    /**
     * 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() {
        super.setTextSize(TypedValue.COMPLEX_UNIT_PX, mTextSize);
        mMaxTextSize = mTextSize;
    }

    /**
     * Override drawing and resize text if necessary
     */
    @Override
    protected void onDraw(Canvas canvas) {
        if(mNeedsResize) {
            resizeText(getWidth(), getHeight());
        }
        super.onDraw(canvas);
    }

    /**
     * Resize the text size with default width and height
     */
    public void resizeText() {
        int heightLimit = getHeight() - getPaddingBottom() - getPaddingTop();
        int widthLimit = getWidth() - getPaddingLeft() - getPaddingRight();
        resizeText(widthLimit, heightLimit);
    }

    /**
     * Resize the text size with specified width and height
     * @param width
     * @param height
     */
    public void resizeText(int width, int height) {
        CharSequence text = getText();
        // 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) {
            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);
        }

        // 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
            StaticLayout layout = new StaticLayout(text, textPaint, width, Alignment.ALIGN_NORMAL, mSpacingMult, mSpacingAdd, false);
            layout.draw(sTextResizeCanvas);
            int lastLine = layout.getLineForVertical(height) - 1;
            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());   
            }
            setText(text.subSequence(0, end) + mEllipsis);

        }

        // Some devices try to auto adjust line spacing, so force default line spacing 
        // and invalidate the layout as a side effect
        textPaint.setTextSize(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) {
        // Update the text paint object
        paint.setTextSize(textSize);
        // Draw using a static layout
        StaticLayout layout = new StaticLayout(source, paint, width, Alignment.ALIGN_NORMAL, mSpacingMult, mSpacingAdd, false);
        layout.draw(sTextResizeCanvas);
        return layout.getHeight();
    }

}

导入android.content.Context；
导入android.graphics.Canvas；
导入android.text.Layout.Alignment；
导入android.text.StaticLayout；
导入android.text.TextPaint；
导入android.util.AttributeSet；
导入android.util.TypedValue；
导入android.widget.TextView；
/**
*自动调整文本大小以适应视图的文本视图。
*如果文本大小等于最小文本大小，但仍然不等于
*fit，用省略号追加。
* 
*@作者蔡斯·科尔伯恩
*@自2011年4月4日起
*/
公共类AutoResizeTextView扩展了TextView{
//此文本视图的最小文本大小
公共静态最终浮点最小值\文本\大小=20；
//调整大小通知的接口
公共接口OnTextResizeListener{
public void onTextResize（TextView TextView、float oldSize、float newSize）；
}
//用于文本大小渲染的屏幕外画布
私有静态最终画布sTextResizeCanvas=新画布（）；
//我们的椭圆弦
私有静态最终字符串mEllipsis=“…”；
//注册调整侦听器大小
私有OnTextResizeListener mTextResizeListener；
//文本和/或大小更改的标志，以强制调整大小
私有布尔值mNeedsResize=false；
//根据代码设置的文本大小。这是调整大小的起点
私有浮动mTextSize；
//起始文本大小的临时上限
私有浮点mMaxTextSize=0；
//文本大小的下限
私有浮点mMinTextSize=MIN\u TEXT\u SIZE；
//文本视图行距倍增器
私人浮动mSpacingMult=1.0f；
//文本视图附加行间距
私人浮动mSpacingAdd=0.0f；
//将省略号添加到以最小文本大小溢出的文本中
私有布尔mAddEllipsis=true；
//默认构造函数重写
公共AutoResizeTextView（上下文）{
这个（上下文，空）；
}
//从XML文件膨胀时的默认构造函数
公共AutoResizeTextView（上下文、属性集属性）{
这（上下文，属性，0）；
}
//默认构造函数重写
公共AutoResizeTextView（上下文上下文、属性集属性、int-defStyle）{
超级（上下文、属性、定义样式）；
mTextSize=getTextSize（）；
}
/**
*文本更改时，请将“强制调整大小”标志设置为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（）{
super.setTextSize（TypedValue.COMPLEX\u UNIT\u PX，mTextSize）；
mmaxtsize=mTextSize；
}
/**
*如有必要，替代图形并调整文本大小
*/
@凌驾
受保护的void onDraw（画布）{
如果（mNeedsResize）{
resizeText（getWidth（），getHeight（））；
}
super.onDraw（帆布）；
}
/**
*使用默认宽度和高度调整文本大小
*/