android实现折线图和柱状图

package com.vanke.easysale.widget.chart;

import android.content.Context;
import android.content.res.TypedArray;
import android.graphics.Canvas;
import android.graphics.Color;
import android.graphics.Paint;
import android.graphics.Rect;
import android.graphics.RectF;
import android.graphics.Typeface;
import android.support.annotation.Nullable;
import android.support.v4.content.ContextCompat;
import android.util.AttributeSet;
import android.util.TypedValue;
import android.view.MotionEvent;
import android.view.View;

import com.vanke.IntegratedPlatform.manager.R;
import com.vanke.easysale.util.DensityUtil;
import com.vanke.easysale.util.TimeUtils;

import java.util.ArrayList;

/**
 * Created by rantao on 2017/8/23.
 * 折线图+柱状图
 */

public class LineBarChartView extends View {

    private int width; // 控件总宽

    private int height; // 控件总高

    private int barWidth; // 柱状图宽度

    private Paint paint; // 画笔

    private String[] xTitles = new String[]{}; // x轴数据

    private int[] yDatasForBar = new int[]{}; // 柱状图数据源

    private int[] xDatasForBar = new int[]{}; // 折线图数据源

    private int TEXTSIZE = 30;

    private int textSize = 20;

    private int bottomForChart; // 图表底部坐标

    private int maxValue = 0; // 最大值

    private int minValue = Integer.MAX_VALUE; // 最小值

    private int yTextHeight; // x轴文字高度

    private int yMinDefaultDistance = DensityUtil.dip2px(getContext(), getResources().getDimension(R.dimen.dimen_10dp)); // y轴最小值默认高度

    private ArrayList<LinePoint> linePoints = new ArrayList<>(); // 柱子集合

    private OnBarItemClickListener onBarItemClickListener; // 点击监听

    private int defaultHighLightPosition = Integer.MAX_VALUE; // 选中高亮的索引下标

    private int timeType = 1; // 时间维度类型(1:本年;2:今日;3:本周;4:本月;5:本季)

    private boolean isAllZero = false; // 是否全部数据都为0

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

    public LineBarChartView(Context context, @Nullable AttributeSet attrs) {
        super(context, attrs);
        init(context, attrs);
    }

    public void setxTitles(String[] xTitles) {
        this.xTitles = xTitles;
    }

    public void setTimeType(int timeType) {
        this.timeType = timeType;
        initHighLightAccordingToTimeType();
        invalidate();
    }

    public void setAllZero(boolean allZero) {
        isAllZero = allZero;
        invalidate();
    }

    public void setOnBarItemClickListener(OnBarItemClickListener onBarItemClickListener) {
        this.onBarItemClickListener = onBarItemClickListener;
    }

    public void setyDatasForBar(int[] yDatasForBar) {
        this.yDatasForBar = yDatasForBar;
    }

    public void setxDatasForBar(int[] xDatasForBar) {
        this.xDatasForBar = xDatasForBar;
    }

    public int getBarWidth() {
        return barWidth;
    }

    @Override
    protected void onSizeChanged(int w, int h, int oldw, int oldh) {
        super.onSizeChanged(w, h, oldw, oldh);
        updateDimensions(w, h);
    }

    /**
     * 根据时间维度初始化高亮位置
     */

    private void initHighLightAccordingToTimeType() {
        switch (timeType) {
            case 1: // 今日
                defaultHighLightPosition = TimeUtils.getCurrentHour() - 1;
                break;
            case 2: // 本周
                defaultHighLightPosition = TimeUtils.getCurrentWeekDay() - 1;
                break;
            case 3: // 本月
                defaultHighLightPosition = TimeUtils.getCurrentDay() - 1;
                break;
            case 4: // 本季
                defaultHighLightPosition = TimeUtils.getCurrentSeason() - 1;
                break;
            case 5: // 本年
                defaultHighLightPosition = TimeUtils.getCurrentMonth() - 1;
                break;
        }
    }

    @Override
    protected void onDraw(Canvas canvas) {
        super.onDraw(canvas);
        barWidth = width / xTitles.length;
        bottomForChart = height - DensityUtil.dip2px(getContext(), getResources().getDimension(R.dimen.dimen_7dp));
        floatX = barWidth * defaultHighLightPosition;
        floatY = height / 2;
        drawXAsix(canvas);
        drawBar(canvas);
        drawLine(canvas);
        drawFloat(canvas);
    }

    private boolean hasData(int[] datas) {
        boolean hasData = false;
        for (int i = 0; i < datas.length; i++) {
            if (datas[i] != 0) {
                hasData = true;
            }
        }
        return hasData;
    }

    @Override
    protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
        super.onMeasure(widthMeasureSpec, heightMeasureSpec);
        int width = measure(widthMeasureSpec);
        int height = measure(heightMeasureSpec);
        setMeasuredDimension(width, height);
        updateDimensions(width, height);
    }

    private void init(Context context, AttributeSet attrs) {
        setLayerType(LAYER_TYPE_SOFTWARE, paint);// 屏蔽掉，阴影不显示，不屏蔽，ondraw方法执行无数次
        paint = new Paint();
        paint.setAntiAlias(true);
        TypedArray a = context.obtainStyledAttributes(attrs, R.styleable.LineBarChartView);
        for (int i = 0; i < a.length(); i++) {
            int attr = a.getIndex(i);
            switch (attr) {
                case R.styleable.LineBarChartView_xAsix_textSize:
                    textSize = (int) a.getDimension(attr, TypedValue.applyDimension(
                            TypedValue.COMPLEX_UNIT_SP, TEXTSIZE,
                            getResources().getDisplayMetrics()));
                    break;
                default:
                    break;
            }
        }
        a.recycle();
    }

    /**
     * 绘制文本
     *
     * @param canvas 画布
     * @param text   文本
     * @param left   坐标
     * @param top
     * @param right
     * @param bottom
     * @param color  文字颜色
     */

    private void drawText(Canvas canvas, String text, int left, int top, int right, int bottom, int color) {
        Rect rect = new Rect(left, top, right, bottom);
        Paint.FontMetricsInt fontMetrics = paint.getFontMetricsInt();
        int baseline = (rect.bottom + rect.top - fontMetrics.bottom - fontMetrics.top) / 2;
        paint.setTextAlign(Paint.Align.CENTER);
        paint.setTextSize(textSize);
        paint.setColor(color);
        paint.setShadowLayer(0, 0, 0, ContextCompat.getColor(getContext(), R.color.color_333333));
        canvas.drawText(text, rect.centerX(), baseline, paint);
    }

    /**
     * 绘制x轴
     *
     * @param canvas
     */

    private void drawXAsix(Canvas canvas) {
        paint.setStyle(Paint.Style.FILL);
        paint.setFakeBoldText(false);
        paint.setAntiAlias(true);
        // 绘制X轴数据
        for (int i = 0; i < xTitles.length; i++) {
            int left = (i) * barWidth;
            int right = (i + 1) * (barWidth);
            int top = height - DensityUtil.dip2px(getContext(), getResources().getDimension(R.dimen.dimen_5dp));
            int bottom = height;
            Rect rect = new Rect(left, top, right, bottom);
            Paint.FontMetricsInt fontMetrics = paint.getFontMetricsInt();
            int baseline = (rect.bottom + rect.top - fontMetrics.bottom - fontMetrics.top) / 2;
            paint.setTextAlign(Paint.Align.CENTER);
            paint.setTextSize(textSize);
            paint.setColor(ContextCompat.getColor(getContext(), R.color.color_999999));
            if (timeType == 1 || timeType == 3) { // 时间维度是今日或者是本月,当x轴数据大于10时，需要间隔一个绘制X轴刻度数据
                if (i > 9) {
                    if (i % 2 == 1) {
                        drawText(canvas, xTitles[i], left, top, right, bottom, ContextCompat.getColor(getContext(), R.color.color_666666));
                    }
                } else {
//                        canvas.drawText(xTitles[i], rect.centerX(), baseline, paint);
                    drawText(canvas, xTitles[i], left, top, right, bottom, ContextCompat.getColor(getContext(), R.color.color_666666));
                }
            } else {
//                    canvas.drawText(xTitles[i], rect.centerX(), baseline, paint);
                drawText(canvas, xTitles[i], left, top, right, bottom, ContextCompat.getColor(getContext(), R.color.color_666666));
            }
            Paint.FontMetrics fr = paint.getFontMetrics();
            //ceil() 函数向上舍入为最接近的整数
            yTextHeight = (int) Math.ceil(fr.descent - fr.ascent);
            bottomForChart = height - yTextHeight - DensityUtil.dip2px(getContext(), getResources().getDimension(R.dimen.dimen_2dp));
        }
        // 绘制X轴刻度线
        for (int i = 0; i <= xTitles.length; i++) {
            int startX = i * barWidth;
            int endX = startX;
            int startY = height - yTextHeight - DensityUtil.dip2px(getContext(), getResources().getDimension(R.dimen.dimen_2dp));
            int endY = height - yTextHeight;
            paint.setColor(ContextCompat.getColor(getContext(), R.color.color_999999));
            paint.setStrokeWidth(1f);
            canvas.drawLine(startX, startY, endX, endY, paint);
        }
//        绘制X轴
        int startX = 0;
        int endX = width;
        int startY = bottomForChart;
        int endY = startY;
        paint.setStrokeWidth(1f);
        paint.setColor(ContextCompat.getColor(getContext(), R.color.color_999999));
        canvas.drawLine(startX, startY, endX, endY, paint);
    }

    /**
     * 绘制柱状图
     *
     * @param canvas
     */

    private void drawBar(Canvas canvas) {
        paint.setStyle(Paint.Style.FILL);
        if (null != linePoints && linePoints.size() > 0) {
            linePoints.clear();
        }
        for (int i = 0; i < yDatasForBar.length; i++) {
            if (yDatasForBar[i] > maxValue) {
                maxValue = yDatasForBar[i];
            }
            if (yDatasForBar[i] < minValue) {
                minValue = yDatasForBar[i];
            }
        }
        for (int i = 0; i < xDatasForBar.length; i++) {
            if (xDatasForBar[i] > maxValue) {
                maxValue = xDatasForBar[i];
            }
            if (xDatasForBar[i] < minValue) {
                minValue = xDatasForBar[i];
            }
        }
        paint.setAlpha(230);
        for (int i = 0; i < yDatasForBar.length; i++) {
            // 记录所有柱状图位置
            LinePoint point = new LinePoint();
            float ratio = (float) (yDatasForBar[i] - minValue) / (float) (maxValue - minValue);
            int left = i * barWidth + DensityUtil.dip2px(getContext(), 1.5f);
            int right = (i + 1) * barWidth - DensityUtil.dip2px(getContext(), 1.5f);
            int bottom = bottomForChart;
            int top = (int) (bottomForChart * (1 - ratio));
            if (!isAllZero) {
                if (ratio == 0) {
                    if (yDatasForBar[i] > 0) { // 最小值不为0
                        top = bottomForChart - yMinDefaultDistance;
                    } else {
                        point.zero = true;
                    }
                } else if (ratio == 1) {
                    top = top - yMinDefaultDistance;
                }
            } else {
                top = bottomForChart;
            }
            paint.setColor(ContextCompat.getColor(getContext(), R.color.color_red));
            Rect rect = new Rect(left, top, right, bottom);
            if (defaultHighLightPosition == i) {
                paint.setColor(ContextCompat.getColor(getContext(), R.color.color_ffd633));
            }
            // 只绘制非0部分
//            if (yDatasForBar[i] != 0) {
            paint.setShadowLayer(0, 0, 0, ContextCompat.getColor(getContext(), R.color.color_333333));
            canvas.drawRect(rect, paint);
//            }

            point.minX = left;
            point.maxX = right;
            point.minY = top;
            point.maxY = bottom;
            linePoints.add(point);
        }
        paint.setAlpha(255);
    }

    /**
     * 绘制折线图
     *
     * @param canvas
     */

    private void drawLine(Canvas canvas) {
        paint.setStyle(Paint.Style.FILL);
        for (int i = 0; i < yDatasForBar.length; i++) {
            if (yDatasForBar[i] > maxValue) {
                maxValue = yDatasForBar[i];
            }
            if (yDatasForBar[i] < minValue) {
                minValue = yDatasForBar[i];
            }
        }
        for (int i = 0; i < xDatasForBar.length; i++) {
            if (xDatasForBar[i] > maxValue) {
                maxValue = xDatasForBar[i];
            }
            if (xDatasForBar[i] < minValue) {
                minValue = xDatasForBar[i];
            }
        }
        for (int i = 0; i < xDatasForBar.length; i++) {
            if (i != xDatasForBar.length - 1) {
                paint.setColor(getResources().getColor(R.color.color_ffd633));
                paint.setStrokeWidth(4);
                int startX = (2 * (i + 1) - 1) * barWidth / 2;
                float ratio = (float) (xDatasForBar[i] - minValue) / (float) (maxValue - minValue);
                int startY = (int) (bottomForChart * (1 - ratio));
                if (!isAllZero) {
                    if (ratio == 0) {
                        if (xDatasForBar[i] > 0) {
                            startY = bottomForChart - yMinDefaultDistance;
                        }
                    } else if (ratio == 1) {
                        startY = startY + DensityUtil.dip2px(getContext(), 20);
                    }
                } else {
                    startY = bottomForChart;
                }
                ratio = (float) (xDatasForBar[i + 1] - minValue) / (float) (maxValue - minValue);
                int endX = (2 * (i + 2) - 1) * barWidth / 2;
                int endY = (int) (bottomForChart * (1 - ratio));
                if (!isAllZero) {
                    if (ratio == 0) {
                        if (xDatasForBar[i + 1] > 0) {
                            endY = bottomForChart - yMinDefaultDistance;
                        }
                    } else if (ratio == 1) {
                        endY = endY + DensityUtil.dip2px(getContext(), 20);
                    }
                } else {
                    endY = bottomForChart;
                }

                paint.setShadowLayer(getResources().getDimensionPixelOffset(R.dimen.dimen_1dp),
                        getResources().getDimensionPixelOffset(R.dimen.dimen_1dp),
                        getResources().getDimensionPixelOffset(R.dimen.dimen_2dp),
                        ContextCompat.getColor(getContext(), R.color.color_999999)); // 绘制阴影代码
                paint.setStrokeWidth(getResources().getDimension(R.dimen.dimen_2dp));
                canvas.drawLine(startX, startY, endX, endY, paint);

                if (defaultHighLightPosition != i) {
                    paint.setColor(getResources().getColor(R.color.color_ffd633));
                    canvas.drawCircle(startX, startY, getResources().getDimension(R.dimen.dimen_4dp), paint);
                    paint.setShadowLayer(0, 0, 0, ContextCompat.getColor(getContext(), R.color.color_333333));
                    paint.setColor(getResources().getColor(R.color.white));
                    canvas.drawCircle(startX, startY, getResources().getDimension(R.dimen.dimen_2dp), paint);
                } else {
                    paint.setColor(getResources().getColor(R.color.color_ffd633));
                    canvas.drawCircle(startX, startY, getResources().getDimension(R.dimen.dimen_8dp), paint);
                    paint.setShadowLayer(0, 0, 0, ContextCompat.getColor(getContext(), R.color.color_333333));
                    paint.setColor(getResources().getColor(R.color.white));
                    canvas.drawCircle(startX, startY, getResources().getDimension(R.dimen.dimen_4dp), paint);
                }
            } else {
                int bottom = bottomForChart;
                int startX = (2 * (i + 1) - 1) * barWidth / 2;
                float ratio = (float) (xDatasForBar[i] - minValue) / (float) (maxValue - minValue);
                int startY = (int) (bottom * (1 - ratio));
                if (!isAllZero) {
                    if (ratio == 0) {
                        if (xDatasForBar[i] > 0) {
                            startY = bottomForChart - yMinDefaultDistance;
                        }
                    } else if (ratio == 1) {
                        startY = startY - DensityUtil.dip2px(getContext(), getResources().getDimension(R.dimen.dimen_10dp));
                    }
                } else {
                    startY = bottomForChart;
                }
                if (defaultHighLightPosition != i) {
                    paint.setColor(getResources().getColor(R.color.color_ffd633));
                    paint.setShadowLayer(getResources().getDimension(R.dimen.dimen_3dp),
                            getResources().getDimension(R.dimen.dimen_1dp),
                            getResources().getDimension(R.dimen.dimen_1dp),
                            ContextCompat.getColor(getContext(), R.color.color_333333));
                    canvas.drawCircle(startX, startY, getResources().getDimension(R.dimen.dimen_5dp), paint);
                    paint.setColor(getResources().getColor(R.color.white));
                    paint.setShadowLayer(0, 0, 0, ContextCompat.getColor(getContext(), R.color.color_333333));
                    canvas.drawCircle(startX, startY, getResources().getDimension(R.dimen.dimen_3dp), paint);
                } else {
                    paint.setColor(getResources().getColor(R.color.color_ffd633));
                    paint.setShadowLayer(getResources().getDimension(R.dimen.dimen_3dp),
                            getResources().getDimension(R.dimen.dimen_1dp),
                            getResources().getDimension(R.dimen.dimen_1dp),
                            ContextCompat.getColor(getContext(), R.color.color_333333));
                    canvas.drawCircle(startX, startY, getResources().getDimension(R.dimen.dimen_8dp), paint);
                    paint.setColor(getResources().getColor(R.color.white));
                    paint.setShadowLayer(0, 0, 0, R.color.color_333333);
                    canvas.drawCircle(startX, startY, getResources().getDimension(R.dimen.dimen_5dp), paint);
                }
            }
        }
    }

    int floatX;
    int floatY;

    /**
     * 绘制浮层
     *
     * @param canvas 画布
     */

    private void drawFloat(Canvas canvas) {
        String currentMonth = "";
        String lastTip = "";
        String currentTip = "";
        switch (timeType) {
            case 1:
                lastTip = "今日";
                currentTip = "昨日";
                currentMonth = (defaultHighLightPosition  + 1)+ "时";
                break;
            case 2:
                lastTip = "本周";
                currentTip = "上周";
                currentMonth = "周" + (defaultHighLightPosition + 1);
                break;
            case 3:
                lastTip = "本月";
                currentTip = "上月";
                currentMonth = (defaultHighLightPosition +1) + "号";
                break;
            case 4:
                lastTip = "本季";
                currentTip = "上季";
                currentMonth = (defaultHighLightPosition + 1) + "月";
                break;
            case 5:
                lastTip = "今年";
                currentTip = "去年";
                currentMonth = (defaultHighLightPosition + 1) + "月";
                break;
            default:
                break;
        }

//        paint.setAlpha(10);
//        paint.setShadowLayer(getResources().getDimension(R.dimen.dimen_3dp),
//                getResources().getDimension(R.dimen.dimen_2dp), getResources().getDimension(R.dimen.dimen_2dp), ContextCompat.getColor(getContext(), R.color.color_333333));
        // 绘制圆角矩形
        int rectLeft = floatX - getResources().getDimensionPixelOffset(R.dimen.dimen_45dp);
        int rectTop = floatY - getResources().getDimensionPixelOffset(R.dimen.dimen_25dp);
        int rectRight = floatX + getResources().getDimensionPixelOffset(R.dimen.dimen_45dp);
        int rectBottom = floatY + getResources().getDimensionPixelOffset(R.dimen.dimen_25dp);
        if (rectLeft <= 0) {
            rectLeft = 0;
            rectRight = 2 * getResources().getDimensionPixelOffset(R.dimen.dimen_50dp);
        }
        if (rectRight >= width) {
            rectRight = width;
            rectLeft = width - 2 * getResources().getDimensionPixelOffset(R.dimen.dimen_50dp);
        }

        RectF rectF = new RectF(rectLeft, rectTop, rectRight, rectBottom);
        canvas.saveLayerAlpha(rectF, 204, Canvas.CLIP_TO_LAYER_SAVE_FLAG);
        paint.setColor(Color.WHITE);
        canvas.drawRect(rectF, paint);
        canvas.restore();
        paint.setStrokeWidth(getResources().getDimension(R.dimen.dimen_05dp));

        paint.setColor(ContextCompat.getColor(getContext(), R.color.color_999999));
        canvas.drawLine(rectLeft, rectTop, rectRight, rectTop, paint);
        canvas.drawLine(rectRight, rectTop, rectRight, rectBottom, paint);
        canvas.drawLine(rectRight, rectBottom, rectLeft, rectBottom, paint);
        canvas.drawLine(rectLeft, rectBottom, rectLeft, rectTop, paint);

//        Path path = new Path();
//        path.moveTo(rectLeft, rectTop);
//        path.lineTo(rectRight, rectTop);
//        path.lineTo(rectRight, rectBottom);
//        path.lineTo(rectLeft, rectBottom);
//        path.lineTo(rectLeft, rectTop - 5f);
//        CornerPathEffect pathEffect = new CornerPathEffect(10f);
//        paint.setPathEffect(pathEffect);
//        paint.setStyle(Paint.Style.STROKE);
//        canvas.drawPath(path, paint);

        paint.setStyle(Paint.Style.FILL);
        // 绘制月份文本
        int monthCenter = (rectLeft + rectRight) / 2;
        int monthLeft = monthCenter - getResources().getDimensionPixelOffset(R.dimen.dimen_5dp);
        int monthRight = monthCenter + getResources().getDimensionPixelOffset(R.dimen.dimen_5dp);
        int monthTop = rectTop + getResources().getDimensionPixelOffset(R.dimen.dimen_10dp);
        int monthBottom = monthTop + getResources().getDimensionPixelOffset(R.dimen.dimen_5dp);
        paint.setTextSize(getResources().getDimensionPixelSize(R.dimen.textsize_10sp));
        drawText(canvas, currentMonth, monthLeft, monthTop, monthRight, monthBottom, ContextCompat.getColor(getContext(), R.color.color_666666));

        int roundRadius = getResources().getDimensionPixelOffset(R.dimen.dimen_3dp);

        // 绘制上期数据圆点
        int lastRoundCenterX = rectLeft + getResources().getDimensionPixelOffset(R.dimen.dimen_10dp);
        int lastRoundCenterY = monthBottom + getResources().getDimensionPixelOffset(R.dimen.dimen_10dp);
        paint.setColor(ContextCompat.getColor(getContext(), R.color.color_ffd633));
        canvas.drawCircle(lastRoundCenterX, lastRoundCenterY, roundRadius, paint);

        // 绘制上期数据提示文本
        int lastTipLeft = lastRoundCenterX + roundRadius + getResources().getDimensionPixelOffset(R.dimen.dimen_20dp);
        int lastTipRight = lastTipLeft + getResources().getDimensionPixelOffset(R.dimen.dimen_10dp);
        int lastTipTop = lastRoundCenterY - getResources().getDimensionPixelOffset(R.dimen.dimen_8dp);
        int lastTipBottom = lastRoundCenterY + getResources().getDimensionPixelOffset(R.dimen.dimen_8dp);
        drawText(canvas, lastTip, lastTipLeft, lastTipTop, lastTipRight, lastTipBottom, ContextCompat.getColor(getContext(), R.color.color_666666));

        // 绘制本期数据圆点
        int currentRoundCenterX = rectLeft + getResources().getDimensionPixelOffset(R.dimen.dimen_10dp);
        int currentRoundCenterY = lastRoundCenterY + getResources().getDimensionPixelOffset(R.dimen.dimen_15dp);
        paint.setColor(ContextCompat.getColor(getContext(), R.color.color_red));
        canvas.drawCircle(currentRoundCenterX, currentRoundCenterY, roundRadius, paint);

        // 绘制本期提示数据
        int currentTipLeft = currentRoundCenterX + roundRadius + getResources().getDimensionPixelOffset(R.dimen.dimen_20dp);
        int currentTipRight = currentTipLeft + getResources().getDimensionPixelOffset(R.dimen.dimen_10dp);
        int currentTipTop = currentRoundCenterY - getResources().getDimensionPixelOffset(R.dimen.dimen_8dp);
        int currentTipBottom = currentRoundCenterY + getResources().getDimensionPixelOffset(R.dimen.dimen_8dp);
        drawText(canvas, currentTip, currentTipLeft, currentTipTop, currentTipRight, currentTipBottom, ContextCompat.getColor(getContext(), R.color.color_666666));

        // 绘制上期数据
        int lastLineLeft = lastTipRight + getResources().getDimensionPixelOffset(R.dimen.dimen_10dp);
        int lastLineRight = lastLineLeft + getResources().getDimensionPixelOffset(R.dimen.dimen_20dp);
        int lastLineTop = lastTipTop;
        int lastLineBottom = lastTipBottom;
        paint.setTypeface(Typeface.DEFAULT_BOLD);
        try {
            drawText(canvas, yDatasForBar[defaultHighLightPosition] + "",
                    lastLineLeft, lastLineTop, lastLineRight, lastLineBottom, ContextCompat.getColor(getContext(), R.color.color_666666));
        } catch (Exception e) {
            e.printStackTrace();
        }

        // 绘制本期数据
        int currentLineLeft = currentTipRight + getResources().getDimensionPixelOffset(R.dimen.dimen_10dp);
        int currentLineRight = currentLineLeft + getResources().getDimensionPixelOffset(R.dimen.dimen_20dp);
        int currentLineTop = currentTipTop;
        int currentLineBottom = currentTipBottom;
        try {
            drawText(canvas, xDatasForBar[defaultHighLightPosition] + "",
                    currentLineLeft, currentLineTop, currentLineRight, currentLineBottom, ContextCompat.getColor(getContext(), R.color.color_666666));
        } catch (Exception e) {
            e.printStackTrace();
        }
        paint.setTypeface(Typeface.DEFAULT);
    }

    int downX = 0; // 按下时X坐标
    int downY = 0; // 按下时Y坐标

    @Override
    public boolean onTouchEvent(MotionEvent event) {
        switch (event.getAction()) {
            case MotionEvent.ACTION_DOWN:
                downX = (int) event.getX();
                downY = (int) event.getY();
                break;
            case MotionEvent.ACTION_UP:
                int upX = (int) event.getX();
                int upY = (int) event.getY();
                if (Math.abs(downX - upX) < 10 && Math.abs(downY - upY) < 10) {
                    for (int i = 0; i < linePoints.size(); i++) {
                        LinePoint point = linePoints.get(i);
                        if (upX > point.minX && upX < point.maxX && upY > 0 && upY < height) {
                            if (null != onBarItemClickListener) {
                                onBarItemClickListener.onBarItemClick(i, upX - DensityUtil.dip2px(getContext(), 30), upY);
                                defaultHighLightPosition = i;
                                floatX = upX;
                                floatY = upY;
                                invalidate();
                            }
                        }
                    }
                }
                break;
        }
        return true;
    }

    private int measure(int measureSpec) {
        int result = 0;
        int mode = MeasureSpec.getMode(measureSpec);
        int size = MeasureSpec.getSize(measureSpec);
        switch (mode) {
            case MeasureSpec.EXACTLY:
                result = size;
                break;
            case MeasureSpec.AT_MOST:
                result = size;
                break;
            case MeasureSpec.UNSPECIFIED:
                break;
            default:
                break;
        }
        return result;
    }

    private void updateDimensions(int width, int height) {
        this.width = width;
        this.height = height;
    }

    private class LinePoint {
        int minX;
        int maxX;
        int minY;
        int maxY;
        boolean zero = false; // 数据是否为0
    }

    public interface OnBarItemClickListener {
        void onBarItemClick(int index, int x, int y);
    }
}