Android特效专辑（八）——实现心型起泡飞舞的特效，让你的APP瞬间暖心

马上也要放年假了，家里估计会没网，更完这篇的话，可能要到年后了，不过在此期间会把更新内容都保存在本地，这样有网就可以发表了，也是极好的，今天说的这个特效，原本是Only上的一个小彩蛋的，我们来看看图片

Android特效专辑（八）——实现心型起泡飞舞的特效，让你的APP瞬间暖心 - 图1

只要我点击了Only这个字，下面就开始上升起起泡了，这个实现起来其实就是一个欲盖弥彰的动画而已，准备好三张颜色不一样的心型图片咯，这样的话，我们就开始动手来写一写吧！
首先新建一个工程——HeartFaom
准备工作就是准备图片咯

BezierEvaluator

  1.       单位转换以及计算轨迹
  2.     
  1.       package com.lgl.heartfaom;
  3. import android.animation.TypeEvaluator;
  4. import android.graphics.PointF;
  6. public class BezierEvaluator implements TypeEvaluator<PointF> {
  8.     private PointF pointF1;
  9.     private PointF pointF2;
  11.     public BezierEvaluator(PointF pointF1, PointF pointF2) {
  12.         this.pointF1 = pointF1;
  13.         this.pointF2 = pointF2;
  14.     }
  16.     @Override
  17.     public PointF evaluate(float time, PointF startValue, PointF endValue) {
  19.         float timeLeft = 1.0f - time;
  20.         PointF point = new PointF();// 结果
  22.         point.x = timeLeft * timeLeft * timeLeft * (startValue.x) + 3
  23.                 * timeLeft * timeLeft * time * (pointF1.x) + 3 * timeLeft
  24.                 * time * time * (pointF2.x) + time * time * time * (endValue.x);
  26.         point.y = timeLeft * timeLeft * timeLeft * (startValue.y) + 3
  27.                 * timeLeft * timeLeft * time * (pointF1.y) + 3 * timeLeft
  28.                 * time * time * (pointF2.y) + time * time * time * (endValue.y);
  29.         return point;
  30.     }
  31. }
  32.

PeriscopeLayout

  1.       贝塞尔曲线的计算以及气泡的实现
  2.     
  1.       package com.lgl.heartfaom;
  3. import java.util.Random;
  5. import android.animation.Animator;
  6. import android.animation.AnimatorListenerAdapter;
  7. import android.animation.AnimatorSet;
  8. import android.animation.ObjectAnimator;
  9. import android.animation.ValueAnimator;
  10. import android.annotation.TargetApi;
  11. import android.content.Context;
  12. import android.graphics.PointF;
  13. import android.graphics.drawable.Drawable;
  14. import android.os.Build;
  15. import android.util.AttributeSet;
  16. import android.view.View;
  17. import android.view.animation.AccelerateDecelerateInterpolator;
  18. import android.view.animation.AccelerateInterpolator;
  19. import android.view.animation.DecelerateInterpolator;
  20. import android.view.animation.Interpolator;
  21. import android.view.animation.LinearInterpolator;
  22. import android.widget.ImageView;
  23. import android.widget.RelativeLayout;
  25. public class PeriscopeLayout extends RelativeLayout {
  27.     private Interpolator line = new LinearInterpolator();// 线性
  28.     private Interpolator acc = new AccelerateInterpolator();// 加速
  29.     private Interpolator dce = new DecelerateInterpolator();// 减速
  30.     private Interpolator accdec = new AccelerateDecelerateInterpolator();// 先加速后减速
  31.     private Interpolator[] interpolators;
  33.     private int mHeight;
  34.     private int mWidth;
  35.     private LayoutParams lp;
  36.     private Drawable[] drawables;
  37.     private Random random = new Random();
  39.     private int dHeight;
  40.     private int dWidth;
  42.     public PeriscopeLayout(Context context) {
  43.         super(context);
  44.         init();
  45.     }
  47.     public PeriscopeLayout(Context context, AttributeSet attrs) {
  48.         super(context, attrs);
  49.         init();
  50.     }
  52.     public PeriscopeLayout(Context context, AttributeSet attrs, int defStyleAttr) {
  53.         super(context, attrs, defStyleAttr);
  54.         init();
  55.     }
  57.     @TargetApi(Build.VERSION_CODES.LOLLIPOP)
  58.     public PeriscopeLayout(Context context, AttributeSet attrs,
  59.             int defStyleAttr, int defStyleRes) {
  60.         super(context, attrs, defStyleAttr, defStyleRes);
  61.         init();
  62.     }
  64.     private void init() {
  66.         // 初始化显示的图片
  67.         drawables = new Drawable[3];
  68.         Drawable red = getResources().getDrawable(R.drawable.pl_red);
  69.         Drawable yellow = getResources().getDrawable(R.drawable.pl_yellow);
  70.         Drawable blue = getResources().getDrawable(R.drawable.pl_blue);
  72.         drawables[0] = red;
  73.         drawables[1] = yellow;
  74.         drawables[2] = blue;
  75.         // 获取图的宽高 用于后面的计算
  76.         // 注意 我这里3张图片的大小都是一样的,所以我只取了一个
  77.         dHeight = red.getIntrinsicHeight();
  78.         dWidth = red.getIntrinsicWidth();
  80.         // 底部 并且 水平居中
  81.         lp = new LayoutParams(dWidth, dHeight);
  82.         lp.addRule(CENTER_HORIZONTAL, TRUE);// 这里的TRUE 要注意 不是true
  83.         lp.addRule(ALIGN_PARENT_BOTTOM, TRUE);
  85.         // 初始化插补器
  86.         interpolators = new Interpolator[4];
  87.         interpolators[0] = line;
  88.         interpolators[1] = acc;
  89.         interpolators[2] = dce;
  90.         interpolators[3] = accdec;
  92.     }
  94.     @Override
  95.     protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
  96.         super.onMeasure(widthMeasureSpec, heightMeasureSpec);
  97.         mWidth = getMeasuredWidth();
  98.         mHeight = getMeasuredHeight();
  99.     }
  101.     public void addHeart() {
  103.         ImageView imageView = new ImageView(getContext());
  104.         // 随机选一个
  105.         imageView.setImageDrawable(drawables[random.nextInt(3)]);
  106.         imageView.setLayoutParams(lp);
  108.         addView(imageView);
  110.         Animator set = getAnimator(imageView);
  111.         set.addListener(new AnimEndListener(imageView));
  112.         set.start();
  114.     }
  116.     private Animator getAnimator(View target) {
  117.         AnimatorSet set = getEnterAnimtor(target);
  119.         ValueAnimator bezierValueAnimator = getBezierValueAnimator(target);
  121.         AnimatorSet finalSet = new AnimatorSet();
  122.         finalSet.playSequentially(set);
  123.         finalSet.playSequentially(set, bezierValueAnimator);
  124.         finalSet.setInterpolator(interpolators[random.nextInt(4)]);
  125.         finalSet.setTarget(target);
  126.         return finalSet;
  127.     }
  129.     private AnimatorSet getEnterAnimtor(final View target) {
  131.         ObjectAnimator alpha = ObjectAnimator.ofFloat(target, View.ALPHA, 0.2f,
  132.                 1f);
  133.         ObjectAnimator scaleX = ObjectAnimator.ofFloat(target, View.SCALE_X,
  134.                 0.2f, 1f);
  135.         ObjectAnimator scaleY = ObjectAnimator.ofFloat(target, View.SCALE_Y,
  136.                 0.2f, 1f);
  137.         AnimatorSet enter = new AnimatorSet();
  138.         enter.setDuration(500);
  139.         enter.setInterpolator(new LinearInterpolator());
  140.         enter.playTogether(alpha, scaleX, scaleY);
  141.         enter.setTarget(target);
  142.         return enter;
  143.     }
  145.     private ValueAnimator getBezierValueAnimator(View target) {
  147.         // 初始化一个贝塞尔计算器- - 传入
  148.         BezierEvaluator evaluator = new BezierEvaluator(getPointF(2),
  149.                 getPointF(1));
  151.         // 这里最好画个图 理解一下 传入了起点 和 终点
  152.         ValueAnimator animator = ValueAnimator.ofObject(evaluator, new PointF(
  153.                 (mWidth - dWidth) / 2, mHeight - dHeight),
  154.                 new PointF(random.nextInt(getWidth()), 0));
  155.         animator.addUpdateListener(new BezierListenr(target));
  156.         animator.setTarget(target);
  157.         animator.setDuration(3000);
  158.         return animator;
  159.     }
  161.     /**
  162.      * 获取中间的两个 点
  163.      *
  164.      * @param scale
  165.      */
  166.     private PointF getPointF(int scale) {
  168.         PointF pointF = new PointF();
  169.         pointF.x = random.nextInt((mWidth - 100));// 减去100 是为了控制 x轴活动范围,看效果 随意~~
  170.         // 再Y轴上 为了确保第二个点 在第一个点之上,我把Y分成了上下两半 这样动画效果好一些 也可以用其他方法
  171.         pointF.y = random.nextInt((mHeight - 100)) / scale;
  172.         return pointF;
  173.     }
  175.     private class BezierListenr implements ValueAnimator.AnimatorUpdateListener {
  177.         private View target;
  179.         public BezierListenr(View target) {
  180.             this.target = target;
  181.         }
  183.         @Override
  184.         public void onAnimationUpdate(ValueAnimator animation) {
  185.             // 这里获取到贝塞尔曲线计算出来的的x y值 赋值给view 这样就能让爱心随着曲线走啦
  186.             PointF pointF = (PointF) animation.getAnimatedValue();
  187.             target.setX(pointF.x);
  188.             target.setY(pointF.y);
  189.             // 这里顺便做一个alpha动画
  190.             target.setAlpha(1 - animation.getAnimatedFraction());
  191.         }
  192.     }
  194.     private class AnimEndListener extends AnimatorListenerAdapter {
  195.         private View target;
  197.         public AnimEndListener(View target) {
  198.             this.target = target;
  199.         }
  201.         @Override
  202.         public void onAnimationEnd(Animator animation) {
  203.             super.onAnimationEnd(animation);
  204.             // 因为不停的add 导致子view数量只增不减,所以在view动画结束后remove掉
  205.             removeView((target));
  206.         }
  207.     }
  208. }
  209.

activity_main.xml

  1.       布局的实现
  2.     
  1.       <RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
  2.     xmlns:tools="http://schemas.android.com/tools"
  3.     android:layout_width="match_parent"
  4.     android:layout_height="match_parent"
  5.     android:background="#000" >
  7.     <Button
  8.         android:id="@+id/btn_start"
  9.         android:layout_width="wrap_content"
  10.         android:layout_height="wrap_content"
  11.         android:layout_centerInParent="true"
  12.         android:text="飞舞吧！" />
  14.     <com.lgl.heartfaom.PeriscopeLayout
  15.         android:id="@+id/periscope"
  16.         android:layout_width="match_parent"
  17.         android:layout_height="match_parent" >
  18.     </com.lgl.heartfaom.PeriscopeLayout>
  20. </RelativeLayout>
  21.

MainActivity

  1.       接着就是怎么去使用它了
  2.     
  1.       package com.lgl.heartfaom;
  3. import android.app.Activity;
  4. import android.os.Bundle;
  5. import android.view.View;
  6. import android.view.View.OnClickListener;
  7. import android.widget.Button;
  9. public class MainActivity extends Activity {
  11.     private Button btn_start;
  12.     // 心型气泡
  13.     private PeriscopeLayout periscopeLayout;
  15.     @Override
  16.     protected void onCreate(Bundle savedInstanceState) {
  17.         super.onCreate(savedInstanceState);
  18.         setContentView(R.layout.activity_main);
  19.         // 初始化
  20.         periscopeLayout = (PeriscopeLayout) findViewById(R.id.periscope);
  22.         btn_start = (Button) findViewById(R.id.btn_start);
  23.         btn_start.setOnClickListener(new OnClickListener() {
  25.             @Override
  26.             public void onClick(View v) {
  27.                 // 调用添加泡泡的方法
  28.                 periscopeLayout.addHeart();
  29.             }
  30.         });
  31.     }
  32. }
  33.

好，我们接下来就可以运行一下试试实际上的效果了

Android特效专辑（八）——实现心型起泡飞舞的特效，让你的APP瞬间暖心 - 图2

觉得不错的点个赞哦！

Demo下载地址：http://download.csdn.net/detail/qq_26787115/9422603