recyclerview-structure

Posted on Edited on Views:

本系列主要分析RecyclerView的源码。本文主要分析RecyclerView的源码结构，以及其各机构的作用。首先来看一下RecyclerView的源码结构:

从图上可以看出RecyclerView依赖了很多别的类。接下来我们首先介绍各个类的作用。

  • RecyclerViewDataObserver 数据观察器
  • Recycler View循环复用系统，核心部件
  • SavedState RecyclerView状态
  • AdapterHelper 适配器更新
  • ChildHelper 管理子View
  • ViewInfoStore 存储子VIEW的动画信息
  • Adapter 数据适配器
  • LayoutManager 负责子VIEW的布局，核心部件
  • ItemAnimator Item动画
  • ViewFlinger 快速滑动管理
  • NestedScrollingChildHelper 管理子VIEW嵌套滑动

###创建布局管理器

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
private void createLayoutManager(Context context, String className, AttributeSet attrs,
            int defStyleAttr, int defStyleRes) {
        if (className != null) {
            className = className.trim();
            if (className.length() != 0) {  // Can't use isEmpty since it was added in API 9.
                className = getFullClassName(context, className);
                try {
                    ClassLoader classLoader;
                    if (isInEditMode()) {
                        // Stupid layoutlib cannot handle simple class loaders.
                        classLoader = this.getClass().getClassLoader();
                    } else {
                        classLoader = context.getClassLoader();
                    }
                    Class<? extends LayoutManager> layoutManagerClass =
                            classLoader.loadClass(className).asSubclass(LayoutManager.class);
                    Constructor<? extends LayoutManager> constructor;
                    Object[] constructorArgs = null;
                    try {
                        constructor = layoutManagerClass
                                .getConstructor(LAYOUT_MANAGER_CONSTRUCTOR_SIGNATURE);
                        constructorArgs = new Object[]{context, attrs, defStyleAttr, defStyleRes};
                    } catch (NoSuchMethodException e) {
                        try {
                            constructor = layoutManagerClass.getConstructor();
                        } catch (NoSuchMethodException e1) {
                            e1.initCause(e);
                            throw new IllegalStateException(attrs.getPositionDescription() +
                                    ": Error creating LayoutManager " + className, e1);
                        }
                    }
                    constructor.setAccessible(true);
                    setLayoutManager(constructor.newInstance(constructorArgs));
                } catch (ClassNotFoundException e) {
                    throw new IllegalStateException(attrs.getPositionDescription()
                            + ": Unable to find LayoutManager " + className, e);
                } catch (InvocationTargetException e) {
                    throw new IllegalStateException(attrs.getPositionDescription()
                            + ": Could not instantiate the LayoutManager: " + className, e);
                } catch (InstantiationException e) {
                    throw new IllegalStateException(attrs.getPositionDescription()
                            + ": Could not instantiate the LayoutManager: " + className, e);
                } catch (IllegalAccessException e) {
                    throw new IllegalStateException(attrs.getPositionDescription()
                            + ": Cannot access non-public constructor " + className, e);
                } catch (ClassCastException e) {
                    throw new IllegalStateException(attrs.getPositionDescription()
                            + ": Class is not a LayoutManager " + className, e);
                }
            }
        }
    }

如果在布局文件里面设置了布局管理器的类型，那么这里会通过反射的方式实例化出对应的布局管理器。最后将实例化出的布局管理器设置到当前的RecyclerView

###设置布局管理器

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
public void setLayoutManager(LayoutManager layout) {
        if (layout == mLayout) {
            return;
        }
        //停止滚动
        stopScroll();
        // TODO We should do this switch a dispachLayout pass and animate children. There is a good
        // chance that LayoutManagers will re-use views.
        if (mLayout != null) {
            if (mIsAttached) {
                mLayout.dispatchDetachedFromWindow(this, mRecycler);
            }
            mLayout.setRecyclerView(null);
        }
        //清空缓存
        mRecycler.clear();
        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);
            }
        }
        requestLayout();
    }

设置布局管理器之前会先清空所有之前的缓存VIEW。最后通知VIEW刷新

###onMeasure
onMeasure这个回调方法用于测量VIEW的大小

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
protected void onMeasure(int widthSpec, int heightSpec) {
        if (mLayout == null) {
            defaultOnMeasure(widthSpec, heightSpec);
            return;
        }
        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 {
            if (mHasFixedSize) {
                mLayout.onMeasure(mRecycler, mState, widthSpec, heightSpec);
                return;
            }
            // custom onMeasure
            if (mAdapterUpdateDuringMeasure) {
                eatRequestLayout();
                processAdapterUpdatesAndSetAnimationFlags();

                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
        }
    }

从上述代码可以看出，

  • 如果布局是空的，那么RecyclerView会创建调用defaultOnMeasure方法
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
/**
    * Used when onMeasure is called before layout manager is set
    */
   void defaultOnMeasure(int widthSpec, int heightSpec) {
       // calling LayoutManager here is not pretty but that API is already public and it is better
       // than creating another method since this is internal.
       final int width = LayoutManager.chooseSize(widthSpec,
               getPaddingLeft() + getPaddingRight(),
               ViewCompat.getMinimumWidth(this));
       final int height = LayoutManager.chooseSize(heightSpec,
               getPaddingTop() + getPaddingBottom(),
               ViewCompat.getMinimumHeight(this));

       setMeasuredDimension(width, height);
   }

默认测量是布局管理器根据指定的宽，高规格，算出宽高。

  • 如果是自动布局，如果宽高都是明确指定的，那么跳过测量。否则，如果
  • 目前是初始阶段，那么调用dispatchLayoutStep1
1
2
3
4
5
6
7
/**
    * The first step of a layout where we;
    * - process adapter updates
    * - decide which animation should run
    * - save information about current views
    * - If necessary, run predictive layout and save its information
    */
  • 第二步，用老的尺寸规格来预布局，然后调用dispatchLayoutStep2
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
private void dispatchLayoutStep2() {
        eatRequestLayout();
        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();
        resumeRequestLayout(false);
    }
  • 这之后我们就能够获取子VIEW的宽高了。如果RecyclerView没有明确的宽高，那么我们需要再次测量，然后重复上述步骤。
  • 如果不是自动布局，如果是固定大小，那么直接用现有规格测量。否则首先进行一些动画前置操作，最后依然由布局管理器来测量。

###onLayout
onLayout是确定位置时的回调方法。

1
2
3
4
5
6
7
@Override
   protected void onLayout(boolean changed, int l, int t, int r, int b) {
       TraceCompat.beginSection(TRACE_ON_LAYOUT_TAG);
       dispatchLayout();
       TraceCompat.endSection();
       mFirstLayoutComplete = true;
   }

dispatchLayout 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
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();
   }
  • 如果是初始状态，调用dispatchLayoutStep1，测量，调用dispatchLayoutStep2。如果高度或宽度发生变化，测量，调用dispatchLayoutStep2。其他情况制作测量。最后统一调用dispatchLayoutStep3主要处理动画。

###onDraw
onDraw是绘制时的回调 

1
2
3
4
5
6
7
8
9
@Override
   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);
       }
   }

主要对ItemDecoration的绘制

至此，RecyclerView的主要回调方法已经简单介绍完毕。