Jetpack之Lifecycle源码解析

1. 首先看看LifecycleObserver相关类的继承关系：

LifecycleObserver 是一个空接口，大部分情况下真正具有使用意义的是它的子接口 ，LifecycleObserver 可以说仅是用于类型标记

public interface LifecycleObserver {}

//用于监听 Lifecycle 的生命周期变化，可以获取到生命周期事件发生的具体变化

public interface LifecycleEventObserver extends LifecycleObserver {
    void onStateChanged(@NonNull LifecycleOwner source, @NonNull Lifecycle.Event event);
}

//根据 Activity 的生命周期回调方法扩展了几个同名的抽象方法

interface FullLifecycleObserver extends LifecycleObserver {

    void onCreate(LifecycleOwner owner);

    void onStart(LifecycleOwner owner);

    void onResume(LifecycleOwner owner);

    void onPause(LifecycleOwner owner);

    void onStop(LifecycleOwner owner);

    void onDestroy(LifecycleOwner owner);
}

//利用java8的default关键字特性，只需要实现自己关心的接口即可

public interface DefaultLifecycleObserver extends FullLifecycleObserver {
    default void onCreate(LifecycleOwner owner);

    default void onStart(LifecycleOwner owner);

    default void onResume(LifecycleOwner owner);

    default void onPause(LifecycleOwner owner);

    default void onStop(LifecycleOwner owner);

    default void onDestroy(LifecycleOwner owner);
}

//用于在收到 Lifecycle 生命周期事件状态变化时对 FullLifecycleObserver、LifecycleEventObserver 进行事件转发

class FullLifecycleObserverAdapter implements LifecycleEventObserver {
    private final FullLifecycleObserver mFullLifecycleObserver;
    private final LifecycleEventObserver mLifecycleEventObserver;

    FullLifecycleObserverAdapter(FullLifecycleObserver fullLifecycleObserver,
            LifecycleEventObserver lifecycleEventObserver) {
        mFullLifecycleObserver = fullLifecycleObserver;
        mLifecycleEventObserver = lifecycleEventObserver;
    }

    @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;
            case ON_RESUME:
                mFullLifecycleObserver.onResume(source);
                break;
            case ON_PAUSE:
                mFullLifecycleObserver.onPause(source);
                break;
            case ON_STOP:
                mFullLifecycleObserver.onStop(source);
                break;
            case ON_DESTROY:
                mFullLifecycleObserver.onDestroy(source);
                break;
            case ON_ANY:
                throw new IllegalArgumentException("ON_ANY must not been send by anybody");
        }
        if (mLifecycleEventObserver != null) {
            mLifecycleEventObserver.onStateChanged(source, event);
        }
    }
}

2. 回顾Lifecycle的使用：在Activity或Fragment中我们是用getLifecycle()获取Lifecycle对象，然后调用addObserver方法来注册监听。跟踪Activity和Fragment的类我们发现返回对象是LifecycleRegistry的实例。getLifecycle()其实是LifecycleOwner接口的方法，由于Fragment和Activity都实现该接口。LifecycleRegistry构造函数中也需要传入LifecycleOwner实例。

public interface LifecycleOwner {
    Lifecycle getLifecycle();
}

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

public class Fragment implements LifecycleOwner{

     public Fragment() {
        initLifecycle();
    }
    
    private void initLifecycle() {
        mLifecycleRegistry = new LifecycleRegistry(this);
    }

    public Lifecycle getLifecycle() {
        return mLifecycleRegistry;
    }
}

由此可知真正的业务都在LifecycleRegistry类中，LifecycleRegistry继承了Lifecycle抽象类：

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

    public enum Event { ON_CREATE, ON_START, ON_RESUME, ON_PAUSE, ON_STOP, ON_DESTROY, ON_ANY }

    public enum State { 
        DESTROYED, INITIALIZED, CREATED, STARTED, RESUMED; 

        public boolean isAtLeast(@NonNull State state) {
            return compareTo(state) >= 0;
        }
    }
}

public class LifecycleRegistry extends Lifecycle {

    public void addObserver(@NonNull LifecycleObserver observer) {
        //设置初始状态
        State initialState = mState == DESTROYED ? DESTROYED : INITIALIZED;
        //封装一个ObserverWithState对象
        ObserverWithState statefulObserver = new ObserverWithState(observer, initialState);
        //判断该observer是否已经存在，如果存在则返回缓存的ObserverWithState，如果不存在则将Observer赋值其中
        ObserverWithState previous = mObserverMap.putIfAbsent(observer, statefulObserver);

        if (previous != null) {
            return;
        }
        LifecycleOwner lifecycleOwner = mLifecycleOwner.get();
        if (lifecycleOwner == null) {
            // it is null we should be destroyed. Fallback quickly
            return;
        }

        boolean isReentrance = mAddingObserverCounter != 0 || mHandlingEvent;
        State targetState = calculateTargetState(observer);
        mAddingObserverCounter++;

        //从ON_CREATE、ON_START、ON_RESUME依次回调
        while ((statefulObserver.mState.compareTo(targetState) < 0
                && mObserverMap.contains(observer))) {
            pushParentState(statefulObserver.mState);
            //调用Observer的onStateChange方法
            statefulObserver.dispatchEvent(lifecycleOwner, upEvent(statefulObserver.mState));
            popParentState();
            // mState / subling may have been changed recalculate
            targetState = calculateTargetState(observer);
        }

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

}

3. 这个时候你可能会问当Activity的生命周期发生变化的时是如何回调的，这就需要看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) {
        ReportFragment.injectIfNeededIn(this);
    }
}

public class ReportFragment extends Fragment {
    public static void injectIfNeededIn(Activity activity) {
        if (Build.VERSION.SDK_INT >= 29) {
            //API 29+ Activity实现了注册Activity生命回调方法，在performXXX的方法的前后调用了dispatchActivityPreXXX和dispatchActivityPostXXX，这个方法中会分别回调onActivityXXX生命周期回调方法。
            activity.registerActivityLifecycleCallbacks(
                    new LifecycleCallbacks());
        }
        
        //添加一个透明的Fragment
        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();
        }
    }

    @Override
    public void onActivityCreated(Bundle savedInstanceState) {
        super.onActivityCreated(savedInstanceState);
        dispatchCreate(mProcessListener);
        dispatch(Lifecycle.Event.ON_CREATE);
    }

    private void dispatch(@NonNull Lifecycle.Event event) {
        if (Build.VERSION.SDK_INT < 29) {
            //API 大于29走registerActivityLifecycleCallbacks进行回调
            dispatch(getActivity(), event);
        }
    }

    //根据类型最终会调用LifecycleRegistry的handleLifecycleEvent方法
   

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

public class LifecycleRegistry extends Lifecycle {
   public void handleLifecycleEvent(@NonNull Lifecycle.Event event) {
        State next = getStateAfter(event);
        moveToState(next); //调用moveToState()
    }

    private void moveToState(State next) {
        if (mState == next) {
            return;
        }
        mState = next;
        if (mHandlingEvent || mAddingObserverCounter != 0) {
            mNewEventOccurred = true;
            return;
        }
        mHandlingEvent = true;
        sync();//调用sync()
        mHandlingEvent = false;
    }

    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()) {
            //根据Activity的生命周期状态判断是执行backwardPass、forwardPass

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

    private void backwardPass(LifecycleOwner lifecycleOwner) {
        Iterator<Entry<LifecycleObserver, ObserverWithState>> descendingIterator =
                mObserverMap.descendingIterator();
        while (descendingIterator.hasNext() && !mNewEventOccurred) {
            Entry<LifecycleObserver, ObserverWithState> entry = descendingIterator.next();
            ObserverWithState observer = entry.getValue();
            while ((observer.mState.compareTo(mState) > 0 && !mNewEventOccurred
                    && mObserverMap.contains(entry.getKey()))) {
                Event event = downEvent(observer.mState);
                pushParentState(getStateAfter(event));
                observer.dispatchEvent(lifecycleOwner, event); //调用dispatchEvent进行回调
                popParentState();
            }
        }
    }
    static class ObserverWithState {
       void dispatchEvent(LifecycleOwner owner, Event event) {
            State newState = getStateAfter(event);
            mState = min(mState, newState);
            mLifecycleObserver.onStateChanged(owner, event);
            mState = newState;
        }
    }
}

4. 最后你可能会产生疑问， 我传入的LifecycleObserver的回调函数是FullLifecycleObserver它是怎么回调对应的方法的？
其实在我们传入LifecycleObserver的时候LifecycleRegistry将其做了包装：

static class ObserverWithState {
        State mState;
        LifecycleEventObserver mLifecycleObserver;

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

public class Lifecycling{

    static LifecycleEventObserver lifecycleEventObserver(Object object) {
        //判断是LifecycleEventObserver类型还是FullLifecycleObserver
        boolean isLifecycleEventObserver类型还是 = object instanceof LifecycleEventObserver;
        boolean isFullLifecycleObserver = object instanceof FullLifecycleObserver;

        //如果都是则包装成FullLifecycleObserverAdapter
        if (isLifecycleEventObserver && isFullLifecycleObserver) {
            return new FullLifecycleObserverAdapter((FullLifecycleObserver) object,
                    (LifecycleEventObserver) object);
        }

        //如果是FullLifecycleObserver则包装成FullLifecycleObserverAdapter
        if (isFullLifecycleObserver) {
            return new FullLifecycleObserverAdapter((FullLifecycleObserver) object, null);
        }


        if (isLifecycleEventObserver) {
            return (LifecycleEventObserver) object;
        }

        //如果都不是则可能是通过注解的方式来实现回调，则通过反射进行回调
        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);
    }
}

class FullLifecycleObserverAdapter implements LifecycleEventObserver {
    switch (event) {
         case ON_CREATE:
             mFullLifecycleObserver.onCreate(source);
             break;
         case ON_START:
             mFullLifecycleObserver.onStart(source);
             break;
         case ON_RESUME:
             mFullLifecycleObserver.onResume(source);
             break;
         case ON_PAUSE:
             mFullLifecycleObserver.onPause(source);
             break;
         case ON_STOP:
             mFullLifecycleObserver.onStop(source);
             break;
         case ON_DESTROY:
             mFullLifecycleObserver.onDestroy(source);
             break;
         case ON_ANY:
             throw new IllegalArgumentException("ON_ANY must not been send by anybody");
     }
     if (mLifecycleEventObserver != null) {
         mLifecycleEventObserver.onStateChanged(source, event);
     }
}