我在使用FragmentStatePagerAdapters和3个选项卡时遇到了同样的问题。每当单击第一个选项卡时，我必须显示一个Dilaog，并在单击其他选项卡时隐藏它。

单独重写setUserVisibleHint（）无助于查找当前可见片段。

从第三个选项卡单击时----->第一个选项卡。第二个片段和第一个片段触发了两次。我将其与isResumed（）方法结合使用。

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

    // Make sure that fragment is currently visible
    if (!isVisible && isResumed()) {
        // Call code when Fragment not visible
    } else if (isVisible && isResumed()) {
       // Call code when Fragment becomes visible.
    }

}

setUserVisibleHint（）有时会在onCreateView（）之前调用，有时会在之后调用。

要克服这个问题，您需要在setUserVisibleHint（）方法中检查isResumed（）。但在本例中，我意识到只有当Fragment恢复并可见时，才会调用setUserVisibleHint（），而不是在Created时。

因此，如果您想在Fragment可见时更新某些内容，请将更新函数放在onCreate（）和setUserVisibleHint（）中：

@Override
public View onCreateView(...){
    ...
    myUIUpdate();
    ...        
}
  ....
@Override
public void setUserVisibleHint(boolean visible){
    super.setUserVisibleHint(visible);
    if (visible && isResumed()){
        myUIUpdate();
    }
}

UPDATE：我仍然意识到myUIUpdate（）有时会被调用两次，原因是，如果您有3个选项卡，而这段代码位于第二个选项卡上，当您第一次打开第一个选项卡时，第二个标签也会被创建，即使它不可见，并且会调用myUIUpdate）。然后，当您滑动到第二个选项卡时，将调用if（visible&&isResumed（））中的myUIUpdate（），因此，myUIUpdate）可能会在一秒内被调用两次。

另一个问题是！setUserVisibleHint中的visible同时被调用：1）当您退出片段屏幕时；2）在创建片段屏幕之前，当您第一次切换到片段屏幕时。

解决方案：

private boolean fragmentResume=false;
private boolean fragmentVisible=false;
private boolean fragmentOnCreated=false;
...

@Override
public View onCreateView(...){
    ...
    //Initialize variables
    if (!fragmentResume && fragmentVisible){   //only when first time fragment is created
        myUIUpdate();
    }
    ...        
}

@Override
public void setUserVisibleHint(boolean visible){
    super.setUserVisibleHint(visible);
    if (visible && isResumed()){   // only at fragment screen is resumed
        fragmentResume=true;
        fragmentVisible=false;
        fragmentOnCreated=true;
        myUIUpdate();
    }else  if (visible){        // only at fragment onCreated
        fragmentResume=false;
        fragmentVisible=true;
        fragmentOnCreated=true;
    }
    else if(!visible && fragmentOnCreated){// only when you go out of fragment screen
        fragmentVisible=false;
        fragmentResume=false;
    }
}

说明：

fragmentResume，fragmentVisible：确保仅在创建片段并可见时才调用onCreateView（）中的myUIUpdate（），而不是在恢复时调用。它还解决了当您处于第一个选项卡时的问题，即使第二个选项卡不可见，也会创建它。这解决了这个问题，并检查在onCreate时片段屏幕是否可见。

fragmentOnCreated：确保片段不可见，并且在第一次创建片段时不会被调用。所以现在，这个if子句只在从片段中滑出时被调用。

使现代化您可以像这样将所有这些代码放在BaseFragment代码中，并重写方法。

为此重写Fragment.onHiddenChanged（）。

公共void onHiddenChanged（布尔隐藏）当片段的隐藏状态（由isHidden（）返回）更改时调用。碎片开始时并不隐藏；每当片段从中改变状态时，都会调用此函数。参数hidden-boolean：如果片段现在隐藏，则为True，如果不可见，则为false。

在版本androidx.fragment:frage:1.1.0的ViewPager2和ViewPager中，您可以使用onPause和onResume回调来确定用户当前可见的片段。当片段可见时调用onResume回调，当片段停止可见时调用onPause回调。

在ViewPager2的情况下，这是默认行为，但同样的行为可以很容易地为旧的好ViewPager启用。

要在第一个ViewPager中启用此行为，必须将FragmentPagerAdapter.behavior_RESUME_ONLY_CURRENT_FRAGMENT参数作为FragmentPagerAdapter构造函数的第二个参数传递。

FragmentPagerAdapter(fragmentManager, BEHAVIOR_RESUME_ONLY_CURRENT_FRAGMENT)

注意：在android jetpack的新版本Fragment中，setUserVisibleHint（）方法和带有一个参数的FragmentPagerAdapter构造函数现在已被弃用。

我支持带有子片段的SectionsPagerAdapter，所以在经历了很多头疼之后，我终于得到了基于本主题解决方案的工作版本：

public abstract class BaseFragment extends Fragment {

    private boolean visible;
    private boolean visibilityHintChanged;

    /**
     * Called when the visibility of the fragment changed
     */
    protected void onVisibilityChanged(View view, boolean visible) {

    }

    private void triggerVisibilityChangedIfNeeded(boolean visible) {
        if (this.visible == visible || getActivity() == null || getView() == null) {
            return;
        }
        this.visible = visible;
        onVisibilityChanged(getView(), visible);
    }

    @Override
    public void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        if (!visibilityHintChanged) {
            setUserVisibleHint(false);
        }
    }

    @Override
    public void onResume() {
        super.onResume();
        if (getUserVisibleHint() && !isHidden()) {
            triggerVisibilityChangedIfNeeded(true);
        }
    }

    @Override
    public void onHiddenChanged(boolean hidden) {
        super.onHiddenChanged(hidden);
        triggerVisibilityChangedIfNeeded(!hidden);
    }

    @Override
    public void setUserVisibleHint(boolean isVisibleToUser) {
        super.setUserVisibleHint(isVisibleToUser);
        visibilityHintChanged = true;
        if (isVisibleToUser && isResumed() && !isHidden()) {
            triggerVisibilityChangedIfNeeded(true);
        } else if (!isVisibleToUser) {
            triggerVisibilityChangedIfNeeded(false);
        }
    }

    @Override
    public void onPause() {
        super.onPause();
        triggerVisibilityChangedIfNeeded(false);
    }

    @Override
    public void onStop() {
        super.onStop();
        triggerVisibilityChangedIfNeeded(false);
    }

    protected boolean isReallyVisible() {
        return visible;
    }
}

注意，在活动/片段停止时不会调用setUserVisibleHint（false）。您仍然需要检查启动/停止以正确注册/注销任何侦听器等。

此外，如果片段以不可见状态开始，则会得到setUserVisibleHint（false）；您不想在那里注销，因为在这种情况下，您以前从未注册过。

@Override
public void onStart() {
    super.onStart();

    if (getUserVisibleHint()) {
        // register
    }
}

@Override
public void onStop() {
    if (getUserVisibleHint()) {
        // unregister
    }

    super.onStop();
}

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

    if (isVisibleToUser && isResumed()) {
        // register

        if (!mHasBeenVisible) {
            mHasBeenVisible = true;
        }
    } else if (mHasBeenVisible){
        // unregister
    }
}