郭神的抽丝剥茧心法修炼： 深剖RecyclerView

RecyclerView mRecyclerView = findViewById(R.id.recycle);
// 设置布局方式
mRecyclerView.setLayoutManager(new LinearLayoutManager(this, LinearLayoutManager.VERTICAL, false));
// 适配器，MainAdapter继承自RecyclerView.Adapter<VH extends RecyclerView.ViewHolder>
MainAdapter mAdapter = new MainAdapter();
mRecyclerView.setAdapter(mAdapter);
// 添加分割线的方法
// mRecyclerView.addItemDecoration();
// 设置布局动画的方法，可以自定义
// mRecyclerView.setItemAnimator();

负责 RecyclerView 子 View 的布局，常用的有 LinearLayoutManager(线性布局)，还有 GridLayoutManager(网格布局) 和 StaggeredGridLayoutManager(瀑布布局) 等。

负责 ViewHolder 的回收和提供。

public RecyclerView(@NonNull Context context, @Nullable AttributeSet attrs) {
    this(context, attrs, 0);
}

public RecyclerView(@NonNull Context context, @Nullable AttributeSet attrs, int defStyle) {
    super(context, attrs, defStyle);
    // ... 省略一些实例的初始化
    
    if (attrs != null) {
        int defStyleRes = 0;
        TypedArray a = context.obtainStyledAttributes(attrs, styleable.RecyclerView, defStyle, defStyleRes);
        String layoutManagerName = a.getString(styleable.RecyclerView_layoutManager);
        // ... 这里唯一值得关注就是看布局文件是否指定LayoutManager
        a.recycle();
        this.createLayoutManager(context, layoutManagerName, attrs, defStyle, defStyleRes);
       // ...
    } else {
        // ...
    }
    // ...
}

public void setLayoutManager(@Nullable RecyclerView.LayoutManager layout) {
    if (layout != this.mLayout) {
        // 停止滚动
        this.stopScroll();
        if (this.mLayout != null) {
            // 因为是第一次设置，所以mLayout为空
            // ... 代码省略 主要是对之前的LayoutManager 进行移除前的操作
        } else {
            this.mRecycler.clear();
        }
        this.mChildHelper.removeAllViewsUnfiltered();
        this.mLayout = layout;
        if (layout != null) {
            // 对新的LayoutManager进行设置
            this.mLayout.setRecyclerView(this);
            if (this.mIsAttached) {
                this.mLayout.dispatchAttachedToWindow(this);
            }
        }
        this.mRecycler.updateViewCacheSize();
        // 重点 通知界面重新布局和重绘
        this.requestLayout();
    }
}

public void setAdapter(@Nullable RecyclerView.Adapter adapter) {
    // 冻结当前布局，不让进行子布局的更新
    this.setLayoutFrozen(false);
    // 重点关注的方法
    this.setAdapterInternal(adapter, false, true);
    this.processDataSetCompletelyChanged(false);
    // 再次请求布局的重新绘制
    this.requestLayout();
}

private void setAdapterInternal(@Nullable RecyclerView.Adapter adapter, Boolean compatibleWithPrevious, Boolean removeAndRecycleViews) {
    if (this.mAdapter != null) {
        // 第一次进入mAdapter为null，故不会进入该代码块
        // 主要是对旧的mAdapter的数据监听器解除注册
        this.mAdapter.unregisterAdapterDataObserver(this.mObserver);
        this.mAdapter.onDetachedFromRecyclerView(this);
    }
    if (!compatibleWithPrevious || removeAndRecycleViews) {
        // 更换适配器的时候移除所有的子View
        this.removeAndRecycleViews();
    }
    this.mAdapterHelper.reset();
    RecyclerView.Adapter oldAdapter = this.mAdapter;
    this.mAdapter = adapter;
    if (adapter != null) {
        // 新的适配器注册数据监听器
        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;
}

protected void onMeasure(int widthSpec, int heightSpec) {
    if (this.mLayout == null) {
        this.defaultOnMeasure(widthSpec, heightSpec);
    } else {
        // LinearLayoutManager#isAutoMeasureEnabled为True
        // GridLayoutManager继承子LinearLayoutManager isAutoMeasureEnabled同样为true
        // 这种情况下，我们主要分析this.mLayout.isAutoMeasureEnabled()为true的场景下
        if (!this.mLayout.isAutoMeasureEnabled()) {
            // ... 省略
        } else {
            int widthMode = MeasureSpec.getMode(widthSpec);
            int heightMode = MeasureSpec.getMode(heightSpec);
            // ... 测量 最后还是走ViewGroup测量子布局的那套
            this.mLayout.onMeasure(this.mRecycler, this.mState, widthSpec, heightSpec);
            Boolean measureSpecModeIsExactly = widthMode == MeasureSpec.EXACTLY && heightMode == MeasureSpec.EXACTLY;
            // 如果当前的RecyclerView的布局方式是设置了具体高宽或Match_Parent或mAdapter为null就直接返回
            if (measureSpecModeIsExactly || this.mAdapter == null) {
                return;
            }
            if (this.mState.mLayoutStep == State.STEP_START) {
                this.dispatchLayoutStep1();
            }
            this.mLayout.setMeasureSpecs(widthSpec, heightSpec);
            this.mState.mIsMeasuring = true;
            this.dispatchLayoutStep2();
            this.mLayout.setMeasuredDimensionFromChildren(widthSpec, heightSpec);
            if (this.mLayout.shouldMeasureTwice()) {
                this.mLayout.setMeasureSpecs(MeasureSpec.makeMeasureSpec(this.getMeasuredWidth(), MeasureSpec.EXACTLY), MeasureSpec.makeMeasureSpec(this.getMeasuredHeight(), MeasureSpec.EXACTLY));
                this.mState.mIsMeasuring = true;
                this.dispatchLayoutStep2();
                this.mLayout.setMeasuredDimensionFromChildren(widthSpec, heightSpec);
            }
        }
    }
}

protected void onLayout(Boolean changed, int l, int t, int r, int b) {
    TraceCompat.beginSection("RV OnLayout");
    this.dispatchLayout();
    TraceCompat.endSection();
    this.mFirstLayoutComplete = true;
}

void dispatchLayout() {
    if (this.mAdapter == null) {
        // ...
    } else if (this.mLayout == null) {
        // ...
    } else {
        this.mState.mIsMeasuring = false;
        // 根据当前State的不同执行不同的流程
        if (this.mState.mLayoutStep == STEP_START) {
            this.dispatchLayoutStep1();
            this.mLayout.setExactMeasureSpecsFrom(this);
            this.dispatchLayoutStep2();
        } else if (!this.mAdapterHelper.hasUpdates() && this.mLayout.getWidth() == this.getWidth() && this.mLayout.getHeight() == this.getHeight()) {
            this.mLayout.setExactMeasureSpecsFrom(this);
        } else {
            this.mLayout.setExactMeasureSpecsFrom(this);
            this.dispatchLayoutStep2();
        }
        this.dispatchLayoutStep3();
    }
}

private void dispatchLayoutStep1() {
    // 全部清空位置信息
    mViewInfoStore.clear();
    // 确定mState.mRunSimpleAnimations和mState.mRunPredictiveAnimations
    // ...
    // 预布局状态跟mState.mRunPredictiveAnimations相关
    mState.mInPreLayout = mState.mRunPredictiveAnimations;
    // ...
    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) {
            // ...
            // 存储子View的位置信息...
            mViewInfoStore.addToPreLayout(holder, animationInfo);
        }
    }
    if (mState.mRunPredictiveAnimations) {
        // 其实我也不太理解PreLayout布局的意义，放出来看看
        // 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.
      
        // 真实布局之前尝试布局一次
        // temporarily disable flag because we are asking for previous layout
        mLayout.onLayoutChildren(mRecycler, mState);
        for (int i = 0; i < mChildHelper.getChildCount(); ++i) {
            //...
            if (!mViewInfoStore.isInPreLayout(viewHolder)) {
                // ...
                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();
    }
    //
    mState.mLayoutStep = State.STEP_LAYOUT;
}

private void processAdapterUpdatesAndSetAnimationFlags() {
    // ...
    // mFirstLayoutComplete 会在RecyclerView第一次完成onLayout变为True
    Boolean animationTypeSupported = mItemsAddedOrRemoved || mItemsChanged;
    mState.mRunSimpleAnimations = mFirstLayoutComplete
                    && mItemAnimator != null
                    && (mDataSetHasChangedAfterLayout
                    || animationTypeSupported
                    || mLayout.mRequestedSimpleAnimations)
                    && (!mDataSetHasChangedAfterLayout
                    || mAdapter.hasStableIds());
    mState.mRunPredictiveAnimations = mState.mRunSimpleAnimations
                    && animationTypeSupported
                    && !mDataSetHasChangedAfterLayout
                    && predictiveItemAnimationsEnabled();
}

private void dispatchLayoutStep2() {
    // ...
    // 预布局结束 进入真实的布局过程
    this.mState.mInPreLayout = false;
    // 实际的布局交给了LayoutManager
    this.mLayout.onLayoutChildren(this.mRecycler, this.mState);
    // ...
    // 是否有动画
    this.mState.mRunSimpleAnimations = this.mState.mRunSimpleAnimations && this.mItemAnimator != null;
    // 变更状态 准备播放动画 STEP_ANIMATIONS-4
    this.mState.mLayoutStep = State.STEP_ANIMATIONS;
    // ...
}

private void dispatchLayoutStep3() {
    this.mState.assertLayoutStep(State.STEP_ANIMATIONS);
    // ... 省略
    this.mState.mLayoutStep = State.STEP_START;
    if (this.mState.mRunSimpleAnimations) {
        for (int i = this.mChildHelper.getChildCount() - 1; i >= 0; --i) {
            // ...省略
            // 总结下来就是两个步骤：
            // 1.添加真实的布局信息
            this.mViewInfoStore.addToPostLayout(holder, animationInfo);
        }
        // 2.挨个执行动画
        this.mViewInfoStore.process(this.mViewInfoProcessCallback);
    }
    //... 清空信息
    this.mViewInfoStore.clear();
}

void process(ProcessCallback callback) {
    for (int index = mLayoutHolderMap.size() - 1; index >= 0; index --) {
        final ViewHolder viewHolder = mLayoutHolderMap.keyAt(index);
        final InfoRecord record = mLayoutHolderMap.removeAt(index);
        if ((record.flags & FLAG_APPEAR_AND_DISAPPEAR) == FLAG_APPEAR_AND_DISAPPEAR) {
            // Appeared then disappeared. Not useful for animations.
            callback.unused(viewHolder);
        } else if ((record.flags & FLAG_DISAPPEARED) != 0) {
            // Set as "disappeared" by the LayoutManager (addDisappearingView)
            if (record.preInfo == null) {
                // similar to appear disappear but happened between different layout passes.
                // this can happen when the layout manager is using auto-measure
                callback.unused(viewHolder);
            } else {
                callback.processDisappeared(viewHolder, record.preInfo, record.postInfo);
            }
        } else if ((record.flags & FLAG_APPEAR_PRE_AND_POST) == FLAG_APPEAR_PRE_AND_POST) {
            // Appeared in the layout but not in the adapter (e.g. entered the viewport)
            callback.processAppeared(viewHolder, record.preInfo, record.postInfo);
        } else if ((record.flags & FLAG_PRE_AND_POST) == FLAG_PRE_AND_POST) {
            // Persistent in both passes. Animate persistence
            callback.processPersistent(viewHolder, record.preInfo, record.postInfo);
        } else if ((record.flags & FLAG_PRE) != 0) {
            // Was in pre-layout, never been added to post layout
            callback.processDisappeared(viewHolder, record.preInfo, null);
        } else if ((record.flags & FLAG_POST) != 0) {
            // Was not in pre-layout, been added to post layout
            callback.processAppeared(viewHolder, record.preInfo, record.postInfo);
        } else if ((record.flags & FLAG_APPEAR) != 0) {
            // Scrap view. RecyclerView will handle removing/recycling this.
        } else if (DEBUG) {
            throw new IllegalStateException("record without any reasonable flag combination:/");
        }
        // 释放record
        InfoRecord.recycle(record);
    }
}

// 回调的接口
interface ProcessCallback {
    void processDisappeared(ViewHolder var1, @NonNull ItemHolderInfo var2, @Nullable ItemHolderInfo var3);
    void processAppeared(ViewHolder var1, @Nullable ItemHolderInfo var2, ItemHolderInfo var3);
    void processPersistent(ViewHolder var1, @NonNull ItemHolderInfo var2, @NonNull ItemHolderInfo var3);
    void unused(ViewHolder var1);
}

this.mViewInfoProcessCallback = new ProcessCallback() {
    // ... 这里我们只展示一个方法就行了
    public void processAppeared(RecyclerView.ViewHolder viewHolder, RecyclerView.ItemAnimator.ItemHolderInfo preInfo, RecyclerView.ItemAnimator.ItemHolderInfo info) {
        RecyclerView.this.animateAppearance(viewHolder, preInfo, info);
    }
    // ...
};

void animateAppearance(@NonNull RecyclerView.ViewHolder itemHolder, @Nullable RecyclerView.ItemAnimator.ItemHolderInfo preLayoutInfo, @NonNull RecyclerView.ItemAnimator.ItemHolderInfo postLayoutInfo) {
    itemHolder.setIsRecyclable(false);
    if (this.mItemAnimator.animateAppearance(itemHolder, preLayoutInfo, postLayoutInfo)) {
        this.postAnimationRunner();
    }
}

public void onDraw(Canvas c) {
 super.onDraw(c);
 int count = this.mItemDecorations.size();
 for (int i = 0; i < count; ++i) {
  ((RecyclerView.ItemDecoration)this.mItemDecorations.get(i)).onDraw(c, this, this.mState);
 }
}

mLayout.onLayoutChildren(mRecycler, mState);

public View getViewForPosition(int position) {
    return getViewForPosition(position, false);
}

// 看函数名称就知道，它是尝试获取ViewHolder
View getViewForPosition(int position, Boolean dryRun) {
    return tryGetViewHolderForPositionByDeadline(position, dryRun, FOREVER_NS).itemView;
}

ViewHolder tryGetViewHolderForPositionByDeadline(int position,
                Boolean dryRun, long deadlineNs) {
    //...
    ViewHolder holder = null;
    // 第一步 从 mChangedScrap 中获取
    // PreLayout从名字可以看出，它不是真实的布局，不过我不是特别清楚
    // 预布局的意义。
    // 除此之外，它其实没有意义的，没有参与实际布局的缓存过程中。
    if (mState.isPreLayout()) {
        holder = getChangedScrapViewForPosition(position);
        fromScrapOrHiddenOrCache = holder != null;
    }
    // 第二步 从 mAttachedScrap或者mCachedViews 中获取
    // 如果RecyclerView之前就有ViewHolder，并且这些ViewHolder之后还要
    // 继续展现，在Layout过程中，它会将这些ViewHolder先取出来存放进mAttachedScrap，
    // 填充的时候再从mAttachedScrap取出
    if (holder == null) {
        holder = getScrapOrHiddenOrCachedHolderForPosition(position, dryRun);
        // ...
    }
    if (holder == null) {
        final int offsetPosition = mAdapterHelper.findPositionOffset(position);
        final int type = mAdapter.getItemViewType(offsetPosition);
        // 第三步 Find from scrap/cache via stable ids, if exists
        if (mAdapter.hasStableIds()) {
            // StableId可以被当做ViewHolder的唯一标识
            holder = getScrapOrCachedViewForId(mAdapter.getItemId(offsetPosition),
                                                    type, dryRun);
            //...
        }
        // 第四步 mViewCacheExtension需要用户自定义实现并设置
        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 (holder == null) {
            // 第五步 从RecycledViewPool中获取
            // 通过RecycledViewPool获取
            // 每种ViewType的ViewHolder最多可以存放五个
            holder = getRecycledViewPool().getRecycledView(type);
            //...
        }
        if (holder == null) {
            // 第六步 缓存中都没有就重新创建
            // 如果缓存中都没有，就需要重新创建
            holder = mAdapter.createViewHolder(RecyclerView.this, type);
            // ...
        }
    }
    Boolean bound = false;
    if (mState.isPreLayout() && holder.isBound()) {
        // ...
    } else if (!holder.isBound() || holder.needsUpdate() || holder.isInvalid()) {
        // ...
        // 没有绑定就重新绑定
        bound = tryBindViewHolderByDeadline(holder, offsetPosition, position, deadlineNs);
    }
    // ...
    return holder;
}

public final VH createViewHolder(ViewGroup parent, int viewType) {
    // ...
    final VH holder = onCreateViewHolder(parent, viewType);
    holder.mItemViewType = viewType;
    // ...
    return holder;
}

public abstract VH onCreateViewHolder(ViewGroup parent, int viewType);

private Boolean tryBindViewHolderByDeadline(ViewHolder holder, int offsetPosition,
                int position, long deadlineNs) {
    // ...
    // 最关键的方法就是调用了Adapter#bindViewHolder方法
    mAdapter.bindViewHolder(holder, offsetPosition);
    // ...
}

public void onBindViewHolder(VH holder, int position, List<Object> payloads) {
    onBindViewHolder(holder, position);
}

public abstract void onBindViewHolder(VH holder, int position);

public Boolean onTouchEvent(MotionEvent e) {
    // ...
    switch (action) {
        // ...
        case MotionEvent.ACTION_MOVE: {
            // ...
            if (mScrollState == SCROLL_STATE_DRAGGING) {
                mLastTouchX = x - mScrollOffset[0];
                mLastTouchY = y - mScrollOffset[1];
                // 当前滑动状态设置为SCROLL_STATE_DRAGGING 需要滑动距离大于阈值
                if (scrollByInternal(
                                            canScrollHorizontally ? dx : 0,
                                            canScrollVertically ? dy : 0,
                                            vtev)) {
                    getParent().requestDisallowInterceptTouchEvent(true);
                }
                // ...
            }
        }
        break;
        // ...
    }
    // ...
    return true;
}

Boolean scrollByInternal(int x, int y, MotionEvent ev) {
    // ...
    if (mAdapter != null) {
        // ...
        // 无论是横向或者纵向都交给了LayoutManager处理
        if (x != 0) {
            consumedX = mLayout.scrollHorizontallyBy(x, mRecycler, mState);
            unconsumedX = x - consumedX;
        }
        if (y != 0) {
            consumedY = mLayout.scrollVerticallyBy(y, mRecycler, mState);
            unconsumedY = y - consumedY;
        }
        // ...
    }
    // ...
    return consumedX != 0 || consumedY != 0;
}

public void recycleView(View view) {
    // ...
    ViewHolder holder = getChildViewHolderint(view);
    // ...
    recycleViewHolderInternal(holder);
}

void recycleViewHolderInternal(ViewHolder holder) {
    // 一系列检查
    // ...
    Boolean cached = false;
    Boolean recycled = false;
    // ...
    if (forceRecycle || holder.isRecyclable()) {
        if (mViewCacheMax > 0
                                && !holder.hasAnyOfTheFlags(ViewHolder.FLAG_INVALID
                                | ViewHolder.FLAG_REMOVED
                                | ViewHolder.FLAG_UPDATE
                                | ViewHolder.FLAG_ADAPTER_POSITION_UNKNOWN)) {
            // mViewCacheMax 默认最大值为2
            int cachedViewSize = mCachedViews.size();
            if (cachedViewSize >= mViewCacheMax && cachedViewSize > 0) {
                // 缓存数量大于2的时候将最先进来的ViewHolder移除
                recycleCachedViewAt(0);
                cachedViewSize--;
            }
            // ...
            mCachedViews.add(targetCacheIndex, holder);
            cached = true;
        }
        if (!cached) {
            addViewHolderToRecycledViewPool(holder, true);
            recycled = true;
        }
    } else {
        // ...
    }
    // ViewInfoStore 中移除
    mViewInfoStore.removeViewHolder(holder);
}

void recycleCachedViewAt(int cachedViewIndex) {
    // ...
    ViewHolder viewHolder = mCachedViews.get(cachedViewIndex);
    // 添加进缓存池RecyclerPool
    addViewHolderToRecycledViewPool(viewHolder, true);
    // 从mCachedViews中移除
    mCachedViews.remove(cachedViewIndex);
}