JetPacks之Lifecycles原理
項(xiàng)目資源
UML 時(shí)序圖

讀懂這里，查看下一篇 LiveDataBus
下一篇LiveData

預(yù)備知識點(diǎn)

<LifeCycles> 「觀察者模式- 反射 - 注解」

源碼結(jié)構(gòu)

Lifecycle 類是abstract

  -> 留意一下這幾個狀態(tài)褪贵，下面會有用
 public enum Event {
    /**
     * Constant for onCreate event of the {@link LifecycleOwner}.
     */
    ON_CREATE,
    /**
     * Constant for onStart event of the {@link LifecycleOwner}.
     */
    ON_START,
    /**
     * Constant for onResume event of the {@link LifecycleOwner}.
     */
    ON_RESUME,
    /**
     * Constant for onPause event of the {@link LifecycleOwner}.
     */
    ON_PAUSE,
    /**
     * Constant for onStop event of the {@link LifecycleOwner}.
     */
    ON_STOP,
    /**
     * Constant for onDestroy event of the {@link LifecycleOwner}.
     */
    ON_DESTROY,
    /**
     * An {@link Event Event} constant that can be used to match all events.
     */
    ON_ANY
}


public enum State {
    
    DESTROYED,

    INITIALIZED,

    CREATED,

    STARTED,

    RESUMED;

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

看下我們的Activity 的關(guān)系

AppCompatActivity extends FragmentActivity implements AppCompatCallback,
    TaskStackBuilder.SupportParentable, ActionBarDrawerToggle.DelegateProvider 
...
public class FragmentActivity extends ComponentActivity implements
    ActivityCompat.OnRequestPermissionsResultCallback,
    ActivityCompat.RequestPermissionsRequestCodeValidator {
...

public class ComponentActivity extends androidx.core.app.ComponentActivity implements
    LifecycleOwner,
    ViewModelStoreOwner,
    SavedStateRegistryOwner,
    OnBackPressedDispatcherOwner {
...

【自定義測試代碼】用一段測試代碼作為入口點(diǎn)渺尘，查看我們的源代碼

public class NameActivity extends AppCompatActivity {

private NameViewModel model;

private TextView nameTextView;
private Button btn;

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_name);
    nameTextView=findViewById(R.id.tvText);
    btn=findViewById(R.id.btn);

    model= ViewModelProviders.of(this).get(NameViewModel.class);

    //需要一個觀察者來觀察數(shù)據(jù)
    Observer observer=new Observer<String>(){
        @Override
        public void onChanged(String s) {
            nameTextView.setText(s);
        }
    };

    //訂閱
    model.getCurrentName().observe(this,observer);

    btn.setOnClickListener(new View.OnClickListener(){
        @Override
        public void onClick(View v) {
            String anotherName="Jetpack"+(model.i++);
            model.getCurrentName().setValue(anotherName);
        }
    });

}

}

看下我們activity_name 布局敛助，為了方便我們就按照最簡單的來寫

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:app="http://schemas.android.com/apk/res-auto"
xmlns:tools="http://schemas.android.com/tools"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:orientation="vertical">

<TextView
    android:id="@+id/tvText"
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    android:text="Hello World!"
     />

<Button
    android:id="@+id/btn"
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    android:text="Hello World!"
     />
</LinearLayout>

我們來找到兩個閱讀源碼的入口點(diǎn)

    //訂閱
    ->  源碼入口點(diǎn)1
    model.getCurrentName().observe(this,observer);

    btn.setOnClickListener(new View.OnClickListener(){
        @Override
        public void onClick(View v) {
            String anotherName="Jetpack"+(model.i++);
            ->  源碼入口點(diǎn)2
            model.getCurrentName().setValue(anotherName);
        }
    });

記錄好這兩個入口使用點(diǎn)骚勘，我們回頭再來看這里

進(jìn)入 源碼ComponentActivity

構(gòu)造方法：

我們知道有一個兼容處理

ComponentActivity()  {   
...
if (19 <= SDK_INT && SDK_INT <= 23) {
        getLifecycle().addObserver(new ImmLeaksCleaner(this));
    }
}

真正重要的是onCreate

-> 關(guān)注一下「ReportFragment」
@Override
protected void onCreate(@Nullable Bundle savedInstanceState) {
    ...
    ReportFragment.injectIfNeededIn(this);
    ...
}

ReportFragment

進(jìn)入方法我們看到虹茶，和Glide等源碼框架思路一致刀森，創(chuàng)建一個沒有布局的fragment

public static void injectIfNeededIn(Activity activity) {
    if (Build.VERSION.SDK_INT >= 29) {
        // On API 29+, we can register for the correct Lifecycle callbacks directly
        activity.registerActivityLifecycleCallbacks(
                new LifecycleCallbacks());
    }
   
    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();
    }
}

進(jìn)入初始化方法查看

  -> 關(guān)注一下源代碼 「分發(fā)事件 」dispatch(Lifecycle.Event.xxx)
@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;
}

我們進(jìn)入dipatch方法一探究竟「可能29+ 走的是回調(diào)結(jié)構(gòu)踱启，但差不多」

-> 發(fā)現(xiàn)最終都是走的 handleLifecycleEvent,進(jìn)入方法看看
    
@SuppressWarnings("deprecation")
static void dispatch(@NonNull Activity activity, @NonNull Lifecycle.Event event) {
    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);
        }
    }
}

handleLifecycleEvent

public void handleLifecycleEvent(@NonNull Lifecycle.Event event) {
    -> 拿到下一個周期的狀態(tài)，并將狀態(tài)移動
    State next = getStateAfter(event);
    -> 移動到下一個狀態(tài)研底，分別進(jìn)入這兩個方法查看一下
    moveToState(next);
}

getStateAfter(event) ------------------------>

-> 看到下面代碼狀態(tài)對應(yīng)的值埠偿，相信都能看懂
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);
}

來一張圖描述

時(shí)序圖

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;
    ->關(guān)注這個方法，再次進(jìn)入看下
    sync();
    mHandlingEvent = false;
}

在這個各方發(fā)里面榜晦，如上圖某個狀態(tài)的冠蒋，對應(yīng)的會有 backwardPass(lifecycleOwner)，forwardPass(lifecycleOwner);
當(dāng)前處于的狀態(tài)和程序目標(biāo)狀態(tài)同步出現(xiàn)差異乾胶，會進(jìn)行移動

private void sync() {
    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.");
    }
    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) {

            -> 關(guān)注這兩個方法實(shí)現(xiàn)差不多抖剿，隨便找一個點(diǎn)進(jìn)去查看==

            backwardPass(lifecycleOwner);
        }
        Entry<LifecycleObserver, ObserverWithState> newest = mObserverMap.newest();
        if (!mNewEventOccurred && newest != null
                && mState.compareTo(newest.getValue().mState) > 0) {

            -> 關(guān)注這兩個方法實(shí)現(xiàn)差不多统屈，隨便找一個點(diǎn)進(jìn)去查看==

            forwardPass(lifecycleOwner);
        }
    }
    mNewEventOccurred = false;
}

forwardPass----------------->dispatchEvent

    private void forwardPass(LifecycleOwner lifecycleOwner) {
    Iterator<Entry<LifecycleObserver, ObserverWithState>> ascendingIterator =
            mObserverMap.iteratorWithAdditions();
    while (ascendingIterator.hasNext() && !mNewEventOccurred) {
        Entry<LifecycleObserver, ObserverWithState> entry = ascendingIterator.next();
        ObserverWithState observer = entry.getValue();
        while ((observer.mState.compareTo(mState) < 0 && !mNewEventOccurred
                && mObserverMap.contains(entry.getKey()))) {
            pushParentState(observer.mState);

            -> dispatchEvent 關(guān)鍵看下這個

            observer.dispatchEvent(lifecycleOwner, upEvent(observer.mState));
            popParentState();
        }
    }
}

你會發(fā)現(xiàn)走了一個靜態(tài)內(nèi)部類回調(diào)-----》onStateChanged

static class ObserverWithState {
    。牙躺。愁憔。

    void dispatchEvent(LifecycleOwner owner, Event event) {
        State newState = getStateAfter(event);
        mState = min(mState, newState);
        -> 注意跟蹤這里
        mLifecycleObserver.onStateChanged(owner, event);
        mState = newState;
    }
}

調(diào)用了【實(shí)現(xiàn)接口的方法類】

class ReflectiveGenericLifecycleObserver implements LifecycleEventObserver {
private final Object mWrapped;
private final CallbackInfo mInfo;

ReflectiveGenericLifecycleObserver(Object wrapped) {
    mWrapped = wrapped;
    mInfo = ClassesInfoCache.sInstance.getInfo(mWrapped.getClass());
}

@Override
public void onStateChanged(@NonNull LifecycleOwner source, @NonNull Event event) {
    mInfo.invokeCallbacks(source, event, mWrapped);
}

}

進(jìn)入構(gòu)造方法，你會看到重要的一句

        OnLifecycleEvent annotation = method.getAnnotation(OnLifecycleEvent.class);

這就是我們卸載自己的周期函數(shù)上的類注解孽拷。我們通過APT 反射方法獲取相關(guān)詳情

執(zhí)行反射onStateChanged

承接最開始吨掌，我們記錄的。
-> 源碼入口點(diǎn)1
model.getCurrentName().observe(this,observer);

跟進(jìn)去脓恕，我們會看程序進(jìn)入onStateChange

observe->owner.getLifecycle().addObserver(wrapper);
->addObserver

pushParentState(statefulObserver.mState);
->        statefulObserver.dispatchEvent(lifecycleOwner, upEvent(statefulObserver.mState));
        popParentState();

-> mLifecycleObserver.onStateChanged(owner, event);

進(jìn)入 ReflectiveGenericLifecycleObserver

-> 源碼入口點(diǎn)2
model.getCurrentName().setValue(anotherName);

@MainThread
protected void setValue(T value) {
    assertMainThread("setValue");
    mVersion++;
    mData = value;
    dispatchingValue(null);
}

跟進(jìn)

void dispatchingValue(@Nullable ObserverWrapper initiator) {
    if (mDispatchingValue) {
        mDispatchInvalidated = true;
        return;
    }
    mDispatchingValue = true;
    do {
        mDispatchInvalidated = false;
        if (initiator != null) {
            -> 關(guān)鍵看這個點(diǎn)
            considerNotify(initiator);
            initiator = null;
        } else {
            for (Iterator<Map.Entry<Observer<? super T>, ObserverWrapper>> iterator =
                    mObservers.iteratorWithAdditions(); iterator.hasNext(); ) {
                  -> 關(guān)鍵看這個點(diǎn)
                considerNotify(iterator.next().getValue());
                if (mDispatchInvalidated) {
                    break;
                }
            }
        }
    } while (mDispatchInvalidated);
    mDispatchingValue = false;
}

看下重要的version比對點(diǎn)膜宋，最終調(diào)用onChange 接口，我們自己的實(shí)現(xiàn)炼幔。整個觀察者閉環(huán)走完

private void considerNotify(ObserverWrapper observer) {
    if (!observer.mActive) {
        return;
    }
    // Check latest state b4 dispatch. Maybe it changed state but we didn't get the event yet.
    //
    // we still first check observer.active to keep it as the entrance for events. So even if
    // the observer moved to an active state, if we've not received that event, we better not
    // notify for a more predictable notification order.
    if (!observer.shouldBeActive()) {
        observer.activeStateChanged(false);
        return;
    }
    if (observer.mLastVersion >= mVersion) {
        return;
    }
    observer.mLastVersion = mVersion;
    observer.mObserver.onChanged((T) mData);
}