Android Architecture Components Part3:Lifecycle

上期文章咱們講解了LiveData，知道它是一個可觀察容器同時具有生命感知能力。那麼它的生命感知能力又是如何實現呢？在使用LiveData進行註冊observer時，是否記得其中的兩個參數。其一是Observer的回調，另外一個就是LifecycleOwner。它就屬於Lifecycle中的一部分。

Activity/Fragment就是具備生命狀態的組件，並且他們的生命狀態都是由操做系統或者framework來控制的，因此咱們在App中是很難來經過代碼來管理他們的生命週期。若是不遵循他們的生命週期，將會很容易致使內存泄露問題。因此若是咱們可以實現生命感知能力的話，將會幫助咱們更好的管理與生命週期有關的邏輯，而Lifecycle就是這樣一個組件。

Lifecycle

Lifecycle能夠爲界面/非界面組件添加生命週期狀態感知，容許觀察者去監聽這些生命狀態。Lifecycle主要經過兩個枚舉來追蹤生命狀態。

1. Event：表明生命事件，是由framework層分發過來的，這些事件與Activity/Fragment中的生命回調相匹配。
2. State：表明當前追蹤的組件所處的生命狀態。

Event與State的聯繫咱們能夠經過下面的圖來進一步瞭解。

依賴

在使用Lifecycle以前，咱們須要在App或者Module的build.gradle中添加以下代碼

dependencies {
    def lifecycle_version = "1.1.1"
 
    // ViewModel and LiveData
    implementation "android.arch.lifecycle:extensions:$lifecycle_version"   
    annotationProcessor "android.arch.lifecycle:compiler:$lifecycle_version"
}

LifecycleObserver

LifecycleObserver是一個接口，它沒有任何方法，做爲標誌做用，同時經過註釋來生成方法。咱們來看下它的使用方式，首先來自定義MyLifeCycleObserver

class MyLifeCycleObserver(private val lifecycle: Lifecycle) : LifecycleObserver {
    @OnLifecycleEvent(Lifecycle.Event.ON_CREATE)
    fun create() {
        if (lifecycle.currentState.isAtLeast(Lifecycle.State.CREATED)) {
           //todo ...
        }
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_START)
    fun start() {
        //todo ...
    }
}

這裏須要在自定義的方法上使用@OnLifecycleEvent註釋來標明這是一個與生命週期狀態相關的方法回調；同時經過Lifecycle.Event，即Event枚舉，來精肯定位到某一個生命週期的回調方法。

上面代碼分別定位到了ON_CREATE與ON_START，即Activity/Fragment的onCreate()與onStart()方法。同時Lifecycle提供getCurrentState()方法，能夠時刻查詢當前的生命狀態；而isAtLeast()方法則能夠比較當前的生命狀態是否大於等於某一個生命週期。經過這些方法可以更好的輔助咱們來管理界面的生命狀態。

LifecycleOwner

如今自定義的觀察者MyLifeCycleObserver已經有了，接下來要作的就是對觀察者進行註冊監聽。

class ContactsActivity : AppCompatActivity() {
 
   override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_contacts_layout)
        lifecycle.addObserver(MyLifeCycleObserver(lifecycle))
    }
}

經過獲取Lifecycle對象來添加觀察者，將咱們上面自定義的MyLifeCycleObserver加入觀察隊列。而getLifecycle()是LifecycleOwner接口中惟一的方法。AppCompatActivity/Fragment默認實現了LifecycleOwner接口。內部經過LifecycleRegistry來註冊了生命週期狀態。

這樣一旦界面的生命狀態發生了改變，就會通知咱們自定義的觀察者MyLifeCycleObserver，即回調MyLifeCycleObserver中所匹配的註釋方法。

不知不覺中經過Lifecycle咱們已經將與生命狀態相關的代碼抽離到了MyLifeCycleObserver中，實現了對Activity/Fragemnt生命狀態相關的解耦。

自定義LifecycleOwner

Activity/Fragment默認實現了LifecycleOwner接口，但必須是在Support Library 26.1.0以後才支持。因此若是咱們想要在它以前的版本使用，須要本身實現LifecycleOwner接口。

class LifecycleActivity : Activity(), LifecycleOwner {
    private lateinit var mMyLifecycle: LifecycleRegistry
 
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_contacts_layout)
        mMyLifecycle = LifecycleRegistry(this)
        mMyLifecycle.markState(Lifecycle.State.CREATED)
        lifecycle.addObserver(MyLifeCycleObserver(lifecycle))
    }
 
    override fun onStart() {
        super.onStart()
        mMyLifecycle.markState(Lifecycle.State.STARTED)
    }
 
    override fun getLifecycle(): Lifecycle = mMyLifecycle
}

首先讓咱們的class實現LifecycleOwner接口，而後藉助LifecycleRegistry來生成一個實現Lifecycle接口的對象。若是要讓咱們添加的Observer可以與以前同樣匹配生命週期方法，咱們還需爲生成的Lifecycle在生命週期方法中添加標記狀態。

如上代碼，在onCreate()方法中使用makeState()來綁定Lifecycle.State.CREATED狀態。如此，在Activity的onCreate調用的時候，咱們的MyLifeCycleObserver中的註釋onCreate方法也會相應的回調。

因此結合LifecycleObserver、LifecycleOwner與LifecycleRegistry，咱們能夠爲任意非生命感知的組件實現生命感知能力，這樣一來就能更好的幫助咱們對組件的生命週期進行管理。減小邏輯處理與沒必要要的異常發生。

Lifecycle & LiveData

那麼再回到文章最初所說的LiveData，咱們來分析LiveData是如何藉助Lifecycle來實現生命感知能力。

在這以前，假設你已經對LiveData有必定的瞭解，或者你能夠查看 Android Architecture Components Part2:LiveData進一步瞭解LiveData

首先咱們來看下LiveData的observer方法源碼

@MainThread
    public void observe(@NonNull LifecycleOwner owner, @NonNull Observer<T> observer) {
        if (owner.getLifecycle().getCurrentState() == DESTROYED) {
            // ignore
            return;
        }
        LifecycleBoundObserver wrapper = new LifecycleBoundObserver(owner, observer);
        ObserverWrapper existing = mObservers.putIfAbsent(observer, wrapper);
        if (existing != null && !existing.isAttachedTo(owner)) {
            throw new IllegalArgumentException("Cannot add the same observer"
                    + " with different lifecycles");
        }
        if (existing != null) {
            return;
        }
        owner.getLifecycle().addObserver(wrapper);
    }

在上面代碼中咱們看到了許多熟悉的代碼，顯而易見它也是經過自定義一個LifecycleBoundObserver，而後將其添加到Lifecycle的監聽隊列中。一旦生命週期發生變化就會回調LifecycleBoundObserver中的方法。而LifecycleBoundObserver實現了GenericLifecycleObserver接口。

public interface GenericLifecycleObserver extends LifecycleObserver {
    /**
     * Called when a state transition event happens.
     *
     * @param source The source of the event
     * @param event The event
     */
    void onStateChanged(LifecycleOwner source, Lifecycle.Event event);
}

在GenericLifecycleObserver咱們看到了熟悉的LifecycleObserver。本質與文章以前咱們本身自定義的MyLifeCycleObserver相同。不一樣的是它提供了onStateChanged()方法。該方法就是Lifecycle觀察到生命週期改變時通知Observer的回調方法。

Observer明白了，如今再來看下最初的Lifecycle究竟是什麼？如今咱們知道的是它來自於Activity/Fragment，咱們到Activity中尋找(Fragment也是同樣)。最後在繼承的SupportActivity中找到了咱們所須要的。

public class SupportActivity extends Activity implements LifecycleOwner {

    private LifecycleRegistry mLifecycleRegistry = new LifecycleRegistry(this);
    ...
    ...
    ...
     
    @CallSuper
    @Override
    protected void onSaveInstanceState(Bundle outState) {
        mLifecycleRegistry.markState(Lifecycle.State.CREATED);
        super.onSaveInstanceState(outState);
    }
     
    @Override
    public Lifecycle getLifecycle() {
        return mLifecycleRegistry;
    }
 
   ...
   ...
}

咱們再一次看到了LifecycleRegistry與LifecycleOwner，它的用法也與上面說起的自定義LifecycleOwner一模一樣，這裏就很少作說明。咱們再來看下它與Observer的鏈接。

如上所示當Activity的onSaveInstanceState回調時會調用markState()方法，而在其方法調用內部，最終會來到ObserverWithState。

static class ObserverWithState {
        State mState;
        GenericLifecycleObserver mLifecycleObserver;
 
        ObserverWithState(LifecycleObserver observer, State initialState) {
            mLifecycleObserver = Lifecycling.getCallback(observer);
            mState = initialState;
        }
 
        void dispatchEvent(LifecycleOwner owner, Event event) {
            State newState = getStateAfter(event);
            mState = min(mState, newState);
            mLifecycleObserver.onStateChanged(owner, event);
            mState = newState;
        }
    }

經過dispatchEvent()的方法來調用mLifecycleObserver，仔細看這個Observer就是GenericLifecycleObserver，因此它會調用onStateChanged()方法。

到這裏LifecycleObserver與LifecycleOwner就完美結合在一塊兒了，爲LiveData實現了生命狀態的感知能力。經過LiveData與Lifecycle的運用，咱們看到了Lifecycle的靈活性與它的強大生命感知能力，這樣咱們就能夠爲任意一個自定義組件或者其餘的數據容器來實現生命感知能力。Lifecycle的強大毋庸置疑。

其次要說明的是LiveData與Lifecycle的運用不只如此，這只是它的註冊監聽，而咱們真正使用的是它的postValue()與setValue()。因爲本篇文章主要是分析Lifecycle，因此這裏就很少作分析。

文章中的代碼均可以在 Github中獲取到。使用時請將分支切換到feat_architecture_components

最後作個預告，接下來咱們要了解的是AAC中的ViewModel，相信你也會立刻喜歡上它。

相關文章

Android Architecture Components Part1:Room
Android Architecture Components Part2:LiveData
Android Architecture Components Part4:ViewModel

關注

私人博客