ViewPager与ViewPager2的Adapter对比

最新推荐文章于 2024-08-13 18:41:42 发布
最新推荐文章于 2024-08-13 18:41:42 发布
阅读量3.9k 收藏 8
点赞数 2
分类专栏： Android应用层源码阅读 文章标签： jetpack
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_40888127/article/details/108432259
版权

目录

1. ViewPagerAdapter与其两个子类FragmentPagerAdapter、FragmentStatePagerAdapter

1.1. ViewPagerAdapter重要方法剖析

a. instantiateItem(ViewGroup container, int position)

该方法的作用是根据position创建页面，container用于承载被添加的View。

b. setPrimaryItem(ViewGroup container, int position, Object object)

该方法的作用是通知ViewPagerAdapter当前的主page，即展示给用户的当前页面。

c. startUpdate(@NonNull View container)/finishUpdate(@NonNull ViewGroup container)

这两个方法总是成对被调用的，调用时机是展示页面发生变化时。

d. destroyItem(@NonNull View container, int position, @NonNull Object object)

这个方法的调用时机是ViewPager从其类型为ArrayList的成员变量mItems中remove一个对象时，然后通过调用ViewPagerAdapter的destroyItem()方法将container中的View删除。
总结一下：以上几个方法基本上都是在ViewPager中的populate()方法中被调用的，其时序为：

ViewPager ViewPagerAdapter populate() 以下函数均是在populate()中被调用 startUpdate() addNewItem() instantiateItem() 此处调用destroyItem()跟mOffscreenPageLimit有关 destroyItem() setPrimaryItem() finishUpdate() ViewPager ViewPagerAdapter

1.2. FragmentPagerAdapter剖析

该适配器继承自PagerAdapter，主要实现了每个页面是Fragment情况的适配工作，内部通过FragmentManager来管理各个Fragment。只要用户还可以返回到某个页面，该Fragment就会永久保留在片段管理器中。主要工作有两个：

a. 重写instantiateItem()方法，通过mFragmentManager来创建Fragment

public Object instantiateItem(@NonNull ViewGroup container, int position) {
        if (mCurTransaction == null) {
            mCurTransaction = mFragmentManager.beginTransaction();
        }

        final long itemId = getItemId(position);

        // Do we already have this fragment?
        String name = makeFragmentName(container.getId(), itemId);
        Fragment fragment = mFragmentManager.findFragmentByTag(name);
        if (fragment != null) {
        	//如果mFragmentManager中已经存在当前Fragment，则开启一个 ATTATCH事务
            if (DEBUG) Log.v(TAG, "Attaching item #" + itemId + ": f=" + fragment);
            mCurTransaction.attach(fragment);
        } else {
        	//如果mFragmentManager中不存在当前Fragmen，则需要创建一个Fragment，并开启一个ADD事务
            fragment = getItem(position);
            if (DEBUG) Log.v(TAG, "Adding item #" + itemId + ": f=" + fragment);
            mCurTransaction.add(container.getId(), fragment,
                    makeFragmentName(container.getId(), itemId));
        }
        //如果此Fragment不是主Fragm，需根据mBehavior来对Fragment的生命周期降级
        if (fragment != mCurrentPrimaryItem) {
            fragment.setMenuVisibility(false);
            if (mBehavior == BEHAVIOR_RESUME_ONLY_CURRENT_FRAGMENT) {
            	//最多会执行到onStart()回调
                mCurTransaction.setMaxLifecycle(fragment, Lifecycle.State.STARTED);
            } else {
            	//采用原来的setUserVisibleHint(false)处理方式，//注意此处传入参数为false
                fragment.setUserVisibleHint(false);
            }
        }
        return fragment;
    }

b. 重写setPrimaryItem()方法，设置主Fragment的生命周期为RESUMED，将即将隐藏的原主Fragment的生命周期降级为STARTED

public void setPrimaryItem(@NonNull ViewGroup container, int position, @NonNull Object object) {
        Fragment fragment = (Fragment)object;
        //
        if (fragment != mCurrentPrimaryItem) {
        	//当mCurrentPrimaryItem != null时，原主Fragment即将隐藏
            if (mCurrentPrimaryItem != null) {
                mCurrentPrimaryItem.setMenuVisibility(false);
                if (mBehavior == BEHAVIOR_RESUME_ONLY_CURRENT_FRAGMENT) {
                    if (mCurTransaction == null) {
                        mCurTransaction = mFragmentManager.beginTransaction();
                    }
                    mCurTransaction.setMaxLifecycle(mCurrentPrimaryItem, Lifecycle.State.STARTED);
                } else {
                    mCurrentPrimaryItem.setUserVisibleHint(false);
                }
            }
            fragment.setMenuVisibility(true);
            //将主Fragement的生命周期设置为RESUMED
            if (mBehavior == BEHAVIOR_RESUME_ONLY_CURRENT_FRAGMENT) {
                if (mCurTransaction == null) {
                    mCurTransaction = mFragmentManager.beginTransaction();
                }
                mCurTransaction.setMaxLifecycle(fragment, Lifecycle.State.RESUMED);
            } else {
            	//注意此处传入参数为true
                fragment.setUserVisibleHint(true);
            }

            mCurrentPrimaryItem = fragment;
        }
    }

1.3. FragmentStatePagerAdapter剖析

该适配器也继承自PagerAdapter，其功能和FragmentPagerAdapter类似，主要也是重写instantiateItem()方法和setPrimaryItem()方法通过FagmentManager来管理Fragment。与其不同的是FragmentStatePagerAdapter还是实现了Fragment的缓存功能，通过类型为ArrayListy的成员变量mSavedState和mFragments来实现。

a. instantiateItem()方法的不同实现

public Object instantiateItem(@NonNull ViewGroup container, int position) {
        //如果能从mFragments缓存中拿到该position对应的Fragment立即返回该Fagement
        if (mFragments.size() > position) {
            Fragment f = mFragments.get(position);
            if (f != null) {
                return f;
            }
        }

        if (mCurTransaction == null) {
            mCurTransaction = mFragmentManager.beginTransaction();
        }
		//如果mFragments缓存中不存在该position对应的Fragment，则通过getItem()创建一个Fragment
        Fragment fragment = getItem(position);
        if (DEBUG) Log.v(TAG, "Adding item #" + position + ": f=" + fragment);
        if (mSavedState.size() > position) {
        	//如果mSavedState缓存中存在该position对应的SavedState对象，则将该对象赋值给新创建的Fragment的mSavedFragmentState变量，
        	//用于该新Fragment恢复原来的数据。
            Fragment.SavedState fss = mSavedState.get(position);
            if (fss != null) {
                fragment.setInitialSavedState(fss);
            }
        }
        while (mFragments.size() <= position) {
            mFragments.add(null);
        }
        fragment.setMenuVisibility(false);
        //原处理方式setUserVisibleHint(false)
        if (mBehavior == BEHAVIOR_SET_USER_VISIBLE_HINT) {
            fragment.setUserVisibleHint(false);
        }
		//	将当前Fragment缓存在mFragments列表中
        mFragments.set(position, fragment);
        mCurTransaction.add(container.getId(), fragment);

        if (mBehavior == BEHAVIOR_RESUME_ONLY_CURRENT_FRAGMENT) {
            mCurTransaction.setMaxLifecycle(fragment, Lifecycle.State.STARTED);
        }

        return fragment;
    }

b. setPrimaryItem()的实现与FragmentPagerAdapter类中的实现是相同的

c. 重写saveState()

ViewPager重写了View的onSaveInstanceState()方法，在该方法中又会调用FragmentStatePagerAdapter的saveState()来将mSavedState与mFragments存储在Bundle对象中。

public Parcelable saveState() {
        Bundle state = null;
        //存储mSavedState
        if (mSavedState.size() > 0) {
            state = new Bundle();
            Fragment.SavedState[] fss = new Fragment.SavedState[mSavedState.size()];
            mSavedState.toArray(fss);
            state.putParcelableArray("states", fss);
        }
        //存储mFragments
        for (int i=0; i<mFragments.size(); i++) {
            Fragment f = mFragments.get(i);
            if (f != null && f.isAdded()) {
                if (state == null) {
                    state = new Bundle();
                }
                String key = "f" + i;
                mFragmentManager.putFragment(state, key, f);
            }
        }
        return state;
    }

d. 重写restoreState()方法

ViewPager重写了View的onRestoreInstanceState()方法，在该方法中又会调用FragmentStatePagerAdapter的restoreState()方法来恢复存储在Bundle中的mSavedState与mFragments对象。代码逻辑与saveState()是相对应的。

2. FragmentStateAdapter

FragmentStateAdapter继承自RecyclerView.Adapter，下面看一下关键方法的实现。

a. 重写onCreateViewHolder()

返回一个FragmentViewHolder对象，该FragmentViewHolder的根布局为FrameLayout，即itemView为FrameLayout对象。

b. 重写onBindViewHolder()

重写该方法主要做三件事：

  1. 更新mItemIdToViewHolder
  2. 创建Fragment
  3. 垃圾回收无用Fragment
public final void onBindViewHolder(final @NonNull FragmentViewHolder holder, int position) {
        final long itemId = holder.getItemId();
        final int viewHolderId = holder.getContainer().getId();
        final Long boundItemId = itemForViewHolder(viewHolderId); // item currently bound to the VH
        if (boundItemId != null && boundItemId != itemId) {
            removeFragment(boundItemId);
            mItemIdToViewHolder.remove(boundItemId);
        }
		//1. 更新mItemIdToViewHolder
        mItemIdToViewHolder.put(itemId, viewHolderId); // this might overwrite an existing entry
        //2. 创建Fragment
        ensureFragment(position);

        /** Special case when {@link RecyclerView} decides to keep the {@link container}
         * attached to the window, but not to the view hierarchy (i.e. parent is null) */
        final FrameLayout container = holder.getContainer();
        if (ViewCompat.isAttachedToWindow(container)) {
            if (container.getParent() != null) {
                throw new IllegalStateException("Design assumption violated.");
            }
            container.addOnLayoutChangeListener(new View.OnLayoutChangeListener() {
                @Override
                public void onLayoutChange(View v, int left, int top, int right, int bottom,
                        int oldLeft, int oldTop, int oldRight, int oldBottom) {
                    if (container.getParent() != null) {
                        container.removeOnLayoutChangeListener(this);
                        placeFragmentInViewHolder(holder);
                    }
                }
            });
        }
		//3. 垃圾回收无用Fragment
        gcFragments();
    }

在ensureFragment()方法中会调用createFragment()虚方法来创建Fragment，需要通过子类实现自己的创建逻辑：

private void ensureFragment(int position) {
        long itemId = getItemId(position);
        //当没有position对应的Fragment时才创建
        if (!mFragments.containsKey(itemId)) {
            // TODO(133419201): check if a Fragment provided here is a new Fragment
            Fragment newFragment = createFragment(position);
            newFragment.setInitialSavedState(mSavedStates.get(itemId));
            mFragments.put(itemId, newFragment);
        }
    }

mFragments成员变量缓存了所以使用过的Fragment，gcFragments() 方法在几处被调用，在绑定ViewHolder时是触发垃圾回收的时机之一：

void gcFragments() {
        if (!mHasStaleFragments || shouldDelayFragmentTransactions()) {
            return;
        }

        // Remove Fragments for items that are no longer part of the data-set
        //对于position不在[0, getItemCount()]内的Fragment应该删除
        Set<Long> toRemove = new ArraySet<>();
        for (int ix = 0; ix < mFragments.size(); ix++) {
            long itemId = mFragments.keyAt(ix);
            if (!containsItem(itemId)) {
                toRemove.add(itemId);
                mItemIdToViewHolder.remove(itemId); // in case they're still bound
            }
        }

        // Remove Fragments that are not bound anywhere -- pending a grace period
        //对于没有被绑定到ViewHolder中的Fragment应该删除
        if (!mIsInGracePeriod) {
            mHasStaleFragments = false; // we've executed all GC checks

            for (int ix = 0; ix < mFragments.size(); ix++) {
                long itemId = mFragments.keyAt(ix);
                if (!isFragmentViewBound(itemId)) {
                    toRemove.add(itemId);
                }
            }
        }

        for (Long itemId : toRemove) {
            removeFragment(itemId);
        }
    }

c. 重写onViewAttachedToWindow()方法

重写该方法做两件事：

  1. 将Fragement添加到ViewHolder中
  2. 垃圾回收无用Fragment
public final void onViewAttachedToWindow(@NonNull final FragmentViewHolder holder) {
        placeFragmentInViewHolder(holder);
        gcFragments();
    }

d. 重写onAttachedToRecyclerView()方法

public void onAttachedToRecyclerView(@NonNull RecyclerView recyclerView) {
        checkArgument(mFragmentMaxLifecycleEnforcer == null);
        mFragmentMaxLifecycleEnforcer = new FragmentMaxLifecycleEnforcer();
        mFragmentMaxLifecycleEnforcer.register(recyclerView);
    }

主要是构造一个FragmentMaxLifecycleEnforcer对象，并将recyclerView注册给该对象，管理当前主Fragment与其余非主Fragment的生命周期，主要通过其updateFragmentMaxLifecycle()方法来实现：

void updateFragmentMaxLifecycle(boolean dataSetChanged) {
			//删除部分状态判断代码
			//...
            long currentItemId = getItemId(currentItem);
            if (currentItemId == mPrimaryItemId && !dataSetChanged) {
                return; // nothing to do
            }

            Fragment currentItemFragment = mFragments.get(currentItemId);
            if (currentItemFragment == null || !currentItemFragment.isAdded()) {
                return;
            }

            mPrimaryItemId = currentItemId;
            FragmentTransaction transaction = mFragmentManager.beginTransaction();
			//寻找即将resume的Fragment
            Fragment toResume = null;
            for (int ix = 0; ix < mFragments.size(); ix++) {
                long itemId = mFragments.keyAt(ix);
                Fragment fragment = mFragments.valueAt(ix);

                if (!fragment.isAdded()) {
                    continue;
                }
				//对于不是寻找的对象，即将其最大生命周期设置为STARTED
                if (itemId != mPrimaryItemId) {
                    transaction.setMaxLifecycle(fragment, STARTED);
                } else {
                    toResume = fragment; // itemId map key, so only one can match the predicate
                }

                fragment.setMenuVisibility(itemId == mPrimaryItemId);
            }
            //将寻找到的Fragment的最大生命周期设置为RESUMED
            if (toResume != null) { // in case the Fragment wasn't added yet
                transaction.setMaxLifecycle(toResume, RESUMED);
            }

            if (!transaction.isEmpty()) {
                transaction.commitNow();
            }
        }

e. 重写onViewRecycled()方法

RecyclerView在回收ViewHolder并将其添加到Pools中时会调用onViewRecycled()方法，FragmentStateAdapter重写该方法将缓存对象从mFragments和mItemIdToViewHolder中删除：

public final void onViewRecycled(@NonNull FragmentViewHolder holder) {
        final int viewHolderId = holder.getContainer().getId();
        final Long boundItemId = itemForViewHolder(viewHolderId); // item currently bound to the VH
        if (boundItemId != null) {
            removeFragment(boundItemId);
            mItemIdToViewHolder.remove(boundItemId);
        }
    }

f. 实现StatefulAdapter接口的saveState()方法和restoreState()方法

和FragmentStatePagerAdapter一样，StatefulAdapter也有两个成员变量mFagment和mSavedStates，实现这两个方法主要是为了存储和恢复mFagment/mSavedStates。

Notice

  1. FragmentStateAdapter的内部维护了一个fragmens数组，对于单个Fragment的创建其暴露给使用者来实现，然而Fragment的销毁也是其在内部维护的，外部不知道何时销毁Fragment。这就没有FragmentStatePagerAdapter使用起来方便了，其不仅暴露了创建Fragment的方法instantiateItem()，而且还暴露了Fragment销毁的方法destroyItem()，因此开发人员可以自己在其子类维护一个fragments数组。
Integrated Machine
关注
专栏目录
ViewPagerAdapter
01-26
ViewPagerAdapter的示例，有三个界面，可以来回滑动。
android仿抖音视频播放 基于GsyVideoPlayer+ViewPager2
12-13
3. **垂直翻页与上下翻页**: 通常，ViewPager默认是水平滑动的，但在这个项目中，通过自定义ViewPager2的滑动方向，实现了垂直滑动的效果。这样，用户可以向上或向下滑动屏幕，来浏览下一个或上一个视频。 4. **...
Android ViewPager和ViewPager2的区别
weixin_40323532的博客
06-04 1056
不可以缓存，Fragment离开屏幕时，该适配器会销毁该Fragment并释放其资源，而在Fragment重新进入屏幕时，该适配器又会重新创建该Fragment。的预加载与离屏加载在view层面有着本质的区别，离屏加载的view已经添加到parent上，而预加载只是准备了布局，并没有加载到parent上。在遇到预加载时，只会创建Fragment对象，不会把Fragment真正的加入到布局中，所以自带懒加载效果；为1时，在第1页会加载2条数据，每滑动一页，都会加载下一页数据，直到第五页，会移除第一页数据。
Android ViewPager2（一）
最新发布
dbfksnbxcnnc的博客
08-13 875
ViewPager2是 Android Jetpack 组件的一部分，旨在取代老旧的ViewPager。它主要用于在多个页面之间滑动切换，适合展示分屏内容，如教程引导页、图片浏览器等。与ViewPager不同，ViewPager2使用了作为底层技术，因此拥有更灵活的功能和更好的性能。ViewPager2支持横向和纵向滑动、Fragment 的更高效管理。
viewpager显示图片的Adapter
anzhenji7632的博客
08-20 167
package com.ming.chiye.yishanghorse.Adapter; import android.content.Context; import android.graphics.Color; import android.net.Uri; import android.support.annotation.NonNull; import andr...
ViewPager PagerAdapter
金溪的博客
12-19 751
ViewPager 是负责翻页的一个View，准确的说是一个ViewGroup，包含多个View页，在手指横向滑动屏蔽时，其负责对View进行切换。为了生成这些View页，需要提供一个PagerAdapter来进行数据绑定以及生成最终的View页。 1、setAdapter ViewPager通过setAdapter()来建立与PagerAdapter的联系。这个联系是双向的，一方面，Vie...
AdapterView类视图控件的使用，Fragment，ViewPager2视图控件的使用
IH_LZH的博客
04-08 1488
Adapter（适配器）是连接后端数据与前端视图的接口，是数据与视图之间交互的中介。众所周知，Android用户界面采用MVC框架，即model-view-controller，model和view可理解为是数据和视图，而Adapter就属于中间的controller部分。用Adapter作为数据和视图之间交互的中介，就可以将这两部分分开操作：数据改变时，不需要修改视图组件，只需更新Adapter；视图组件改变时，不需要修改数据，只需绑定Adapter即可。：容器控件，整体由一个个子元素item组成，
ViewPager之Adapter
抓鱼的猫的博客
08-18 494
概述在讲Adapter之前 我们先来看看官方对ViewPager的Adapter 的解释。 我相信 这简单的English就不用我解释了吧，我们来看一下PagerAdapter的两个子类FragmentPagerAdapter和FragmnetStatePagerAdapter的区别。区别FragmentPagerAdapter和FragmentStatePagerAdapter：
为 RecyclerView/ViewPager 提供简单易用的 Adapter.zip
09-24
针对这一问题，有一个开源项目名为"EfficientAdapter"，它旨在提供一个简单易用的Adapter解决方案，简化RecyclerView和ViewPager的适配器创建过程。 "EfficientAdapter"项目的核心目标是通过抽象和封装常见的适配器...
viewpager2TabFragmentDemo.zip
11-17
- 在`TabLayout`中，我们可以设置自定义的Tab图标和文字，还可以通过`TabLayoutMediator`与`ViewPager2`进行绑定，实现Tab切换时`ViewPager2`内容的同步更新。 4. **底部导航菜单（BottomNavigationView）**： - ...
Android App中ViewPager与Fragment结合的一些问题解决
01-05
在了解ViewPager的工作原理之前，先回顾ListView的工作原理： ListView只有在需要显示某些列表项时，它才会去申请可用的视图对象；如果为所有的列表项数据创建视图对象，会浪费内存； ListView找谁去申请视图对象呢...
ViewPager 3中Adapter实现方式
01-05
在这个主题下，我们将深入探讨ViewPager 3中的Adapter实现方式，以及如何与Fragment进行交互。 首先，我们来看ViewPager 3的核心变化之一——移除了对`PagerAdapter`的支持。在早期版本的ViewPager中，我们通常会...
ViewPager的Adapter
lixinxiaos的博客
12-31 366
viewPager在开发中是不少用到的，每个ViewPager都需要对应的Adapter，很简单，直接看代码： 首先，新建一个类集成 PagerAdapter，如下： public class GiveAwayViewPagerAdapter extends PagerAdapter { private ArrayList<User> list; private Co...
ViewPager的adapter
ButtonXin的博客
10-06 371
有2个继承PagerAdapter的子类 FragmentStatePagerAdapter FragmentPagerAdapter 区别：二者在写在不需要的Fragment时，采用的处理方法不同 FragmentStatePagerAdapter会销毁不需要的Fragment，事务提交后，可将Fragment从activity的Fragmentmanager中彻底删除，就是销毁了不需要的fr
androidx viewpager2的使用详解
2401_84415615的博客
04-30 749
我见过很多技术leader在面试的时候，遇到处于迷茫期的大龄程序员，比面试官年龄都大。这些人有一些共同特征：可能工作了5、6年，还是每天重复给业务部门写代码，工作内容的重复性比较高，没有什么技术含量的工作。问到这些人的职业规划时，他们也没有太多想法。其实30岁到40岁是一个人职业发展的黄金阶段，一定要在业务范围内的扩张，技术广度和深度提升上有自己的计划，才有助于在职业发展上有持续的发展路径，而不至于停滞不前。不断奔跑，你就知道学习的意义所在！
Android ViewPager与RadioGroup联动实现教程
viewPager.setAdapter(adapter); // 添加RadioButton与页面的关联 for (int i = 0; i < viewPager.getAdapter().getCount(); i++) { RadioButton radioButton = new RadioButton(this); radioButton.setText(...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值