devbox
Cpp五条
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

【Android界面实现】ZListView，一个最强大的刷新、加载、滑动删除的ListView控件（二）_can not find swipelayout in target view

作者：Cpp五条 | 2024-05-25 00:06:56

赞

踩

can not find swipelayout in target view

    转载请注明出处：http://blog.csdn.net/zhaokaiqiang1992  

    我们接着上篇的文章说，在前一篇文章中，我们学习了ZListView的使用，这一篇就开始说一些干货了，本篇文章将介绍ZListView的实现原理。

    其实说是ZListView的实现原理，不如说是ZSwipeItem的实现原理，因为ZSwipeItem才是滑动的关键所在。

    ZSwipeItem的滑动，主要是通过ViewDragHelper这个类实现的。在接触这个项目之前，我没听过，也从来碰到过这个类，ViewDragHelper是v4包中的一个帮助类，文档中是这样介绍的：

ViewDragHelper is a utility class for writing custom ViewGroups. It offers a number of useful operations and state tracking for allowing a user to drag and reposition views within their parent ViewGroup.
    看明白的吧？ViewDragHelper就是专门用来帮助自定义我们的ViewGroup的工具类，它提供了一些非常有用的方法和状态堆栈，允许用户去拖拽并且改变ViewGroup里面的View的位置，也就是重定位。这样看来，可能还不是很明确，不着急，我们根据ZSwipeItem的实现代码一点点分析这个类的用法，一会儿你就明白了。
    下面的分析过程，请大家参照着ZListView项目的源代码来看，这样好理解一些。

    ZSwipeItem继承自Framelayout,所以我们实际上是在自定义一个ViewGroup。ZSwipeItem一共有三个构造函数，但是实际上就是一个，因为最终调用的都是下面的这个构造函数

  1. public ZSwipeItem(Context context, AttributeSet attrs, int defStyle) {
  2. 		super(context, attrs, defStyle);
  3.  
  4. 		mDragHelper = ViewDragHelper.create(this, mDragHelperCallback);
  5.  
  6. 		TypedArray a = context.obtainStyledAttributes(attrs,
  7. 				R.styleable.ZSwipeItem);
  8. 		// 默认是右边缘检测
  9. 		int ordinal = a.getInt(R.styleable.ZSwipeItem_drag_edge,
  10. 				DragEdge.Right.ordinal());
  11. 		mDragEdge = DragEdge.values()[ordinal];
  12. 		// 默认模式是拉出
  13. 		ordinal = a.getInt(R.styleable.ZSwipeItem_show_mode,
  14. 				ShowMode.PullOut.ordinal());
  15. 		mShowMode = ShowMode.values()[ordinal];
  16.  
  17. 		mHorizontalSwipeOffset = a.getDimension(
  18. 				R.styleable.ZSwipeItem_horizontalSwipeOffset, 0);
  19. 		mVerticalSwipeOffset = a.getDimension(
  20. 				R.styleable.ZSwipeItem_verticalSwipeOffset, 0);
  21.  
  22. 		a.recycle();
  23. 	}

    在构造函数的第一行代码中，利用ViewDragHelper的工厂方法，创建了一个ViewDragHelper对象。注意后面的第二个参数是ViewDragHelper.Callback对象，我们需要初始化一个这个对象，然后在这里面处理对应的操作。在Callback对象里面，下面几个方法非常重要。

（1） public int clampViewPositionHorizontal(View child, int left, int dx)这个是返回被横向移动的子控件child的左坐标left，和移动距离dx，我们可以根据这些值来返回child的新的left。这个方法必须重写，要不然就不能移动了。

（2）public int clampViewPositionVertical(View child, int top, int dy) 这个和上面的方法一个意思，就是换成了垂直方向的移动和top坐标。如果有垂直移动，这个也必须重写，要不默认返回0，也不能移动了。

（3）public abstract boolean tryCaptureView(View child, int pointerId) 这个方法用来返回可以被移动的View对象，我们可以通过判断child与我们想移动的View是的相等来控制谁能移动。

（4）public int getViewVerticalDragRange(View child) 这个用来控制垂直移动的边界范围，单位是像素。

（5）public int getViewHorizontalDragRange(View child) 和上面一样，就是是横向的边界范围。

（6）public void onViewReleased(View releasedChild, float xvel, float yvel) 当releasedChild被释放的时候，xvel和yvel是x和y方向的加速度

（7）public void onViewPositionChanged(View changedView, int left, int top, int dx, int dy) 这个是当changedView的位置发生变化时调用，我们可以在这里面控制View的显示位置和移动。

    我们前面虽然获取了ViewDragHelper的对象，但是现在我们还是不能接收到事件的，我们需要在onTouch()和onInterceptTouchEvent()里面，将触摸事件传入到ViewDragHelper里面，才能进行处理，就像下面这样

  1. @Override
  2. public boolean onInterceptTouchEvent(MotionEvent ev) {
  3.  
  4. 	…
  5.  
  6. 	return mDragHelper.shouldInterceptTouchEvent(ev);
  7. }

  1. @Override
  2. public boolean onTouchEvent(MotionEvent event) {
  3. 	
  4. 	…
  5. 	mDragHelper.processTouchEvent(event);
  6. 	return true;
  7. }

    传递给ViewDragHelper之后，我们就可以在Callback的各个事件里面进行处理了。

    了解了这些之后，我们再看下面的代码，应该就能够明白什么意思了。

  1. /**
  2. 	 * 进行拖拽的主要类
  3. 	 */
  4. 	private ViewDragHelper.Callback mDragHelperCallback = new ViewDragHelper.Callback() {
  5.  
  6. 		/**
  7. 		 * 计算被横向拖动view的left
  8. 		 */
  9. 		@Override
  10. 		public int clampViewPositionHorizontal(View child, int left, int dx) {
  11. 			if (child == getSurfaceView()) {
  12. 				switch (mDragEdge) {
  13. 				case Top:
  14. 				case Bottom:
  15. 					return getPaddingLeft();
  16. 				case Left:
  17. 					if (left < getPaddingLeft())
  18. 						return getPaddingLeft();
  19. 					if (left > getPaddingLeft() + mDragDistance)
  20. 						return getPaddingLeft() + mDragDistance;
  21. 					break;
  22. 				case Right:
  23. 					if (left > getPaddingLeft())
  24. 						return getPaddingLeft();
  25. 					if (left < getPaddingLeft() - mDragDistance)
  26. 						return getPaddingLeft() - mDragDistance;
  27. 					break;
  28. 				}
  29. 			} else if (child == getBottomView()) {
  30.  
  31. 				switch (mDragEdge) {
  32. 				case Top:
  33. 				case Bottom:
  34. 					return getPaddingLeft();
  35. 				case Left:
  36. 					if (mShowMode == ShowMode.PullOut) {
  37. 						if (left > getPaddingLeft())
  38. 							return getPaddingLeft();
  39. 					}
  40. 					break;
  41. 				case Right:
  42. 					if (mShowMode == ShowMode.PullOut) {
  43. 						if (left < getMeasuredWidth() - mDragDistance) {
  44. 							return getMeasuredWidth() - mDragDistance;
  45. 						}
  46. 					}
  47. 					break;
  48. 				}
  49. 			}
  50. 			return left;
  51. 		}
  52.  
  53. 		/**
  54. 		 * 计算被纵向拖动的view的top
  55. 		 */
  56. 		@Override
  57. 		public int clampViewPositionVertical(View child, int top, int dy) {
  58. 			if (child == getSurfaceView()) {
  59. 				switch (mDragEdge) {
  60. 				case Left:
  61. 				case Right:
  62. 					return getPaddingTop();
  63. 				case Top:
  64. 					if (top < getPaddingTop())
  65. 						return getPaddingTop();
  66. 					if (top > getPaddingTop() + mDragDistance)
  67. 						return getPaddingTop() + mDragDistance;
  68. 					break;
  69. 				case Bottom:
  70. 					if (top < getPaddingTop() - mDragDistance) {
  71. 						return getPaddingTop() - mDragDistance;
  72. 					}
  73. 					if (top > getPaddingTop()) {
  74. 						return getPaddingTop();
  75. 					}
  76. 				}
  77. 			} else {
  78. 				switch (mDragEdge) {
  79. 				case Left:
  80. 				case Right:
  81. 					return getPaddingTop();
  82. 				case Top:
  83. 					if (mShowMode == ShowMode.PullOut) {
  84. 						if (top > getPaddingTop())
  85. 							return getPaddingTop();
  86. 					} else {
  87. 						if (getSurfaceView().getTop() + dy < getPaddingTop())
  88. 							return getPaddingTop();
  89. 						if (getSurfaceView().getTop() + dy > getPaddingTop()
  90. 								+ mDragDistance)
  91. 							return getPaddingTop() + mDragDistance;
  92. 					}
  93. 					break;
  94. 				case Bottom:
  95. 					if (mShowMode == ShowMode.PullOut) {
  96. 						if (top < getMeasuredHeight() - mDragDistance)
  97. 							return getMeasuredHeight() - mDragDistance;
  98. 					} else {
  99. 						if (getSurfaceView().getTop() + dy >= getPaddingTop())
  100. 							return getPaddingTop();
  101. 						if (getSurfaceView().getTop() + dy <= getPaddingTop()
  102. 								- mDragDistance)
  103. 							return getPaddingTop() - mDragDistance;
  104. 					}
  105. 				}
  106. 			}
  107. 			return top;
  108. 		}
  109.  
  110. 		/**
  111. 		 * 确定要进行拖动的view
  112. 		 */
  113. 		@Override
  114. 		public boolean tryCaptureView(View child, int pointerId) {
  115. 			return child == getSurfaceView() || child == getBottomView();
  116. 		}
  117.  
  118. 		/**
  119. 		 * 确定横向拖动边界
  120. 		 */
  121. 		@Override
  122. 		public int getViewHorizontalDragRange(View child) {
  123. 			return mDragDistance;
  124. 		}
  125.  
  126. 		/**
  127. 		 * 确定纵向拖动边界
  128. 		 */
  129. 		@Override
  130. 		public int getViewVerticalDragRange(View child) {
  131. 			return mDragDistance;
  132. 		}
  133.  
  134. 		/**
  135. 		 * 当子控件被释放的时候调用，可以获取加速度的数据，来判断用户意图
  136. 		 */
  137. 		@Override
  138. 		public void onViewReleased(View releasedChild, float xvel, float yvel) {
  139. 			super.onViewReleased(releasedChild, xvel, yvel);
  140.  
  141. 			for (SwipeListener l : swipeListeners) {
  142. 				l.onHandRelease(ZSwipeItem.this, xvel, yvel);
  143. 			}
  144.  
  145. 			if (releasedChild == getSurfaceView()) {
  146. 				processSurfaceRelease(xvel, yvel);
  147. 			} else if (releasedChild == getBottomView()) {
  148. 				if (getShowMode() == ShowMode.PullOut) {
  149. 					processBottomPullOutRelease(xvel, yvel);
  150. 				} else if (getShowMode() == ShowMode.LayDown) {
  151. 					processBottomLayDownMode(xvel, yvel);
  152. 				}
  153. 			}
  154.  
  155. 			invalidate();
  156. 		}
  157.  
  158. 		/**
  159. 		 * 当view的位置发生变化的时候调用，可以设置view的位置跟随手指移动
  160. 		 */
  161. 		@Override
  162. 		public void onViewPositionChanged(View changedView, int left, int top,
  163. 				int dx, int dy) {
  164.  
  165. 			int evLeft = getSurfaceView().getLeft();
  166. 			int evTop = getSurfaceView().getTop();
  167.  
  168. 			if (changedView == getSurfaceView()) {
  169.  
  170. 				if (mShowMode == ShowMode.PullOut) {
  171. 					if (mDragEdge == DragEdge.Left
  172. 							|| mDragEdge == DragEdge.Right) {
  173. 						getBottomView().offsetLeftAndRight(dx);
  174. 					} else {
  175. 						getBottomView().offsetTopAndBottom(dy);
  176. 					}
  177. 				}
  178.  
  179. 			} else if (changedView == getBottomView()) {
  180.  
  181. 				if (mShowMode == ShowMode.PullOut) {
  182. 					getSurfaceView().offsetLeftAndRight(dx);
  183. 					getSurfaceView().offsetTopAndBottom(dy);
  184. 				} else {
  185. 					Rect rect = computeBottomLayDown(mDragEdge);
  186. 					getBottomView().layout(rect.left, rect.top, rect.right,
  187. 							rect.bottom);
  188.  
  189. 					int newLeft = getSurfaceView().getLeft() + dx;
  190. 					int newTop = getSurfaceView().getTop() + dy;
  191.  
  192. 					if (mDragEdge == DragEdge.Left
  193. 							&& newLeft < getPaddingLeft())
  194. 						newLeft = getPaddingLeft();
  195. 					else if (mDragEdge == DragEdge.Right
  196. 							&& newLeft > getPaddingLeft())
  197. 						newLeft = getPaddingLeft();
  198. 					else if (mDragEdge == DragEdge.Top
  199. 							&& newTop < getPaddingTop())
  200. 						newTop = getPaddingTop();
  201. 					else if (mDragEdge == DragEdge.Bottom
  202. 							&& newTop > getPaddingTop())
  203. 						newTop = getPaddingTop();
  204.  
  205. 					getSurfaceView().layout(newLeft, newTop,
  206. 							newLeft + getMeasuredWidth(),
  207. 							newTop + getMeasuredHeight());
  208. 				}
  209. 			}
  210.  
  211. 			// 及时派发滑动事件
  212. 			dispatchSwipeEvent(evLeft, evTop, dx, dy);
  213.  
  214. 			invalidate();
  215. 		}
  216. 	};

    在这里面有一个变量mDragDistance，这个就是我们进行滑动的范围，这个值的初始化在onMesure()里面 

  1. @Override
  2. 	protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
  3. 		super.onMeasure(widthMeasureSpec, heightMeasureSpec);
  4. 		// 初始化移动距离
  5. 		if (mDragEdge == DragEdge.Left || mDragEdge == DragEdge.Right)
  6. 			mDragDistance = getBottomView().getMeasuredWidth()
  7. 					- dp2px(mHorizontalSwipeOffset);
  8. 		else {
  9. 			mDragDistance = getBottomView().getMeasuredHeight()
  10. 					- dp2px(mVerticalSwipeOffset);
  11. 		}
  12. 	}
    因为没必要对onMeasure()进行自定义，所以调用了父类的onMeasure()，然后，根据后面布局的宽度或者是高度，对滑动范围进行了初始化。

    getBottomView()返回的就是后面的布局ViewGroup对象，而getSurfaceView()返回的则是前面的布局ViewGroup对象。下面是获取方法，这也就解释了为什么在item的布局文件里面，必须嵌套两个ViewGroup对象了。

  1. public ViewGroup getSurfaceView() {
  2. 		return (ViewGroup) getChildAt(1);
  3. 	}
  4.  
  5. 	public ViewGroup getBottomView() {
  6. 		return (ViewGroup) getChildAt(0);
  7. 	}
    其实，在onLayout()里面也保证了必须这样做，要不然就崩掉了！ 
  1. @Override
  2. 	protected void onLayout(boolean changed, int l, int t, int r, int b) {
  3. 		int childCount = getChildCount();
  4. 		if (childCount != 2) {
  5. 			throw new IllegalStateException("You need 2  views in SwipeLayout");
  6. 		}
  7. 		if (!(getChildAt(0) instanceof ViewGroup)
  8. 				|| !(getChildAt(1) instanceof ViewGroup)) {
  9. 			throw new IllegalArgumentException(
  10. 					"The 2 children in SwipeLayout must be an instance of ViewGroup");
  11. 		}
  12.  
  13. 		if (mShowMode == ShowMode.PullOut) {
  14. 			layoutPullOut();
  15. 		} else if (mShowMode == ShowMode.LayDown) {
  16. 			layoutLayDown();
  17. 		}
  18.  
  19. 		safeBottomView();
  20.  
  21. 		if (mOnLayoutListeners != null)
  22. 			for (int i = 0; i < mOnLayoutListeners.size(); i++) {
  23. 				mOnLayoutListeners.get(i).onLayout(this);
  24. 			}
  25.  
  26. 	}

    我们再回过头来仔细看一下Callback里面的一些回调方法。

    下面的办法返回是这样的，意思就是说，前面布局和后面布局都是可以移动的。

  1. @Override
  2. 		public boolean tryCaptureView(View child, int pointerId) {
  3. 			return child == getSurfaceView() || child == getBottomView();
  4. 		}

    而在onViewPositionChange()中，如果位置发生变化的是前面的布局，并且展示方式是PullOut，那么就通过View.offsetLeftAndRight()、View.offsetTopAndBottom()来控制位置，这样，就能够实现前面布局随着手指移动的效果了！

  1. if (changedView == getSurfaceView()) {
  2.  
  3. 				if (mShowMode == ShowMode.PullOut) {
  4. 					if (mDragEdge == DragEdge.Left
  5. 							|| mDragEdge == DragEdge.Right) {
  6. 						getBottomView().offsetLeftAndRight(dx);
  7. 					} else {
  8. 						getBottomView().offsetTopAndBottom(dy);
  9. 					}
  10. 				}
  11.  
  12. 			}
    但是如果移动的View是后面的布局的话，就复杂一点了。如果是PullOut，操作是一样的。但是如果是LayDown模式，需要通过layout()来控制显示的位置，具体的计算就不详细说了。 
  1. else if (changedView == getBottomView()) {
  2.  
  3. 				if (mShowMode == ShowMode.PullOut) {
  4. 					getSurfaceView().offsetLeftAndRight(dx);
  5. 					getSurfaceView().offsetTopAndBottom(dy);
  6. 				} else {
  7. 					Rect rect = computeBottomLayDown(mDragEdge);
  8. 					getBottomView().layout(rect.left, rect.top, rect.right,
  9. 							rect.bottom);
  10.  
  11. 					int newLeft = getSurfaceView().getLeft() + dx;
  12. 					int newTop = getSurfaceView().getTop() + dy;
  13.  
  14. 					if (mDragEdge == DragEdge.Left
  15. 							&& newLeft < getPaddingLeft())
  16. 						newLeft = getPaddingLeft();
  17. 					else if (mDragEdge == DragEdge.Right
  18. 							&& newLeft > getPaddingLeft())
  19. 						newLeft = getPaddingLeft();
  20. 					else if (mDragEdge == DragEdge.Top
  21. 							&& newTop < getPaddingTop())
  22. 						newTop = getPaddingTop();
  23. 					else if (mDragEdge == DragEdge.Bottom
  24. 							&& newTop > getPaddingTop())
  25. 						newTop = getPaddingTop();
  26.  
  27. 					getSurfaceView().layout(newLeft, newTop,
  28. 							newLeft + getMeasuredWidth(),
  29. 							newTop + getMeasuredHeight());
  30. 				}
  31. 			}
    在这个方法的最后，调用了dispatchSwipeEvent()， dispatchSwipeEvent()有两个重载的方法，第一个方法根据滑动边缘方向和移动距离，来判断是否是想要打开，然后就调用了另外一个dispatchSwipeEvent()，代码如下所示。

    在这个方法里面，完成了对swipeListener的各种方法的调用。这里大家可能有个疑问啊，其实每一个item并不是只有一个SwipeListener的，而是两个，一个是我们自己添加的，另外一个是在适配器中，自动添加的，因此这里我们需要遍历取得每一个SwipeListener，然后进行调用。之前的BUG也是因为这个地方出现了问题。

  1. 	protected void dispatchSwipeEvent(int surfaceLeft, int surfaceTop,
  2. 			boolean open) {
  3.  
  4. 		safeBottomView();
  5. 		Status status = getOpenStatus();
  6.  
  7. 		if (!swipeListeners.isEmpty()) {
  8.  
  9. 			mEventCounter++;
  10.  
  11. 			if (mEventCounter == 1) {
  12. 				if (open) {
  13. 					swipeListeners.get(0).onStartOpen(ZSwipeItem.this);
  14. 					swipeListeners.get(swipeListeners.size() - 1).onStartOpen(
  15. 							ZSwipeItem.this);
  16. 				} else {
  17. 					swipeListeners.get(0).onStartClose(ZSwipeItem.this);
  18. 					swipeListeners.get(swipeListeners.size() - 1).onStartClose(
  19. 							ZSwipeItem.this);
  20. 				}
  21. 			}
  22.  
  23. 			for (SwipeListener l : swipeListeners) {
  24. 				l.onUpdate(ZSwipeItem.this, surfaceLeft - getPaddingLeft(),
  25. 						surfaceTop - getPaddingTop());
  26. 			}
  27.  
  28. 			if (status == Status.Close) {
  29. 				swipeListeners.get(0).onClose(ZSwipeItem.this);
  30. 				swipeListeners.get(swipeListeners.size() - 1).onClose(
  31. 						ZSwipeItem.this);
  32. 				mEventCounter = 0;
  33. 			} else if (status == Status.Open) {
  34. 				getBottomView().setEnabled(true);
  35. 				swipeListeners.get(0).onOpen(ZSwipeItem.this);
  36. 				swipeListeners.get(swipeListeners.size() - 1).onOpen(
  37. 						ZSwipeItem.this);
  38. 				mEventCounter = 0;
  39. 			}
  40. 		}
  41. 	}

    分析了上面这些之后，我们明白了为什么手指在item上滑动的时候，前面布局为什么能跟随手指移动了，下面我们分析为什么放手之后，前面布局能够很优雅的会弹回去。
    如果要了解这个的实现原理，那么我们就需要分析onViewReleased()。这个方法就是在用户的手指离开屏幕的时候触发的，下面是ZSwipeItem中的代码实现 

  1. /**
  2. 		 * 当子控件被释放的时候调用，可以获取加速度的数据，来判断用户意图
  3. 		 */
  4. 		@Override
  5. 		public void onViewReleased(View releasedChild, float xvel, float yvel) {
  6. 			super.onViewReleased(releasedChild, xvel, yvel);
  7.  
  8. 			for (SwipeListener l : swipeListeners) {
  9. 				l.onHandRelease(ZSwipeItem.this, xvel, yvel);
  10. 			}
  11.  
  12. 			if (releasedChild == getSurfaceView()) {
  13. 				processSurfaceRelease(xvel, yvel);
  14. 			} else if (releasedChild == getBottomView()) {
  15. 				if (getShowMode() == ShowMode.PullOut) {
  16. 					processBottomPullOutRelease(xvel, yvel);
  17. 				} else if (getShowMode() == ShowMode.LayDown) {
  18. 					processBottomLayDownMode(xvel, yvel);
  19. 				}
  20. 			}
  21.  
  22. 			invalidate();
  23. 		}
    在这里面，首先调用了SwipeListener的onHandRelease()，然后根据用户所触摸的布局的不同，分配给了其他的方法，我们以processSurfaceRelease(xvel, yvel)为例，说明到底做了什么。代码如下： 
  1. /**
  2. 	 * 执行前布局的释放过程
  3. 	 * 
  4. 	 * @param xvel
  5. 	 * @param yvel
  6. 	 */
  7. 	private void processSurfaceRelease(float xvel, float yvel) {
  8. 		if (xvel == 0 && getOpenStatus() == Status.Middle)
  9. 			close();
  10.  
  11. 		if (mDragEdge == DragEdge.Left || mDragEdge == DragEdge.Right) {
  12. 			if (xvel > 0) {
  13. 				if (mDragEdge == DragEdge.Left)
  14. 					open();
  15. 				else
  16. 					close();
  17. 			}
  18. 			if (xvel < 0) {
  19. 				if (mDragEdge == DragEdge.Left)
  20. 					close();
  21. 				else
  22. 					open();
  23. 			}
  24. 		} else {
  25. 			if (yvel > 0) {
  26. 				if (mDragEdge == DragEdge.Top)
  27. 					open();
  28. 				else
  29. 					close();
  30. 			}
  31. 			if (yvel < 0) {
  32. 				if (mDragEdge == DragEdge.Top)
  33. 					close();
  34. 				else
  35. 					open();
  36. 			}
  37. 		}
  38. 	}
    在这个方法里面，根据用户拖动方向和x或者是y加速度的大小，调用了open()和close()方法，那么我们在进入这些方法看看。 
  1. public void open() {
  2. 		open(true, true);
  3. 	}
  4.  
  5. 	public void open(boolean smooth) {
  6. 		open(smooth, true);
  7. 	}
  8.  
  9. 	public void open(boolean smooth, boolean notify) {
  10. 		ViewGroup surface = getSurfaceView(), bottom = getBottomView();
  11. 		int dx, dy;
  12. 		Rect rect = computeSurfaceLayoutArea(true);
  13. 		if (smooth) {
  14. 			mDragHelper
  15. 					.smoothSlideViewTo(getSurfaceView(), rect.left, rect.top);
  16. 		} else {
  17. 			dx = rect.left - surface.getLeft();
  18. 			dy = rect.top - surface.getTop();
  19. 			surface.layout(rect.left, rect.top, rect.right, rect.bottom);
  20. 			if (getShowMode() == ShowMode.PullOut) {
  21. 				Rect bRect = computeBottomLayoutAreaViaSurface(
  22. 						ShowMode.PullOut, rect);
  23. 				bottom.layout(bRect.left, bRect.top, bRect.right, bRect.bottom);
  24. 			}
  25. 			if (notify) {
  26. 				dispatchSwipeEvent(rect.left, rect.top, dx, dy);
  27. 			} else {
  28. 				safeBottomView();
  29. 			}
  30. 		}
  31. 		invalidate();
  32. 	}
    上面的3个open()实现了方法重载，最后调用的是最后一个。smooth代表是否是平滑移动的，如果是的话，就调用了ViewDragHelper.smoothSlideViewTo()。其实在ViewDragHelper里面有一个Scroller，这个方法就是通过Scroller类来实现的，但是只这样写还不行，我们还需要重写computeScroll(),然后用下面的代码，让滚动一直持续下去，否则View是不会滚动起来的。如果不是smooth的话，就直接layout()，把View的位置定位过去了。 
  1. 	@Override
  2. 	public void computeScroll() {
  3. 		super.computeScroll();
  4. 		// 让滚动一直进行下去
  5. 		if (mDragHelper.continueSettling(true)) {
  6. 			ViewCompat.postInvalidateOnAnimation(this);
  7. 		}
  8. 	}

    如果我们只做好这些，那么SwipeItem的侧滑功能已经差不多了，但是会有一个问题，因为我们重写了onTouch()和onInterceptTouchEvent()，所以如果我们给ListView设置onItemClickListener,是没有反应的，也就是说item的点击事件被我们破坏了！

    怎么办呢？我们可以通过GestureDetector，来模拟item的点击事件，这也就是为什么在ZSwipeItem中需要存在一个手势监听器了。

  1. private GestureDetector gestureDetector = new GestureDetector(getContext(),
  2. 			new SwipeDetector());
  3.  
  4. 	/**
  5. 	 * 手势监听器，通过调用performItemClick、performItemLongClick，来解决item的点击问题，
  6. 	 * 
  7. 	 * @class: com.socks.zlistview.SwipeDetector
  8. 	 * @author zhaokaiqiang
  9. 	 * @date 2015-1-7 下午3:44:09
  10. 	 * 
  11. 	 */
  12. 	private class SwipeDetector extends GestureDetector.SimpleOnGestureListener {
  13. 		@Override
  14. 		public boolean onDown(MotionEvent e) {
  15. 			return true;
  16. 		}
  17.  
  18. 		@Override
  19. 		public boolean onSingleTapUp(MotionEvent e) {
  20. 			// 当用户单击之后，手指抬起的时候调用，如果没有双击监听器，就直接调用
  21. 			performAdapterViewItemClick(e);
  22. 			return true;
  23. 		}
  24.  
  25. 		@Override
  26. 		public boolean onSingleTapConfirmed(MotionEvent e) {
  27. 			// 这个方法只有在确认用户不会发生双击事件的时候调用
  28. 			return false;
  29. 		}
  30.  
  31. 		@Override
  32. 		public void onLongPress(MotionEvent e) {
  33. 			// 长按事件
  34. 			performLongClick();
  35. 		}
  36.  
  37. 		@Override
  38. 		public boolean onDoubleTap(MotionEvent e) {
  39. 			return false;
  40. 		}
  41. 	}
    在上面的代码里面，我们通过手势监听，然后手动的去调用item的点击事件和长按事件，如果需要双击事件，也可以添加。 
  1. private void performAdapterViewItemClick(MotionEvent e) {
  2. 		ViewParent t = getParent();
  3.  
  4. 		Log.d(TAG, "performAdapterViewItemClick()");
  5.  
  6. 		while (t != null) {
  7. 			if (t instanceof AdapterView) {
  8. 				@SuppressWarnings("rawtypes")
  9. 				AdapterView view = (AdapterView) t;
  10. 				int p = view.getPositionForView(ZSwipeItem.this);
  11. 				if (p != AdapterView.INVALID_POSITION
  12. 						&& view.performItemClick(
  13. 								view.getChildAt(p
  14. 										- view.getFirstVisiblePosition()), p,
  15. 								view.getAdapter().getItemId(p)))
  16. 					return;
  17. 			} else {
  18. 				if (t instanceof View && ((View) t).performClick())
  19. 					return;
  20. 			}
  21.  
  22. 			t = t.getParent();
  23. 		}
  24. 	}
    
    其实ZSwipeItem代码里面还有好多需要介绍的东西，但是确实篇幅有限，大家还是去自己去看吧！

    下面再简单的介绍下BaseSwipeAdapter的实现。

    我们直接从getView()开始看

  1. @Override
  2. 	public final View getView(int position, View convertView, ViewGroup parent) {
  3.  
  4. 		if (convertView == null) {
  5. 			convertView = generateView(position, parent);
  6. 			initialize(convertView, position);
  7. 		} else {
  8. 			updateConvertView(convertView, position);
  9. 		}
  10. 		fillValues(position, convertView);
  11. 		return convertView;
  12.  
  13. 	}
    在这里面，我们实现了convertView的复用，减少布局初始化的消耗。initialize()是用来初始化布局的，下面是代码实现。在这里面添加了一个SwipeMemory，它是一个SwipeListener的实现类，这也就是为什么在ZSwipeItem里面不只有一个监听器了。同时，还添加了一个onLayoutListener,然后封装到一个ValueBox里面，添加了tag上。 
  1. public void initialize(View target, int position) {
  2.  
  3. 		int resId = getSwipeLayoutResourceId(position);
  4.  
  5. 		OnLayoutListener onLayoutListener = new OnLayoutListener(position);
  6. 		ZSwipeItem swipeLayout = (ZSwipeItem) target.findViewById(resId);
  7. 		if (swipeLayout == null)
  8. 			throw new IllegalStateException(
  9. 					"can not find SwipeLayout in target view");
  10.  
  11. 		SwipeMemory swipeMemory = new SwipeMemory(position);
  12. 		// 添加滑动监听器
  13. 		swipeLayout.addSwipeListener(swipeMemory);
  14. 		// 添加布局监听器
  15. 		swipeLayout.addOnLayoutListener(onLayoutListener);
  16. 		swipeLayout.setTag(resId, new ValueBox(position, swipeMemory,
  17. 				onLayoutListener));
  18.  
  19. 		mShownLayouts.add(swipeLayout);
  20.  
  21. 	}
    而在复用的问题上，则是通过下面的代码完成的，主要是更新了position属性。 
  1. public void updateConvertView(View target, int position) {
  2.  
  3. 		int resId = getSwipeLayoutResourceId(position);
  4.  
  5. 		ZSwipeItem swipeLayout = (ZSwipeItem) target.findViewById(resId);
  6. 		if (swipeLayout == null)
  7. 			throw new IllegalStateException(
  8. 					"can not find SwipeLayout in target view");
  9.  
  10. 		ValueBox valueBox = (ValueBox) swipeLayout.getTag(resId);
  11. 		valueBox.swipeMemory.setPosition(position);
  12. 		valueBox.onLayoutListener.setPosition(position);
  13. 		valueBox.position = position;
  14.  
  15. 		Log.d(TAG, "updateConvertView=" + position);
  16.  
  17. 	}
    SwipeMerory是干了什么呢？从下面的代码中，我们根据不同的模式，维护着当前打开的item的position属性。为什么维护position呢？这是因为getView()的复用会导致我们刚打开的item，如果离开当前屏幕然后再返回的话，就会恢复原状，因此我们需要自己维护这个状态。 
  1. class SwipeMemory extends SimpleSwipeListener {
  2.  
  3. 		private int position;
  4.  
  5. 		SwipeMemory(int position) {
  6. 			this.position = position;
  7. 		}
  8.  
  9. 		@Override
  10. 		public void onClose(ZSwipeItem layout) {
  11.  
  12. 			if (mode == Mode.Multiple) {
  13. 				openPositions.remove(position);
  14. 			} else {
  15. 				openPosition = INVALID_POSITION;
  16. 			}
  17. 		}
  18.  
  19. 		@Override
  20. 		public void onStartOpen(ZSwipeItem layout) {
  21.  
  22. 			if (mode == Mode.Single) {
  23. 				closeAllExcept(layout);
  24. 			}
  25. 		}
  26.  
  27. 		@Override
  28. 		public void onOpen(ZSwipeItem layout) {
  29.  
  30. 			if (mode == Mode.Multiple)
  31. 				openPositions.add(position);
  32. 			else {
  33. 				closeAllExcept(layout);
  34. 				openPosition = position;
  35. 			}
  36. 		}
  37.  
  38. 		public void setPosition(int position) {
  39. 			this.position = position;
  40. 		}
  41. 	}
    既然维护了position，我们就要用啊！在什么地方用呢？我们看下下面的代码 

  1. class OnLayoutListener implements OnSwipeLayoutListener {
  2.  
  3. 		private int position;
  4.  
  5. 		OnLayoutListener(int position) {
  6. 			this.position = position;
  7. 		}
  8.  
  9. 		public void setPosition(int position) {
  10. 			this.position = position;
  11. 		}
  12.  
  13. 		@Override
  14. 		public void onLayout(ZSwipeItem v) {
  15.  
  16. 			if (isOpen(position)) {
  17. 				v.open(false, false);
  18. 			} else {
  19. 				v.close(false, false);
  20. 			}
  21. 		}
  22.  
  23. 	}
    还记得ZSwipeItem里面的onLayout()吗？在那里面执行了onLayout的onLayout方法，因此，当我们的item被滑动的时候，就会不断的调用这个onLayout方法，我们判断当前打开的position，然后恢复现场即可！

    说了这么多，不知道大家有没有学到新的东西，看SwipeLayout的源码看了三天，我才搞懂了这么些东西，感觉很有收获，所以想分享给大家，如果你有什么疑问或者是建议，请留言或者是私信。

    写的很累，我要休息去了，拜拜～


    项目的Github地址：https://github.com/ZhaoKaiQiang/ZListVIew

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/Cpp五条/article/detail/619701
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号