RecyclerView(三):LayoutManager职责及相关方法

概述

在RecyclerView之前,对于线性布局和网格布局用的基本上是ListView和GridView,到RecyclerView,就不需要这么麻烦了,RecyclerView对于职责划分的很明确,布局相关的就只需要LayoutManager,继承LayoutManager就可以实现你想要的布局,比如android为我们提供的一下几个布局:

  1. 线性布局:LinearLayoutManager
  2. 网格布局:GridLayoutManager
  3. 瀑布流布局:StaggerGridLayoutManager

这些布局管理都直接或间接实现了LayoutManager,这也就是LayoutManager的主要作用:布局管理。
LayoutManager是RecyclerView的内部类,RecyclerView把它的测量和布局工作都转交给了LayoutManager,如果你想要的布局android没有给你提供,那么就可以考虑去继承LayoutManager去实现。

这几个布局提供的常见方法

  • findFirstCompletelyVisibleItemPosition()
  • findFirstVisibleItemPosition()
  • findLastCompletelyVisibleItemPosition()
  • findLastVisibleItemPosition()
  • onSaveInstanceState()
  • onRestoreInstanceState()

前面四个方法好理解,看名字应该就能知道,找到最前最后显示item的位置,其中含有Completely的方法返回的是完全可见的第一个item,而不含的则是真正的第一个item,这个item可能只显示了一部分,这个显示需要注意一点,比如使用的LinearLayoutManager布局,这个可见指的是布局方向上的可见。
onSaveInstanceState():
对于onSaveInstanceState()这个方法肯定很多人都见过,那就是在Activity中就有这个方法,当Activity异常销毁(比如由于内存过大)时就会调用到这个方法,而在LayoutManager中提供的这个方法是一个空方法,在他的子类中提供了实现,这里看下在LinearLayoutManager中的实现:

    @Override
    public Parcelable onSaveInstanceState() {
        if (mPendingSavedState != null) {
            return new SavedState(mPendingSavedState);
        }
        SavedState state = new SavedState();
        // RecyclerView中是否含有子view,如果有就会保存子view的状态
        if (getChildCount() > 0) {
            ensureLayoutState();
            boolean didLayoutFromEnd = mLastStackFromEnd ^ mShouldReverseLayout;
            state.mAnchorLayoutFromEnd = didLayoutFromEnd;
            //判断布局是否是倒序
            if (didLayoutFromEnd) {
            // 倒序布局
                final View refChild = getChildClosestToEnd();
                state.mAnchorOffset = mOrientationHelper.getEndAfterPadding()
                        - mOrientationHelper.getDecoratedEnd(refChild);
                state.mAnchorPosition = getPosition(refChild);
            } else {
            // 顺序布局,可以看到,state中主要是保存两个变量,一个是当前显示第一个view所在的position,另一个是当前这个
            // view没有显示的偏移量
                final View refChild = getChildClosestToStart();
                state.mAnchorPosition = getPosition(refChild);
                state.mAnchorOffset = mOrientationHelper.getDecoratedStart(refChild)
                        - mOrientationHelper.getStartAfterPadding();
            }
        } else {
            state.invalidateAnchor();
        }
        return state;
    }

这里可以看出主要是保存了两个变量,保存的这两个变量有什么用呢?主要是在RecyclerView被remove后再次添加进来时可以恢复上一次显示item的位置,什么意思呢?先来看下下面这个界面:
RecyclerView(三):LayoutManager职责及相关方法_第1张图片
可以看到这个布局的最外层是一个RecyclerView,里面的子item还有RecyclerView,当我们往上滑的时候,子RecyclerView最终是会被reMove()掉的,子RecyclerView中的子item的显示的位置信息是不会被记录的,当再次往回滑的时候,子RecyclerView显示的总是会是第一个,如果想往回滑的时候,子RecyclerView显示的总是上次滑动到的位置,那么要怎么去是想呢?这时候就可以用到上面提到的onSaveInstanceState(),在这个方法里正好会保存RecyclerView的位置信息,当我们往回滑添加的之前被回收的RecyclerView时,那就可以将上次保存的位置信息取出来再次添加进去就可以了,思路是有了,接下来就是如何在代码中去实现了,首先是回收的时候保存信息,关于item的回收,想到的就是Adapter的onViewRecycled()方法,接下来就是去恢复它的位置信息了,我想到的就是onBindViewHolder()中可以去恢复它的位置信息,毕竟reMove()的item都会调用到这个方法(detach掉的view本身就会保留它本身的信息,不需要我们维护),下面是一些实现的关键代码:
1.确定当前的item当中是否含有RecyclerView:

    RecyclerView findNestedRecyclerView(@NonNull View view) {
        if (!(view instanceof ViewGroup)) {
            return null;
        }
        if (view instanceof RecyclerView) {
            return (RecyclerView) view;
        }
        final ViewGroup parent = (ViewGroup) view;
        final int count = parent.getChildCount();
        for (int i = 0; i < count; i++) {
            final View child = parent.getChildAt(i);
            final RecyclerView descendant = findNestedRecyclerView(child);
            if (descendant != null) {
                return descendant;
            }
        }
        return null;
    }

2.回收时保存当前RecyclerView中item的位置信息:onViewRecycled()

		private SparseArray rvState = new SparseArray<>();
        @Override
        public void onViewRecycled(@NonNull MyViewHolder holder) {
            super.onViewRecycled(holder);
            RecyclerView nestedRecyclerView = findNestedRecyclerView(holder.itemView);
            if (nestedRecyclerView != null) {
                Parcelable parcelable = nestedRecyclerView.getLayoutManager().onSaveInstanceState();
                // 保存时key为当前item所处的位置position,值为子RecyclerView的子item的显示位置信息
                rvState.put(holder.getAdapterPosition(),parcelable);
            }
        }

3.重新绑定时恢复RecyclerView中item的位置信息,onBindViewHolder():

        @Override
        public void onBindViewHolder(@NonNull MyViewHolder myViewHolder, int i) {
            Log.d(TAG, "onBindViewHolder: position = "+i);
            // 这里type=0的item的布局中就有RecyclerView
            if (getItemViewType(i) == 0) {
                myViewHolder.rv.setLayoutManager(new LinearLayoutManager(TestRVActivity.this,RecyclerView.HORIZONTAL,false));
                // 获取当前position之前回收时的位置信息,如果不为null,那么就恢复之前的位置信息
                Parcelable parcelable = rvState.get(i);
                if (parcelable != null) {
                    rvState.remove(i);
                    // 
                    myViewHolder.rv.getLayoutManager().onRestoreInstanceState(parcelable);
                }
                if (myViewHolder.rv.getAdapter() == null) {
                    myViewHolder.rv.setAdapter(new MyChildAdapter());
                }
                return;
            }
        }

自定义LayoutManager

如果需要实现自定义布局,那么可以实现generateDefaultLayoutParams()和onLayoutChildren(),第二个方法主要就是给他进行布局,能不能滑动主要由canScrollHorizontally()和canScrollVertically()进行决定,返回true表示可以滑动,当然,滑动也是需要我们进行处理的,scrollHorizontallyBy()和scrollVerticallyBy()就是让我们来处理滑动的,可以在这两个方法中调用offsetChildrenHorizontal()进行滑动处理。这里看下我写的一个小demo,可以好好理解下:

public class CustomeLayoutManager extends RecyclerView.LayoutManager {
    private static final String TAG = "CustomeLayoutManager";
    public static final int HORIZONTAL = 0;
    public static final int VERTICAL = 1;

    @IntDef({VERTICAL, HORIZONTAL})
    public @interface OrientationType {
    }

    @OrientationType
    private int mOrientation;
    private int mRows;
    private int mColms;
    private int mOnePageSize;
    private int mMoveDistance;
    private int mMaxScrollX;
    private int mMaxScrollY;
    private SparseArray<Rect> mItemFramsList = new SparseArray<>();

    public CustomeLayoutManager(@IntRange(from = 1, to = 30) int row, @IntRange(from = 1, to = 30) int col, @OrientationType int orientation) {
        this.mRows = row;
        this.mColms = col;
        mOnePageSize = mRows * mColms;
        this.mOrientation = orientation;
    }


    @Override
    public RecyclerView.LayoutParams generateDefaultLayoutParams() {
        return new RecyclerView.LayoutParams(ViewGroup.LayoutParams.WRAP_CONTENT, ViewGroup.LayoutParams.WRAP_CONTENT);
    }

    @Override
    public boolean canScrollHorizontally() {
        return mOrientation == HORIZONTAL;
    }

    @Override
    public boolean canScrollVertically() {
        return mOrientation == VERTICAL;
    }

    private int getWidthUse() {
        int width = getWidth() - getPaddingLeft() - getPaddingRight();
        return width;
    }

    private int getHeightUse() {
        return getHeight() - getPaddingTop() - getPaddingBottom();
    }

    private int getItemWidth() {
        return getWidthUse() / mColms;
    }

    private int getItemHeight() {
        return getHeightUse() / mRows;
    }

    private Rect getItemFrameByPosition(int position) {
        Rect rect = mItemFramsList.get(position);
        if (rect == null) {
            rect = new Rect();
            int currentPage = position / mOnePageSize;
            //当前页编译量
            int offsetX = 0;
            int offsetY = 0;
            if (canScrollHorizontally()) {
                offsetX = getWidthUse() * currentPage;
            } else {
                offsetY = getHeightUse() * currentPage;
            }
            int itemIndex = position % mOnePageSize;
            int rowIndex = itemIndex / mColms;
            int colIndex = itemIndex % mColms;
            offsetX += colIndex * getItemWidth();
            offsetY += rowIndex * getItemHeight();
            rect.left = offsetX;
            rect.top = offsetY;
            rect.right = offsetX + getItemWidth();
            rect.bottom = offsetY + getItemHeight();
        }
        return rect;
    }

    @Override
    public void onLayoutChildren(RecyclerView.Recycler recycler, RecyclerView.State state) {
        int i1 = getItemCount();

        int pageCount = getItemCount() / mOnePageSize;
        if (getItemCount() % mOnePageSize == 0) {
            pageCount--;
        }
        Log.d(TAG, "onLayoutChildren: i1 = " + i1+"   pageCount = "+pageCount+"    width = "+getWidthUse());
        if (canScrollHorizontally()) {
            mMaxScrollX = getWidthUse() * pageCount;
        } else {
            mMaxScrollY = getHeightUse() * pageCount;
        }

        for (int i = 0; i < i1; i++) {
            View childView = recycler.getViewForPosition(i);
            addView(childView);
            Rect rect = getItemFrameByPosition(i);
            measureChildWithMargins(childView, 0, 0);
            RecyclerView.LayoutParams params = (RecyclerView.LayoutParams) childView.getLayoutParams();
            layoutDecorated(childView, rect.left + params.leftMargin, rect.top + params.topMargin,
                    rect.right - params.rightMargin, rect.bottom - params.bottomMargin);
        }
    }

    @Override
    public int scrollHorizontallyBy(int dx, RecyclerView.Recycler recycler, RecyclerView.State state) {
        Log.d(TAG, "scrollHorizontallyBy: mMoveDistance = " + mMoveDistance + "     " + dx+"   mMaxScrollX = "+mMaxScrollX);
        if (mMoveDistance + dx < 0) {
            dx = 0 - mMoveDistance;
        }
        if (mMoveDistance + dx > mMaxScrollX) {
            dx = mMaxScrollX - mMoveDistance;
        }
        mMoveDistance += dx;
        offsetChildrenHorizontal(-dx);
        return dx;
    }
    
}

就写到这了,如果还想更深入的学习,可以自己花点时间在研究下源码。如果有不懂的欢迎一起讨论学习。

你可能感兴趣的:(Android)