Android architect's in-depth understanding of RecyclerView reuse and caching mechanism

This article is reprinted from the WeChat public account "Android Development Programming", the author is Android Development Programming. Please contact the Android Development Programming public account for reprinting this article.

Preface

Learning source code and studying source code programming ideas are the only way for programmers to advance

Everyone knows that RecyclerView has a recycling and reuse mechanism, so how does the recycling and reuse mechanism work?

Today we will use source code to explain and learn together

1. Recycler Introduction

RecyclerView is a cache managed by the internal class Recycler, so what is cached in Recycler? We know that RecyclerView can still slide smoothly when there is a lot of data, and RecyclerView itself is a ViewGroup, so it is inevitable to add or remove sub-Views when sliding (sub-Views are created through onCreateViewHolder in RecyclerView#Adapter). If the sub-Views have to be recreated every time they are used, it will definitely affect the smoothness of sliding. Therefore, RecyclerView caches ViewHolder (which contains sub-Views) through Recycler, so that sub-Views can be reused when sliding, and under certain conditions, the data bound to sub-Views can also be reused. So in essence, caching is to reduce the time of repeatedly drawing Views and binding data, thereby improving the performance of sliding.

 public final class Recycler {
        final ArrayList<ViewHolder> mAttachedScrap = new ArrayList<>();
        ArrayList<ViewHolder> mChangedScrap = null ;
        final ArrayList<ViewHolder> mCachedViews = new ArrayList<ViewHolder>();
        private final List<ViewHolder>
                mUnmodifiableAttachedScrap = Collections.unmodifiableList(mAttachedScrap);
        private int mRequestedCacheMax = DEFAULT_CACHE_SIZE;
 int mViewCacheMax = DEFAULT_CACHE_SIZE;
        RecycledViewPool mRecyclerPool;
        private ViewCacheExtension mViewCacheExtension;
 static final int DEFAULT_CACHE_SIZE = 2;

Recycler caches ViewHolder objects at four levels, with the priorities from high to low being:

1. ArrayList mAttachedScrap --- Cache the ViewHolder of the visible range on the screen

2. ArrayList mCachedViews ---- caches the ViewHolder that will be separated from the RecyclerView when sliding, cached by the position or id of the child View, and stores up to 2 by default

3. ViewCacheExtension mViewCacheExtension --- Cache implemented by the developer

4. RecycledViewPool mRecyclerPool --- ViewHolder cache pool, which is essentially a SparseArray, where the key is ViewType (int type) and the value is ArrayList< ViewHolder>. By default, each ArrayList can store up to 5 ViewHolders.

2. Detailed Analysis of Cache Mechanism

When RecyclerView slides, onTouchEvent#onMove is triggered, and the recycling and reuse of ViewHolder will begin here. We know that when setting RecyclerView, we need to set LayoutManager. LayoutManager is responsible for the layout of RecyclerView, including the acquisition and reuse of ItemView. Taking LinearLayoutManager as an example, when RecyclerView is rearranged, the following methods will be executed in sequence:

onLayoutChildren(): Entry method for layout of RecyclerView

fill(): Responsible for continuously filling the remaining space, the calling method is layoutChunk()

layoutChunk(): Responsible for filling the View, which is ultimately found by finding a suitable View in the cache class Recycler

The entire call chain above: onLayoutChildren()->fill()->layoutChunk()->next()->getViewForPosition(), getViewForPosition() is to get the appropriate View from the RecyclerView recycling mechanism implementation class Recycler,

The following mainly looks at the implementation of Recycler#getViewForPosition().

 @NonNull
 public   View getViewForPosition( int position) {
 return getViewForPosition(position, false );
 }
 View getViewForPosition( int position, boolean dryRun) {
 return tryGetViewHolderForPositionByDeadline(position, dryRun, FOREVER_NS).itemView;
 }

They will all execute the tryGetViewHolderForPositionByDeadline function and continue to follow it:

//Get ViewHolder according to the passed position

 ViewHolder tryGetViewHolderForPositionByDeadline( int position,
        boolean dryRun, long deadlineNs) {
 ...omitted
    boolean fromScrapOrHiddenOrCache = false ;
    ViewHolder holder = null ;
 //Pre-layout is a special case. Get ViewHolder from mChangedScrap
    if (mState.isPreLayout()) {
        holder = getChangedScrapViewForPosition(position);
        fromScrapOrHiddenOrCache = holder != null ;
 }
 if (holder == null ) {
 //1. Try to get the ViewHolder from mAttachedScrap. At this time, the ViewHolder in the visible range of the screen is obtained.
 //2. If there is no ViewHolder in the mAttachedScrap cache, continue to try to get the ViewHolder from mCachedViews
        holder = getScrapOrHiddenOrCachedHolderForPosition(position, dryRun);
 ...omitted
 }
 if (holder == null ) {
        final int offsetPosition = mAdapterHelper.findPositionOffset(position);
 ...omitted
        final int type = mAdapter.getItemViewType(offsetPosition);
 //If the Adapter declares an ID, try to get it from the ID, which is not cached here
        if (mAdapter.hasStableIds()) {
            holder = getScrapOrCachedViewForId(mAdapter.getItemId(offsetPosition),
                    type, dryRun);
 }
        if (holder == null && mViewCacheExtension != null ) {
 3. Try to get ViewHolder from the custom cache mViewCacheExtension, which needs to be implemented by the developer
 final View   view = mViewCacheExtension
                    .getViewForPositionAndType(this, position, type);
            if ( view != null ) {
                holder = getChildViewHolder( view );
 }
 }
        if (holder == null ) { // fallback to pool
 //4. Try to get ViewHolder from the cache pool mRecyclerPool
            holder = getRecycledViewPool().getRecycledView(type);
            if (holder != null ) {
 //If the acquisition is successful, the ViewHolder state will be reset, so you need to re-execute Adapter#onBindViewHolder to bind the data
                holder.resetInternal();
                if (FORCE_INVALIDATE_DISPLAY_LIST) {
                    invalidateDisplayListInt(holder);
 }
 }
 }
        if (holder == null ) {
 ...omitted
 //5. If no corresponding ViewHolder is found in the above cache, onCreateViewHolder in Adapter will be called to create one
            holder = mAdapter.createViewHolder(RecyclerView.this, type);
 }
 }
 boolean bound = false ;
    if (mState.isPreLayout() && holder.isBound()) {
        holder.mPreLayoutPosition = position;
    } else if (!holder.isBound() || holder.needsUpdate() || holder.isInvalid()) {
        final int offsetPosition = mAdapterHelper.findPositionOffset(position);
 //6. If data needs to be bound, Adapter#onBindViewHolder will be called to bind the data
        bound = tryBindViewHolderByDeadline(holder, offsetPosition, position, deadlineNs);
 }
 ...omitted
 return holder;
 }

The ViewHolder obtained through mAttachedScrap, mCachedViews and mViewCacheExtension does not need to recreate the layout and bind data; the ViewHolder obtained through the cache pool mRecyclerPool does not need to recreate the layout, but needs to rebind the data; if the target ViewHolder is not obtained in the above cache, Adapter#onCreateViewHolder will be called back to create the layout, and Adapter#onBindViewHolder will be called back to bind the data

Summarize

There are two structures involved in the recycling and reuse of RecyclerView in the sliding scenario:

• mCachedViews and RecyclerViewPool
• mCachedViews has a higher priority than RecyclerViewPool. When recycling, the latest ViewHolder is placed in mCachedViews. If it is full, one is removed and thrown into ViewPool to make room to cache the latest ViewHolder.
• When reusing, the ViewHolder is also first found in mCachedViews, but various matching conditions are required. In summary, only the card position in the original position can reuse the ViewHolder in mCachedViews. If there is no ViewHolder in mCachedViews, then it will be found in ViewPool.
• The ViewHolders in the ViewPool are the same as the new ViewHolders. As long as the type is the same and it is found, it can be reused and the data can be re-bound.