PathMeasure-穹灵科技

把商品添加到购物车的动画效果（贝塞尔曲线）

如图：

这里写图片描述

参考：

Android补间动画，属性动画实现购物车添加动画

思路：

确定动画的起终点
在起终点之间使用二次贝塞尔曲线填充起终点之间的点的轨迹
设置属性动画，ValueAnimator插值器，获取中间点的坐标
将执行动画的控件的x、y坐标设为上面得到的中间点坐标
开启属性动画
当动画结束时的操作

难点：

PathMeasure的使用
– getLength()
– boolean getPosTan(float distance, float[] pos, float[] tan) 的理解

涉及到的知识点：

如何获取控件在屏幕中的*对坐标

//得到父布局的起始点坐标（用于辅助计算动画开始/结束时的点的坐标）
   int[] parentLocation = new int[2];
   rl.getLocationInWindow(parentLocation);

如何使用贝塞尔曲线以及属性动画插值器ValueAnimator

//        四、计算中间动画的插值坐标（贝塞尔曲线）（其实就是用贝塞尔曲线来完成起终点的过程）
        //开始绘制贝塞尔曲线
        Path path = new Path();
        //移动到起始点（贝塞尔曲线的起点）
        path.moveTo(startX, startY);
        //使用二次萨贝尔曲线：注意*个起始坐标越大，贝塞尔曲线的横向距离就会越大，一般按照下面的式子取即可
        path.quadTo((startX + toX) / 2, startY, toX, toY);
        //mPathMeasure用来计算贝塞尔曲线的曲线长度和贝塞尔曲线中间插值的坐标，
        // 如果是true，path会形成一个闭环
        mPathMeasure = new PathMeasure(path, false);

        //★★★属性动画实现（从0到贝塞尔曲线的长度之间进行插值计算，获取中间过程的距离值）
        ValueAnimator valueAnimator = ValueAnimator.ofFloat(0, mPathMeasure.getLength());
        valueAnimator.setDuration(1000);
        // 匀速线性插值器
        valueAnimator.setInterpolator(new LinearInterpolator());
        valueAnimator.addUpdateListener(new ValueAnimator.AnimatorUpdateListener() {
            @Override
            public void onAnimationUpdate(ValueAnimator animation) {
                // 当插值计算进行时，获取中间的每个值，
                // 这里这个值是中间过程中的曲线长度（下面根据这个值来得出中间点的坐标值）
                float value = (Float) animation.getAnimatedValue();
                // ★★★★★获取当前点坐标封装到mCurrentPosition
                // boolean getPosTan(float distance, float[] pos, float[] tan) ：
                // 传入一个距离distance(0<=distance<=getLength())，然后会计算当前距
                // 离的坐标点和切线，pos会自动填充上坐标，这个方法很重要。
                mPathMeasure.getPosTan(value, mCurrentPosition, null);//mCurrentPosition此时就是中间距离点的坐标值
                // 移动的商品图片（动画图片）的坐标设置为该中间点的坐标
                goods.setTranslationX(mCurrentPosition[0]);
                goods.setTranslationY(mCurrentPosition[1]);
            }
        });
//      五、 开始执行动画
        valueAnimator.start();

所有代码：

package cn.c.com.beziercurveanimater;

import android.animation.Animator;
import android.animation.ValueAnimator;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.graphics.Path;
import android.graphics.PathMeasure;
import android.os.Bundle;
import android.support.v7.app.AppCompatActivity;
import android.support.v7.widget.LinearLayoutManager;
import android.support.v7.widget.RecyclerView;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.view.animation.LinearInterpolator;
import android.widget.ImageView;
import android.widget.RelativeLayout;
import android.widget.TextView;

import java.util.ArrayList;

public class MainActivity extends AppCompatActivity {

    private RecyclerView mRecyclerView;
    private ImageView cart;
    private ArrayList<Bitmap> bitmapList = new ArrayList<>();
    private RelativeLayout rl;
    private PathMeasure mPathMeasure;
    /**
     * 贝塞尔曲线中间过程的点的坐标
     */
    private float[] mCurrentPosition = new float[2];
    private TextView count;
    private int i = 0;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        initView();
        initImg();
        MyAdapter myAdapter = new MyAdapter(bitmapList);
        mRecyclerView.setAdapter(myAdapter);
        mRecyclerView.setLayoutManager(new LinearLayoutManager(MainActivity.this));
    }

    private void initImg() {
        bitmapList.add(BitmapFactory.decodeResource(getResources(), R.drawable.coin));
        bitmapList.add(BitmapFactory.decodeResource(getResources(), R.drawable.coin1));
        bitmapList.add(BitmapFactory.decodeResource(getResources(), R.drawable.coin91));
    }

    private void initView() {
        mRecyclerView = (RecyclerView) findViewById(R.id.recyclerView);
        cart = (ImageView) findViewById(R.id.cart);
        rl = (RelativeLayout) findViewById(R.id.rl);
        count = (TextView) findViewById(R.id.count);
    }

    class MyAdapter extends RecyclerView.Adapter<MyVH> {
        private ArrayList<Bitmap> bitmapList;

        public MyAdapter(ArrayList<Bitmap> bitmapList) {
            this.bitmapList = bitmapList;
        }

        @Override
        public MyVH onCreateViewHolder(ViewGroup parent, int viewType) {
            LayoutInflater inflater = LayoutInflater.from(MainActivity.this);
            View itemView = inflater.inflate(R.layout.item, parent, false);
            MyVH myVH = new MyVH(itemView);
            return myVH;
        }

        @Override
        public void onBindViewHolder(final MyVH holder, final int position) {
            holder.iv.setImageBitmap(bitmapList.get(position));
            holder.buy.setOnClickListener(new View.OnClickListener() {
                @Override
                public void onClick(View v) {
                    addCart(holder.iv);
                }
            });
        }

        @Override
        public int getItemCount() {
            return bitmapList.size();
        }
    }

    /**
     * ★★★★★把商品添加到购物车的动画效果★★★★★
     * @param iv
     */
    private void addCart( ImageView iv) {
//      一、创造出执行动画的主题---imageview
        //代码new一个imageview，图片资源是上面的imageview的图片
        // (这个图片就是执行动画的图片，从开始位置出发，经过一个抛物线（贝塞尔曲线），移动到购物车里)
        final ImageView goods = new ImageView(MainActivity.this);
        goods.setImageDrawable(iv.getDrawable());
        RelativeLayout.LayoutParams params = new RelativeLayout.LayoutParams(100, 100);
        rl.addView(goods, params);

//        二、计算动画开始/结束点的坐标的准备工作
        //得到父布局的起始点坐标（用于辅助计算动画开始/结束时的点的坐标）
        int[] parentLocation = new int[2];
        rl.getLocationInWindow(parentLocation);

        //得到商品图片的坐标（用于计算动画开始的坐标）
        int startLoc[] = new int[2];
        iv.getLocationInWindow(startLoc);

        //得到购物车图片的坐标(用于计算动画结束后的坐标)
        int endLoc[] = new int[2];
        cart.getLocationInWindow(endLoc);


//        三、正式开始计算动画开始/结束的坐标
        //开始掉落的商品的起始点：商品起始点-父布局起始点+该商品图片的一半
        float startX = startLoc[0] - parentLocation[0] + iv.getWidth() / 2;
        float startY = startLoc[1] - parentLocation[1] + iv.getHeight() / 2;

        //商品掉落后的终点坐标：购物车起始点-父布局起始点+购物车图片的1/5
        float toX = endLoc[0] - parentLocation[0] + cart.getWidth() / 5;
        float toY = endLoc[1] - parentLocation[1];

//        四、计算中间动画的插值坐标（贝塞尔曲线）（其实就是用贝塞尔曲线来完成起终点的过程）
        //开始绘制贝塞尔曲线
        Path path = new Path();
        //移动到起始点（贝塞尔曲线的起点）
        path.moveTo(startX, startY);
        //使用二次萨贝尔曲线：注意*个起始坐标越大，贝塞尔曲线的横向距离就会越大，一般按照下面的式子取即可
        path.quadTo((startX + toX) / 2, startY, toX, toY);
        //mPathMeasure用来计算贝塞尔曲线的曲线长度和贝塞尔曲线中间插值的坐标，
        // 如果是true，path会形成一个闭环
        mPathMeasure = new PathMeasure(path, false);

        //★★★属性动画实现（从0到贝塞尔曲线的长度之间进行插值计算，获取中间过程的距离值）
        ValueAnimator valueAnimator = ValueAnimator.ofFloat(0, mPathMeasure.getLength());
        valueAnimator.setDuration(1000);
        // 匀速线性插值器
        valueAnimator.setInterpolator(new LinearInterpolator());
        valueAnimator.addUpdateListener(new ValueAnimator.AnimatorUpdateListener() {
            @Override
            public void onAnimationUpdate(ValueAnimator animation) {
                // 当插值计算进行时，获取中间的每个值，
                // 这里这个值是中间过程中的曲线长度（下面根据这个值来得出中间点的坐标值）
                float value = (Float) animation.getAnimatedValue();
                // ★★★★★获取当前点坐标封装到mCurrentPosition
                // boolean getPosTan(float distance, float[] pos, float[] tan) ：
                // 传入一个距离distance(0<=distance<=getLength())，然后会计算当前距
                // 离的坐标点和切线，pos会自动填充上坐标，这个方法很重要。
                mPathMeasure.getPosTan(value, mCurrentPosition, null);//mCurrentPosition此时就是中间距离点的坐标值
                // 移动的商品图片（动画图片）的坐标设置为该中间点的坐标
                goods.setTranslationX(mCurrentPosition[0]);
                goods.setTranslationY(mCurrentPosition[1]);
            }
        });
//      五、 开始执行动画
        valueAnimator.start();

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

            }

            //当动画结束后：
            @Override
            public void onAnimationEnd(Animator animation) {
                // 购物车的数量加1
                i++;
                count.setText(String.valueOf(i));
                // 把移动的图片imageview从父布局里移除
                rl.removeView(goods);
            }

            @Override
            public void onAnimationCancel(Animator animation) {

            }

            @Override
            public void onAnimationRepeat(Animator animation) {

            }
        });
    }


    class MyVH extends RecyclerView.ViewHolder {

        private ImageView iv;
        private TextView buy;

        public MyVH(View itemView) {
            super(itemView);
            iv = (ImageView) itemView.findViewById(R.id.iv);
            buy = (TextView) itemView.findViewById(R.id.buy);
        }
    }


}

今天我们一起利用 Path 做个比较实用的小例子；

上一篇我们使用 Path 绘制了一个小桃心，我们这一篇继续围绕着这个小桃心进行展开：

%title插图%num

————————————————–

如果对这个桃心绘制有问题或有兴趣的同学，可以链接到 Path相关方法讲解(二)，此时我们的需求是这样的：

假定我们现在是一个婚恋产品，有一个“心动”的功能，用户点击“心动”按钮的时候，有一个光点快速的沿着桃心转一圈，然后整个桃心泛起光晕！

针对这个需求，很多人可能会想到以下方案：

不就一个光点沿着桃心跑一圈么，既然桃心是使用贝塞尔曲线画出来的，那么我们就可以用对应的函数模拟出这条曲线，然后算出对应位置上的点，不断将光点绘制到对应的位置上！

这个思路当然没有问题，但我们还有相对简单的方式，那就是使用 PathMeasure:

我们主要使用它两个方法：

1.getLength() – 获取路径的长度

2.getPosTan(float distance, float pos[],float tan[]) － path 为 null ，返回 false

distance 为一个 0 － getLength() 之间的值，根据这个值 PathMeasure 会计算出当前点的坐标封装到 pos 中；

上面这句话我们可以这么来理解，不管实际 Path 多么的复杂，PathMeasure 都相当于做了一个事情，就是把 Path “拉直”，然后给了我们一个接口(getLength)告诉我们path的总长度，然后我们想要知道具体某一点的坐标，只需要用相对的distance去取即可，这样就省去了自己用函数模拟path，然后计算获取点坐标的过程；

接下来，我们用代码实现这一效果：

我们先创建一个 PathMeasure ，并将创建好的 path 作为参数传入

mPath = new Path();
mPath.moveTo(START_POINT[0], START_POINT[1]);
mPath.quadTo(RIGHT_CONTROL_POINT[0], RIGHT_CONTROL_POINT[1], BOTTOM_POINT[0],
BOTTOM_POINT[1]);
mPath.quadTo(LEFT_CONTROL_POINT[0], LEFT_CONTROL_POINT[1], START_POINT[0], START_POINT[1]);
mPathMeasure = new PathMeasure(mPath, true);

然后用一个数组纪录点的坐标：

private float[] mCurrentPosition = new float[2];

向外暴露一个开启动效的接口：

// 开启路径动画
public void startPathAnim(long duration) {
// 0 － getLength()
ValueAnimator valueAnimator = ValueAnimator.ofFloat(0, mPathMeasure.getLength());
Log.i(TAG, “measure length = ” + mPathMeasure.getLength());
valueAnimator.setDuration(duration);
// 减速插值器
valueAnimator.setInterpolator(new DecelerateInterpolator());
valueAnimator.addUpdateListener(new AnimatorUpdateListener() {
@Override
public void onAnimationUpdate(ValueAnimator animation) {
float value = (Float) animation.getAnimatedValue();
// 获取当前点坐标封装到mCurrentPosition
mPathMeasure.getPosTan(value, mCurrentPosition, null);
postInvalidate();
}
});
valueAnimator.start();
}

实时获取到当前点之后，将目标绘制到对应位置：

protected void onDraw(Canvas canvas) {
super.onDraw(canvas);
canvas.drawColor(Color.WHITE);
canvas.drawPath(mPath, mPaint);
canvas.drawCircle(RIGHT_CONTROL_POINT[0], RIGHT_CONTROL_POINT[1], 5, mPaint);
canvas.drawCircle(LEFT_CONTROL_POINT[0], LEFT_CONTROL_POINT[1], 5, mPaint);
// 绘制对应目标
canvas.drawCircle(mCurrentPosition[0], mCurrentPosition[1], 10, mPaint);
}

到这里目标环绕 path 的效果就ok了，不管这条路径简单也好，复杂也罢，我们都可以如此简单的完成对应的效果，而不需要自己用简单或复杂函数模拟求解了；

完成了一步，自己提的需求还有一点就是光晕的问题，这个东西如何是好呢？切图？！不需要，Android 已经给我们提供了一个好用的东西 MaskFilter ,后面我就不做了，大家有兴趣自己做的玩玩，只需要注意一点，MaskFilter 不支持硬件加速，记得关掉！

好了，PathMeasure 看似很简单，但着实很有用，有了它，再结合上 Path 、Shader、ColorMatrix 等利器，我们已经可以做出很多酷炫的效果了！

*后，完整的代码献上，请笑纳：

public class DynamicHeartView extends View {
private static final String TAG = “DynamicHeartView”;
private static final int PATH_WIDTH = 2;
// 起始点
private static final int[] START_POINT = new int[] {
300, 270
};
// 爱心下端点
private static final int[] BOTTOM_POINT = new int[] {
300, 400
};
// 左侧控制点
private static final int[] LEFT_CONTROL_POINT = new int[] {
450, 200
};
// 右侧控制点
private static final int[] RIGHT_CONTROL_POINT = new int[] {
150, 200
};
private PathMeasure mPathMeasure;
private Paint mPaint;
private Path mPath;
private float[] mCurrentPosition = new float[2];
public DynamicHeartView(Context context) {
super(context);
init();
}
private void init() {
mPaint = new Paint(Paint.ANTI_ALIAS_FLAG);
mPaint.setStyle(Style.STROKE);
mPaint.setStrokeWidth(PATH_WIDTH);
mPaint.setColor(Color.RED);
mPath = new Path();
mPath.moveTo(START_POINT[0], START_POINT[1]);
mPath.quadTo(RIGHT_CONTROL_POINT[0], RIGHT_CONTROL_POINT[1], BOTTOM_POINT[0],
BOTTOM_POINT[1]);
mPath.quadTo(LEFT_CONTROL_POINT[0], LEFT_CONTROL_POINT[1], START_POINT[0], START_POINT[1]);
mPathMeasure = new PathMeasure(mPath, true);
mCurrentPosition = new float[2];
}
@Override
protected void onDraw(Canvas canvas) {
super.onDraw(canvas);
canvas.drawColor(Color.WHITE);
canvas.drawPath(mPath, mPaint);
canvas.drawCircle(RIGHT_CONTROL_POINT[0], RIGHT_CONTROL_POINT[1], 5, mPaint);
canvas.drawCircle(LEFT_CONTROL_POINT[0], LEFT_CONTROL_POINT[1], 5, mPaint);
// 绘制对应目标
canvas.drawCircle(mCurrentPosition[0], mCurrentPosition[1], 10, mPaint);
}
// 开启路径动画
public void startPathAnim(long duration) {
// 0 － getLength()
ValueAnimator valueAnimator = ValueAnimator.ofFloat(0, mPathMeasure.getLength());
Log.i(TAG, “measure length = ” + mPathMeasure.getLength());
valueAnimator.setDuration(duration);
// 减速插值器
valueAnimator.setInterpolator(new DecelerateInterpolator());
valueAnimator.addUpdateListener(new AnimatorUpdateListener() {
@Override
public void onAnimationUpdate(ValueAnimator animation) {
float value = (Float) animation.getAnimatedValue();
// 获取当前点坐标封装到mCurrentPosition
mPathMeasure.getPosTan(value, mCurrentPosition, null);
postInvalidate();
}
});
valueAnimator.start();
}
}

以上代码的效果如下，其余效果大家自行补充：

%title插图%num

PathMeasure打造万能路径特效

标签： PathMeasure

Android 把商品添加到购物车的动画效果（贝塞尔曲线）

把商品添加到购物车的动画效果（贝塞尔曲线）

如图：

参考：

思路：

难点：

涉及到的知识点：

所有代码：

Path特效之PathMeasure打造万能路径动效

2024 年 12 月
一	二	三	四	五	六	日
						1
2	3	4	5	6	7	8
9	10	11	12	13	14	15
16	17	18	19	20	21	22
23	24	25	26	27	28	29
30	31