Android Lifecycle 使用、原理解析

官网 - Lifecycle

是什么？

• Lifecycle是Google推出的Android Jetpack 的一部分，用以感知Activity、Fragment生命周期的框架

基本使用

注册 -> 处理事件

class MainActivity : AppCompatActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
        // 注册生命周期变化观察者
        lifecycle.addObserver(object : LifecycleEventObserver {
            override fun onStateChanged(source: LifecycleOwner, event: Lifecycle.Event) {
                // 处理Activity生命周期变化事件
                when (event) {
                    Lifecycle.Event.ON_CREATE->{}
                    Lifecycle.Event.ON_START->{}
                    Lifecycle.Event.ON_RESUME->{}
                    Lifecycle.Event.ON_PAUSE->{}
                    Lifecycle.Event.ON_STOP->{}
                    Lifecycle.Event.ON_DESTROY->{}
                    Lifecycle.Event.ON_ANY->{}
                }
            }
        })
    }
}

重点类

Lifecycle

是一个接口，子类：LifecycleRegistry

public abstract class Lifecycle {
    // 组件生命周期事件
    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;
        }
    }
    ...
}

LifecycleRegistry

实现自Lifecycle，用以管理事件的注册、发布
构建时需要传入一个LifecycleOwner，然后在事件发布时一并给到观察者

public class LifecycleRegistry extends Lifecycle {
    // 观察者集合
    private FastSafeIterableMap<LifecycleObserver, ObserverWithState> mObserverMap = new FastSafeIterableMap<>();
    // 当前作用域的状态
    private State mState;
    // 指向的作用域
    // 作用域大概率是Activity、Fragment这种短生命周期对象，所以使用WeakReference包裹，避免内存泄漏可能
    private final WeakReference<LifecycleOwner> mLifecycleOwner;
    ...
}

LifecycleOwner

作用域接口：实现类需构建自己的Lifecycle，并通过实现方法getLifecycle返回
子类：ComponentActivity

public interface LifecycleOwner {
    @NonNull
    Lifecycle getLifecycle();
}

ComponentActivity

LifecycleOwner子类，是一个Lifecycle的作用域

package androidx.activity;
public class ComponentActivity extends androidx.core.app.ComponentActivity implements LifecycleOwner, ...{
    // 构建作用域自己的Lifecycle
    private final LifecycleRegistry mLifecycleRegistry = new LifecycleRegistry(this);
    // 返回自己的Lifecycle
    @NonNull
    @Override
    public Lifecycle getLifecycle() {
        return mLifecycleRegistry;
    }
}

LifecycleObserver

观察者标识：只有实现LifecycleObserver才能被视为Lifecycle观察者
子类：FullLifecycleObserver、DefaultLifecycleObserver、LifecycleEventObserver

// 空接口，仅作为标识使用
public interface LifecycleObserver {
}

FullLifecycleObserver

LifecycleObserver子类，通过构建多种回调方法，在不同方法中处理生命周期
非公开，开发者不能直接使用，但可以使用其子类DefaultLifecycleObserver

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

DefaultLifecycleObserver

FullLifecycleObserver的子类，公开可使用的
使用类Java8新特性：默认接口方法，开发者构建子类时可选择性实现接口方法，避免造成子类臃肿的问题

public interface DefaultLifecycleObserver extends FullLifecycleObserver {
    @Override
    default void onCreate(@NonNull LifecycleOwner owner) {
    	// 方法使用default修饰，并支持添加方法体
    }
    // ...
}

LifecycleEventObserver

LifecycleObserver子类
只有一个回调方法：onStateChange

public interface LifecycleEventObserver extends LifecycleObserver {
    // Lifecycle的事件都会回调到这个方法内
    void onStateChanged(@NonNull LifecycleOwner source, 
    @NonNull Lifecycle.Event event);
}

不同LifecycleObserver回调方式不一样，这不禁让人有个疑问：

• Lifecycle内部是怎么处理这种回调多样性的？

生命周期监听原理

抓重点

1. 解析 - 观察者注册
2. 解析 - 生命周期监听
3. 解析 - 生命周期回调

解析 - 观察者注册

可以通过构建DefaultLifecycleObserver、LifecycleEventObserver子类对象进行构建

// 通过构建DefaultLifecycleObserver子类注册观察者
lifecycle.addObserver(object : DefaultLifecycleObserver{
    override fun onCreate(owner: LifecycleOwner) {
        super.onCreate(owner)
    }
})

// 通过构建LifecycleEventObserver子类注册观察者
lifecycle.addObserver(object : LifecycleEventObserver {
    override fun onStateChanged(source: LifecycleOwner, event: Lifecycle.Event) {
        when (event) {
            Lifecycle.Event.ON_CREATE->{}
            ...
        }
    }
})

lifecycle.addObserver将传入的观察者给到到LifecycleRegister中保存起来，便于进行通知，如下

// LifecycleRegistry.addObserver
@Override
public void addObserver(@NonNull LifecycleObserver observer) {
    enforceMainThreadIfNeeded("addObserver");
    State initialState = mState == DESTROYED ? DESTROYED : INITIALIZED;
    // 这里将当前注册的回调与当前状态封装到 ObserverWithState
    ObserverWithState statefulObserver = new ObserverWithState(observer, initialState);
    // 保存观察者到mObserverMap集合中，便于遍历通知
    ObserverWithState previous = mObserverMap.putIfAbsent(observer, statefulObserver);
    ...
}

这里提个疑问，下按下不表：

• ObserverWithState是什么？为什么要将观察者封装起来？是跟回调多样性有关系吗？

解析 - 生命周期监听

Lifecycle是怎么监听作用域（Activity）的生命周期？

一般来说，我们监听Activity生命周期都是在生命周期回调中监听，例如onCreate、onStart、onResume等，这种方式需要我们重写各种生命周期方法，造成Activity出现臃肿情况。

ComponentActivity实现了LifecycleOwner，是Lifecycle的作用域。但并没有直接通过复写各种Activity的生命周期方法以达到生命周期监听的效果，那它是怎么做的？

ComponentActivity选择将生命周期监听交给一个无UI的Fragment - ReportFragment，在ReportFragment中再去复写生命周期方法，从而擦到监听宿主生命周期的目的，代码如下

• ComponentActivity构建时会去判断add一个无UIFragment - ReportFragment

@Override
protected void onCreate(@Nullable Bundle savedInstanceState) {
    ...
    // 添加 ReportFragment
    ReportFragment.injectIfNeededIn(this);
    ..
}

• ReportFragment

这里有个判断

• Build.VERSION.SDK_INT >= 29，通过注册ActivityLifecycleCallbacks监听Activity生命周期
  • 同样会add ReportFragment，但不处理复写的生命周期回调；
• Build.VERSION.SDK_INT < 29，通过添加ReportFragment后，复写生命周期方法，达到监听宿主Activity生命周期的目的

public class ReportFragment extends android.app.Fragment {

    public static void injectIfNeededIn(Activity activity) {
        if (Build.VERSION.SDK_INT >= 29) {
       		// 其实就是 
       		// activity.registerActivityLifecycleCallbacks(new LifecycleCallbacks());
            LifecycleCallbacks.registerIn(activity);
        }
        // add一个无UI的Fragment - ReportFragment
        android.app.FragmentManager manager = activity.getFragmentManager();
        if (manager.findFragmentByTag(REPORT_FRAGMENT_TAG) == null) {
            manager.beginTransaction().add(new ReportFragment(), REPORT_FRAGMENT_TAG).commit();
            manager.executePendingTransactions();
        }
    }

    @SuppressWarnings("deprecation")
    static void dispatch(@NonNull Activity activity, @NonNull Lifecycle.Event event) {
        ...
        if (activity instanceof LifecycleOwner) {
            Lifecycle lifecycle = ((LifecycleOwner) activity).getLifecycle();
            if (lifecycle instanceof LifecycleRegistry) {
            	// 拿到作用域的LifecycleRegistry对象，处理事件
                ((LifecycleRegistry) lifecycle).handleLifecycleEvent(event);
            }
        }
    }

    private void dispatch(@NonNull Lifecycle.Event event) {
    	// Build.VERSION.SDK_INT >= 29 情况下，已经交给ActivityLifecycleCallbacks回调处理了
        if (Build.VERSION.SDK_INT < 29) {
            dispatch(getActivity(), event);
        }
    }

	/** 29以下监听生命周期方式 */
    @Override
    public void onActivityCreated(Bundle savedInstanceState) {
        super.onActivityCreated(savedInstanceState);
        ...
        dispatch(Lifecycle.Event.ON_CREATE);
    }

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

    @Override
    public void onResume() {
        super.onResume();
        ...
        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);
        ...
    }

	/** 29以上监听生命周期方式 */
    @RequiresApi(29)
    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);
        }
    }
}

上面可知，监听到的生命周期更新消息最终会转交给LifecycleRegistry.handleLifecycleEvent
接下来，我们看看他做了什么

解析 - 生命周期回调

• LifecycleRegistry.handleLifecycleEvent

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

private void moveToState(State next) {
    ... 
    sync();
    ..
}

private void sync() {
    LifecycleOwner lifecycleOwner = mLifecycleOwner.get();
    ... 
    while (!isSynced()) {
        mNewEventOccurred = false;
        if (mState.compareTo(mObserverMap.eldest().getValue().mState) < 0) {
            backwardPass(lifecycleOwner);
        }
        Map.Entry<LifecycleObserver, ObserverWithState> newest = mObserverMap.newest();
        if (!mNewEventOccurred && newest != null && mState.compareTo(newest.getValue().mState) > 0) {
            forwardPass(lifecycleOwner);
        }
    }
    mNewEventOccurred = false;
}

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);
            // 遍历观察者列表，通过 ObserverWithState.dispatchEvent 处理回调
            observer.dispatchEvent(lifecycleOwner, upEvent(observer.mState));
            popParentState();
        }
    }
}

• ObserverWithState

static class ObserverWithState {
    State mState;
    LifecycleEventObserver mLifecycleObserver;
    ObserverWithState(LifecycleObserver observer, State initialState) {
   		// ObserverWithState统通过 LifecycleEventObserver.onStateChange 处理事件回调
   		// 但使用者可能传入的观察者回调多种多样，怎么办？
        mLifecycleObserver = Lifecycling.lifecycleEventObserver(observer);
        mState = initialState;
    }
    void dispatchEvent(LifecycleOwner owner, Event event) {
        State newState = event.getTargetState();
        mState = min(mState, newState);
        mLifecycleObserver.onStateChanged(owner, event);
        mState = newState;
    }
}

• Lifecycling.lifecycleEventObserver

ObserverWithState源码中可以看到，统一通过LifecycleEventObserver.onStateChanged进行事件回调，但是使用者可能传入各种观察者回调，例如：DefaultLifecycleObserver、LifecycleEventObserver等，这又是处理的呢？关键在Lifecycling.lifecycleEventObserve中

// Lifecycling.lifecycleEventObserver
static LifecycleEventObserver lifecycleEventObserver(Object object) {
    boolean isLifecycleEventObserver = object instanceof LifecycleEventObserver;
    boolean isFullLifecycleObserver = object instanceof FullLifecycleObserver;
    // 通过对象适配器模式，处理自定义观察者同时实现LifecycleEventObserver、FullLifecycleObserver的情况
    if (isLifecycleEventObserver && isFullLifecycleObserver) {        
        return new FullLifecycleObserverAdapter((FullLifecycleObserver) object,
                (LifecycleEventObserver) object);
    }
    // 通过对象适配器模式，处理使用DefaultLifecycleObserver注册观察者的情况
    if (isFullLifecycleObserver) {
        return new FullLifecycleObserverAdapter((FullLifecycleObserver) object, null);
    }

    // LifecycleEventObserver方式注册观察者,直接返回
    if (isLifecycleEventObserver) {
        return (LifecycleEventObserver) object;
    }

    // 实现LifecycleObserver，并通过注解方式注册观察者
    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);
}

可见，Lifecycle通过适配器，将LifecycleEventObserver接口，转换成用户传入的接口，达到Lifecycle只处理LifecycleEventObserver情况下，能同时支持用户传入回调接口的多样性。
举例说一下FullLifecycleObserverAdapter适配器

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_ANY:
                throw new IllegalArgumentException("ON_ANY must not been send by anybody");
        }
        if (mLifecycleEventObserver != null) {
            // 回调给onStateChanged方法
            mLifecycleEventObserver.onStateChanged(source, event);
        }
    }
}

FullLifecycleObserverAdapter适配器作为桥梁，将ObserverWithState中针对LifecycleEventObserver的操作转换成用户传入的FullLifecycleObserver或LifecycleEventObserver操作

想了解适配器模式，可点击

总结

• 需要申明自己是Lifecycle作用域并支持Lifecycle监听的类，需先实现 - LifecycleOwner，例如ComponentActivity
• 作用域通过构建Lifecycle的观察者注册管理类 - LifecycleRegistry，将事件注册、通知工作转交给LifecycleRegistry
• 开发者注册一个事件观察者，需要通过作用域的LifecycleRegistry对象的addObserver进行注册，注册支持回调多样化
• ComponentActivity不会直接在自己的生命周期方法中通知观察者，而是会给自己add一个无UI的Fragment - ReportFragment进行生命周期的监听，这种方式也运用在Glide中，Glide也会使用该方式对宿主进行生命周期监听然后执行请求恢复、暂停等操作。
• ReportFragment中监听到生命周期变化后，将事件转交给作用域持有的LifecycleRegister对象，LifecycleRegister通过遍历观察者集合，将事件回调给各个观察者进行处理
• 观察者回调中使用到了适配器模式用以支持回调方式的多样性