Androidx 下 Fragment 懒加载的新实现

2401_84544854

于 2024-04-29 08:43:53 发布

阅读量845

点赞数 15

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

本文链接：https://blog.csdn.net/2401_84544854/article/details/138300486

版权

程序员专栏收录该内容

168 篇文章 0 订阅

订阅专栏

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);

}

mCurrentPrimaryItem = fragment;

}

既然在上述条件下，只有实际可见的 Fragment 会调用 onResume 方法，那是不是为我们提供了 ViewPager 下实现懒加载的新思路呢？也就是我们可以这样实现 Fragment 的懒加载：

abstract class LazyFragment : Fragment() {

private var isLoaded = false

override fun onResume() {

super.onResume()

if (!isLoaded) {

lazyInit()

Log.d(TAG, "lazyInit:!!!”)

isLoaded = true

}

override fun onDestroyView() {

super.onDestroyView()

isLoaded = false

}

abstract fun lazyInit()

}

add+show+hide 模式下的新方案

虽然我们实现了Androidx 包下 ViewPager下的懒加载，但是我们仍然要考虑 add+show+hide 模式下的 Fragment 懒加载的情况，基于 ViewPager 在 setPrimaryItem 方法中的思路，我们可以在调用 add+show+hide 时，这样处理：

完整的代码请点击—>ShowHideExt

/**

使用add+show+hide模式加载fragment
默认显示位置[showPosition]的Fragment，最大Lifecycle为Lifecycle.State.RESUMED
其他隐藏的Fragment，最大Lifecycle为Lifecycle.State.STARTED

*@param containerViewId 容器id

*@param showPosition fragments

*@param fragmentManager FragmentManager

*@param fragments 控制显示的Fragments

private fun loadFragmentsTransaction(

@IdRes containerViewId: Int,

showPosition: Int,

fragmentManager: FragmentManager,

vararg fragments: Fragment

) {

if (fragments.isNotEmpty()) {

fragmentManager.beginTransaction().apply {

for (index in fragments.indices) {

val fragment = fragments[index]

add(containerViewId, fragment, fragment.javaClass.name)

if (showPosition == index) {

setMaxLifecycle(fragment, Lifecycle.State.RESUMED)

} else {

hide(fragment)

setMaxLifecycle(fragment, Lifecycle.State.STARTED)

}

}.commit()

} else {

throw IllegalStateException(

"fragments must not empty”

)

}

/** 显示需要显示的Fragment[showFragment]，并设置其最大Lifecycle为Lifecycle.State.RESUMED。

同时隐藏其他Fragment,并设置最大Lifecycle为Lifecycle.State.STARTED
@param fragmentManager
@param showFragment

private fun showHideFragmentTransaction(fragmentManager: FragmentManager, showFragment: Fragment) {

fragmentManager.beginTransaction().apply {

show(showFragment)

setMaxLifecycle(showFragment, Lifecycle.State.RESUMED)

//获取其中所有的fragment,其他的fragment进行隐藏

val fragments = fragmentManager.fragments

for (fragment in fragments) {

if (fragment != showFragment) {

hide(fragment)

setMaxLifecycle(fragment, Lifecycle.State.STARTED)

}

}.commit()

}

上述代码的实现也非常简单：

将需要显示的 Fragment ，在调用 add 或 show 方法后，setMaxLifecycle(showFragment, Lifecycle.State.RESUMED)
将需要隐藏的 Fragment ，在调用 hide 方法后，setMaxLifecycle(fragment, Lifecycle.State.STARTED)

结合上述操作模式，查看使用 setMaxLifecycle 后，Fragment 生命周期函数调用的情况。

add Fragment_1、Fragment_2、Fragment_3，并 hide Fragment_2,Fragment_3

show Fragment_2，hide 其他 Fragment:

show Fragment_3 hide 其他 Fragment:

参考上图，好像真的也能处理懒加载！！！！！美滋滋

并不完美的 setMaxLifecycle

当我第一次使用 setMaxLifycycle 方法时，我也和大家一样觉得万事大吉。但这套方案仍然有点点瑕疵，当 Fragment 的嵌套时，即使使用了 setMaxLifycycle 方法，第一次初始化时，同级不可见的Fragment，仍然 TMD 要调用可见生命周期方法。看下面的例子：

不知道是否是谷歌大大没有考虑到 Fragment 嵌套的情况，所以这里我们要对之前的方案就行修改，也就是如下所示：

abstract class LazyFragment : Fragment() {

private var isLoaded = false

关于面试的充分准备

一些基础知识和理论肯定是要背的，要理解的背，用自己的语言总结一下背下来。

虽然 Android 没有前几年火热了，已经过去了会四大组件就能找到高薪职位的时代了。这只能说明 Android 中级以下的岗位饱和了，现在高级工程师还是比较缺少的，我能明显感觉到国庆后多了很多高级职位，所以努力让自己成为高级工程师才是最重要的。

好了，希望对大家有所帮助。

接下来是整理的一些Android学习资料，有兴趣的朋友们可以关注下我免费领取方式。

①Android开发核心知识点笔记

②对标“阿里 P7” 40W+年薪企业资深架构师成长学习路线图

③面试精品集锦汇总

④全套体系化高级架构视频

**Android精讲视频领取学习后更加是如虎添翼！**进军BATJ大厂等（备战）！现在都说互联网寒冬，其实无非就是你上错了车，且穿的少（技能），要是你上对车，自身技术能力够强，公司换掉的代价大，怎么可能会被裁掉，都是淘汰末端的业务Curd而已！现如今市场上初级程序员泛滥，这套教程针对Android开发工程师1-6年的人员、正处于瓶颈期，想要年后突破自己涨薪的，进阶Android中高级、架构师对你更是如鱼得水！