1 仓库信息
https://github.com/yanzhenjie/SwipeRecyclerView
2 布局层级分析
定义了一个继承RecyclerView的子类SwipeRecyclerView。在该类中重写了onInterceptTouchEvent方法。其中ItemView为SwipeMenuLayout继承FrameLayout。itemView的布局如下：
<?xml version="1.0" encoding="utf-8"?>
<com.yanzhenjie.recyclerview.SwipeMenuLayout
xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:app="http://schemas.android.com/apk/res-auto"
android:layout_width="match_parent"
android:layout_height="wrap_content"
app:contentViewId="@+id/swipe_content"
app:leftViewId="@+id/swipe_left"
app:rightViewId="@+id/swipe_right">
<com.yanzhenjie.recyclerview.SwipeMenuView
android:id="@+id/swipe_left"
android:layout_width="wrap_content"
android:layout_height="match_parent"/>
<FrameLayout
android:id="@+id/swipe_content"
android:layout_width="match_parent"
android:layout_height="wrap_content"/>
<com.yanzhenjie.recyclerview.SwipeMenuView
android:id="@+id/swipe_right"
android:layout_width="wrap_content"
android:layout_height="match_parent"/>
</com.yanzhenjie.recyclerview.SwipeMenuLayout>
AdapterWrapper的onCreateViewHolder中，将child添加到swipe_content view中。
public RecyclerView.ViewHolder onCreateViewHolder(@NonNull ViewGroup parent, int viewType) {
View contentView = mHeaderViews.get(viewType);
if (contentView != null) {
return new ViewHolder(contentView);
}
contentView = mFootViews.get(viewType);
if (contentView != null) {
return new ViewHolder(contentView);
}
final RecyclerView.ViewHolder viewHolder = mAdapter.onCreateViewHolder(parent, viewType);
...
contentView = mInflater.inflate(R.layout.x_recycler_view_item, parent, false);
ViewGroup viewGroup = contentView.findViewById(R.id.swipe_content);
viewGroup.addView(viewHolder.itemView);
try {
Field itemView = getSupperClass(viewHolder.getClass()).getDeclaredField("itemView");
if (!itemView.isAccessible()) itemView.setAccessible(true);
itemView.set(viewHolder, contentView);
} catch (Exception ignored) {
}
return viewHolder;
}
swipe_content view的child的布局如下：
<?xml version="1.0" encoding="utf-8"?>
<LinearLayout
xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:tools="http://schemas.android.com/tools"
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:background="?selectableItemBackground"
android:gravity="center_vertical"
android:minHeight="@dimen/dp_70"
android:padding="@dimen/dp_10">
<TextView
android:id="@+id/tv_title"
android:layout_width="match_parent"
android:layout_height="wrap_content"
tools:text="Testing"/>
</LinearLayout>
3 事件处理
假设在列表中手指向左下方划动，划动的轨迹是一个理想的线段，且该线段与x轴的夹角< 45度，则线段上任意两点的横向位移dx > dy。通过ViewConfiguration分别得到引起滚动的最小偏移量touchSlop（假如是24px）、使View Fling的maxmumFlingVelocity（24000 pixels per second）和minimumFlingVelocity(150 pexels per second)。
SwipeRecyclerView.java
public boolean onInterceptTouchEvent(MotionEvent e) {
boolean isIntercepted = super.onInterceptTouchEvent(e);
if (allowSwipeDelete || mSwipeMenuCreator == null) {
return isIntercepted;
} else {
if (e.getPointerCount() > 1) return true;
int action = e.getAction();
// 1 获取MotinEvent对应的坐标(x, y)。该坐标是相对自身左上角顶点的坐标。
int x = (int)e.getX();
int y = (int)e.getY();
// 2 根据坐标(x, y)确定对应的position、ViewHolder、ItemView。
int touchPosition = getChildAdapterPosition(findChildViewUnder(x, y));
ViewHolder touchVH = findViewHolderForAdapterPosition(touchPosition);
SwipeMenuLayout touchView = null;
if (touchVH != null) {
View itemView = getSwipeMenuView(touchVH.itemView);
if (itemView instanceof SwipeMenuLayout) {
touchView = (SwipeMenuLayout)itemView;
}
}
boolean touchMenuEnable = mSwipeItemMenuEnable && !mDisableSwipeItemMenuList.contains(touchPosition);
if (touchView != null) {
touchView.setSwipeEnable(touchMenuEnable);
}
if (!touchMenuEnable) return isIntercepted;
switch (action) {
case MotionEvent.ACTION_DOWN: {
// 3 Down事件赋值第一个触点的坐标(mDownX, mDownY)。
mDownX = x;
mDownY = y;
isIntercepted = false;
// 4 如果上一次发生的触摸事件，且上一次的postion和这一次的position不相等；且上一次position的
// itemView打开了菜单，那么关闭这个菜单，然后清除上一次触摸事件的记录。且对应的方法的返回值为true
// 拦截该DOWN事件。
if (touchPosition != mOldTouchedPosition
&& mOldSwipedLayout != null
&& mOldSwipedLayout.isMenuOpen()) {
mOldSwipedLayout.smoothCloseMenu();
isIntercepted = true;
}
// 5 如果这次触摸事件是第一次，或者上一次触摸事件处理中没有打开菜单，那么记录这次触摸事件。
// 通过记录mOldTouchPosition和mOldSwipedLayout即可。并且方法的返回值为false，即不拦截Down
//事件 将事件传递给childView SwipeMenuLayout。
if (isIntercepted) {
mOldSwipedLayout = null;
mOldTouchedPosition = INVALID_POSITION;
} else if (touchView != null) {
mOldSwipedLayout = touchView;
mOldTouchedPosition = touchPosition;
}
break;
}
// They are sensitive to retain sliding and inertia.
case MotionEvent.ACTION_MOVE: {
// 6 调用handleUnDown方法，参数isIntercepted为false。如果横向的位移和纵向的位移小于
// 可引起滚动的偏移量，则方法的返回值为false，在最初的Move事件横向和纵向的位移都是小于
//touchSlop的。
isIntercepted = handleUnDown(x, y, isIntercepted);
if (mOldSwipedLayout == null) break;
ViewParent viewParent = getParent();
if (viewParent == null) break;
// 10 记录这次MotionEvent相对上次MotionEvent的横向位移。如果横向发生了位移则
// 对ViewParent设置Disallow_intercept的Flag。申请parentView不要拦截以后的事件。
int disX = mDownX - x;
// 向左滑，显示右侧菜单，或者关闭左侧菜单。
boolean showRightCloseLeft = disX > 0 &&
(mOldSwipedLayout.hasRightMenu() || mOldSwipedLayout.isLeftCompleteOpen());
// 向右滑，显示左侧菜单，或者关闭右侧菜单。
boolean showLeftCloseRight = disX < 0 &&
(mOldSwipedLayout.hasLeftMenu() || mOldSwipedLayout.isRightCompleteOpen());
Log.d(TAG, "onInterceptTouchEvent: wyj showRightCloseLeft:" + showRightCloseLeft
+ " showLeftCloseRight:" + showLeftCloseRight);
viewParent.requestDisallowInterceptTouchEvent(showRightCloseLeft || showLeftCloseRight);
}
case MotionEvent.ACTION_UP:
case MotionEvent.ACTION_CANCEL: {
isIntercepted = handleUnDown(x, y, isIntercepted);
break;
}
}
}
Log.d(TAG, "onInterceptTouchEvent: wyj isIntercepted:" + isIntercepted);
return isIntercepted;
}
private boolean handleUnDown(int x, int y, boolean defaultValue) {
Log.d(TAG, "handleUnDown: wyj defaultValue:" + defaultValue);
// 7 计算这次MotionEvent相对上次MotionEvent的横向和纵向的位移。
int disX = mDownX - x;
int disY = mDownY - y;
Log.d(TAG, "handleUnDown: wyj disX:" + disX + " disY:" + disY + " mScaleTouchSlop:" + mScaleTouchSlop);
// 8 如果横向位移大于可引起滚动的偏移量，并且横向的位移大于纵向的位移，则返回false。
// swipe
if (Math.abs(disX) > mScaleTouchSlop && Math.abs(disX) > Math.abs(disY)) {
Log.d(TAG, "handleUnDown: wyj > scaleTouchSlop and return false");
return false;
}
// 9 如果纵向的位移小于可引起滚动的偏移量，并且横向的位移也小于可引起滚动的偏移量，则方法返回false。
// click
if (Math.abs(disY) < mScaleTouchSlop && Math.abs(disX) < mScaleTouchSlop) {
Log.d(TAG, "handleUnDown: wyj < scaleTouchSlop and return false");
return false;
}
Log.d(TAG, "handleUnDown: wyj return defaultValue:" + defaultValue);
return defaultValue;
}
SwipeMenuLayout.java
public boolean onInterceptTouchEvent(MotionEvent ev) {
boolean isIntercepted = super.onInterceptTouchEvent(ev);
if (!isSwipeEnable()) {
return isIntercepted;
}
int action = ev.getAction();
switch (action) {
case MotionEvent.ACTION_DOWN: {
// 1 Down事件记录第一个触点的坐标(mDownX, mDownY)，方法的返回值为false，即不拦截
// 将Down事件传递给childView（id为swipe_content的FrameLayout）。默认情况下
// swipe_content的view是会处理Down事件。
mDownX = mLastX = (int)ev.getX();
mDownY = (int)ev.getY();
Log.d(TAG, "onInterceptTouchEvent: wyj down result false.");
return false;
}
case MotionEvent.ACTION_MOVE: {
// 2 记录这次MotionEvent相对于上一次MotionEvent的横向和纵向的位移。
// 如果横向的位移大于可引起滚动的偏移量touchSlop，并且横向的位移大会纵向的位移，则方法的返回值为
// true，表明拦截该Move事件，但是由于mFirstTouchTarget != null，仍会调用
// childView（swipe_content）的dispatchTouchEvent方法，但是会将mFirstTouchTarget置为null。
// 由于parentView SwipeRecyclerView的mFirstTouchTarget != null，则下一个Move事件仍会传到
// SwipeMenuLayout中，由于mFirstTouchTarget = null，则会调用onTouchEvent方法。
int disX = (int)(ev.getX() - mDownX);
int disY = (int)(ev.getY() - mDownY);
Log.d(TAG, "onInterceptTouchEvent: wyj disX:" + disX + " disY:" + disY
+ " mScaledTouchSlop:" + mScaledTouchSlop);
boolean result = Math.abs(disX) > mScaledTouchSlop && Math.abs(disX) > Math.abs(disY);
Log.d(TAG, "onInterceptTouchEvent: wyj move result:" + result);
return result;
}
case MotionEvent.ACTION_UP: {
boolean isClick = mSwipeCurrentHorizontal != null &&
mSwipeCurrentHorizontal.isClickOnContentView(getWidth(), ev.getX());
if (isMenuOpen() && isClick) {
smoothCloseMenu();
Log.d(TAG, "onInterceptTouchEvent: wyj up result true");
return true;
}
Log.d(TAG, "onInterceptTouchEvent: wyj up result false");
return false;
}
case MotionEvent.ACTION_CANCEL: {
if (!mScroller.isFinished()) mScroller.abortAnimation();
Log.d(TAG, "onInterceptTouchEvent: wyj cancel result false");
return false;
}
}
return isIntercepted;
}
public boolean onTouchEvent(MotionEvent ev) {
if (!isSwipeEnable()) {
return super.onTouchEvent(ev);
}
if (mVelocityTracker == null) mVelocityTracker = VelocityTracker.obtain();
mVelocityTracker.addMovement(ev);
int dx;
int dy;
int action = ev.getAction();
Log.d(TAG, "onTouchEvent: wyj ev.getAction:" + action);
switch (action) {
case MotionEvent.ACTION_DOWN: {
mLastX = (int)ev.getX();
mLastY = (int)ev.getY();
Log.d(TAG, "onTouchEvent: wyj down");
break;
}
case MotionEvent.ACTION_MOVE: {
// 3 这次MotionEvent事件onTouchEvent方法被调用说明了上次MotionEvent Move事件
// 被SwipeMenuLayout拦截且mFirstTouchTarget == null，
// 如果mDragging为false，即没有横向滚动（调用scrollBy方法）则mLastX是down事件对应的触点
// 坐标x，mLastY 为0。如果mDagging为true，即之前发生了滚动（调用了scrollBy）则
// mLastX、mLstY为上次MotionEvent的x、y坐标。
// 随着 dix 的值越来越大直到超过纵向的位移，并且超过了touchSlop则视为发起滚动的信号，
// mDragging记为true，且调用scollBy(dix, 0)。mLastX，mLastY重新赋值。调用scrollBy
// 对调用scollTo方法和computeScoll方法，会慢慢拉开隐藏的菜单，如果dx > 0 会拉开右边的菜单。
// 接下来的的move事件也是这样的处理，会使得scrollX越来越大。
int disX = (int)(mLastX - ev.getX());
int disY = (int)(mLastY - ev.getY());
Log.d(TAG, "onTouchEvent: wyj move");
Log.d(TAG, "onTouchEvent: wyj disX:" + disX + " disY:" + disY + " mScaledTouchSlop:" + mScaledTouchSlop);
if (!mDragging && Math.abs(disX) > mScaledTouchSlop && Math.abs(disX) > Math.abs(disY)) {
mDragging = true;
}
if (mDragging) {
if (mSwipeCurrentHorizontal == null || shouldResetSwipe) {
if (disX < 0) {
if (mSwipeLeftHorizontal != null) {
mSwipeCurrentHorizontal = mSwipeLeftHorizontal;
} else {
mSwipeCurrentHorizontal = mSwipeRightHorizontal;
}
} else {
if (mSwipeRightHorizontal != null) {
mSwipeCurrentHorizontal = mSwipeRightHorizontal;
} else {
mSwipeCurrentHorizontal = mSwipeLeftHorizontal;
}
}
}
Log.d(TAG, "onTouchEvent: wyj scrollBy");
scrollBy(disX, 0);
mLastX = (int)ev.getX();
mLastY = (int)ev.getY();
shouldResetSwipe = false;
}
break;
}
case MotionEvent.ACTION_UP: {
// 4 松手，通过VelocityTracker 获取当前横向的速度，假如是左滑，那么是< 0 的，
// 如果速率 > minimumFlingVelocity，则完全打开菜单。通过OverScroller#startScroll打开。
// 调用scroll执行动画，会调用computeScoll方法。
dx = (int)(mDownX - ev.getX());
dy = (int)(mDownY - ev.getY());
mDragging = false;
mVelocityTracker.computeCurrentVelocity(1000, mScaledMaximumFlingVelocity);
int velocityX = (int)mVelocityTracker.getXVelocity();
int velocity = Math.abs(velocityX);
if (velocity > mScaledMinimumFlingVelocity) {
if (mSwipeCurrentHorizontal != null) {
int duration = getSwipeDuration(ev, velocity);
if (mSwipeCurrentHorizontal instanceof RightHorizontal) {
if (velocityX < 0) {
// 5 velocityX < 0 ，左划，则打开菜单；否则右划，关闭菜单。
//
smoothOpenMenu(duration);
} else {
smoothCloseMenu(duration);
}
} else {
if (velocityX > 0) {
smoothOpenMenu(duration);
} else {
smoothCloseMenu(duration);
}
}
ViewCompat.postInvalidateOnAnimation(this);
}
} else {
judgeOpenClose(dx, dy);
}
mVelocityTracker.clear();
mVelocityTracker.recycle();
mVelocityTracker = null;
if (Math.abs(mDownX - ev.getX()) > mScaledTouchSlop ||
Math.abs(mDownY - ev.getY()) > mScaledTouchSlop || isLeftMenuOpen() || isRightMenuOpen()) {
ev.setAction(MotionEvent.ACTION_CANCEL);
super.onTouchEvent(ev);
return true;
}
Log.d(TAG, "onTouchEvent: wyj up");
break;
}
case MotionEvent.ACTION_CANCEL: {
mDragging = false;
if (!mScroller.isFinished()) {
mScroller.abortAnimation();
} else {
dx = (int)(mDownX - ev.getX());
dy = (int)(mDownY - ev.getY());
judgeOpenClose(dx, dy);
}
Log.d(TAG, "onTouchEvent: wyj cancel");
break;
}
}
boolean result = super.onTouchEvent(ev);
Log.d(TAG, "onTouchEvent: wyj result:" + result);
return result;
}
@Override
public void scrollTo(int x, int y) {
Log.d(TAG, "scrollTo: wyj x:" + x + " y:" + y);
if (mSwipeCurrentHorizontal == null) {
super.scrollTo(x, y);
} else {
Horizontal.Checker checker = mSwipeCurrentHorizontal.checkXY(x, y);
shouldResetSwipe = checker.shouldResetSwipe;
if (checker.x != getScrollX()) {
super.scrollTo(checker.x, checker.y);
}
}
}
public void computeScroll() {
// 6 判断是否执行了scroll的动画。在调用OverScroll#startScroll方法的时候，且动画未完成，则返回
// false。
boolean isOffset = mScroller.computeScrollOffset();
int currX = mScroller.getCurrX();
Log.d(TAG, "computeScroll: wyj isOffset:" + isOffset + " currX:" + currX);
if (isOffset && mSwipeCurrentHorizontal != null) {
if (mSwipeCurrentHorizontal instanceof RightHorizontal) {
scrollTo(Math.abs(mScroller.getCurrX()), 0);
invalidate();
} else {
scrollTo(-Math.abs(mScroller.getCurrX()), 0);
invalidate();
}
}
}
总结：
SwipeRecyclerView重写onInterceptTouchEvent方法，SwipeMenuLayout重写onInterceptTouchEvent、onTouchEvent、scrollTo、computeScroll方法。
(1) SwipeRecyclerView不拦截Down事件，将Down事件传递给SwipeMenuLayout，记录第一个触点的坐标(mDownX, mDownY)。
(2) SwipeMenuLayout不拦截Down事件，记录第一个触点的坐标(mDownX, mDownY)。并初始化mLastX = mDownX。
(3) SwipeRecyclerView处理Move事件；计算这次触点和第一个触点的位移，如果有横向的位移，则获取parentView并设置disallow_intercept_flag；如果横向的位移dx < touchSlop && dy < touchSlop，则将事件传递给SwipeMenuLaout；如果dx > touchSlop && dx > dy，将事件传递给SwipeMenuLayout；否则onInterceptTouchEvent方法的返回值取super.onInterceptTouchEvent方法的返回值。
(4) SwipeMenuLayout的onInterceptTouchEvent处理Move事件：计算这次触点和第一触点的横向和纵向的位移，如果dx > touchSlop && dx > dy，则方法的返回值为true，拦截这个事件；否则方法的返回值取super.onInterceptTouchEvent返回值。
(5) 如果上一次Move事件被SwipeMenuLayout拦截，则接下来的Move事件不会传递给child view，SwipeMenuLayout的onTouchEvent方法被调用。
(6) SwipeMenuLayout的onTouchEvent方法处理Move事件。将mLastX - ev.getX记为dx，将mLastY - ev.getY记为dy，由于mLastX = mDownX，mLastY第一次为0，则有可能dx的绝对值小于dy的绝对值，只有当dx的绝对值 > touchSlop且，dx的绝对值大于dy，才判定为发起拖动，意图打开菜单。为什么不在onInterceptTouchEvent的处理Down事件逻辑中不设置mLastY = mDownY，推断是这里不希望将打开菜单做的敏感，希望当划动轨迹与x轴的夹角比较小，或者划动轨迹的线段足够长才触发打开菜单，这里是体验上的优化。如果满足这两个场景，则判定为发起拖动意图打开菜单。字段mDraging = true，重置mLastX，mLastY，并调用scrollBy(dx, 0)。
(7) View的scrollBy，如果方法的dx > 0，则将View中的内容向左划，否则向右划。调用scrollBy之后，会调用scrollTo，computeScroll方法。
(8) 如果发起了滚动，在接下来的Move事件中，也会调用scrollBy，导致getScrollX越来越大，其绝对值逐渐接近menuView的宽度。
(9)SwipeMenuLayout的onTouchEvent方法处理UP事件。根据VelocityTracker获取当前横向的速度，如果左划，则velocityX < 0，如果右划，则velocity > 0，取横向速率和minimunFlingVelocity比较，如果横向速率大于minumumFlingVelocity，则打开菜单，通过OverScroller#startScoll执行滚动动画打开菜单。否则调用judgeOpenClose。
(10) SwipeMenuLayout处理Up事件的judgeOpenClose方法。如果当前横向滚动的偏移量scollX的绝对值 < 菜单宽度的1/2，则隐藏菜单，通过OverScoller#startScroll隐藏菜单。如果当前横向滚动的偏移量不小于菜单宽度的1/2，判断如果菜单时开的状态则关，如果菜单时关的状态则开。
(11) OverScroller#startScroll方法执行滚动动画，会触发View的computeScoll方法。
2101
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
