Jetpack:LiveData

提莫队长

发布于 2020-06-03 10:16:53

5800

发布于 2020-06-03 10:16:53

文章被收录于专栏：刘晓杰刘晓杰

LiveData是一个可被观察的数据持有者类。与常规的Observable不同，LiveData能意识到应用程序组件的生命周期变化，这意味着它能遵守Activity、Fragment、Service等组件的生命周期

1.优点

(1)确保UI符合数据状态.LiveData遵循观察者模式.当生命周期状态改变时,LiveData会向Observer发出通知去更新UI. (2)没有内存泄漏.Observer会绑定具有生命周期的对象，并在这个绑定的对象被销毁后自行清理. (3)不需要手动处理生命周期.UI组件只需要去观察相关数据，不需要手动去停止或恢复观察。LiveData会进行自动管理这些事情，因为在观察时，它会感知到相应组件的生命周期变化。 (4)始终保持最新的数据.如果一个对象的生命周期变到非活跃状态，它将在再次变为活跃状态时接收最新的数据。例如，后台Activity在返回到前台后立即收到最新数据。

2.用法

(1)创建LiveData对象

public class UserModel extends ViewModel {
    private MutableLiveData<String> name;
    int age;

    public MutableLiveData<String> getName() {
        if (name == null) {
            name = new MutableLiveData<>();
            name.setValue("lalalala");
        }
        return name;
    }
}

(2)创建观察者并观察LiveData对象

        final UserModel model = ViewModelProviders.of(this).get(UserModel.class);

        final Observer<String> nameObserver = new Observer<String>() {
            @Override
            public void onChanged(@Nullable final String newName) {
                Log.e("text", newName);
            }
        };
        model.getName().observe(this, nameObserver);

(3)更新数据

        findViewById(R.id.test).setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                model.getName().setValue("hhhh");.//Log里面会显示hhhh
            }
        });

3.源码解析

public void observe(@NonNull LifecycleOwner owner, @NonNull Observer<T> observer) {
        LifecycleBoundObserver wrapper = new LifecycleBoundObserver(owner, observer);
        ......
        owner.getLifecycle().addObserver(wrapper);
    }

和Lifecycle相似 addObserver最终都会调用observer.dispatchEvent,都会响应mLifecycleObserver.onStateChanged(owner, event),而这个mLifecycleObserver就是LifecycleBoundObserver (顾名思义,就是和生命周期绑定的Observer)

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

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

        @Override
        boolean shouldBeActive() {
            return mOwner.getLifecycle().getCurrentState().isAtLeast(STARTED);
        }

        @Override
        public void onStateChanged(LifecycleOwner source, Lifecycle.Event event) {
            if (mOwner.getLifecycle().getCurrentState() == DESTROYED) {
                removeObserver(mObserver);
                return;
            }
            activeStateChanged(shouldBeActive());
            //这里调用dispatchingValue,里面会看到遍历Observer然后调用considerNotify
            //再里面就会看到observer.mObserver.onChanged((T) mData)
            //也就是nameObserver的onChanged方法
        }

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

        @Override
        void detachObserver() {
            mOwner.getLifecycle().removeObserver(this);
        }
    }