Android开发知识(二十三)从源码角度分析ListView的滑动复用机制

文章目录

  • 前言
  • 认识RecycleBin机制
  • ListView的布局方式
  • ListView的元素创建流程
  • ListView滑动加载过程

前言

ListView作为一个常用的列表控件,虽然现在基本被RecycleView取代了,但是它的内部思想还是很多值得我们学习的地方。既然新出了RecycleView来代替ListView,我们就要摸清他们两个之间的区别。
鉴于篇幅关系,本篇先分析ListView的原理。

认识RecycleBin机制

解析ListView源码前,我们有必要先探究里面的RecycleBin机制,某种程度上讲,它正是ListView的精髓所在。

RecycleBin是在AbsListView里的一个内部类,SDK是这么注释的:

    /**
     * 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,一种是ActiveViews,也就是目前正显示在屏幕上的,由我们自己创建的View。

另外一种是ScrapViews,也就是被废弃掉的View,它是当ActiveViews被移除之后就变成了ScrapViews,ScrapViews可以避免adapter去创建没必要的View

这个我们都理解,就是要记录当前屏幕上的View在ActiveViews里,当ListView向上滑动时,底部出现新的item会去ScrapViews中拿,而不重新创建。而顶部的ActiveView划出屏幕中,自动变化为ScrapView

它有以下几个重要的方法:

  • fillActiveViews()
  • getActiveView()
  • addScrapView()
  • getScrapView()
  • setViewTypeCount()
  • clear()

fillActiveViews()

   void fillActiveViews(int childCount, int firstActivePosition) {
            if (mActiveViews.length < childCount) {
                mActiveViews = new View[childCount];
            }
            mFirstActivePosition = firstActivePosition;

            //noinspection MismatchedReadAndWriteOfArray
            final View[] activeViews = mActiveViews;
            for (int i = 0; i < childCount; i++) {
                View child = getChildAt(i);
                AbsListView.LayoutParams lp = (AbsListView.LayoutParams) child.getLayoutParams();
                // Don't put header or footer views into the scrap heap
                if (lp != null && lp.viewType != ITEM_VIEW_TYPE_HEADER_OR_FOOTER) {
                    // Note:  We do place AdapterView.ITEM_VIEW_TYPE_IGNORE in active views.
                    //        However, we will NOT place them into scrap views.
                    activeViews[i] = child;
                    // Remember the position so that setupChild() doesn't reset state.
                    lp.scrappedFromPosition = firstActivePosition + i;
                }
            }
        }

上面的源码,方法接收两个参数

  • childCount 要存储的View的数量,这里其实会传入进来ListView在屏幕上能显示的数量
  • firstActivePosition 第一个可见View的postion

mActiveViews会保证储存的数量是ListView在屏幕上能显示的数量,然后把0到childCount的child view 赋值给mActiveViews

如果mActiveViews.length < childCount,比如ListView可以显示10个条目,但是只有5个数据,那么这里mActiveViews也是5

等下次假如ListView有100个条目了,那么mActiveViews就要扩容为10了。

getActiveView()

 View getActiveView(int position) {
            int index = position - mFirstActivePosition;
            final View[] activeViews = mActiveViews;
            if (index >=0 && index < activeViews.length) {
                final View match = activeViews[index];
                //被get完之后被置空
                activeViews[index] = null;
                return match;
            }
            return null;
        }

通过具体的位置得到activeViews数组中对应存储的View
特别注意的是被get完之后被置空,也就是说,在activeViews数组元素没有被更新之前,每个对应的位置只能被get一次拿到View。为什么呢?我们留着这个问题

addScrapView()
void addScrapView(View scrap, int position) {

if (mViewTypeCount == 1) {
mCurrentScrap.add(scrap);
} else {
mScrapViews[viewType].add(scrap);
}

}
addScrapView方法有几十行代码,我们只抓这个核心代码就好了,可以看出。当mViewTypeCount是1的时候是被加到mCurrentScrap中,而mViewTypeCount大于1的时候则会加到mScrapViews中

我们知道,在Adapter中允许我们使用多个布局类型,我们可以用getItemViewType()方法区分,这里的mViewTypeCount会对应这个数字。

当有多种布局样式的时候,这个时候要回收这些View肯定是需要分类的,不然复用的时候,不同样式的view就乱了。所以用mScrapViews用来记录有多个布局类型的时候

而mCurrentScrap来记录只有一种类型的时候。

getScrapView()

   View getScrapView(int position) {
        final int whichScrap = mAdapter.getItemViewType(position);
        if (whichScrap < 0) {
            return null;
        }
        if (mViewTypeCount == 1) {
            return retrieveFromScrap(mCurrentScrap, position);
        } else if (whichScrap < mScrapViews.length) {
            return retrieveFromScrap(mScrapViews[whichScrap], position);
        }
        return null;
    }

可以看到getScrapView方法中会判断mViewTypeCount是否等于1,来选择用mCurrentScrap还是mScrapViews,最终都会调用retrieveFromScrap方法来获得View

这个retrieveFromScrap方法如下:

private View retrieveFromScrap(ArrayList scrapViews, int position) {
            final int size = scrapViews.size();
            if (size > 0) {
                // See if we still have a view for this position or ID.
                // Traverse backwards to find the most recently used scrap view
                for (int i = size - 1; i >= 0; i--) {
                    final View view = scrapViews.get(i);
                    final AbsListView.LayoutParams params =
                            (AbsListView.LayoutParams) view.getLayoutParams();
                    //优先匹配stable id
                    if (mAdapterHasStableIds) {
                        final long id = mAdapter.getItemId(position);
                        if (id == params.itemId) {
                            return scrapViews.remove(i);
                        }
                     //其次再匹配有没有回收过的相同位置
                    } else if (params.scrappedFromPosition == position) {
                        final View scrap = scrapViews.remove(i);
                        clearScrapForRebind(scrap);
                        return scrap;
                    }
                }
                //实在不行再取最后面一个
                final View scrap = scrapViews.remove(size - 1);
                clearScrapForRebind(scrap);
                return scrap;
            } else {
                return null;
            }
        }

retrieveFromScrap方法源码可以发现,再获取之前scrap View的时候,会经历几个优先级判断:

  • 先匹配是否有存在itemId相同的scrap View
  • 如果不存在itemId相同的,则判断存不存在相同位置的scrap View
  • 如果相同位置的scrap View也没有,那么只能去取列表中的最后一个了

setViewTypeCount()

  public void setViewTypeCount(int viewTypeCount) {
        if (viewTypeCount < 1) {
            throw new IllegalArgumentException("Can't have a viewTypeCount < 1");
        }
        //noinspection unchecked
        ArrayList[] scrapViews = new ArrayList[viewTypeCount];
        for (int i = 0; i < viewTypeCount; i++) {
            scrapViews[i] = new ArrayList();
        }
        mViewTypeCount = viewTypeCount;
        mCurrentScrap = scrapViews[0];
        mScrapViews = scrapViews;
    }

可以发现setViewTypeCount其实是对scrapViews和mCurrentScrap的初始化,初始化后在其他地方会根据viewTypeCount是否等于1来判断是否用mCurrentScrap还是mScrapViews

从mCurrentScrap = scrapViews[0];上看,可以看出本质上mCurrentScrap只是指向scrapViews数组的第0个而已,并没有自己单独new ArrayList

clear()

  void clear() {
    if (mViewTypeCount == 1) {
        final ArrayList scrap = mCurrentScrap;
        clearScrap(scrap);
    } else {
        final int typeCount = mViewTypeCount;
        for (int i = 0; i < typeCount; i++) {
            final ArrayList scrap = mScrapViews[i];
            clearScrap(scrap);
        }
    }

    clearTransientStateViews();
 }

clear方法不难看出,它就是一个清除所有Scrap View的方法。当我们重新setAdapter的时候会就应该clear掉原先的View。

滤清了RecycleBin这几个重要方法后,我们心中对这个机制就有个大概的框架了

  • 猜想是会调用fillActiveViews()方法来记录当前在屏幕上的View,之后可以用getActiveView来获取。
    这样做可能是为了避免两次onLayout过程使屏幕上的View重复创建,而在getActiveView方法之后置空,这样才可以回收内存。

  • 在顶(底)部的View被滑出屏幕的时候,会调用addScrapView来回收一个View

  • 同时有新元素被滑进屏幕时通过getScrapView方法来获取一个废弃过的View,达到复用的效果。

究竟是不是这样?我们分析完源码就知道

ListView的布局方式

我们知道 每个显示在界面上的View,都会经历onMeasure、onLayout、onDraw三个过程。

看ListView的onMeasure流程,并没有啥值得深挖的地方

onDraw方面,ListView本身除了绘制下分割线这些,并不负责每个item的绘制,所以它的重点和强大之处应该是在于如何布局,也就是onLayout

ListView并没有直接实现onlayout,而它的基类AbsListView实现了,并且在onLayout里面调用了一个layoutChildren的空方法

这个空方法交由ListView来实现,我们看下layoutChildren方法:

    @Override
    protected void layoutChildren() {

     ....
    final int childCount = getChildCount();
    final RecycleBin recycleBin = mRecycler;
    // 1
    if (dataChanged) {
        for (int i = 0; i < childCount; i++) {
            recycleBin.addScrapView(getChildAt(i), firstPosition+i);
        }
    } else {
        recycleBin.fillActiveViews(childCount, firstPosition);
    }
    // Clear out old views
    detachAllViewsFromParent();
     ...

     default:
        if (childCount == 0) {
            if (!mStackFromBottom) {
                final int position = lookForSelectablePosition(0, true);
                setSelectedPositionInt(position);
                // 2
                sel = fillFromTop(childrenTop);
            } else {
                final int position = lookForSelectablePosition(mItemCount - 1, false);
                setSelectedPositionInt(position);
                sel = fillUp(mItemCount - 1, childrenBottom);
            }
        } else {
            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;
    }
    // Flush any cached views that did not get reused above
      recycleBin.scrapActiveViews();
    ...

    }

这里面会列出几个layoutMode,比如setSelection的时候的layoutMode,这里正常我们setAdapter的话就会走这个LAYOUT_NORMAL,

我在代码里面只贴出两个重点的地方,直接看这个流程

首先第一个重点是:

    if (dataChanged) {
        for (int i = 0; i < childCount; i++) {
            recycleBin.addScrapView(getChildAt(i), firstPosition+i);
        }
    } else {
        recycleBin.fillActiveViews(childCount, firstPosition);
    }
  // Clear out old views
    detachAllViewsFromParent();

mDataChanged就是只有在数据要发生改变的时候才会设置成true(mDataChanged在AbsListView被多处地方设置标记,这里不深究)

第一次执行的话,View还没有被加载到ListView上,所以这里dataChanged为false,会执行recycleBin.fillActiveViews(childCount, firstPosition);

childCount是从getChildCount中来的,第一次是0,所以这里即使调用了recycleBin.fillActiveViews也没啥用

但是下一次有初始数据了的话,fillActiveViews就有作用了,我们知道它记录了当前ListView上显示的View的引用。

然后注意接下来会调用detachAllViewsFromParent方法移除掉ListView所有的View。
要保证这次layout的过程不会被上一次所影响,所以会移除掉所有View。
这个就跟getActiveView挂钩了,因为ListView上的view被移除了,但是却被记录在了RecycleBin里面,等下第二次布局的时候要用到View,就可以直接拿这个View来做改动,而没必要重新new一个

第二个重点我们看下

第一次的话,childCount肯定是0,

mStackFromBottom变量是表示列表要从头开始显示,还是从尾部开始。
mStackFromBottom貌似不常用,如果我们想从尾部开始显示,对应的方法是:

lv.setStackFromBottom(true);

默认是false,所以会执行这个分支

 if (childCount == 0) {
            if (!mStackFromBottom) {
                final int position = lookForSelectablePosition(0, true);
                setSelectedPositionInt(position);
                // 2
                sel = fillFromTop(childrenTop);
            }
        }

重点的方法就来到了fillFromTop方法,这里先插播一下接下来调用的这句代码recycleBin.scrapActiveViews();

在上面我们讲RecycleBin的时候没讲这个方法,scrapActiveViews()方法就是把多余的ActiveView转化成ScrapView,因为到这一步已经是布局完成了,没必要去记录ActiveView了

回到上面来,那么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);
    }

注意传递的nextTop的值是来自:

final int childrenTop = mListPadding.top;

通常我们不设置ListView的paddingTop的话,那么这里传进来的nextTop就是0,

fillFromTop方法简单判断了下起始位置的逻辑后,调用了fillDown方法:

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

源码不多,都看看下。

首先是end变量,取的是mBottom - mTop,相当于getHeight(),如果我们让ListView铺满屏幕,那么就是一个屏幕的高度了

而在while循环里面有: nextTop = child.getBottom() + mDividerHeight;

然后进来一个循环:while (nextTop < end && pos < mItemCount)

判断nextTop < end ,nextTop 是我们传进来的值,通常来说一开始的话 也没设置paddingTop,它就是0

可以发现nextTop就是记录了下一个元素要布局的位置

第二个条件是pos < mItemCount 这个是要确保小标一定得小于长度 没毛病。

因为可能没那么多元素,还不能布满listView的高度。

到这里我们也知道了ListView的布局规则:不管ListView有多少个元素,总是只布局当前能显示在ListView上的元素,其余的元素不会被布局

ListView的元素创建流程

接下来的重点就是这一句了:

 View child = makeAndAddView(pos, nextTop, true, mListPadding.left, selected);

它决定了ListView是如何获取View的,makeAndAddView方法如下:

    private View makeAndAddView(int position, int y, boolean flow, int childrenLeft,
            boolean selected) {
        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;
            }
        }

        // Make a new view for this position, or convert an unused view if
        // possible.
        final View child = obtainView(position, mIsScrap);

        // This needs to be positioned and measured.
        setupChild(child, position, y, flow, childrenLeft, selected, mIsScrap[0]);

        return child;
    }

这里判断mDataChanged,一开始是false,所以会走if里面的逻辑,但是第一次layout时 mRecycler.getActiveView(position)肯定是为null

如果是第二次layout了话,这里有值了也就拿得到了。

而ListView在布局的时候需要先清理掉旧的View,再重新布局。

这种情况下已经调用过mRecycler.fillActiveViews方法缓存了当前屏幕上的View了,在这里做恢复就OK了,而不用重复创建

如果获取不到ActiveView,通常就是第一次的时候。则只能到obtainView(position, mIsScrap);这里拿了。

我们看下obtainView方法:

View obtainView(int position, boolean[] outMetadata) {

        ...

        final View scrapView = mRecycler.getScrapView(position);
        final View child = mAdapter.getView(position, scrapView, this);
        if (scrapView != null) {
            if (child != scrapView) {
                // Failed to re-bind the data, return scrap to the heap.
                mRecycler.addScrapView(scrapView, position);
            } else if (child.isTemporarilyDetached()) {
                outMetadata[0] = true;

                // Finish the temporary detach started in addScrapView().
                child.dispatchFinishTemporaryDetach();
            }
        }

       ...

        return child;
    }

我们挑出了以上的重点方法,看看这两句:

        final View scrapView = mRecycler.getScrapView(position);
        final View child = mAdapter.getView(position, scrapView, this);

先从RecyclerBin中获取一个scrapView,然后调用Adapter中我们熟悉的getView方法。
我们平时写getView方法的时候会都判断convertView==null来复用,这里就是会去复用一个已经废弃过的View,让我们在getView方法里面不需要再去创建
当然 一开始也拿不到废弃的View,所以ListView能显示几个条目,这里就会创建几个View了

然后下面再做了一层判断:

 if (child != scrapView) {
        // Failed to re-bind the data, return scrap to the heap.
        mRecycler.addScrapView(scrapView, position);
 }

尽管把废弃的View给我们调出来用,但是我们不一定会用它,如果没用它的话而去创建个新的View,那么这里就把新的加入进来

不管是走mRecycler.getActiveView拿到activeView,还是走了obtainView方法,接下来都会调用setupChild方法,该方法也比较长。也不是我们的重点,所以不再说了。

里面最主要的就是调用了addViewInLayout方法,最终调用addViewInner方法完成child的添加(我们熟悉的addView方法最终也是调用addViewInner方法)

ListView滑动加载过程

上面我们只是讲了ListView在初始化数据的过程,那如果ListView有100条数据,我们在滑动的过程中,是怎么样的呢?

我们找下滑动事件,发现是放在了AbsListView的onTouchEvent里面,由于我们关心的是滑动的过程,也就是ACTION_MOVE。
(注意低版本的SDK这里好像对各个事件单独封装方法)
所以会调用onTouchMove()方法,在里面判断了mTouchMode。

正常来讲,我们手指滑动的时候mTouchMode是TOUCH_MODE_SCROLL,那么会执行scrollIfNeeded方法

这个方法也很长,我们没办法去仔细分析它的过程。我们要抓的是重点

 private void scrollIfNeeded(int x, int y, MotionEvent vtev){
    ...
    int rawDeltaY = y - mMotionY;
    final int deltaY = rawDeltaY;
    ...
    int incrementalDeltaY =
         mLastY != Integer.MIN_VALUE ? y - mLastY + scrollConsumedCorrection : deltaY;
    if (incrementalDeltaY != 0) {
         atEdge = trackMotionScroll(deltaY, incrementalDeltaY);
    }
    ...
    mLastY = y + lastYCorrection + scrollOffsetCorrection;
 }

scrollIfNeeded的重点在这里,当然它还有其他各种复杂的滑动情况我也分析不了。

看代码mMotionY是按下的时候记录的y坐标,那么deltaY就是手指滑动的距离

mLastY是记录上一次滑动的距离

所以incrementalDeltaY也就是一个增量,表名这个move事件在y轴上偏移了多少

然后会把eltaY(手指滑动的距离)和incrementalDeltaY(增量)传递给trackMotionScroll方法,剩下的逻辑在里面完成

boolean trackMotionScroll(int deltaY, int incrementalDeltaY) {

    ...
    final int height = getHeight() - mPaddingBottom - mPaddingTop;
   if (incrementalDeltaY < 0) {
            incrementalDeltaY = Math.max(-(height - 1), incrementalDeltaY);
        } else {
            incrementalDeltaY = Math.min(height - 1, incrementalDeltaY);
        }

    ...

    final boolean down = incrementalDeltaY < 0;

    if (down) {
        int top = -incrementalDeltaY;
        if ((mGroupFlags & CLIP_TO_PADDING_MASK) == CLIP_TO_PADDING_MASK) {
            top += listPadding.top;
        }
        for (int i = 0; i < childCount; i++) {
            final View child = getChildAt(i);
            if (child.getBottom() >= top) {
                break;
            } else {
               ...
               int position = firstPosition + i;
                mRecycler.addScrapView(child, position);
            }
        }
    } else {
        int bottom = getHeight() - incrementalDeltaY;
        if ((mGroupFlags & CLIP_TO_PADDING_MASK) == CLIP_TO_PADDING_MASK) {
            bottom -= listPadding.bottom;
        }
        for (int i = childCount - 1; i >= 0; i--) {
            final View child = getChildAt(i);
            if (child.getTop() <= bottom) {
                break;
            } else {
                ...
                int position = firstPosition + i;
                mRecycler.addScrapView(child, position);
            }
        }
    }
   final int absIncrementalDeltaY = Math.abs(incrementalDeltaY);
        if (spaceAbove < absIncrementalDeltaY || spaceBelow < absIncrementalDeltaY) {
            fillGap(down);
        }
}

同样,我精简掉了N多代码,让我们抓重点来看。

我们知道传进来了incrementalDeltaY是个增量,在里面会判断incrementalDeltaY是否小于0

我们知道,Android的坐标系是以左上角为原点的,从原点以右为x轴正方向,从原点向下为y轴的正方向(有区别与数学上的坐标系的第四象限)

所以我们手指在往下滑的时候,y轴的数值会递增,那么他们之间的差值(end - start)就是大于0的

相反往上滑的话那么差值就是个负数。

在这里判断incrementalDeltaY小于0,那么就是手指往上滑,则down为true,这里的down是针对于ListView来说,对它来说就是往下滚动

这时候会遍历ListView中当前的view,如果直到遇到child.getBottom() >= top才跳出,怎么理解?

top就是 top = -incrementalDeltaY;; 也就是这次到来的move事件滑动的距离

而child.getBottom()就是与ListView顶部的距离,

如果child距离顶部的距离比这次滑动事件的距离还小,说明顶部的这个View被划出了屏幕

也就是child.getBottom() < top那就是有child被滑出顶部,需要回收

这个时候就调用了mRecycler.addScrapView(child, position);来回收这个child

当下个child的底部距离顶部比这次滑动事件的距离大,则说明还没滑出屏幕,那么后面的更不会滑出屏幕,所以就跳出循环

讲完了手指上滑这个过程,那么手指下滑的时候 也就是down=false也是一样的道理

只不过判断的是从底部的child开始判断它的child.getTop()是否已经划出屏幕了,

在这个滑动的同时,有回收view,当然也有新的view进来啊,比如我们手指往上滑,ListView顶部的child被回收,同时底部也有child被添加进来,我们看下

逻辑就是在这个fillGap方法里:

   void fillGap(boolean down) {
        final int count = getChildCount();
        if (down) {
            int paddingTop = 0;
            if ((mGroupFlags & CLIP_TO_PADDING_MASK) == CLIP_TO_PADDING_MASK) {
                paddingTop = getListPaddingTop();
            }
            final int startOffset = count > 0 ? getChildAt(count - 1).getBottom() + mDividerHeight :
                    paddingTop;
            fillDown(mFirstPosition + count, startOffset);
            correctTooHigh(getChildCount());
        } else {
            int paddingBottom = 0;
            if ((mGroupFlags & CLIP_TO_PADDING_MASK) == CLIP_TO_PADDING_MASK) {
                paddingBottom = getListPaddingBottom();
            }
            final int startOffset = count > 0 ? getChildAt(0).getTop() - mDividerHeight :
                    getHeight() - paddingBottom;
            fillUp(mFirstPosition - 1, startOffset);
            correctTooLow(getChildCount());
        }
    }

这个方法里面会根据down的正负决定方向,从而决定调用fillDown还是fillUp,
而fillDown我们前面讲过,fillUp没讲但是也是同一个道理。

所以在这个move事件过程就是判断顶部或底部的child是否需要回收,然后再进行调用fillDown或fillUp来重新填充child

你可能感兴趣的:(移动开发,Android开发知识点)