根本上解决多重多层级ViewPgaer嵌套Fragment，Fragment是否可见问题

灰太狼 2023-10-17 23:29 133阅读 0赞

## 根本上解决多重多层级ViewPgaer嵌套Fragment，Fragment是否可见问题 ##

如果是简单的一个ViewPager里面放置若干个Fragment，然后判断当前处于用户可见视野范围内，这个问题容易解决，方案也很多，在此不再具体解释。最麻烦的是ViewPager与Fragment发生多重嵌套，并且嵌套的层级很深时候，判断一个特定的Fragment是否可见变的是否棘手。比如ViewPagerA里面放几个Fragment（Fa,Fb,Fc），而Fa里面有放一个ViewPagerB，而ViewPagerB里面又盛放若干个Fragment（F甲，F乙，F丙），而 F甲 里面又再放一个ViewPagerC，ViewPagerC里面又放几个Fragment（F1，,F2，F3）…… 就像这样嵌套的越来越深时候，判断某一个特定的Fragment是否可见变的是否困难，但是这个需求和技术点又非常需要明确。典型的假如这些Fragment实时性都很强，都需要周期性的从服务器读取数据更新UI，如果让所有Fragment都同时实时更新，开销比较大，节俭的做法是只更新当前用户切换到的、处于用户视野可见范围内的Fragment数据才更新，而那些已经被用户切换走、处于不可见的Fragment暂停更新，但是当用户把那些原先不可见的Fragment切换到可见视野范围内又重新回来后，又有必要重新启动更新了。  
我写一个代码例子：

package zhangphil.test;
    
    import android.graphics.Color;
    import android.os.Bundle;
    import android.support.annotation.NonNull;
    import android.support.annotation.Nullable;
    import android.support.design.widget.TabLayout;
    import android.support.v4.app.Fragment;
    import android.support.v4.app.FragmentManager;
    import android.support.v4.app.FragmentPagerAdapter;
    import android.support.v4.view.ViewPager;
    import android.support.v7.app.AppCompatActivity;
    import android.util.TypedValue;
    import android.view.Gravity;
    import android.view.LayoutInflater;
    import android.view.View;
    import android.view.ViewGroup;
    import android.widget.TextView;
    
    import org.greenrobot.eventbus.EventBus;
    import org.greenrobot.eventbus.Subscribe;
    import org.greenrobot.eventbus.ThreadMode;
    
    import java.util.ArrayList;
    import java.util.concurrent.TimeUnit;
    
    public class ViewPagerActivity extends AppCompatActivity {
    
        @Override
        protected void onCreate(@Nullable Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.view_pager);
    
            ArrayList<Fragment> mFragments = new ArrayList<>();
            mFragments.add(TestFragmetA.newInstance("A0"));
            mFragments.add(TestFragmetA.newInstance("A1"));
            mFragments.add(TestFragmetA.newInstance("A2"));
            mFragments.add(TestFragmetA.newInstance("A3"));
    
            ViewPager mViewPager = findViewById(R.id.view_pager);
            MyPagerAdapter mPagerAdapter = new MyPagerAdapter(getSupportFragmentManager(), mFragments);
            mViewPager.setAdapter(mPagerAdapter);
    
            TabLayout mTabLayout = findViewById(R.id.tab_layout);
    
            for (int i = 0; i < mPagerAdapter.getCount(); i++) {
                TabLayout.Tab tab = mTabLayout.newTab();
                tab.setText("A" + i);
                mTabLayout.addTab(tab);
            }
    
            mViewPager.addOnPageChangeListener(new TabLayout.TabLayoutOnPageChangeListener(mTabLayout));
            mTabLayout.addOnTabSelectedListener(new TabLayout.ViewPagerOnTabSelectedListener(mViewPager) {
                @Override
                public void onTabSelected(TabLayout.Tab tab) {
                    mViewPager.setCurrentItem(tab.getPosition());
    
                    mFragments.get(tab.getPosition()).setUserVisibleHint(true);
                }
    
                @Override
                public void onTabUnselected(TabLayout.Tab tab) {
                    mFragments.get(tab.getPosition()).setUserVisibleHint(false);
                }
            });
    
            /**
             * 全局的周期更新信号发射源，每隔3秒发一个信号，这个信号触发一次更新操作。
             */
            new Thread(new Runnable() {
                int count = 0;
    
                @Override
                public void run() {
                    while (true) {
                        String string = count + "";
                        EventBus.getDefault().post(string);
    
                        try {
                            TimeUnit.SECONDS.sleep(3);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
    
                        count++;
                    }
                }
            }).start();
        }
    
        public static class MyPagerAdapter extends FragmentPagerAdapter {
    
            private ArrayList<Fragment> fragments;
    
            public MyPagerAdapter(FragmentManager fm, ArrayList<Fragment> fragments) {
                super(fm);
                this.fragments = fragments;
            }
    
            @Override
            public Fragment getItem(int position) {
                return fragments.get(position);
            }
    
            @Override
            public int getCount() {
                return fragments.size();
            }
        }
    
        public static class TestFragmetA extends Fragment {
            private static String TAG = "A";
    
            public static TestFragmetA newInstance(String tag) {
                Bundle args = new Bundle();
                args.putString(TAG, tag);
                TestFragmetA fragment = new TestFragmetA();
                fragment.setArguments(args);
                return fragment;
            }
    
    
            @Nullable
            @Override
            public View onCreateView(@NonNull LayoutInflater inflater, @Nullable ViewGroup container, @Nullable Bundle savedInstanceState) {
                View v = inflater.inflate(R.layout.view_pager, container, false);
                return v;
            }
    
            @Override
            public void onViewCreated(@NonNull View view, @Nullable Bundle savedInstanceState) {
                ArrayList<Fragment> mFragments = new ArrayList<>();
                mFragments.add(TestFragmetB.newInstance(getArguments().getString(TAG) + "-甲"));
                mFragments.add(TestFragmetB.newInstance(getArguments().getString(TAG) + "-乙"));
                mFragments.add(TestFragmetB.newInstance(getArguments().getString(TAG) + "-丙"));
                mFragments.add(TestFragmetB.newInstance(getArguments().getString(TAG) + "-丁"));
    
                ViewPager mViewPager = view.findViewById(R.id.view_pager);
                MyPagerAdapter mPagerAdapter = new MyPagerAdapter(getChildFragmentManager(), mFragments);
                mViewPager.setAdapter(mPagerAdapter);
    
                TabLayout mTabLayout = view.findViewById(R.id.tab_layout);
    
                for (int i = 0; i < mPagerAdapter.getCount(); i++) {
                    TabLayout.Tab tab = mTabLayout.newTab();
                    tab.setText("B" + i);
                    mTabLayout.addTab(tab);
                }
    
                mViewPager.addOnPageChangeListener(new TabLayout.TabLayoutOnPageChangeListener(mTabLayout));
                mTabLayout.addOnTabSelectedListener(new TabLayout.ViewPagerOnTabSelectedListener(mViewPager) {
                    @Override
                    public void onTabSelected(TabLayout.Tab tab) {
                        mViewPager.setCurrentItem(tab.getPosition());
    
                        mFragments.get(tab.getPosition()).setUserVisibleHint(true);
                    }
    
                    @Override
                    public void onTabUnselected(TabLayout.Tab tab) {
                        mFragments.get(tab.getPosition()).setUserVisibleHint(false);
                    }
                });
            }
    
            @Override
            public void setUserVisibleHint(boolean isVisibleToUser) {
                super.setUserVisibleHint(isVisibleToUser);
                //这里的 isVisibleToUser 已经被上一层级切换TabLayout中设置过。
            }
        }
    
        public static class TestFragmetB extends Fragment {
            private static String TAG = "B";
            private TextView mRootView;
    
            //根据生命周期控制是否更新。
            private boolean CAN_REFRESH = false;
    
            public static TestFragmetB newInstance(String tag) {
                Bundle args = new Bundle();
                args.putString(TAG, tag);
                TestFragmetB fragment = new TestFragmetB();
                fragment.setArguments(args);
                return fragment;
            }
    
            @Override
            public void onCreate(@Nullable Bundle savedInstanceState) {
                super.onCreate(savedInstanceState);
                EventBus.getDefault().register(this);
            }
    
            @Nullable
            @Override
            public View onCreateView(@NonNull LayoutInflater inflater, @Nullable ViewGroup container, @Nullable Bundle savedInstanceState) {
                if (mRootView == null) {
                    mRootView = new TextView(container.getContext());
                    mRootView.setGravity(Gravity.LEFT | Gravity.TOP);
                    mRootView.setText(getArguments().getString(TAG));
                    mRootView.setTextColor(Color.RED);
                    mRootView.setTextSize(TypedValue.COMPLEX_UNIT_DIP, 15);
                }
    
                return mRootView;
            }
    
            @Subscribe(threadMode = ThreadMode.MAIN)
            public void onMsgEvent(String msg) {
                /**
                 * 刷新判断条件是否成立。
                 */
                if (getUserVisibleHint() && getParentFragment().getUserVisibleHint() && CAN_REFRESH) {
                    update(msg);
                }
            }
    
            /**
             * 这里可以进行UI刷新。
             *
             * @param msg
             */
            private void update(String msg) {
                if (mRootView != null) {
                    String s = mRootView.getText() + "";
                    mRootView.setText(s + "," + msg);
                }
            }
    
            @Override
            public void onResume() {
                super.onResume();
                CAN_REFRESH = true;
            }
    
            @Override
            public void onPause() {
                super.onPause();
                CAN_REFRESH = false;
            }
    
            @Override
            public void onDestroy() {
                super.onDestroy();
                CAN_REFRESH = false;
                EventBus.getDefault().unregister(this);
            }
        }
    }

布局文件：

<?xml version="1.0" encoding="utf-8"?>
    <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:orientation="vertical">
    
        <android.support.design.widget.TabLayout
            android:id="@+id/tab_layout"
            android:layout_width="match_parent"
            android:layout_height="wrap_content" />
    
        <android.support.v4.view.ViewPager
            android:id="@+id/view_pager"
            android:layout_width="match_parent"
            android:layout_height="match_parent" />
    
    </LinearLayout>

在ViewPager与Fragment多重嵌套且层级深时候，我的这个方案采用主动通过setUserVisibleHint设置isVisibleToUser的值，在TabLayout（本例是TabLayout，可以是其他形式触发ViewPager切换）切换时候，TabLayout中调度ViewPager加载哪一个Fragment是明确的，那么就给当前TabLayout选中的那个Fragment（也即是ViewPager切换到的Fragment）的isVisibleToUser设置为true，其他未被选中的Fragment，isVisibleToUser设置为false。因为ViewPager中的某一个Fragment又嵌套了一个ViewPager，所以需要把上一级的TabLayout选中Fragment可见状态传递下去，所以在Fragment中，如果Fragment又包含一重ViewPager，则和上一步一样，把isVisibleToUser的值在本级TabLayout切换中传递下去（通过setUserVisibleHint）。  
做了这么多isVisibleToUser的传递，目的最终是打算通过getUserVisibleHint()来判断当前Fragment是否可见。  
本例通过EventBus没隔3秒发送一个更新触发信号，在所有Fragment中都可以接收这个更新信号，但是只有处于用户可见的Fragment才可以更新，而判断当前Fragment是否处于可见，就通过getUserVisibleHint()返回的布尔值，注意到本例还有一个getParentFragment().getUserVisibleHint()作为当前Fragment是否处于可见的联合判断条件之一，是因为Fragment嵌套的太深了，当前Fragment的上一层级Fragment也必须在多重嵌套中处于可见时候，才满足最终的可见条件判断。  
同时增加了一个CAN\_REFRESH布尔值作为更新判断条件之一，CAN\_REFRESH目的是为了标记当前Fragment的生命周期情况，假设一种场景，当前Fragment的确处于可见，但是用户按了手机的home键，导致整个App处于不可见，那么getUserVisibleHint()方法捕捉不到这种变化，需要联合生命周期的onResume和onPause共同判断当前Fragment是否处于手机屏幕的可见状态。  
代码运行后，每一个Fragment只有出于可见状态时候，接收到EventBus的更新消息并把数据显示到屏幕上，如果处于不可见，不会显示EventBus发射的更新信号。来回切换Fragment和ViewPager时候，只有出于当前可见的Fragment才会更新到最新的EventBus发射的消息编号。其他不可见的Fragment不会更新，但是切换到时候，就会追加更新到最新EventBus更新消息编号。

![70][]

[70]: https://img-blog.csdn.net/20180816113644814?watermark/2/text/aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poYW5ncGhpbA==/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70