官網(wǎng)Lifecycle文檔

一：Lifecycle的集成

1.1采用下面的方式骇笔，添加注解和集成implementation找到默認(rèn)的DefaultLifecycleObserver

老版本  
    def lifecycle_version = "2.4.0"
annotationProcessor "androidx.lifecycle:lifecycle-compiler:$lifecycle_version"
    // alternately - if using Java8, use the following instead of lifecycle-compiler
  implementation "androidx.lifecycle:lifecycle-common-java8:$lifecycle_version"
      
新版本
  // Annotation processor
    annotationProcessor "androidx.lifecycle:lifecycle-compiler:$lifecycle_version"
    // alternately - if using Java8, use the following instead of lifecycle-compiler存在DefaultLifecycleObserver
    api "androidx.lifecycle:lifecycle-common-java8:$lifecycle_version"
    //暫時(shí)還么有生效，采用lifecycle-common-java8:
//    api "androidx.lifecycle:lifecycle-common:$lifecycle_version"

截止2021.12.17更新的時(shí)候發(fā)現(xiàn)最新并不是2.4.0，二是2.3.1，但是該版本并沒(méi)有默認(rèn)的DefaultLifecycleObserver，所以還是改用老方式，或者自己實(shí)現(xiàn)FullLifecycleObserver是一樣的結(jié)果，自己復(fù)寫(xiě)里面的oncreate等方法灸叼，實(shí)現(xiàn)需要的邏輯

image.png

image.png

image.png

二：使用樣例

2.1推薦使用DefaultLifecycleObserver或者LifecycleEventObserver

官網(wǎng)說(shuō)明：自 2.3.0 以來(lái)的重要變更廢棄了 @OnLifecycleEvent。應(yīng)改用 LifecycleEventObserver 或 DefaultLifecycleObserver你画。

2.1.1:創(chuàng)建觀察者抵碟，默認(rèn)繼承DefaultLifecycleObserver，實(shí)現(xiàn)里面的默認(rèn)生命周期

package com.cc.qq.jetpack;


import androidx.annotation.NonNull;
import androidx.lifecycle.DefaultLifecycleObserver;
import androidx.lifecycle.LifecycleOwner;

public class LifeCycleListener implements DefaultLifecycleObserver {
    @Override
    public void onCreate(@NonNull LifecycleOwner owner) {

    }

    @Override
    public void onResume(@NonNull LifecycleOwner owner) {

    }

    @Override
    public void onPause(@NonNull LifecycleOwner owner) {
        
    }

    @Override
    public void onDestroy(@NonNull LifecycleOwner owner) {

    }
}

2.1.2：MainActivity添加創(chuàng)建的Observer：LifeCycleListener

package com.cc.qq.jetpack;

import android.os.Bundle;

import androidx.annotation.Nullable;
import androidx.appcompat.app.AppCompatActivity;

import com.cc.qq.R;


public class LifeCyclerActivity extends AppCompatActivity {
    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_rx);
        getLifecycle().addObserver(new LifeCycleListener());
    }
}

三：原理分析

3.1：LifeCyclerActivity層級(jí)關(guān)系

image.png

3.2：分析父類在app/ComponetActivity和activity/CompoentActivity

• 1坏匪、兩個(gè)目錄下的Activity均存在一個(gè)ReportFragment
• 2拟逮、兩個(gè)ComponetActivity均實(shí)現(xiàn)了LifecycleOwner接口
• 3、LifecycleOwner中持有一個(gè)Lifecycle生命周期适滓，在兩個(gè)ComponetActivity都實(shí)現(xiàn)了LifecycleOwner接口的getLifecycle（）方法獲取生命周期敦迄，該生命周期實(shí)現(xiàn)類為L(zhǎng)ifecycleRegistry

3.2.1：先看看ComponentActivity

1、 app/ComponetActivity和activity/CompoentActivity
@SuppressLint("RestrictedApi")
    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        ReportFragment.injectIfNeededIn(this);
    }

    private LifecycleRegistry mLifecycleRegistry = new LifecycleRegistry(this);
    
    @NonNull
    @Override
    public Lifecycle getLifecycle() {
        return mLifecycleRegistry;
    }

3.2.2：看看 ReportFragment中的injectIfNeededIn創(chuàng)建Fragment凭迹，F(xiàn)ragment中還有生命周期和dispatch方法

當(dāng)ReportFragment生命周期變化的時(shí)候會(huì)調(diào)用dispatch（event）發(fā)方法罚屋，猶豫Activity實(shí)現(xiàn)了LifecycleOwner接口，所以會(huì)調(diào)用LifecycleRegistry#handleLifecycleEvent（）

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

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

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

3.2.3：LifecycleRegistry#handleLifecycleEvent方法

根據(jù)handleLifecycleEvent傳遞進(jìn)來(lái)的Lifecycle.Event 參數(shù)蕊苗，返回對(duì)應(yīng)的State

1、LifecycleRegistry#handleLifecycleEvent
public void handleLifecycleEvent(@NonNull Lifecycle.Event event) {
        State next = getStateAfter(event);
        moveToState(next);
    }
2沿彭、LifecycleRegistry#getStateAfter(event);
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);
    }
3朽砰、LifecycleRegistry#3、LifecycleRegistry#moveToState
 private void moveToState(State next) {
        if (mState == next) {
            return;
        }
        mState = next;
        if (mHandlingEvent || mAddingObserverCounter != 0) {
            mNewEventOccurred = true;
            // we will figure out what to do on upper level.
            return;
        }
        mHandlingEvent = true;
        sync();
        mHandlingEvent = false;
    }
4、LifecycleRegistry#sync
private void sync() {
        //得到的是Activity
        LifecycleOwner lifecycleOwner = mLifecycleOwner.get();
        if (lifecycleOwner == null) {
            throw new IllegalStateException("LifecycleOwner of this LifecycleRegistry is already"
                    + "garbage collected. It is too late to change lifecycle state.");
        }
        //由下面5處得知isSynced為false,則繼續(xù)往下執(zhí)行瞧柔。
        //枚舉比較大小漆弄，越前面越小，
        //a造锅、如果新傳遞過(guò)來(lái)的生命周期狀態(tài)比所有觀察者中最先添加進(jìn)去的觀察者生命周期還小
        //那么執(zhí)行backwardPass（lifecycleOwner被觀察者Activity）撼唾，什么情況下會(huì)觸發(fā)次場(chǎng)景呢？
        //b哥蔚、如果新傳遞過(guò)來(lái)的生命周期狀態(tài)比所有觀察者中最先添加進(jìn)去的觀察者生命周期還大
        //那么執(zhí)行forwardPass（lifecycleOwner被觀察者Activity）倒谷，什么情況下會(huì)觸發(fā)次場(chǎng)景呢？
        
        while (!isSynced()) {
            mNewEventOccurred = false;
            // no need to check eldest for nullability, because isSynced does it for us.
            if (mState.compareTo(mObserverMap.eldest().getValue().mState) < 0) {
                backwardPass(lifecycleOwner);
            }
            Entry<LifecycleObserver, ObserverWithState> newest = mObserverMap.newest();
            if (!mNewEventOccurred && newest != null
                    && mState.compareTo(newest.getValue().mState) > 0) {
                forwardPass(lifecycleOwner);
            }
        }
        mNewEventOccurred = false;
    }
 5糙箍、 LifecycleRegistry#isSynced
 private boolean isSynced() {
        if (mObserverMap.size() == 0) {
            return true;
        }
        //匹配里面mObserverMap所有的觀察者最老的和最新的狀態(tài)是否一致
        State eldestObserverState = mObserverMap.eldest().getValue().mState;
        State newestObserverState = mObserverMap.newest().getValue().mState;
        //先檢查是否一致
        //mState = INITIALIZED;mState默認(rèn)初始狀態(tài)
        //當(dāng)Fragment生命周期發(fā)生變化時(shí)將Event生命周期事件傳遞過(guò)來(lái)moveToState（event）
        //傳遞過(guò)來(lái)后調(diào)用mState=event渤愁，
        //判斷條件1是否只存在一個(gè)觀察者：一般不止一個(gè)
        //判斷條件2最新的觀察者生命周期是否為傳遞過(guò)來(lái)的：一般不相等，所以一般是false深夯，走到上面分析4處
        return eldestObserverState == newestObserverState && mState == newestObserverState;
    }
 6抖格、LifecycleRegistry#mObserverMap是一個(gè)存有State的觀察者，addObserve的時(shí)候添加值
 private FastSafeIterableMap<LifecycleObserver, ObserverWithState> mObserverMap =
            new FastSafeIterableMap<>();
7咕晋、
public enum State {
    //按照這個(gè)正向走則是forwardPass雹拄，因?yàn)閭鬟f過(guò)來(lái)的往后，相當(dāng)于創(chuàng)建Activity的過(guò)程掌呜。
    //逆向走則是往后backwardPass滓玖，因?yàn)槭堑怪呖梢钥闯鰜?lái)是生命周期結(jié)束的過(guò)程
    DESTROYED，INITIALIZED站辉，CREATED呢撞，STARTED，RESUMED
}
8饰剥、
public enum Event {
    ON_CREATE殊霞，ON_START，ON_RESUME汰蓉，ON_PAUSE绷蹲，ON_STOP，ON_DESTROY顾孽，ON_ANY
}

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

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



9祝钢、
  private void forwardPass(LifecycleOwner lifecycleOwner) {
        Iterator<Entry<LifecycleObserver, ObserverWithState>> ascendingIterator =
                mObserverMap.iteratorWithAdditions();
        //循環(huán)遍歷mObserverMap觀察者
        while (ascendingIterator.hasNext() && !mNewEventOccurred) {
            Entry<LifecycleObserver, ObserverWithState> entry = ascendingIterator.next();
            ObserverWithState observer = entry.getValue();
            //小于《狀態(tài)順流走，也就是往右走若厚，往下走拦英，往前走
            while ((observer.mState.compareTo(mState) < 0 && !mNewEventOccurred
                    && mObserverMap.contains(entry.getKey()))) {
                    //添加新的狀態(tài)進(jìn)去
                pushParentState(observer.mState);
                //觀察者分發(fā)事件，執(zhí)行裝飾模式后的Observable的onStateChanged（）
                //DefaultLifecycleObserver extends FullLifecycleObserver测秸，
                //FullLifecycleObserverAdapter extends LifecycleEventObserver extends LifecycleObserver
                //FullLifecycleObserverAdapter#onStateChanged（）通過(guò)switch語(yǔ)句判斷生命周期疤估，
                //從而讓觀察者調(diào)用自己實(shí)現(xiàn)的生命周期方法灾常，就是上面自定義的LifecycleListener，可以換一個(gè)名字铃拇。钞瀑。
                //注意：如果直接 extends LifecycleObserver，那需要添加事件注解慷荔，通過(guò)反射來(lái)達(dá)到目的雕什，損失性能
                所以官方推薦DefaultLifecycleObserver或者LifecycleEventObserver
                observer.dispatchEvent(lifecycleOwner, upEvent(observer.mState));
                popParentState();
            }
        }
    }

//同forwardPass
    private void backwardPass(LifecycleOwner lifecycleOwner) {
        Iterator<Entry<LifecycleObserver, ObserverWithState>> descendingIterator =
                mObserverMap.descendingIterator();
        while (descendingIterator.hasNext() && !mNewEventOccurred) {
            Entry<LifecycleObserver, ObserverWithState> entry = descendingIterator.next();
            ObserverWithState observer = entry.getValue();
            while ((observer.mState.compareTo(mState) > 0 && !mNewEventOccurred
                    && mObserverMap.contains(entry.getKey()))) {
                Event event = downEvent(observer.mState);
                pushParentState(getStateAfter(event));
                observer.dispatchEvent(lifecycleOwner, event);
                popParentState();
            }
        }
    }

結(jié)論：

1、以上說(shuō)明Activity實(shí)現(xiàn)了LifecycleOwner并持有一個(gè)生命周期显晶，在創(chuàng)建Activity的時(shí)候也同時(shí)創(chuàng)建了ReportFragment贷岸，ReportFragment生命周期變化時(shí)會(huì)觸發(fā)dispatch事件。

2吧碾、由LifecycleRegistry讓MainActivity得到一個(gè)Lifecycle凰盔，也就是MainActivity通過(guò)實(shí)現(xiàn)了LifecycleOwner持有生命周期Lifecycle。

3倦春、通過(guò)添加addObserver(觀察者)得到一個(gè)ObserverWithState對(duì)象户敬，將ObserverWithState對(duì)象添加到mObserverMap中。

4睁本、創(chuàng)建ObserverWithState該對(duì)象的時(shí)候會(huì)創(chuàng)建新的裝飾的觀察者FullLifecycleObserverAdapter implements LifecycleEventObserver尿庐。有個(gè)onStateChange()方法，該方法由上面的1生命周期變化的時(shí)候觸發(fā)呢堰。onStateChange該方法有個(gè)switch判斷生命周期事件抄瑟，從而調(diào)用我們自己創(chuàng)建的觀察者對(duì)應(yīng)的方法。

5枉疼、ReportFragment什么周期變化時(shí)觸發(fā)的dispatch會(huì)經(jīng)過(guò)一系列轉(zhuǎn)換皮假，最后通過(guò)forwardPass/backwardPass調(diào)用FullLifecycleObserverAdapter 的onStateChange。轉(zhuǎn)換過(guò)程中涉及到的類LifecycleRegister骂维。