Skip to content

生命周期 LifeCycle

使用生命周期感知型组件处理生命周期。

生命周期感知型组件可执行操作来响应另一个组件(如 Activity 和 Fragment)的生命周期状态的变化。这些组件有助于您写出更有条理且往往更精简的代码,这样的代码更易于维护。

一种常见的模式是在 Activity 和 Fragment 的生命周期方法中实现依赖组件的操作。但是,这种模式会导致代码条理性很差而且会扩散错误。通过使用生命周期感知型组件,您可以将依赖组件的代码从生命周期方法移入组件本身中。

androidx.lifecycle 软件包提供了可用于构建生命周期感知型组件的类和接口 - 这些组件可以根据 Activity 或 Fragment 的当前生命周期状态自动调整其行为。

Lifecycle 是一个类,用于存储有关组件(如 Activity 或 Fragment)的生命周期状态的信息,并允许其他对象观察此状态。

Lifecycle 使用两种主要枚举跟踪其关联组件的生命周期状态:

活动

从框架和 Lifecycle 类分派的生命周期事件。这些事件映射到 Activity 和 Fragment 中的回调事件。

状态转换

由 Lifecycle 对象跟踪的组件的当前状态。

构成 Android Activity 生命周期的状态和事件

类可以通过向其方法添加注解来监控组件的生命周期状态。然后,您可以通过调用 Lifecycle 类的 addObserver() 方法并传递观察者的实例来添加观察者,如以下示例中所示:

    public class MyObserver implements LifecycleObserver {
        @OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
        public void connectListener() {
            ...
        }

        @OnLifecycleEvent(Lifecycle.Event.ON_PAUSE)
        public void disconnectListener() {
            ...
        }
    }

    myLifecycleOwner.getLifecycle().addObserver(new MyObserver());

在上面的示例中,myLifecycleOwner 对象实现了 LifecycleOwner 接口,我们将在接下来的部分中对该接口进行说明。

具体示例

引入androidx.appcompat依赖

dependencies {
    implementation 'androidx.appcompat:appcompat:1.1.0'
    // ...
}

构建一个观察者MyObserver1,监听生命周期的变化。

import androidx.lifecycle.Lifecycle;
import androidx.lifecycle.LifecycleObserver;
import androidx.lifecycle.OnLifecycleEvent;

public class MyObserver1 implements LifecycleObserver {
    private static final String TAG = "rustAppOb1";

    @OnLifecycleEvent(Lifecycle.Event.ON_CREATE)
    public void doOnCreate() {
        Log.d(TAG, "[obs]doOnCreate"); // 监听生命周期的变化
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_START)
    public void doOnStart() {
        Log.d(TAG, "[obs]doOnStart");
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
    public void doOnResume() {
        Log.d(TAG, "[obs]doOnResume");
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
    public void doOnResume2() {
        Log.d(TAG, "[obs]doOnResume2");
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_PAUSE)
    public void doOnPause() {
        Log.d(TAG, "[obs]doOnPause");
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_STOP)
    public void doOnStop() {
        Log.d(TAG, "[obs]doOnStop");
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_DESTROY)
    public void doOnDestroy() {
        Log.d(TAG, "[obs]doOnDestroy");
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_ANY)
    public void doOnAny() {
        Log.d(TAG, "[obs]doOnAny");
    }
}

在activity中使用,各个生命周期打印log。继承androidx.appcompat.app.AppCompatActivity

public class Lc1Act extends AppCompatActivity {
    private static final String TAG = "rustAppLc1";

    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        Log.d(TAG, "[act]onCreate: start");
        super.onCreate(savedInstanceState);
        ActLc1Binding binding = DataBindingUtil.setContentView(this, R.layout.act_lc1);

        getLifecycle().addObserver(new MyObserver1());
        Log.d(TAG, "[act]onCreate: END");
    }

    @Override
    protected void onStart() {
        Log.d(TAG, "[act]onStart: start");
        super.onStart();
        Log.d(TAG, "[act]onStart: END");
    }

    @Override
    protected void onResume() {
        Log.d(TAG, "[act]onResume: start");
        super.onResume();
        Log.d(TAG, "[act]onResume: END");
    }

    @Override
    protected void onPause() {
        Log.d(TAG, "[act]onPause: start");
        super.onPause();
        Log.d(TAG, "[act]onPause: END");
    }

    @Override
    protected void onStop() {
        Log.d(TAG, "[act]onStop: start");
        super.onStop();
        Log.d(TAG, "[act]onStop: END");
    }

    @Override
    protected void onDestroy() {
        Log.d(TAG, "[act]onDestroy: start");
        super.onDestroy();
        Log.d(TAG, "[act]onDestroy: END");
    }

    @Override
    public void onBackPressed() {
        Log.d(TAG, "[act]onBackPressed");
        super.onBackPressed();
    }
}

运行日志

D/rustAppLc1: [act]onCreate: start
D/rustAppLc1: [act]onCreate: END
D/rustAppOb1: [obs]doOnCreate
D/rustAppOb1: [obs]doOnAny
D/rustAppLc1: [act]onStart: start
D/rustAppLc1: [act]onStart: END
D/rustAppOb1: [obs]doOnStart
D/rustAppOb1: [obs]doOnAny
D/rustAppLc1: [act]onResume: start
D/rustAppLc1: [act]onResume: END
D/rustAppOb1: [obs]doOnResume
D/rustAppOb1: [obs]doOnResume2
D/rustAppOb1: [obs]doOnAny
D/rustAppLc1: [act]onBackPressed
D/rustAppOb1: [obs]doOnPause
D/rustAppOb1: [obs]doOnAny
D/rustAppLc1: [act]onPause: start
D/rustAppLc1: [act]onPause: END
D/rustAppOb1: [obs]doOnStop
D/rustAppOb1: [obs]doOnAny
D/rustAppLc1: [act]onStop: start
D/rustAppLc1: [act]onStop: END
D/rustAppOb1: [obs]doOnDestroy
D/rustAppOb1: [obs]doOnAny
D/rustAppLc1: [act]onDestroy: start
D/rustAppLc1: [act]onDestroy: END

从log中可以看出activity生命周期和观察者回调函数执行的先后顺序。 新建activity时,先执行activity的生命周期函数,再执行观察者的监听方法。 销毁界面时,先执行的时观察者的方法,然后是activity的方法。 即先建立页面,再建立观察者;退出时先退观察者,再退界面。

如果弹出AlertDialog,activity回调onWindowFocusChanged(boolean hasFocus),观察者不会响应。

LifecycleOwner

LifecycleOwner 是单一方法接口,表示类具有 Lifecycle(生命周期)。 它具有一个方法(即 getLifecycle()),该方法必须由类实现。 如果您尝试管理整个应用进程的生命周期,请参阅 ProcessLifecycleOwner。

此接口从各个类(如 Fragment 和 AppCompatActivity)抽象化 Lifecycle 的所有权,并允许编写与这些类搭配使用的组件。任何自定义应用类均可实现 LifecycleOwner 接口。

实现 LifecycleObserver 的组件可与实现 LifecycleOwner 的组件无缝协同工作,因为所有者可以提供生命周期,而观察者可以注册以观察生命周期。

上面的MyObserver1类实现 LifecycleObserver,然后在 onCreate() 方法中使用 Activity 的 Lifecycle 对其进行初始化。 这样,MyObserver1 类便可以“自给自足”,这意味着,对生命周期状态的变化做出响应的逻辑会在 MyObserver1(而不是在 Activity)中进行声明。让各个组件存储自己的逻辑,可使 Activity 和 Fragment 逻辑更易于管理。

持有Lifecycle的观察者示例

观察者可以持有Lifecycle对象。在进行一些操作前,可以判断页面当前的状态。

新建MyObserver2类。持有Lifecycle实例。

import androidx.lifecycle.Lifecycle;
import androidx.lifecycle.LifecycleObserver;
import androidx.lifecycle.OnLifecycleEvent;

public class MyObserver2 implements LifecycleObserver {
    private static final String TAG = "rustAppOb2";

    private Lifecycle lifecycle;

    public MyObserver2(Lifecycle lifecycle) {
        this.lifecycle = lifecycle;
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_ANY)
    public void doOnAny() {
        Log.d(TAG, "[obs2]doOnAny; lifecycle-cur-state: " + lifecycle.getCurrentState());
        Log.d(TAG, "doOnAny: atLeast INITIALIZED: " + lifecycle.getCurrentState().isAtLeast(Lifecycle.State.INITIALIZED));
        Log.d(TAG, "doOnAny: atLeast CREATED: " + lifecycle.getCurrentState().isAtLeast(Lifecycle.State.CREATED));
        Log.d(TAG, "doOnAny: atLeast STARTED: " + lifecycle.getCurrentState().isAtLeast(Lifecycle.State.STARTED));
        Log.d(TAG, "doOnAny: atLeast RESUMED: " + lifecycle.getCurrentState().isAtLeast(Lifecycle.State.RESUMED));
        Log.d(TAG, "doOnAny: atLeast DESTROYED: " + lifecycle.getCurrentState().isAtLeast(Lifecycle.State.DESTROYED));
    }
}

观察ON_ANY这个事件,打一些log,看看lifecycle的状态。 使用了isAtLeast方法。

Activity中注册这个观察者。

getLifecycle().addObserver(new MyObserver2(getLifecycle()));

运行部分log信息

D/rustAppLc1: [act]onCreate: start
D/rustAppLc1: [act]onCreate: END
D/rustAppOb2: [obs2]doOnAny; lifecycle-cur-state: CREATED
D/rustAppOb2: doOnAny: atLeast INITIALIZED: true
D/rustAppOb2: doOnAny: atLeast CREATED: true
D/rustAppOb2: doOnAny: atLeast STARTED: false
D/rustAppOb2: doOnAny: atLeast RESUMED: false
D/rustAppOb2: doOnAny: atLeast DESTROYED: true

观察Lifecycle.State枚举,它把生命周期状态按顺序排列。

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

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

isAtLeast比较当前状态和传入的状态。返回true则标明相对传入的state,当前是“安全”的。

实现自定义 LifecycleOwner

上面的activity继承自androidx.appcompat.app.AppCompatActivity,它的父类实现了LifecycleOwner接口。 我们也可以实现自定义 LifecycleOwner。

如果您有一个自定义类并希望使其成为 LifecycleOwner,您可以使用 LifecycleRegistry 类,但需要将事件转发到该类,如以下代码示例中所示:

    public class MyActivity extends Activity implements LifecycleOwner {
        private LifecycleRegistry lifecycleRegistry;

        @Override
        protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);

            lifecycleRegistry = new LifecycleRegistry(this);
            lifecycleRegistry.markState(Lifecycle.State.CREATED);
        }

        @Override
        public void onStart() {
            super.onStart();
            lifecycleRegistry.markState(Lifecycle.State.STARTED);
        }

        @NonNull
        @Override
        public Lifecycle getLifecycle() {
            return lifecycleRegistry;
        }
    }