图片绕固定点旋转

package com.freeskin.everday.util;

import android.animation.ValueAnimator;
import android.content.Context;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.graphics.Canvas;
import android.graphics.Matrix;
import android.graphics.Paint;
import android.graphics.drawable.Drawable;
import android.os.Build;
import android.support.annotation.Nullable;
import android.util.AttributeSet;
import android.util.Log;
import android.view.View;
import android.view.animation.LinearInterpolator;

import com.freeskin.everday.R;


public class CircleView extends View {
    private Bitmap mBitmap;
    private int bitmapWidth;
    private int bitmapHeight;
    private int width;
    private int height;
    private float radius = 0;
    private float centerPointX;
    private float centerPointY;
    private int angle;
    private int angle2;
    private int angle3;
    private int angle4;
    private int angle5;
    private int angle6;
    private Paint mPaint;

    public float getRadius() {
        return radius;
    }

    private ValueAnimator animator1;
    private ValueAnimator animator2;
    private ValueAnimator animator3;
    private ValueAnimator animator4;
    private ValueAnimator animator5;
    private ValueAnimator animator6;

    public CircleView(Context context) {
        this(context, null);
    }

    public CircleView(Context context, @Nullable AttributeSet attrs) {
        this(context, attrs, 0);
    }

    public CircleView(Context context, @Nullable AttributeSet attrs, int defStyleAttr) {
        super(context, attrs, defStyleAttr);
    }


    public void initData(int position) {
        mPaint = new Paint();
        if (position == 0) {
            mBitmap = getBitmap(getContext(), R.mipmap.icon_bird_normal);
        } else {
            mBitmap = getBitmap(getContext(), R.mipmap.icon_bird_super);
        }
        Matrix matrix = new Matrix();
        matrix.postScale(2, 2); //长和宽放大缩小的比例
        mBitmap = Bitmap.createBitmap(mBitmap, 0, 0, mBitmap.getWidth(), mBitmap.getHeight(), matrix, true);
        bitmapHeight = mBitmap.getWidth();
        bitmapWidth = mBitmap.getWidth();

        animator1 = ValueAnimator.ofInt(-150, 210);
        animator1.addUpdateListener(new ValueAnimator.AnimatorUpdateListener() {
            @Override
            public void onAnimationUpdate(ValueAnimator animation) {
                angle = (Integer) animation.getAnimatedValue();
                postInvalidate();//刷新界面
            }
        });


        animator2 = ValueAnimator.ofInt(-90, 270);
        animator2.addUpdateListener(new ValueAnimator.AnimatorUpdateListener() {
            @Override
            public void onAnimationUpdate(ValueAnimator animation) {
                angle2 = (Integer) animation.getAnimatedValue();
                postInvalidate();//刷新界面
            }
        });

        animator3 = ValueAnimator.ofInt(-30, 330);
        animator3.addUpdateListener(new ValueAnimator.AnimatorUpdateListener() {
            @Override
            public void onAnimationUpdate(ValueAnimator animation) {
                angle3 = (Integer) animation.getAnimatedValue();
                postInvalidate();//刷新界面
            }
        });

        animator4 = ValueAnimator.ofInt(30, 390);
        animator4.addUpdateListener(new ValueAnimator.AnimatorUpdateListener() {
            @Override
            public void onAnimationUpdate(ValueAnimator animation) {
                angle4 = (Integer) animation.getAnimatedValue();
                postInvalidate();//刷新界面
            }
        });


        animator5 = ValueAnimator.ofInt(90, 450);
        animator5.addUpdateListener(new ValueAnimator.AnimatorUpdateListener() {
            @Override
            public void onAnimationUpdate(ValueAnimator animation) {
                angle5 = (Integer) animation.getAnimatedValue();
                postInvalidate();//刷新界面
            }
        });

        animator6 = ValueAnimator.ofInt(150, 510);
        animator6.addUpdateListener(new ValueAnimator.AnimatorUpdateListener() {
            @Override
            public void onAnimationUpdate(ValueAnimator animation) {
                angle6 = (Integer) animation.getAnimatedValue();
                postInvalidate();//刷新界面
            }
        });


    }

    @Override
    protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
        width = MeasureSpec.getSize(widthMeasureSpec);
        height = MeasureSpec.getSize(heightMeasureSpec);
        float minLength = Math.min(width, height);
        float maxBitmapLength = Math.min(bitmapWidth, bitmapHeight);
        if (minLength / 2 > maxBitmapLength) {
            radius = (minLength - maxBitmapLength) / 2;
        }
        centerPointX = minLength / 2;
        centerPointY = minLength / 2;
        setMeasuredDimension(width, height);//向父view申请指定的宽高
    }

    @Override
    protected void onLayout(boolean changed, int left, int top, int right, int bottom) {
        super.onLayout(changed, left, top, right, bottom);
    }

    @Override
    protected void onDraw(Canvas canvas) {
        super.onDraw(canvas);
        float pointX = (float) (centerPointX + radius * Math.cos(Math.toRadians(angle)));
        float pointY = (float) (centerPointY + radius * Math.sin(Math.toRadians(angle)));

        float pointX2 = (float) (centerPointX + radius * Math.cos(Math.toRadians(angle2)));
        float pointY2 = (float) (centerPointY + radius * Math.sin(Math.toRadians(angle2)));

        float pointX3 = (float) (centerPointX + radius * Math.cos(Math.toRadians(angle3)));
        float pointY3 = (float) (centerPointY + radius * Math.sin(Math.toRadians(angle3)));

        float pointX4 = (float) (centerPointX + radius * Math.cos(Math.toRadians(angle4)));
        float pointY4 = (float) (centerPointY + radius * Math.sin(Math.toRadians(angle4)));
        float pointX5 = (float) (centerPointX + radius * Math.cos(Math.toRadians(angle5)));
        float pointY5 = (float) (centerPointY + radius * Math.sin(Math.toRadians(angle5)));
        float pointX6 = (float) (centerPointX + radius * Math.cos(Math.toRadians(angle6)));
        float pointY6 = (float) (centerPointY + radius * Math.sin(Math.toRadians(angle6)));

        Log.d("Logger", "onDraw: " + pointX + "  " + pointY);

        Log.d("Logger", "centerPointX: " + centerPointX + "  " + centerPointY);
        canvas.drawBitmap(mBitmap, pointX2 - bitmapWidth / 2, pointY2 - bitmapHeight / 2, mPaint);
        canvas.drawBitmap(mBitmap, pointX - bitmapWidth / 2, pointY - bitmapHeight / 2, mPaint);
        canvas.drawBitmap(mBitmap, pointX3 - bitmapWidth / 2, pointY3 - bitmapHeight / 2, mPaint);
        canvas.drawBitmap(mBitmap, pointX4 - bitmapWidth / 2, pointY4 - bitmapHeight / 2, mPaint);
        canvas.drawBitmap(mBitmap, pointX5 - bitmapWidth / 2, pointY5 - bitmapHeight / 2, mPaint);
        canvas.drawBitmap(mBitmap, pointX6 - bitmapWidth / 2, pointY6 - bitmapHeight / 2, mPaint);
    }

    public void startDraw() {
        animator1.setInterpolator(new LinearInterpolator());
        animator1.setDuration(2000);// 动画时间
        animator1.setRepeatCount(2);
        animator1.start();// 启动动画

        animator2.setInterpolator(new LinearInterpolator());
        animator2.setDuration(2000);// 动画时间
        animator2.setRepeatCount(2);
        animator2.start();// 启动动画

        animator3.setInterpolator(new LinearInterpolator());
        animator3.setDuration(2000);// 动画时间
        animator3.setRepeatCount(2);
        animator3.start();// 启动动画

        animator4.setInterpolator(new LinearInterpolator());
        animator4.setDuration(2000);// 动画时间
        animator4.setRepeatCount(2);
        animator4.start();// 启动动画

        animator5.setInterpolator(new LinearInterpolator());
        animator5.setDuration(2000);// 动画时间
        animator5.setRepeatCount(2);
        animator5.start();// 启动动画

        animator6.setInterpolator(new LinearInterpolator());
        animator6.setDuration(2000);// 动画时间
        animator6.setRepeatCount(2);
        animator6.start();// 启动动画
    }


    private Bitmap getBitmap(Context context, int vectorDrawableId) {
        Bitmap bitmap = null;
        if (Build.VERSION.SDK_INT > Build.VERSION_CODES.LOLLIPOP) {
            Drawable vectorDrawable = context.getDrawable(vectorDrawableId);
            bitmap = Bitmap.createBitmap(vectorDrawable.getIntrinsicWidth(),
                    vectorDrawable.getIntrinsicHeight(), Bitmap.Config.ARGB_8888);
            Canvas canvas = new Canvas(bitmap);
            vectorDrawable.setBounds(0, 0, canvas.getWidth(), canvas.getHeight());
            vectorDrawable.draw(canvas);
        } else {
            bitmap = BitmapFactory.decodeResource(context.getResources(), vectorDrawableId);
        }
        return bitmap;
    }
}