Android进阶Jetpack
1.LifeCycle

MyJetpackStudy: jetpack学习 (gitee.com)

Lifecycle是什么？

1
2
3
4
lifecycle 是属于Android Jetpack（官方开发工具包）—— Architecture（架构组件）中的一员。

官方介绍:构建生命周期感知型组件，这些组件可以根据 Activity 或 Fragment 的当前生命周期状态调整行为。
白话:lifecycle可以和Activity或Fragment生命周期绑定，方便我们做一些跟生命周期相关的业务逻辑。

Lifecycle的特点

1
2
3
4
5
6
7
1.生命周期感知：Lifecycle 可以感知应用组件的生命周期状态，包括活动状态、暂停状态、停止状态等。
2.简化生命周期回调：使用 Lifecycle，可以避免在应用组件中手动实现繁琐的生命周期回调。
3.灵活性：Lifecycle 可以与其他 Jetpack 组件（如 ViewModel、LiveData 等）结合使用，提供更灵活的生命周期管理方案。
4.生命周期安全性：Lifecycle 能够确保在正确的生命周期状态下执行相应的操作，避免了可能导致崩溃或内存泄漏的问题。

通过 Lifecycle，开发者可以更好地管理和控制应用组件的生命周期，执行与生命周期相关的操作，如初始化资源、释放资源、注册/注销观
察者等。它可以帮助开发者编写更健壮、可维护的代码，并提供更好的用户体验。

Lifecycle使用

1.先看看可以引用哪些？

1
2
//androidx
implementation 'androidx.appcompat:appcompat:1.3.0'
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
   //非androidx
  dependencies {
    def lifecycle_version = "1.1.1"
    // 包含ViewModel和LiveData
    implementation "android.arch.lifecycle:extensions:$lifecycle_version"
    // 仅仅包含ViewModel
    implementation "android.arch.lifecycle:viewmodel:$lifecycle_version" // For Kotlin use viewmodel-ktx
    // 仅仅包含LiveData
    implementation "android.arch.lifecycle:livedata:$lifecycle_version"
    // 仅仅包含Lifecycles
    implementation "android.arch.lifecycle:runtime:$lifecycle_version"
    annotationProcessor "android.arch.lifecycle:compiler:$lifecycle_version" // For Kotlin use kapt instead of annotationProcessor
    // 如果用Java8, 用于替代compiler
    implementation "android.arch.lifecycle:common-java8:$lifecycle_version"
    // 可选，ReactiveStreams对LiveData的支持
    implementation "android.arch.lifecycle:reactivestreams:$lifecycle_version"
    // 可选，LiveData的测试
    testImplementation "android.arch.core:core-testing:$lifecycle_version"
}

除了Activity和Fragment外，还可以绑定Service和Application的生命周期。只要引入支持相关的可选库即可；官方提到最多的是Activity和Fragment，是因为平时主要用于这两个组件；其实只要有生命周期的组件都可以跟它绑定。而在Android中大多数的组件都是有生命周期的。

2.简单使用案例：

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
package com.example.lifecycledemo1;

import android.arch.lifecycle.Lifecycle;
import android.arch.lifecycle.LifecycleObserver;
import android.arch.lifecycle.OnLifecycleEvent;
import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.util.Log;

public class MainActivity extends AppCompatActivity {
    private static final String TAG = "MainActivity";
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        getLifecycle().addObserver(new MyObserver());//1
    }
    public class MyObserver implements LifecycleObserver{
        @OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
        void onResume(){
            Log.d(TAG, "Lifecycle call onResume");
        }
        @OnLifecycleEvent(Lifecycle.Event.ON_PAUSE)
        void onPause(){
            Log.d(TAG, "Lifecycle call onPause");
        }
    }
    @Override
    protected void onResume() {
        super.onResume();
        Log.d(TAG, "onResume");
    }
    @Override
    protected void onPause() {
        super.onPause();
        Log.d(TAG, "onPause");
    }
}

工具类封装：

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
//使用：被观察者继承BaseActivity或者添加getLifecycle().addObserver(new BaseLifeCycle());即可
public abstract class BaseActivity <T extends BaseLifeCycle> extends AppCompatActivity {
    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        getLifecycle().addObserver(new BaseLifeCycle());
    }
}
		
//观察者类
public class BaseLifeCycle implements LifecycleObserver{
    private String TAG="tyl";
    @OnLifecycleEvent(Lifecycle.Event.ON_CREATE)
    void onCreate(LifecycleOwner owner) {
        Log.e(TAG, "BaseLifeCycle-onCreate:"+owner.getClass().toString());
    }
		
    @OnLifecycleEvent(Lifecycle.Event.ON_START)
    void onStart(LifecycleOwner owner) {
        Log.e(TAG, "BaseLifeCycle-onStart:"+owner.getClass().toString());
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_STOP)
    void onStop(LifecycleOwner owner) {
        Log.e(TAG, "BaseLifeCycle-onStop:"+owner.getClass().toString());
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
    void onResume(LifecycleOwner owner) {
        Log.e(TAG, "BaseLifeCycle-onResume:"+owner.getClass().toString());
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_PAUSE)
    void onPause(LifecycleOwner owner) {
        Log.e(TAG, "BaseLifeCycle-onPause:"+owner.getClass().toString());
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_DESTROY)
    void onDestory(LifecycleOwner owner) {
        Log.e(TAG, "BaseLifeCycle-onDestory:"+owner.getClass().toString());
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_ANY)
    void onAny(LifecycleOwner owner) {//无论当前活动处于何种生命周期状态，都会触发相应的生命周期方法
//        Log.e(TAG, "BaseLifeCycle-onAny:"+owner.getClass().toString());
    }

}