欧美bbbwbbbw肥妇,免费乱码人妻系列日韩,一级黄片

Android?狀態(tài)管理之Lifecycle淺析

 更新時間:2022年06月30日 14:24:52   作者:??rEd_????  
這篇文章主要介紹了Android?狀態(tài)管理之Lifecycle淺析,Lifecycle主要用于Activity、Fragment這一類具有狀態(tài)的組件的狀態(tài)監(jiān)聽,更多相關(guān)資料介紹需要的小伙伴可以參考下面文章內(nèi)容

原理概述

Lifecycle主要用于Activity、Fragment這一類具有狀態(tài)的組件的狀態(tài)監(jiān)聽,最主要的一個作用就是將原先Activity、Fragment中的大量的生命周期相關(guān)的回調(diào)函數(shù)移出View層文件,從設(shè)計角度上來說,使得MVVM中的View層文件的結(jié)構(gòu)更加清晰、簡單,簡化了View層的任務,使得代碼更清晰、易于維護。

Lifecycle實現(xiàn)監(jiān)聽的原理主要有兩種方式,在API29以下的版本主要采用的是方法一,而在API29+的版本采用的是方法二。

  • 和Glide插件一樣的,采用一個專門用于報告狀態(tài)的Fragment,當這個特殊的空白Fragment被插入到宿主Activity時,就可以獲取到宿主的生命周期狀態(tài)改變。
  • 實現(xiàn)Application.ActivityLifecycleCallbacks,監(jiān)聽相關(guān)的生命周期的改變。

大概的使用步驟如下:

  • 聲明自己的監(jiān)聽組件:MyUtil實現(xiàn)LifecycleObserver接口。
  • 采用注解聲明生命周期回調(diào)函數(shù):
    @OnLifecycleEvent(Lifecycle.Event.ON_CREATE)
    private void fun1(){
        //on_create時需要做的事情
    }

在MainActivity.java中調(diào)用:

getLifecycle().addObserver(new MyUtil());

顯然,在這個模型中,lifecycle本身只是一個事件的源頭,而我們自己實現(xiàn)的監(jiān)聽者MyUtil則是觀察者,我們像lifecycle注冊我們的工具,一旦lifecycle收到了生命周期的變化通知,那么就通知一系列的觀察者進行更新:

Lifecycle本身更像是一個代理,我們的工具類不需要自己去做監(jiān)聽這一件事情了,所以這實際上可以看做是兩個觀察者模式的合成,而中間的lifecycle是一個系統(tǒng)為我們提供的接口,用于獲得回調(diào)。我們只需要注冊我們的Observer即可。這樣一來,分析lifecycle的過程明顯被拆成了兩個子問題:

問題1. MyUtil(LifecycleObserver)是如何監(jiān)聽lifecycle的?

問題2. lifecycle是如何監(jiān)聽宿主(LifecycleOwner)生命周期變化的?

構(gòu)成

Lifecycle的構(gòu)成對象:

  • Lifecycle:即生命周期,某個組件(Activity、Fragment)可能會具有自己的Lifecycle。
  • LifecycleOwner:Lifecycle的持有者,某個組件(Activity、Fragment)。
  • LifecycleObserver:即觀察者,我們需要對某個組件的生命周期進行觀察,那么就必須實現(xiàn)LifecycleObserver,通過lifecycle的addObserver方法對LifecycleObserver進行注冊監(jiān)聽,這樣一來對應的LifecycleObserver的類就能夠得到生命周期的相關(guān)回調(diào)了。
  • Event:即生命周期回調(diào)的方法,例如ON_CREATE、ON_START等等。
  • State:當某個Event發(fā)生后,會導致State的轉(zhuǎn)變,例如ON_CREATE事件發(fā)生時,State將會從INITIALIZED走向CREATED,如下【模型】中的狀態(tài)轉(zhuǎn)移關(guān)系圖。
    • INITIALIZED:剛剛被初始化。
    • CREATED:ON_CREATE之后、ON_STOP之后。
    • STARTED:ON_START之后、ON_PAUSE之后。
    • RESUMED:ON_RESUME之后、ON_PAUSE之前
    • ON_DESTORYED:ON_DESTROY之后,還未被創(chuàng)建或者已經(jīng)銷毀。

模型

//對應的狀態(tài)轉(zhuǎn)移函數(shù)
@NonNull
public State getTargetState() {
  	//枚舉類,this標識的是某種事件,例如ON_CREATE、ON_STOP等等。
    switch (this) {
        //對于ON_CREATE和ON_STOP事件,都對應CREATED狀態(tài)。(圖上二者都指向CREATED)
        case ON_CREATE:
        case ON_STOP:
            return State.CREATED;
        case ON_START:
        case ON_PAUSE:
            return State.STARTED;
        case ON_RESUME:
            return State.RESUMED;
        case ON_DESTROY:
            return State.DESTROYED;
        case ON_ANY:
            break;
    }
    throw new IllegalArgumentException(this + " has no target state");
}

源碼

1. addObserver(observer)

LifecycleOwner作為事件的源頭,F(xiàn)ragment、Activity都是LifecycleOwner。換句話說就是這兩者會產(chǎn)生一些列生命周期相關(guān)的事件。

public class ComponentActivity extends androidx.core.app.ComponentActivity implements
        LifecycleOwner

LifecycleOwner提供了唯一一個方法,并且,在ComponentActivity類中,使用的是Lifecycle的一個實現(xiàn)類:mLifecycleRegistry

public interface LifecycleOwner {
    @NonNull
    Lifecycle getLifecycle();
}
private final LifecycleRegistry mLifecycleRegistry = new LifecycleRegistry(this);
//LifecycleRegistry.java
@Override
public void addObserver(@NonNull LifecycleObserver observer) {
    enforceMainThreadIfNeeded("addObserver");//主線程斷言
    State initialState = mState == DESTROYED ? DESTROYED : INITIALIZED;//如果mState是已經(jīng)銷毀的則就標記為已經(jīng)銷毀;如果是其他的(所有有效的),就標記為已初始化過的。
    ObserverWithState statefulObserver = new ObserverWithState(observer, initialState);//傳入自定義的觀察者(非被觀察者)和狀態(tài)。
    ObserverWithState previous = mObserverMap.putIfAbsent(observer, statefulObserver);//嘗試放入被觀察者維護的觀察者對象集合中(如果不存在的話,防止多次注冊)。如果存在,返回既有值的value;如果不存在put,并返回null。
  	//如果之前存在一個相同的observer,那么直接return;
    if (previous != null) {
        return;
    }
  	//取得lifecycleOwner對象,通常是Activity或者是Fragment,注意,此處的LifecycleOwner是被WeakReference<LivecycleOwner>引用住的。是在LifecycleRegistry的構(gòu)造函數(shù)中,被注入了值。
   	//private final WeakReference<LifecycleOwner> mLifecycleOwner;

    LifecycleOwner lifecycleOwner = mLifecycleOwner.get();

  	//如果為空,說明對象已經(jīng)被回收了,return掉。
    if (lifecycleOwner == null) {
        // it is null we should be destroyed. Fallback quickly
        return;
    }

    boolean isReentrance = mAddingObserverCounter != 0 || mHandlingEvent;
    State targetState = calculateTargetState(observer);
    mAddingObserverCounter++;
		//正在注冊的觀察者數(shù)量+1

  	//ENUM Class之間的比較,二者相等會返回0。這個循環(huán)作用就是追加之前的生命周期事件派發(fā)(粘性)
    while ((statefulObserver.mState.compareTo(targetState) < 0
            && mObserverMap.contains(observer))) {
      	//該行代碼的內(nèi)部實現(xiàn)是:mParentStates.add(state);其中的mParentStates是一個ArrayList,用于存儲一些“舊”的消息。例如我們在running(create、start、resume都走完了)狀態(tài)通過點擊按鈕注冊一個監(jiān)聽,此時的pushParentState中的參數(shù):statefulObserver.mState就是“INITIALIZED”。
        pushParentState(statefulObserver.mState);
      	//接著上面的情況,傳入的參數(shù)是:INITIALIZED,從upFrom中取出的Event是“ON_CREATE”,但是此時onCreate狀態(tài)實際上早已走完了。
        final Event event = Event.upFrom(statefulObserver.mState);
        if (event == null) {
            throw new IllegalStateException("no event up from " + statefulObserver.mState);
        }
      	//注意,我們在實例中的ON_CREATE等等回調(diào)都是在這步里面執(zhí)行的【圖1】,主要是更新狀態(tài),和派發(fā)事件,走完這代碼,statefulObserver.mState就變成了CREATED
        statefulObserver.dispatchEvent(lifecycleOwner, event);

      	//和pushParentState對應,此時刪除后parentState長度為0。
        popParentState();

        targetState = calculateTargetState(observer);
      	//此時statefulObserver.mState為CREATED,而targetState的值被更新為:RESUME。
    }

    if (!isReentrance) {
        // we do sync only on the top level.
        sync();
    }
    mAddingObserverCounter--;
}

接下來的第二輪代碼的,其實和第一輪類似,就是從Event從ON_CREATE變成了ON_START,然后派發(fā)了ON_START事件。ON_RESUME同理。大概的流程是,添加Observer的時候。以statefulObserver為主,不論Activity是什么狀態(tài),進入時initialState都是INITIALIZED狀態(tài),然后利用Event.upFrom函數(shù),根據(jù)狀態(tài)(State,例如CREATED),取出事件(Event,例如ON_CREATE),然后, statefulObserver.dispatchEvent(lifecycleOwner, event);更新了statefulObserver的狀態(tài),依次類推。

以上代碼的幾個比較關(guān)鍵的展開:

private State calculateTargetState(LifecycleObserver observer) {

  	//mObserverMap即上面addObserver主干代碼中的第七行:
  	//ObserverWithState previous = mObserverMap.putIfAbsent(observer, statefulObserver);
  	//此處是對該Map唯一的加入調(diào)用。

  	//取出臨近的ObserverWithState,FastSafeIterableMap,注釋中說是:Poor's man LinkedHashMap
  	//LifecycleObserver在androidx.core.app.ComponentActivity中可以看到,ComponentActivity實現(xiàn)了該接口。
  	//所以,該Map是一個Activity對應ObserverWithState(一個State、一個LifecycleEventObserver)的結(jié)構(gòu):

    Map.Entry<LifecycleObserver, ObserverWithState> previous = mObserverMap.ceil(observer);

  	//如果不為空,那么就設(shè)置siblingState為previous中存儲對象的mState else null
    State siblingState = previous != null ? previous.getValue().mState : null;
  	//如果有parentState,那么獲取其中的最后一個的State else null
    State parentState = !mParentStates.isEmpty() ? mParentStates.get(mParentStates.size() - 1)
            : null;
  	//取mState、siblingState和parentState中最小值。
    return min(min(mState, siblingState), parentState);
}


//statefulObserver.dispatchEvent(lifecycleOwner, event);
void dispatchEvent(LifecycleOwner owner, Event event)
   //根據(jù)event(ENUM)獲取其狀態(tài),這個和上面的狀態(tài)圖是一樣的。
   State newState = event.getTargetState();
	 //取最小狀態(tài)
   mState = min(mState, newState);
   //更新狀態(tài),響應回調(diào)
   mLifecycleObserver.onStateChanged(owner, event);
	 //設(shè)置新狀態(tài)
   mState = newState;
}

2. sync()

private void sync() {
  	//即Activity、Fragment這類生命周期持有者。
    LifecycleOwner lifecycleOwner = mLifecycleOwner.get();
  	//判斷是否已經(jīng)被回收
    if (lifecycleOwner == null) {
        throw new IllegalStateException("LifecycleOwner of this LifecycleRegistry is already"
                + "garbage collected. It is too late to change lifecycle state.");
    }
  	//如果mObserverMap中的元素還沒有完全同步就進行循環(huán),進行所有保存著的觀察者的狀態(tài)同步。
    while (!isSynced()) {
      	//標記是否有新的事件出現(xiàn),當moveToState被調(diào)用時,滿足條件(mHandlingEvent || mAddingObserverCounter != 0)時,該屬性會被置為true。
      	//這兩個條件是:1是否正在處理事件,2是是否正在處理新加入的觀察者。
        mNewEventOccurred = false;
        //利用mState和mObserverMap中最老的元素狀態(tài)相比較,如果更?。ㄗ钚〉氖荄ESTROY,INITIALIZED,一直到RESUMED),那么久從最早被加入的元素,順著這個LinkedHashMap進行后向的更新。例如CREATED < RESUMED
        if (mState.compareTo(mObserverMap.eldest().getValue().mState) < 0) {
          	//后向傳播
            backwardPass(lifecycleOwner);
        }
        Map.Entry<LifecycleObserver, ObserverWithState> newest = mObserverMap.newest();
      	//如果沒有新的事件出現(xiàn)(期間沒有moveToState被觸發(fā)),最新的觀察者不為空,并且有當前組件的狀態(tài)更先于最新組件的狀態(tài)。
      	//例如mState = RESUMED和newest.mState = CREATED,那么就觸發(fā)前向傳播。
        if (!mNewEventOccurred && newest != null
                && mState.compareTo(newest.getValue().mState) > 0) {
          	//前向傳播
            forwardPass(lifecycleOwner);
        }
      	//在這個循環(huán)中,直到所有Observer狀態(tài)全部同步為止。
    }
    mNewEventOccurred = false;
}

private boolean isSynced() {
  	if (mObserverMap.size() == 0) {
    	return true;
  	}
  	State eldestObserverState = mObserverMap.eldest().getValue().mState;
  	State newestObserverState = mObserverMap.newest().getValue().mState;
  	//判斷最晚加入的 是否等于 最早加入的 是否等于 當前的狀態(tài)。
  	return eldestObserverState == newestObserverState && mState == newestObserverState;
}
//forwardPass同理;
private void backwardPass(LifecycleOwner lifecycleOwner) {
  	//迭代器
    Iterator<Map.Entry<LifecycleObserver, ObserverWithState>> descendingIterator =
            mObserverMap.descendingIterator();
  	//在forwardPass中:
    //Iterator<Map.Entry<LifecycleObserver, ObserverWithState>> ascendingIterator =
    //			mObserverMap.iteratorWithAdditions();
  	//在沒有新的事件(moveToState觸發(fā))的情況下進行迭代。
    while (descendingIterator.hasNext() && !mNewEventOccurred) {
        Map.Entry<LifecycleObserver, ObserverWithState> entry = descendingIterator.next();
        ObserverWithState observer = entry.getValue();
        while ((observer.mState.compareTo(mState) > 0 && !mNewEventOccurred
                && mObserverMap.contains(entry.getKey()))) {
          	//和addObserver中相似的邏輯,同步時主動去回調(diào)其他滯后的監(jiān)聽者的狀態(tài)。
            Event event = Event.downFrom(observer.mState);
            if (event == null) {
                throw new IllegalStateException("no event down from " + observer.mState);
            }
            pushParentState(event.getTargetState());
            observer.dispatchEvent(lifecycleOwner, event);
            popParentState();
        }
    }
}

3. setCurrentState、moveToState

這一類的方法用于外部調(diào)用,用于lifecycle的狀態(tài)轉(zhuǎn)移。例如我們可以顯式地在一個Activity的所有生命周期中,調(diào)用setCurrentState方法來標記(通知)lifecycle狀態(tài)。標記完成后,將觸發(fā)sync進行所有觀察者狀態(tài)的同步。

    @MainThread
    public void setCurrentState(@NonNull State state) {
        enforceMainThreadIfNeeded("setCurrentState");//斷言主線程
        moveToState(state);
    }

    /**
     * Sets the current state and notifies the observers.
     * <p>
     * Note that if the {@code currentState} is the same state as the last call to this method,
     * calling this method has no effect.(如果在相同的State下調(diào)用此方法無效。)
     *
     * @param event The event that was received
     */
    public void handleLifecycleEvent(@NonNull Lifecycle.Event event) {
        enforceMainThreadIfNeeded("handleLifecycleEvent");//斷言主線程
        moveToState(event.getTargetState());
    }

    private void moveToState(State next) {
      	//相同狀態(tài)下調(diào)用無效。
        if (mState == next) {
            return;
        }
        mState = next;
      	//如果正在處理事件,或者含有某個剛剛加入的Observer(數(shù)量不為0),那么久標記當前有新的事件出現(xiàn)了。
        if (mHandlingEvent || mAddingObserverCounter != 0) {
            mNewEventOccurred = true;
            // we will figure out what to do on upper level.
            return;
        }
        mHandlingEvent = true;//標記正在處理事件,有點像鎖
        sync();//同步(前后向傳播)
        mHandlingEvent = false;//結(jié)束
    }

監(jiān)聽

從moveToState說起,它有三個調(diào)用。

@Deprecated
@MainThread
public void markState(@NonNull State state) {
    enforceMainThreadIfNeeded("markState");
    setCurrentState(state);
}

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

markState已經(jīng)被標記為@Deprecated,但是我們可以找到它的一個調(diào)用:package androidx.core.app下的ComponentActivity中的onSaveInstanceState仍然保持著這個方法的調(diào)用。

package androidx.core.app;

@CallSuper
@Override
protected void onSaveInstanceState(@NonNull Bundle outState) {
    mLifecycleRegistry.markState(Lifecycle.State.CREATED);//
    super.onSaveInstanceState(outState);
}

setCurrentState則在package androidx.activity;中的ComponentActivity被引用:

package androidx.activity;

@CallSuper
@Override
protected void onSaveInstanceState(@NonNull Bundle outState) {
    Lifecycle lifecycle = getLifecycle();
    if (lifecycle instanceof LifecycleRegistry) {
        ((LifecycleRegistry) lifecycle).setCurrentState(Lifecycle.State.CREATED);//
    }
    super.onSaveInstanceState(outState);
    mSavedStateRegistryController.performSave(outState);
}

至于handleLifecycleEvent:

很明顯在AppcompatActivity中,handleLifecycleEventlifecyle的關(guān)系比較密切。

例如,在onCreate方法中,有:

    protected void onCreate(@Nullable Bundle savedInstanceState) {
        mFragments.attachHost(null /*parent*/);

        if (savedInstanceState != null) {
           //如果是重建的Activity進行的操作,以下省略
           ......
        }

        if (mPendingFragmentActivityResults == null) {
            mPendingFragmentActivityResults = new SparseArrayCompat<>();
            mNextCandidateRequestIndex = 0;
        }

        super.onCreate(savedInstanceState);

        mFragmentLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_CREATE);//派發(fā)事件
        mFragments.dispatchCreate();
    }

每當我們的Activity父類的FragmentActivity的方法:onCreate被回調(diào)時,必然會觸發(fā)handleLifecycleEvent()的執(zhí)行,這樣一來非常簡單地就實現(xiàn)了監(jiān)聽。

但是,在androidx.activity.ComponentActivity;中,有一段非常特殊的代碼:

@Override
protected void onCreate(@Nullable Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    mSavedStateRegistryController.performRestore(savedInstanceState);
    ReportFragment.injectIfNeededIn(this);//
    if (mContentLayoutId != 0) {
        setContentView(mContentLayoutId);
    }
}
public static void injectIfNeededIn(Activity activity) {
    if (Build.VERSION.SDK_INT >= 29) {
        // On API 29+(Android 10.0 +), 我們可以直接注冊正確的lifecycle監(jiān)聽,內(nèi)部將會直接實現(xiàn)監(jiān)聽:在Activity類中的mActivityLifecycleCallbacks中,加入一個Callback:mActivityLifecycleCallbacks.add(callback);
        activity.registerActivityLifecycleCallbacks(
                new LifecycleCallbacks());
    }

    android.app.FragmentManager manager = activity.getFragmentManager();
    if (manager.findFragmentByTag(REPORT_FRAGMENT_TAG) == null) {
      	//注意這里,我們向當前的Activity中新加入了一個new ReportFragment()。
        manager.beginTransaction().add(new ReportFragment(), REPORT_FRAGMENT_TAG).commit();
        manager.executePendingTransactions();
    }
}

任取一個Fragment的生命周期函數(shù)作為觀察,進入dispatch()方法。

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

在dispatch方法中,發(fā)現(xiàn)將activity當做LifecycleOwner獲取了其Lifecycle進行事件的處理。

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

其中,LifecycleRegistryOwner是LifecycleOwner接口的子類,可以看到返回值不同。顯然,當Activity生命周期發(fā)生變動時,F(xiàn)ragment的生命周期也會相應地發(fā)生變動,由ReportFragment的生命周期函數(shù)中進行handleLifecycleEvent就非常巧妙地實現(xiàn)了監(jiān)聽這一功能。這一點和Glide的實現(xiàn)(采用一個空白的RequestManagerFragment)非常相似。

但是,在API29+,程序會走這樣一段代碼:

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

static class LifecycleCallbacks implements Application.ActivityLifecycleCallbacks {

  	//有做省略
    static void registerIn(Activity activity) {
        activity.registerActivityLifecycleCallbacks(new LifecycleCallbacks());
    }
    @Override
    public void onActivityPostCreated(@NonNull Activity activity,
            @Nullable Bundle savedInstanceState) {
        dispatch(activity, Lifecycle.Event.ON_CREATE);
    }
    @Override
    public void onActivityPostStarted(@NonNull Activity activity) {
        dispatch(activity, Lifecycle.Event.ON_START);
    }
    @Override
    public void onActivityPostResumed(@NonNull Activity activity) {
        dispatch(activity, Lifecycle.Event.ON_RESUME);
    }
    @Override
    public void onActivityPrePaused(@NonNull Activity activity) {
        dispatch(activity, Lifecycle.Event.ON_PAUSE);
    }
    @Override
    public void onActivityPreStopped(@NonNull Activity activity) {
        dispatch(activity, Lifecycle.Event.ON_STOP);
    }
    @Override
    public void onActivityPreDestroyed(@NonNull Activity activity) {
        dispatch(activity, Lifecycle.Event.ON_DESTROY);
    }
}

同時,Api29+的機型,也會走到:插入一個ReportFragment。理論上,通過Application.ActivityLifecycleCallbacks 回調(diào)就已經(jīng)能夠注冊到監(jiān)聽了,至于為什么這么設(shè)計并不清楚。但是到派發(fā)事件時的dispatch方法:

private void dispatch(@NonNull Lifecycle.Event event) {
    if (Build.VERSION.SDK_INT < 29) {
        dispatch(getActivity(), event);//TAG
    }
}

它限制了通過Fragment生命周期回調(diào)產(chǎn)生的監(jiān)聽只在Api<29才會進行派發(fā),所以不會產(chǎn)生兩次派發(fā)。而標記的TAG處的dispatch是一個靜態(tài)方法,注意,API29+的dispatch直接就是調(diào)用的這個靜態(tài)方法。

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

//API29中的調(diào)用,走的是上面的靜態(tài)方法。
@Override
public void onActivityPostStarted(@NonNull Activity activity) {
	  dispatch(activity, Lifecycle.Event.ON_START);
}

不論是API29以下通過Fragment監(jiān)聽,還是API29以上,通過Application.ActivityLifecycleCallbacks進行監(jiān)聽,走的都是lifecycle.handleLifecycleEvent()方法。這也是為什么在上文中提handleLifecycleEvent有大量調(diào)用的調(diào)用:

其他

1. Application.ActivityLifecycleCallbacks

該接口含有大量的回調(diào)函數(shù),和日常開發(fā)中的那三對回調(diào)函數(shù)不同,這里的劃分更加細致,有三組,并且每組又區(qū)分pre和post,外加一個onActivitySaveInstanceState,每當Activity發(fā)生生命周期轉(zhuǎn)變時,該回調(diào)函數(shù)都會被回調(diào)到,并且參數(shù)是發(fā)生變化的Activity。我們可以自定義一個類實現(xiàn)該接口,然后this.registerActivityLifecycleCallbacks(callbacks);注冊一下即可。該類還可以實現(xiàn)更靈活的Activity 實例數(shù)量管控。大部分的事件都是在POST部分中處理的,而不是Pre。

@Override
public void onActivityResumed(@NonNull Activity activity) {
}
@Override
public void onActivityPostResumed(@NonNull Activity activity) {
    dispatch(activity, Lifecycle.Event.ON_RESUME);//向監(jiān)聽者(MyUtils類等等)派發(fā)事件
}

總結(jié)

從監(jiān)聽開始,在API29以下的版本中,會向Activity中加入一個ReportFragment,該Fragment的生命周期發(fā)生變化時,將會進行派發(fā)時間,更新lifecycle的生命周期,再由Lifecycle統(tǒng)一通知LifecycleObserver生命周期更新;而API29+,則會直接通過監(jiān)聽Application.ActivityLifecycleCallbacks接口,進行獲取Activity的狀態(tài),同時也會插入ReportFragment,但是該用于報告狀態(tài)的Fragment的生命周期中的dispatch將不會生效,F(xiàn)ragment和Activity都添加一個監(jiān)聽,并在onStop前后添加輸出,兩種方式(API29+和API29以下)的回調(diào)順序也是不同的。

到此這篇關(guān)于Android 狀態(tài)管理之Lifecycle淺析的文章就介紹到這了,更多相關(guān)Andorid Lifecycle 內(nèi)容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關(guān)文章希望大家以后多多支持腳本之家!

相關(guān)文章

  • android實現(xiàn)藍牙app代碼

    android實現(xiàn)藍牙app代碼

    這篇文章主要為大家詳細介紹了android實現(xiàn)藍牙app的代碼,具有一定的參考價值,感興趣的小伙伴們可以參考一下
    2018-05-05
  • Android MediaPlayer 音頻倍速播放 調(diào)整播放速度問題

    Android MediaPlayer 音頻倍速播放 調(diào)整播放速度問題

    這篇文章主要介紹了Android MediaPlayer 音頻倍速播放,調(diào)整播放速度,本文給大家介紹的非常詳細,具有一定的參考借鑒價值,需要的朋友可以參考下
    2019-09-09
  • Android下2d物理引擎Box2d用法簡單實例

    Android下2d物理引擎Box2d用法簡單實例

    這篇文章主要介紹了Android下2d物理引擎Box2d用法,實例分析了在Android平臺上使用Box2d的基本技巧,具有一定參考借鑒價值,需要的朋友可以參考下
    2015-07-07
  • android textview 顯示html方法解析

    android textview 顯示html方法解析

    現(xiàn)在網(wǎng)絡(luò)的繁盛時代,光文字是不能滿足人們的胃口的,圖片,flash,音頻,視頻就成為瀏覽網(wǎng)頁的主流顯示,在手機上也一樣,本文將詳細介紹此功能的實現(xiàn)方法
    2012-11-11
  • Android中SurfaceTexture TextureView SurfaceView GLSurfaceView的區(qū)別

    Android中SurfaceTexture TextureView SurfaceView GLSurfaceView

    這篇文章主要介紹了Android中SurfaceTexture TextureView SurfaceView GLSurfaceView的區(qū)別,本文給大家介紹的非常詳細,對大家的學習或工作具有一定的參考借鑒價值,需要的朋友可以參考下
    2021-09-09
  • Flutter自定義底部導航欄的方法

    Flutter自定義底部導航欄的方法

    這篇文章主要為大家詳細介紹了Flutter自定義底部導航欄的方法,文中示例代碼介紹的非常詳細,具有一定的參考價值,感興趣的小伙伴們可以參考一下
    2022-07-07
  • Android studio 快速刪除無用資源的方法

    Android studio 快速刪除無用資源的方法

    最近苦于android 項目越來越大,項目需求不停變動。項目中的資源文件越來越雜,越來越亂。android studio怎么刪除無用資源呢?下文圖文并茂給大家介紹的非常詳細,需要的朋友參考下吧
    2017-11-11
  • Android實現(xiàn)可滑動的自定義日歷控件

    Android實現(xiàn)可滑動的自定義日歷控件

    這篇文章主要為大家詳細介紹了Android實現(xiàn)可滑動的自定義日歷控件,具有一定的參考價值,感興趣的小伙伴們可以參考一下
    2018-07-07
  • Flutter學習之Navigator的高級用法分享

    Flutter學習之Navigator的高級用法分享

    這篇文章主要為大家詳細介紹了Flutter中之Navigator的高級用法的相關(guān)知識,文中的示例代碼講解詳細,具有一定的學習價值,感興趣的可以了解一下
    2023-02-02
  • Android之高效加載大圖的方法示例

    Android之高效加載大圖的方法示例

    這篇文章主要介紹了Android之高效加載大圖的方法示例,小編覺得挺不錯的,現(xiàn)在分享給大家,也給大家做個參考。一起跟隨小編過來看看吧
    2019-03-03

最新評論