RecyclerView源码详解(第三篇LayoutManager源码详解)

上两篇已经谈到RecyclerView布局子View的位置完全是交给LayoutManager的子类来实现,它不像ListView和GridView那样什么事情都自己处理,而把一些功能完全抽离出来交给客户端自己扩展,当然它也提供了类似ListView和GridView的布局管理器,如LinearLayoutManager线性布局,GridLayoutManager网格布局,瀑布流布局StaggeredGridLayoutManager。首先我们来看一下LayoutManager这个抽象类到底有几个抽象方法,再重写这个类的时候,我们必须实现抽象方法


generateDefaultLayoutParams() :这个方法获得子控件LayoutParams属性的时候默认调用,我们可以在这个方法里扩展一下我们自己新加的控件属性

在源码中只找到这一个抽象方法,麻痹,难道重写它的时候就只实现这个方法吗?尝试了一下果然不行,子View都不知道死哪去了
public void setLayoutManager(LayoutManager layout) {
        if (layout == mLayout) {
            return;
        }
        stopScroll();
        // TODO We should do this switch a dispatchLayout pass and animate children. There is a good
        // chance that LayoutManagers will re-use views.
        if (mLayout != null) {
            // end all running animations
            if (mItemAnimator != null) {
                mItemAnimator.endAnimations();
            }
            mLayout.removeAndRecycleAllViews(mRecycler);
            mLayout.removeAndRecycleScrapInt(mRecycler);
            mRecycler.clear();

            if (mIsAttached) {
                mLayout.dispatchDetachedFromWindow(this, mRecycler);
            }
            mLayout.setRecyclerView(null);
            mLayout = null;
        } else {
            mRecycler.clear();
        }
        // this is just a defensive measure for faulty item animators.
        mChildHelper.removeAllViewsUnfiltered();
        mLayout = layout;
        if (layout != null) {
            if (layout.mRecyclerView != null) {
                throw new IllegalArgumentException("LayoutManager " + layout +
                        " is already attached to a RecyclerView: " + layout.mRecyclerView);
            }
            mLayout.setRecyclerView(this);
            if (mIsAttached) {
                mLayout.dispatchAttachedToWindow(this);
            }
        }
        mRecycler.updateViewCacheSize();
        requestLayout();
    }

这个方法是为RecyclerView设置LayoutManager的,在最后一行惊喜的发现 requestLayout(),这是什么,每次设置了LayoutManager之后就会执行View树的重绘,想到重绘的三部曲不就是onMeasure、onLayout、onDraw吗,ok先看一下RecycleView的onMeasure方法
 
  
 
  
@Override
	protected void onMeasure(int widthSpec, int heightSpec) {
		// 正在测量的时候数据通知改变
		if (mAdapterUpdateDuringMeasure) {
			eatRequestLayout();
			processAdapterUpdatesAndSetAnimationFlags();
			/**
			 * 如果设置了动画的话mState.mInPreLayout为true
			 */
			if (mState.mRunPredictiveAnimations) {
				// TODO: try to provide a better approach.
				// When RV decides to run predictive animations, we need to
				// measure in pre-layout
				// state so that pre-layout pass results in correct layout.
				// On the other hand, this will prevent the layout manager from
				// resizing properly.
				mState.mInPreLayout = true;
			} else {
				// consume remaining updates to provide a consistent state with
				// the layout pass.
				mAdapterHelper.consumeUpdatesInOnePass();
				mState.mInPreLayout = false;
			}
			mAdapterUpdateDuringMeasure = false;
			resumeRequestLayout(false);
		}

		if (mAdapter != null) {
			// 为状态添加子View的数量
			mState.mItemCount = mAdapter.getItemCount();
		} else {
			mState.mItemCount = 0;
		}
		// 假如布局文件为空,那么采用默认测量
		if (mLayout == null) {
			defaultOnMeasure(widthSpec, heightSpec);
		} else {
			// 否则用布局文件测量
			mLayout.onMeasure(mRecycler, mState, widthSpec, heightSpec);
		}

		mState.mInPreLayout = false; // clear
	}

在方法的最后可以看到,如果mLayout 不为null,就会用mLayout.onMeasure 方法进行测量,如果没有,调用默认的方法测量,也就是我们可以重写LayoutManager的
onMeasure方法进行测量子view(不过这时还没有调用CreateHodler所以没有子View,所以一般此方法不用重写),那么接下来就是RecyclerView的onLayout方法了
 
  
@Override
	protected void onLayout(boolean changed, int l, int t, int r, int b) {
		eatRequestLayout();
		// TraceView的速度测量
		TraceCompat.beginSection(TRACE_ON_LAYOUT_TAG);
		dispatchLayout();
		TraceCompat.endSection();
		resumeRequestLayout(false);
		// 第一次布局完成时
		mFirstLayoutComplete = true;
	}

这个方法较为简洁,都是调用的其他方法,布局的调用方法是在dispatchLayout方法中
 
  
void dispatchLayout() {
		// 没有adapter和mLayout直接返回
		if (mAdapter == null) {
			Log.e(TAG, "No adapter attached; skipping layout");
			return;
		}
		if (mLayout == null) {
			Log.e(TAG, "No layout manager attached; skipping layout");
			return;
		}
		// 储存动画信息的类

		mViewInfoStore.clear();
		eatRequestLayout();
		// 布局和滚动的累加器
		onEnterLayoutOrScroll();
		// 设置一些必要的参数
		processAdapterUpdatesAndSetAnimationFlags();
		mState.mTrackOldChangeHolders = mState.mRunSimpleAnimations
				&& mItemsChanged;
		mItemsAddedOrRemoved = mItemsChanged = false;
		// 如果有动画的话mInPreLayout为true
		mState.mInPreLayout = mState.mRunPredictiveAnimations;
		mState.mItemCount = mAdapter.getItemCount();
		findMinMaxChildLayoutPositions(mMinMaxLayoutPositions);
		mState.mItemCount = mAdapter.getItemCount();
		//省略若干行….

		// Step 2: Run layout
		mState.mInPreLayout = false;
		mLayout.onLayoutChildren(mRecycler, mState);
//省略若干行…..
	}
 
  

dispatchLayout方法代码量相当的多,所以省略了一些itemView动画参数的判断和处理,也省略了滚动到那个位置的参数清空处理等,很明显,最后的代码调用了LayoutManager的onLayoutChildren方法进行子View的位置排版,由于onMeasure的时候子View还不存在,所以测量和布局都会交给onLayoutChildren来处理,下面以LinearLayoutManager方法为例


public void onLayoutChildren(RecyclerView.Recycler recycler,
			RecyclerView.State state) {
		省略若干行代码….
		if (mPendingSavedState != null || mPendingScrollPosition != NO_POSITION) {
			if (state.getItemCount() == 0) {
//移除所有的子View
				removeAndRecycleAllViews(recycler);
				return;
			}
		}
		省略若干行代码….
		mAnchorInfo.reset();
		mAnchorInfo.mLayoutFromEnd = mShouldReverseLayout ^ mStackFromEnd;
		// calculate anchor position and coordinate
		// 得到锚点
		updateAnchorInfoForLayout(recycler, state, mAnchorInfo);
		
		int startOffset;
		int endOffset;
		onAnchorReady(recycler, state, mAnchorInfo);
		//回收所有的子View进scrapView
		detachAndScrapAttachedViews(recycler);
		mLayoutState.mIsPreLayout = state.isPreLayout();
		if (mAnchorInfo.mLayoutFromEnd) {
			// fill towards start
			updateLayoutStateToFillStart(mAnchorInfo);
			mLayoutState.mExtra = extraForStart;
//填充子View
			fill(recycler, mLayoutState, state, false);
			startOffset = mLayoutState.mOffset;
			final int firstElement = mLayoutState.mCurrentPosition;
			if (mLayoutState.mAvailable > 0) {
				extraForEnd += mLayoutState.mAvailable;
			}
			// fill towards end
			updateLayoutStateToFillEnd(mAnchorInfo);
			mLayoutState.mExtra = extraForEnd;
			mLayoutState.mCurrentPosition += mLayoutState.mItemDirection;
			fill(recycler, mLayoutState, state, false);
			endOffset = mLayoutState.mOffset;

			if (mLayoutState.mAvailable > 0) {
				// end could not consume all. add more items towards start
				extraForStart = mLayoutState.mAvailable;
				updateLayoutStateToFillStart(firstElement, startOffset);
				mLayoutState.mExtra = extraForStart;
				fill(recycler, mLayoutState, state, false);
				startOffset = mLayoutState.mOffset;
			}
		} else {
			// fill towards end
			updateLayoutStateToFillEnd(mAnchorInfo);
			mLayoutState.mExtra = extraForEnd;
			fill(recycler, mLayoutState, state, false);
			endOffset = mLayoutState.mOffset;
			final int lastElement = mLayoutState.mCurrentPosition;
			if (mLayoutState.mAvailable > 0) {
				extraForStart += mLayoutState.mAvailable;
			}
			// fill towards start
			updateLayoutStateToFillStart(mAnchorInfo);
			mLayoutState.mExtra = extraForStart;
			mLayoutState.mCurrentPosition += mLayoutState.mItemDirection;
			fill(recycler, mLayoutState, state, false);
			startOffset = mLayoutState.mOffset;

			if (mLayoutState.mAvailable > 0) {
				extraForEnd = mLayoutState.mAvailable;
				// start could not consume all it should. add more items towards
				// end
				updateLayoutStateToFillEnd(lastElement, endOffset);
				mLayoutState.mExtra = extraForEnd;
				fill(recycler, mLayoutState, state, false);
				endOffset = mLayoutState.mOffset;
			}
		}
省略若干行…
		
	}


这个方法做的最主要工作就是调用detachAndScrapAttachedViews回收以前的itemView,updateAnchorInfoForLayout方法寻找锚点,也就是参考坐标,假如以屏幕上方为参考坐
标的话,那么子View就从屏幕上方开始填入RecyclerView,如果在下方则
从底部开始填充,当然RecycleView刚开始显示的时候,默认是从屏幕上面开始填充的,锚点也有可能是在屏幕任何一个位置,比如我调用scrollToPosition
方法滚动哪一个位置,那么这个子View将在下一次的Onlayout充当锚点,以它为基础向上布局,向下布局,找到锚点后就是向上或向下填充子view了,填充调用fill方法。
 
  

int fill(RecyclerView.Recycler recycler, LayoutState layoutState,
			RecyclerView.State state, boolean stopOnFocusable) {
		// max offset we should set is mFastScroll + available
		final int start = layoutState.mAvailable;
		if (layoutState.mScrollingOffset != LayoutState.SCOLLING_OFFSET_NaN) {
			// TODO ugly bug fix. should not happen
			if (layoutState.mAvailable < 0) {
				layoutState.mScrollingOffset += layoutState.mAvailable;
			}
			//回收超过边界的View
			recycleByLayoutState(recycler, layoutState);
		}
		int remainingSpace = layoutState.mAvailable + layoutState.mExtra;
		LayoutChunkResult layoutChunkResult = new LayoutChunkResult();
		while (remainingSpace > 0 && layoutState.hasMore(state)) {
			layoutChunkResult.resetInternal();
			layoutChunk(recycler, state, layoutState, layoutChunkResult);
			if (layoutChunkResult.mFinished) {
				break;
			}
			//间距累加上个子控件所占用的高度
			layoutState.mOffset += layoutChunkResult.mConsumed
					* layoutState.mLayoutDirection;
			/**
			 * Consume the available space if: * layoutChunk did not request to
			 * be ignored * OR we are laying out scrap children * OR we are not
			 * doing pre-layout
			 */
			if (!layoutChunkResult.mIgnoreConsumed
					|| mLayoutState.mScrapList != null || !state.isPreLayout()) {
				layoutState.mAvailable -= layoutChunkResult.mConsumed;
				// we keep a separate remaining space because mAvailable is
				// important for recycling
				remainingSpace -= layoutChunkResult.mConsumed;
			}

			if (layoutState.mScrollingOffset != LayoutState.SCOLLING_OFFSET_NaN) {
				layoutState.mScrollingOffset += layoutChunkResult.mConsumed;
				if (layoutState.mAvailable < 0) {
					//最后一个view离开屏幕的偏移量
					layoutState.mScrollingOffset += layoutState.mAvailable;
				}
				recycleByLayoutState(recycler, layoutState);
			}
			if (stopOnFocusable && layoutChunkResult.mFocusable) {
				break;
			}
		}
		if (DEBUG) {
			validateChildOrder();
		}
		//返回实际占用了多少距离,只显示一部分的
		return start - layoutState.mAvailable;
	}


int fill(RecyclerView.Recycler recycler, LayoutState layoutState,
			RecyclerView.State state, boolean stopOnFocusable) {
		// max offset we should set is mFastScroll + available
		final int start = layoutState.mAvailable;
		if (layoutState.mScrollingOffset != LayoutState.SCOLLING_OFFSET_NaN) {
			// TODO ugly bug fix. should not happen
			if (layoutState.mAvailable < 0) {
				layoutState.mScrollingOffset += layoutState.mAvailable;
			}
			//回收超过边界的View
			recycleByLayoutState(recycler, layoutState);
		}
		int remainingSpace = layoutState.mAvailable + layoutState.mExtra;
		LayoutChunkResult layoutChunkResult = new LayoutChunkResult();
		while (remainingSpace > 0 && layoutState.hasMore(state)) {
			layoutChunkResult.resetInternal();
			layoutChunk(recycler, state, layoutState, layoutChunkResult);
			if (layoutChunkResult.mFinished) {
				break;
			}
			//间距累加上个子控件所占用的高度
			layoutState.mOffset += layoutChunkResult.mConsumed
					* layoutState.mLayoutDirection;
			/**
			 * Consume the available space if: * layoutChunk did not request to
			 * be ignored * OR we are laying out scrap children * OR we are not
			 * doing pre-layout
			 */
			if (!layoutChunkResult.mIgnoreConsumed
					|| mLayoutState.mScrapList != null || !state.isPreLayout()) {
				layoutState.mAvailable -= layoutChunkResult.mConsumed;
				// we keep a separate remaining space because mAvailable is
				// important for recycling
				remainingSpace -= layoutChunkResult.mConsumed;
			}

			if (layoutState.mScrollingOffset != LayoutState.SCOLLING_OFFSET_NaN) {
				layoutState.mScrollingOffset += layoutChunkResult.mConsumed;
				if (layoutState.mAvailable < 0) {
					//最后一个view离开屏幕的偏移量
					layoutState.mScrollingOffset += layoutState.mAvailable;
				}
				recycleByLayoutState(recycler, layoutState);
			}
			if (stopOnFocusable && layoutChunkResult.mFocusable) {
				break;
			}
		}
		if (DEBUG) {
			validateChildOrder();
		}
		//返回实际占用了多少距离,只显示一部分的
		return start - layoutState.mAvailable;
	}

首先获得屏幕还有多少剩余空间remainingSpace可用,根据这个值不断的减去子View所占用的空间大小,当这个值小于0的时候那么,布局子View结束,如果当前所有子View满足还没有超过remainingSpace时调用layoutChunk安排下一个view的位置
 
  
 
  
void layoutChunk(RecyclerView.Recycler recycler, RecyclerView.State state,
			LayoutState layoutState, LayoutChunkResult result) {
		View view = layoutState.next(recycler);
		if (view == null) {
			if (DEBUG && layoutState.mScrapList == null) {
				throw new RuntimeException("received null view when unexpected");
			}
			// if we are laying out views in scrap, this may return null which
			// means there is
			// no more items to layout.
			result.mFinished = true;
			return;
		}
		LayoutParams params = (LayoutParams) view.getLayoutParams();
		if (layoutState.mScrapList == null) {
			if (mShouldReverseLayout == (layoutState.mLayoutDirection == LayoutState.LAYOUT_START)) {
				addView(view);
			} else {
				addView(view, 0);
			}
		} else {
			if (mShouldReverseLayout == (layoutState.mLayoutDirection == LayoutState.LAYOUT_START)) {
				addDisappearingView(view);
			} else {
				addDisappearingView(view, 0);
			}
		}
		//测量子View、
		measureChildWithMargins(view, 0, 0);
		//result.mConsumed=子View总够需要的空间
		result.mConsumed = mOrientationHelper.getDecoratedMeasurement(view);
		int left, top, right, bottom;
		if (mOrientation == VERTICAL) {
			if (isLayoutRTL()) {
				right = getWidth() - getPaddingRight();
				left = right
						- mOrientationHelper
								.getDecoratedMeasurementInOther(view);
			} else {
				left = getPaddingLeft();
				right = left
						+ mOrientationHelper
								.getDecoratedMeasurementInOther(view);
			}
			if (layoutState.mLayoutDirection == LayoutState.LAYOUT_START) {
				bottom = layoutState.mOffset;
				top = layoutState.mOffset - result.mConsumed;
			} else {
				top = layoutState.mOffset;
				bottom = layoutState.mOffset + result.mConsumed;
			}
		} else {
			top = getPaddingTop();
			//需加上分割线的距离定义top的位置
			bottom = top
					+ mOrientationHelper.getDecoratedMeasurementInOther(view);

			if (layoutState.mLayoutDirection == LayoutState.LAYOUT_START) {
				right = layoutState.mOffset;
				left = layoutState.mOffset - result.mConsumed;
			} else {
				left = layoutState.mOffset;
				right = layoutState.mOffset + result.mConsumed;
			}
		}
		// We calculate everything with View's bounding box (which includes
		// decor and margins)
		// To calculate correct layout position, we subtract margins.
		layoutDecorated(view, left + params.leftMargin, top + params.topMargin,
				right - params.rightMargin, bottom - params.bottomMargin);
		if (DEBUG) {
			Log.d(TAG, "laid out child at position " + getPosition(view)
					+ ", with l:" + (left + params.leftMargin) + ", t:"
					+ (top + params.topMargin) + ", r:"
					+ (right - params.rightMargin) + ", b:"
					+ (bottom - params.bottomMargin));
		}
		// Consume the available space if the view is not removed OR changed
		if (params.isItemRemoved() || params.isItemChanged()) {
			result.mIgnoreConsumed = true;
		}
		result.mFocusable = view.isFocusable();
	}

这个方法首先通过layoutState.next获取到下一个子View,然后通过addView将子view添加到RecyclerView中,然后通过measureChildWithMargins测量子view的大小,然后计算子
view的left、top、right、bottom,最后layoutDecorated实现子view的位置排列。那么先看一下怎么通过适配器获得子View的
 
  
View next(RecyclerView.Recycler recycler) {
			if (mScrapList != null) {
				return nextViewFromScrapList();
			}
			final View view = recycler.getViewForPosition(mCurrentPosition);
			mCurrentPosition += mItemDirection;
			return view;
		}
首先通过判断mScrapList 集合中是否有缓存有的话就用mScrapList里面的数据,这个缓存主要用于onLayout被调用多次时用的,假如第一次没有子view,那么创建的子view会
被添加到mScrapList中,第二次的时候不会创建子view,而是直接取缓存获得速度。也就是说这个缓存只在onlayout中能用到,如果没有数据,那么调用getViewForPosition
获得子view
 
  
View getViewForPosition(int position, boolean dryRun) {
			if (position < 0 || position >= mState.getItemCount()) {
				throw new IndexOutOfBoundsException("Invalid item position "
						+ position + "(" + position + "). Item count:"
						+ mState.getItemCount());
			}
			boolean fromScrap = false;
			ViewHolder holder = null;
			// 0) If there is a changed scrap, try to find from there
			if (mState.isPreLayout()) {
				holder = getChangedScrapViewForPosition(position);
				fromScrap = holder != null;
			}
			// 1) Find from scrap by position
			if (holder == null) {
				holder = getScrapViewForPosition(position, INVALID_TYPE, dryRun);
				if (holder != null) {
					if (!validateViewHolderForOffsetPosition(holder)) {
						// recycle this scrap
						if (!dryRun) {
							// we would like to recycle this but need to make
							// sure it is not used by
							// animation logic etc.
							holder.addFlags(ViewHolder.FLAG_INVALID);
							if (holder.isScrap()) {
								removeDetachedView(holder.itemView, false);
								holder.unScrap();
							} else if (holder.wasReturnedFromScrap()) {
								holder.clearReturnedFromScrapFlag();
							}
							recycleViewHolderInternal(holder);
						}
						holder = null;
					} else {
						fromScrap = true;
					}
				}
			}

			if (holder == null) {
				final int offsetPosition = mAdapterHelper
						.findPositionOffset(position);
				if (offsetPosition < 0
						|| offsetPosition >= mAdapter.getItemCount()) {
					throw new IndexOutOfBoundsException(
							"Inconsistency detected. Invalid item "
									+ "position " + position + "(offset:"
									+ offsetPosition + ")." + "state:"
									+ mState.getItemCount());
				}

				final int type = mAdapter.getItemViewType(offsetPosition);
				// 2) Find from scrap via stable ids, if exists
				if (mAdapter.hasStableIds()) {
					holder = getScrapViewForId(
							mAdapter.getItemId(offsetPosition), type, dryRun);
					if (holder != null) {
						// update position
						holder.mPosition = offsetPosition;
						fromScrap = true;
					}
				}
				if (holder == null && mViewCacheExtension != null) {
					// We are NOT sending the offsetPosition because
					// LayoutManager does not
					// know it.
					final View view = mViewCacheExtension
							.getViewForPositionAndType(this, position, type);
					if (view != null) {
						holder = getChildViewHolder(view);
						if (holder == null) {
							throw new IllegalArgumentException(
									"getViewForPositionAndType returned"
											+ " a view which does not have a ViewHolder");
						} else if (holder.shouldIgnore()) {
							throw new IllegalArgumentException(
									"getViewForPositionAndType returned"
											+ " a view that is ignored. You must call stopIgnoring before"
											+ " returning this view.");
						}
					}
				}
				if (holder == null) { // fallback to recycler
					// try recycler.
					// Head to the shared pool.
					if (DEBUG) {
						Log.d(TAG, "getViewForPosition(" + position
								+ ") fetching from shared " + "pool");
					}
					holder = getRecycledViewPool().getRecycledView(type);
					if (holder != null) {
						holder.resetInternal();
						if (FORCE_INVALIDATE_DISPLAY_LIST) {
							invalidateDisplayListInt(holder);
						}
					}
				}
				if (holder == null) {
					holder = mAdapter.createViewHolder(RecyclerView.this, type);
					if (DEBUG) {
						Log.d(TAG, "getViewForPosition created new ViewHolder");
					}
				}
			}

			// This is very ugly but the only place we can grab this information
			// before the View is rebound and returned to the LayoutManager for
			// post layout ops.
			// We don't need this in pre-layout since the VH is not updated by
			// the LM.
			if (fromScrap
					&& !mState.isPreLayout()
					&& holder
							.hasAnyOfTheFlags(ViewHolder.FLAG_BOUNCED_FROM_HIDDEN_LIST)) {
				holder.setFlags(0, ViewHolder.FLAG_BOUNCED_FROM_HIDDEN_LIST);
				if (mState.mRunSimpleAnimations) {
					int changeFlags = ItemAnimator
							.buildAdapterChangeFlagsForAnimations(holder);
					changeFlags |= ItemAnimator.FLAG_APPEARED_IN_PRE_LAYOUT;
					final ItemHolderInfo info = mItemAnimator
							.recordPreLayoutInformation(mState, holder,
									changeFlags, holder.getUnmodifiedPayloads());
					recordAnimationInfoIfBouncedHiddenView(holder, info);
				}
			}

			boolean bound = false;
			if (mState.isPreLayout() && holder.isBound()) {
				// do not update unless we absolutely have to.
				holder.mPreLayoutPosition = position;
			} else if (!holder.isBound() || holder.needsUpdate()
					|| holder.isInvalid()) {
				if (DEBUG && holder.isRemoved()) {
					throw new IllegalStateException(
							"Removed holder should be bound and it should"
									+ " come here only in pre-layout. Holder: "
									+ holder);
				}
				final int offsetPosition = mAdapterHelper
						.findPositionOffset(position);
				holder.mOwnerRecyclerView = RecyclerView.this;
				mAdapter.bindViewHolder(holder, offsetPosition);
				attachAccessibilityDelegate(holder.itemView);
				bound = true;
				if (mState.isPreLayout()) {
					holder.mPreLayoutPosition = position;
				}
			}

			final ViewGroup.LayoutParams lp = holder.itemView.getLayoutParams();
			final LayoutParams rvLayoutParams;
			if (lp == null) {
				rvLayoutParams = (LayoutParams) generateDefaultLayoutParams();
				holder.itemView.setLayoutParams(rvLayoutParams);
			} else if (!checkLayoutParams(lp)) {
				rvLayoutParams = (LayoutParams) generateLayoutParams(lp);
				holder.itemView.setLayoutParams(rvLayoutParams);
			} else {
				rvLayoutParams = (LayoutParams) lp;
			}
			rvLayoutParams.mViewHolder = holder;
			rvLayoutParams.mPendingInvalidate = fromScrap && bound;
			return holder.itemView;
		}

 
  
这个方法的代码量很大,但主题意思不难看懂,首先从mAttachedScrap缓存集合中获取,如果有的话,如果没有的话从mViewCacheExtension集合中获取,如果还没有的话,
从RecycledViewPool缓存中获取,如果还是没有的话,那么只能通过mAdapter.createViewHolder创建了。从中可以看出RecyclerView总共用了四级缓存
mScrapList缓存:在onLayout中使用
mAttachedScrap:在滑动的时候缓存view
mViewCacheExtension:用户扩展缓存
RecycledViewPool:在滑动的时候使用,配合mAttachedScrap


看到这可以看出,如果想自定义LayoutManager的话,那么必须重写onLayoutChildren方法布局子view,还不要忘了将子view在合适的时机加入的缓存中。最后看一下在手指滑动
的时候LayoutManager需要做一些什么操作,那么进入RecyclerView的onTouchEvent里看一下
 
  
 
  
public boolean onTouchEvent(MotionEvent e) {
		final boolean canScrollHorizontally = mLayout.canScrollHorizontally();
		final boolean canScrollVertically = mLayout.canScrollVertically();
省略若干行…..
		switch (action) {
		case MotionEvent.ACTION_MOVE: {
			final int index = MotionEventCompat.findPointerIndex(e,
					mScrollPointerId);
			省略若干行…..
				if (scrollByInternal(canScrollHorizontally ? dx : 0,
						canScrollVertically ? dy : 0, vtev)) {
					getParent().requestDisallowInterceptTouchEvent(true);
				} {
					省略若干行…..
			}
			省略若干行…..
			break;
		case MotionEvent.ACTION_UP: {
		省略若干行…..
			if (!((xvel != 0 || yvel != 0) && fling((int) xvel, (int) yvel))) {
				setScrollState(SCROLL_STATE_IDLE);
			}
			resetTouch();
		}
			break;
		}
		省略若干行…..
		return true;
	}

这个方法代码将多,这里只留最主要的代码,可以看出这里回调了mLayout.canScrollHorizontally()和mLayout.canScrollVertically(),也就是说在重写LayoutManager的方法
时,如果我们想左右滑动就将canScrollHorizontally的返回值设为true,同理想垂直滑动的话canScrollVertically必须也得返回true。如果满足一些列条件的话
滑动最后将交给scrollByInternal方法处理,手指抬起时如果认为是快速滑动的话,那么会调用fling方法进行移动,那么先看一下scrollByInternal方法
 
  
boolean scrollByInternal(int x, int y, MotionEvent ev) {
		int unconsumedX = 0, unconsumedY = 0;
		int consumedX = 0, consumedY = 0;

		consumePendingUpdateOperations();
		if (mAdapter != null) {
			eatRequestLayout();
			onEnterLayoutOrScroll();
			TraceCompat.beginSection(TRACE_SCROLL_TAG);
			if (x != 0) {
				consumedX = mLayout.scrollHorizontallyBy(x, mRecycler, mState);
				unconsumedX = x - consumedX;
			}
			if (y != 0) {
				consumedY = mLayout.scrollVerticallyBy(y, mRecycler, mState);
				unconsumedY = y - consumedY;
			}
			TraceCompat.endSection();
			repositionShadowingViews();
			onExitLayoutOrScroll();
			resumeRequestLayout(false);
		}
		if (!mItemDecorations.isEmpty()) {
			invalidate();
		}

		if (dispatchNestedScroll(consumedX, consumedY, unconsumedX,
				unconsumedY, mScrollOffset)) {
			// Update the last touch co-ords, taking any scroll offset into
			// account
			mLastTouchX -= mScrollOffset[0];
			mLastTouchY -= mScrollOffset[1];
			if (ev != null) {
				ev.offsetLocation(mScrollOffset[0], mScrollOffset[1]);
			}
			mNestedOffsets[0] += mScrollOffset[0];
			mNestedOffsets[1] += mScrollOffset[1];
		} else if (ViewCompat.getOverScrollMode(this) != ViewCompat.OVER_SCROLL_NEVER) {
			if (ev != null) {
				pullGlows(ev.getX(), unconsumedX, ev.getY(), unconsumedY);
			}
			considerReleasingGlowsOnScroll(x, y);
		}
		if (consumedX != 0 || consumedY != 0) {
			dispatchOnScrolled(consumedX, consumedY);
		}
		if (!awakenScrollBars()) {
			invalidate();
		}
		return consumedX != 0 || consumedY != 0;
	}

这个方法最终调用了如果是水平滑动的话调用mLayout.scrollHorizontallyBy(x, mRecycler, mState),如果是垂直滑动的话调用了mLayout.scrollVerticallyBy,所以最终
滑动多少距离由LayoutManager实现,那么你想实现左右滑动就重写scrollHorizontallyBy方法,如果实现垂直滑动就重写scrollVerticallyBy方法实现看下LinearLayoutManager
怎么实现的
 
  
 
  
@Override
	public int scrollVerticallyBy(int dy, RecyclerView.Recycler recycler,
			RecyclerView.State state) {
		if (mOrientation == HORIZONTAL) {
			return 0;
		}
		return scrollBy(dy, recycler, state);
	}


 
  
 
  
int scrollBy(int dy, RecyclerView.Recycler recycler,
			RecyclerView.State state) {
		if (getChildCount() == 0 || dy == 0) {
			return 0;
		}
		mLayoutState.mRecycle = true;
		ensureLayoutState();
		final int layoutDirection = dy > 0 ? LayoutState.LAYOUT_END
				: LayoutState.LAYOUT_START;
		final int absDy = Math.abs(dy);
		updateLayoutState(layoutDirection, absDy, true, state);
		final int freeScroll = mLayoutState.mScrollingOffset;
		final int consumed = freeScroll
				+ fill(recycler, mLayoutState, state, false);
		if (consumed < 0) {
			if (DEBUG) {
				Log.d(TAG, "Don't have any more elements to scroll");
			}
			return 0;
		}
		final int scrolled = absDy > consumed ? layoutDirection * consumed : dy;
	    mOrientationHelper.offsetChildren(-scrolled);
		if (DEBUG) {
			Log.d(TAG, "scroll req: " + dy + " scrolled: " + scrolled);
		}
		mLayoutState.mLastScrollDelta = scrolled;
		return scrolled;
	}

这两个方法主要做了三件事,通过updateLayoutState修正一些状态,比如锚点在哪,是否有itemView的动画等,通过fill先检查哪些子view超出边界进行回收,然后重新填充
新的子view,通过offsetChildren改变所有子view的top or bottom的值从而达到移动的效果。
 
  
 
  


你可能感兴趣的:(android高级组件原理篇)