前言: 当前市场上有很多成熟的RecyclerView分析文章,但那始终是其他人总结出来的,还得自己动手分析,才知道自己理解了有多少,当然这个也算是加深对RecyclerView对理解吧;
官方简介:A flexible view for providing a limited window into a large data set.
一种灵活的视图,在有限的窗口,展示大量的数据集;
在开始之前,为了加深理解,我们需要带着疑问进行阅读;
(1)RecyclerView是怎么加载数据的?
(2)RecyclerView是怎么将View绘制到页面上的?
(3)RecyclerView是怎么复用item的?
1.总体结构
由上图可知,RecyclerView主要由这几部分组成;那他们的关系是啥呢? 具体是如何关联的呢?且听完细细道来!
数据层面:首页RecyclerView需要将数据和view绑定起来,是通过Adapter加载ViewHolder来实现绑定数据的;
布局层面:RecyclerView的Item的布局是通过LayoutManager来进行布局的;
复用层面:LayoutManger从Recycler获取item来进行复用;
总结:
1,Adapter:将数据转化为RecyclerView可以识别的数据;
2,ViewHolder:将数据和item绑定起来;
3,LayoutManager:通过计算将Item布局到页面中;
4,Recycler:复用机制,统一管理Item,用于复用;
5,ItemDecoration:绘制item的样式;
2.具体流程:
2.1 RecyclerView 初始化流程
首先,先来看看RecyclerView 的初始化流程,先举个简单的例子;
//获取RecyclerView 控件
RecyclerView recyclerView = (RecyclerView) findViewById(R.id.recyclerview);
//创建adapter
MyAdapter adapter = new MyAdapter(list);
//创建LayoutManager
LinearLayoutManager linearLayoutManager = new LinearLayoutManager(getContext());
//设置LayoutManager
recyclerView.setLayoutManager(linearLayoutManager);
//设置Adapter
recyclerView.setAdapter(adapter);
1,我们先来看看RecyclerView 的构造方法做了啥?
public RecyclerView(@NonNull Context context, @Nullable AttributeSet attrs, int defStyle) {
super(context, attrs, defStyle);
//创建观察者
this.mObserver = new RecyclerView.RecyclerViewDataObserver();
//创建回收器
this.mRecycler = new RecyclerView.Recycler();
//创建布局信息保存类
this.mViewInfoStore = new ViewInfoStore();
this.mUpdateChildViewsRunnable = new Runnable() {
public void run() {
if (RecyclerView.this.mFirstLayoutComplete && !RecyclerView.this.isLayoutRequested()) {
if (!RecyclerView.this.mIsAttached) {
RecyclerView.this.requestLayout();
} else if (RecyclerView.this.mLayoutFrozen) {
RecyclerView.this.mLayoutWasDefered = true;
} else {
RecyclerView.this.consumePendingUpdateOperations();
}
}
}
};
...
if (attrs != null) {
TypedArray a = context.obtainStyledAttributes(attrs, CLIP_TO_PADDING_ATTR, defStyle, 0);
this.mClipToPadding = a.getBoolean(0, true);
a.recycle();
} else {
this.mClipToPadding = true;
}
...
this.mAccessibilityManager = (AccessibilityManager)this.getContext().getSystemService("accessibility");
this.setAccessibilityDelegateCompat(new RecyclerViewAccessibilityDelegate(this));
boolean nestedScrollingEnabled = true;
if (attrs != null) {
int defStyleRes = 0;
TypedArray a = context.obtainStyledAttributes(attrs, styleable.RecyclerView, defStyle, defStyleRes);
//从布局文件获取Layoutmanger的名称
String layoutManagerName = a.getString(styleable.RecyclerView_layoutManager);
int descendantFocusability = a.getInt(styleable.RecyclerView_android_descendantFocusability, -1);
if (descendantFocusability == -1) {
this.setDescendantFocusability(262144);
}
this.mEnableFastScroller = a.getBoolean(styleable.RecyclerView_fastScrollEnabled, false);
//通过layoutManger的名称进行反射创建layoutManager,并设置给RecycleView
this.createLayoutManager(context, layoutManagerName, attrs, defStyle, defStyleRes);
...
} else {
this.setDescendantFocusability(262144);
}
//设置是否支持嵌套滚动,默认为true
this.setNestedScrollingEnabled(nestedScrollingEnabled);
}
从构造方法可以看出,里面做了一大堆初始化的操作,最主要看一下这个创建layoutManager的方法createLayoutManager();
根据布局属性进行反射来创建layoutManager;
private void createLayoutManager(Context context, String className, AttributeSet attrs, int defStyleAttr, int defStyleRes) {
if (className != null) {
className = className.trim();
if (!className.isEmpty()) {
className = this.getFullClassName(context, className);
try {
ClassLoader classLoader;
if (this.isInEditMode()) {
classLoader = this.getClass().getClassLoader();
} else {
classLoader = context.getClassLoader();
}
Class extends RecyclerView.LayoutManager> layoutManagerClass = classLoader.loadClass(className).asSubclass(RecyclerView.LayoutManager.class);
Object[] constructorArgs = null;
Constructor constructor;
try {
//通过反射创建布局构造器
constructor = layoutManagerClass.getConstructor(LAYOUT_MANAGER_CONSTRUCTOR_SIGNATURE);
constructorArgs = new Object[]{context, attrs, defStyleAttr, defStyleRes};
} catch (NoSuchMethodException var13) {
try {
constructor = layoutManagerClass.getConstructor();
} catch (NoSuchMethodException var12) {
var12.initCause(var13);
throw new IllegalStateException(attrs.getPositionDescription() + ": Error creating LayoutManager " + className, var12);
}
}
constructor.setAccessible(true);
//将创建出来的LayoutManger设置给RecycleView
this.setLayoutManager((RecyclerView.LayoutManager)constructor.newInstance(constructorArgs));
} catch (ClassNotFoundException var14) {
throw new IllegalStateException(attrs.getPositionDescription() + ": Unable to find LayoutManager " + className, var14);
} catch (InvocationTargetException var15) {
throw new IllegalStateException(attrs.getPositionDescription() + ": Could not instantiate the LayoutManager: " + className, var15);
} catch (InstantiationException var16) {
throw new IllegalStateException(attrs.getPositionDescription() + ": Could not instantiate the LayoutManager: " + className, var16);
} catch (IllegalAccessException var17) {
throw new IllegalStateException(attrs.getPositionDescription() + ": Cannot access non-public constructor " + className, var17);
} catch (ClassCastException var18) {
throw new IllegalStateException(attrs.getPositionDescription() + ": Class is not a LayoutManager " + className, var18);
}
}
}
}
再看一下setLayoutManager()这个方法里面做了啥操作?
public void setLayoutManager(@Nullable RecyclerView.LayoutManager layout) {
if (layout != this.mLayout) {
//停止当前的滚动操作
this.stopScroll();
if (this.mLayout != null) {
//判断当前的layoutManager如果为空,则将该layoutManager的状态进行初始化;
if (this.mItemAnimator != null) {
this.mItemAnimator.endAnimations();
}
this.mLayout.removeAndRecycleAllViews(this.mRecycler);
this.mLayout.removeAndRecycleScrapInt(this.mRecycler);
this.mRecycler.clear();
if (this.mIsAttached) {
this.mLayout.dispatchDetachedFromWindow(this, this.mRecycler);
}
this.mLayout.setRecyclerView((RecyclerView)null);
this.mLayout = null;
} else {
this.mRecycler.clear();
}
this.mChildHelper.removeAllViewsUnfiltered();
//将当前的layoutManager赋值给成员变量
this.mLayout = layout;
if (layout != null) {
if (layout.mRecyclerView != null) {
throw new IllegalArgumentException("LayoutManager " + layout + " is already attached to a RecyclerView:" + layout.mRecyclerView.exceptionLabel());
}
//将当前的RecyclerView赋值给layoutManager
this.mLayout.setRecyclerView(this);
if (this.mIsAttached) {
this.mLayout.dispatchAttachedToWindow(this);
}
}
//更新一下RecyclerView的缓存
this.mRecycler.updateViewCacheSize();
//触发重新布局
this.requestLayout();
}
}
总结:看完RecyclerView的构造方法,里面主要是做了一些初始化的操作,并创建了layoutManager设置给RecyclerView(如果布局属性有设置的话);
2,看完了RecyclerView的setLayoutManager()的流程,我们继续接着分析,看一下setAdapter()具体做了啥?
public void setAdapter(@Nullable RecyclerView.Adapter adapter) {
this.setLayoutFrozen(false);
//主要模块
this.setAdapterInternal(adapter, false, true);
this.processDataSetCompletelyChanged(false);
this.requestLayout();
}
跟进源码,我们主要分析setAdapterInternal()这个方法,让我们看看这个源码里面做了什么操作;
private void setAdapterInternal(@Nullable RecyclerView.Adapter adapter, boolean compatibleWithPrevious, boolean removeAndRecycleViews) {
if (this.mAdapter != null) {
//解注册之前的数据观察者
this.mAdapter.unregisterAdapterDataObserver(this.mObserver);
this.mAdapter.onDetachedFromRecyclerView(this);
}
if (!compatibleWithPrevious || removeAndRecycleViews) {
//进行初始化操作,初始化layoutManger,初始化mRecycler
this.removeAndRecycleViews();
}
this.mAdapterHelper.reset();
RecyclerView.Adapter oldAdapter = this.mAdapter;
//将adapter赋值给当前成员变量
this.mAdapter = adapter;
if (adapter != null) {
//adapter注册数据观察者,用于监听数据的增删改查
adapter.registerAdapterDataObserver(this.mObserver);
adapter.onAttachedToRecyclerView(this);
}
if (this.mLayout != null) {
this.mLayout.onAdapterChanged(oldAdapter, this.mAdapter);
}
this.mRecycler.onAdapterChanged(oldAdapter, this.mAdapter, compatibleWithPrevious);
this.mState.mStructureChanged = true;
}
这个方法里面主要是给adapter注册数据监听,用于数据的增删改查的刷新,并做一些初始化的操作;
我们再看一下这个观察者里面主要做了什么操作,具体的实现是在RecyclerViewDataObserver 这个类里面;
private class RecyclerViewDataObserver extends RecyclerView.AdapterDataObserver {
RecyclerViewDataObserver() {
}
public void onChanged() {
RecyclerView.this.assertNotInLayoutOrScroll((String)null);
RecyclerView.this.mState.mStructureChanged = true;
RecyclerView.this.processDataSetCompletelyChanged(true);
if (!RecyclerView.this.mAdapterHelper.hasPendingUpdates()) {
RecyclerView.this.requestLayout();
}
}
public void onItemRangeChanged(int positionStart, int itemCount, Object payload) {
RecyclerView.this.assertNotInLayoutOrScroll((String)null);
if (RecyclerView.this.mAdapterHelper.onItemRangeChanged(positionStart, itemCount, payload)) {
this.triggerUpdateProcessor();
}
}
public void onItemRangeInserted(int positionStart, int itemCount) {
RecyclerView.this.assertNotInLayoutOrScroll((String)null);
if (RecyclerView.this.mAdapterHelper.onItemRangeInserted(positionStart, itemCount)) {
this.triggerUpdateProcessor();
}
}
public void onItemRangeRemoved(int positionStart, int itemCount) {
RecyclerView.this.assertNotInLayoutOrScroll((String)null);
if (RecyclerView.this.mAdapterHelper.onItemRangeRemoved(positionStart, itemCount)) {
this.triggerUpdateProcessor();
}
}
public void onItemRangeMoved(int fromPosition, int toPosition, int itemCount) {
RecyclerView.this.assertNotInLayoutOrScroll((String)null);
if (RecyclerView.this.mAdapterHelper.onItemRangeMoved(fromPosition, toPosition, itemCount)) {
this.triggerUpdateProcessor();
}
}
void triggerUpdateProcessor() {
if (RecyclerView.POST_UPDATES_ON_ANIMATION && RecyclerView.this.mHasFixedSize && RecyclerView.this.mIsAttached) {
ViewCompat.postOnAnimation(RecyclerView.this, RecyclerView.this.mUpdateChildViewsRunnable);
} else {
RecyclerView.this.mAdapterUpdateDuringMeasure = true;
RecyclerView.this.requestLayout();
}
}
}
看到了我们很熟悉的方法,即adapter刷新数据所调用的方法;我们主要分析其中一个方法即可,让我们来看一下onItemRangeChanged()这个方法;
这里面主要分为两步:
public void onItemRangeChanged(int positionStart, int itemCount, Object payload) {
RecyclerView.this.assertNotInLayoutOrScroll((String)null);
//这里通过AdapterHelper将传进来的信息保存起来
if (RecyclerView.this.mAdapterHelper.onItemRangeChanged(positionStart, itemCount, payload)) {
//重新布局
this.triggerUpdateProcessor();
}
}
(1)通过AdapterHelper将传进来的信息保存起来;
boolean onItemRangeChanged(int positionStart, int itemCount, Object payload) {
if (itemCount < 1) {
return false;
} else {
this.mPendingUpdates.add(this.obtainUpdateOp(4, positionStart, itemCount, payload));
this.mExistingUpdateTypes |= 4;
return this.mPendingUpdates.size() == 1;
}
}
(2)通过triggerUpdateProcessor()方法触发RecyclerView重新布局;
void triggerUpdateProcessor() {
if (RecyclerView.POST_UPDATES_ON_ANIMATION && RecyclerView.this.mHasFixedSize && RecyclerView.this.mIsAttached) {
//当前有动画正在执行的时候会走这里
ViewCompat.postOnAnimation(RecyclerView.this, RecyclerView.this.mUpdateChildViewsRunnable);
} else {
//触发重新布局
RecyclerView.this.mAdapterUpdateDuringMeasure = true;
RecyclerView.this.requestLayout();
}
}
3. 工作流程
3.1 主体关系
首先我们来看一下各个模块的关系;
通过上图大体可以看出这几个模块的关系:
(1)RecyclerView通过LayoutManager来进行布局操作;
(2)LayoutManager从Recycler里面获取复用的item来进行布局;
(3)Recycler管理着ViewHolder的创建与复用;
(4)Adapter将数据和ViewHolder绑定起来,并和RecyclerView注册观察者;
(5)RecyclerView通过ItemDecoration进行item样式的绘制;
接下来通过源码来细细剖析,看看具体是怎么实现的;
那么我们接着上面分析的setAdapter()方法继续分析,在setAdapter()方法里,最后调用来requestLayout(),来触发RecyclerView 的绘制流程;
这个requestLayout()这个方法最终会调用到ViewRootImp里面的requestLayout()方法;
public void requestLayout() {
if (!mHandlingLayoutInLayoutRequest) {
checkThread();
mLayoutRequested = true;
//触发绘制流程
scheduleTraversals();
}
}
在ViewRootImp里调用requestLayout()方法进行绘制,我们主要看scheduleTraversals()方法,里面最终会调用到performTraversals()方法,源码如下;
void scheduleTraversals() {
if (!mTraversalScheduled) {
mTraversalScheduled = true;
mTraversalBarrier = mHandler.getLooper().getQueue().postSyncBarrier();
mChoreographer.postCallback(
Choreographer.CALLBACK_TRAVERSAL, mTraversalRunnable, null);
if (!mUnbufferedInputDispatch) {
scheduleConsumeBatchedInput();
}
notifyRendererOfFramePending();
pokeDrawLockIfNeeded();
}
}
...
final class TraversalRunnable implements Runnable {
@Override
public void run() {
doTraversal();
}
}
final TraversalRunnable mTraversalRunnable = new TraversalRunnable();
...
void doTraversal() {
if (mTraversalScheduled) {
mTraversalScheduled = false;
mHandler.getLooper().getQueue().removeSyncBarrier(mTraversalBarrier);
if (mProfile) {
Debug.startMethodTracing("ViewAncestor");
}
performTraversals();
if (mProfile) {
Debug.stopMethodTracing();
mProfile = false;
}
}
}
...
performTraversals()这个方法里面执行了三大步骤,测量(measure),布局(layout),绘制(draw),完成的view的工作流程,将页面绘制出来;
{
// cache mView since it is used so much below...
final View host = mView;
...
if (!mStopped || mReportNextDraw) {
//执行view的测量流程
performMeasure(childWidthMeasureSpec, childHeightMeasureSpec);
} else {
...
}
...
if (didLayout) {
//执行view的布局流程
performLayout(lp, mWidth, mHeight);
...
}
...
if (!cancelDraw && !newSurface) {
...
//执行view的绘制流程
performDraw();
} else {
...
}
}
从上面整理的方法来看,绘制流程主要是这performMeasure(),performLayout(),performDraw();最终会触发RecyclerView的onMeasure(),onLayout(),onDraw()方法,具体源码这里就不过多分析了,感兴趣的可以看一下View的绘制流程;
让我们一个个来进行分析,先看看RecyclerView的onMeasure()方法里面做了什么?
onMeasure()分析:
protected void onMeasure(int widthSpec, int heightSpec) {
if (mLayout == null) {
//1.判断当前的LayoutManger是否为空,为空则走RecyclerView默认测量的方法 ;
defaultOnMeasure(widthSpec, heightSpec);
return;
}
//2.LayoutManger开启自动测量时走这里处理逻辑;
if (mLayout.mAutoMeasure) {
final int widthMode = MeasureSpec.getMode(widthSpec);
final int heightMode = MeasureSpec.getMode(heightSpec);
final boolean skipMeasure = widthMode == MeasureSpec.EXACTLY
&& heightMode == MeasureSpec.EXACTLY;
mLayout.onMeasure(mRecycler, mState, widthSpec, heightSpec);
if (skipMeasure || mAdapter == null) {
return;
}
if (mState.mLayoutStep == State.STEP_START) {
dispatchLayoutStep1();
}
// set dimensions in 2nd step. Pre-layout should happen with old dimensions for
// consistency
mLayout.setMeasureSpecs(widthSpec, heightSpec);
mState.mIsMeasuring = true;
dispatchLayoutStep2();
// now we can get the width and height from the children.
mLayout.setMeasuredDimensionFromChildren(widthSpec, heightSpec);
// if RecyclerView has non-exact width and height and if there is at least one child
// which also has non-exact width & height, we have to re-measure.
if (mLayout.shouldMeasureTwice()) {
mLayout.setMeasureSpecs(
MeasureSpec.makeMeasureSpec(getMeasuredWidth(), MeasureSpec.EXACTLY),
MeasureSpec.makeMeasureSpec(getMeasuredHeight(), MeasureSpec.EXACTLY));
mState.mIsMeasuring = true;
dispatchLayoutStep2();
// now we can get the width and height from the children.
mLayout.setMeasuredDimensionFromChildren(widthSpec, heightSpec);
}
} else {
//3.LayoutManger没有开启自动测量时走这里处理逻辑;
if (mHasFixedSize) {
mLayout.onMeasure(mRecycler, mState, widthSpec, heightSpec);
return;
}
// custom onMeasure
if (mAdapterUpdateDuringMeasure) {
eatRequestLayout();
onEnterLayoutOrScroll();
processAdapterUpdatesAndSetAnimationFlags();
onExitLayoutOrScroll();
if (mState.mRunPredictiveAnimations) {
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) {
mState.mItemCount = mAdapter.getItemCount();
} else {
mState.mItemCount = 0;
}
eatRequestLayout();
mLayout.onMeasure(mRecycler, mState, widthSpec, heightSpec);
resumeRequestLayout(false);
mState.mInPreLayout = false; // clear
}
}
这里面主要分三种情况,而我们大部分情况都是走第三步,通过查看官方的LayoutManger的源码得知,LinearLayoutManager和StaggeredGridLayoutManager都开启了自动测试,而GridLayoutManager继承自LinearLayoutManager;所以,官方的LayoutManager都开启了自动测量,这里我们只需要关注第二步的逻辑;从上面源码可以看出,RecyclerView通过LayoutManger里的onMeasure()来进行测量操作;
通过State这个类来进行布局和测试状态的记录,这里的mLayoutStep 包括STEP_START、STEP_LAYOUT 、 STEP_ANIMATIONS三个状态;从源码分析,此时测量完毕之后,判断当前状态为开始的时候(STEP_START),调用了dispatchLayoutStep1()进行了一系列的操作,这个方法执行完了之后,会将mLayoutStep 赋值为STEP_LAYOUT;后面就执行了dispatchLayoutStep2(),在这个方法里将mLayoutStep 赋值为STEP_ANIMATIONS;
这里我们可以理解为,RecyclerView在测量完毕之后,就开始进行布局了,分别执行了dispatchLayoutStep1()和dispatchLayoutStep2()方法;到此onMeasure()分析完了;
让我们继续接着往下看,此时RecyclerView的onMeasure()已经执行完了,接下来会执行onLayout()方法,让我们看看这个方法里面做了啥?
onLayout()分析:
先看一下源码
protected void onLayout(boolean changed, int l, int t, int r, int b) {
TraceCompat.beginSection("RV OnLayout");
//执行布局操作
this.dispatchLayout();
TraceCompat.endSection();
this.mFirstLayoutComplete = true;
}
主要看dispatchLayout()这个方法
void dispatchLayout() {
if (mAdapter == null) {
Log.e(TAG, "No adapter attached; skipping layout");
// leave the state in START
return;
}
if (mLayout == null) {
Log.e(TAG, "No layout manager attached; skipping layout");
// leave the state in START
return;
}
mState.mIsMeasuring = false;
if (mState.mLayoutStep == State.STEP_START) {
dispatchLayoutStep1();
mLayout.setExactMeasureSpecsFrom(this);
dispatchLayoutStep2();
} else if (mAdapterHelper.hasUpdates() || mLayout.getWidth() != getWidth()
|| mLayout.getHeight() != getHeight()) {
// First 2 steps are done in onMeasure but looks like we have to run again due to
// changed size.
mLayout.setExactMeasureSpecsFrom(this);
dispatchLayoutStep2();
} else {
// always make sure we sync them (to ensure mode is exact)
mLayout.setExactMeasureSpecsFrom(this);
}
dispatchLayoutStep3();
}
通过上面源码可以看出,之前在onMeasure()里的这个dispatchLayoutStep2()方法里面已经把mLayoutStep 赋值为STEP_ANIMATIONS,那么这里就会走最后一个方法dispatchLayoutStep3();如果没有执行STEP_START方法,那么就会依次执行dispatchLayoutStep1(),dispatchLayoutStep2(),dispatchLayoutStep3()这几个布局方法;让我们来一个个分析;
dispatchLayoutStep1():
private void dispatchLayoutStep1() {
mState.assertLayoutStep(State.STEP_START);
mState.mIsMeasuring = false;
eatRequestLayout();
mViewInfoStore.clear();
onEnterLayoutOrScroll();
processAdapterUpdatesAndSetAnimationFlags();
saveFocusInfo();
mState.mTrackOldChangeHolders = mState.mRunSimpleAnimations && mItemsChanged;
mItemsAddedOrRemoved = mItemsChanged = false;
mState.mInPreLayout = mState.mRunPredictiveAnimations;
mState.mItemCount = mAdapter.getItemCount();
findMinMaxChildLayoutPositions(mMinMaxLayoutPositions);
if (mState.mRunSimpleAnimations) {
// Step 0: Find out where all non-removed items are, pre-layout
int count = mChildHelper.getChildCount();
for (int i = 0; i < count; ++i) {
final ViewHolder holder = getChildViewHolderInt(mChildHelper.getChildAt(i));
if (holder.shouldIgnore() || (holder.isInvalid() && !mAdapter.hasStableIds())) {
continue;
}
final ItemHolderInfo animationInfo = mItemAnimator
.recordPreLayoutInformation(mState, holder,
ItemAnimator.buildAdapterChangeFlagsForAnimations(holder),
holder.getUnmodifiedPayloads());
mViewInfoStore.addToPreLayout(holder, animationInfo);
if (mState.mTrackOldChangeHolders && holder.isUpdated() && !holder.isRemoved()
&& !holder.shouldIgnore() && !holder.isInvalid()) {
long key = getChangedHolderKey(holder);
// This is NOT the only place where a ViewHolder is added to old change holders
// list. There is another case where:
// * A VH is currently hidden but not deleted
// * The hidden item is changed in the adapter
// * Layout manager decides to layout the item in the pre-Layout pass (step1)
// When this case is detected, RV will un-hide that view and add to the old
// change holders list.
mViewInfoStore.addToOldChangeHolders(key, holder);
}
}
}
if (mState.mRunPredictiveAnimations) {
// Step 1: run prelayout: This will use the old positions of items. The layout manager
// is expected to layout everything, even removed items (though not to add removed
// items back to the container). This gives the pre-layout position of APPEARING views
// which come into existence as part of the real layout.
// Save old positions so that LayoutManager can run its mapping logic.
saveOldPositions();
final boolean didStructureChange = mState.mStructureChanged;
mState.mStructureChanged = false;
// temporarily disable flag because we are asking for previous layout
mLayout.onLayoutChildren(mRecycler, mState);
mState.mStructureChanged = didStructureChange;
for (int i = 0; i < mChildHelper.getChildCount(); ++i) {
final View child = mChildHelper.getChildAt(i);
final ViewHolder viewHolder = getChildViewHolderInt(child);
if (viewHolder.shouldIgnore()) {
continue;
}
if (!mViewInfoStore.isInPreLayout(viewHolder)) {
int flags = ItemAnimator.buildAdapterChangeFlagsForAnimations(viewHolder);
boolean wasHidden = viewHolder
.hasAnyOfTheFlags(ViewHolder.FLAG_BOUNCED_FROM_HIDDEN_LIST);
if (!wasHidden) {
flags |= ItemAnimator.FLAG_APPEARED_IN_PRE_LAYOUT;
}
final ItemHolderInfo animationInfo = mItemAnimator.recordPreLayoutInformation(
mState, viewHolder, flags, viewHolder.getUnmodifiedPayloads());
if (wasHidden) {
recordAnimationInfoIfBouncedHiddenView(viewHolder, animationInfo);
} else {
mViewInfoStore.addToAppearedInPreLayoutHolders(viewHolder, animationInfo);
}
}
}
// we don't process disappearing list because they may re-appear in post layout pass.
clearOldPositions();
} else {
clearOldPositions();
}
onExitLayoutOrScroll();
resumeRequestLayout(false);
mState.mLayoutStep = State.STEP_LAYOUT;
}
这个方法主要做了ViewHolder信息的保存,里面通过遍历当前的子View,根据子view的位置信息创建ItemHolderInfo,并添加到 ViewInfoStore这个类里面进行保存;
看一下ItemHolderInfo这个类;
public static class ItemHolderInfo {
public int left;
public int top;
public int right;
public int bottom;
public ItemHolderInfo() {
}
...
public ItemHolderInfo setFrom(@NonNull RecyclerView.ViewHolder holder,
@AdapterChanges int flags) {
final View view = holder.itemView;
this.left = view.getLeft();
this.top = view.getTop();
this.right = view.getRight();
this.bottom = view.getBottom();
return this;
}
}
class ViewInfoStore {
private static final boolean DEBUG = false;
/**
* View data records for pre-layout
*/
@VisibleForTesting
final ArrayMap mLayoutHolderMap = new ArrayMap<>();
@VisibleForTesting
final LongSparseArray mOldChangedHolders = new LongSparseArray<>();
/**
* Clears the state and all existing tracking data
*/
void clear() {
mLayoutHolderMap.clear();
mOldChangedHolders.clear();
}
/**
* Adds the item information to the prelayout tracking
* @param holder The ViewHolder whose information is being saved
* @param info The information to save
*/
void addToPreLayout(RecyclerView.ViewHolder holder, RecyclerView.ItemAnimator.ItemHolderInfo info) {
InfoRecord record = mLayoutHolderMap.get(holder);
if (record == null) {
record = InfoRecord.obtain();
mLayoutHolderMap.put(holder, record);
}
record.preInfo = info;
record.flags |= FLAG_PRE;
}
}
通过源码可以看出,在dispatchLayoutStep1()方法里会先遍历子view,并创建ItemHolderInfo,然后再通过ViewInfoStore的addToPreLayout()的这个方法将ItemHolderInfo赋值给InfoRecord,再保存到mLayoutHolderMap这个集合里面;
下面我们再来分析一下dispatchLayoutStep2()这个方法里面做来啥?
dispatchLayoutStep2():
private void dispatchLayoutStep2() {
private void dispatchLayoutStep2() {
startInterceptRequestLayout();
onEnterLayoutOrScroll();
mState.assertLayoutStep(State.STEP_LAYOUT | State.STEP_ANIMATIONS);
mAdapterHelper.consumeUpdatesInOnePass();
mState.mItemCount = mAdapter.getItemCount();
mState.mDeletedInvisibleItemCountSincePreviousLayout = 0;
// Step 2: Run layout
mState.mInPreLayout = false;
// 开始真正的去布局
mLayout.onLayoutChildren(mRecycler, mState);
mState.mStructureChanged = false;
mPendingSavedState = null;
// onLayoutChildren may have caused client code to disable item animations; re-check
mState.mRunSimpleAnimations = mState.mRunSimpleAnimations && mItemAnimator != null;
mState.mLayoutStep = State.STEP_ANIMATIONS;
onExitLayoutOrScroll();
stopInterceptRequestLayout(false);
}
}
通过上面的源码可以看出,dispatchLayoutStep2()里面就开始真正的去布局了,通过onLayoutChildre()方法进行布局,具体的实现都在LayoutManager的子类里面;我们常用的LayoutManager基本上是LinearLayoutManager,那么这里我们具体来分析一下这个类里面是怎么实现的;
先看一下源码:
public void onLayoutChildren(RecyclerView.Recycler recycler, RecyclerView.State state) {
...
final View focused = getFocusedChild();
if (!mAnchorInfo.mValid || mPendingScrollPosition != RecyclerView.NO_POSITION
|| mPendingSavedState != null) {
mAnchorInfo.reset();
// 获取布局的锚点
updateAnchorInfoForLayout(recycler, state, mAnchorInfo);
mAnchorInfo.mValid = true;
} else if (focused != null && (mOrientationHelper.getDecoratedStart(focused)
>= mOrientationHelper.getEndAfterPadding()
|| mOrientationHelper.getDecoratedEnd(focused)
<= mOrientationHelper.getStartAfterPadding())) {
...
// 更新锚点信息
mAnchorInfo.assignFromViewAndKeepVisibleRect(focused, getPosition(focused));
}
//判断是否是从后往前开始布局
if (mAnchorInfo.mLayoutFromEnd) {
...
//布局操作
fill(recycler, mLayoutState, state, false);
...
} else {
...
// fill towards end
fill(recycler, mLayoutState, state, false);
// fill towards start
fill(recycler, mLayoutState, state, false);
...
}
...
}
这里把代码简化了,我们只需要关注几个重点的方法;这里的布局操作是,通过寻找布局的锚点(mAnchorInfo),判断是从后往前布局还是从前往后布局,然后调用fill()方法进行布局;
寻找布局的锚点是通过updateAnchorInfoForLayout(recycler, state, mAnchorInfo)这个方法
private void updateAnchorInfoForLayout(RecyclerView.Recycler recycler, RecyclerView.State state,
AnchorInfo anchorInfo) {
...
if (updateAnchorFromChildren(recycler, state, anchorInfo)) {
if (DEBUG) {
Log.d(TAG, "updated anchor info from existing children");
}
return;
}
...
}
这里我们只需要关注updateAnchorFromChildren这个方法,跟进去看一下具体做了什么;
private boolean updateAnchorFromChildren(RecyclerView.Recycler recycler,
RecyclerView.State state, AnchorInfo anchorInfo) {
if (getChildCount() == 0) {
return false;
}
final View focused = getFocusedChild();
if (focused != null && anchorInfo.isViewValidAsAnchor(focused, state)) {
anchorInfo.assignFromViewAndKeepVisibleRect(focused, getPosition(focused));
return true;
}
if (mLastStackFromEnd != mStackFromEnd) {
return false;
}
View referenceChild = anchorInfo.mLayoutFromEnd
? findReferenceChildClosestToEnd(recycler, state)
: findReferenceChildClosestToStart(recycler, state);
if (referenceChild != null) {
anchorInfo.assignFromView(referenceChild, getPosition(referenceChild));
...
}
return true;
}
return false;
}
从这里的源码可以看出,先通过getFocusedChild()去获取focused 这个view,当获取到了的时候将其标记为锚点,如果获取不到那么就通过findReferenceChildClosestToEnd和findReferenceChildClosestToStart去寻找合适的view,并将其标记为锚点;
让我们回到onLayoutChildren这个方法,当获取到锚点的时候,调用fill方法开始填充页面,根据fill方法看看具体做了什么?
int fill(RecyclerView.Recycler recycler, LayoutState layoutState,
RecyclerView.State state, boolean stopOnFocusable) {
...
if (layoutState.mScrollingOffset != LayoutState.SCROLLING_OFFSET_NaN) {
//回收没有用到的view
recycleByLayoutState(recycler, layoutState);
}
...
while ((layoutState.mInfinite || remainingSpace > 0) && layoutState.hasMore(state)) {
layoutChunk(recycler, state, layoutState, layoutChunkResult);
...
}
}
这里通过recycleByLayoutState方法先将没有用到view进行回收,然后再通过while循环调用layoutChunk方法进行布局;
看一下layoutChunk方法具体做了什么操作?
void layoutChunk(RecyclerView.Recycler recycler, RecyclerView.State state,
LayoutState layoutState, LayoutChunkResult result) {
View view = layoutState.next(recycler);
...
RecyclerView.LayoutParams params = (RecyclerView.LayoutParams) view.getLayoutParams();
if (layoutState.mScrapList == null) {
if (mShouldReverseLayout == (layoutState.mLayoutDirection
== LayoutState.LAYOUT_START)) {
addView(view);
} else {
addView(view, 0);
}
} else {
...
}
...
layoutDecoratedWithMargins(view, left, top, right, bottom);
...
}
到这里就是最终布局的地方了,先通过recycler获取要布局的view,再通过addView方法将view添加到RecyclerView里去,然后根据参数调用layoutDecoratedWithMargins方法进行布局;
public void layoutDecoratedWithMargins(@NonNull View child, int left, int top, int right,
int bottom) {
final LayoutParams lp = (LayoutParams) child.getLayoutParams();
final Rect insets = lp.mDecorInsets;
child.layout(left + insets.left + lp.leftMargin, top + insets.top + lp.topMargin,
right - insets.right - lp.rightMargin,
bottom - insets.bottom - lp.bottomMargin);
}
这里最终调用了view的layout方法进行布局;到这里dispatchLayoutStep2()就分析完了,让我们继续接着看dispatchLayoutStep3()第三步里面做了啥;
dispatchLayoutStep3():
private void dispatchLayoutStep3() {
mState.assertLayoutStep(State.STEP_ANIMATIONS);
...
mState.mLayoutStep = State.STEP_START;
if (mState.mRunSimpleAnimations) {
...
for (int i = mChildHelper.getChildCount() - 1; i >= 0; i--) {
ViewHolder holder = getChildViewHolderInt(mChildHelper.getChildAt(i));
if (holder.shouldIgnore()) {
continue;
}
long key = getChangedHolderKey(holder);
final ItemHolderInfo animationInfo = mItemAnimator
.recordPostLayoutInformation(mState, holder);
ViewHolder oldChangeViewHolder = mViewInfoStore.getFromOldChangeHolders(key);
...
if (oldDisappearing && oldChangeViewHolder == holder) {
// run disappear animation instead of change
mViewInfoStore.addToPostLayout(holder, animationInfo);
} else {
...
mViewInfoStore.addToPostLayout(holder, animationInfo);
...
}
} else {
mViewInfoStore.addToPostLayout(holder, animationInfo);
}
}
// Step 4: Process view info lists and trigger animations
//触发动画
mViewInfoStore.process(mViewInfoProcessCallback);
}
...
}
这个方法里面只需要关注addToPostLayout这个方法就行,这里和第一步类似,也是通过遍历viewholder信息来创建ItemHolderInfo,并保存到mViewInfoStore里去;
看一下addToPostLayout这个方法做了啥?
void addToPostLayout(RecyclerView.ViewHolder holder, RecyclerView.ItemAnimator.ItemHolderInfo info) {
InfoRecord record = mLayoutHolderMap.get(holder);
if (record == null) {
record = InfoRecord.obtain();
mLayoutHolderMap.put(holder, record);
}
record.postInfo = info;
也是通过将ItemHolderInfo信息转化为InfoRecord类,然后保存到集合里去(mLayoutHolderMap);
到此,RecyclerView的onLayout流程就已经走完了;那么接下来就要开始分析onDraw的流程了;
onDraw()分析
先看一下源码;
public void draw(Canvas c) {
super.draw(c);
...
for (int i = 0; i < count; i++) {
mItemDecorations.get(i).onDrawOver(c, this, mState);
}
...
}
public void onDraw(Canvas c) {
super.onDraw(c);
final int count = mItemDecorations.size();
for (int i = 0; i < count; i++) {
mItemDecorations.get(i).onDraw(c, this, mState);
}
}
很简单,就几行,mItemDecorations这个集合里面存的是ItemDecoration,也就是说,RecyclerView的onDraw是用来绘制ItemDecoration的;而itemView的绘制是在ViewGroup里面;
至此,RecyclerView的onMeasure,onLayout,onDraw,流程就已经分析完毕了;
总结:
RecyclerView的布局流程比较复杂,但是还是遵循viewGroup的绘制原理,即onMeasure,onLayout,onDraw这几步流程;
那么到这里,绘制的流程就已经讲完了,希望能对你有所帮助,后面会继续分析RecyclerView的复用机制,敬请期待!