Androidx-下-Fragment-懒加载的新实现，看完豁然开朗

媒飞王者

于 2024-03-25 07:54:59 发布

阅读量802

点赞数 24

分类专栏：程序员文章标签： androidx

本文链接：https://blog.csdn.net/weixin_58142821/article/details/137000937

版权

程序员专栏收录该内容

9 篇文章 0 订阅

订阅专栏

*/
private var isLoaded = false

/**

当前Fragment是否对用户可见
*/
private var isVisibleToUser = false

/**

当使用ViewPager+Fragment形式会调用该方法时，setUserVisibleHint会优先Fragment生命周期函数调用，
所以这个时候就,会导致在setUserVisibleHint方法执行时就执行了懒加载，
而不是在onResume方法实际调用的时候执行懒加载。所以需要这个变量
*/
private var isCallResume = false

override fun onResume() {
super.onResume()
isCallResume = true
judgeLazyInit()
}

private fun judgeLazyInit() {
if (!isLoaded && isVisibleToUser && isCallResume) {
lazyInit()
Log.d(TAG, "lazyInit:!!!”)
isLoaded = true
}
}

override fun onHiddenChanged(hidden: Boolean) {
super.onHiddenChanged(hidden)
isVisibleToUser = !hidden
judgeLazyInit()
}

//在Fragment销毁View的时候，重置状态
override fun onDestroyView() {
super.onDestroyView()
isLoaded = false
isVisibleToUser = false
isCallResume = false
}

override fun setUserVisibleHint(isVisibleToUser: Boolean) {
super.setUserVisibleHint(isVisibleToUser)
this.isVisibleToUser = isVisibleToUser
judgeLazyInit()
}

abstract fun lazyInit()
}

复杂 Fragment 嵌套的情况

当然，在实际项目中，我们可能会遇到更为复杂的 Fragment 嵌套组合。比如 Fragment+Fragment、Fragment+ViewPager、ViewPager+ViewPager….等等。
如下图所示：

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

对于以上场景，我们就需要重写我们的懒加载，以支持不同嵌套组合模式下 Fragment 正确懒加载。我们需要将 LazyFragment 修改成如下这样：

abstract class LazyFragment : Fragment() {

/**

是否执行懒加载
*/
private var isLoaded = false

/**

当前Fragment是否对用户可见
*/
private var isVisibleToUser = false

/**

当使用ViewPager+Fragment形式会调用该方法时，setUserVisibleHint会优先Fragment生命周期函数调用，
所以这个时候就,会导致在setUserVisibleHint方法执行时就执行了懒加载，
而不是在onResume方法实际调用的时候执行懒加载。所以需要这个变量
*/
private var isCallResume = false

/**

是否调用了setUserVisibleHint方法。处理show+add+hide模式下，默认可见 Fragment 不调用
onHiddenChanged 方法，进而不执行懒加载方法的问题。
*/
private var isCallUserVisibleHint = false

override fun onResume() {
super.onResume()
isCallResume = true
if (!isCallUserVisibleHint) isVisibleToUser = !isHidden
judgeLazyInit()
}

private fun judgeLazyInit() {
if (!isLoaded && isVisibleToUser && isCallResume) {
lazyInit()
Log.d(TAG, "lazyInit:!!!”)
isLoaded = true
}
}

override fun onHiddenChanged(hidden: Boolean) {
super.onHiddenChanged(hidden)
isVisibleToUser = !hidden
judgeLazyInit()
}

override fun onDestroyView() {
super.onDestroyView()
isLoaded = false
isVisibleToUser = false
isCallUserVisibleHint = false
isCallResume = false
}

override fun setUserVisibleHint(isVisibleToUser: Boolean) {
super.setUserVisibleHint(isVisibleToUser)
this.isVisibleToUser = isVisibleToUser
isCallUserVisibleHint = true
judgeLazyInit()
}

abstract fun lazyInit()
}

Androidx 下的懒加载

虽然之前的方案就能解决轻松的解决 Fragment 的懒加载，但这套方案有一个最大的弊端，就是不可见的 Fragment 执行了 onResume() 方法。onResume 方法设计的初衷，难道不是当前 Fragment 可以和用户进行交互吗？你他妈既不可见，又不能和用户进行交互，你执行 onResume 方法干嘛？

基于此问题，Google 在 Androidx 在 FragmentTransaction 中增加了 setMaxLifecycle 方法来控制 Fragment 所能调用的最大的生命周期函数。如下所示：

/**

Set a ceiling for the state of an active fragment in this FragmentManager. If fragment is
already above the received state, it will be forced down to the correct state.
The fragment provided must currently be added to the FragmentManager to have it’s
Lifecycle state capped, or previously added as part of this transaction. The
{@link Lifecycle.State} passed in must at least be {@link Lifecycle.State#CREATED}, otherwise
an {@link IllegalArgumentException} will be thrown.
@param fragment the fragment to have it’s state capped.
@param state the ceiling state for the fragment.
@return the same FragmentTransaction instance
*/
@NonNull
public FragmentTransaction setMaxLifecycle(@NonNull Fragment fragment,
@NonNull Lifecycle.State state) {
addOp(new Op(OP_SET_MAX_LIFECYCLE, fragment, state));
return this;
}

根据官方的注释，我们能知道，该方法可以设置活跃状态下 Fragment 最大的状态，如果该 Fragment 超过了设置的最大状态，那么会强制将 Fragment 降级到正确的状态。

那如何使用该方法呢？我们先看该方法在 Androidx 模式下 ViewPager+Fragment 模式下的使用例子。

ViewPager+Fragment 模式下的方案

在 FragmentPagerAdapter 与 FragmentStatePagerAdapter 新增了含有 behavior 字段的构造函数，如下所示：

public FragmentPagerAdapter(@NonNull FragmentManager fm,
@Behavior int behavior) {
mFragmentManager = fm;
mBehavior = behavior;
}

public FragmentStatePagerAdapter(@NonNull FragmentManager fm,
@Behavior int behavior) {
mFragmentManager = fm;
mBehavior = behavior;
}

其中 Behavior 的声明如下：

@Retention(RetentionPolicy.SOURCE)
@IntDef({BEHAVIOR_SET_USER_VISIBLE_HINT, BEHAVIOR_RESUME_ONLY_CURRENT_FRAGMENT})
private @interface Behavior { }

/**

Indicates that {@link Fragment#setUserVisibleHint(boolean)} will be called when the current
fragment changes.
@deprecated This behavior relies on the deprecated
{@link Fragment#setUserVisibleHint(boolean)} API. Use
{@link #BEHAVIOR_RESUME_ONLY_CURRENT_FRAGMENT} to switch to its replacement,
{@link FragmentTransaction#setMaxLifecycle}.
@see #FragmentPagerAdapter(FragmentManager, int)
*/
@Deprecated
public static final int BEHAVIOR_SET_USER_VISIBLE_HINT = 0;

/**

Indicates that only the current fragment will be in the {@link Lifecycle.State#RESUMED}
state. All other Fragments are capped at {@link Lifecycle.State#STARTED}.
@see #FragmentPagerAdapter(FragmentManager, int)
*/
public static final int BEHAVIOR_RESUME_ONLY_CURRENT_FRAGMENT = 1;

从官方的注释声明中，我们能得到如下两条结论：

如果 behavior 的值为 BEHAVIOR_SET_USER_VISIBLE_HINT，那么当 Fragment 对用户的可见状态发生改变时，setUserVisibleHint 方法会被调用。
如果 behavior 的值为 BEHAVIOR_RESUME_ONLY_CURRENT_FRAGMENT ，那么当前选中的 Fragment 在 Lifecycle.State#RESUMED 状态，其他不可见的 Fragment 会被限制在 Lifecycle.State#STARTED 状态。

那 BEHAVIOR_RESUME_ONLY_CURRENT_FRAGMENT 这个值到底有什么作用呢？我们看下面的例子：

在该例子中设置了 ViewPager 的适配器为 FragmentPagerAdapter 且 behavior 值为 BEHAVIOR_RESUME_ONLY_CURRENT_FRAGMENT。

默认初始化ViewPager，Fragment 生命周期如下所示：

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

切换到 Fragment_2 时，日志情况如下所示：

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

切换到 Fragment_3 时，日志情况如下所示:

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

因为篇幅的原因，本文没有在讲解 FragmentStatePagerAdapter 设置 behavior 下的使用情况，但是原理以及生命周期函数调用情况一样，感兴趣的小伙伴，可以根据 AndroidxLazyLoad 项目自行测试。

观察上述例子，我们可以发现，使用了 BEHAVIOR_RESUME_ONLY_CURRENT_FRAGMENT 后，确实只有当前可见的 Fragment 调用了 onResume 方法。而导致产生这种改变的原因，是因为 FragmentPagerAdapter 在其 setPrimaryItem 方法中调用了 setMaxLifecycle 方法，如下所示：

public void setPrimaryItem(@NonNull ViewGroup container, int position, @NonNull Object object) {
Fragment fragment = (Fragment)object;
//如果当前的fragment不是当前选中并可见的Fragment,那么就会调用
// setMaxLifecycle 设置其最大生命周期为 Lifecycle.State.STARTED
if (fragment != mCurrentPrimaryItem) {
if (mCurrentPrimaryItem != null) {
mCurrentPrimaryItem.setMenuVisibility(false);
if (mBehavior == BEHAVIOR_RESUME_ONLY_CURRENT_FRAGMENT) {
if (mCurTransaction == null) {
mCurTransaction = mFragmentManager.beginTransaction();
}
mCurTransaction.setMaxLifecycle(mCurrentPrimaryItem, Lifecycle.State.STARTED);
} else {
mCurrentPrimaryItem.setUserVisibleHint(false);
}
}
//对于其他非可见的Fragment,则设置其最大生命周期为
//Lifecycle.State.RESUMED
fragment.setMenuVisibility(true);
if (mBehavior == BEHAVIOR_RESUME_ONLY_CURRENT_FRAGMENT) {
if (mCurTransaction == null) {
mCurTransaction = mFragmentManager.beginTransaction();
}
mCurTransaction.setMaxLifecycle(fragment, Lifecycle.State.RESUMED);
} else {
fragment.setUserVisibleHint(true);
}