Android 使用FragmentStatePagerAdapter时Fragment为null

我的应用程序中有3个底部导航选项卡：

• 家
• 我的旅行
• 侧面图

在

MyTour

中，我使用的是

MyTourFragment

，它有3个不同的选项卡：

• 待定（0）
• 成功（1）
• 失败（2）

对于所有三个选项卡（挂起、成功、失败），我使用的是

FragmentMyTourJobList

，具体取决于我在所有三个选项卡中显示挂起、成功或失败数据的条件

问题陈述：

当我单击

MyTour

导航项时，挂起的片段实例将为空，我只能看到空白片段，但如果单击成功或失败，则可以看到数据。挂起的选项卡数据仅在从其他选项卡返回后才可见，但最初不可见

以下是MyTourFragment代码：

public class MyTourFragment {

    public MyTourFragment() {

    }

    public static MyTourFragment newInstance(MyTourFragmentListener myTourFragmentListener) {
        return new MyTourFragment(myTourFragmentListener);
    }

    private MyTourFragment(MyTourFragmentListener myTourFragmentListener) {
        this.mMyTourFragmentListener = myTourFragmentListener;
    }

    @Override
    public void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        mViewModel.setNavigator(this);
        setHasOptionsMenu(true);

        //Get the Tab Id.
        Bundle bundle = this.getArguments();
        if (bundle != null) {
            mViewModel.setSelectedDateTimeMillis(bundle.getLong("todaysDateForMyTour", Calendar.getInstance().getTimeInMillis()));
            mSelectedTabId = bundle.getInt(KEY_SELECTED_TAB, 0);
        }

        mMyTourJobsListPagerAdapter = new MyTourJobsListPagerAdapter(this, mViewModel.getTourIdForSelectedDate(), this);

    }

    @Override
    public void onViewCreated(@NonNull View view, @Nullable Bundle savedInstanceState) {
        super.onViewCreated(view, savedInstanceState);

        mFragmentMyTourBinding = getViewDataBinding();

        mFragmentMyTourBinding.vpMyTour.setOffscreenPageLimit(2);
        mFragmentMyTourBinding.vpMyTour.setCurrentItem(0);
        mFragmentMyTourBinding.vpMyTour.setAdapter(mMyTourJobsListPagerAdapter);
        mFragmentMyTourBinding.tabLayoutMyTour.setupWithViewPager(mFragmentMyTourBinding.vpMyTour, true);
        mFragmentMyTourBinding.tabLayoutMyTour.addOnTabSelectedListener(this);

        setUpTabs();
    }

    private void setUpTabs() {

        //Select the current Tab.
        mFragmentMyTourBinding.vpMyTour.setCurrentItem(mSelectedTabId);

        //Refresh job list as per the selected date.
        FragmentMyTourJobsList fragmentMyTourJobsList = mMyTourJobsListPagerAdapter.getFragmentAtTab(mSelectedTabId); **// this is null first time**
        if (fragmentMyTourJobsList != null) {
            fragmentMyTourJobsList.refreshJobsList(mViewModel.getTourIdForSelectedDate());
        } 
    }
}    

以下是MyTourJobsListPagerAdapter代码：

public class MyTourJobsListPagerAdapter extends FragmentStatePagerAdapter {

    private static final int MY_TOUR_JOBS_LIST_PAGES_COUNT = 3;
    private static final int POSITION_TAB_PENDING = 0;
    private static final int POSITION_TAB_SUCCESS = 1;
    private static final int POSITION_TAB_FAILED = 2;
    private HashMap<Integer, FragmentMyTourJobsList> mTabsFragments = new HashMap<Integer, FragmentMyTourJobsList>();
    private long mTourId;
    private FragmentMyTourJobsList.FragmentMyTourJobsListListener mFragmentMyTourJobsListListener;

    public MyTourJobsListPagerAdapter(Fragment fragment, long tourId, FragmentMyTourJobsList.FragmentMyTourJobsListListener fragmentMyTourJobsListListener) {
        super(fragment.getChildFragmentManager(), BEHAVIOR_RESUME_ONLY_CURRENT_FRAGMENT);
        this.mTourId = tourId;
        this.mFragmentMyTourJobsListListener = fragmentMyTourJobsListListener;
    }

    public void setTourId(long tourId) {
        this.mTourId = tourId;
    }

    @Override
    public int getCount() {
        return MY_TOUR_JOBS_LIST_PAGES_COUNT;
    }

    @NonNull
    @Override
    public Object instantiateItem(@NonNull ViewGroup container, int position) {
        Fragment fragment = (Fragment) super.instantiateItem(container, position);
        mTabsFragments.put(position, (FragmentMyTourJobsList) fragment);
        return fragment;
    }


    @Override
    public void destroyItem(@NonNull ViewGroup container, int position, @NonNull Object object) {
        mTabsFragments.remove(position);
        super.destroyItem(container, position, object);
    }

    @Override
    public Fragment getItem(int position) {
        FragmentMyTourJobsList fragmentMyTourJobsList;
        switch (position) {
            case POSITION_TAB_SUCCESS:
                fragmentMyTourJobsList = getFragmentWithBundle(Constants.JOB_STATUS_SUCCESSFUL);
                break;
            case POSITION_TAB_FAILED:
                fragmentMyTourJobsList = getFragmentWithBundle(Constants.JOB_STATUS_FAILED);
                break;
            case POSITION_TAB_PENDING:
            default:
                fragmentMyTourJobsList = getFragmentWithBundle(Constants.JOB_STATUS_ACCEPTED);
                break;

        }
        return fragmentMyTourJobsList;
    }

    public FragmentMyTourJobsList getFragmentAtTab(int tabPosition) {
        return mTabsFragments.get(tabPosition);
    }

    private FragmentMyTourJobsList getFragmentWithBundle(String jobsStatus) {
        FragmentMyTourJobsList fragmentToLoad = FragmentMyTourJobsList.newInstance();

        Bundle bundle = new Bundle();
        bundle.putString(FragmentMyTourJobsList.KEY_ARG_JOBS_STATUS, jobsStatus);
        bundle.putLong(FragmentMyTourJobsList.KEY_ARG_TOUR_ID, mTourId);
        bundle.putSerializable(FragmentMyTourJobsList.KEY_ARG_FRAGMENT_MY_TOUR_JOBS_LIST_LISTENER, mFragmentMyTourJobsListListener);

        fragmentToLoad.setArguments(bundle);

        return fragmentToLoad;
    }
}

公共类MyTourJobsListPageAdapter扩展了FragmentStatePagerAdapter{
私有静态最终int MY_TOUR_JOBS_LIST_PAGES_COUNT=3；
私有静态最终整数位置\u TAB\u PENDING=0；
私有静态最终整数位置选项卡成功=1；
私有静态最终整数位置选项卡失败=2；
私有HashMap mTabsFragments=新HashMap（）；
私人长途旅行；
私有FragmentMyTourJobsList.FragmentMyTourJobsListener MFFragmentMyTourJobsListener；
公共MyTourJobsListManager适配器（片段片段片段、长片段、片段MyTourJobsList.片段MyTourJobsListener片段MyTourJobsListener）{
super（fragment.getChildFragmentManager（），行为\仅恢复\当前\片段）；
this.mTourId=tourId；
this.mFragmentMyTourJobsListener=片段MyTourJobsListener；
}
公共旅游（长期旅游）{
this.mTourId=tourId；
}
@凌驾
public int getCount（）{
返回我的工作列表页数；
}
@非空
@凌驾
公共对象实例化项（@NonNull视图组容器，int位置）{
Fragment Fragment=（Fragment）super.instanceItem（容器，位置）；
放置（位置，（FragmentMyTourJobsList）片段）；
返回片段；
}
@凌驾
public void destructionItem（@NonNull视图组容器，int位置，@NonNull对象）{
删除（位置）；
超级项目（容器、位置、对象）；
}
@凌驾
公共片段getItem（int位置）{
FragmentMyTourJobsList FragmentMyTourJobsList；
开关（位置）{
案例位置选项卡成功：
fragmentMyTourJobsList=getFragmentWithBundle（常量。作业状态\u成功）；
打破
案例位置选项卡失败：
fragmentMyTourJobsList=getFragmentWithBundle（常量。作业状态\u失败）；
打破
案例位置选项卡待定：
违约：
fragmentMyTourJobsList=getFragmentWithBundle（常量、作业状态、已接受）；
打破
}
返回碎片MyTourJobsList；
}
公共碎片MyTourJobsList getFragmentAtTab（int选项卡位置）{
返回MTABSSfragments.get（tabPosition）；
}
私有碎片MyTourJobsList getFragmentWithBundle（字符串jobsStatus）{
FragmentMyTourJobsList fragmentToLoad=FragmentMyTourJobsList.newInstance（）；
Bundle=新Bundle（）；
bundle.putString（FragmentMyTourJobsList.KEY\u ARG\u JOBS\u STATUS，jobsStatus）；
bundle.putLong（FragmentMyTourJobsList.KEY\u ARG\u TOUR\u ID，mTourId）；
bundle.putSerializable（FragmentMyTourJobsList.KEY_ARG_FRAGMENT_MY_TOUR_JOBS_LIST_LISTENER，MFFragmentMyTourJobsListener）；
fragmentToLoad.setArguments（bundle）；
返回碎片装载；
}
}

一切都在工作，但当我第一次进入待定选项卡时，它就不工作了。我有什么遗漏吗

添加了碎片MyTourJobList

public class FragmentMyTourJobsList extends BaseFragment<FragmentMyTourJobsListBinding, MyTourJobsListViewModel> implements MyTourJobsListNavigator {

    public static FragmentMyTourJobsList newInstance() {
        return new FragmentMyTourJobsList();
    }

    @Override
    public void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        mViewModel.setNavigator(this);

        Bundle bundle = this.getArguments();
        if (bundle != null) {
            mJobsStatus = bundle.getString(KEY_ARG_JOBS_STATUS);
            mTourId = bundle.getLong(KEY_ARG_TOUR_ID, 0);
        }
    }

    @Override
    public int getBindingVariable() {
        return myTourJobsListViewModel;
    }

    @Override
    public int getLayoutId() {
        return R.layout.fragment_my_tour_jobs_list;
    }

    @Override
    public MyTourJobsListViewModel getViewModel() {
        mViewModel = ViewModelProviders.of(this, new ViewModelProviderFactory(Objects.requireNonNull(getActivity()).getApplication())).get(MyTourJobsListViewModel.class);
        return mViewModel;
    }

    @Override
    public void onViewCreated(@NonNull View view, @Nullable Bundle savedInstanceState) {
        super.onViewCreated(view, savedInstanceState);
        mFragmentMyTourJobsListBinding = getViewDataBinding();

        // fetch job list  from database
        ArrayList<JobUiModel> jobList = mViewModel.fetchJobs(mTourId, mJobsStatus);
        RecyclerView.LayoutManager rvLayoutManager = new LinearLayoutManager(getActivity());
        mFragmentMyTourJobsListBinding.rvMyTourJobs.setLayoutManager(rvLayoutManager);

        // initialize adapter
        mJobsListAdapter = new MyTourJobsListAdapter(getContext(), jobList, mJobsStatus);
        mFragmentMyTourJobsListBinding.rvMyTourJobs.setAdapter(mJobsListAdapter);
        mJobsListAdapter.setClickInterface(this);

        mFragmentMyTourJobsListBinding.rvMyTourJobs.addItemDecoration(new EndOffsetItemDecoration(CommonUtils.dpToPx(56)));
    }

    void refreshJobsList(long tourId) {

        if (tourId > 0) {
            mTourId = tourId;
            mViewModel.fetchJobs(tourId, mJobsStatus);
            // fetch job list  from database
            ArrayList<JobUiModel> jobList = mViewModel.fetchJobs(mTourId, mJobsStatus);
            mJobsListAdapter.setDataset(jobList);
            mJobsListAdapter.notifyDataSetChanged();


        } else {
            mJobsListAdapter.setDataset(null);
            mJobsListAdapter.notifyDataSetChanged();

        }
    }
}

公共类FragmentMyTourJobsList扩展了BaseFragment实现MyTourJobsList导航器{
公共静态碎片MyTourJobsList newInstance（）{
返回新碎片MyTourJobsList（）；
}
@凌驾
创建时的公共void（@Nullable Bundle savedInstanceState）{
super.onCreate（savedInstanceState）；
mViewModel.setNavigator（这个）；
Bundle=this.getArguments（）；
if（bundle！=null）{
mjobstatus=bundle.getString（KEY\u ARG\u JOBS\u STATUS）；
mTourId=bundle.getLong（KEY\u ARG\u TOUR\u ID，0）；
}
}
@凌驾
public int getBindingVariable（）{
返回myTourJobsListViewModel；
}
@凌驾
public int getLayoutId（）{
返回R.layout.fragment\u my\u tour\u jobs\u list；
}
@凌驾
公共MyTourJobsListViewModel getViewModel（）{
mViewModel=ViewModelProviders.of（这是新的ViewModelProviderFactory（Objects.requirennoull（getActivity（））.getApplication（））.get（MyTourJobsListViewModel.class）；
返回mViewModel；
}
@凌驾
已创建公用void onview（@NonNull视图，@Nullable Bundle savedInstanceState）{
super.onViewCreated（视图，savedInstanceState）；
MFFragmentMyTourJobsListBinding=getViewDataBinding（）；
//从数据库中获取作业列表
ArrayList作业列表=mViewModel.fetchJobs（mTourId，mjobstatus）；
RecyclerView.LayoutManager rvLayoutManager=新的LinearLayoutManager（getActivity（））；
MFFragmentMyTourJobsListBinding.rvMyTourJobs.setLayoutManager（rvLayoutManager）；
//初始化适配器
mJobsListAdapter=新的MyTourJobsListAdapter（getContext（），作业列表，mJobsStatus）；
mFragmentMyTourJobsListBinding.rvMyTourJobs.setAdapter（mJobsListAdapter）；
mJobsListAdapter.setClickInterface（此界面）；
MFFragmentMyTourJobsListBinding.rvMyTourJobs.addItemDecoration（新EndOffsetItemDecoration（CommonUtils.dpToP