LifeCycles

使用时候层次：「User的Activity」-》【中间BaseActivity】--> AppCompatActivity--》FragmentActivity --》 ComponentActivity

观察者模式

我们可以加上任意对象观察Activity声明周期

getLifecycle().addObserver(presenter);
//----> getLifecycle().addObserver(任意一个我们想要加入的观察);

getLifecycle()返回这个类
  LifecycleRegistry ----》
    public LifecycleRegistry(@NonNull LifecycleOwner provider) {
        mLifecycleOwner = new WeakReference<>(provider);
        mState = INITIALIZED;
    }

addObserver（xxxx） 的运行时实现
          State initialState = mState == DESTROYED ? DESTROYED : INITIALIZED;
        ObserverWithState statefulObserver = new ObserverWithState(observer, initialState);

一开始一定是 INITIALIZED 状态

ComponentActivity

public class ComponentActivity extends androidx.core.app.ComponentActivity implements
        LifecycleOwner,
        ViewModelStoreOwner,
        HasDefaultViewModelProviderFactory,
        SavedStateRegistryOwner,
        OnBackPressedDispatcherOwner {

SavedStateRegistryOwner extends LifecycleOwner

所以有事后用了这两个类，注意

@Override
protected void onCreate(@Nullable Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    mSavedStateRegistryController.performRestore(savedInstanceState);
    ReportFragment.injectIfNeededIn(this);
    if (mContentLayoutId != 0) {
        setContentView(mContentLayoutId);
    }
}

这段代码的意思是，在Activity里面 ReportFragment.injectIfNeededIn(this); 注入，生成一个看不见的fragment在上面

有一个变量全程在记录Ativity 的声明周期状态

ReportFragment -->各种声明周期调用dispatch（）进行各种事件的分发

-- >handleLifecycleEvent ---> 「String next= getStateAfter」

----> moveToState()---> sync()

「目的是将状态正向推，或者反向推，和Activity的当前状态保持一致」

---> backwardPass 或者 forwardPass

----> mLifecycleObserver.onStateChanged---->「很多实现CompositeGeneratedAdaptersObserver ,FullLifecycleObserverAdapter ,SingleGeneratedAdapterObserver , ReflectiveGenericLifecycleObserver」

所有实现最终会走到 ReflectiveGenericLifecycleObserver ===》

ReflectiveGenericLifecycleObserver 构造方法，通过反射拿到带有OnLifecycleEvent注解的方法

LiveData

LiveData 不会单独使用，一般会和ViewModel一起用，封装集成ViewModel 提供返回数据的方法返回LiveData<T>

viewModel.getLiveData<T>.observe(xxxx, 实现)；

LiveData 的逻辑结构是这个样子的观察者和被观察者

【被观察者】<--------【LiveData--- mVersion】<----------【其他观察者1---mLastVersion】

<-----------【其他观察者n----mLasteVersion】

observe 方法里面有这样两句话

LifecycleBoundObserver wrapper = new LifecycleBoundObserver(owner, observer);
ObserverWrapper existing = mObservers.putIfAbsent(observer, wrapper);

putIfAbsent----> 从SafeIterableMap 拿观察者，如果有拿着用没有就放进去观察者

LiveData 的设置 setValue 查看他的机构 mVersion，

分发数据

dispatchingValue（null）

默认是null情况去循环迭代拿观察者，进行通知

considerNotify(ObserverWrapper observer)

同步 activity Livecycles 的状态 mLastversion = mVersion 更新消息

然后回调到哦们的onChange

补充：查看一下 LiveData 的postValue 方法：他是在子线程的

ArchTaskExecutor.getInstance().postToMainThread(mPostValueRunnable);

用了一个线程池，会帮助你从子线程切换到主线程上去

LiveData 封装成 bus集合

通常我们项目中不可能到处用LiveData，我们用一个数组总线的方式控制

简单实现，开源有实现

public class LiveDataBus {
    //存放订阅者
    private Map<String, MutableLiveData<Object>> bus;
    private static LiveDataBus liveDataBus = new LiveDataBus();

    private LiveDataBus() {
        bus = new HashMap();
    }
    public static LiveDataBus getInstance() {
        return liveDataBus;
    }
    //注册订阅者
    public synchronized <T> MutableLiveData<T> with(String key, Class<T> type) {
        if(!bus.containsKey(key)){
            bus.put(key,new MutableLiveData<Object>());
        }
        return (MutableLiveData<T>)bus.get(key);
    }
}

LifeCycles

LiveData

LiveData 封装 成 bus集合

LiveData 封装成 bus集合