總目錄
Jetpack框架探究01：Lifecycle組件的使用與原始碼分析
Jetpack框架探究02：LiveData組件的使用與原始碼分析
Jetpack框架探究03：ViewModel組件的使用與原始碼分析
Jetpack框架探究04：Room組件的使用與原始碼分析
Jetpack框架探究05：WorkerManager組件的使用與原始碼分析
1. Lifecycle簡介
?Lifecycle是Android Jetpack框架提供的能夠感知組件(宿主)生命周期變化的組件，它能持有宿主(如Activity或Fragment)生命周期狀態的資訊，并且允許其他觀察者注冊監聽宿主的生命周期狀態變化，這就使得我們不用主動去獲取宿主的狀態，有利于降低代碼耦合度并更容易維護，Lifecycle是JetPack組件庫的核心基礎，很多其他的Jetpack組件，比如LiveData、ViewMoedel等，都是基于它實作的，
1.1 Lifecycle基本使用
?Lifecycle的使用非常簡單，主要分為以下三步：
（1）添加依賴，直接匯入androidx庫即可；
android {
...
compileOptions {
sourceCompatibility JavaVersion.VERSION_1_8
targetCompatibility JavaVersion.VERSION_1_8
}
kotlinOptions {
jvmTarget = '1.8'
}
}
dependencies {
implementation 'androidx.appcompat:appcompat:1.2.0'
// 如果需要支持 Java8 的組件，需要引入 lifecycle:common-java8
// DefaultLifecycleObserver需要Java8
implementation "android.arch.lifecycle:common-java8:1.1.1"
}
注：如果觀察者使用繼承DefaultLifecycleObserver方式，則需要Java8支持，
（2）實作一個觀察者；
?創建一個觀察者Observer主要有三種實作方式，即LifecycleObserver、LifecycleEventObserver和DefaultLifecycleObserver，其中，后兩者均繼承于LifecycleObserver，它是一個空的介面，如果直接繼承這個介面，將通過注解的方式實作監聽回呼，但相比注解方式，官方更推薦使用DefaultLifecycleObserver，該介面也允許我們選擇性的實作對應的回呼方法，注意，它需要Java8支持，
class MyLifecycleObserver: DefaultLifecycleObserver {
override fun onStart(owner: LifecycleOwner) {
super.onStart(owner)
Log.i("LifecycleObserver", "I'm observer, activity now in--->onStart")
}
override fun onStop(owner: LifecycleOwner) {
super.onStop(owner)
Log.i("LifecycleObserver", "I'm observer, activity now in--->onStop")
}
}
（3）注冊觀察者；
?為了實作對宿主生命周期狀態的監聽，我們需要將一個觀察者物件注冊到宿主中，這個程序主要是通過獲取宿主的Lifecycle物件，并呼叫它的addObserver()方法實作的，該方法的具體實作在LifecycleRegister中，這個類是Lifecycle的唯一實作類，以監聽Activity為例：
class StudyLifecycleActivity: AppCompatActivity() {
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
addLifecycleObserver()
}
private fun addLifecycleObserver() {
lifecycle.addObserver(MyLifecycleObserver())
}
}
?至此，當Activity的生命周期變化時，與其對應的觀察者方法將被回呼，
1.2 Lifecycle實戰案例
?為了加深對Lifecycle感知組件生命周期變化的理解，這里舉一個在開發中經常遇到的例子，即判斷APP是否顯示在前臺，本例需要結合Application的registerActivityLifecycleCallbacks()方法實作，該方法的作用是當Activity的生命周期發生變化時，其對應的方法就會被回呼，基于此，我們創建一個自定義組件，使其繼承于LifecycleOwner，并擁有Lifecycle.Event.ON_START和Lifecycle.Event.ON_STOP生命周期事件，分別表示APP的狀態處于前臺和后臺，該組件具體原始碼如下：
/**
* author: jiangdg
* date: 2021/1/8 2:35 PM
* description: 自定義宿主，擁有Start和Stop生命周期事件
*/
object AppStatusOwner: LifecycleOwner {
private val mLifecycleRegistry = LifecycleRegistry(this)
override fun getLifecycle(): Lifecycle = mLifecycleRegistry
fun init(application: Application) {
application.registerActivityLifecycleCallbacks(object : Application.ActivityLifecycleCallbacks {
private var activityFrontCount = 0
override fun onActivityStarted(activity: Activity) {
// 第一個activity置于前臺時
// 向外部發送Lifecycle.Event.ON_START事件，表示APP當前處于前臺
if (activityFrontCount == 0) {
mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_START)
}
activityFrontCount++
}
override fun onActivityStopped(activity: Activity) {
activityFrontCount--
// 當前沒有Activity置于前臺時
// 向外部發送Lifecycle.Event.ON_STOP事件，表示APP當前處于后臺
if (activityFrontCount == 0) {
mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_STOP)
}
}
override fun onActivityPaused(activity: Activity) {
}
override fun onActivityDestroyed(activity: Activity) {
}
override fun onActivitySaveInstanceState(activity: Activity, outState: Bundle) {
}
override fun onActivityCreated(activity: Activity, savedInstanceState: Bundle?) {
}
override fun onActivityResumed(activity: Activity) {
}
})
}
}
?然后，我們通過繼承DefaultLifecycleObserver創建一個觀察者，并實作onStart、onStop方法，當onStart()方法被回呼時表明APP當前置于前臺，當onStop()方法被回呼時表明APP當前置于后臺，代碼如下：
/**
* author: jiangdg
* date: 2021/1/8 3:08 PM
* description: APP前后臺狀態觀察者
*/
class AppStatusObserver: DefaultLifecycleObserver {
override fun onStart(owner: LifecycleOwner) {
super.onStart(owner)
Log.i("AppStatusObserver", "APP置于前臺")
// 發送APP置于前臺廣播
}
override fun onStop(owner: LifecycleOwner) {
super.onStop(owner)
Log.i("AppStatusObserver", "APP置于后臺")
// 發送APP置于前臺廣播
}
}
?最后，在Application類中進行初始化操作，代碼如下：
class JetpackApplication: Application() {
override fun onCreate() {
super.onCreate()
// 啟動監聽所有Activity的狀態變化
AppStatusOwner.init(this)
// 注冊觀察者到宿主
AppStatusOwner.lifecycle.addObserver(AppStatusObserver())
}
}
2. Lifecycle實作原理
2.1 Lifecycle框架模型
?Lifecycle框架類圖如下：
?從Lifecycle框架模型可知，該框架感知一個組件的生命周期狀態變化原理為：首先，讓一個組件(如Activity或Fragment)繼承LifecycleOwner介面，用以表明自己是一個擁有生命周期變化的組件(宿主)，同時重寫lifecycleOwner介面的getLifecycle()方法，該方法會回傳一個Lifecycle物件；然后，通過繼承LifecycleObserver介面實作一個觀察者，并呼叫Lifecycle物件的addObserver()方法進行注冊監聽，當宿主生命周期發生變化時宿主內部就會通過Lifecycle的唯一實作類LifecycleRegister將生命周期事件分發給所有觀察者；最后，觀察者與生命周期事件對應的方法將會被自動回呼， 類或介面具體說明如下：
- LifecycleOwner
?LifecycleOwner是一個介面，它用于表明一個類是能夠提供生命周期事件的宿主，Activity和Fragment均實作了LifecycleOwner，并重寫了LifecycleOwner的getLifecycle()方法，該方法回傳一個Lifecycle物件，當然，任何類均可以實作LifecycleOwner，表示該類是一個能夠提供生命周期事件的宿主，LifecycleOwner原始碼如下：
public interface LifecycleOwner {
@NonNull
Lifecycle getLifecycle();
}
- Lifecycle
?Lifecycle是一個抽象類，用于存盤有關組件(或稱宿主，比如Activity/Fragment)的生命周期狀態的資訊，并允許其他物件觀察此狀態，Lifecycle使用兩種主要列舉跟蹤其關聯宿主的生命周期狀態，即事件和狀態，其中，事件為宿主的生命周期事件，而狀態為Lifecycle物件跟蹤的宿主的當前狀態，不同的事件可能對應相同的狀態，Lifecycle原始碼如下：
public abstract class Lifecycle {
// 注冊生命周期事件觀察者
// 所有的觀察者為LifecycleObserver或其子類
@MainThread
public abstract void addObserver(@NonNull LifecycleObserver observer);
// 移除生命周期事件觀察者
@MainThread
public abstract void removeObserver(@NonNull LifecycleObserver observer);
// 獲取Lifecycle當前的狀態
@MainThread
@NonNull
public abstract State getCurrentState();
// 宿主生命周期
// 比如ON_CREATE即為生命周期onCreate
public enum Event {
ON_CREATE,
ON_START,
ON_RESUME,
ON_PAUSE,
ON_STOP,
ON_DESTROY,
ON_ANY
}
// 宿主的狀態型別
// 比如CREATED狀態對應于宿主生命周期為onCreate/onStop
@SuppressWarnings("WeakerAccess")
public enum State {
DESTROYED,
INITIALIZED,
CREATED,
STARTED,
RESUMED;
public boolean isAtLeast(@NonNull State state) {
return compareTo(state) >= 0;
}
}
}
- LifecycleRegister
?LifecycleRegister是Lifecycle的唯一實作類，主要用來負責注冊Observer(觀察者)，以及分發宿主狀態事件給這些觀察者，LifecycleRegister維護著一個Map集合，該集合存盤了已注冊的觀察者以及它們當前的狀態，同時維護一個State物件表示當前宿主的狀態，從LifecycleRegister的構造方法可以看出，宿主的初始狀態為INITIALIZED，LifecycleRegister原始碼如下：
public class LifecycleRegistry extends Lifecycle {
// Observer串列
// ObserverWithState包裝了要注冊的Observer及其當前狀態
private FastSafeIterableMap<LifecycleObserver, ObserverWithState> mObserverMap =
new FastSafeIterableMap<>();
// 宿主當前狀態
private State mState
public LifecycleRegistry(@NonNull LifecycleOwner provider) {
mLifecycleOwner = new WeakReference<>(provider);
// 初始狀態INITIALIZED
mState = INITIALIZED;
}
// 注冊Observer
@Override
public void addObserver(@NonNull LifecycleObserver observer) {
...
}
// 移除Observer
@Override
public void removeObserver(@NonNull LifecycleObserver observer) {
mObserverMap.remove(observer);
}
...
}
- LifecycleObserver
?LifecycleObserver是一個介面，用于宣告一個類為Lifecycle的觀察者，LifecycleObserver是一個空的介面，通常我們使用注解或它的實作類，比如LifecycleEventObserver、DefaultLifecycleObserver等，來監聽宿主lifecycle的變化，原始碼如下：
// LifecycleObserver類
public interface LifecycleObserver {
}
// LifecycleEventObserver類
public interface LifecycleEventObserver extends LifecycleObserver {
/**
* 當宿主生命周期事件變化時，該方法被回呼
*
* @param 宿主，即被觀察的物件
* @param event 生命周期事件
*/
void onStateChanged(@NonNull LifecycleOwner source, @NonNull Lifecycle.Event event);
}
// DefaultLifecycleObserver類
// 當使用Java 8時，推薦使用它
public interface DefaultLifecycleObserver extends FullLifecycleObserver {
/**
* 當宿主的生命周期事件為ON_CREATE時
* 該方法被回呼
*
* @param owner 宿主，即被觀察的物件
*/
@Override
default void onCreate(@NonNull LifecycleOwner owner) {
}
...
}
2.2 Lifecycle狀態模型
?Lifecycle狀態模型描述了宿主生命周期與宿主狀態之間的關系，簡單來說，就是指當宿主的生命周期變化時，它處于哪一種狀態，總共有五種狀態：INITIALIZED、CREATED、STARTED、RESUMED、DESTROYED，LifecycleRegistry在分發事件時依賴這兩種之間的關系，宿主生命周期與宿主狀態模型圖如下：
2.3 原始碼分析
2.3.1 Fragment實作Lifecycle原理
// androidx.fragment.app.Fragment
public class Fragment implements LifecycleOwner,..
{
LifecycleRegistry mLifecycleRegistry;
@Override
@NonNull
public Lifecycle getLifecycle() {
return mLifecycleRegistry;
}
private void initLifecycle() {
mLifecycleRegistry = new LifecycleRegistry(this);
mSavedStateRegistryController = SavedStateRegistryController.create(this);
}
void performCreate(Bundle savedInstanceState) {
// 設定Fragment當前狀態為CREATED
mState = CREATED;
onCreate(savedInstanceState);
...
// 分發Fragment的生命周期onCreate
mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_CREATE);
}
void performActivityCreated(Bundle savedInstanceState) {
// 設定Fragment當前狀為ACTIVITY_CREATED
// 沒有分發生命周期
mState = ACTIVITY_CREATED;
...
onActivityCreated(savedInstanceState);
}
void performStart() {
mState = STARTED;
onStart();
...
mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_START);
}
void performResume() {
mState = RESUMED;
onResume();
...
mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_RESUME);
}
void performPause() {
mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_PAUSE);
mState = STARTED;
...
onPause();
}
void performStop() {
mState = ACTIVITY_CREATED;
mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_STOP);
...
onStop();
}
void performDestroyView() {
// 設定Fragment當前狀為CREATED
// 沒有分發生命周期
mState = CREATED;
...
onDestroyView();
}
void performDestroy() {
mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_DESTROY);
mState = INITIALIZING;
...
onDestroy();
}
}
?從Fragment原始碼可知，它通過繼承于LifecycleOwner介面，表明自己是一個擁有生命周期變化的組件，并實作該介面的getLifecycle()方法，該方法回傳一個Lifecycle物件，實際上回傳的是Lifecycle的唯一子類LifecycleRegistry，當Fragment的生命周期狀態變化時，Fragment會更新自己的狀態State，并通過LifecycleRegistry向外界(所有觀察者)分發對應的生命周期事件，
2.3.2 Activity實作Lifecycler原理
// AppcompatActivity父類
public class ComponentActivity implements LifecycleOwner...{
private final LifecycleRegistry mLifecycleRegistry = new LifecycleRegistry(this);
@Override
protected void onCreate(@Nullable Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
mSavedStateRegistryController.performRestore(savedInstanceState);
// 將ReportFragment添加到Activity中
ReportFragment.injectIfNeededIn(this);
if (mContentLayoutId != 0) {
setContentView(mContentLayoutId);
}
}
@NonNull
@Override
public Lifecycle getLifecycle() {
return mLifecycleRegistry;
}
...
}
// ReportFragment
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 onActivityCreated(Bundle savedInstanceState) {
super.onActivityCreated(savedInstanceState);
dispatchCreate(mProcessListener);
dispatch(Lifecycle.Event.ON_CREATE);
}
@Override
public void onStart() {
super.onStart();
dispatchStart(mProcessListener);
dispatch(Lifecycle.Event.ON_START);
}
@Override
public void onResume() {
super.onResume();
dispatchResume(mProcessListener);
dispatch(Lifecycle.Event.ON_RESUME);
}
...
private void dispatch(Lifecycle.Event event) {
Activity activity = getActivity();
// 呼叫LifecycleRegistry的handleLifecycleEvent方法
// 向外分發生命周期變化事件
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);
}
}
}
}
?從上述原始碼可知，Activity實作Lifecycle需要借助于ReportFragment往Activity上添加一個 fragment 用以報告生命周期的變化，目的是為了兼顧不是繼承自 AppCompactActivity的場景，同時也支持我們自定義LifecycleOwner的場景，假如我們自定義一個繼承于android.app.Activity的Activity需要實作Lifecycle，就需要借助于ReportFragment來實作，示例代碼如下：
class StudyLifecycleActivity2: Activity(), LifecycleOwner {
private val mLifecycleRegistry = LifecycleRegistry(this)
// 回傳一個LifecycleRegistry物件
override fun getLifecycle(): Lifecycle = mLifecycleRegistry
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
// 添加ReportFragment到Activity
ReportFragment.injectIfNeededIn(this)
// 注冊觀察者
addLifecycleObserver()
}
private fun addLifecycleObserver() {
lifecycle.addObserver(MyLifecycleObserver())
}
}
2.3.3 事件分發程序
?Lifecycle事件分發時序圖：
?從Fragment和Activity實作Lifecycle原理可知，當宿主的生命周期發生變化時，就會通過呼叫LifecycleRegistry的handleLifecycleEvent()方法向外分發生命周期變化事件，該方法原始碼如下：
public void handleLifecycleEvent(@NonNull Lifecycle.Event event) {
// （1）獲取宿主當前生命周期事件對應的狀態
State next = getStateAfter(event);
// （2）進入事件分發流程
moveToState(next);
}
?事件分發具體程序如下：
?（1）呼叫getStateAfter()方法獲取當前生命周期事件對應的狀態；
static State getStateAfter(Event event) {
switch (event) {
case ON_CREATE:
case ON_STOP:
return CREATED;
case ON_START:
case ON_PAUSE:
return STARTED;
case ON_RESUME:
return RESUMED;
case ON_DESTROY:
return DESTROYED;
case ON_ANY:
break;
}
throw new IllegalArgumentException("Unexpected event value " + event);
}
?（2）呼叫moveToState更新宿主的狀態mState，然后呼叫sync方法通過比對宿主當前的狀態和觀察者之前保存的狀態，完成觀察者狀態同步和事件分發，在sync方法中，首先會呼叫isSynced()方法判斷是否需要同步觀察者的狀態；然后再判斷當前事件的狀態如果小于mObserverMap集合中最先添加的觀察者狀態，說明宿主的狀態發生了回退，比如之前是RESUMED狀態，執行了onPause()則回退到STARTED狀態，此時就會呼叫backwardPass()方法把集合中的每一個觀察者分發一個ON_PAUSE事件，并同步該觀察者的狀態，同理，如果當前事件宿主狀態大于mObserverMap集合最近添加的觀察者狀態，說明宿主的狀態發生了前進，此時就好呼叫forwardPass()分發事件，并同步該觀察者狀態，相關原始碼如下：
private void sync() {
...
while (!isSynced()) {
mNewEventOccurred = false;
// 宿主狀態回退
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);
}
}
mNewEventOccurred = false;
}
?在backwardPass()和forwardPass()方法中，它們均會去遍歷mObserverMap集合，獲取與觀察者關聯的ObserverWithState物件，該物件存盤了觀察者及其狀態，然后，判斷這些Observer的狀態State是否滿足要求，如果滿足，則呼叫dispatchEvent()方法同步觀察者的狀態，同時呼叫觀察者的onStateChanged()方法完成宿主生命周期變化事件的分發，ObserverWithState原始碼如下：
static class ObserverWithState {
State mState;
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);
// 分發生命周期變化事件
// 注：這里表明了無論我們使用哪種方式實作觀察者
// Lifecycle原始碼中最終將統一轉換為LifecycleEventObserver
// 即通過它來完成最終的事件分發，以便統一分發形式
mLifecycleObserver.onStateChanged(owner, event);
mState = newState;
}
}
2.3.4 觀察者注冊程序
?Lifecycle注冊觀察者時序圖：
?從上述時序圖可知，Lifecycle的觀察者注冊是從呼叫LifecycleRegistry的addObserver()方法開始的，該方法首先會根據宿主當前的狀態為新添加的觀察者設定一個初始狀態，只要不是在onDestory方法中注冊，那么觀察者的初始狀態為INITIALIZED；然后將observer包裝成ObserverWithState，并添加到mObserverMap集合中；最后就是一個while回圈，即不斷拿觀察者的狀態與宿主當前狀態作比較以判斷是否對齊，如果沒有則向觀察者分發對應的事件，同時更新觀察者的狀態，直到兩者的狀態一致，addObserver方法原始碼如下：
@Override
public void addObserver(@NonNull LifecycleObserver observer) {
// 指定新添加觀察者的初始狀態
// 只要不在onDestory方法中注冊，初始狀態為INITIALIZED
State initialState = mState == DESTROYED ? DESTROYED : INITIALIZED;
// 將observer包裝成ObserverWithState，它存盤了觀察者及其狀態
// 使用ObserverWithState的目的就是方便在分發事件時作狀態對比
ObserverWithState statefulObserver = new ObserverWithState(observer, initialState);
// 將ObserverWithState添加到集合
// 如果之前已經添加，則return
ObserverWithState previous = mObserverMap.putIfAbsent(observer, statefulObserver);
if (previous != null) {
return;
}
LifecycleOwner lifecycleOwner = mLifecycleOwner.get();
if (lifecycleOwner == null) {
return;
}
boolean isReentrance = mAddingObserverCounter != 0 || mHandlingEvent;
// 同步觀察者的狀態，舉個例子：
//假設是在宿主的onresume犯法內注冊的該觀察者
//第一次：分發on_Create事件，觀察者狀態INIT->CREATED
//第二次：分發on_Start事件，觀察者狀態CREATED->STARTED
//第三次：分發on_Resume事件，觀察者狀態STARTED->RESUMED
State targetState = calculateTargetState(observer);
mAddingObserverCounter++;
while ((statefulObserver.mState.compareTo(targetState) < 0
&& mObserverMap.contains(observer))) {
pushParentState(statefulObserver.mState);
// 分發事件
statefulObserver.dispatchEvent(lifecycleOwner, upEvent(statefulObserver.mState));
popParentState();
// 再一次計算觀察的狀態是否與宿主一致
targetState = calculateTargetState(observer);
}
if (!isReentrance) {
// we do sync only on the top level.
sync();
}
mAddingObserverCounter--;
}
Github原始碼：ExampleJetpack
轉載請註明出處，本文鏈接：https://www.uj5u.com/qita/247603.html
標籤：AI