(一) Jetpack Lifecycle 源碼分析

文章一文章二文章三文章四文章五文章六文章七

依賴

implementation 'androidx.lifecycle:lifecycle-extensions:2.2.0'
kapt 'androidx.lifecycle:lifecycle-compiler:2.2.0'

示例代碼

生命週期觀察者

class MyLifecycleObserver : LifecycleObserver {
    @OnLifecycleEvent(Lifecycle.Event.ON_CREATE)
    fun onCreate(owner: LifecycleOwner?) {
        //doSomething
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_DESTROY)
    fun onDestroy(owner: LifecycleOwner?) {
        //doSomething
    }
}

Activity中的代碼

class LifecycleDemoActivity : AppCompatActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        ...
        // 添加觀察者
        lifecycle.addObserver(MyLifecycleObserver())
    }
}

概述

LifecycleOwner:生命週期的事件分發者,在Activity/Fragment他們的生命週期發生變化的時發出相應的Event給LifecycleRegistry.
LifecycleObserver:生命週期的觀察者,通過註解將處理函數與希望監聽的Event綁定,當相應的Event發生時,LifecycleRegistry會通知相應的函數進行處理。
LifecycleRegistry:控制中心。它負責控制state的轉換、接受分發event事件。

觀察者被添加到哪裏了?

首先,Android X中ComponentActivity實現了LifecycleOwner接口, 該接口唯一方法getLifecycle()用來返回一個Lifecycle對象.

// ComponentActivity類實現LifecycleOwner接口
public class ComponentActivity extends androidx.core.app.ComponentActivity implements LifecycleOwner,ViewModelStoreOwner,HasDefaultViewModelProviderFactory,SavedStateRegistryOwner{
    // ComponentActivity類中創建了一個LifecycleRegistry變量,getLifecycle()方法返回的正是此變量.
    private final LifecycleRegistry mLifecycleRegistry = new LifecycleRegistry(this);
    @CallSuper
    @Override
    protected void onSaveInstanceState(@NonNull Bundle outState) {
        Lifecycle lifecycle = getLifecycle();
        if (lifecycle instanceof LifecycleRegistry) {
            // 設置LifecycleRegistry對象當前的狀態爲Lifecycle.State.CREATED.
            ((LifecycleRegistry) lifecycle).setCurrentState(Lifecycle.State.CREATED);
        }
        super.onSaveInstanceState(outState);
        mSavedStateRegistryController.performSave(outState);
    }
    @NonNull
    @Override
    public Lifecycle getLifecycle() {
        // LifecycleRegistry類型變量
        return mLifecycleRegistry;
    }
}
// LifecycleOwner 接口
public interface LifecycleOwner {
    @NonNull
    Lifecycle getLifecycle();
}

調用lifecycle.addObserver(MyLifecycleObserver())實際上就是調用ComponentActivity中的mLifecycleRegistry對象的addObserver()方法
2. 分析LifecycleRegistry.addObserver(LifecycleObserver observer)

public class LifecycleRegistry extends Lifecycle {
    // LifecycleRegistry的狀態
    private State mState;
    // 保留觀察者並在遍歷期間可以處理刪除/添加的自定義列表
    private FastSafeIterableMap<LifecycleObserver, ObserverWithState> mObserverMap = new FastSafeIterableMap<>();
    // 構造方法
    public LifecycleRegistry(@NonNull LifecycleOwner provider) {
        // mLifecycleOwner代表當前Activity的弱引用.
        mLifecycleOwner = new WeakReference<>(provider);
        // LifecycleRegistry剛創建時候爲INITIALIZED狀態.
        mState = INITIALIZED;
    }
    @Override
    public void addObserver(@NonNull LifecycleObserver observer) {
        State initialState = mState == DESTROYED ? DESTROYED : INITIALIZED;
        // 將用戶傳入的觀察者和當前觀察者對應的初始狀態放入ObserverWithState對象中保存起來.
        ObserverWithState statefulObserver = new ObserverWithState(observer, initialState);
        // 將觀察者對象與它對應的ObserverWithState對象保存在FastSafeIterableMap集合中.
        ObserverWithState previous = mObserverMap.putIfAbsent(observer, statefulObserver);
        if (previous != null) {
            // 如果觀察者往mObserverMap中添加不成功,就不繼續向下執行了.
            return;
        }
        // 從Activity弱引用mLifecycleOwner中獲取Activity對象.
        LifecycleOwner lifecycleOwner = mLifecycleOwner.get();
        // mAddingObserverCounter: 是否在添加觀察者中.
        // mHandlingEvent: 是否在處理事件同步
        // 這裏爲false.
        boolean isReentrance = mAddingObserverCounter != 0 || mHandlingEvent;
        // 計算當前被添加進來的觀察者應該同步到哪種最終狀態
        State targetState = calculateTargetState(observer);
        mAddingObserverCounter++;
        // 當前觀察者的狀態是INITIALIZED,LifecycleRegistry當前的狀態一般都比INITIALIZED要大,
        // 就要進入while()循環提升當前觀察者的狀態.
        while ((statefulObserver.mState.compareTo(targetState) < 0 && mObserverMap.contains(observer))) {
            pushParentState(statefulObserver.mState);
            // upEvent() 方法就是將狀態轉換爲事件,然後再由dispatchEvent()方法中將事件轉換爲狀態.
            // dispatchEvent() 方法負責分發事件以及更新ObserverWithState對象中的狀態.
            statefulObserver.dispatchEvent(lifecycleOwner, upEvent(statefulObserver.mState));
            popParentState();
            // 再次計算當前觀察者應該同步到哪種最終狀態,因爲這個過程中可能LifecycleRegistry的狀態會改變.
            // 如果LifecycleRegistry的狀態改變了或者第一次循環完事後,當前觀察者的狀態還未和LifecycleRegistry的狀態同步,那麼還需要繼續的循環執行.
            targetState = calculateTargetState(observer);
        }
        if (!isReentrance) {
            // 該方法的作用是將mObserverMap中所有的觀察者的狀態都同步爲當前LifecycleRegistry的狀態.
            sync();
        }
        mAddingObserverCounter--;
    }
}

分析calculateTargetState()該方法,該方法是計算LifecycleRegistry對象當前的狀態的.

private State calculateTargetState(LifecycleObserver observer) 
    // 獲取observer鍵在mObserverMap中對應的前一個對象
    Entry<LifecycleObserver, ObserverWithState> previous = mObserverMap.ceil(observer);
    // 獲取前一個對象的狀態
    State siblingState = previous != null ? previous.getValue().mState : null;
    // 這裏一般是null
    State parentState = !mParentStates.isEmpty() ? mParentStates.get(mParentStates.size() - 1): null;
    // 所以最終返回的就是LifecycleRegistry對象的mState變量.
    return min(min(mState, siblingState), parentState);
}

以上主要是分析觀察者對象被添加是怎麼回事,其中主要的dispatchEvent()和sync()方法下面分析.

事件是如何從`Activity`被分發到`LifecycleRegistry`中間的?

還是看ComponentActivity類

public class ComponentActivity extends androidx.core.app.ComponentActivity implements LifecycleOwner,ViewModelStoreOwner,HasDefaultViewModelProviderFactory,SavedStateRegistryOwner{
    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        mSavedStateRegistryController.performRestore(savedInstanceState);
        // 這裏狠關鍵
        ReportFragment.injectIfNeededIn(this);
        if (mContentLayoutId != 0) {
            setContentView(mContentLayoutId);
        }
    }
}

ReportFragment可以感知Activity的生命週期,生命週期事件最終由ReportFragment對象來分發.

public class ReportFragment extends Fragment {
    public static void injectIfNeededIn(Activity activity) {
        if (Build.VERSION.SDK_INT >= 29) {
            // Android10以上的系統生命週期的事件分發與10以下的稍微不同
            activity.registerActivityLifecycleCallbacks(new LifecycleCallbacks());
        }
        android.app.FragmentManager manager = activity.getFragmentManager();
        if (manager.findFragmentByTag(REPORT_FRAGMENT_TAG) == null) {
            // 將無界面的Fragment添加到Activity中.
            manager.beginTransaction().add(new ReportFragment(), REPORT_FRAGMENT_TAG).commit();
            manager.executePendingTransactions();
        }
    }
    // ReportFragment中的onActivityCreated()方法
    @Override
    public void onActivityCreated(Bundle savedInstanceState) {
        super.onActivityCreated(savedInstanceState);
        dispatchCreate(mProcessListener);
        // 10 以下的系統直接在Fragment的生命週期中調用調用方法分發生命週期事件
        dispatch(Lifecycle.Event.ON_CREATE);
    }
    
    // 10 以上的系統調用方法分發生命週期事件
    // LifecycleCallbacks類繼承了ActivityLifecycleCallbacks接口.
    static class LifecycleCallbacks implements Application.ActivityLifecycleCallbacks {
        @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);
        }
    }
    // 生命週期事件分發最終由該方法來做
    @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) {
                // 當前Activity實現的是LifecycleOwner方法,創建的對象爲LifecycleRegistry類型.
                ((LifecycleRegistry) lifecycle).handleLifecycleEvent(event);
            }
        }
    }
}

上面捋了下生命週期事件如何傳遞到LifecycleRegistry中的.

`LifecycleRegistry`如何處理生命週期事件?

handleLifecycleEvent()處理生命週期事件.

public class LifecycleRegistry extends Lifecycle {
    
    public void handleLifecycleEvent(@NonNull Lifecycle.Event event) {
        // 將當前Activity傳遞過來的生命週期事件轉化爲對應的生命週期狀態
        State next = getStateAfter(event);
        // 該方法是同步觀察者的生命週期狀態以及通知各個觀察者調用對應的生命週期方法的開端.
        moveToState(next);
    }
}

moveToState(State next)方法分析

public class LifecycleRegistry extends Lifecycle {
    private void moveToState(State next) {
        // 如果當前LifecycleRegistry狀態和需要同步的狀態相同就不向下執行了.
        if (mState == next) {
            return;
        }
        // 更新LifecycleRegistry當前狀態
        mState = next;
        // mHandlingEvent: 如果正在處理生命週期事件
        // mAddingObserverCounter: 如果正在添加觀察者中
        // 兩個條件滿足其一也將不會向下執行.
        if (mHandlingEvent || mAddingObserverCounter != 0) {
            mNewEventOccurred = true;
            // we will figure out what to do on upper level.
            return;
        }
        mHandlingEvent = true;
        // 這裏開始正式的同步狀態以及通知觀察者調用相應的生命週期了.
        sync();
        mHandlingEvent = false;
    }
}

sync()同步以及通知觀察者

public class LifecycleRegistry extends Lifecycle {
    private void sync() {
        LifecycleOwner lifecycleOwner = mLifecycleOwner.get();
        // isSynced(): 判斷觀察者是否需要同步,該方法下面分析.
        while (!isSynced()) {
            mNewEventOccurred = false;
            // mObserverMap.eldest().getValue().mState: 獲取最後一個觀察者對應的狀態
            // mState.compareTo(mObserverMap.eldest().getValue().mState) : 當前LifecycleRegistry狀態與最後一個觀察者對應的狀態進行比較,
            // 如果LifecycleRegistry狀態比觀察者對應的狀態小,那麼執行backwardPass(lifecycleOwner);.
            if (mState.compareTo(mObserverMap.eldest().getValue().mState) < 0) {
                backwardPass(lifecycleOwner);
            }
            Entry<LifecycleObserver, ObserverWithState> newest = mObserverMap.newest();
            // 這裏表示的是如果當前LifecycleRegistry狀態與最開始的觀察者對應的狀態比較,如果LifecycleRegistry狀態比觀察者對應的狀態大,那麼執行forwardPass(lifecycleOwner);.
            if (!mNewEventOccurred && newest != null&& mState.compareTo(newest.getValue().mState) > 0) {
                forwardPass(lifecycleOwner);
            }
        }
        mNewEventOccurred = false;
    }
}

backwardPass(lifecycleOwner);與forwardPass(lifecycleOwner);

public class LifecycleRegistry extends Lifecycle {
    private void backwardPass(LifecycleOwner lifecycleOwner) {
        Iterator<Entry<LifecycleObserver, ObserverWithState>> descendingIterator =  mObserverMap.descendingIterator();
        // 遍歷mObserverMap集合中的所有鍵值對,鍵爲觀察者LifecycleObserver,值爲ObserverWithState
        while (descendingIterator.hasNext() && !mNewEventOccurred) {
            Entry<LifecycleObserver, ObserverWithState> entry = descendingIterator.next();
            // 獲取ObserverWithState對象
            ObserverWithState observer = entry.getValue();
            // observer.mState.compareTo(mState): 比較當前ObserverWithState對象中的狀態與LifecycleRegistry對應的狀態,
            // 如果ObserverWithState的狀態需要降級,繼續向下執行.
            // 這裏爲何要使用while()循環,因爲LifecycleRegistry當前狀態與ObserverWithState的狀態可能隔了2個或者多個等級,所以需要while()循環執行,
            // 直到ObserverWithState的狀態與LifecycleRegistry當前狀態相等位置.
            while ((observer.mState.compareTo(mState) > 0 && !mNewEventOccurred && mObserverMap.contains(entry.getKey()))) {
                // downEvent()獲取當前狀態降級之後的目標事件.
                Event event = downEvent(observer.mState);
                pushParentState(getStateAfter(event));
                // 然後調用ObserverWithState對象中的事件分發的方法, 這個方法稍後分析.
                observer.dispatchEvent(lifecycleOwner, event);
                popParentState();
            }
        }
    } 
    // 該方法與上面的backwardPass()方法差不多,他是將觀察者對應的狀態,升級爲當前LifecycleRegistry的狀態.
    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();
            }
        }
    }
}

在這個對觀察者對應的狀態進行與當前LifecycleRegistry的狀態同步的過程中,就會調用到觀察者對應的生命週期方法了.

調用`ObserverWithState.dispatchEvent()`將生命週期方法分發到觀察者中

分析ObserverWithState類

public class LifecycleRegistry extends Lifecycle {
    static class ObserverWithState {
        State mState;// 當前觀察者對應的狀態
        LifecycleEventObserver mLifecycleObserver; // 生命週期事件觀察者
        ObserverWithState(LifecycleObserver observer, State initialState) {
            // lifecycleEventObserver() 通過觀察者得到對應的生命週期事件觀察者.
            mLifecycleObserver = Lifecycling.lifecycleEventObserver(observer);
            mState = initialState;
        }
        void dispatchEvent(LifecycleOwner owner, Event event) {
            // 將當前生命週期事件轉化爲對應的生命週期狀態
            State newState = getStateAfter(event);
            mState = min(mState, newState);
            // 調用LifecycleEventObserver.onStateChanged()通知觀察者調用相應的方法.
            mLifecycleObserver.onStateChanged(owner, event);
            mState = newState;
        }
    }
}

Lifecycling.lifecycleEventObserver(observer)適配不同的觀察者對象得到對應的LifecycleEventObserver適配器對象

public class Lifecycling {
    // 視Observer的不同情況返回對應的觀察者適配器對象.
    @NonNull
    static LifecycleEventObserver lifecycleEventObserver(Object object) {
        boolean isLifecycleEventObserver = object instanceof LifecycleEventObserver;
        boolean isFullLifecycleObserver = object instanceof FullLifecycleObserver;
        if (isLifecycleEventObserver && isFullLifecycleObserver) {
            return new FullLifecycleObserverAdapter((FullLifecycleObserver) object,(LifecycleEventObserver) object);
        }
        if (isFullLifecycleObserver) {
            return new FullLifecycleObserverAdapter((FullLifecycleObserver) object, null);
        }
        if (isLifecycleEventObserver) {
            return (LifecycleEventObserver) object;
        }
        // 上面幾種適配器都好說,然後這個適配器是根據註釋來生成的,編譯後生成,路徑爲..\jetpack-sample\app\build\generated\source\kapt\debug\com\chiclaim\jetpack\test\MyLifeCycleObserver_LifecycleAdapter.java
        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);
    }
}

通過註解生成適配器邏輯關鍵看getAdapterName()方法

public class Lifecycling {
    // 這裏通過反射將觀察者的名字拼接後得到適配器對應的類名稱,然後反射創建該適配器對象.
    public static String getAdapterName(String className) {
        return className.replace(".", "_") + "_LifecycleAdapter";
    }
}

最後回到forwardPass()與backwardPass()方法中調用的ObserverWithState.dispatchEvent()方法

static class ObserverWithState {
    void dispatchEvent(LifecycleOwner owner, Event event) {
        State newState = getStateAfter(event);
        mState = min(mState, newState);
        // 上面分析過mLifecycleObserver就是通過不同類型的觀察者獲取到的對應的適配器對象,
        // 通過調用這些適配器對象的onStateChanged()方法,繼續向下看.
        mLifecycleObserver.onStateChanged(owner, event);
        mState = newState;
    }
}

mLifecycleObserver.onStateChanged(owner, event);
假如獲取的是FullLifecycleObserverAdapter對象

class FullLifecycleObserverAdapter implements LifecycleEventObserver {
    private final FullLifecycleObserver mFullLifecycleObserver; // 傳入的觀察者對象
    // 上一步中的mLifecycleObserver.onStateChanged(owner, event)最終調用了這裏
    @Override
    public void onStateChanged(@NonNull LifecycleOwner source, @NonNull Lifecycle.Event event) {
        switch (event) {
            case ON_CREATE:
                mFullLifecycleObserver.onCreate(source);
                break;
            case ON_START:
                mFullLifecycleObserver.onStart(source);
                break;
            ...
            }
    }
}

假如獲取的是SingleGeneratedAdapterObserver對象的話

class SingleGeneratedAdapterObserver implements LifecycleEventObserver {
    private final GeneratedAdapter mGeneratedAdapter; // 爲註解編譯後生成的類通過反射獲取到的對象
    // 上一步中的mLifecycleObserver.onStateChanged(owner, event)最終調用了這裏
    @Override
    public void onStateChanged(@NonNull LifecycleOwner source, @NonNull Lifecycle.Event event) {
        // 這裏是調用通過註解生成類對象中的callMethods()方法
        mGeneratedAdapter.callMethods(source, event, false, null);
        mGeneratedAdapter.callMethods(source, event, true, null);
    }
}

再來看看示例代碼中通過註解設置的觀察者編譯之後得到的類

public class MyLifeCycleObserver_LifecycleAdapter implements GeneratedAdapter {
    final MyLifecycleObserver mReceiver; // 這裏就是用戶創建的觀察者對象了.
    MyLifeCycleObserver_LifecycleAdapter(MyLifecycleObserver receiver) {
      this.mReceiver = receiver;
    }
    // 上一步調用的callMethods()方法
    @Override
    public void callMethods(LifecycleOwner owner, Lifecycle.Event event, boolean onAny, MethodCallsLogger logger) {
      ...
      if (event == Lifecycle.Event.ON_CREATE) {
        if (!hasLogger || logger.approveCall("onCreate", 2)) {
          // 到了這裏,最終會通過相應的事件調用對應的觀察者中的方法了.  
          mReceiver.onCreate(owner);
        }
        return;
      }
      if (event == Lifecycle.Event.ON_DESTROY) {
        if (!hasLogger || logger.approveCall("onDestroy", 2)) {
          mReceiver.onDestroy(owner);
        }
        return;
      }
    }
}

觀察訂閱模式其實很簡單,爲何Lifecycles組件整這麼複雜呢?原因可以看這個大佬寫的一篇博客.

(一) Jetpack Lifecycle 源碼分析

依賴

示例代碼

概述

觀察者被添加到哪裏了?

事件是如何從`Activity`被分發到`LifecycleRegistry`中間的?

`LifecycleRegistry`如何處理生命週期事件?

調用`ObserverWithState.dispatchEvent()`將生命週期方法分發到觀察者中

電子科技大學計算機科學與技術就讀體驗

Golang爬蟲代理接入的技術與實踐

(二) Jetpack LiveData 源碼分析

(一) Jetpack Lifecycle 源碼分析

Android 8.0 啓動圖標適配

(一) Dagger2 @Inject分析一

(三) Dagger2 @Module分析一

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結

(一) Jetpack Lifecycle 源碼分析

依賴

示例代碼

概述

觀察者被添加到哪裏了?

事件是如何從Activity被分發到LifecycleRegistry中間的?

LifecycleRegistry如何處理生命週期事件?

調用ObserverWithState.dispatchEvent()將生命週期方法分發到觀察者中

事件是如何從`Activity`被分發到`LifecycleRegistry`中間的?

`LifecycleRegistry`如何處理生命週期事件?

調用`ObserverWithState.dispatchEvent()`將生命週期方法分發到觀察者中