Lifecycle簡(jiǎn)介

Lifecycle是一個(gè)生命周期感知組件，一般用來(lái)響應(yīng)Activity、Fragment等組件的生命周期變化，并將變化通知到已注冊(cè)的觀察者。有助于更好地組織代碼，讓代碼邏輯符合生命周期規(guī)范，減少內(nèi)存泄漏，增強(qiáng)穩(wěn)定性。

使用方法

1、在app或者相關(guān)module下的build.gradle文件下添加如下依賴：

androidX項(xiàng)目：直接使用
非androidX項(xiàng)目：

//運(yùn)行時(shí)
implementation "android.arch.lifecycle:runtime:1.1.1"
// 編譯期
annotationProcessor "android.arch.lifecycle:compiler:1.1.1"

2、生命周期觀察者組件實(shí)現(xiàn)LifecycleObserver接口

public class LocationUtil implements LifecycleObserver {

    private static final String TAG = "LocationUtil";

    @OnLifecycleEvent(Lifecycle.Event.ON_CREATE)
    public void createLocation(){
        Log.d(TAG,"lifecycle:onCreate");
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_START)
    public void startLocation(){
        Log.d(TAG,"lifecycle:onStart");
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
    public void resumeLocation(){
        Log.d(TAG,"lifecycle:onResume");
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_PAUSE)
    public void pauseLocation(){
        Log.d(TAG,"lifecycle:onPause");
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_STOP)
    public void stopLocation(){
        Log.d(TAG,"lifecycle:onStop");
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_DESTROY)
    public void destoryLocation(){
        Log.d(TAG,"lifecycle:onDestory");
    }

}

3、將組件添加到Lifecycle的觀察者列表

假如你使用新版本的AppcompatActivity（>26.1.0）[我使用的是27.1.1],因?yàn)锳ppcompatActivity繼承的ComponentActivity實(shí)現(xiàn)了LifecycleOwner接口，所以寫(xiě)法如下：

image.png

public class LifeCycleActivity extends AppCompatActivity {

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

如此，LocationUtil便可以關(guān)聯(lián)到Activity的生命周期

AppcompatActivity<26.1.0,這種情況下也可以自己實(shí)現(xiàn)LifecycleOwner接口：
1、實(shí)現(xiàn)LifecycleOwner 接口的方法：getLifecycle()
2、注冊(cè)Lifecycle new LifecycleRegistry(this)
3、在Activity生命周期函數(shù)中分發(fā)事件

public class MainActivity extends Activity implements LifecycleOwner {
    private LifecycleRegistry mLifecycleRegistry;

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

        mLifecycleRegistry = new LifecycleRegistry(this);
        mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_CREATE);
        mLifecycleRegistry.addObserver(new TestObserver());
    }

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

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

    @Override
    public void onResume() {
        super.onResume();
        mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_RESUME);
    }

    @Override
    public void onPause() {
        mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_PAUSE);
        super.onPause();
    }

    @Override
    public void onStop() {
        mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_STOP);
        super.onStop();
    }

    @Override
    public void onDestroy() {
        mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_DESTROY);
        super.onDestroy();
    }
}

源碼分析

Lifecycle相關(guān)類圖：

image.png

回顧LocationUtil代碼：

public class LocationUtil implements LifecycleObserver {

    private static final String TAG = "LocationUtil";

    @OnLifecycleEvent(Lifecycle.Event.ON_CREATE)
    public void createLocation(){
        Log.d(TAG,"lifecycle:onCreate");
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_START)
    public void startLocation(){
        Log.d(TAG,"lifecycle:onStart");
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
    public void resumeLocation(){
        Log.d(TAG,"lifecycle:onResume");
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_PAUSE)
    public void pauseLocation(){
        Log.d(TAG,"lifecycle:onPause");
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_STOP)
    public void stopLocation(){
        Log.d(TAG,"lifecycle:onStop");
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_DESTROY)
    public void destoryLocation(){
        Log.d(TAG,"lifecycle:onDestory");
    }

}

可以很清楚地知道Lifecycle是通過(guò)@OnLifecycleEvent（參數(shù)）注解來(lái)關(guān)聯(lián)生命周期的。
我們從引用代碼處出發(fā)：

public class LifeCycleActivity extends AppCompatActivity {

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

發(fā)現(xiàn)僅僅一行g(shù)etLifecycle().addObserver(new LocationUtil());代碼。從這行代碼我們可以知道Lifecycle使用了觀察者模式，通過(guò)通過(guò)關(guān)聯(lián)生命周期通知訂閱的觀察者。那么這行代碼是如何使Lifecycle關(guān)聯(lián)上Activity的生命周期的呢？
帶著這個(gè)疑問(wèn)，我們查看getLifecycle()的源碼：

ComponentActivity(AppCompatActivity的父類)
-----------------------------
public Lifecycle getLifecycle() {
        return mLifecycleRegistry;
    }

獲取一個(gè)mLifecycleRegistry實(shí)例

private final LifecycleRegistry mLifecycleRegistry = new LifecycleRegistry(this);

mLifecycleRegistry是LifecycleRegistry類的一個(gè)實(shí)例，
查看ComponentActivity的生命周期onCreate方法：

protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        mSavedStateRegistryController.performRestore(savedInstanceState);
        ReportFragment.injectIfNeededIn(this);
        if (mContentLayoutId != 0) {
            setContentView(mContentLayoutId);
        }
    }

繼續(xù)查看 ReportFragment.injectIfNeededIn(this)：

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

發(fā)現(xiàn)injectIfNeededIn（）方法其實(shí)就是給當(dāng)前Activity添加一個(gè)Fragment,如此ReportFragment便能感知到當(dāng)前Activity的生命周期。
再看ReportFragment的生命周期函數(shù)：

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

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

發(fā)現(xiàn)全都調(diào)用了dispatch（）方法，而dispatch（）方法則會(huì)判斷activity是否實(shí)現(xiàn)了LifecycleOwner接口，如果實(shí)現(xiàn)了該接口接調(diào)用LifecycleRegister的handleLifecycleEvent()，這樣生命周期的狀態(tài)就會(huì)借由LifecycleRegister通知給各個(gè)LifecycleObserver從而調(diào)用其中對(duì)應(yīng)Lifecycle.Event的方法。
這是Activity的聲明周期感知，那么Fragment呢？看一下Fragment源碼你會(huì)發(fā)現(xiàn)Fragment也實(shí)現(xiàn)了LifecycleOwner接口，也關(guān)聯(lián)了一個(gè)LifecycleRegistry對(duì)象。
我們接著看handleLifecycleEvent（）方法：

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

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

image.png

moveToState(next):

 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) {
            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) {
                backwardPass(lifecycleOwner);
            }
            Entry<LifecycleObserver, ObserverWithState> newest = mObserverMap.newest();
            if (!mNewEventOccurred && newest != null
                    && mState.compareTo(newest.getValue().mState) > 0) {
                forwardPass(lifecycleOwner);
            }
        }
        mNewEventOccurred = false;
    }

這里可以看到
如果ObserverWithState的state小于當(dāng)前state，那么就調(diào)用forwardPass方法，
如果大于當(dāng)前state，那么就調(diào)用backwardPass方法。
繼續(xù)看forwardPass方法:

    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);
                observer.dispatchEvent(lifecycleOwner, upEvent(observer.mState));
                popParentState();
            }
        }
    }

上面的observer其實(shí)是一個(gè)ObserverWithState對(duì)象,它是一個(gè)靜態(tài)內(nèi)部類

    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 = getStateAfter(event);
            mState = min(mState, newState);
            mLifecycleObserver.onStateChanged(owner, event);
            mState = newState;
        }
    }

通過(guò)lifecycleEventObserver（）方法獲取mLifecycleObserver實(shí)例，調(diào)用onStateChanged（owner，event）通知實(shí)現(xiàn)了 LifecycleObserver的類，生命周期發(fā)生了變化。至此Lifecycle的原理實(shí)現(xiàn)就分析完了。

Q:為什么要使用ReportFragment？

我認(rèn)為應(yīng)該是為了降低侵入性，所以封裝一個(gè)具有同樣生命周期的Fragment來(lái)給Lifecycle分發(fā)生命周期事件。

image.png

這樣只需要在onCreate方法里面調(diào)用ReportFragment.injectIfNeededIn(this);即可

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

Lifecycle簡(jiǎn)單使用及源碼淺析

Lifecycle簡(jiǎn)單使用及源碼淺析

Lifecycle簡(jiǎn)介

使用方法

1、在app或者相關(guān)module下的build.gradle文件下添加如下依賴：

2、生命周期觀察者組件實(shí)現(xiàn)LifecycleObserver接口

3、將組件添加到Lifecycle的觀察者列表

源碼分析

Q:為什么要使用ReportFragment？

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

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

Lifecycle簡(jiǎn)單使用及源碼淺析

Lifecycle簡(jiǎn)介

使用方法

1、在app或者相關(guān)module下的build.gradle文件下添加如下依賴：

2、生命周期觀察者組件實(shí)現(xiàn)LifecycleObserver接口

3、將組件添加到Lifecycle的觀察者列表

源碼分析

Q:為什么要使用ReportFragment？

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

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

2、生命周期觀察者組件實(shí)現(xiàn)LifecycleObserver接口

3、將組件添加到Lifecycle的觀察者列表

Q:為什么要使用ReportFragment？