RippleView.java

package com.wavemeasure.wavemeasure.ui.widget;

import android.animation.Animator;
import android.animation.ValueAnimator;
import android.content.Context;
import android.graphics.Canvas;
import android.graphics.Paint;
import android.support.annotation.ColorInt;
import android.util.AttributeSet;
import android.view.View;
import android.view.animation.AccelerateDecelerateInterpolator;

import com.wavemeasure.wavemeasure.R;
import com.wavemeasure.wavemeasure.ui.util.ResourcesUtils;

public class RippleView extends View
        implements ValueAnimator.AnimatorUpdateListener, Animator.AnimatorListener {

    private static final int RADIUS = 48;


    private Paint mInPaint = new Paint();

    private Paint mInStrokePaint = new Paint();

    private Paint mOutStrokePaint = new Paint();


    private RippleStateListener mRippleStateListener;

    private ValueAnimator mValueAnimator;


    private float mCx;

    private float mCy;


    private int mChangeRadius;

    private int mRadius;


    private int mDuration = 3000;

    private int mRepeatCount = 1;

    private int mStrokeWidth = 1;


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

        initComponents();
    }

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

        initComponents();
    }

    public RippleView(Context context, AttributeSet attrs, int defStyleAttr) {
        super(context, attrs, defStyleAttr);

        initComponents();
    }


    @Override
    public void onAnimationCancel(Animator animation) {
        mChangeRadius = mRadius;
    }

    @Override
    public void onAnimationEnd(Animator animation) {
        if (mRippleStateListener != null) {
            mRippleStateListener.stopRipple();
        }

        mChangeRadius = mRadius;
    }

    @Override
    public void onAnimationRepeat(Animator animation) {

    }

    @Override
    public void onAnimationStart(Animator animation) {
        if (mRippleStateListener != null) {
            mRippleStateListener.startRipple();
        }
    }

    @Override
    public void onAnimationUpdate(ValueAnimator animation) {
        mChangeRadius = (int) animation.getAnimatedValue();

        postInvalidate();

        if (mRippleStateListener != null) {
            mRippleStateListener.onRippleUpdate(animation);
        }
    }


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

        canvas.drawCircle(mCx, mCy, mChangeRadius, mOutStrokePaint);

        if (mChangeRadius >= mRadius * 1.5) {
            canvas.drawCircle(mCx, mCy, mChangeRadius - (mRadius / 2), mOutStrokePaint);
        }

        if (mChangeRadius >= mRadius * 2) {
            canvas.drawCircle(mCx, mCy, mChangeRadius - (mRadius), mOutStrokePaint);
        }

        // canvas.drawCircle(mCx, mCy, mRadius, mInPaint);

        // canvas.drawCircle(mCx, mCy, mRadius, mInStrokePaint);
    }

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

        mCx = getMeasuredWidth() / 2;

        mCy = getMeasuredHeight() / 2;
    }


    public void startRipple() {
        if (mValueAnimator == null) {
            mValueAnimator = new ValueAnimator();

            mValueAnimator.setDuration(mDuration);

            mValueAnimator.setInterpolator(new AccelerateDecelerateInterpolator());

            mValueAnimator.setIntValues(mRadius, (int) (mCx > mCy ? mCx * 1.4 : mCy * 1.4));

            mValueAnimator.setRepeatCount(mRepeatCount);

            mValueAnimator.addListener(this);

            mValueAnimator.addUpdateListener(this);

            mValueAnimator.start();
        } else {
            if (!mValueAnimator.isRunning()) {
                mValueAnimator.start();
            }
        }
    }

    public void stopRipple() {
        if (mValueAnimator != null) {
            mValueAnimator.end();
        }
    }


    public void setCirclePoint(float x, float y) {
        mCx = x;

        mCy = y;
    }


    public int getDuration() {
        return mDuration;
    }

    public void setDuration(int duration) {
        mDuration = duration;
    }


    public void setInPaintColor(int color) {
        mInPaint.setColor(color);
    }

    public void setInStrokePaintColor(int color) {
        mInStrokePaint.setColor(color);
    }

    public void setOutStrokePaintColor(int color) {
        mOutStrokePaint.setColor(color);
    }

    public void setRadius(int radius) {
        mRadius = radius;

        mChangeRadius = radius;
    }

    public void setRepeatCount(int repeatCount) {
        mRepeatCount = repeatCount;
    }

    public void setRippleStateListener(RippleStateListener listener) {
        mRippleStateListener = listener;
    }

    public void setStrokeWidth(int strokeWidth) {
        mStrokeWidth = strokeWidth;
    }


    private void initComponents() {
        @ColorInt
        final int color = ResourcesUtils.getColor(getContext(), R.color.colorYellow);


        mRadius = dp2px(RADIUS);

        mChangeRadius = mRadius;


        mInPaint.setColor(color);

        mInPaint.setAntiAlias(true);

        mInPaint.setStyle(Paint.Style.FILL);


        mInStrokePaint.setColor(color);

        mInStrokePaint.setAntiAlias(true);

        mInStrokePaint.setStyle(Paint.Style.STROKE);

        mInStrokePaint.setStrokeWidth(dp2px(mStrokeWidth));


        mOutStrokePaint.setColor(color);

        mOutStrokePaint.setAntiAlias(true);

        mOutStrokePaint.setStyle(Paint.Style.STROKE);

        mOutStrokePaint.setStrokeWidth(dp2px(mStrokeWidth));
    }

    private int dp2px(float dpValue) {
        float scale = getContext().getResources().getDisplayMetrics().density;

        return (int) (dpValue * scale + 0.5f);
    }


    public interface RippleStateListener {

        void startRipple();

        void stopRipple();

        void onRippleUpdate(ValueAnimator animation);

    }

}