欧美亚洲爱草在线,久久视频一二,久久亚洲精品人妻

概述

Lifecycle 是用來管理感知生命周期的Jetpack基礎(chǔ)組件，主要是為了方便需要依賴生命周期來搭建的業(yè)務(wù)邏輯。其本質(zhì)原理是觀察者模式，即把生命周期組件作為被觀察的對象，通過注冊觀察者，構(gòu)建狀態(tài)或者事件變化通知，從而達(dá)到感知生命周期的。

生命周期感知型組件可執(zhí)行操作來響應(yīng)另一個組件（如 Activity 和 Fragment）的生命周期狀態(tài)的變化。這些組件有助于您編寫出更有條理且往往更精簡的代碼，此類代碼更易于維護(hù)。

Lifecycle 主要構(gòu)成

三個重要角色

通過Lifecycle-common的源碼，歸結(jié)Lifecycle的三個重要角色

LifeCycleOwner 生命周期擁有者，即Activity與Fragment（也可自定義，但局限性大）
LifeCycleObserver 生命周期觀察者，可以是任何類，常見的有mvp的p，自定義View等
Lifecycle 是一個抽象類，其內(nèi)部不僅包括了添加和移除觀察者的方法，還包括了 Event 和 State 枚舉?？梢钥吹?Event 中的事件和 Activity 的生命周期幾乎是對應(yīng)的，除了 ON_ANY，它可用于匹配所有事件。

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

    /**
     * Lifecycle states. You can consider the states as the nodes in a graph and
     * {@link Event}s as the edges between these nodes.
     * 見下圖1
     */
    @SuppressWarnings("WeakerAccess")
    public enum State {
        DESTROYED,
        INITIALIZED,
        CREATED,
        STARTED,
        RESUMED;
        public boolean isAtLeast(@NonNull State state) {
            return compareTo(state) >= 0;
        }
    }
}

state與event事件關(guān)系

state與event事件關(guān)系如下圖，您可以將狀態(tài)看作圖中的節(jié)點(diǎn)，將事件看作這些節(jié)點(diǎn)之間的邊。

基本使用方法

引入Lifecycle-lib

基礎(chǔ)組件只需要通過appcompat, 無需再單獨(dú)引用某一個lib

implementation 'androidx.appcompat:appcompat:1.3.0'

以activity生命周期感知

以activity生命周期的感知舉例使用（lifecycle-runtime）

public class MainActivity extends AppCompatActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        getLifecycle().addObserver(new MainLifecycleObserver(getLifecycle()));
    }

    public class MainLifecycleObserver implements LifecycleObserver {
        private static final String TAG = "MainLifecycleObserver";
        Lifecycle lifecycle;

        MainLifecycleObserver(Lifecycle lifecycle) {
            this.lifecycle = lifecycle;
        }

        @OnLifecycleEvent(Lifecycle.Event.ON_CREATE)
        public void onActivityCreate() {
            Log.d(TAG, "onActivityCreate");
        }
        ...     
        @OnLifecycleEvent(Lifecycle.Event.ON_DESTROY)
        public void onActivityDestroy() {
            Log.d(TAG, "onActivityDestroy");
        }

        @OnLifecycleEvent(Lifecycle.Event.ON_ANY)
        public void onActivityAny() {
            Log.d(TAG, "onActivityAny : " + lifecycle.getCurrentState().name());
        }
    }
}

lifecycle-runtime 源碼分析

在上面的例子中，我們注冊的 MainLifecycleObserver 注冊的監(jiān)聽者如何保存、增刪的？到底是如何監(jiān)聽到activity生命周期變化的？事件又是如何分發(fā)的？接下來按照事件分發(fā)的流程逐步分析。

ReportFragment

Activity 生命周期的監(jiān)聽，是通過 ReportFragment向外傳遞的。

ComponentActivity | oncreate

在 androidx.activity.ComponentActivity 的oncreate方法中, 會調(diào)用ReportFragment.injectIfNeededIn

@Override
protected void onCreate(@Nullable Bundle savedInstanceState) {
    ...
    ReportFragment.injectIfNeededIn(this);
    ...
}

injectIfNeededIn

接入，在injectIfNeededIn（）方法中分為兩種情況來處理

SDK_INT >= 29 此情況會向 Activity 注冊一個 LifecycleCallbacks ，以此來直接獲得各個生命周期事件的回調(diào)通知。但也會繼續(xù)執(zhí)行第二種情況。
SDK_INT < 29 此情況會通過向 Activity 添加一個無 UI 界面的 Fragment（即 ReportFragment），間接獲得 Activity 的各個生命周期事件的回調(diào)通知

public static void injectIfNeededIn(Activity activity) {
    if (Build.VERSION.SDK_INT >= 29) {
        // On API 29+, we can register for the correct Lifecycle callbacks directly
        LifecycleCallbacks.registerIn(activity);
    }
    // Prior to API 29 and to maintain compatibility with older versions of
    // ProcessLifecycleOwner (which may not be updated when lifecycle-runtime is updated and
    // need to support activities that don't extend from FragmentActivity from support lib),
    // use a framework fragment to get the correct timing of Lifecycle events
    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();
    }
}

SDK_INT >= 29

直接通過注冊 activity.registerActivityLifecycleCallbacks

@RequiresApi(29)
static class LifecycleCallbacks implements Application.ActivityLifecycleCallbacks {

    static void registerIn(Activity activity) {
        activity.registerActivityLifecycleCallbacks(new LifecycleCallbacks());
    }

    @Override
    public void onActivityCreated(@NonNull Activity activity,
            @Nullable Bundle bundle) {
    }

    @Override
    public void onActivityPostCreated(@NonNull Activity activity,
            @Nullable Bundle savedInstanceState) {
        dispatch(activity, Lifecycle.Event.ON_CREATE);
    }
    ....
  }

SDK_INT < 29

向activity添加了一個fragment后，ReportFragment 本身的生命周期函數(shù)和所在的 Activity 是相關(guān)聯(lián)的，進(jìn)而實(shí)現(xiàn)間接監(jiān)聽activity生命周期，這里列出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);
}

此處會繼續(xù)對版本判斷，防止重復(fù)分發(fā)事件

private void dispatch(@NonNull Lifecycle.Event event) {
    if (Build.VERSION.SDK_INT < 29) {
        // Only dispatch events from ReportFragment on API levels prior
        // to API 29\. On API 29+, this is handled by the ActivityLifecycleCallbacks
        // added in ReportFragment.injectIfNeededIn
        dispatch(getActivity(), event);
    }
}

dispatch

兩種情況中，最終都會調(diào)到 dispatch方法

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

在這個方法中最終通過 LifecycleRegistry.handleLifecycleEvent 來將事件傳遞出去，從而使得外部得到各個生命周期事件的通知。

LifecycleRegistry

拿到事件后，再來看下 LifecycleRegistry 是如何將 Event 值轉(zhuǎn)發(fā)給 LifecycleObserver 的

可以看到在 androidx.activity.ComponentActivity、androidx.fragment.app.Fragment 中都定義了 LifecycleRegistry

// 在ComponentActivity
private final LifecycleRegistry mLifecycleRegistry = new LifecycleRegistry(this);

@NonNull
@Override
public Lifecycle getLifecycle() {
    return mLifecycleRegistry;
}

//在 Fragment
LifecycleRegistry mLifecycleRegistry;
...
private void initLifecycle() {
    mLifecycleRegistry = new LifecycleRegistry(this);
    ....
}
...
@Override
@NonNull
public Lifecycle getLifecycle() {
    return mLifecycleRegistry;
}
...

handleLifecycleEvent

public void handleLifecycleEvent(@NonNull Lifecycle.Event event) {
    enforceMainThreadIfNeeded("handleLifecycleEvent");
    moveToState(event.getTargetState());
}

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

sync

private void sync() {
    LifecycleOwner lifecycleOwner = mLifecycleOwner.get();
    if (lifecycleOwner == null) {  // 注釋1
        throw new IllegalStateException("LifecycleOwner of this LifecycleRegistry is already"
                + "garbage collected. It is too late to change lifecycle state.");
    }
    while (!isSynced()) {  // 注釋2
        mNewEventOccurred = false;
        // no need to check eldest for nullability, because isSynced does it for us.      
        // 注釋 3
        if (mState.compareTo(mObserverMap.eldest().getValue().mState) < 0) {
            backwardPass(lifecycleOwner);
        }
        Map.Entry<LifecycleObserver, ObserverWithState> newest = mObserverMap.newest();
        // 注釋4
        if (!mNewEventOccurred && newest != null
                && mState.compareTo(newest.getValue().mState) > 0) {
            forwardPass(lifecycleOwner);
        }
    }
    mNewEventOccurred = false;
}

針對這個同步到各個觀察者重要方法，我們逐個拆解

注釋1 通過弱引用，判斷當(dāng)前的lifecycleowner是否已經(jīng)被回收，避免無效同步
注釋2 循環(huán)條件，是否已經(jīng)同步完成，具體判斷：當(dāng)前的狀態(tài)mState、第一個觀察者狀態(tài)eldestObserverState、最后一個觀察者狀態(tài)newestObserverState，三者否是相等，相等表明同步完成

private boolean isSynced() {
    if (mObserverMap.size() == 0) { //無觀察者了
        return true;
    }
    State eldestObserverState = mObserverMap.eldest().getValue().mState;
    State newestObserverState = mObserverMap.newest().getValue().mState;
    return eldestObserverState == newestObserverState && mState == newestObserverState;
}

如果這三個狀態(tài)值不相等進(jìn)入循環(huán)，就需要判斷當(dāng)前狀態(tài)是向前還是向后，比如由 STARTED 到 RESUMED 是狀態(tài)向前，反過來就是狀態(tài)向后
注釋3 表明當(dāng)前狀態(tài)是在第一個觀察者前面，此時狀態(tài)是向后，故走到 backwardPass
注釋4 表明當(dāng)前狀態(tài)在最后一個觀察者后面，此時狀態(tài)是向前，故走到 forwardPass

接下里我們選擇 forwardPass 分析，另一個類似，不在贅析

forwardPass

其實(shí)到這里，既然決定了同步狀態(tài)方向，那就要輪詢通知所有的觀察者了吧？

private void forwardPass(LifecycleOwner lifecycleOwner) {
    Iterator<Map.Entry<LifecycleObserver, ObserverWithState>> ascendingIterator =
            mObserverMap.iteratorWithAdditions();
    while (ascendingIterator.hasNext() && !mNewEventOccurred) {
        // 注釋1
        Map.Entry<LifecycleObserver, ObserverWithState> entry = ascendingIterator.next();
        ObserverWithState observer = entry.getValue();
        // 注釋2
        while ((observer.mState.compareTo(mState) < 0 && !mNewEventOccurred
                && mObserverMap.contains(entry.getKey()))) {
            // 注釋3
            pushParentState(observer.mState);
            // 注釋4
            final Event event = Event.upFrom(observer.mState);
            if (event == null) {
                throw new IllegalStateException("no event up from " + observer.mState);
            }
            // 注釋5
            observer.dispatchEvent(lifecycleOwner, event);
            popParentState();
        }
    }
}

注釋1 進(jìn)入ascendingIterator循環(huán)遍歷，取出entry的value,即每一個觀察者 ObserverWithState
注釋2 由于我們選取的是向前同步，此處的判定條件有三個
- 此處的小于0 ，表明觀察者狀態(tài)位于當(dāng)前狀態(tài)之前，所以需要向前同步
- 無新的事件發(fā)生
- 再次判斷map中依然含有此觀察者，防止被移除
注釋3 將 observer 已經(jīng)遍歷到的當(dāng)前的狀態(tài)值 mState 保存下來
注釋4 獲取當(dāng)前觀察者狀態(tài)向前同步后，對應(yīng)的事件
注釋5 確定事件后，此處真正的去分發(fā)給觀察者，即ObserverWithState

最終會調(diào)用到 ObserverWithState.dispatchEvent

ObserverWithState

這是LifecycleRegistry 一個內(nèi)部類，會對注冊進(jìn)來的觀察者會重新進(jìn)行一次包裝，成為 ObserverWithState

static class ObserverWithState {
    State mState;
    LifecycleEventObserver mLifecycleObserver;

    ObserverWithState(LifecycleObserver observer, State initialState) {
        mLifecycleObserver = Lifecycling.lifecycleEventObserver(observer);
        mState = initialState;
    }

    void dispatchEvent(LifecycleOwner owner, Event event) {
        State newState = event.getTargetState();
        mState = min(mState, newState);
        mLifecycleObserver.onStateChanged(owner, event);
        mState = newState;
    }
}

dispatchEvent

這里主要做了兩件事

更新觀察者的當(dāng)前的狀態(tài)為最新的狀態(tài)，即我們要同步的狀態(tài)
調(diào)用 LifecycleObserver.onStateChanged 傳遞事件。這個LifecycleObserver 是在構(gòu)造方法中通過 Lifecycling.``*lifecycleEventObserver*來統(tǒng)一包裝后的接口對象

其實(shí)到這里整個事件分發(fā)的流程已經(jīng)完成了，狀態(tài)也同步了，也分發(fā)到每個觀察者了，但可以注意到這里并沒有直接調(diào)用開頭示例中的那些注解方法？接下來我們繼續(xù)分析 Lifecycling的包裝流程

Lifecycling

如果在 LifecycleRegistry 中直接對外部傳入的 Observer 來進(jìn)行類型判斷、接口回調(diào)、反射調(diào)用等一系列操作的話，那勢必會使得 LifecycleRegistry 整個類非常的臃腫，所以 Lifecycling 的作用就是來將這一系列的邏輯給封裝起來，僅僅開放一個 onStateChanged 方法即可讓 LifecycleRegistry 完成整個事件分發(fā)，從而使得整個流程會更加清晰明了且職責(zé)分明。

lifecycleEventObserver

@NonNull
static LifecycleEventObserver lifecycleEventObserver(Object object) {
    boolean isLifecycleEventObserver = object instanceof LifecycleEventObserver;
    boolean isFullLifecycleObserver = object instanceof FullLifecycleObserver;
    //注釋1
    if (isLifecycleEventObserver && isFullLifecycleObserver) {
        return new FullLifecycleObserverAdapter((FullLifecycleObserver) object,
                (LifecycleEventObserver) object);
    }
    // 注釋2
    if (isFullLifecycleObserver) {
        return new FullLifecycleObserverAdapter((FullLifecycleObserver) object, null);
    }

    if (isLifecycleEventObserver) {
        return (LifecycleEventObserver) object;
    }
    // 注釋3
    final Class<?> klass = object.getClass();
    int type = getObserverConstructorType(klass);
    if (type == GENERATED_CALLBACK) {
        List<Constructor<? extends GeneratedAdapter>> constructors =
                sClassToAdapters.get(klass);
        if (constructors.size() == 1) {
            GeneratedAdapter generatedAdapter = createGeneratedAdapter(
                    constructors.get(0), object);
            return new SingleGeneratedAdapterObserver(generatedAdapter);
        }
        GeneratedAdapter[] adapters = new GeneratedAdapter[constructors.size()];
        for (int i = 0; i < constructors.size(); i++) {
            adapters[i] = createGeneratedAdapter(constructors.get(i), object);
        }
        return new CompositeGeneratedAdaptersObserver(adapters);
    }
    return new ReflectiveGenericLifecycleObserver(object);
}

這里分為三種情況

注釋1 自定義觀察者：實(shí)現(xiàn)兩個接口LifecycleEventObserver、FullLifecycleObserver
注釋2 自定義觀察者：只實(shí)現(xiàn)接口FullLifecycleObserver或者 LifecycleEventObserver
注釋3 以注解的方式，此時就要通過反射來進(jìn)行回調(diào)注解的生命周期方法

這里三種case后續(xù)的邏輯不在贅述，主要是采用適配器的設(shè)計模式，對觀察者做onstatechange調(diào)用適配。

總結(jié)

這里總結(jié)一下整個事件分發(fā)的調(diào)用順序

LifeCycle時序圖.png

【參考文檔】

https://developer.android.com/topic/libraries/architecture/lifecycle

https://developer.android.com/jetpack/androidx/releases/lifecycle

色偷偷精品伊人,欧洲久久精品,欧美综合婷婷骚逼,国产AV主播,国产最新探花在线,九色在线视频一区,伊人大交九欧美,1769亚洲,黄色成人av

Jetpack 組件之 Lifecycle

Jetpack 組件之 Lifecycle

概述

Lifecycle 主要構(gòu)成

三個重要角色

state與event事件關(guān)系

基本使用方法

引入Lifecycle-lib

以activity生命周期感知

lifecycle-runtime 源碼分析

ReportFragment

ComponentActivity | oncreate

injectIfNeededIn

SDK_INT >= 29

SDK_INT < 29

dispatch

LifecycleRegistry

handleLifecycleEvent

moveToState

sync

forwardPass

ObserverWithState

dispatchEvent

Lifecycling

lifecycleEventObserver

總結(jié)

更多應(yīng)用場景

【參考文檔】

相關(guān)閱讀更多精彩內(nèi)容

友情鏈接更多精彩內(nèi)容

色偷偷精品伊人,欧洲久久精品,欧美综合婷婷骚逼,国产AV主播,国产最新探花在线,九色在线视频一区,伊人大交九 欧美,1769亚洲,黄色成人av

Jetpack 組件之 Lifecycle

概述

Lifecycle 主要構(gòu)成

三個重要角色

state與event事件關(guān)系

基本使用方法

引入Lifecycle-lib

以activity生命周期感知

lifecycle-runtime 源碼分析

ReportFragment

ComponentActivity | oncreate

injectIfNeededIn

SDK_INT >= 29

SDK_INT < 29

dispatch

LifecycleRegistry

handleLifecycleEvent

moveToState

sync

forwardPass

ObserverWithState

dispatchEvent

Lifecycling

lifecycleEventObserver

總結(jié)

更多應(yīng)用場景

【參考文檔】

相關(guān)閱讀更多精彩內(nèi)容

友情鏈接更多精彩內(nèi)容

色偷偷精品伊人,欧洲久久精品,欧美综合婷婷骚逼,国产AV主播,国产最新探花在线,九色在线视频一区,伊人大交九欧美,1769亚洲,黄色成人av