Android Jetpack架构组件(二)Lifecycle使用

前言

Lifecycle是生命周期感知组件,可以对Activity或者Fragment的生命周期的状态变化做出响应,帮助开发者写出更好组织的,轻量级的代码,更容易维护。

为什么需要Lifecycle

举个栗子,在应用开发过程中,处理Activity或者Fragment的生命周期不可避免,先看官方文档举的例子,是一段对获取位置的监听代码,分别在onStart()里启动监听和在onStop()里停止监听,代码如下:

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
class MyLocationListener(private val context: Context, private val callback:(Location) -> Unit) {

fun start(){
// 连接接定位系统服务
}

fun stop(){
// 断开与定位服务的连接
}
}

class MyLocationActivity : AppCompatActivity() {

private lateinit var myLocationListener: MyLocationListener

override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_my_location)

myLocationListener = MyLocationListener(this) {
// updata UI
}
}

override fun onStart() {
super.onStart()
myLocationListener.start()
}

override fun onStop() {
super.onStop()
myLocationListener.stop()
}
}

在实际开发中,可能要在多个Activity的生命周期进行回调,这样,Activity中就要写大量代码,造成代码难以维护。还有一个问题,如果我们在onStart()方法里做了耗时操作,就可能造成当Activity或者Fragment的onStop()方法在onStart()方法之前结束,所以,我们需要一个感知生命周期的组件,这就是Lifecycle。

使用Lifecycle

添加依赖

官方给出的添加Lifecycle的依赖如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
dependencies {
def lifecycle_version = "2.1.0"

// ViewModel and LiveData
implementation "androidx.lifecycle:lifecycle-extensions:$lifecycle_version"
// alternatively - just ViewModel
implementation "androidx.lifecycle:lifecycle-viewmodel:$lifecycle_version" // For Kotlin use lifecycle-viewmodel-ktx
// alternatively - just LiveData
implementation "androidx.lifecycle:lifecycle-livedata:$lifecycle_version"
// alternatively - Lifecycles only (no ViewModel or LiveData). Some UI
// AndroidX libraries use this lightweight import for Lifecycle
implementation "androidx.lifecycle:lifecycle-runtime:$lifecycle_version"

annotationProcessor "androidx.lifecycle:lifecycle-compiler:$lifecycle_version" // For Kotlin use kapt instead of annotationProcessor
// alternately - if using Java8, use the following instead of lifecycle-compiler
implementation "androidx.lifecycle:lifecycle-common-java8:$lifecycle_version"

// optional - ReactiveStreams support for LiveData
implementation "androidx.lifecycle:lifecycle-reactivestreams:$lifecycle_version" // For Kotlin use lifecycle-reactivestreams-ktx

// optional - Test helpers for LiveData
testImplementation "androidx.arch.core:core-testing:$lifecycle_version"
}

创建MyObserver

创建MyObserver并实现LifecycleObserver接口,Lifecycle实现的过程实际上是观察者模式。

1
2
3
4
5
package cn.appblog.jetpack.lifecycle;

public interface LifecycleCallback {
void update(String message);
}
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
package cn.appblog.jetpack.lifecycle;

import android.util.Log;

import androidx.lifecycle.Lifecycle;
import androidx.lifecycle.LifecycleObserver;
import androidx.lifecycle.OnLifecycleEvent;

public class MyObserver implements LifecycleObserver {

private Lifecycle lifecycle;
private LifecycleCallback lifecycleCallback;

public MyObserver(Lifecycle lifecycle, LifecycleCallback lifecycleCallback) {
this.lifecycle = lifecycle;
this.lifecycleCallback = lifecycleCallback;
}

@OnLifecycleEvent(Lifecycle.Event.ON_CREATE)
public void connectOnCreate() {
Log.i("yezhou", "OnCreate");
update("OnCreate");
}

@OnLifecycleEvent(Lifecycle.Event.ON_START)
public void connectOnStart() {
Log.i("yezhou", "OnStart");
update("OnStart");
}

@OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
public void connectOnResume() {
Log.i("yezhou", "OnResume");
update("OnResume");
}

@OnLifecycleEvent(Lifecycle.Event.ON_PAUSE)
public void connectOnPause() {
Log.i("yezhou", "OnPause");
update("OnPause");
}

@OnLifecycleEvent(Lifecycle.Event.ON_STOP)
public void connectOnStop() {
Log.i("yezhou", "OnStop");
update("OnStop");
}

@OnLifecycleEvent(Lifecycle.Event.ON_DESTROY)
public void connectOnDestroy() {
Log.i("yezhou", "OnDestroy");
update("OnDestroy");
}

private void update(String message) {
lifecycleCallback.update(message);
}
}

在Activity中使用

在Activity中,只要将自定义的MyObserver添加到监听列表中,就可以监听到Activity的生命周期变化。

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
package cn.appblog.jetpack.lifecycle;

import android.os.Bundle;
import android.util.Log;

import androidx.annotation.Nullable;
import androidx.appcompat.app.AppCompatActivity;
import androidx.lifecycle.Lifecycle;

public class LifecycleActivity extends AppCompatActivity {

private MyObserver myObserver;

@Override
protected void onCreate(@Nullable Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
Lifecycle lifecycle = getLifecycle();
myObserver = new MyObserver(lifecycle, new LifecycleCallback() {
@Override
public void update(String message) {
Log.i("yezhou", "LifecycleActivity.myObserver.update: " + message);
}
});

lifecycle.addObserver(myObserver);
}

}

从执行结果中,看到了是执行了索要监听的生命周期。

1
2
3
4
5
6
7
8
9
10
11
12
cn.appblog.jetpack I/yezhou: OnCreate
cn.appblog.jetpack I/yezhou: LifecycleActivity.myObserver.update: OnCreate
cn.appblog.jetpack I/yezhou: OnStart
cn.appblog.jetpack I/yezhou: LifecycleActivity.myObserver.update: OnStart
cn.appblog.jetpack I/yezhou: OnResume
cn.appblog.jetpack I/yezhou: LifecycleActivity.myObserver.update: OnResume
cn.appblog.jetpack I/yezhou: OnPause
cn.appblog.jetpack I/yezhou: LifecycleActivity.myObserver.update: OnPause
cn.appblog.jetpack I/yezhou: OnStop
cn.appblog.jetpack I/yezhou: LifecycleActivity.myObserver.update: OnStop
cn.appblog.jetpack I/yezhou: OnDestroy
cn.appblog.jetpack I/yezhou: LifecycleActivity.myObserver.update: OnDestroy

实现自定义的LifecycleOwner

LifecycleOwner是一个接口,定义如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
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
*/
@SuppressWarnings({"WeakerAccess", "unused"})
public interface LifecycleOwner {
/**
* Returns the Lifecycle of the provider.
*
* @return The lifecycle of the provider.
*/
@NonNull
Lifecycle getLifecycle();
}

可以看到,LifecycleOwner只有一个方法,返回了Lifecycle,Lifecycle这个类包含Fragments 和 Activities的生命周期状态,并且可以让其他的组件观察这个状态。

Fragment 和 AppCompatActivity在Support Library 26.1.0及以后的版本已经实现了LifecycleOwner接口,如果我们想要一个自定义类,拥有Fragments 和 Activities的生命周期状态,可以实现LifecycleOwner接口,使用LifecycleRegistry类,具体代码如下:

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
package cn.appblog.jetpack.lifecycle;

import android.app.Activity;
import android.os.Bundle;

import androidx.annotation.NonNull;
import androidx.annotation.Nullable;
import androidx.lifecycle.Lifecycle;
import androidx.lifecycle.LifecycleOwner;
import androidx.lifecycle.LifecycleRegistry;

public class BaseActivity extends Activity implements LifecycleOwner {

protected LifecycleRegistry lifecycleRegistry;

@Override
protected void onCreate(@Nullable Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
lifecycleRegistry = new LifecycleRegistry(this);
lifecycleRegistry.setCurrentState(Lifecycle.State.CREATED);
}

@Override
protected void onStart() {
super.onStart();
lifecycleRegistry.setCurrentState(Lifecycle.State.STARTED);
}

@Override
protected void onResume() {
super.onResume();
lifecycleRegistry.setCurrentState(Lifecycle.State.RESUMED);
}

@Override
protected void onDestroy() {
super.onDestroy();
lifecycleRegistry.setCurrentState(Lifecycle.State.DESTROYED);
}

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

通过新建LifecycleRegistry,为LifecycleRegistry设置Lifecycle的各个状态。

同上注册观察者即可:

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
package cn.appblog.jetpack.lifecycle;

import android.os.Bundle;
import android.util.Log;

import androidx.annotation.Nullable;
import androidx.lifecycle.Lifecycle;

public class LifecycleOwnerActivity extends BaseActivity {

private MyObserver myObserver;

@Override
protected void onCreate(@Nullable Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
Lifecycle lifecycle = getLifecycle();
myObserver = new MyObserver(lifecycle, new LifecycleCallback() {
@Override
public void update(String message) {
Log.i("yezhou", "LifecycleOwnerActivity.myObserver.update: " + message);
}
});
lifecycle.addObserver(myObserver);
}
}
1
2
3
4
5
6
7
8
9
10
11
12
cn.appblog.jetpack I/yezhou: OnCreate
cn.appblog.jetpack I/yezhou: LifecycleOwnerActivity.myObserver.update: OnCreate
cn.appblog.jetpack I/yezhou: OnStart
cn.appblog.jetpack I/yezhou: LifecycleOwnerActivity.myObserver.update: OnStart
cn.appblog.jetpack I/yezhou: OnResume
cn.appblog.jetpack I/yezhou: LifecycleOwnerActivity.myObserver.update: OnResume
cn.appblog.jetpack I/yezhou: OnPause
cn.appblog.jetpack I/yezhou: LifecycleOwnerActivity.myObserver.update: OnPause
cn.appblog.jetpack I/yezhou: OnStop
cn.appblog.jetpack I/yezhou: LifecycleOwnerActivity.myObserver.update: OnStop
cn.appblog.jetpack I/yezhou: OnDestroy
cn.appblog.jetpack I/yezhou: LifecycleOwnerActivity.myObserver.update: OnDestroy

Powered by AppBlog.CN     浙ICP备14037229号

Copyright © 2012 - 2020 APP开发技术博客 All Rights Reserved.

访客数 : | 访问量 :