Android lifecyle 源码解剖

时间  2019-12-07
标签 android lifecyle 源码 栏目 Android 繁體版
原文   原文链接

说在前面

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

Android lifecycle 使用详解java

Android LiveData 使用详解android

Android lifecyle 源码解剖git

Android livedata 源码解剖github

github sample 地址： ArchiteComponentsSample设计模式

Android 技术人，一位不羁的码农。缓存

Android 技术人

前言

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

从自定义的 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。app

接下来，咱们一块儿来看一下它的 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。以下图

从图中能够看到，有几个地方使用到他。咱们先来看一下 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 设计借鉴

  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 源码解剖

推荐阅读：

java 代理模式详解

观察者设计模式 Vs 事件委托（java）

Android Fragment 的妙用 - 优雅地申请权限和处理onActivityResult

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