Android自定义守望先锋loading学习

学习自http://blog.csdn.net/chen_zhang_yu/article/details/53396801#效果

只是学习了这个loading的创意，具体制作没有学，因为他是用surface view做的，我不会

不过也从他这里学到了drawPath的技巧，这里总结下

moveTo只移动

lineTo画直线

cubicTo和quadTo画曲线

arcTo画弧线

我的实现效果（很烂，因为透明度不知道为啥没实现好，我也懒得去弄了，因为项目没这需求，纯属兴趣爱好）

我的控制显隐是采用Handler+Value动画实现的

我的代码写的很烂，而且有严重的内存泄漏，如果想用到项目里去，还是用上面链接里的东西吧

全部代码

 pojo

public class Hexagon {
    private int centerPointX;
    private int centerPointY;
    private float lenScale = 0;
    private int alpha = 0;
    private int len;//中心点到顶点距离

    private int offsetX;//点到边的距离

    private int[] vertexXArray = new int[6];
    private int[] vertexYArray = new int[6];

    public Hexagon(int centerPointX, int centerPointY, int len) {
        this.centerPointX = centerPointX;
        this.centerPointY = centerPointY;
        this.len = len;
        this.offsetX = (int) (len * 1.732 / 2);
        calculateVertex();
    }

    //最上方顺时针开始
    public void calculateVertex() {
        vertexXArray[0] = centerPointX;
        vertexXArray[1] = (int) (centerPointX + offsetX * lenScale);
        vertexXArray[2] = (int) (centerPointX + offsetX * lenScale);
        vertexXArray[3] = centerPointX;
        vertexXArray[4] = (int) (centerPointX - offsetX * lenScale);
        vertexXArray[5] = (int) (centerPointX - offsetX * lenScale);

        vertexYArray[0] = (int) (centerPointY + len * lenScale);
        vertexYArray[1] = (int) (centerPointY + len  * lenScale / 2);
        vertexYArray[2] = (int) (centerPointY - len  * lenScale / 2);
        vertexYArray[3] = (int) (centerPointY - len * lenScale);
        vertexYArray[4] = (int) (centerPointY - len  * lenScale / 2);
        vertexYArray[5] = (int) (centerPointY + len  * lenScale / 2);
    }

    private Path getPath() {
        Path path = new Path();
        for (int i = 0; i < 6; i ++) {
            if (i == 0) {
                path.moveTo(vertexXArray[i], vertexYArray[i]);
            } else {
                path.lineTo(vertexXArray[i], vertexYArray[i]);
                //我这里没有移到最初点，最后会自动闭合吗
            }
        }
        path.close();
        return path;
    }

    public void drawHexagon(Canvas canvas, Paint paint) {
        paint.setAlpha(alpha);
        canvas.drawPath(getPath(), paint);
    }

    public void setLenScale(float lenScale) {
        this.lenScale = lenScale;
    }

    public void setAlpha(int alpha) {
        this.alpha = alpha;
    }
}

view

//守望先锋loading
public class AssLoadingView extends View {

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

    private int viewCenterX;
    private int viewCenterY;
    private int hexLen = 50;
    private int hexPadding = 0;

    private Hexagon[] hexagons = new Hexagon[7];
    private Paint paint = new Paint();

    private int i = 0;
    private ValueAnimator valueAnimator1;
    private ValueAnimator valueAnimator2;

    @SuppressLint("HandlerLeak")
    private android.os.Handler handler = new android.os.Handler() {
        @Override
        public void handleMessage(Message msg) {
            if (i % 14 <= 6) {
                valueAnimator1.start();
            } else {
                valueAnimator2.start();
            }
            this.sendEmptyMessageDelayed(0, 150);
        }
    };

    private void init() {
        paint.setColor(Color.parseColor("#bec0c9"));

        viewCenterX = ScreenUtils.getScreenWidth(getContext()) / 2;
        viewCenterY = ScreenUtils.getScreenHeight(getContext()) / 2;

        int centerDistance = 2 * hexLen + hexPadding;
        int offsetX = centerDistance / 2;
        int offsetY = (int) (centerDistance * 1.732 / 2);
        hexagons[6] = new Hexagon(viewCenterX, viewCenterY, hexLen);
        int x = viewCenterX + offsetX;
        int y = viewCenterY + offsetY;
        hexagons[3] = new Hexagon(x, y, hexLen);
        x = viewCenterX + centerDistance;
        y = viewCenterY;
        hexagons[2] = new Hexagon(x, y, hexLen);
        x = viewCenterX + offsetX;
        y = viewCenterY - offsetY;
        hexagons[1] = new Hexagon(x, y, hexLen);
        x = viewCenterX - offsetX;
        y = viewCenterY - offsetY;
        hexagons[0] = new Hexagon(x, y, hexLen);
        x = viewCenterX - centerDistance;
        y = viewCenterY;
        hexagons[5] = new Hexagon(x, y, hexLen);
        x = viewCenterX - offsetX;
        y = viewCenterY + offsetY;
        hexagons[4] = new Hexagon(x, y, hexLen);

        valueAnimator1 = ValueAnimator.ofInt(0, 255);
        valueAnimator1.setDuration(120);
        valueAnimator1.addUpdateListener(new ValueAnimator.AnimatorUpdateListener() {
            @Override
            public void onAnimationUpdate(ValueAnimator animation) {
                int value = (int)animation.getAnimatedValue();
                hexagons[i % 7].setLenScale((float)value / 255);
                hexagons[i % 7].setAlpha(value);
                invalidate();
            }
        });
        valueAnimator1.addListener(new Animator.AnimatorListener() {
            @Override
            public void onAnimationStart(Animator animation) {

            }

            @Override
            public void onAnimationEnd(Animator animation) {
                i ++;
            }

            @Override
            public void onAnimationCancel(Animator animation) {

            }

            @Override
            public void onAnimationRepeat(Animator animation) {

            }
        });

        valueAnimator2 = ValueAnimator.ofInt(255, 0);
        valueAnimator2.setDuration(120);
        valueAnimator2.addUpdateListener(new ValueAnimator.AnimatorUpdateListener() {
            @Override
            public void onAnimationUpdate(ValueAnimator animation) {
                int value = (int)animation.getAnimatedValue();
                hexagons[i % 7].setLenScale((float)value / 255);
                hexagons[i % 7].setAlpha(value);
                invalidate();
            }
        });
        valueAnimator2.addListener(new Animator.AnimatorListener() {
            @Override
            public void onAnimationStart(Animator animation) {

            }

            @Override
            public void onAnimationEnd(Animator animation) {
                i ++;
            }

            @Override
            public void onAnimationCancel(Animator animation) {

            }

            @Override
            public void onAnimationRepeat(Animator animation) {

            }
        });


        handler.sendEmptyMessage(0);
    }

    @Override
    protected void onDraw(Canvas canvas) {
        super.onDraw(canvas);
        for (int i = 0; i < hexagons.length; i++) {
            hexagons[i].calculateVertex();
            hexagons[i].drawHexagon(canvas, paint);
        }
    }
}