4.Lifecycle

JetPack
Word count: 4.4k   |   Reading time≈ 19 min

生命周期组件详解&原理分析

Jetpack中第一个极为重要的组件

观察者设计模式完成的

Lifecycle源码原理解析

1.Lifecycle是什么?

监听Activity、Fragment的生命周期行为的各种变化

  • Lifecycle可以有效的避免内存泄漏和解决android生命周期的常见难题
  • Livecycle 是一个表示android生命周期及状态的对象
  • LivecycleOwner 用于连接有生命周期的对象，如activity,fragment
  • LivecycleObserver 用于观察查LifecycleOwner
  • Lifecycle框架使用观察者模式实现观察者监听被观察者的生命周期的变化

2.各种Lifecycle各种系列使用篇

LifecycleObserver

DefaultLifecycleObserver（对LifecycleObserver的二次封装，更加好用，可以拿到Activity、Fragment的所有环境）

关联注册：

1
lifecycle.addObserver(MyObserver())

3.Lifecycle的源码原理解析

事件驱动状态变化.png

1
ReportFragment.injectIfNeededIn(this);

生成一个ReportFragment（空白Fragment，无UI）黏贴到用户Activity界面上，观察用户Activity的生命周期变化，跟随其一起变化。
当用户Activity进入某一个生命周期，在ReportFragment中的对应方法中就会触发对应事件的分发。

ReportFragment中生命周期函数都调用了：dispatch(Lifecycle.Event.ON_RESUME);方法，分发事件

Lifecycle 抽象类

  • 这个类定义了一个生命周期状态的枚举（如 STARTED, RESUMED, DESTROYED 等），并且提供了状态的管理和观察机制。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    //事件
    public enum class Event {
            ON_CREATE,
            ON_START,
            ON_RESUME,
            ON_PAUSE,
            ON_STOP,
            ON_DESTROY,
            ON_ANY;
    }

    //状态由事件驱动（）
    public enum class State{
        DESTROYED,//销毁状态
        INITIALIZED,//初始化状态
        CREATED,//创建状态
        STARTED,//启动状态
        RESUMED;//界面显示状态
    }

    //------------事件对应的状态-------------------
    public val targetState: State
        get() {
            when (this) {
                ON_CREATE, ON_STOP -> return State.CREATED
                ON_START, ON_PAUSE -> return State.STARTED
                ON_RESUME -> return State.RESUMED
                ON_DESTROY -> return State.DESTROYED
                ON_ANY -> {}
            }
            throw IllegalArgumentException("$this has no target state")
        }

LifecycleOwner 接口（AppCompatActivity顶层接口）

  • LifecycleOwner 是所有具有生命周期的组件的接口（如 Activity 和 Fragment）。任何实现这个接口的类都需要提供一个 getLifecycle() 方法，返回相应的 Lifecycle 实例。

LifecycleObserver 接口

  • LifecycleObserver接口用于定义响应生命周期事件的回调方法。它通过使用 @OnLifecycleEvent 注解来指示哪个方法应该在特定的生命周期状态下调用。

LifecycleRegistry 类（实现了Lifecycle抽象类）

  • 这个类是 Lifecycle 的具体实现，用于跟踪和管理组件的状态变化。它提供了 handleLifecycleEvent() 方法，通过这个方法，可以更新当前的生命周期状态。

  • **handleLifecycleEvent()**平移状态

    1
    2
    3
    4
    open fun handleLifecycleEvent(event: Event) {
        enforceMainThreadIfNeeded("handleLifecycleEvent")
        moveToState(event.targetState)
    }

    枚举比大小，确定前进还是后退

  • moveToState()

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    private fun moveToState(next: State) {
        if (state == next) { //对齐
            return
        }
        //不对齐
        check(!(state == State.INITIALIZED && next == State.DESTROYED)) {
            "no event down from $state in component ${lifecycleOwner.get()}"
        }
        state = next
        if (handlingEvent || addingObserverCounter != 0) {
            newEventOccurred = true
            // we will figure out what to do on upper level.
            return
        }
        handlingEvent = true
        sync()//同步对齐方法
        handlingEvent = false
        if (state == State.DESTROYED) {
            observerMap = FastSafeIterableMap()
        }
    }

  • **sync()**对齐方法——比枚举大小

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    private fun sync() {
        val lifecycleOwner = lifecycleOwner.get()
            ?: throw IllegalStateException(
                "LifecycleOwner of this LifecycleRegistry is already " +
                    "garbage collected. It is too late to change lifecycle state."
            )
        while (!isSynced) {
            newEventOccurred = false
            if (state < observerMap.eldest()!!.value.state) {
                backwardPass(lifecycleOwner) // 后退
            }
            val newest = observerMap.newest()
            if (!newEventOccurred && newest != null && state > newest.value.state) {
                forwardPass(lifecycleOwner) // 前进
            }
        }
        newEventOccurred = false
    }

流程示例

  1. 状态变化：
    当一个 Activity 从 CREATED 转变为 STARTED 时，Activity 的 onStart() 方法被调用，LifecycleRegistry 会更新生命周期状态为 STARTED。
  2. 通知观察者：
    此时，所有注册的观察者都会接收到状态变化的通知。如果观察者有一个被标注为 @OnLifecycleEvent(Lifecycle.Event.ON_START) 的方法，它会被调用。
  3. 可扩展性：
    开发者可以创建自定义的 LifecycleObserver，并在应用的不同部分监控生命周期事件，从而能够实现更清晰、更解耦的代码结构。

自己看源码

1.从使用处入手——getLifecycle()最终返回一个LifecycleRegistry

1
2
MyObserver observer = new MyObserver();
getLifecycle().addObserver(observer);

从 getLifecycle() 进入，该方法在ComponentActivity类中

ComponentActivity类实现了LifecycleOwner接口

LifecycleOwner 接口——该接口的作用是标记类有Android的生命周期的,比如Activity和Fragment

该接口有 getLifecycle() 方法

1
2
3
4
public interface LifecycleOwner {
    @NonNull
    Lifecycle getLifecycle();
}
1
2
3
4
5
public class ComponentActivity extends Activity implements
        LifecycleOwner,
        KeyEventDispatcher.Component {
            
        }

发现 getLifecycle() 方法最终返回的是LifecycleRegistry类，其是Lifecycle抽象类的子类，该抽象类有仨抽象方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
public abstract class Lifecycle {
    @MainThread
    public abstract void addObserver(@NonNull LifecycleObserver observer);
    
    @MainThread
    public abstract void removeObserver(@NonNull LifecycleObserver observer);
    
    @MainThread
    @NonNull
    public abstract State getCurrentState();
    
    
    //两个枚举类
    public enum Event{
        
    }
    
    public enum State{
        
    }
}

待会儿再解释LifecycleRegister类

2.从顶层onCreate()中找到ReportFragment.injectIfNeededIn(this)

看在ComponentActivity类中的onCreate()方法

1
2
3
4
5
6
@SuppressLint("RestrictedApi")
@Override
protected void onCreate(@Nullable Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    ReportFragment.injectIfNeededIn(this);
}

调用了ReportFragment类中的静态方法 injectIfNeededIn(activity)
在Activity中注入了一个ReportFragment，这个Fragment是没有界面的

1
2
3
4
5
6
7
8
9
10
11
12
public static void injectIfNeededIn(Activity activity) {
    if (Build.VERSION.SDK_INT >= 29) {
        LifecycleCallbacks.registerIn(activity);
    }

    android.app.FragmentManager manager = activity.getFragmentManager();
    if (manager.findFragmentByTag(REPORT_FRAGMENT_TAG) == null) {
        manager.beginTransaction().add(new ReportFragment(), REPORT_FRAGMENT_TAG).commit();
        // Hopefully, we are the first to make a transaction.
        manager.executePendingTransactions();
    }
}

其实这个injectIfNeededIn()看起来像是注入的方法干的就是将Fragment添加到Activity中

来看看这个ReportFragment的生命周期方法都干了些啥,

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
//ReportFragment
@Override
public void onActivityCreated(Bundle savedInstanceState) {
    super.onActivityCreated(savedInstanceState);
    dispatchCreate(mProcessListener);
    dispatch(Lifecycle.Event.ON_CREATE);
}

@Override
public void onStart() {
    super.onStart();
    dispatchStart(mProcessListener);
    dispatch(Lifecycle.Event.ON_START);
}

@Override
public void onResume() {
    super.onResume();
    dispatchResume(mProcessListener);
    dispatch(Lifecycle.Event.ON_RESUME);
}
//-----------------------------------------------------
@Override
public void onPause() {
    super.onPause();
    dispatch(Lifecycle.Event.ON_PAUSE);
}

@Override
public void onStop() {
    super.onStop();
    dispatch(Lifecycle.Event.ON_STOP);
}

@Override
public void onDestroy() {
    super.onDestroy();
    dispatch(Lifecycle.Event.ON_DESTROY);
    // just want to be sure that we won't leak reference to an activity
    mProcessListener = null;
}

调用两个方法：
dispatchCreate(mProcessListener); //分发当前的生命周期
dispatch(Lifecycle.Event.ON_CREATE); //分发事件

跟随mProcessListener这个变量，找它是在哪里设置的

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
//ReportFragment中
public fun setProcessListener(processListener: ActivityInitializationListener?) {
    this.processListener = processListener
}


//ProcessLifecycleOwner中设置 该类为整个应用程序过程提供生命周期。------------------------
class ProcessLifecycleOwner private constructor() : LifecycleOwner{
    
    //实现了ReportFragment.ActivityInitializationListener接口
    private val initializationListener: ReportFragment.ActivityInitializationListener =
        object : ReportFragment.ActivityInitializationListener {
            override fun onCreate() {}

            override fun onStart() {
                activityStarted()
            }

            override fun onResume() {
                activityResumed()
            }
        }

    //单例
    companion object {
        @VisibleForTesting
        internal const val TIMEOUT_MS: Long = 700 // mls
        private val newInstance = ProcessLifecycleOwner()

        /**
         * The LifecycleOwner for the whole application process. Note that if your application
         * has multiple processes, this provider does not know about other processes.
         *
         * @return [LifecycleOwner] for the whole application.
         */
        @JvmStatic
        fun get(): LifecycleOwner {
            return newInstance
        }

        @JvmStatic
        internal fun init(context: Context) {
            newInstance.attach(context)
        }
    }
    
	
    //attach()方法
    internal fun attach(context: Context) {
        handler = Handler()
        registry.handleLifecycleEvent(Lifecycle.Event.ON_CREATE)
        val app = context.applicationContext as Application
        
        //registerActivityLifecycleCallbacks()注册了一个监听器,
        //一旦有Activity创建就给它设置一个Listener.
        //这样就保证了每个ReportFragment都有Listener.
        app.registerActivityLifecycleCallbacks(object : EmptyActivityLifecycleCallbacks() {
            @RequiresApi(29)
            override fun onActivityPreCreated(
                activity: Activity,
                savedInstanceState: Bundle?
            ) {
                // We need the ProcessLifecycleOwner to get ON_START and ON_RESUME precisely
                // before the first activity gets its LifecycleOwner started/resumed.
                // The activity's LifecycleOwner gets started/resumed via an activity registered
                // callback added in onCreate(). By adding our own activity registered callback in
                // onActivityPreCreated(), we get our callbacks first while still having the
                // right relative order compared to the Activity's onStart()/onResume() callbacks.
                Api29Impl.registerActivityLifecycleCallbacks(activity,
                    object : EmptyActivityLifecycleCallbacks() {
                        override fun onActivityPostStarted(activity: Activity) {
                            activityStarted()
                        }

                        override fun onActivityPostResumed(activity: Activity) {
                            activityResumed()
                        }
                    })
            }

            override fun onActivityCreated(activity: Activity, savedInstanceState: Bundle?) {
                // Only use ReportFragment pre API 29 - after that, we can use the
                // onActivityPostStarted and onActivityPostResumed callbacks registered in
                // onActivityPreCreated()
                if (Build.VERSION.SDK_INT < 29) {
                    //配置
                    activity.reportFragment.setProcessListener(initializationListener)
                }
            }

            override fun onActivityPaused(activity: Activity) {
                activityPaused()
            }

            override fun onActivityStopped(activity: Activity) {
                activityStopped()
            }
        })
    }
}

3.ProcessLifecycleInitializer初始化LifecycleDispatcher、ProcessLifecycleOwner

ProcessLifecycleOwner类

既然是一个全局的单例,并且可以监听整个应用程序的生命周期,那么,肯定一开始就需要初始化.

既然没有让我们在Application里面初始化,那么肯定就是在ContentProvider里面初始化的.

ProcessLifecycleInitializer类初始化 ProcessLifecycleOwner

在onCreate()方法中调用ProcessLifecycleOwner.init(context)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
override fun create(context: Context): LifecycleOwner {
    val appInitializer = AppInitializer.getInstance(context)
    check(appInitializer.isEagerlyInitialized(javaClass)) {
        """ProcessLifecycleInitializer cannot be initialized lazily.
           Please ensure that you have:
           <meta-data
               android:name='androidx.lifecycle.ProcessLifecycleInitializer'
               android:value='androidx.startup' />
           under InitializationProvider in your AndroidManifest.xml"""
    }
    
    //---------------俩初始化--------------------
    LifecycleDispatcher.init(context)
    ProcessLifecycleOwner.init(context)
    
    return ProcessLifecycleOwner.get()
}

LifecycleDispatcher

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
internal object LifecycleDispatcher {
    private val initialized = AtomicBoolean(false)

    @JvmStatic
    fun init(context: Context) {
        if (initialized.getAndSet(true)) {
            return
        }
        //注册监听器
        (context.applicationContext as Application)
            .registerActivityLifecycleCallbacks(DispatcherActivityCallback())
    }

    @VisibleForTesting
    internal class DispatcherActivityCallback : EmptyActivityLifecycleCallbacks() {
        override fun onActivityCreated(activity: Activity, savedInstanceState: Bundle?) {
            //又来注入ReportFragment----------------------------------*******
            ReportFragment.injectIfNeededIn(activity)
        }
    }
}

初始化的时候,就注册了一个监听器,每个创建的时候都给它注入一个ReportFragment.咦?这里又来注入一次,不是每个Activity都注册了一次么,在ComponentActivity中,搞啥玩意儿?

我猜,,可能是为了兼容吧.2次注入,确保万无一失.而且这个injectIfNeededIn()方法,内部实现是只会成功注入一次的,所以多调用一次,无所谓.

4. 分发事件 ReportFragment

相当于,到了这里,应用程序里面的任何一个Activity都会被注入一个ReportFragment.而注入的这个无界面的ReportFragment是可以观察到当然Activity的生命周期的.

下面我们来仔细看一下,这个事件是如何一步步分发下去的.

ReportFragment类中的dispatch()方法都调用了
LifecycleRegistry中的handleLifecycleEvent()

1
2
3
4
5
6
7
8
9
10
11
12
internal fun dispatch(activity: Activity, event: Lifecycle.Event) {
    if (activity is LifecycleRegistryOwner) {
        activity.lifecycle.handleLifecycleEvent(event)
        return
    }
    if (activity is LifecycleOwner) {
        val lifecycle = (activity as LifecycleOwner).lifecycle
        if (lifecycle is LifecycleRegistry) {
            lifecycle.handleLifecycleEvent(event)
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
//LifecycleRegistry
public actual open fun handleLifecycleEvent(event: Event) {
    enforceMainThreadIfNeeded("handleLifecycleEvent")
    moveToState(event.targetState)
}

private fun moveToState(next: State) {
    if (state == next) {
        return
    }
    check(!(state == State.INITIALIZED && next == State.DESTROYED)) {
        "State must be at least CREATED to move to $next, but was $state in component " +
            "${lifecycleOwner.get()}"
    }
    state = next
    if (handlingEvent || addingObserverCounter != 0) {
        newEventOccurred = true
        // we will figure out what to do on upper level.
        return
    }
    handlingEvent = true
    sync()
    handlingEvent = false
    if (state == State.DESTROYED) {
        observerMap = FastSafeIterableMap()
    }
}



 private fun sync() {
    val lifecycleOwner = lifecycleOwner.get()
        ?: throw IllegalStateException(
            "LifecycleOwner of this LifecycleRegistry is already " +
                "garbage collected. It is too late to change lifecycle state."
        )
    while (!isSynced) {
        newEventOccurred = false
        if (state < observerMap.eldest()!!.value.state) {
            backwardPass(lifecycleOwner)
        }
        val newest = observerMap.newest()
        if (!newEventOccurred && newest != null && state > newest.value.state) {
            forwardPass(lifecycleOwner)
        }
    }
    newEventOccurred = false
    _currentStateFlow.value = currentState
}

面试

Lifecycle的使用与实现原理

在Android中，Activity和Fragment的生命周期（Lifecycle）是非常重要的概念，它管理着组件的创建、运行、暂停、停止和销毁的状态。理解生命周期对于正确实现组件的行为和避免内存泄漏至关重要。

Lifecycle的使用

  1. LifecycleOwner: 在Activity或Fragment中，你可以实现LifecycleOwner接口，它提供了获取当前生命周期状态的方法。getLifecycle()方法返回Lifecycle对象。

  2. LifecycleObserver: 通过实现LifecycleObserver接口，你可以创建一个观察者，使用注解来监听某个生命周期状态。例如，使用@OnLifecycleEvent注解，可以定义当生命周期进入某个状态时调用的方法。

  3. LifecycleEvent: 生命周期的主要状态包括：

    • ON_CREATE: Activity或Fragment被创建
    • ON_START: Activity或Fragment变得可见
    • ON_RESUME: Activity或Fragment处于前台并与用户交互
    • ON_PAUSE: Activity或Fragment失去焦点，但仍然可见
    • ON_STOP: Activity或Fragment完全不可见
    • ON_DESTROY: Activity或Fragment被销毁

实现原理

  1. 状态管理: Android通过状态机来管理Activity和Fragment的生命周期，每个组件都有一个状态（如创建、运行、停止）。当用户与应用交互时，系统会改变这些状态并调用相应的生命周期回调方法。

  2. LifecycleRegistry: 实现部分是通过LifecycleRegistry类，该类维护了一个Lifecycle状态和相应的Observer列表。当状态发生变化时，它会通知所有注册的Observer。

  3. Lifecycle状态的转移: 当Activity或Fragment的状态发生变化时，系统会调用LifecycleRegistry的handleLifecycleEvent()方法，并根据新的状态更新所有观察者。这个机制能够确保每个生命周期方法都在正确的时机被调用，从而支持组件的解耦。

注意事项

  • 内存管理: 使用Lifecycle可以帮助管理内存，避免因未注销的观察者导致内存泄漏。
  • AndroidX Lifecycle库: 在现代Android开发中，推荐使用AndroidX的Lifecycle库，它提供了更加简单和强大的API来处理组件的生命周期。

6.10 什么是Lifecycle？请分析其内部原理和使用场景？（享学）

Jetpack的Lifecycle库：它可以有效的避免内存泄漏，解决 Android 生命周期的常见难题。

内部原理：ComponentActivity 的 onCreate 方法中注入了 ReportFragment，通过 Fragment 来实现生命周期监听。 使用场景：给 RecyclerView 的 ViewHolder 添加 Lifecycle 的能 力。自己实现 LifecycleHandler，在 Activity销毁的时候，自动 移除 Handler的消息避免 Handler导致的内存泄漏。

在安卓开发中，Jetpack 的 Lifecycle 组件是面试中的常见话题。以下是一些常见的面试题及其简要回答：

1. 什么是 Lifecycle 组件？它的作用是什么？

  • 回答: Lifecycle 组件是 Android Jetpack 的一部分，用于管理 Activity 和 Fragment 的生命周期。它允许开发者编写与生命周期相关的代码，避免内存泄漏和资源浪费。通过 LifecycleObserver，开发者可以在生命周期状态变化时执行特定操作。

2. Lifecycle 组件的主要类有哪些？

  • 回答: 主要类包括：
    • Lifecycle: 生命周期事件的抽象类。
    • LifecycleOwner: 拥有生命周期的组件（如 Activity 和 Fragment）。
    • LifecycleObserver: 观察生命周期事件的接口。
    • LifecycleRegistry: 管理生命周期状态和事件的实际实现。

3. 如何使用 LifecycleObserver 监听生命周期事件？

  • 回答: 通过实现 LifecycleObserver 接口，并使用 @OnLifecycleEvent 注解来监听特定生命周期事件。例如：
    1
    2
    3
    4
    5
    6
    public class MyObserver implements LifecycleObserver {
        @OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
        public void onResume() {
            // 处理 ON_RESUME 事件
        }
    }

4. Lifecycle 组件如何避免内存泄漏？

  • 回答: Lifecycle 组件通过自动管理观察者的生命周期，确保在组件销毁时移除观察者，从而避免内存泄漏。开发者无需手动处理生命周期回调，减少了出错的可能性。

5. Lifecycle 组件与 ViewModel 的关系是什么？

  • 回答: ViewModel 与 Lifecycle 组件紧密相关。ViewModel 通过 ViewModelProvider 与 LifecycleOwner 绑定，确保在配置更改（如屏幕旋转）时保留数据，并在适当的生命周期事件中清理资源。

6. 如何在非 Activity/Fragment 类中使用 Lifecycle 组件？

  • 回答: 可以通过实现 LifecycleOwner 接口，并在类中维护 LifecycleRegistry 来管理生命周期。例如：
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    public class MyLifecycleOwner implements LifecycleOwner {
        private LifecycleRegistry lifecycleRegistry;

        public MyLifecycleOwner() {
            lifecycleRegistry = new LifecycleRegistry(this);
        }

        @Override
        public Lifecycle getLifecycle() {
            return lifecycleRegistry;
        }
    }

7. Lifecycle 组件如何处理后台任务？

  • 回答: 可以使用 LifecycleService 或 ProcessLifecycleOwner 来管理后台任务的生命周期。LifecycleService 用于 Service，而 ProcessLifecycleOwner 用于整个应用进程的生命周期管理。

8. Lifecycle 组件中的 Lifecycle.State 和 Lifecycle.Event 有什么区别？

  • 回答:
    • Lifecycle.State: 表示当前的生命周期状态，如 CREATED、STARTED、RESUMED 等。
    • Lifecycle.Event: 表示生命周期事件，如 ON_CREATE、ON_START、ON_RESUME 等。事件会触发状态的改变。

9. 如何在 Kotlin 中使用 Lifecycle 组件？

  • 回答: 在 Kotlin 中，可以使用 lifecycle 扩展函数来简化生命周期观察。例如：
    1
    2
    3
    4
    5
    6
    lifecycle.addObserver(object : LifecycleObserver {
        @OnLifecycleEvent(Lifecycle.Event.ON_START)
        fun onStart() {
            // 处理 ON_START 事件
        }
    })

10. Lifecycle 组件如何与 LiveData 配合使用？

  • 回答: LiveData 是一个生命周期感知的数据持有者，它会自动在 LifecycleOwner 处于活跃状态时更新 UI。通过 observe 方法，LiveData 可以自动管理观察者的生命周期，避免内存泄漏。

11. Lifecycle 组件如何处理配置更改？

  • 回答: Lifecycle 组件通过 ViewModel 和 LiveData 来处理配置更改。ViewModel 在配置更改时不会被销毁，LiveData 会在 LifecycleOwner 重新创建后自动更新 UI。

12. Lifecycle 组件中的 LifecycleRegistry 是什么？

  • 回答: LifecycleRegistry 是 Lifecycle 的实现类，用于管理生命周期状态和事件。它通常在自定义 LifecycleOwner 中使用，用于手动管理生命周期状态。

13. Lifecycle 组件如何与协程结合使用？

  • 回答: 可以使用 lifecycleScope 或 viewModelScope 来启动协程，这些协程会自动与 LifecycleOwner 或 ViewModel 的生命周期绑定，确保在组件销毁时取消协程。

14. Lifecycle 组件如何处理 Fragment 的生命周期？

  • 回答: Fragment 本身就是一个 LifecycleOwner，因此可以直接使用 Lifecycle 组件来管理其生命周期。可以通过 fragment.lifecycle 来访问 Fragment 的生命周期对象。

15. Lifecycle 组件中的 ProcessLifecycleOwner 是什么？

  • 回答: ProcessLifecycleOwner 用于监听整个应用进程的生命周期。它可以用来检测应用何时进入前台或后台，适用于需要全局生命周期管理的场景。

16. Lifecycle 组件如何与 WorkManager 结合使用？

  • 回答: WorkManager 是一个后台任务调度库，它可以与 Lifecycle 组件结合使用，确保任务在适当的生命周期状态下执行。例如，可以在应用进入后台时调度任务。

17. Lifecycle 组件如何处理多 Activity 或 Fragment 的场景？

  • 回答: 每个 Activity 和 Fragment 都有自己的 LifecycleOwner，因此可以分别为它们注册不同的 LifecycleObserver。通过 ViewModel 和 LiveData，可以在多个 Activity 或 Fragment 之间共享数据。

18. Lifecycle 组件中的 LifecycleService 是什么？

  • 回答: LifecycleService 是一个具有生命周期的 Service，它允许开发者使用 Lifecycle 组件来管理 Service 的生命周期。适用于需要在 Service 中处理生命周期事件的场景。

19. Lifecycle 组件如何处理异步任务的生命周期？

  • 回答: 可以使用 LiveData 或 Coroutine 来处理异步任务的生命周期。LiveData 会自动在 LifecycleOwner 处于活跃状态时更新 UI，而 Coroutine 可以通过 lifecycleScope 或 viewModelScope 自动管理生命周期。

20. Lifecycle 组件如何与 Navigation 组件结合使用？

  • 回答: Navigation 组件用于管理 Fragment 的导航，它与 Lifecycle 组件紧密集成。通过 NavController 和 LifecycleOwner，可以在导航过程中自动管理 Fragment 的生命周期。

这些面试题涵盖了 Lifecycle 组件的核心概念和使用场景，帮助开发者更好地理解和应用 Jetpack 中的 Lifecycle 组件。

Donate
  • Copyright： Copyright is owned by the author. For commercial reprints, please contact the author for authorization. For non-commercial reprints, please indicate the source.

扫一扫，分享到微信

微信分享二维码
  • Copyrights © 2023-2025 Annie
  • Visitors: | Views:

嘿嘿 请我吃小蛋糕吧~

支付宝
微信