Android Jetpack - Lifecycle使用方法及原理分析

时间  2019-11-26
标签 android jetpack lifecycle 使用方法 原理 分析 栏目 Android 繁體版
原文   原文链接

Android Architecture Components

Android架构组件库的集合,帮助您设计健壮的、可测试的、可维护的应用程序。从类管理UI组件的生命周期和处理数据持久性。java

一 Android常规生命周期管理方式node

二 Lifecycle的使用react

三 Lifecycle组件的关键类android

四 Lifecycle实现原理api

一 Android常规生命周期管理方式

在应用开发的过程当中，咱们常常须要根据 组件如 Activity/Fragment 的生命周期，来作相应的操做，若是代码基于 MVP 架构开发，那么咱们须要在 presenter 中定义好接口，如：架构

public interface ILoginPresenter {
    void login(String name, String pw);
    void onCreate();
    void onStart();
    void onResume();
    void onPause();
    void onStop();
    void onDestroy();
}
复制代码

而后在 Activity/Fragment 相应的生命周期方法中，将不一样的生命周期状态回调给 presenter：app

@Override
protected void onStart() {
    super.onStart();
    mLoginPresenter.onStart();
}

@Override
protected void onResume() {
    super.onResume();
    mLoginPresenter.onResume();
}

@Override
protected void onPause() {
    super.onPause();
    mLoginPresenter.onPause();
}

@Override
protected void onStop() {
    super.onStop();
    mLoginPresenter.onStop();
}

@Override
protected void onDestroy() {
    super.onDestroy();
    mLoginPresenter.onDestroy();
}
复制代码

尽管这样看起来，代码结构是清晰的，但这是在应用体量小的状况下，想象一下，若是咱们在一个核心界面，该界面须要处理各类各样的受当前组件生命周期影响的事物，那么在该组件的生命周期方法中（onStart()/onResume()/onDestroy...）,咱们就须要去作大量的处理，以及时通知不一样的 presenter 去作相应的操做，这将使得咱们的生命周期方法中的代码变得冗杂。框架

并且组件的状态是具有不肯定性的，例如咱们在 onResume() 方法中作了大量的工做去初始化组件，但这个初始化工做可能还没作完，该组件就进入 stopped 状态了。ide

此外，假如除了 presenter ，还有其余类须要监听组件的生命周期变化，那一样须要新增不少生命周期回调接口，这时至关繁琐的，那咱们是否能够在组件的生命周期发生变化的时候主动通知须要该状态的类呢？答案就是使用 Google提供Lifecycle组件，下面来看看使用 Lifecycle 组件，能带来什么样的改善吧。函数

二 Lifecycle的使用

Google官方文档 ： Handling Lifecycles with Lifecycle-Aware Components

先简单介绍下使用 Lifecycle 的方法，后续再对几个经常使用类及源码实现展开细讲

1.首先是依赖导入:

在应用/模块的 build.gradle 文件中按需添加以下依赖

官网地址：Declaring dependencies

dependencies {
    def lifecycle_version = "2.1.0"

    // ViewModel and LiveData
    implementation "androidx.lifecycle:lifecycle-extensions:$lifecycle_version"
    // alternatively - just ViewModel
    implementation "androidx.lifecycle:lifecycle-viewmodel:$lifecycle_version" // For Kotlin use lifecycle-viewmodel-ktx
    // alternatively - just LiveData
    implementation "androidx.lifecycle:lifecycle-livedata:$lifecycle_version"
    // alternatively - Lifecycles only (no ViewModel or LiveData). Some UI
    //     AndroidX libraries use this lightweight import for Lifecycle
    implementation "androidx.lifecycle:lifecycle-runtime:$lifecycle_version"

    annotationProcessor "androidx.lifecycle:lifecycle-compiler:$lifecycle_version" // For Kotlin use kapt instead of annotationProcessor
    // alternately - if using Java8, use the following instead of lifecycle-compiler
    implementation "androidx.lifecycle:lifecycle-common-java8:$lifecycle_version"

    // optional - ReactiveStreams support for LiveData
    implementation "androidx.lifecycle:lifecycle-reactivestreams:$lifecycle_version" // For Kotlin use lifecycle-reactivestreams-ktx

    // optional - Test helpers for LiveData
    testImplementation "androidx.arch.core:core-testing:$lifecycle_version"
}
复制代码

生命周期observer须要作的：

2.让须要监听组件生命周期方法的observer实现 LifecycleObserver 接口，表示当前类是组件生命周期的观察者

public class LoginPresenterImpl implements ILoginPresenter, LifecycleObserver {...}
复制代码

3.同时在须要被通知的接口上，添加 @OnLifecycleEvent(Lifecycle.Event.ON_XXX 注解, OnLifecycleEvent 对应了 组件 Activity/Fragment 的生命周期方法

@OnLifecycleEvent(Lifecycle.Event.ON_CREATE)
@Override
public void onCreate() {
    Log.d(TAG, "onCreate: state=" + getLifecycle().getCurrentState());
}

@OnLifecycleEvent(Lifecycle.Event.ON_START)
@Override
public void onStart() {
    Log.d(TAG, "onStart: state=" + getLifecycle().getCurrentState());
}
复制代码

生命周期owner须要作的:

4.实现 LifecycleOwner 接口，代表本身是生命周期的拥有者

public class LoginActivity extends AppCompatActivity implements ILoginView, LifecycleOwner {...}
复制代码

5.注册observer，这样就能在组件的生命周期变化时主动通知observer了

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);

    // 注册须要监听组件生命周期的 observer
    getLifecycle().addObserver(new LoginPresenterImpl());
}
复制代码

到这里，observer就能在owner每次生命周期变化时收到通知，相较于前面在owner的生命周期函数中逐个去手动通知各个observer，这种方式显然更便捷。

下面看看log：

// step1 : 进入应用
com.example.lifecycletest2 D/LoginActivity: onCreate: state=INITIALIZED
com.example.lifecycletest2 D/LoginPresenterImpl: onCreate: state=CREATED
com.example.lifecycletest2 D/LoginActivity: onStart: state=CREATED
com.example.lifecycletest2 D/LoginPresenterImpl: onStart: state=STARTED
com.example.lifecycletest2 D/LoginActivity: onResume: enter,state=STARTED
com.example.lifecycletest2 D/LoginPresenterImpl: onResume: state=RESUMED

// step2 : 退出应用
com.example.lifecycletest2 D/LoginPresenterImpl: onPause: state=STARTED
com.example.lifecycletest2 D/LoginActivity: onPause: enter,state=STARTED
com.example.lifecycletest2 D/LoginPresenterImpl: onStop: state=CREATED
com.example.lifecycletest2 D/LoginActivity: onStop: enter,state=CREATED
com.example.lifecycletest2 D/LoginPresenterImpl: onDestroy: state=DESTROYED
com.example.lifecycletest2 D/LoginActivity: onDestroy: enter,state=DESTROYED
复制代码

能够看到，当 Activity 挂起后再次回到当前界面时，收到生命周期事件的顺序变了，先看看官网对 Event && State 这两个状态是怎么解释的吧

Enent:

从框架和生命周期类Lifecycle分发过来的生命周期事件，这些事件对应活动和碎片中的生命周期回调事件

State:

由Lifecycle对象追踪的组件当前的状态

官方文档是这么说的：Think of the states as nodes of a graph and events as the edges between these nodes.也就是将state当作 图的节点 ，将event当作 两个节点之间的边。看下下面的图：

lifecycle-states.png

Google给出的 时间 && 状态 的流程图 结合上面的log打印，就很清晰了，即：

组件处于 INITIALIZED状态 时，触发 ON_CREATE 事件，分发事件onCreate()给observer，此时组件仍处于 INITIALIZED状态 状态，当observer收到onCreate()事件时，组件owner进入CREATED状态，依次类推...

至于为何上面log中，step1阶段时是owner先收到生命周期事件，接着observer才收到；而 step2阶段是 observer先收到生命周期事件，接着owner才收到。这个在 Lifecycle类 中有解释，下面来看看

三 Lifecycle组件的关键类

上面介绍完简单用法后，咱们来看下用到的几个关键类：

1.抽象类Lifecycle

下面是该类给出的说明：

定义的一个持有Android生命周期的类。 Fragment 和 FragmentActivity 类实现了 LifecycleOwner 接口，Support Library 26.1.0 及以上的Activity && Fragment 也都实现了LifecycleOwner接口 并 重写了LifecycleOwner#getLifecycle() ，因此若是咱们的组件是继承自以上类型组件的话，就不用再去实现 LifecycleOwner 接口而能够直接调用 getLifecycle() 来获取 Lifecycle

Event#ON_CREATE} && Event#ON_START && Event#ON_RESUME 这三个事件是在 LifecycleOwner 自身相关的生命周期方法返回后分发的，因此上面log的setp1中， Activity 先于监听类收到生命周期函数回调。

Event#ON_PAUSE && Event#ON_STOP && Event#ON_DESTROY 这三个事件是在 LifecycleOwner 自身相关的生命周期方法被调用前分发的，因此上面log的setp2中，监听类先于组件类收到回调。

清楚了这个以后，在监听类中咱们就能够确切得知道当前组件确切的生命周期节点了，而向上文提到的，onResume() 还没作完就进入 onStopped()了，这种状况也就迎刃而解了。

此外基于不一样的Java版本，推荐使用的LifecycleObserver也有所区别：

  • 若是你用的是Java8，监听组件生命周期时推荐继承DefaultLifecycleObserver类，build.gradle中导入的包为"androidx.lifecycle:common-java8:<version>"；
  • 若是你使用的是Java7，生命周期事件的监听是经过注解实现的，监听生命周期组件时继承LifecycleObserver类。
  • 而Java8一旦成为主流，注解的方式将被丢弃(注解经过反射实现，而反射须要的成本较大)，因此咱们使用的时候尽可能选择DefaultLifecycleObserver。

上面的使用例子中用的就是LifecycleObserver，下面再来看看Java8上使用DefaultLifecycleObserver是怎么样的

监听者

public class LoginPresenterImpl implements ILoginPresenter, DefaultLifecycleObserver {

    private static final String TAG = "LoginPresenterImpl";

    @Override
    public void onCreate(@NonNull LifecycleOwner owner) {
        Log.d(TAG, "onCreate: owner=" + owner);
    }

    @Override
    public void onStart(@NonNull LifecycleOwner owner) {
        Log.d(TAG, "onStart: ");
    }

    @Override
    public void onResume(@NonNull LifecycleOwner owner) {
        Log.d(TAG, "onResume: ");
    }

    @Override
    public void onPause(@NonNull LifecycleOwner owner) {
        Log.d(TAG, "onPause: ");
    }

    @Override
    public void onStop(@NonNull LifecycleOwner owner) {
        Log.d(TAG, "onStop: ");
    }

    @Override
    public void onDestroy(@NonNull LifecycleOwner owner) {
        Log.d(TAG, "onDestroy: ");
    }
}
复制代码

DefaultLifecycleObserver接口中定义了各个生命周期函数,因此咱们可在须要监听组件生命周期的observer中按需重写生命周期回调函数，而后在组件类中将监听者添加到监听列表（getLifecycle().addObserver(new LoginPresenterImpl());）便可收到回调了

能够看到，若是咱们用的是DefaultLifecycleObserver接口，就再也不须要去给每一个须要监听生命周期函数的方法添加注解了，使用上明显更方便了，因此更推荐用这种方式

固然使用DefaultLifecycleObserver接口是有条件的，不然编译会报错：

default interface methods are only supported starting with Android N (--min-api 24): void androidx.lifecycle.DefaultLifecycleObserver.onCreate(androidx.lifecycle.LifecycleOwner)
复制代码

也就是build.gradle文件中声明的minSdkVersion必须大于等于24，不然会报错，因此咱们使用的时候须要综合Java版本 && minSdkVersion要求来作选择。

接着来看该类提供了哪些方法：

// 添加一个生命周期观察者，在 LifecycleOwner 生命周期改变时观察者将能收到回调，例如
// 当 LifecycleOwner 处于 STARTED 时,观察者将能收到 Event#ON_CREATE && Event#ON_START 两个时间回调
@MainThread
public abstract void addObserver(@NonNull LifecycleObserver observer);

// 移除观察者
这里有几种状况：
若是该函数被调用时，某个生命周期状态已经被分发出去了：
a.若是观察者此时还未收到该事件，它将能继续收到
b.若是观察者类中有多个方法监听了该事件且其中至少一个方法已经收到了该回调，
则剩余全部的方法也都能收到该回调，全部回调完成后该观察者才会被移除
@MainThread
public abstract void removeObserver(@NonNull LifecycleObserver observer);

// 获取组件的生命周期状态，一个经常使用场景是：当咱们要去触发某个操做时，这个操做依赖于生命周期的状态，
// 这时咱们能够这么作：if (lifecycle.getCurrentState().isAtLeast(STARTED)){ // TO DO }
@MainThread
@NonNull
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;
    }
}
复制代码

2.接口LifecycleObserver观察者

这是个空的接口，依赖于OnLifecycleEvent注解

3.接口LifecycleOwner/接口DefaultLifecycleObserver生命周期拥有者

  • 接口LifecycleOwner

只有一个方法**Lifecycle getLifecycle();**用于获取Lifecycle对象

  • 接口DefaultLifecycleObserver

上文已经简单叙述了该接口同LifecycleObserver的区别了，来看看该类给出的说明：若是一个监听者同时实现了DefaultLifecycleObserver && LifecycleEventObserver，那么DefaultLifecycleObserver的方法将会先被调用，随后才是LifecycleEventObserver#onStateChanged(LifecycleOwner, Lifecycle.Event)，若是一个类在实现该接口的同时还给方法添加OnLifecycleEvent注解，那么相关注解将被忽视。

4.LifecycleEventObserver

上文提到了这个接口，来看下该类的描述：该类能接收任何生命周期改变同时分发给监听者，这里试了一下observer同时实现DefaultLifecycleObserver && LifecycleEventObserver，结合上面第3点，看下下面的log：

com.example.lifecycletest2 D/LoginActivity: onCreate: enter,state=INITIALIZED
com.example.lifecycletest2 D/LoginPresenterImpl: onCreate: 
com.example.lifecycletest2 D/LoginPresenterImpl: onStateChanged: event=ON_CREATE

com.example.lifecycletest2 D/LoginActivity: onStart: enter,state=CREATED
com.example.lifecycletest2 D/LoginPresenterImpl: onStart: 
com.example.lifecycletest2 D/LoginPresenterImpl: onStateChanged: event=ON_START

com.example.lifecycletest2 D/LoginActivity: onResume: enter,state=STARTED
com.example.lifecycletest2 D/LoginPresenterImpl: onResume: 
com.example.lifecycletest2 D/LoginPresenterImpl: onStateChanged: event=ON_RESUME
复制代码

能够看到，若是一个类同时实现了DefaultLifecycleObserver && LifecycleEventObserver，那么会先调用相应的生命周期函数，接着才是onStateChanged(),因此关于这两个接口的选择也就一目了然了，若是你须要在确切的生命周期作特定的事，那么实现DefaultLifecycleObserver，若是你只是想在生命周期变化时被告知，能够实现LifecycleEventObserver

5.LifecycleReistry

前面说过，Fragment 和 FragmentActivity 类自己实现了 LifecycleOwner 接口，Support Library 26.1.0 及以上的Activity && Fragment 也都实现了LifecycleOwner接口，而若是你的组件不是以上类型的呢（如android.app.Avtivity），这个时候若是你想实现上面一样的效果的话就须要用到 LifecycleOwner + LifecycleReistry 了，下面来看看具体例子：

  • 组件类的实现：

    • a.实现LifecycleOwner接口

    • b.重写getLifecycle()方法，并返回mLifecycleRegistry

    • c.建立LifecycleRegistry对象，并在但愿通知监听者的生命周期方法中用LifecycleRegistry.markState(Lifecycle.State.XXX)标记相应的状态，

    • d.最后添加监听者便可

      public class LoginActivity extends Activity implements ILoginView ,LifecycleOwner//a {

      private static final String TAG = "LoginActivity";
      private LifecycleRegistry mLifecycleRegistry;
  
      @Override
      protected void onCreate(Bundle savedInstanceState) {
          super.onCreate(savedInstanceState);
          setContentView(R.layout.activity_main);
          // c
          mLifecycleRegistry = new LifecycleRegistry(this);
          Log.d(TAG, "onCreate: state=" + getLifecycle().getCurrentState());
          mLifecycleRegistry.markState(Lifecycle.State.CREATED);
          // d
          getLifecycle().addObserver(new LoginPresenterImpl());
      }
  
      @Override
      protected void onStart() {
          super.onStart();
          Log.d(TAG, "onStart: state=" + getLifecycle().getCurrentState());
          mLifecycleRegistry.markState(Lifecycle.State.STARTED);
      }
  
      // b
      @NonNull
      @Override
      public Lifecycle getLifecycle() {
          return mLifecycleRegistry;
      }
  }
复制代码

  • 监听者的实现：有两种，一种是实现LifecycleObserver，而后在但愿监听生命周期的函数上添加OnLifecycleEvent注解

    public class LoginPresenterImpl implements ILoginPresenter, LifecycleObserver {

      private static final String TAG = "LoginPresenterImpl";
  
      @OnLifecycleEvent(Lifecycle.Event.ON_CREATE)
      @Override
      public void onCreate() {
          Log.d(TAG, "onCreate: ");
      }
  
      @OnLifecycleEvent(Lifecycle.Event.ON_START)
      @Override
      public void onStart() {
          Log.d(TAG, "onStart: ");
      }
      
      @OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
      @Override
      public void onResume() {
          Log.d(TAG, "onResume: ");
      }
  }
复制代码

log打印以下

com.example.lifecycletest2 D/LoginActivity: onCreate: state=INITIALIZED
com.example.lifecycletest2 D/LoginPresenterImpl: onCreate: 

com.example.lifecycletest2 D/LoginActivity: onStart: state=CREATED
com.example.lifecycletest2 D/LoginPresenterImpl: onStart: 
// owner 中未用 markState 标记，因此 observer 没法收到回调
com.example.lifecycletest2 D/LoginActivity: onResume: enter,state=STARTED
复制代码

能够看到，只有在owner中使用LifecycleRegistry.markState(Lifecycle.State.XXX)标记了的函数，监听者才能收到回调。

  • 监听者的另外一种实现：实现DefaultLifecycleObserver接口，按需实现须要的回调函数，

    public class LoginPresenterImpl implements ILoginPresenter, DefaultLifecycleObserver {

      private static final String TAG = "LoginPresenterImpl";
  
      @Override
      public void onCreate(@NonNull LifecycleOwner owner) {
          Log.d(TAG, "onCreate: ");
      }
  
      @Override
      public void onStart(@NonNull LifecycleOwner owner) {
          Log.d(TAG, "onStart: ");
      }
  
      @Override
      public void onResume(@NonNull LifecycleOwner owner) {
          Log.d(TAG, "onResume: ");
      }
  
      @Override
      public void onPause(@NonNull LifecycleOwner owner) {
          Log.d(TAG, "onPause: ");
      }
  
      @Override
      public void onStop(@NonNull LifecycleOwner owner) {
          Log.d(TAG, "onStop: ");
      }
  
      @Override
      public void onDestroy(@NonNull LifecycleOwner owner) {
          Log.d(TAG, "onDestroy: ");
      }
  }
复制代码

log打印结果同上，一样是只有用LifecycleRegistry.markState标记过的生命周期函数才会自动通知到监听者类中。

四 Lifecycle实现原理

看完Lifecycle的用法后，咱们来看看它是怎么实现的：

相信你们也是不少疑惑的，Lifecycle组件这套逻辑是怎么搭起来的，Activity/Fragment 是怎么在生命周期变化的时候自动通知到观察者的？

首先解答一个疑问：自定义实现LifecycleOwner必须重写getLifecycle()方法并返回一个LifecycleRegistry实例，那么不须要咱们手动重写getLifecycle()的组件，是在哪一个地方帮咱们作了这件事呢,下面来看看：

若是咱们的Activity是继承自AppCompatActivity，咱们就不须要再手动去实现LifecycleOwner了，咱们往上追溯能够发现，父类ComponentActivity实现了该接口，其getLifecycle()方法返回了一个LifecycleRegistry实例，因此就是在这里帮咱们作了这件事的。

先思考下面两个问题：

  • 往LifecycleRegistry中添加监听者后，LifecycleRegistry是怎么感知组件的生命周期变化的?
  • LifecycleRegistry是如何将生命周期变化分发到对应的observer的？

核心实现涉及两个类：ComponentActivity && LifecycleRegistry

ComponentActivity#onCreate():

有这么一行代码ReportFragment.injectIfNeededIn(this),这个FragmentManager是什么，injectIfNeededIn()方法又作了什么事？

public class ReportFragment extends Fragment {
    
    public static void injectIfNeededIn(Activity activity) {
    android.app.FragmentManager manager = activity.getFragmentManager();
    if (manager.findFragmentByTag(REPORT_FRAGMENT_TAG) == null) {
        manager.beginTransaction().add(new ReportFragment(), REPORT_FRAGMENT_TAG).commit();
        manager.executePendingTransactions();
    }
    
    @Override
    public void onActivityCreated(Bundle savedInstanceState) {
        super.onActivityCreated(savedInstanceState);
        dispatchCreate(mProcessListener);
        dispatch(Lifecycle.Event.ON_CREATE);
    }

    @Override
    public void onStart() {
        super.onStart();
        dispatchStart(mProcessListener);
        dispatch(Lifecycle.Event.ON_START);
    }

    @Override
    public void onResume() {
        super.onResume();
        dispatchResume(mProcessListener);
        dispatch(Lifecycle.Event.ON_RESUME);
    }

    @Override
    public void onPause() {
        super.onPause();
        dispatch(Lifecycle.Event.ON_PAUSE);
    }

    @Override
    public void onStop() {
        super.onStop();
        dispatch(Lifecycle.Event.ON_STOP);
    }

    @Override
    public void onDestroy() {
        super.onDestroy();
        dispatch(Lifecycle.Event.ON_DESTROY);
        // just want to be sure that we won't leak reference to an activity
        mProcessListener = null;
    }
    
    // 分发生命周期函数到 LifecycleRegistry 
    private void dispatch(Lifecycle.Event event) {
        Activity activity = getActivity();
        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);
            }
        }
    }
    ...
}
复制代码

类的注释是：一个分发初始化事件的内部类，上面贴出了该类的几个关键方法：

a.首先是injectIfNeededIn()方法，建立了一个Fragment而后添加到Activity中去

b.在该Fragment的生命周期函数中都调用了dispatch(Lifecycle.Event event)方法，而该方法作的就是，判断当前Activity是否实现了LifecycleRegistryOwner/LifecycleOwner接口，是的话就调用LifecycleRegistry#handleLifecycleEvent(event)

到这里咱们就能够明白了第一个问题了，即经过添加一个Fragment到当前Activity中，而后利用Fragment与Activity的生命周期函数先后调用关系，来感知Activity的生命周期。

来看看LifecycleRegistry#handleLifecycleEvent(event)又作了什么,关键代码都作了注释

public void handleLifecycleEvent(@NonNull Lifecycle.Event event) {
    // 根据 owner 传过来的生命周期事件，拿到要分发给 observer 的状态
    State next = getStateAfter(event);
    // 将状态分发给 observer
    moveToState(next);
}

// moveToState(State next) 中的关键代码只有一句：调用 sync()
private void sync() {
    ......
    while (!isSynced()) {
        mNewEventOccurred = false;
        if (mState.compareTo(mObserverMap.eldest().getValue().mState) < 0) {
            // 分发点1
            backwardPass(lifecycleOwner);
        }
        Entry<LifecycleObserver, ObserverWithState> newest = mObserverMap.newest();
        if (!mNewEventOccurred && newest != null
                && mState.compareTo(newest.getValue().mState) > 0) {
            // 分发点2
            forwardPass(lifecycleOwner);
        }
    }
    mNewEventOccurred = false;
}

// 分发点1
private void forwardPass(LifecycleOwner lifecycleOwner) {
    Iterator<Entry<LifecycleObserver, ObserverWithState>> ascendingIterator =
            mObserverMap.iteratorWithAdditions();
    // 遍历当前的 observer 
    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
            observer.dispatchEvent(lifecycleOwner, upEvent(observer.mState));
            popParentState();
        }
    }
}

// 分发点2
private void backwardPass(LifecycleOwner lifecycleOwner) {
    Iterator<Entry<LifecycleObserver, ObserverWithState>> descendingIterator =
            mObserverMap.descendingIterator();
    // 遍历当前的 observer 
    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
            observer.dispatchEvent(lifecycleOwner, event);
            popParentState();
        }
    }
}
复制代码

看到这里咱们能明白第二个问题了，即ReportFragment在自身的生命周期函数中，将当前生命周期事件报告给LifecycleRegistry, 而LifecycleRegistry经由addObserver(observer),是持有各个observer的引用的，这样便能将收到的报告转发给各个observer了。

整个流程用了一个很巧妙的技巧：利用一个Fragment以及 Fragment的各个生命周期函数与Activity的生命周期函数的先后调用关系，以LifecycleRegistry为桥梁，将Activity的生命周期分发给observer。

相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程