Java tutorial
/* * Created by LuaView. * Copyright (c) 2017, Alibaba Group. All rights reserved. * * This source code is licensed under the MIT. * For the full copyright and license information,please view the LICENSE file in the root directory of this source tree. */ package com.taobao.luaview.view.widget; import android.content.Context; import android.content.res.TypedArray; import android.os.Build; import android.os.Handler; import android.support.v4.view.MotionEventCompat; import android.support.v4.view.ViewCompat; import android.util.AttributeSet; import android.util.DisplayMetrics; import android.util.Log; import android.view.Display; import android.view.MotionEvent; import android.view.View; import android.view.ViewConfiguration; import android.view.ViewGroup; import android.view.WindowManager; import android.view.animation.Animation; import android.view.animation.Animation.AnimationListener; import android.view.animation.DecelerateInterpolator; import android.view.animation.Transformation; import android.widget.AbsListView; import android.widget.RelativeLayout; /** * Created by tuoli on 12/5/16. */ public class SuperSwipeRefreshLayout extends ViewGroup { private static final int HEADER_VIEW_HEIGHT = 50;// HeaderView height (dp) private static final float DECELERATE_INTERPOLATION_FACTOR = 2f; private static final int INVALID_POINTER = -1; private static final float DRAG_RATE = .5f; private static final int ANIMATE_TO_TRIGGER_DURATION = 200; private static final int ANIMATE_TO_START_DURATION = 200; private static final int DEFAULT_CIRCLE_TARGET = 64; // SuperSwipeRefreshLayoutViewLVViewGroup,((ViewGroup)mTarget).getChildAt(0)?view, RecyclerView,ListView,ScrollView,GridView // etc. private View mTarget; private OnPullRefreshListener mListener;// listener private boolean mRefreshing = false; private int mTouchSlop; private float mTotalDragDistance = -1; private int mMediumAnimationDuration; private int mCurrentTargetOffsetTop; private boolean mOriginalOffsetCalculated = false; private float mInitialMotionY; private boolean mIsBeingDragged; private int mActivePointerId = INVALID_POINTER; private boolean mReturningToStart; private final DecelerateInterpolator mDecelerateInterpolator; private static final int[] LAYOUT_ATTRS = new int[] { android.R.attr.enabled }; private HeadViewContainer mHeadViewContainer; protected int mFrom; protected int mOriginalOffsetTop; private Animation mScaleAnimation; // ?????pxDEFAULT_CIRCLE_TARGET private float mSpinnerFinalOffset; private boolean mNotify; private int mHeaderViewWidth;// headerView private int mHeaderViewHeight; private boolean targetScrollWithLayout = true; private int pushDistance = 0; private boolean usingDefaultHeader = true; private float density = 1.0f; /** * ???? */ private AnimationListener mRefreshListener = new AnimationListener() { @Override public void onAnimationStart(Animation animation) { } @Override public void onAnimationRepeat(Animation animation) { } @Override public void onAnimationEnd(Animation animation) { if (mRefreshing) { if (mNotify) { if (mListener != null) { Log.i("tuolidd", "onRefresh"); mListener.onRefresh(); } } } mCurrentTargetOffsetTop = mHeadViewContainer.getTop(); updateListenerCallBack(); } }; /** * */ private void updateListenerCallBack() { int distance = mCurrentTargetOffsetTop + mHeadViewContainer.getHeight(); if (mListener != null) { mListener.onPullDistance(mNotify, distance); } } public SuperSwipeRefreshLayout(Context context) { this(context, null); } @SuppressWarnings("deprecation") public SuperSwipeRefreshLayout(Context context, AttributeSet attrs) { super(context, attrs); /** * getScaledTouchSlop???????? */ mTouchSlop = ViewConfiguration.get(context).getScaledTouchSlop(); mMediumAnimationDuration = getResources().getInteger(android.R.integer.config_mediumAnimTime); setWillNotDraw(false); mDecelerateInterpolator = new DecelerateInterpolator(DECELERATE_INTERPOLATION_FACTOR); final TypedArray a = context.obtainStyledAttributes(attrs, LAYOUT_ATTRS); setEnabled(a.getBoolean(0, true)); a.recycle(); WindowManager wm = (WindowManager) context.getSystemService(Context.WINDOW_SERVICE); Display display = wm.getDefaultDisplay(); final DisplayMetrics metrics = getResources().getDisplayMetrics(); mHeaderViewWidth = (int) display.getWidth(); mHeaderViewHeight = (int) (HEADER_VIEW_HEIGHT * metrics.density); createHeaderViewContainer(); ViewCompat.setChildrenDrawingOrderEnabled(this, true); mSpinnerFinalOffset = DEFAULT_CIRCLE_TARGET * metrics.density; density = metrics.density; mTotalDragDistance = mSpinnerFinalOffset; } public void setRefreshingOffset(float offset) { mSpinnerFinalOffset = offset * density * 2; } /** * */ private void createHeaderViewContainer() { mHeadViewContainer = new HeadViewContainer(getContext()); addView(mHeadViewContainer); } /** * * * @param listener */ public void setOnRefreshListener(OnPullRefreshListener listener) { mListener = listener; } /** * Notify the widget that refresh state has changed. Do not call this when * refresh is triggered by a swipe gesture. * * @param refreshing Whether or not the view should show refresh progress. */ public void setRefreshing(boolean refreshing) { if (refreshing && mRefreshing != refreshing) { // scale and show mRefreshing = refreshing; int endTarget = (int) (mSpinnerFinalOffset + mOriginalOffsetTop); setTargetOffsetTopAndBottom(endTarget - mCurrentTargetOffsetTop, true /* requires update */); mNotify = false; startScaleUpAnimation(mRefreshListener); } else { setRefreshing(refreshing, false /* notify */); } } private void startScaleUpAnimation(AnimationListener listener) { mScaleAnimation = new Animation() { @Override public void applyTransformation(float interpolatedTime, Transformation t) { setAnimationProgress(interpolatedTime); } }; mScaleAnimation.setDuration(mMediumAnimationDuration); if (listener != null) { mHeadViewContainer.setAnimationListener(listener); } mHeadViewContainer.clearAnimation(); mHeadViewContainer.startAnimation(mScaleAnimation); } private void setAnimationProgress(float progress) { if (!usingDefaultHeader) { progress = 1; } ViewCompat.setScaleX(mHeadViewContainer, progress); ViewCompat.setScaleY(mHeadViewContainer, progress); } private void setRefreshing(boolean refreshing, final boolean notify) { if (mRefreshing != refreshing) { mNotify = notify; ensureTarget(); mRefreshing = refreshing; if (mRefreshing) { animateOffsetToCorrectPosition(mCurrentTargetOffsetTop, mRefreshListener); } else { animateOffsetToStartPosition(mCurrentTargetOffsetTop, mRefreshListener); } } } /** * ?mTarget?<br> * mTarget?ScrollView,ListView,RecyclerView */ private void ensureTarget() { if (mTarget == null) { for (int i = 0; i < getChildCount(); i++) { View child = getChildAt(i); if (!child.equals(mHeadViewContainer)) { mTarget = child; break; } } } } /** * Set the distance to trigger a sync in dips * * @param distance */ public void setDistanceToTriggerSync(int distance) { mTotalDragDistance = distance; } @Override protected void onLayout(boolean changed, int left, int top, int right, int bottom) { final int width = getMeasuredWidth(); final int height = getMeasuredHeight(); if (getChildCount() == 0) { return; } if (mTarget == null) { ensureTarget(); } if (mTarget == null) { return; } int distance = mCurrentTargetOffsetTop + mHeadViewContainer.getMeasuredHeight(); if (!targetScrollWithLayout) { // ?View?????0 distance = 0; } final View child = mTarget; final int childLeft = getPaddingLeft(); final int childTop = getPaddingTop() + distance - pushDistance;// ????distance final int childWidth = width - getPaddingLeft() - getPaddingRight(); final int childHeight = height - getPaddingTop() - getPaddingBottom(); child.layout(childLeft, childTop, childLeft + childWidth, childTop + childHeight);// View? int headViewWidth = mHeadViewContainer.getMeasuredWidth(); int headViewHeight = mHeadViewContainer.getMeasuredHeight(); mHeadViewContainer.layout((width / 2 - headViewWidth / 2), mCurrentTargetOffsetTop, (width / 2 + headViewWidth / 2), mCurrentTargetOffsetTop + headViewHeight);// ? } @Override public void onMeasure(int widthMeasureSpec, int heightMeasureSpec) { super.onMeasure(widthMeasureSpec, heightMeasureSpec); if (mTarget == null) { ensureTarget(); } if (mTarget == null) { return; } mTarget.measure( MeasureSpec.makeMeasureSpec(getMeasuredWidth() - getPaddingLeft() - getPaddingRight(), MeasureSpec.EXACTLY), MeasureSpec.makeMeasureSpec(getMeasuredHeight() - getPaddingTop() - getPaddingBottom(), MeasureSpec.EXACTLY)); mHeadViewContainer.measure(MeasureSpec.makeMeasureSpec(mHeaderViewWidth, MeasureSpec.EXACTLY), MeasureSpec.makeMeasureSpec(3 * mHeaderViewHeight, MeasureSpec.EXACTLY)); if (!mOriginalOffsetCalculated) { mOriginalOffsetCalculated = true; mCurrentTargetOffsetTop = mOriginalOffsetTop = -mHeadViewContainer.getMeasuredHeight(); updateListenerCallBack(); } } /** * View?-? * * @return */ public boolean isChildScrollToTop() { if (Build.VERSION.SDK_INT < 14) { if (((ViewGroup) mTarget).getChildAt(0) instanceof AbsListView) { final AbsListView absListView = (AbsListView) ((ViewGroup) mTarget).getChildAt(0); return !(absListView.getChildCount() > 0 && (absListView.getFirstVisiblePosition() > 0 || absListView.getChildAt(0).getTop() < absListView.getPaddingTop())); } else { return !(((ViewGroup) mTarget).getChildAt(0).getScrollY() > 0); } } else { return !ViewCompat.canScrollVertically(((ViewGroup) mTarget).getChildAt(0), -1); } } /** * ???View<br> * OnTouchEvent?<br> * ??View?<br> */ @Override public boolean onInterceptTouchEvent(MotionEvent ev) { ensureTarget(); final int action = MotionEventCompat.getActionMasked(ev); if (mReturningToStart && action == MotionEvent.ACTION_DOWN) { mReturningToStart = false; } if (!isEnabled() || mReturningToStart || mRefreshing || !isChildScrollToTop()) { // ?View???View?- // ?View?- return false; } // switch (action) { case MotionEvent.ACTION_DOWN: setTargetOffsetTopAndBottom(mOriginalOffsetTop - mHeadViewContainer.getTop(), true);// ??HeaderView?? mActivePointerId = MotionEventCompat.getPointerId(ev, 0); mIsBeingDragged = false; final float initialMotionY = getMotionEventY(ev, mActivePointerId); if (initialMotionY == -1) { return false; } mInitialMotionY = initialMotionY;// ? case MotionEvent.ACTION_MOVE: if (mActivePointerId == INVALID_POINTER) { return false; } final float y = getMotionEventY(ev, mActivePointerId); if (y == -1) { return false; } float yDiff = y - mInitialMotionY;// ? if (yDiff > mTouchSlop && !mIsBeingDragged) {// ?? mIsBeingDragged = true;// } break; case MotionEventCompat.ACTION_POINTER_UP: onSecondaryPointerUp(ev); break; case MotionEvent.ACTION_UP: case MotionEvent.ACTION_CANCEL: mIsBeingDragged = false; mActivePointerId = INVALID_POINTER; break; } return mIsBeingDragged;// ?View } private float getMotionEventY(MotionEvent ev, int activePointerId) { final int index = MotionEventCompat.findPointerIndex(ev, activePointerId); if (index < 0) { return -1; } return MotionEventCompat.getY(ev, index); } @Override public boolean onTouchEvent(MotionEvent ev) { final int action = MotionEventCompat.getActionMasked(ev); if (mReturningToStart && action == MotionEvent.ACTION_DOWN) { mReturningToStart = false; } if (!isEnabled() || mReturningToStart || !isChildScrollToTop()) { // ?View???View? return false; } return handlerPullTouchEvent(ev, action); } private boolean handlerPullTouchEvent(MotionEvent ev, int action) { switch (action) { case MotionEvent.ACTION_DOWN: mActivePointerId = MotionEventCompat.getPointerId(ev, 0); mIsBeingDragged = false; break; 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 overscrollTop = (y - mInitialMotionY) * DRAG_RATE; if (mIsBeingDragged) { float originalDragPercent = overscrollTop / mTotalDragDistance; if (originalDragPercent < 0) { return false; } float dragPercent = Math.min(1f, Math.abs(originalDragPercent)); float extraOS = Math.abs(overscrollTop) - mTotalDragDistance; float slingshotDist = mSpinnerFinalOffset; 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 = mOriginalOffsetTop + (int) ((slingshotDist * dragPercent) + extraMove); if (overscrollTop < mTotalDragDistance) { if (mListener != null) { mListener.onPullEnable(false); } } else { if (mListener != null) { mListener.onPullEnable(true); } } setTargetOffsetTopAndBottom(targetY - mCurrentTargetOffsetTop, 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 /* notify */); } else { mRefreshing = false; AnimationListener listener = null; animateOffsetToStartPosition(mCurrentTargetOffsetTop, listener); } mActivePointerId = INVALID_POINTER; return false; } } return true; } private void animateOffsetToCorrectPosition(int from, AnimationListener listener) { mFrom = from; mAnimateToCorrectPosition.reset(); mAnimateToCorrectPosition.setDuration(ANIMATE_TO_TRIGGER_DURATION); mAnimateToCorrectPosition.setInterpolator(mDecelerateInterpolator); if (listener != null) { mHeadViewContainer.setAnimationListener(listener); } mHeadViewContainer.clearAnimation(); mHeadViewContainer.startAnimation(mAnimateToCorrectPosition); } private void animateOffsetToStartPosition(int from, AnimationListener listener) { mFrom = from; mAnimateToStartPosition.reset(); mAnimateToStartPosition.setDuration(ANIMATE_TO_START_DURATION); mAnimateToStartPosition.setInterpolator(mDecelerateInterpolator); if (listener != null) { mHeadViewContainer.setAnimationListener(listener); } mHeadViewContainer.clearAnimation(); mHeadViewContainer.startAnimation(mAnimateToStartPosition); resetTargetLayoutDelay(ANIMATE_TO_START_DURATION); } /** * ?Target? * * @param delay */ public void resetTargetLayoutDelay(int delay) { new Handler().postDelayed(new Runnable() { @Override public void run() { resetTargetLayout(); } }, delay); } /** * ?Target? */ public void resetTargetLayout() { final int width = getMeasuredWidth(); final View child = mTarget; final int childLeft = getPaddingLeft(); final int childTop = getPaddingTop(); final int childWidth = child.getWidth() - getPaddingLeft() - getPaddingRight(); final int childHeight = child.getHeight() - getPaddingTop() - getPaddingBottom(); child.layout(childLeft, childTop, childLeft + childWidth, childTop + childHeight); int headViewWidth = mHeadViewContainer.getMeasuredWidth(); int headViewHeight = mHeadViewContainer.getMeasuredHeight(); mHeadViewContainer.layout((width / 2 - headViewWidth / 2), -headViewHeight, (width / 2 + headViewWidth / 2), 0);// ? } private final Animation mAnimateToCorrectPosition = new Animation() { @Override public void applyTransformation(float interpolatedTime, Transformation t) { int endTarget = (int) (mSpinnerFinalOffset - Math.abs(mOriginalOffsetTop)); int targetTop = (mFrom + (int) ((endTarget - mFrom) * interpolatedTime)); int offset = targetTop - mHeadViewContainer.getTop() - (int) mSpinnerFinalOffset / 2; setTargetOffsetTopAndBottom(offset, false /* requires update */); } @Override public void setAnimationListener(AnimationListener listener) { super.setAnimationListener(listener); } }; private void moveToStart(float interpolatedTime) { int targetTop = (mFrom + (int) ((mOriginalOffsetTop - mFrom) * interpolatedTime)); int offset = targetTop - mHeadViewContainer.getTop(); setTargetOffsetTopAndBottom(offset, false /* requires update */); } private final Animation mAnimateToStartPosition = new Animation() { @Override public void applyTransformation(float interpolatedTime, Transformation t) { moveToStart(interpolatedTime); } }; private void setTargetOffsetTopAndBottom(int offset, boolean requiresUpdate) { mHeadViewContainer.bringToFront(); mHeadViewContainer.offsetTopAndBottom(offset); mCurrentTargetOffsetTop = mHeadViewContainer.getTop(); if (requiresUpdate && Build.VERSION.SDK_INT < 11) { invalidate(); } updateListenerCallBack(); } 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 class HeadViewContainer extends RelativeLayout { private AnimationListener mAnimationListener; public HeadViewContainer(Context context) { super(context); } public void setAnimationListener(AnimationListener listener) { mAnimationListener = listener; } @Override public void onAnimationStart() { super.onAnimationStart(); if (mListener != null && mAnimationListener != null) { mAnimationListener.onAnimationStart(getAnimation()); } } @Override public void onAnimationEnd() { super.onAnimationEnd(); if (mListener != null && mAnimationListener != null) { mAnimationListener.onAnimationEnd(getAnimation()); } } } public interface OnPullRefreshListener { void onRefresh(); void onPullDistance(boolean notify, int distance); void onPullEnable(boolean enable); } }