自定义圆头柱状图

自己的项目碰到需要自定义圆头柱状图，记录下来

public abstract class BaseCoordinateView extends View {
    public static final String TAG = "MChartView";

    private RectF mRealRect0;
    private RectF mRealRect1;
    private RectF mRealRect2;

    private Paint mXAxisPaint;
    private Paint mYAxisPaint;

    private PointF mOriginPoint;

    private boolean mNeedXAxis = true, mNeedYAxis = true;

    public BaseCoordinateView(Context context, AttributeSet attrs) {
        super(context, attrs);

        init0(attrs);
    }

    public BaseCoordinateView(Context context) {
        super(context);

        init0(null);
    }

    private void init0(AttributeSet attrs) {
        float _1dp = ViewUtils.dp2px(getContext(), 1);

        float xStroke = _1dp * 1.0f;
        mXAxisPaint = new Paint(Paint.ANTI_ALIAS_FLAG);
        mXAxisPaint.setStrokeWidth(xStroke);
        mXAxisPaint.setColor(Color.parseColor("#9b9b9b"));
        mXAxisPaint.setStyle(Paint.Style.FILL);

        float yStroke = _1dp * 1.0f;
        mYAxisPaint = new Paint(Paint.ANTI_ALIAS_FLAG);
        mYAxisPaint.setStrokeWidth(yStroke);
        mYAxisPaint.setColor(Color.LTGRAY);
        mYAxisPaint.setStyle(Paint.Style.FILL);

        mOriginPoint = new PointF();
    }

    public void reDraw() {
        mRealRect0 = null;
        invalidate();
    }

    @Override
    protected void onDraw(Canvas canvas) {
        super.onDraw(canvas);

        if (getWidth() + getHeight() <= 0) return;

        if (mRealRect0 == null) {
            initRealRect();
        }

        if (mNeedXAxis) {
            drawXAxis(canvas);
        }

        if (mNeedYAxis) {
            drawYAxis(canvas);
        }

        mRealRect1.set(mRealRect0); // avoid alloc, different rectangle
        mRealRect2.set(mRealRect0);
        beforeDraw(canvas, mRealRect1);

        drawChart(canvas, mRealRect2);
    }

    private void initRealRect() {
        mRealRect0 = new RectF();
        mRealRect0.left = getPaddingLeft();
        mRealRect0.right = getWidth() - getPaddingRight();
        mRealRect0.top = getPaddingTop();
        mRealRect0.bottom = getHeight() - getPaddingBottom();

        narrowMainRect(mRealRect0);

        mOriginPoint.set(mRealRect0.left, mRealRect0.bottom);

        mRealRect1 = new RectF();
        mRealRect2 = new RectF();
    }

    protected void needXAxis(boolean isNeed) {
        mNeedXAxis = isNeed;
    }

    protected void needYAxis(boolean isNeed) {
        mNeedYAxis = isNeed;
    }

    /**
     * Before the content draws, after draw axis.
     *
     * @param c
     * @param realRect
     */
    protected void beforeDraw(Canvas c, RectF realRect) {
    }

    protected abstract void drawChart(Canvas c, RectF realRect);

    protected void narrowMainRect(RectF rectF) {
        int padding = ViewUtils.dp2px(getContext(), 5);
        ViewUtils.narrowRectF(rectF, padding);
    }

    public Paint getXAxisPaint() {
        return mXAxisPaint;
    }

    public Paint getYAxisPaint() {
        return mYAxisPaint;
    }

    private void drawXAxis(Canvas c) {
        // move down to draw x axis
        float offset = getXAxisOffset();
        c.drawLine(mOriginPoint.x, mOriginPoint.y + offset, mRealRect0.right, mOriginPoint.y + offset, mXAxisPaint);
    }

    protected float getXAxisOffset() {
        return mXAxisPaint.getStrokeWidth() / 2;
    }

    private void drawYAxis(Canvas c) {
        // move left to draw y axis
        float offset = getYAxisOffset();
        c.drawLine(mOriginPoint.x - offset, mOriginPoint.y, mOriginPoint.x - offset, mRealRect0.top, mYAxisPaint);
    }

    protected float getYAxisOffset() {
        return mYAxisPaint.getStrokeWidth() / 2;
    }
}

public abstract class AbsPartsChartView extends BaseCoordinateView {
    /**
     * exactly same as list.size
     * initialized in #setDatas()
     */
    protected int COUNT = -1;
    protected float MAX = 100;

    private float mPaddingLeft = 0.0f, mPaddingRight = 0.0f;

    private List<Item> mItemList;
    private List<PointF> mPointList;

    private boolean mPointInited = false; //

    protected int mNormalColor = 0xFFf1e9e9, mHighLightColor = 0xFFffc107;

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

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

    /**
     * draw the paddings of item INSIDE the coordinate
     *
     * @param l left
     * @param t top
     * @param r right
     * @param b bottom
     */
    public void setInnerPadding(float l, float t, float r, float b) {
        mPaddingLeft = l;
        mPaddingRight = r;
    }

    public void setColors(int normal, int highLight) {
        mNormalColor = normal;
        mHighLightColor = highLight;
    }

    @Override
    protected void drawChart(Canvas c, RectF realRect) {
        if (!mPointInited) {
            makePoints(realRect);
        }

        for (int i = 0; i < COUNT; i++) {
            PointF p = mPointList.get(i);
            Item item = mItemList.get(i);

            drawItem(c, item, p, realRect);
        }
    }

    private void makePoints(RectF rect) {
        float width = rect.right - rect.left - mPaddingLeft - mPaddingRight;
        float height = rect.bottom - rect.top;

        float partWidth = width / (COUNT - 1);
        float startX = rect.left + mPaddingLeft;
        float startY = rect.bottom;// should bottom rect.top -> rect.bottom
        for (int i = 0; i < COUNT; i++) {
            Item item = mItemList.get(i);
            float progress = item.progress;

            float x = startX + i * partWidth;
            float y;
            if(progress > 0){
                y = startY - progress / MAX * height;
                if(y < 0){
                    y = rect.top;
                }
            }else {
                y = -1;
            }

            PointF p = mPointList.get(i);
            p.set(x, y);
        }

        mPointInited = true;
    }

    protected abstract int drawItem(Canvas c, Item item, PointF itemPoint, RectF realRect);

    public void setDatas(List<Item> list) {
        setDatas(list, true);
    }

    public void setDatas(List<Item> list, boolean needInvalidate) {
        mItemList = list;

        COUNT = mItemList.size();
        mPointList = new ArrayList<PointF>(COUNT);
        for (int i = 0; i < COUNT; i++) {
            PointF p = new PointF();
            mPointList.add(p);
        }

        mPointInited = false;

        if (needInvalidate) {
            invalidate();
        }
    }

    public void setMax(float max) {
        MAX = max;
    }

    public class Item {
        public float progress;
        public boolean highLight = false;
    }
}

public class HistogramChartView extends AbsPartsChartView {
    private float mRectWidth;
    private Paint mRectPaint;

    private Paint mPointPaint;

    public HistogramChartView(Context context) {
        super(context);

        init();
    }

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

    protected void init() {
        mPointPaint = new Paint(Paint.ANTI_ALIAS_FLAG);
        mPointPaint.setStyle(Paint.Style.FILL);
        mPointPaint.setStrokeWidth(5);
        mPointPaint.setColor(Color.RED);

        mRectWidth = ViewUtils.dp2px(getContext(), 10);

        mRectPaint = new Paint(Paint.ANTI_ALIAS_FLAG);
        mRectPaint.setStyle(Paint.Style.FILL);
        mRectPaint.setColor(mNormalColor);
    }

    @Override
    protected int drawItem(Canvas c, Item item, PointF itemPoint, RectF realRect) {
        if (itemPoint.y > 0) {
            mRectPaint.setColor(item.highLight ? mHighLightColor : mNormalColor);
            RectF rect = makeHistogramRect(itemPoint, realRect.bottom, mRectWidth);
//            c.drawRect(rect, mRectPaint);

            // TODO: 2016/7/1 17:04modify ---
            RoundRectShape rr = new RoundRectShape(new float[]{8, 8, 8, 8, 0, 0, 0, 0}, null, null);
            ShapeDrawable shapeDrawable = new ShapeDrawable(rr);
            shapeDrawable.getPaint().setColor(mRectPaint.getColor());
            Rect r = new Rect();
            rect.round(r);
            shapeDrawable.setBounds(r);
            shapeDrawable.draw(c);
            //---
        }

        return 0;
    }

    private RectF makeHistogramRect(PointF p, float bottom, float width) {
        RectF rect = new RectF();
        rect.left = p.x - width / 2;
        rect.right = p.x + width / 2;
        rect.top = p.y;
        rect.bottom = bottom;
        return rect;
    }