Android 框架组件 Lifecycle 使用详解

public class TestLifeCycle implements LifecycleObserver {
    private static final String TAG = "test";

    @OnLifecycleEvent(Lifecycle.Event.ON_CREATE)
    public void onCreate() {
        Log.d(TAG, "onCreate: ");
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_START)
    public void onStart() {
        Log.d(TAG, "onStart: ");
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
    public void onResume() {
        Log.d(TAG, "onResume: ");
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_PAUSE)
    public void onPause() {
        Log.d(TAG, "onPause: ");
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_STOP)
    public void onStop() {
        Log.d(TAG, "onStop: ");
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_DESTROY)
    public void onDestroy() {
        Log.d(TAG, "onDestroy: ");
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_ANY)
    public void onAny() {
        Log.d(TAG, "onAny: ");
    }
}

通过实现 LifecycleObserver 接口，并在相应的方法上添加注解 @OnLifecycleEvent(Lifecycle.Event.XXX) 即可。实际上，这就是一个观察者模式。当执行到某个生命周期时，会通知观察者执行对应的方法。

3.3 Activity 中添加观察者

public class TestActivity extends AppCompatActivity {
    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.test_activity);
        getLifecycle().addObserver(new TestLifeCycle());
    }
}

继承 AppCompatActivity 后，即可通过添加观察者来监听此 Activity 的生命周期。相比之前的例子，只需一行代码，简单许多。

完整的生命周期输出结果如下：

07-24 23.23:55.892 15728-15728/com.test.start D/test: onCreate: 07-24 23.23:55.892 15728-15728/com.test.start D/test: onAny: 07-24 23.23:55.893 15728-15728/com.test.start D/test: onStart: 07-24 23.23:55.893 15728-15728/com.test.start D/test: onAny: 07-24 23.23:55.895 15728-15728/com.test.start D/test: onResume: 07-24 23.23:55.895 15728-15728/com.test.start D/test: onAny: 07-24 23.23:58.183 15728-15728/com.test.start D/test: onPause: 07-24 23.23:58.184 15728-15728/com.test.start D/test: onAny: 07-24 23.23:58.576 15728-15728/com.test.start D/test: onStop: 07-24 23.23:58.577 15728-15728/com.test.start D/test: onAny: 07-24 23.23:58.585 15728-15728/com.test.start D/test: onDestroy: 07-24 23.23:58.586 15728-15728/com.test.start D/test: onAny:

可以看到，onAny 在每个生命周期都会调用一次。其他则是正常调用。

注意，目前只能通过继承 AppCompatActivity 来实现这种简单的方式。直接继承 Activity 的话稍复杂，详见后面的分析。

3.4 Fragment 中添加观察者

public class TestFragment extends Fragment {
    @Override
    public void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        getLifecycle().addObserver(new TestLifeCycle());
    }
}

同样，也可以监听到 Fragment 的生命周期，加一个观察者即可。

4. Lifecycle 角色说明

4.1 Lifecycle 类

Lifecycle 类持有 Activity 或 Fragment 等组件的生命周期信息，并且允许其他对象观察这些信息。

Lifecycle 内部使用了两个枚举来跟踪其关联组件的生命周期状态：Event 和 State。

可以通过调用 Lifecycle 类的 addObserver() 方法来添加观察者：

getLifecycle().addObserver(new TestLifeCycle());

4.2 Lifecycle 事件

Lifecycle 组件可以感知如下事件：

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

看起来有 7 种，实际上也就是 6 种而已。ON_ANY 表示所有的事件都会感知。可以看到，像 Activity 的 onRestart()，Fragment 的 onCreateView() 等等其他生命周期是无法感知的。

4.3 Lifecycle 状态

Lifecycle 组件内部维护了一个 State 来标识 Activity 或 Fragment 当前的状态：

public abstract class Lifecycle {
    public enum State {
        DESTROYED,
        INITIALIZED,
        CREATED,
        STARTED,
        RESUMED;

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

一共也就 5 种状态而已，其状态和事件的状态关系如下图所示（此处省略图片）。

4.4 LifecycleOwner 接口

LifecycleOwner 表示它的实现类具有一个 Lifecycle。它有一个 getLifecycle() 方法，该方法必须由实现类实现。

AppCompatActivity 和 Fragment 都实现了 LifecycleOwner 接口（Support Library 26.1.0 之后的版本），所以可以直接拿来使用。

但是 Activity 类并没有实现 LifecycleOwner 接口，所以，如果我们需要去监听自定义 Activity 的话，需要自己手动去实现 LifecycleOwner 接口。

4.5 LifecycleObserver 接口（观察者）

LifecycleObserver 其实现类可以通过感知相应的生命周期来完成特定的操作。

5. 自定义 Activity 中实现 LifecycleOwner

感知 AppCompatActivity 和 Fragment 的子类生命周期都很简单，一行代码就可以完成。但是感知自定义 Activity 就稍微复杂了点，需要手动完成以下步骤：

1. 实现 LifecycleOwner 接口
2. 重写 getLifecycle() 方法
3. 手动标记生命周期的状态

代码如下所示：

public class TestActivity extends Activity implements LifecycleOwner {
    private LifecycleRegistry mLifecycleRegistry;

    @NonNull
    @Override
    public Lifecycle getLifecycle() {
        // 返回 Lifecycle
        return mLifecycleRegistry;
    }

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.test_activity);
        // 创建 Lifecycle 对象
        mLifecycleRegistry = new LifecycleRegistry(this);
        // 标记状态
        mLifecycleRegistry.markState(Lifecycle.State.CREATED);
        // 添加观察者
        getLifecycle().addObserver(new TestLifeCycle());
    }
    
    @Override
    public void onStart() {
        super.onStart();
        // 标记状态
        mLifecycleRegistry.markState(Lifecycle.State.STARTED);
    }

    @Override
    protected void onResume() {
        super.onResume();
        // 标记状态
        mLifecycleRegistry.markState(Lifecycle.State.RESUMED);
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
        // 标记状态
        mLifecycleRegistry.markState(Lifecycle.State.DESTROYED);
    }
}

上面的 LifecycleRegistry 其父类是 Lifecycle。