深入瞭解Android Jetpack架構組件 - Lifecycle

一、前言

隨着Android開發模式的成熟，組件化已經成爲解耦複雜Activity的一個簡單實用的方式，因爲通過組件化可以大大降低一個Activity的代碼複雜度，並且抽離成獨立組件，實現代碼分離，避免造成內存泄漏和應用崩潰。

那麼如何實現組件生命週期同步Activity的生命週期？下面是一個BaseComponent實現和MainActivity生命週期同步的簡單實現，相信很多人第一時間都會想到這麼做或者類似的實現：

這樣做看起來是沒有問題，但是隨着組件增加，在Activity每個生命週期裏面都會放置大量代碼，使得Activity維護變得艱難，在這種背景下，Google官方推出了Lifecycle組件以幫助開發者更加簡潔地實現組件化。

二、使用

在我們升級androidx之後，裏面已經包含了lifecycle組件，如下圖所示。

我們只需要使用到其中的LifecycleObserver和LifecycleOwner即可實現組件化監聽Activity的生命週期，代碼如下所示。

public class MainActivity extends AppCompatActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        getLifecycle().addObserver(new BaseComponent());
    }
}


public class BaseComponent implements LifecycleObserver {
    private static final String TAG = "BaseComponent";

    @OnLifecycleEvent(Lifecycle.Event.ON_CREATE)
    public void onCreate() {
        Log.i(TAG, "onCreate");
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
    public void onResume() {
        Log.i(TAG, "onResume");
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_STOP)
    public void onStop() {
        Log.i(TAG, "onStop");
    }
}

三、底層實現

如果大家只滿足瞭解如何使用Lifecycle的層面，那麼本篇文章就到此爲止，下面主要是手把手帶領大家瞭解它的底層實現，一探究竟。

在窺探源碼之前，其實我們也能猜測到它的實現方式，就是利用非常常用的觀察者者模式來實現，只不過它通過反射來實現註解調用。

首先我們瞭解一下LifeOwner和LifecycleObserver兩個接口，LifeOwner的意思就是生命週期的持有者，即被觀察者，對應於Activity和Fragment，LifecycleObserver就是生命週期觀察者，對應於我們自定義的組件，它們都是接口，實現非常簡單：

LifecycleObserver、LifecycleOwner

public interface LifecycleObserver {

}

public interface LifecycleOwner {
    @NonNull
    Lifecycle getLifecycle();
}

Lifecycle

由於我們的Activity/Fragment是被觀察者，所以在androidx裏面，它們都實現了LifecycleOwner接口，所以它們要實現LifecycleOwner的接口getLifecycle()，返回一個Lifecycle實例，那麼Lifecycle是什麼呢？如下代碼所示，它是一個抽象類，需要實現addObserver、removeObserver、getCurrentState三個抽象方法，其實非常好理解，它就是一個橋接觀察者和被觀察者的橋樑，負責處理兩者關聯的邏輯，而Lifecycle的唯一實現類就是LifecycleRegistry，我們下面再說。

public abstract class Lifecycle {
  
    @MainThread
    public abstract void addObserver(@NonNull LifecycleObserver observer);

      @MainThread
    public abstract void removeObserver(@NonNull LifecycleObserver observer);

    @MainThread
    @NonNull
    public abstract State getCurrentState();

    @SuppressWarnings("WeakerAccess")
    public enum Event {

        ON_CREATE,
  
        ON_START,
     
        ON_RESUME,
      
        ON_PAUSE,
      
        ON_STOP,
      
        ON_DESTROY,
       
        ON_ANY
    }

       @SuppressWarnings("WeakerAccess")
    public enum State {
   
        DESTROYED,

        INITIALIZED,

        CREATED,

        STARTED,

        RESUMED;

        public boolean isAtLeast(@NonNull State state) {
            return compareTo(state) >= 0;
        }
    }
}

LifecycleRegistry

作爲一個橋接者，LifecycleRegistry內部維護了一個狀態值mState，它是枚舉類型State，即Lifecycle裏面定義的State，它具有DESTROYED、INITIALIZED、CREATED、STARTED、RESUMED五個狀態。

    public class LifecycleRegistry extends Lifecycle {
        /**
         * Current state
         */
        private State mState;
    }

設計者認爲被觀察者的生命週期就是從這五個狀態循環執行，這五個狀態轉換過程就響應到觀察者的Event的狀態變化，即Lifecycle裏面定義的ON_CREATE、ON_START、ON_RESUME、ON_PAUSE、ON_STOP、ON_DESTROY、ON_ANY，也是我們比較容易理解的狀態。怎麼理解State和Event之間的轉換關係呢？如下圖所示，例如當LifecycleRegistry從CREATED變化到STARTED時，觀察者就出發了ON_START事件。

這個圖在LifecycleRegistry裏面的代碼也得到證實：

public class LifecycleRegistry extends Lifecycle {
    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);
    }

    private static Event downEvent(State state) {
        switch (state) {
            case INITIALIZED:
                throw new IllegalArgumentException();
            case CREATED:
                return ON_DESTROY;
            case STARTED:
                return ON_STOP;
            case RESUMED:
                return ON_PAUSE;
            case DESTROYED:
                throw new IllegalArgumentException();
        }
        throw new IllegalArgumentException("Unexpected state value " + state);
    }
    }

EVENT變化

那麼什麼情況下會觸發Event變化，響應到觀察者呢？就是handleLifecycleEvent方法，被觀察者通過調用handleLifecycleEvent，從而觸發Event的變化。

public class LifecycleRegistry extends Lifecycle {
    public void handleLifecycleEvent(@NonNull Lifecycle.Event event) {
        State next = getStateAfter(event);
        moveToState(next);
    }
}

那麼是哪裏調用handleLifecycleEvent的呢？就是來自於一個ReportFragment的dispatch方法，在ReportFragment的每個生命週期方法都會觸發dispatch方法的調用，從而觸發LifecycleRegistry的handleLifecycleEvent方法。

public class ReportFragment extends Fragment {
  
    @Override
    public void onActivityCreated(Bundle savedInstanceState) {
        super.onActivityCreated(savedInstanceState);
        dispatch(Lifecycle.Event.ON_CREATE);
    }

    @Override
    public void onStart() {
        super.onStart();
        dispatch(Lifecycle.Event.ON_START);
    }

    @Override
    public void onResume() {
        super.onResume();
        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);
    }

    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);
            }
        }
    }
}

相信你一定知道，這個ReportFragment肯定被Activity持有，沒錯，就是ComponentActivity會在創建的時候創建一個ReportFragment：

public class ComponentActivity extends Activity
        implements LifecycleOwner, KeyEventDispatcher.Component {
   
    @Override
    @SuppressWarnings("RestrictedApi")
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        ReportFragment.injectIfNeededIn(this);
    }
}

而我們開發者使用的AppCompatActivity就是通過繼承ComponentActivity實現的：

AppCompatActivity -> FragmentActivity -> ComponentActivity -> Activity

四、總結

我們自定義的組件需要實現LifecycleObserver作爲觀察者，Activity/Fragment作爲被觀察者，它需要實現LifecycleOwner接口，並且需要實現一個Lifecycle子類LifecycleRegistry作爲橋接觀察者和被觀察者的橋樑，並且在Activity裏面實現了一個無界面的ReportFragment（生命週期與Activity同步）觸發LifecycleRegistry裏面的Event變化，從而通知到被觀察者相應事件。