解决ViewPager嵌套时Fragment的mUserVisibleHint属性不同步的问题

最新推荐文章于 2022-12-08 15:29:05 发布
最新推荐文章于 2022-12-08 15:29:05 发布
阅读量2k 收藏 1
点赞数 1
分类专栏： 问题排查经验总结 Android&YII

2017-1-11日更新：setUserVisibleHint中过滤父Fragment未显示的情况

上一篇【Android】友盟统计Fragment页面显示隐藏的完美解决方案 我们讲了通过Fragment的mUserVisibleHint属性可以准确的监听Fragment在ViewPager中的显示与隐藏

现在新的问题又来了，当ViewPager嵌套ViewPager的时候子ViewPager中Fragment的mUserVisibleHint属性却不会同其父Fragment的mUserVisibleHint同步，这样一来子ViewPager中Fragment的状态的统计就不准确了

举个栗子，现有如下结构：

ViewPagerParent
    Fragment1
        ViewPagerChild1
            Fragment11
            Fragment12
    Fragment2
        ViewPagerChild2
            Fragment21
            Fragment22

初始化完成后的状态是

ViewPagerParent
    Fragment1.mUserVisibleHint=true
        ViewPagerChild1
            Fragment11.mUserVisibleHint=true
            Fragment12.mUserVisibleHint=false
    Fragment2.mUserVisibleHint=false
        ViewPagerChild2
            Fragment21.mUserVisibleHint=true
            Fragment22.mUserVisibleHint=false

可以明确的看出来这时候Fragment11和Fragment21的mUserVisibleHint属性都是true，如果我们通过上一篇中讲述的方法用getUserVisibleHint()&&isResume()来记录页面显示日志的话一下子会记录Fragment11和Fragment21都显示了，

可这时候我们能看到的只有Fragment11，所以我们不希望Fragment21的mUserVisibleHint也是true，可ViewPager并未提供解决此问题的方法，得靠自己来解决

接下来滑动到Fragment2，这时候的状态是

ViewPagerParent
    Fragment1.mUserVisibleHint=false
        ViewPagerChild1
            Fragment11.mUserVisibleHint=true
            Fragment12.mUserVisibleHint=false

    Fragment2.mUserVisibleHint=true
        ViewPagerChild2
            Fragment21.mUserVisibleHint=true
            Fragment22.mUserVisibleHint=false

我们可以看到Fragment1的mUserVisibleHint属性已经是false了，可是其子Framgnet11依然还是true，并不会跟父Fragment1同步，这时候我们打开新的Activity再回来重走onResume()方法的时候所有Fragment都会重走onResume()方法，那么这时候所有mUserVisibleHint状态是true的Fragment都会记录一次显示事件

我们先来解决初始化时候让Fragment21.mUserVisibleHint为false

解决思路就是在子Fragment onAttach的时候检查其父Fragment的mUserVisibleHint属性的状态，如果是false就强制将当前子Fragment的mUserVisibleHint属性设置为false并设置一个恢复标记（因为接下来还需要恢复）
然后在父Fragment setUserVisibleHint为true的时候检查其所有子Fragment，有恢复标记的子Fragment，设置其mUserVisibleHint属性为true，看代码：

public class BaseFragment extends Fragment{
    private boolean waitingShowToUser;

    @Override
    public void onActivityCreated(@Nullable Bundle savedInstanceState) {
        super.onActivityCreated(savedInstanceState);

        // 如果自己是显示状态，但父Fragment却是隐藏状态，就把自己也改为隐藏状态，并且设置一个等待显示标记
        if(getUserVisibleHint()){
            Fragment parentFragment = getParentFragment();
            if(parentFragment != null && !parentFragment.getUserVisibleHint()){
                waitingShowToUser = true;
                super.setUserVisibleHint(false);
            }
        }
    }

    @Override
    public void setUserVisibleHint(boolean isVisibleToUser) {
        super.setUserVisibleHint(isVisibleToUser);

        if(getActivity() != null) {
            List<Fragment> childFragmentList = getChildFragmentManager().getFragments();
            if (isVisibleToUser) {
                // 将所有正等待显示的子Fragment设置为显示状态，并取消等待显示标记
                if (childFragmentList != null && childFragmentList.size() > 0) {
                    for (Fragment childFragment : childFragmentList) {
                        if (childFragment instanceof BaseFragment) {
                            BaseFragment childBaseFragment = (BaseFragment) childFragment;
                            if (childBaseFragment.isWaitingShowToUser()) {
                                childBaseFragment.setWaitingShowToUser(false);
                                childFragment.setUserVisibleHint(true);
                            }
                        }
                    }
                }
            }
        }
    }

    public boolean isWaitingShowToUser() {
        return waitingShowToUser;
    }

    public void setWaitingShowToUser(boolean waitingShowToUser) {
        this.waitingShowToUser = waitingShowToUser;
    }
}
接下来解决父ViewPager切换的时候同步其子Fragment的mUserVisibleHint属性

思路就是在父Fragment setUserVisibleHint为false的时候将其所有mUserVisibleHint为true的子Fragment都强制改为false，然后设置一个恢复标记，然后在setUserVisibleHint为true的时候再恢复，看代码：

public class BaseFragment extends Fragment{
    private boolean waitingShowToUser;

    @Override
    public void onActivityCreated(@Nullable Bundle savedInstanceState) {
        super.onActivityCreated(savedInstanceState);

        // 如果自己是显示状态，但父Fragment却是隐藏状态，就把自己也改为隐藏状态，并且设置一个等待显示标记
        if(getUserVisibleHint()){
            Fragment parentFragment = getParentFragment();
            if(parentFragment != null && !parentFragment.getUserVisibleHint()){
                waitingShowToUser = true;
                super.setUserVisibleHint(false);
            }
        }
    }

    @Override
    public void setUserVisibleHint(boolean isVisibleToUser) {
        super.setUserVisibleHint(isVisibleToUser);

        // 父Fragment还没显示，你着什么急
        if (isVisibleToUser) {
            Fragment parentFragment = getParentFragment();
            if (parentFragment != null && !parentFragment.getUserVisibleHint()) {
                waitingShowToUser = true;
                super.setUserVisibleHint(false);
                return;
            }
        }

        if(getActivity() != null) {
            List<Fragment> childFragmentList = getChildFragmentManager().getFragments();
            if (isVisibleToUser) {
                // 将所有正等待显示的子Fragment设置为显示状态，并取消等待显示标记
                if (childFragmentList != null && childFragmentList.size() > 0) {
                    for (Fragment childFragment : childFragmentList) {
                        if (childFragment instanceof BaseFragment) {
                            BaseFragment childBaseFragment = (BaseFragment) childFragment;
                            if (childBaseFragment.isWaitingShowToUser()) {
                                childBaseFragment.setWaitingShowToUser(false);
                                childFragment.setUserVisibleHint(true);
                            }
                        }
                    }
                }
            } else {
                // 将所有正在显示的子Fragment设置为隐藏状态，并设置一个等待显示标记
                if (childFragmentList != null && childFragmentList.size() > 0) {
                    for (Fragment childFragment : childFragmentList) {
                        if (childFragment instanceof BaseFragment) {
                            BaseFragment childBaseFragment = (BaseFragment) childFragment;
                            if (childFragment.getUserVisibleHint()) {
                                childBaseFragment.setWaitingShowToUser(true);
                                childFragment.setUserVisibleHint(false);
                            }
                        }
                    }
                }
            }
        }
    }

    public boolean isWaitingShowToUser() {
        return waitingShowToUser;
    }

    public void setWaitingShowToUser(boolean waitingShowToUser) {
        this.waitingShowToUser = waitingShowToUser;
    }
}
最后我们结合上一篇文章的需求将对Fragment.mUserVisibleHint属性的管理封装成一个FragmentUserVisibleController.java，如下：
/**
 * Fragment的mUserVisibleHint属性控制器，用于准确的监听Fragment是否对用户可见
 * <br>
 * <br>mUserVisibleHint属性有什么用？
 * <br>* 使用ViewPager时我们可以通过Fragment的getUserVisibleHint()&&isResume()方法来判断用户是否能够看见某个Fragment
 * <br>* 利用这个特性我们可以更精确的统计页面的显示事件和标准化页面初始化流程（真正对用户可见的时候才去请求数据）
 * <br>
 * <br>解决BUG
 * <br>* FragmentUserVisibleController还专门解决了在Fragment或ViewPager嵌套ViewPager时子Fragment的mUserVisibleHint属性与父Fragment的mUserVisibleHint属性不同步的问题
 * <br>* 例如外面的Fragment的mUserVisibleHint属性变化时，其包含的ViewPager中的Fragment的mUserVisibleHint属性并不会随着改变，这是ViewPager的BUG
 * <br>
 * <br>使用方式（假设你的基类Fragment是MyFragment）：
 * <br>1. 在你的MyFragment的构造函数中New一个FragmentUserVisibleController（一定要在构造函数中new）
 * <br>2. 重写Fragment的onActivityCreated()、onResume()、onPause()、setUserVisibleHint(boolean)方法，分别调用FragmentUserVisibleController的activityCreated()、resume()、pause()、setUserVisibleHint(boolean)方法
 * <br>3. 实现FragmentUserVisibleController.UserVisibleCallback接口并实现以下方法
 * <br>&nbsp&nbsp&nbsp&nbsp* void setWaitingShowToUser(boolean)：直接调用FragmentUserVisibleController的setWaitingShowToUser(boolean)即可
 * <br>&nbsp&nbsp&nbsp&nbsp* void isWaitingShowToUser()：直接调用FragmentUserVisibleController的isWaitingShowToUser()即可
 * <br>&nbsp&nbsp&nbsp&nbsp* void callSuperSetUserVisibleHint(boolean)：调用父Fragment的setUserVisibleHint(boolean)方法即可
 * <br>&nbsp&nbsp&nbsp&nbsp* void onVisibleToUserChanged(boolean, boolean)：当Fragment对用户可见或不可见的就会回调此方法，你可以在这个方法里记录页面显示日志或初始化页面
 * <br>&nbsp&nbsp&nbsp&nbsp* boolean isVisibleToUser()：判断当前Fragment是否对用户可见，直接调用FragmentUserVisibleController的isVisibleToUser()即可
 */
@SuppressLint("LongLogTag")
public class FragmentUserVisibleController {
    private static final String TAG = "FragmentUserVisibleController";
    public static boolean DEBUG = false;
    @SuppressWarnings("FieldCanBeLocal")
    private String fragmentName;
    private boolean waitingShowToUser;
    private Fragment fragment;
    private UserVisibleCallback userVisibleCallback;
    private List<OnUserVisibleListener> userVisibleListenerList;

    public FragmentUserVisibleController(Fragment fragment, UserVisibleCallback userVisibleCallback) {
        this.fragment = fragment;
        this.userVisibleCallback = userVisibleCallback;
        //noinspection ConstantConditions
        this.fragmentName = DEBUG ? fragment.getClass().getSimpleName() : null;
    }

    public void activityCreated() {
        if (DEBUG) {
            Log.d(TAG, fragmentName + ": activityCreated, userVisibleHint=" + fragment.getUserVisibleHint());
        }
        if (fragment.getUserVisibleHint()) {
            Fragment parentFragment = fragment.getParentFragment();
            if (parentFragment != null && !parentFragment.getUserVisibleHint()) {
                if (DEBUG) {
                    Log.d(TAG, fragmentName + ": activityCreated, parent " + parentFragment.getClass().getSimpleName() + " is hidden, therefore hidden self");
                }
                userVisibleCallback.setWaitingShowToUser(true);
                userVisibleCallback.callSuperSetUserVisibleHint(false);
            }
        }
    }

    public void resume() {
        if (DEBUG) {
            Log.d(TAG, fragmentName + ": resume, userVisibleHint=" + fragment.getUserVisibleHint());
        }
        if (fragment.getUserVisibleHint()) {
            userVisibleCallback.onVisibleToUserChanged(true, true);
            callbackListener(true, true);
            if (DEBUG) {
                Log.i(TAG, fragmentName + ": visibleToUser on resume");
            }
        }
    }

    public void pause() {
        if (DEBUG) {
            Log.d(TAG, fragmentName + ": pause, userVisibleHint=" + fragment.getUserVisibleHint());
        }
        if (fragment.getUserVisibleHint()) {
            userVisibleCallback.onVisibleToUserChanged(false, true);
            callbackListener(false, true);
            if (DEBUG) {
                Log.w(TAG, fragmentName + ": hiddenToUser on pause");
            }
        }
    }

    public void setUserVisibleHint(boolean isVisibleToUser) {
        Fragment parentFragment = fragment.getParentFragment();
        if (DEBUG) {
            String parent;
            if (parentFragment != null) {
                parent = "parent " + parentFragment.getClass().getSimpleName() + " userVisibleHint=" + parentFragment.getUserVisibleHint();
            } else {
                parent = "parent is null";
            }
            Log.d(TAG, fragmentName + ": setUserVisibleHint, userVisibleHint=" + isVisibleToUser + ", " + (fragment.isResumed() ? "resume" : "pause") + ", " + parent);
        }

        // 父Fragment还没显示，你着什么急
        if (isVisibleToUser) {
            if (parentFragment != null && !parentFragment.getUserVisibleHint()) {
                if (DEBUG) {
                    Log.d(TAG, fragmentName + ": setUserVisibleHint, parent " + parentFragment.getClass().getSimpleName() + " is hidden, therefore hidden self");
                }
                userVisibleCallback.setWaitingShowToUser(true);
                userVisibleCallback.callSuperSetUserVisibleHint(false);
                return;
            }
        }

        if (fragment.isResumed()) {
            userVisibleCallback.onVisibleToUserChanged(isVisibleToUser, false);
            callbackListener(isVisibleToUser, false);
            if (DEBUG) {
                if (isVisibleToUser) {
                    Log.i(TAG, fragmentName + ": visibleToUser on setUserVisibleHint");
                } else {
                    Log.w(TAG, fragmentName + ": hiddenToUser on setUserVisibleHint");
                }
            }
        }

        if (fragment.getActivity() != null) {
            List<Fragment> childFragmentList = fragment.getChildFragmentManager().getFragments();
            if (isVisibleToUser) {
                // 显示待显示的子Fragment
                if (childFragmentList != null && childFragmentList.size() > 0) {
                    for (Fragment childFragment : childFragmentList) {
                        if (childFragment instanceof UserVisibleCallback) {
                            UserVisibleCallback userVisibleCallback = (UserVisibleCallback) childFragment;
                            if (userVisibleCallback.isWaitingShowToUser()) {
                                if (DEBUG) {
                                    Log.d(TAG, fragmentName + ": setUserVisibleHint, show child " + childFragment.getClass().getSimpleName());
                                }
                                userVisibleCallback.setWaitingShowToUser(false);
                                childFragment.setUserVisibleHint(true);
                            }
                        }
                    }
                }
            } else {
                // 隐藏正在显示的子Fragment
                if (childFragmentList != null && childFragmentList.size() > 0) {
                    for (Fragment childFragment : childFragmentList) {
                        if (childFragment instanceof UserVisibleCallback) {
                            UserVisibleCallback userVisibleCallback = (UserVisibleCallback) childFragment;
                            if (childFragment.getUserVisibleHint()) {
                                if (DEBUG) {
                                    Log.d(TAG, fragmentName + ": setUserVisibleHint, hidden child " + childFragment.getClass().getSimpleName());
                                }
                                userVisibleCallback.setWaitingShowToUser(true);
                                childFragment.setUserVisibleHint(false);
                            }
                        }
                    }
                }
            }
        }
    }

    private void callbackListener(boolean isVisibleToUser, boolean invokeInResumeOrPause) {
        if (userVisibleListenerList != null && userVisibleListenerList.size() > 0) {
            for (OnUserVisibleListener listener : userVisibleListenerList) {
                listener.onVisibleToUserChanged(isVisibleToUser, invokeInResumeOrPause);
            }
        }
    }

    /**
     * 当前Fragment是否对用户可见
     */
    @SuppressWarnings("unused")
    public boolean isVisibleToUser() {
        return fragment.isResumed() && fragment.getUserVisibleHint();
    }

    public boolean isWaitingShowToUser() {
        return waitingShowToUser;
    }

    public void setWaitingShowToUser(boolean waitingShowToUser) {
        this.waitingShowToUser = waitingShowToUser;
    }

    public void addOnUserVisibleListener(OnUserVisibleListener listener) {
        if (listener != null) {
            if (userVisibleListenerList == null) {
                userVisibleListenerList = new LinkedList<OnUserVisibleListener>();
            }
            userVisibleListenerList.add(listener);
        }
    }

    public void removeOnUserVisibleListener(OnUserVisibleListener listener) {
        if (listener != null && userVisibleListenerList != null) {
            userVisibleListenerList.remove(listener);
        }
    }

    public interface UserVisibleCallback {
        boolean isWaitingShowToUser();

        void setWaitingShowToUser(boolean waitingShowToUser);

        boolean isVisibleToUser();

        void callSuperSetUserVisibleHint(boolean isVisibleToUser);

        void onVisibleToUserChanged(boolean isVisibleToUser, boolean invokeInResumeOrPause);
    }

    public interface OnUserVisibleListener {
        void onVisibleToUserChanged(boolean isVisibleToUser, boolean invokeInResumeOrPause);
    }
}

使用起来非常简单，可快速集成到你的Fragment中，：

  1. 在你的基类Fragment的构造函数中New一个FragmentUserVisibleController（一定要在构造函数中new）
  2. 重写Fragment的onActivityCreated()、onResume()、onPause()、setUserVisibleHint(boolean)方法，分别调用FragmentUserVisibleController的activityCreated()、resume()、pause()、setUserVisibleHint(boolean)方法
  3. 实现FragmentUserVisibleController.UserVisibleCallback接口并实现以下方法
    void setWaitingShowToUser(boolean)：直接调用FragmentUserVisibleController的setWaitingShowToUser(boolean)即可
    void isWaitingShowToUser()：直接调用FragmentUserVisibleController的isWaitingShowToUser()即可
    void callSuperSetUserVisibleHint(boolean)：调用父Fragment的setUserVisibleHint(boolean)方法即可
    void onVisibleToUserChanged(boolean, boolean)：当Fragment对用户可见或不可见的就会回调此方法，你可以在这个方法里记录页面显示日志或初始化页面
    boolean isVisibleToUser()：判断当前Fragment是否对用户可见，直接调用FragmentUserVisibleController的isVisibleToUser()即可

如下所示：

public class MyFragment extends Fragment implements FragmentUserVisibleController.UserVisibleCallback{
    private FragmentUserVisibleController userVisibleController;

    public MyFragment() {
        userVisibleController = new FragmentUserVisibleController(this, this);
    }

    @Override
    public void onActivityCreated(@Nullable Bundle savedInstanceState) {
        super.onActivityCreated(savedInstanceState);
        userVisibleController.activityCreated();
    }

    @Override
    public void onResume() {
        super.onResume();
        userVisibleController.resume();
    }

    @Override
    public void onPause() {
        super.onPause();
        userVisibleController.pause();
    }

    @Override
    public void setUserVisibleHint(boolean isVisibleToUser) {
        super.setUserVisibleHint(isVisibleToUser);
        userVisibleController.setUserVisibleHint(isVisibleToUser);
    }

    @Override
    public void setWaitingShowToUser(boolean waitingShowToUser) {
        userVisibleController.setWaitingShowToUser(waitingShowToUser);
    }

    @Override
    public boolean isWaitingShowToUser() {
        return userVisibleController.isWaitingShowToUser();
    }

    @Override
    public boolean isVisibleToUser() {
        return userVisibleController.isVisibleToUser();
    }

    @Override
    public void callSuperSetUserVisibleHint(boolean isVisibleToUser) {
        super.setUserVisibleHint(isVisibleToUser);
    }

    @Override
    public void onVisibleToUserChanged(boolean isVisibleToUser, boolean invokeInResumeOrPause) {

    }
}
转载自http://www.jianshu.com/p/e7449278e33d
lxg2015
关注
专栏目录
Android解决ViewPager嵌套ViewPager中多层Fragment子ViewPager中加载不出来Fragment
Flutter|Android移动开发
12-13 3844
Android中ViewPager嵌套ViewPager先看代码：这一步处理最重要的是MyPagerAdapter构造方法中不能传入getActivity().getSupportFragmentManager()原因如下： 最近UI重新设计了一个店铺首页的效果，要用到ViewPager嵌套ViewPager才能实现效果，可是在子ViewPager中出现了加载不出来Fragment,由于里面用了多...
ViewPager嵌套Fragment时Fragment的生命周期问题
YanRu的专栏
12-05 1955
我是StackFlow的搬运工~ ViewPager嵌套Fragment的时候,Fragment的onResume()和onPause()不能很好的反应出Fragment的可见和不可见.网上也有网友说可以用setUserVisibleHint(boolean isVisibleToUser)方法来解决这个问题.但是~~~今天的这个解决方法有些不同,是以为外国网友提供的.如下: 1) C
viewpager切换，fragment可见，userVisibleHint却一直显示false
正义
11-14 1680
情景：fragment中是tablayout+viewpager布局，viewpager中加载的是fragment。 为了打开app时，不会一次请求viewpager中所有的fragment数据，使用懒加载方式。当fragment可见时，请求数据。 这里是根据userVisibleHint返回值判断fragment是否可见。而viewpager中的fragment因为显示隐藏以及嵌套的原因，use...
viewpager + fragment 使用中的setUserVisibleHint方法
zhaojianand的专栏
07-25 856
当fragment被用户可见时，setUserVisibleHint()会调用且传入true值，当fragment不被用户可见时，setUserVisibleHint()则得到false值。而在传统的fragment生命周期里也看不到这个函数。 1、viewpager监听切换tab事件，tab切换一次，执行一次setUserVisibleHint()方法 2、setUserVisibleHin...
Fragment的setUserVisibleHint详解
fanleiym的专栏
03-26 892
Android应用开发过程中，ViewPager同时加载多个fragment，以实现多tab页面快速切换, 但是fragment初始化时若加载的内容较多，就可能导致整个应用启动速度缓慢，影响用户体验。 为了提高用户体验，我们会使用一些懒加载方案，实现加载延迟。这时我们会用到getUserVisibleHint()与setUserVisibleHint()这两个方法。 /** * * @para...
Android ViewPager+Fragment（使用问题处理）
u010218170的博客
08-14 779
ViewPager+Fragment可以非常高效地实现动态编辑多个相似页面。 但是ViewPager会预加载Fragment（左右n（n>=1）个页面） ,导致Fragment的onResume()和onPause()可能不会按预期的执行。在接入友盟统计时，页面统计需要Activity和Fragment的onResume()和onPause()配对，但ViewPager中的Fragment...
TabLayout+ViewPager+Fragment中Fragment的可见和不可见问题
唐客项阳的博客
01-06 1046
场景 TabLayout+ViewPager+Fragment的使用过程中需要判断Fragment是否对用户可见，监听Fragment由不可见变为可见的事件 解决方案 重写Fragment的setUserVisibleHint(boolean isVisibleToUser)方法 坑 由于ViewPager有预加载，所以在切换时，每个预加载完的Fragment都会执行setUserVisibleHint方法，所以加一个状态标识，来确定发生变化的Fragment 代码 boolean isVi
谷歌官方提供的解决Viewpager2嵌套ViewPager2同一方向无法滑动问题使用到的文件
01-02
两个ViewPager2嵌套，同一方向无法滑动，可以在子 ViewPager2 外面嵌套一层 NestedScrollableHost.
完美解决ViewPager嵌套的滑动问题
10-28
当ViewPager 嵌套时，子ViewPager，不能优先处理滑动事件。 玩一下 网易新闻 客户端，多层嵌套，处理的很流畅，不过也有点小bug。此Demo完美解决ViewPager嵌套的滑动问题，但快速滑动父ViewPager,再滑动ViewPager...
ViewPager + Fragment注意事项
yufumatou的博客
10-21 209
前言：使用ViewPager和fragment情况很常见，然而今天却遇到了问题，通过查阅ViewPager相关资料发现是ViewPager缓存机制造成的，在此记录一下，避免再次入坑。 问题：在一个包含ViewPager页面里包含两个fragment（OneFragment、TwoFragment），在activity的onResume（）中调用加载数据方法，然而当前页面切至后台并发生被系统回收后...
Android 解决ViewPager+Fragment懒加载的问题
刘永祥的专栏
06-23 4797
使用ViewPager+Fragment的朋友应该知道其具有懒加载机制的，其实懒加载机制是Viewpager 所具有的，看过ViewPager源码的都会知道里面设置的有默认的懒加载的页数，默认的是1，这个1可不是我们通常所说的一页，这个1是左右各一页的意思。 比如说当进入应用时默认显示的是第一页，因为第一页左边没有要加载的页面，此时只会加载推荐和地图，如果你点击服务的时候，打印日志你就会发现
ViewPager+ Fragment结合的setUserVisibleHint（）调用时机
不忘初心
06-15 5320
    最近的项目使用到了ViewPager + Fragment的模式，要求在每次Fragment获取显示的时候来刷新数据，该项目下ViewPager有5个子fragment，在onCreateView及fragment的setUserVisibleHint（bool isVisibleToUser)中的isVisibleToUser为true的时候刷新数据的时候出现数据多次刷新的情况，因此对V...
Android学习笔记-Fragment的setUserVisibleHint()与getUserVisibleHint()
最新发布
HaveFun_Wine的博客
12-08 1581
当viewPaper初始化完成以后，执行viewPaper.setAdapter()的时候就会执行setUserVisibleHint()，待setAdapter()执行完成以后，才会进入fragment的生命周期。我们在调用setUserVisibleHint()时加载数据时，一般都会调用getUserVisibleHint()获取当前fragment是否可见，只有当fragment为可见状态时(getUserVisibleHint()返回值为ture)，才会加载数据。
Fragment可见与隐藏终极解决方案
u012933335的博客
09-19 4647
背景 前一段时间，运营同事发现首页tab pv数据异常，希望我们可以修改下。先介绍下app首页架构：首先底部四个按钮，点击切换tab（fragment），第二个fragment中使用viewPager加载了三个fragment（后续成为内部fragment），而这三个fragment的pv埋点原先都是在setUserVisibleHint()中埋的，而此方法只有在内部fragment切换中才会触发...
Viewpager嵌套fragment问题
qq_34736014的博客
01-23 188
在Viewpager中嵌套fragment，fragment显示不全，这和viewpager的回收机制有关， mViewPager.setOffscreenPageLimit(6);这个属性可以最大的支持tab的个数，使其不回收 还有一个问题，继承同一个懒加载会因为是同一个的原因，标签会改变，所以也会出现问题
viewpager嵌套fragment 再嵌套
08-17
当我们需要在一个`Fragment`中展示多个子页面时，就会用到`ViewPager`嵌套`Fragment`的技术。在这个场景下，如果`Fragment`内部也需要这样的滑动切换功能，就可能出现`ViewPager`嵌套`Fragment`再嵌套`ViewPager`的...
Fragment中嵌套Fragment，多次显示隐藏父Fragment之后子Fragment不显示
Zou_pl的博客
08-18 7072
项目中遇到一个问题，就是一个Fragment中嵌套Fragment，多次显示隐藏父Fragment之后子Fragment不显示。具体的表现是在父Fragment A中嵌套添加了一个子Fragment B。外部调用父Fragment A第一次显示时，FragmentA、B都正常显示；外部第二次调用父Fragment显示时，Fragment A正常显示，Fragment B显示空白。
Fragment的setUserVisibleHint方法实现
qq_18353977的博客
07-10 814
我们在做应用开发的时候，一个Activity里面可能会以viewpager（或其他容器）与多个Fragment来组合使用，而如果每个fragment都需要去加载数据，或从本地加载，或从网络加载，那么在这个activity刚创建的时候就变成需要初始化大量资源。这样的结果，我们当然不会满意。那么，能不能做到当切换到这个fragment的时候，它才去初始化呢？ 注释：setUserVisibleHin
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值