Lifecycle

Jetpack LifeCycle 库

Lifecycle 是 Android Jetpack 的一部分，它提供了一种机制可以让程序可以更加方便的响应 Android 组件（如 Activity）的生命周期。

Lifecycle 解决了什么问题？

在此之前，如果一个组件需要响应 Android 组件的生命周期事件，通常可以在对应的生命周期回调里进行，例如下面的代码示例：

internal class MyLocationListener(
        private val context: Context,
        private val callback: (Location) -> Unit
) {

    fun start() {
        // connect to system location service
    }

    fun stop() {
        // disconnect from system location service
    }
}


class MyActivity : AppCompatActivity() {
    private lateinit var myLocationListener: MyLocationListener

    override fun onCreate(...) {
        myLocationListener = MyLocationListener(this) { location ->
            // update UI
        }
    }

    public override fun onStart() {
        super.onStart()
        myLocationListener.start()
        
        // manage other components that need to respond
        // to the activity lifecycle
    }

    public override fun onStop() {
        super.onStop()
        myLocationListener.stop()
        
        // manage other components that need to respond
        // to the activity lifecycle
    }
}

但是上面的代码会导致两个问题：

代码质量问题

可能有多个组件需要响应同一个 Activity 的生命周期，这就导致了Activity 的生命周期方法里充斥着处理各个组件的代码，不易维护
可能多个Activity 需要使用同一个组件，那么就需要在每个Activity的生命周期回调中都添加处理这个组件的逻辑，产生了不必要的重复代码

内存泄漏问题

举一个官方文档中提到的例子：

class MyActivity : AppCompatActivity() {
    private lateinit var myLocationListener: MyLocationListener

    override fun onCreate(...) {
        myLocationListener = MyLocationListener(this) { location ->
            // update UI
        }
    }

    public override fun onStart() {
        super.onStart()
        Util.checkUserStatus { result ->
            // what if this callback is invoked AFTER activity is stopped?
            if (result) {
                myLocationListener.start()
            }
        }
    }

    public override fun onStop() {
        super.onStop()
        myLocationListener.stop()
    }

}

在上面例子中，如果 Util.checkUserStatus 回调在 onStop 之后，就可能会导致 MyActivity 被销毁后还在内存中（非静态内部类引用），引发 Activity 泄漏。

而通过 Lifecycle 提供的机制，可以将响应生命周期的操作集中在组件内部，同时在拥有生命周期的组件销毁时自动移除监听器，提高代码的可维护性。

如何使用 LifeCycle

集成 lifecycle 库

lifecycle 有两个核心库:lifecycle-common 和 lifecycle-runtime。如果使用了AndroidX，这两个库就会被间接集成到项目中（通过 androidx.core:core或者androidx.appcompat:appcompat ）。

如果项目使用 Java 8，则需要集成lifecycle-common-java8，否则可以集成lifecycle-compiler来通过注解避免反射调用（后面会详细讲解），如下面所示：

dependencies {
    def lifecycle_version = "2.2.0"
    // Annotation processor
    kapt "androidx.lifecycle:lifecycle-compiler:$lifecycle_version"
    
    // alternately - if using Java8, use the following instead of lifecycle-compiler
    implementation "androidx.lifecycle:lifecycle-common-java8:$lifecycle_version"
}

注：如果两个库都不集成，则会通过反射进行监听器方法的调用。

创建监听器

未使用Java 8

使用LifecycleObserver+注解

// 1. 实现 LifecycleObserver 接口
class MyObserver : LifecycleObserver {

    //2. 通过注解标记要响应的生命周期事件
    @OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
    fun connectListener() {
        ...
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_PAUSE)
    fun disconnectListener() {
        ...
    }
}

// 3. 添加监听
myLifecycleOwner.getLifecycle().addObserver(MyObserver())

使用 LifecycleEventObserver

class MyLifecycleEventObserver : LifecycleEventObserver {

    override fun onStateChanged(source: LifecycleOwner, event: Lifecycle.Event) {
        //do something
    }

    //不会被调用
    @OnLifecycleEvent(Lifecycle.Event.ON_CREATE)
    fun resolveCreate() {
        //never called

    }
}

上面被OnLifeCycleEvent注解标记的方法不会被自动调用，因为在LifecycleEventObserver注释中可以看到：

If a class implements this interface and in the same time uses OnLifecycleEvent, then annotations will be ignored.

组件之间通过事件来进行通信。

带有参数的情况。方便处理监听多个LifecycleOwener的情况，或者对Event统一处理。

 class TestObserver implements LifecycleObserver {
   @OnLifecycleEvent(ON_CREATE)
   void onCreated(LifecycleOwner source) {}
   @OnLifecycleEvent(ON_ANY)
   void onAny(LifecycleOwner source, Event event) {}
 }

使用Java8

class TestObserver implements DefaultLifecycleObserver {
     @Override
     public void onCreate(LifecycleOwner owner) {
         // your code
     }
     
     //其他生命周期方法
 }

为什么Java8之前通过注解+接口？个人理解是为了灵活性，Java8的接口可以拥有默认的实现，这样开发者只需要按需重写方法，而且不会影响继承关系；而在Java8之前，这只能通过抽象类来实现，但是抽象类会影响继承关系，完全使用接口则需要实现所有方法。

注册监听器

监听生命周期的源码

处理生命周期事件源码

关系

监听 Activity 生命周期

//androidx.activity.ComponentActivity
@Override
protected void onCreate(@Nullable Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    //...
    ReportFragment.injectIfNeededIn(this);
    //...
}

public static void injectIfNeededIn(Activity activity) {
        if (Build.VERSION.SDK_INT >= 29) {
            // On API 29+, we can register for the correct Lifecycle callbacks directly
            activity.registerActivityLifecycleCallbacks(
                    new LifecycleCallbacks());
        }
        // Prior to API 29 and to maintain compatibility with older versions of
        // ProcessLifecycleOwner (which may not be updated when lifecycle-runtime is updated and
        // need to support activities that don't extend from FragmentActivity from support lib),
        // use a framework fragment to get the correct timing of Lifecycle events
        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();
        }
    }

ReportFragment

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

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

private void dispatch(@NonNull Lifecycle.Event event) {
        if (Build.VERSION.SDK_INT < 29) {
            // Only dispatch events from ReportFragment on API levels prior
            // to API 29. On API 29+, this is handled by the ActivityLifecycleCallbacks
            // added in ReportFragment.injectIfNeededIn
            dispatch(getActivity(), event);
        }
    }

// androidx.lifecycle.ReportFragment.LifecycleCallback
static class LifecycleCallbacks implements Application.ActivityLifecycleCallbacks {
        @Override
        public void onActivityCreated(@NonNull Activity activity,
                @Nullable Bundle bundle) {
        }

        @Override
        public void onActivityPostCreated(@NonNull Activity activity,
                @Nullable Bundle savedInstanceState) {
            dispatch(activity, Lifecycle.Event.ON_CREATE);
        }

        @Override
        public void onActivityStarted(@NonNull Activity activity) {
        }

        @Override
        public void onActivityPostStarted(@NonNull Activity activity) {
            dispatch(activity, Lifecycle.Event.ON_START);
        }
}

//androidx.lifecycle.ReportFragment
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

/**
     * 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.
     *
     * @param event The event that was received
     */
    public void handleLifecycleEvent(@NonNull Lifecycle.Event event) {
        State next = getStateAfter(event);
        moveToState(next);
    }

监听器注解的处理时机

注解处理器生成 observe——adapter类。

//androidx.lifecycle.LifycycleRegistry
@Override
public void addObserver(@NonNull LifecycleObserver observer) {
    State initialState = mState == DESTROYED ? DESTROYED : INITIALIZED;
    ObserverWithState statefulObserver = new ObserverWithState(observer, initialState);
    //....
    //ObserverWithState previous = mObserverMap.putIfAbsent(observer, statefulObserver);
}

static class ObserverWithState {
        State mState;
        LifecycleEventObserver mLifecycleObserver;

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

        void dispatchEvent(LifecycleOwner owner, Event event) {
            State newState = getStateAfter(event);
            mState = min(mState, newState);
            mLifecycleObserver.onStateChanged(owner, event);
            mState = newState;
        }
    }

//androidx.lifecycle.LifeCycling
//参数是 object
@NonNull
static LifecycleEventObserver lifecycleEventObserver(Object object) {
    // 根据不同的类型创建observer
    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;
    }

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

如果集成了注解处理库，就会生成对应的Adapter类，就不会进行反射调用；否则会通过反射进行调用。

监听应用生命周期

集成依赖

implementation "androidx.lifecycle:lifecycle-process:$lifecycle_version"

ProcessLifecycleOwner | API reference | Android DevelopersAndroid Developers

自定义 LifeCyclerOwner

一些小问题

使用Java 8 开发时可以通过集成 common-java8 并继承 DefaultLifecycleObserver，重写对应的生命周期方法即可，从而可以避免注解处理过程。DefaultLifecycleObserver 是一个接口，为每个回调方法提供了空的实现。