简单使用案例：
MainActivity：
viewModel.getMessageObserver().observe(this, new Observer() {
@Override
public void onChanged(@Nullable MessageBean messageBean) {
if (messageBean != null) {
LogUtils.d(messageBean.toString());
}
}
});
MessageViewModel：
public class MessageViewModel extends ViewModel {
private final MutableLiveData mMessageObserver = new MutableLiveData<>();
public LiveData getMessageObserver() {
return mMessageObserver ;
}
public void setHoroscopeId(int horoscopeId) {
List characters = new ArrayList<>();
characters.add(new MessageBean("body1"));
characters.add(new MessageBean("body2"));
characters.add(new MessageBean("body3"));
characters.add(new MessageBean("body4"));
mMessageObserver.setValue(characters.get(horoscopeId));
}
public void getProjectList() {
DataRepository.getInstance().getProjectList(mMessageObserver , "1", 294);
}
}
其中viewModel.getMessageObserver().observe(this, new Observer() )
中的this即SupportActivity ：LifecycleOwner
SupportActivity implements LifecycleOwner
public interface LifecycleOwner {
Lifecycle getLifecycle();
}
SupportActivity
public class SupportActivity extends Activity implements LifecycleOwner {
private LifecycleRegistry mLifecycleRegistry = new LifecycleRegistry(this);
@Override
protected void onCreate(@Nullable Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
ReportFragment.injectIfNeededIn(this);
}
@CallSuper
@Override
protected void onSaveInstanceState(Bundle outState) {
mLifecycleRegistry.markState(Lifecycle.State.CREATED);
super.onSaveInstanceState(outState);
}
@Override
public Lifecycle getLifecycle() {
return mLifecycleRegistry;
}
}
SupportActivity就是通过getLifecycle()获取 mLifecycleRegistry来标记当前Activity或Fragment的各种状态，其中ReportFragment.injectIfNeededIn(this)内部源码也是与mLifecycleRegistry.markState(Lifecycle.State.CREATED) 类似，状态的信息记录在mLifecycleRegistry对象内部。Activity的其他类型的事件如onCreate,onPause等都是通过getLifecycle()获取 mLifecycleRegistry对象调用mLifecycleRegistry内部方法来改变其状态的。
Fragment的状态更加容易看到，FragmentActivity即在Activity的生命周期中获取
FragmentActivity部分源码：
@Override
protected void onStop() {
super.onStop();
mStopped = true;
markState(getSupportFragmentManager(), Lifecycle.State.CREATED);
mHandler.sendEmptyMessage(MSG_REALLY_STOPPED);
mFragments.dispatchStop();
}
private static void markState(FragmentManager manager, Lifecycle.State state) {
Collection fragments = manager.getFragments();
for (Fragment fragment : fragments) {
if (fragment == null) {
continue;
}
fragment.mLifecycleRegistry.markState(state);
markState(fragment.getChildFragmentManager(), state);
}
}
通过上面的简单分析，两个重要的类即 LifecycleRegistry extends Lifecycle：
下面是Lifecycle抽象类：
public abstract class Lifecycle {
@MainThread
public abstract void addObserver(@NonNull LifecycleObserver observer);
@MainThread
public abstract void removeObserver(@NonNull LifecycleObserver observer);
@MainThread
public abstract State getCurrentState();
public enum Event {
ON_CREATE,
ON_START,
ON_RESUME,
ON_PAUSE,
ON_STOP,
ON_DESTROY,
ON_ANY
}
public enum State {
DESTROYED,
INITIALIZED,
CREATED,
STARTED,
RESUMED;
public boolean isAtLeast(@NonNull State state) {
return compareTo(state) >= 0;
}
}
}
回到开始的案例：
LiveData.observe(this, new Observer);
public void observe(@NonNull LifecycleOwner owner, @NonNull Observer observer) {
if (owner.getLifecycle().getCurrentState() == DESTROYED) {
// ignore
return;
}
// 经典的装饰器模式，这里的设计很精妙，可以看出我们传入的Observer和 owner.getLifecycle().addObserver()是不同的。
LifecycleBoundObserver wrapper = new LifecycleBoundObserver(owner, observer);
// 判断是否已经添加过防止重复添加
LifecycleBoundObserver existing = mObservers.putIfAbsent(observer, wrapper);
if (existing != null && existing.owner != wrapper.owner) {
throw new IllegalArgumentException("Cannot add the same observer"
+ " with different lifecycles");
}
if (existing != null) {
return;
}
owner.getLifecycle().addObserver(wrapper);
}
这里我们传入的Observer和 owner.getLifecycle().addObserver()即 Activity中的Lifecycle 是不同的。
我们上面已经知道Activity中的Lifecycle是与生命周期相关的，通过Lifecycle.addObserver()可以监听到 Activity的生命周期 然后在LifecycleBoundObserver作出
相应的处理，具体的实现在LifecycleRegistry.addObserver中(Lifecycle实现类)，最终会根据事件变化调用 mLifecycleObserver.onStateChanged(owner, event)，
class LifecycleBoundObserver implements GenericLifecycleObserver {
public final LifecycleOwner owner;
public final Observer observer;
LifecycleBoundObserver(LifecycleOwner owner, Observer observer) {
this.owner = owner;
this.observer = observer;
}
@Override
public void onStateChanged(LifecycleOwner source, Lifecycle.Event event) {
// 此处在组件如Activity onDestroy的时候自动移除观察者。
if (owner.getLifecycle().getCurrentState() == DESTROYED) {
removeObserver(observer);
return;
}
// immediately set active state, so we'd never dispatch anything to inactive
// owner
activeStateChanged(isActiveState(owner.getLifecycle().getCurrentState()));
}
}
LifecycleBoundObserver.onStateChanged -> activeStateChanged -> dispatchingValue -> considerNotify(initiator) -> observer.observer.onChanged((T) mData);
最终调用的是我们传入的observer。
这样看来 LiveData
public abstract class LiveData {
private static final Object NOT_SET = new Object();
// LiveData 存取的值，即T， setValue，postValue 会强制转换为T。
private volatile Object mData = NOT_SET;
}
https://developer.android.com/reference/android/arch/lifecycle/Lifecycle