Android lifecyle 源码解剖 - gdutxiaoxu的博客(微信公众号 stormjun94)

版权声明:本文为博主原创文章,遵循CC 4.0
by-sa
版权协议,转载请附上原文出处链接和本声明。

本文链接:https://blog.csdn.net/gdutxiaoxu/article/details/86660766

说在前面

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

Android lifecycle
使用详解

Android LiveData
使用详解

Android lifecyle
源码解剖

Android livedata
源码解剖

github sample 地址:
ArchiteComponentsSample

Android 技术人,一位不羁的码农。

Android lifecyle 源码解剖 - gdutxiaoxu的博客(微信公众号 stormjun94)


前言

前两篇博客,我们已经讲解了 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。如下图

Android lifecyle 源码解剖 - gdutxiaoxu的博客(微信公众号 stormjun94)

从图中可以看到,有几个地方使用到他。我们先来看一下 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-*"
            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

Android lifecyle 源码解剖 - gdutxiaoxu的博客(微信公众号 stormjun94)

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

Android lifecyle 源码解剖 - gdutxiaoxu的博客(微信公众号 stormjun94)

上一篇:微信小程序(基础)


下一篇:微信小程序开发的movable开发的坑