前言
為了幫助開發者更高效，更容易地構建優秀的應用，在 2018 Google IO 大會上，谷歌正式推出了 Android Jetpack Components 系列架構元件。本文的主題是 Lifecycle，它可以有效的避免記憶體洩漏，和解決 Android 中生命週期常見的難題。
在最近學習官方的架構元件時，我詢問了我的朋友，他指導我的學習順序為：Lifecycle - ViewModel - LiveData。我當時很不解，直到我將原始碼過了一邊，才發現 Lifecycle 是 ViewModel 和 LiveData 元件的支撐。
使用
1. 首先定義一個類實現 LifecycleObserver 介面
class MainPresenter : LifecycleObserver { @OnLifecycleEvent(Lifecycle.Event.ON_CREATE) fun onCreate() {
println("MainPresenter: ON_CREATE")
} @OnLifecycleEvent(Lifecycle.Event.ON_DESTROY) fun onDestroy() {
println("MainPresenter: ON_DESTROY")
}
}複製程式碼在對應的方法新增 @OnLifecycleEvent 註解，接下來在 LifecyleOwner 中註冊觀察者。
2. 在 Activity 中註冊觀察者
class MainActivity : AppCompatActivity() {
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState) setContentView(R.layout.activity_main) println("MainActivity: onCreate") // 註冊觀察者 lifecycle.addObserver(MainPresenter())
}
}複製程式碼簡單的 2 步操作，我們的 MainPresenter 就可以感知當前 Activity 的生命週期。
2018-12-06 20:05:50.199 22452-22452/com.i3kmsteady.jetpacksample I/System.out: MainActivity: onCreate2018-12-06 20:05:50.214 22452-22452/com.i3kmsteady.jetpacksample I/System.out: MainPresenter: ON_CREATE2018-12-06 20:06:03.159 22452-22452/com.i3kmsteady.jetpacksample I/System.out: MainPresenter: ON_DESTROY2018-12-06 20:06:03.161 22452-22452/com.i3kmsteady.jetpacksample I/System.out: MainActivity: onDestroy複製程式碼當然了，這只是一個簡單的例項。在專案中的具體使用，冒昧推薦下 卻把清梅嗅 的 MVVM-Rhine。
3. 如果在專案中使用了 Java8，推薦使用DefaultLifecycleObserver
class MainPresenter : DefaultLifecycleObserver { override fun onCreate(owner: LifecycleOwner) {
super.onCreate(owner)
}
}複製程式碼大概率會遇到以下錯誤：
Super calls to Java default methods are prohibited in JVM target 1.6. Recompile with '-jvm-target 1.8'複製程式碼在 app 下的 build.gradle 中的 android 閉包中新增以下程式碼即可解決：
kotlinOptions{
jvmTarget = '1.8'
}複製程式碼雖然程式碼實現很簡單，但是我們要保持好奇心，去探究下 Lifecycle 元件的具體實現。
原始碼分析
從 MainActivity 中的程式碼展開，來探索一步一步的實現。
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState) setContentView(R.layout.activity_main) // 新增觀察者 lifecycle.addObserver(MainPresenter())
}複製程式碼1. LifecycleOwner
LifecycleOwner 是描述 Android生命週期持有者的一個類。以 Activiy 為例來展開
@RestrictTo({Scope.LIBRARY_GROUP
})public class SupportActivity extends Activity implements LifecycleOwner, Component { ... protected void onCreate(@Nullable Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
ReportFragment.injectIfNeededIn(this);
} @CallSuper protected void onSaveInstanceState(Bundle outState) {
this.mLifecycleRegistry.markState(State.CREATED);
super.onSaveInstanceState(outState);
} @RestrictTo({Scope.LIBRARY_GROUP
}) public <
T extends SupportActivity.ExtraData>
T getExtraData(Class<
T>
extraDataClass) {
return (SupportActivity.ExtraData)this.mExtraDataMap.get(extraDataClass);
} public Lifecycle getLifecycle() {
return this.mLifecycleRegistry;
} ...
}複製程式碼lifecycle 返回的是在 SupprotActivity 中初始化的 LifecycleRegistery 物件。
2. Lifecycle
Lifecycle 是表示 Android 生命週期及其狀態的物件，具體實現為 LifecycleRegistery 物件。讓我們看下 addObserver()
@Override public void addObserver(@NonNull LifecycleObserver observer) {
State initialState = mState == DESTROYED ? DESTROYED : INITIALIZED;
ObserverWithState statefulObserver = new ObserverWithState(observer, initialState);
ObserverWithState previous = mObserverMap.putIfAbsent(observer, statefulObserver);
if (previous != null) {
return;
} LifecycleOwner lifecycleOwner = mLifecycleOwner.get();
if (lifecycleOwner == null) {
// it is null we should be destroyed. Fallback quickly return;
} boolean isReentrance = mAddingObserverCounter != 0 || mHandlingEvent;
State targetState = calculateTargetState(observer);
mAddingObserverCounter++;
while ((statefulObserver.mState.compareTo(targetState) <
0 &
&
mObserverMap.contains(observer))) {
pushParentState(statefulObserver.mState);
statefulObserver.dispatchEvent(lifecycleOwner, upEvent(statefulObserver.mState));
popParentState();
// mState / subling may have been changed recalculate targetState = calculateTargetState(observer);
} if (!isReentrance) {
// we do sync only on the top level. sync();
} mAddingObserverCounter--;
}複製程式碼到這一步，似乎自定義的 LifecycleObserver 還是無法感知生命週期。回過頭去看下 SupportActivity 中的 onCreate()，發現了 ReportFragment 的身影。
3. ReportFragment
ReportFragment 是一個不可見的 Fragment，注入在 SupprotActivity 中。通過 Fragment 去感知生命週期，然後通知到 LifecycleObserver()。這樣就可以獲取到當前的生命週期。以下是ReportFragment 中生命週期的分發過程
... @Override public void onActivityCreated(Bundle savedInstanceState) {
super.onActivityCreated(savedInstanceState);
dispatchCreate(mProcessListener);
// 生命週期分發 dispatch(Lifecycle.Event.ON_CREATE);
} ...複製程式碼接下來看下 dispatch() 的實現
private void dispatch(Lifecycle.Event event) {
Activity activity = getActivity();
if (activity instanceof LifecycleRegistryOwner) {
((LifecycleRegistryOwner) activity).getLifecycle().handleLifecycleEvent(event);
return;
} if (activity instanceof LifecycleOwner) {
Lifecycle lifecycle = ((LifecycleOwner) activity).getLifecycle();
if (lifecycle instanceof LifecycleRegistry) {
((LifecycleRegistry) lifecycle).handleLifecycleEvent(event);
}
}
}複製程式碼然後呼叫 Lifecycle 的 handleLifecycleEvent 去分發生命週期。
4. LifecyleRegistery
LifecyleRegistery 是 Lifecycle 的實現，通過呼叫 handleLifecycleEvent() 去通知 LifecycleObsever 生命週期發生了變化。
public void handleLifecycleEvent(@NonNull Lifecycle.Event event) {
State next = getStateAfter(event);
moveToState(next);
}複製程式碼5. ObserverWithState
ObserverWithState 是 LifecyleRegistery 的靜態內部類，呼叫 dispatchEvent() 去通知 LifecycleObserver。
void dispatchEvent(LifecycleOwner owner, Event event) {
State newState = getStateAfter(event);
mState = min(mState, newState);
mLifecycleObserver.onStateChanged(owner, event);
mState = newState;
}複製程式碼通過 debug 除錯，發現 mLifecycleObserver 的最終實現是 ReflectiveGenericLifecycleObserver。
6. ReflectiveGenericLifecycleObserver
ReflectiveGenericLifecycleObserver 是 GenericLifecycleObserver 的實現類。onStateChanged() 最終會呼叫到 CallbackInfo 的 invokeCallbacks()。在其內部通過反射，解析 OnLifecycleEvent註解，通知到我們所宣告的OnLifecycleEvent註解的方法上。
結語
到此，Lifecycle 的基本流程就已經過了一邊。筆者並沒有對原始碼展開一步步的分析，而是從大體上出發，對程式碼的具體實現還有勞大傢俬下進一步的學習。