前言
本文將開始Jetpack系列之Lifecycle的學習，為什么先說Lifecycle呢，因為Lifecycle是Jetpack的核心，我們熟悉的ViewModel,LiveData都是基于它實現的。（關于Jetpack大家也可以直接看Jetpack官網 ）
看完本文可以達到什么程度
- 掌握Lifecycle的基本原理及使用
- 掌握Activity Fragment是如何實現Lifecycle的。
- 掌握Lifecycle宿主分發
如果您已經達到上面的程度，那么可以不看下文了；
什么是Jetpack
簡單點總結就是：Jetpack是眾多組件的統稱，而AndroidX是這些組件的統一包名。
什么是Lifecycle
Lifecycle也即是Jetpack眾多組件之一，這個組件庫代碼也就是小十個類，如下：
Lifecycle庫.png
簡單點總結就是：Lifecycle組件抽象出了一套觀察者(繼承LifecycleObserver)，被觀察者(繼承LifecycleOwner,例如Fragment)，以及他們兩之間事件分發 的能力。
Lifecycle簡單流程.png
- Lifecycle是一個能感知宿主(LifecycleOwner)生命周期的組件。
- 允許其它觀察者監聽宿主生命周期狀態。
- 省略了以前手動分發宿主生命周期的操作.(例如在onDestroy中去調用三方組件的銷毀)。
- 宿主如何分發生命周期狀態？之后再詳細分析。
Lifecycle的使用
1). 首先得添加依賴，以下兩種選一種就行
//通常情況下，只需要添加appcompat就可以了
api 'androidx.appcompat:appcompat:1.1.0'
//如果想單獨使用，可引入下面這個依賴
api 'androidx.lifecycle:lifecycle-common:2.1.0'
2). 使用有如下三種方式：
- 實現LifecycleObserver，并使用@OnLifecycleEvent注解
// 1.自定義的組件，也是LifecycleObserver觀察者
class MyObserver implements LifecycleObserver {
// 在對應的方法上用注解聲明想要觀察的宿主生命周期
@OnLifecycleEvent(Lifecycle.Event.ON_CREATE)
void onCreate(LifecycleOwner owner){
// 宿主(例如Fragment)的onCreate事件分發
}
@OnLifecycleEvent(Lifecycle.Event.ON_DESTROY)
void onDestroy(LifecycleOwner owner){
// 宿主(例如Fragment)的onDestroy事件分發
}
}
// 1.Fragment繼承了LifecycleOwner，是個宿主
// 2.注冊觀察者,觀察宿主生命周期變化
class MyFragment extends Fragment {
@Override
public void onCreate(@Nullable Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
MyObserver observer = new MyObserver();
getLifecycle().addObserver(observer);
}
}
- 實現FullLifecyclerObserver，擁有生命周期所有事件，但FullLifecyclerObserver類對外不可見。
class MyObserver1 implements FullLifecycleObserver {
@Override
public void onCreate(LifecycleOwner owner) {
}
@Override
public void onStart(LifecycleOwner owner) {
}
@Override
public void onResume(LifecycleOwner owner) {
}
@Override
public void onPause(LifecycleOwner owner) {
}
@Override
public void onStop(LifecycleOwner owner) {
}
@Override
public void onDestroy(LifecycleOwner owner) {
}
}
- LifecycleEventObserver宿主生命周期事件封裝成 Lifecycle.Event，觀察者根據Lifecycle.Event區分宿主的不同生命周期
// 源碼
public interface LifecycleEventObserver extends LifecycleObserver {
void onStateChanged(@NonNull LifecycleOwner source, @NonNull Lifecycle.Event event);
}
class MyObserver2 implements LifecycleEventObserver {
@Override
public void onStateChanged(@NonNull LifecycleOwner source, @NonNull Lifecycle.Event event) {
switch (event){
case ON_CREATE:
// 宿主onCreate生命周期
break;
case ON_DESTROY:
// 宿主onDestroy生命周期
break;
}
}
}
3). 我們的Activity跟Fragment都是LifecycleOwner；也就是說一些自定義組件可以通過addObserver，在組件內部獲得Activity跟Fragment的生命周期回調；舉個例子：
/**
* 倒計時組件
* 1. 最原始的做法我們需要在Activity或Fragment的onDestroy中手動去停止。萬一漏了就可能造成內存泄漏問題。
* 2. 有了Lifecycle，就能在組件內部去處理，再也不怕內存泄漏了
*/
public class CountDownTextView extends AppCompatTextView implements LifecycleObserver {
public CountDownTextView(......) {
super(......);
// 自動注冊
autoBindLifecycle(context);
}
}
private void autoBindLifecycle(Context context) {
...
xxx.getLifecycle().addObserver(this);
...
}
@OnLifecycleEvent(Lifecycle.Event.ON_DESTROY)
private void onDestroy() {
// 自動去做一些停止，釋放資源等操作
......
}
Fragment如何實現Lifecycle
先看看整體架構圖：
Lifecycle-fragment架構.png
Fragment中代碼如下：
public class Fragment implements LifecycleOwner {
LifecycleRegistry mLifecycleRegistry = new LifecycleRegistry(this);
@Override
public Lifecycle getLifecycle() {
//復寫自LifecycleOwner,所以必須new LifecycleRegistry對象返回
return mLifecycleRegistry;
}
void performCreate(){
mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_CREATE);
}
void performStart(){
mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_START);
}
.....
void performResume(){
mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_RESUME);
}
}
- Fragment實現了LifecycleOwner接口，是一個能提供生命周期事件的宿主
- Fragment中通過Lifecycle addObserver()，來添加觀察者。
- Fragment中通過Lifecycle的具體實現類LifecycleRegistry來進行生命周期事件的分發。
Activity如何實現Lifecycle
Activity的實現跟Fragment稍有不同，不是利用自己的生命周期去分發事件，而是添加一個Fragment，通過Fragment的生命周期去分發。(為啥這樣設計？？)
public class ComponentActivity extends Activity implements LifecycleOwner{
private LifecycleRegistry mLifecycleRegistry = new LifecycleRegistry(this);
@NonNull
@Override
public Lifecycle getLifecycle() {
return mLifecycleRegistry;
}
protected void onCreate(Bundle bundle) {
super.onCreate(savedInstanceState);
//往Activity上添加一個fragment,用以報告生命周期的變化
//目的是為了兼顧不是繼承自AppCompactActivity的場景.
ReportFragment.injectIfNeededIn(this);
}
ReportFragment的實現原理跟Fragment類似，通過LifecycleRegistry對生命周期事件分發。
public class ReportFragment extends Fragment{
public static void injectIfNeededIn(Activity activity) {
android.app.FragmentManager manager = activity.getFragmentManager();
if (manager.findFragmentByTag(REPORT_FRAGMENT_TAG) == null) {
manager.beginTransaction().add(new ReportFragment(), REPORT_FRAGMENT_TAG).commit();
manager.executePendingTransactions();
}
}
@Override
public void onStart() {
super.onStart();
dispatch(Lifecycle.Event.ON_START);
}
@Override
public void onResume() {
super.onResume();
dispatch(Lifecycle.Event.ON_RESUME);
}
@Override
public void onPause() {
super.onPause();
dispatch(Lifecycle.Event.ON_PAUSE);
}
@Override
public void onDestroy() {
super.onDestroy();
dispatch(Lifecycle.Event.ON_DESTROY);
}
private void dispatch(Lifecycle.Event event) {
Lifecycle lifecycle = activity.getLifecycle();
if (lifecycle instanceof LifecycleRegistry) {
((LifecycleRegistry) lifecycle).handleLifecycleEvent(event);
}
}
生命周期事件及狀態
先明確兩個概念：Lifecycle類中有兩個枚舉，Event(事件),State(狀態)。
Event：當宿主的生命周期有變化時，會發送相應的事件Event,如下：
void performCreate(Bundle savedInstanceState) {
mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_CREATE);
}
State：Lifecycle的實現類LifecycleRegistry中保存了mState，代表當前宿主的狀態；宿主發送不同的事件，相應的State也會變化。
Event和State關系如下：
Lifecycle事件及狀態.png
事件分發原理
首先先思考一個問題：如果是在Fragment的onResume中注冊一個Observer，這個Observer還能收到Fragment的oncreate,onstart,onresume事件嗎？
這里先給答案：可以收到，這幾個事件在addObserver方法中就會去分發。
以這個為例來講講lifecycle的事件分發原理，主要看下LifecycleRegistry流程，先見下圖：
LifecycleRegistry主要流程.png
上圖就是一個大致的了解，要詳細的認知還是得看源碼：
Step1:初始化
public LifecycleRegistry(@NonNull LifecycleOwner provider) {
mLifecycleOwner = new WeakReference<>(provider);
mState = INITIALIZED;
}
這個構造方法就是在Fragment的構造方法中調用，主要是對mState做了個初始化INITIALIZED
Step2：注冊Observer
以下代碼只展示一些主流程
public void addObserver(@NonNull LifecycleObserver observer) {
// 1.添加新的Observer時，會根據宿主狀態計算observer的初始狀態
State initialState = mState == DESTROYED ? DESTROYED : INITIALIZED;
// 2.把初始狀態跟observer封裝成一個新的對象ObserverWithState
ObserverWithState statefulObserver = new ObserverWithState(observer, initialState);
// 3. 計算宿主對象的狀態
State targetState = calculateTargetState(observer);
......
}
// Observer對象的封裝對象
static class ObserverWithState {
State mState;
// 所有的Observer會轉成LifecycleEventObserver類型
LifecycleEventObserver mLifecycleObserver;
ObserverWithState(LifecycleObserver observer, State initialState) {
mLifecycleObserver = Lifecycling.lifecycleEventObserver(observer);
mState = initialState;
}
// 事件發送
void dispatchEvent(LifecycleOwner owner, Event event) {
State newState = getStateAfter(event);
mState = min(mState, newState);
mLifecycleObserver.onStateChanged(owner, event);
mState = newState;
}
}
把observer與State封裝成ObserverWithState，這個對象對把observer統一轉成LifecycleEventObserver類型；怎么轉的大家可以詳細看下Lifecycling中lifecycleEventObserver，這里不展開敘述了
Step3:對比Observer狀態跟宿主狀態
public void addObserver( LifecycleObserver observer) {
以上是Step2
......
// 1. 拿觀察者的狀態和宿主當前狀態做比較，如果小于0，說明兩者狀態還沒有對齊
while ((statefulObserver.mState.compareTo(targetState) < 0,...){
......
// 2.接著就會分發一次相應的事件，于此同時statefulObserver的mState對象也會被升級
statefulObserver.dispatchEvent(lifecycleOwner, upEvent(statefulObserver.mState));
// 3.再一次計算觀察者應該到達的狀態
targetState = calculateTargetState(observer);
}
}
在以上三步后，在onResume中注冊的Observer就能收到oncreate,onstart,onresume三個事件。當宿主在執行其他的生命周期時，會通過handleLifecycleEvent發送相應的事件。
Step4:宿主發送相應事件
public void handleLifecycleEvent(@NonNull Lifecycle.Event event) {
// 1. 獲取事件相對應的狀態
State next = getStateAfter(event);
// 2.同步到該狀態，給所有的Observer發送事件
moveToState(next);
}
總結
看完本篇再回到開頭的幾項目標，是不是都掌握了呢？還沒掌握可以對著源碼再細細屢屢，相信一定能掌握Lifecycle的核心，之后要講的LiveData，ViewModel都是基于它來實現的。
