Jetpack 組件之 Lifecycle 使用與淺析
Lifecycle 是什么？
官方解釋：
Lifecycle is a class that holds the information about the lifecycle state of a component (like an activity or a fragment) and allows other objects to observe this state.
個人理解：Lifecycle 就是管理組件( Activity / Fragment )生命周期的一個工具(類），可以在其他組件( Activity / Fragment 之外)監(jiān)聽生命周期變化。該組件是 Jetpack 架構組件庫(Jetpack Architecture Components)中非常重要的一部分，例如 LiveData、ViewModel 等組件，必須依賴該組件實現(xiàn)監(jiān)聽和處理生命周期變化。
怎么使用 Lifecycle？
DefaultLifecycleObserver方式：[推薦]
前提
項目使用Java 8 進行編譯 添加 gradle 依賴 "androidx.lifecycle:lifecycle-common-java8:$lifecycle_version"
class LoginActivity : AppCompatActivity() {
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_login)
//注冊生命周期監(jiān)聽
lifecycle.addObserver(ActivityLifecycleObserver())
}
}
/**
* 生命周期的監(jiān)聽類
* 可實現(xiàn)生命周期相關邏輯，使 LoginActivity 中的代碼邏輯更加簡潔
*/
class ActivityLifecycleObserver: DefaultLifecycleObserver{
override fun onResume(owner: LifecycleOwner) {
super.onResume(owner)
//生命周期執(zhí)行到了 onResume
}
}
注解方式：
不推薦。注解方式是通過反射調(diào)用，存在性能損耗。
class LoginActivity : AppCompatActivity() {
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_login)
//注冊生命周期監(jiān)聽
lifecycle.addObserver(ActivityLifecycleObserver())
}
}
/**
* 生命周期的監(jiān)聽類
* 可實現(xiàn)生命周期相關邏輯，使 LoginActivity 中的代碼邏輯更加簡潔
*/
class ActivityLifecycleObserver: LifecycleObserver{
@OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
fun onResume(){
//生命周期執(zhí)行到了 onResume
}
}
拓展，自主管理生命周期
非常不推薦。這種自行維護生命周期，可能會出現(xiàn)競態(tài)情況。
class LoginActivity : AppCompatActivity() {
private lateinit var mLifecycleRegistry: LifecycleRegistry
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_login)
//這里自定義LifecycleRegistry
mLifecycleRegistry = LifecycleRegistry(this)
mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_CREATE)
//注冊生命周期監(jiān)聽
lifecycle.addObserver(ActivityLifecycleObserver())
}
override fun onStart() {
super.onStart()
//通過自定義的 LifecycleRegistry 發(fā)送生命周期，可覆蓋默認實現(xiàn)
mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_START)
}
// 必須要重寫該方法，賦予自定義的Registry
override fun getLifecycle(): Lifecycle {
return mLifecycleRegistry
}
}
class ActivityLifecycleObserver: LifecycleObserver{
@OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
fun onResume(){
//生命周期執(zhí)行到了 onResume
}
}
Lifecycle 的原理是什么？
理解 Event、State
在開始源碼講解前，首先要明白 Event 與 State 之間的關系。這個至關重要，因為在源碼中經(jīng)常會有 Event 與 State 間的互相轉(zhuǎn)換，需要依賴兩者的關系圖()促進理解才行。
Event： Lifecycle 發(fā)送對應的生命周期事件的枚舉類，包含 onCreate、onStart 等生命周期事件。
State： Lifecycle 處理的生命周期狀態(tài)，與Event是映射關系。
實現(xiàn)原理
原理僅講解 Activity 部分，F(xiàn)ragment 的實現(xiàn)邏輯，可自行查看下 FragmentActivity # HostCallbacks 類的相關調(diào)用與邏輯。
源碼部分基于 lifecycle 2.2.0 版本 與 acitivity 1.1.0 版本。
源碼分析分為兩部分，先從調(diào)用方法出發(fā)，大體知道內(nèi)部邏輯，再從疑問入手，解答心里疑惑。
從調(diào)用方法出發(fā)
/**
* 這里有三部分組成: lifecycle、addObserver()、ActivityLifecycleObserver對象
* lifecycle: 對應的 getLifecycle() 方法,獲取 Lifecycle 對象
* addObserver(): 調(diào)用 Lifecycle 對象的 addObserver() 方法
* ActivityLifecycleObserver對象: 這個是我們實現(xiàn) DefaultLifecycleObserver 接口的類對象
*/
lifecycle.addObserver(ActivityLifecycleObserver())
通過調(diào)用方法可以發(fā)現(xiàn)，需要看一下 getLifecycle() 和 addObserver() 兩個方法的內(nèi)部邏輯是什么？
getLifecycle() 內(nèi)部實現(xiàn)：
通過下面代碼可以看到，getLifecycle() 方法真正實現(xiàn)是在 ComponentActivity中，并且創(chuàng)建一個 LifecycleRegistry 對象，通過該方法返回。
public class ComponentActivity extends androidx.core.app.ComponentActivity implements LifecycleOwner{
// ... 省略 ...
// 直接 new 了一個 LifecycleRegistry 對象。
// LifecycleRegistry 這個類又是做什么的呢？ 這個我們后面在看。
private final LifecycleRegistry mLifecycleRegistry = new LifecycleRegistry(this);
// ... 省略 ...
@NonNull
@Override
public Lifecycle getLifecycle() {
return mLifecycleRegistry;
}
// ... 省略 ...
}
addObserver() 內(nèi)部實現(xiàn)：
通過代碼可以發(fā)現(xiàn) LifecycleRegistry 才是實際的生命周期的管理類，這也是為什么上面 getLifecycle() 返回的是LifecycleRegistry 對象。代碼看起來不少，但也是最核心的部分，簡單總結(jié)下：
調(diào)用 addObserver() 方法，內(nèi)部會給定一個初始狀態(tài)，并與 observer 綁定(通過 ObserverWithState)，然后調(diào)用了 sync() 方法。 sync() 方法內(nèi)部根據(jù)狀態(tài)之間的差異判斷是往前走(forwardPass())還是往后走(backwardPass())。（此處咱們以往前走為例） forwardPass()內(nèi)部調(diào)用 upEvent() 方法，將 observer 的 State 轉(zhuǎn)換為 Event，然后調(diào)用 ObserverWithState#dispatchEvent() 進行分發(fā)。 此時我們自己實現(xiàn)的 Observer 類就會收到生命周期回調(diào)了。
PS: 這里需要注意 LifecycleRegistry#mState 和 ObserverWithState#mState 不要搞混了。
public class LifecycleRegistry extends Lifecycle {
// ... 省略 ...
@Override
public void addObserver(@NonNull LifecycleObserver observer) {
// 給定一個初始狀態(tài)，創(chuàng)建 ObserverWithState 對象，將狀態(tài)與 observer 傳入，
// 然后將 ObserverWithState 對象存入 map 中
State initialState = mState == DESTROYED ? DESTROYED : INITIALIZED;
ObserverWithState statefulObserver = new ObserverWithState(observer, initialState);
ObserverWithState previous = mObserverMap.putIfAbsent(observer, statefulObserver);
// ... 省略 ...
if (!isReentrance) {
// we do sync only on the top level.
sync();
}
// ... 省略 ...
}
// ... 省略 ...
private void sync() {
LifecycleOwner lifecycleOwner = mLifecycleOwner.get();
// ... 省略 ...
// 通過 isSynced() 方法判斷狀態(tài)是否已經(jīng)對齊。
// 下面邏輯用于判斷是往前走，還是往后走。
// 需要借助“State 與 Event 關系圖”來理解。
// 例如:
// 顯示一個新建的Activity, mState = Created, mObserverMap.eldest().getValue().mState = INITIALIZED,
// newest.getValue().mState = INITIALIZED。通過以下邏輯可以判斷，執(zhí)行 forwardPass() 方法(往前走)
while (!isSynced()) {
if (mState.compareTo(mObserverMap.eldest().getValue().mState) < 0) {
backwardPass(lifecycleOwner);
}
Entry<LifecycleObserver, ObserverWithState> newest = mObserverMap.newest();
if (!mNewEventOccurred && newest != null
&& mState.compareTo(newest.getValue().mState) > 0) {
forwardPass(lifecycleOwner);
}
}
}
// ... 省略 ...
private void forwardPass(LifecycleOwner lifecycleOwner) {
Iterator<Entry<LifecycleObserver, ObserverWithState>> ascendingIterator =
mObserverMap.iteratorWithAdditions();
while (ascendingIterator.hasNext() && !mNewEventOccurred) {
Entry<LifecycleObserver, ObserverWithState> entry = ascendingIterator.next();
ObserverWithState observer = entry.getValue();
while ((observer.mState.compareTo(mState) < 0 && !mNewEventOccurred
&& mObserverMap.contains(entry.getKey()))) {
pushParentState(observer.mState);
// 重點在這里~ 調(diào)用 upEvent() 方法，獲取當前 State 對應的 Event，
// 然后調(diào)用 ObserverWithState 的 dispatchEvent() 方法分發(fā)
observer.dispatchEvent(lifecycleOwner, upEvent(observer.mState));
popParentState();
}
}
}
// ... 省略 ...
// State 轉(zhuǎn) Event?？蓞⒄铡癝tate 與 Event 關系圖”來理解
private static Event upEvent(State state) {
switch (state) {
case INITIALIZED:
case DESTROYED:
return ON_CREATE;
case CREATED:
return ON_START;
case STARTED:
return ON_RESUME;
case RESUMED:
throw new IllegalArgumentException();
}
throw new IllegalArgumentException("Unexpected state value " + state);
}
// ... 省略 ...
// 靜態(tài)內(nèi)部類，用于綁定 observer 與 State
static class ObserverWithState {
State mState;
LifecycleEventObserver mLifecycleObserver;
ObserverWithState(LifecycleObserver observer, State initialState) {
// 這里將自己實現(xiàn)的 Observer 類對象做了一層轉(zhuǎn)換。內(nèi)部有對注解方式的實現(xiàn)，可自行查看。
mLifecycleObserver = Lifecycling.lifecycleEventObserver(observer);
mState = initialState;
}
// 通過 Event 轉(zhuǎn) State，對當前 Event 事件進行下發(fā)，并更新 observer 的 State
void dispatchEvent(LifecycleOwner owner, Event event) {
State newState = getStateAfter(event);
mState = min(mState, newState);
mLifecycleObserver.onStateChanged(owner, event);
mState = newState;
}
}
// ... 省略 ...
}
從疑問出發(fā)
1. Lifecycle 是如何監(jiān)聽生命周期的？又怎么通知其他組件(Observer)生命周期變化的？
從上面的“從調(diào)用方法入手”沒有看到如何監(jiān)聽生命周期變化的，那么這一塊邏輯在哪里呢？(這里以 監(jiān)聽 Activity 生命周期為例) 在 ComponentActivity#onCreate() 方法中調(diào)用了 ReportFragment#injectIfNeededIn()。ReportFragment 就是真正的生命周期提供者(被觀察者)，它內(nèi)部提供生命周期的變化，并調(diào)用 LifecycleRegistry#handleLifecycleEvent() 方法進行下發(fā)。handleLifecycleEvent() 方法內(nèi)部將 Event 轉(zhuǎn) State，然后調(diào)用 sync 方法，剩余邏輯就和“從調(diào)用方法觸發(fā)”中的一樣了(可以看 addObserver() 內(nèi)部實現(xiàn) 部分)。
public class ComponentActivity extends androidx.core.app.ComponentActivity implements
LifecycleOwner,
ViewModelStoreOwner,
SavedStateRegistryOwner,
OnBackPressedDispatcherOwner {
// ... 省略 ...
@Override
protected void onCreate(@Nullable Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
mSavedStateRegistryController.performRestore(savedInstanceState);
// 這里
ReportFragment.injectIfNeededIn(this);
if (mContentLayoutId != 0) {
setContentView(mContentLayoutId);
}
}
}
//實際生命周期被觀察者
public class ReportFragment extends Fragment {
// ... 此處省略生命周期相關邏輯，最后都會調(diào)用 dispatch() ...
private void dispatch(Lifecycle.Event event) {
Activity activity = getActivity();
// ... 省略 ...
if (activity instanceof LifecycleOwner) {
Lifecycle lifecycle = ((LifecycleOwner) activity).getLifecycle();
if (lifecycle instanceof LifecycleRegistry) {
//調(diào)用 LifecycleRegistry#handleLifecycleEvent() 方法觸發(fā)事件
((LifecycleRegistry) lifecycle).handleLifecycleEvent(event);
}
}
}
}
public class LifecycleRegistry extends Lifecycle {
// ... 省略 ...
public void handleLifecycleEvent(@NonNull Lifecycle.Event event) {
// 根據(jù)傳入的 Event 獲取 State
State next = getStateAfter(event);
moveToState(next);
}
// 更新 LifecycleRegistry#mState 值，然后調(diào)用 sync() 方法
private void moveToState(State next) {
// ... 省略 ...
mState = next;
// ... 省略 ...
sync();
}
// ... 省略 ...
}
2. addObserver() 在 onStart() 中調(diào)用的話，還會受到 onCreate 生命周期嗎？
通過如下代碼和注釋可以得出結(jié)論：如果不是在 onCreate() 中調(diào)用 addObserver()，仍然可以得到生命周期事件。
public class LifecycleRegistry extends Lifecycle {
// ... 省略 ...
@Override
public void addObserver(@NonNull LifecycleObserver observer) {
// ... 省略 ...
// 這里開始比較 observer 的 State 與當前的 State，如果晚于當前的 State 則觸發(fā) dipatchEvent 追趕當前的生命周期。
// 比較兩個 State 的意義在于 addObserver() 調(diào)用如果不在 onCreate 中，則仍可以接收到 onCreate 生命周期。
// 例如：
// 當前的 State = Started, observer 的 State = INITIALIZED，
// observer 的 State 晚于當前的 State，則觸發(fā) dispatchEvent(INITIALIZED)
while ((statefulObserver.mState.compareTo(targetState) < 0
&& mObserverMap.contains(observer))) {
pushParentState(statefulObserver.mState);
statefulObserver.dispatchEvent(lifecycleOwner, upEvent(statefulObserver.mState));
popParentState();
// 為了防止在observer State 在追趕途中，當前 State 又發(fā)生了變化，則調(diào)用 calculateTargetState() 再次計算一下兩者差距
targetState = calculateTargetState(observer);
}
if (!isReentrance) {
// we do sync only on the top level.
sync();
}
// ... 省略 ...
}
// ... 省略 ...
}
3. 項目現(xiàn)在繼承的是 Activity 類，怎么使用 Lifecycle 呢？
通過代碼可以得知，Lifecycle 的生命周期變化是在 ComponentActivity，如果繼承的是 Activity，那只能自己維護生命周期的變化，類似于“拓展，自主管理生命周期”，區(qū)別在于需要實現(xiàn) LifecycleOwner 接口，并維護全生命周期。以下為示例代碼：
open class BaseActivity : Activity(), LifecycleOwner{
private val mLifecycleRegistry = LifecycleRegistry(this)
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_CREATE)
}
override fun onStart() {
super.onStart()
mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_START)
}
override fun onDestroy() {
super.onDestroy()
mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_DESTROY)
}
override fun getLifecycle(): Lifecycle {
return mLifecycleRegistry
}
}
總結(jié)
簡單總結(jié)下Lifecycle的實現(xiàn)原理：在 ComponentActivity 調(diào)用 ReportFragment 來監(jiān)聽生命周期變化，當生命周期變化時，調(diào)用 LifecycleRegistry#handleLifecycleEvent() 來通知。然后調(diào)用 LifecycleRegistry#addObserver() 方法，內(nèi)部會根據(jù) State 與 Event 進行轉(zhuǎn)換，并下發(fā)生命周期事件。下面為調(diào)用時序圖，可參照自行走一遍源碼。