前言
ViewPager搭配Fragment去实现标签页是一种非常常见的做法，基本上Android初学者都能顺手写出来，可是有时候虽然代码简单，其中却有很多微妙之处。本篇主要是聊一下Fragment遇上ViewPager之后，应该注意到的一些细节问题。为了更好地理解本文，在阅读之前最好先看一下洞若观火：Fragment不为人知的细节。
PagerAdapter
不使用Fragment的话，我们就会继承PagerAdapter，通常会重写它以下几个方法：
Object instantiateItem(ViewGroup container, int position)
创建对应position的页面，返回的对象不一定是View，可以使View的容器或者相关联的对象
void destroyItem(ViewGroup container, int position, Object object)
移除对应position的页面
int getCount()
页面数量
boolean isViewFromObject(View view, Object object)
决定一个页面的View对象是否和object关联，怎么关联的。
这四个方法大家一定很熟啦，但是本文呢我们还要关注以下几个方法：
Parcelable saveState()
在ViewPager的onSaveInstanceState方法中调用
void restoreState(Parcelable state, ClassLoader loader)
在ViewPager的onRestoreInstanceState方法和setAdapter方法中调用。
这两个方法，相信大家一看就能明白怎么回事，就是ViewPager为了保存和恢复Adapter中的页面状态而设计的。
void setPrimaryItem(ViewGroup container, int position, Object object)
当position页面被选中时候，会回调该方法
void notifyDataSetChanged()
数据发生变化时候调用，该方法会引起mViewPagerObserver调用其onChanged()方法，最终会调用到ViewPager的dataSetChanged方法
int getItemPosition(Object object)
这个方法决定一个页面的位置是否变化了，参数object是instantiateItem的返回值。这个方法的返回值有：
- POSITION_UNCHANGED 表示页面位置永远不会变化
- POSITION_NONE 表示页面不存在了，需要重新加载
- [0,getCount()) 表示更换页面的位置到指定position
默认的实现是返回POSITION_UNCHANGED，即认为页面位置不会发生变化。因此我们在需要调用notifyDataSetChanged()刷新时候，应该考虑去重写getItemPosition
ViewPager的离屏缓存
ViewPager有一个方法setOffscreenPageLimit(int limit)，
该方法设置保存当前页面两侧各limit个页面，已经超出limit的部分会被销毁，因此最多保存2*limit+1个页面，边界情况自行脑补吧。有人管着叫预加载，个人感觉不是特别合适,因为还会去销毁，叫离屏页面缓存可能比较合理，大家理解就算了。假设我们有0,1,2,3四个页面，一开始ViewPager的currentItem为0，此时会预加载1页面；滑动到1页面时候，因为0已经加载过了，此时会预加载2页面；当滑动到2时候，就会销毁0，预加载3。其中加载时会调用PagerAdapter的instantiateItem(ViewGroup container, int position)方法，销毁时会调用destroyItem(ViewGroup container, int position, Object object)方法。
limit默认为1且最小必须为1。当然如果你不想有页面缓存的话，可以修改源码DEFAULT_OFFSCREEN_PAGES常量。
FragmentPagerAdapter与FragmentStatePagerAdapter
区别
当页面超出上面所说的超过offscreenPageLimit时候，FragmentPagerAdapter不会销毁Fragment实例，而只会销毁视图；而FragmentStatePagerAdapter会销毁实例。
想必你一定能到它们是怎么实现的吧？
没错FragmentPagerAdapter在不用的时候执行detach，当又需要用到的时候再attach；FragmentStatePagerAdapter则是执行remove与add操作。因此在选择二者的时候，当你的页面比较多，比如十几个时候，为了节省内存，应该选用FragmentStatePagerAdpater;只有几个页面时候就用FragmentPagerAdapter，省去一些反复创建销毁的开销。
FragmentPagerAdapter
接下来我们来看一段非常简单的Fragment搭配ViewPager使用的代码:
@Override
protected void onCreate(@Nullable Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_view_pager);
viewPager = findViewById(R.id.viewPager);
List<BaseFragment> list = new ArrayList<>();
list.add(new FragmentOne());
list.add(new FragmentTwo());
list.add(new FragmentThree());
viewPager.setAdapter(new ViewPagerAdapter(getSupportFragmentManager(), list));
}
private class ViewPagerAdapter extends FragmentPagerAdapter {
private List<BaseFragment> list;
public ViewPagerAdapter(FragmentManager fm, List<BaseFragment> list) {
super(fm);
this.list = list;
}
@Override
public Fragment getItem(int position) {
return list.get(position);
}
@Override
public int getCount() {
return list.size();
}
}
我觉得应该有人写过类似这样的代码吧。唉，有些读者可能发现问题了，不是说要判断是否为null吗，这样不会有问题吗?
答案是确实会在Activity重创建时候多创建“部分”实例，但是注意多创建的这部分实例并不会被add到FragmentManager中去，仍旧会使用FragmentManager自己恢复的实例。这里要注意“部分”，其实也很好理解，“部分”就是指在Activity重创建之前已经添加到FragmentManager中的，List中可能还有一部分实例还未添加进去。
另外如果是FragmentStatePagerAdapter的话，List一直持有Fragment的引用，这样的话就回收不了实例啦，也就失去了FragmentStatePagerAdapter的意义。
接下来我们从FragmentPagerAdapter的代码来分析一下：
public Object instantiateItem(ViewGroup container, int position) {
if (mCurTransaction == null) {
mCurTransaction = mFragmentManager.beginTransaction();
}
final long itemId = getItemId(position);
// 通过containerId和itemId拼接一个name，对于特定position，name是不会变的,使用name作为fragmnet的tag
String name = makeFragmentName(container.getId(), itemId);
//去FragmentManager中查找是否存在该实例
Fragment fragment = mFragmentManager.findFragmentByTag(name);
//存在直接attach
if (fragment != null) {
if (DEBUG) Log.v(TAG, "Attaching item #" + itemId + ": f=" + fragment);
mCurTransaction.attach(fragment);
} else {
//不存在调用getItem然后add进去
fragment = getItem(position);
if (DEBUG) Log.v(TAG, "Adding item #" + itemId + ": f=" + fragment);
mCurTransaction.add(container.getId(), fragment,
makeFragmentName(container.getId(), itemId));
}
if (fragment != mCurrentPrimaryItem) {
fragment.setMenuVisibility(false);
fragment.setUserVisibleHint(false);
}
return fragment;
}
逻辑注释已经写的很清楚啦，很容易看懂。
再来看一下destroyItem方法吧：
public void destroyItem(ViewGroup container, int position, Object object) {
if (mCurTransaction == null) {
mCurTransaction = mFragmentManager.beginTransaction();
}
if (DEBUG) Log.v(TAG, "Detaching item #" + getItemId(position) + ": f=" + object
+ " v=" + ((Fragment)object).getView());
mCurTransaction.detach((Fragment)object);
}
其实就是调用detach方法，销毁视图。到这里我们顺便也搞清楚了，使用FragmentPagerAdapter切换ViewPager时候，到底发生了什么。
这部分代码我们要从两种情况理解:
1）假设我们有0,1,2三个页面，limit为1，初始页面为0。此时ViewPager先加载0，然后再加载1，这时候发现FragmentManager中没有这两个该实例，就会去调用getItem然后add进去。如果我切换到2页面，此时0页面超出保留的范围啦就会去调用destroyItem，然后会销毁0页面Fragment的视图。然后再切到1页面，此时又要去加载0页面,FragmentManager已经有对应的Fragment实例，只需要执行attach重建视图就好。
2）当Activity重创建时候，FragmentManager会帮助我们保存与恢复已经添加到其中的实例。因此虽然我们往List中又add了新new的Fragment实例，但是这Fragment发现该位置的实例有保存就不会去调用getItem。只有在Activity重建前没有添加到FragmentManger中的实例才会去调用getItem。
因此我们在getItem方法调用时候再去创建Fragment实例，就可以避免上面多创建无用实例的问题，这一点对于FragmentStatePagerAdapter来说同样适用。
private class MyPagerAdapter extends FragmentPagerAdapter{
public MyPagerAdapter(FragmentManager fm) {
super(fm);
}
@Override
public Fragment getItem(int position) {
if (position==0){
return new FragmentOne();
}else if (position==1){
return new FragmentTwo();
}else {
return new FragmentThree();
}
}
@Override
public int getCount() {
return 3;
}
这时候可能又有同学有话说啦，我们平时重写FragmentPagerAdapter的代码基本上都是一样的,这样写不就没什么复用可言了。那咱们这样吧：
public interface FragmentCreator {
Fragment createFragment();
}
class LazyPagerAdapter extends FragmentPagerAdapter {
private List<FragmentCreator> list;
public LazyPagerAdapter(FragmentManager fm, List<FragmentCreator> list) {
super(fm);
this.list=list;
}
@Override
public Fragment getItem(int position) {
FragmentCreator fragmentCreator = list.get(position);
return fragmentCreator.createFragment();
}
@Override
public int getCount() {
return list.size();
}
}
FragmentStatePagerAdapter
对于FragmentStatePagerAdapter我们先来关注一个问题，由于当ViewPager滑动超过limit的时候，会销毁Fragment实例，那再重新创Fragment实例，我之前的界面状态和数据岂不是丢失了？
FragmentStatePagerAdapter当然有考虑到这个问题，在需要销毁Fragment实例时候，会调用它的onSaveInstanceState(Bundle outState) 方法，重新创建时候会调用setInitialSavedState去恢复。因此我们要想在切换界面之后回来还能保存之前的状态态，就要自己实现好onSaveInstanceState方法，并在onCreate、onCreateView或onActivtyCreated方法中去恢复。
接下来我们来看看代码：
@Override
public Object instantiateItem(ViewGroup container, int position) {
//mFragments中保存ViewPager缓存的页面对应的Fragment实例，如果在缓存中就直接返回啦
if (mFragments.size() > position) {
Fragment f = mFragments.get(position);
if (f != null) {
return f;
}
}
if (mCurTransaction == null) {
mCurTransaction = mFragmentManager.beginTransaction();
}
Fragment fragment = getItem(position);
if (DEBUG) Log.v(TAG, "Adding item #" + position + ": f=" + fragment);
if (mSavedState.size() > position) {
//是否之前保存过该页面的状态，保存过就恢复
Fragment.SavedState fss = mSavedState.get(position);
if (fss != null) {
fragment.setInitialSavedState(fss);
}
}
while (mFragments.size() <= position) {
mFragments.add(null);
}
fragment.setMenuVisibility(false);
fragment.setUserVisibleHint(false);
mFragments.set(position, fragment);
mCurTransaction.add(container.getId(), fragment);
return fragment;
}
@Override
public void destroyItem(ViewGroup container, int position, Object object) {
Fragment fragment = (Fragment) object;
if (mCurTransaction == null) {
mCurTransaction = mFragmentManager.beginTransaction();
}
if (DEBUG) Log.v(TAG, "Removing item #" + position + ": f=" + object
+ " v=" + ((Fragment)object).getView());
while (mSavedState.size() <= position) {
mSavedState.add(null);
}
//保存该Fragment的状态
mSavedState.set(position, fragment.isAdded()
? mFragmentManager.saveFragmentInstanceState(fragment) : null);
//将缓存对应位置置空
mFragments.set(position, null);
//销毁实例
mCurTransaction.remove(fragment);
}
逻辑都写注释啦，也比较简单。
接下来该考虑一下Actvity重创建之后的三个问题：
1)ViewPager离屏缓存的Fragment,FragmentManager会帮助我们恢复
2)从来没有add到过FragmentManager中实例，我们在getItem放法中创建就好
3)曾经add到过Fragment实例，要保留之前的状态，这部分怎么办呢？
其实从上面的代码来看我们只要能够保存mSavedState这个List就好啦，那怎么保存呢？这就用到我们在之前说过的PagerAdapter关键方法，直接来看一下是怎么实现的吧：
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);
}
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;
/*putFragment是存一个Bundle给这个Fragment，这个Bundle对象也会被保存。这里key纯粹是为了记录Fragment f在List的哪个位置。*/
mFragmentManager.putFragment(state, key, f);
}
}
return state;
}
@Override
public void restoreState(Parcelable state, ClassLoader loader) {
if (state != null) {
Bundle bundle = (Bundle)state;
bundle.setClassLoader(loader);
Parcelable[] fss = bundle.getParcelableArray("states");
mSavedState.clear();
mFragments.clear();
if (fss != null) {
for (int i=0; i<fss.length; i++) {
mSavedState.add((Fragment.SavedState)fss[i]);
}
}
Iterable<String> keys = bundle.keySet();
for (String key: keys) {
if (key.startsWith("f")) {
int index = Integer.parseInt(key.substring(1));
Fragment f = mFragmentManager.getFragment(bundle, key);
if (f != null) {
while (mFragments.size() <= index) {
mFragments.add(null);
}
f.setMenuVisibility(false);
mFragments.set(index, f);
} else {
Log.w(TAG, "Bad fragment at key " + key);
}
}
}
}
}
setUserVisibleHint
关于这个方法我们经常会用来判断当前页面是否对用户可见，然后执行一些动画啊什么的。但是有一点要注意，这个方法也只有你用了FragmentPagerAdapter或者FragmentStatePagerAdapter才有用，看了下面的代码你就明白了。
public void setPrimaryItem(ViewGroup container, int position, Object object) {
Fragment fragment = (Fragment)object;
if (fragment != mCurrentPrimaryItem) {
if (mCurrentPrimaryItem != null) {
mCurrentPrimaryItem.setMenuVisibility(false);
mCurrentPrimaryItem.setUserVisibleHint(false);
}
if (fragment != null) {
fragment.setMenuVisibility(true);
fragment.setUserVisibleHint(true);
}
mCurrentPrimaryItem = fragment;
}
}
notifyDataSetChanged()问题
首先我们需要明确的一件事情是对于ViewPager而言，页面其实是跟随着切换去加载和销毁的，当数据变化的时候其实ViewPager要做的只是让缓存的页面做出变化就可以啦。上文已经说过 notifyDataSetChanged()最终会调用到ViewPager的dataSetChanged()方法，接下来上源码
void dataSetChanged() {
...
//mItems中存储的是缓存页面的信息
for (int i = 0; i < mItems.size(); i++) {
final ItemInfo ii = mItems.get(i);
//调用getItemPosition判断页面的位置是否变化
final int newPos = mAdapter.getItemPosition(ii.object);
//如果没有变化
if (newPos == PagerAdapter.POSITION_UNCHANGED) {
continue;
}
//这个位置页面需要重新加载
if (newPos == PagerAdapter.POSITION_NONE) {
mItems.remove(i);
i--;
if (!isUpdating) {
mAdapter.startUpdate(this);
isUpdating = true;
}
//调用PagerAdapter的destroyItem方法销毁
mAdapter.destroyItem(this, ii.position, ii.object);
needPopulate = true;
if (mCurItem == ii.position) {
// Keep the current item in the valid range
newCurrItem = Math.max(0, Math.min(mCurItem, adapterCount - 1));
//标记需要重新填充
needPopulate = true;
}
continue;
}
//如果只是页面位置发生改变的话
if (ii.position != newPos) {
if (ii.position == mCurItem) {
// Our current item changed position. Follow it.
newCurrItem = newPos;
}
ii.position = newPos;
needPopulate = true;
}
}
if (isUpdating) {
mAdapter.finishUpdate(this);
}
//对缓存中的页面按照位置先后排序
Collections.sort(mItems, COMPARATOR);
//填充
if (needPopulate)
final int childCount = getChildCount();
for (int i = 0; i < childCount; i++) {
final View child = getChildAt(i);
final LayoutParams lp = (LayoutParams) child.getLayoutParams();
if (!lp.isDecor) {
lp.widthFactor = 0.f;
}
}
setCurrentItemInternal(newCurrItem, false, true);
requestLayout();
}
}
重写getItemPosition
看了上面的代码我们知道如果数据发生变化，一定要重写getItemPosition方法。比如：
public int getItemPosition(Object object) {
return POSITION_NONE;
}
这样的话如果你使用FragmentStatePagerAdapter是没有问题的，因为它缓存的Fragment是放在mFragments集合中的，当调用destroyItem时候会调用 mFragments.set(position, null)移除对应的实例。但是FragmentPagerAdapter的Fragment是由FragmentManager管理的，当调用destroyItem时候只是detach掉，而Fragment实例还存在其中。instantiateItem方法有这么几行代码：
final long itemId = getItemId(position);
String name = makeFragmentName(container.getId(), itemId);
Fragment fragment = mFragmentManager.findFragmentByTag(name);
我们看到Fragment的TAG是由makeFragmentName方法决定的，看下实现：
public long getItemId(int position) {
return position;
}
private static String makeFragmentName(int viewId, long id) {
return "android:switcher:" + viewId + ":" + id;
}
因此对于FragmentPagerAdapter而言，只要是加载过的Fragment根本就不会被替换掉，因此我们在数据变化时候需要清空掉FragmentManager管理的Fragment。
贴上代码：
class LazyPagerAdapter extends FragmentPagerAdapter {
private List<FragmentCreator> list;
private FragmentManager mFragmentManager;
public void setFragments(List<FragmentCreator> list) {
FragmentTransaction transaction = mFragmentManager.beginTransaction();
for (Fragment f : mFragmentManager.getFragments()) {
transaction.remove(f);
}
transaction.commitNow();
this.list = list;
notifyDataSetChanged();
}
public LazyPagerAdapter(FragmentManager fm, List<FragmentCreator> list) {
super(fm);
this.list = list;
mFragmentManager = fm;
}
@Override
public Fragment getItem(int position) {
FragmentCreator fragmentCreator = list.get(position);
return fragmentCreator.createFragment();
}
@Override
public int getItemPosition(Object object) {
return POSITION_NONE;
}
@Override
public int getCount() {
return list.size();
}
}
本文就到这里啦，由于个人水平及精力有限，如有错误，打脸请轻点
网友评论