技术圈首页 程序员 解决方案 聚合短信
APP下载 注册
首页 文章详情

Fragment可见性监听方案(含Android X适配)

Carson带你学习Android | 1852 2021-08-30 18:23 0 0 0
UniSMS (合一短信)

前言

在开发当中，很多时候需要监听 Fragment 的显示与隐藏从而进行一些业务逻辑，本文将提供一种 「Fragment可见性」的监听方案（含Android X适配）。

监听场景

  1. Replace操作
  2. Hide 和 Show 操作
  3. ViewPager 嵌套 Fragment
  4. 宿主 Fragment 再嵌套 Fragment
  5. Android X 适配

场景1：Replace操作

  • Replace操作的作用是：先移除所有存在的Fragment， 然后把新的Fragment 添加进来。此时会正常调用 onResume()、onPause()。
  • 监听时机：在 onResume()、onPause()
override fun onResume() {
    info("onResume")
    super.onResume()
    onActivityVisibilityChanged(true)
}


override fun onPause() {
    info("onPause")
    super.onPause()
    onActivityVisibilityChanged(false)
}

场景2：Hide 和 Show 操作

  • 说明：这两个操作不会触发生命周期回调。但会触发onHiddenChanged()
  • 监听时机：通过 onHiddenChanged() 监听
override fun onHiddenChanged(hidden: Boolean) {
    super.onHiddenChanged(hidden)
    checkVisibility(hidden)
}

场景3：ViewPager 嵌套 Fragment

  • 说明：因为 ViewPager 的预加载机制，在 onResume()监听不准确。
  • 监听时机：setUserVisibleHint()，当方法传入值为true时，说明Fragment可见；传入为false时说明Fragment被切走了。
public void setUserVisibleHint(boolean isVisibleToUser)

有一点需要注意的是，该方法可能先于Fragment的生命周期被调用（在FragmentPagerAdapter中，在Fragment被add之前这个方法就被调用了），所以在这个方法中进行操作之前，需要先判断一下生命周期是否执行。

 /**
   * Tab切换时会回调此方法。对于没有Tab的页面，[Fragment.getUserVisibleHint]默认为true。
   */
  @Suppress("DEPRECATION")
  override fun setUserVisibleHint(isVisibleToUser: Boolean) {
      info("setUserVisibleHint = $isVisibleToUser")
      super.setUserVisibleHint(isVisibleToUser)
      checkVisibility(isVisibleToUser)
  }

  /**
   * 检查可见性是否变化
   *
   * @param expected 可见性期望的值。只有当前值和expected不同，才需要做判断
   */
  private fun checkVisibility(expected: Boolean) {
      if (expected == visible) return
      val parentVisible = if (localParentFragment == null) {
          parentActivityVisible
      } else {
          localParentFragment?.isFragmentVisible() ?: false
      }
      val superVisible = super.isVisible()
      val hintVisible = userVisibleHint
      val visible = parentVisible && superVisible && hintVisible
      info(
              String.format(
                      "==> checkVisibility = %s  ( parent = %s, super = %s, hint = %s )",
                      visible, parentVisible, superVisible, hintVisible
              )
      )
      if (visible != this.visible) {
          this.visible = visible
          onVisibilityChanged(this.visible)
      }
  }

场景4：宿主 Fragment 再嵌套 Fragment

如 ViewPager 嵌套 ViewPager，再嵌套 Fragment。宿主Fragment在生命周期执行的时候会相应的分发到子Fragment中，但是setUserVisibleHint和onHiddenChanged却没有进行相应的回调。试想这么一个场景：一个ViewPager中有一个FragmentA的tab，而FragmentA中有一个子FragmentB，FragmentA被滑走了，FragmentB并不能接收到setUserVisibleHint事件及onHiddenChange事件。

所以，关键点在于：如何监听到宿主的 setUserVisibleHint 、onHiddenChange 事件，有两个方案：

  1. 方法1：宿主 Fragment 提供可见性的回调 - 子 Fragment 监听改回调，有点类似于观察者模式。难点在于子 Fragment 要怎么拿到宿主 Fragment；
  2. 方法2：宿主 Fragment 可见性变化的时候，主动去遍历所有的 子 Fragment，调用 子 Fragment 的相应方法。

下面将详细说明

方法1：宿主 Fragment 提供可见性的回调

 /**
   * 1. 定义一个接口
   */
   interface OnFragmentVisibilityChangedListener {
      fun onFragmentVisibilityChanged(visible: Boolean)
  }

/**
   * 2. 在 BaseVisibilityFragment 中提供 addOnVisibilityChangedListener 和 removeOnVisibilityChangedListener 方法
   * 注：
   *   1. 我们需要用一个 ArrayList 来保存所有的 listener，因为一个宿主 Fragment 可能有多个子 Fragment。
   *   2. 当 Fragment 可见性变化的时候，会遍历 List 调用 OnFragmentVisibilityChangedListener 的 onFragmentVisibilityChanged 方法
   */
  open class BaseVisibilityFragment : Fragment(), View.OnAttachStateChangeListener,
        OnFragmentVisibilityChangedListener {


    private val listeners = ArrayList<OnFragmentVisibilityChangedListener>()

    fun addOnVisibilityChangedListener(listener: OnFragmentVisibilityChangedListener?) {
        listener?.apply {
            listeners.add(this)
        }
    }

    fun removeOnVisibilityChangedListener(listener: OnFragmentVisibilityChangedListener?) {
        listener?.apply {
            listeners.remove(this)
        }
    }
    
    private fun checkVisibility(expected: Boolean) {
        if (expected == visible) return
        val parentVisible =
            if (localParentFragment == null) parentActivityVisible
            else localParentFragment?.isFragmentVisible() ?: false
        val superVisible = super.isVisible()
        val hintVisible = userVisibleHint
        val visible = parentVisible && superVisible && hintVisible
    
        if (visible != this.visible) {
            this.visible = visible
            listeners.forEach { it ->
                it.onFragmentVisibilityChanged(visible)
            }
            onVisibilityChanged(this.visible)
        }
    }

 
 /**
   * 3.在 Fragment attach 时，通过 getParentFragment()，拿到宿主 Fragment，进行监听。
   * 此时，当宿主 Fragment 可见性变化时，子 Fragment能感应到。
   */
   override fun onAttach(context: Context) {
        super.onAttach(context)
        val parentFragment = parentFragment
        if (parentFragment != null && parentFragment is BaseVisibilityFragment) {
            this.localParentFragment = parentFragment
            info("onAttach， localParentFragment is $localParentFragment")
            localParentFragment?.addOnVisibilityChangedListener(this)
        }
        checkVisibility(true)
    }

方法2：主动遍历

宿主 Fragment 生命周期变化时，主动去遍历所有的 子 Fragment，调用 子 Fragment 的相应方法通知其生命周期发生了变化。

//当自己的显示隐藏状态改变时，调用这个方法通知子Fragment
private void notifyChildHiddenChange(boolean hidden) {
    if (isDetached() || !isAdded()) {
        return;
    }
    FragmentManager fragmentManager = getChildFragmentManager();
    List<Fragment> fragments = fragmentManager.getFragments();
    if (fragments == null || fragments.isEmpty()) {
        return;
    }
    for (Fragment fragment : fragments) {
        if (!(fragment instanceof IPareVisibilityObserver)) {
            continue;
        }
        ((IPareVisibilityObserver) fragment).onParentFragmentHiddenChanged(hidden);
    }
}

场景5：AndroidX 的适配

在 AndroidX 当中，FragmentAdapter 和 FragmentStatePagerAdapter 的构造方法，是添加一个 behavior 参数实现的。若我们指定不同的 behavior，会有不同的表现：

  1. behavior = BEHAVIOR_RESUME_ONLY_CURRENT_FRAGMENT 时：ViewPager 中切换 Fragment，setUserVisibleHint 方法将不再被调用，但会确保 onResume 的正确调用时机
  2. behavior = BEHAVIOR_SET_USER_VISIBLE_HINT：跟之前的方式是一致，可通过 setUserVisibleHint 结合 fragment 的生命周期来监听。
// FragmentStatePagerAdapter构造方法
public FragmentStatePagerAdapter(@NonNull FragmentManager fm,
        @Behavior int behavior) {
    mFragmentManager = fm;
    mBehavior = behavior;
}
 
// FragmentPagerAdapter构造方法
public FragmentPagerAdapter(@NonNull FragmentManager fm,
        @Behavior int behavior) {
    mFragmentManager = fm;
    mBehavior = behavior;
}

@IntDef({BEHAVIOR_SET_USER_VISIBLE_HINT, BEHAVIOR_RESUME_ONLY_CURRENT_FRAGMENT})
private @interface Behavior { }

即 在 onResume 中调用 checkVisibility ()判断当前 Fragment 是否可见即可。继续看Behavior 该如何实现，以FragmentStatePagerAdapter 为例，源码如下：

@SuppressWarnings({"ReferenceEquality", "deprecation"})
@Override
public void setPrimaryItem(@NonNull ViewGroup container, int position, @NonNull Object object) {
    Fragment fragment = (Fragment)object;
    if (fragment != mCurrentPrimaryItem) {
        if (mCurrentPrimaryItem != null) {
      //当前显示Fragment
            mCurrentPrimaryItem.setMenuVisibility(false);
            if (mBehavior == BEHAVIOR_RESUME_ONLY_CURRENT_FRAGMENT) {
                if (mCurTransaction == null) {
                    mCurTransaction = mFragmentManager.beginTransaction();
                }
    //最大生命周期设置为STARTED,生命周期回退到onPause
                mCurTransaction.setMaxLifecycle(mCurrentPrimaryItem, Lifecycle.State.STARTED);
            } else {
    //可见性设置为false
                mCurrentPrimaryItem.setUserVisibleHint(false);
            }
        }
  
  //将要显示的Fragment
        fragment.setMenuVisibility(true);
        if (mBehavior == BEHAVIOR_RESUME_ONLY_CURRENT_FRAGMENT) {
            if (mCurTransaction == null) {
                mCurTransaction = mFragmentManager.beginTransaction();
            }
   //最大 生命周期设置为RESUMED
            mCurTransaction.setMaxLifecycle(fragment, Lifecycle.State.RESUMED);
        } else {
   //可见性设置为true
            fragment.se tUserVisibleHint(true);
        }

  //赋值
        mCurrentPrimaryItem = fragment;
    }
}
  • 当 mBehavior 设置为 BEHAVIOR_RESUME_ONLY_CURRENT_FRAGMENT时，会通过 setMaxLifecycle 来修改当前Fragment和将要显示的Fragment的状态，使得只有正在显示的 Fragmen t执行到 onResume() 方法，其他 Fragment 只会执行到 onStart() 方法，并且当 Fragment 切换到不显示状态时触发 onPause() 方法；
  • 当 mBehavior 设置为 BEHAVIOR_SET_USER_VISIBLE_HINT 时，会当 frament 可见性发生变化时调用 setUserVisibleHint() ，也就是跟我们上面提到的第一种懒加载实现方式一样。

本文来自读者 程序员徐公Jason 投稿，原文链接：https://juejin.cn/post/6899429993231679501

「Carson每天带你学习一个Android知识点」，长按扫描关注公众号。同时，期待您精彩文章的投稿：真诚邀请您来分享

最后福利：学习资料赠送

  • 福利：由本人亲自撰写 & 整理的「Android学习方法资料」
  • 数量：10名
  • 参与方式：「点击文章右下角”在看“ -> 回复截图到公众号 即可，我将从中随机抽取」

    点击“在看”就能升职 & 加薪水哦！
good-icon 0
赞
favorite-icon 0
收藏
回复数量: 0
    暂无评论~~
    Ctrl+Enter
    Carson带你学习Android
    Carson带你学习Android
    179
    文章
    0
    获赞
    UniSMS (合一短信) NEW

    相关文章推荐

    plat-ensure-img