Android Jetpack 之 LiveData

安卓開發 · 發表 2018-11-29 10:24:51

摘要： LiveData 是一個持有資料的類，它持有的資料是可以被觀察者訂閱的，當資料被修改時就會通知觀察者。觀察者可以是 Activity、Fragment、Service 等。 LiveData 能夠感知觀察者的生命週期，只有當觀察者處於啟用狀態（STARTED、RESUMED）...

LiveData 是一個持有資料的類，它持有的資料是可以被觀察者訂閱的，當資料被修改時就會通知觀察者。觀察者可以是 Activity、Fragment、Service 等。
LiveData 能夠感知觀察者的生命週期，只有當觀察者處於啟用狀態（STARTED、RESUMED）才會接收到資料更新的通知，在未啟用時會自動解註冊觀察者，以減少記憶體洩漏。
使用 LiveData 儲存資料時，由於資料和元件是分離的，當元件重建時可以保證資料不會丟失。

優點

確保 UI 介面始終和資料狀態保持一致。
沒有記憶體洩漏，觀察者繫結到 Lifecycle 物件並在其相關生命週期 destroyed 後自行解除繫結。
不會因為 Activity 停止了而奔潰，如 Activity finish 了，它就不會收到任何 LiveData 事件了。
UI 元件只需觀察相關資料，不需要停止或恢復觀察，LiveData 會自動管理這些操作，因為 LiveData 可以感知生命週期狀態的更改。
在生命週期從非啟用狀態變為啟用狀態，始終保持最新資料，如後臺 Activity 在返回到前臺後可以立即收到最新資料。
當配置發生更改（如螢幕旋轉）而重建 Activity / Fragment，它會立即收到最新的可用資料。
LiveData 很適合用於元件（Activity / Fragment）之間的通訊。

使用

ofollow,noindex">新增相關依賴

LiveData 有兩種使用方式，結合 ViewModel 使用以及直接繼承 LiveData 類。

結合 ViewModel 使用

以下程式碼場景：點選按鈕提示一個名字。

class MyViewModel : ViewModel() {

// 建立一個 String 型別的 LiveData
// MutableLiveData 是抽象類 LiveData 的子類，我們一般使用的是 MutableLiveData
private lateinit var name: MutableLiveData<String>

fun getName(): MutableLiveData<String> {
if (!::name.isInitialized) {
name = MutableLiveData()
}
return name
}
}
複製程式碼

class LiveDataActivity : AppCompatActivity() {

private lateinit var myViewModel: MyViewModel

override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_live_data)

// 建立並註冊觀察者
myViewModel = ViewModelProviders.of(this).get(MyViewModel::class.java)
myViewModel.getName().observe(this, Observer {
// LiveData 資料更新回撥，it 代表被觀察物件的資料，此處為 name
Toast.makeText(baseContext, it, Toast.LENGTH_SHORT).show()
})

btnSetName.setOnClickListener {
// 使用 setValue 的方式更新 LiveData 資料
myViewModel.getName().value = "張三"
}
}
}
複製程式碼

讓資料（name）和元件（LiveDataActivity）分離，當 Activity 重建時，資料（name）不會丟失。

直接繼承 LiveData 類

以下程式碼場景：在 Activity 中監聽 Wifi 訊號強度。

class WifiLiveData private constructor(context: Context) : LiveData<Int>() {

private var mContext: WeakReference<Context> = WeakReference(context)

companion object {

private var instance: WifiLiveData? = null

fun getInstance(context: Context): WifiLiveData {
if (instance == null) {
instance = WifiLiveData(context)
}
return instance!!
}
}

override fun onActive() {
super.onActive()
registerReceiver()
}

override fun onInactive() {
super.onInactive()
unregisterReceiver()
}

/**
* 註冊廣播，監聽 Wifi 訊號強度
*/
private fun registerReceiver() {
val intentFilter = IntentFilter()
intentFilter.addAction(WifiManager.RSSI_CHANGED_ACTION)
mContext.get()!!.registerReceiver(mReceiver, intentFilter)
}

/**
* 登出廣播
*/
private fun unregisterReceiver() {
mContext.get()!!.unregisterReceiver(mReceiver)
}

private val mReceiver = object : BroadcastReceiver() {

override fun onReceive(context: Context?, intent: Intent) {
when (intent.action) {
WifiManager.RSSI_CHANGED_ACTION -> getWifiLevel()
}
}
}

private fun getWifiLevel() {
val wifiManager = mContext.get()!!.applicationContext.getSystemService(android.content.Context.WIFI_SERVICE) as WifiManager
val wifiInfo = wifiManager.connectionInfo
val level = wifiInfo.rssi

instance!!.value = level // 傳送 Wifi 的訊號強度給觀察者
}
}
複製程式碼

class LiveDataActivity : AppCompatActivity() {

override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_live_data)

withExtendsLiveDataTest()
}

/**
* 直接繼承 LiveData 類
*/
private fun withExtendsLiveDataTest() {
WifiLiveData.getInstance(this).observe(this, Observer {
Log.e("LiveDataActivity", it.toString()) // 觀察者收到資料更新的通知，列印 Wifi 訊號強度
})
}
}
複製程式碼

當元件（Activity）處於啟用狀態（onActive）時註冊廣播，處於非啟用狀態時登出廣播（onInactive）。

原始碼解析

observe 註冊流程

LiveData 通過 observe() 方法將被觀察者 LifecycleOwner (Activity / Fragment) 和觀察者 Observer 關聯起來。

LiveData.observe(LifecycleOwner owner , Observer<T> observer)
複製程式碼

進入 LiveData 的 observe() 方法中

public void observe(@NonNull LifecycleOwner owner, @NonNull Observer<T> observer) {
if (owner.getLifecycle().getCurrentState() == DESTROYED) {
// 若 LifecycleOwner 處於 DESTROYED 狀態，則返回
return;
}

// LifecycleBoundObserver 把 LifecycleOwner 物件和 Observer 物件包裝在一起
LifecycleBoundObserver wrapper = new LifecycleBoundObserver(owner, observer);

// mObservers（類似 Map 的容器）的 putIfAbsent() 方法用於判斷容器中的 observer（key）
// 是否已有 wrapper（value）與之關聯
// 若已關聯則直接返回關聯值，否則關聯後再返回 wrapper
ObserverWrapper existing = mObservers.putIfAbsent(observer, wrapper);

if (existing != null && !existing.isAttachedTo(owner)) {
throw new IllegalArgumentException("Cannot add the same observer"
+ " with different lifecycles");
}
if (existing != null) {
return;
}

// 由於 LifecycleBoundObserver 實現了 GenericLifecycleObserver 介面，而 GenericLifecycleObserver 又
// 繼承了 LifecycleObserver，所以 LifecycleBoundObserver 本質是一個 LifecycleObserver
// 此處屬於註冊過程， Lifecycle 新增觀察者 LifecycleObserver
owner.getLifecycle().addObserver(wrapper);
}
複製程式碼

從上面的程式碼可知，observe() 方法最終是會呼叫LifecycleOwner.getLifecycle().addObserver(LifecycleObserver) ，因此 LiveData 是能夠感知觀察者的生命週期變化的。

感知生命週期變化

通過以上的分析，我們知道 LifecycleBoundObserver（LiveData 的內部類）是觀察者，以下具體分析 LifecycleBoundObserver 的實現過程。

class LifecycleBoundObserver extends ObserverWrapper implements GenericLifecycleObserver {
@NonNull final LifecycleOwner mOwner;

LifecycleBoundObserver(@NonNull LifecycleOwner owner, Observer<T> observer) {
super(observer); // 儲存 Observer
mOwner = owner;// 儲存 LifecycleOwner
}

@Override
boolean shouldBeActive() {
// 判斷是否處於啟用狀態
return mOwner.getLifecycle().getCurrentState().isAtLeast(STARTED);
}


@Override
public void onStateChanged(LifecycleOwner source, Lifecycle.Event event) {
// 若 Lifecycle 處於 DESTROYED 狀態，則移除 Observer 物件
if (mOwner.getLifecycle().getCurrentState() == DESTROYED) {
// 移除觀察者，在這個方法中會移除生命週期監聽並且回撥 activeStateChanged() 方法
removeObserver(mObserver);
return;
}
// 若處於啟用狀態，則呼叫 activeStateChanged() 方法
activeStateChanged(shouldBeActive());
}

@Override
boolean isAttachedTo(LifecycleOwner owner) {
return mOwner == owner;
}

@Override
void detachObserver() {
mOwner.getLifecycle().removeObserver(this);
}
}
複製程式碼

當元件（Activity / Fragment）的生命週期發生改變時，onStateChanged() 方法將會被呼叫。若當前處於 DESTROYED 狀態，則會移除觀察者；若當前處於啟用狀態，則會呼叫 activeStateChanged() 方法。activeStateChanged() 方法位於父類 ObserverWrapper 中。

void activeStateChanged(boolean newActive) {
// 若新舊狀態一致，則返回
if (newActive == mActive) {
return;
}
// immediately set active state, so we'd never dispatch anything to inactive owner
mActive = newActive;
boolean wasInactive = LiveData.this.mActiveCount == 0;
LiveData.this.mActiveCount += mActive ? 1 : -1;
if (wasInactive && mActive) { // 啟用狀態的 observer 個數從 0 到 1
onActive(); // 空實現，一般讓子類去重寫
}
if (LiveData.this.mActiveCount == 0 && !mActive) { // 啟用狀態的 observer 個數從 1 到 0
onInactive();// 空實現，一般讓子類去重寫
}
if (mActive) { // 啟用狀態，向觀察者傳送 LiveData 的值
dispatchingValue(this);
}
}
複製程式碼

再看看最終呼叫的 dispatchingValue() 方法。

private void dispatchingValue(@Nullable ObserverWrapper initiator) {
// ...
do {
mDispatchInvalidated = false;
if (initiator != null) {
considerNotify(initiator);
initiator = null;
} else {
// 迴圈遍歷 mObservers 這個 map , 向每一個觀察者都發送新的資料
for (Iterator<Map.Entry<Observer<T>, ObserverWrapper>> iterator =
mObservers.iteratorWithAdditions(); iterator.hasNext(); ) {
considerNotify(iterator.next().getValue());
if (mDispatchInvalidated) {
break;
}
}
}
} while (mDispatchInvalidated);
// ...
}
複製程式碼

可以看到 dispatchingValue() 方法裡面再通過 considerNotify() 方法將訊息通知下去。

private void considerNotify(ObserverWrapper observer) {
// ...
observer.mObserver.onChanged((T) mData);
}
複製程式碼

上面的 mObserver 正是我們呼叫 observe() 方法時傳入的觀察者。

總結上面的分析就是：呼叫 LiveData.observe(LifecycleOwner owner , Observer observer) 進行註冊後，當 LiveData 資料發生變化後，最終就會呼叫 Observer 物件的 onChanged() 方法，並把變化的資料作為引數回傳。

通知觀察者更新資料的方式

LiveData 為我們提供了兩種改變資料後，通知觀察者更新資料的方式，一個是 setValue() 方法（必須在主執行緒呼叫 ），另一個是 postValue() 方法（必須在子執行緒呼叫 ）。

setValue() 方法

@MainThread
protected void setValue(T value) {
assertMainThread("setValue");
mVersion++;
mData = value;
dispatchingValue(null);
}
複製程式碼

dispatchingValue() 方法會跑我們上面分析的流程，最終把改變的資料 value（對應上面的 mData）作為 onChanged() 方法的引數傳給觀察者。

postValue() 方法

protected void postValue(T value) {
boolean postTask;
synchronized (mDataLock) {
postTask = mPendingData == NOT_SET;
mPendingData = value;
}
if (!postTask) {
return;
}
ArchTaskExecutor.getInstance().postToMainThread(mPostValueRunnable);
}

private final Runnable mPostValueRunnable = new Runnable() {
@Override
public void run() {
Object newValue;
synchronized (mDataLock) {
newValue = mPendingData;
mPendingData = NOT_SET;
}
//noinspection unchecked
setValue((T) newValue);
}
};
複製程式碼

可以看出 postValue() 方法最終也會在主執行緒中呼叫 setValue() 方法。

AndroidJetpackDemo" rel="nofollow,noindex">文中 Demo GitHub 地址

參考資料：