写点什么

“终于懂了“系列,android 直播面试题

用户头像
Android架构
关注
发布于: 11 小时前

@OnLifecycleEvent(value = Lifecycle.Event.ON_PAUSE)


public void disConnect(){


Log.i(TAG, "disConnect: ");


}


}


复制代码


首先 MyObserver 实现了接口 LifecycleObserver,LifecycleObserver 用于标记一个类是生命周期观察者。 然后在 connectListener()、disconnectListener()上 分别都加了 @OnLifecycleEvent 注解,且 value 分别是 Lifecycle.Event.ON_RESUME、Lifecycle.Event.ON_PAUSE,这个效果就是:connectListener()会在 ON_RESUME 时执行,disconnectListener()会在 ON_PAUSE 时执行。


我们打开 LifecycleTestActivity 然后退出,日志打印如下:


2020-11-09 17:25:40.601 4822-4822/com.hfy.androidlearning I/Lifecycle_Test: onCreate:


2020-11-09 17:25:40.605 4822-4822/com.hfy.androidlearning I/Lifecycle_Test: onResume:


2020-11-09 17:25:40.605 4822-4822/com.hfy.androidlearning I/Lifecycle_Test: connect:


2020-11-09 17:25:51.841 4822-4822/com.hfy.androidlearning I/Lifecycle_Test: disConnect:


2020-11-09 17:25:51.841 4822-4822/com.hfy.androidlearning I/Lifecycle_Test: onPause:


复制代码


可见 MyObserver 的方法 确实是在对应关注的生命周期触发时调用。 当然注解中的 value 你也写成其它 你关注的任何一个生命周期,例如 Lifecycle.Event.ON_DESTROY。

[](

)2.2.2.2 MVP 架构中的使用


如果是 在 MVP 架构中,那么就可以把 presenter 作为观察者:


public class LifecycleTestActivity extends AppCompatActivity implements IView {


private String TAG = "Lifecycle_Test";


@Override


protected void onCreate(Bundle savedInstanceState) {


super.onCreate(savedInstanceState);


setContentView(R.layout.activity_lifecycle_test);


//Lifecycle 生命周期


// getLifecycle().addObserver(new MyObserver());


//MVP 中使用 Lifecycle


getLifecycle().addObserver(new MyPresenter(this));


Log.i(TAG, "onCreate: ");


}


@Override


protected void onResume() {


super.onResume();


Log.i(TAG, "onResume: ");


}


@Override


protected void onPause() {


super.onPause();


Log.i(TAG, "onPause: ");


}


@Override


public void showView() {}


@Override


public void hideView() {}


}


//Presenter


class MyPresenter implements LifecycleObserver {


private static final String TAG = "Lifecycle_Test";


private final IView mView;


public MyPresenter(IView view) {mView = view;}


@OnLifecycleEvent(value = Lifecycle.Event.ON_START)


private void getDataOnStart(LifecycleOwner owner){


Log.i(TAG, "getDataOnStart: ");


Util.checkUserStatus(result -> {


//checkUserStatus 是耗时操作,回调后检查当前生命周期状态


if (owner.getLifecycle().getCurrentState().isAtLeast(STARTED)) {


start();


mView.showView();


}


});


}


@OnLifecycleEvent(value = Lifecycle.Event.ON_STOP)


private void hideDataOnStop(){


Log.i(TAG, "hideDataOnStop: ");


stop();


mView.hideView();


}


}


//IView


interface IView {


void showView();


void hideView();


}


复制代码


这里是让 Presenter 实现 LifecycleObserver 接口,同样在方法上注解要触发的生命周期,最后在 Activity 中作为观察者添加到 Lifecycle 中。


这样做好处是啥呢? 当 Activity 生命周期发生变化时,MyPresenter 就可以感知并执行方法,不需要在 MainActivity 的多个生命周期方法中调用 MyPresenter 的方法了。


  • 所有方法调用操作都由组件本身管理:Presenter 类自动感知生命周期,如果需要在其他的 Activity/Fragment 也使用这个 Presenter,只需添加其为观察者即可。

  • 让各个组件存储自己的逻辑,减轻 Activity/Fragment 中代码,更易于管理


—— 上面提到的第一个问题点就解决了。


另外,注意到 getDataOnStart()中耗时校验回调后,对当前生命周期状态进行了检查:至少处于 STARTED 状态才会继续执行 start()方法,也就是保证了 Activity 停止后不会走 start()方法;


—— 上面提到的第二个问题点也解决了。

[](

)2.2.3 自定义 LifecycleOwner


在 Activity 中调用 getLifecycle()能获取到 Lifecycle 实例,那 getLifecycle()是哪里定义的方法呢 ?是接口 LifecycleOwner,顾明来思义,生命周期拥有者:


/**


  • 生命周期拥有者

  • 生命周期事件可被 自定义的组件 用来 处理生命周期事件的变化,同时不会在 Activity/Fragmen 中写任何代码


*/


public interface LifecycleOwner {


@NonNull


Lifecycle getLifecycle();


}


复制代码


Support Library 26.1.0 及以上、AndroidX 的 Fragment 和 Activity 已实现 LifecycleOwner 接口,所以我们在 Activity 中可以直接使用 getLifecycle()。


如果有一个自定义类并希望使其成为 LifecycleOwner,可以使用 LifecycleRegistry 类,它是 Lifecycle 的实现类,但需要将事件转发到该类:


public class MyActivity extends Activity implements LifecycleOwner {


private LifecycleRegistry lifecycleRegistry;


@Override


protected void onCreate(Bundle savedInstanceState) {


super.onCreate(savedInstanceState);


lifecycleRegistry = new LifecycleRegistry(this);


lifecycleRegistry.markState(Lifecycle.State.CREATED);


}


@Override


public void onStart() {


super.onStart();


lifecycleRegistry.markState(Lifecycle.State.STARTED);


}


@NonNull


@Override


public Lifecycle getLifecycle() {


return lifecycleRegistry;


}


}


复制代码


MyActivity 实现 LifecycleOwner,getLifecycle()返回 lifecycleRegistry 实例。lifecycleRegistry 实例则是在 onCreate 创建,并且在各个生命周期内调用 markState()方法完成生命周期事件的传递。这就完成了 LifecycleOwner 的自定义,也即 MyActivity 变成了 LifecycleOwner,然后就可以和 实现了 LifecycleObserver 的组件配合使用了。


补充一点,观察者的方法可以接受一个参数 LifecycleOwner,就可以用来获取当前状态、或者继续添加观察者。 若注解的是 ON_ANY 还可以接收 Event,用于区分是哪个事件。如下:


class TestObserver implements LifecycleObserver {


@OnLifecycleEvent(Lifecycle.Event.ON_CREATE)


void onCreated(LifecycleOwner owner) {


// owner.getLifecycle().addObserver(anotherObserver);


// owner.getLifecycle().getCurrentState();


}


@OnLifecycleEvent(Lifecycle.Event.ON_ANY)


void onAny(LifecycleOwner owner, Lifecycle.Event event) {


// event.name()


}


}


复制代码

[](

)2.3 Application 生命周期 ProcessLifecycleOwner


之前对 App 进入前后台的判断是通过 registerActivityLifecycleCallbacks(callback)方法,然后在 callback 中利用一个全局变量做计数,在 onActivityStarted()中计数加 1,在 onActivityStopped 方法中计数减 1,从而判断前后台切换。


而使用 ProcessLifecycleOwner 可以直接获取应用前后台切换状态。(记得先引入 lifecycle-process 依赖)


使用方式和 Activity 中类似,只不过要使用 ProcessLifecycleOwner.get()获取 ProcessLifecycleOwner,代码如下:


public class MyApplication extends Application {


@Override


public void onCreate() {


super.onCreate();


//注册 App 生命周期观察者


ProcessLifecycleOwner.get().getLifecycle().addObserver(new ApplicationLifecycleObserver());


}


/**


  • Application 生命周期观察,提供整个应用进程的生命周期

  • Lifecycle.Event.ON_CREATE 只会分发一次,Lifecycle.Event.ON_DESTROY 不会被分发。

  • 第一个 Activity 进入时,ProcessLifecycleOwner 将分派 Lifecycle.Event.ON_START, Lifecycle.Event.ON_RESUME。

  • 而 Lifecycle.Event.ON_PAUSE, Lifecycle.Event.ON_STOP,将在最后一个 Activit 退出后后延迟分发。如果由于配置更改而销毁并重新创建活动,则此延迟足以保证 ProcessLifecycleOwner 不会发送任何事件。

  • 作用:监听应用程序进入前台或后台


*/


private static class ApplicationLifecycleObserver implements LifecycleObserver {


@OnLifecycleEvent(Lifecycle.Event.ON_START)


private void onAppForeground() {


Log.w(TAG, "ApplicationObserver: app moved to foreground");


}


@OnLifecycleEvent(Lifecycle.Event.ON_STOP)


private void onAppBackground() {


Log.w(TAG, "ApplicationObserver: app moved to background");


}


}


}


复制代码


看到确实很简单,和前面 Activity 的 Lifecycle 用法几乎一样,而我们使用 ProcessLifecycleOwner 就显得很优雅了。 生命周期分发逻辑已在注释里说明。


[](


)三、 源码分析


==================================================================


Lifecycle 的使用很简单,接下来就是对 Lifecycle 原理和源码的解析了。


我们可以先猜下原理:LifecycleOwner(如 Activity)在生命周期状态改变时(也就是生命周期方法执行时),遍历观察者,获取每个观察者的方法上的注解,如果注解是 @OnLifecycleEvent 且 value 是和生命周期状态一致,那么就执行这个方法。 这个猜测合理吧?下面你来看看。


[](


)3.1 Lifecycle 类




先来瞅瞅 Lifecycle:


public abstract class Lifecycle {


//添加观察者


@MainThread


public abstract void addObserver(@NonNull LifecycleObserver observer);


//移除观察者


@MainThread


public abstract void removeObserver(@NonNull LifecycleObserver observer);


//获取当前状态


public abstract State getCurrentState();


//生命周期事件,对应 Activity 生命周期方法


public enum Event {


ON_CREATE,


ON_START,


ON_RESUME,


ON_PAUSE,


ON_STOP,


ON_DESTROY,


ON_ANY //可以响应任意一个事件


}


//生命周期状态. (Event 是进入这种状态的事件)


public enum State {


DESTROYED,


INITIALIZED,


CREATED,


STARTED,


RESUMED;


//判断至少是某一状态


public boolean isAtLeast(@NonNull State state) {


return compareTo(state) >= 0;


}


}


复制代码


Lifecycle 使用两种主要枚举跟踪其关联组件的生命周期状态:


  1. Event,生命周期事件,这些事件对应 Activity/Fragment 生命周期方法。

  2. State,生命周期状态,而 Event 是指进入一种状态的事件。


Event 触发的时机:


  • ON_CREATE、ON_START、ON_RESUME 事件,是在 LifecycleOwner 对应的方法执行 之后 分发。

  • ON_PAUSE、ON_STOP、ON_DESTROY 事件,是在 LifecycleOwner 对应的方法调用 之前 分发。


这保证了 LifecycleOwner 是在这个状态内。


官网有个图很清晰:



[](


)3.2 Activity 对 LifecycleOwner 的实现




前面提到 Activity 实现了 LifecycleOwner,所以才能直接使用 getLifecycle(),具体是在 androidx.activity.ComponentActivity 中:


//androidx.activity.ComponentActivity,这里忽略了一些其他代码,我们只看 Lifecycle 相关


public class ComponentActivity extends androidx.core.app.ComponentActivity implements LifecycleOwner{


...


private final LifecycleRegistry mLifecycleRegistry = new LifecycleRegistry(this);


...


@Override


protected void onCreate(@Nullable Bundle savedInstanceState) {


super.onCreate(savedInstanceState);


mSavedStateRegistryController.performRestore(savedInstanceState);


ReportFragment.injectIfNeededIn(this); //使用 ReportFragment 分发生命周期事件


if (mContentLayoutId != 0) {


setContentView(mContentLayoutId);


}


}


@CallSuper


@Override


protected void onSaveInstanceState(@NonNull Bundle outState) {


Lifecycle lifecycle = getLifecycle();


if (lifecycle instanceof LifecycleRegistry) {


((LifecycleRegistry) lifecycle).setCurrentState(Lifecycle.State.CREATED);


}


super.onSaveInstanceState(outState);


mSavedStateRegistryController.performSave(outState);


}


@NonNull


@Override


public Lifecycle getLifecycle() {


return mLifecycleRegistry;


}


}


复制代码


这里忽略了一些其他代码,我们只看 Lifecycle 相关。


看到 ComponentActivity 实现了接口 LifecycleOwner,并在 getLifecycle()返回了 LifecycleRegistry 实例。前面提到 LifecycleRegistry 是 Lifecycle 具体实现。


然后在 onSaveInstanceState()中设置 mLifecycleRegistry 的状态为 State.CREATED,然后怎么没有了?其他生命周期方法内咋没处理?what?和猜测的不一样啊。 别急,在 onCreate()中有这么一行:ReportFragment.injectIfNeededIn(this);,这个就是关键所在。


[](


)3.3 生命周期事件分发——ReportFragment




//专门用于分发生命周期事件的 Fragment


public class ReportFragment extends Fragment {


public static void injectIfNeededIn(Activity activity) {


if (Build.VERSION.SDK_INT >= 29) {


//在 API 29 及以上,可以直接注册回调 获取生命周期


activity.registerActivityLifecycleCallbacks(


new LifecycleCallbacks());


}


//API29 以前,使用 fragment 获取生命周期


if (manager.findFragmentByTag(REPORT_FRAGMENT_TAG) == null) {


manager.beginTransaction().add(new ReportFragment(), REPORT_FRAGMENT_TAG).commit();


manager.executePendingTransactions();


}


}


@SuppressWarnings("deprecation")


static void dispatch(@NonNull Activity activity, @NonNull Lifecycle.Event event) {


if (activity instanceof LifecycleRegistryOwner) {//这里废弃了,不用看


((LifecycleRegistryOwner) activity).getLifecycle().handleLifecycleEvent(event);


return;


}


if (activity instanceof LifecycleOwner) {


Lifecycle lifecycle = ((LifecycleOwner) activity).getLifecycle();


if (lifecycle instanceof LifecycleRegistry) {


((LifecycleRegistry) lifecycle).handleLifecycleEvent(event);//使用 LifecycleRegistry 的 handleLifecycleEvent 方法处理事件


}


}


}


@Override


public void onActivityCreated(Bundle savedInstanceState) {


super.onActivityCreated(savedInstanceState);


dispatch(Lifecycle.Event.ON_CREATE);


}


@Override


public void onStart() {


super.onStart();


dispatch(Lifecycle.Event.ON_START);


}


@Override


public void onResume() {


super.onResume();


dispatch(Lifecycle.Event.ON_RESUME);


}


@Override


public void onPause() {


super.onPause();


dispatch(Lifecycle.Event.ON_PAUSE);


}


...省略 onStop、onDestroy


private void dispatch(@NonNull Lifecycle.Event event) {


if (Build.VERSION.SDK_INT < 29) {


dispatch(getActivity(), event);


}


}


//在 API 29 及以上,使用的生命周期回调


static class LifecycleCallbacks implements Application.ActivityLifecycleCallbacks {


...


@Override


public void onActivityPostCreated(@NonNull Activity activity,@Nullable Bundle savedInstanceState) {


dispatch(activity, Lifecycle.Event.ON_CREATE);


}


@Override


public void onActivityPostStarted(@NonNull Activity activity) {


dispatch(activity, Lifecycle.Event.ON_START);


}


@Override


public void onActivityPostResumed(@NonNull Activity activity) {


dispatch(activity, Lifecycle.Event.ON_RESUME);


}


@Override


public void onActivityPrePaused(@NonNull Activity activity) {


dispatch(activity, Lifecycle.Event.ON_PAUSE);


}


...省略 onStop、onDestroy


}


}


复制代码


首先 injectIfNeededIn()内进行了版本区分:在 API 29 及以上 直接使用 activity 的 registerActivityLifecycleCallbacks 直接注册了生命周期回调,然后给当前 activity 添加了 ReportFragment,注意这个 fragment 是没有布局的。


然后, 无论 LifecycleCallbacks、还是 fragment 的生命周期方法 最后都走到了 dispatch(Activity activity, Lifecycle.Event event)方法,其内部使用 LifecycleRegistry 的 handleLifecycleEvent 方法处理事件。


而 ReportFragment 的作用就是获取生命周期而已,因为 fragment 生命周期是依附 Activity 的。好处就是把这部分逻辑抽离出来,实现 activity 的无侵入。如果你对图片加载库 Glide 比较熟,就会知道它也是使用透明 Fragment 获取生命周期的。


[](


)3.4 生命周期事件处理——LifecycleRegistry




到这里,生命中周期事件的处理有转移到了 LifecycleRegistry 中:


//LifecycleRegistry.java


//系统自定义的保存 Observer 的 map,可在遍历中增删


private FastSafeIterableMap<LifecycleObserver, ObserverWithState> mObserverMap = new FastSafeIterableMap<>();


public void handleLifecycleEvent(@NonNull Lifecycle.Event event) {


State next = getStateAfter(event);//获取 event 发生之后的将要处于的状态


moveToState(next);//移动到这个状态


}


private void moveToState(State next) {


if (mState == next) {


return;//如果和当前状态一致,不处理


}


mState = next; //赋值新状态


if (mHandlingEvent || mAddingObserverCounter != 0) {


mNewEventOccurred = true;


return;


}


mHandlingEvent = true;


sync(); //把生命周期状态同步给所有观察者


mHandlingEvent = false;


}


private void sync() {


LifecycleOwner lifecycleOwner = mLifecycleOwner.get();


if (lifecycleOwner == null) {


throw new IllegalStateException("LifecycleOwner of this LifecycleRegistry is already"


  • "garbage collected. It is too late to change lifecycle state.");


}


while (!isSynced()) { //isSynced()意思是 所有观察者都同步完了


mNewEventOccurred = false;


//mObserverMap 就是 在 activity 中添加 observer 后 用于存放 observer 的 map


if (mState.compareTo(mObserverMap.eldest().getValue().mState) < 0) {


backwardPass(lifecycleOwner);


}


Entry<LifecycleObserver, ObserverWithState> newest = mObserverMap.newest();


if (!mNewEventOccurred && newest != null


&& mState.compareTo(newest.getValue().mState) > 0) {


forwardPass(lifecycleOwner);


}


}


mNewEventOccurred = false;


}


...


static State getStateAfter(Event event) {


switch (event) {


case ON_CREATE:


case ON_STOP:


return CREATED;


case ON_START:


case ON_PAUSE:


return STARTED;


case ON_RESUME:


return RESUMED;


case ON_DESTROY:


return DESTROYED;


case ON_ANY:


break;


}


throw new IllegalArgumentException("Unexpected event value " + event);


}


复制代码


逻辑很清晰:使用 getStateAfter()获取 event 发生之后的将要处于的状态(看前面那张图很好理解),moveToState()是移动到新状态,最后使用 sync()把生命周期状态同步给所有观察者。


注意到 sync()中有个 while 循环,很显然是在遍历观察者。并且很显然观察者是存放在 mObserverMap 中的,而 mObserverMap 对观察者的添加 很显然 就是 Activity 中使用 getLifecycle().addObserver()这里:


//LifecycleRegistry.java


@Override


public void addObserver(@NonNull LifecycleObserver observer) {


State initialState = mState == DESTROYED ? DESTROYED : INITIALIZED;


//带状态的观察者,这个状态的作用:新的事件触发后 遍历通知所有观察者时,判断是否已经通知这个观察者了


ObserverWithState statefulObserver = new ObserverWithState(observer, initialState);


ObserverWithState previous = mObserverMap.putIfAbsent(observer, statefulObserver);


//observer 作为 key,ObserverWithState 作为 value,存到 mObserverMap


if (previous != null) {


return;//已经添加过,不处理


}


LifecycleOwner lifecycleOwner = mLifecycleOwner.get();


if (lifecycleOwner == null) {


return;//lifecycleOwner 退出了,不处理


}


//下面代码的逻辑:通过 while 循环,把新的观察者的状态 连续地 同步到最新状态 mState。


//意思就是:虽然可能添加的晚,但把之前的事件一个个分发给你(upEvent 方法),即粘性


boolean isReentrance = mAddingObserverCounter != 0 || mHandlingEvent;


State targetState = calculateTargetState(observer);//计算目标状态


mAddingObserverCounter++;


while ((statefulObserver.mState.compareTo(targetState) < 0


&& mObserverMap.contains(observer))) {


pushParentState(statefulObserver.mState);


statefulObserver.dispatchEvent(lifecycleOwner, upEvent(statefulObserver.mState));


popParentState();


// mState / subling may have been changed recalculate


targetState = calculateTargetState(observer);


}


if (!isReentrance) {


sync();


}


mAddingObserverCounter--;


}


复制代码


用 observer 创建带状态的观察者 ObserverWithState,observer 作为 key、ObserverWithState 作为 value,存到 mObserverMap。 接着做了安全判断,最后把新的观察者的状态 连续地 同步到最新状态 mState,意思就是:虽然可能添加的晚,但会把之前的事件一个个分发给你,即粘性。


回到刚刚 sync()的 while 循环,看看如何处理分发事件:


private void sync() {


LifecycleOwner lifecycleOwner = mLifecycleOwner.get();


if (lifecycleOwner == null) {


Log.w(LOG_TAG, "LifecycleOwner is garbage collected, you shouldn't try dispatch "


  • "new events from it.");


return;


}


while (!isSynced()) {


mNewEventOccurred = false;


// no need to check eldest for nullability, because isSynced does it for us.


if (mState.compareTo(mObserverMap.eldest().getValue().mState) < 0) {


backwardPass(lifecycleOwner);


}


Entry<LifecycleObserver, ObserverWithState> newest = mObserverMap.newest();


if (!mNewEventOccurred && newest != null


&& mState.compareTo(newest.getValue().mState) > 0) {


forwardPass(lifecycleOwner);


}


}


mNewEventOccurred = false;


}


private boolean isSynced() {


if (mObserverMap.size() == 0) {


return true;


}//最老的和最新的观察者的状态一致,都是 ower 的当前状态,说明已经同步完了


State eldestObserverState = mObserverMap.eldest().getValue().mState;


State newestObserverState = mObserverMap.newest().getValue().mState;


return eldestObserverState == newestObserverState && mState == newestObserverState;


}


private void forwardPass(LifecycleOwner lifecycleOwner) {


Iterator<Entry<LifecycleObserver, ObserverWithState>> ascendingIterator = mObserverMap.iteratorWithAdditions();


while (ascendingIterator.hasNext() && !mNewEventOccurred) {//正向遍历,从老到新


Entry<LifecycleObserver, ObserverWithState> entry = ascendingIterator.next();


ObserverWithState observer = entry.getValue();


while ((observer.mState.compareTo(mState) < 0 && !mNewEventOccurred && mObserverMap.contains(entry.getKey()))) {


pushParentState(observer.mState);


observer.dispatchEvent(lifecycleOwner, upEvent(observer.mState));//observer 获取事件


popParentState();


}


}


}


private void backwardPass(LifecycleOwner lifecycleOwner) {


Iterator<Entry<LifecycleObserver, ObserverWithState>> descendingIterator = mObserverMap.descendingIterator();


while (descendingIterator.hasNext() && !mNewEventOccurred) {//反向遍历,从新到老


Entry<LifecycleObserver, ObserverWithState> entry = descendingIterator.next();


ObserverWithState observer = entry.getValue();


while ((observer.mState.compareTo(mState) > 0 && !mNewEventOccurred && mObserverMap.contains(entry.getKey()))) {


Event event = downEvent(observer.mState);


pushParentState(getStateAfter(event));


observer.dispatchEvent(lifecy


《Android学习笔记总结+最新移动架构视频+大厂安卓面试真题+项目实战源码讲义》
浏览器打开:qq.cn.hn/FTe 免费领取
复制代码


cleOwner, event);//observer 获取事件


popParentState();


}


}


}


复制代码


循环条件是!isSynced(),若最老的和最新的观察者的状态一致,且都是 ower 的当前状态,说明已经同步完了。


没有同步完就进入循环体:


  • mState 比最老观察者状态小,走 backwardPass(lifecycleOwner):从新到老分发,循环使用 downEvent()和 observer.dispatchEvent(),连续分发事件;

  • mState 比最新观察者状态大,走 forwardPass(lifecycleOwner):从老到新分发,循环使用 upEvent()和 observer.dispatchEvent(),连续分发事件。


接着 ObserverWithState 类型的 observer 就获取到了事件,即 observer.dispatchEvent(lifecycleOwner, event),下面来看看它是如何让加了对应注解的方法执行的。


[](


)3.5 事件回调后 方法执行




我们继续看下 ObserverWithState:


static class ObserverWithState {


State mState;


GenericLifecycleObserver mLifecycleObserver;


ObserverWithState(LifecycleObserver observer, State initialState) {


mLifecycleObserver = Lifecycling.getCallback(observer);


mState = initialState;


}


void dispatchEvent(LifecycleOwner owner, Event event) {


State newState = getStateAfter(event);


mState = min(mState, newState);


mLifecycleObserver.onStateChanged(owner, event);


mState = newState;


}


}


复制代码


mState 的作用是:新的事件触发后 遍历通知所有观察者时,判断是否已经通知这个观察者了,即防止重复通知。


mLifecycleObserver 是使用 Lifecycling.getCallback(observer)获取的 GenericLifecycleObserver 实例。GenericLifecycleObserver 是接口,继承自 LifecycleObserver:


//接受生命周期改变并分发给真正的观察者


public interface LifecycleEventObserver extends LifecycleObserver {


//生命周期状态变化


void onStateChanged(@NonNull LifecycleOwner source, @NonNull Lifecycle.Event event);


}


复制代码


也就说,LifecycleEventObserver 给 LifecycleObserver 增加了感知生命周期状态变化的能力。


看看 Lifecycling.getCallback(observer):


@NonNull


static LifecycleEventObserver lifecycleEventObserver(Object object) {


...省略很多类型判断的代码


return new ReflectiveGenericLifecycleObserver(object);


}


复制代码

用户头像

Android架构

关注

还未添加个人签名 2021.10.31 加入

还未添加个人简介

评论

发布
暂无评论
“终于懂了“系列,android直播面试题