Lifecycle，將Activity或Fragment的生命周期與需要根據(jù)生命周期進(jìn)行邏輯處理的類關(guān)聯(lián)起來(lái)，減少該類與Activity或Fragment的耦合。

1.使用

/**
 * Activity，被觀察者
 */
public class MainActivity extends AppCompatActivity {
    private static final String TAG = "MainActivity";

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        // 添加觀察者
        getLifecycle().add(new Presenter());
    }
}

/**
 * Presenter，觀察者
 */
public class Presenter implements LifecycleObserver {
    private static final String TAG = "Presenter";

    @OnLifecycleEvent(Lifecycle.Event.ON_ANY)
    void onAny(LifecycleOwner owner, Lifecycle.Event event) {
        Log.d(TAG, "onAny() called with: owner = [" + owner + "], event = [" + event + "]");
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_CREATE)
    void onCreate() {
        Log.d(TAG, "onCreate() called");
    }
    // 其他幾個(gè)生命周期類似寫(xiě)法，不再列舉
    ......
}

被觀察者通過(guò)getLifecycle().add(new Presenter());添加觀察者；觀察者則通過(guò)注解@OnLifecycleEvent的形式觀察其生命周期變化。

特別注意：onCreate onStart onResume 是先走Activity的相關(guān)方法然后是觀察者的相關(guān)方法；onPause onStop onDestory是先走觀察者的相關(guān)方法然后是Activity的相關(guān)方法。

日志

2. 涉及到的類

• Lifecycle：持有Android生命周期的抽象類，提供了addObserver removeObserver getCurrentState 方法，生命周期事件Event和狀態(tài)State

/**
 * Defines an object that has an Android Lifecycle.
 */
public abstract class Lifecycle {
    public abstract void addObserver(@NonNull LifecycleObserver observer);
    public abstract void removeObserver(@NonNull LifecycleObserver observer);
    public abstract State getCurrentState();
    public enum Event {
        ON_CREATE
        ... // 生命周期事件不再一一列舉
    }
    public enum State {
        INITIALIZED
        ... // 狀態(tài)不再一一列舉
    }
}

• LifecycleRegistry：Lifecycle 的實(shí)現(xiàn)類，維護(hù)了一個(gè)觀察者列表、處理了生命周期事件

public class LifecycleRegistry extends Lifecycle {
    ...
    // 觀察者列表
    private FastSafeIterableMap<LifecycleObserver, ObserverWithState> mObserverMap = new FastSafeIterableMap<>();
    ...
    // 處理生命周期事件
    public void handleLifecycleEvent(@NonNull Lifecycle.Event event) {
        ...
    }
    ...
}

• LifecycelObserver：生命周期觀察者標(biāo)記標(biāo)記接口，無(wú)任何方法；實(shí)現(xiàn)該接口的類才能被 addObserver

/**
 * Marks a class as a LifecycleObserver.
 */
public interface LifecycleObserver {

}

• LifecycleOwner：擁有Android生命周期的接口，實(shí)現(xiàn)該接口的類會(huì)持有 Lifecycle

/**
 * A class that has an Android lifecycle. 
 */
public interface LifecycleOwner {
    Lifecycle getLifecycle();
}

類圖

Lifecycle.png

3. 原理

原理簡(jiǎn)單的理解為三步：
1.注冊(cè)觀察者，將需要依賴Activity或Fragment的類注冊(cè)為觀察者，觀察者需要實(shí)現(xiàn)Lifecycle接口；
2.Fragment和Activity關(guān)聯(lián)Lifecycle，目的是在Frament或Activity觸發(fā)生命周期時(shí)通知Lifecycle；
3.LifecycleRegistry（Lifecycle的實(shí)現(xiàn)類）通知觀察者，通過(guò)反射的方法實(shí)現(xiàn)；

3.1 注冊(cè)觀察者

從添加觀察者 getLifecycle().addObserver(new Presenter()); 入手，了解注冊(cè)觀察者原理
首先會(huì)追溯到 LifecycleRegistry

public class LifecycleRegistry extends Lifecycle {
    @Override
    public void addObserver(@NonNull LifecycleObserver observer) {
        ...
        // 關(guān)鍵代碼1 new ObserverWithState
        ObserverWithState statefulObserver =  new ObserverWithState(observer, initialState);
        ...
    }
    // 靜態(tài)內(nèi)部類
    static class ObserverWithState {
        // 接--關(guān)鍵代碼1
        ObserverWithState(LifecycleObserver observer, State initialState) {
            // 關(guān)鍵代碼2 Lifecycling.lifecycleEventObserver
            mLifecycleObserver = Lifecycling.lifecycleEventObserver(observer);
            ...
        }
     }
}

接著會(huì)追溯到 Lifecycling

public class Lifecycling {
    // 接--關(guān)鍵代碼2
    static LifecycleEventObserver lifecycleEventObserver(Object object) {
        ...
        // 關(guān)鍵代碼3
        return new ReflectiveGenericLifecycleObserver(object);
    }
}

接著會(huì)追溯到 ReflectiveGenericLifecycleObserver

class ReflectiveGenericLifecycleObserver implements LifecycleEventObserver {
    // 接--關(guān)鍵代碼3
    ReflectiveGenericLifecycleObserver(Object wrapped) {
        ...
        // 關(guān)鍵代碼4
        mInfo = ClassesInfoCache.sInstance.getInfo(mWrapped.getClass());
    }
}

最終追溯到 ClassesInfoCache

final class ClassesInfoCache {
    // 接--關(guān)鍵代碼4
    CallbackInfo getInfo(Class<?> klass) {
        ...
        // 關(guān)鍵代碼5
        existing = createInfo(klass, null);
        return existing;
    }
    ...
    // 接--關(guān)鍵代碼5
    private CallbackInfo createInfo(Class<?> klass, @Nullable Method[] declaredMethods) {
        ...
        // 通過(guò)反射獲得類的方法
        Method[] methods = declaredMethods != null ? declaredMethods : getDeclaredMethods(klass);
        for (Method method : methods) {
            // 找到使用注解 @OnLifecycleEvent 的方法
            OnLifecycleEvent annotation = method.getAnnotation(OnLifecycleEvent.class);
            ...
            verifyAndPutHandler(handlerToEvent, methodReference, event, klass);
            ...
        }
        // 會(huì)創(chuàng)建一個(gè)回到的信息類，后續(xù)的反射就會(huì)從整個(gè)信息里取值
        CallbackInfo info = new CallbackInfo(handlerToEvent);
        mCallbackMap.put(klass, info);
        mHasLifecycleMethods.put(klass, hasLifecycleMethods);
        return info;
    }
    ...
       
    static class CallbackInfo {
        // 反射回調(diào)時(shí)，會(huì)從該集合里取值
        final Map<Lifecycle.Event, List<MethodReference>> mEventToHandlers;
        CallbackInfo(Map<MethodReference, Lifecycle.Event> handlerToEvent) {
            mHandlerToEvent = handlerToEvent;
            mEventToHandlers = new HashMap<>();
            for (Map.Entry<MethodReference, Lifecycle.Event> entry : handlerToEvent.entrySet()) {
                Lifecycle.Event event = entry.getValue();
                List<MethodReference> methodReferences = mEventToHandlers.get(event);
                if (methodReferences == null) {
                    methodReferences = new ArrayList<>();
                    // 向集合里添加事件和對(duì)應(yīng)的回調(diào)方法
                    mEventToHandlers.put(event, methodReferences);
                }
                methodReferences.add(entry.getKey());
            }
        }  
    }
    
}

注冊(cè)觀察者方法調(diào)用關(guān)系圖

Observer Register

3.2 將Fragment或Activity關(guān)聯(lián)Lifecycle

Fragment或Activity持有Lifecycle的對(duì)象，在Frament或Activity觸發(fā)生命周期時(shí)通知Lifecycle。Activity和Fragment的關(guān)聯(lián)方式稍有不同。
Fragment的關(guān)聯(lián)比較簡(jiǎn)單，注意是 androidx.fragment.app.Fragment;

3.2.1 Fragment關(guān)聯(lián)Lifecycle

/**
 * androidx.fragment.app.Fragment
 */ 
public class Fragment implements LifecycleOwner{
    // 生命周期(Lifecycle)類
    LifecycleRegistry mLifecycleRegistry;
    ...
    @Override
    @NonNull
    public Lifecycle getLifecycle() {
        // 實(shí)現(xiàn) LifecycleOwner 的方法
        return mLifecycleRegistry;
    }
    // 構(gòu)造函數(shù)會(huì)初始化 生命周期(Lifecycle)
    public Fragment() {
        initLifecycle();
    }
    
    private void initLifecycle() {
        mLifecycleRegistry = new LifecycleRegistry(this);
        ...
    }
    
    // ================= Fragment 生命周期 Create 事件 =================
    void performCreate(Bundle savedInstanceState) {
        ...
        // 調(diào)用 Fragment 的 onCreate 方法
        onCreate(savedInstanceState);
        ...
        // 調(diào)用生命周期(Lifecycle)方法通知 onCreate 事件
        mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_CREATE);
    }
    
    // ================= Fragment 生命周期 Start 事件 =================
    void performStart() {
        ...
        onStart();
        ...
        mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_START);
        ...
    }

    // ================= Fragment 生命周期 Resume 事件 =================
    void performResume() {
        ...
        onResume();
        ...
        mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_RESUME);
        ...
    }
    
    // ================= Fragment 生命周期 Pause 事件；注意這里的調(diào)用順序變了 =================
    void performPause() {
        ...
        // 調(diào)用生命周期(Lifecycle)方法通知 onPause 事件
        mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_PAUSE);
        ...
        // 先調(diào)用了 mLifecycleRegistry ，后調(diào)用 onPause()
        // 調(diào)用 Fragment 的 onResume 方法
        onPause();
        ...
    }
    
   // ================= Fragment 生命周期 Stop 事件；注意這里的調(diào)用順序變了 =================
    void performStop() {
        ...
        mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_STOP);
        ...
        onStop();
        ...
    }
    
    // ================= Fragment 生命周期 Destroy 事件；注意這里的調(diào)用順序變了 =================
    void performDestroy() {
        ...
        mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_DESTROY);
        ...
        onDestroy();
        ...
    }
}

至此，F(xiàn)ragment的生命周期通過(guò)Lifecycle的實(shí)現(xiàn)類LifecycleRegistry與Lifecycle關(guān)聯(lián)起來(lái)，接下來(lái)看一下Activity是如何與Lifecycle關(guān)聯(lián)起來(lái)。

3.2.2 Activity關(guān)聯(lián)Lifecycle

Activity并不是直接關(guān)聯(lián)Lifecyle，而是通過(guò)一個(gè) ReportFragment 作為中介實(shí)現(xiàn)關(guān)聯(lián)回調(diào)的。首先看一下Activity的繼承關(guān)系

Activity Extends

從Fragment的分析可以了解到持有生命周期的類(Fragment/Activity)主要是通過(guò) LifecycleRegistry 來(lái)通知觀察者。

Activity繼承比較復(fù)雜，如何正確尋找處理Lifecycle的Activity（心路歷程...可跳過(guò)）
錯(cuò)誤線路：首先找到與之相關(guān)的類 androidx.fragment.app.FragmentActivity ，他有一個(gè)成員變量 mFragmentLifecycleRegistry ，根據(jù)Fragment的邏輯去查看 FragmentActivity 的生命周期方法，確實(shí)發(fā)現(xiàn)有調(diào)用 mFragmentLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event); 方法，但是這個(gè)并不是我們要找的。我們知道在添加觀察者時(shí)需要調(diào)用 getLifecycle() 方法，而 FragmentActivity 并沒(méi)有實(shí)現(xiàn) LifecycleOwner 接口；FragmentActivity 的成員變量 mFragmentLifecycleRegistry 時(shí)間是為其內(nèi)部類 HostCallbacks 服務(wù)的。因此這是錯(cuò)誤的，我在Debug的時(shí)候深深的踩了這個(gè)坑......

正確路線：在添加觀察者時(shí)要調(diào)用getLifecycle() 方法，從類圖中可以看到 androidx.activity.ComponentActivity 和 androidx.core.app.ComponentActivity 都實(shí)現(xiàn)了 LifecycleOwner 接口的getLifecycle() 方法，那么到底是調(diào)用哪一個(gè)呢？根據(jù)繼承關(guān)系可以得出實(shí)際上是會(huì)調(diào)用 androidx.activity.ComponentActivity 中的方法，根據(jù)編譯器 ctrl+b 也會(huì)引導(dǎo)到這里。

根據(jù)正確路線找到了正確的類 androidx.activity.ComponentActivity（以下簡(jiǎn)稱ComponentActivity），看一下ComponentActivity的生命周期方法，驚奇的發(fā)現(xiàn)并沒(méi)有調(diào)用 mFragmentLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event); 方法，和Fragment不一樣（這也是我一直陷入錯(cuò)誤路線的原因）。接下來(lái)查看一下 ComponentActivity 的 onCreate 方法

查看 ComponentActivity 源碼

public class ComponentActivity extends androidx.core.app.ComponentActivity implements LifecycleOwner{
    private final LifecycleRegistry mLifecycleRegistry = new LifecycleRegistry(this);

    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        ...
        // 通過(guò)一個(gè)沒(méi)有UI的ReportFragment綁定到Activity上來(lái)實(shí)現(xiàn)觸發(fā)
        ReportFragment.injectIfNeededIn(this);
        ...
    }
    
    @Override
    public Lifecycle getLifecycle() {
        return mLifecycleRegistry;
    }
}

查看 ReportFragment 源碼，可以看到其中有：獲取其綁定的Activity的 Lifecycle 并調(diào)用 handleLifecycleEvent 方法的代碼。以下代碼截取的是Api 29 以下的，Api29及以上大同小異

public class ReportFragment{
    
    // 綁定 Activity
    public static void injectIfNeededIn(Activity activity) {
        ...
        android.app.FragmentManager manager = activity.getFragmentManager();
        if (manager.findFragmentByTag(REPORT_FRAGMENT_TAG) == null) {
            manager.beginTransaction().add(new ReportFragment(), REPORT_FRAGMENT_TAG).commit();
            manager.executePendingTransactions();
        }
    }
    
    // 以 Create 為例，其他生命周期時(shí)間雷同
    @Override
    public void onActivityCreated(Bundle savedInstanceState) {
        ...
        // 分發(fā)事件
        dispatch(Lifecycle.Event.ON_CREATE);
    }
    
    private void dispatch(@NonNull Lifecycle.Event event) {
        ...
        // 獲取其綁定的Activity
        dispatch(getActivity(), event);
    }
    // 最終回調(diào)到該方法
    static void dispatch(@NonNull Activity activity, @NonNull Lifecycle.Event event) {
        if (activity instanceof LifecycleRegistryOwner) {
            // 調(diào)用綁定的Activity的生命周期(Lifecycle)方法通知相關(guān)事件
            ((LifecycleRegistryOwner) activity).getLifecycle().handleLifecycleEvent(event);
            return;
        }

        if (activity instanceof LifecycleOwner) {
            Lifecycle lifecycle = ((LifecycleOwner) activity).getLifecycle();
            if (lifecycle instanceof LifecycleRegistry) {
                // 調(diào)用生命周期(Lifecycle)方法通知相關(guān)事件
                ((LifecycleRegistry) lifecycle).handleLifecycleEvent(event);
            }
        }
    }
}

不要忘記生命周期調(diào)用順序的區(qū)別，再放一次圖

日志

Activity是如何控制以上流程的？查看Activity源碼

public class Activity{
    // ============================ Create 事件 ============================
    final void performCreateCommon() {
        ...
        mFragments.dispatchActivityCreated();
        ...
    }

    final void performCreate(Bundle icicle) {
        ...
        // Activity 的onCreate
        onCreate(icicle);
        ...
        // Fragment 分發(fā)Create
        performCreateCommon();
    }

    final void performCreate(Bundle icicle, PersistableBundle persistentState) {
        ...
        onCreate(icicle, persistentState);
        ...
        performCreateCommon();
    }
    
    // ============================ Start 事件 ============================
    final void performStart() {
        ...
        // Activity 的 onStart
        mInstrumentation.callActivityOnStart(this);
        ...
        // Fragment 分發(fā) Start
        mFragments.dispatchStart();
        ...
    }
    // ============================ Resume 事件 ============================
    final void performResume() {
        ...
        // Activity 的 onStart
        mInstrumentation.callActivityOnResume(this);
        ...
        // Fragment 分發(fā) Resume
        mFragments.dispatchResume();
        ...
    }
    // ============================ Pause 事件 ============================
    final void performPause() {
        ...
        // Fragment 分發(fā) Pause
        mFragments.dispatchPause();
        ...
        // Activity 的 onPause
        onPause();
        ...
    }
    // ============================ Stop 事件 ============================
    final void performStop(boolean preserveWindow) {
        ...
        // Fragment 分發(fā) Stop
        mFragments.dispatchStop();
        ...
        // Activity 的 onStop
        mInstrumentation.callActivityOnStop(this);
        ...
    }
    // ============================ Destroy 事件 ============================
    final void performDestroy() {
        ...
        // Fragment 分發(fā) Stop
        mFragments.dispatchDestroy();
        // Activity 的 onDestroy
        onDestroy();
        ...
    }

}

3.3 LifecycleRegistry通知觀察者

通過(guò)以上分析得出，最終都會(huì)回調(diào)到 LifecycleRegistry.handleLifecycleEvent(event) ，看一下該方法做了什么操作

public class LifecycleRegistry extends Lifecycle {
    
    public void handleLifecycleEvent(@NonNull Lifecycle.Event event) {
        ...
        moveToState(event.getTargetState());
    }
    private void moveToState(State next) {
        ...
        sync();
        ...
    }
    private void sync() {
        LifecycleOwner lifecycleOwner = mLifecycleOwner.get();
        ...
        while (!isSynced()) {
            ...
            // 調(diào)用 backwardPass 或 forwardPass
            backwardPass(lifecycleOwner);
            ...
            forwardPass(lifecycleOwner);
        }
            ...
    }
    // 以 forwardPass 為例
    private void forwardPass(LifecycleOwner lifecycleOwner) {
        // 這里就開(kāi)始遍歷觀察者列表 mObserverMap 
        Iterator<Map.Entry<LifecycleObserver, ObserverWithState>> ascendingIterator = mObserverMap.iteratorWithAdditions();
        while (ascendingIterator.hasNext() && !mNewEventOccurred) {
            Map.Entry<LifecycleObserver, ObserverWithState> entry = ascendingIterator.next();
            // 這里拿到注冊(cè)的觀察者對(duì)象
            ObserverWithState observer = entry.getValue();
            while ((observer.mState.compareTo(mState) < 0 && !mNewEventOccurred && mObserverMap.contains(entry.getKey()))) {
                pushParentState(observer.mState);
                final Event event = Event.upFrom(observer.mState);
                if (event == null) {
                    throw new IllegalStateException("no event up from " + observer.mState);
                }
                // 調(diào)用觀察者的事件分發(fā)
                observer.dispatchEvent(lifecycleOwner, event);
                popParentState();
            }
        }
    }
    
    // 帶狀態(tài)的觀察者
    static class ObserverWithState {
        LifecycleEventObserver mLifecycleObserver;
        
        void dispatchEvent(LifecycleOwner owner, Event event) {
            ...
            // 通知觀察者發(fā)生變化
            mLifecycleObserver.onStateChanged(owner, event);
            ...
        }
    }
}

class ReflectiveGenericLifecycleObserver implements LifecycleEventObserver {
    ...
    private final CallbackInfo mInfo;

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

    @Override
    public void onStateChanged(@NonNull LifecycleOwner source, @NonNull Event event) {
        // 回調(diào)
        mInfo.invokeCallbacks(source, event, mWrapped);
    }
}

final class ClassesInfoCache {
    ...
    // 回調(diào)
    void invokeCallbacks(LifecycleOwner source, Lifecycle.Event event, Object target) {
        // 反射回調(diào)方法
        invokeMethodsForEvent(mEventToHandlers.get(event), source, event, target);
        invokeMethodsForEvent(mEventToHandlers.get(Lifecycle.Event.ON_ANY), source, event,target);
    }

    private static void invokeMethodsForEvent(List<MethodReference> handlers, LifecycleOwner source, Lifecycle.Event event, Object mWrapped) {
        if (handlers != null) {
            for (int i = handlers.size() - 1; i >= 0; i--) {
                // 反射回調(diào)
                handlers.get(i).invokeCallback(source, event, mWrapped);
            }
        }
    }
    static final class MethodReference {
        void invokeCallback(LifecycleOwner source, Lifecycle.Event event, Object target) {
            ...
            switch (mCallType) {
                case CALL_TYPE_NO_ARG:
                    // 反射調(diào)用，完成了整個(gè)流程
                    mMethod.invoke(target);
                    break;
                case CALL_TYPE_PROVIDER:
                    mMethod.invoke(target, source);
                    break;
                case CALL_TYPE_PROVIDER_WITH_EVENT:
                    mMethod.invoke(target, source, event);
                    break;
            }
            ...
    }
}

4.總結(jié)

方法調(diào)用關(guān)系圖

Lifecycle Callback