Android LiveData使用

文章目錄

• Jetpack LiveData
• • 概述
  • API說明
  • LiveData使用
  • • 基本使用
    • Transformations#map() 資料修改
    • Transformations#switchMap() 資料切換
    • MediatorLiveData#addSource() 觀察多個資料

Jetpack LiveData

概述

LiveData是一種可觀察到資料存儲器類，LiveData具有感覺生命周期的能力，確定LiveData僅更新處于活躍生命周期狀态的觀察者。

優點：

• 確定界面符合資料狀态，當生命周期狀态變化時，LiveData通知Observer，可以在observer中更新界面。觀察者可以在生命周期狀态更改時重新整理界面，而不是在每次資料變化時重新整理界面。
• 不會發生記憶體洩漏，observer會在LifecycleOwner狀态變為DESTROYED後自動remove。
• 不會因 Activity 停止而導緻崩潰，如果LifecycleOwner生命周期處于非活躍狀态，則它不會接收任何 LiveData事件。
• 不需要手動解除觀察，開發者不需要在onPause或onDestroy方法中解除對LiveData的觀察，因為LiveData能感覺生命周期狀态變化，是以會自動管理所有這些操作。
• 資料始終保持最新狀态，資料更新時 若LifecycleOwner為非活躍狀态，那麼會在變為活躍時接收最新資料。例如，曾經在背景的 Activity 會在傳回前台後，observer立即接收最新的資料。

API說明

setValue() 主線程更新資料
postValue() 子線程更新資料
observe() 添加觀察者
onChanged() 接收資料
           

LiveData使用

基本使用

public class MainActivity extends AppCompatActivity {
    private final String TAG = "TAG";

    private MutableLiveData<String> liveData;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        liveData = new MutableLiveData<>();
        liveData.observe(this, new Observer<String>() {
            @Override
            public void onChanged(String s) {
                Log.e(TAG, "onChanged: " + s);
            }
        });

        Log.e(TAG, "onCreate()");
        liveData.setValue("onCreate"); //非活動狀态，不會調用onChanged()
    }

    @Override
    protected void onStart() {
        super.onStart();
        Log.e(TAG, "onStart()");
        liveData.setValue("onStart"); //活動狀态，會調用onChanged()
    }

    @Override
    protected void onResume() {
        super.onResume();
        Log.e(TAG, "onResume");
        liveData.setValue("onResume"); //活動狀态，會調用onChanged()
    }

    @Override
    protected void onPause() {
        super.onPause();
        Log.e(TAG, "onPause()");
        liveData.setValue("onPause"); //活動狀态，會調用onChanged()
    }

    @Override
    protected void onStop() {
        super.onStop();
        Log.e(TAG, "onStop()");
        liveData.setValue("onStop"); //非活動狀态，不會調用onChanged()
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
        Log.e(TAG, "onDestroy()");
        liveData.setValue("onDestroy"); //非活動狀态，不會調用onChanged()
    }
}
           

Transformations#map() 資料修改

MutableLiveData<String> liveData = new MutableLiveData<>();
LiveData<String> liveDataMap = Transformations.map(liveData, new Function<String, String>() {
    @Override
    public String apply(String input) {
        String str = input + " LiveData";
        Log.e(TAG, "apply: " + str);
        return str;
    }
});

liveDataMap.observe(this, new Observer<String>() {
    @Override
    public void onChanged(String s) {
        Log.e(TAG, "onChanged: " + s);
    }
});

liveData.setValue("hello");
           

apply: hello LiveData
onChanged: hello LiveData
           

Transformations#switchMap() 資料切換

根據判斷條件切換不同的LiveData

MutableLiveData<String> liveData1 = new MutableLiveData<>();
MutableLiveData<String> liveData2 = new MutableLiveData<>();
//切換LiveData的條件
MutableLiveData<Boolean> switchLiveData = new MutableLiveData<>();

LiveData<String> resultLiveData = Transformations.switchMap(switchLiveData, new Function<Boolean, LiveData<String>>() {
    @Override
    public LiveData<String> apply(Boolean input) {
        //判斷使用哪一個LiveData
        if (input) {
            return liveData1;
        } else {
            return liveData2;
        }
    }
});

resultLiveData.observe(this, new Observer<String>() {
    @Override
    public void onChanged(String s) {
        Log.e(TAG, "onChanged: " + s);
    }
});

switchLiveData.postValue(true);
liveData1.postValue("ABC");
liveData2.postValue("123");
           

onChanged: ABC
           

MediatorLiveData#addSource() 觀察多個資料

MutableLiveData<String> liveData1 = new MutableLiveData<>();
MutableLiveData<String> liveData2 = new MutableLiveData<>();
MediatorLiveData<String> mediatorLiveData = new MediatorLiveData<>();

mediatorLiveData.addSource(liveData1, new Observer<String>() {
    @Override
    public void onChanged(String s) {
        Log.e(TAG, "onChanged liveData1: " + s);
        mediatorLiveData.setValue(s);
    }
});

mediatorLiveData.addSource(liveData2, new Observer<String>() {
    @Override
    public void onChanged(String s) {
        Log.e(TAG, "onChanged liveData2: " + s);
        mediatorLiveData.setValue(s);
    }
});

mediatorLiveData.observe(this, new Observer<String>() {
    @Override
    public void onChanged(String s) {
        Log.e(TAG, "onChanged: " + s);
    }
});

liveData1.setValue("ABC");
//liveData2.setValue("123");
           

onChanged liveData1: ABC
onChanged: ABC