package com.example.pullrefersh;import android.content.Context;import android.content.res.TypedArray;import android.support.v4.view.MotionEventCompat;import android.support.v4.view.ViewCompat;import android.util.AttributeSet;import android.util.TypedValue;import android.view.MotionEvent;import android.view.View;import android.view.ViewConfiguration;import android.view.ViewGroup;import android.view.animation.Animation;import android.view.animation.DecelerateInterpolator;import android.view.animation.Interpolator;import android.view.animation.Transformation;import android.widget.AbsListView;import android.widget.ImageView;import java.security.InvalidParameterException;import refresh_view.BaseRefreshView;import refresh_view.SunRefreshView;import util.Utils;public class PullToRefreshView extends ViewGroup {    private static final int DRAG_MAX_DISTANCE = 120;    private static final float DRAG_RATE = .5f;    private static final float DECELERATE_INTERPOLATION_FACTOR = 2f;    public static final int STYLE_SUN = 0;    public static final int STYLE_JET = 1;    public static final int MAX_OFFSET_ANIMATION_DURATION = 700;    private static final int INVALID_POINTER = -1;    private View mTarget;    private ImageView mRefreshView;    private Interpolator mDecelerateInterpolator;    private int mTouchSlop;    private int mTotalDragDistance;    private BaseRefreshView mBaseRefreshView;    private float mCurrentDragPercent;    private int mCurrentOffsetTop;    private boolean mRefreshing;    private int mActivePointerId;    private boolean mIsBeingDragged;    private float mInitialMotionY;    private int mFrom;    private float mFromDragPercent;    private boolean mNotify;    private OnRefreshListener mListener;    public PullToRefreshView(Context context) {        this(context, null);    }    public PullToRefreshView(Context context, AttributeSet attrs) {        super(context, attrs);        TypedArray a = context.obtainStyledAttributes(attrs, R.styleable.RefreshView);        final int type = a.getInteger(R.styleable.RefreshView_type, STYLE_SUN);        a.recycle();        mDecelerateInterpolator = new DecelerateInterpolator(DECELERATE_INTERPOLATION_FACTOR);        mTouchSlop = ViewConfiguration.get(context).getScaledTouchSlop();        mTotalDragDistance = Utils.convertDpToPixel(context, DRAG_MAX_DISTANCE);        mRefreshView = new ImageView(context);        setRefreshStyle(type);        addView(mRefreshView);        setWillNotDraw(false);//        ViewCompat.setChildrenDrawingOrderEnabled(this, true);    }    public void setRefreshStyle(int type) {        setRefreshing(false);        switch (type) {            case STYLE_SUN:                mBaseRefreshView = new SunRefreshView(getContext(), this);                break;            case STYLE_JET:                // TODO            default:                throw new InvalidParameterException("Type does not exist");        }        mRefreshView.setImageDrawable(mBaseRefreshView);    }    public int getTotalDragDistance() {        return mTotalDragDistance;    }    @Override    protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {        super.onMeasure(widthMeasureSpec, heightMeasureSpec);        ensureTarget();        if (mTarget == null)            return;        widthMeasureSpec = MeasureSpec.makeMeasureSpec(getMeasuredWidth() - getPaddingRight() - getPaddingLeft(), MeasureSpec.EXACTLY);        heightMeasureSpec = MeasureSpec.makeMeasureSpec(getMeasuredHeight() - getPaddingTop() - getPaddingBottom(), MeasureSpec.EXACTLY);        mTarget.measure(widthMeasureSpec, heightMeasureSpec);        mRefreshView.measure(widthMeasureSpec, heightMeasureSpec);    }    private void ensureTarget() {        if (mTarget != null)            return;        if (getChildCount() > 0) {            for (int i = 0; i < getChildCount(); i++) {                View child = getChildAt(i);                if (child != mRefreshView)                    mTarget = child;            }        }    }    @Override    public boolean onInterceptTouchEvent(MotionEvent ev) {        if (!isEnabled() || canChildScrollUp() || mRefreshing) {            return false;        }        final int action = MotionEventCompat.getActionMasked(ev);        switch (action) {            case MotionEvent.ACTION_DOWN:                setTargetOffsetTop(0, true);                mActivePointerId = MotionEventCompat.getPointerId(ev, 0);                mIsBeingDragged = false;                final float initialMotionY = getMotionEventY(ev, mActivePointerId);                if (initialMotionY == -1) {                    return false;                }                mInitialMotionY = initialMotionY;                break;            case MotionEvent.ACTION_MOVE:                if (mActivePointerId == INVALID_POINTER) {                    return false;                }                final float y = getMotionEventY(ev, mActivePointerId);                if (y == -1) {                    return false;                }                final float yDiff = y - mInitialMotionY;                if (yDiff > mTouchSlop && !mIsBeingDragged) {                    mIsBeingDragged = true;                }                break;            case MotionEvent.ACTION_UP:            case MotionEvent.ACTION_CANCEL:                mIsBeingDragged = false;                mActivePointerId = INVALID_POINTER;                break;            case MotionEventCompat.ACTION_POINTER_UP:                onSecondaryPointerUp(ev);                break;        }        return mIsBeingDragged;    }    @Override    public boolean onTouchEvent(MotionEvent ev) {        if (!mIsBeingDragged) {            return super.onTouchEvent(ev);        }        final int action = MotionEventCompat.getActionMasked(ev);        switch (action) {            case MotionEvent.ACTION_MOVE: {                final int pointerIndex = MotionEventCompat.findPointerIndex(ev, mActivePointerId);                if (pointerIndex < 0) {                    return false;                }                final float y = MotionEventCompat.getY(ev, pointerIndex);                final float yDiff = y - mInitialMotionY;                final float scrollTop = yDiff * DRAG_RATE;                mCurrentDragPercent = scrollTop / mTotalDragDistance;                if (mCurrentDragPercent < 0) {                    return false;                }                float boundedDragPercent = Math.min(1f, Math.abs(mCurrentDragPercent));                float extraOS = Math.abs(scrollTop) - mTotalDragDistance;                float slingshotDist = mTotalDragDistance;                float tensionSlingshotPercent = Math.max(0,                        Math.min(extraOS, slingshotDist * 2) / slingshotDist);                float tensionPercent = (float) ((tensionSlingshotPercent / 4) - Math.pow(                        (tensionSlingshotPercent / 4), 2)) * 2f;                float extraMove = (slingshotDist) * tensionPercent / 2;                int targetY = (int) ((slingshotDist * boundedDragPercent) + extraMove);                mBaseRefreshView.setPercent(mCurrentDragPercent, true);                setTargetOffsetTop(targetY - mCurrentOffsetTop, true);                break;            }            case MotionEventCompat.ACTION_POINTER_DOWN:                final int index = MotionEventCompat.getActionIndex(ev);                mActivePointerId = MotionEventCompat.getPointerId(ev, index);                break;            case MotionEventCompat.ACTION_POINTER_UP:                onSecondaryPointerUp(ev);                break;            case MotionEvent.ACTION_UP:            case MotionEvent.ACTION_CANCEL: {                if (mActivePointerId == INVALID_POINTER) {                    return false;                }                final int pointerIndex = MotionEventCompat.findPointerIndex(ev, mActivePointerId);                final float y = MotionEventCompat.getY(ev, pointerIndex);                final float overScrollTop = (y - mInitialMotionY) * DRAG_RATE;                mIsBeingDragged = false;                if (overScrollTop > mTotalDragDistance) {                    setRefreshing(true, true);                } else {                    mRefreshing = false;                    animateOffsetToStartPosition();                }                mActivePointerId = INVALID_POINTER;                return false;            }        }        return true;    }    private void animateOffsetToStartPosition() {        mFrom = mCurrentOffsetTop;        mFromDragPercent = mCurrentDragPercent;        long animationDuration = Math.abs((long) (MAX_OFFSET_ANIMATION_DURATION * mFromDragPercent));        mAnimateToStartPosition.reset();        mAnimateToStartPosition.setDuration(animationDuration);        mAnimateToStartPosition.setInterpolator(mDecelerateInterpolator);        mAnimateToStartPosition.setAnimationListener(mToStartListener);        mRefreshView.clearAnimation();        mRefreshView.startAnimation(mAnimateToStartPosition);    }    private void animateOffsetToCorrectPosition() {        mFrom = mCurrentOffsetTop;        mFromDragPercent = mCurrentDragPercent;        mAnimateToCorrectPosition.reset();        mAnimateToCorrectPosition.setDuration(MAX_OFFSET_ANIMATION_DURATION);        mAnimateToCorrectPosition.setInterpolator(mDecelerateInterpolator);        mRefreshView.clearAnimation();        mRefreshView.startAnimation(mAnimateToCorrectPosition);        if (mRefreshing) {            mBaseRefreshView.start();            if (mNotify) {                if (mListener != null) {                    mListener.onRefresh();                }            }        } else {            mBaseRefreshView.stop();            animateOffsetToStartPosition();        }        mCurrentOffsetTop = mTarget.getTop();    }    private final Animation mAnimateToStartPosition = new Animation() {        @Override        public void applyTransformation(float interpolatedTime, Transformation t) {            moveToStart(interpolatedTime);        }    };    private final Animation mAnimateToCorrectPosition = new Animation() {        @Override        public void applyTransformation(float interpolatedTime, Transformation t) {            int targetTop;            int endTarget = mTotalDragDistance;            targetTop = (mFrom + (int) ((endTarget - mFrom) * interpolatedTime));            int offset = targetTop - mTarget.getTop();            mCurrentDragPercent = mFromDragPercent - (mFromDragPercent - 1.0f) * interpolatedTime;            mBaseRefreshView.setPercent(mCurrentDragPercent, false);            setTargetOffsetTop(offset, false /* requires update */);        }    };    private void moveToStart(float interpolatedTime) {        int targetTop = mFrom - (int) (mFrom * interpolatedTime);        float targetPercent = mFromDragPercent * (1.0f - interpolatedTime);        int offset = targetTop - mTarget.getTop();        mCurrentDragPercent = targetPercent;        mBaseRefreshView.setPercent(mCurrentDragPercent, true);        setTargetOffsetTop(offset, false);    }    public void setRefreshing(boolean refreshing) {        if (mRefreshing != refreshing) {            setRefreshing(refreshing, false /* notify */);        }    }    private void setRefreshing(boolean refreshing, final boolean notify) {        if (mRefreshing != refreshing) {            mNotify = notify;            ensureTarget();            mRefreshing = refreshing;            if (mRefreshing) {                mBaseRefreshView.setPercent(1f, true);                animateOffsetToCorrectPosition();            } else {                animateOffsetToStartPosition();            }        }    }    private Animation.AnimationListener mToStartListener = new Animation.AnimationListener() {        @Override        public void onAnimationStart(Animation animation) {        }        @Override        public void onAnimationRepeat(Animation animation) {        }        @Override        public void onAnimationEnd(Animation animation) {            mBaseRefreshView.stop();            mCurrentOffsetTop = mTarget.getTop();        }    };    private void onSecondaryPointerUp(MotionEvent ev) {        final int pointerIndex = MotionEventCompat.getActionIndex(ev);        final int pointerId = MotionEventCompat.getPointerId(ev, pointerIndex);        if (pointerId == mActivePointerId) {            final int newPointerIndex = pointerIndex == 0 ? 1 : 0;            mActivePointerId = MotionEventCompat.getPointerId(ev, newPointerIndex);        }    }    private float getMotionEventY(MotionEvent ev, int activePointerId) {        final int index = MotionEventCompat.findPointerIndex(ev, activePointerId);        if (index < 0) {            return -1;        }        return MotionEventCompat.getY(ev, index);    }    private void setTargetOffsetTop(int offset, boolean requiresUpdate) {        mTarget.offsetTopAndBottom(offset);        mBaseRefreshView.offsetTopAndBottom(offset);        mCurrentOffsetTop = mTarget.getTop();        if (requiresUpdate && android.os.Build.VERSION.SDK_INT < 11) {            invalidate();        }    }    private boolean canChildScrollUp() {        if (android.os.Build.VERSION.SDK_INT < 14) {            if (mTarget instanceof AbsListView) {                final AbsListView absListView = (AbsListView) mTarget;                return absListView.getChildCount() > 0                        && (absListView.getFirstVisiblePosition() > 0 || absListView.getChildAt(0)                        .getTop() < absListView.getPaddingTop());            } else {                return mTarget.getScrollY() > 0;            }        } else {            return ViewCompat.canScrollVertically(mTarget, -1);        }    }    @Override    protected void onLayout(boolean changed, int l, int t, int r, int b) {        ensureTarget();        if (mTarget == null)            return;        int height = getMeasuredHeight();        int width = getMeasuredWidth();        int left = getPaddingLeft();        int top = getPaddingTop();        int right = getPaddingRight();        int bottom = getPaddingBottom();        mTarget.layout(left, top + mCurrentOffsetTop, left + width - right, top + height - bottom + mCurrentOffsetTop);        mRefreshView.layout(left, top, left + width - right, top + height - bottom);    }    public void setOnRefreshListener(OnRefreshListener listener) {        mListener = listener;    }    public static interface OnRefreshListener {        public void onRefresh();    }}