Android 自定义下拉刷新动画 -- 仿百度外卖下拉刷新

Hankkin
5,641 阅读6分钟
原文链接： blog.csdn.net

好久没写博客了，小编之前一段时间一直在找工作，从天津来到了我们的大帝都，感觉还不错。好了废话不多说了，开始我们今天的主题吧。现如今的APP各式各样，同样也带来了各种需求，一个下拉刷新都能玩出花样了，前两天订饭的时候不经意间看到了“百度外卖”的下拉刷新，今天的主题就是它–自定义下拉刷新动画。

看一下实现效果吧：
这里写图片描述

动画

我们先来看看Android中的动画吧：
Android中的动画分为三种：

  • Tween动画，这一类的动画提供了旋转、平移、缩放等效果。
    • Alpha – 淡入淡出
    • Scale – 缩放效果
    • Roate – 旋转效果
    • Translate – 平移效果
  • Frame动画（帧动画），这一类动画可以创建一个Drawable序列，按照指定时间间歇一个一个显示出来。
  • Property动画（属性动画），Android3.0之后引入出来的属性动画，它更改的是对象的实际属性。

分析

这里写图片描述

我们可以看到百度外卖的下拉刷新的头是一个骑车的快递员在路上疾行，分析一下我们得到下面的动画：

  1. 背景图片的平移动画
  2. 太阳的自旋转动画
  3. 两个小轮子的自旋转动画

这就很简单了，接下来我们去百度外面的图片资源文件里找到这几张图片：（下载百度外卖的apk直接解压即可）
这里写图片描述

定义下拉刷新头文件：headview.xml

这里注意一下：我们定义了两张背景图片的ImageView是为了可以实现背景的平移动画效果。

这里写图片描述

接下来我们定义动画效果：

背景图片的平移效果：
实现两个animation xml文件，一个起始位置在100%，结束位置在0%，设置repeat属性为循环往复。

另一个起始位置在0%，结束位置在-100%

太阳围绕中心旋转动画：
从0-360度开始循环旋转，旋转所用时间为1s，旋转中心距离view的左定点上边缘为50%的距离，也就是正中心。

下面是具体属性：

android:fromDegrees 起始的角度度数

android:toDegrees 结束的角度度数，负数表示逆时针，正数表示顺时针。如10圈则比android:fromDegrees大3600即可

android:pivotX 旋转中心的X坐标

浮点数或是百分比。浮点数表示相对于Object的左边缘，如5; 百分比表示相对于Object的左边缘，如5%; 另一种百分比表示相对于父容器的左边缘，如5%p; 一般设置为50%表示在Object中心

android:pivotY 旋转中心的Y坐标

浮点数或是百分比。浮点数表示相对于Object的上边缘，如5; 百分比表示相对于Object的上边缘，如5%; 另一种百分比表示相对于父容器的上边缘，如5%p; 一般设置为50%表示在Object中心

android:duration 表示从android:fromDegrees转动到android:toDegrees所花费的时间，单位为毫秒。可以用来计算速度。

android:interpolator表示变化率，但不是运行速度。一个插补属性，可以将动画效果设置为加速，减速，反复，反弹等。默认为开始和结束慢中间快，

android:startOffset 在调用start函数之后等待开始运行的时间，单位为毫秒，若为10，表示10ms后开始运行

android:repeatCount 重复的次数，默认为0，必须是int，可以为-1表示不停止

android:repeatMode 重复的模式，默认为restart，即重头开始重新运行，可以为reverse即从结束开始向前重新运行。在android:repeatCount大于0或为infinite时生效

android:detachWallpaper 表示是否在壁纸上运行

android:zAdjustment 表示被animated的内容在运行时在z轴上的位置，默认为normal。

normal保持内容当前的z轴顺序

top运行时在最顶层显示

bottom运行时在最底层显示

同理轮子的动画也一样，不占代码了。

动画定义完了我们开始定义下拉刷新列表，下拉刷新网上有很多，不详细的说了，简单的改造一下，根据刷新状态开启关闭动画即可。
注释写的很详细，看一下代码吧：

package com.hankkin.baidugoingrefreshlayout;

import android.widget.AbsListView;
import android.widget.ListView;

import android.content.Context;
import android.util.AttributeSet;
import android.view.LayoutInflater;
import android.view.MotionEvent;
import android.view.View;
import android.view.ViewGroup;
import android.view.animation.Animation;
import android.view.animation.AnimationUtils;
import android.widget.ImageView;
import android.widget.RelativeLayout;

/**
 * Created by Hankkin on 16/4/10.
 */
public class BaiDuRefreshListView extends ListView implements AbsListView.OnScrollListener{
    private static final int DONE = 0;      
    private static final int PULL_TO_REFRESH = 1;   
    private static final int RELEASE_TO_REFRESH = 2;    
    private static final int REFRESHING = 3;    
    private static final int RATIO = 3;
    private RelativeLayout headView;    
    private int headViewHeight; 
    private float startY;   
    private float offsetY;  
    private OnBaiduRefreshListener mOnRefreshListener;  
    private int state;  
    private int mFirstVisibleItem;  
    private boolean isRecord;   
    private boolean isEnd;  
    private boolean isRefreable;    

    private ImageView ivWheel1,ivWheel2;    
    private ImageView ivRider;  
    private ImageView ivSun,ivBack1,ivBack2;    
    private Animation wheelAnimation,sunAnimation;  
    private Animation backAnimation1,backAnimation2;    

    public BaiDuRefreshListView(Context context) {
        super(context);
        init(context);
    }

    public BaiDuRefreshListView(Context context, AttributeSet attrs) {
        super(context, attrs);
        init(context);
    }

    public BaiDuRefreshListView(Context context, AttributeSet attrs, int defStyleAttr) {
        super(context, attrs, defStyleAttr);
        init(context);
    }

    public interface OnBaiduRefreshListener{
        void onRefresh();
    }

    /**
     * 回调接口，想实现下拉刷新的listview实现此接口
     * @param onRefreshListener
     */
    public void setOnBaiduRefreshListener(OnBaiduRefreshListener onRefreshListener){
        mOnRefreshListener = onRefreshListener;
        isRefreable = true;
    }

    /**
     * 刷新完毕，从主线程发送过来，并且改变headerView的状态和文字动画信息
     */
    public void setOnRefreshComplete(){
        
        isEnd = true;
        state = DONE;

        changeHeaderByState(state);
    }

    private void init(Context context) {
        
        setOverScrollMode(OVER_SCROLL_NEVER);
        setOnScrollListener(this);
        
        headView = (RelativeLayout) LayoutInflater.from(context).inflate(R.layout.headview,this,false);
        
        measureView(headView);
        
        addHeaderView(headView);
        
        headViewHeight = headView.getMeasuredHeight();
        headView.setPadding(0, -headViewHeight, 0, 0);

        
        ivRider = (ImageView) headView.findViewById(R.id.iv_rider);
        ivSun = (ImageView) headView.findViewById(R.id.ivsun);
        ivWheel1 = (ImageView) headView.findViewById(R.id.wheel1);
        ivWheel2 = (ImageView) headView.findViewById(R.id.wheel2);
        ivBack1 = (ImageView) headView.findViewById(R.id.iv_back1);
        ivBack2 = (ImageView) headView.findViewById(R.id.iv_back2);
        
        wheelAnimation = AnimationUtils.loadAnimation(context, R.anim.tip);
        sunAnimation = AnimationUtils.loadAnimation(context, R.anim.tip1);

        backAnimation1 = AnimationUtils.loadAnimation(context, R.anim.a);
        backAnimation2 = AnimationUtils.loadAnimation(context, R.anim.b);

        state = DONE;
        isEnd = true;
        isRefreable = false;


    }

    @Override
    public void onScrollStateChanged(AbsListView absListView, int i) {
    }
    @Override
    public void onScroll(AbsListView absListView, int firstVisibleItem, int visibleItemCount, int totalItemCount) {
        mFirstVisibleItem = firstVisibleItem;
    }

    @Override
    public boolean onTouchEvent(MotionEvent ev) {
        if (isEnd) {
            if (isRefreable) {
                switch (ev.getAction()){
                    
                    case MotionEvent.ACTION_DOWN:
                        
                        if (mFirstVisibleItem == 0 && !isRecord) {
                            
                            isRecord = true;
                            
                            startY = ev.getY();
                        }
                        break;
                    
                    case MotionEvent.ACTION_MOVE:
                        
                        float tempY = ev.getY();
                        
                        if (mFirstVisibleItem == 0 && !isRecord) {
                            isRecord = true;
                            startY = tempY;
                        }
                        
                        if (state!=REFRESHING && isRecord ) {
                            
                            offsetY = tempY - startY;
                            
                            float currentHeight = (-headViewHeight+offsetY/3);
                            
                            float currentProgress = 1+currentHeight/headViewHeight;
                            
                            if (currentProgress>=1) {
                                currentProgress = 1;
                            }
                            
                            if (state == RELEASE_TO_REFRESH && isRecord) {

                                setSelection(0);
                                
                                if (-headViewHeight+offsetY/RATIO<0) {
                                    
                                    state = PULL_TO_REFRESH;
                                    
                                    changeHeaderByState(state);
                                    
                                }else if (offsetY<=0) {
                                    
                                    state = DONE;
                                    stopAnim();
                                    
                                    changeHeaderByState(state);
                                }
                            }
                            
                            if (state == PULL_TO_REFRESH && isRecord) {
                                setSelection(0);
                                
                                if (-headViewHeight+offsetY/RATIO>=0) {
                                    
                                    state = RELEASE_TO_REFRESH;
                                    
                                    changeHeaderByState(state);
                                    
                                }else if (offsetY<=0) {
                                    
                                    state = DONE;
                                    
                                    changeHeaderByState(state);
                                }
                            }
                            
                            if (state == DONE && isRecord) {
                                
                                if (offsetY>=0) {
                                    
                                    state = PULL_TO_REFRESH;
                                    changeHeaderByState(state);
                                }
                            }
                            
                            if (state == PULL_TO_REFRESH) {
                                
                                headView.setPadding(0,(int)(-headViewHeight+offsetY/RATIO) ,0,0);
                            }
                            
                            if (state == RELEASE_TO_REFRESH) {
                                
                                headView.setPadding(0,(int)(-headViewHeight+offsetY/RATIO) ,0, 0);
                            }
                        }
                        break;
                    
                    case MotionEvent.ACTION_UP:
                        
                        if (state == PULL_TO_REFRESH) {
                            
                            this.smoothScrollBy((int)(-headViewHeight+offsetY/RATIO)+headViewHeight, 500);
                            
                            changeHeaderByState(state);
                        }
                        
                        if (state == RELEASE_TO_REFRESH) {
                            
                            this.smoothScrollBy((int)(-headViewHeight+offsetY/RATIO), 500);
                            
                            state = REFRESHING;
                            
                            mOnRefreshListener.onRefresh();
                            
                            changeHeaderByState(state);
                        }
                        
                        isRecord = false;
                        break;
                }

            }
        }
        return super.onTouchEvent(ev);
    }

    /**
     * 根据状态改变headerView的动画和文字显示
     * @param state
     */
    private void changeHeaderByState(int state){
        switch (state) {
            case DONE:
                
                headView.setPadding(0, -headViewHeight, 0, 0);
                startAnim();
                break;
            case RELEASE_TO_REFRESH:
                break;
            case PULL_TO_REFRESH:
                startAnim();
                break;
            case REFRESHING:
                break;
            default:
                break;
        }
    }

    /**
     * 测量View
     * @param child
     */
    private void measureView(View child) {
        ViewGroup.LayoutParams p = child.getLayoutParams();
        if (p == null) {
            p = new ViewGroup.LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT,
                    ViewGroup.LayoutParams.WRAP_CONTENT);
        }
        int childWidthSpec = ViewGroup.getChildMeasureSpec(0, 0 + 0, p.width);
        int lpHeight = p.height;
        int childHeightSpec;
        if (lpHeight > 0) {
            childHeightSpec = MeasureSpec.makeMeasureSpec(lpHeight,
                    MeasureSpec.EXACTLY);
        } else {
            childHeightSpec = MeasureSpec.makeMeasureSpec(0,
                    MeasureSpec.UNSPECIFIED);
        }
        child.measure(childWidthSpec, childHeightSpec);
    }

    /**
     * 开启动画
     */
    public void startAnim(){
        ivBack1.startAnimation(backAnimation1);
        ivBack2.startAnimation(backAnimation2);
        ivSun.startAnimation(sunAnimation);
        ivWheel1.startAnimation(wheelAnimation);
        ivWheel2.startAnimation(wheelAnimation);
    }

    /**
     * 关闭动画
     */
    public void stopAnim(){
        ivBack1.clearAnimation();
        ivBack2.clearAnimation();
        ivSun.clearAnimation();
        ivWheel1.clearAnimation();
        ivWheel2.clearAnimation();
    }
}

好了，自定义下拉刷新动画我们就实现了，其实很简单，所有的下拉刷新动画都类似这样实现的。源码我已经上传到Github上了：
github.com/Hankkin/Bai…
求star啊。有不合理的地方还希望大家多多指正，共同进步哈。

avatar
文章
阅读
粉丝