收藏动画效果的工具类

package com.gwm.app.mediawidget.playdetail.radio.util;

import android.animation.Animator;
import android.animation.ValueAnimator;
import android.annotation.SuppressLint;
import android.content.Context;
import android.graphics.Path;
import android.graphics.PathMeasure;
import android.view.View;
import android.view.ViewGroup;
import android.view.animation.AccelerateInterpolator;
import android.widget.ImageView;

import androidx.constraintlayout.widget.ConstraintLayout;
import androidx.core.content.res.ResourcesCompat;

import com.airbnb.lottie.LottieAnimationView;
import com.gwm.app.mediawidget.R;

/**
 * @author liukai
 */
public class FavoriteAnimUtil {
    //抛物线动画执行总时间，毫秒
    private static final int TIME_ANIM_LONG = 800;
    //是否开启开始时候的缩放动画
    private static final boolean SWITCH_ON_START_ZOOM = true;
    //是否开启结束时候的弹跳动画
    private static final boolean SWITCH_ON_END_BOUNCE = true;

    private static final int VIEW_FAVORITE_BOUNCE_WIDTH = 150;

    private static final int VIEW_FAVORITE_BOUNCE_HEIGHT = 150;

    private static final int TIME_FRAME_ANIMATION_SPACING = 30;


    private static volatile FavoriteAnimUtil instance;
    public static FavoriteAnimUtil getInstance() {
        if (instance == null) {
            synchronized (FavoriteAnimUtil.class) {
                if (instance == null) {
                    instance = new FavoriteAnimUtil();
                }
            }
        }
        return instance;
    }

    private PathMeasure mPathMeasure;
    /**
     * 贝塞尔曲线中间过程的点的坐标
     */
    private final float[] mCurrentPosition = new float[2];
    @SuppressLint("Recycle") ValueAnimator valueAnimator;
    ImageView favorite;

    private void init(Context mContext,ConstraintLayout allView, LottieAnimationView startView, LottieAnimationView endView){
        int[] parentLocation = new int[2];
        allView.getLocationInWindow(parentLocation);
        int[] startLoc = new int[2];
        startView.getLocationInWindow(startLoc);
        int[] endLoc = new int[2];
        endView.getLocationInWindow(endLoc);

        //开始掉落的心心的起始点：startView起始点-父布局起始点+该图片的一半
        float startX = startLoc[0] - parentLocation[0] ;
        float startY = startLoc[1] - parentLocation[1] ;

        if(favorite!=null){
            allView.removeView(favorite);
        }
        favorite = new ImageView(mContext);
        ConstraintLayout.LayoutParams params = new ConstraintLayout.LayoutParams(startView.getWidth(), startView.getHeight());
        allView.addView(favorite, params);
        favorite.setTranslationX(startX);
        favorite.setTranslationY(startY);
        favorite.bringToFront();

        //小心心掉落后的终点坐标
        float toX = endLoc[0] - parentLocation[0] ;
        float toY = endLoc[1] - parentLocation[1];
        //开始绘制贝塞尔曲线
        Path path = new Path();
        //移动到起始点（贝塞尔曲线的起点）
        path.moveTo(startX, startY);
        //使用二次萨贝尔曲线：注意第一个起始坐标越大，贝塞尔曲线的横向距离就会越大，一般按照下面的式子取即可
        path.quadTo((startX + toX) / 2, startY/2, toX, toY);
        //mPathMeasure用来计算贝塞尔曲线的曲线长度和贝塞尔曲线中间插值的坐标，
        // 如果是true，path会形成一个闭环
        mPathMeasure = new PathMeasure(path, false);

        //★★★属性动画实现（从0到贝塞尔曲线的长度之间进行插值计算，获取中间过程的距离值）
        valueAnimator = ValueAnimator.ofFloat(0, mPathMeasure.getLength());
        valueAnimator.setDuration(TIME_ANIM_LONG);
        // 插值器
        valueAnimator.setInterpolator(new AccelerateInterpolator());
        valueAnimator.addUpdateListener(animation -> {
            // 当插值计算进行时，获取中间的每个值，
            float value = (Float) animation.getAnimatedValue();
            // 获取当前点坐标封装到mCurrentPosition
            mPathMeasure.getPosTan(value, mCurrentPosition, null);//mCurrentPosition此时就是中间距离点的坐标值
            // 移动图片（动画图片）的坐标设置为该中间点的坐标
            favorite.setTranslationX(mCurrentPosition[0]);
            favorite.setTranslationY(mCurrentPosition[1]);
        });

        //   六、动画结束后的处理
        valueAnimator.addListener(new Animator.AnimatorListener() {
            @Override
            public void onAnimationStart(Animator animation) {

            }

            //当动画结束后：
            @Override
            public void onAnimationEnd(Animator animation) {
                if(favorite==null){
                    return;
                }
                ViewGroup.LayoutParams layoutParams = favorite.getLayoutParams();
                layoutParams.width = VIEW_FAVORITE_BOUNCE_WIDTH;
                layoutParams.height = VIEW_FAVORITE_BOUNCE_HEIGHT;
                favorite.setLayoutParams(layoutParams);
                favorite.setTranslationX(toX- ((VIEW_FAVORITE_BOUNCE_WIDTH - endView.getWidth()) >> 1));
                favorite.setTranslationY(toY-(VIEW_FAVORITE_BOUNCE_HEIGHT-endView.getHeight()));
                startAnimFavoriteBounce(allView,endView);
            }

            @Override
            public void onAnimationCancel(Animator animation) {
                if(favorite==null){
                    return;
                }
                allView.removeView(favorite);
                favorite = null;
            }

            @Override
            public void onAnimationRepeat(Animator animation) {

            }
        });
    }
    public void startAnim(Context mContext, ConstraintLayout allView, LottieAnimationView startView, LottieAnimationView endView) {
        //如果正在执行就不要处理
        if(valueAnimator!=null&&valueAnimator.isRunning()){
            return;
        }
        if(favorite!=null){
            return;
        }
        //是否初始化数据，没有的话要初始化计算
        init(mContext,allView,startView,endView);
        startView.setVisibility(View.VISIBLE);
        startView.playAnimation();
        startView.addAnimatorListener(new Animator.AnimatorListener() {  //添加动画监听
            @Override
            public void onAnimationStart(Animator animation) {

            }

            @Override
            public void onAnimationEnd(Animator animation) {
                startView.setVisibility(View.INVISIBLE);
                //开始喜欢动画
                startAnimFavoriteZoom(mContext);
            }

            @Override
            public void onAnimationCancel(Animator animation) {

            }

            @Override
            public void onAnimationRepeat(Animator animation) {

            }
        });

    }

    public void cancelAnim(ConstraintLayout allView, LottieAnimationView startView, LottieAnimationView endView){
        if(startView.isAnimating()){
            startView.pauseAnimation();
            startView.setFrame(0);
            startView.setVisibility(View.INVISIBLE);
            favorite = null;
            return;
        }
        if(valueAnimator!=null&&valueAnimator.isRunning()){
            valueAnimator.cancel();
            if(favorite!=null){
                allView.removeView(favorite);
                favorite = null;
            }
            return;
        }
        if(endView.isAnimating()){
            endView.pauseAnimation();
            endView.setFrame(0);
            endView.setVisibility(View.INVISIBLE);
            favorite = null;
        }
    }

    private void startAnimFavoriteZoom(Context mContext){
        favorite.setImageDrawable(ResourcesCompat.getDrawable(mContext.getResources(), R.drawable.ic_media_collected_normal, null));
        valueAnimator.start();
    }

    private void startAnimFavoriteBounce( ConstraintLayout allView,LottieAnimationView endView){
        allView.removeView(favorite);
        favorite = null;
        endView.setVisibility(View.VISIBLE);
        endView.playAnimation();
        endView.addAnimatorListener(new Animator.AnimatorListener() {  //添加动画监听
            @Override
            public void onAnimationStart(Animator animation) {

            }

            @Override
            public void onAnimationEnd(Animator animation) {
                endView.setVisibility(View.INVISIBLE);
            }

            @Override
            public void onAnimationCancel(Animator animation) {

            }

            @Override
            public void onAnimationRepeat(Animator animation) {

            }
        });
    }
}