ListView 绘制流程解析详解手机开发

目录

LinearLayout绘制流程解析

RelativeLayout绘制流程解析

ListView绘制流程解析

RecyclerView绘制流程解析

絮絮叨叨

从年初到现在，一直积攒了好多知识点没有学习和总结，待办越积越多，此时此刻立下flag，要在这个可爱的八月把所有的待办解决掉。

—- 鲁迅：不，我没说过

背景

在我刚开始学习Android的时候，ListView是列表实现的首选项，现在因为效率等问题慢慢地被RecyclerView替代了，当然，很多简单的业务还是用listview实现更方便。抛开具体现实，光谈理论也是耍流氓的。

为了后面更好的学习RecyclerView，很有必要好好学习了解ListView的绘制机制。

分析

在开始LIstView开始之前，先看下整体重要的数据结构。

AbsListView 是 ListView的父类，也是GridView的父类，当然ListView和GridView都是列表，有很多地方是相似的，因此提取了很多同样的流程到AbsListView中。

AbsListView有一个重要的内部类： RecycleBin

RecycleBin 是 ListView绘制机制的基石，顾名思义，是回收桶的意思。负责专门回收和提供、复用ItemView（ItemView就是ListView中每个滑动的子View）。

RecycleBin

看RecycleBin的注释有这么一段说明它的作用

/**
* The RecycleBin facilitates reuse of views across layouts. The RecycleBin has two levels of
* storage: ActiveViews and ScrapViews. ActiveViews are those views which were onscreen at the
* start of a layout. By construction, they are displaying current information. At the end of
* layout, all views in ActiveViews are demoted to ScrapViews. ScrapViews are old views that
* could potentially be used by the adapter to avoid allocating views unnecessarily.
**/

简单来说，RecycleBin负责回收复用view，其中有两个复用存储空间：

一个是ActiveView负责回收当前界面的活跃的View，他们保留着当前显示的信息。另外一个ScrapViews，ActiveView当被滑出屏幕会被回收到到ScrapViews，ScrapViews里面的View可以被复用，重新绑定，这样可以避免listView的Adpater重新生成新的View。

翻译一下，就是ActiveViews是负责保存当前屏幕活跃的View，而ScrapViews是保存滑出屏幕非活跃的View。

二者的区别有一个在于，ActiveViews取出来的View可以直接拿来绘制显示，不需要重新绑定，就是调用Adapter的onCreateView(其中，onCreateView具备了创建View和绑定View的逻辑，而RecyclerView将二者分离开了)，而ScrapViews取出来的需要重新绑定。

RecyleBin的数据结构

 private View[] mActiveViews = new View[0]; 
// 缓存当前界面显示的子View 
  
 private ArrayList<View>[] mScrapViews; 
 private ArrayList<View> mCurrentScrap; 
 // 存储已经废弃的View，mCurrentScrap在viewTypeCount为1下使用，mScrapViews数组对应viewTypeCount种view 
  
 private int mViewTypeCount; 
// View种类数量，对应Adapter的getItemType() 
 
 private ArrayList<View> mSkippedScrap; 
  
 private SparseArray<View> mTransientStateViews;  
 private LongSparseArray<View> mTransientStateViewsById; 
// mTransientStateViews/mTransientStateViewsById 缓存Transient瞬态的view，若hasStableId=true，则key为itemId 
  

上面其中的mTransientStateViews缓存的是transient状态的view，transient表示瞬间临时状态，通过View的hasTransientState函数来判断，当View处理动画时候，会处于transient状态。

void fillActiveViews(int childCount, int firstActivePosition); 
// 将ListView指定元素存储到mActiveViews 
 
View getActiveView(int position) 
// 从ActiveViews中取出，但只能取一次 
 
void addScrapView(View scrap, int position) 
// 添加ScrapView 
 
View getScrapView(int position) 
// 从ScrapViews中取出 
 
void setViewTypeCount(int viewTypeCount) 
// 设置ViewTypeCount，子View种类 
 
void scrapActiveViews() 
// 将ActiveViews移动到ScrapViews种 
 

在布局之前，如果数据集没有变化，会将显示的子View存到mActivieViews，若数据集发生了变化，将显示的子View添加到mScrapViews，布局完成之后，将mActiveViews剩下的View放到mScrapViews中。

获取子View过程中，如果数据集没有变化，则从mActiveViews直接取出布局子View，若数据集发生了变化，则从mScrapViews中获取，如果匹配到了会重新绑定，如果没匹配到，则创建一个子View绑定。

RecyleBin的大部分的方法都是从上述中获取出View或者存储View的逻辑，在后面源码的过程中再好好具体学习分析。

Measure

之前有分析了ViewGroup/View的绘制流程，其中三个最重要的流程：

measure 测量、layout 布局、draw 绘制

按照这个流程继续来学习ListView，Measure的流程相对比较简单。

protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
    
    // Sets up mListPadding 
    super.onMeasure(widthMeasureSpec, heightMeasureSpec); 
    final int widthMode = MeasureSpec.getMode(widthMeasureSpec); 
    final int heightMode = MeasureSpec.getMode(heightMeasureSpec); 
    int widthSize = MeasureSpec.getSize(widthMeasureSpec); 
    int heightSize = MeasureSpec.getSize(heightMeasureSpec); 
    int childWidth = 0; 
    int childHeight = 0; 
    int childState = 0; 
    mItemCount = mAdapter == null ? 0 : mAdapter.getCount(); 
    if (mItemCount > 0 && (widthMode == MeasureSpec.UNSPECIFIED 
            || heightMode == MeasureSpec.UNSPECIFIED)) {
    
    // 存在子View，无法确定高度时候 
        final View child = obtainView(0, mIsScrap); 
        // Lay out child directly against the parent measure spec so that 
        // we can obtain exected minimum width and height. 
        measureScrapChild(child, 0, widthMeasureSpec, heightSize); 
        childWidth = child.getMeasuredWidth(); 
        childHeight = child.getMeasuredHeight(); 
        childState = combineMeasuredStates(childState, child.getMeasuredState()); 
        if (recycleOnMeasure() && mRecycler.shouldRecycleViewType( 
               ((LayoutParams) child.getLayoutParams()).viewType)) {
    
            mRecycler.addScrapView(child, 0); 
        } 
    } 
     
    if (widthMode == MeasureSpec.UNSPECIFIED) {
    
        widthSize = mListPadding.left + mListPadding.right + childWidth + 
              getVerticalScrollbarWidth(); 
    } else {
    
        widthSize |= (childState & MEASURED_STATE_MASK); 
    } 
     
    if (heightMode == MeasureSpec.UNSPECIFIED) {
    
        heightSize = mListPadding.top + mListPadding.bottom + childHeight + 
               getVerticalFadingEdgeLength() * 2; 
    } 
    if (heightMode == MeasureSpec.AT_MOST) {
    
        // TODO: after first layout we should maybe start at the first visible position, not 0 
        heightSize = measureHeightOfChildren(widthMeasureSpec, 0, NO_POSITION, heightSize, -1); 
    } 
    setMeasuredDimension(widthSize, heightSize); 
    mWidthMeasureSpec = widthMeasureSpec; 
} 

measure的过程相对简单，有一种特殊的情况是在ListView没有确定高度，设定为warp_content时候，会去测量首个子View当做ListView的布局。

Layout

// AbsListView 
    protected void onLayout(boolean changed, int l, int t, int r, int b) {
    
        super.onLayout(changed, l, t, r, b); 
        mInLayout = true; 
        final int childCount = getChildCount(); 
        
        if (changed) {
    // 数据集发生变化 
            for (int i = 0; i < childCount; i++) {
    
               // 强制布局 
                getChildAt(i).forceLayout(); 
            } 
            mRecycler.markChildrenDirty(); 
        } 
        layoutChildren(); 
        …. 
        mInLayout = false; 
} 
 
// AbsListView 
protected void layoutChildren() {
    
    // 空实现 
} 

layoutChildren在于AbsListView是空实现，由具体的ListView实现布局。

这里是ListView的最重要的一段。

protected void layoutChildren() {
    
    .... 
    final int firstPosition = mFirstPosition; 
    final RecycleBin recycleBin = mRecycler; 
    if (dataChanged) {
    // 数据集发生了变化 
        // 加入mScrapViews 
        for (int i = 0; i < childCount; i++) {
    
            recycleBin.addScrapView(getChildAt(i), firstPosition+i); 
        } 
    } else {
    
        // 加入mActiveViews 
        recycleBin.fillActiveViews(childCount, firstPosition); 
    } 
    // 清除掉当前显示view 
    detachAllViewsFromParent(); 
    recycleBin.removeSkippedScrap(); 
    switch (mLayoutMode) {
    
        .... 
        default: 
             // 首次调用layoutChildren时childCount是0 
            if (childCount == 0) {
    
                if (!mStackFromBottom) {
    
                   final int position = lookForSelectablePosition(0, true); 
                   setSelectedPositionInt(position); 
                   sel = fillFromTop(childrenTop); 
                } else {
    
                    final int position = lookForSelectablePosition(mItemCount - 1, false); 
                    setSelectedPositionInt(position); 
                    sel = fillUp(mItemCount - 1, childrenBottom); 
                } 
            } else {
    
            // 非首次调用layoutChildren 
                if (mSelectedPosition >= 0 && mSelectedPosition < mItemCount) {
    
                   sel = fillSpecific(mSelectedPosition, 
                         oldSel == null ? childrenTop : oldSel.getTop()); 
                } else if (mFirstPosition < mItemCount) {
    
                   sel = fillSpecific(mFirstPosition, 
                         oldFirst == null ? childrenTop : oldFirst.getTop()); 
                } else {
    
                   sel = fillSpecific(0, childrenTop); 
                } 
            } 
            break; 
        } 
        // 布局完成之后，将mActiveViews剩下的View放到mScrapViews 
        recycleBin.scrapActiveViews(); 
        .... 
} 

画个图，在这里分成两个逻辑：

首次加载和非首次加载

继续看下fillFromTop()方法，表示从最上面开始往下填充布局

    private View fillFromTop(int nextTop) {
    
        mFirstPosition = Math.min(mFirstPosition, mSelectedPosition); 
        mFirstPosition = Math.min(mFirstPosition, mItemCount - 1); 
        if (mFirstPosition < 0) {
    
            mFirstPosition = 0; 
        } 
        return fillDown(mFirstPosition, nextTop); 
    } 
    // 向下填充布局 
    private View fillDown(int pos, int nextTop) {
    
        View selectedView = null; 
        int end = (mBottom - mTop); 
        if ((mGroupFlags & CLIP_TO_PADDING_MASK) == CLIP_TO_PADDING_MASK) {
    
            end -= mListPadding.bottom; 
        } 
        while (nextTop < end && pos < mItemCount) {
    
            // is this the selected item? 
            boolean selected = pos == mSelectedPosition; 
           // 获取一个childView，调用了makeAndAddView 
            View child = makeAndAddView(pos, nextTop, true, mListPadding.left, selected); 
            nextTop = child.getBottom() + mDividerHeight; 
            if (selected) {
    
                selectedView = child; 
            } 
            pos++; 
        } 
        setVisibleRangeHint(mFirstPosition, mFirstPosition + getChildCount() - 1); 
        return selectedView; 
    } 

我们看一下makeAndAddView如何获取一个子View

    private View makeAndAddView(int position, int y, boolean flow, int childrenLeft, 
            boolean selected) {
    
       // 如果数据集未发生变化，则从mRecycler.getActiveView()从ActiveViews获取 
        if (!mDataChanged) {
    
            // Try to use an existing view for this position. 
            final View activeView = mRecycler.getActiveView(position); 
            if (activeView != null) {
    
                // Found it. We're reusing an existing child, so it just needs 
                // to be positioned like a scrap view. 
                setupChild(activeView, position, y, flow, childrenLeft, selected, true); 
                return activeView; 
            } 
        } 
       // 数据集发生变化，调用obtainView获取View 
        final View child = obtainView(position, mIsScrap); 
        // This needs to be positioned and measured. 
        setupChild(child, position, y, flow, childrenLeft, selected, mIsScrap[0]); 
        return child; 
    } 

无论从哪里获取到了子View，都会调用setupChild()，内部对子View进行measure、layout调整子View的位置。

我们继续看在mScrapView中获取子View，也就是obtainView

View obtainView(int position, boolean[] outMetadata) {
    
        outMetadata[0] = false; 
       // 检查是不是瞬态transient状态，如果是，则从mTransientStateViews获取，这里我们不讨论这种情况 
        final View transientView = mRecycler.getTransientStateView(position); 
        if (transientView != null) {
    
            final LayoutParams params = (LayoutParams) transientView.getLayoutParams(); 
            // If the view type hasn't changed, attempt to re-bind the data. 
            if (params.viewType == mAdapter.getItemViewType(position)) {
    
                final View updatedView = mAdapter.getView(position, transientView, this); 
                // If we failed to re-bind the data, scrap the obtained view. 
                if (updatedView != transientView) {
    
                    setItemViewLayoutParams(updatedView, position); 
                    mRecycler.addScrapView(updatedView, position); 
                } 
            } 
            outMetadata[0] = true; 
            // Finish the temporary detach started in addScrapView(). 
            transientView.dispatchFinishTemporaryDetach(); 
            return transientView; 
        } 
       // 从mScrapView中获取一个可用的子View，可能为null 
        final View scrapView = mRecycler.getScrapView(position); 
        final View child = mAdapter.getView(position, scrapView, this); 
        if (scrapView != null) {
    
            if (child != scrapView) {
    
               //说明重新绑定失败了，将加入mScrapViews 
                mRecycler.addScrapView(scrapView, position); 
            } else if (child.isTemporarilyDetached()) {
    
               // 绑定成功 
                outMetadata[0] = true; 
                // Finish the temporary detach started in addScrapView(). 
                child.dispatchFinishTemporaryDetach(); 
            } 
        } 
       // 设置View的布局参数 
        setItemViewLayoutParams(child, position); 
        return child; 
    } 

obtainView()内部调用了 mAdapter.getView(position, scrapView, this);

fillSpecific()填充指定的位置的子View，内部基本逻辑是一样的

private View fillSpecific(int position, int top) {
    
        boolean tempIsSelected = position == mSelectedPosition; 
        View temp = makeAndAddView(position, top, true, mListPadding.left, tempIsSelected); 
        // Possibly changed again in fillUp if we add rows above this one. 
        mFirstPosition = position; 
        View above; 
        View below; 
        final int dividerHeight = mDividerHeight; 
        if (!mStackFromBottom) {
    
            above = fillUp(position - 1, temp.getTop() - dividerHeight); 
            // This will correct for the top of the first view not touching the top of the list 
            adjustViewsUpOrDown(); 
            below = fillDown(position + 1, temp.getBottom() + dividerHeight); 
            int childCount = getChildCount(); 
            if (childCount > 0) {
    
                correctTooHigh(childCount); 
            } 
        } else {
    
            below = fillDown(position + 1, temp.getBottom() + dividerHeight); 
            // This will correct for the bottom of the last view not touching the bottom of the list 
            adjustViewsUpOrDown(); 
            above = fillUp(position - 1, temp.getTop() - dividerHeight); 
            int childCount = getChildCount(); 
            if (childCount > 0) {
    
                 correctTooLow(childCount); 
            } 
        } 
        if (tempIsSelected) {
    
            return temp; 
        } else if (above != null) {
    
            return above; 
        } else {
    
            return below; 
        } 
    } 

Draw

@Override 
protected void dispatchDraw(Canvas canvas) {
     
    // Draw the dividers 
    ... 
    super.dispatchDraw(canvas); 
} 

Draw流程比较简单，绘制divider、overscrollFooter、overscrollHeader等

最后调用交由super.dispatchDraw()父类处理，最后是到ViewGroup，跟之前文章的draw分析是一样的

总结

在布局之前，如果数据集没有变化，会将显示的子View存到mActivieViews，若数据集发生了变化，将显示的子View添加到mScrapViews，布局完成之后，将mActiveViews剩下的View放到mScrapViews中。

获取子View过程中，如果数据集没有变化，则从mActiveViews直接取出布局子View，若数据集发生了变化，则从mScrapViews中获取，如果匹配到了会重新绑定，如果没匹配到，则创建一个子View绑定。

参考

非常感谢郭霖老师的ListView的解析，真的帮助理解了很多。

云图网

云图网