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