ViewPager刷新问题原理分析及解决方案(FragmentPagerAdapter+FragementStatePagerAdapter)ViewPager+FragmentPagerAdapte

Android开发中经常用到ViewPager+Fragment+Adapter的场景,一般每个Fragment控制自己的刷新,但是如果想要刷新整个ViewPager怎么做呢?或者想要将缓存的Fragent给重建怎么做呢?之前做业务的时候遇到一个问题,ViewPage在第二次setAdapter的如果用的是FragmentPager并不会导致页面刷新,但是采用FragementStatePagerAdapter却会刷新?不由得有些好奇,随跟踪了部分源码,简单整理如下:

ViewPager+FragmentPagerAdapter为何不能通过setAdapter做到整体刷新

第二次设置PagerAdapter的时候,首先会将原来的Fragment进行清理,之后在调用populate()重建,只是重建的时候并不一定真的重新创建Fragment,如下:

public void setAdapter(PagerAdapter adapter) {
    if (mAdapter != null) {
        ...
        for (int i = 0; i < mItems.size(); i++) {
            final ItemInfo ii = mItems.get(i);
            <!--全部destroy-->
            mAdapter.destroyItem(this, ii.position, ii.object);
        }
        mAdapter.finishUpdate(this);
        <!--清理-->
        mItems.clear();
        removeNonDecorViews();
        <!--重置位置-->
        mCurItem = 0;
        scrollTo(0, 0);
    }
    ...
    if (!wasFirstLayout) {
    <!--重新设置Fragment-->
       populate();
       }
    ...   
    }        

之前说过,第二次通过setAdapter的方式来设置ViewPager的FragmentAdapter时不会立即刷新的效果,但是如果往后滑动几屏会发现其实是有效果了?为什么呢,因为第二次setAdapter的时候,已经被FragmentManager缓存的Fragent不会被新建,也不会被刷新,因为FragmentPagerAdapter在调用destroy的时候,采用的是detach的方式,并未真正的销毁Fragment,仅仅是打算销毁了View,这就导致FragmentManager中仍旧保留正Fragment的缓存:

@Override
public void destroyItem(ViewGroup container, int position, Object object) {
    if (mCurTransaction == null) {
        mCurTransaction = mFragmentManager.beginTransaction();
    }
    // 仅仅detach
    mCurTransaction.detach((Fragment)object);
}

Transaction.detach函数最终会调用FragmentManager的detachFragment函数,将Fragment从当前Activity detach

     public void detachFragment(Fragment fragment, int transition, int transitionStyle) {
    if (!fragment.mDetached) {
        <!--只是detach -->
        fragment.mDetached = true;
        if (fragment.mAdded) {
        <!--如果是被added 从added列表中移除-->
            if (mAdded != null) {
                mAdded.remove(fragment);
            }
            ...
            fragment.mAdded = false;
            <!--将状态设置为Fragment.CREATED-->
            moveToState(fragment, Fragment.CREATED, transition, transitionStyle, false);
        }
    }
}

可以看到,这里仅仅会将Fragment设置为Fragment.CREATED,对于Fragment.CREATED状态的Fragment,FragmentManager是不会调用makeInactive进行清理的,

void moveToState(Fragment f, int newState, int transit, int transitionStyle,
        boolean keepActive) {
        ...
 case Fragment.CREATED:
         if (newState < Fragment.CREATED) {
             ...
                if (!keepActive) {
                    if (!f.mRetaining) {
                        makeInactive(f);
                    } else {
                        f.mActivity = null;
                        f.mParentFragment = null;
                        f.mFragmentManager = null;
                    }
               ...

因为只有makeInactive才会清理Fragment的引用如下:

void makeInactive(Fragment f) {
    if (f.mIndex < 0) {
        return;
    }
    <!--置空mActive列表对于Fragment的强引用-->
    mActive.set(f.mIndex, null);
    if (mAvailIndices == null) {
        mAvailIndices = new ArrayList<Integer>();
    }
    mAvailIndices.add(f.mIndex);
    mActivity.invalidateFragment(f.mWho);
    f.initState();
}

可见,Fragment的缓存仍旧留在FragmentManager中。新的FragmentPagerAdapter被设置后,会通过instantiateItem函数来获取Fragment,这个时候它首先会从FragmentManager的缓存中去取Fragment,取到的Fragment其实就是之前未销毁的Fragment,就会导致之前传递的参数仍然是旧的,这也是为什么可能不会刷新的原因:

@Override
public Object instantiateItem(ViewGroup container, int position) {
    <!--新建一个事务-->
    if (mCurTransaction == null) {
        mCurTransaction = mFragmentManager.beginTransaction();
    }
    final long itemId = getItemId(position);
    <!--利用id与container的id创建name-->
    String name = makeFragmentName(container.getId(), itemId);
    <!--根据name在Activity的FragmentManager中查找缓存Fragment-->
    Fragment fragment = mFragmentManager.findFragmentByTag(name);
    <!--如果找到的话,直接使用当前Fragment-->
    if (fragment != null) {
        mCurTransaction.attach(fragment);
    } else {
    <!--如果找不到则新建,并新建name,添加到container中去-->
        fragment = getItem(position);
        mCurTransaction.add(container.getId(), fragment,
                makeFragmentName(container.getId(), itemId));
    }
    if (fragment != mCurrentPrimaryItem) {
        fragment.setMenuVisibility(false);
        fragment.setUserVisibleHint(false);
    }
   return fragment;
}

从上面代码可以看到,在新建Fragment对象的时候,首先是通过mFragmentManager.findFragmentByTag(name);查找是否已经有Fragment缓存,第二次设置Adapter的时候,由于部分Fragment已经被添加到FragmentManager的缓存中去了,新的Adapter仍然能通过mFragmentManager.findFragmentByTag(name)找到缓存Fragment,阻止了Fragment的新建,因此不会有整体刷新的效果。那如果想要整体刷新怎么办呢?可以使用FragementStatePagerAdapter,两者对于Fragment的缓存管理不同。

ViewPager+FragementStatePagerAdapter可以通过setAdapter做到整体刷新

同样先看一下FragementStatePagerAdapter的destroyItem函数,FragementStatePagerAdapter在destroyItem的时候使用的是remove的方式,这种方式对于没有添加到回退栈的Fragment操作来说,不仅会销毁view,还会销毁Fragment。

@Override
public void destroyItem(ViewGroup container, int position, Object object) {
    Fragment fragment = (Fragment)object;

    if (mCurTransaction == null) {
        mCurTransaction = mFragmentManager.beginTransaction();
    }
   while (mSavedState.size() <= position) {
        mSavedState.add(null);
    }
    mSavedState.set(position, mFragmentManager.saveFragmentInstanceState(fragment));
    <!--FragementStatePagerAdapter先清理自己的缓存-->
    mFragments.set(position, null);
    <!--直接删除-->
    mCurTransaction.remove(fragment);
}

可见FragementStatePagerAdapter会首先通过mFragments.set(position, null)清理自己的缓存,然后,通过Transaction.remove清理在FragmentManager中的缓存,Transaction.remove最终会调用FragmentManager的removeFragment函数:

public void removeFragment(Fragment fragment, int transition, int transitionStyle) {
<!-- 其实两者的主要区别就是看是否在回退栈,如果在,表现就一致,如果不在,表现不一致-->
    final boolean inactive = !fragment.isInBackStack();
    if (!fragment.mDetached || inactive) {
        if (mAdded != null) {
            mAdded.remove(fragment);
        }
        ...
        fragment.mAdded = false;
        fragment.mRemoving = true;
        <!--将状态设置为Fragment.CREATED或者Fragment.INITIALIZING-->
        moveToState(fragment, inactive ? Fragment.INITIALIZING : Fragment.CREATED,
                transition, transitionStyle, false);
    }
}

FragementStatePagerAdapter中的Fragment在添加的时候,都没有addToBackStack,所以moveToState会将状态设置为Fragment.INITIALIZING ,

void moveToState(Fragment f, int newState, int transit, int transitionStyle,
        boolean keepActive) {
        ...
 case Fragment.CREATED:
         if (newState < Fragment.CREATED) {
             ...
                if (!keepActive) {
                    if (!f.mRetaining) {
                        makeInactive(f);
                    } else {
                        f.mActivity = null;
                        f.mParentFragment = null;
                        f.mFragmentManager = null;
                    }
               ...

Fragment.INITIALIZING < Fragment.CREATED,这里一般会调用makeInactive函数清理Fragment的引用,这里其实就算销毁了Fragment在FragmentManager中的缓存。

ViewPager通过populate因此再次新建的时候,FragementStatePagerAdapter的instantiateItem 一定会新建Fragment,因为之前的Fragment已经被清理掉了,在自己的Fragment缓存列表中取不到,就新建。看如下代码:

    @Override
public Object instantiateItem(ViewGroup container, int position) {
    <!--查看FragementStatePagerAdapter中是否有缓存的Fragment,如果有直接返回-->
    if (mFragments.size() > position) {
        Fragment f = mFragments.get(position);
        if (f != null) {
            return f;
        }
    }
   ...
     <!--关键点   如果在FragementStatePagerAdapter找不到,直接新建,不关心FragmentManager中是否有-->
    Fragment fragment = getItem(position);
    <!--查看是否需恢复,如果需要,则恢复-->
    if (mSavedState.size() > position) {
        Fragment.SavedState fss = mSavedState.get(position);
        if (fss != null) {
            fragment.setInitialSavedState(fss);
        }
    }
    ...
    mFragments.set(position, fragment);
    mCurTransaction.add(container.getId(), fragment);

    return fragment;
}

从上面代码也可以看出,FragementStatePagerAdapter在新建Fragment的时候,不会去FragmentMangerImpl中去取,而是直接在FragementStatePagerAdapter的缓存中取,如果取不到,则直接新建Fragment,如果通过setAdapter设置了新的FragementStatePagerAdapter,一定会新建所有的Fragment,就能够达到整体刷新的效果。

FragmentPagerAdapter如何通过notifyDataSetChanged刷新ViewPager

FragmentPagerAdapter中的数据发生改变时,往往要重新将数据设置到Fragment,或者干脆新建Fragment,而对于用FragmentPagerAdapter的ViewPager来说,只是利用其notifyDataSetChanged是不够的,跟踪源码会发现,notifyDataSetChanged最终会调用ViewPager中的dataSetChanged:

notifyDataSetChanged流程

void dataSetChanged() {
    ...
    for (int i = 0; i < mItems.size(); i++) {
        final ItemInfo ii = mItems.get(i);
        final int newPos = mAdapter.getItemPosition(ii.object);
       if (newPos == PagerAdapter.POSITION_UNCHANGED) {
            continue;
        }
       if (newPos == PagerAdapter.POSITION_NONE) {
            mItems.remove(i);
            i--;
           ...
           mAdapter.destroyItem(this, ii.position, ii.object);
            needPopulate = true;
           ...
            continue;
        }
    ...
    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();
    }
}

默认情况下FragmentPagerAdapter中的getItemPosition返回的是PagerAdapter.POSITION_UNCHANGED,所以这里不会 destroyItem,即时设置了PagerAdapter.POSITION_NONE,调用了其destroyItem,也仅仅是detach,销毁了View,Fragment仍旧不会重建,必须手动更改参数才可以,这个时机在哪里呢?FragmentAdapter的getItem函数会在第一次需要创建Fragment的时候调用,如果需要将参数传递给Fragment,可以通过Fragment.setArguments()来设置,但是仅仅在getItem新建的时候有效,一旦被Fragment被创建,就会被FragmentManager缓存,如果不主动释放,对于当前位置的Fragment来说,getItem函数是不会再次被调用的,原因已经在上文的instantiateItem函数处说明了,它会首先去缓存中取。那这个时候,如何更新呢?Fragment.setArguments是不能再调用的,因为被attach过的Fragment来说不能再次通过setArguments被设置参数,否则抛出异常

public void setArguments(Bundle args) {
    if (mIndex >= 0) {
        throw new IllegalStateException("Fragment already active");
    }
    mArguments = args;
}

那如果真要更改就需要在其instantiateItem的时候,通过额外的接口手动设置,同时也必须将getItemPosition返回值设置为POSITION_NONE,这样才会每次都走View的新建流程,才有可能刷新:

public int getItemPosition(Object object) {
    return POSITION_NONE;
}

至于参数如何设置呢?这里就需要用户手动提供接口变更参数了,在自定义的FragmentAdapter覆盖instantiateItem,自己手动获取缓存Fragment,在attach之前,将参数给重新设置进去,之后,Fragment在走onCreateView流程的时候,就会获取到新的参数。

@Override
public Object instantiateItem(ViewGroup container, int position) {

    String name = makeFragmentName(container.getId(), position);
    Fragment fragment =((FragmentActivity) container.getContext()).getSupportFragmentManager().findFragmentByTag(name);

    if(fragment instanceof MyFragment){
        Bundle bundle=new Bundle();
        bundle.putString("msg",""+System.currentTimeMillis());
        ( (MyFragment) fragment).resetArgument(bundle);
    }

    return super.instantiateItem(container, position);
}

private static String makeFragmentName(int viewId, long id) {
    return "android:switcher:" + viewId + ":" + id;
}

如此,便可以完成FragmentPagerAdapter中Fragment的刷新。并且到这里我们也知道了,对于FragmentPagerAdapter来说,用户完全不需要自己缓存Fragment,只需要缓存View,因为FragmentPagerAdapter不会销毁Fragment,也不会销毁FragmentManager中缓存的Fragment,至于缓存的View要不要刷新,可能就要你具体的业务需求了。

FragmentStatePagerAdapter如何通过notifyDataSetChanged刷新ViewPager页面

对于FragmentStatePagerAdapter相对容易些,如果不需要考虑效率,重建所有的Fragment即可,只需要复写其getItemPosition函数

public int getItemPosition(Object object) {
    return POSITION_NONE;
}

因为FragmentStatePagerAdapter中会真正的remove Fragment,达到完全重建的效果。

Fragmentmanager Transaction栈的意义

最后看一下Fragmentmanager中Transaction栈,FragmentManager的Transaction栈到底是做什么的呢?FragmentManager对于Fragment的操作是分批量进行的,在一个Transaction中有多个add、remove、attach操作,Android是有返回键的,为了支持点击返回键恢复上一个场景的操作,Android的Fragment管理引入Transaction栈,更方便回退,其实将一个Transaction的操作全部翻转:添加变删除、attach变detach,反之亦然。对于每个入栈的Transaction,都是需要出栈的,而且每个操作都有前后文,比如进入与退出的动画,当需要翻转这个操作,也就是点击返回键的时候,需要知道如何翻转,也就是需要记录当前场景,对于remove,如果没有入栈操作,说明不用记录上下文,可以直接清理掉。对于ViewPager在使用FragmentPagerAdapter/FragmentStatePagerAdapter的时候都不会addToBackStack,这也是为什么detach跟remove有时候表现一致或者不一致的原因。简单看一下出栈操作,其实就是将原来从操作翻转一遍,当然,并不是完全照搬,还跟当前的Fragment状体有关。

public void popFromBackStack(boolean doStateMove) {
   Op op = mTail;
    while (op != null) {
        switch (op.cmd) {
            case OP_ADD: {
                Fragment f = op.fragment;
                f.mNextAnim = op.popExitAnim;
                mManager.removeFragment(f,
                        FragmentManagerImpl.reverseTransit(mTransition),
                        mTransitionStyle);
            } break;
            case OP_REPLACE: {
                Fragment f = op.fragment;
                if (f != null) {
                    f.mNextAnim = op.popExitAnim;
                    mManager.removeFragment(f,
                            FragmentManagerImpl.reverseTransit(mTransition),
                            mTransitionStyle);
                }
                if (op.removed != null) {
                    for (int i=0; i<op.removed.size(); i++) {
                        Fragment old = op.removed.get(i);
                        old.mNextAnim = op.popEnterAnim;
                        mManager.addFragment(old, false);
                    }
                }
            } break;
            ...

FragmentManager对于Fragment的缓存管理

FragmentManager主要维护三个重要List,一个是mActive Fragment列表,一个是mAdded FragmentList,还有个BackStackRecord回退栈

ArrayList<Fragment> mActive;
ArrayList<Fragment> mAdded;
ArrayList<BackStackRecord> mBackStack;

mAdded列表是被当前添加到Container中去的,而mActive是全部参与的Fragment集合,只要没有被remove,就会一致存在,可以认为mAdded的Fragment都是活着的,而mActive的Fragment却可能被处决,并被置null,只有makeInactive函数会这么做。

void makeInactive(Fragment f) {
    if (f.mIndex < 0) {
        return;
    }
    mActive.set(f.mIndex, null);
    if (mAvailIndices == null) {
        mAvailIndices = new ArrayList<Integer>();
    }
    mAvailIndices.add(f.mIndex);
    mActivity.invalidateFragment(f.mWho);
    f.initState();
}

FragmentPagerAdapter获取试图获取的Fragment就是从这两个列表中读取的 。

public Fragment findFragmentByTag(String tag) {
    if (mAdded != null && tag != null) {
        for (int i=mAdded.size()-1; i>=0; i--) {
            Fragment f = mAdded.get(i);
            if (f != null && tag.equals(f.mTag)) {
                return f;
            }
        }
    }
    if (mActive != null && tag != null) {
        for (int i=mActive.size()-1; i>=0; i--) {
            Fragment f = mActive.get(i);
            if (f != null && tag.equals(f.mTag)) {
                return f;
            }
        }
    }
    return null;
}    

总结

本文简单分析了下ViewPager在使用FrgmentPagerAdapter跟FragmentStatePagerAdapter遇到问题,原理、及问题的解决方案。

作者:看书的小蜗牛 原文链接:ViewPager刷新问题原理分析及解决方案(FragmentPagerAdapter+FragementStatePagerAdapter)

仅供参考,欢迎指正

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

发表于

我来说两句

0 条评论
登录 后参与评论

相关文章

来自专栏向治洪

achartengine之折线图

问题在文章的最后,大致说来就是折线图,如果点的个数大于3个的时候,不是所有的点都显示对应的值的,这是为什么呢,本来以为是小问题,但两天了还没找到原因) 将前...

19810
来自专栏非著名程序员

Android Material Design系列之RecyclerView和CardView

去年很早之前,我就讲解过RecyclerView的使用,今天我们就在讲解CardView的时候,顺便再把RecyclerView同时讲解一下。RecyclerV...

1828
来自专栏双十二技术哥

Android fragment 标签加载过程分析

在上一篇文章中我们介绍了 AsyncLayoutInflater 使用的注意事项及改进方案。

751
来自专栏小鄧子的技术博客专栏

【译】在列表视图中处理空值

本篇文章主要针对两类开发者。第一个是曾遇到过IllegalArgumentException: Path must not be empty问题的开发者。第二个...

723
来自专栏Android干货

Android 购物车功能的实现

3505
来自专栏7号代码

Android网络与数据存储——SharedPreferences(实现是否开启引导界面)

SharedPreferences保存的数据主要是简单类型的key-value对。

1318
来自专栏水击三千

ImageButton与Button

1.Button控件 Butotn控件,主要用来实现一些命令操作,通过注册监听事件来实现。首先需要在xml文档中放入一个button按钮。 1 <But...

2399
来自专栏Android开发指南

5.侧边栏逻辑

33912
来自专栏向治洪

android Titlebar一行代码实现沉浸式效果

github地址 一个简单易用的导航栏TitleBar,可以轻松实现IOS导航栏的各种效果  整个代码全部集中在TitleBar.java中,所有控件都动...

1878
来自专栏向治洪

开源库BaseRecyclerViewAdapterHelper

相信大家RecyclerView应该不会陌生,大多数开发者应该都使用上它了,它也是google推荐替换ListView的控件,但是用过它的同学应该都知道它在某些...

2226

扫码关注云+社区