花生_TL007

这个屌丝很懒，什么也没留下！

热门标签

【Android-Jetpack进阶】1、JetPack 库是什么、用 LifeCycle 库管理 Activity、Fragment、Service 和 Application 的生命周期_jetpack库

作者：花生_TL007 | 2024-03-17 04:02:45

踩

jetpack库

文章目录

一、Jetpack 库是什么
二、LifeCycle 库

一、Jetpack 库是什么

Jetpack 是一个由多个库组成的套件，可帮助开发者遵循最佳做法、减少样板代码并编写可在各种 Android 版本和设备中一致运行的代码，让开发者可将精力集中于真正重要的编码工作。

Jetpack 的构成，如下图所示：
在这里插入图片描述

Jetpact 库由如下4个方面构成：

Arch（架构组件）：
- Data Bingding（数据绑定）
- Room（数据库）
- WorkManager（后台任务管家）
- Lifecycle（生命周期）
- Navigation（导航）
- Paging（分页）
- Data Binding（数据绑定）
- LiveData（底层数据通知更改视图）
- ViewModel（以注重生命周期的方式管理界面的相关数据）
Foundation（基础）
- AppCompat（向后兼容）
- Android KTX（编写更加简洁的 Kotlin 代码）
- Multidex （dex的多处理）
- Test（测试）
Behavior（行为）
- Download manager（下载管理器）
- Media & playback（媒体和播放）
- Notifications（通知）
- Permissions（权限）
- Preferences（偏好设置）
- Sharing（共享）
- Slices （切片）
UI (视觉交互)
- Animation & transitions（动画和过渡）
- Auto（Auto组件）
- Emoji（标签）
- Fragment（Fragment 布局）
- Layout（布局）
- Palette（调色板）
- TV（TV）
- Wear OS by Google（穿戴设备）

Jetpack 库的 import 路径都是 androidx.xxx，例如下例的appcompact、recyclerview等库：

dependencies {
    debugImplementation 'com.guolindev.glance:glance:1.1.0'
    implementation 'androidx.core:core-ktx:1.7.0'
    implementation 'androidx.appcompat:appcompat:1.4.2'
    implementation 'com.google.android.material:material:1.6.1'
    implementation 'androidx.constraintlayout:constraintlayout:2.1.4'
    implementation 'androidx.lifecycle:lifecycle-extensions:2.2.0'
    implementation 'androidx.recyclerview:recyclerview:1.2.1'
    implementation 'androidx.room:room-runtime:2.4.3'
    kapt 'androidx.room:room-compiler:2.4.3'
    testImplementation 'junit:junit:4.13.2'
    androidTestImplementation 'androidx.test.ext:junit:1.1.3'
    androidTestImplementation 'androidx.test.espresso:espresso-core:3.4.0'
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

用 Android Studio 新建项目时，默认就会使用 Jetpack 库。可以在项目的 gradle.properties 文件中确认包含了 android.useAndroidX=true 的话，则说明已启用此功能。

二、LifeCycle 库

对于 Activity、Fragment、Service、Application 等组件，我们希望其自己实现自己的 onCreate()、onDestroy() 回调函数，然后在其生命周期的不同阶段，这些回调函数被 Android 系统调用。LifeCycle 库通过这种回调的方式，更好的管理生命周期。

例如，如果我们希望 App 启动后，自动通过蓝牙配对耳机，不使用 LifeCycle 库的话就会和 Activity 或 Fragment 的声明周期耦合，如下代码就是未使用 LifeCycle 库的例子，本节就会对此代码做改造：

package com.bignerdranch.android.jetpacktest

import android.os.Bundle
import androidx.appcompat.app.AppCompatActivity
import android.util.Log

class MainActivity : AppCompatActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
        Log.d("Init BlueTooth")
    }

    override fun onResume() {
        super.onResume()
        Log.d("Start BlueTooth")
    }

    override fun onPause() {
        super.onPause()
        Log.d("Stop BlueTooth")
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

2.1 用 LifeCycle 监听 Acrtivity 和 Fragment 的生命周期

2.1.1 ComponentActivity 类、LifecycleOwner 和 LifeCycleObserve 源码分析

首先，androidx 的 lifecycle 库的源码如下：

package androidx.lifecycle;

import androidx.annotation.NonNull;

/**
 * A class that has an Android lifecycle. These events can be used by custom components to
 * handle lifecycle changes without implementing any code inside the Activity or the Fragment.
 *
 * @see Lifecycle
 * @see ViewTreeLifecycleOwner
 */
@SuppressWarnings({"WeakerAccess", "unused"})
public interface LifecycleOwner {
    /**
     * Returns the Lifecycle of the provider.
     *
     * @return The lifecycle of the provider.
     */
    @NonNull
    Lifecycle getLifecycle();
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

其次，很多类都实现了 getLifecycle() 方法，其中就包括 ComponentActivity 类，如下图所示：

在这里插入图片描述

接下来，我们看 ComponentActivity 的源码，可知 ComponentActivity 实现了 LifecyeleOwner 接口（实现了该接口的 getLifecycle() 函数），其源码如下：

public class ComponentActivity extends androidx.core.app.ComponentActivity implements
        ContextAware,
        LifecycleOwner,
        ViewModelStoreOwner,
        HasDefaultViewModelProviderFactory,
        SavedStateRegistryOwner,
        OnBackPressedDispatcherOwner,
        ActivityResultRegistryOwner,
        ActivityResultCaller {
    private final LifecycleRegistry mLifecycleRegistry = new LifecycleRegistry(this);
    public Lifecycle getLifecycle() {
        return mLifecycleRegistry;
    }
    protected void onSaveInstanceState(@NonNull Bundle outState) {
        Lifecycle lifecycle = getLifecycle();
        if (lifecycle instanceof LifecycleRegistry) {
            ((LifecycleRegistry) lifecycle).setCurrentState(Lifecycle.State.CREATED);
        }
        super.onSaveInstanceState(outState);
        mSavedStateRegistryController.performSave(outState);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

而 LifecycleObserver 是一个空 interface，其源码如下：

package androidx.lifecycle;

/**
 * Marks a class as a LifecycleObserver. Don't use this interface directly. Instead implement either
 * {@link DefaultLifecycleObserver} or {@link LifecycleEventObserver} to be notified about
 * lifecycle events.
 *
 * @see Lifecycle Lifecycle - for samples and usage patterns.
 */
@SuppressWarnings("WeakerAccess")
public interface LifecycleObserver {

}
1
2
3
4
5
6
7
8
9
10
11
12
13

所以，ComponentActivity 类，同时实现了 LifecycleOwner 和 LifeCycleObserver 两个 interface，可以实现观察者模式。

2.1.2 用 LifeCycle 将功能和 Activity 解耦

现在，用 LifeCycle 改写上述蓝牙需求，将蓝牙功能，从 Activity 中拆分出来，既能解耦，又能实现对生命周期的监听。

首先，新建 MyBlueToothListener 类的自定义组件，让其实现 LifecycleObserver 接口，此类负责所有蓝牙的管理。对于组件中，需要在页面生命周期变化时得到通知的方法，我们需要在这些方法上用 `@OnLifecycleEvent(Lifecycle.Event.ON_XXX) 标签来标识，这样当页面生命周期变化时，即会自动调用这些标识过的方法，代码如下：

package com.bignerdranch.android.jetpacktest

import android.app.Activity
import android.util.Log
import androidx.lifecycle.Lifecycle
import androidx.lifecycle.LifecycleObserver
import androidx.lifecycle.OnLifecycleEvent

private const val TAG = "MyBlueToothListener"

class MyBlueToothListener(context: Activity?, onBlueToothChangeListener: OnBlueToothChangeListener) : LifecycleObserver {
    init {
        Log.d(TAG, "Init BlueTooth()")
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
    private fun startBlueTooth() {
        Log.d(TAG, "Start BlueTooth()")
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_PAUSE)
    private fun stopBlueTooth() {
        Log.d(TAG, "Stop BlueTooth()")
    }

    interface OnBlueToothChangeListener {
        fun onChanged(latitude: Double, longitude: Double)
    }
}
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

其次，在 MainActivity 中，只需新建 myBlueToothListener 变量，并通过 getLifeCycle().addObserver() 将观察者和被观察者绑定起来，代码如下：

package com.bignerdranch.android.jetpacktest

import android.os.Bundle
import android.util.Log
import androidx.appcompat.app.AppCompatActivity

private const val TAG = "MainActivity"

class MainActivity : AppCompatActivity() {
    private lateinit var myBlueToothListener: MyBlueToothListener
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
        myBlueToothListener = MyBlueToothListener(this, object : MyBlueToothListener.OnBlueToothChangeListener {
            override fun onChanged(latitude: Double, longitude: Double) {
                Log.d(TAG, "on MyBlueToothListener Changed")
            }
        })
        lifecycle.addObserver(myBlueToothListener)
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

运行后，日志会打印如下：现在已经避免了 MyBlueTooth 类，对 Activity 页面生命周期的依赖问题，使组件可以自己管理自己的生命周期，而无需在 Activity 页面中管理，从而实现了解耦：

2022-09-25 08:04:55.717 25451-25451/? D/MyBlueToothListener: Init BlueTooth()
2022-09-25 08:04:55.729 25451-25451/? D/MyBlueToothListener: Start BlueTooth()
2022-09-25 08:05:39.485 25556-25556/com.bignerdranch.android.jetpacktest D/MyBlueToothListener: Init BlueTooth()
2022-09-25 08:05:39.493 25556-25556/com.bignerdranch.android.jetpacktest D/MyBlueToothListener: Start BlueTooth()
1
2
3
4

2.1.3 用 LifeCycle 将功能和 Fragment 解耦

同理，Fragment 的用法和上文中 Activity 的用法相同。Fragment 的源码中生命周期的部分如下：

package androidx.fragment.app;

public class Fragment implements ComponentCallbacks, OnCreateContextMenuListener, LifecycleOwner,
        ViewModelStoreOwner, HasDefaultViewModelProviderFactory, SavedStateRegistryOwner,
        ActivityResultCaller {
    LifecycleRegistry mLifecycleRegistry;
    public Lifecycle getLifecycle() {
        return mLifecycleRegistry;
    }
}
1
2
3
4
5
6
7
8
9
10

2.2 用 LifeCycleService 监听 Service 的生命周期

添加 implementation 'androidx.lifecycle:lifecycle-extensions:2.2.0' 的依赖后，即可使用 LifecycleService 类。

其继承自 Service，实现了 LifecyclerOwner 接口，和 Activity、Fragment 类似，也提供了 getLifeCycle() 方法，其源码如下：

/*
 * Copyright (C) 2017 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package androidx.lifecycle;

import android.app.Service;
import android.content.Intent;
import android.os.IBinder;

import androidx.annotation.CallSuper;
import androidx.annotation.NonNull;
import androidx.annotation.Nullable;

/**
 * A Service that is also a {@link LifecycleOwner}.
 */
public class LifecycleService extends Service implements LifecycleOwner {

    private final ServiceLifecycleDispatcher mDispatcher = new ServiceLifecycleDispatcher(this);

    @CallSuper
    @Override
    public void onCreate() {
        mDispatcher.onServicePreSuperOnCreate();
        super.onCreate();
    }

    @CallSuper
    @Nullable
    @Override
    public IBinder onBind(@NonNull Intent intent) {
        mDispatcher.onServicePreSuperOnBind();
        return null;
    }

    @SuppressWarnings("deprecation")
    @CallSuper
    @Override
    public void onStart(@Nullable Intent intent, int startId) {
        mDispatcher.onServicePreSuperOnStart();
        super.onStart(intent, startId);
    }

    // this method is added only to annotate it with @CallSuper.
    // In usual service super.onStartCommand is no-op, but in LifecycleService
    // it results in mDispatcher.onServicePreSuperOnStart() call, because
    // super.onStartCommand calls onStart().
    @CallSuper
    @Override
    public int onStartCommand(@Nullable Intent intent, int flags, int startId) {
        return super.onStartCommand(intent, flags, startId);
    }

    @CallSuper
    @Override
    public void onDestroy() {
        mDispatcher.onServicePreSuperOnDestroy();
        super.onDestroy();
    }

    @Override
    @NonNull
    public Lifecycle getLifecycle() {
        return mDispatcher.getLifecycle();
    }
}
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

首先，新建一个 MyService 类，让其继承 LifecycleService 类，代码如下：

package com.bignerdranch.android.jetpacktest

import androidx.lifecycle.LifecycleService

class MyService:LifecycleService() {
    private var myServiceObserver :MyServiceObserver = MyServiceObserver()
    init {
        lifecycle.addObserver(myServiceObserver)
    }
}
1
2
3
4
5
6
7
8
9
10

其次，新建 MyServiceObserver 类，在其中写2个回调函数，代码如下：

package com.bignerdranch.android.jetpacktest

import android.util.Log
import androidx.lifecycle.Lifecycle
import androidx.lifecycle.LifecycleObserver
import androidx.lifecycle.OnLifecycleEvent

class MyServiceObserver : LifecycleObserver {
    private val TAG = "MyServiceObserver"

    // 当 Service 的 onCreate() 被调用时，此方法会被调用
    @OnLifecycleEvent(Lifecycle.Event.ON_CREATE)
    private fun startBlueTooth() {
        Log.d(TAG, "start BlueTooth()")
    }

    // 当 Service 的 onDestroy() 被调用时，此方法会被调用
    @OnLifecycleEvent(Lifecycle.Event.ON_DESTROY)
    private fun stopBlueTooth() {
        Log.d(TAG, "stop BlueTooth()")
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

然后，在 AndroidManifest.xml 中通过 <service android:name=".MyService"/> 注册 Service，代码如下：

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    package="com.bignerdranch.android.jetpacktest">

    <application
        android:allowBackup="true"
        android:dataExtractionRules="@xml/data_extraction_rules"
        android:fullBackupContent="@xml/backup_rules"
        android:icon="@mipmap/ic_launcher"
        android:label="@string/app_name"
        android:roundIcon="@mipmap/ic_launcher_round"
        android:supportsRtl="true"
        android:theme="@style/Theme.JetpackTest"
        tools:targetApi="31">
        <activity
            android:name=".MainActivity"
            android:exported="true">
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />

                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>
        <service android:name=".MyService"/>
    </application>

</manifest>
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

最后，在 activity_main.xml 布局添加2个Button，控制 Service 的启动和停止，布局如下：

<?xml version="1.0" encoding="utf-8"?>
<androidx.constraintlayout.widget.ConstraintLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    tools:context=".MainActivity">

    <TextView
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="Hello World!"
        app:layout_constraintBottom_toBottomOf="parent"
        app:layout_constraintEnd_toEndOf="parent"
        app:layout_constraintStart_toStartOf="parent"
        app:layout_constraintTop_toTopOf="parent" />

    <Button
        android:id="@+id/start_service_button"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:text="start service"
        app:layout_constraintTop_toTopOf="parent"
        tools:layout_editor_absoluteX="30dp" />

    <Button
        android:id="@+id/stop_service_button"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:text="stop service"
        app:layout_constraintTop_toBottomOf="@+id/start_service_button"
        tools:layout_editor_absoluteX="28dp" />
</androidx.constraintlayout.widget.ConstraintLayout>
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

布局效果如下：

在这里插入图片描述

然后，在 MainActivity.kt 中设置2个 Button 的监听函数，代码如下：

运行后，当点击 start_button 则会启动 MyService 即会调用 MyServiceObserver类的 startBlueTooth() 回调方法，当点击 stop_button 则会启动 MyService 即会调用 MyServiceObserver类的 startBlueTooth() 回调方法，日志如下：

2022-09-25 13:59:16.460 29147-29147/com.bignerdranch.android.jetpacktest D/MyServiceObserver: start BlueTooth()
2022-09-25 13:59:17.953 29147-29147/com.bignerdranch.android.jetpacktest D/MyServiceObserver: stop BlueTooth()
1
2

即通过 LifecycleService 库，可以当 Service 生命周期变化时，不再需要主动对组件通知，组件就可在其内部管理 Service 生命周期所带来的变化，即实现了组件和Service的解耦。

2.3 用 ProcessLifeCycleOwner 监听 Application 的生命周期

为了监听当前 App 处在前台还是后台，可通过 ProcessLifecycleOwner 类来监听整个 Application 的生命周期。

首先，在 build.gradle 添加 implementation 'androidx.lifecycle:lifecycle-extensions:2.2.0' 依赖。

然后，在 AndroidManifest.xml 中通过 android:name=".MyApplication" 注册 Application，代码如下：

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    package="com.bignerdranch.android.jetpacktest">

    <application
        android:name=".MyApplication"
        android:allowBackup="true"
        android:dataExtractionRules="@xml/data_extraction_rules"
        android:fullBackupContent="@xml/backup_rules"
        android:icon="@mipmap/ic_launcher"
        android:label="@string/app_name"
        android:roundIcon="@mipmap/ic_launcher_round"
        android:supportsRtl="true"
        android:theme="@style/Theme.JetpackTest"
        tools:targetApi="31">
        <activity
            android:name=".MainActivity"
            android:exported="true">
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />

                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>
        <service android:name=".MyService" />
    </application>

</manifest>
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

然后，新建 MyApplication 类，代码如下：

package com.bignerdranch.android.jetpacktest

import android.app.Application
import androidx.lifecycle.ProcessLifecycleOwner

class MyApplication:Application() {
    override fun onCreate() {
        super.onCreate()
        ProcessLifecycleOwner.get().lifecycle.addObserver(ApplicationObServer())
    }
}
1
2
3
4
5
6
7
8
9
10
11

其次，新建 ApplicationObserver 类，代码如下：

package com.bignerdranch.android.jetpacktest

import android.util.Log
import androidx.lifecycle.Lifecycle
import androidx.lifecycle.LifecycleObserver
import androidx.lifecycle.OnLifecycleEvent

class ApplicationObserver : LifecycleObserver {
    private val TAG = "ApplicationObserver"

    // 在 App 的整个生命周期只会调用一次
    @OnLifecycleEvent(Lifecycle.Event.ON_CREATE)
    fun onCreate() {
        Log.d(TAG, "Lifecycle.Event.ON_CREATE")
    }

    // 当 App 在前台时，会被调用
    @OnLifecycleEvent(Lifecycle.Event.ON_START)
    fun onStart() {
        Log.d(TAG, "Lifecycle.Event.ON_START")
    }

    // 当 App 在前台时，会被调用
    @OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
    fun onResume() {
        Log.d(TAG, "Lifecycle.Event.ON_RESUME")
    }

    // 当 App 在后台时，会被调用
    @OnLifecycleEvent(Lifecycle.Event.ON_PAUSE)
    fun onPause() {
        Log.d(TAG, "Lifecycle.Event.ON_PAUSE")
    }

    // 当 App 在后台时，会被调用
    @OnLifecycleEvent(Lifecycle.Event.ON_STOP)
    fun onStop() {
        Log.d(TAG, "Lifecycle.Event.ON_STOP")
    }

    // 永远不会调用，因为系统不会分发调用 ON_DESTROY 事件
    @OnLifecycleEvent(Lifecycle.Event.ON_DESTROY)
    fun onDestroy() {
        Log.d(TAG, "Lifecycle.Event.ON_DESTROY")
    }
}
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

对 Applicaiton 的监听是指，无论只有一个 Activity 还是有多个 Activity，都会监听。

运行后，打印了 ProcessLifeCycleOwner 的回调函数，日志如下：

// 启动后，打印如下日志：
2022-09-25 14:37:02.870 29613-29613/com.bignerdranch.android.jetpacktest D/ApplicationObserver: Lifecycle.Event.ON_CREATE
2022-09-25 14:37:02.996 29613-29613/com.bignerdranch.android.jetpacktest D/ApplicationObserver: Lifecycle.Event.ON_START
2022-09-25 14:37:03.001 29613-29613/com.bignerdranch.android.jetpacktest D/ApplicationObserver: Lifecycle.Event.ON_RESUME
// 按 Home 键后，打印如下日志：
2022-09-25 14:38:51.164 29613-29613/com.bignerdranch.android.jetpacktest D/ApplicationObserver: Lifecycle.Event.ON_PAUSE
2022-09-25 14:38:51.164 29613-29613/com.bignerdranch.android.jetpacktest D/ApplicationObserver: Lifecycle.Event.ON_STOP
1
2
3
4
5
6
7

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/花生_TL007/article/detail/253899