Android Jetpack之Lifecycles

版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/mingyunxiaohai/article/details/89429908

Android中大多数的组件都有生命周期函数，生命周期由操作系统或者framework层的代码来管理，它们是Andorid的核心运行方式。我们平时写程序必须遵循生命周期的原则，否则会造成内存泄露甚至程序崩溃

我们通常会在activity和fragment的生命周期函数内来做一些初始化操作和释放资源的一些操作，但是这样会导致代码组织不良，容易出错，使用生命周期感知组件，可以让生命周期方法移动到组件上来。

android.arch.lifecycle包中提供了一些类和接口来构建生命周期组件，它们可以根据activity和fragment的生命周期的当前状态自动调整自身行为。

在没有使用生命周期感知组件之前，如果我们想要使用定位服务，我们可能会按照下面的方式来写，通过一个接口来回调

class MyListener {
    public MyListener() {
        // ...
    }

    void start() {
        // 连接到系统位置服务
    }

    void stop() {
        // 断开连接
    }
}

class MyActivity extends AppCompatActivity {
    private MyListener myListener;

    @Override
    public void onCreate(...) {
        myListener = new MyListener(this, (location) -> {
             //更新UI
        });
    }

    @Override
    public void onStart() {
        super.onStart();
        myListener.start();
       //如果有其他组件需要监听生命周期，在下面继续回调
    }

    @Override
    public void onStop() {
        super.onStop();
        myListener.stop();
         //如果有其他组件需要监听生命周期，在下面继续回调
    }
}

上面的写法是可以的，但是考虑到假如除了定位服务还有一些别的服务也需要在这个activity的生命周期函数内执行，比如网络，比如媒体查询，这时候，onStart()和onStop()这两个方法内会有很多的接口回调不利于维护。

另外还会有一些别的问题，比如执行onStop()的时候，初始化还没完成，而我们又在初始化之后做了一些耗时的操作，这就会导致资源不能及时的关闭或者断开。我们可能需要在初始化完成后来检查其所依赖的activity的状态来避免这个问题。

lifecycle组件可以很灵活的处理这些问题。

lifecyle的导入

    //如果没用AndroidX
    implementation "android.arch.lifecycle:runtime:1.1.1"
    annotationProcessor "android.arch.lifecycle:compiler:1.1.1"

   //如果用了AndoridX
   def lifecycle_version = "2.0.0"
    // 包含 ViewModel and LiveData
    implementation "androidx.lifecycle:lifecycle-extensions:$lifecycle_version"
    //只包含 ViewModel 如果是 Kotlin 使用 lifecycle-viewmodel-ktx
    implementation "androidx.lifecycle:lifecycle-viewmodel:$lifecycle_version" 
    // 只包含 LiveData
    implementation "androidx.lifecycle:lifecycle-livedata:$lifecycle_version"
    // 只包含Lifecycles
    implementation "androidx.lifecycle:lifecycle-runtime:$lifecycle_version"
    //注解处理器，如果是Kotlin 使用 kapt 代替 annotationProcessor
    annotationProcessor "androidx.lifecycle:lifecycle-compiler:$lifecycle_version" 
    //如果使用了Java8, 使用下面的代替lifecycle-compiler
    implementation "androidx.lifecycle:lifecycle-common-java8:$lifecycle_version"

lifecycle是一个类，它包含一些生命周期组件的生命周期的信息比如activity和fragment，并允许其他的对象监听此状态

它主要使用两个枚举类来监听它所关联的组件的生命周期

• Event: 这些events是从系统框架层（framework ）和 Lifecycle类中派发的，他们映射到 activities 和 fragments 中的回调中。
• State：由Lifecycle对象来跟组组件的当前状态。

LifecycleOwner是一个单一的方法接口，表示该类有一个Lifecycle，它有一个方法， getLifecycle()必须由类实现，该方法可以获取生命周期比如activity和fragment的生命周期，任何自定义的类都可以实现这个接口。

使用LifecycleObserver可以和LifecycleOwner无缝对接，LifecycleOwner 相当于被观察者，LifecycleObserver相当于观察者，LifecycleOwner可以获取组件的生命周期，那么观察者也能观察生命周期的变化了。

在Support Library 26.1.0 和以上的版本中，activity和fragment已经默认实现了LifecycleOwner接口，如果是26.1.0以下版本需要自定义实现LifecycleOwner接口。

比如一开始的例子，可以让MyLocationListener实现LifecycleObserver

public class MyListener implements LifecycleObserver {
    @OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
    public void connectListener() {
        // 连接到服务
        Log.i("LifecycleEvent","start");
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_PAUSE)
    public void disconnectListener() {
        // 断开连接
        Log.i("LifecycleEvent","stop");
    }
}

public class LifeActivity extends AppCompatActivity {
    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        getLifecycle().addObserver(new MyListener());
    }
}

通过上面的实现，MyListener类就可以感知生命周期了，以后所有的初始化和释放的操作它都可以自己完成，查看log日志可以看到MyListener已经可以感知到生命周期了

04-08 16:43:49.144 11995-11995/com.chs.androiddailytext I/LifecycleEvent: start
04-08 16:43:50.873 11995-11995/com.chs.androiddailytext I/LifecycleEvent: stop

MyListenr除了实现LifecycleObserver然后使用注解，也可以继承DefaultLifecycleObserver然后实现里面的方法。因为Java8之后注解的方式会被弃用，所以推荐使用DefaultLifecycleObserver

/**
 * Callback interface for listening to {@link LifecycleOwner} state changes.
 * <p>
 * If you use Java 8 language, <b>always</b> prefer it over annotations.
 */
@SuppressWarnings("unused")
public interface DefaultLifecycleObserver extends FullLifecycleObserver {......}

Lifecycle的实现原理: 本文使用的API28

它其实就是一个观察者模式，LifecycleOwner是被观察者，在Support Library 26.1.0 和以上的版本中，activity和fragment已经默认实现了LifecycleOwner接口，所以他俩都是被观察者，我们自己定义的LifecycleObserver就是观察者， 通过getLifecycle().addObserver方法注册观察者。

下面从getLifecycle()这个方法开始查看源码

  //在FragmentActivity中，FragmentActivity继承自ComponentActivity(本文使用的API28)
  public Lifecycle getLifecycle() {
        return super.getLifecycle();
    }
 //在ComponentActivity 中
 public Lifecycle getLifecycle() {
        return mLifecycleRegistry;
    }
LifecycleRegistry mLifecycleRegistry = new LifecycleRegistry(this);

getLifecycle()方法返回了一个LifecycleRegistry对象

public class LifecycleRegistry extends Lifecycle {
      public LifecycleRegistry(@NonNull LifecycleOwner provider) {
        mLifecycleOwner = new WeakReference<>(provider);
        mState = INITIALIZED;
    }
}
public class ComponentActivity extends Activity
        implements LifecycleOwner, KeyEventDispatcher.Component {
        ......
        protected void onCreate(@Nullable Bundle savedInstanceState) {
           super.onCreate(savedInstanceState);
           ReportFragment.injectIfNeededIn(this);
          }
        ......  
        }

LifecycleRegistry对象继承自Lifecycle，是从ComponentActivity中直接new出来的，并传入一个LifecycleOwner对象。ComponentActivity实现了LifecycleOwner接口所以传入自己就好了。

ComponentActivity中除了创建了LifecycleRegistry对象外在其onCreate方法中还执行了ReportFragment.injectIfNeededIn(this)这个方法。

下面来看看这个ReportFragment

/**
 * 分派初始化事件的内部类。
 * @hide
 */
@SuppressWarnings("UnknownNullness") // TODO https://issuetracker.google.com/issues/112197238
@RestrictTo(RestrictTo.Scope.LIBRARY_GROUP_PREFIX)
public class ReportFragment extends Fragment {
    private static final String REPORT_FRAGMENT_TAG = "androidx.lifecycle"
            + ".LifecycleDispatcher.report_fragment_tag";

    public static void injectIfNeededIn(Activity activity) {
        // ProcessLifecycleOwner should always correctly work and some activities may not extend
        // FragmentActivity from support lib, so we use framework fragments for activities
        android.app.FragmentManager manager = activity.getFragmentManager();
        if (manager.findFragmentByTag(REPORT_FRAGMENT_TAG) == null) {
            manager.beginTransaction().add(new ReportFragment(), REPORT_FRAGMENT_TAG).commit();
            // Hopefully, we are the first to make a transaction.
            manager.executePendingTransactions();
        }
    }

    static ReportFragment get(Activity activity) {
        return (ReportFragment) activity.getFragmentManager().findFragmentByTag(
                REPORT_FRAGMENT_TAG);
    }

    private ActivityInitializationListener mProcessListener;

    private void dispatchCreate(ActivityInitializationListener listener) {
        if (listener != null) {
            listener.onCreate();
        }
    }

    private void dispatchStart(ActivityInitializationListener listener) {
        if (listener != null) {
            listener.onStart();
        }
    }

    private void dispatchResume(ActivityInitializationListener listener) {
        if (listener != null) {
            listener.onResume();
        }
    }

    @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;
    }

    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);
            }
        }
    }

    void setProcessListener(ActivityInitializationListener processListener) {
        mProcessListener = processListener;
    }

    interface ActivityInitializationListener {
        void onCreate();

        void onStart();

        void onResume();
    }
}

通过上面的代码我们可以知道：

• injectIfNeededIn方法用来创建这个ReportFragment，并且将它commit到当前的Activity中。这是一个没有布局文件的空的Fragment，虽然没有布局文件，但是它有一个完整的生命周期，我们可以把它的生命周期利用起来。
• 在其生命周期方法中调用dispatch(Lifecycle.Event event)方法，传入对应的event，Event是一个枚举类，里面定义了生命周期函数名字对应的标志位常量。比如onStart()中就传入Lifecycle.Event.ON_RESUME。
• dispatch方法中调用了getLifecycle().handleLifecycleEvent(event)，前面我们知道getLifecycle()返回的是一个LifecycleRegistry对象，已经在Activity成员变量中new了出来。
• 注意：在onActivityCreated，onStart，onResume方法中除了调用dispatch方法还是调用了dispatchCreate，dispatchStart，dispatchResume方法。这些先略过最后在看。

  public void handleLifecycleEvent(@NonNull Lifecycle.Event event) {
        State next = getStateAfter(event);
        moveToState(next);
    }

handleLifecycleEvent方法的作用就是，设置当前状态并通知观察者,下面来看getStateAfter和moveToState方法

    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);
    }
    private void moveToState(State next) {
        if (mState == next) {
            return;
        }
        mState = next;
        //如果正在发送事件或者正在注册事件，直接返回
        if (mHandlingEvent || mAddingObserverCounter != 0) {
            mNewEventOccurred = true;
            // we will figure out what to do on upper level.
            return;
        }
        mHandlingEvent = true;
        sync();
        mHandlingEvent = false;
    }

从getStateAfter中找出当前的需要赋值的状态，然后赋值给成员变量mState。

状态赋值完之后调用了sync()方法，下面看这个方法

    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()) {
            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;
        }
        State eldestObserverState = mObserverMap.eldest().getValue().mState;
        State newestObserverState = mObserverMap.newest().getValue().mState;
        return eldestObserverState == newestObserverState && mState == newestObserverState;
    }

isSynced()方法，用来判断最后添加的观察者和最新添加的观察者的状态是否一致，并且当前将要分发的事件状态和最新添加的观察者的状态是否一致。

如果一致执行backwardPass方法和forwardPass方法，两个方法都是循环遍历观察者的集合分发事件，正常情况下执行backwardPass方法，如果在执行backwardPass方法的过程中有新的状态改变，会执行forwardPass方法。

    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(lifecycleOwner, event);
                popParentState();
            }
        }
    }
      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));
                popParentState();
            }
        }
    }

可以看到这两个方法中都是循环观察者的集合，调用观察者（observer）的dispatchEvent方法来分发事件。这个观察者是一个ObserverWithState对象

观察者的集合是咋来的呢，Ok,现在回到Activity中getLifecycle().addObserver(new MyListener());，前面我们都是跟着getLifecycle()走的，现在看addObserver这个添加观察者的方法。

addObserver是Lifecycle这个接口中的方法，LifecycleRegistry实现了Lifecycle接口，着getLifecycle()方法返回一个LifecycleRegistry对象，所以去LifecycleRegistry中看addObserver方法

    public void addObserver(@NonNull LifecycleObserver observer) {
        State initialState = mState == DESTROYED ? DESTROYED : INITIALIZED;
        ObserverWithState statefulObserver = new ObserverWithState(observer, initialState);
        ObserverWithState previous = mObserverMap.putIfAbsent(observer, statefulObserver);

        if (previous != null) {
            return;
        }
        LifecycleOwner lifecycleOwner = mLifecycleOwner.get();
        if (lifecycleOwner == null) {
            // it is null we should be destroyed. Fallback quickly
            return;
        }

        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) {
            // we do sync only on the top level.
            sync();
        }
        mAddingObserverCounter--;
    }

上面代码最主要的就是封装一个ObserverWithState对象，然后保存到一个自定义的Map集合中。前面我们知道backwardPass和forwardPass方法中都是当状态改变的时候，循环调用的ObserverWithState中的dispatchEvent方法。

   static class ObserverWithState {
        State mState;
        LifecycleEventObserver mLifecycleObserver;

        ObserverWithState(LifecycleObserver observer, State initialState) {
            mLifecycleObserver = Lifecycling.lifecycleEventObserver(observer);
            mState = initialState;
        }

        void dispatchEvent(LifecycleOwner owner, Event event) {
            State newState = getStateAfter(event);
            mState = min(mState, newState);
            mLifecycleObserver.onStateChanged(owner, event);
            mState = newState;
        }
    }

• 构造方法中，把我们传入的LifecycleObserver对象通过lifecycleEventObserver方法转换成一个LifecycleEventObserver对象，
• LifecycleEventObserver也是一个接口，只有一个方法onStateChanged。它有好几个子类，比如我们的MyListener实现了LifecycleObserver接口，那么它会转化成SingleGeneratedAdapterObserver，如果我们的MyListener实现了DefaultLifecycleObserver接口，就会转化成FullLifecycleObserverAdapter。
• 事件分发方法dispatchEvent中调用onStateChanged通知状态改变了。

到这里观察和监听的一个闭环就完成了

现在回到ReportFragment中，前面在看其生命周期方法的时候看到在onActivityCreated，onStart，onResume方法中除了调用dispatch方法还是调用了dispatchCreate，dispatchStart，dispatchResume方法。为啥呢？

因为这个ReportFragment是在ComponentActivity这个Activity中的onCreate方法中创建的，ComponentActivity继承自Activity假如我们的Activity也直接继承自Activity，那没法初始化ReportFragment，怎么监听生命周期呢？

跟进这几个方法看看

  private void dispatchCreate(ActivityInitializationListener listener) {
        if (listener != null) {
            listener.onCreate();
        }
    }

调用了ActivityInitializationListener的相关方法，前面贴的ReportFragment的代码最后可以看到ActivityInitializationListener是一个接口，里面有onCreate，onStart，onResume方法，ReportFragment中还提供了一个set方法。studio中点击这个set方法，进入到新大陆

public class ProcessLifecycleOwner implements LifecycleOwner {

    @VisibleForTesting
    static final long TIMEOUT_MS = 700; //mls

    // ground truth counters
    private int mStartedCounter = 0;
    private int mResumedCounter = 0;

    private boolean mPauseSent = true;
    private boolean mStopSent = true;

    private Handler mHandler;
    private final LifecycleRegistry mRegistry = new LifecycleRegistry(this);

    private Runnable mDelayedPauseRunnable = new Runnable() {
        @Override
        public void run() {
            dispatchPauseIfNeeded();
            dispatchStopIfNeeded();
        }
    };

    ActivityInitializationListener mInitializationListener =
            new ActivityInitializationListener() {
                @Override
                public void onCreate() {
                }

                @Override
                public void onStart() {
                    activityStarted();
                }

                @Override
                public void onResume() {
                    activityResumed();
                }
            };

    private static final ProcessLifecycleOwner sInstance = new ProcessLifecycleOwner();

    /**
     * The LifecycleOwner for the whole application process. Note that if your application
     * has multiple processes, this provider does not know about other processes.
     *
     * @return {@link LifecycleOwner} for the whole application.
     */
    @NonNull
    public static LifecycleOwner get() {
        return sInstance;
    }

    static void init(Context context) {
        sInstance.attach(context);
    }

    void activityStarted() {
        mStartedCounter++;
        if (mStartedCounter == 1 && mStopSent) {
            mRegistry.handleLifecycleEvent(Lifecycle.Event.ON_START);
            mStopSent = false;
        }
    }

    void activityResumed() {
        mResumedCounter++;
        if (mResumedCounter == 1) {
            if (mPauseSent) {
                mRegistry.handleLifecycleEvent(Lifecycle.Event.ON_RESUME);
                mPauseSent = false;
            } else {
                mHandler.removeCallbacks(mDelayedPauseRunnable);
            }
        }
    }

    void activityPaused() {
        mResumedCounter--;
        if (mResumedCounter == 0) {
            mHandler.postDelayed(mDelayedPauseRunnable, TIMEOUT_MS);
        }
    }

    void activityStopped() {
        mStartedCounter--;
        dispatchStopIfNeeded();
    }

    void dispatchPauseIfNeeded() {
        if (mResumedCounter == 0) {
            mPauseSent = true;
            mRegistry.handleLifecycleEvent(Lifecycle.Event.ON_PAUSE);
        }
    }

    void dispatchStopIfNeeded() {
        if (mStartedCounter == 0 && mPauseSent) {
            mRegistry.handleLifecycleEvent(Lifecycle.Event.ON_STOP);
            mStopSent = true;
        }
    }

    private ProcessLifecycleOwner() {
    }

    void attach(Context context) {
        mHandler = new Handler();
        mRegistry.handleLifecycleEvent(Lifecycle.Event.ON_CREATE);
        Application app = (Application) context.getApplicationContext();
        app.registerActivityLifecycleCallbacks(new EmptyActivityLifecycleCallbacks() {
            @Override
            public void onActivityCreated(Activity activity, Bundle savedInstanceState) {
                ReportFragment.get(activity).setProcessListener(mInitializationListener);
            }

            @Override
            public void onActivityPaused(Activity activity) {
                activityPaused();
            }

            @Override
            public void onActivityStopped(Activity activity) {
                activityStopped();
            }
        });
    }

    @NonNull
    @Override
    public Lifecycle getLifecycle() {
        return mRegistry;
    }
}

从注释里可以看到，该类为整个应用程序过程提供生命周期。在它的attach方法中，通过registerActivityLifecycleCallbacks方法注册了监听了程序的生命周期。在onActivityCreated方法中可以看到给ReportFragment设置了mInitializationListener。

attach方法在哪里调用的呢

 private static final ProcessLifecycleOwner sInstance = new ProcessLifecycleOwner();
 
    static void init(Context context) {
        sInstance.attach(context);
    }

调用了一个静态的init方法，进入调用的地方

public class ProcessLifecycleOwnerInitializer extends ContentProvider {
    @Override
    public boolean onCreate() {
        LifecycleDispatcher.init(getContext());
        ProcessLifecycleOwner.init(getContext());
        return true;
    }

    @Nullable
    @Override
    public Cursor query(@NonNull Uri uri, String[] strings, String s, String[] strings1,
            String s1) {
        return null;
    }

    @Nullable
    @Override
    public String getType(@NonNull Uri uri) {
        return null;
    }

    @Nullable
    @Override
    public Uri insert(@NonNull Uri uri, ContentValues contentValues) {
        return null;
    }

    @Override
    public int delete(@NonNull Uri uri, String s, String[] strings) {
        return 0;
    }

    @Override
    public int update(@NonNull Uri uri, ContentValues contentValues, String s, String[] strings) {
        return 0;
    }
}

这里我们看到了初始化的地方，ProcessLifecycleOwnerInitializer继承自ContentProvider，Lifecycle自动在我们的AndroidManifest.xml中添加了一个ContentProvider，用于初始化ProcessLifecycleOwner和LifecycleDispatcher。

ContentProvider的onCreate()方法执行时间比Application的onCreate()执行时间还要早，而且肯定会执行。所以在ContentProvider的onCreate()方法里面初始化这是是没问题的。

我们看到还调用了LifecycleDispatcher的初始化的方法

class LifecycleDispatcher {

    private static AtomicBoolean sInitialized = new AtomicBoolean(false);

    static void init(Context context) {
        if (sInitialized.getAndSet(true)) {
            return;
        }
        ((Application) context.getApplicationContext())
                .registerActivityLifecycleCallbacks(new DispatcherActivityCallback());
    }

    @SuppressWarnings("WeakerAccess")
    @VisibleForTesting
    static class DispatcherActivityCallback extends EmptyActivityLifecycleCallbacks {

        @Override
        public void onActivityCreated(Activity activity, Bundle savedInstanceState) {
            ReportFragment.injectIfNeededIn(activity);
        }

        @Override
        public void onActivityStopped(Activity activity) {
        }

        @Override
        public void onActivitySaveInstanceState(Activity activity, Bundle outState) {
        }
    }

    private LifecycleDispatcher() {
    }
}

可以看到这里面也注册了registerActivityLifecycleCallbacks来监听生命周期，并在其onActivityCreated方法中创建了一个ReportFragment，哈哈还是使用ReportFragment。ReportFragment的injectIfNeededIn方法只会创建一个ReportFragment。所以即使我们在ComponentActivity中的onCreate方法中重复调用也只有一个实例。

OK到这里就看完了总结一下：

应用程序创建的时候，会初始化一个空的Fragment，虽然这个Fragment没有布局文件，但是它有一个完整的生命周期，而且生命周期跟它所在的这个Activity同步，所以我们就可以在这个Fragment的生命周期中来管理观察者的生命周期，通过addObserver方法，可以把一个我们自定义的观察者注册到Activiy中的一个集合中，当生命周期变化的时候，循环遍历集合，调用观察者相关的状态方法。

---

一般情况下lifecycle结合着ViewModel和LiveData一块使用。

Lifecycle的最佳实践

• 保持UI控制器（activities and fragments）尽可能的精简，他们中不应该有请求数据的代码，这部分的代码我们最好交给 ViewModel去做，然后通过LiveData来更新视图。
• 尝试编写数据驱动的UI，当数据改变的时候，UI控制器负责更改视图，或者把用户的操作传递给ViewModel
• 可以使用Data Binding来让activities and fragments中的代码更少更简洁。
• 如果UI界面非常复杂，可以尝试写一个presenter类来处理UI逻辑，这样可以使UI组件更容易测试。
• 避免在ViewModel中引用View或者Activity的上下文，如果ViewModel执行时间过长，会导致View和Activity无法被回收。

Lifecycle的用例

• 比如位置更新，在程序可见的时候，使用细粒度的位置更新，在程序后台运行时使用粗粒度的位置更新
• 比如视频的缓冲，我们可以在activity销毁的时候，取消视频的缓冲
• 启动和停止网络连接，在应用进入后台的时候，断开网络连接
• 暂停和恢复动画，后台时停止动画，回到前台时在启动动画