内容简介:本次推出 Android Architecture Components 系列文章,目前写好了四篇,主要是关于 lifecycle,livedata 的使用和源码分析,其余的 Navigation, Paging library,Room,WorkMannager 等春节结束之后会更新,欢迎关注我的公众号,有更新的话会第一时间会在公众号上面通知。
本次推出 Android Architecture Components 系列文章,目前写好了四篇,主要是关于 lifecycle,livedata 的使用和源码分析,其余的 Navigation, Paging library,Room,WorkMannager 等春节结束之后会更新,欢迎关注我的公众号,有更新的话会第一时间会在公众号上面通知。
github sample 地址: ArchiteComponentsSample
Android 技术人,一位不羁的码农。
前言
前两篇博客,我们已经讲解了 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; } } 复制代码
- 第一步:先实现 LifecycleOwner 接口,并返回 mLifecycleRegistry
- 第二步:在 Activity 生命周期变化的时候,调用 mLifecycleRegistry.markState() 方法标记相应的状态
- 如果想添加 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 方法中,它主要干这几件事情
- 首先,先初始化状态, 判断当前 mState 是否是 DESTROYED,如果是将初始状态置为 DESTROYED,否则为 INITIALIZED,接着用 ObserverWithState 包装 observer 和 初始化状态 initialState
- 将 observer 作为 key,在缓存的 mObserverMap 中查找是否存在,如果存在,证明该 observer 已经添加过,直接返回回去,不必再进行处理。
- 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); } 复制代码
- 首先,取出 mObserverMap 中上一个的 entry,该 LifecycleRegistry 实例如果是第一次调用 addObserver 实例的话,那么是 null,否则是上一个 observer 的 entry
- 根据 previous 是否为 null,设置 siblingState 的值
- 判断 mParentStates 是否为 null,不为 null,取 mParentStates 最后一次的状态
- 取 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。如下图
从图中可以看到,有几个地方使用到他。我们先来看一下 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 里面注册了。
<manifest xmlns:android="http://schemas.android.com/apk/res/android" package="android.arch.lifecycle.extensions" > <uses-sdk android:minSdkVersion="14" /> <application> <provider android:name="android.arch.lifecycle.ProcessLifecycleOwnerInitializer" android:authorities="${applicationId}.lifecycle-trojan" android:exported="false" android:multiprocess="true" /> </application> </manifest> 复制代码
而 ContentProvider 的 onCreate 方法优先于 Application 的 onCreate 执行,所以在 Application 之前我们就调用了 ProcessLifecycleOwnerInitializer init 方法,监听了 Activity 的创建,当 Actiivty 创建的时候,会尝试为 Activity 添加 ReportFragment。而 ReportFragment 会在 Activity 生命周期变化的时候帮助我们分发生命周期。
ContentProvider 的 onCreate 方法优先于 Application 的 onCreate 执行,可以查看这一篇博客 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
Lifecycle 设计借鉴
- 利用 ProcessLifecycleOwnerInitializer contentProvider 来隐式加载
想一下,如果 ProcessLifecycleOwnerInitializer 不利用 contentProvider 来隐式加载的话,对于 普通的 Activity,旧版本等,如果想使用 lifecycle,那必须在基类中,手动调用 ReportFragment.injectIfNeededIn(activity) 的方法。
- 利用 fragment 来分发生命周期
利用 fragment 来分发生命周期有两个优点
- 将逻辑从 Activity 中剥离出来,减少耦合,方便复用
- 可以做到在 Activity onCreate 之后才回调 observer 的 CREATED Event 事件。如果是通过 Application registerActivityLifecycleCallbacks 方法来分发生命周期的话,因为 ActivityLifecycleCallbacks 的 onActivityCreated 是在 Activity oncreate 之前调用的。
以上所述就是小编给大家介绍的《Android lifecyle 源码解剖》,希望对大家有所帮助,如果大家有任何疑问请给我留言,小编会及时回复大家的。在此也非常感谢大家对 码农网 的支持!
猜你喜欢:本站部分资源来源于网络,本站转载出于传递更多信息之目的,版权归原作者或者来源机构所有,如转载稿涉及版权问题,请联系我们。