【JetPack】Lifecycle - 生命周期观察者的简单使用和原理分析

最新推荐文章于 2022-09-25 19:58:48 发布

珍心

最新推荐文章于 2022-09-25 19:58:48 发布

阅读量397

点赞数 1

分类专栏： JetPack 文章标签： android

本文链接：https://blog.csdn.net/yuzhangzhen/article/details/110409667

版权

JetPack 专栏收录该内容

2 篇文章 0 订阅

订阅专栏

学而不思则罔，思而不学则殆

一.引言

Jetpack 是一套库、工具和指南，可帮助开发者更轻松地编写优质应用。Jetpack 是一个由多个库组成的套件，可帮助开发者遵循最佳做法，减少样板代码并编写可在各种 Android 版本和设备中一致运行的代码，让开发者精力集中编写重要的代码。

Lifecycle的出现是为了解决生命周期的建立对原生组件的侵入，比如MVP模式，P层想要判断生命周期就需要在V层手动去调用周期方法。这种方法代码的侵入性太高，不够美观，而且有时候容易忘记。Google针对这一痛点做了统一规范适配Lifecycle，减少侵入性。

Lifecycle主要是通过观察者模式+注解的方式实现组件生命周期的监听。
先来看看Lifecycle怎么使用！

二.Lifecycle 使用范例

2.1 Activity生命收起观察

Lifecycle可以观察Activity的生命周期。

2.1.1 实现LifecycleObserver

public class MyActivityObserver implements LifecycleObserver {

    private static final String TAG = MyActivityObserver.class.getName();
    
    @OnLifecycleEvent(Lifecycle.Event.ON_CREATE)
    private void workOnCreate() {
        Log.d(TAG, "workOnCreate");
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_START)
    private void workOnStart() {
        Log.d(TAG, "workOnStart");
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_ANY)
    private void workOnAny() {
        //Log.d(TAG, "workOnAny");
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
    private void workOnResume() {
        //Log.d(TAG, "workOnResume " + Thread.currentThread() + " " + Log.getStackTraceString(new Throwable()));
        Log.d(TAG, "workOnResume");
    }
    
    @OnLifecycleEvent(Lifecycle.Event.ON_PAUSE)
    private void workOnPause() {
        Log.d(TAG, "workOnPause");
    }


    @OnLifecycleEvent(Lifecycle.Event.ON_STOP)
    private void workOnStop() {
        Log.d(TAG, "workOnStop");
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_DESTROY)
    private void workOnDestroy() {
        Log.d(TAG, "workOnDestroy");
    }
}

主要就是实现LifecycleObserver 接口，内部方法通过注解@OnLifecycleEvent来表明我要观察哪个事件。
看一下注解的取值范围：

    //Lifecycle.java
    public enum Event {
        /**
         * Constant for onCreate event of the {@link LifecycleOwner}.
         */
        ON_CREATE,
        /**
         * Constant for onStart event of the {@link LifecycleOwner}.
         */
        ON_START,
        /**
         * Constant for onResume event of the {@link LifecycleOwner}.
         */
        ON_RESUME,
        /**
         * Constant for onPause event of the {@link LifecycleOwner}.
         */
        ON_PAUSE,
        /**
         * Constant for onStop event of the {@link LifecycleOwner}.
         */
        ON_STOP,
        /**
         * Constant for onDestroy event of the {@link LifecycleOwner}.
         */
        ON_DESTROY,
        /**
         * An {@link Event Event} constant that can be used to match all events.
         */
        ON_ANY
    }

主要就是对应生命周期的取值字段，但是其中混进了一个奇怪的字段【ON_ANY】,实现了该字段，返回会在任意一个事件都会回调。

2.1.2 建立订阅关系

public class MainActivity extends AppCompatActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        //建立订阅关系
        getLifecycle().addObserver(new MyActivityObserver());
    }
    ...
}

这里最新的AppCompatActivity 都已经实现了LifecycleOwner接口，可以直接获取Lifecycle,建立订阅关系

2.1.3 测试效果

2020-12-01 08:14:02.419 14410-14410/com.example.jetpack D/com.example.jetpack.lifecycle.MyActivityObserver: workOnCreate
2020-12-01 08:14:02.425 14410-14410/com.example.jetpack D/com.example.jetpack.lifecycle.MyActivityObserver: workOnStart
2020-12-01 08:14:02.427 14410-14410/com.example.jetpack D/com.example.jetpack.lifecycle.MyActivityObserver: workOnResume
2020-12-01 08:14:08.808 14410-14410/com.example.jetpack D/com.example.jetpack.lifecycle.MyActivityObserver: workOnPause
2020-12-01 08:14:08.834 14410-14410/com.example.jetpack D/com.example.jetpack.lifecycle.MyActivityObserver: workOnStop
2020-12-01 08:14:12.888 14410-14410/com.example.jetpack D/com.example.jetpack.lifecycle.MyActivityObserver: workOnStart
2020-12-01 08:14:12.890 14410-14410/com.example.jetpack D/com.example.jetpack.lifecycle.MyActivityObserver: workOnResume
2020-12-01 08:14:18.286 14410-14410/com.example.jetpack D/com.example.jetpack.lifecycle.MyActivityObserver: workOnPause
2020-12-01 08:14:19.133 14410-14410/com.example.jetpack D/com.example.jetpack.lifecycle.MyActivityObserver: workOnStop
2020-12-01 08:14:19.139 14410-14410/com.example.jetpack D/com.example.jetpack.lifecycle.MyActivityObserver: workOnDestroy

生命周期的回调会随着Activity生命周期变化回调回来。

2.2 Service生命周期观察

2.2.1 实现LifecycleObserver 接口

public class MyServiceObserver implements LifecycleObserver {
    private static final String TAG = MyServiceObserver.class.getName();

    @OnLifecycleEvent(Lifecycle.Event.ON_CREATE)
    private void start() {
        Log.d(TAG, "start");
    }


    @OnLifecycleEvent(Lifecycle.Event.ON_DESTROY)
    private void stop() {
        Log.d(TAG, "stop");
    }
}

同上

2.2.2 建立订阅关系

public class MyLifecycleService extends LifecycleService {
    public MyLifecycleService() {
        getLifecycle().addObserver(new MyServiceObserver());
    }
}

这里需要引入LifecycleService ，需要引入新的包。

    //LifecycleService,ProcessLifecycleOwner监听应用程序的生命周期
    implementation 'androidx.lifecycle:lifecycle-extensions:2.2.0'

同理LifecycleService 继承了Service 实现了LifecycleOwner 接口。

public class LifecycleService extends Service implements LifecycleOwner {
    ...
}

2.2.3 测试效果

简单实现了两个Button，用来启动和停止服务

    public void startService(View view) {
        Intent intent = new Intent(this, MyLifecycleService.class);
        startService(intent);
    }

    public void stopService(View view) {
        Intent intent = new Intent(this, MyLifecycleService.class);
        stopService(intent);
    }

测试效果：

2020-12-01 08:21:42.839 14758-14758/com.example.jetpack D/com.example.jetpack.lifecycle.MyServiceObserver: start
2020-12-01 08:21:43.552 14758-14758/com.example.jetpack D/com.example.jetpack.lifecycle.MyServiceObserver: stop
2020-12-01 08:21:45.664 14758-14758/com.example.jetpack D/com.example.jetpack.lifecycle.MyServiceObserver: start
2020-12-01 08:21:46.378 14758-14758/com.example.jetpack D/com.example.jetpack.lifecycle.MyServiceObserver: stop

当服务的生命发生变化时，会回调给观察者

2.3 Application生命周期观察

2.3.1 实现LifecycleObserver

系统没有回调ON_DESTROY事件，这点需要注意

public class ApplicationObserver implements LifecycleObserver {
    private final static String TAG = ApplicationObserver.class.getName();


    /**
     * 在应用的整个生命周期中只会调用一次
     */
    @OnLifecycleEvent(Lifecycle.Event.ON_CREATE)
    private void onCreate() {
        Log.d(TAG, "onCreate");
    }


    /**
     * 当应用程序在前台出现时被调用
     */
    @OnLifecycleEvent(Lifecycle.Event.ON_START)
    private void onStart() {
        Log.d(TAG, "onStart");
    }


    /**
     * 当应用程序在前台出现时被调用
     */
    @OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
    private void onResume() {
        Log.d(TAG, "onResume");
    }


    /**
     * 当应用程序退出到后台时被调用
     */
    @OnLifecycleEvent(Lifecycle.Event.ON_PAUSE)
    private void onPause() {
        Log.d(TAG, "onPause");
    }

    /**
     * 当应用程序退出到后台时被调用
     */
    @OnLifecycleEvent(Lifecycle.Event.ON_STOP)
    private void onStop() {
        Log.d(TAG, "onStop");
    }


    /**
     * 永远不会调用，系统不会分发调用ON_DESTROY事件
     */
    @OnLifecycleEvent(Lifecycle.Event.ON_DESTROY)
    private void onDestroy() {
        Log.d(TAG, "onDestroy");
    }
}

2.3.2 建立订阅关系

public class App extends Application {
    @Override
    public void onCreate() {
        super.onCreate();
        ProcessLifecycleOwner.get().getLifecycle().addObserver(new ApplicationObserver());
    }
}

2.3.3 测试结果

2020-12-01 08:28:00.768 14969-14969/com.example.jetpack D/com.example.jetpack.lifecycle.ApplicationObserver: onCreate
2020-12-01 08:28:01.110 14969-14969/com.example.jetpack D/com.example.jetpack.lifecycle.ApplicationObserver: onStart
2020-12-01 08:28:01.111 14969-14969/com.example.jetpack D/com.example.jetpack.lifecycle.ApplicationObserver: onResume
2020-12-01 08:28:07.467 14969-14969/com.example.jetpack D/com.example.jetpack.lifecycle.ApplicationObserver: onPause
2020-12-01 08:28:07.467 14969-14969/com.example.jetpack D/com.example.jetpack.lifecycle.ApplicationObserver: onStop
2020-12-01 08:28:12.734 14969-14969/com.example.jetpack D/com.example.jetpack.lifecycle.ApplicationObserver: onStart
2020-12-01 08:28:12.735 14969-14969/com.example.jetpack D/com.example.jetpack.lifecycle.ApplicationObserver: onResume
2020-12-01 08:28:29.329 14969-14969/com.example.jetpack D/com.example.jetpack.lifecycle.ApplicationObserver: onPause
2020-12-01 08:28:29.329 14969-14969/com.example.jetpack D/com.example.jetpack.lifecycle.ApplicationObserver: onStop

首先没有回调ON_DESTROY事件。其次是如果当前是onResume状态，启动其他页面，状态是不会发生变化的。

三.Lifecycle 原理分析

通过前面的范例使用，我们大概了解了Lifecycle 的使用方法，俗话说不仅知其然还要知其所以然，接下来我们来分析一下Lifecycle 的原理。
在这里插入图片描述

先看主要的三个类或者接口。

LifecycleOwner 负责提供Lifecycle 已经默认实现了
LifecycleObserver 用户自定义实现接口，观察者，通过方法注解被调用
Lifecycle 添加观察者，删除观察者，事件回调给LifecycleObserver

3.1 Activity级别 - FragmentActivity

最新的模块中Activity已经自动实现了,如下代码：

public class ComponentActivity extends androidx.core.app.ComponentActivity implements
        LifecycleOwner,
        ViewModelStoreOwner,
        HasDefaultViewModelProviderFactory,
        SavedStateRegistryOwner,
        OnBackPressedDispatcherOwner {
        ...
    private final LifecycleRegistry mLifecycleRegistry = new LifecycleRegistry(this);
    
    @NonNull
    @Override
    public Lifecycle getLifecycle() {
        return mLifecycleRegistry;
    }
        ...
}

再来看看Activity是怎么分发状态给Lifecycle 的。

public class FragmentActivity extends ComponentActivity implements
        ActivityCompat.OnRequestPermissionsResultCallback,
        ActivityCompat.RequestPermissionsRequestCodeValidator {
    ...
    final LifecycleRegistry mFragmentLifecycleRegistry = new LifecycleRegistry(this);
    ...
        @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        ...
        super.onCreate(savedInstanceState);

        mFragmentLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_CREATE);
        mFragments.dispatchCreate();
    }

    @Override
    protected void onPause() {
        super.onPause();
        mResumed = false;
        mFragments.dispatchPause();
        mFragmentLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_PAUSE);
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
        mFragments.dispatchDestroy();
        mFragmentLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_DESTROY);
    }
    
    @Override
    protected void onPostResume() {
        super.onPostResume();
        onResumeFragments();
    }

    /**
     * This is the fragment-orientated version of {@link #onResume()} that you
     * can override to perform operations in the Activity at the same point
     * where its fragments are resumed.  Be sure to always call through to
     * the super-class.
     */
    protected void onResumeFragments() {
        mFragmentLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_RESUME);
        mFragments.dispatchResume();
    }
    
    @Override
    protected void onSaveInstanceState(@NonNull Bundle outState) {
        super.onSaveInstanceState(outState);
        markFragmentsCreated();
        mFragmentLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_STOP);
       ...
    }
    
    @Override
    protected void onStart() {
        super.onStart();
        ...
        mFragmentLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_START);
        mFragments.dispatchStart();
    }
    
    @Override
    protected void onStop() {
        super.onStop();
        ...
        mFragments.dispatchStop();
        mFragmentLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_STOP);
    }
}

可见当Activity的生命周期被调用时，同步调用一下LifecycleRegistry的handleLifecycleEvent的方法，该方法内部会去分发有观察Lifecycle.Event的事件的观察者。

在这里插入图片描述
通过查看handleLifecycleEvent的方法的调用者可看到主要分为四大类，分别是Fragment,FragmentActivity,ProcessLifecycleOwner和ServiceLifecycleDispatcher，这四个就是分别处理对应的生命周期回调

对象	说明
Fragment	处理Fragment的生命周期观察回调
FragmentActivity	处理Activity的生命周期观察回调
ServiceLifecycleDispatcher	处理Service的生命周期观察回调
ProcessLifecycleOwner	处理进程的生命周期观察回调

3.2 Service级别 - ServiceLifecycleDispatcher

查看LifecycleService 源码，很明实现了LifecycleOwner 接口，内部通过ServiceLifecycleDispatcher 来进行事件观察回调。源码如下：

public class LifecycleService extends Service implements LifecycleOwner {

    private final ServiceLifecycleDispatcher mDispatcher = new ServiceLifecycleDispatcher(this);

    @CallSuper
    @Override
    public void onCreate() {
        mDispatcher.onServicePreSuperOnCreate();
        super.onCreate();
    }

    @CallSuper
    @Nullable
    @Override
    public IBinder onBind(@NonNull Intent intent) {
        mDispatcher.onServicePreSuperOnBind();
        return null;
    }

    @SuppressWarnings("deprecation")
    @CallSuper
    @Override
    public void onStart(@Nullable Intent intent, int startId) {
        mDispatcher.onServicePreSuperOnStart();
        super.onStart(intent, startId);
    }

    // this method is added only to annotate it with @CallSuper.
    // In usual service super.onStartCommand is no-op, but in LifecycleService
    // it results in mDispatcher.onServicePreSuperOnStart() call, because
    // super.onStartCommand calls onStart().
    @CallSuper
    @Override
    public int onStartCommand(@Nullable Intent intent, int flags, int startId) {
        return super.onStartCommand(intent, flags, startId);
    }

    @CallSuper
    @Override
    public void onDestroy() {
        mDispatcher.onServicePreSuperOnDestroy();
        super.onDestroy();
    }

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

查看ServiceLifecycleDispatcher 内部源码，代码很少，结构很清晰。持有LifecycleRegistry 对象，通过LifecycleRegistry 的handleLifecycleEvent发送观察事件处理，本身通过一个Handler来实现队列发送处理。

public class ServiceLifecycleDispatcher {
    private final LifecycleRegistry mRegistry;
    private final Handler mHandler;
    private DispatchRunnable mLastDispatchRunnable;

    /**
     * @param provider {@link LifecycleOwner} for a service, usually it is a service itself
     */
    public ServiceLifecycleDispatcher(@NonNull LifecycleOwner provider) {
        mRegistry = new LifecycleRegistry(provider);
        mHandler = new Handler();
    }

    private void postDispatchRunnable(Lifecycle.Event event) {
        if (mLastDispatchRunnable != null) {
            mLastDispatchRunnable.run();
        }
        mLastDispatchRunnable = new DispatchRunnable(mRegistry, event);
        mHandler.postAtFrontOfQueue(mLastDispatchRunnable);
    }

    /**
     * Must be a first call in {@link Service#onCreate()} method, even before super.onCreate call.
     */
    public void onServicePreSuperOnCreate() {
        postDispatchRunnable(Lifecycle.Event.ON_CREATE);
    }

    /**
     * Must be a first call in {@link Service#onBind(Intent)} method, even before super.onBind
     * call.
     */
    public void onServicePreSuperOnBind() {
        postDispatchRunnable(Lifecycle.Event.ON_START);
    }

    /**
     * Must be a first call in {@link Service#onStart(Intent, int)} or
     * {@link Service#onStartCommand(Intent, int, int)} methods, even before
     * a corresponding super call.
     */
    public void onServicePreSuperOnStart() {
        postDispatchRunnable(Lifecycle.Event.ON_START);
    }

    /**
     * Must be a first call in {@link Service#onDestroy()} method, even before super.OnDestroy
     * call.
     */
    public void onServicePreSuperOnDestroy() {
        postDispatchRunnable(Lifecycle.Event.ON_STOP);
        postDispatchRunnable(Lifecycle.Event.ON_DESTROY);
    }

    /**
     * @return {@link Lifecycle} for the given {@link LifecycleOwner}
     */
    @NonNull
    public Lifecycle getLifecycle() {
        return mRegistry;
    }

    static class DispatchRunnable implements Runnable {
        private final LifecycleRegistry mRegistry;
        final Lifecycle.Event mEvent;
        private boolean mWasExecuted = false;

        DispatchRunnable(@NonNull LifecycleRegistry registry, Lifecycle.Event event) {
            mRegistry = registry;
            mEvent = event;
        }

        @Override
        public void run() {
            if (!mWasExecuted) {
                mRegistry.handleLifecycleEvent(mEvent);
                mWasExecuted = true;
            }
        }
    }
}

3.3 Application级别 - ProcessLifecycleOwner

查看内部源码ProcessLifecycleOwner ，代码量也不是很多，很清晰。

public class ProcessLifecycleOwner implements LifecycleOwner {

    @VisibleForTesting
    static final long TIMEOUT_MS = 700; //mls
    ...
    private Handler mHandler;
    private final LifecycleRegistry mRegistry = new LifecycleRegistry(this);

    private Runnable mDelayedPauseRunnable = new Runnable() {
        @Override
        public void run() {
            dispatchPauseIfNeeded();
            dispatchStopIfNeeded();
        }
    };
    ...
    private static final ProcessLifecycleOwner sInstance = new ProcessLifecycleOwner();

    @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() {
            ...
        });
    }

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

ProcessLifecycleOwner 是通过单例模式构建ProcessLifecycleOwner 实例sInstance。保证一个进程只有一个实例。然后注册registerActivityLifecycleCallbacks用来观察整个进程的Activity的生命收起回调，然后来计算进程的生命周期回调。感兴趣的同学可以研究一下。
还有一点这里需要仔细看一下，在发送mDelayedPauseRunnable事件的时候，这里有延迟700毫秒处理，没有立马处理，是为了给Activity重新初始化提供一些时间，防止有些机器启动页面有些慢，提供一下缓冲时间。

通过如上的分析我们已经知道了，无论是Activity，Fragment,Service还是Application的Lifecycle观察，内部都是通过LifecycleRegistry 来进行处理的，入口是LifecycleRegistry.handleLifecycleEvent方法。接下来就来分析一个LifecycleRegistry 的内部原理。

3.4 LifecycleRegistry原理分析

分析原理之前先来一张时序图：
在这里插入图片描述
整体来说外部通过调用handleLifecycleEvent方法来分发状态。

    /**
     * Sets the current state and notifies the observers.
     * <p>
     * Note that if the {@code currentState} is the same state as the last call to this method,
     * calling this method has no effect.
     *
     * @param event The event that was received
     */
    public void handleLifecycleEvent(@NonNull Lifecycle.Event event) {
        State next = getStateAfter(event);
        moveToState(next);
    }

我理解为该方法是获取当前事件的后的状态。

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

当ON_CREATE和ON_STOP事件后状态为CREATED
当ON_START和ON_PAUSE事件后状态为STARTED
当ON_RESUME事件后状态为RESUMED
当ON_DESTROY事件后状态为DESTROYED
ON_ANY不做处理

有大佬画了张图，很不错，就直接拿过来用了。推荐一下文章Android Arch LifeCycle用法详解与源码解析

在这里插入图片描述
上面这个方法跟这张图完美的契合了。
还有两个方法也可以结合这个图来分析：

根据状态判断接下来的事件。

   private static Event downEvent(State state) {
        switch (state) {
            case INITIALIZED:
                throw new IllegalArgumentException();
            case CREATED:
                return ON_DESTROY;
            case STARTED:
                return ON_STOP;
            case RESUMED:
                return ON_PAUSE;
            case DESTROYED:
                throw new IllegalArgumentException();
        }
        throw new IllegalArgumentException("Unexpected state value " + state);
    }

获取降级事件，结合图片来理解：

如果状态是INITIALIZED，那么不能降级了，没有可以降级的事件，抛出异常
如果是CREATED状态，要降级的话只能是收到ON_DESTROY事件，变成DESTROYED状态
如果是STARTED状态，要降级的话只能收到ON_STOP事件，降级成CREATED状态
如果是RESUMED状态，要降级的话只能收到ON_PAUSE事件，降级成STARTED状态
如果是DESTROYED状态，那么就不能降级了，意思是已经是最低等级，不能在降级了，抛出异常

    private static Event upEvent(State state) {
        switch (state) {
            case INITIALIZED:
            case DESTROYED:
                return ON_CREATE;
            case CREATED:
                return ON_START;
            case STARTED:
                return ON_RESUME;
            case RESUMED:
                throw new IllegalArgumentException();
        }
        throw new IllegalArgumentException("Unexpected state value " + state);
    }

获取状态想要升级的话需要的事件，结合图片来分析一下。

如果当前状态是INITIALIZED，DESTROYED状态，要升级状态需要接收ON_CREATE事件，升级成CREATED状态
如果当前状态是CREATED，要升级需要接收ON_START事件，升级成STARTED状态
如果当前状态是STARTED，要升级需要接收ON_RESUME事件，升级成为RESUMED状态
如果当前状态是RESUMED，就不能再升级了，抛出异常，意思是说已经是最高等级了。

通过上面的分析，我们了解到，新的模式中为组件的状态有分级处理。有等级高和等级低的说法。
画一个简单的模型理解一下：
在这里插入图片描述
刚刚在handleLifecycleEvent方法中获取接受到的事件的后一个状态。

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

把mState 设置为当前的状态，然后通过sync方法同步当前状态。

    // happens only on the top of stack (never in reentrance),
    // so it doesn't have to take in account parents
    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;
    }

在sync方法中。主要是while循环，判断需不需要同步。

判断mObserverMap的最早添加的元素和最新添加元素Value元素是否相等，如果相等且状态等于最新状态，则不需要同步，泛指需要同步。

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

之前没有说过mObserverMap，我们先来看看mObserverMap什么时候设置元素。

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

设置观察者，添加订阅的时候设置数据，其中key值是LifecycleObserver ，value值是ObserverWithState 对象。这里看着很简单，实际上在ObserverWithState 对象初始的时候干了很多事，主要及时解析observer中的方法，为后面同步状态，反射调用提供基础。

还是回到sync这个方法。当判断需要同步状态的时候，这里又需要在判断一下，需要往上还是往下，前面我们说了状态有等级高低的说法。比如当前状态是STARTED，之前的状态是RESUMED，就要调用backwardPass方法，实现状态降级。反之，之前的状态是CREATED状态，那么就需要调用forwardPass实现状态升级的观察回调。

状态降级处理

backwardPass状态降级处理，状态升级处理原理是一样的，知道了降级处理逻辑，升级逻辑就明白了。

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

根据刚刚我们知道每注册一个观察者就有一对Entry<LifecycleObserver, ObserverWithState>对象。其中ObserverWithState就代表一个观察者实例，而且保存了其状态。然后循环处理每一个观察者，拿到其当前的状态，然后通过downEvent方法获取当前状态需要降级需要的事件。然后交个ObserverWithState的dispatchEvent方法处理。

ObserverWithState类源码如下，mState保存当前的状态，mLifecycleObserver持有了真正的需要调用的方法处理，是一种静态代理模式

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

LifecycleEventObserver 之间的类图如下。
在这里插入图片描述
然后走到ReflectiveGenericLifecycleObserver实例中。
ReflectiveGenericLifecycleObserver源码如下：

class ReflectiveGenericLifecycleObserver implements LifecycleEventObserver {
    private final Object mWrapped;
    private final CallbackInfo mInfo;

    ReflectiveGenericLifecycleObserver(Object wrapped) {
        mWrapped = wrapped;
        mInfo = ClassesInfoCache.sInstance.getInfo(mWrapped.getClass());
    }

    @Override
    public void onStateChanged(@NonNull LifecycleOwner source, @NonNull Event event) {
        mInfo.invokeCallbacks(source, event, mWrapped);
    }
}

ReflectiveGenericLifecycleObserver代码很少，直接就走到了CallbackInfo 的invokeCallbacks方法。其中mWrapped就是我们之前注册是传入的自定义LifecycleObserver实例对象。
CallbackInfo 源码如下：

    static class CallbackInfo {
        final Map<Lifecycle.Event, List<MethodReference>> mEventToHandlers;
        final Map<MethodReference, Lifecycle.Event> mHandlerToEvent;

        CallbackInfo(Map<MethodReference, Lifecycle.Event> handlerToEvent) {
            ...
        }

        @SuppressWarnings("ConstantConditions")
        void invokeCallbacks(LifecycleOwner source, Lifecycle.Event event, Object target) {
            invokeMethodsForEvent(mEventToHandlers.get(event), source, event, target);
            invokeMethodsForEvent(mEventToHandlers.get(Lifecycle.Event.ON_ANY), source, event,
                    target);
        }

        private static void invokeMethodsForEvent(List<MethodReference> handlers,
                LifecycleOwner source, Lifecycle.Event event, Object mWrapped) {
            if (handlers != null) {
                for (int i = handlers.size() - 1; i >= 0; i--) {
                    handlers.get(i).invokeCallback(source, event, mWrapped);
                }
            }
        }
    }

这里不知道大家有没有注意到，这里没有调用了两次invokeMethodsForEvent方法，一次是传入的event，一次是Lifecycle.Event.ON_ANY。这就是为啥注解实现了Lifecycle.Event.ON_ANY的方法每次都会被调用。但是是后调用的哟。

CallbackInfo 可以理解为是一个具体累的解析集合类。其中由于反射调用是昂贵的，所有都是有缓存的.
首先作为单例模式的ClassesInfoCache ，getInfo方法每次回会先从缓存中获取CallbackInfo ，没有才会去createInfo。

class ClassesInfoCache {

    static ClassesInfoCache sInstance = new ClassesInfoCache();
    ...
    private final Map<Class<?>, CallbackInfo> mCallbackMap = new HashMap<>();
    ...
    CallbackInfo getInfo(Class<?> klass) {
        CallbackInfo existing = mCallbackMap.get(klass);
        if (existing != null) {
            return existing;
        }
        existing = createInfo(klass, null);
        return existing;
    }
    ...
 }

这里为啥直接使用的是HashMap?
因为这些方法理论上都是主线程调用，不存在线程安全问题。

MethodReference可以理解为是带有@OnLifecycleEvent注解的方法解析对象。
CallbackInfo 内部持有了两个Map集合。其中mEventToHandlers是Lifecycle.Event最为键值，List最为V值。

这里为啥Lifecycle.Event对应的是一个List集合呢？
因为LifecycleObserver类中可能有多个方法实现了同一个注解的值
比如：

public class MyActivityObserver implements LifecycleObserver {

    private static final String TAG = MyActivityObserver.class.getName();

    @OnLifecycleEvent(Lifecycle.Event.ON_CREATE)
    private void workOnCreate() {
        Log.d(TAG, "workOnCreate");
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_START)
    private void workOnStart() {
        Log.d(TAG, "workOnStart");
    }
    ...
}

MethodReference 代表每个方法的引用，内部直接通过反射调用方法，实现了生命周期和观察者的分离。

    static class MethodReference {
        final int mCallType;
        final Method mMethod;

        MethodReference(int callType, Method method) {
            mCallType = callType;
            mMethod = method;
            mMethod.setAccessible(true);
        }

        void invokeCallback(LifecycleOwner source, Lifecycle.Event event, Object target) {
            //noinspection TryWithIdenticalCatches
            try {
                switch (mCallType) {
                    case CALL_TYPE_NO_ARG:
                        mMethod.invoke(target);
                        break;
                    case CALL_TYPE_PROVIDER:
                        mMethod.invoke(target, source);
                        break;
                    case CALL_TYPE_PROVIDER_WITH_EVENT:
                        mMethod.invoke(target, source, event);
                        break;
                }
            } catch (InvocationTargetException e) {
                throw new RuntimeException("Failed to call observer method", e.getCause());
            } catch (IllegalAccessException e) {
                throw new RuntimeException(e);
            }
        }
  }

到这里整个流程就结束了。欢迎阅读，你的点赞就是我分享的动力！！！
有一点我要说一下，就是生命周期的状态等级很重要，在LiveData中，实现自动分离，防止内存泄漏。小伙伴们可以多多注意留心一下

四.总结

type	Activity&Fragment	Service	Application
ON_CREATE	onCreate是调用	服务onCreate时	进程启动时调用
ON_START	onStart时调用	服务onBind或者onStart时	进程第一个页面onStart
ON_RESUME	onResume时调用	-	进程第一个页面onResume
ON_PAUSE	onPause时调用	-	进程退出到后台时
ON_STOP	onStop时调用	服务onDestroy时调用	进程退出到后台时
ON_DESTROY	onDestrop时调用	服务onDestroy时调用	不会调用
ON_ANY	-	-	上面所有情况被调用时都会被调用

珍心

关注

1
点赞
踩
2

收藏

觉得还不错? 一键收藏
1
评论
【JetPack】Lifecycle - 生命周期观察者的简单使用和原理分析

学而不思则罔，思而不学则殆【JetPack】Lifecycle - 生命周期观察者的简单使用和原理分析一.引言二.JetPack使用范例Activity生命收起观察Service生命周期观察Application生命周期观察三.JetPack原理分析Activity级别Service级别Application级别四.总结一.引言二.JetPack使用范例Activity生命收起观察Service生命周期观察Application生命周期观察三.JetPack原理分析Activity级别S
复制链接

扫一扫

专栏目录