抽奖转盘(二)属性动画的简单实现和自定义View实现

前言：

布局解决了，剩下的就是实现了，最简单也是最容易想到的就是RotateAnimation了，只需要在动画开始和动画结束的监听器中计算好时间，然后用总的旋转角度乘以时间百分比就行了。这里就不具体去实现了，感觉这个实现是真的没什么好说的。
这里要说的是属性动画实现这个效果，但是这里也有一个坑，那就是属性动画的结束操作，这个只能靠拦截器去实现了，如果对属性动画不太清楚的可以看看我写的这个 Android动画-Property Animation(一)

简单实现旋转和停止旋转

 private int getTarget() {
        Random random = new Random();
        int target = random.nextInt(6);
        return 60 * target;
    }

    public void start(View view) {
        objectAnimator = ObjectAnimator.ofFloat(pointer, "rotation", 0, getTarget() + 1800);
        objectAnimator.setDuration(3000);
        objectAnimator.setInterpolator(new LinearInterpolator());
        objectAnimator.setInterpolator(new Interpolator() {
            @Override
            public float getInterpolation(float input) {
                if (stop) {
                    if (!once) {
                        mInput = input;
                        once = true;
                    }
                    return mInput;
                }
                return input;
            }
        });
        pointer.setPivotX(pointer.getWidth() / 2);
        pointer.setPivotY(pointer.getHeight() * 4 / 5);
        objectAnimator.start();
        stop = false;
        once = false;
    }

    public void stop(View view) {
        stop = true;
    }

属性动画的基本使用这里就不介绍了，主要是对于拦截器的使用，为objectAnimator设置一个自定义的拦截器，重写getInterpolation(input)方法，定义once为赋值的标志，当停止的时候stop值为true，但是mInput被只能赋值一次，在stop中不断返回唯一的值。这样就造成一种停止属性动画的假象了。
getTarget()，每个扇形的中间必定是60的整数倍，很简单的逻辑。

属性动画的实现就到这里了，除了拦截器的使用，其实没什么好讲究的。
接下来就来说说Property Animation的局限性：
无法连续动画。拦截器的处理根本就没有真正的停止动画，所以如果再次点击开始，可能之前的动画仍在处理中，会造成各种各样的奇怪现象。
当然一般情况下，抽奖也只会有一次机会，但是偏偏想着怎么能把旋转连起来。这里使用了自定义View的一种方法。

自定义View实现

关于如何使用自定义View画出指针的位置在上一篇中已经讲过了，接下来我们来贴下主要的代码：

Circleview：

package com.example.administrator.cjhcircle;

import android.content.Context;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.graphics.Canvas;
import android.graphics.Color;
import android.graphics.Matrix;
import android.graphics.Paint;
import android.widget.ImageView;

public class Circleview extends ImageView implements Runnable {

    private Bitmap mHourBitmap;

    private boolean bInitComplete = false;
    private boolean stopRoter = true;
    float Angel = 0.0f;
    Matrix matx = new Matrix();
    float maxAngel = 0.0f;
    int screnWidth = 0;

    public Circleview(Context context,int width) {
        super(context);
        this.screnWidth = width;
        init();
        new Thread(this).start();
    }

    public void init() {

        mHourBitmap = BitmapFactory.decodeResource(getResources(),R.mipmap.share_lottery_pointer);
        bInitComplete = true;

    }

    public void setRotate_degree(float degree) {
        Angel = degree;
    }

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

        matx.reset();
        canvas.drawColor(Color.TRANSPARENT);

        if (!bInitComplete) {
            return;
        }
        Paint localPaint = new Paint();
        localPaint.setAntiAlias(true);
        localPaint.setFilterBitmap(true);

        matx.setTranslate(this.screnWidth/2-mHourBitmap.getWidth()/2, DensityUtil.dip2px(getContext(), 300)/2-mHourBitmap.getHeight()+DensityUtil.dip2px(getContext(), 20));

        matx.preRotate(Angel, mHourBitmap.getWidth() / 2,mHourBitmap.getHeight() * 4 / 5);

        canvas.drawBitmap(mHourBitmap, matx, localPaint);
    }

    public void run() {
        try {
            while (true) {
                if (!isStopRoter()) {
                    if(maxAngel!=0&&Angel>=maxAngel)
                    {
                        setStopRoter(true);
                        maxAngel = 0.0f;
                    }
                    else
                    {
                        if(maxAngel-Angel<360)
                            setRotate_degree(Angel+=10);
                        else
                            setRotate_degree(Angel+=15);
                        this.postInvalidate();
                        Thread.sleep(50);
                    }
                }
            }

        } catch (InterruptedException e) {

            e.printStackTrace();
        }

    }



    public void setStopPlace(int place){
        getRoterByPlace(place);
    }

    void getRoterByPlace(int place){
        float roter = getRoteCenter(place);
        float currentRoter = getCurrentRoter();

        float difRoter = currentRoter - roter;
        maxAngel = Angel + 360*2 + 360-difRoter;
    }


     float getRoteCenter(int place){
        float roter = 0.0f;
        switch (place) {
            case 1:
                roter = 0;
                break;
            case 2:
                roter = 60/2 + 30;
                break;
            case 3:
                roter = 60/2 + 90;
                break;
            case 4:
                roter = 60/2 + 150;
                break;
            case 5:
                roter = 60/2 + 210;
                break;
            case 6:
                roter = 60/2 + 270;
                break;
            default:
                break;
        }
        return roter;
     }


     float getCurrentRoter(){
         int current = (int) Angel/360;
            if(0==current)
                return Angel;
            float roter = Angel - 360*current;
            return roter;
    }

    public boolean isStopRoter() {
        return stopRoter;
    }

    public void setStopRoter(boolean stopRoter) {
        this.stopRoter = stopRoter;
    }
}

在使用的时候

Circleview claert = new Circleview(this,screnWidth);

 private void stop(Circleview claert, boolean stopRoter) {
        claert.setStopRoter(stopRoter);
    }

    private void start(int place, Circleview claert) {
        claert.setStopPlace(place);
        stop(claert, false);
    }

其中place其实就是你从服务器获取的结果，用来展示的，在Circleview 中定义每个奖品的位置以及角度

float getRoteCenter(int place){
        float roter = 0.0f;
        switch (place) {
            case 1:
                roter = 0;
                break;
            case 2:
                roter = 60/2 + 30;
                break;
            case 3:
                roter = 60/2 + 90;
                break;
            case 4:
                roter = 60/2 + 150;
                break;
            case 5:
                roter = 60/2 + 210;
                break;
            case 6:
                roter = 60/2 + 270;
                break;
            default:
                break;
        }
        return roter;
     }

在Circleview创建的时候，我就跑了一个子线程

public Circleview(Context context,int width) {
        super(context);
        this.screnWidth = width;
        init();
        new Thread(this).start();
    }

public void run() {
        try {
            while (true) {
                if (!isStopRoter()) {
                    if(maxAngel!=0&&Angel>=maxAngel)
                    {
                        setStopRoter(true);
                        maxAngel = 0.0f;
                    }
                    else
                    {
                        if(maxAngel-Angel<360)
                            setRotate_degree(Angel+=10);
                        else
                            setRotate_degree(Angel+=15);
                        this.postInvalidate();
                        Thread.sleep(50);
                    }
                }
            }

        } catch (InterruptedException e) {

            e.printStackTrace();
        }

    }

每隔50毫秒，我就去刷新view，如果处于转动的状态，也就是stopRoter为false时，说明在转动的状态，另外定义了两个变量Angel和maxAngel ，分别代表着当前转动的角度和最终的角度，每隔50毫秒就去改变Angel的值，当Angel >= maxAngel 时，就说明已经结束了，那么就停止。在转动时，还设置了最后一圈的慢速旋转。
好像就是这样了，也没有什么特别复杂的东西。