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教程