Android lifecyle 源码解剖

╰半夏微凉° 2022-03-22 07:17 162阅读 0赞

## 说在前面 ##

本次推出 Android Architecture Components 系列文章，目前写好了四篇，主要是关于 lifecycle，livedata 的使用和源码分析，其余的 Navigation， Paging library，Room，WorkMannager 等春节结束之后会更新，欢迎关注我的公众号，有更新的话会第一时间会在公众号上面通知。

[Android lifecycle 使用详解][Android lifecycle]

[Android LiveData 使用详解][Android LiveData]

[Android lifecyle 源码解剖][Android lifecyle]

[Android livedata 源码解剖][Android livedata]

[github sample 地址： ArchiteComponentsSample][github sample _ ArchiteComponentsSample]

**程序员徐公**，五年中大厂开发经验，助你升职加薪，带你走进大厂

1.  公众号程序员徐公回复**黑马**，获取 Android 学习视频
2.  公众号程序员徐公回复**徐公666**，获取简历模板，教你如何优化简历，走进大厂
3.  公众号程序员徐公回复**面试**，可以获得面试常见算法，剑指 offer 题解
4.  公众号程序员徐公回复**马士兵**，可以获得马士兵学习视频一份

![程序员徐公][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2dkdXR4aWFveHU_size_16_color_FFFFFF_t_70]

--------------------

## 前言 ##

前两篇博客，我们已经讲解了 lifecycle ，liveData， ViewModel 的使用，这一篇博客，让我们一起来看一下 lifecycle 的原理。

--------------------

## 从自定义的 lifecycle 说起 ##

首先我们先来复习一下，如果要自定义 lifecycle，我们要这样做。

public class CustomLifecycleActivity extends FragmentActivity implements LifecycleOwner { 
    
        private LifecycleRegistry mLifecycleRegistry;
    
        private static final String TAG = "CustomLifecycleActivity";
    
        @Override
        protected void onCreate(Bundle savedInstanceState) { 
            super.onCreate(savedInstanceState);
            setContentView(R.layout.activity_custom_lifecycle);
            mLifecycleRegistry = new LifecycleRegistry(this);
            mLifecycleRegistry.markState(Lifecycle.State.CREATED);
            getLifecycle().addObserver(new GenericLifecycleObserver() { 
                @Override
                public void onStateChanged(LifecycleOwner source, Lifecycle.Event event) { 
                    Log.d(TAG, "onStateChanged: event = " + event);
                }
            });
    
        }
    	
    	    @Override
        protected void onStart() { 
            super.onStart();
            mLifecycleRegistry.markState(Lifecycle.State.STARTED);
        }
    
        @Override
        protected void onResume() { 
            super.onResume();
            mLifecycleRegistry.markState(Lifecycle.State.RESUMED);
        }
    
        @Override
        protected void onDestroy() { 
            super.onDestroy();
            mLifecycleRegistry.markState(Lifecycle.State.DESTROYED);
        }
    
        @NonNull
        @Override
        public Lifecycle getLifecycle() { 
            return mLifecycleRegistry;
        }
    }

1.  第一步:先实现 LifecycleOwner 接口，并返回 mLifecycleRegistry
2.  第二步：在 Activity 生命周期变化的时候，调用 mLifecycleRegistry.markState() 方法标记相应的状态
3.  如果想添加 observer，调用 addObserver 方法添加观察者，这样会在 activity 生命周期变化的时候，回调 observer 的 onchange 方法。

我们先来看一下 getLifecycle() 方法， getLifecycle() 它返回的是一个 Lifecycle 的实例，sdk 中默认的实现类为 LifecycleRegistry。

接下来，我们一起来看一下它的 observer 方法。

public void addObserver(@NonNull LifecycleObserver observer) {
      // 判断是否是 DESTROYED，如果是将初始状态置为 DESTROYED，否则为 INITIALIZED
        State initialState = mState == DESTROYED ? DESTROYED : INITIALIZED;
     // ObserverWithState 包装
        ObserverWithState statefulObserver = new ObserverWithState(observer, initialState);
    	//  将 observer 作为key，在缓存的 mObserverMap 中查找是否存在
        ObserverWithState previous = mObserverMap.putIfAbsent(observer, statefulObserver);
      
       // 存在，直接返回回去，证明该 observer 已经添加过了。否则，证明还没有添加过该 observer
        if (previous != null) {
            return;
        }
    	 
        LifecycleOwner lifecycleOwner = mLifecycleOwner.get();
        if (lifecycleOwner == null) {
            // it is null we should be destroyed. Fallback quickly
            return;
        }
    
        // 这里 mAddingObserverCounter 为 0 ，mHandlingEvent 为 false
        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--;
    }

在 addObserver 方法中，它主要干这几件事情

1.  首先，先初始化状态， 判断当前 mState 是否是 DESTROYED，如果是将初始状态置为 DESTROYED，否则为 INITIALIZED，接着用 ObserverWithState 包装 observer 和 初始化状态 initialState
2.  将 observer 作为 key，在缓存的 mObserverMap 中查找是否存在，如果存在，证明该 observer 已经添加过，直接返回回去，不必再进行处理。
3.  addObserver 方法中第 21 行 ， isReentrance 一般情况下为 false，什么情况 为 true，暂时未想到，

接下来我们先来看 calculateTargetState 方法。

private State calculateTargetState(LifecycleObserver observer) {
       // 取出 mObserverMap 的上一个 entry，previous
        Entry<LifecycleObserver, ObserverWithState> previous = mObserverMap.ceil(observer);
    
       // 如果不为空，获取它的状态
        State siblingState = previous != null ? previous.getValue().mState : null;
    	// 判断 mParentStates 是否为 null，不为 null，去最后的一个状态，否则，为 null
        State parentState = !mParentStates.isEmpty() ? mParentStates.get(mParentStates.size() - 1)
                : null;
        // 取最小的状态
        return min(min(mState, siblingState), parentState);
    }

1.  首先，取出 mObserverMap 中上一个的 entry，该 LifecycleRegistry 实例如果是第一次调用 addObserver 实例的话，那么是 null，否则是上一个 observer 的 entry
2.  根据 previous 是否为 null，设置 siblingState 的值
3.  判断 mParentStates 是否为 null，不为 null，取 mParentStates 最后一次的状态
4.  取 mState, siblingState 最小的状态 a，再取 a 与 parentState 的状态 b

public enum State {
       
        DESTROYED,
    
        INITIALIZED,
    
        CREATED,
    
        STARTED,
    
        RESUMED;
    
        public boolean isAtLeast(@NonNull State state) {
            return compareTo(state) >= 0;
        }
    }

State 中，他们排序的顺序是 DESTROYED < INITIALIZED < CREATED < STARTED < RESUMED。

我们知道，我们在 activity 的 onCreate 方法中初始化 LifecycleRegistry，并标记它的状态为 CREATED。当我们第一次在 onCreate 方法调用 addObserver 的时候，在 calculateTargetState 方法中，若是首次调用 previous 为 null，则 siblingState，parentState 为 null， 而 mState 为 CREATED，所以最终的状态为 CREATED，即 State targetState = calculateTargetState(observer); 中 targetState 为 CREATED

// 取最小的状态
        return min(min(mState, siblingState), parentState);

看完 calculateTargetState 方法，我们回过头再来看一下 addObserver 方法。

public void addObserver(@NonNull LifecycleObserver observer) {
      
      
         // 省略若干行
    
        // 这里 mAddingObserverCounter 为 0 ，mHandlingEvent 为 false
        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--;
    }

这里 statefulObserver.mState 为 DESTROYED 或者 INITIALIZED，肯定比 CREATED 小。而 mObserverMap.contains(observer) 必定为 true，除非我们手动移除掉 mObserverMap。因而，会走进 while循环。

private void pushParentState(State state) { 
        mParentStates.add(state);
    }
    
    private ArrayList<State> mParentStates = new ArrayList<>();

pushParentState(statefulObserver.mState); 很简单，只是将 statefulObserver 的状态添加到 mParentStates 集合中。

继续往下走，接着会调用 statefulObserver.dispatchEvent(lifecycleOwner, upEvent(statefulObserver.mState));

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

upEvent 方法也很简单，只是返回它的下一个 event。这里因为他们的 state为 INITIALIZED，所以它会返回 ON\_CREATE。

void dispatchEvent(LifecycleOwner owner, Event event) { 
        State newState = getStateAfter(event);
        mState = min(mState, newState);
        mLifecycleObserver.onStateChanged(owner, event);
        mState = newState;
    }
    
    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);
    }

这里 event 为 ON\_CREATE，所以 newState 也为 CREATED。 mState = min(mState, newState); mState newState，两者状态相同，所以 mState 也为 CREATED。接着回调 mLifecycleObserver 的 onStateChanged 方法。所以，这里，会收到我们的 onCreate 事件，与我们的预想相符。

**但是我们并没有在 onStart，onResume, onPause , onStop 和 onDestroy 方法中调用 mLifecycleRegistry.handleLifecycleEvent 方法，它又是怎样促发 Observer 的 onStateChanged 方法的。这里先不揭晓，我们先来看一下 26.1.0 以后的 AppCompatActivity，待会你就明白了，会感叹 google 真的牛逼！**

--------------------

## 从 26.1.0 以后 AppCompatActivity 的设计说起 ##

我们知道，在 26.1.0 以后，如果我们要使用 lifecycle，我们只需要调用以下的方法即可。

### SupportActivity ###

getLifecycle().addObserver(new GenericLifecycleObserver() { 
    
        @Override
        public void onStateChanged(LifecycleOwner source, Lifecycle.Event event) { 
            Log.d(TAG, "onStateChanged: event =" + event);
        }
    });

跟踪 getLifecycle() 方法，它会跳转到 SupportActivity 的 getLifecycle 方法 中。

public class SupportActivity extends Activity implements LifecycleOwner, Component { 
     
        private LifecycleRegistry mLifecycleRegistry = new LifecycleRegistry(this);
    
        protected void onCreate(@Nullable Bundle savedInstanceState) { 
            super.onCreate(savedInstanceState);
            ReportFragment.injectIfNeededIn(this);
        }
    	
    	    @Override
        public Lifecycle getLifecycle() { 
            return mLifecycleRegistry;
        }
    	
    }

在 SupportActivity 中，它默认为我们初始化 mLifecycleRegistry，作为一个成员变量。接着，他在  
onCreate 方法中调用了 ReportFragment.injectIfNeededIn(this); 方法。

public class ReportFragment extends Fragment { 
        private static final String REPORT_FRAGMENT_TAG = "android.arch.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();
            }
        }

在 injectIfNeededIn 方法中，它会判断我们是否已经添加 ReportFragment，没有的话，添加进去。

public class ReportFragment extends Fragment { 
        private static final String REPORT_FRAGMENT_TAG = "android.arch.lifecycle"
                + ".LifecycleDispatcher.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;
        }
    	}

然后，它在 onCreat ，onStart， onResume， onPause， onStop， onDestroy 方法中分别调用 dispatch 方法进行分发生命周期。

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

在 dispatch 方法中，会先判断 activity 是不是实现了 LifecycleRegistryOwner ，如果是，直接分发，不过不是，判断是否实现 LifecycleOwner，获取它的 lifecycle，调用它 的 handleLifecycleEvent 进行分发。

public class SupportActivity extends Activity implements LifecycleOwner, Component { 
       
        private LifecycleRegistry mLifecycleRegistry = new LifecycleRegistry(this

而很明显，高版本的 SupportActivity 实现了 LifecycleOwner 接口，并写 LifecycleOwner.getLifecycle() 是 LifecycleRegistry

### 普通的 Activity ###

对于 26.1.0 以后的版本，你会发现，对于普通的 Activity，如果你想要使用 lifecycle，你只需要实现  
LifecycleOwner 接口即可。当生命周期变化的时候，它也可以回调 Observer 的 onStateChanged 方法。

回到我们前面的问题：

**我们并没有在 onStart，onResume, onPause , onStop 和 onDestroy 方法中调用 mLifecycleRegistry.handleLifecycleEvent 方法，它又是怎样促发 onStateChanged 方法的**

\*\*我们猜想它也是通过 ReportFragment 实现的。\*\*但是在 Activity 的 onCreate 方法中，我们并没有发现它有添加 ReportFragment，我们在 As 全局搜一下，看哪些地方使用到 ReportFragment。如下图

![format_png][]

从图中可以看到，有几个地方使用到他。我们先来看一下 LifecycleDispatcher

class LifecycleDispatcher { 
    
        private static final String REPORT_FRAGMENT_TAG = "android.arch.lifecycle"
                + ".LifecycleDispatcher.report_fragment_tag";
    
        private static AtomicBoolean sInitialized = new AtomicBoolean(false);
    
        static void init(Context context) { 
            if (sInitialized.getAndSet(true)) { 
                return;
            }
    		// 在 init 方法中，监听全局 activity 的创建，从而来添加 fragment
            ((Application) context.getApplicationContext())
                    .registerActivityLifecycleCallbacks(new DispatcherActivityCallback());
        }
    
        @SuppressWarnings("WeakerAccess")
        @VisibleForTesting
        static class DispatcherActivityCallback extends EmptyActivityLifecycleCallbacks { 
            private final FragmentCallback mFragmentCallback;
    
            DispatcherActivityCallback() { 
                mFragmentCallback = new FragmentCallback();
            }
    
            @Override
            public void onActivityCreated(Activity activity, Bundle savedInstanceState) { 
                if (activity instanceof FragmentActivity) { 
                    ((FragmentActivity) activity).getSupportFragmentManager()
                            .registerFragmentLifecycleCallbacks(mFragmentCallback, true);
                }
                ReportFragment.injectIfNeededIn(activity);
            }
    
            @Override
            public void onActivityStopped(Activity activity) { 
                if (activity instanceof FragmentActivity) { 
                    markState((FragmentActivity) activity, CREATED);
                }
            }
    
            @Override
            public void onActivitySaveInstanceState(Activity activity, Bundle outState) { 
                if (activity instanceof FragmentActivity) { 
                    markState((FragmentActivity) activity, CREATED);
                }
            }
        }
    	
    	// 省略若干代码
    
    }

可以看到，它 在 init 方法中，通过 context.getApplicationContext() .registerActivityLifecycleCallbacks 监听全局 activity 的创建，在 activity oncreate 的时候，调用 ReportFragment.injectIfNeededIn(activity) ，从而来添加 fragment，进而分发相应的事件。

那 LifecycleDispatcher 的 init 方法又是在哪里调用的呢？ 我们全局搜索一下

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

可以看到它是在 ProcessLifecycleOwnerInitializer 的 onCreate 方法中调用的。而 ProcessLifecycleOwnerInitializer 是一个 ContentProvider。我们知道 ContentProvider 一般是在 AndroidManifest 中生命的。

果然，在 extensions-1.1.1.aar 中，我们惊喜地发现，它在 Manifest 里面注册了。

而 ContentProvider 的 onCreate 方法优先于 Application 的 onCreate 执行，所以在 Application 之前我们就调用了 ProcessLifecycleOwnerInitializer init 方法，监听了 Activity 的创建，当 Actiivty 创建的时候，会尝试为 Activity 添加 ReportFragment。而 ReportFragment 会在 Activity 生命周期变化的时候帮助我们分发生命周期。

ContentProvider 的 onCreate 方法优先于 Application 的 onCreate 执行，可以查看这一篇博客 [Android系统中的Application和四大组件一些方法的启动顺序和一些坑][Android_Application]

--------------------

## 总结 ##

ok，我们来梳理一下。

**对于 26.1.0 以后的 SupportActivity**

它在 Activity onCreate 的时候添加了 ReportFragment，这个 ReportFragment 相当于一个代理，它在 onActivityCreated 的时候 dispatch(Lifecycle.Event.ON\_CREATE) 进行分发生命周期，onStart， onResume, onPause, onStop, onDestroy 的时候也是如此。而 在 dispatch 中 它调用了 LifecycleRegistry handleLifecycleEvent 的方法。而 LifecycleRegistry 方法中经过一系列处理，它又调用了 observer 的 onStateChange 方法，去通知相应的 observer。

**对于普通的 Activity**

它利用了 ContentProvide 的特征，它是在 Application onCreate 之前初始化的，他在 ProcessLifecycleOwnerInitializer oncreate 的时候监听 Activity 的创建，在 Activity 创建的时候，判断是否已经添加过 ReportFragment，没有的话，添加进去。***这是一个很巧妙的设计，隐式初始化了 lifecycle。***

用流程图表示如下：

该图片引用自 [Android 架构组件（一）——Lifecycle][Android _Lifecycle]

![format_png 1][]

### Lifecycle 设计借鉴 ###

1.  利用 ProcessLifecycleOwnerInitializer contentProvider 来隐式加载

想一下，如果 ProcessLifecycleOwnerInitializer 不利用 contentProvider 来隐式加载的话，对于 普通的 Activity，旧版本等，如果想使用 lifecycle，那必须在基类中，手动调用 ReportFragment.injectIfNeededIn(activity) 的方法。

1.  利用 fragment 来分发生命周期

利用 fragment 来分发生命周期有两个优点

*  将逻辑从 Activity 中剥离出来，减少耦合，方便复用
 *  可以做到在 Activity onCreate 之后才回调 observer 的 CREATED Event 事件。如果是通过 Application registerActivityLifecycleCallbacks 方法来分发生命周期的话，因为 ActivityLifecycleCallbacks 的 onActivityCreated 是在 Activity oncreate 之前调用的。

下一篇：[Android livedata 源码解剖][Android livedata]

**推荐阅读：**

[java 代理模式详解][java]  
[观察者设计模式 Vs 事件委托（java）][Vs _java]  
[Android Fragment 的妙用 - 优雅地申请权限和处理 onActivityResult][Android Fragment _ - _ onActivityResult]

[Android lifecycle]: https://blog.csdn.net/gdutxiaoxu/article/details/86660746
[Android LiveData]: https://blog.csdn.net/gdutxiaoxu/article/details/86660760
[Android lifecyle]: https://blog.csdn.net/gdutxiaoxu/article/details/86660766
[Android livedata]: https://blog.csdn.net/gdutxiaoxu/article/details/86660776
[github sample _ ArchiteComponentsSample]: https://github.com/gdutxiaoxu/ArchiteComponentsSample
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2dkdXR4aWFveHU_size_16_color_FFFFFF_t_70]: /images/20220322/7cb3f41d92b241608e664965adae769e.png
[format_png]: /images/20220322/4abaf434bfe749bd8786d76a6fb6682f.png
[Android_Application]: https://blog.csdn.net/long117long/article/details/66477562
[Android _Lifecycle]: https://blog.csdn.net/zhuzp_blog/article/details/78871374
[format_png 1]: /images/20220322/ce49b032ce714ae1ba65220a6fc0d936.png
[java]: https://blog.csdn.net/gdutxiaoxu/article/details/81394050
[Vs _java]: https://blog.csdn.net/gdutxiaoxu/article/details/51824769
[Android Fragment _ - _ onActivityResult]: https://blog.csdn.net/gdutxiaoxu/article/details/86498647